~vcs-imports/busybox/trunk

« back to all changes in this revision

Viewing changes to libbb/hash_md5_sha256_x86-64_shaNI.S

  • Committer: Denys Vlasenko
  • Date: 2023-07-18 14:41:12 UTC
  • Revision ID: git-v1:8f0845cad7bfc46939132b33f9cd0753b261b953
libbb: rename source files, no code changes

Signed-off-by: Denys Vlasenko <vda.linux@googlemail.com>

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
#if ENABLE_SHA256_HWACCEL && defined(__GNUC__) && defined(__x86_64__)
2
 
/* The code is adapted from Linux kernel's source */
3
 
 
4
 
// We use shorter insns, even though they are for "wrong"
5
 
// data type (fp, not int).
6
 
// For Intel, there is no penalty for doing it at all
7
 
// (CPUs which do have such penalty do not support SHA insns).
8
 
// For AMD, the penalty is one extra cycle
9
 
// (allegedly: I failed to find measurable difference).
10
 
 
11
 
//#define mova128 movdqa
12
 
#define mova128 movaps
13
 
//#define movu128 movdqu
14
 
#define movu128 movups
15
 
//#define shuf128_32 pshufd
16
 
#define shuf128_32 shufps
17
 
 
18
 
// pshufb and palignr are SSSE3 insns.
19
 
// We do not check SSSE3 in cpuid,
20
 
// all SHA-capable CPUs support it as well.
21
 
 
22
 
#ifdef __linux__
23
 
        .section        .note.GNU-stack, "", @progbits
24
 
#endif
25
 
        .section        .text.sha256_process_block64_shaNI, "ax", @progbits
26
 
        .globl  sha256_process_block64_shaNI
27
 
        .hidden sha256_process_block64_shaNI
28
 
        .type   sha256_process_block64_shaNI, @function
29
 
 
30
 
#define DATA_PTR        %rdi
31
 
 
32
 
#define SHA256CONSTANTS %rax
33
 
 
34
 
#define MSG             %xmm0
35
 
#define STATE0          %xmm1
36
 
#define STATE1          %xmm2
37
 
#define MSGTMP0         %xmm3
38
 
#define MSGTMP1         %xmm4
39
 
#define MSGTMP2         %xmm5
40
 
#define MSGTMP3         %xmm6
41
 
 
42
 
#define XMMTMP          %xmm7
43
 
 
44
 
#define SAVE0           %xmm8
45
 
#define SAVE1           %xmm9
46
 
 
47
 
#define SHUF(a,b,c,d) $(a+(b<<2)+(c<<4)+(d<<6))
48
 
 
49
 
        .balign 8       # allow decoders to fetch at least 2 first insns
50
 
sha256_process_block64_shaNI:
51
 
 
52
 
        movu128         80+0*16(%rdi), XMMTMP /* ABCD (little-endian dword order) */
53
 
        movu128         80+1*16(%rdi), STATE1 /* EFGH */
54
 
/* shufps takes dwords 0,1 from *2nd* operand, and dwords 2,3 from 1st one */
55
 
        mova128         STATE1, STATE0
56
 
        /* ---          -------------- ABCD -- EFGH */
57
 
        shufps          SHUF(1,0,1,0), XMMTMP, STATE0 /* FEBA */
58
 
        shufps          SHUF(3,2,3,2), XMMTMP, STATE1 /* HGDC */
59
 
 
60
 
/* XMMTMP holds flip mask from here... */
61
 
        mova128         PSHUFFLE_BSWAP32_FLIP_MASK(%rip), XMMTMP
62
 
        leaq            K256+8*16(%rip), SHA256CONSTANTS
63
 
 
64
 
        /* Save hash values for addition after rounds */
65
 
        mova128         STATE0, SAVE0
66
 
        mova128         STATE1, SAVE1
67
 
 
68
 
        /* Rounds 0-3 */
69
 
        movu128         0*16(DATA_PTR), MSG
70
 
        pshufb          XMMTMP, MSG
71
 
        mova128         MSG, MSGTMP0
72
 
                paddd           0*16-8*16(SHA256CONSTANTS), MSG
73
 
                sha256rnds2     MSG, STATE0, STATE1
74
 
                shuf128_32      $0x0E, MSG, MSG
75
 
                sha256rnds2     MSG, STATE1, STATE0
76
 
 
77
 
        /* Rounds 4-7 */
78
 
        movu128         1*16(DATA_PTR), MSG
79
 
        pshufb          XMMTMP, MSG
80
 
        mova128         MSG, MSGTMP1
81
 
                paddd           1*16-8*16(SHA256CONSTANTS), MSG
82
 
                sha256rnds2     MSG, STATE0, STATE1
83
 
                shuf128_32      $0x0E, MSG, MSG
84
 
                sha256rnds2     MSG, STATE1, STATE0
85
 
        sha256msg1      MSGTMP1, MSGTMP0
86
 
 
87
 
        /* Rounds 8-11 */
88
 
        movu128         2*16(DATA_PTR), MSG
89
 
        pshufb          XMMTMP, MSG
90
 
        mova128         MSG, MSGTMP2
91
 
                paddd           2*16-8*16(SHA256CONSTANTS), MSG
92
 
                sha256rnds2     MSG, STATE0, STATE1
93
 
                shuf128_32      $0x0E, MSG, MSG
94
 
                sha256rnds2     MSG, STATE1, STATE0
95
 
        sha256msg1      MSGTMP2, MSGTMP1
96
 
 
97
 
        /* Rounds 12-15 */
98
 
        movu128         3*16(DATA_PTR), MSG
99
 
        pshufb          XMMTMP, MSG
100
 
/* ...to here */
101
 
        mova128         MSG, MSGTMP3
102
 
                paddd           3*16-8*16(SHA256CONSTANTS), MSG
103
 
                sha256rnds2     MSG, STATE0, STATE1
104
 
        mova128         MSGTMP3, XMMTMP
105
 
        palignr         $4, MSGTMP2, XMMTMP
106
 
        paddd           XMMTMP, MSGTMP0
107
 
        sha256msg2      MSGTMP3, MSGTMP0
108
 
                shuf128_32      $0x0E, MSG, MSG
109
 
                sha256rnds2     MSG, STATE1, STATE0
110
 
        sha256msg1      MSGTMP3, MSGTMP2
111
 
 
112
 
        /* Rounds 16-19 */
113
 
        mova128         MSGTMP0, MSG
114
 
                paddd           4*16-8*16(SHA256CONSTANTS), MSG
115
 
                sha256rnds2     MSG, STATE0, STATE1
116
 
        mova128         MSGTMP0, XMMTMP
117
 
        palignr         $4, MSGTMP3, XMMTMP
118
 
        paddd           XMMTMP, MSGTMP1
119
 
        sha256msg2      MSGTMP0, MSGTMP1
120
 
                shuf128_32      $0x0E, MSG, MSG
121
 
                sha256rnds2     MSG, STATE1, STATE0
122
 
        sha256msg1      MSGTMP0, MSGTMP3
123
 
 
124
 
        /* Rounds 20-23 */
125
 
        mova128         MSGTMP1, MSG
126
 
                paddd           5*16-8*16(SHA256CONSTANTS), MSG
127
 
                sha256rnds2     MSG, STATE0, STATE1
128
 
        mova128         MSGTMP1, XMMTMP
129
 
        palignr         $4, MSGTMP0, XMMTMP
130
 
        paddd           XMMTMP, MSGTMP2
131
 
        sha256msg2      MSGTMP1, MSGTMP2
132
 
                shuf128_32      $0x0E, MSG, MSG
133
 
                sha256rnds2     MSG, STATE1, STATE0
134
 
        sha256msg1      MSGTMP1, MSGTMP0
135
 
 
136
 
        /* Rounds 24-27 */
137
 
        mova128         MSGTMP2, MSG
138
 
                paddd           6*16-8*16(SHA256CONSTANTS), MSG
139
 
                sha256rnds2     MSG, STATE0, STATE1
140
 
        mova128         MSGTMP2, XMMTMP
141
 
        palignr         $4, MSGTMP1, XMMTMP
142
 
        paddd           XMMTMP, MSGTMP3
143
 
        sha256msg2      MSGTMP2, MSGTMP3
144
 
                shuf128_32      $0x0E, MSG, MSG
145
 
                sha256rnds2     MSG, STATE1, STATE0
146
 
        sha256msg1      MSGTMP2, MSGTMP1
147
 
 
148
 
        /* Rounds 28-31 */
149
 
        mova128         MSGTMP3, MSG
150
 
                paddd           7*16-8*16(SHA256CONSTANTS), MSG
151
 
                sha256rnds2     MSG, STATE0, STATE1
152
 
        mova128         MSGTMP3, XMMTMP
153
 
        palignr         $4, MSGTMP2, XMMTMP
154
 
        paddd           XMMTMP, MSGTMP0
155
 
        sha256msg2      MSGTMP3, MSGTMP0
156
 
                shuf128_32      $0x0E, MSG, MSG
157
 
                sha256rnds2     MSG, STATE1, STATE0
158
 
        sha256msg1      MSGTMP3, MSGTMP2
159
 
 
160
 
        /* Rounds 32-35 */
161
 
        mova128         MSGTMP0, MSG
162
 
                paddd           8*16-8*16(SHA256CONSTANTS), MSG
163
 
                sha256rnds2     MSG, STATE0, STATE1
164
 
        mova128         MSGTMP0, XMMTMP
165
 
        palignr         $4, MSGTMP3, XMMTMP
166
 
        paddd           XMMTMP, MSGTMP1
167
 
        sha256msg2      MSGTMP0, MSGTMP1
168
 
                shuf128_32      $0x0E, MSG, MSG
169
 
                sha256rnds2     MSG, STATE1, STATE0
170
 
        sha256msg1      MSGTMP0, MSGTMP3
171
 
 
172
 
        /* Rounds 36-39 */
173
 
        mova128         MSGTMP1, MSG
174
 
                paddd           9*16-8*16(SHA256CONSTANTS), MSG
175
 
                sha256rnds2     MSG, STATE0, STATE1
176
 
        mova128         MSGTMP1, XMMTMP
177
 
        palignr         $4, MSGTMP0, XMMTMP
178
 
        paddd           XMMTMP, MSGTMP2
179
 
        sha256msg2      MSGTMP1, MSGTMP2
180
 
                shuf128_32      $0x0E, MSG, MSG
181
 
                sha256rnds2     MSG, STATE1, STATE0
182
 
        sha256msg1      MSGTMP1, MSGTMP0
183
 
 
184
 
        /* Rounds 40-43 */
185
 
        mova128         MSGTMP2, MSG
186
 
                paddd           10*16-8*16(SHA256CONSTANTS), MSG
187
 
                sha256rnds2     MSG, STATE0, STATE1
188
 
        mova128         MSGTMP2, XMMTMP
189
 
        palignr         $4, MSGTMP1, XMMTMP
190
 
        paddd           XMMTMP, MSGTMP3
191
 
        sha256msg2      MSGTMP2, MSGTMP3
192
 
                shuf128_32      $0x0E, MSG, MSG
193
 
                sha256rnds2     MSG, STATE1, STATE0
194
 
        sha256msg1      MSGTMP2, MSGTMP1
195
 
 
196
 
        /* Rounds 44-47 */
197
 
        mova128         MSGTMP3, MSG
198
 
                paddd           11*16-8*16(SHA256CONSTANTS), MSG
199
 
                sha256rnds2     MSG, STATE0, STATE1
200
 
        mova128         MSGTMP3, XMMTMP
201
 
        palignr         $4, MSGTMP2, XMMTMP
202
 
        paddd           XMMTMP, MSGTMP0
203
 
        sha256msg2      MSGTMP3, MSGTMP0
204
 
                shuf128_32      $0x0E, MSG, MSG
205
 
                sha256rnds2     MSG, STATE1, STATE0
206
 
        sha256msg1      MSGTMP3, MSGTMP2
207
 
 
208
 
        /* Rounds 48-51 */
209
 
        mova128         MSGTMP0, MSG
210
 
                paddd           12*16-8*16(SHA256CONSTANTS), MSG
211
 
                sha256rnds2     MSG, STATE0, STATE1
212
 
        mova128         MSGTMP0, XMMTMP
213
 
        palignr         $4, MSGTMP3, XMMTMP
214
 
        paddd           XMMTMP, MSGTMP1
215
 
        sha256msg2      MSGTMP0, MSGTMP1
216
 
                shuf128_32      $0x0E, MSG, MSG
217
 
                sha256rnds2     MSG, STATE1, STATE0
218
 
        sha256msg1      MSGTMP0, MSGTMP3
219
 
 
220
 
        /* Rounds 52-55 */
221
 
        mova128         MSGTMP1, MSG
222
 
                paddd           13*16-8*16(SHA256CONSTANTS), MSG
223
 
                sha256rnds2     MSG, STATE0, STATE1
224
 
        mova128         MSGTMP1, XMMTMP
225
 
        palignr         $4, MSGTMP0, XMMTMP
226
 
        paddd           XMMTMP, MSGTMP2
227
 
        sha256msg2      MSGTMP1, MSGTMP2
228
 
                shuf128_32      $0x0E, MSG, MSG
229
 
                sha256rnds2     MSG, STATE1, STATE0
230
 
 
231
 
        /* Rounds 56-59 */
232
 
        mova128         MSGTMP2, MSG
233
 
                paddd           14*16-8*16(SHA256CONSTANTS), MSG
234
 
                sha256rnds2     MSG, STATE0, STATE1
235
 
        mova128         MSGTMP2, XMMTMP
236
 
        palignr         $4, MSGTMP1, XMMTMP
237
 
        paddd           XMMTMP, MSGTMP3
238
 
        sha256msg2      MSGTMP2, MSGTMP3
239
 
                shuf128_32      $0x0E, MSG, MSG
240
 
                sha256rnds2     MSG, STATE1, STATE0
241
 
 
242
 
        /* Rounds 60-63 */
243
 
        mova128         MSGTMP3, MSG
244
 
                paddd           15*16-8*16(SHA256CONSTANTS), MSG
245
 
                sha256rnds2     MSG, STATE0, STATE1
246
 
                shuf128_32      $0x0E, MSG, MSG
247
 
                sha256rnds2     MSG, STATE1, STATE0
248
 
 
249
 
        /* Add current hash values with previously saved */
250
 
        paddd           SAVE0, STATE0
251
 
        paddd           SAVE1, STATE1
252
 
 
253
 
        /* Write hash values back in the correct order */
254
 
        mova128         STATE0, XMMTMP
255
 
/* shufps takes dwords 0,1 from *2nd* operand, and dwords 2,3 from 1st one */
256
 
        /* ---          -------------- HGDC -- FEBA */
257
 
        shufps          SHUF(3,2,3,2), STATE1, STATE0 /* ABCD */
258
 
        shufps          SHUF(1,0,1,0), STATE1, XMMTMP /* EFGH */
259
 
        movu128         STATE0, 80+0*16(%rdi)
260
 
        movu128         XMMTMP, 80+1*16(%rdi)
261
 
 
262
 
        ret
263
 
        .size   sha256_process_block64_shaNI, .-sha256_process_block64_shaNI
264
 
 
265
 
        .section        .rodata.cst256.K256, "aM", @progbits, 256
266
 
        .balign 16
267
 
K256:
268
 
        .long   0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5
269
 
        .long   0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5
270
 
        .long   0xd807aa98,0x12835b01,0x243185be,0x550c7dc3
271
 
        .long   0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174
272
 
        .long   0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc
273
 
        .long   0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da
274
 
        .long   0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7
275
 
        .long   0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967
276
 
        .long   0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13
277
 
        .long   0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85
278
 
        .long   0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3
279
 
        .long   0xd192e819,0xd6990624,0xf40e3585,0x106aa070
280
 
        .long   0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5
281
 
        .long   0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3
282
 
        .long   0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208
283
 
        .long   0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2
284
 
 
285
 
        .section        .rodata.cst16.PSHUFFLE_BSWAP32_FLIP_MASK, "aM", @progbits, 16
286
 
        .balign 16
287
 
PSHUFFLE_BSWAP32_FLIP_MASK:
288
 
        .octa   0x0c0d0e0f08090a0b0405060700010203
289
 
 
290
 
#endif