Wt 18 некорректный расчёт

Sha256macro.asm

@@ -0,0 +1,3 @@
+WTMACRO MACRO PARAMETER
+STATEMENTS
+ENDM

sha-256.asm

@@ -3,8 +3,8 @@ include includes\temphls.inc
 include includes\win64.inc
 include includes\user32.inc
 includelib includes\user32.lib
-OPTION PROLOGUE:none
-OPTION EPILOGUE:none
+OPTION PROLOGUE:PrologueDef 
+OPTION EPILOGUE:EpilogueDef
 .data
 	AppName: ;DLL Skeleton
 		dw 0044h,004ch,004ch,0020h,0053h,006bh,0065h,006ch,0065h,0074h,006fh,006eh,0000h 
@@ -29,20 +29,18 @@ OPTION EPILOGUE:none
 		 043bh,0020h,0044h,004ch,004ch,005fh,0050h,0052h,004fh,0043h,0045h,0053h,0053h,005fh,0044h,0045h,0054h,0041h,0043h,0048h,0000h
 	
 	prime_nums: ; 8 байт с простыми числами от 2 до 19
-	 	db 0 dup (8)		
+	 	db 8 dup (0)	
+	align 16	
+	k_konst dd 64 dup (0)	;64 32-битных значения инициированных первыми 32 битами дробной части кубических корней от 2 о 311
 	align 16
 	my3sqrt REAL8 0.3333333333333333333333333333
 	;xmminst dq 12232434,13342342342
-	xmmhash xmmword 0 dup (4); 4 Байта в которых хранится хэш
-	k_konst dd 0 dup (64)	;64 32-битных значения инициированных первыми 32 битами дробной части кубических корней от 2 о 311
-	myXMMSAVE xmmword 0 dup (10) 	;глобальная переменная для сохранения/восстановления регистров XMM6-XMM15 (неизменяемые)
-	myRnSAVE dq 0 dup (4)			;глобальная переменная для сохранения/восстановления регистров R12-R15 (неизменяемые)
 
 .code
 DllMain proc hInstDLL:QWORD, reason:QWORD, unused:QWORD
 	;push rbp
 	;mov	rbp,rsp
-	sub rsp,28h
+	;sub rsp,28h
 	.if edx==DLL_PROCESS_ATTACH				;Обрабатываю событие вызова DLL
 		call _isAvxSupported
 		pshufd xmm0,xmm0,10010011b			;Перераспределяет 32-битные qword'ы в xmm согласно битовой маске: 2 бита, числа от 0-3 сообщают
@@ -81,12 +79,12 @@ DllMain proc hInstDLL:QWORD, reason:QWORD, unused:QWORD
 	.elseif edx==DLL_THREAD_ATTACH			;Обрабатываю событие создания треда в вызывающем процессе
 											;(ох и попило крови это событие: не обрабатывал, а по-умолчанию падало на другой обработчик)
 		;lea rdx,DllAtata					;Указатель на сообщение "неожиданно прилетел DLL_THREAD_ATTACH"
-		add rsp,28h							;восстанавливаю вершину стека
+		;add rsp,28h							;восстанавливаю вершину стека
 		xor rax,rax							;возвращаю ноль
 		ret									;Выхожу
 	.elseif edx==DLL_THREAD_DETACH			;Обрабатываю событие закрытия треда в вызывающем процессе 
 		;lea rdx,DllDetata					;Указатель на сообщение "Неожиданно прилетел DLL_PROCESS_DETACH"
-		add rsp,28h							;восстанавливаю вершину стека
+		;add rsp,28h							;восстанавливаю вершину стека
 		xor rax,rax							;возвращаю ноль
 		ret									;Выхожу
 	.endif 
@@ -94,7 +92,7 @@ DllMain proc hInstDLL:QWORD, reason:QWORD, unused:QWORD
 	jmp exit
 DllMain Endp
 TestHello proc 
-	sub rsp,28h
+	;sub rsp,28h
 	lea rdx,HelloMsg
 	mov r9d,MB_OK + MB_ICONERROR
 exit::	lea r8,AppName
@@ -102,32 +100,167 @@ exit::	lea r8,AppName
 	call MessageBoxW
 	;mov rsp,rbp
 	;pop rbp
-	add rsp,28h
+	;add rsp,28h
 	mov rax,TRUE
+	leave
 	ret
 TestHello endp
-;Sha256 - Функция, принимающая в качестве параметра 1-Адрес хешируемого объекта;2-его полный размер; 3-Размер отрезка; 4-последний ли он?. Возвращаемое значение: NULL в случае успеха 
-Sha256 proc __fastcall
-	enter 128,0
+; Sha256 - хэш-Функция. Возвращаемое значение: NULL в случае успеха, CF_digests заполняется хэш-суммой.
+	;1-CF_Addr-Адрес хешируемого объекта:QWORD
+	;2-CF_FullSize-его полный размер:QWORD
+	;3-CF_CurrSize-Размер отрезка:QWORD
+	;4-CF_digests-адрес 8 байт хэша (если ноль, то это первый отрезок):QWORD
+	;5-CF_Last-последний ли он?:QWORD
+	align 16
+Sha256 proc CF_Addr:QWORD,CF_FullSize:QWORD,CF_CurrSize:QWORD,CF_digests:QWORD,CF_Last:QWORD
+	LOCAL myXMMSAVE[10]:xmmword 	;локальная область для сохранения/восстановления регистров XMM6-XMM15 (неизменяемые)
+	LOCAL myRnSAVE[4]:QWORD			;локальная область для сохранения/восстановления регистров R12-R15 (неизменяемые)
+	LOCAL myBuff2Hash[8]:DWORD	;локальная область, куда будут перекинуты данные для хэширования
+	LOCAL lastblock[32]:DWORD	;32 двойных слова (1024 бит) - место для одного или двух блоков дописанного кончания файла (блока)
+	LOCAL lastblocksize:DWORD	;тут интересен только последний бит: 0-переполнения не было, окончание 512 бит; 1-переполнение было, окончание 1024 бита
+	LOCAL myOffset2End:QWORD	;локальная переменная для сохранения смещения до последнего байта хэшируемого отрезка
+	LOCAL cyclesInSegment:DWORD	;локальная переменная для сохранения количества циклов перебора отрезка. Перебирается весь отрезок кроме "хвоста"
+	LOCAL endingOfSegment:DWORD ;локальная переменная для сохранения размера хвоста файла<=64,который необходимо закончить по SHA-256
+	;Сохраняю входные данные	
+		mov CF_Addr,rcx ;Сохраняю адрес объекта
+		mov CF_FullSize,rdx ;Сохраняю его полный размер
+		mov CF_CurrSize,r8	;Сохраняю размер данного отрезка
+		mov CF_digests,r9	;Адрес хэша
+		;mov rax,[rbp+32]
+		;mov CF_Last,rax		;Сохреняю флаг, последний-ли отрезок
+	;Сохраняю в выровненную локальную область 10  XMM Регистров  с XMM6-XMM15, r12-r15.
+		movdqu myXMMSAVE,XMM6
+		movdqu myXMMSAVE+16,XMM7
+		movdqu myXMMSAVE+32,XMM8
+		movdqu myXMMSAVE+48,XMM9
+		movdqu myXMMSAVE+64,XMM10
+		movdqu myXMMSAVE+80,XMM11
+		movdqu myXMMSAVE+96,XMM12
+		movdqu myXMMSAVE+112,XMM13
+		movdqu myXMMSAVE+128,XMM14
+		movdqu myXMMSAVE+144,XMM15
+		mov myRnSAVE,r12
+		mov myRnSAVE+4,r13
+		mov myRnSAVE+8,r14
+		mov myRnSAVE+12,r15
+	;если хэш по предложенному адресу = 0, запускаем Sha256Init
+		mov rax,qword ptr [r9]
+		add r9,8
+		or rax,qword ptr [r9]
+		add r9,8
+		or rax,qword ptr [r9]
+		add r9,8
+		or rax,qword ptr [r9]
+		test rax,rax
+		jnz Inithash
+		mov rcx,CF_digests
+		call Sha256Init
+	Inithash:	;Инициирую R12D-r15D (ХЭШ)
+		mov rax,CF_digests
+		mov r12,QWORD PTR [rax]
+		mov r13,QWORD PTR [rax+8]
+		mov r14,QWORD PTR [rax+16]
+		mov r15,QWORD PTR [rax+24]		
+	;Является ли массив последним?
+		mov rax,CF_Last
+		cmp rax,1 ;1-блок является последним
+		jnz cycleCheck
+	;Да. Копирую окончание массива в локальную область. Заканчиваю блок
+		mov lastblocksize,0	; инициирцю lastblocksize. 0, значит - переполнения не было и дописанный "хвост" будет умещён в 1 блок 
+		mov rax,CF_FullSize	; В rax=полный размер файла
+		xor rdx,rdx			; Обнуляю RDX т.к. он участвукт в расчётах
+		mov rbx,CF_CurrSize ; в rbx=размер отрезка
+		div rbx				; делю по модулю rax/rbx
+		mov myOffset2End,rdx ; в rdx теперь смещение до конца файла в отрезке
+		mov rax,rdx			; сохраняю rdx для следующего деления
+		xor rdx,rdx			; Обнуляю RDX т.к. он участвукт в расчётах
+		mov rbx,64			; в rbx=64-х байтный отрезок, размер хешированя sha256 
+		div rbx				; делю по модулю rax/rbx
+		mov cyclesInSegment,eax	;в rax теперь количество ЦЕЛЫХ отрезков по 64 байта в массиве
+		mov endingOfSegment,edx ;в rdx теперь остаток от деления по модулю 64 (отрезок,<64 байта,который необходимо закончить по SHA-256 )
+		mov rax,CF_Addr		;--------------------------------------|
+		add rax,myOffset2End;Получаю адрес начала "хвоста" массива-|
+		sub rax,rdx			;--------------------------------------|
+		cmp rdx,56			;сравниваю "хвост" с 56 (448)
+		jb endingofsegment1	;Переходим, если меньше
+		mov lastblocksize,1	;сообщаю, что произойдёт переполнение и блока будет 2 (1024 бита)
+		endingofsegment1:	;━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+		lea rcx,lastblock	;rcx - указатель									┃
+		endingofsegment2:	;													┃
+		mov bl,[rax]		;	перебрасываю хвост в локальную область			┃
+		mov [rcx],bl		;													┃
+		inc rax				;													┃
+		inc rcx				;													┃
+		dec rdx				;													┃
+		jnz endingofsegment2;━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+		mov BYTE ptr [rcx],128	;дописываю 1 и 7 бит
+		mov edx,endingOfSegment
+		inc rdx				;в rdx - длинна хвоста + 8 бит
+		cmp lastblocksize,1 ;далее разный расчёт в зависимости от того было ли переполнение или нет.
+		je endingofsegment3	;если переполнение было, то посылаем на endingofsegment3
+		mov rcx,56
+		sub rcx,rdx			;в rcx количество байт, необходимых для дописания нулей до значения 56 (448 бит)
+		jmp endingofsegment4
+		endingofsegment3:
+		mov rcx,120
+		sub rcx,rdx			;в rcx количество байт, необходимых для дописания нулей до значения 120 (960 бит)
+		endingofsegment4:
+		lea rax,lastblock
+		add rax,rdx			;в rax следующий байт за дописанным 10000000
+		loop_endingofsegment:		;━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+		cmp rcx,0					;													┃
+		je end_loop_endingofsegment	;													┃
+		mov BYTE PTR [rax],0		;заполняю нулями до кратного 56 или 120 байт		┃
+		inc rax						;													┃
+		dec rcx						;													┃
+		jmp loop_endingofsegment	;━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+		end_loop_endingofsegment:	;━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+		mov rbx,CF_FullSize			;													┃
+		shl rbx,3					;дописываю в конец 8 байт размера файла				┃
+		bswap rbx					;													┃
+		mov QWORD PTR [rax],rbx		;━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+	;Счётчик цикла=0?
+		cycleCheck:
+		mov eax,cyclesInSegment
+		cmp eax,0
+		je exithash
+	;Беру очередной блок 64B В XMM0-XMM4
+		mov rax,CF_Addr
+		movdqu XMM0,XMMWORD PTR [rax]
+		movdqu XMM1,XMMWORD PTR [rax+16]
+		movdqu XMM2,XMMWORD PTR [rax+32]
+		movdqu XMM3,XMMWORD PTR [rax+48]
+	;Готовлю очередь сообщений W в регистрах XMM0-XMM15 от младшего слова к старшему, от 0 до 15
+		call Wt	;
+		;--------------------------------------------------------------------------
 
-	leave
-	xor rax,rax
+	;Да. Беру окончание массива (64 или 128 байт), хэширую их
+		exithash:
+		;Беру очередной блок 64B В XMM0-XMM4
+		lea rax,lastblock
+		movdqu XMM0,XMMWORD PTR [rax]
+		movdqu XMM1,XMMWORD PTR [rax+16]
+		movdqu XMM2,XMMWORD PTR [rax+32]
+		movdqu XMM3,XMMWORD PTR [rax+48]
+		call Wt	
 		ret
 Sha256 Endp
 ;Инициализация хэш функции, ввод исходных значений
-Sha256Init proc __fastcall
+Sha256Init proc;__fastcall
 	LOCAL myInt64:QWORD ;Число для преобразования
 	LOCAL squareRoot:QWORD ;Корень
 	LOCAL delitel:QWORD ;делитель (равен 1 для извлечения дробной части числа)
 	LOCAL mnoz:QWORD;множитель для выведение целого числа
 	LOCAL myxmmword:XMMWORD
-	enter 8*8,0
+	;push rbp			;пролог, для того что бы по rbp-n \
+	;mov rbp,rsp			;\обращаться к локальным переменным
+	;sub rsp,4*8		;создаю стековый фрйм, нахуя он нужен в душе не ябу(((
 	lea rdx,prime_nums ;в RDX массив простых чисел
-	lea r8,xmmhash ;в R8 - адрес инициализированного хэша (его начальных значений)
+	mov r8,rcx ;в R8 - адрес инициализированного хэша переданного вызывающей процедурой
 	mov rcx,8 ;в RCX количество повторений цикла. Для процессора нет разницы, обращаться к DL или к RDX, поэтому снижаю расходы приводя всё к единому размеру
-	mov rax,1373893702338282242
+	mov rax,1373893702338282242 ;8 простых чисел от 2 до 19-ти, прекрасно ложатся в 16 байт 64-битного регистра. Поэтому сунул их в один регистр
 	mov QWORD PTR [rdx],rax ; инициализирую простые числа от 2 до 19
-loop1:
+	loop1:
 	finit
 	mov al, BYTE PTR [rdx]		;беру текущее простое число
 	and rax,255
@@ -148,12 +281,12 @@ loop1:
 	inc rdx						;сдвигаю указатель на простое число 
 	dec rcx
 	jnz loop1					;цикл
-; Далее, инициализирую константы (k) кубическим корнем ряда первых 64 простых числел от 2 до 311
+	; Далее, инициализирую константы (k) кубическим корнем ряда первых 64 простых числел от 2 до 311
 	lea rdx,prime2nums ;в RDX адресс массива простых числел
-forxmm0: ;Заполняю регистр XMM0 значениями 4-х корней
+	forxmm0: ;Заполняю регистр XMM0 значениями 4-х корней
 	mov r8,64	;счётчик цикла
 	lea r9,k_konst ;указатель на буфер k_konst
-loopxmm0:	
+	loopxmm0:	
 	mov cx, word ptr [rdx]; беру текущее простое число
 	and rcx,65535	;обнуляю остальные биты
 	call z3sqrt ;вызываю процедуру рассчёта дробной части от кубического корня от числа в rcx
@@ -162,7 +295,6 @@ loopxmm0:
 	add r9,4	;сдвигаю указатель на буфер k_konst
 	dec r8	;уменьшаю счётчик
 	jnz loopxmm0						;цикл
-	leave
 	ret
 Sha256Init Endp
 _isAvxSupported: ; extern "C" int isAvxSupported()
@@ -185,13 +317,12 @@ _isAvxSupported: ; extern "C" int isAvxSupported()
 	not_supported:
     xor eax, eax
     ret
-z3sqrt proc __fastcall ;вынес вычисление кубического корня в процедуру. На входе, в rcx - простое число, на выходе, в rax 32 бита остатка.
+z3sqrt proc  ;вынес вычисление кубического корня в процедуру. На входе, в rcx - простое число, на выходе, в rax 32 бита остатка.
 	LOCAL myInt64:QWORD	;локальная переменная для хранения простого числа
 	LOCAL delitel:QWORD ;делитель (равен 1 для извлечения дробной части числа)
 	LOCAL mnoz:QWORD;множитель для выведение целого числа
 	LOCAL result:QWORD ;результат
 	LOCAL regCR:word	;ячейка для сохренения регистра CR (FPU)	
-	enter 5*8,0	
 	mov myInt64,rcx	;сохраняю в переменную
 	mov delitel,1	;единица для деления по модулю
 	mov rax,4294967296			;множитель 2^32, нужен...\
@@ -218,7 +349,135 @@ z3sqrt proc __fastcall ;вынес вычисление кубического
 	fmul ST,ST(2)				;сдвигаю на 32
 	fisttp qword ptr result	;сохраняю результат	
 	mov rax,result
-	leave
 	ret
 z3sqrt endp
+Wt proc; вынес в отдельную процедуру заполнение Wt. На выходе - заполненные XMM регистры
+	xorps xmm4,xmm4		;━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+	xorps xmm5,xmm5		;													┃
+	xorps xmm6,xmm6		;													┃
+	xorps xmm7,xmm7		;													┃
+	xorps xmm8,xmm8		;													┃
+	xorps xmm9,xmm9		;													┃
+	xorps xmm10,xmm10	;инициирую xmm регистры нулями						┃
+	xorps xmm11,xmm11	;													┃
+	xorps xmm12,xmm12	;													┃
+	xorps xmm13,xmm13	;													┃
+	xorps xmm14,xmm14	;													┃
+	xorps xmm15,xmm15	;━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+	;W16--------------------------------------------------------------------------
+		xor rcx,rcx	;в ecx будет xor трёх вращений 
+		pshufd xmm0,xmm0,00111001b	;-15. 1-е слово двигается на младшую позицию XMM
+		movd eax,xmm0
+		bswap eax
+		ror eax,7
+		xor ecx,eax
+		ror eax,11
+		xor ecx,eax
+		rol eax,15
+		and eax,1fffffffh
+		xor ecx,eax 		; S0
+		pshufd xmm3,xmm3,01001110b	;-2. 14-е слово двигается на младшую позицию XMM
+		xor rbx,rbx	;в ebx будет xor трёх вращений
+		movd eax,xmm3
+		bswap eax
+		ror eax,17
+		xor ebx,eax
+		ror eax,2
+		xor ebx,eax
+		rol eax,9
+		and eax,3fffffh
+		xor ebx,eax			;S1
+		pshufd xmm0,xmm0,10010011b ;-16. 0-е слово двигается на младшую позицию XMM
+		xor rdx,rdx
+		movd eax,xmm0
+		bswap eax
+		add edx,eax
+		add edx,ecx
+		pshufd xmm2,xmm2,00111001b ;-7. 9-е слово двигается на младшую позицию XMM
+		movd eax,xmm2
+		bswap eax
+		add edx,eax
+		add edx,ebx ;w[i]=w[i-16]+s0+w[i-7]+s1
+		;pshufd xmm4,xmm4,11100100b ;16-е слово двигается на младшую позицию XMM
+		;bswap edx
+		movd xmm4,edx
+		;movd eax,xmm4;проверяю, как хранить данные в xmm/
+	;W17---------------------------------------------------------------------------
+		xor rcx,rcx	;в ecx будет xor трёх вращений 
+		pshufd xmm0,xmm0,01001110b	;-15. 2-е слово двигается на младшую позицию XMM
+		movd eax,xmm0
+		bswap eax
+		ror eax,7
+		xor ecx,eax
+		ror eax,11
+		xor ecx,eax
+		rol eax,15
+		and eax,1fffffffh
+		xor ecx,eax 		; S0
+		pshufd xmm3,xmm3,00111001b	;-2. 15-е слово двигается на младшую позицию XMM
+		xor rbx,rbx	;в ebx будет xor трёх вращений
+		movd eax,xmm3
+		bswap eax
+		ror eax,17
+		xor ebx,eax
+		ror eax,2
+		xor ebx,eax
+		rol eax,9
+		and eax,3fffffh
+		xor ebx,eax			;S1
+		pshufd xmm0,xmm0,10010011b ;-16. 1-е слово двигается на младшую позицию XMM
+		xor rdx,rdx
+		movd eax,xmm0
+		bswap eax
+		add edx,eax
+		add edx,ecx
+		pshufd xmm2,xmm2,00111001b ;-7. 10-е слово двигается на младшую позицию XMM
+		movd eax,xmm2
+		bswap eax
+		add edx,eax
+		add edx,ebx ;w[i]=w[i-16]+s0+w[i-7]+s1
+		pshufd xmm4,xmm4,00111001b ;17-е слово двигается на младшую позицию XMM
+		;bswap edx
+		movd xmm15,edx
+		orpd xmm4,xmm15
+	;W18---------------------------------------------------------------------------
+		xor rcx,rcx	;в ecx будет xor трёх вращений 
+		pshufd xmm0,xmm0,01001110b	;-15. 3-е слово двигается на младшую позицию XMM
+		movd eax,xmm0
+		bswap eax
+		ror eax,7
+		xor ecx,eax
+		ror eax,11
+		xor ecx,eax
+		rol eax,15
+		and eax,1fffffffh
+		xor ecx,eax 		; S0
+		pshufd xmm4,xmm4,10010011b	;-2. 16-е слово двигается на младшую позицию XMM
+		xor rbx,rbx	;в ebx будет xor трёх вращений
+		movd eax,xmm4
+		bswap eax
+		ror eax,17
+		xor ebx,eax
+		ror eax,2
+		xor ebx,eax
+		rol eax,9
+		and eax,3fffffh
+		xor ebx,eax			;S1
+		pshufd xmm0,xmm0,10010011b ;-16. 2-е слово двигается на младшую позицию XMM
+		xor rdx,rdx
+		movd eax,xmm0
+		bswap eax
+		add edx,eax
+		add edx,ecx
+		pshufd xmm2,xmm2,00111001b ;-7. 11-е слово двигается на младшую позицию XMM
+		movd eax,xmm2
+		bswap eax
+		add edx,eax
+		add edx,ebx ;w[i]=w[i-16]+s0+w[i-7]+s1
+		pshufd xmm4,xmm4,01001110b ;18-е слово двигается на младшую позицию XMM
+		;bswap edx
+		movd xmm15,edx
+		orpd xmm4,xmm15
+	ret	
+Wt Endp
 end

На чём остановился.txt

@@ -1,2 +1,19 @@
-После подключения DLL вызывающая прогамма ловит исключение через 20-30 секунд (в дебагере - сразу). Похоже, глюк в адресации. Проверить возвращаемые значения.
-Проблема оказалась в том, что в wndproc переменные я хранил локально, что давало исключене после вызова DLL
+в секции .data глюк: несколько массивов (DUP) находятся под разными метками, но имеют один адрес в дебагере
+Конкретно: k_konst и sha_hash
+Решилось: неправильно использовал оператор DUP: Надо сначала писать сколько, а в скобках (чего). 10 dup (0), а я писал наоборот
+
+Остановился на деление по модулю. Нужно разделить весь объём на величину отрезка. Пока исключение, видимо потому, что 64-битные регистры использую.
+Решено: не обнулял rdx. Деление происходит не одного rax, а пары rdx:rax. Вылетало по переполнению.
+
+Разобраться с прологом и эпилогом. Сейчас их нет и обращение идёт по недопустимому адресу т.к. в rbp ноль.
+Решено: пролог и эпилог подставляются автоматически, если установить опции: 
+    OPTION PROLOGUE:PrologueDef 
+    OPTION EPILOGUE:EpilogueDef
+Кстати, enter - везде пишут, что он тормозной и лучше использовать push ebp; mov ebp,esp. А sub esp,nnn нужен, чтобы вызываемая процедура могла делать push
+и не перезаписывать при этом локальные переменные.
+
+Написать в Excel скрипт, который в зависимости от i, даёт имя регистра в котором есть i-15, i-2 и i-16, выдавая при этом порядок байт, при котором команда pshufd выдвинет 
+искомое слово на младшие 32 бита XMM регистра 
+- Сделано
+
+Закончил расчёт w16, считает павильно. Но пока не получилось правильно сохранить в XMM4

Регистры.txt

@@ -9,19 +9,19 @@ R12 64(double) 00000000 00000000 8 байт - H1,H2
 R13 64(double) 00000000 00000000 8 байт - H3,H4
 R14	64(double) 00000000 00000000 8 байт - H5,H6
 R15	64(double) 00000000 00000000 8 байт - H7,H8
-XMM0 128 00000000 00000000 00000000 00000000 16 байт - W1,W2,W3,W4
-XMM1 128 00000000 00000000 00000000 00000000 16 байт - W5,W6,W7,W8
-XMM2 128 00000000 00000000 00000000 00000000 16 байт - W9,W10,W11,W12
-XMM3 128 00000000 00000000 00000000 00000000 16 байт - W13,W14,W15,W16
-XMM4 128 00000000 00000000 00000000 00000000 16 байт - W17,W18,W19,W20
-XMM5 128 00000000 00000000 00000000 00000000 16 байт - W21,W22,W23,W24
-XMM6 128 00000000 00000000 00000000 00000000 16 байт - W25,W26,W27,W28
-XMM7 128 00000000 00000000 00000000 00000000 16 байт - W29,W30,W31,W32
-XMM8 128 00000000 00000000 00000000 00000000 16 байт - W33,W34,W35,W36
-XMM9 128 00000000 00000000 00000000 00000000 16 байт - W37,W38,W39,W40
-XMM10 128 00000000 00000000 00000000 00000000 16 байт- W41,W24,W43,W44
-XMM11 128 00000000 00000000 00000000 00000000 16 байт- W45,W46,W47,W48
-XMM12 128 00000000 00000000 00000000 00000000 16 байт- W49,W50,W51,W52
-XMM13 128 00000000 00000000 00000000 00000000 16 байт- W53,W54,W55,W56
-XMM14 128 00000000 00000000 00000000 00000000 16 байт- W57,W58,W59,W60
-XMM15 128 00000000 00000000 00000000 00000000 16 байт- W61,W62,W63,W64
+XMM0 128 00000000 00000000 00000000 00000000 16 байт - W3,W2,W1,W0
+XMM1 128 00000000 00000000 00000000 00000000 16 байт - W7,W6,W5,W4
+XMM2 128 00000000 00000000 00000000 00000000 16 байт - W11,W10,W9,W8
+XMM3 128 00000000 00000000 00000000 00000000 16 байт - W15,W14,W13,W12
+XMM4 128 00000000 00000000 00000000 00000000 16 байт - W19,W18,W17,W16
+XMM5 128 00000000 00000000 00000000 00000000 16 байт - W23,W22,W21,W20
+XMM6 128 00000000 00000000 00000000 00000000 16 байт - W27,W26,W25,W24
+XMM7 128 00000000 00000000 00000000 00000000 16 байт - W31,W30,W29,W28
+XMM8 128 00000000 00000000 00000000 00000000 16 байт - W35,W34,W33,W32
+XMM9 128 00000000 00000000 00000000 00000000 16 байт - W39,W38,W36,W36
+XMM10 128 00000000 00000000 00000000 00000000 16 байт- W43,W42,W41,W40
+XMM11 128 00000000 00000000 00000000 00000000 16 байт- W47,W46,W45,W44
+XMM12 128 00000000 00000000 00000000 00000000 16 байт- W51,W50,W49,W48
+XMM13 128 00000000 00000000 00000000 00000000 16 байт- W55,W54,W53,W52
+XMM14 128 00000000 00000000 00000000 00000000 16 байт- W59,W58,W57,W56
+XMM15 128 00000000 00000000 00000000 00000000 16 байт- W63,W62,W61,W60