Black Lives Matter. Support the Equal Justice Initiative.

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)
   102TEXT ·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
   121loop:
   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
   226end:
   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