...
Run Format

Text file src/crypto/sha1/sha1block_arm.s

Documentation: crypto/sha1

     1	// Copyright 2014 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	// ARM version of md5block.go
     6	
     7	#include "textflag.h"
     8	
     9	// SHA-1 block routine. See sha1block.go for Go equivalent.
    10	//
    11	// There are 80 rounds of 4 types:
    12	//   - rounds 0-15 are type 1 and load data (ROUND1 macro).
    13	//   - rounds 16-19 are type 1 and do not load data (ROUND1x macro).
    14	//   - rounds 20-39 are type 2 and do not load data (ROUND2 macro).
    15	//   - rounds 40-59 are type 3 and do not load data (ROUND3 macro).
    16	//   - rounds 60-79 are type 4 and do not load data (ROUND4 macro).
    17	//
    18	// Each round loads or shuffles the data, then computes a per-round
    19	// function of b, c, d, and then mixes the result into and rotates the
    20	// five registers a, b, c, d, e holding the intermediate results.
    21	//
    22	// The register rotation is implemented by rotating the arguments to
    23	// the round macros instead of by explicit move instructions.
    24	
    25	// Register definitions
    26	#define Rdata	R0	// Pointer to incoming data
    27	#define Rconst	R1	// Current constant for SHA round
    28	#define Ra	R2		// SHA-1 accumulator
    29	#define Rb	R3		// SHA-1 accumulator
    30	#define Rc	R4		// SHA-1 accumulator
    31	#define Rd	R5		// SHA-1 accumulator
    32	#define Re	R6		// SHA-1 accumulator
    33	#define Rt0	R7		// Temporary
    34	#define Rt1	R8		// Temporary
    35	// r9, r10 are forbidden
    36	// r11 is OK provided you check the assembler that no synthetic instructions use it
    37	#define Rt2	R11		// Temporary
    38	#define Rctr	R12	// loop counter
    39	#define Rw	R14		// point to w buffer
    40	
    41	// func block(dig *digest, p []byte)
    42	// 0(FP) is *digest
    43	// 4(FP) is p.array (struct Slice)
    44	// 8(FP) is p.len
    45	//12(FP) is p.cap
    46	//
    47	// Stack frame
    48	#define p_end	end-4(SP)		// pointer to the end of data
    49	#define p_data	data-8(SP)	// current data pointer (unused?)
    50	#define w_buf	buf-(8+4*80)(SP)	//80 words temporary buffer w uint32[80]
    51	#define saved	abcde-(8+4*80+4*5)(SP)	// saved sha1 registers a,b,c,d,e - these must be last (unused?)
    52	// Total size +4 for saved LR is 352
    53	
    54		// w[i] = p[j]<<24 | p[j+1]<<16 | p[j+2]<<8 | p[j+3]
    55		// e += w[i]
    56	#define LOAD(Re) \
    57		MOVBU	2(Rdata), Rt0 ; \
    58		MOVBU	3(Rdata), Rt1 ; \
    59		MOVBU	1(Rdata), Rt2 ; \
    60		ORR	Rt0<<8, Rt1, Rt0	    ; \
    61		MOVBU.P	4(Rdata), Rt1 ; \
    62		ORR	Rt2<<16, Rt0, Rt0	    ; \
    63		ORR	Rt1<<24, Rt0, Rt0	    ; \
    64		MOVW.P	Rt0, 4(Rw)		    ; \
    65		ADD	Rt0, Re, Re
    66		
    67		// tmp := w[(i-3)&0xf] ^ w[(i-8)&0xf] ^ w[(i-14)&0xf] ^ w[(i)&0xf]
    68		// w[i&0xf] = tmp<<1 | tmp>>(32-1)
    69		// e += w[i&0xf] 
    70	#define SHUFFLE(Re) \
    71		MOVW	(-16*4)(Rw), Rt0 ; \
    72		MOVW	(-14*4)(Rw), Rt1 ; \
    73		MOVW	(-8*4)(Rw), Rt2  ; \
    74		EOR	Rt0, Rt1, Rt0  ; \
    75		MOVW	(-3*4)(Rw), Rt1  ; \
    76		EOR	Rt2, Rt0, Rt0  ; \
    77		EOR	Rt0, Rt1, Rt0  ; \
    78		MOVW	Rt0@>(32-1), Rt0  ; \
    79		MOVW.P	Rt0, 4(Rw)	  ; \
    80		ADD	Rt0, Re, Re
    81	
    82		// t1 = (b & c) | ((~b) & d)
    83	#define FUNC1(Ra, Rb, Rc, Rd, Re) \
    84		MVN	Rb, Rt1	   ; \
    85		AND	Rb, Rc, Rt0  ; \
    86		AND	Rd, Rt1, Rt1 ; \
    87		ORR	Rt0, Rt1, Rt1
    88	
    89		// t1 = b ^ c ^ d
    90	#define FUNC2(Ra, Rb, Rc, Rd, Re) \
    91		EOR	Rb, Rc, Rt1 ; \
    92		EOR	Rd, Rt1, Rt1
    93	
    94		// t1 = (b & c) | (b & d) | (c & d) =
    95		// t1 = (b & c) | ((b | c) & d)
    96	#define FUNC3(Ra, Rb, Rc, Rd, Re) \
    97		ORR	Rb, Rc, Rt0  ; \
    98		AND	Rb, Rc, Rt1  ; \
    99		AND	Rd, Rt0, Rt0 ; \
   100		ORR	Rt0, Rt1, Rt1
   101	
   102	#define FUNC4 FUNC2
   103	
   104		// a5 := a<<5 | a>>(32-5)
   105		// b = b<<30 | b>>(32-30)
   106		// e = a5 + t1 + e + const
   107	#define MIX(Ra, Rb, Rc, Rd, Re) \
   108		ADD	Rt1, Re, Re	 ; \
   109		MOVW	Rb@>(32-30), Rb	 ; \
   110		ADD	Ra@>(32-5), Re, Re ; \
   111		ADD	Rconst, Re, Re
   112	
   113	#define ROUND1(Ra, Rb, Rc, Rd, Re) \
   114		LOAD(Re)		; \
   115		FUNC1(Ra, Rb, Rc, Rd, Re)	; \
   116		MIX(Ra, Rb, Rc, Rd, Re)
   117	
   118	#define ROUND1x(Ra, Rb, Rc, Rd, Re) \
   119		SHUFFLE(Re)	; \
   120		FUNC1(Ra, Rb, Rc, Rd, Re)	; \
   121		MIX(Ra, Rb, Rc, Rd, Re)
   122	
   123	#define ROUND2(Ra, Rb, Rc, Rd, Re) \
   124		SHUFFLE(Re)	; \
   125		FUNC2(Ra, Rb, Rc, Rd, Re)	; \
   126		MIX(Ra, Rb, Rc, Rd, Re)
   127	
   128	#define ROUND3(Ra, Rb, Rc, Rd, Re) \
   129		SHUFFLE(Re)	; \
   130		FUNC3(Ra, Rb, Rc, Rd, Re)	; \
   131		MIX(Ra, Rb, Rc, Rd, Re)
   132	
   133	#define ROUND4(Ra, Rb, Rc, Rd, Re) \
   134		SHUFFLE(Re)	; \
   135		FUNC4(Ra, Rb, Rc, Rd, Re)	; \
   136		MIX(Ra, Rb, Rc, Rd, Re)
   137	
   138	
   139	// func block(dig *digest, p []byte)
   140	TEXT	·block(SB), 0, $352-16
   141		MOVW	p+4(FP), Rdata	// pointer to the data
   142		MOVW	p_len+8(FP), Rt0	// number of bytes
   143		ADD	Rdata, Rt0
   144		MOVW	Rt0, p_end	// pointer to end of data
   145	
   146		// Load up initial SHA-1 accumulator
   147		MOVW	dig+0(FP), Rt0
   148		MOVM.IA (Rt0), [Ra,Rb,Rc,Rd,Re]
   149	
   150	loop:
   151		// Save registers at SP+4 onwards
   152		MOVM.IB [Ra,Rb,Rc,Rd,Re], (R13)
   153	
   154		MOVW	$w_buf, Rw
   155		MOVW	$0x5A827999, Rconst
   156		MOVW	$3, Rctr
   157	loop1:	ROUND1(Ra, Rb, Rc, Rd, Re)
   158		ROUND1(Re, Ra, Rb, Rc, Rd)
   159		ROUND1(Rd, Re, Ra, Rb, Rc)
   160		ROUND1(Rc, Rd, Re, Ra, Rb)
   161		ROUND1(Rb, Rc, Rd, Re, Ra)
   162		SUB.S	$1, Rctr
   163		BNE	loop1
   164	
   165		ROUND1(Ra, Rb, Rc, Rd, Re)
   166		ROUND1x(Re, Ra, Rb, Rc, Rd)
   167		ROUND1x(Rd, Re, Ra, Rb, Rc)
   168		ROUND1x(Rc, Rd, Re, Ra, Rb)
   169		ROUND1x(Rb, Rc, Rd, Re, Ra)
   170		
   171		MOVW	$0x6ED9EBA1, Rconst
   172		MOVW	$4, Rctr
   173	loop2:	ROUND2(Ra, Rb, Rc, Rd, Re)
   174		ROUND2(Re, Ra, Rb, Rc, Rd)
   175		ROUND2(Rd, Re, Ra, Rb, Rc)
   176		ROUND2(Rc, Rd, Re, Ra, Rb)
   177		ROUND2(Rb, Rc, Rd, Re, Ra)
   178		SUB.S	$1, Rctr
   179		BNE	loop2
   180		
   181		MOVW	$0x8F1BBCDC, Rconst
   182		MOVW	$4, Rctr
   183	loop3:	ROUND3(Ra, Rb, Rc, Rd, Re)
   184		ROUND3(Re, Ra, Rb, Rc, Rd)
   185		ROUND3(Rd, Re, Ra, Rb, Rc)
   186		ROUND3(Rc, Rd, Re, Ra, Rb)
   187		ROUND3(Rb, Rc, Rd, Re, Ra)
   188		SUB.S	$1, Rctr
   189		BNE	loop3
   190		
   191		MOVW	$0xCA62C1D6, Rconst
   192		MOVW	$4, Rctr
   193	loop4:	ROUND4(Ra, Rb, Rc, Rd, Re)
   194		ROUND4(Re, Ra, Rb, Rc, Rd)
   195		ROUND4(Rd, Re, Ra, Rb, Rc)
   196		ROUND4(Rc, Rd, Re, Ra, Rb)
   197		ROUND4(Rb, Rc, Rd, Re, Ra)
   198		SUB.S	$1, Rctr
   199		BNE	loop4
   200	
   201		// Accumulate - restoring registers from SP+4
   202		MOVM.IB (R13), [Rt0,Rt1,Rt2,Rctr,Rw]
   203		ADD	Rt0, Ra
   204		ADD	Rt1, Rb
   205		ADD	Rt2, Rc
   206		ADD	Rctr, Rd
   207		ADD	Rw, Re
   208	
   209		MOVW	p_end, Rt0
   210		CMP	Rt0, Rdata
   211		BLO	loop
   212	
   213		// Save final SHA-1 accumulator
   214		MOVW	dig+0(FP), Rt0
   215		MOVM.IA [Ra,Rb,Rc,Rd,Re], (Rt0)
   216	
   217		RET

View as plain text