...
Run Format

Text file src/crypto/sha1/sha1block_386.s

Documentation: crypto/sha1

     1	// Copyright 2013 The Go Authors. All rights reserved.
     2	// Use of this source code is governed by a BSD-style
     3	// license that can be found in the LICENSE file.
     4	
     5	#include "textflag.h"
     6	
     7	// SHA-1 block routine. See sha1block.go for Go equivalent.
     8	//
     9	// There are 80 rounds of 4 types:
    10	//   - rounds 0-15 are type 1 and load data (ROUND1 macro).
    11	//   - rounds 16-19 are type 1 and do not load data (ROUND1x macro).
    12	//   - rounds 20-39 are type 2 and do not load data (ROUND2 macro).
    13	//   - rounds 40-59 are type 3 and do not load data (ROUND3 macro).
    14	//   - rounds 60-79 are type 4 and do not load data (ROUND4 macro).
    15	//
    16	// Each round loads or shuffles the data, then computes a per-round
    17	// function of b, c, d, and then mixes the result into and rotates the
    18	// five registers a, b, c, d, e holding the intermediate results.
    19	//
    20	// The register rotation is implemented by rotating the arguments to
    21	// the round macros instead of by explicit move instructions.
    22	
    23	// Like sha1block_amd64.s, but we keep the data and limit pointers on the stack.
    24	// To free up the word pointer (R10 on amd64, DI here), we add it to e during
    25	// LOAD/SHUFFLE instead of during MIX.
    26	//
    27	// The stack holds the intermediate word array - 16 uint32s - at 0(SP) up to 64(SP).
    28	// The saved a, b, c, d, e (R11 through R15 on amd64) are at 64(SP) up to 84(SP).
    29	// The saved limit pointer (DI on amd64) is at 84(SP).
    30	// The saved data pointer (SI on amd64) is at 88(SP).
    31	
    32	#define LOAD(index, e) \
    33		MOVL	88(SP), SI; \
    34		MOVL	(index*4)(SI), DI; \
    35		BSWAPL	DI; \
    36		MOVL	DI, (index*4)(SP); \
    37		ADDL	DI, e
    38	
    39	#define SHUFFLE(index, e) \
    40		MOVL	(((index)&0xf)*4)(SP), DI; \
    41		XORL	(((index-3)&0xf)*4)(SP), DI; \
    42		XORL	(((index-8)&0xf)*4)(SP), DI; \
    43		XORL	(((index-14)&0xf)*4)(SP), DI; \
    44		ROLL	$1, DI; \
    45		MOVL	DI, (((index)&0xf)*4)(SP); \
    46		ADDL	DI, e
    47	
    48	#define FUNC1(a, b, c, d, e) \
    49		MOVL	d, DI; \
    50		XORL	c, DI; \
    51		ANDL	b, DI; \
    52		XORL	d, DI
    53	
    54	#define FUNC2(a, b, c, d, e) \
    55		MOVL	b, DI; \
    56		XORL	c, DI; \
    57		XORL	d, DI
    58	
    59	#define FUNC3(a, b, c, d, e) \
    60		MOVL	b, SI; \
    61		ORL	c, SI; \
    62		ANDL	d, SI; \
    63		MOVL	b, DI; \
    64		ANDL	c, DI; \
    65		ORL	SI, DI
    66	
    67	#define FUNC4 FUNC2
    68	
    69	#define MIX(a, b, c, d, e, const) \
    70		ROLL	$30, b; \
    71		ADDL	DI, e; \
    72		MOVL	a, SI; \
    73		ROLL	$5, SI; \
    74		LEAL	const(e)(SI*1), e
    75	
    76	#define ROUND1(a, b, c, d, e, index) \
    77		LOAD(index, e); \
    78		FUNC1(a, b, c, d, e); \
    79		MIX(a, b, c, d, e, 0x5A827999)
    80	
    81	#define ROUND1x(a, b, c, d, e, index) \
    82		SHUFFLE(index, e); \
    83		FUNC1(a, b, c, d, e); \
    84		MIX(a, b, c, d, e, 0x5A827999)
    85	
    86	#define ROUND2(a, b, c, d, e, index) \
    87		SHUFFLE(index, e); \
    88		FUNC2(a, b, c, d, e); \
    89		MIX(a, b, c, d, e, 0x6ED9EBA1)
    90	
    91	#define ROUND3(a, b, c, d, e, index) \
    92		SHUFFLE(index, e); \
    93		FUNC3(a, b, c, d, e); \
    94		MIX(a, b, c, d, e, 0x8F1BBCDC)
    95	
    96	#define ROUND4(a, b, c, d, e, index) \
    97		SHUFFLE(index, e); \
    98		FUNC4(a, b, c, d, e); \
    99		MIX(a, b, c, d, e, 0xCA62C1D6)
   100	
   101	// func block(dig *digest, p []byte)
   102	TEXT ·block(SB),NOSPLIT,$92-16
   103		MOVL	dig+0(FP),	BP
   104		MOVL	p+4(FP),	SI
   105		MOVL	p_len+8(FP),	DX
   106		SHRL	$6,		DX
   107		SHLL	$6,		DX
   108		
   109		LEAL	(SI)(DX*1),	DI
   110		MOVL	(0*4)(BP),	AX
   111		MOVL	(1*4)(BP),	BX
   112		MOVL	(2*4)(BP),	CX
   113		MOVL	(3*4)(BP),	DX
   114		MOVL	(4*4)(BP),	BP
   115	
   116		CMPL	SI,		DI
   117		JEQ	end
   118	
   119		MOVL	DI,	84(SP)
   120	
   121	loop:
   122		MOVL	SI,	88(SP)
   123	
   124		MOVL	AX,	64(SP)
   125		MOVL	BX,	68(SP)
   126		MOVL	CX,	72(SP)
   127		MOVL	DX,	76(SP)
   128		MOVL	BP,	80(SP)
   129	
   130		ROUND1(AX, BX, CX, DX, BP, 0)
   131		ROUND1(BP, AX, BX, CX, DX, 1)
   132		ROUND1(DX, BP, AX, BX, CX, 2)
   133		ROUND1(CX, DX, BP, AX, BX, 3)
   134		ROUND1(BX, CX, DX, BP, AX, 4)
   135		ROUND1(AX, BX, CX, DX, BP, 5)
   136		ROUND1(BP, AX, BX, CX, DX, 6)
   137		ROUND1(DX, BP, AX, BX, CX, 7)
   138		ROUND1(CX, DX, BP, AX, BX, 8)
   139		ROUND1(BX, CX, DX, BP, AX, 9)
   140		ROUND1(AX, BX, CX, DX, BP, 10)
   141		ROUND1(BP, AX, BX, CX, DX, 11)
   142		ROUND1(DX, BP, AX, BX, CX, 12)
   143		ROUND1(CX, DX, BP, AX, BX, 13)
   144		ROUND1(BX, CX, DX, BP, AX, 14)
   145		ROUND1(AX, BX, CX, DX, BP, 15)
   146	
   147		ROUND1x(BP, AX, BX, CX, DX, 16)
   148		ROUND1x(DX, BP, AX, BX, CX, 17)
   149		ROUND1x(CX, DX, BP, AX, BX, 18)
   150		ROUND1x(BX, CX, DX, BP, AX, 19)
   151		
   152		ROUND2(AX, BX, CX, DX, BP, 20)
   153		ROUND2(BP, AX, BX, CX, DX, 21)
   154		ROUND2(DX, BP, AX, BX, CX, 22)
   155		ROUND2(CX, DX, BP, AX, BX, 23)
   156		ROUND2(BX, CX, DX, BP, AX, 24)
   157		ROUND2(AX, BX, CX, DX, BP, 25)
   158		ROUND2(BP, AX, BX, CX, DX, 26)
   159		ROUND2(DX, BP, AX, BX, CX, 27)
   160		ROUND2(CX, DX, BP, AX, BX, 28)
   161		ROUND2(BX, CX, DX, BP, AX, 29)
   162		ROUND2(AX, BX, CX, DX, BP, 30)
   163		ROUND2(BP, AX, BX, CX, DX, 31)
   164		ROUND2(DX, BP, AX, BX, CX, 32)
   165		ROUND2(CX, DX, BP, AX, BX, 33)
   166		ROUND2(BX, CX, DX, BP, AX, 34)
   167		ROUND2(AX, BX, CX, DX, BP, 35)
   168		ROUND2(BP, AX, BX, CX, DX, 36)
   169		ROUND2(DX, BP, AX, BX, CX, 37)
   170		ROUND2(CX, DX, BP, AX, BX, 38)
   171		ROUND2(BX, CX, DX, BP, AX, 39)
   172		
   173		ROUND3(AX, BX, CX, DX, BP, 40)
   174		ROUND3(BP, AX, BX, CX, DX, 41)
   175		ROUND3(DX, BP, AX, BX, CX, 42)
   176		ROUND3(CX, DX, BP, AX, BX, 43)
   177		ROUND3(BX, CX, DX, BP, AX, 44)
   178		ROUND3(AX, BX, CX, DX, BP, 45)
   179		ROUND3(BP, AX, BX, CX, DX, 46)
   180		ROUND3(DX, BP, AX, BX, CX, 47)
   181		ROUND3(CX, DX, BP, AX, BX, 48)
   182		ROUND3(BX, CX, DX, BP, AX, 49)
   183		ROUND3(AX, BX, CX, DX, BP, 50)
   184		ROUND3(BP, AX, BX, CX, DX, 51)
   185		ROUND3(DX, BP, AX, BX, CX, 52)
   186		ROUND3(CX, DX, BP, AX, BX, 53)
   187		ROUND3(BX, CX, DX, BP, AX, 54)
   188		ROUND3(AX, BX, CX, DX, BP, 55)
   189		ROUND3(BP, AX, BX, CX, DX, 56)
   190		ROUND3(DX, BP, AX, BX, CX, 57)
   191		ROUND3(CX, DX, BP, AX, BX, 58)
   192		ROUND3(BX, CX, DX, BP, AX, 59)
   193		
   194		ROUND4(AX, BX, CX, DX, BP, 60)
   195		ROUND4(BP, AX, BX, CX, DX, 61)
   196		ROUND4(DX, BP, AX, BX, CX, 62)
   197		ROUND4(CX, DX, BP, AX, BX, 63)
   198		ROUND4(BX, CX, DX, BP, AX, 64)
   199		ROUND4(AX, BX, CX, DX, BP, 65)
   200		ROUND4(BP, AX, BX, CX, DX, 66)
   201		ROUND4(DX, BP, AX, BX, CX, 67)
   202		ROUND4(CX, DX, BP, AX, BX, 68)
   203		ROUND4(BX, CX, DX, BP, AX, 69)
   204		ROUND4(AX, BX, CX, DX, BP, 70)
   205		ROUND4(BP, AX, BX, CX, DX, 71)
   206		ROUND4(DX, BP, AX, BX, CX, 72)
   207		ROUND4(CX, DX, BP, AX, BX, 73)
   208		ROUND4(BX, CX, DX, BP, AX, 74)
   209		ROUND4(AX, BX, CX, DX, BP, 75)
   210		ROUND4(BP, AX, BX, CX, DX, 76)
   211		ROUND4(DX, BP, AX, BX, CX, 77)
   212		ROUND4(CX, DX, BP, AX, BX, 78)
   213		ROUND4(BX, CX, DX, BP, AX, 79)
   214	
   215		ADDL	64(SP), AX
   216		ADDL	68(SP), BX
   217		ADDL	72(SP), CX
   218		ADDL	76(SP), DX
   219		ADDL	80(SP), BP
   220	
   221		MOVL	88(SP), SI
   222		ADDL	$64, SI
   223		CMPL	SI, 84(SP)
   224		JB	loop
   225	
   226	end:
   227		MOVL	dig+0(FP), DI
   228		MOVL	AX, (0*4)(DI)
   229		MOVL	BX, (1*4)(DI)
   230		MOVL	CX, (2*4)(DI)
   231		MOVL	DX, (3*4)(DI)
   232		MOVL	BP, (4*4)(DI)
   233		RET

View as plain text