~vcs-imports/busybox/trunk

« back to all changes in this revision

Viewing changes to libbb/hash_md5_sha_x86-64.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
 
### Generated by hash_md5_sha_x86-64.S.sh ###
2
 
 
3
 
#if CONFIG_SHA1_SMALL == 0 && defined(__GNUC__) && defined(__x86_64__)
4
 
#ifdef __linux__
5
 
        .section        .note.GNU-stack, "", @progbits
6
 
#endif
7
 
        .section        .text.sha1_process_block64, "ax", @progbits
8
 
        .globl  sha1_process_block64
9
 
        .hidden sha1_process_block64
10
 
        .type   sha1_process_block64, @function
11
 
 
12
 
        .balign 8       # allow decoders to fetch at least 5 first insns
13
 
sha1_process_block64:
14
 
        pushq   %rbp    # 1 byte insn
15
 
        pushq   %rbx    # 1 byte insn
16
 
#       pushq   %r15    # 2 byte insn
17
 
        pushq   %r14    # 2 byte insn
18
 
        pushq   %r13    # 2 byte insn
19
 
        pushq   %r12    # 2 byte insn
20
 
        pushq   %rdi    # we need ctx at the end
21
 
 
22
 
#Register and stack use:
23
 
# eax..edx: a..d
24
 
# ebp: e
25
 
# esi,edi,r8..r14: temps
26
 
# r15: unused
27
 
# xmm0..xmm3: W[]
28
 
# xmm4,xmm5: temps
29
 
# xmm6: current round constant
30
 
# xmm7: all round constants
31
 
# -64(%rsp): area for passing RCONST + W[] from vector to integer units
32
 
 
33
 
        movl    80(%rdi), %eax          # a = ctx->hash[0]
34
 
        movl    84(%rdi), %ebx          # b = ctx->hash[1]
35
 
        movl    88(%rdi), %ecx          # c = ctx->hash[2]
36
 
        movl    92(%rdi), %edx          # d = ctx->hash[3]
37
 
        movl    96(%rdi), %ebp          # e = ctx->hash[4]
38
 
 
39
 
        movaps  sha1const(%rip), %xmm7
40
 
        pshufd  $0x00, %xmm7, %xmm6
41
 
 
42
 
        # Load W[] to xmm0..3, byteswapping on the fly.
43
 
        #
44
 
        # For iterations 0..15, we pass W[] in rsi,r8..r14
45
 
        # for use in RD1As instead of spilling them to stack.
46
 
        # We lose parallelized addition of RCONST, but LEA
47
 
        # can do two additions at once, so it is probably a wash.
48
 
        # (We use rsi instead of rN because this makes two
49
 
        # LEAs in two first RD1As shorter by one byte).
50
 
        movq    4*0(%rdi), %rsi
51
 
        movq    4*2(%rdi), %r8
52
 
        bswapq  %rsi
53
 
        bswapq  %r8
54
 
        rolq    $32, %rsi               # rsi = W[1]:W[0]
55
 
        rolq    $32, %r8                # r8  = W[3]:W[2]
56
 
        movq    %rsi, %xmm0
57
 
        movq    %r8, %xmm4
58
 
        punpcklqdq %xmm4, %xmm0 # xmm0 = r8:rsi = (W[0],W[1],W[2],W[3])
59
 
#       movaps  %xmm0, %xmm4            # add RCONST, spill to stack
60
 
#       paddd   %xmm6, %xmm4
61
 
#       movups  %xmm4, -64+16*0(%rsp)
62
 
 
63
 
        movq    4*4(%rdi), %r9
64
 
        movq    4*6(%rdi), %r10
65
 
        bswapq  %r9
66
 
        bswapq  %r10
67
 
        rolq    $32, %r9                # r9  = W[5]:W[4]
68
 
        rolq    $32, %r10               # r10 = W[7]:W[6]
69
 
        movq    %r9, %xmm1
70
 
        movq    %r10, %xmm4
71
 
        punpcklqdq %xmm4, %xmm1 # xmm1 = r10:r9 = (W[4],W[5],W[6],W[7])
72
 
 
73
 
        movq    4*8(%rdi), %r11
74
 
        movq    4*10(%rdi), %r12
75
 
        bswapq  %r11
76
 
        bswapq  %r12
77
 
        rolq    $32, %r11               # r11 = W[9]:W[8]
78
 
        rolq    $32, %r12               # r12 = W[11]:W[10]
79
 
        movq    %r11, %xmm2
80
 
        movq    %r12, %xmm4
81
 
        punpcklqdq %xmm4, %xmm2 # xmm2 = r12:r11 = (W[8],W[9],W[10],W[11])
82
 
 
83
 
        movq    4*12(%rdi), %r13
84
 
        movq    4*14(%rdi), %r14
85
 
        bswapq  %r13
86
 
        bswapq  %r14
87
 
        rolq    $32, %r13               # r13 = W[13]:W[12]
88
 
        rolq    $32, %r14               # r14 = W[15]:W[14]
89
 
        movq    %r13, %xmm3
90
 
        movq    %r14, %xmm4
91
 
        punpcklqdq %xmm4, %xmm3 # xmm3 = r14:r13 = (W[12],W[13],W[14],W[15])
92
 
 
93
 
# 0
94
 
        leal    0x5A827999(%rbp,%rsi), %ebp # e += RCONST + W[n]
95
 
        shrq    $32, %rsi
96
 
        movl    %ecx, %edi              # c
97
 
        xorl    %edx, %edi              # ^d
98
 
        andl    %ebx, %edi              # &b
99
 
        xorl    %edx, %edi              # (((c ^ d) & b) ^ d)
100
 
        addl    %edi, %ebp              # e += (((c ^ d) & b) ^ d)
101
 
        movl    %eax, %edi              #
102
 
        roll    $5, %edi                # rotl32(a,5)
103
 
        addl    %edi, %ebp              # e += rotl32(a,5)
104
 
        rorl    $2, %ebx                # b = rotl32(b,30)
105
 
# 1
106
 
        leal    0x5A827999(%rdx,%rsi), %edx # e += RCONST + W[n]
107
 
        movl    %ebx, %edi              # c
108
 
        xorl    %ecx, %edi              # ^d
109
 
        andl    %eax, %edi              # &b
110
 
        xorl    %ecx, %edi              # (((c ^ d) & b) ^ d)
111
 
        addl    %edi, %edx              # e += (((c ^ d) & b) ^ d)
112
 
        movl    %ebp, %edi              #
113
 
        roll    $5, %edi                # rotl32(a,5)
114
 
        addl    %edi, %edx              # e += rotl32(a,5)
115
 
        rorl    $2, %eax                # b = rotl32(b,30)
116
 
# 2
117
 
        leal    0x5A827999(%rcx,%r8), %ecx # e += RCONST + W[n]
118
 
        shrq    $32, %r8
119
 
        movl    %eax, %edi              # c
120
 
        xorl    %ebx, %edi              # ^d
121
 
        andl    %ebp, %edi              # &b
122
 
        xorl    %ebx, %edi              # (((c ^ d) & b) ^ d)
123
 
        addl    %edi, %ecx              # e += (((c ^ d) & b) ^ d)
124
 
        movl    %edx, %edi              #
125
 
        roll    $5, %edi                # rotl32(a,5)
126
 
        addl    %edi, %ecx              # e += rotl32(a,5)
127
 
        rorl    $2, %ebp                # b = rotl32(b,30)
128
 
# 3
129
 
        leal    0x5A827999(%rbx,%r8), %ebx # e += RCONST + W[n]
130
 
        movl    %ebp, %edi              # c
131
 
        xorl    %eax, %edi              # ^d
132
 
        andl    %edx, %edi              # &b
133
 
        xorl    %eax, %edi              # (((c ^ d) & b) ^ d)
134
 
        addl    %edi, %ebx              # e += (((c ^ d) & b) ^ d)
135
 
        movl    %ecx, %edi              #
136
 
        roll    $5, %edi                # rotl32(a,5)
137
 
        addl    %edi, %ebx              # e += rotl32(a,5)
138
 
        rorl    $2, %edx                # b = rotl32(b,30)
139
 
# 4
140
 
        leal    0x5A827999(%rax,%r9), %eax # e += RCONST + W[n]
141
 
        shrq    $32, %r9
142
 
        movl    %edx, %edi              # c
143
 
        xorl    %ebp, %edi              # ^d
144
 
        andl    %ecx, %edi              # &b
145
 
        xorl    %ebp, %edi              # (((c ^ d) & b) ^ d)
146
 
        addl    %edi, %eax              # e += (((c ^ d) & b) ^ d)
147
 
        movl    %ebx, %edi              #
148
 
        roll    $5, %edi                # rotl32(a,5)
149
 
        addl    %edi, %eax              # e += rotl32(a,5)
150
 
        rorl    $2, %ecx                # b = rotl32(b,30)
151
 
# 5
152
 
        leal    0x5A827999(%rbp,%r9), %ebp # e += RCONST + W[n]
153
 
        movl    %ecx, %edi              # c
154
 
        xorl    %edx, %edi              # ^d
155
 
        andl    %ebx, %edi              # &b
156
 
        xorl    %edx, %edi              # (((c ^ d) & b) ^ d)
157
 
        addl    %edi, %ebp              # e += (((c ^ d) & b) ^ d)
158
 
        movl    %eax, %edi              #
159
 
        roll    $5, %edi                # rotl32(a,5)
160
 
        addl    %edi, %ebp              # e += rotl32(a,5)
161
 
        rorl    $2, %ebx                # b = rotl32(b,30)
162
 
# 6
163
 
        leal    0x5A827999(%rdx,%r10), %edx # e += RCONST + W[n]
164
 
        shrq    $32, %r10
165
 
        movl    %ebx, %edi              # c
166
 
        xorl    %ecx, %edi              # ^d
167
 
        andl    %eax, %edi              # &b
168
 
        xorl    %ecx, %edi              # (((c ^ d) & b) ^ d)
169
 
        addl    %edi, %edx              # e += (((c ^ d) & b) ^ d)
170
 
        movl    %ebp, %edi              #
171
 
        roll    $5, %edi                # rotl32(a,5)
172
 
        addl    %edi, %edx              # e += rotl32(a,5)
173
 
        rorl    $2, %eax                # b = rotl32(b,30)
174
 
# 7
175
 
        leal    0x5A827999(%rcx,%r10), %ecx # e += RCONST + W[n]
176
 
        movl    %eax, %edi              # c
177
 
        xorl    %ebx, %edi              # ^d
178
 
        andl    %ebp, %edi              # &b
179
 
        xorl    %ebx, %edi              # (((c ^ d) & b) ^ d)
180
 
        addl    %edi, %ecx              # e += (((c ^ d) & b) ^ d)
181
 
        movl    %edx, %edi              #
182
 
        roll    $5, %edi                # rotl32(a,5)
183
 
        addl    %edi, %ecx              # e += rotl32(a,5)
184
 
        rorl    $2, %ebp                # b = rotl32(b,30)
185
 
# PREP %xmm0 %xmm1 %xmm2 %xmm3 -64+16*0(%rsp)
186
 
        movaps  %xmm3, %xmm4
187
 
        psrldq  $4, %xmm4       # rshift by 4 bytes: T1 = ([13],[14],[15],0)
188
 
#       pshufd  $0x4e, %xmm0, %xmm5     # 01001110=2,3,0,1 shuffle, ([2],[3],x,x)
189
 
#       punpcklqdq %xmm1, %xmm5 # T2 = W4[0..63]:T2[0..63] = ([2],[3],[4],[5])
190
 
# same result as above, but shorter and faster:
191
 
# pshufd/shufps are subtly different: pshufd takes all dwords from source operand,
192
 
# shufps takes dwords 0,1 from *2nd* operand, and dwords 2,3 from 1st one!
193
 
        movaps  %xmm0, %xmm5
194
 
        shufps  $0x4e, %xmm1, %xmm5     # 01001110=(T2.dw[2], T2.dw[3], W4.dw[0], W4.dw[1]) = ([2],[3],[4],[5])
195
 
        xorps   %xmm2, %xmm0    # ([8],[9],[10],[11]) ^ ([0],[1],[2],[3])
196
 
        xorps   %xmm4, %xmm5    # ([13],[14],[15],0) ^ ([2],[3],[4],[5])
197
 
        xorps   %xmm5, %xmm0    # ^
198
 
        # W0 = unrotated (W[0]..W[3]), still needs W[3] fixup
199
 
        movaps  %xmm0, %xmm5
200
 
        xorps   %xmm4, %xmm4    # rol(W0,1):
201
 
        pcmpgtd %xmm0, %xmm4    #  ffffffff for elements <0 (ones with msb bit 1)
202
 
        paddd   %xmm0, %xmm0    #  shift left by 1
203
 
        psubd   %xmm4, %xmm0    #  add 1 to those who had msb bit 1
204
 
        # W0 = rotated (W[0]..W[3]), still needs W[3] fixup
205
 
        pslldq  $12, %xmm5      # lshift by 12 bytes: T2 = (0,0,0,unrotW[0])
206
 
        movaps  %xmm5, %xmm4
207
 
        pslld   $2, %xmm5
208
 
        psrld   $30, %xmm4
209
 
#       xorps   %xmm4, %xmm5    # rol((0,0,0,unrotW[0]),2)
210
 
        xorps   %xmm4, %xmm0    # same result, but does not depend on/does not modify T2
211
 
        xorps   %xmm5, %xmm0    # W0 = rol(W[0]..W[3],1) ^ (0,0,0,rol(unrotW[0],2))
212
 
        movaps  %xmm0, %xmm5
213
 
        paddd   %xmm6, %xmm5
214
 
        movups  %xmm5, -64+16*0(%rsp)
215
 
# 8
216
 
        leal    0x5A827999(%rbx,%r11), %ebx # e += RCONST + W[n]
217
 
        shrq    $32, %r11
218
 
        movl    %ebp, %edi              # c
219
 
        xorl    %eax, %edi              # ^d
220
 
        andl    %edx, %edi              # &b
221
 
        xorl    %eax, %edi              # (((c ^ d) & b) ^ d)
222
 
        addl    %edi, %ebx              # e += (((c ^ d) & b) ^ d)
223
 
        movl    %ecx, %edi              #
224
 
        roll    $5, %edi                # rotl32(a,5)
225
 
        addl    %edi, %ebx              # e += rotl32(a,5)
226
 
        rorl    $2, %edx                # b = rotl32(b,30)
227
 
# 9
228
 
        leal    0x5A827999(%rax,%r11), %eax # e += RCONST + W[n]
229
 
        movl    %edx, %edi              # c
230
 
        xorl    %ebp, %edi              # ^d
231
 
        andl    %ecx, %edi              # &b
232
 
        xorl    %ebp, %edi              # (((c ^ d) & b) ^ d)
233
 
        addl    %edi, %eax              # e += (((c ^ d) & b) ^ d)
234
 
        movl    %ebx, %edi              #
235
 
        roll    $5, %edi                # rotl32(a,5)
236
 
        addl    %edi, %eax              # e += rotl32(a,5)
237
 
        rorl    $2, %ecx                # b = rotl32(b,30)
238
 
# 10
239
 
        leal    0x5A827999(%rbp,%r12), %ebp # e += RCONST + W[n]
240
 
        shrq    $32, %r12
241
 
        movl    %ecx, %edi              # c
242
 
        xorl    %edx, %edi              # ^d
243
 
        andl    %ebx, %edi              # &b
244
 
        xorl    %edx, %edi              # (((c ^ d) & b) ^ d)
245
 
        addl    %edi, %ebp              # e += (((c ^ d) & b) ^ d)
246
 
        movl    %eax, %edi              #
247
 
        roll    $5, %edi                # rotl32(a,5)
248
 
        addl    %edi, %ebp              # e += rotl32(a,5)
249
 
        rorl    $2, %ebx                # b = rotl32(b,30)
250
 
# 11
251
 
        leal    0x5A827999(%rdx,%r12), %edx # e += RCONST + W[n]
252
 
        movl    %ebx, %edi              # c
253
 
        xorl    %ecx, %edi              # ^d
254
 
        andl    %eax, %edi              # &b
255
 
        xorl    %ecx, %edi              # (((c ^ d) & b) ^ d)
256
 
        addl    %edi, %edx              # e += (((c ^ d) & b) ^ d)
257
 
        movl    %ebp, %edi              #
258
 
        roll    $5, %edi                # rotl32(a,5)
259
 
        addl    %edi, %edx              # e += rotl32(a,5)
260
 
        rorl    $2, %eax                # b = rotl32(b,30)
261
 
        pshufd  $0x55, %xmm7, %xmm6
262
 
# PREP %xmm1 %xmm2 %xmm3 %xmm0 -64+16*1(%rsp)
263
 
        movaps  %xmm0, %xmm4
264
 
        psrldq  $4, %xmm4       # rshift by 4 bytes: T1 = ([13],[14],[15],0)
265
 
#       pshufd  $0x4e, %xmm1, %xmm5     # 01001110=2,3,0,1 shuffle, ([2],[3],x,x)
266
 
#       punpcklqdq %xmm2, %xmm5 # T2 = W4[0..63]:T2[0..63] = ([2],[3],[4],[5])
267
 
# same result as above, but shorter and faster:
268
 
# pshufd/shufps are subtly different: pshufd takes all dwords from source operand,
269
 
# shufps takes dwords 0,1 from *2nd* operand, and dwords 2,3 from 1st one!
270
 
        movaps  %xmm1, %xmm5
271
 
        shufps  $0x4e, %xmm2, %xmm5     # 01001110=(T2.dw[2], T2.dw[3], W4.dw[0], W4.dw[1]) = ([2],[3],[4],[5])
272
 
        xorps   %xmm3, %xmm1    # ([8],[9],[10],[11]) ^ ([0],[1],[2],[3])
273
 
        xorps   %xmm4, %xmm5    # ([13],[14],[15],0) ^ ([2],[3],[4],[5])
274
 
        xorps   %xmm5, %xmm1    # ^
275
 
        # W0 = unrotated (W[0]..W[3]), still needs W[3] fixup
276
 
        movaps  %xmm1, %xmm5
277
 
        xorps   %xmm4, %xmm4    # rol(W0,1):
278
 
        pcmpgtd %xmm1, %xmm4    #  ffffffff for elements <0 (ones with msb bit 1)
279
 
        paddd   %xmm1, %xmm1    #  shift left by 1
280
 
        psubd   %xmm4, %xmm1    #  add 1 to those who had msb bit 1
281
 
        # W0 = rotated (W[0]..W[3]), still needs W[3] fixup
282
 
        pslldq  $12, %xmm5      # lshift by 12 bytes: T2 = (0,0,0,unrotW[0])
283
 
        movaps  %xmm5, %xmm4
284
 
        pslld   $2, %xmm5
285
 
        psrld   $30, %xmm4
286
 
#       xorps   %xmm4, %xmm5    # rol((0,0,0,unrotW[0]),2)
287
 
        xorps   %xmm4, %xmm1    # same result, but does not depend on/does not modify T2
288
 
        xorps   %xmm5, %xmm1    # W0 = rol(W[0]..W[3],1) ^ (0,0,0,rol(unrotW[0],2))
289
 
        movaps  %xmm1, %xmm5
290
 
        paddd   %xmm6, %xmm5
291
 
        movups  %xmm5, -64+16*1(%rsp)
292
 
# 12
293
 
        leal    0x5A827999(%rcx,%r13), %ecx # e += RCONST + W[n]
294
 
        shrq    $32, %r13
295
 
        movl    %eax, %edi              # c
296
 
        xorl    %ebx, %edi              # ^d
297
 
        andl    %ebp, %edi              # &b
298
 
        xorl    %ebx, %edi              # (((c ^ d) & b) ^ d)
299
 
        addl    %edi, %ecx              # e += (((c ^ d) & b) ^ d)
300
 
        movl    %edx, %edi              #
301
 
        roll    $5, %edi                # rotl32(a,5)
302
 
        addl    %edi, %ecx              # e += rotl32(a,5)
303
 
        rorl    $2, %ebp                # b = rotl32(b,30)
304
 
# 13
305
 
        leal    0x5A827999(%rbx,%r13), %ebx # e += RCONST + W[n]
306
 
        movl    %ebp, %edi              # c
307
 
        xorl    %eax, %edi              # ^d
308
 
        andl    %edx, %edi              # &b
309
 
        xorl    %eax, %edi              # (((c ^ d) & b) ^ d)
310
 
        addl    %edi, %ebx              # e += (((c ^ d) & b) ^ d)
311
 
        movl    %ecx, %edi              #
312
 
        roll    $5, %edi                # rotl32(a,5)
313
 
        addl    %edi, %ebx              # e += rotl32(a,5)
314
 
        rorl    $2, %edx                # b = rotl32(b,30)
315
 
# 14
316
 
        leal    0x5A827999(%rax,%r14), %eax # e += RCONST + W[n]
317
 
        shrq    $32, %r14
318
 
        movl    %edx, %edi              # c
319
 
        xorl    %ebp, %edi              # ^d
320
 
        andl    %ecx, %edi              # &b
321
 
        xorl    %ebp, %edi              # (((c ^ d) & b) ^ d)
322
 
        addl    %edi, %eax              # e += (((c ^ d) & b) ^ d)
323
 
        movl    %ebx, %edi              #
324
 
        roll    $5, %edi                # rotl32(a,5)
325
 
        addl    %edi, %eax              # e += rotl32(a,5)
326
 
        rorl    $2, %ecx                # b = rotl32(b,30)
327
 
# 15
328
 
        leal    0x5A827999(%rbp,%r14), %ebp # e += RCONST + W[n]
329
 
        movl    %ecx, %edi              # c
330
 
        xorl    %edx, %edi              # ^d
331
 
        andl    %ebx, %edi              # &b
332
 
        xorl    %edx, %edi              # (((c ^ d) & b) ^ d)
333
 
        addl    %edi, %ebp              # e += (((c ^ d) & b) ^ d)
334
 
        movl    %eax, %edi              #
335
 
        roll    $5, %edi                # rotl32(a,5)
336
 
        addl    %edi, %ebp              # e += rotl32(a,5)
337
 
        rorl    $2, %ebx                # b = rotl32(b,30)
338
 
# PREP %xmm2 %xmm3 %xmm0 %xmm1 -64+16*2(%rsp)
339
 
        movaps  %xmm1, %xmm4
340
 
        psrldq  $4, %xmm4       # rshift by 4 bytes: T1 = ([13],[14],[15],0)
341
 
#       pshufd  $0x4e, %xmm2, %xmm5     # 01001110=2,3,0,1 shuffle, ([2],[3],x,x)
342
 
#       punpcklqdq %xmm3, %xmm5 # T2 = W4[0..63]:T2[0..63] = ([2],[3],[4],[5])
343
 
# same result as above, but shorter and faster:
344
 
# pshufd/shufps are subtly different: pshufd takes all dwords from source operand,
345
 
# shufps takes dwords 0,1 from *2nd* operand, and dwords 2,3 from 1st one!
346
 
        movaps  %xmm2, %xmm5
347
 
        shufps  $0x4e, %xmm3, %xmm5     # 01001110=(T2.dw[2], T2.dw[3], W4.dw[0], W4.dw[1]) = ([2],[3],[4],[5])
348
 
        xorps   %xmm0, %xmm2    # ([8],[9],[10],[11]) ^ ([0],[1],[2],[3])
349
 
        xorps   %xmm4, %xmm5    # ([13],[14],[15],0) ^ ([2],[3],[4],[5])
350
 
        xorps   %xmm5, %xmm2    # ^
351
 
        # W0 = unrotated (W[0]..W[3]), still needs W[3] fixup
352
 
        movaps  %xmm2, %xmm5
353
 
        xorps   %xmm4, %xmm4    # rol(W0,1):
354
 
        pcmpgtd %xmm2, %xmm4    #  ffffffff for elements <0 (ones with msb bit 1)
355
 
        paddd   %xmm2, %xmm2    #  shift left by 1
356
 
        psubd   %xmm4, %xmm2    #  add 1 to those who had msb bit 1
357
 
        # W0 = rotated (W[0]..W[3]), still needs W[3] fixup
358
 
        pslldq  $12, %xmm5      # lshift by 12 bytes: T2 = (0,0,0,unrotW[0])
359
 
        movaps  %xmm5, %xmm4
360
 
        pslld   $2, %xmm5
361
 
        psrld   $30, %xmm4
362
 
#       xorps   %xmm4, %xmm5    # rol((0,0,0,unrotW[0]),2)
363
 
        xorps   %xmm4, %xmm2    # same result, but does not depend on/does not modify T2
364
 
        xorps   %xmm5, %xmm2    # W0 = rol(W[0]..W[3],1) ^ (0,0,0,rol(unrotW[0],2))
365
 
        movaps  %xmm2, %xmm5
366
 
        paddd   %xmm6, %xmm5
367
 
        movups  %xmm5, -64+16*2(%rsp)
368
 
# 16
369
 
        movl    %ebx, %edi              # c
370
 
        xorl    %ecx, %edi              # ^d
371
 
        andl    %eax, %edi              # &b
372
 
        xorl    %ecx, %edi              # (((c ^ d) & b) ^ d)
373
 
        addl    -64+4*0(%rsp), %edx     # e += RCONST + W[n & 15]
374
 
        addl    %edi, %edx              # e += (((c ^ d) & b) ^ d)
375
 
        movl    %ebp, %esi              #
376
 
        roll    $5, %esi                # rotl32(a,5)
377
 
        addl    %esi, %edx              # e += rotl32(a,5)
378
 
        rorl    $2, %eax                # b = rotl32(b,30)
379
 
# 17
380
 
        movl    %eax, %edi              # c
381
 
        xorl    %ebx, %edi              # ^d
382
 
        andl    %ebp, %edi              # &b
383
 
        xorl    %ebx, %edi              # (((c ^ d) & b) ^ d)
384
 
        addl    -64+4*1(%rsp), %ecx     # e += RCONST + W[n & 15]
385
 
        addl    %edi, %ecx              # e += (((c ^ d) & b) ^ d)
386
 
        movl    %edx, %esi              #
387
 
        roll    $5, %esi                # rotl32(a,5)
388
 
        addl    %esi, %ecx              # e += rotl32(a,5)
389
 
        rorl    $2, %ebp                # b = rotl32(b,30)
390
 
# 18
391
 
        movl    %ebp, %edi              # c
392
 
        xorl    %eax, %edi              # ^d
393
 
        andl    %edx, %edi              # &b
394
 
        xorl    %eax, %edi              # (((c ^ d) & b) ^ d)
395
 
        addl    -64+4*2(%rsp), %ebx     # e += RCONST + W[n & 15]
396
 
        addl    %edi, %ebx              # e += (((c ^ d) & b) ^ d)
397
 
        movl    %ecx, %esi              #
398
 
        roll    $5, %esi                # rotl32(a,5)
399
 
        addl    %esi, %ebx              # e += rotl32(a,5)
400
 
        rorl    $2, %edx                # b = rotl32(b,30)
401
 
# 19
402
 
        movl    %edx, %edi              # c
403
 
        xorl    %ebp, %edi              # ^d
404
 
        andl    %ecx, %edi              # &b
405
 
        xorl    %ebp, %edi              # (((c ^ d) & b) ^ d)
406
 
        addl    -64+4*3(%rsp), %eax     # e += RCONST + W[n & 15]
407
 
        addl    %edi, %eax              # e += (((c ^ d) & b) ^ d)
408
 
        movl    %ebx, %esi              #
409
 
        roll    $5, %esi                # rotl32(a,5)
410
 
        addl    %esi, %eax              # e += rotl32(a,5)
411
 
        rorl    $2, %ecx                # b = rotl32(b,30)
412
 
# PREP %xmm3 %xmm0 %xmm1 %xmm2 -64+16*3(%rsp)
413
 
        movaps  %xmm2, %xmm4
414
 
        psrldq  $4, %xmm4       # rshift by 4 bytes: T1 = ([13],[14],[15],0)
415
 
#       pshufd  $0x4e, %xmm3, %xmm5     # 01001110=2,3,0,1 shuffle, ([2],[3],x,x)
416
 
#       punpcklqdq %xmm0, %xmm5 # T2 = W4[0..63]:T2[0..63] = ([2],[3],[4],[5])
417
 
# same result as above, but shorter and faster:
418
 
# pshufd/shufps are subtly different: pshufd takes all dwords from source operand,
419
 
# shufps takes dwords 0,1 from *2nd* operand, and dwords 2,3 from 1st one!
420
 
        movaps  %xmm3, %xmm5
421
 
        shufps  $0x4e, %xmm0, %xmm5     # 01001110=(T2.dw[2], T2.dw[3], W4.dw[0], W4.dw[1]) = ([2],[3],[4],[5])
422
 
        xorps   %xmm1, %xmm3    # ([8],[9],[10],[11]) ^ ([0],[1],[2],[3])
423
 
        xorps   %xmm4, %xmm5    # ([13],[14],[15],0) ^ ([2],[3],[4],[5])
424
 
        xorps   %xmm5, %xmm3    # ^
425
 
        # W0 = unrotated (W[0]..W[3]), still needs W[3] fixup
426
 
        movaps  %xmm3, %xmm5
427
 
        xorps   %xmm4, %xmm4    # rol(W0,1):
428
 
        pcmpgtd %xmm3, %xmm4    #  ffffffff for elements <0 (ones with msb bit 1)
429
 
        paddd   %xmm3, %xmm3    #  shift left by 1
430
 
        psubd   %xmm4, %xmm3    #  add 1 to those who had msb bit 1
431
 
        # W0 = rotated (W[0]..W[3]), still needs W[3] fixup
432
 
        pslldq  $12, %xmm5      # lshift by 12 bytes: T2 = (0,0,0,unrotW[0])
433
 
        movaps  %xmm5, %xmm4
434
 
        pslld   $2, %xmm5
435
 
        psrld   $30, %xmm4
436
 
#       xorps   %xmm4, %xmm5    # rol((0,0,0,unrotW[0]),2)
437
 
        xorps   %xmm4, %xmm3    # same result, but does not depend on/does not modify T2
438
 
        xorps   %xmm5, %xmm3    # W0 = rol(W[0]..W[3],1) ^ (0,0,0,rol(unrotW[0],2))
439
 
        movaps  %xmm3, %xmm5
440
 
        paddd   %xmm6, %xmm5
441
 
        movups  %xmm5, -64+16*3(%rsp)
442
 
# 20
443
 
        movl    %ecx, %edi              # c
444
 
        xorl    %edx, %edi              # ^d
445
 
        xorl    %ebx, %edi              # ^b
446
 
        addl    -64+4*4(%rsp), %ebp     # e += RCONST + W[n & 15]
447
 
        addl    %edi, %ebp              # e += (c ^ d ^ b)
448
 
        movl    %eax, %esi              #
449
 
        roll    $5, %esi                # rotl32(a,5)
450
 
        addl    %esi, %ebp              # e += rotl32(a,5)
451
 
        rorl    $2, %ebx                # b = rotl32(b,30)
452
 
# 21
453
 
        movl    %ebx, %edi              # c
454
 
        xorl    %ecx, %edi              # ^d
455
 
        xorl    %eax, %edi              # ^b
456
 
        addl    -64+4*5(%rsp), %edx     # e += RCONST + W[n & 15]
457
 
        addl    %edi, %edx              # e += (c ^ d ^ b)
458
 
        movl    %ebp, %esi              #
459
 
        roll    $5, %esi                # rotl32(a,5)
460
 
        addl    %esi, %edx              # e += rotl32(a,5)
461
 
        rorl    $2, %eax                # b = rotl32(b,30)
462
 
# 22
463
 
        movl    %eax, %edi              # c
464
 
        xorl    %ebx, %edi              # ^d
465
 
        xorl    %ebp, %edi              # ^b
466
 
        addl    -64+4*6(%rsp), %ecx     # e += RCONST + W[n & 15]
467
 
        addl    %edi, %ecx              # e += (c ^ d ^ b)
468
 
        movl    %edx, %esi              #
469
 
        roll    $5, %esi                # rotl32(a,5)
470
 
        addl    %esi, %ecx              # e += rotl32(a,5)
471
 
        rorl    $2, %ebp                # b = rotl32(b,30)
472
 
# 23
473
 
        movl    %ebp, %edi              # c
474
 
        xorl    %eax, %edi              # ^d
475
 
        xorl    %edx, %edi              # ^b
476
 
        addl    -64+4*7(%rsp), %ebx     # e += RCONST + W[n & 15]
477
 
        addl    %edi, %ebx              # e += (c ^ d ^ b)
478
 
        movl    %ecx, %esi              #
479
 
        roll    $5, %esi                # rotl32(a,5)
480
 
        addl    %esi, %ebx              # e += rotl32(a,5)
481
 
        rorl    $2, %edx                # b = rotl32(b,30)
482
 
# PREP %xmm0 %xmm1 %xmm2 %xmm3 -64+16*0(%rsp)
483
 
        movaps  %xmm3, %xmm4
484
 
        psrldq  $4, %xmm4       # rshift by 4 bytes: T1 = ([13],[14],[15],0)
485
 
#       pshufd  $0x4e, %xmm0, %xmm5     # 01001110=2,3,0,1 shuffle, ([2],[3],x,x)
486
 
#       punpcklqdq %xmm1, %xmm5 # T2 = W4[0..63]:T2[0..63] = ([2],[3],[4],[5])
487
 
# same result as above, but shorter and faster:
488
 
# pshufd/shufps are subtly different: pshufd takes all dwords from source operand,
489
 
# shufps takes dwords 0,1 from *2nd* operand, and dwords 2,3 from 1st one!
490
 
        movaps  %xmm0, %xmm5
491
 
        shufps  $0x4e, %xmm1, %xmm5     # 01001110=(T2.dw[2], T2.dw[3], W4.dw[0], W4.dw[1]) = ([2],[3],[4],[5])
492
 
        xorps   %xmm2, %xmm0    # ([8],[9],[10],[11]) ^ ([0],[1],[2],[3])
493
 
        xorps   %xmm4, %xmm5    # ([13],[14],[15],0) ^ ([2],[3],[4],[5])
494
 
        xorps   %xmm5, %xmm0    # ^
495
 
        # W0 = unrotated (W[0]..W[3]), still needs W[3] fixup
496
 
        movaps  %xmm0, %xmm5
497
 
        xorps   %xmm4, %xmm4    # rol(W0,1):
498
 
        pcmpgtd %xmm0, %xmm4    #  ffffffff for elements <0 (ones with msb bit 1)
499
 
        paddd   %xmm0, %xmm0    #  shift left by 1
500
 
        psubd   %xmm4, %xmm0    #  add 1 to those who had msb bit 1
501
 
        # W0 = rotated (W[0]..W[3]), still needs W[3] fixup
502
 
        pslldq  $12, %xmm5      # lshift by 12 bytes: T2 = (0,0,0,unrotW[0])
503
 
        movaps  %xmm5, %xmm4
504
 
        pslld   $2, %xmm5
505
 
        psrld   $30, %xmm4
506
 
#       xorps   %xmm4, %xmm5    # rol((0,0,0,unrotW[0]),2)
507
 
        xorps   %xmm4, %xmm0    # same result, but does not depend on/does not modify T2
508
 
        xorps   %xmm5, %xmm0    # W0 = rol(W[0]..W[3],1) ^ (0,0,0,rol(unrotW[0],2))
509
 
        movaps  %xmm0, %xmm5
510
 
        paddd   %xmm6, %xmm5
511
 
        movups  %xmm5, -64+16*0(%rsp)
512
 
# 24
513
 
        movl    %edx, %edi              # c
514
 
        xorl    %ebp, %edi              # ^d
515
 
        xorl    %ecx, %edi              # ^b
516
 
        addl    -64+4*8(%rsp), %eax     # e += RCONST + W[n & 15]
517
 
        addl    %edi, %eax              # e += (c ^ d ^ b)
518
 
        movl    %ebx, %esi              #
519
 
        roll    $5, %esi                # rotl32(a,5)
520
 
        addl    %esi, %eax              # e += rotl32(a,5)
521
 
        rorl    $2, %ecx                # b = rotl32(b,30)
522
 
# 25
523
 
        movl    %ecx, %edi              # c
524
 
        xorl    %edx, %edi              # ^d
525
 
        xorl    %ebx, %edi              # ^b
526
 
        addl    -64+4*9(%rsp), %ebp     # e += RCONST + W[n & 15]
527
 
        addl    %edi, %ebp              # e += (c ^ d ^ b)
528
 
        movl    %eax, %esi              #
529
 
        roll    $5, %esi                # rotl32(a,5)
530
 
        addl    %esi, %ebp              # e += rotl32(a,5)
531
 
        rorl    $2, %ebx                # b = rotl32(b,30)
532
 
# 26
533
 
        movl    %ebx, %edi              # c
534
 
        xorl    %ecx, %edi              # ^d
535
 
        xorl    %eax, %edi              # ^b
536
 
        addl    -64+4*10(%rsp), %edx    # e += RCONST + W[n & 15]
537
 
        addl    %edi, %edx              # e += (c ^ d ^ b)
538
 
        movl    %ebp, %esi              #
539
 
        roll    $5, %esi                # rotl32(a,5)
540
 
        addl    %esi, %edx              # e += rotl32(a,5)
541
 
        rorl    $2, %eax                # b = rotl32(b,30)
542
 
# 27
543
 
        movl    %eax, %edi              # c
544
 
        xorl    %ebx, %edi              # ^d
545
 
        xorl    %ebp, %edi              # ^b
546
 
        addl    -64+4*11(%rsp), %ecx    # e += RCONST + W[n & 15]
547
 
        addl    %edi, %ecx              # e += (c ^ d ^ b)
548
 
        movl    %edx, %esi              #
549
 
        roll    $5, %esi                # rotl32(a,5)
550
 
        addl    %esi, %ecx              # e += rotl32(a,5)
551
 
        rorl    $2, %ebp                # b = rotl32(b,30)
552
 
# PREP %xmm1 %xmm2 %xmm3 %xmm0 -64+16*1(%rsp)
553
 
        movaps  %xmm0, %xmm4
554
 
        psrldq  $4, %xmm4       # rshift by 4 bytes: T1 = ([13],[14],[15],0)
555
 
#       pshufd  $0x4e, %xmm1, %xmm5     # 01001110=2,3,0,1 shuffle, ([2],[3],x,x)
556
 
#       punpcklqdq %xmm2, %xmm5 # T2 = W4[0..63]:T2[0..63] = ([2],[3],[4],[5])
557
 
# same result as above, but shorter and faster:
558
 
# pshufd/shufps are subtly different: pshufd takes all dwords from source operand,
559
 
# shufps takes dwords 0,1 from *2nd* operand, and dwords 2,3 from 1st one!
560
 
        movaps  %xmm1, %xmm5
561
 
        shufps  $0x4e, %xmm2, %xmm5     # 01001110=(T2.dw[2], T2.dw[3], W4.dw[0], W4.dw[1]) = ([2],[3],[4],[5])
562
 
        xorps   %xmm3, %xmm1    # ([8],[9],[10],[11]) ^ ([0],[1],[2],[3])
563
 
        xorps   %xmm4, %xmm5    # ([13],[14],[15],0) ^ ([2],[3],[4],[5])
564
 
        xorps   %xmm5, %xmm1    # ^
565
 
        # W0 = unrotated (W[0]..W[3]), still needs W[3] fixup
566
 
        movaps  %xmm1, %xmm5
567
 
        xorps   %xmm4, %xmm4    # rol(W0,1):
568
 
        pcmpgtd %xmm1, %xmm4    #  ffffffff for elements <0 (ones with msb bit 1)
569
 
        paddd   %xmm1, %xmm1    #  shift left by 1
570
 
        psubd   %xmm4, %xmm1    #  add 1 to those who had msb bit 1
571
 
        # W0 = rotated (W[0]..W[3]), still needs W[3] fixup
572
 
        pslldq  $12, %xmm5      # lshift by 12 bytes: T2 = (0,0,0,unrotW[0])
573
 
        movaps  %xmm5, %xmm4
574
 
        pslld   $2, %xmm5
575
 
        psrld   $30, %xmm4
576
 
#       xorps   %xmm4, %xmm5    # rol((0,0,0,unrotW[0]),2)
577
 
        xorps   %xmm4, %xmm1    # same result, but does not depend on/does not modify T2
578
 
        xorps   %xmm5, %xmm1    # W0 = rol(W[0]..W[3],1) ^ (0,0,0,rol(unrotW[0],2))
579
 
        movaps  %xmm1, %xmm5
580
 
        paddd   %xmm6, %xmm5
581
 
        movups  %xmm5, -64+16*1(%rsp)
582
 
# 28
583
 
        movl    %ebp, %edi              # c
584
 
        xorl    %eax, %edi              # ^d
585
 
        xorl    %edx, %edi              # ^b
586
 
        addl    -64+4*12(%rsp), %ebx    # e += RCONST + W[n & 15]
587
 
        addl    %edi, %ebx              # e += (c ^ d ^ b)
588
 
        movl    %ecx, %esi              #
589
 
        roll    $5, %esi                # rotl32(a,5)
590
 
        addl    %esi, %ebx              # e += rotl32(a,5)
591
 
        rorl    $2, %edx                # b = rotl32(b,30)
592
 
# 29
593
 
        movl    %edx, %edi              # c
594
 
        xorl    %ebp, %edi              # ^d
595
 
        xorl    %ecx, %edi              # ^b
596
 
        addl    -64+4*13(%rsp), %eax    # e += RCONST + W[n & 15]
597
 
        addl    %edi, %eax              # e += (c ^ d ^ b)
598
 
        movl    %ebx, %esi              #
599
 
        roll    $5, %esi                # rotl32(a,5)
600
 
        addl    %esi, %eax              # e += rotl32(a,5)
601
 
        rorl    $2, %ecx                # b = rotl32(b,30)
602
 
# 30
603
 
        movl    %ecx, %edi              # c
604
 
        xorl    %edx, %edi              # ^d
605
 
        xorl    %ebx, %edi              # ^b
606
 
        addl    -64+4*14(%rsp), %ebp    # e += RCONST + W[n & 15]
607
 
        addl    %edi, %ebp              # e += (c ^ d ^ b)
608
 
        movl    %eax, %esi              #
609
 
        roll    $5, %esi                # rotl32(a,5)
610
 
        addl    %esi, %ebp              # e += rotl32(a,5)
611
 
        rorl    $2, %ebx                # b = rotl32(b,30)
612
 
# 31
613
 
        movl    %ebx, %edi              # c
614
 
        xorl    %ecx, %edi              # ^d
615
 
        xorl    %eax, %edi              # ^b
616
 
        addl    -64+4*15(%rsp), %edx    # e += RCONST + W[n & 15]
617
 
        addl    %edi, %edx              # e += (c ^ d ^ b)
618
 
        movl    %ebp, %esi              #
619
 
        roll    $5, %esi                # rotl32(a,5)
620
 
        addl    %esi, %edx              # e += rotl32(a,5)
621
 
        rorl    $2, %eax                # b = rotl32(b,30)
622
 
        pshufd  $0xaa, %xmm7, %xmm6
623
 
# PREP %xmm2 %xmm3 %xmm0 %xmm1 -64+16*2(%rsp)
624
 
        movaps  %xmm1, %xmm4
625
 
        psrldq  $4, %xmm4       # rshift by 4 bytes: T1 = ([13],[14],[15],0)
626
 
#       pshufd  $0x4e, %xmm2, %xmm5     # 01001110=2,3,0,1 shuffle, ([2],[3],x,x)
627
 
#       punpcklqdq %xmm3, %xmm5 # T2 = W4[0..63]:T2[0..63] = ([2],[3],[4],[5])
628
 
# same result as above, but shorter and faster:
629
 
# pshufd/shufps are subtly different: pshufd takes all dwords from source operand,
630
 
# shufps takes dwords 0,1 from *2nd* operand, and dwords 2,3 from 1st one!
631
 
        movaps  %xmm2, %xmm5
632
 
        shufps  $0x4e, %xmm3, %xmm5     # 01001110=(T2.dw[2], T2.dw[3], W4.dw[0], W4.dw[1]) = ([2],[3],[4],[5])
633
 
        xorps   %xmm0, %xmm2    # ([8],[9],[10],[11]) ^ ([0],[1],[2],[3])
634
 
        xorps   %xmm4, %xmm5    # ([13],[14],[15],0) ^ ([2],[3],[4],[5])
635
 
        xorps   %xmm5, %xmm2    # ^
636
 
        # W0 = unrotated (W[0]..W[3]), still needs W[3] fixup
637
 
        movaps  %xmm2, %xmm5
638
 
        xorps   %xmm4, %xmm4    # rol(W0,1):
639
 
        pcmpgtd %xmm2, %xmm4    #  ffffffff for elements <0 (ones with msb bit 1)
640
 
        paddd   %xmm2, %xmm2    #  shift left by 1
641
 
        psubd   %xmm4, %xmm2    #  add 1 to those who had msb bit 1
642
 
        # W0 = rotated (W[0]..W[3]), still needs W[3] fixup
643
 
        pslldq  $12, %xmm5      # lshift by 12 bytes: T2 = (0,0,0,unrotW[0])
644
 
        movaps  %xmm5, %xmm4
645
 
        pslld   $2, %xmm5
646
 
        psrld   $30, %xmm4
647
 
#       xorps   %xmm4, %xmm5    # rol((0,0,0,unrotW[0]),2)
648
 
        xorps   %xmm4, %xmm2    # same result, but does not depend on/does not modify T2
649
 
        xorps   %xmm5, %xmm2    # W0 = rol(W[0]..W[3],1) ^ (0,0,0,rol(unrotW[0],2))
650
 
        movaps  %xmm2, %xmm5
651
 
        paddd   %xmm6, %xmm5
652
 
        movups  %xmm5, -64+16*2(%rsp)
653
 
# 32
654
 
        movl    %eax, %edi              # c
655
 
        xorl    %ebx, %edi              # ^d
656
 
        xorl    %ebp, %edi              # ^b
657
 
        addl    -64+4*0(%rsp), %ecx     # e += RCONST + W[n & 15]
658
 
        addl    %edi, %ecx              # e += (c ^ d ^ b)
659
 
        movl    %edx, %esi              #
660
 
        roll    $5, %esi                # rotl32(a,5)
661
 
        addl    %esi, %ecx              # e += rotl32(a,5)
662
 
        rorl    $2, %ebp                # b = rotl32(b,30)
663
 
# 33
664
 
        movl    %ebp, %edi              # c
665
 
        xorl    %eax, %edi              # ^d
666
 
        xorl    %edx, %edi              # ^b
667
 
        addl    -64+4*1(%rsp), %ebx     # e += RCONST + W[n & 15]
668
 
        addl    %edi, %ebx              # e += (c ^ d ^ b)
669
 
        movl    %ecx, %esi              #
670
 
        roll    $5, %esi                # rotl32(a,5)
671
 
        addl    %esi, %ebx              # e += rotl32(a,5)
672
 
        rorl    $2, %edx                # b = rotl32(b,30)
673
 
# 34
674
 
        movl    %edx, %edi              # c
675
 
        xorl    %ebp, %edi              # ^d
676
 
        xorl    %ecx, %edi              # ^b
677
 
        addl    -64+4*2(%rsp), %eax     # e += RCONST + W[n & 15]
678
 
        addl    %edi, %eax              # e += (c ^ d ^ b)
679
 
        movl    %ebx, %esi              #
680
 
        roll    $5, %esi                # rotl32(a,5)
681
 
        addl    %esi, %eax              # e += rotl32(a,5)
682
 
        rorl    $2, %ecx                # b = rotl32(b,30)
683
 
# 35
684
 
        movl    %ecx, %edi              # c
685
 
        xorl    %edx, %edi              # ^d
686
 
        xorl    %ebx, %edi              # ^b
687
 
        addl    -64+4*3(%rsp), %ebp     # e += RCONST + W[n & 15]
688
 
        addl    %edi, %ebp              # e += (c ^ d ^ b)
689
 
        movl    %eax, %esi              #
690
 
        roll    $5, %esi                # rotl32(a,5)
691
 
        addl    %esi, %ebp              # e += rotl32(a,5)
692
 
        rorl    $2, %ebx                # b = rotl32(b,30)
693
 
# PREP %xmm3 %xmm0 %xmm1 %xmm2 -64+16*3(%rsp)
694
 
        movaps  %xmm2, %xmm4
695
 
        psrldq  $4, %xmm4       # rshift by 4 bytes: T1 = ([13],[14],[15],0)
696
 
#       pshufd  $0x4e, %xmm3, %xmm5     # 01001110=2,3,0,1 shuffle, ([2],[3],x,x)
697
 
#       punpcklqdq %xmm0, %xmm5 # T2 = W4[0..63]:T2[0..63] = ([2],[3],[4],[5])
698
 
# same result as above, but shorter and faster:
699
 
# pshufd/shufps are subtly different: pshufd takes all dwords from source operand,
700
 
# shufps takes dwords 0,1 from *2nd* operand, and dwords 2,3 from 1st one!
701
 
        movaps  %xmm3, %xmm5
702
 
        shufps  $0x4e, %xmm0, %xmm5     # 01001110=(T2.dw[2], T2.dw[3], W4.dw[0], W4.dw[1]) = ([2],[3],[4],[5])
703
 
        xorps   %xmm1, %xmm3    # ([8],[9],[10],[11]) ^ ([0],[1],[2],[3])
704
 
        xorps   %xmm4, %xmm5    # ([13],[14],[15],0) ^ ([2],[3],[4],[5])
705
 
        xorps   %xmm5, %xmm3    # ^
706
 
        # W0 = unrotated (W[0]..W[3]), still needs W[3] fixup
707
 
        movaps  %xmm3, %xmm5
708
 
        xorps   %xmm4, %xmm4    # rol(W0,1):
709
 
        pcmpgtd %xmm3, %xmm4    #  ffffffff for elements <0 (ones with msb bit 1)
710
 
        paddd   %xmm3, %xmm3    #  shift left by 1
711
 
        psubd   %xmm4, %xmm3    #  add 1 to those who had msb bit 1
712
 
        # W0 = rotated (W[0]..W[3]), still needs W[3] fixup
713
 
        pslldq  $12, %xmm5      # lshift by 12 bytes: T2 = (0,0,0,unrotW[0])
714
 
        movaps  %xmm5, %xmm4
715
 
        pslld   $2, %xmm5
716
 
        psrld   $30, %xmm4
717
 
#       xorps   %xmm4, %xmm5    # rol((0,0,0,unrotW[0]),2)
718
 
        xorps   %xmm4, %xmm3    # same result, but does not depend on/does not modify T2
719
 
        xorps   %xmm5, %xmm3    # W0 = rol(W[0]..W[3],1) ^ (0,0,0,rol(unrotW[0],2))
720
 
        movaps  %xmm3, %xmm5
721
 
        paddd   %xmm6, %xmm5
722
 
        movups  %xmm5, -64+16*3(%rsp)
723
 
# 36
724
 
        movl    %ebx, %edi              # c
725
 
        xorl    %ecx, %edi              # ^d
726
 
        xorl    %eax, %edi              # ^b
727
 
        addl    -64+4*4(%rsp), %edx     # e += RCONST + W[n & 15]
728
 
        addl    %edi, %edx              # e += (c ^ d ^ b)
729
 
        movl    %ebp, %esi              #
730
 
        roll    $5, %esi                # rotl32(a,5)
731
 
        addl    %esi, %edx              # e += rotl32(a,5)
732
 
        rorl    $2, %eax                # b = rotl32(b,30)
733
 
# 37
734
 
        movl    %eax, %edi              # c
735
 
        xorl    %ebx, %edi              # ^d
736
 
        xorl    %ebp, %edi              # ^b
737
 
        addl    -64+4*5(%rsp), %ecx     # e += RCONST + W[n & 15]
738
 
        addl    %edi, %ecx              # e += (c ^ d ^ b)
739
 
        movl    %edx, %esi              #
740
 
        roll    $5, %esi                # rotl32(a,5)
741
 
        addl    %esi, %ecx              # e += rotl32(a,5)
742
 
        rorl    $2, %ebp                # b = rotl32(b,30)
743
 
# 38
744
 
        movl    %ebp, %edi              # c
745
 
        xorl    %eax, %edi              # ^d
746
 
        xorl    %edx, %edi              # ^b
747
 
        addl    -64+4*6(%rsp), %ebx     # e += RCONST + W[n & 15]
748
 
        addl    %edi, %ebx              # e += (c ^ d ^ b)
749
 
        movl    %ecx, %esi              #
750
 
        roll    $5, %esi                # rotl32(a,5)
751
 
        addl    %esi, %ebx              # e += rotl32(a,5)
752
 
        rorl    $2, %edx                # b = rotl32(b,30)
753
 
# 39
754
 
        movl    %edx, %edi              # c
755
 
        xorl    %ebp, %edi              # ^d
756
 
        xorl    %ecx, %edi              # ^b
757
 
        addl    -64+4*7(%rsp), %eax     # e += RCONST + W[n & 15]
758
 
        addl    %edi, %eax              # e += (c ^ d ^ b)
759
 
        movl    %ebx, %esi              #
760
 
        roll    $5, %esi                # rotl32(a,5)
761
 
        addl    %esi, %eax              # e += rotl32(a,5)
762
 
        rorl    $2, %ecx                # b = rotl32(b,30)
763
 
# PREP %xmm0 %xmm1 %xmm2 %xmm3 -64+16*0(%rsp)
764
 
        movaps  %xmm3, %xmm4
765
 
        psrldq  $4, %xmm4       # rshift by 4 bytes: T1 = ([13],[14],[15],0)
766
 
#       pshufd  $0x4e, %xmm0, %xmm5     # 01001110=2,3,0,1 shuffle, ([2],[3],x,x)
767
 
#       punpcklqdq %xmm1, %xmm5 # T2 = W4[0..63]:T2[0..63] = ([2],[3],[4],[5])
768
 
# same result as above, but shorter and faster:
769
 
# pshufd/shufps are subtly different: pshufd takes all dwords from source operand,
770
 
# shufps takes dwords 0,1 from *2nd* operand, and dwords 2,3 from 1st one!
771
 
        movaps  %xmm0, %xmm5
772
 
        shufps  $0x4e, %xmm1, %xmm5     # 01001110=(T2.dw[2], T2.dw[3], W4.dw[0], W4.dw[1]) = ([2],[3],[4],[5])
773
 
        xorps   %xmm2, %xmm0    # ([8],[9],[10],[11]) ^ ([0],[1],[2],[3])
774
 
        xorps   %xmm4, %xmm5    # ([13],[14],[15],0) ^ ([2],[3],[4],[5])
775
 
        xorps   %xmm5, %xmm0    # ^
776
 
        # W0 = unrotated (W[0]..W[3]), still needs W[3] fixup
777
 
        movaps  %xmm0, %xmm5
778
 
        xorps   %xmm4, %xmm4    # rol(W0,1):
779
 
        pcmpgtd %xmm0, %xmm4    #  ffffffff for elements <0 (ones with msb bit 1)
780
 
        paddd   %xmm0, %xmm0    #  shift left by 1
781
 
        psubd   %xmm4, %xmm0    #  add 1 to those who had msb bit 1
782
 
        # W0 = rotated (W[0]..W[3]), still needs W[3] fixup
783
 
        pslldq  $12, %xmm5      # lshift by 12 bytes: T2 = (0,0,0,unrotW[0])
784
 
        movaps  %xmm5, %xmm4
785
 
        pslld   $2, %xmm5
786
 
        psrld   $30, %xmm4
787
 
#       xorps   %xmm4, %xmm5    # rol((0,0,0,unrotW[0]),2)
788
 
        xorps   %xmm4, %xmm0    # same result, but does not depend on/does not modify T2
789
 
        xorps   %xmm5, %xmm0    # W0 = rol(W[0]..W[3],1) ^ (0,0,0,rol(unrotW[0],2))
790
 
        movaps  %xmm0, %xmm5
791
 
        paddd   %xmm6, %xmm5
792
 
        movups  %xmm5, -64+16*0(%rsp)
793
 
# 40
794
 
        movl    %ebx, %edi              # di: b
795
 
        movl    %ebx, %esi              # si: b
796
 
        orl     %ecx, %edi              # di: b | c
797
 
        andl    %ecx, %esi              # si: b & c
798
 
        andl    %edx, %edi              # di: (b | c) & d
799
 
        orl     %esi, %edi              # ((b | c) & d) | (b & c)
800
 
        addl    %edi, %ebp              # += ((b | c) & d) | (b & c)
801
 
        addl    -64+4*8(%rsp), %ebp     # e += RCONST + W[n & 15]
802
 
        movl    %eax, %esi              #
803
 
        roll    $5, %esi                # rotl32(a,5)
804
 
        addl    %esi, %ebp              # e += rotl32(a,5)
805
 
        rorl    $2, %ebx                # b = rotl32(b,30)
806
 
# 41
807
 
        movl    %eax, %edi              # di: b
808
 
        movl    %eax, %esi              # si: b
809
 
        orl     %ebx, %edi              # di: b | c
810
 
        andl    %ebx, %esi              # si: b & c
811
 
        andl    %ecx, %edi              # di: (b | c) & d
812
 
        orl     %esi, %edi              # ((b | c) & d) | (b & c)
813
 
        addl    %edi, %edx              # += ((b | c) & d) | (b & c)
814
 
        addl    -64+4*9(%rsp), %edx     # e += RCONST + W[n & 15]
815
 
        movl    %ebp, %esi              #
816
 
        roll    $5, %esi                # rotl32(a,5)
817
 
        addl    %esi, %edx              # e += rotl32(a,5)
818
 
        rorl    $2, %eax                # b = rotl32(b,30)
819
 
# 42
820
 
        movl    %ebp, %edi              # di: b
821
 
        movl    %ebp, %esi              # si: b
822
 
        orl     %eax, %edi              # di: b | c
823
 
        andl    %eax, %esi              # si: b & c
824
 
        andl    %ebx, %edi              # di: (b | c) & d
825
 
        orl     %esi, %edi              # ((b | c) & d) | (b & c)
826
 
        addl    %edi, %ecx              # += ((b | c) & d) | (b & c)
827
 
        addl    -64+4*10(%rsp), %ecx    # e += RCONST + W[n & 15]
828
 
        movl    %edx, %esi              #
829
 
        roll    $5, %esi                # rotl32(a,5)
830
 
        addl    %esi, %ecx              # e += rotl32(a,5)
831
 
        rorl    $2, %ebp                # b = rotl32(b,30)
832
 
# 43
833
 
        movl    %edx, %edi              # di: b
834
 
        movl    %edx, %esi              # si: b
835
 
        orl     %ebp, %edi              # di: b | c
836
 
        andl    %ebp, %esi              # si: b & c
837
 
        andl    %eax, %edi              # di: (b | c) & d
838
 
        orl     %esi, %edi              # ((b | c) & d) | (b & c)
839
 
        addl    %edi, %ebx              # += ((b | c) & d) | (b & c)
840
 
        addl    -64+4*11(%rsp), %ebx    # e += RCONST + W[n & 15]
841
 
        movl    %ecx, %esi              #
842
 
        roll    $5, %esi                # rotl32(a,5)
843
 
        addl    %esi, %ebx              # e += rotl32(a,5)
844
 
        rorl    $2, %edx                # b = rotl32(b,30)
845
 
# PREP %xmm1 %xmm2 %xmm3 %xmm0 -64+16*1(%rsp)
846
 
        movaps  %xmm0, %xmm4
847
 
        psrldq  $4, %xmm4       # rshift by 4 bytes: T1 = ([13],[14],[15],0)
848
 
#       pshufd  $0x4e, %xmm1, %xmm5     # 01001110=2,3,0,1 shuffle, ([2],[3],x,x)
849
 
#       punpcklqdq %xmm2, %xmm5 # T2 = W4[0..63]:T2[0..63] = ([2],[3],[4],[5])
850
 
# same result as above, but shorter and faster:
851
 
# pshufd/shufps are subtly different: pshufd takes all dwords from source operand,
852
 
# shufps takes dwords 0,1 from *2nd* operand, and dwords 2,3 from 1st one!
853
 
        movaps  %xmm1, %xmm5
854
 
        shufps  $0x4e, %xmm2, %xmm5     # 01001110=(T2.dw[2], T2.dw[3], W4.dw[0], W4.dw[1]) = ([2],[3],[4],[5])
855
 
        xorps   %xmm3, %xmm1    # ([8],[9],[10],[11]) ^ ([0],[1],[2],[3])
856
 
        xorps   %xmm4, %xmm5    # ([13],[14],[15],0) ^ ([2],[3],[4],[5])
857
 
        xorps   %xmm5, %xmm1    # ^
858
 
        # W0 = unrotated (W[0]..W[3]), still needs W[3] fixup
859
 
        movaps  %xmm1, %xmm5
860
 
        xorps   %xmm4, %xmm4    # rol(W0,1):
861
 
        pcmpgtd %xmm1, %xmm4    #  ffffffff for elements <0 (ones with msb bit 1)
862
 
        paddd   %xmm1, %xmm1    #  shift left by 1
863
 
        psubd   %xmm4, %xmm1    #  add 1 to those who had msb bit 1
864
 
        # W0 = rotated (W[0]..W[3]), still needs W[3] fixup
865
 
        pslldq  $12, %xmm5      # lshift by 12 bytes: T2 = (0,0,0,unrotW[0])
866
 
        movaps  %xmm5, %xmm4
867
 
        pslld   $2, %xmm5
868
 
        psrld   $30, %xmm4
869
 
#       xorps   %xmm4, %xmm5    # rol((0,0,0,unrotW[0]),2)
870
 
        xorps   %xmm4, %xmm1    # same result, but does not depend on/does not modify T2
871
 
        xorps   %xmm5, %xmm1    # W0 = rol(W[0]..W[3],1) ^ (0,0,0,rol(unrotW[0],2))
872
 
        movaps  %xmm1, %xmm5
873
 
        paddd   %xmm6, %xmm5
874
 
        movups  %xmm5, -64+16*1(%rsp)
875
 
# 44
876
 
        movl    %ecx, %edi              # di: b
877
 
        movl    %ecx, %esi              # si: b
878
 
        orl     %edx, %edi              # di: b | c
879
 
        andl    %edx, %esi              # si: b & c
880
 
        andl    %ebp, %edi              # di: (b | c) & d
881
 
        orl     %esi, %edi              # ((b | c) & d) | (b & c)
882
 
        addl    %edi, %eax              # += ((b | c) & d) | (b & c)
883
 
        addl    -64+4*12(%rsp), %eax    # e += RCONST + W[n & 15]
884
 
        movl    %ebx, %esi              #
885
 
        roll    $5, %esi                # rotl32(a,5)
886
 
        addl    %esi, %eax              # e += rotl32(a,5)
887
 
        rorl    $2, %ecx                # b = rotl32(b,30)
888
 
# 45
889
 
        movl    %ebx, %edi              # di: b
890
 
        movl    %ebx, %esi              # si: b
891
 
        orl     %ecx, %edi              # di: b | c
892
 
        andl    %ecx, %esi              # si: b & c
893
 
        andl    %edx, %edi              # di: (b | c) & d
894
 
        orl     %esi, %edi              # ((b | c) & d) | (b & c)
895
 
        addl    %edi, %ebp              # += ((b | c) & d) | (b & c)
896
 
        addl    -64+4*13(%rsp), %ebp    # e += RCONST + W[n & 15]
897
 
        movl    %eax, %esi              #
898
 
        roll    $5, %esi                # rotl32(a,5)
899
 
        addl    %esi, %ebp              # e += rotl32(a,5)
900
 
        rorl    $2, %ebx                # b = rotl32(b,30)
901
 
# 46
902
 
        movl    %eax, %edi              # di: b
903
 
        movl    %eax, %esi              # si: b
904
 
        orl     %ebx, %edi              # di: b | c
905
 
        andl    %ebx, %esi              # si: b & c
906
 
        andl    %ecx, %edi              # di: (b | c) & d
907
 
        orl     %esi, %edi              # ((b | c) & d) | (b & c)
908
 
        addl    %edi, %edx              # += ((b | c) & d) | (b & c)
909
 
        addl    -64+4*14(%rsp), %edx    # e += RCONST + W[n & 15]
910
 
        movl    %ebp, %esi              #
911
 
        roll    $5, %esi                # rotl32(a,5)
912
 
        addl    %esi, %edx              # e += rotl32(a,5)
913
 
        rorl    $2, %eax                # b = rotl32(b,30)
914
 
# 47
915
 
        movl    %ebp, %edi              # di: b
916
 
        movl    %ebp, %esi              # si: b
917
 
        orl     %eax, %edi              # di: b | c
918
 
        andl    %eax, %esi              # si: b & c
919
 
        andl    %ebx, %edi              # di: (b | c) & d
920
 
        orl     %esi, %edi              # ((b | c) & d) | (b & c)
921
 
        addl    %edi, %ecx              # += ((b | c) & d) | (b & c)
922
 
        addl    -64+4*15(%rsp), %ecx    # e += RCONST + W[n & 15]
923
 
        movl    %edx, %esi              #
924
 
        roll    $5, %esi                # rotl32(a,5)
925
 
        addl    %esi, %ecx              # e += rotl32(a,5)
926
 
        rorl    $2, %ebp                # b = rotl32(b,30)
927
 
# PREP %xmm2 %xmm3 %xmm0 %xmm1 -64+16*2(%rsp)
928
 
        movaps  %xmm1, %xmm4
929
 
        psrldq  $4, %xmm4       # rshift by 4 bytes: T1 = ([13],[14],[15],0)
930
 
#       pshufd  $0x4e, %xmm2, %xmm5     # 01001110=2,3,0,1 shuffle, ([2],[3],x,x)
931
 
#       punpcklqdq %xmm3, %xmm5 # T2 = W4[0..63]:T2[0..63] = ([2],[3],[4],[5])
932
 
# same result as above, but shorter and faster:
933
 
# pshufd/shufps are subtly different: pshufd takes all dwords from source operand,
934
 
# shufps takes dwords 0,1 from *2nd* operand, and dwords 2,3 from 1st one!
935
 
        movaps  %xmm2, %xmm5
936
 
        shufps  $0x4e, %xmm3, %xmm5     # 01001110=(T2.dw[2], T2.dw[3], W4.dw[0], W4.dw[1]) = ([2],[3],[4],[5])
937
 
        xorps   %xmm0, %xmm2    # ([8],[9],[10],[11]) ^ ([0],[1],[2],[3])
938
 
        xorps   %xmm4, %xmm5    # ([13],[14],[15],0) ^ ([2],[3],[4],[5])
939
 
        xorps   %xmm5, %xmm2    # ^
940
 
        # W0 = unrotated (W[0]..W[3]), still needs W[3] fixup
941
 
        movaps  %xmm2, %xmm5
942
 
        xorps   %xmm4, %xmm4    # rol(W0,1):
943
 
        pcmpgtd %xmm2, %xmm4    #  ffffffff for elements <0 (ones with msb bit 1)
944
 
        paddd   %xmm2, %xmm2    #  shift left by 1
945
 
        psubd   %xmm4, %xmm2    #  add 1 to those who had msb bit 1
946
 
        # W0 = rotated (W[0]..W[3]), still needs W[3] fixup
947
 
        pslldq  $12, %xmm5      # lshift by 12 bytes: T2 = (0,0,0,unrotW[0])
948
 
        movaps  %xmm5, %xmm4
949
 
        pslld   $2, %xmm5
950
 
        psrld   $30, %xmm4
951
 
#       xorps   %xmm4, %xmm5    # rol((0,0,0,unrotW[0]),2)
952
 
        xorps   %xmm4, %xmm2    # same result, but does not depend on/does not modify T2
953
 
        xorps   %xmm5, %xmm2    # W0 = rol(W[0]..W[3],1) ^ (0,0,0,rol(unrotW[0],2))
954
 
        movaps  %xmm2, %xmm5
955
 
        paddd   %xmm6, %xmm5
956
 
        movups  %xmm5, -64+16*2(%rsp)
957
 
# 48
958
 
        movl    %edx, %edi              # di: b
959
 
        movl    %edx, %esi              # si: b
960
 
        orl     %ebp, %edi              # di: b | c
961
 
        andl    %ebp, %esi              # si: b & c
962
 
        andl    %eax, %edi              # di: (b | c) & d
963
 
        orl     %esi, %edi              # ((b | c) & d) | (b & c)
964
 
        addl    %edi, %ebx              # += ((b | c) & d) | (b & c)
965
 
        addl    -64+4*0(%rsp), %ebx     # e += RCONST + W[n & 15]
966
 
        movl    %ecx, %esi              #
967
 
        roll    $5, %esi                # rotl32(a,5)
968
 
        addl    %esi, %ebx              # e += rotl32(a,5)
969
 
        rorl    $2, %edx                # b = rotl32(b,30)
970
 
# 49
971
 
        movl    %ecx, %edi              # di: b
972
 
        movl    %ecx, %esi              # si: b
973
 
        orl     %edx, %edi              # di: b | c
974
 
        andl    %edx, %esi              # si: b & c
975
 
        andl    %ebp, %edi              # di: (b | c) & d
976
 
        orl     %esi, %edi              # ((b | c) & d) | (b & c)
977
 
        addl    %edi, %eax              # += ((b | c) & d) | (b & c)
978
 
        addl    -64+4*1(%rsp), %eax     # e += RCONST + W[n & 15]
979
 
        movl    %ebx, %esi              #
980
 
        roll    $5, %esi                # rotl32(a,5)
981
 
        addl    %esi, %eax              # e += rotl32(a,5)
982
 
        rorl    $2, %ecx                # b = rotl32(b,30)
983
 
# 50
984
 
        movl    %ebx, %edi              # di: b
985
 
        movl    %ebx, %esi              # si: b
986
 
        orl     %ecx, %edi              # di: b | c
987
 
        andl    %ecx, %esi              # si: b & c
988
 
        andl    %edx, %edi              # di: (b | c) & d
989
 
        orl     %esi, %edi              # ((b | c) & d) | (b & c)
990
 
        addl    %edi, %ebp              # += ((b | c) & d) | (b & c)
991
 
        addl    -64+4*2(%rsp), %ebp     # e += RCONST + W[n & 15]
992
 
        movl    %eax, %esi              #
993
 
        roll    $5, %esi                # rotl32(a,5)
994
 
        addl    %esi, %ebp              # e += rotl32(a,5)
995
 
        rorl    $2, %ebx                # b = rotl32(b,30)
996
 
# 51
997
 
        movl    %eax, %edi              # di: b
998
 
        movl    %eax, %esi              # si: b
999
 
        orl     %ebx, %edi              # di: b | c
1000
 
        andl    %ebx, %esi              # si: b & c
1001
 
        andl    %ecx, %edi              # di: (b | c) & d
1002
 
        orl     %esi, %edi              # ((b | c) & d) | (b & c)
1003
 
        addl    %edi, %edx              # += ((b | c) & d) | (b & c)
1004
 
        addl    -64+4*3(%rsp), %edx     # e += RCONST + W[n & 15]
1005
 
        movl    %ebp, %esi              #
1006
 
        roll    $5, %esi                # rotl32(a,5)
1007
 
        addl    %esi, %edx              # e += rotl32(a,5)
1008
 
        rorl    $2, %eax                # b = rotl32(b,30)
1009
 
        pshufd  $0xff, %xmm7, %xmm6
1010
 
# PREP %xmm3 %xmm0 %xmm1 %xmm2 -64+16*3(%rsp)
1011
 
        movaps  %xmm2, %xmm4
1012
 
        psrldq  $4, %xmm4       # rshift by 4 bytes: T1 = ([13],[14],[15],0)
1013
 
#       pshufd  $0x4e, %xmm3, %xmm5     # 01001110=2,3,0,1 shuffle, ([2],[3],x,x)
1014
 
#       punpcklqdq %xmm0, %xmm5 # T2 = W4[0..63]:T2[0..63] = ([2],[3],[4],[5])
1015
 
# same result as above, but shorter and faster:
1016
 
# pshufd/shufps are subtly different: pshufd takes all dwords from source operand,
1017
 
# shufps takes dwords 0,1 from *2nd* operand, and dwords 2,3 from 1st one!
1018
 
        movaps  %xmm3, %xmm5
1019
 
        shufps  $0x4e, %xmm0, %xmm5     # 01001110=(T2.dw[2], T2.dw[3], W4.dw[0], W4.dw[1]) = ([2],[3],[4],[5])
1020
 
        xorps   %xmm1, %xmm3    # ([8],[9],[10],[11]) ^ ([0],[1],[2],[3])
1021
 
        xorps   %xmm4, %xmm5    # ([13],[14],[15],0) ^ ([2],[3],[4],[5])
1022
 
        xorps   %xmm5, %xmm3    # ^
1023
 
        # W0 = unrotated (W[0]..W[3]), still needs W[3] fixup
1024
 
        movaps  %xmm3, %xmm5
1025
 
        xorps   %xmm4, %xmm4    # rol(W0,1):
1026
 
        pcmpgtd %xmm3, %xmm4    #  ffffffff for elements <0 (ones with msb bit 1)
1027
 
        paddd   %xmm3, %xmm3    #  shift left by 1
1028
 
        psubd   %xmm4, %xmm3    #  add 1 to those who had msb bit 1
1029
 
        # W0 = rotated (W[0]..W[3]), still needs W[3] fixup
1030
 
        pslldq  $12, %xmm5      # lshift by 12 bytes: T2 = (0,0,0,unrotW[0])
1031
 
        movaps  %xmm5, %xmm4
1032
 
        pslld   $2, %xmm5
1033
 
        psrld   $30, %xmm4
1034
 
#       xorps   %xmm4, %xmm5    # rol((0,0,0,unrotW[0]),2)
1035
 
        xorps   %xmm4, %xmm3    # same result, but does not depend on/does not modify T2
1036
 
        xorps   %xmm5, %xmm3    # W0 = rol(W[0]..W[3],1) ^ (0,0,0,rol(unrotW[0],2))
1037
 
        movaps  %xmm3, %xmm5
1038
 
        paddd   %xmm6, %xmm5
1039
 
        movups  %xmm5, -64+16*3(%rsp)
1040
 
# 52
1041
 
        movl    %ebp, %edi              # di: b
1042
 
        movl    %ebp, %esi              # si: b
1043
 
        orl     %eax, %edi              # di: b | c
1044
 
        andl    %eax, %esi              # si: b & c
1045
 
        andl    %ebx, %edi              # di: (b | c) & d
1046
 
        orl     %esi, %edi              # ((b | c) & d) | (b & c)
1047
 
        addl    %edi, %ecx              # += ((b | c) & d) | (b & c)
1048
 
        addl    -64+4*4(%rsp), %ecx     # e += RCONST + W[n & 15]
1049
 
        movl    %edx, %esi              #
1050
 
        roll    $5, %esi                # rotl32(a,5)
1051
 
        addl    %esi, %ecx              # e += rotl32(a,5)
1052
 
        rorl    $2, %ebp                # b = rotl32(b,30)
1053
 
# 53
1054
 
        movl    %edx, %edi              # di: b
1055
 
        movl    %edx, %esi              # si: b
1056
 
        orl     %ebp, %edi              # di: b | c
1057
 
        andl    %ebp, %esi              # si: b & c
1058
 
        andl    %eax, %edi              # di: (b | c) & d
1059
 
        orl     %esi, %edi              # ((b | c) & d) | (b & c)
1060
 
        addl    %edi, %ebx              # += ((b | c) & d) | (b & c)
1061
 
        addl    -64+4*5(%rsp), %ebx     # e += RCONST + W[n & 15]
1062
 
        movl    %ecx, %esi              #
1063
 
        roll    $5, %esi                # rotl32(a,5)
1064
 
        addl    %esi, %ebx              # e += rotl32(a,5)
1065
 
        rorl    $2, %edx                # b = rotl32(b,30)
1066
 
# 54
1067
 
        movl    %ecx, %edi              # di: b
1068
 
        movl    %ecx, %esi              # si: b
1069
 
        orl     %edx, %edi              # di: b | c
1070
 
        andl    %edx, %esi              # si: b & c
1071
 
        andl    %ebp, %edi              # di: (b | c) & d
1072
 
        orl     %esi, %edi              # ((b | c) & d) | (b & c)
1073
 
        addl    %edi, %eax              # += ((b | c) & d) | (b & c)
1074
 
        addl    -64+4*6(%rsp), %eax     # e += RCONST + W[n & 15]
1075
 
        movl    %ebx, %esi              #
1076
 
        roll    $5, %esi                # rotl32(a,5)
1077
 
        addl    %esi, %eax              # e += rotl32(a,5)
1078
 
        rorl    $2, %ecx                # b = rotl32(b,30)
1079
 
# 55
1080
 
        movl    %ebx, %edi              # di: b
1081
 
        movl    %ebx, %esi              # si: b
1082
 
        orl     %ecx, %edi              # di: b | c
1083
 
        andl    %ecx, %esi              # si: b & c
1084
 
        andl    %edx, %edi              # di: (b | c) & d
1085
 
        orl     %esi, %edi              # ((b | c) & d) | (b & c)
1086
 
        addl    %edi, %ebp              # += ((b | c) & d) | (b & c)
1087
 
        addl    -64+4*7(%rsp), %ebp     # e += RCONST + W[n & 15]
1088
 
        movl    %eax, %esi              #
1089
 
        roll    $5, %esi                # rotl32(a,5)
1090
 
        addl    %esi, %ebp              # e += rotl32(a,5)
1091
 
        rorl    $2, %ebx                # b = rotl32(b,30)
1092
 
# PREP %xmm0 %xmm1 %xmm2 %xmm3 -64+16*0(%rsp)
1093
 
        movaps  %xmm3, %xmm4
1094
 
        psrldq  $4, %xmm4       # rshift by 4 bytes: T1 = ([13],[14],[15],0)
1095
 
#       pshufd  $0x4e, %xmm0, %xmm5     # 01001110=2,3,0,1 shuffle, ([2],[3],x,x)
1096
 
#       punpcklqdq %xmm1, %xmm5 # T2 = W4[0..63]:T2[0..63] = ([2],[3],[4],[5])
1097
 
# same result as above, but shorter and faster:
1098
 
# pshufd/shufps are subtly different: pshufd takes all dwords from source operand,
1099
 
# shufps takes dwords 0,1 from *2nd* operand, and dwords 2,3 from 1st one!
1100
 
        movaps  %xmm0, %xmm5
1101
 
        shufps  $0x4e, %xmm1, %xmm5     # 01001110=(T2.dw[2], T2.dw[3], W4.dw[0], W4.dw[1]) = ([2],[3],[4],[5])
1102
 
        xorps   %xmm2, %xmm0    # ([8],[9],[10],[11]) ^ ([0],[1],[2],[3])
1103
 
        xorps   %xmm4, %xmm5    # ([13],[14],[15],0) ^ ([2],[3],[4],[5])
1104
 
        xorps   %xmm5, %xmm0    # ^
1105
 
        # W0 = unrotated (W[0]..W[3]), still needs W[3] fixup
1106
 
        movaps  %xmm0, %xmm5
1107
 
        xorps   %xmm4, %xmm4    # rol(W0,1):
1108
 
        pcmpgtd %xmm0, %xmm4    #  ffffffff for elements <0 (ones with msb bit 1)
1109
 
        paddd   %xmm0, %xmm0    #  shift left by 1
1110
 
        psubd   %xmm4, %xmm0    #  add 1 to those who had msb bit 1
1111
 
        # W0 = rotated (W[0]..W[3]), still needs W[3] fixup
1112
 
        pslldq  $12, %xmm5      # lshift by 12 bytes: T2 = (0,0,0,unrotW[0])
1113
 
        movaps  %xmm5, %xmm4
1114
 
        pslld   $2, %xmm5
1115
 
        psrld   $30, %xmm4
1116
 
#       xorps   %xmm4, %xmm5    # rol((0,0,0,unrotW[0]),2)
1117
 
        xorps   %xmm4, %xmm0    # same result, but does not depend on/does not modify T2
1118
 
        xorps   %xmm5, %xmm0    # W0 = rol(W[0]..W[3],1) ^ (0,0,0,rol(unrotW[0],2))
1119
 
        movaps  %xmm0, %xmm5
1120
 
        paddd   %xmm6, %xmm5
1121
 
        movups  %xmm5, -64+16*0(%rsp)
1122
 
# 56
1123
 
        movl    %eax, %edi              # di: b
1124
 
        movl    %eax, %esi              # si: b
1125
 
        orl     %ebx, %edi              # di: b | c
1126
 
        andl    %ebx, %esi              # si: b & c
1127
 
        andl    %ecx, %edi              # di: (b | c) & d
1128
 
        orl     %esi, %edi              # ((b | c) & d) | (b & c)
1129
 
        addl    %edi, %edx              # += ((b | c) & d) | (b & c)
1130
 
        addl    -64+4*8(%rsp), %edx     # e += RCONST + W[n & 15]
1131
 
        movl    %ebp, %esi              #
1132
 
        roll    $5, %esi                # rotl32(a,5)
1133
 
        addl    %esi, %edx              # e += rotl32(a,5)
1134
 
        rorl    $2, %eax                # b = rotl32(b,30)
1135
 
# 57
1136
 
        movl    %ebp, %edi              # di: b
1137
 
        movl    %ebp, %esi              # si: b
1138
 
        orl     %eax, %edi              # di: b | c
1139
 
        andl    %eax, %esi              # si: b & c
1140
 
        andl    %ebx, %edi              # di: (b | c) & d
1141
 
        orl     %esi, %edi              # ((b | c) & d) | (b & c)
1142
 
        addl    %edi, %ecx              # += ((b | c) & d) | (b & c)
1143
 
        addl    -64+4*9(%rsp), %ecx     # e += RCONST + W[n & 15]
1144
 
        movl    %edx, %esi              #
1145
 
        roll    $5, %esi                # rotl32(a,5)
1146
 
        addl    %esi, %ecx              # e += rotl32(a,5)
1147
 
        rorl    $2, %ebp                # b = rotl32(b,30)
1148
 
# 58
1149
 
        movl    %edx, %edi              # di: b
1150
 
        movl    %edx, %esi              # si: b
1151
 
        orl     %ebp, %edi              # di: b | c
1152
 
        andl    %ebp, %esi              # si: b & c
1153
 
        andl    %eax, %edi              # di: (b | c) & d
1154
 
        orl     %esi, %edi              # ((b | c) & d) | (b & c)
1155
 
        addl    %edi, %ebx              # += ((b | c) & d) | (b & c)
1156
 
        addl    -64+4*10(%rsp), %ebx    # e += RCONST + W[n & 15]
1157
 
        movl    %ecx, %esi              #
1158
 
        roll    $5, %esi                # rotl32(a,5)
1159
 
        addl    %esi, %ebx              # e += rotl32(a,5)
1160
 
        rorl    $2, %edx                # b = rotl32(b,30)
1161
 
# 59
1162
 
        movl    %ecx, %edi              # di: b
1163
 
        movl    %ecx, %esi              # si: b
1164
 
        orl     %edx, %edi              # di: b | c
1165
 
        andl    %edx, %esi              # si: b & c
1166
 
        andl    %ebp, %edi              # di: (b | c) & d
1167
 
        orl     %esi, %edi              # ((b | c) & d) | (b & c)
1168
 
        addl    %edi, %eax              # += ((b | c) & d) | (b & c)
1169
 
        addl    -64+4*11(%rsp), %eax    # e += RCONST + W[n & 15]
1170
 
        movl    %ebx, %esi              #
1171
 
        roll    $5, %esi                # rotl32(a,5)
1172
 
        addl    %esi, %eax              # e += rotl32(a,5)
1173
 
        rorl    $2, %ecx                # b = rotl32(b,30)
1174
 
# PREP %xmm1 %xmm2 %xmm3 %xmm0 -64+16*1(%rsp)
1175
 
        movaps  %xmm0, %xmm4
1176
 
        psrldq  $4, %xmm4       # rshift by 4 bytes: T1 = ([13],[14],[15],0)
1177
 
#       pshufd  $0x4e, %xmm1, %xmm5     # 01001110=2,3,0,1 shuffle, ([2],[3],x,x)
1178
 
#       punpcklqdq %xmm2, %xmm5 # T2 = W4[0..63]:T2[0..63] = ([2],[3],[4],[5])
1179
 
# same result as above, but shorter and faster:
1180
 
# pshufd/shufps are subtly different: pshufd takes all dwords from source operand,
1181
 
# shufps takes dwords 0,1 from *2nd* operand, and dwords 2,3 from 1st one!
1182
 
        movaps  %xmm1, %xmm5
1183
 
        shufps  $0x4e, %xmm2, %xmm5     # 01001110=(T2.dw[2], T2.dw[3], W4.dw[0], W4.dw[1]) = ([2],[3],[4],[5])
1184
 
        xorps   %xmm3, %xmm1    # ([8],[9],[10],[11]) ^ ([0],[1],[2],[3])
1185
 
        xorps   %xmm4, %xmm5    # ([13],[14],[15],0) ^ ([2],[3],[4],[5])
1186
 
        xorps   %xmm5, %xmm1    # ^
1187
 
        # W0 = unrotated (W[0]..W[3]), still needs W[3] fixup
1188
 
        movaps  %xmm1, %xmm5
1189
 
        xorps   %xmm4, %xmm4    # rol(W0,1):
1190
 
        pcmpgtd %xmm1, %xmm4    #  ffffffff for elements <0 (ones with msb bit 1)
1191
 
        paddd   %xmm1, %xmm1    #  shift left by 1
1192
 
        psubd   %xmm4, %xmm1    #  add 1 to those who had msb bit 1
1193
 
        # W0 = rotated (W[0]..W[3]), still needs W[3] fixup
1194
 
        pslldq  $12, %xmm5      # lshift by 12 bytes: T2 = (0,0,0,unrotW[0])
1195
 
        movaps  %xmm5, %xmm4
1196
 
        pslld   $2, %xmm5
1197
 
        psrld   $30, %xmm4
1198
 
#       xorps   %xmm4, %xmm5    # rol((0,0,0,unrotW[0]),2)
1199
 
        xorps   %xmm4, %xmm1    # same result, but does not depend on/does not modify T2
1200
 
        xorps   %xmm5, %xmm1    # W0 = rol(W[0]..W[3],1) ^ (0,0,0,rol(unrotW[0],2))
1201
 
        movaps  %xmm1, %xmm5
1202
 
        paddd   %xmm6, %xmm5
1203
 
        movups  %xmm5, -64+16*1(%rsp)
1204
 
# 60
1205
 
        movl    %ecx, %edi              # c
1206
 
        xorl    %edx, %edi              # ^d
1207
 
        xorl    %ebx, %edi              # ^b
1208
 
        addl    -64+4*12(%rsp), %ebp    # e += RCONST + W[n & 15]
1209
 
        addl    %edi, %ebp              # e += (c ^ d ^ b)
1210
 
        movl    %eax, %esi              #
1211
 
        roll    $5, %esi                # rotl32(a,5)
1212
 
        addl    %esi, %ebp              # e += rotl32(a,5)
1213
 
        rorl    $2, %ebx                # b = rotl32(b,30)
1214
 
# 61
1215
 
        movl    %ebx, %edi              # c
1216
 
        xorl    %ecx, %edi              # ^d
1217
 
        xorl    %eax, %edi              # ^b
1218
 
        addl    -64+4*13(%rsp), %edx    # e += RCONST + W[n & 15]
1219
 
        addl    %edi, %edx              # e += (c ^ d ^ b)
1220
 
        movl    %ebp, %esi              #
1221
 
        roll    $5, %esi                # rotl32(a,5)
1222
 
        addl    %esi, %edx              # e += rotl32(a,5)
1223
 
        rorl    $2, %eax                # b = rotl32(b,30)
1224
 
# 62
1225
 
        movl    %eax, %edi              # c
1226
 
        xorl    %ebx, %edi              # ^d
1227
 
        xorl    %ebp, %edi              # ^b
1228
 
        addl    -64+4*14(%rsp), %ecx    # e += RCONST + W[n & 15]
1229
 
        addl    %edi, %ecx              # e += (c ^ d ^ b)
1230
 
        movl    %edx, %esi              #
1231
 
        roll    $5, %esi                # rotl32(a,5)
1232
 
        addl    %esi, %ecx              # e += rotl32(a,5)
1233
 
        rorl    $2, %ebp                # b = rotl32(b,30)
1234
 
# 63
1235
 
        movl    %ebp, %edi              # c
1236
 
        xorl    %eax, %edi              # ^d
1237
 
        xorl    %edx, %edi              # ^b
1238
 
        addl    -64+4*15(%rsp), %ebx    # e += RCONST + W[n & 15]
1239
 
        addl    %edi, %ebx              # e += (c ^ d ^ b)
1240
 
        movl    %ecx, %esi              #
1241
 
        roll    $5, %esi                # rotl32(a,5)
1242
 
        addl    %esi, %ebx              # e += rotl32(a,5)
1243
 
        rorl    $2, %edx                # b = rotl32(b,30)
1244
 
# PREP %xmm2 %xmm3 %xmm0 %xmm1 -64+16*2(%rsp)
1245
 
        movaps  %xmm1, %xmm4
1246
 
        psrldq  $4, %xmm4       # rshift by 4 bytes: T1 = ([13],[14],[15],0)
1247
 
#       pshufd  $0x4e, %xmm2, %xmm5     # 01001110=2,3,0,1 shuffle, ([2],[3],x,x)
1248
 
#       punpcklqdq %xmm3, %xmm5 # T2 = W4[0..63]:T2[0..63] = ([2],[3],[4],[5])
1249
 
# same result as above, but shorter and faster:
1250
 
# pshufd/shufps are subtly different: pshufd takes all dwords from source operand,
1251
 
# shufps takes dwords 0,1 from *2nd* operand, and dwords 2,3 from 1st one!
1252
 
        movaps  %xmm2, %xmm5
1253
 
        shufps  $0x4e, %xmm3, %xmm5     # 01001110=(T2.dw[2], T2.dw[3], W4.dw[0], W4.dw[1]) = ([2],[3],[4],[5])
1254
 
        xorps   %xmm0, %xmm2    # ([8],[9],[10],[11]) ^ ([0],[1],[2],[3])
1255
 
        xorps   %xmm4, %xmm5    # ([13],[14],[15],0) ^ ([2],[3],[4],[5])
1256
 
        xorps   %xmm5, %xmm2    # ^
1257
 
        # W0 = unrotated (W[0]..W[3]), still needs W[3] fixup
1258
 
        movaps  %xmm2, %xmm5
1259
 
        xorps   %xmm4, %xmm4    # rol(W0,1):
1260
 
        pcmpgtd %xmm2, %xmm4    #  ffffffff for elements <0 (ones with msb bit 1)
1261
 
        paddd   %xmm2, %xmm2    #  shift left by 1
1262
 
        psubd   %xmm4, %xmm2    #  add 1 to those who had msb bit 1
1263
 
        # W0 = rotated (W[0]..W[3]), still needs W[3] fixup
1264
 
        pslldq  $12, %xmm5      # lshift by 12 bytes: T2 = (0,0,0,unrotW[0])
1265
 
        movaps  %xmm5, %xmm4
1266
 
        pslld   $2, %xmm5
1267
 
        psrld   $30, %xmm4
1268
 
#       xorps   %xmm4, %xmm5    # rol((0,0,0,unrotW[0]),2)
1269
 
        xorps   %xmm4, %xmm2    # same result, but does not depend on/does not modify T2
1270
 
        xorps   %xmm5, %xmm2    # W0 = rol(W[0]..W[3],1) ^ (0,0,0,rol(unrotW[0],2))
1271
 
        movaps  %xmm2, %xmm5
1272
 
        paddd   %xmm6, %xmm5
1273
 
        movups  %xmm5, -64+16*2(%rsp)
1274
 
# 64
1275
 
        movl    %edx, %edi              # c
1276
 
        xorl    %ebp, %edi              # ^d
1277
 
        xorl    %ecx, %edi              # ^b
1278
 
        addl    -64+4*0(%rsp), %eax     # e += RCONST + W[n & 15]
1279
 
        addl    %edi, %eax              # e += (c ^ d ^ b)
1280
 
        movl    %ebx, %esi              #
1281
 
        roll    $5, %esi                # rotl32(a,5)
1282
 
        addl    %esi, %eax              # e += rotl32(a,5)
1283
 
        rorl    $2, %ecx                # b = rotl32(b,30)
1284
 
# 65
1285
 
        movl    %ecx, %edi              # c
1286
 
        xorl    %edx, %edi              # ^d
1287
 
        xorl    %ebx, %edi              # ^b
1288
 
        addl    -64+4*1(%rsp), %ebp     # e += RCONST + W[n & 15]
1289
 
        addl    %edi, %ebp              # e += (c ^ d ^ b)
1290
 
        movl    %eax, %esi              #
1291
 
        roll    $5, %esi                # rotl32(a,5)
1292
 
        addl    %esi, %ebp              # e += rotl32(a,5)
1293
 
        rorl    $2, %ebx                # b = rotl32(b,30)
1294
 
# 66
1295
 
        movl    %ebx, %edi              # c
1296
 
        xorl    %ecx, %edi              # ^d
1297
 
        xorl    %eax, %edi              # ^b
1298
 
        addl    -64+4*2(%rsp), %edx     # e += RCONST + W[n & 15]
1299
 
        addl    %edi, %edx              # e += (c ^ d ^ b)
1300
 
        movl    %ebp, %esi              #
1301
 
        roll    $5, %esi                # rotl32(a,5)
1302
 
        addl    %esi, %edx              # e += rotl32(a,5)
1303
 
        rorl    $2, %eax                # b = rotl32(b,30)
1304
 
# 67
1305
 
        movl    %eax, %edi              # c
1306
 
        xorl    %ebx, %edi              # ^d
1307
 
        xorl    %ebp, %edi              # ^b
1308
 
        addl    -64+4*3(%rsp), %ecx     # e += RCONST + W[n & 15]
1309
 
        addl    %edi, %ecx              # e += (c ^ d ^ b)
1310
 
        movl    %edx, %esi              #
1311
 
        roll    $5, %esi                # rotl32(a,5)
1312
 
        addl    %esi, %ecx              # e += rotl32(a,5)
1313
 
        rorl    $2, %ebp                # b = rotl32(b,30)
1314
 
# PREP %xmm3 %xmm0 %xmm1 %xmm2 -64+16*3(%rsp)
1315
 
        movaps  %xmm2, %xmm4
1316
 
        psrldq  $4, %xmm4       # rshift by 4 bytes: T1 = ([13],[14],[15],0)
1317
 
#       pshufd  $0x4e, %xmm3, %xmm5     # 01001110=2,3,0,1 shuffle, ([2],[3],x,x)
1318
 
#       punpcklqdq %xmm0, %xmm5 # T2 = W4[0..63]:T2[0..63] = ([2],[3],[4],[5])
1319
 
# same result as above, but shorter and faster:
1320
 
# pshufd/shufps are subtly different: pshufd takes all dwords from source operand,
1321
 
# shufps takes dwords 0,1 from *2nd* operand, and dwords 2,3 from 1st one!
1322
 
        movaps  %xmm3, %xmm5
1323
 
        shufps  $0x4e, %xmm0, %xmm5     # 01001110=(T2.dw[2], T2.dw[3], W4.dw[0], W4.dw[1]) = ([2],[3],[4],[5])
1324
 
        xorps   %xmm1, %xmm3    # ([8],[9],[10],[11]) ^ ([0],[1],[2],[3])
1325
 
        xorps   %xmm4, %xmm5    # ([13],[14],[15],0) ^ ([2],[3],[4],[5])
1326
 
        xorps   %xmm5, %xmm3    # ^
1327
 
        # W0 = unrotated (W[0]..W[3]), still needs W[3] fixup
1328
 
        movaps  %xmm3, %xmm5
1329
 
        xorps   %xmm4, %xmm4    # rol(W0,1):
1330
 
        pcmpgtd %xmm3, %xmm4    #  ffffffff for elements <0 (ones with msb bit 1)
1331
 
        paddd   %xmm3, %xmm3    #  shift left by 1
1332
 
        psubd   %xmm4, %xmm3    #  add 1 to those who had msb bit 1
1333
 
        # W0 = rotated (W[0]..W[3]), still needs W[3] fixup
1334
 
        pslldq  $12, %xmm5      # lshift by 12 bytes: T2 = (0,0,0,unrotW[0])
1335
 
        movaps  %xmm5, %xmm4
1336
 
        pslld   $2, %xmm5
1337
 
        psrld   $30, %xmm4
1338
 
#       xorps   %xmm4, %xmm5    # rol((0,0,0,unrotW[0]),2)
1339
 
        xorps   %xmm4, %xmm3    # same result, but does not depend on/does not modify T2
1340
 
        xorps   %xmm5, %xmm3    # W0 = rol(W[0]..W[3],1) ^ (0,0,0,rol(unrotW[0],2))
1341
 
        movaps  %xmm3, %xmm5
1342
 
        paddd   %xmm6, %xmm5
1343
 
        movups  %xmm5, -64+16*3(%rsp)
1344
 
# 68
1345
 
        movl    %ebp, %edi              # c
1346
 
        xorl    %eax, %edi              # ^d
1347
 
        xorl    %edx, %edi              # ^b
1348
 
        addl    -64+4*4(%rsp), %ebx     # e += RCONST + W[n & 15]
1349
 
        addl    %edi, %ebx              # e += (c ^ d ^ b)
1350
 
        movl    %ecx, %esi              #
1351
 
        roll    $5, %esi                # rotl32(a,5)
1352
 
        addl    %esi, %ebx              # e += rotl32(a,5)
1353
 
        rorl    $2, %edx                # b = rotl32(b,30)
1354
 
# 69
1355
 
        movl    %edx, %edi              # c
1356
 
        xorl    %ebp, %edi              # ^d
1357
 
        xorl    %ecx, %edi              # ^b
1358
 
        addl    -64+4*5(%rsp), %eax     # e += RCONST + W[n & 15]
1359
 
        addl    %edi, %eax              # e += (c ^ d ^ b)
1360
 
        movl    %ebx, %esi              #
1361
 
        roll    $5, %esi                # rotl32(a,5)
1362
 
        addl    %esi, %eax              # e += rotl32(a,5)
1363
 
        rorl    $2, %ecx                # b = rotl32(b,30)
1364
 
# 70
1365
 
        movl    %ecx, %edi              # c
1366
 
        xorl    %edx, %edi              # ^d
1367
 
        xorl    %ebx, %edi              # ^b
1368
 
        addl    -64+4*6(%rsp), %ebp     # e += RCONST + W[n & 15]
1369
 
        addl    %edi, %ebp              # e += (c ^ d ^ b)
1370
 
        movl    %eax, %esi              #
1371
 
        roll    $5, %esi                # rotl32(a,5)
1372
 
        addl    %esi, %ebp              # e += rotl32(a,5)
1373
 
        rorl    $2, %ebx                # b = rotl32(b,30)
1374
 
# 71
1375
 
        movl    %ebx, %edi              # c
1376
 
        xorl    %ecx, %edi              # ^d
1377
 
        xorl    %eax, %edi              # ^b
1378
 
        addl    -64+4*7(%rsp), %edx     # e += RCONST + W[n & 15]
1379
 
        addl    %edi, %edx              # e += (c ^ d ^ b)
1380
 
        movl    %ebp, %esi              #
1381
 
        roll    $5, %esi                # rotl32(a,5)
1382
 
        addl    %esi, %edx              # e += rotl32(a,5)
1383
 
        rorl    $2, %eax                # b = rotl32(b,30)
1384
 
# 72
1385
 
        movl    %eax, %edi              # c
1386
 
        xorl    %ebx, %edi              # ^d
1387
 
        xorl    %ebp, %edi              # ^b
1388
 
        addl    -64+4*8(%rsp), %ecx     # e += RCONST + W[n & 15]
1389
 
        addl    %edi, %ecx              # e += (c ^ d ^ b)
1390
 
        movl    %edx, %esi              #
1391
 
        roll    $5, %esi                # rotl32(a,5)
1392
 
        addl    %esi, %ecx              # e += rotl32(a,5)
1393
 
        rorl    $2, %ebp                # b = rotl32(b,30)
1394
 
# 73
1395
 
        movl    %ebp, %edi              # c
1396
 
        xorl    %eax, %edi              # ^d
1397
 
        xorl    %edx, %edi              # ^b
1398
 
        addl    -64+4*9(%rsp), %ebx     # e += RCONST + W[n & 15]
1399
 
        addl    %edi, %ebx              # e += (c ^ d ^ b)
1400
 
        movl    %ecx, %esi              #
1401
 
        roll    $5, %esi                # rotl32(a,5)
1402
 
        addl    %esi, %ebx              # e += rotl32(a,5)
1403
 
        rorl    $2, %edx                # b = rotl32(b,30)
1404
 
# 74
1405
 
        movl    %edx, %edi              # c
1406
 
        xorl    %ebp, %edi              # ^d
1407
 
        xorl    %ecx, %edi              # ^b
1408
 
        addl    -64+4*10(%rsp), %eax    # e += RCONST + W[n & 15]
1409
 
        addl    %edi, %eax              # e += (c ^ d ^ b)
1410
 
        movl    %ebx, %esi              #
1411
 
        roll    $5, %esi                # rotl32(a,5)
1412
 
        addl    %esi, %eax              # e += rotl32(a,5)
1413
 
        rorl    $2, %ecx                # b = rotl32(b,30)
1414
 
# 75
1415
 
        movl    %ecx, %edi              # c
1416
 
        xorl    %edx, %edi              # ^d
1417
 
        xorl    %ebx, %edi              # ^b
1418
 
        addl    -64+4*11(%rsp), %ebp    # e += RCONST + W[n & 15]
1419
 
        addl    %edi, %ebp              # e += (c ^ d ^ b)
1420
 
        movl    %eax, %esi              #
1421
 
        roll    $5, %esi                # rotl32(a,5)
1422
 
        addl    %esi, %ebp              # e += rotl32(a,5)
1423
 
        rorl    $2, %ebx                # b = rotl32(b,30)
1424
 
# 76
1425
 
        movl    %ebx, %edi              # c
1426
 
        xorl    %ecx, %edi              # ^d
1427
 
        xorl    %eax, %edi              # ^b
1428
 
        addl    -64+4*12(%rsp), %edx    # e += RCONST + W[n & 15]
1429
 
        addl    %edi, %edx              # e += (c ^ d ^ b)
1430
 
        movl    %ebp, %esi              #
1431
 
        roll    $5, %esi                # rotl32(a,5)
1432
 
        addl    %esi, %edx              # e += rotl32(a,5)
1433
 
        rorl    $2, %eax                # b = rotl32(b,30)
1434
 
# 77
1435
 
        movl    %eax, %edi              # c
1436
 
        xorl    %ebx, %edi              # ^d
1437
 
        xorl    %ebp, %edi              # ^b
1438
 
        addl    -64+4*13(%rsp), %ecx    # e += RCONST + W[n & 15]
1439
 
        addl    %edi, %ecx              # e += (c ^ d ^ b)
1440
 
        movl    %edx, %esi              #
1441
 
        roll    $5, %esi                # rotl32(a,5)
1442
 
        addl    %esi, %ecx              # e += rotl32(a,5)
1443
 
        rorl    $2, %ebp                # b = rotl32(b,30)
1444
 
# 78
1445
 
        movl    %ebp, %edi              # c
1446
 
        xorl    %eax, %edi              # ^d
1447
 
        xorl    %edx, %edi              # ^b
1448
 
        addl    -64+4*14(%rsp), %ebx    # e += RCONST + W[n & 15]
1449
 
        addl    %edi, %ebx              # e += (c ^ d ^ b)
1450
 
        movl    %ecx, %esi              #
1451
 
        roll    $5, %esi                # rotl32(a,5)
1452
 
        addl    %esi, %ebx              # e += rotl32(a,5)
1453
 
        rorl    $2, %edx                # b = rotl32(b,30)
1454
 
# 79
1455
 
        movl    %edx, %edi              # c
1456
 
        xorl    %ebp, %edi              # ^d
1457
 
        xorl    %ecx, %edi              # ^b
1458
 
        addl    -64+4*15(%rsp), %eax    # e += RCONST + W[n & 15]
1459
 
        addl    %edi, %eax              # e += (c ^ d ^ b)
1460
 
        movl    %ebx, %esi              #
1461
 
        roll    $5, %esi                # rotl32(a,5)
1462
 
        addl    %esi, %eax              # e += rotl32(a,5)
1463
 
        rorl    $2, %ecx                # b = rotl32(b,30)
1464
 
 
1465
 
        popq    %rdi            #
1466
 
        popq    %r12            #
1467
 
        addl    %eax, 80(%rdi)  # ctx->hash[0] += a
1468
 
        popq    %r13            #
1469
 
        addl    %ebx, 84(%rdi)  # ctx->hash[1] += b
1470
 
        popq    %r14            #
1471
 
        addl    %ecx, 88(%rdi)  # ctx->hash[2] += c
1472
 
#       popq    %r15            #
1473
 
        addl    %edx, 92(%rdi)  # ctx->hash[3] += d
1474
 
        popq    %rbx            #
1475
 
        addl    %ebp, 96(%rdi)  # ctx->hash[4] += e
1476
 
        popq    %rbp            #
1477
 
 
1478
 
        ret
1479
 
        .size   sha1_process_block64, .-sha1_process_block64
1480
 
 
1481
 
        .section        .rodata.cst16.sha1const, "aM", @progbits, 16
1482
 
        .balign 16
1483
 
sha1const:
1484
 
        .long   0x5A827999
1485
 
        .long   0x6ED9EBA1
1486
 
        .long   0x8F1BBCDC
1487
 
        .long   0xCA62C1D6
1488
 
 
1489
 
#endif