Я не вижу в предоставленном листинге mov

вот если так яснее:
mov     esi, src[esp]
mov     edi, dest[esp]
mov     ecx, esi
sub     ecx, edi
test    ecx, 1
jnz     .Lmemcpy1
test    ecx, 2
jnz     .Lmemcpy2
но ещё есть вариант не использовать ecx и потом снова со стека загрузить esi/edi

Ну это снова какой-то маленький кусок кода. Что тут оптимизировать-то?

хз... ладно я пока весь алгоритм простряпаю сначала

вот начальный вариант, даже не тестированный
https://gist.github.com/disba1ancer/f5fedefc34f71a61fb4d0385e5fafd07

Или вот так: (Ну это, опять же, для K8, т.к там для mov r, m - пропускная способность = 1/2, так что не имеет смысла вставлять сразу 3 mov r, m, ибо для этого процессора они не выполнятся параллельно, процессор перенесёт 3-й в дублированный исполнительный блок - AGU1)
mov     esi, src[esp]  ; AGU0 0.0 - 3.0
mov     edi, dest[esp] ;
sub     esi, edi       ; ALU0 0.0 - 1.0
mov     ecx, size[esp] ; AGU0 3.0 - 6.0
;sub     esi, edi      
test    esi, 1         ; ALU0 1.0 - 2.0
jnz     .Lmemcpy1      ; ALU0 (ZF  2.0 - 4.0) (!ZF 2.0 - 6.0)

Ну а в целом - нормально. Конечно, всё равно зависимостей много, как и в прошлых алгоритмах, но... Просто "улучшенный" rep movs

Блин, как работают смещения? Можете, пожалуйста, на "пальцах" обьяснить? Не могу понять.

0x400000: example1: db 'Test 1', 0
0x400007: example2: db 'Test 2', 0
0x40000E: example3: db 'Test 3', 0

0x400015: offset_table:
; Смещение = Размер одного элемента (должны быть все одинаковы размером)*Элемент
dd example1 ; Offset = 4*0 = 0 = 1-й элемент = адрес на строку "Test 1"
dd example2 ; Offset = 4*1 = 4 = 2-й элемент = адрес на строку "Test2"
dd example3 ; Offset = 4*2 = 8 = 3-й элемент = адрес на строку "Test 3"

Пример получения кодом:

mov eax, offset_table
mov ebx, dword[eax] ; Адрес стоит на offset_table=dd example1, нам нужно получить само значение example1, т.е сам адрес на example1, в EBX
; EBX = 'Test 1' = потому что метка offset_table уже указывает на первый элемент

add eax, 4
mov ebx, dword[eax]
; EBX = 'Test 2'

add eax, 4
mov ebx, dword[eax]
; EBX = 'Test 3'

Другой пример:
mov eax, dword[offset_table+4] ; 'Test 2'
mov eax, dword[offset_table] ; или mov eax, dword[offset_table+0] = 'Test 1'
mov eax, dword[offset_table+8] ; 'Test 3'

просто перенести sub немного выше, это можно, кстати, сделал я тест для этой функции и нашёл ошибку

правда тут от процессора как ты намекаешь зависит, но вполне возможно что на других процессорах хуже это не сделает

кстати, как вариант вот это место (https://gist.github.com/disba1ancer/f5fedefc34f71a61fb4d0385e5fafd07#file-memcpy-s-L17) можно будет заменить на таблицу переходов по bsf

Не сделает. На современных процессорах пропускная способность для mov r32, m = 1/2, или выше (вот если выше - тогда плохо, потому что тогда можно пожертвовать третьим mov r32, m, и перенести sub - ниже, но я не слежу за процессорами, и таких ещё не знаю, поэтому 1/2), на старых - ниже, и вот как раз если ниже, тогда тебе нужно как можно раньше дать процессору выполнить инструкцию в sub, потому что для r32, m нужен AGU, и ещё хорошо отделаешься, если они дублированные, и их хватит. Ибо если не хватит - придётся ждать освобождения занятого исполнительного блока, что вызовет доп. задержку.
Так что да - лучше оставить sub ближе к mov r32, m (ну, то есть, как я  и скинул выше)

я сейчас заметил, что забываю проверять аргумент с размером, и у меня возникает переполнение буффера

Вон те две проверки?

во первых на 0 в начале, чтобы все проверки обойти и проверки при подравнивании после уменьшения ecx, перед выполнением основного цикла

Ну попробуй, не знаю)

У меня творится мистика!, имею число одинадцать 9-ок с минусом, вот что у меня в регистрах, и что в калькуляторе. В парах EDX:EAX и ECX:EBX одинаковые числа только EDX:EAX уже инвертирована, Где же может быть глюк? :)

Скинь в личные сообщения, и скажи что сделал, гляну

ты хочешь сделать инверсию EDX:EAX?