~vcs-imports/busybox/trunk

« back to all changes in this revision

Viewing changes to libbb/hash_sha1_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_SHA1_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 xor128 pxor
 
16
#define xor128 xorps
 
17
//#define shuf128_32 pshufd
 
18
#define shuf128_32 shufps
 
19
 
 
20
#define extr128_32 pextrd
 
21
//#define extr128_32 extractps  # not shorter
 
22
 
 
23
// pshufb is a SSSE3 insn.
 
24
// pinsrd, pextrd, extractps are SSE4.1 insns.
 
25
// We do not check SSSE3/SSE4.1 in cpuid,
 
26
// all SHA-capable CPUs support them as well.
 
27
 
 
28
#ifdef __linux__
 
29
        .section        .note.GNU-stack, "", @progbits
 
30
#endif
 
31
        .section        .text.sha1_process_block64_shaNI, "ax", @progbits
 
32
        .globl  sha1_process_block64_shaNI
 
33
        .hidden sha1_process_block64_shaNI
 
34
        .type   sha1_process_block64_shaNI, @function
 
35
 
 
36
#define ABCD            %xmm0
 
37
#define E0              %xmm1   /* Need two E's b/c they ping pong */
 
38
#define E1              %xmm2
 
39
#define MSG0            %xmm3
 
40
#define MSG1            %xmm4
 
41
#define MSG2            %xmm5
 
42
#define MSG3            %xmm6
 
43
 
 
44
        .balign 8       # allow decoders to fetch at least 2 first insns
 
45
sha1_process_block64_shaNI:
 
46
        /* load initial hash values */
 
47
        movu128         76(%eax), ABCD
 
48
        xor128          E0, E0
 
49
        pinsrd          $3, 76+4*4(%eax), E0    # load to uppermost 32-bit word
 
50
        shuf128_32      $0x1B, ABCD, ABCD       # DCBA -> ABCD
 
51
 
 
52
        mova128         PSHUFFLE_BYTE_FLIP_MASK, %xmm7
 
53
 
 
54
        movu128         0*16(%eax), MSG0
 
55
        pshufb          %xmm7, MSG0
 
56
        movu128         1*16(%eax), MSG1
 
57
        pshufb          %xmm7, MSG1
 
58
        movu128         2*16(%eax), MSG2
 
59
        pshufb          %xmm7, MSG2
 
60
        movu128         3*16(%eax), MSG3
 
61
        pshufb          %xmm7, MSG3
 
62
 
 
63
        /* Save hash values for addition after rounds */
 
64
        mova128         E0, %xmm7
 
65
        /*mova128       ABCD, %xmm8 - NOPE, 32bit has no xmm8 */
 
66
 
 
67
        /* Rounds 0-3 */
 
68
                paddd           MSG0, E0
 
69
                mova128         ABCD, E1
 
70
                sha1rnds4       $0, E0, ABCD
 
71
 
 
72
        /* Rounds 4-7 */
 
73
                sha1nexte       MSG1, E1
 
74
                mova128         ABCD, E0
 
75
                sha1rnds4       $0, E1, ABCD
 
76
        sha1msg1        MSG1, MSG0
 
77
 
 
78
        /* Rounds 8-11 */
 
79
                sha1nexte       MSG2, E0
 
80
                mova128         ABCD, E1
 
81
                sha1rnds4       $0, E0, ABCD
 
82
        sha1msg1        MSG2, MSG1
 
83
        xor128          MSG2, MSG0
 
84
 
 
85
        /* Rounds 12-15 */
 
86
                sha1nexte       MSG3, E1
 
87
                mova128         ABCD, E0
 
88
        sha1msg2        MSG3, MSG0
 
89
                sha1rnds4       $0, E1, ABCD
 
90
        sha1msg1        MSG3, MSG2
 
91
        xor128          MSG3, MSG1
 
92
 
 
93
        /* Rounds 16-19 */
 
94
                sha1nexte       MSG0, E0
 
95
                mova128         ABCD, E1
 
96
        sha1msg2        MSG0, MSG1
 
97
                sha1rnds4       $0, E0, ABCD
 
98
        sha1msg1        MSG0, MSG3
 
99
        xor128          MSG0, MSG2
 
100
 
 
101
        /* Rounds 20-23 */
 
102
                sha1nexte       MSG1, E1
 
103
                mova128         ABCD, E0
 
104
        sha1msg2        MSG1, MSG2
 
105
                sha1rnds4       $1, E1, ABCD
 
106
        sha1msg1        MSG1, MSG0
 
107
        xor128          MSG1, MSG3
 
108
 
 
109
        /* Rounds 24-27 */
 
110
                sha1nexte       MSG2, E0
 
111
                mova128         ABCD, E1
 
112
        sha1msg2        MSG2, MSG3
 
113
                sha1rnds4       $1, E0, ABCD
 
114
        sha1msg1        MSG2, MSG1
 
115
        xor128          MSG2, MSG0
 
116
 
 
117
        /* Rounds 28-31 */
 
118
                sha1nexte       MSG3, E1
 
119
                mova128         ABCD, E0
 
120
        sha1msg2        MSG3, MSG0
 
121
                sha1rnds4       $1, E1, ABCD
 
122
        sha1msg1        MSG3, MSG2
 
123
        xor128          MSG3, MSG1
 
124
 
 
125
        /* Rounds 32-35 */
 
126
                sha1nexte       MSG0, E0
 
127
                mova128         ABCD, E1
 
128
        sha1msg2        MSG0, MSG1
 
129
                sha1rnds4       $1, E0, ABCD
 
130
        sha1msg1        MSG0, MSG3
 
131
        xor128          MSG0, MSG2
 
132
 
 
133
        /* Rounds 36-39 */
 
134
                sha1nexte       MSG1, E1
 
135
                mova128         ABCD, E0
 
136
        sha1msg2        MSG1, MSG2
 
137
                sha1rnds4       $1, E1, ABCD
 
138
        sha1msg1        MSG1, MSG0
 
139
        xor128          MSG1, MSG3
 
140
 
 
141
        /* Rounds 40-43 */
 
142
                sha1nexte       MSG2, E0
 
143
                mova128         ABCD, E1
 
144
        sha1msg2        MSG2, MSG3
 
145
                sha1rnds4       $2, E0, ABCD
 
146
        sha1msg1        MSG2, MSG1
 
147
        xor128          MSG2, MSG0
 
148
 
 
149
        /* Rounds 44-47 */
 
150
                sha1nexte       MSG3, E1
 
151
                mova128         ABCD, E0
 
152
        sha1msg2        MSG3, MSG0
 
153
                sha1rnds4       $2, E1, ABCD
 
154
        sha1msg1        MSG3, MSG2
 
155
        xor128          MSG3, MSG1
 
156
 
 
157
        /* Rounds 48-51 */
 
158
                sha1nexte       MSG0, E0
 
159
                mova128         ABCD, E1
 
160
        sha1msg2        MSG0, MSG1
 
161
                sha1rnds4       $2, E0, ABCD
 
162
        sha1msg1        MSG0, MSG3
 
163
        xor128          MSG0, MSG2
 
164
 
 
165
        /* Rounds 52-55 */
 
166
                sha1nexte       MSG1, E1
 
167
                mova128         ABCD, E0
 
168
        sha1msg2        MSG1, MSG2
 
169
                sha1rnds4       $2, E1, ABCD
 
170
        sha1msg1        MSG1, MSG0
 
171
        xor128          MSG1, MSG3
 
172
 
 
173
        /* Rounds 56-59 */
 
174
                sha1nexte       MSG2, E0
 
175
                mova128         ABCD, E1
 
176
        sha1msg2        MSG2, MSG3
 
177
                sha1rnds4       $2, E0, ABCD
 
178
        sha1msg1        MSG2, MSG1
 
179
        xor128          MSG2, MSG0
 
180
 
 
181
        /* Rounds 60-63 */
 
182
                sha1nexte       MSG3, E1
 
183
                mova128         ABCD, E0
 
184
        sha1msg2        MSG3, MSG0
 
185
                sha1rnds4       $3, E1, ABCD
 
186
        sha1msg1        MSG3, MSG2
 
187
        xor128          MSG3, MSG1
 
188
 
 
189
        /* Rounds 64-67 */
 
190
                sha1nexte       MSG0, E0
 
191
                mova128         ABCD, E1
 
192
        sha1msg2        MSG0, MSG1
 
193
                sha1rnds4       $3, E0, ABCD
 
194
        sha1msg1        MSG0, MSG3
 
195
        xor128          MSG0, MSG2
 
196
 
 
197
        /* Rounds 68-71 */
 
198
                sha1nexte       MSG1, E1
 
199
                mova128         ABCD, E0
 
200
        sha1msg2        MSG1, MSG2
 
201
                sha1rnds4       $3, E1, ABCD
 
202
        xor128          MSG1, MSG3
 
203
 
 
204
        /* Rounds 72-75 */
 
205
                sha1nexte       MSG2, E0
 
206
                mova128         ABCD, E1
 
207
        sha1msg2        MSG2, MSG3
 
208
                sha1rnds4       $3, E0, ABCD
 
209
 
 
210
        /* Rounds 76-79 */
 
211
                sha1nexte       MSG3, E1
 
212
                mova128         ABCD, E0
 
213
                sha1rnds4       $3, E1, ABCD
 
214
 
 
215
        /* Add current hash values with previously saved */
 
216
        sha1nexte       %xmm7, E0
 
217
        /*paddd         %xmm8, ABCD - 32-bit mode has no xmm8 */
 
218
        movu128         76(%eax), %xmm7 # get original ABCD (not shuffled)...
 
219
 
 
220
        /* Write hash values back in the correct order */
 
221
        shuf128_32      $0x1B, ABCD, ABCD
 
222
        paddd           %xmm7, ABCD     # ...add it to final ABCD
 
223
        movu128         ABCD, 76(%eax)
 
224
        extr128_32      $3, E0, 76+4*4(%eax)
 
225
 
 
226
        ret
 
227
        .size   sha1_process_block64_shaNI, .-sha1_process_block64_shaNI
 
228
 
 
229
        .section        .rodata.cst16.PSHUFFLE_BYTE_FLIP_MASK, "aM", @progbits, 16
 
230
        .balign 16
 
231
PSHUFFLE_BYTE_FLIP_MASK:
 
232
        .octa   0x000102030405060708090a0b0c0d0e0f
 
233
 
 
234
#endif