← Back to branch summary

~ubuntu-branches/ubuntu/vivid/nettle/vivid-proposed

« back to all changes in this revision

Viewing changes to arm/neon/sha512-compress.asm

  • Committer: Package Import Robot
  • Author(s): Magnus Holmgren
  • Date: 2013-05-04 19:50:28 UTC
  • mfrom: (1.4.6) (3.1.11 experimental)
  • mto: This revision was merged to the branch mainline in revision 14.
  • Revision ID: package-import@ubuntu.com-20130504195028-fp6c9fw1tsm5scwa
Tags: 2.7-1
http://bugs.debian.org/706081
* New upstream release (Closes: #706081).
* Include watch file improvements from Bart Martens <bartm@debian.org>
  via the QA system.

Show diffs side-by-side

added added

removed removed

Lines of Context:
arm/neon/sha512-compress.asm
 
1
C nettle, low-level cryptographics library
 
2
C
 
3
C Copyright (C) 2013 Niels Möller
 
4
C
 
5
C The nettle library is free software; you can redistribute it and/or modify
 
6
C it under the terms of the GNU Lesser General Public License as published by
 
7
C the Free Software Foundation; either version 2.1 of the License, or (at your
 
8
C option) any later version.
 
9
C
 
10
C The nettle library is distributed in the hope that it will be useful, but
 
11
C WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 
12
C or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
 
13
C License for more details.
 
14
C
 
15
C You should have received a copy of the GNU Lesser General Public License
 
16
C along with the nettle library; see the file COPYING.LIB.  If not, write to
 
17
C the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 
18
C MA 02111-1301, USA.
 
19
 
 
20
        .file "sha512-compress.asm"
 
21
        .fpu    neon
 
22
 
 
23
define(<STATE>, <r0>)
 
24
define(<INPUT>, <r1>)
 
25
define(<K>, <r2>)
 
26
define(<COUNT>, <r3>)
 
27
define(<SHIFT>, <r12>)
 
28
 
 
29
define(<SA>, <d0>)
 
30
define(<SB>, <d1>)
 
31
define(<SC>, <d2>)
 
32
define(<SD>, <d3>)
 
33
define(<SE>, <d4>)
 
34
define(<SF>, <d5>)
 
35
define(<SG>, <d6>)
 
36
define(<SH>, <d7>)
 
37
define(<QSAB>, <q0>)
 
38
define(<QSCD>, <q1>)
 
39
define(<QSEF>, <q2>)
 
40
define(<QSGH>, <q3>)
 
41
 
 
42
C d8-d15 are callee-save        
 
43
define(<DT0>, <d8>)
 
44
define(<DT1>, <d9>)
 
45
define(<QT01>, <q4>)
 
46
define(<DT2>, <d10>)
 
47
define(<DT3>, <d11>)
 
48
define(<QT23>, <q5>)
 
49
define(<DT4>, <d12>)
 
50
define(<DT5>, <d13>)
 
51
define(<QT45>, <q6>)
 
52
 
 
53
C Used only when reading the input, can overlap with state
 
54
define(<DT6>, <d0>)
 
55
define(<DT7>, <d1>)
 
56
define(<QT67>, <q0>)
 
57
 
 
58
define(<DW0>, <d16>)
 
59
define(<DW1>, <d17>)
 
60
define(<DW2>, <d18>)
 
61
define(<DW3>, <d19>)
 
62
define(<DW4>, <d20>)
 
63
define(<DW5>, <d21>)
 
64
define(<DW6>, <d22>)
 
65
define(<DW7>, <d23>)
 
66
define(<DW8>, <d24>)
 
67
define(<DW9>, <d25>)
 
68
define(<DW10>, <d26>)
 
69
define(<DW11>, <d27>)
 
70
define(<DW12>, <d28>)
 
71
define(<DW13>, <d29>)
 
72
define(<DW14>, <d30>)
 
73
define(<DW15>, <d31>)
 
74
define(<QW0001>, <q8>)
 
75
define(<QW0203>, <q9>)
 
76
define(<QW0405>, <q10>)
 
77
define(<QW0607>, <q11>)
 
78
define(<QW0809>, <q12>)
 
79
define(<QW1011>, <q13>)
 
80
define(<QW1213>, <q14>)
 
81
define(<QW1415>, <q15>)
 
82
 
 
83
define(<EXPAND_ME>, <$1>)
 
84
define(<W>, <EXPAND_ME(<DW>eval(($1) % 16))>)
 
85
 
 
86
C If x = W(i+14), y = w(i+1), we xor in parallel
 
87
C
 
88
C       x << 45         y << 63
 
89
C       x >> 19         y >> 1
 
90
C       x << 3          y << 56
 
91
C       x >> 61         y >> 8
 
92
C  xor  x >> 6          y >> 7
 
93
C  -----------------------------
 
94
C       DT0             DT1
 
95
define(<EXPN>, <
 
96
        vshl.i64        DT0, W($1+14), #45
 
97
        vshl.i64        DT1, W($1 + 1), #63
 
98
        vshr.u64        DT2, W($1+14), #19
 
99
        vshr.u64        DT3, W($1 + 1), #1
 
100
        vshl.i64        DT4, W($1+14), #3
 
101
        vshl.i64        DT5, W($1 + 1), #56
 
102
        veor.i64        QT01, QT01, QT23
 
103
        vshr.u64        DT2, W($1+14), #61
 
104
        vshr.u64        DT3, W($1 + 1), #8
 
105
        veor.i64        QT01, QT01, QT45
 
106
        vshr.u64        DT4, W($1+14), #6
 
107
        vshr.u64        DT5, W($1 + 1), #7
 
108
        veor.i64        QT01, QT01, QT23
 
109
        vadd.i64        W($1), W($1), W($1 + 9)
 
110
        veor.i64        QT01, QT01, QT45
 
111
        vadd.i64        W($1), W($1), DT0
 
112
        vadd.i64        W($1), W($1), DT1
 
113
>)
 
114
 
 
115
C ROUND(A,B,C,D,E,F,G,H,i)
 
116
C
 
117
C H += S1(E) + Choice(E,F,G) + K + W
 
118
C D += H
 
119
C H += S0(A) + Majority(A,B,C)
 
120
C
 
121
C Where
 
122
C
 
123
C S1(E) = E<<<50 ^ E<<<46 ^ E<<<23
 
124
C S0(A) = A<<<36 ^ A<<<30 ^ A<<<25
 
125
C Choice (E, F, G) = G^(E&(F^G))
 
126
C Majority (A,B,C) = (A&B) + (C&(A^B))
 
127
 
 
128
C Do S1 and S0 in parallel
 
129
C
 
130
C       e << 50         a << 36
 
131
C       e >> 14         a >> 28
 
132
C       e << 46         a << 30
 
133
C       e >> 18         a >> 34
 
134
C       e << 23         a << 25
 
135
C  xor  e >> 41         a >> 39
 
136
C  ----------------------------
 
137
C       DT0             DT1
 
138
define(<ROUND>, <
 
139
        vshl.i64        DT0, $5, #50
 
140
        vshl.i64        DT1, $1, #36
 
141
        vshr.u64        DT2, $5, #14
 
142
        vshr.u64        DT3, $1, #28
 
143
        vshl.i64        DT4, $5, #46
 
144
        vshl.i64        DT5, $1, #30
 
145
        veor            QT01, QT01, QT23
 
146
        vshr.u64        DT2, $5, #18
 
147
        vshr.u64        DT3, $1, #34
 
148
        veor            QT01, QT01, QT45
 
149
        vshl.i64        DT4, $5, #23
 
150
        vshl.i64        DT5, $1, #25
 
151
        veor            QT01, QT01, QT23
 
152
        vshr.u64        DT2, $5, #41
 
153
        vshr.u64        DT3, $1, #39
 
154
        veor            QT01, QT01, QT45
 
155
        veor            DT4, $6, $7
 
156
        veor            DT5, $1, $2
 
157
        vand            DT4, DT4, $5
 
158
        vand            DT5, DT5, $3
 
159
        veor            DT4, DT4, $7
 
160
        veor            QT01, QT01, QT23
 
161
        vand            DT2, $1, $2
 
162
        vldr            DT3, [K,#eval(8*$9)]
 
163
        vadd.i64        $8, $8, W($9)
 
164
        vadd.i64        QT01, QT01, QT45
 
165
        vadd.i64        $8, $8, DT3
 
166
        vadd.i64        $8, $8, DT0
 
167
        vadd.i64        DT1, DT1, DT2
 
168
        vadd.i64        $4, $4, $8
 
169
        vadd.i64        $8, $8, DT1
 
170
>)
 
171
 
 
172
        C void
 
173
        C _nettle_sha512_compress(uint64_t *state, const uint8_t *input, const uint64_t *k)
 
174
 
 
175
        .text
 
176
        .align 2
 
177
 
 
178
PROLOGUE(_nettle_sha512_compress)
 
179
        vpush   {d8,d9,d10,d11,d12,d13}
 
180
        
 
181
        ands    SHIFT, INPUT, #7
 
182
        and     INPUT, INPUT, #-8
 
183
        vld1.8  {DT5}, [INPUT :64]
 
184
        addne   INPUT, INPUT, #8
 
185
        addeq   SHIFT, SHIFT, #8
 
186
        lsl     SHIFT, SHIFT, #3
 
187
 
 
188
        C Put right shift in DT0 and DT1, aka QT01
 
189
        neg     SHIFT, SHIFT
 
190
        vmov.i32        DT0, #0
 
191
        vmov.32         DT0[0], SHIFT
 
192
        vmov            DT1, DT0
 
193
        C Put left shift in DT2 and DT3, aka QT23
 
194
        add             SHIFT, SHIFT, #64
 
195
        vmov.i32        DT2, #0
 
196
        vmov.32         DT2[0], SHIFT
 
197
        vmov            DT3, DT2
 
198
        vshl.u64        DT5, DT5, DT0
 
199
 
 
200
        C Set w[i] <-- w[i-1] >> RSHIFT + w[i] << LSHIFT
 
201
        vld1.8          {W(0),W(1),W(2),W(3)}, [INPUT :64]!
 
202
        vshl.u64        QT67, QW0001, QT01      C Right shift
 
203
        vshl.u64        QW0001, QW0001, QT23    C Left shift
 
204
        veor            W(0), W(0), DT5
 
205
        veor            W(1), W(1), DT6
 
206
        vrev64.8        QW0001, QW0001
 
207
        vshl.u64        QT45, QW0203, QT01      C Right shift
 
208
        vshl.u64        QW0203, QW0203, QT23    C Left shift
 
209
        veor            W(2), W(2), DT7
 
210
        veor            W(3), W(3), DT4
 
211
        vrev64.8        QW0203, QW0203
 
212
 
 
213
        vld1.8          {W(4),W(5),W(6),W(7)}, [INPUT :64]!
 
214
        vshl.u64        QT67, QW0405, QT01      C Right shift
 
215
        vshl.u64        QW0405, QW0405, QT23    C Left shift
 
216
        veor            W(4), W(4), DT5
 
217
        veor            W(5), W(5), DT6
 
218
        vrev64.8        QW0405, QW0405
 
219
        vshl.u64        QT45, QW0607, QT01      C Right shift
 
220
        vshl.u64        QW0607, QW0607, QT23    C Left shift
 
221
        veor            W(6), W(6), DT7
 
222
        veor            W(7), W(7), DT4
 
223
        vrev64.8        QW0607, QW0607
 
224
 
 
225
        vld1.8          {W(8),W(9),W(10),W(11)}, [INPUT :64]!
 
226
        vshl.u64        QT67, QW0809, QT01      C Right shift
 
227
        vshl.u64        QW0809, QW0809, QT23    C Left shift
 
228
        veor            W(8), W(8), DT5
 
229
        veor            W(9), W(9), DT6
 
230
        vrev64.8        QW0809, QW0809
 
231
        vshl.u64        QT45, QW1011, QT01      C Right shift
 
232
        vshl.u64        QW1011, QW1011, QT23    C Left shift
 
233
        veor            W(10), W(10), DT7
 
234
        veor            W(11), W(11), DT4
 
235
        vrev64.8        QW1011, QW1011
 
236
 
 
237
        vld1.8          {W(12),W(13),W(14),W(15)}, [INPUT :64]!
 
238
        vshl.u64        QT67, QW1213, QT01      C Right shift
 
239
        vshl.u64        QW1213, QW1213, QT23    C Left shift
 
240
        veor            W(12), W(12), DT5
 
241
        veor            W(13), W(13), DT6
 
242
        vrev64.8        QW1213, QW1213
 
243
        vshl.u64        QT45, QW1415, QT01      C Right shift
 
244
        vshl.u64        QW1415, QW1415, QT23    C Left shift
 
245
        veor            W(14), W(14), DT7
 
246
        veor            W(15), W(15), DT4
 
247
        vrev64.8        QW1415, QW1415
 
248
 
 
249
        vldm    STATE, {SA,SB,SC,SD,SE,SF,SG,SH}
 
250
 
 
251
        ROUND(SA,SB,SC,SD,SE,SF,SG,SH, 0)
 
252
        ROUND(SH,SA,SB,SC,SD,SE,SF,SG, 1)
 
253
        ROUND(SG,SH,SA,SB,SC,SD,SE,SF, 2)
 
254
        ROUND(SF,SG,SH,SA,SB,SC,SD,SE, 3)
 
255
        ROUND(SE,SF,SG,SH,SA,SB,SC,SD, 4)
 
256
        ROUND(SD,SE,SF,SG,SH,SA,SB,SC, 5)
 
257
        ROUND(SC,SD,SE,SF,SG,SH,SA,SB, 6)
 
258
        ROUND(SB,SC,SD,SE,SF,SG,SH,SA, 7)
 
259
 
 
260
        ROUND(SA,SB,SC,SD,SE,SF,SG,SH, 8)
 
261
        ROUND(SH,SA,SB,SC,SD,SE,SF,SG, 9)
 
262
        ROUND(SG,SH,SA,SB,SC,SD,SE,SF, 10)
 
263
        ROUND(SF,SG,SH,SA,SB,SC,SD,SE, 11)
 
264
        ROUND(SE,SF,SG,SH,SA,SB,SC,SD, 12)
 
265
        ROUND(SD,SE,SF,SG,SH,SA,SB,SC, 13)
 
266
        ROUND(SC,SD,SE,SF,SG,SH,SA,SB, 14)
 
267
        ROUND(SB,SC,SD,SE,SF,SG,SH,SA, 15)
 
268
 
 
269
        add     K, K, #128
 
270
 
 
271
        mov     COUNT, #4
 
272
.Loop:
 
273
 
 
274
        EXPN( 0) ROUND(SA,SB,SC,SD,SE,SF,SG,SH,  0)
 
275
        EXPN( 1) ROUND(SH,SA,SB,SC,SD,SE,SF,SG,  1)
 
276
        EXPN( 2) ROUND(SG,SH,SA,SB,SC,SD,SE,SF,  2)
 
277
        EXPN( 3) ROUND(SF,SG,SH,SA,SB,SC,SD,SE,  3)
 
278
        EXPN( 4) ROUND(SE,SF,SG,SH,SA,SB,SC,SD,  4)
 
279
        EXPN( 5) ROUND(SD,SE,SF,SG,SH,SA,SB,SC,  5)
 
280
        EXPN( 6) ROUND(SC,SD,SE,SF,SG,SH,SA,SB,  6)
 
281
        EXPN( 7) ROUND(SB,SC,SD,SE,SF,SG,SH,SA,  7)
 
282
        EXPN( 8) ROUND(SA,SB,SC,SD,SE,SF,SG,SH,  8)
 
283
        EXPN( 9) ROUND(SH,SA,SB,SC,SD,SE,SF,SG,  9)
 
284
        EXPN(10) ROUND(SG,SH,SA,SB,SC,SD,SE,SF, 10)
 
285
        EXPN(11) ROUND(SF,SG,SH,SA,SB,SC,SD,SE, 11)
 
286
        EXPN(12) ROUND(SE,SF,SG,SH,SA,SB,SC,SD, 12)
 
287
        EXPN(13) ROUND(SD,SE,SF,SG,SH,SA,SB,SC, 13)
 
288
        EXPN(14) ROUND(SC,SD,SE,SF,SG,SH,SA,SB, 14)
 
289
        subs    COUNT, COUNT, #1
 
290
        EXPN(15) ROUND(SB,SC,SD,SE,SF,SG,SH,SA, 15)
 
291
        add     K, K, #128
 
292
        bne     .Loop
 
293
 
 
294
        vld1.64         {DW0, DW1, DW2, DW3}, [STATE]
 
295
        vadd.i64        QSAB, QSAB, QW0001
 
296
        vadd.i64        QSCD, QSCD, QW0203
 
297
        vst1.64         {SA,SB,SC,SD}, [STATE]!
 
298
        vld1.64         {DW0, DW1, DW2, DW3}, [STATE]
 
299
        vadd.i64        QSEF, QSEF, QW0001
 
300
        vadd.i64        QSGH, QSGH, QW0203
 
301
        vst1.64         {SE,SF,SG,SH}, [STATE]!
 
302
 
 
303
        vpop    {d8,d9,d10,d11,d12,d13}
 
304
        bx      lr
 
305
EPILOGUE(_nettle_sha512_compress)
 
306
 
 
307
divert(-1)
 
308
define shastate
 
309
p/x $d0.u64
 
310
p/x $d1.u64
 
311
p/x $d2.u64
 
312
p/x $d3.u64
 
313
p/x $d4.u64
 
314
p/x $d5.u64
 
315
p/x $d6.u64
 
316
p/x $d7.u64
 
317
end