Text file src/crypto/sha1/sha1block_386.s

     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
   234  

View as plain text