1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2;  Project:  TwlSDK - MATH - libraries
3;  File:     sha256.s
4;
5;  Copyright 2008 Nintendo.  All rights reserved.
6;
7;  These coded instructions, statements, and computer programs contain
8;  proprietary information of Nintendo of America Inc. and/or Nintendo
9;  Company Ltd., and are protected by Federal copyright law.  They may
10;  not be disclosed to third parties or copied or duplicated in any form,
11;  in whole or in part, without the prior written consent of Nintendo.
12;
13;  $Date:$
14;  $Rev:$
15;  $Author:$
16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
17
18; ����
19;   �\���� MATHSHA256Context �̃����o�̃A���C�����g�͌���ȉ��̒ʂ�
20;     h - 0 �` 32
21;     data - 40 �` 104
22;   �����o���ύX�ɂȂ����ꍇ�͗v�C��
23
24;rfp	.req	r9
25;sl	.req	r10
26;fp	.req	r11
27;ip	.req	r12
28;sp	.req	r13
29;lr	.req	r14
30;pc	.req	r15
31    .text
32.L100:
33.L101:
34	.extern MATH_SHA256iConst
35	.word MATH_SHA256iConst
36.text
37	.align 0
38	.globl MATH_SHA256iProcessBlock
39	.type MATH_SHA256iProcessBlock,@function
40MATH_SHA256iProcessBlock:
41	stmfd sp!,{r4,r5,r6,r7,r8,r9,r10,r11,r12,lr}
42
43	; ����context ��ۑ�
44	stmfd sp!,{r0}
45	; ���[�J���ϐ����m��
46	;      u32   w[64];
47	sub sp, sp, #256
48
49	; t = 0;
50	mov r12, #0
51
52	; r0      : context�̃A�h���X
53	; r2      : �ėp
54	; r3      : �ėp
55	; r4      : NETConvert32HToBE�p�萔
56	; r5-r8   : data[t],w[t]
57    ; r5-r11  : �ėp
58	; r12     : t
59	; lr      : �ėp
60	; sp      : w�̃A�h���X
61
62	mvn r4, #0x0000FF00
63.L102:
64	; w[t] = NETConvert32HToBE(((u32*)context->data)[t]);
65	add lr, r0, #40
66	add lr, lr, r12, lsl #2
67	ldmia lr, {r5, r6, r7, r8}
68	; NETConvert32HToBE
69	eor r2, r5, r5, ror #16
70	and r2, r4, r2, lsr #8
71	eor r5, r2, r5, ror #8
72	; NETConvert32HToBE
73	eor r2, r6, r6, ror #16
74	and r2, r4, r2, lsr #8
75	eor r6, r2, r6, ror #8
76	; NETConvert32HToBE
77	eor r2, r7, r7, ror #16
78	and r2, r4, r2, lsr #8
79	eor r7, r2, r7, ror #8
80	; NETConvert32HToBE
81	eor r2, r8, r8, ror #16
82	and r2, r4, r2, lsr #8
83	eor r8, r2, r8, ror #8
84	add lr, sp, r12, lsl #2
85	stmia lr, {r5, r6, r7, r8}
86
87	; for (t = 0; t < 16; ++t)
88	add r12, r12, #4
89    cmp r12, #16
90	bne .L102
91
92	; r0      : context�̃A�h���X
93	; r2      : w[t]
94	; r3-r6   : ���[�h����prev�̒l
95	; r7      : not use
96	; r8-r10  : ���[�h����prev�̒l
97	; r11     : �ėp
98	; r12     : t
99	; lr      : �ėp
100	; sp      : w�̃A�h���X
101
102.L103:
103    ; prev = &w[t - 16];
104	add lr, sp, r12, lsl #2
105	sub lr, lr, #64
106    ; w[t] = prev[ 0];
107	ldr r3, [lr]
108	ldr r4, [lr, #4]
109	ldr r8, [lr, #8]
110	ldr r5, [lr, #36]
111	ldr r9, [lr, #40]
112	ldr r6, [lr, #56]
113	ldr r10, [lr, #60]
114	; w[t] += SHA256_SSIGMA_0(prev[ 1]);
115	;       = SHA256_ROTR(7,prev[ 1]) ^ SHA256_ROTR(18,prev[ 1]) ^ SHA256_SHR(3,prev[ 1]);
116    mov r11, r4, lsl #25
117	orr lr, r11, r4, lsr #7
118    mov r11, r4, lsl #14
119	orr r11, r11, r4, lsr #18
120	eor lr, lr, r11
121	eor lr, lr, r4, lsr #3
122	add r2, r3, lr
123    ; w[t] += prev[ 9];
124	add r2, r2, r5
125    ; w[t] += SHA256_SSIGMA_1(prev[14]);
126	;       = SHA256_ROTR(17,prev[14]) ^ SHA256_ROTR(19,prev[14]) ^ SHA256_SHR(10,prev[14]);
127    mov r11, r6, lsl #15
128	orr lr, r11, r6, lsr #17
129    mov r11, r6, lsl #13
130	orr r11, r11, r6, lsr #19
131	eor lr, lr, r11
132	eor lr, lr, r6, lsr #10
133	add r2, r2, lr
134	; w[t]�������߂�
135	str r2, [sp, r12, lsl #2]
136
137	add r12, r12, #1
138
139    ; prev = &w[t - 16];
140    ; w[t] = prev[ 0];
141	; w[t] += SHA256_SSIGMA_0(prev[ 1]);
142	;       = SHA256_ROTR(7,prev[ 1]) ^ SHA256_ROTR(18,prev[ 1]) ^ SHA256_SHR(3,prev[ 1]);
143    mov r11, r8, lsl #25
144	orr lr, r11, r8, lsr #7
145    mov r11, r8, lsl #14
146	orr r11, r11, r8, lsr #18
147	eor lr, lr, r11
148	eor lr, lr, r8, lsr #3
149	add r2, r4, lr
150    ; w[t] += prev[ 9];
151	add r2, r2, r9
152    ; w[t] += SHA256_SSIGMA_1(prev[14]);
153	;       = SHA256_ROTR(17,prev[14]) ^ SHA256_ROTR(19,prev[14]) ^ SHA256_SHR(10,prev[14]);
154    mov r11, r10, lsl #15
155	orr lr, r11, r10, lsr #17
156    mov r11, r10, lsl #13
157	orr r11, r11, r10, lsr #19
158	eor lr, lr, r11
159	eor lr, lr, r10, lsr #10
160	add r2, r2, lr
161	; w[t]�������߂�
162	str r2, [sp, r12, lsl #2]
163
164	; for (; t < 64; ++t)
165	add r12, r12, #1
166    cmp r12, #64
167	bne .L103
168
169	; a�`h �����[�h
170	ldmia r0, {r4, r5, r6, r7, r8, r9, r10, r11}
171
172	; t = 0;
173	mov r12, #0
174
175	; r0      : �ėp
176	; r1      : MATH_SHA256iConst�̃A�h���X
177	; r2      : tmp1
178	; r3      : tmp2
179    ; r4-r11  : a-h
180	; r12     : t
181	; lr      : �ėp
182	; sp      : w�̃A�h���X
183
184	ldr r1, .L101
185	ldr lr, [sp, r12, lsl #2]
186	ldr r0, [r1, r12, lsl #2]
187.L104:
188	; tmp1 = MATH_SHA256iConst[t];
189	; tmp1 += w[t];
190	add r2, r0, lr
191	; tmp1 += h;
192	; tmp1 += SHA256_LSIGMA_1(e);
193	;       = SHA256_ROTR(6,e) ^ SHA256_ROTR(11,e) ^ SHA256_ROTR(25,e))
194	mov lr, r8, lsl #26
195	orr lr, lr, r8, lsr #6
196	mov r0, r8, lsl #21
197	orr r0, r0, r8, lsr #11
198	eor lr, lr, r0
199	mov r0, r8, lsl #7
200	orr r0, r0, r8, lsr #25
201	eor lr, lr, r0
202	add r2, r2, r11
203	add r2, r2, lr
204	; tmp1 += SHA256_CH(e,f,g);
205	;       = (((e)&(f))^((~e)&(g)))
206	and lr, r8, r9
207	mvn r0, r8
208	and r0, r0, r10
209	eor lr, lr, r0
210	add r2, r2, lr
211
212	; tmp2 = SHA256_LSIGMA_0(a);
213	;      = SHA256_ROTR(2,a) ^ SHA256_ROTR(13,a) ^ SHA256_ROTR(22,a)
214	mov lr, r4, lsl #30
215	orr lr, lr, r4, lsr #2
216	mov r0, r4, lsl #19
217	orr r0, r0, r4, lsr #13
218	eor lr, lr, r0
219	mov r0, r4, lsl #10
220	orr r0, r0, r4, lsr #22
221	eor r3, lr, r0
222	; tmp2 += SHA256_MAJ(a,b,c);
223	;       = ((a)&(b))^((a)&(c))^((b)&(c))
224	and lr, r4, r5
225	and r0, r4, r6
226	eor lr, lr, r0
227	and r0, r5, r6
228	eor lr, lr, r0
229	add r3, r3, lr
230
231    ; h = g;
232	mov r11, r10
233    ; g = f;
234	mov r10, r9
235    ; f = e;
236	mov r9, r8
237    ; e = d + tmp1;
238	add r8, r7, r2
239    ; d = c;
240	mov r7, r6
241    ; c = b;
242	mov r6, r5
243    ; b = a;
244	mov r5, r4
245    ; a = tmp1 + tmp2;
246	add r4, r2, r3
247
248	; for (t = 0; t < 64; ++t)
249	add r12, r12, #1
250    cmp r12, #64
251	ldrne r0, [r1, r12, lsl #2]
252	ldrne lr, [sp, r12, lsl #2]
253	bne .L104
254
255	; ���[�J���ϐ����������
256	;      u32   w[64];
257	add sp, sp, #256
258
259	; r0      : ����context
260    ; r4-r11  : a-h
261	; r1-r3,r12,lr : �ėp
262
263	; ����context��ǂݍ���
264	ldmfd sp!,{r0}
265	; a-h ��context->h�ɑ�������
266	ldmia r0, {r1, r2, r3, r12}
267	add r1, r1, r4
268	add r2, r2, r5
269	add r3, r3, r6
270	add r12, r12, r7
271	stmia r0!, {r1, r2, r3, r12}
272	ldmia r0, {r1, r2, r3, r12}
273	add r1, r1, r8
274	add r2, r2, r9
275	add r3, r3, r10
276	add r12, r12, r11
277	stmia r0!, {r1, r2, r3, r12}
278
279	ldmfd sp!,{r4,r5,r6,r7,r8,r9,r10,r11,r12,pc}
280.L105:
281	.size	MATH_SHA256iProcessBlock,.L105-.L100
282
283
284
285#if 0
286.text
287    .align 0
288	.globl SHA256_ROTR
289	.type SHA256_ROTR,@function
290SHA256_ROTR:
291    ; r0     : �������Ԃ�l
292	; r1     : ����
293	; r2     : �ėp
294	; r3     : �ėp
295	rsb r0, r0, #32
296    mov r2, r1, lsl r0
297	rsb r3, r0, #32
298	mov r3, r1, lsr r3
299	orr r0, r2, r3
300	mov pc, lr
301.L106:
302    .size   SHA256_ROTR,.L106-SHA256_ROTR
303
304
305.text
306    .align 0
307	.globl NETRotateLeft32
308	.type NETRotateLeft32,@function
309NETRotateLeft32:
310    ; r0     : �������Ԃ�l
311	; r1     : ����
312	; r2     : �ėp
313	; r3     : �ėp
314    mov r2, r1, lsl r0
315	rsb r3, r0, #32
316	mov r3, r1, lsr r3
317	orr r0, r2, r3
318	mov pc, lr
319.L107:
320    .size   NETRotateLeft32,.L107-NETRotateLeft32
321
322
323.text
324    .align 0
325	.globl NETConvert32HToBE
326	.type NETConvert32HToBE,@function
327NETConvert32HToBE:
328    ; r0     : �������Ԃ�l
329	; r1     : �ėp
330	; r2     : �ėp
331#if 1
332	mvn r1, #0x0000FF00
333	eor r2, r0, r0, ror #16
334	and r2, r1, r2, lsr #8
335	eor r0, r2, r0, ror #8
336#else
337	eor r1, r0, r0, ror #16
338	mov r1, r1, lsr #8
339	bic r1, r1, #0xff00
340	eor r0, r1, r0, ror #8
341#endif
342	mov pc, lr
343.L108:
344    .size   NETConvert32HToBE,.L108-NETConvert32HToBE
345#endif
346