~vcs-imports/busybox/trunk

« back to all changes in this revision

Viewing changes to libbb/hash_sha256_hwaccel_x86-32.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(__i386__)
 
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        %eax
 
31
 
 
32
#define SHA256CONSTANTS %ecx
 
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 SHUF(a,b,c,d) $(a+(b<<2)+(c<<4)+(d<<6))
 
45
 
 
46
        .balign 8       # allow decoders to fetch at least 2 first insns
 
47
sha256_process_block64_shaNI:
 
48
 
 
49
        movu128         76+0*16(%eax), XMMTMP /* ABCD (little-endian dword order) */
 
50
        movu128         76+1*16(%eax), STATE1 /* EFGH */
 
51
/* shufps takes dwords 0,1 from *2nd* operand, and dwords 2,3 from 1st one */
 
52
        mova128         STATE1, STATE0
 
53
        /* ---          -------------- ABCD -- EFGH */
 
54
        shufps          SHUF(1,0,1,0), XMMTMP, STATE0 /* FEBA */
 
55
        shufps          SHUF(3,2,3,2), XMMTMP, STATE1 /* HGDC */
 
56
 
 
57
/* XMMTMP holds flip mask from here... */
 
58
        mova128         PSHUFFLE_BSWAP32_FLIP_MASK, XMMTMP
 
59
        movl            $K256+8*16, SHA256CONSTANTS
 
60
 
 
61
        /* Rounds 0-3 */
 
62
        movu128         0*16(DATA_PTR), MSG
 
63
        pshufb          XMMTMP, MSG
 
64
        mova128         MSG, MSGTMP0
 
65
                paddd           0*16-8*16(SHA256CONSTANTS), MSG
 
66
                sha256rnds2     MSG, STATE0, STATE1
 
67
                shuf128_32      $0x0E, MSG, MSG
 
68
                sha256rnds2     MSG, STATE1, STATE0
 
69
 
 
70
        /* Rounds 4-7 */
 
71
        movu128         1*16(DATA_PTR), MSG
 
72
        pshufb          XMMTMP, MSG
 
73
        mova128         MSG, MSGTMP1
 
74
                paddd           1*16-8*16(SHA256CONSTANTS), MSG
 
75
                sha256rnds2     MSG, STATE0, STATE1
 
76
                shuf128_32      $0x0E, MSG, MSG
 
77
                sha256rnds2     MSG, STATE1, STATE0
 
78
        sha256msg1      MSGTMP1, MSGTMP0
 
79
 
 
80
        /* Rounds 8-11 */
 
81
        movu128         2*16(DATA_PTR), MSG
 
82
        pshufb          XMMTMP, MSG
 
83
        mova128         MSG, MSGTMP2
 
84
                paddd           2*16-8*16(SHA256CONSTANTS), MSG
 
85
                sha256rnds2     MSG, STATE0, STATE1
 
86
                shuf128_32      $0x0E, MSG, MSG
 
87
                sha256rnds2     MSG, STATE1, STATE0
 
88
        sha256msg1      MSGTMP2, MSGTMP1
 
89
 
 
90
        /* Rounds 12-15 */
 
91
        movu128         3*16(DATA_PTR), MSG
 
92
        pshufb          XMMTMP, MSG
 
93
/* ...to here */
 
94
        mova128         MSG, MSGTMP3
 
95
                paddd           3*16-8*16(SHA256CONSTANTS), MSG
 
96
                sha256rnds2     MSG, STATE0, STATE1
 
97
        mova128         MSGTMP3, XMMTMP
 
98
        palignr         $4, MSGTMP2, XMMTMP
 
99
        paddd           XMMTMP, MSGTMP0
 
100
        sha256msg2      MSGTMP3, MSGTMP0
 
101
                shuf128_32      $0x0E, MSG, MSG
 
102
                sha256rnds2     MSG, STATE1, STATE0
 
103
        sha256msg1      MSGTMP3, MSGTMP2
 
104
 
 
105
        /* Rounds 16-19 */
 
106
        mova128         MSGTMP0, MSG
 
107
                paddd           4*16-8*16(SHA256CONSTANTS), MSG
 
108
                sha256rnds2     MSG, STATE0, STATE1
 
109
        mova128         MSGTMP0, XMMTMP
 
110
        palignr         $4, MSGTMP3, XMMTMP
 
111
        paddd           XMMTMP, MSGTMP1
 
112
        sha256msg2      MSGTMP0, MSGTMP1
 
113
                shuf128_32      $0x0E, MSG, MSG
 
114
                sha256rnds2     MSG, STATE1, STATE0
 
115
        sha256msg1      MSGTMP0, MSGTMP3
 
116
 
 
117
        /* Rounds 20-23 */
 
118
        mova128         MSGTMP1, MSG
 
119
                paddd           5*16-8*16(SHA256CONSTANTS), MSG
 
120
                sha256rnds2     MSG, STATE0, STATE1
 
121
        mova128         MSGTMP1, XMMTMP
 
122
        palignr         $4, MSGTMP0, XMMTMP
 
123
        paddd           XMMTMP, MSGTMP2
 
124
        sha256msg2      MSGTMP1, MSGTMP2
 
125
                shuf128_32      $0x0E, MSG, MSG
 
126
                sha256rnds2     MSG, STATE1, STATE0
 
127
        sha256msg1      MSGTMP1, MSGTMP0
 
128
 
 
129
        /* Rounds 24-27 */
 
130
        mova128         MSGTMP2, MSG
 
131
                paddd           6*16-8*16(SHA256CONSTANTS), MSG
 
132
                sha256rnds2     MSG, STATE0, STATE1
 
133
        mova128         MSGTMP2, XMMTMP
 
134
        palignr         $4, MSGTMP1, XMMTMP
 
135
        paddd           XMMTMP, MSGTMP3
 
136
        sha256msg2      MSGTMP2, MSGTMP3
 
137
                shuf128_32      $0x0E, MSG, MSG
 
138
                sha256rnds2     MSG, STATE1, STATE0
 
139
        sha256msg1      MSGTMP2, MSGTMP1
 
140
 
 
141
        /* Rounds 28-31 */
 
142
        mova128         MSGTMP3, MSG
 
143
                paddd           7*16-8*16(SHA256CONSTANTS), MSG
 
144
                sha256rnds2     MSG, STATE0, STATE1
 
145
        mova128         MSGTMP3, XMMTMP
 
146
        palignr         $4, MSGTMP2, XMMTMP
 
147
        paddd           XMMTMP, MSGTMP0
 
148
        sha256msg2      MSGTMP3, MSGTMP0
 
149
                shuf128_32      $0x0E, MSG, MSG
 
150
                sha256rnds2     MSG, STATE1, STATE0
 
151
        sha256msg1      MSGTMP3, MSGTMP2
 
152
 
 
153
        /* Rounds 32-35 */
 
154
        mova128         MSGTMP0, MSG
 
155
                paddd           8*16-8*16(SHA256CONSTANTS), MSG
 
156
                sha256rnds2     MSG, STATE0, STATE1
 
157
        mova128         MSGTMP0, XMMTMP
 
158
        palignr         $4, MSGTMP3, XMMTMP
 
159
        paddd           XMMTMP, MSGTMP1
 
160
        sha256msg2      MSGTMP0, MSGTMP1
 
161
                shuf128_32      $0x0E, MSG, MSG
 
162
                sha256rnds2     MSG, STATE1, STATE0
 
163
        sha256msg1      MSGTMP0, MSGTMP3
 
164
 
 
165
        /* Rounds 36-39 */
 
166
        mova128         MSGTMP1, MSG
 
167
                paddd           9*16-8*16(SHA256CONSTANTS), MSG
 
168
                sha256rnds2     MSG, STATE0, STATE1
 
169
        mova128         MSGTMP1, XMMTMP
 
170
        palignr         $4, MSGTMP0, XMMTMP
 
171
        paddd           XMMTMP, MSGTMP2
 
172
        sha256msg2      MSGTMP1, MSGTMP2
 
173
                shuf128_32      $0x0E, MSG, MSG
 
174
                sha256rnds2     MSG, STATE1, STATE0
 
175
        sha256msg1      MSGTMP1, MSGTMP0
 
176
 
 
177
        /* Rounds 40-43 */
 
178
        mova128         MSGTMP2, MSG
 
179
                paddd           10*16-8*16(SHA256CONSTANTS), MSG
 
180
                sha256rnds2     MSG, STATE0, STATE1
 
181
        mova128         MSGTMP2, XMMTMP
 
182
        palignr         $4, MSGTMP1, XMMTMP
 
183
        paddd           XMMTMP, MSGTMP3
 
184
        sha256msg2      MSGTMP2, MSGTMP3
 
185
                shuf128_32      $0x0E, MSG, MSG
 
186
                sha256rnds2     MSG, STATE1, STATE0
 
187
        sha256msg1      MSGTMP2, MSGTMP1
 
188
 
 
189
        /* Rounds 44-47 */
 
190
        mova128         MSGTMP3, MSG
 
191
                paddd           11*16-8*16(SHA256CONSTANTS), MSG
 
192
                sha256rnds2     MSG, STATE0, STATE1
 
193
        mova128         MSGTMP3, XMMTMP
 
194
        palignr         $4, MSGTMP2, XMMTMP
 
195
        paddd           XMMTMP, MSGTMP0
 
196
        sha256msg2      MSGTMP3, MSGTMP0
 
197
                shuf128_32      $0x0E, MSG, MSG
 
198
                sha256rnds2     MSG, STATE1, STATE0
 
199
        sha256msg1      MSGTMP3, MSGTMP2
 
200
 
 
201
        /* Rounds 48-51 */
 
202
        mova128         MSGTMP0, MSG
 
203
                paddd           12*16-8*16(SHA256CONSTANTS), MSG
 
204
                sha256rnds2     MSG, STATE0, STATE1
 
205
        mova128         MSGTMP0, XMMTMP
 
206
        palignr         $4, MSGTMP3, XMMTMP
 
207
        paddd           XMMTMP, MSGTMP1
 
208
        sha256msg2      MSGTMP0, MSGTMP1
 
209
                shuf128_32      $0x0E, MSG, MSG
 
210
                sha256rnds2     MSG, STATE1, STATE0
 
211
        sha256msg1      MSGTMP0, MSGTMP3
 
212
 
 
213
        /* Rounds 52-55 */
 
214
        mova128         MSGTMP1, MSG
 
215
                paddd           13*16-8*16(SHA256CONSTANTS), MSG
 
216
                sha256rnds2     MSG, STATE0, STATE1
 
217
        mova128         MSGTMP1, XMMTMP
 
218
        palignr         $4, MSGTMP0, XMMTMP
 
219
        paddd           XMMTMP, MSGTMP2
 
220
        sha256msg2      MSGTMP1, MSGTMP2
 
221
                shuf128_32      $0x0E, MSG, MSG
 
222
                sha256rnds2     MSG, STATE1, STATE0
 
223
 
 
224
        /* Rounds 56-59 */
 
225
        mova128         MSGTMP2, MSG
 
226
                paddd           14*16-8*16(SHA256CONSTANTS), MSG
 
227
                sha256rnds2     MSG, STATE0, STATE1
 
228
        mova128         MSGTMP2, XMMTMP
 
229
        palignr         $4, MSGTMP1, XMMTMP
 
230
        paddd           XMMTMP, MSGTMP3
 
231
        sha256msg2      MSGTMP2, MSGTMP3
 
232
                shuf128_32      $0x0E, MSG, MSG
 
233
                sha256rnds2     MSG, STATE1, STATE0
 
234
 
 
235
        /* Rounds 60-63 */
 
236
        mova128         MSGTMP3, MSG
 
237
                paddd           15*16-8*16(SHA256CONSTANTS), MSG
 
238
                sha256rnds2     MSG, STATE0, STATE1
 
239
                shuf128_32      $0x0E, MSG, MSG
 
240
                sha256rnds2     MSG, STATE1, STATE0
 
241
 
 
242
        /* Write hash values back in the correct order */
 
243
        mova128         STATE0, XMMTMP
 
244
/* shufps takes dwords 0,1 from *2nd* operand, and dwords 2,3 from 1st one */
 
245
        /* ---          -------------- HGDC -- FEBA */
 
246
        shufps          SHUF(3,2,3,2), STATE1, STATE0 /* ABCD */
 
247
        shufps          SHUF(1,0,1,0), STATE1, XMMTMP /* EFGH */
 
248
        /* add current hash values to previous ones */
 
249
        movu128         76+1*16(%eax), STATE1
 
250
        paddd           XMMTMP, STATE1
 
251
        movu128         STATE1, 76+1*16(%eax)
 
252
        movu128         76+0*16(%eax), XMMTMP
 
253
        paddd           XMMTMP, STATE0
 
254
        movu128         STATE0, 76+0*16(%eax)
 
255
 
 
256
        ret
 
257
        .size   sha256_process_block64_shaNI, .-sha256_process_block64_shaNI
 
258
 
 
259
        .section        .rodata.cst256.K256, "aM", @progbits, 256
 
260
        .balign 16
 
261
K256:
 
262
        .long   0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5
 
263
        .long   0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5
 
264
        .long   0xd807aa98,0x12835b01,0x243185be,0x550c7dc3
 
265
        .long   0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174
 
266
        .long   0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc
 
267
        .long   0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da
 
268
        .long   0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7
 
269
        .long   0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967
 
270
        .long   0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13
 
271
        .long   0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85
 
272
        .long   0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3
 
273
        .long   0xd192e819,0xd6990624,0xf40e3585,0x106aa070
 
274
        .long   0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5
 
275
        .long   0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3
 
276
        .long   0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208
 
277
        .long   0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2
 
278
 
 
279
        .section        .rodata.cst16.PSHUFFLE_BSWAP32_FLIP_MASK, "aM", @progbits, 16
 
280
        .balign 16
 
281
PSHUFFLE_BSWAP32_FLIP_MASK:
 
282
        .octa   0x0c0d0e0f08090a0b0405060700010203
 
283
 
 
284
#endif