diff options
Diffstat (limited to 'nacl/crypto_onetimeauth')
21 files changed, 0 insertions, 7714 deletions
diff --git a/nacl/crypto_onetimeauth/measure.c b/nacl/crypto_onetimeauth/measure.c deleted file mode 100644 index 6d3ddfd5..00000000 --- a/nacl/crypto_onetimeauth/measure.c +++ /dev/null | |||
@@ -1,69 +0,0 @@ | |||
1 | #include "crypto_onetimeauth.h" | ||
2 | #include "randombytes.h" | ||
3 | #include "cpucycles.h" | ||
4 | |||
5 | extern void printentry(long long,const char *,long long *,long long); | ||
6 | extern unsigned char *alignedcalloc(unsigned long long); | ||
7 | extern const char *primitiveimplementation; | ||
8 | extern const char *implementationversion; | ||
9 | extern const char *sizenames[]; | ||
10 | extern const long long sizes[]; | ||
11 | extern void allocate(void); | ||
12 | extern void measure(void); | ||
13 | |||
14 | const char *primitiveimplementation = crypto_onetimeauth_IMPLEMENTATION; | ||
15 | const char *implementationversion = crypto_onetimeauth_VERSION; | ||
16 | const char *sizenames[] = { "outputbytes", "keybytes", 0 }; | ||
17 | const long long sizes[] = { crypto_onetimeauth_BYTES, crypto_onetimeauth_KEYBYTES }; | ||
18 | |||
19 | #define MAXTEST_BYTES 4096 | ||
20 | #ifdef SUPERCOP | ||
21 | #define MGAP 8192 | ||
22 | #else | ||
23 | #define MGAP 8 | ||
24 | #endif | ||
25 | |||
26 | static unsigned char *k; | ||
27 | static unsigned char *m; | ||
28 | static unsigned char *h; | ||
29 | |||
30 | void preallocate(void) | ||
31 | { | ||
32 | } | ||
33 | |||
34 | void allocate(void) | ||
35 | { | ||
36 | k = alignedcalloc(crypto_onetimeauth_KEYBYTES); | ||
37 | m = alignedcalloc(MAXTEST_BYTES); | ||
38 | h = alignedcalloc(crypto_onetimeauth_BYTES); | ||
39 | } | ||
40 | |||
41 | #define TIMINGS 15 | ||
42 | static long long cycles[TIMINGS + 1]; | ||
43 | |||
44 | void measure(void) | ||
45 | { | ||
46 | int i; | ||
47 | int loop; | ||
48 | int mlen; | ||
49 | |||
50 | for (loop = 0;loop < LOOPS;++loop) { | ||
51 | for (mlen = 0;mlen <= MAXTEST_BYTES;mlen += 1 + mlen / MGAP) { | ||
52 | randombytes(k,crypto_onetimeauth_KEYBYTES); | ||
53 | randombytes(m,mlen); | ||
54 | randombytes(h,crypto_onetimeauth_BYTES); | ||
55 | for (i = 0;i <= TIMINGS;++i) { | ||
56 | cycles[i] = cpucycles(); | ||
57 | crypto_onetimeauth(h,m,mlen,k); | ||
58 | } | ||
59 | for (i = 0;i < TIMINGS;++i) cycles[i] = cycles[i + 1] - cycles[i]; | ||
60 | printentry(mlen,"cycles",cycles,TIMINGS); | ||
61 | for (i = 0;i <= TIMINGS;++i) { | ||
62 | cycles[i] = cpucycles(); | ||
63 | crypto_onetimeauth_verify(h,m,mlen,k); | ||
64 | } | ||
65 | for (i = 0;i < TIMINGS;++i) cycles[i] = cycles[i + 1] - cycles[i]; | ||
66 | printentry(mlen,"verify_cycles",cycles,TIMINGS); | ||
67 | } | ||
68 | } | ||
69 | } | ||
diff --git a/nacl/crypto_onetimeauth/poly1305/53/api.h b/nacl/crypto_onetimeauth/poly1305/53/api.h deleted file mode 100644 index acc133ed..00000000 --- a/nacl/crypto_onetimeauth/poly1305/53/api.h +++ /dev/null | |||
@@ -1,2 +0,0 @@ | |||
1 | #define CRYPTO_BYTES 16 | ||
2 | #define CRYPTO_KEYBYTES 32 | ||
diff --git a/nacl/crypto_onetimeauth/poly1305/53/auth.c b/nacl/crypto_onetimeauth/poly1305/53/auth.c deleted file mode 100644 index a4a9c3f6..00000000 --- a/nacl/crypto_onetimeauth/poly1305/53/auth.c +++ /dev/null | |||
@@ -1,1616 +0,0 @@ | |||
1 | /* | ||
2 | 20080910 | ||
3 | D. J. Bernstein | ||
4 | Public domain. | ||
5 | */ | ||
6 | |||
7 | #include "crypto_onetimeauth.h" | ||
8 | |||
9 | typedef unsigned char uchar; | ||
10 | typedef int int32; | ||
11 | typedef unsigned int uint32; | ||
12 | typedef long long int64; | ||
13 | typedef unsigned long long uint64; | ||
14 | |||
15 | static const double poly1305_53_constants[] = { | ||
16 | 0.00000000558793544769287109375 /* alpham80 = 3 2^(-29) */ | ||
17 | , 24.0 /* alpham48 = 3 2^3 */ | ||
18 | , 103079215104.0 /* alpham16 = 3 2^35 */ | ||
19 | , 6755399441055744.0 /* alpha0 = 3 2^51 */ | ||
20 | , 1770887431076116955136.0 /* alpha18 = 3 2^69 */ | ||
21 | , 29014219670751100192948224.0 /* alpha32 = 3 2^83 */ | ||
22 | , 7605903601369376408980219232256.0 /* alpha50 = 3 2^101 */ | ||
23 | , 124615124604835863084731911901282304.0 /* alpha64 = 3 2^115 */ | ||
24 | , 32667107224410092492483962313449748299776.0 /* alpha82 = 3 2^133 */ | ||
25 | , 535217884764734955396857238543560676143529984.0 /* alpha96 = 3 2^147 */ | ||
26 | , 35076039295941670036888435985190792471742381031424.0 /* alpha112 = 3 2^163 */ | ||
27 | , 9194973245195333150150082162901855101712434733101613056.0 /* alpha130 = 3 2^181 */ | ||
28 | , 0.0000000000000000000000000000000000000036734198463196484624023016788195177431833298649127735047148490821200539357960224151611328125 /* scale = 5 2^(-130) */ | ||
29 | , 6755408030990331.0 /* offset0 = alpha0 + 2^33 - 5 */ | ||
30 | , 29014256564239239022116864.0 /* offset1 = alpha32 + 2^65 - 2^33 */ | ||
31 | , 124615283061160854719918951570079744.0 /* offset2 = alpha64 + 2^97 - 2^65 */ | ||
32 | , 535219245894202480694386063513315216128475136.0 /* offset3 = alpha96 + 2^130 - 2^97 */ | ||
33 | } ; | ||
34 | |||
35 | int crypto_onetimeauth(unsigned char *out,const unsigned char *m,unsigned long long l,const unsigned char *k) | ||
36 | { | ||
37 | register const unsigned char *r = k; | ||
38 | register const unsigned char *s = k + 16; | ||
39 | double r0high_stack; | ||
40 | double r1high_stack; | ||
41 | double r1low_stack; | ||
42 | double sr1high_stack; | ||
43 | double r2low_stack; | ||
44 | double sr2high_stack; | ||
45 | double r0low_stack; | ||
46 | double sr1low_stack; | ||
47 | double r2high_stack; | ||
48 | double sr2low_stack; | ||
49 | double r3high_stack; | ||
50 | double sr3high_stack; | ||
51 | double r3low_stack; | ||
52 | double sr3low_stack; | ||
53 | int64 d0; | ||
54 | int64 d1; | ||
55 | int64 d2; | ||
56 | int64 d3; | ||
57 | register double scale; | ||
58 | register double alpha0; | ||
59 | register double alpha32; | ||
60 | register double alpha64; | ||
61 | register double alpha96; | ||
62 | register double alpha130; | ||
63 | register double h0; | ||
64 | register double h1; | ||
65 | register double h2; | ||
66 | register double h3; | ||
67 | register double h4; | ||
68 | register double h5; | ||
69 | register double h6; | ||
70 | register double h7; | ||
71 | register double y7; | ||
72 | register double y6; | ||
73 | register double y1; | ||
74 | register double y0; | ||
75 | register double y5; | ||
76 | register double y4; | ||
77 | register double x7; | ||
78 | register double x6; | ||
79 | register double x1; | ||
80 | register double x0; | ||
81 | register double y3; | ||
82 | register double y2; | ||
83 | register double r3low; | ||
84 | register double r0low; | ||
85 | register double r3high; | ||
86 | register double r0high; | ||
87 | register double sr1low; | ||
88 | register double x5; | ||
89 | register double r3lowx0; | ||
90 | register double sr1high; | ||
91 | register double x4; | ||
92 | register double r0lowx6; | ||
93 | register double r1low; | ||
94 | register double x3; | ||
95 | register double r3highx0; | ||
96 | register double r1high; | ||
97 | register double x2; | ||
98 | register double r0highx6; | ||
99 | register double sr2low; | ||
100 | register double r0lowx0; | ||
101 | register double sr2high; | ||
102 | register double sr1lowx6; | ||
103 | register double r2low; | ||
104 | register double r0highx0; | ||
105 | register double r2high; | ||
106 | register double sr1highx6; | ||
107 | register double sr3low; | ||
108 | register double r1lowx0; | ||
109 | register double sr3high; | ||
110 | register double sr2lowx6; | ||
111 | register double r1highx0; | ||
112 | register double sr2highx6; | ||
113 | register double r2lowx0; | ||
114 | register double sr3lowx6; | ||
115 | register double r2highx0; | ||
116 | register double sr3highx6; | ||
117 | register double r1highx4; | ||
118 | register double r1lowx4; | ||
119 | register double r0highx4; | ||
120 | register double r0lowx4; | ||
121 | register double sr3highx4; | ||
122 | register double sr3lowx4; | ||
123 | register double sr2highx4; | ||
124 | register double sr2lowx4; | ||
125 | register double r0lowx2; | ||
126 | register double r0highx2; | ||
127 | register double r1lowx2; | ||
128 | register double r1highx2; | ||
129 | register double r2lowx2; | ||
130 | register double r2highx2; | ||
131 | register double sr3lowx2; | ||
132 | register double sr3highx2; | ||
133 | register double z0; | ||
134 | register double z1; | ||
135 | register double z2; | ||
136 | register double z3; | ||
137 | register int64 r0; | ||
138 | register int64 r1; | ||
139 | register int64 r2; | ||
140 | register int64 r3; | ||
141 | register uint32 r00; | ||
142 | register uint32 r01; | ||
143 | register uint32 r02; | ||
144 | register uint32 r03; | ||
145 | register uint32 r10; | ||
146 | register uint32 r11; | ||
147 | register uint32 r12; | ||
148 | register uint32 r13; | ||
149 | register uint32 r20; | ||
150 | register uint32 r21; | ||
151 | register uint32 r22; | ||
152 | register uint32 r23; | ||
153 | register uint32 r30; | ||
154 | register uint32 r31; | ||
155 | register uint32 r32; | ||
156 | register uint32 r33; | ||
157 | register int64 m0; | ||
158 | register int64 m1; | ||
159 | register int64 m2; | ||
160 | register int64 m3; | ||
161 | register uint32 m00; | ||
162 | register uint32 m01; | ||
163 | register uint32 m02; | ||
164 | register uint32 m03; | ||
165 | register uint32 m10; | ||
166 | register uint32 m11; | ||
167 | register uint32 m12; | ||
168 | register uint32 m13; | ||
169 | register uint32 m20; | ||
170 | register uint32 m21; | ||
171 | register uint32 m22; | ||
172 | register uint32 m23; | ||
173 | register uint32 m30; | ||
174 | register uint32 m31; | ||
175 | register uint32 m32; | ||
176 | register uint64 m33; | ||
177 | register char *constants; | ||
178 | register int32 lbelow2; | ||
179 | register int32 lbelow3; | ||
180 | register int32 lbelow4; | ||
181 | register int32 lbelow5; | ||
182 | register int32 lbelow6; | ||
183 | register int32 lbelow7; | ||
184 | register int32 lbelow8; | ||
185 | register int32 lbelow9; | ||
186 | register int32 lbelow10; | ||
187 | register int32 lbelow11; | ||
188 | register int32 lbelow12; | ||
189 | register int32 lbelow13; | ||
190 | register int32 lbelow14; | ||
191 | register int32 lbelow15; | ||
192 | register double alpham80; | ||
193 | register double alpham48; | ||
194 | register double alpham16; | ||
195 | register double alpha18; | ||
196 | register double alpha50; | ||
197 | register double alpha82; | ||
198 | register double alpha112; | ||
199 | register double offset0; | ||
200 | register double offset1; | ||
201 | register double offset2; | ||
202 | register double offset3; | ||
203 | register uint32 s00; | ||
204 | register uint32 s01; | ||
205 | register uint32 s02; | ||
206 | register uint32 s03; | ||
207 | register uint32 s10; | ||
208 | register uint32 s11; | ||
209 | register uint32 s12; | ||
210 | register uint32 s13; | ||
211 | register uint32 s20; | ||
212 | register uint32 s21; | ||
213 | register uint32 s22; | ||
214 | register uint32 s23; | ||
215 | register uint32 s30; | ||
216 | register uint32 s31; | ||
217 | register uint32 s32; | ||
218 | register uint32 s33; | ||
219 | register uint64 bits32; | ||
220 | register uint64 f; | ||
221 | register uint64 f0; | ||
222 | register uint64 f1; | ||
223 | register uint64 f2; | ||
224 | register uint64 f3; | ||
225 | register uint64 f4; | ||
226 | register uint64 g; | ||
227 | register uint64 g0; | ||
228 | register uint64 g1; | ||
229 | register uint64 g2; | ||
230 | register uint64 g3; | ||
231 | register uint64 g4; | ||
232 | |||
233 | r00 = *(uchar *) (r + 0); | ||
234 | constants = (char *) &poly1305_53_constants; | ||
235 | |||
236 | r01 = *(uchar *) (r + 1); | ||
237 | |||
238 | r02 = *(uchar *) (r + 2); | ||
239 | r0 = 2151; | ||
240 | |||
241 | r03 = *(uchar *) (r + 3); r03 &= 15; | ||
242 | r0 <<= 51; | ||
243 | |||
244 | r10 = *(uchar *) (r + 4); r10 &= 252; | ||
245 | r01 <<= 8; | ||
246 | r0 += r00; | ||
247 | |||
248 | r11 = *(uchar *) (r + 5); | ||
249 | r02 <<= 16; | ||
250 | r0 += r01; | ||
251 | |||
252 | r12 = *(uchar *) (r + 6); | ||
253 | r03 <<= 24; | ||
254 | r0 += r02; | ||
255 | |||
256 | r13 = *(uchar *) (r + 7); r13 &= 15; | ||
257 | r1 = 2215; | ||
258 | r0 += r03; | ||
259 | |||
260 | d0 = r0; | ||
261 | r1 <<= 51; | ||
262 | r2 = 2279; | ||
263 | |||
264 | r20 = *(uchar *) (r + 8); r20 &= 252; | ||
265 | r11 <<= 8; | ||
266 | r1 += r10; | ||
267 | |||
268 | r21 = *(uchar *) (r + 9); | ||
269 | r12 <<= 16; | ||
270 | r1 += r11; | ||
271 | |||
272 | r22 = *(uchar *) (r + 10); | ||
273 | r13 <<= 24; | ||
274 | r1 += r12; | ||
275 | |||
276 | r23 = *(uchar *) (r + 11); r23 &= 15; | ||
277 | r2 <<= 51; | ||
278 | r1 += r13; | ||
279 | |||
280 | d1 = r1; | ||
281 | r21 <<= 8; | ||
282 | r2 += r20; | ||
283 | |||
284 | r30 = *(uchar *) (r + 12); r30 &= 252; | ||
285 | r22 <<= 16; | ||
286 | r2 += r21; | ||
287 | |||
288 | r31 = *(uchar *) (r + 13); | ||
289 | r23 <<= 24; | ||
290 | r2 += r22; | ||
291 | |||
292 | r32 = *(uchar *) (r + 14); | ||
293 | r2 += r23; | ||
294 | r3 = 2343; | ||
295 | |||
296 | d2 = r2; | ||
297 | r3 <<= 51; | ||
298 | alpha32 = *(double *) (constants + 40); | ||
299 | |||
300 | r33 = *(uchar *) (r + 15); r33 &= 15; | ||
301 | r31 <<= 8; | ||
302 | r3 += r30; | ||
303 | |||
304 | r32 <<= 16; | ||
305 | r3 += r31; | ||
306 | |||
307 | r33 <<= 24; | ||
308 | r3 += r32; | ||
309 | |||
310 | r3 += r33; | ||
311 | h0 = alpha32 - alpha32; | ||
312 | |||
313 | d3 = r3; | ||
314 | h1 = alpha32 - alpha32; | ||
315 | |||
316 | alpha0 = *(double *) (constants + 24); | ||
317 | h2 = alpha32 - alpha32; | ||
318 | |||
319 | alpha64 = *(double *) (constants + 56); | ||
320 | h3 = alpha32 - alpha32; | ||
321 | |||
322 | alpha18 = *(double *) (constants + 32); | ||
323 | h4 = alpha32 - alpha32; | ||
324 | |||
325 | r0low = *(double *) &d0; | ||
326 | h5 = alpha32 - alpha32; | ||
327 | |||
328 | r1low = *(double *) &d1; | ||
329 | h6 = alpha32 - alpha32; | ||
330 | |||
331 | r2low = *(double *) &d2; | ||
332 | h7 = alpha32 - alpha32; | ||
333 | |||
334 | alpha50 = *(double *) (constants + 48); | ||
335 | r0low -= alpha0; | ||
336 | |||
337 | alpha82 = *(double *) (constants + 64); | ||
338 | r1low -= alpha32; | ||
339 | |||
340 | scale = *(double *) (constants + 96); | ||
341 | r2low -= alpha64; | ||
342 | |||
343 | alpha96 = *(double *) (constants + 72); | ||
344 | r0high = r0low + alpha18; | ||
345 | |||
346 | r3low = *(double *) &d3; | ||
347 | |||
348 | alpham80 = *(double *) (constants + 0); | ||
349 | r1high = r1low + alpha50; | ||
350 | sr1low = scale * r1low; | ||
351 | |||
352 | alpham48 = *(double *) (constants + 8); | ||
353 | r2high = r2low + alpha82; | ||
354 | sr2low = scale * r2low; | ||
355 | |||
356 | r0high -= alpha18; | ||
357 | r0high_stack = r0high; | ||
358 | |||
359 | r3low -= alpha96; | ||
360 | |||
361 | r1high -= alpha50; | ||
362 | r1high_stack = r1high; | ||
363 | |||
364 | sr1high = sr1low + alpham80; | ||
365 | |||
366 | alpha112 = *(double *) (constants + 80); | ||
367 | r0low -= r0high; | ||
368 | |||
369 | alpham16 = *(double *) (constants + 16); | ||
370 | r2high -= alpha82; | ||
371 | sr3low = scale * r3low; | ||
372 | |||
373 | alpha130 = *(double *) (constants + 88); | ||
374 | sr2high = sr2low + alpham48; | ||
375 | |||
376 | r1low -= r1high; | ||
377 | r1low_stack = r1low; | ||
378 | |||
379 | sr1high -= alpham80; | ||
380 | sr1high_stack = sr1high; | ||
381 | |||
382 | r2low -= r2high; | ||
383 | r2low_stack = r2low; | ||
384 | |||
385 | sr2high -= alpham48; | ||
386 | sr2high_stack = sr2high; | ||
387 | |||
388 | r3high = r3low + alpha112; | ||
389 | r0low_stack = r0low; | ||
390 | |||
391 | sr1low -= sr1high; | ||
392 | sr1low_stack = sr1low; | ||
393 | |||
394 | sr3high = sr3low + alpham16; | ||
395 | r2high_stack = r2high; | ||
396 | |||
397 | sr2low -= sr2high; | ||
398 | sr2low_stack = sr2low; | ||
399 | |||
400 | r3high -= alpha112; | ||
401 | r3high_stack = r3high; | ||
402 | |||
403 | |||
404 | sr3high -= alpham16; | ||
405 | sr3high_stack = sr3high; | ||
406 | |||
407 | |||
408 | r3low -= r3high; | ||
409 | r3low_stack = r3low; | ||
410 | |||
411 | |||
412 | sr3low -= sr3high; | ||
413 | sr3low_stack = sr3low; | ||
414 | |||
415 | if (l < 16) goto addatmost15bytes; | ||
416 | |||
417 | m00 = *(uchar *) (m + 0); | ||
418 | m0 = 2151; | ||
419 | |||
420 | m0 <<= 51; | ||
421 | m1 = 2215; | ||
422 | m01 = *(uchar *) (m + 1); | ||
423 | |||
424 | m1 <<= 51; | ||
425 | m2 = 2279; | ||
426 | m02 = *(uchar *) (m + 2); | ||
427 | |||
428 | m2 <<= 51; | ||
429 | m3 = 2343; | ||
430 | m03 = *(uchar *) (m + 3); | ||
431 | |||
432 | m10 = *(uchar *) (m + 4); | ||
433 | m01 <<= 8; | ||
434 | m0 += m00; | ||
435 | |||
436 | m11 = *(uchar *) (m + 5); | ||
437 | m02 <<= 16; | ||
438 | m0 += m01; | ||
439 | |||
440 | m12 = *(uchar *) (m + 6); | ||
441 | m03 <<= 24; | ||
442 | m0 += m02; | ||
443 | |||
444 | m13 = *(uchar *) (m + 7); | ||
445 | m3 <<= 51; | ||
446 | m0 += m03; | ||
447 | |||
448 | m20 = *(uchar *) (m + 8); | ||
449 | m11 <<= 8; | ||
450 | m1 += m10; | ||
451 | |||
452 | m21 = *(uchar *) (m + 9); | ||
453 | m12 <<= 16; | ||
454 | m1 += m11; | ||
455 | |||
456 | m22 = *(uchar *) (m + 10); | ||
457 | m13 <<= 24; | ||
458 | m1 += m12; | ||
459 | |||
460 | m23 = *(uchar *) (m + 11); | ||
461 | m1 += m13; | ||
462 | |||
463 | m30 = *(uchar *) (m + 12); | ||
464 | m21 <<= 8; | ||
465 | m2 += m20; | ||
466 | |||
467 | m31 = *(uchar *) (m + 13); | ||
468 | m22 <<= 16; | ||
469 | m2 += m21; | ||
470 | |||
471 | m32 = *(uchar *) (m + 14); | ||
472 | m23 <<= 24; | ||
473 | m2 += m22; | ||
474 | |||
475 | m33 = *(uchar *) (m + 15); | ||
476 | m2 += m23; | ||
477 | |||
478 | d0 = m0; | ||
479 | m31 <<= 8; | ||
480 | m3 += m30; | ||
481 | |||
482 | d1 = m1; | ||
483 | m32 <<= 16; | ||
484 | m3 += m31; | ||
485 | |||
486 | d2 = m2; | ||
487 | m33 += 256; | ||
488 | |||
489 | m33 <<= 24; | ||
490 | m3 += m32; | ||
491 | |||
492 | m3 += m33; | ||
493 | d3 = m3; | ||
494 | |||
495 | m += 16; | ||
496 | l -= 16; | ||
497 | |||
498 | z0 = *(double *) &d0; | ||
499 | |||
500 | z1 = *(double *) &d1; | ||
501 | |||
502 | z2 = *(double *) &d2; | ||
503 | |||
504 | z3 = *(double *) &d3; | ||
505 | |||
506 | z0 -= alpha0; | ||
507 | |||
508 | z1 -= alpha32; | ||
509 | |||
510 | z2 -= alpha64; | ||
511 | |||
512 | z3 -= alpha96; | ||
513 | |||
514 | h0 += z0; | ||
515 | |||
516 | h1 += z1; | ||
517 | |||
518 | h3 += z2; | ||
519 | |||
520 | h5 += z3; | ||
521 | |||
522 | if (l < 16) goto multiplyaddatmost15bytes; | ||
523 | |||
524 | multiplyaddatleast16bytes:; | ||
525 | |||
526 | m2 = 2279; | ||
527 | m20 = *(uchar *) (m + 8); | ||
528 | y7 = h7 + alpha130; | ||
529 | |||
530 | m2 <<= 51; | ||
531 | m3 = 2343; | ||
532 | m21 = *(uchar *) (m + 9); | ||
533 | y6 = h6 + alpha130; | ||
534 | |||
535 | m3 <<= 51; | ||
536 | m0 = 2151; | ||
537 | m22 = *(uchar *) (m + 10); | ||
538 | y1 = h1 + alpha32; | ||
539 | |||
540 | m0 <<= 51; | ||
541 | m1 = 2215; | ||
542 | m23 = *(uchar *) (m + 11); | ||
543 | y0 = h0 + alpha32; | ||
544 | |||
545 | m1 <<= 51; | ||
546 | m30 = *(uchar *) (m + 12); | ||
547 | y7 -= alpha130; | ||
548 | |||
549 | m21 <<= 8; | ||
550 | m2 += m20; | ||
551 | m31 = *(uchar *) (m + 13); | ||
552 | y6 -= alpha130; | ||
553 | |||
554 | m22 <<= 16; | ||
555 | m2 += m21; | ||
556 | m32 = *(uchar *) (m + 14); | ||
557 | y1 -= alpha32; | ||
558 | |||
559 | m23 <<= 24; | ||
560 | m2 += m22; | ||
561 | m33 = *(uchar *) (m + 15); | ||
562 | y0 -= alpha32; | ||
563 | |||
564 | m2 += m23; | ||
565 | m00 = *(uchar *) (m + 0); | ||
566 | y5 = h5 + alpha96; | ||
567 | |||
568 | m31 <<= 8; | ||
569 | m3 += m30; | ||
570 | m01 = *(uchar *) (m + 1); | ||
571 | y4 = h4 + alpha96; | ||
572 | |||
573 | m32 <<= 16; | ||
574 | m02 = *(uchar *) (m + 2); | ||
575 | x7 = h7 - y7; | ||
576 | y7 *= scale; | ||
577 | |||
578 | m33 += 256; | ||
579 | m03 = *(uchar *) (m + 3); | ||
580 | x6 = h6 - y6; | ||
581 | y6 *= scale; | ||
582 | |||
583 | m33 <<= 24; | ||
584 | m3 += m31; | ||
585 | m10 = *(uchar *) (m + 4); | ||
586 | x1 = h1 - y1; | ||
587 | |||
588 | m01 <<= 8; | ||
589 | m3 += m32; | ||
590 | m11 = *(uchar *) (m + 5); | ||
591 | x0 = h0 - y0; | ||
592 | |||
593 | m3 += m33; | ||
594 | m0 += m00; | ||
595 | m12 = *(uchar *) (m + 6); | ||
596 | y5 -= alpha96; | ||
597 | |||
598 | m02 <<= 16; | ||
599 | m0 += m01; | ||
600 | m13 = *(uchar *) (m + 7); | ||
601 | y4 -= alpha96; | ||
602 | |||
603 | m03 <<= 24; | ||
604 | m0 += m02; | ||
605 | d2 = m2; | ||
606 | x1 += y7; | ||
607 | |||
608 | m0 += m03; | ||
609 | d3 = m3; | ||
610 | x0 += y6; | ||
611 | |||
612 | m11 <<= 8; | ||
613 | m1 += m10; | ||
614 | d0 = m0; | ||
615 | x7 += y5; | ||
616 | |||
617 | m12 <<= 16; | ||
618 | m1 += m11; | ||
619 | x6 += y4; | ||
620 | |||
621 | m13 <<= 24; | ||
622 | m1 += m12; | ||
623 | y3 = h3 + alpha64; | ||
624 | |||
625 | m1 += m13; | ||
626 | d1 = m1; | ||
627 | y2 = h2 + alpha64; | ||
628 | |||
629 | x0 += x1; | ||
630 | |||
631 | x6 += x7; | ||
632 | |||
633 | y3 -= alpha64; | ||
634 | r3low = r3low_stack; | ||
635 | |||
636 | y2 -= alpha64; | ||
637 | r0low = r0low_stack; | ||
638 | |||
639 | x5 = h5 - y5; | ||
640 | r3lowx0 = r3low * x0; | ||
641 | r3high = r3high_stack; | ||
642 | |||
643 | x4 = h4 - y4; | ||
644 | r0lowx6 = r0low * x6; | ||
645 | r0high = r0high_stack; | ||
646 | |||
647 | x3 = h3 - y3; | ||
648 | r3highx0 = r3high * x0; | ||
649 | sr1low = sr1low_stack; | ||
650 | |||
651 | x2 = h2 - y2; | ||
652 | r0highx6 = r0high * x6; | ||
653 | sr1high = sr1high_stack; | ||
654 | |||
655 | x5 += y3; | ||
656 | r0lowx0 = r0low * x0; | ||
657 | r1low = r1low_stack; | ||
658 | |||
659 | h6 = r3lowx0 + r0lowx6; | ||
660 | sr1lowx6 = sr1low * x6; | ||
661 | r1high = r1high_stack; | ||
662 | |||
663 | x4 += y2; | ||
664 | r0highx0 = r0high * x0; | ||
665 | sr2low = sr2low_stack; | ||
666 | |||
667 | h7 = r3highx0 + r0highx6; | ||
668 | sr1highx6 = sr1high * x6; | ||
669 | sr2high = sr2high_stack; | ||
670 | |||
671 | x3 += y1; | ||
672 | r1lowx0 = r1low * x0; | ||
673 | r2low = r2low_stack; | ||
674 | |||
675 | h0 = r0lowx0 + sr1lowx6; | ||
676 | sr2lowx6 = sr2low * x6; | ||
677 | r2high = r2high_stack; | ||
678 | |||
679 | x2 += y0; | ||
680 | r1highx0 = r1high * x0; | ||
681 | sr3low = sr3low_stack; | ||
682 | |||
683 | h1 = r0highx0 + sr1highx6; | ||
684 | sr2highx6 = sr2high * x6; | ||
685 | sr3high = sr3high_stack; | ||
686 | |||
687 | x4 += x5; | ||
688 | r2lowx0 = r2low * x0; | ||
689 | z2 = *(double *) &d2; | ||
690 | |||
691 | h2 = r1lowx0 + sr2lowx6; | ||
692 | sr3lowx6 = sr3low * x6; | ||
693 | |||
694 | x2 += x3; | ||
695 | r2highx0 = r2high * x0; | ||
696 | z3 = *(double *) &d3; | ||
697 | |||
698 | h3 = r1highx0 + sr2highx6; | ||
699 | sr3highx6 = sr3high * x6; | ||
700 | |||
701 | r1highx4 = r1high * x4; | ||
702 | z2 -= alpha64; | ||
703 | |||
704 | h4 = r2lowx0 + sr3lowx6; | ||
705 | r1lowx4 = r1low * x4; | ||
706 | |||
707 | r0highx4 = r0high * x4; | ||
708 | z3 -= alpha96; | ||
709 | |||
710 | h5 = r2highx0 + sr3highx6; | ||
711 | r0lowx4 = r0low * x4; | ||
712 | |||
713 | h7 += r1highx4; | ||
714 | sr3highx4 = sr3high * x4; | ||
715 | |||
716 | h6 += r1lowx4; | ||
717 | sr3lowx4 = sr3low * x4; | ||
718 | |||
719 | h5 += r0highx4; | ||
720 | sr2highx4 = sr2high * x4; | ||
721 | |||
722 | h4 += r0lowx4; | ||
723 | sr2lowx4 = sr2low * x4; | ||
724 | |||
725 | h3 += sr3highx4; | ||
726 | r0lowx2 = r0low * x2; | ||
727 | |||
728 | h2 += sr3lowx4; | ||
729 | r0highx2 = r0high * x2; | ||
730 | |||
731 | h1 += sr2highx4; | ||
732 | r1lowx2 = r1low * x2; | ||
733 | |||
734 | h0 += sr2lowx4; | ||
735 | r1highx2 = r1high * x2; | ||
736 | |||
737 | h2 += r0lowx2; | ||
738 | r2lowx2 = r2low * x2; | ||
739 | |||
740 | h3 += r0highx2; | ||
741 | r2highx2 = r2high * x2; | ||
742 | |||
743 | h4 += r1lowx2; | ||
744 | sr3lowx2 = sr3low * x2; | ||
745 | |||
746 | h5 += r1highx2; | ||
747 | sr3highx2 = sr3high * x2; | ||
748 | alpha0 = *(double *) (constants + 24); | ||
749 | |||
750 | m += 16; | ||
751 | h6 += r2lowx2; | ||
752 | |||
753 | l -= 16; | ||
754 | h7 += r2highx2; | ||
755 | |||
756 | z1 = *(double *) &d1; | ||
757 | h0 += sr3lowx2; | ||
758 | |||
759 | z0 = *(double *) &d0; | ||
760 | h1 += sr3highx2; | ||
761 | |||
762 | z1 -= alpha32; | ||
763 | |||
764 | z0 -= alpha0; | ||
765 | |||
766 | h5 += z3; | ||
767 | |||
768 | h3 += z2; | ||
769 | |||
770 | h1 += z1; | ||
771 | |||
772 | h0 += z0; | ||
773 | |||
774 | if (l >= 16) goto multiplyaddatleast16bytes; | ||
775 | |||
776 | multiplyaddatmost15bytes:; | ||
777 | |||
778 | y7 = h7 + alpha130; | ||
779 | |||
780 | y6 = h6 + alpha130; | ||
781 | |||
782 | y1 = h1 + alpha32; | ||
783 | |||
784 | y0 = h0 + alpha32; | ||
785 | |||
786 | y7 -= alpha130; | ||
787 | |||
788 | y6 -= alpha130; | ||
789 | |||
790 | y1 -= alpha32; | ||
791 | |||
792 | y0 -= alpha32; | ||
793 | |||
794 | y5 = h5 + alpha96; | ||
795 | |||
796 | y4 = h4 + alpha96; | ||
797 | |||
798 | x7 = h7 - y7; | ||
799 | y7 *= scale; | ||
800 | |||
801 | x6 = h6 - y6; | ||
802 | y6 *= scale; | ||
803 | |||
804 | x1 = h1 - y1; | ||
805 | |||
806 | x0 = h0 - y0; | ||
807 | |||
808 | y5 -= alpha96; | ||
809 | |||
810 | y4 -= alpha96; | ||
811 | |||
812 | x1 += y7; | ||
813 | |||
814 | x0 += y6; | ||
815 | |||
816 | x7 += y5; | ||
817 | |||
818 | x6 += y4; | ||
819 | |||
820 | y3 = h3 + alpha64; | ||
821 | |||
822 | y2 = h2 + alpha64; | ||
823 | |||
824 | x0 += x1; | ||
825 | |||
826 | x6 += x7; | ||
827 | |||
828 | y3 -= alpha64; | ||
829 | r3low = r3low_stack; | ||
830 | |||
831 | y2 -= alpha64; | ||
832 | r0low = r0low_stack; | ||
833 | |||
834 | x5 = h5 - y5; | ||
835 | r3lowx0 = r3low * x0; | ||
836 | r3high = r3high_stack; | ||
837 | |||
838 | x4 = h4 - y4; | ||
839 | r0lowx6 = r0low * x6; | ||
840 | r0high = r0high_stack; | ||
841 | |||
842 | x3 = h3 - y3; | ||
843 | r3highx0 = r3high * x0; | ||
844 | sr1low = sr1low_stack; | ||
845 | |||
846 | x2 = h2 - y2; | ||
847 | r0highx6 = r0high * x6; | ||
848 | sr1high = sr1high_stack; | ||
849 | |||
850 | x5 += y3; | ||
851 | r0lowx0 = r0low * x0; | ||
852 | r1low = r1low_stack; | ||
853 | |||
854 | h6 = r3lowx0 + r0lowx6; | ||
855 | sr1lowx6 = sr1low * x6; | ||
856 | r1high = r1high_stack; | ||
857 | |||
858 | x4 += y2; | ||
859 | r0highx0 = r0high * x0; | ||
860 | sr2low = sr2low_stack; | ||
861 | |||
862 | h7 = r3highx0 + r0highx6; | ||
863 | sr1highx6 = sr1high * x6; | ||
864 | sr2high = sr2high_stack; | ||
865 | |||
866 | x3 += y1; | ||
867 | r1lowx0 = r1low * x0; | ||
868 | r2low = r2low_stack; | ||
869 | |||
870 | h0 = r0lowx0 + sr1lowx6; | ||
871 | sr2lowx6 = sr2low * x6; | ||
872 | r2high = r2high_stack; | ||
873 | |||
874 | x2 += y0; | ||
875 | r1highx0 = r1high * x0; | ||
876 | sr3low = sr3low_stack; | ||
877 | |||
878 | h1 = r0highx0 + sr1highx6; | ||
879 | sr2highx6 = sr2high * x6; | ||
880 | sr3high = sr3high_stack; | ||
881 | |||
882 | x4 += x5; | ||
883 | r2lowx0 = r2low * x0; | ||
884 | |||
885 | h2 = r1lowx0 + sr2lowx6; | ||
886 | sr3lowx6 = sr3low * x6; | ||
887 | |||
888 | x2 += x3; | ||
889 | r2highx0 = r2high * x0; | ||
890 | |||
891 | h3 = r1highx0 + sr2highx6; | ||
892 | sr3highx6 = sr3high * x6; | ||
893 | |||
894 | r1highx4 = r1high * x4; | ||
895 | |||
896 | h4 = r2lowx0 + sr3lowx6; | ||
897 | r1lowx4 = r1low * x4; | ||
898 | |||
899 | r0highx4 = r0high * x4; | ||
900 | |||
901 | h5 = r2highx0 + sr3highx6; | ||
902 | r0lowx4 = r0low * x4; | ||
903 | |||
904 | h7 += r1highx4; | ||
905 | sr3highx4 = sr3high * x4; | ||
906 | |||
907 | h6 += r1lowx4; | ||
908 | sr3lowx4 = sr3low * x4; | ||
909 | |||
910 | h5 += r0highx4; | ||
911 | sr2highx4 = sr2high * x4; | ||
912 | |||
913 | h4 += r0lowx4; | ||
914 | sr2lowx4 = sr2low * x4; | ||
915 | |||
916 | h3 += sr3highx4; | ||
917 | r0lowx2 = r0low * x2; | ||
918 | |||
919 | h2 += sr3lowx4; | ||
920 | r0highx2 = r0high * x2; | ||
921 | |||
922 | h1 += sr2highx4; | ||
923 | r1lowx2 = r1low * x2; | ||
924 | |||
925 | h0 += sr2lowx4; | ||
926 | r1highx2 = r1high * x2; | ||
927 | |||
928 | h2 += r0lowx2; | ||
929 | r2lowx2 = r2low * x2; | ||
930 | |||
931 | h3 += r0highx2; | ||
932 | r2highx2 = r2high * x2; | ||
933 | |||
934 | h4 += r1lowx2; | ||
935 | sr3lowx2 = sr3low * x2; | ||
936 | |||
937 | h5 += r1highx2; | ||
938 | sr3highx2 = sr3high * x2; | ||
939 | |||
940 | h6 += r2lowx2; | ||
941 | |||
942 | h7 += r2highx2; | ||
943 | |||
944 | h0 += sr3lowx2; | ||
945 | |||
946 | h1 += sr3highx2; | ||
947 | |||
948 | addatmost15bytes:; | ||
949 | |||
950 | if (l == 0) goto nomorebytes; | ||
951 | |||
952 | lbelow2 = l - 2; | ||
953 | |||
954 | lbelow3 = l - 3; | ||
955 | |||
956 | lbelow2 >>= 31; | ||
957 | lbelow4 = l - 4; | ||
958 | |||
959 | m00 = *(uchar *) (m + 0); | ||
960 | lbelow3 >>= 31; | ||
961 | m += lbelow2; | ||
962 | |||
963 | m01 = *(uchar *) (m + 1); | ||
964 | lbelow4 >>= 31; | ||
965 | m += lbelow3; | ||
966 | |||
967 | m02 = *(uchar *) (m + 2); | ||
968 | m += lbelow4; | ||
969 | m0 = 2151; | ||
970 | |||
971 | m03 = *(uchar *) (m + 3); | ||
972 | m0 <<= 51; | ||
973 | m1 = 2215; | ||
974 | |||
975 | m0 += m00; | ||
976 | m01 &= ~lbelow2; | ||
977 | |||
978 | m02 &= ~lbelow3; | ||
979 | m01 -= lbelow2; | ||
980 | |||
981 | m01 <<= 8; | ||
982 | m03 &= ~lbelow4; | ||
983 | |||
984 | m0 += m01; | ||
985 | lbelow2 -= lbelow3; | ||
986 | |||
987 | m02 += lbelow2; | ||
988 | lbelow3 -= lbelow4; | ||
989 | |||
990 | m02 <<= 16; | ||
991 | m03 += lbelow3; | ||
992 | |||
993 | m03 <<= 24; | ||
994 | m0 += m02; | ||
995 | |||
996 | m0 += m03; | ||
997 | lbelow5 = l - 5; | ||
998 | |||
999 | lbelow6 = l - 6; | ||
1000 | lbelow7 = l - 7; | ||
1001 | |||
1002 | lbelow5 >>= 31; | ||
1003 | lbelow8 = l - 8; | ||
1004 | |||
1005 | lbelow6 >>= 31; | ||
1006 | m += lbelow5; | ||
1007 | |||
1008 | m10 = *(uchar *) (m + 4); | ||
1009 | lbelow7 >>= 31; | ||
1010 | m += lbelow6; | ||
1011 | |||
1012 | m11 = *(uchar *) (m + 5); | ||
1013 | lbelow8 >>= 31; | ||
1014 | m += lbelow7; | ||
1015 | |||
1016 | m12 = *(uchar *) (m + 6); | ||
1017 | m1 <<= 51; | ||
1018 | m += lbelow8; | ||
1019 | |||
1020 | m13 = *(uchar *) (m + 7); | ||
1021 | m10 &= ~lbelow5; | ||
1022 | lbelow4 -= lbelow5; | ||
1023 | |||
1024 | m10 += lbelow4; | ||
1025 | lbelow5 -= lbelow6; | ||
1026 | |||
1027 | m11 &= ~lbelow6; | ||
1028 | m11 += lbelow5; | ||
1029 | |||
1030 | m11 <<= 8; | ||
1031 | m1 += m10; | ||
1032 | |||
1033 | m1 += m11; | ||
1034 | m12 &= ~lbelow7; | ||
1035 | |||
1036 | lbelow6 -= lbelow7; | ||
1037 | m13 &= ~lbelow8; | ||
1038 | |||
1039 | m12 += lbelow6; | ||
1040 | lbelow7 -= lbelow8; | ||
1041 | |||
1042 | m12 <<= 16; | ||
1043 | m13 += lbelow7; | ||
1044 | |||
1045 | m13 <<= 24; | ||
1046 | m1 += m12; | ||
1047 | |||
1048 | m1 += m13; | ||
1049 | m2 = 2279; | ||
1050 | |||
1051 | lbelow9 = l - 9; | ||
1052 | m3 = 2343; | ||
1053 | |||
1054 | lbelow10 = l - 10; | ||
1055 | lbelow11 = l - 11; | ||
1056 | |||
1057 | lbelow9 >>= 31; | ||
1058 | lbelow12 = l - 12; | ||
1059 | |||
1060 | lbelow10 >>= 31; | ||
1061 | m += lbelow9; | ||
1062 | |||
1063 | m20 = *(uchar *) (m + 8); | ||
1064 | lbelow11 >>= 31; | ||
1065 | m += lbelow10; | ||
1066 | |||
1067 | m21 = *(uchar *) (m + 9); | ||
1068 | lbelow12 >>= 31; | ||
1069 | m += lbelow11; | ||
1070 | |||
1071 | m22 = *(uchar *) (m + 10); | ||
1072 | m2 <<= 51; | ||
1073 | m += lbelow12; | ||
1074 | |||
1075 | m23 = *(uchar *) (m + 11); | ||
1076 | m20 &= ~lbelow9; | ||
1077 | lbelow8 -= lbelow9; | ||
1078 | |||
1079 | m20 += lbelow8; | ||
1080 | lbelow9 -= lbelow10; | ||
1081 | |||
1082 | m21 &= ~lbelow10; | ||
1083 | m21 += lbelow9; | ||
1084 | |||
1085 | m21 <<= 8; | ||
1086 | m2 += m20; | ||
1087 | |||
1088 | m2 += m21; | ||
1089 | m22 &= ~lbelow11; | ||
1090 | |||
1091 | lbelow10 -= lbelow11; | ||
1092 | m23 &= ~lbelow12; | ||
1093 | |||
1094 | m22 += lbelow10; | ||
1095 | lbelow11 -= lbelow12; | ||
1096 | |||
1097 | m22 <<= 16; | ||
1098 | m23 += lbelow11; | ||
1099 | |||
1100 | m23 <<= 24; | ||
1101 | m2 += m22; | ||
1102 | |||
1103 | m3 <<= 51; | ||
1104 | lbelow13 = l - 13; | ||
1105 | |||
1106 | lbelow13 >>= 31; | ||
1107 | lbelow14 = l - 14; | ||
1108 | |||
1109 | lbelow14 >>= 31; | ||
1110 | m += lbelow13; | ||
1111 | lbelow15 = l - 15; | ||
1112 | |||
1113 | m30 = *(uchar *) (m + 12); | ||
1114 | lbelow15 >>= 31; | ||
1115 | m += lbelow14; | ||
1116 | |||
1117 | m31 = *(uchar *) (m + 13); | ||
1118 | m += lbelow15; | ||
1119 | m2 += m23; | ||
1120 | |||
1121 | m32 = *(uchar *) (m + 14); | ||
1122 | m30 &= ~lbelow13; | ||
1123 | lbelow12 -= lbelow13; | ||
1124 | |||
1125 | m30 += lbelow12; | ||
1126 | lbelow13 -= lbelow14; | ||
1127 | |||
1128 | m3 += m30; | ||
1129 | m31 &= ~lbelow14; | ||
1130 | |||
1131 | m31 += lbelow13; | ||
1132 | m32 &= ~lbelow15; | ||
1133 | |||
1134 | m31 <<= 8; | ||
1135 | lbelow14 -= lbelow15; | ||
1136 | |||
1137 | m3 += m31; | ||
1138 | m32 += lbelow14; | ||
1139 | d0 = m0; | ||
1140 | |||
1141 | m32 <<= 16; | ||
1142 | m33 = lbelow15 + 1; | ||
1143 | d1 = m1; | ||
1144 | |||
1145 | m33 <<= 24; | ||
1146 | m3 += m32; | ||
1147 | d2 = m2; | ||
1148 | |||
1149 | m3 += m33; | ||
1150 | d3 = m3; | ||
1151 | |||
1152 | alpha0 = *(double *) (constants + 24); | ||
1153 | |||
1154 | z3 = *(double *) &d3; | ||
1155 | |||
1156 | z2 = *(double *) &d2; | ||
1157 | |||
1158 | z1 = *(double *) &d1; | ||
1159 | |||
1160 | z0 = *(double *) &d0; | ||
1161 | |||
1162 | z3 -= alpha96; | ||
1163 | |||
1164 | z2 -= alpha64; | ||
1165 | |||
1166 | z1 -= alpha32; | ||
1167 | |||
1168 | z0 -= alpha0; | ||
1169 | |||
1170 | h5 += z3; | ||
1171 | |||
1172 | h3 += z2; | ||
1173 | |||
1174 | h1 += z1; | ||
1175 | |||
1176 | h0 += z0; | ||
1177 | |||
1178 | y7 = h7 + alpha130; | ||
1179 | |||
1180 | y6 = h6 + alpha130; | ||
1181 | |||
1182 | y1 = h1 + alpha32; | ||
1183 | |||
1184 | y0 = h0 + alpha32; | ||
1185 | |||
1186 | y7 -= alpha130; | ||
1187 | |||
1188 | y6 -= alpha130; | ||
1189 | |||
1190 | y1 -= alpha32; | ||
1191 | |||
1192 | y0 -= alpha32; | ||
1193 | |||
1194 | y5 = h5 + alpha96; | ||
1195 | |||
1196 | y4 = h4 + alpha96; | ||
1197 | |||
1198 | x7 = h7 - y7; | ||
1199 | y7 *= scale; | ||
1200 | |||
1201 | x6 = h6 - y6; | ||
1202 | y6 *= scale; | ||
1203 | |||
1204 | x1 = h1 - y1; | ||
1205 | |||
1206 | x0 = h0 - y0; | ||
1207 | |||
1208 | y5 -= alpha96; | ||
1209 | |||
1210 | y4 -= alpha96; | ||
1211 | |||
1212 | x1 += y7; | ||
1213 | |||
1214 | x0 += y6; | ||
1215 | |||
1216 | x7 += y5; | ||
1217 | |||
1218 | x6 += y4; | ||
1219 | |||
1220 | y3 = h3 + alpha64; | ||
1221 | |||
1222 | y2 = h2 + alpha64; | ||
1223 | |||
1224 | x0 += x1; | ||
1225 | |||
1226 | x6 += x7; | ||
1227 | |||
1228 | y3 -= alpha64; | ||
1229 | r3low = r3low_stack; | ||
1230 | |||
1231 | y2 -= alpha64; | ||
1232 | r0low = r0low_stack; | ||
1233 | |||
1234 | x5 = h5 - y5; | ||
1235 | r3lowx0 = r3low * x0; | ||
1236 | r3high = r3high_stack; | ||
1237 | |||
1238 | x4 = h4 - y4; | ||
1239 | r0lowx6 = r0low * x6; | ||
1240 | r0high = r0high_stack; | ||
1241 | |||
1242 | x3 = h3 - y3; | ||
1243 | r3highx0 = r3high * x0; | ||
1244 | sr1low = sr1low_stack; | ||
1245 | |||
1246 | x2 = h2 - y2; | ||
1247 | r0highx6 = r0high * x6; | ||
1248 | sr1high = sr1high_stack; | ||
1249 | |||
1250 | x5 += y3; | ||
1251 | r0lowx0 = r0low * x0; | ||
1252 | r1low = r1low_stack; | ||
1253 | |||
1254 | h6 = r3lowx0 + r0lowx6; | ||
1255 | sr1lowx6 = sr1low * x6; | ||
1256 | r1high = r1high_stack; | ||
1257 | |||
1258 | x4 += y2; | ||
1259 | r0highx0 = r0high * x0; | ||
1260 | sr2low = sr2low_stack; | ||
1261 | |||
1262 | h7 = r3highx0 + r0highx6; | ||
1263 | sr1highx6 = sr1high * x6; | ||
1264 | sr2high = sr2high_stack; | ||
1265 | |||
1266 | x3 += y1; | ||
1267 | r1lowx0 = r1low * x0; | ||
1268 | r2low = r2low_stack; | ||
1269 | |||
1270 | h0 = r0lowx0 + sr1lowx6; | ||
1271 | sr2lowx6 = sr2low * x6; | ||
1272 | r2high = r2high_stack; | ||
1273 | |||
1274 | x2 += y0; | ||
1275 | r1highx0 = r1high * x0; | ||
1276 | sr3low = sr3low_stack; | ||
1277 | |||
1278 | h1 = r0highx0 + sr1highx6; | ||
1279 | sr2highx6 = sr2high * x6; | ||
1280 | sr3high = sr3high_stack; | ||
1281 | |||
1282 | x4 += x5; | ||
1283 | r2lowx0 = r2low * x0; | ||
1284 | |||
1285 | h2 = r1lowx0 + sr2lowx6; | ||
1286 | sr3lowx6 = sr3low * x6; | ||
1287 | |||
1288 | x2 += x3; | ||
1289 | r2highx0 = r2high * x0; | ||
1290 | |||
1291 | h3 = r1highx0 + sr2highx6; | ||
1292 | sr3highx6 = sr3high * x6; | ||
1293 | |||
1294 | r1highx4 = r1high * x4; | ||
1295 | |||
1296 | h4 = r2lowx0 + sr3lowx6; | ||
1297 | r1lowx4 = r1low * x4; | ||
1298 | |||
1299 | r0highx4 = r0high * x4; | ||
1300 | |||
1301 | h5 = r2highx0 + sr3highx6; | ||
1302 | r0lowx4 = r0low * x4; | ||
1303 | |||
1304 | h7 += r1highx4; | ||
1305 | sr3highx4 = sr3high * x4; | ||
1306 | |||
1307 | h6 += r1lowx4; | ||
1308 | sr3lowx4 = sr3low * x4; | ||
1309 | |||
1310 | h5 += r0highx4; | ||
1311 | sr2highx4 = sr2high * x4; | ||
1312 | |||
1313 | h4 += r0lowx4; | ||
1314 | sr2lowx4 = sr2low * x4; | ||
1315 | |||
1316 | h3 += sr3highx4; | ||
1317 | r0lowx2 = r0low * x2; | ||
1318 | |||
1319 | h2 += sr3lowx4; | ||
1320 | r0highx2 = r0high * x2; | ||
1321 | |||
1322 | h1 += sr2highx4; | ||
1323 | r1lowx2 = r1low * x2; | ||
1324 | |||
1325 | h0 += sr2lowx4; | ||
1326 | r1highx2 = r1high * x2; | ||
1327 | |||
1328 | h2 += r0lowx2; | ||
1329 | r2lowx2 = r2low * x2; | ||
1330 | |||
1331 | h3 += r0highx2; | ||
1332 | r2highx2 = r2high * x2; | ||
1333 | |||
1334 | h4 += r1lowx2; | ||
1335 | sr3lowx2 = sr3low * x2; | ||
1336 | |||
1337 | h5 += r1highx2; | ||
1338 | sr3highx2 = sr3high * x2; | ||
1339 | |||
1340 | h6 += r2lowx2; | ||
1341 | |||
1342 | h7 += r2highx2; | ||
1343 | |||
1344 | h0 += sr3lowx2; | ||
1345 | |||
1346 | h1 += sr3highx2; | ||
1347 | |||
1348 | |||
1349 | nomorebytes:; | ||
1350 | |||
1351 | offset0 = *(double *) (constants + 104); | ||
1352 | y7 = h7 + alpha130; | ||
1353 | |||
1354 | offset1 = *(double *) (constants + 112); | ||
1355 | y0 = h0 + alpha32; | ||
1356 | |||
1357 | offset2 = *(double *) (constants + 120); | ||
1358 | y1 = h1 + alpha32; | ||
1359 | |||
1360 | offset3 = *(double *) (constants + 128); | ||
1361 | y2 = h2 + alpha64; | ||
1362 | |||
1363 | y7 -= alpha130; | ||
1364 | |||
1365 | y3 = h3 + alpha64; | ||
1366 | |||
1367 | y4 = h4 + alpha96; | ||
1368 | |||
1369 | y5 = h5 + alpha96; | ||
1370 | |||
1371 | x7 = h7 - y7; | ||
1372 | y7 *= scale; | ||
1373 | |||
1374 | y0 -= alpha32; | ||
1375 | |||
1376 | y1 -= alpha32; | ||
1377 | |||
1378 | y2 -= alpha64; | ||
1379 | |||
1380 | h6 += x7; | ||
1381 | |||
1382 | y3 -= alpha64; | ||
1383 | |||
1384 | y4 -= alpha96; | ||
1385 | |||
1386 | y5 -= alpha96; | ||
1387 | |||
1388 | y6 = h6 + alpha130; | ||
1389 | |||
1390 | x0 = h0 - y0; | ||
1391 | |||
1392 | x1 = h1 - y1; | ||
1393 | |||
1394 | x2 = h2 - y2; | ||
1395 | |||
1396 | y6 -= alpha130; | ||
1397 | |||
1398 | x0 += y7; | ||
1399 | |||
1400 | x3 = h3 - y3; | ||
1401 | |||
1402 | x4 = h4 - y4; | ||
1403 | |||
1404 | x5 = h5 - y5; | ||
1405 | |||
1406 | x6 = h6 - y6; | ||
1407 | |||
1408 | y6 *= scale; | ||
1409 | |||
1410 | x2 += y0; | ||
1411 | |||
1412 | x3 += y1; | ||
1413 | |||
1414 | x4 += y2; | ||
1415 | |||
1416 | x0 += y6; | ||
1417 | |||
1418 | x5 += y3; | ||
1419 | |||
1420 | x6 += y4; | ||
1421 | |||
1422 | x2 += x3; | ||
1423 | |||
1424 | x0 += x1; | ||
1425 | |||
1426 | x4 += x5; | ||
1427 | |||
1428 | x6 += y5; | ||
1429 | |||
1430 | x2 += offset1; | ||
1431 | *(double *) &d1 = x2; | ||
1432 | |||
1433 | x0 += offset0; | ||
1434 | *(double *) &d0 = x0; | ||
1435 | |||
1436 | x4 += offset2; | ||
1437 | *(double *) &d2 = x4; | ||
1438 | |||
1439 | x6 += offset3; | ||
1440 | *(double *) &d3 = x6; | ||
1441 | |||
1442 | |||
1443 | |||
1444 | |||
1445 | f0 = d0; | ||
1446 | |||
1447 | f1 = d1; | ||
1448 | bits32 = -1; | ||
1449 | |||
1450 | f2 = d2; | ||
1451 | bits32 >>= 32; | ||
1452 | |||
1453 | f3 = d3; | ||
1454 | f = f0 >> 32; | ||
1455 | |||
1456 | f0 &= bits32; | ||
1457 | f &= 255; | ||
1458 | |||
1459 | f1 += f; | ||
1460 | g0 = f0 + 5; | ||
1461 | |||
1462 | g = g0 >> 32; | ||
1463 | g0 &= bits32; | ||
1464 | |||
1465 | f = f1 >> 32; | ||
1466 | f1 &= bits32; | ||
1467 | |||
1468 | f &= 255; | ||
1469 | g1 = f1 + g; | ||
1470 | |||
1471 | g = g1 >> 32; | ||
1472 | f2 += f; | ||
1473 | |||
1474 | f = f2 >> 32; | ||
1475 | g1 &= bits32; | ||
1476 | |||
1477 | f2 &= bits32; | ||
1478 | f &= 255; | ||
1479 | |||
1480 | f3 += f; | ||
1481 | g2 = f2 + g; | ||
1482 | |||
1483 | g = g2 >> 32; | ||
1484 | g2 &= bits32; | ||
1485 | |||
1486 | f4 = f3 >> 32; | ||
1487 | f3 &= bits32; | ||
1488 | |||
1489 | f4 &= 255; | ||
1490 | g3 = f3 + g; | ||
1491 | |||
1492 | g = g3 >> 32; | ||
1493 | g3 &= bits32; | ||
1494 | |||
1495 | g4 = f4 + g; | ||
1496 | |||
1497 | g4 = g4 - 4; | ||
1498 | s00 = *(uchar *) (s + 0); | ||
1499 | |||
1500 | f = (int64) g4 >> 63; | ||
1501 | s01 = *(uchar *) (s + 1); | ||
1502 | |||
1503 | f0 &= f; | ||
1504 | g0 &= ~f; | ||
1505 | s02 = *(uchar *) (s + 2); | ||
1506 | |||
1507 | f1 &= f; | ||
1508 | f0 |= g0; | ||
1509 | s03 = *(uchar *) (s + 3); | ||
1510 | |||
1511 | g1 &= ~f; | ||
1512 | f2 &= f; | ||
1513 | s10 = *(uchar *) (s + 4); | ||
1514 | |||
1515 | f3 &= f; | ||
1516 | g2 &= ~f; | ||
1517 | s11 = *(uchar *) (s + 5); | ||
1518 | |||
1519 | g3 &= ~f; | ||
1520 | f1 |= g1; | ||
1521 | s12 = *(uchar *) (s + 6); | ||
1522 | |||
1523 | f2 |= g2; | ||
1524 | f3 |= g3; | ||
1525 | s13 = *(uchar *) (s + 7); | ||
1526 | |||
1527 | s01 <<= 8; | ||
1528 | f0 += s00; | ||
1529 | s20 = *(uchar *) (s + 8); | ||
1530 | |||
1531 | s02 <<= 16; | ||
1532 | f0 += s01; | ||
1533 | s21 = *(uchar *) (s + 9); | ||
1534 | |||
1535 | s03 <<= 24; | ||
1536 | f0 += s02; | ||
1537 | s22 = *(uchar *) (s + 10); | ||
1538 | |||
1539 | s11 <<= 8; | ||
1540 | f1 += s10; | ||
1541 | s23 = *(uchar *) (s + 11); | ||
1542 | |||
1543 | s12 <<= 16; | ||
1544 | f1 += s11; | ||
1545 | s30 = *(uchar *) (s + 12); | ||
1546 | |||
1547 | s13 <<= 24; | ||
1548 | f1 += s12; | ||
1549 | s31 = *(uchar *) (s + 13); | ||
1550 | |||
1551 | f0 += s03; | ||
1552 | f1 += s13; | ||
1553 | s32 = *(uchar *) (s + 14); | ||
1554 | |||
1555 | s21 <<= 8; | ||
1556 | f2 += s20; | ||
1557 | s33 = *(uchar *) (s + 15); | ||
1558 | |||
1559 | s22 <<= 16; | ||
1560 | f2 += s21; | ||
1561 | |||
1562 | s23 <<= 24; | ||
1563 | f2 += s22; | ||
1564 | |||
1565 | s31 <<= 8; | ||
1566 | f3 += s30; | ||
1567 | |||
1568 | s32 <<= 16; | ||
1569 | f3 += s31; | ||
1570 | |||
1571 | s33 <<= 24; | ||
1572 | f3 += s32; | ||
1573 | |||
1574 | f2 += s23; | ||
1575 | f3 += s33; | ||
1576 | |||
1577 | *(uchar *) (out + 0) = f0; | ||
1578 | f0 >>= 8; | ||
1579 | *(uchar *) (out + 1) = f0; | ||
1580 | f0 >>= 8; | ||
1581 | *(uchar *) (out + 2) = f0; | ||
1582 | f0 >>= 8; | ||
1583 | *(uchar *) (out + 3) = f0; | ||
1584 | f0 >>= 8; | ||
1585 | f1 += f0; | ||
1586 | |||
1587 | *(uchar *) (out + 4) = f1; | ||
1588 | f1 >>= 8; | ||
1589 | *(uchar *) (out + 5) = f1; | ||
1590 | f1 >>= 8; | ||
1591 | *(uchar *) (out + 6) = f1; | ||
1592 | f1 >>= 8; | ||
1593 | *(uchar *) (out + 7) = f1; | ||
1594 | f1 >>= 8; | ||
1595 | f2 += f1; | ||
1596 | |||
1597 | *(uchar *) (out + 8) = f2; | ||
1598 | f2 >>= 8; | ||
1599 | *(uchar *) (out + 9) = f2; | ||
1600 | f2 >>= 8; | ||
1601 | *(uchar *) (out + 10) = f2; | ||
1602 | f2 >>= 8; | ||
1603 | *(uchar *) (out + 11) = f2; | ||
1604 | f2 >>= 8; | ||
1605 | f3 += f2; | ||
1606 | |||
1607 | *(uchar *) (out + 12) = f3; | ||
1608 | f3 >>= 8; | ||
1609 | *(uchar *) (out + 13) = f3; | ||
1610 | f3 >>= 8; | ||
1611 | *(uchar *) (out + 14) = f3; | ||
1612 | f3 >>= 8; | ||
1613 | *(uchar *) (out + 15) = f3; | ||
1614 | |||
1615 | return 0; | ||
1616 | } | ||
diff --git a/nacl/crypto_onetimeauth/poly1305/53/verify.c b/nacl/crypto_onetimeauth/poly1305/53/verify.c deleted file mode 100644 index c7e063f1..00000000 --- a/nacl/crypto_onetimeauth/poly1305/53/verify.c +++ /dev/null | |||
@@ -1,9 +0,0 @@ | |||
1 | #include "crypto_verify_16.h" | ||
2 | #include "crypto_onetimeauth.h" | ||
3 | |||
4 | int crypto_onetimeauth_verify(const unsigned char *h,const unsigned char *in,unsigned long long inlen,const unsigned char *k) | ||
5 | { | ||
6 | unsigned char correct[16]; | ||
7 | crypto_onetimeauth(correct,in,inlen,k); | ||
8 | return crypto_verify_16(h,correct); | ||
9 | } | ||
diff --git a/nacl/crypto_onetimeauth/poly1305/amd64/api.h b/nacl/crypto_onetimeauth/poly1305/amd64/api.h deleted file mode 100644 index acc133ed..00000000 --- a/nacl/crypto_onetimeauth/poly1305/amd64/api.h +++ /dev/null | |||
@@ -1,2 +0,0 @@ | |||
1 | #define CRYPTO_BYTES 16 | ||
2 | #define CRYPTO_KEYBYTES 32 | ||
diff --git a/nacl/crypto_onetimeauth/poly1305/amd64/auth.s b/nacl/crypto_onetimeauth/poly1305/amd64/auth.s deleted file mode 100644 index 5212a3e7..00000000 --- a/nacl/crypto_onetimeauth/poly1305/amd64/auth.s +++ /dev/null | |||
@@ -1,2787 +0,0 @@ | |||
1 | |||
2 | # qhasm: int64 r11_caller | ||
3 | |||
4 | # qhasm: int64 r12_caller | ||
5 | |||
6 | # qhasm: int64 r13_caller | ||
7 | |||
8 | # qhasm: int64 r14_caller | ||
9 | |||
10 | # qhasm: int64 r15_caller | ||
11 | |||
12 | # qhasm: int64 rbx_caller | ||
13 | |||
14 | # qhasm: int64 rbp_caller | ||
15 | |||
16 | # qhasm: caller r11_caller | ||
17 | |||
18 | # qhasm: caller r12_caller | ||
19 | |||
20 | # qhasm: caller r13_caller | ||
21 | |||
22 | # qhasm: caller r14_caller | ||
23 | |||
24 | # qhasm: caller r15_caller | ||
25 | |||
26 | # qhasm: caller rbx_caller | ||
27 | |||
28 | # qhasm: caller rbp_caller | ||
29 | |||
30 | # qhasm: stack64 r11_stack | ||
31 | |||
32 | # qhasm: stack64 r12_stack | ||
33 | |||
34 | # qhasm: stack64 r13_stack | ||
35 | |||
36 | # qhasm: stack64 r14_stack | ||
37 | |||
38 | # qhasm: stack64 r15_stack | ||
39 | |||
40 | # qhasm: stack64 rbx_stack | ||
41 | |||
42 | # qhasm: stack64 rbp_stack | ||
43 | |||
44 | # qhasm: int64 out | ||
45 | |||
46 | # qhasm: stack64 out_stack | ||
47 | |||
48 | # qhasm: int64 m | ||
49 | |||
50 | # qhasm: int64 l | ||
51 | |||
52 | # qhasm: int64 k | ||
53 | |||
54 | # qhasm: stack64 k_stack | ||
55 | |||
56 | # qhasm: int64 m0 | ||
57 | |||
58 | # qhasm: int64 m1 | ||
59 | |||
60 | # qhasm: int64 m2 | ||
61 | |||
62 | # qhasm: int64 m3 | ||
63 | |||
64 | # qhasm: float80 a0 | ||
65 | |||
66 | # qhasm: float80 a1 | ||
67 | |||
68 | # qhasm: float80 a2 | ||
69 | |||
70 | # qhasm: float80 a3 | ||
71 | |||
72 | # qhasm: float80 h0 | ||
73 | |||
74 | # qhasm: float80 h1 | ||
75 | |||
76 | # qhasm: float80 h2 | ||
77 | |||
78 | # qhasm: float80 h3 | ||
79 | |||
80 | # qhasm: float80 x0 | ||
81 | |||
82 | # qhasm: float80 x1 | ||
83 | |||
84 | # qhasm: float80 x2 | ||
85 | |||
86 | # qhasm: float80 x3 | ||
87 | |||
88 | # qhasm: float80 y0 | ||
89 | |||
90 | # qhasm: float80 y1 | ||
91 | |||
92 | # qhasm: float80 y2 | ||
93 | |||
94 | # qhasm: float80 y3 | ||
95 | |||
96 | # qhasm: float80 r0x0 | ||
97 | |||
98 | # qhasm: float80 r1x0 | ||
99 | |||
100 | # qhasm: float80 r2x0 | ||
101 | |||
102 | # qhasm: float80 r3x0 | ||
103 | |||
104 | # qhasm: float80 r0x1 | ||
105 | |||
106 | # qhasm: float80 r1x1 | ||
107 | |||
108 | # qhasm: float80 r2x1 | ||
109 | |||
110 | # qhasm: float80 sr3x1 | ||
111 | |||
112 | # qhasm: float80 r0x2 | ||
113 | |||
114 | # qhasm: float80 r1x2 | ||
115 | |||
116 | # qhasm: float80 sr2x2 | ||
117 | |||
118 | # qhasm: float80 sr3x2 | ||
119 | |||
120 | # qhasm: float80 r0x3 | ||
121 | |||
122 | # qhasm: float80 sr1x3 | ||
123 | |||
124 | # qhasm: float80 sr2x3 | ||
125 | |||
126 | # qhasm: float80 sr3x3 | ||
127 | |||
128 | # qhasm: stack64 d0 | ||
129 | |||
130 | # qhasm: stack64 d1 | ||
131 | |||
132 | # qhasm: stack64 d2 | ||
133 | |||
134 | # qhasm: stack64 d3 | ||
135 | |||
136 | # qhasm: stack64 r0 | ||
137 | |||
138 | # qhasm: stack64 r1 | ||
139 | |||
140 | # qhasm: stack64 r2 | ||
141 | |||
142 | # qhasm: stack64 r3 | ||
143 | |||
144 | # qhasm: stack64 sr1 | ||
145 | |||
146 | # qhasm: stack64 sr2 | ||
147 | |||
148 | # qhasm: stack64 sr3 | ||
149 | |||
150 | # qhasm: enter crypto_onetimeauth_poly1305_amd64 | ||
151 | .text | ||
152 | .p2align 5 | ||
153 | .globl _crypto_onetimeauth_poly1305_amd64 | ||
154 | .globl crypto_onetimeauth_poly1305_amd64 | ||
155 | _crypto_onetimeauth_poly1305_amd64: | ||
156 | crypto_onetimeauth_poly1305_amd64: | ||
157 | mov %rsp,%r11 | ||
158 | and $31,%r11 | ||
159 | add $192,%r11 | ||
160 | sub %r11,%rsp | ||
161 | |||
162 | # qhasm: input out | ||
163 | |||
164 | # qhasm: input m | ||
165 | |||
166 | # qhasm: input l | ||
167 | |||
168 | # qhasm: input k | ||
169 | |||
170 | # qhasm: r11_stack = r11_caller | ||
171 | # asm 1: movq <r11_caller=int64#9,>r11_stack=stack64#1 | ||
172 | # asm 2: movq <r11_caller=%r11,>r11_stack=32(%rsp) | ||
173 | movq %r11,32(%rsp) | ||
174 | |||
175 | # qhasm: r12_stack = r12_caller | ||
176 | # asm 1: movq <r12_caller=int64#10,>r12_stack=stack64#2 | ||
177 | # asm 2: movq <r12_caller=%r12,>r12_stack=40(%rsp) | ||
178 | movq %r12,40(%rsp) | ||
179 | |||
180 | # qhasm: r13_stack = r13_caller | ||
181 | # asm 1: movq <r13_caller=int64#11,>r13_stack=stack64#3 | ||
182 | # asm 2: movq <r13_caller=%r13,>r13_stack=48(%rsp) | ||
183 | movq %r13,48(%rsp) | ||
184 | |||
185 | # qhasm: r14_stack = r14_caller | ||
186 | # asm 1: movq <r14_caller=int64#12,>r14_stack=stack64#4 | ||
187 | # asm 2: movq <r14_caller=%r14,>r14_stack=56(%rsp) | ||
188 | movq %r14,56(%rsp) | ||
189 | |||
190 | # qhasm: r15_stack = r15_caller | ||
191 | # asm 1: movq <r15_caller=int64#13,>r15_stack=stack64#5 | ||
192 | # asm 2: movq <r15_caller=%r15,>r15_stack=64(%rsp) | ||
193 | movq %r15,64(%rsp) | ||
194 | |||
195 | # qhasm: rbx_stack = rbx_caller | ||
196 | # asm 1: movq <rbx_caller=int64#14,>rbx_stack=stack64#6 | ||
197 | # asm 2: movq <rbx_caller=%rbx,>rbx_stack=72(%rsp) | ||
198 | movq %rbx,72(%rsp) | ||
199 | |||
200 | # qhasm: rbp_stack = rbp_caller | ||
201 | # asm 1: movq <rbp_caller=int64#15,>rbp_stack=stack64#7 | ||
202 | # asm 2: movq <rbp_caller=%rbp,>rbp_stack=80(%rsp) | ||
203 | movq %rbp,80(%rsp) | ||
204 | |||
205 | # qhasm: round *(uint16 *) &crypto_onetimeauth_poly1305_amd64_rounding | ||
206 | fldcw crypto_onetimeauth_poly1305_amd64_rounding(%rip) | ||
207 | |||
208 | # qhasm: m0 = *(uint32 *) (k + 0) | ||
209 | # asm 1: movl 0(<k=int64#4),>m0=int64#5d | ||
210 | # asm 2: movl 0(<k=%rcx),>m0=%r8d | ||
211 | movl 0(%rcx),%r8d | ||
212 | |||
213 | # qhasm: m1 = *(uint32 *) (k + 4) | ||
214 | # asm 1: movl 4(<k=int64#4),>m1=int64#6d | ||
215 | # asm 2: movl 4(<k=%rcx),>m1=%r9d | ||
216 | movl 4(%rcx),%r9d | ||
217 | |||
218 | # qhasm: m2 = *(uint32 *) (k + 8) | ||
219 | # asm 1: movl 8(<k=int64#4),>m2=int64#7d | ||
220 | # asm 2: movl 8(<k=%rcx),>m2=%eax | ||
221 | movl 8(%rcx),%eax | ||
222 | |||
223 | # qhasm: m3 = *(uint32 *) (k + 12) | ||
224 | # asm 1: movl 12(<k=int64#4),>m3=int64#8d | ||
225 | # asm 2: movl 12(<k=%rcx),>m3=%r10d | ||
226 | movl 12(%rcx),%r10d | ||
227 | |||
228 | # qhasm: out_stack = out | ||
229 | # asm 1: movq <out=int64#1,>out_stack=stack64#8 | ||
230 | # asm 2: movq <out=%rdi,>out_stack=88(%rsp) | ||
231 | movq %rdi,88(%rsp) | ||
232 | |||
233 | # qhasm: k_stack = k | ||
234 | # asm 1: movq <k=int64#4,>k_stack=stack64#9 | ||
235 | # asm 2: movq <k=%rcx,>k_stack=96(%rsp) | ||
236 | movq %rcx,96(%rsp) | ||
237 | |||
238 | # qhasm: d0 top = 0x43300000 | ||
239 | # asm 1: movl $0x43300000,>d0=stack64#10 | ||
240 | # asm 2: movl $0x43300000,>d0=108(%rsp) | ||
241 | movl $0x43300000,108(%rsp) | ||
242 | |||
243 | # qhasm: d1 top = 0x45300000 | ||
244 | # asm 1: movl $0x45300000,>d1=stack64#11 | ||
245 | # asm 2: movl $0x45300000,>d1=116(%rsp) | ||
246 | movl $0x45300000,116(%rsp) | ||
247 | |||
248 | # qhasm: d2 top = 0x47300000 | ||
249 | # asm 1: movl $0x47300000,>d2=stack64#12 | ||
250 | # asm 2: movl $0x47300000,>d2=124(%rsp) | ||
251 | movl $0x47300000,124(%rsp) | ||
252 | |||
253 | # qhasm: d3 top = 0x49300000 | ||
254 | # asm 1: movl $0x49300000,>d3=stack64#13 | ||
255 | # asm 2: movl $0x49300000,>d3=132(%rsp) | ||
256 | movl $0x49300000,132(%rsp) | ||
257 | |||
258 | # qhasm: (uint32) m0 &= 0x0fffffff | ||
259 | # asm 1: and $0x0fffffff,<m0=int64#5d | ||
260 | # asm 2: and $0x0fffffff,<m0=%r8d | ||
261 | and $0x0fffffff,%r8d | ||
262 | |||
263 | # qhasm: (uint32) m1 &= 0x0ffffffc | ||
264 | # asm 1: and $0x0ffffffc,<m1=int64#6d | ||
265 | # asm 2: and $0x0ffffffc,<m1=%r9d | ||
266 | and $0x0ffffffc,%r9d | ||
267 | |||
268 | # qhasm: (uint32) m2 &= 0x0ffffffc | ||
269 | # asm 1: and $0x0ffffffc,<m2=int64#7d | ||
270 | # asm 2: and $0x0ffffffc,<m2=%eax | ||
271 | and $0x0ffffffc,%eax | ||
272 | |||
273 | # qhasm: (uint32) m3 &= 0x0ffffffc | ||
274 | # asm 1: and $0x0ffffffc,<m3=int64#8d | ||
275 | # asm 2: and $0x0ffffffc,<m3=%r10d | ||
276 | and $0x0ffffffc,%r10d | ||
277 | |||
278 | # qhasm: inplace d0 bottom = m0 | ||
279 | # asm 1: movl <m0=int64#5d,<d0=stack64#10 | ||
280 | # asm 2: movl <m0=%r8d,<d0=104(%rsp) | ||
281 | movl %r8d,104(%rsp) | ||
282 | |||
283 | # qhasm: inplace d1 bottom = m1 | ||
284 | # asm 1: movl <m1=int64#6d,<d1=stack64#11 | ||
285 | # asm 2: movl <m1=%r9d,<d1=112(%rsp) | ||
286 | movl %r9d,112(%rsp) | ||
287 | |||
288 | # qhasm: inplace d2 bottom = m2 | ||
289 | # asm 1: movl <m2=int64#7d,<d2=stack64#12 | ||
290 | # asm 2: movl <m2=%eax,<d2=120(%rsp) | ||
291 | movl %eax,120(%rsp) | ||
292 | |||
293 | # qhasm: inplace d3 bottom = m3 | ||
294 | # asm 1: movl <m3=int64#8d,<d3=stack64#13 | ||
295 | # asm 2: movl <m3=%r10d,<d3=128(%rsp) | ||
296 | movl %r10d,128(%rsp) | ||
297 | |||
298 | # qhasm: a0 = *(float64 *) &d0 | ||
299 | # asm 1: fldl <d0=stack64#10 | ||
300 | # asm 2: fldl <d0=104(%rsp) | ||
301 | fldl 104(%rsp) | ||
302 | # comment:fpstackfrombottom:<a0#28: | ||
303 | |||
304 | # qhasm: a0 -= *(float64 *) &crypto_onetimeauth_poly1305_amd64_doffset0 | ||
305 | fsubl crypto_onetimeauth_poly1305_amd64_doffset0(%rip) | ||
306 | # comment:fpstackfrombottom:<a0#28: | ||
307 | |||
308 | # qhasm: a1 = *(float64 *) &d1 | ||
309 | # asm 1: fldl <d1=stack64#11 | ||
310 | # asm 2: fldl <d1=112(%rsp) | ||
311 | fldl 112(%rsp) | ||
312 | # comment:fpstackfrombottom:<a0#28:<a1#29: | ||
313 | |||
314 | # qhasm: a1 -= *(float64 *) &crypto_onetimeauth_poly1305_amd64_doffset1 | ||
315 | fsubl crypto_onetimeauth_poly1305_amd64_doffset1(%rip) | ||
316 | # comment:fpstackfrombottom:<a0#28:<a1#29: | ||
317 | |||
318 | # qhasm: a2 = *(float64 *) &d2 | ||
319 | # asm 1: fldl <d2=stack64#12 | ||
320 | # asm 2: fldl <d2=120(%rsp) | ||
321 | fldl 120(%rsp) | ||
322 | # comment:fpstackfrombottom:<a0#28:<a1#29:<a2#30: | ||
323 | |||
324 | # qhasm: a2 -= *(float64 *) &crypto_onetimeauth_poly1305_amd64_doffset2 | ||
325 | fsubl crypto_onetimeauth_poly1305_amd64_doffset2(%rip) | ||
326 | # comment:fpstackfrombottom:<a0#28:<a1#29:<a2#30: | ||
327 | |||
328 | # qhasm: a3 = *(float64 *) &d3 | ||
329 | # asm 1: fldl <d3=stack64#13 | ||
330 | # asm 2: fldl <d3=128(%rsp) | ||
331 | fldl 128(%rsp) | ||
332 | # comment:fpstackfrombottom:<a0#28:<a1#29:<a2#30:<a3#31: | ||
333 | |||
334 | # qhasm: a3 -= *(float64 *) &crypto_onetimeauth_poly1305_amd64_doffset3 | ||
335 | fsubl crypto_onetimeauth_poly1305_amd64_doffset3(%rip) | ||
336 | # comment:fpstackfrombottom:<a0#28:<a1#29:<a2#30:<a3#31: | ||
337 | |||
338 | # qhasm: internal stacktop a0 | ||
339 | # asm 1: fxch <a0=float80#4 | ||
340 | # asm 2: fxch <a0=%st(3) | ||
341 | fxch %st(3) | ||
342 | |||
343 | # qhasm: *(float64 *) &r0 = a0 | ||
344 | # asm 1: fstpl >r0=stack64#14 | ||
345 | # asm 2: fstpl >r0=136(%rsp) | ||
346 | fstpl 136(%rsp) | ||
347 | # comment:fpstackfrombottom:<a3#31:<a1#29:<a2#30: | ||
348 | |||
349 | # qhasm: internal stacktop a1 | ||
350 | # asm 1: fxch <a1=float80#2 | ||
351 | # asm 2: fxch <a1=%st(1) | ||
352 | fxch %st(1) | ||
353 | |||
354 | # qhasm: *(float64 *) &r1 = a1 | ||
355 | # asm 1: fstl >r1=stack64#15 | ||
356 | # asm 2: fstl >r1=144(%rsp) | ||
357 | fstl 144(%rsp) | ||
358 | # comment:fpstackfrombottom:<a3#31:<a2#30:<a1#29: | ||
359 | |||
360 | # qhasm: a1 *= *(float64 *) &crypto_onetimeauth_poly1305_amd64_scale | ||
361 | fmull crypto_onetimeauth_poly1305_amd64_scale(%rip) | ||
362 | # comment:fpstackfrombottom:<a3#31:<a2#30:<a1#29: | ||
363 | |||
364 | # qhasm: *(float64 *) &sr1 = a1 | ||
365 | # asm 1: fstpl >sr1=stack64#16 | ||
366 | # asm 2: fstpl >sr1=152(%rsp) | ||
367 | fstpl 152(%rsp) | ||
368 | # comment:fpstackfrombottom:<a3#31:<a2#30: | ||
369 | |||
370 | # qhasm: *(float64 *) &r2 = a2 | ||
371 | # asm 1: fstl >r2=stack64#17 | ||
372 | # asm 2: fstl >r2=160(%rsp) | ||
373 | fstl 160(%rsp) | ||
374 | # comment:fpstackfrombottom:<a3#31:<a2#30: | ||
375 | |||
376 | # qhasm: a2 *= *(float64 *) &crypto_onetimeauth_poly1305_amd64_scale | ||
377 | fmull crypto_onetimeauth_poly1305_amd64_scale(%rip) | ||
378 | # comment:fpstackfrombottom:<a3#31:<a2#30: | ||
379 | |||
380 | # qhasm: *(float64 *) &sr2 = a2 | ||
381 | # asm 1: fstpl >sr2=stack64#18 | ||
382 | # asm 2: fstpl >sr2=168(%rsp) | ||
383 | fstpl 168(%rsp) | ||
384 | # comment:fpstackfrombottom:<a3#31: | ||
385 | |||
386 | # qhasm: *(float64 *) &r3 = a3 | ||
387 | # asm 1: fstl >r3=stack64#19 | ||
388 | # asm 2: fstl >r3=176(%rsp) | ||
389 | fstl 176(%rsp) | ||
390 | # comment:fpstackfrombottom:<a3#31: | ||
391 | |||
392 | # qhasm: a3 *= *(float64 *) &crypto_onetimeauth_poly1305_amd64_scale | ||
393 | fmull crypto_onetimeauth_poly1305_amd64_scale(%rip) | ||
394 | # comment:fpstackfrombottom:<a3#31: | ||
395 | |||
396 | # qhasm: *(float64 *) &sr3 = a3 | ||
397 | # asm 1: fstpl >sr3=stack64#20 | ||
398 | # asm 2: fstpl >sr3=184(%rsp) | ||
399 | fstpl 184(%rsp) | ||
400 | # comment:fpstackfrombottom: | ||
401 | |||
402 | # qhasm: h3 = 0 | ||
403 | fldz | ||
404 | # comment:fpstackfrombottom:<h3#39: | ||
405 | |||
406 | # qhasm: h2 = 0 | ||
407 | fldz | ||
408 | # comment:fpstackfrombottom:<h3#39:<h2#40: | ||
409 | |||
410 | # qhasm: h1 = 0 | ||
411 | fldz | ||
412 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41: | ||
413 | |||
414 | # qhasm: h0 = 0 | ||
415 | fldz | ||
416 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
417 | |||
418 | # qhasm: unsigned<? l - 16 | ||
419 | # asm 1: cmp $16,<l=int64#3 | ||
420 | # asm 2: cmp $16,<l=%rdx | ||
421 | cmp $16,%rdx | ||
422 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
423 | # comment:fp stack unchanged by jump | ||
424 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
425 | |||
426 | # qhasm: goto addatmost15bytes if unsigned< | ||
427 | jb ._addatmost15bytes | ||
428 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
429 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
430 | |||
431 | # qhasm: initialatleast16bytes: | ||
432 | ._initialatleast16bytes: | ||
433 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
434 | |||
435 | # qhasm: m3 = *(uint32 *) (m + 12) | ||
436 | # asm 1: movl 12(<m=int64#2),>m3=int64#1d | ||
437 | # asm 2: movl 12(<m=%rsi),>m3=%edi | ||
438 | movl 12(%rsi),%edi | ||
439 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
440 | |||
441 | # qhasm: m2 = *(uint32 *) (m + 8) | ||
442 | # asm 1: movl 8(<m=int64#2),>m2=int64#4d | ||
443 | # asm 2: movl 8(<m=%rsi),>m2=%ecx | ||
444 | movl 8(%rsi),%ecx | ||
445 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
446 | |||
447 | # qhasm: m1 = *(uint32 *) (m + 4) | ||
448 | # asm 1: movl 4(<m=int64#2),>m1=int64#5d | ||
449 | # asm 2: movl 4(<m=%rsi),>m1=%r8d | ||
450 | movl 4(%rsi),%r8d | ||
451 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
452 | |||
453 | # qhasm: m0 = *(uint32 *) (m + 0) | ||
454 | # asm 1: movl 0(<m=int64#2),>m0=int64#6d | ||
455 | # asm 2: movl 0(<m=%rsi),>m0=%r9d | ||
456 | movl 0(%rsi),%r9d | ||
457 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
458 | |||
459 | # qhasm: inplace d3 bottom = m3 | ||
460 | # asm 1: movl <m3=int64#1d,<d3=stack64#13 | ||
461 | # asm 2: movl <m3=%edi,<d3=128(%rsp) | ||
462 | movl %edi,128(%rsp) | ||
463 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
464 | |||
465 | # qhasm: inplace d2 bottom = m2 | ||
466 | # asm 1: movl <m2=int64#4d,<d2=stack64#12 | ||
467 | # asm 2: movl <m2=%ecx,<d2=120(%rsp) | ||
468 | movl %ecx,120(%rsp) | ||
469 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
470 | |||
471 | # qhasm: inplace d1 bottom = m1 | ||
472 | # asm 1: movl <m1=int64#5d,<d1=stack64#11 | ||
473 | # asm 2: movl <m1=%r8d,<d1=112(%rsp) | ||
474 | movl %r8d,112(%rsp) | ||
475 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
476 | |||
477 | # qhasm: inplace d0 bottom = m0 | ||
478 | # asm 1: movl <m0=int64#6d,<d0=stack64#10 | ||
479 | # asm 2: movl <m0=%r9d,<d0=104(%rsp) | ||
480 | movl %r9d,104(%rsp) | ||
481 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
482 | |||
483 | # qhasm: m += 16 | ||
484 | # asm 1: add $16,<m=int64#2 | ||
485 | # asm 2: add $16,<m=%rsi | ||
486 | add $16,%rsi | ||
487 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
488 | |||
489 | # qhasm: l -= 16 | ||
490 | # asm 1: sub $16,<l=int64#3 | ||
491 | # asm 2: sub $16,<l=%rdx | ||
492 | sub $16,%rdx | ||
493 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
494 | |||
495 | # qhasm: internal stacktop h3 | ||
496 | # asm 1: fxch <h3=float80#4 | ||
497 | # asm 2: fxch <h3=%st(3) | ||
498 | fxch %st(3) | ||
499 | |||
500 | # qhasm: h3 += *(float64 *) &d3 | ||
501 | # asm 1: faddl <d3=stack64#13 | ||
502 | # asm 2: faddl <d3=128(%rsp) | ||
503 | faddl 128(%rsp) | ||
504 | # comment:fpstackfrombottom:<h0#42:<h2#40:<h1#41:<h3#39: | ||
505 | |||
506 | # qhasm: h3 -= *(float64 *) &crypto_onetimeauth_poly1305_amd64_doffset3minustwo128 | ||
507 | fsubl crypto_onetimeauth_poly1305_amd64_doffset3minustwo128(%rip) | ||
508 | # comment:fpstackfrombottom:<h0#42:<h2#40:<h1#41:<h3#39: | ||
509 | |||
510 | # qhasm: internal stacktop h1 | ||
511 | # asm 1: fxch <h1=float80#2 | ||
512 | # asm 2: fxch <h1=%st(1) | ||
513 | fxch %st(1) | ||
514 | |||
515 | # qhasm: h1 += *(float64 *) &d1 | ||
516 | # asm 1: faddl <d1=stack64#11 | ||
517 | # asm 2: faddl <d1=112(%rsp) | ||
518 | faddl 112(%rsp) | ||
519 | # comment:fpstackfrombottom:<h0#42:<h2#40:<h3#39:<h1#41: | ||
520 | |||
521 | # qhasm: h1 -= *(float64 *) &crypto_onetimeauth_poly1305_amd64_doffset1 | ||
522 | fsubl crypto_onetimeauth_poly1305_amd64_doffset1(%rip) | ||
523 | # comment:fpstackfrombottom:<h0#42:<h2#40:<h3#39:<h1#41: | ||
524 | |||
525 | # qhasm: internal stacktop h2 | ||
526 | # asm 1: fxch <h2=float80#3 | ||
527 | # asm 2: fxch <h2=%st(2) | ||
528 | fxch %st(2) | ||
529 | |||
530 | # qhasm: h2 += *(float64 *) &d2 | ||
531 | # asm 1: faddl <d2=stack64#12 | ||
532 | # asm 2: faddl <d2=120(%rsp) | ||
533 | faddl 120(%rsp) | ||
534 | # comment:fpstackfrombottom:<h0#42:<h1#41:<h3#39:<h2#40: | ||
535 | |||
536 | # qhasm: h2 -= *(float64 *) &crypto_onetimeauth_poly1305_amd64_doffset2 | ||
537 | fsubl crypto_onetimeauth_poly1305_amd64_doffset2(%rip) | ||
538 | # comment:fpstackfrombottom:<h0#42:<h1#41:<h3#39:<h2#40: | ||
539 | |||
540 | # qhasm: internal stacktop h0 | ||
541 | # asm 1: fxch <h0=float80#4 | ||
542 | # asm 2: fxch <h0=%st(3) | ||
543 | fxch %st(3) | ||
544 | |||
545 | # qhasm: h0 += *(float64 *) &d0 | ||
546 | # asm 1: faddl <d0=stack64#10 | ||
547 | # asm 2: faddl <d0=104(%rsp) | ||
548 | faddl 104(%rsp) | ||
549 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42: | ||
550 | |||
551 | # qhasm: h0 -= *(float64 *) &crypto_onetimeauth_poly1305_amd64_doffset0 | ||
552 | fsubl crypto_onetimeauth_poly1305_amd64_doffset0(%rip) | ||
553 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42: | ||
554 | |||
555 | # qhasm: unsigned<? l - 16 | ||
556 | # asm 1: cmp $16,<l=int64#3 | ||
557 | # asm 2: cmp $16,<l=%rdx | ||
558 | cmp $16,%rdx | ||
559 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42: | ||
560 | # comment:fp stack unchanged by jump | ||
561 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42: | ||
562 | |||
563 | # qhasm: goto multiplyaddatmost15bytes if unsigned< | ||
564 | jb ._multiplyaddatmost15bytes | ||
565 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42: | ||
566 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42: | ||
567 | |||
568 | # qhasm: multiplyaddatleast16bytes: | ||
569 | ._multiplyaddatleast16bytes: | ||
570 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42: | ||
571 | |||
572 | # qhasm: m3 = *(uint32 *) (m + 12) | ||
573 | # asm 1: movl 12(<m=int64#2),>m3=int64#1d | ||
574 | # asm 2: movl 12(<m=%rsi),>m3=%edi | ||
575 | movl 12(%rsi),%edi | ||
576 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42: | ||
577 | |||
578 | # qhasm: m2 = *(uint32 *) (m + 8) | ||
579 | # asm 1: movl 8(<m=int64#2),>m2=int64#4d | ||
580 | # asm 2: movl 8(<m=%rsi),>m2=%ecx | ||
581 | movl 8(%rsi),%ecx | ||
582 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42: | ||
583 | |||
584 | # qhasm: m1 = *(uint32 *) (m + 4) | ||
585 | # asm 1: movl 4(<m=int64#2),>m1=int64#5d | ||
586 | # asm 2: movl 4(<m=%rsi),>m1=%r8d | ||
587 | movl 4(%rsi),%r8d | ||
588 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42: | ||
589 | |||
590 | # qhasm: m0 = *(uint32 *) (m + 0) | ||
591 | # asm 1: movl 0(<m=int64#2),>m0=int64#6d | ||
592 | # asm 2: movl 0(<m=%rsi),>m0=%r9d | ||
593 | movl 0(%rsi),%r9d | ||
594 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42: | ||
595 | |||
596 | # qhasm: inplace d3 bottom = m3 | ||
597 | # asm 1: movl <m3=int64#1d,<d3=stack64#13 | ||
598 | # asm 2: movl <m3=%edi,<d3=128(%rsp) | ||
599 | movl %edi,128(%rsp) | ||
600 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42: | ||
601 | |||
602 | # qhasm: inplace d2 bottom = m2 | ||
603 | # asm 1: movl <m2=int64#4d,<d2=stack64#12 | ||
604 | # asm 2: movl <m2=%ecx,<d2=120(%rsp) | ||
605 | movl %ecx,120(%rsp) | ||
606 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42: | ||
607 | |||
608 | # qhasm: inplace d1 bottom = m1 | ||
609 | # asm 1: movl <m1=int64#5d,<d1=stack64#11 | ||
610 | # asm 2: movl <m1=%r8d,<d1=112(%rsp) | ||
611 | movl %r8d,112(%rsp) | ||
612 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42: | ||
613 | |||
614 | # qhasm: inplace d0 bottom = m0 | ||
615 | # asm 1: movl <m0=int64#6d,<d0=stack64#10 | ||
616 | # asm 2: movl <m0=%r9d,<d0=104(%rsp) | ||
617 | movl %r9d,104(%rsp) | ||
618 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42: | ||
619 | |||
620 | # qhasm: m += 16 | ||
621 | # asm 1: add $16,<m=int64#2 | ||
622 | # asm 2: add $16,<m=%rsi | ||
623 | add $16,%rsi | ||
624 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42: | ||
625 | |||
626 | # qhasm: l -= 16 | ||
627 | # asm 1: sub $16,<l=int64#3 | ||
628 | # asm 2: sub $16,<l=%rdx | ||
629 | sub $16,%rdx | ||
630 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42: | ||
631 | |||
632 | # qhasm: x0 = *(float64 *) &crypto_onetimeauth_poly1305_amd64_alpha130 | ||
633 | fldl crypto_onetimeauth_poly1305_amd64_alpha130(%rip) | ||
634 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42:<x0#53: | ||
635 | |||
636 | # qhasm: x0 += h3 | ||
637 | # asm 1: fadd <h3=float80#3,<x0=float80#1 | ||
638 | # asm 2: fadd <h3=%st(2),<x0=%st(0) | ||
639 | fadd %st(2),%st(0) | ||
640 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42:<x0#53: | ||
641 | |||
642 | # qhasm: x0 -= *(float64 *) &crypto_onetimeauth_poly1305_amd64_alpha130 | ||
643 | fsubl crypto_onetimeauth_poly1305_amd64_alpha130(%rip) | ||
644 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42:<x0#53: | ||
645 | |||
646 | # qhasm: h3 -= x0 | ||
647 | # asm 1: fsubr <x0=float80#1,<h3=float80#3 | ||
648 | # asm 2: fsubr <x0=%st(0),<h3=%st(2) | ||
649 | fsubr %st(0),%st(2) | ||
650 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42:<x0#53: | ||
651 | |||
652 | # qhasm: x0 *= *(float64 *) &crypto_onetimeauth_poly1305_amd64_scale | ||
653 | fmull crypto_onetimeauth_poly1305_amd64_scale(%rip) | ||
654 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42:<x0#53: | ||
655 | |||
656 | # qhasm: x1 = *(float64 *) &crypto_onetimeauth_poly1305_amd64_alpha32 | ||
657 | fldl crypto_onetimeauth_poly1305_amd64_alpha32(%rip) | ||
658 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42:<x0#53:<x1#54: | ||
659 | |||
660 | # qhasm: x1 += h0 | ||
661 | # asm 1: fadd <h0=float80#3,<x1=float80#1 | ||
662 | # asm 2: fadd <h0=%st(2),<x1=%st(0) | ||
663 | fadd %st(2),%st(0) | ||
664 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42:<x0#53:<x1#54: | ||
665 | |||
666 | # qhasm: x1 -= *(float64 *) &crypto_onetimeauth_poly1305_amd64_alpha32 | ||
667 | fsubl crypto_onetimeauth_poly1305_amd64_alpha32(%rip) | ||
668 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42:<x0#53:<x1#54: | ||
669 | |||
670 | # qhasm: h0 -= x1 | ||
671 | # asm 1: fsubr <x1=float80#1,<h0=float80#3 | ||
672 | # asm 2: fsubr <x1=%st(0),<h0=%st(2) | ||
673 | fsubr %st(0),%st(2) | ||
674 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42:<x0#53:<x1#54: | ||
675 | |||
676 | # qhasm: internal stacktop h0 | ||
677 | # asm 1: fxch <h0=float80#3 | ||
678 | # asm 2: fxch <h0=%st(2) | ||
679 | fxch %st(2) | ||
680 | |||
681 | # qhasm: x0 += h0 | ||
682 | # asm 1: faddp <h0=float80#1,<x0=float80#2 | ||
683 | # asm 2: faddp <h0=%st(0),<x0=%st(1) | ||
684 | faddp %st(0),%st(1) | ||
685 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<x1#54:<x0#53: | ||
686 | |||
687 | # qhasm: x2 = *(float64 *) &crypto_onetimeauth_poly1305_amd64_alpha64 | ||
688 | fldl crypto_onetimeauth_poly1305_amd64_alpha64(%rip) | ||
689 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<x1#54:<x0#53:<x2#55: | ||
690 | |||
691 | # qhasm: x2 += h1 | ||
692 | # asm 1: fadd <h1=float80#5,<x2=float80#1 | ||
693 | # asm 2: fadd <h1=%st(4),<x2=%st(0) | ||
694 | fadd %st(4),%st(0) | ||
695 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<x1#54:<x0#53:<x2#55: | ||
696 | |||
697 | # qhasm: x2 -= *(float64 *) &crypto_onetimeauth_poly1305_amd64_alpha64 | ||
698 | fsubl crypto_onetimeauth_poly1305_amd64_alpha64(%rip) | ||
699 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<x1#54:<x0#53:<x2#55: | ||
700 | |||
701 | # qhasm: h1 -= x2 | ||
702 | # asm 1: fsubr <x2=float80#1,<h1=float80#5 | ||
703 | # asm 2: fsubr <x2=%st(0),<h1=%st(4) | ||
704 | fsubr %st(0),%st(4) | ||
705 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<x1#54:<x0#53:<x2#55: | ||
706 | |||
707 | # qhasm: x3 = *(float64 *) &crypto_onetimeauth_poly1305_amd64_alpha96 | ||
708 | fldl crypto_onetimeauth_poly1305_amd64_alpha96(%rip) | ||
709 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<x1#54:<x0#53:<x2#55:<x3#56: | ||
710 | |||
711 | # qhasm: x3 += h2 | ||
712 | # asm 1: fadd <h2=float80#7,<x3=float80#1 | ||
713 | # asm 2: fadd <h2=%st(6),<x3=%st(0) | ||
714 | fadd %st(6),%st(0) | ||
715 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<x1#54:<x0#53:<x2#55:<x3#56: | ||
716 | |||
717 | # qhasm: x3 -= *(float64 *) &crypto_onetimeauth_poly1305_amd64_alpha96 | ||
718 | fsubl crypto_onetimeauth_poly1305_amd64_alpha96(%rip) | ||
719 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<x1#54:<x0#53:<x2#55:<x3#56: | ||
720 | |||
721 | # qhasm: h2 -= x3 | ||
722 | # asm 1: fsubr <x3=float80#1,<h2=float80#7 | ||
723 | # asm 2: fsubr <x3=%st(0),<h2=%st(6) | ||
724 | fsubr %st(0),%st(6) | ||
725 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<x1#54:<x0#53:<x2#55:<x3#56: | ||
726 | |||
727 | # qhasm: internal stacktop h2 | ||
728 | # asm 1: fxch <h2=float80#7 | ||
729 | # asm 2: fxch <h2=%st(6) | ||
730 | fxch %st(6) | ||
731 | |||
732 | # qhasm: x2 += h2 | ||
733 | # asm 1: faddp <h2=float80#1,<x2=float80#2 | ||
734 | # asm 2: faddp <h2=%st(0),<x2=%st(1) | ||
735 | faddp %st(0),%st(1) | ||
736 | # comment:fpstackfrombottom:<x3#56:<h1#41:<h3#39:<x1#54:<x0#53:<x2#55: | ||
737 | |||
738 | # qhasm: internal stacktop h3 | ||
739 | # asm 1: fxch <h3=float80#4 | ||
740 | # asm 2: fxch <h3=%st(3) | ||
741 | fxch %st(3) | ||
742 | |||
743 | # qhasm: x3 += h3 | ||
744 | # asm 1: faddp <h3=float80#1,<x3=float80#6 | ||
745 | # asm 2: faddp <h3=%st(0),<x3=%st(5) | ||
746 | faddp %st(0),%st(5) | ||
747 | # comment:fpstackfrombottom:<x3#56:<h1#41:<x2#55:<x1#54:<x0#53: | ||
748 | |||
749 | # qhasm: internal stacktop h1 | ||
750 | # asm 1: fxch <h1=float80#4 | ||
751 | # asm 2: fxch <h1=%st(3) | ||
752 | fxch %st(3) | ||
753 | |||
754 | # qhasm: x1 += h1 | ||
755 | # asm 1: faddp <h1=float80#1,<x1=float80#2 | ||
756 | # asm 2: faddp <h1=%st(0),<x1=%st(1) | ||
757 | faddp %st(0),%st(1) | ||
758 | # comment:fpstackfrombottom:<x3#56:<x0#53:<x2#55:<x1#54: | ||
759 | |||
760 | # qhasm: h3 = *(float64 *) &r3 | ||
761 | # asm 1: fldl <r3=stack64#19 | ||
762 | # asm 2: fldl <r3=176(%rsp) | ||
763 | fldl 176(%rsp) | ||
764 | # comment:fpstackfrombottom:<x3#56:<x0#53:<x2#55:<x1#54:<h3#39: | ||
765 | |||
766 | # qhasm: h3 *= x0 | ||
767 | # asm 1: fmul <x0=float80#4,<h3=float80#1 | ||
768 | # asm 2: fmul <x0=%st(3),<h3=%st(0) | ||
769 | fmul %st(3),%st(0) | ||
770 | # comment:fpstackfrombottom:<x3#56:<x0#53:<x2#55:<x1#54:<h3#39: | ||
771 | |||
772 | # qhasm: h2 = *(float64 *) &r2 | ||
773 | # asm 1: fldl <r2=stack64#17 | ||
774 | # asm 2: fldl <r2=160(%rsp) | ||
775 | fldl 160(%rsp) | ||
776 | # comment:fpstackfrombottom:<x3#56:<x0#53:<x2#55:<x1#54:<h3#39:<h2#40: | ||
777 | |||
778 | # qhasm: h2 *= x0 | ||
779 | # asm 1: fmul <x0=float80#5,<h2=float80#1 | ||
780 | # asm 2: fmul <x0=%st(4),<h2=%st(0) | ||
781 | fmul %st(4),%st(0) | ||
782 | # comment:fpstackfrombottom:<x3#56:<x0#53:<x2#55:<x1#54:<h3#39:<h2#40: | ||
783 | |||
784 | # qhasm: h1 = *(float64 *) &r1 | ||
785 | # asm 1: fldl <r1=stack64#15 | ||
786 | # asm 2: fldl <r1=144(%rsp) | ||
787 | fldl 144(%rsp) | ||
788 | # comment:fpstackfrombottom:<x3#56:<x0#53:<x2#55:<x1#54:<h3#39:<h2#40:<h1#41: | ||
789 | |||
790 | # qhasm: h1 *= x0 | ||
791 | # asm 1: fmul <x0=float80#6,<h1=float80#1 | ||
792 | # asm 2: fmul <x0=%st(5),<h1=%st(0) | ||
793 | fmul %st(5),%st(0) | ||
794 | # comment:fpstackfrombottom:<x3#56:<x0#53:<x2#55:<x1#54:<h3#39:<h2#40:<h1#41: | ||
795 | |||
796 | # qhasm: h0 = *(float64 *) &r0 | ||
797 | # asm 1: fldl <r0=stack64#14 | ||
798 | # asm 2: fldl <r0=136(%rsp) | ||
799 | fldl 136(%rsp) | ||
800 | # comment:fpstackfrombottom:<x3#56:<x0#53:<x2#55:<x1#54:<h3#39:<h2#40:<h1#41:<h0#42: | ||
801 | |||
802 | # qhasm: h0 *= x0 | ||
803 | # asm 1: fmulp <x0=float80#1,<h0=float80#7 | ||
804 | # asm 2: fmulp <x0=%st(0),<h0=%st(6) | ||
805 | fmulp %st(0),%st(6) | ||
806 | # comment:fpstackfrombottom:<x3#56:<h0#42:<x2#55:<x1#54:<h3#39:<h2#40:<h1#41: | ||
807 | |||
808 | # qhasm: r2x1 = *(float64 *) &r2 | ||
809 | # asm 1: fldl <r2=stack64#17 | ||
810 | # asm 2: fldl <r2=160(%rsp) | ||
811 | fldl 160(%rsp) | ||
812 | # comment:fpstackfrombottom:<x3#56:<h0#42:<x2#55:<x1#54:<h3#39:<h2#40:<h1#41:<r2x1#57: | ||
813 | |||
814 | # qhasm: r2x1 *= x1 | ||
815 | # asm 1: fmul <x1=float80#5,<r2x1=float80#1 | ||
816 | # asm 2: fmul <x1=%st(4),<r2x1=%st(0) | ||
817 | fmul %st(4),%st(0) | ||
818 | # comment:fpstackfrombottom:<x3#56:<h0#42:<x2#55:<x1#54:<h3#39:<h2#40:<h1#41:<r2x1#57: | ||
819 | |||
820 | # qhasm: h3 += r2x1 | ||
821 | # asm 1: faddp <r2x1=float80#1,<h3=float80#4 | ||
822 | # asm 2: faddp <r2x1=%st(0),<h3=%st(3) | ||
823 | faddp %st(0),%st(3) | ||
824 | # comment:fpstackfrombottom:<x3#56:<h0#42:<x2#55:<x1#54:<h3#39:<h2#40:<h1#41: | ||
825 | |||
826 | # qhasm: r1x1 = *(float64 *) &r1 | ||
827 | # asm 1: fldl <r1=stack64#15 | ||
828 | # asm 2: fldl <r1=144(%rsp) | ||
829 | fldl 144(%rsp) | ||
830 | # comment:fpstackfrombottom:<x3#56:<h0#42:<x2#55:<x1#54:<h3#39:<h2#40:<h1#41:<r1x1#58: | ||
831 | |||
832 | # qhasm: r1x1 *= x1 | ||
833 | # asm 1: fmul <x1=float80#5,<r1x1=float80#1 | ||
834 | # asm 2: fmul <x1=%st(4),<r1x1=%st(0) | ||
835 | fmul %st(4),%st(0) | ||
836 | # comment:fpstackfrombottom:<x3#56:<h0#42:<x2#55:<x1#54:<h3#39:<h2#40:<h1#41:<r1x1#58: | ||
837 | |||
838 | # qhasm: h2 += r1x1 | ||
839 | # asm 1: faddp <r1x1=float80#1,<h2=float80#3 | ||
840 | # asm 2: faddp <r1x1=%st(0),<h2=%st(2) | ||
841 | faddp %st(0),%st(2) | ||
842 | # comment:fpstackfrombottom:<x3#56:<h0#42:<x2#55:<x1#54:<h3#39:<h2#40:<h1#41: | ||
843 | |||
844 | # qhasm: r0x1 = *(float64 *) &r0 | ||
845 | # asm 1: fldl <r0=stack64#14 | ||
846 | # asm 2: fldl <r0=136(%rsp) | ||
847 | fldl 136(%rsp) | ||
848 | # comment:fpstackfrombottom:<x3#56:<h0#42:<x2#55:<x1#54:<h3#39:<h2#40:<h1#41:<r0x1#59: | ||
849 | |||
850 | # qhasm: r0x1 *= x1 | ||
851 | # asm 1: fmul <x1=float80#5,<r0x1=float80#1 | ||
852 | # asm 2: fmul <x1=%st(4),<r0x1=%st(0) | ||
853 | fmul %st(4),%st(0) | ||
854 | # comment:fpstackfrombottom:<x3#56:<h0#42:<x2#55:<x1#54:<h3#39:<h2#40:<h1#41:<r0x1#59: | ||
855 | |||
856 | # qhasm: h1 += r0x1 | ||
857 | # asm 1: faddp <r0x1=float80#1,<h1=float80#2 | ||
858 | # asm 2: faddp <r0x1=%st(0),<h1=%st(1) | ||
859 | faddp %st(0),%st(1) | ||
860 | # comment:fpstackfrombottom:<x3#56:<h0#42:<x2#55:<x1#54:<h3#39:<h2#40:<h1#41: | ||
861 | |||
862 | # qhasm: sr3x1 = *(float64 *) &sr3 | ||
863 | # asm 1: fldl <sr3=stack64#20 | ||
864 | # asm 2: fldl <sr3=184(%rsp) | ||
865 | fldl 184(%rsp) | ||
866 | # comment:fpstackfrombottom:<x3#56:<h0#42:<x2#55:<x1#54:<h3#39:<h2#40:<h1#41:<sr3x1#60: | ||
867 | |||
868 | # qhasm: sr3x1 *= x1 | ||
869 | # asm 1: fmulp <x1=float80#1,<sr3x1=float80#5 | ||
870 | # asm 2: fmulp <x1=%st(0),<sr3x1=%st(4) | ||
871 | fmulp %st(0),%st(4) | ||
872 | # comment:fpstackfrombottom:<x3#56:<h0#42:<x2#55:<sr3x1#60:<h3#39:<h2#40:<h1#41: | ||
873 | |||
874 | # qhasm: internal stacktop sr3x1 | ||
875 | # asm 1: fxch <sr3x1=float80#4 | ||
876 | # asm 2: fxch <sr3x1=%st(3) | ||
877 | fxch %st(3) | ||
878 | |||
879 | # qhasm: h0 += sr3x1 | ||
880 | # asm 1: faddp <sr3x1=float80#1,<h0=float80#6 | ||
881 | # asm 2: faddp <sr3x1=%st(0),<h0=%st(5) | ||
882 | faddp %st(0),%st(5) | ||
883 | # comment:fpstackfrombottom:<x3#56:<h0#42:<x2#55:<h1#41:<h3#39:<h2#40: | ||
884 | |||
885 | # qhasm: r1x2 = *(float64 *) &r1 | ||
886 | # asm 1: fldl <r1=stack64#15 | ||
887 | # asm 2: fldl <r1=144(%rsp) | ||
888 | fldl 144(%rsp) | ||
889 | # comment:fpstackfrombottom:<x3#56:<h0#42:<x2#55:<h1#41:<h3#39:<h2#40:<r1x2#61: | ||
890 | |||
891 | # qhasm: r1x2 *= x2 | ||
892 | # asm 1: fmul <x2=float80#5,<r1x2=float80#1 | ||
893 | # asm 2: fmul <x2=%st(4),<r1x2=%st(0) | ||
894 | fmul %st(4),%st(0) | ||
895 | # comment:fpstackfrombottom:<x3#56:<h0#42:<x2#55:<h1#41:<h3#39:<h2#40:<r1x2#61: | ||
896 | |||
897 | # qhasm: h3 += r1x2 | ||
898 | # asm 1: faddp <r1x2=float80#1,<h3=float80#3 | ||
899 | # asm 2: faddp <r1x2=%st(0),<h3=%st(2) | ||
900 | faddp %st(0),%st(2) | ||
901 | # comment:fpstackfrombottom:<x3#56:<h0#42:<x2#55:<h1#41:<h3#39:<h2#40: | ||
902 | |||
903 | # qhasm: r0x2 = *(float64 *) &r0 | ||
904 | # asm 1: fldl <r0=stack64#14 | ||
905 | # asm 2: fldl <r0=136(%rsp) | ||
906 | fldl 136(%rsp) | ||
907 | # comment:fpstackfrombottom:<x3#56:<h0#42:<x2#55:<h1#41:<h3#39:<h2#40:<r0x2#62: | ||
908 | |||
909 | # qhasm: r0x2 *= x2 | ||
910 | # asm 1: fmul <x2=float80#5,<r0x2=float80#1 | ||
911 | # asm 2: fmul <x2=%st(4),<r0x2=%st(0) | ||
912 | fmul %st(4),%st(0) | ||
913 | # comment:fpstackfrombottom:<x3#56:<h0#42:<x2#55:<h1#41:<h3#39:<h2#40:<r0x2#62: | ||
914 | |||
915 | # qhasm: h2 += r0x2 | ||
916 | # asm 1: faddp <r0x2=float80#1,<h2=float80#2 | ||
917 | # asm 2: faddp <r0x2=%st(0),<h2=%st(1) | ||
918 | faddp %st(0),%st(1) | ||
919 | # comment:fpstackfrombottom:<x3#56:<h0#42:<x2#55:<h1#41:<h3#39:<h2#40: | ||
920 | |||
921 | # qhasm: sr3x2 = *(float64 *) &sr3 | ||
922 | # asm 1: fldl <sr3=stack64#20 | ||
923 | # asm 2: fldl <sr3=184(%rsp) | ||
924 | fldl 184(%rsp) | ||
925 | # comment:fpstackfrombottom:<x3#56:<h0#42:<x2#55:<h1#41:<h3#39:<h2#40:<sr3x2#63: | ||
926 | |||
927 | # qhasm: sr3x2 *= x2 | ||
928 | # asm 1: fmul <x2=float80#5,<sr3x2=float80#1 | ||
929 | # asm 2: fmul <x2=%st(4),<sr3x2=%st(0) | ||
930 | fmul %st(4),%st(0) | ||
931 | # comment:fpstackfrombottom:<x3#56:<h0#42:<x2#55:<h1#41:<h3#39:<h2#40:<sr3x2#63: | ||
932 | |||
933 | # qhasm: h1 += sr3x2 | ||
934 | # asm 1: faddp <sr3x2=float80#1,<h1=float80#4 | ||
935 | # asm 2: faddp <sr3x2=%st(0),<h1=%st(3) | ||
936 | faddp %st(0),%st(3) | ||
937 | # comment:fpstackfrombottom:<x3#56:<h0#42:<x2#55:<h1#41:<h3#39:<h2#40: | ||
938 | |||
939 | # qhasm: sr2x2 = *(float64 *) &sr2 | ||
940 | # asm 1: fldl <sr2=stack64#18 | ||
941 | # asm 2: fldl <sr2=168(%rsp) | ||
942 | fldl 168(%rsp) | ||
943 | # comment:fpstackfrombottom:<x3#56:<h0#42:<x2#55:<h1#41:<h3#39:<h2#40:<sr2x2#64: | ||
944 | |||
945 | # qhasm: sr2x2 *= x2 | ||
946 | # asm 1: fmulp <x2=float80#1,<sr2x2=float80#5 | ||
947 | # asm 2: fmulp <x2=%st(0),<sr2x2=%st(4) | ||
948 | fmulp %st(0),%st(4) | ||
949 | # comment:fpstackfrombottom:<x3#56:<h0#42:<sr2x2#64:<h1#41:<h3#39:<h2#40: | ||
950 | |||
951 | # qhasm: internal stacktop sr2x2 | ||
952 | # asm 1: fxch <sr2x2=float80#4 | ||
953 | # asm 2: fxch <sr2x2=%st(3) | ||
954 | fxch %st(3) | ||
955 | |||
956 | # qhasm: h0 += sr2x2 | ||
957 | # asm 1: faddp <sr2x2=float80#1,<h0=float80#5 | ||
958 | # asm 2: faddp <sr2x2=%st(0),<h0=%st(4) | ||
959 | faddp %st(0),%st(4) | ||
960 | # comment:fpstackfrombottom:<x3#56:<h0#42:<h2#40:<h1#41:<h3#39: | ||
961 | |||
962 | # qhasm: r0x3 = *(float64 *) &r0 | ||
963 | # asm 1: fldl <r0=stack64#14 | ||
964 | # asm 2: fldl <r0=136(%rsp) | ||
965 | fldl 136(%rsp) | ||
966 | # comment:fpstackfrombottom:<x3#56:<h0#42:<h2#40:<h1#41:<h3#39:<r0x3#65: | ||
967 | |||
968 | # qhasm: r0x3 *= x3 | ||
969 | # asm 1: fmul <x3=float80#6,<r0x3=float80#1 | ||
970 | # asm 2: fmul <x3=%st(5),<r0x3=%st(0) | ||
971 | fmul %st(5),%st(0) | ||
972 | # comment:fpstackfrombottom:<x3#56:<h0#42:<h2#40:<h1#41:<h3#39:<r0x3#65: | ||
973 | |||
974 | # qhasm: h3 += r0x3 | ||
975 | # asm 1: faddp <r0x3=float80#1,<h3=float80#2 | ||
976 | # asm 2: faddp <r0x3=%st(0),<h3=%st(1) | ||
977 | faddp %st(0),%st(1) | ||
978 | # comment:fpstackfrombottom:<x3#56:<h0#42:<h2#40:<h1#41:<h3#39: | ||
979 | |||
980 | # qhasm: stacktop h0 | ||
981 | # asm 1: fxch <h0=float80#4 | ||
982 | # asm 2: fxch <h0=%st(3) | ||
983 | fxch %st(3) | ||
984 | # comment:fpstackfrombottom:<x3#56:<h3#39:<h2#40:<h1#41:<h0#42: | ||
985 | |||
986 | # qhasm: sr3x3 = *(float64 *) &sr3 | ||
987 | # asm 1: fldl <sr3=stack64#20 | ||
988 | # asm 2: fldl <sr3=184(%rsp) | ||
989 | fldl 184(%rsp) | ||
990 | # comment:fpstackfrombottom:<x3#56:<h3#39:<h2#40:<h1#41:<h0#42:<sr3x3#66: | ||
991 | |||
992 | # qhasm: sr3x3 *= x3 | ||
993 | # asm 1: fmul <x3=float80#6,<sr3x3=float80#1 | ||
994 | # asm 2: fmul <x3=%st(5),<sr3x3=%st(0) | ||
995 | fmul %st(5),%st(0) | ||
996 | # comment:fpstackfrombottom:<x3#56:<h3#39:<h2#40:<h1#41:<h0#42:<sr3x3#66: | ||
997 | |||
998 | # qhasm: h2 += sr3x3 | ||
999 | # asm 1: faddp <sr3x3=float80#1,<h2=float80#4 | ||
1000 | # asm 2: faddp <sr3x3=%st(0),<h2=%st(3) | ||
1001 | faddp %st(0),%st(3) | ||
1002 | # comment:fpstackfrombottom:<x3#56:<h3#39:<h2#40:<h1#41:<h0#42: | ||
1003 | |||
1004 | # qhasm: stacktop h1 | ||
1005 | # asm 1: fxch <h1=float80#2 | ||
1006 | # asm 2: fxch <h1=%st(1) | ||
1007 | fxch %st(1) | ||
1008 | # comment:fpstackfrombottom:<x3#56:<h3#39:<h2#40:<h0#42:<h1#41: | ||
1009 | |||
1010 | # qhasm: sr2x3 = *(float64 *) &sr2 | ||
1011 | # asm 1: fldl <sr2=stack64#18 | ||
1012 | # asm 2: fldl <sr2=168(%rsp) | ||
1013 | fldl 168(%rsp) | ||
1014 | # comment:fpstackfrombottom:<x3#56:<h3#39:<h2#40:<h0#42:<h1#41:<sr2x3#67: | ||
1015 | |||
1016 | # qhasm: sr2x3 *= x3 | ||
1017 | # asm 1: fmul <x3=float80#6,<sr2x3=float80#1 | ||
1018 | # asm 2: fmul <x3=%st(5),<sr2x3=%st(0) | ||
1019 | fmul %st(5),%st(0) | ||
1020 | # comment:fpstackfrombottom:<x3#56:<h3#39:<h2#40:<h0#42:<h1#41:<sr2x3#67: | ||
1021 | |||
1022 | # qhasm: h1 += sr2x3 | ||
1023 | # asm 1: faddp <sr2x3=float80#1,<h1=float80#2 | ||
1024 | # asm 2: faddp <sr2x3=%st(0),<h1=%st(1) | ||
1025 | faddp %st(0),%st(1) | ||
1026 | # comment:fpstackfrombottom:<x3#56:<h3#39:<h2#40:<h0#42:<h1#41: | ||
1027 | |||
1028 | # qhasm: sr1x3 = *(float64 *) &sr1 | ||
1029 | # asm 1: fldl <sr1=stack64#16 | ||
1030 | # asm 2: fldl <sr1=152(%rsp) | ||
1031 | fldl 152(%rsp) | ||
1032 | # comment:fpstackfrombottom:<x3#56:<h3#39:<h2#40:<h0#42:<h1#41:<sr1x3#68: | ||
1033 | |||
1034 | # qhasm: sr1x3 *= x3 | ||
1035 | # asm 1: fmulp <x3=float80#1,<sr1x3=float80#6 | ||
1036 | # asm 2: fmulp <x3=%st(0),<sr1x3=%st(5) | ||
1037 | fmulp %st(0),%st(5) | ||
1038 | # comment:fpstackfrombottom:<sr1x3#68:<h3#39:<h2#40:<h0#42:<h1#41: | ||
1039 | |||
1040 | # qhasm: internal stacktop sr1x3 | ||
1041 | # asm 1: fxch <sr1x3=float80#5 | ||
1042 | # asm 2: fxch <sr1x3=%st(4) | ||
1043 | fxch %st(4) | ||
1044 | |||
1045 | # qhasm: h0 += sr1x3 | ||
1046 | # asm 1: faddp <sr1x3=float80#1,<h0=float80#2 | ||
1047 | # asm 2: faddp <sr1x3=%st(0),<h0=%st(1) | ||
1048 | faddp %st(0),%st(1) | ||
1049 | # comment:fpstackfrombottom:<h1#41:<h3#39:<h2#40:<h0#42: | ||
1050 | |||
1051 | # qhasm: unsigned<? l - 16 | ||
1052 | # asm 1: cmp $16,<l=int64#3 | ||
1053 | # asm 2: cmp $16,<l=%rdx | ||
1054 | cmp $16,%rdx | ||
1055 | # comment:fpstackfrombottom:<h1#41:<h3#39:<h2#40:<h0#42: | ||
1056 | |||
1057 | # qhasm: stacktop h3 | ||
1058 | # asm 1: fxch <h3=float80#3 | ||
1059 | # asm 2: fxch <h3=%st(2) | ||
1060 | fxch %st(2) | ||
1061 | # comment:fpstackfrombottom:<h1#41:<h0#42:<h2#40:<h3#39: | ||
1062 | |||
1063 | # qhasm: y3 = *(float64 *) &d3 | ||
1064 | # asm 1: fldl <d3=stack64#13 | ||
1065 | # asm 2: fldl <d3=128(%rsp) | ||
1066 | fldl 128(%rsp) | ||
1067 | # comment:fpstackfrombottom:<h1#41:<h0#42:<h2#40:<h3#39:<y3#70: | ||
1068 | |||
1069 | # qhasm: y3 -= *(float64 *) &crypto_onetimeauth_poly1305_amd64_doffset3minustwo128 | ||
1070 | fsubl crypto_onetimeauth_poly1305_amd64_doffset3minustwo128(%rip) | ||
1071 | # comment:fpstackfrombottom:<h1#41:<h0#42:<h2#40:<h3#39:<y3#70: | ||
1072 | |||
1073 | # qhasm: h3 += y3 | ||
1074 | # asm 1: faddp <y3=float80#1,<h3=float80#2 | ||
1075 | # asm 2: faddp <y3=%st(0),<h3=%st(1) | ||
1076 | faddp %st(0),%st(1) | ||
1077 | # comment:fpstackfrombottom:<h1#41:<h0#42:<h2#40:<h3#39: | ||
1078 | |||
1079 | # qhasm: stacktop h2 | ||
1080 | # asm 1: fxch <h2=float80#2 | ||
1081 | # asm 2: fxch <h2=%st(1) | ||
1082 | fxch %st(1) | ||
1083 | # comment:fpstackfrombottom:<h1#41:<h0#42:<h3#39:<h2#40: | ||
1084 | |||
1085 | # qhasm: y2 = *(float64 *) &d2 | ||
1086 | # asm 1: fldl <d2=stack64#12 | ||
1087 | # asm 2: fldl <d2=120(%rsp) | ||
1088 | fldl 120(%rsp) | ||
1089 | # comment:fpstackfrombottom:<h1#41:<h0#42:<h3#39:<h2#40:<y2#71: | ||
1090 | |||
1091 | # qhasm: y2 -= *(float64 *) &crypto_onetimeauth_poly1305_amd64_doffset2 | ||
1092 | fsubl crypto_onetimeauth_poly1305_amd64_doffset2(%rip) | ||
1093 | # comment:fpstackfrombottom:<h1#41:<h0#42:<h3#39:<h2#40:<y2#71: | ||
1094 | |||
1095 | # qhasm: h2 += y2 | ||
1096 | # asm 1: faddp <y2=float80#1,<h2=float80#2 | ||
1097 | # asm 2: faddp <y2=%st(0),<h2=%st(1) | ||
1098 | faddp %st(0),%st(1) | ||
1099 | # comment:fpstackfrombottom:<h1#41:<h0#42:<h3#39:<h2#40: | ||
1100 | |||
1101 | # qhasm: stacktop h1 | ||
1102 | # asm 1: fxch <h1=float80#4 | ||
1103 | # asm 2: fxch <h1=%st(3) | ||
1104 | fxch %st(3) | ||
1105 | # comment:fpstackfrombottom:<h2#40:<h0#42:<h3#39:<h1#41: | ||
1106 | |||
1107 | # qhasm: y1 = *(float64 *) &d1 | ||
1108 | # asm 1: fldl <d1=stack64#11 | ||
1109 | # asm 2: fldl <d1=112(%rsp) | ||
1110 | fldl 112(%rsp) | ||
1111 | # comment:fpstackfrombottom:<h2#40:<h0#42:<h3#39:<h1#41:<y1#72: | ||
1112 | |||
1113 | # qhasm: y1 -= *(float64 *) &crypto_onetimeauth_poly1305_amd64_doffset1 | ||
1114 | fsubl crypto_onetimeauth_poly1305_amd64_doffset1(%rip) | ||
1115 | # comment:fpstackfrombottom:<h2#40:<h0#42:<h3#39:<h1#41:<y1#72: | ||
1116 | |||
1117 | # qhasm: h1 += y1 | ||
1118 | # asm 1: faddp <y1=float80#1,<h1=float80#2 | ||
1119 | # asm 2: faddp <y1=%st(0),<h1=%st(1) | ||
1120 | faddp %st(0),%st(1) | ||
1121 | # comment:fpstackfrombottom:<h2#40:<h0#42:<h3#39:<h1#41: | ||
1122 | |||
1123 | # qhasm: stacktop h0 | ||
1124 | # asm 1: fxch <h0=float80#3 | ||
1125 | # asm 2: fxch <h0=%st(2) | ||
1126 | fxch %st(2) | ||
1127 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42: | ||
1128 | |||
1129 | # qhasm: y0 = *(float64 *) &d0 | ||
1130 | # asm 1: fldl <d0=stack64#10 | ||
1131 | # asm 2: fldl <d0=104(%rsp) | ||
1132 | fldl 104(%rsp) | ||
1133 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42:<y0#73: | ||
1134 | |||
1135 | # qhasm: y0 -= *(float64 *) &crypto_onetimeauth_poly1305_amd64_doffset0 | ||
1136 | fsubl crypto_onetimeauth_poly1305_amd64_doffset0(%rip) | ||
1137 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42:<y0#73: | ||
1138 | |||
1139 | # qhasm: h0 += y0 | ||
1140 | # asm 1: faddp <y0=float80#1,<h0=float80#2 | ||
1141 | # asm 2: faddp <y0=%st(0),<h0=%st(1) | ||
1142 | faddp %st(0),%st(1) | ||
1143 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42: | ||
1144 | # comment:fp stack unchanged by jump | ||
1145 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42: | ||
1146 | |||
1147 | # qhasm: goto multiplyaddatleast16bytes if !unsigned< | ||
1148 | jae ._multiplyaddatleast16bytes | ||
1149 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42: | ||
1150 | # comment:fp stack unchanged by fallthrough | ||
1151 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42: | ||
1152 | |||
1153 | # qhasm: multiplyaddatmost15bytes: | ||
1154 | ._multiplyaddatmost15bytes: | ||
1155 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42: | ||
1156 | |||
1157 | # qhasm: x0 = *(float64 *) &crypto_onetimeauth_poly1305_amd64_alpha130 | ||
1158 | fldl crypto_onetimeauth_poly1305_amd64_alpha130(%rip) | ||
1159 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42:<x0#74: | ||
1160 | |||
1161 | # qhasm: x0 += h3 | ||
1162 | # asm 1: fadd <h3=float80#3,<x0=float80#1 | ||
1163 | # asm 2: fadd <h3=%st(2),<x0=%st(0) | ||
1164 | fadd %st(2),%st(0) | ||
1165 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42:<x0#74: | ||
1166 | |||
1167 | # qhasm: x0 -= *(float64 *) &crypto_onetimeauth_poly1305_amd64_alpha130 | ||
1168 | fsubl crypto_onetimeauth_poly1305_amd64_alpha130(%rip) | ||
1169 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42:<x0#74: | ||
1170 | |||
1171 | # qhasm: h3 -= x0 | ||
1172 | # asm 1: fsubr <x0=float80#1,<h3=float80#3 | ||
1173 | # asm 2: fsubr <x0=%st(0),<h3=%st(2) | ||
1174 | fsubr %st(0),%st(2) | ||
1175 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42:<x0#74: | ||
1176 | |||
1177 | # qhasm: x0 *= *(float64 *) &crypto_onetimeauth_poly1305_amd64_scale | ||
1178 | fmull crypto_onetimeauth_poly1305_amd64_scale(%rip) | ||
1179 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42:<x0#74: | ||
1180 | |||
1181 | # qhasm: x1 = *(float64 *) &crypto_onetimeauth_poly1305_amd64_alpha32 | ||
1182 | fldl crypto_onetimeauth_poly1305_amd64_alpha32(%rip) | ||
1183 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42:<x0#74:<x1#75: | ||
1184 | |||
1185 | # qhasm: x1 += h0 | ||
1186 | # asm 1: fadd <h0=float80#3,<x1=float80#1 | ||
1187 | # asm 2: fadd <h0=%st(2),<x1=%st(0) | ||
1188 | fadd %st(2),%st(0) | ||
1189 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42:<x0#74:<x1#75: | ||
1190 | |||
1191 | # qhasm: x1 -= *(float64 *) &crypto_onetimeauth_poly1305_amd64_alpha32 | ||
1192 | fsubl crypto_onetimeauth_poly1305_amd64_alpha32(%rip) | ||
1193 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42:<x0#74:<x1#75: | ||
1194 | |||
1195 | # qhasm: h0 -= x1 | ||
1196 | # asm 1: fsubr <x1=float80#1,<h0=float80#3 | ||
1197 | # asm 2: fsubr <x1=%st(0),<h0=%st(2) | ||
1198 | fsubr %st(0),%st(2) | ||
1199 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42:<x0#74:<x1#75: | ||
1200 | |||
1201 | # qhasm: x2 = *(float64 *) &crypto_onetimeauth_poly1305_amd64_alpha64 | ||
1202 | fldl crypto_onetimeauth_poly1305_amd64_alpha64(%rip) | ||
1203 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42:<x0#74:<x1#75:<x2#76: | ||
1204 | |||
1205 | # qhasm: x2 += h1 | ||
1206 | # asm 1: fadd <h1=float80#6,<x2=float80#1 | ||
1207 | # asm 2: fadd <h1=%st(5),<x2=%st(0) | ||
1208 | fadd %st(5),%st(0) | ||
1209 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42:<x0#74:<x1#75:<x2#76: | ||
1210 | |||
1211 | # qhasm: x2 -= *(float64 *) &crypto_onetimeauth_poly1305_amd64_alpha64 | ||
1212 | fsubl crypto_onetimeauth_poly1305_amd64_alpha64(%rip) | ||
1213 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42:<x0#74:<x1#75:<x2#76: | ||
1214 | |||
1215 | # qhasm: h1 -= x2 | ||
1216 | # asm 1: fsubr <x2=float80#1,<h1=float80#6 | ||
1217 | # asm 2: fsubr <x2=%st(0),<h1=%st(5) | ||
1218 | fsubr %st(0),%st(5) | ||
1219 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42:<x0#74:<x1#75:<x2#76: | ||
1220 | |||
1221 | # qhasm: x3 = *(float64 *) &crypto_onetimeauth_poly1305_amd64_alpha96 | ||
1222 | fldl crypto_onetimeauth_poly1305_amd64_alpha96(%rip) | ||
1223 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42:<x0#74:<x1#75:<x2#76:<x3#77: | ||
1224 | |||
1225 | # qhasm: x3 += h2 | ||
1226 | # asm 1: fadd <h2=float80#8,<x3=float80#1 | ||
1227 | # asm 2: fadd <h2=%st(7),<x3=%st(0) | ||
1228 | fadd %st(7),%st(0) | ||
1229 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42:<x0#74:<x1#75:<x2#76:<x3#77: | ||
1230 | |||
1231 | # qhasm: x3 -= *(float64 *) &crypto_onetimeauth_poly1305_amd64_alpha96 | ||
1232 | fsubl crypto_onetimeauth_poly1305_amd64_alpha96(%rip) | ||
1233 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42:<x0#74:<x1#75:<x2#76:<x3#77: | ||
1234 | |||
1235 | # qhasm: h2 -= x3 | ||
1236 | # asm 1: fsubr <x3=float80#1,<h2=float80#8 | ||
1237 | # asm 2: fsubr <x3=%st(0),<h2=%st(7) | ||
1238 | fsubr %st(0),%st(7) | ||
1239 | # comment:fpstackfrombottom:<h2#40:<h1#41:<h3#39:<h0#42:<x0#74:<x1#75:<x2#76:<x3#77: | ||
1240 | |||
1241 | # qhasm: internal stacktop h2 | ||
1242 | # asm 1: fxch <h2=float80#8 | ||
1243 | # asm 2: fxch <h2=%st(7) | ||
1244 | fxch %st(7) | ||
1245 | |||
1246 | # qhasm: x2 += h2 | ||
1247 | # asm 1: faddp <h2=float80#1,<x2=float80#2 | ||
1248 | # asm 2: faddp <h2=%st(0),<x2=%st(1) | ||
1249 | faddp %st(0),%st(1) | ||
1250 | # comment:fpstackfrombottom:<x3#77:<h1#41:<h3#39:<h0#42:<x0#74:<x1#75:<x2#76: | ||
1251 | |||
1252 | # qhasm: internal stacktop h1 | ||
1253 | # asm 1: fxch <h1=float80#6 | ||
1254 | # asm 2: fxch <h1=%st(5) | ||
1255 | fxch %st(5) | ||
1256 | |||
1257 | # qhasm: x1 += h1 | ||
1258 | # asm 1: faddp <h1=float80#1,<x1=float80#2 | ||
1259 | # asm 2: faddp <h1=%st(0),<x1=%st(1) | ||
1260 | faddp %st(0),%st(1) | ||
1261 | # comment:fpstackfrombottom:<x3#77:<x2#76:<h3#39:<h0#42:<x0#74:<x1#75: | ||
1262 | |||
1263 | # qhasm: internal stacktop h3 | ||
1264 | # asm 1: fxch <h3=float80#4 | ||
1265 | # asm 2: fxch <h3=%st(3) | ||
1266 | fxch %st(3) | ||
1267 | |||
1268 | # qhasm: x3 += h3 | ||
1269 | # asm 1: faddp <h3=float80#1,<x3=float80#6 | ||
1270 | # asm 2: faddp <h3=%st(0),<x3=%st(5) | ||
1271 | faddp %st(0),%st(5) | ||
1272 | # comment:fpstackfrombottom:<x3#77:<x2#76:<x1#75:<h0#42:<x0#74: | ||
1273 | |||
1274 | # qhasm: x0 += h0 | ||
1275 | # asm 1: faddp <h0=float80#1,<x0=float80#2 | ||
1276 | # asm 2: faddp <h0=%st(0),<x0=%st(1) | ||
1277 | faddp %st(0),%st(1) | ||
1278 | # comment:fpstackfrombottom:<x3#77:<x2#76:<x1#75:<x0#74: | ||
1279 | |||
1280 | # qhasm: h3 = *(float64 *) &r3 | ||
1281 | # asm 1: fldl <r3=stack64#19 | ||
1282 | # asm 2: fldl <r3=176(%rsp) | ||
1283 | fldl 176(%rsp) | ||
1284 | # comment:fpstackfrombottom:<x3#77:<x2#76:<x1#75:<x0#74:<h3#39: | ||
1285 | |||
1286 | # qhasm: h3 *= x0 | ||
1287 | # asm 1: fmul <x0=float80#2,<h3=float80#1 | ||
1288 | # asm 2: fmul <x0=%st(1),<h3=%st(0) | ||
1289 | fmul %st(1),%st(0) | ||
1290 | # comment:fpstackfrombottom:<x3#77:<x2#76:<x1#75:<x0#74:<h3#39: | ||
1291 | |||
1292 | # qhasm: h2 = *(float64 *) &r2 | ||
1293 | # asm 1: fldl <r2=stack64#17 | ||
1294 | # asm 2: fldl <r2=160(%rsp) | ||
1295 | fldl 160(%rsp) | ||
1296 | # comment:fpstackfrombottom:<x3#77:<x2#76:<x1#75:<x0#74:<h3#39:<h2#40: | ||
1297 | |||
1298 | # qhasm: h2 *= x0 | ||
1299 | # asm 1: fmul <x0=float80#3,<h2=float80#1 | ||
1300 | # asm 2: fmul <x0=%st(2),<h2=%st(0) | ||
1301 | fmul %st(2),%st(0) | ||
1302 | # comment:fpstackfrombottom:<x3#77:<x2#76:<x1#75:<x0#74:<h3#39:<h2#40: | ||
1303 | |||
1304 | # qhasm: h1 = *(float64 *) &r1 | ||
1305 | # asm 1: fldl <r1=stack64#15 | ||
1306 | # asm 2: fldl <r1=144(%rsp) | ||
1307 | fldl 144(%rsp) | ||
1308 | # comment:fpstackfrombottom:<x3#77:<x2#76:<x1#75:<x0#74:<h3#39:<h2#40:<h1#41: | ||
1309 | |||
1310 | # qhasm: h1 *= x0 | ||
1311 | # asm 1: fmul <x0=float80#4,<h1=float80#1 | ||
1312 | # asm 2: fmul <x0=%st(3),<h1=%st(0) | ||
1313 | fmul %st(3),%st(0) | ||
1314 | # comment:fpstackfrombottom:<x3#77:<x2#76:<x1#75:<x0#74:<h3#39:<h2#40:<h1#41: | ||
1315 | |||
1316 | # qhasm: h0 = *(float64 *) &r0 | ||
1317 | # asm 1: fldl <r0=stack64#14 | ||
1318 | # asm 2: fldl <r0=136(%rsp) | ||
1319 | fldl 136(%rsp) | ||
1320 | # comment:fpstackfrombottom:<x3#77:<x2#76:<x1#75:<x0#74:<h3#39:<h2#40:<h1#41:<h0#42: | ||
1321 | |||
1322 | # qhasm: h0 *= x0 | ||
1323 | # asm 1: fmulp <x0=float80#1,<h0=float80#5 | ||
1324 | # asm 2: fmulp <x0=%st(0),<h0=%st(4) | ||
1325 | fmulp %st(0),%st(4) | ||
1326 | # comment:fpstackfrombottom:<x3#77:<x2#76:<x1#75:<h0#42:<h3#39:<h2#40:<h1#41: | ||
1327 | |||
1328 | # qhasm: r2x1 = *(float64 *) &r2 | ||
1329 | # asm 1: fldl <r2=stack64#17 | ||
1330 | # asm 2: fldl <r2=160(%rsp) | ||
1331 | fldl 160(%rsp) | ||
1332 | # comment:fpstackfrombottom:<x3#77:<x2#76:<x1#75:<h0#42:<h3#39:<h2#40:<h1#41:<r2x1#78: | ||
1333 | |||
1334 | # qhasm: r2x1 *= x1 | ||
1335 | # asm 1: fmul <x1=float80#6,<r2x1=float80#1 | ||
1336 | # asm 2: fmul <x1=%st(5),<r2x1=%st(0) | ||
1337 | fmul %st(5),%st(0) | ||
1338 | # comment:fpstackfrombottom:<x3#77:<x2#76:<x1#75:<h0#42:<h3#39:<h2#40:<h1#41:<r2x1#78: | ||
1339 | |||
1340 | # qhasm: h3 += r2x1 | ||
1341 | # asm 1: faddp <r2x1=float80#1,<h3=float80#4 | ||
1342 | # asm 2: faddp <r2x1=%st(0),<h3=%st(3) | ||
1343 | faddp %st(0),%st(3) | ||
1344 | # comment:fpstackfrombottom:<x3#77:<x2#76:<x1#75:<h0#42:<h3#39:<h2#40:<h1#41: | ||
1345 | |||
1346 | # qhasm: r1x1 = *(float64 *) &r1 | ||
1347 | # asm 1: fldl <r1=stack64#15 | ||
1348 | # asm 2: fldl <r1=144(%rsp) | ||
1349 | fldl 144(%rsp) | ||
1350 | # comment:fpstackfrombottom:<x3#77:<x2#76:<x1#75:<h0#42:<h3#39:<h2#40:<h1#41:<r1x1#79: | ||
1351 | |||
1352 | # qhasm: r1x1 *= x1 | ||
1353 | # asm 1: fmul <x1=float80#6,<r1x1=float80#1 | ||
1354 | # asm 2: fmul <x1=%st(5),<r1x1=%st(0) | ||
1355 | fmul %st(5),%st(0) | ||
1356 | # comment:fpstackfrombottom:<x3#77:<x2#76:<x1#75:<h0#42:<h3#39:<h2#40:<h1#41:<r1x1#79: | ||
1357 | |||
1358 | # qhasm: h2 += r1x1 | ||
1359 | # asm 1: faddp <r1x1=float80#1,<h2=float80#3 | ||
1360 | # asm 2: faddp <r1x1=%st(0),<h2=%st(2) | ||
1361 | faddp %st(0),%st(2) | ||
1362 | # comment:fpstackfrombottom:<x3#77:<x2#76:<x1#75:<h0#42:<h3#39:<h2#40:<h1#41: | ||
1363 | |||
1364 | # qhasm: r0x1 = *(float64 *) &r0 | ||
1365 | # asm 1: fldl <r0=stack64#14 | ||
1366 | # asm 2: fldl <r0=136(%rsp) | ||
1367 | fldl 136(%rsp) | ||
1368 | # comment:fpstackfrombottom:<x3#77:<x2#76:<x1#75:<h0#42:<h3#39:<h2#40:<h1#41:<r0x1#80: | ||
1369 | |||
1370 | # qhasm: r0x1 *= x1 | ||
1371 | # asm 1: fmul <x1=float80#6,<r0x1=float80#1 | ||
1372 | # asm 2: fmul <x1=%st(5),<r0x1=%st(0) | ||
1373 | fmul %st(5),%st(0) | ||
1374 | # comment:fpstackfrombottom:<x3#77:<x2#76:<x1#75:<h0#42:<h3#39:<h2#40:<h1#41:<r0x1#80: | ||
1375 | |||
1376 | # qhasm: h1 += r0x1 | ||
1377 | # asm 1: faddp <r0x1=float80#1,<h1=float80#2 | ||
1378 | # asm 2: faddp <r0x1=%st(0),<h1=%st(1) | ||
1379 | faddp %st(0),%st(1) | ||
1380 | # comment:fpstackfrombottom:<x3#77:<x2#76:<x1#75:<h0#42:<h3#39:<h2#40:<h1#41: | ||
1381 | |||
1382 | # qhasm: sr3x1 = *(float64 *) &sr3 | ||
1383 | # asm 1: fldl <sr3=stack64#20 | ||
1384 | # asm 2: fldl <sr3=184(%rsp) | ||
1385 | fldl 184(%rsp) | ||
1386 | # comment:fpstackfrombottom:<x3#77:<x2#76:<x1#75:<h0#42:<h3#39:<h2#40:<h1#41:<sr3x1#81: | ||
1387 | |||
1388 | # qhasm: sr3x1 *= x1 | ||
1389 | # asm 1: fmulp <x1=float80#1,<sr3x1=float80#6 | ||
1390 | # asm 2: fmulp <x1=%st(0),<sr3x1=%st(5) | ||
1391 | fmulp %st(0),%st(5) | ||
1392 | # comment:fpstackfrombottom:<x3#77:<x2#76:<sr3x1#81:<h0#42:<h3#39:<h2#40:<h1#41: | ||
1393 | |||
1394 | # qhasm: internal stacktop sr3x1 | ||
1395 | # asm 1: fxch <sr3x1=float80#5 | ||
1396 | # asm 2: fxch <sr3x1=%st(4) | ||
1397 | fxch %st(4) | ||
1398 | |||
1399 | # qhasm: h0 += sr3x1 | ||
1400 | # asm 1: faddp <sr3x1=float80#1,<h0=float80#4 | ||
1401 | # asm 2: faddp <sr3x1=%st(0),<h0=%st(3) | ||
1402 | faddp %st(0),%st(3) | ||
1403 | # comment:fpstackfrombottom:<x3#77:<x2#76:<h1#41:<h0#42:<h3#39:<h2#40: | ||
1404 | |||
1405 | # qhasm: r1x2 = *(float64 *) &r1 | ||
1406 | # asm 1: fldl <r1=stack64#15 | ||
1407 | # asm 2: fldl <r1=144(%rsp) | ||
1408 | fldl 144(%rsp) | ||
1409 | # comment:fpstackfrombottom:<x3#77:<x2#76:<h1#41:<h0#42:<h3#39:<h2#40:<r1x2#82: | ||
1410 | |||
1411 | # qhasm: r1x2 *= x2 | ||
1412 | # asm 1: fmul <x2=float80#6,<r1x2=float80#1 | ||
1413 | # asm 2: fmul <x2=%st(5),<r1x2=%st(0) | ||
1414 | fmul %st(5),%st(0) | ||
1415 | # comment:fpstackfrombottom:<x3#77:<x2#76:<h1#41:<h0#42:<h3#39:<h2#40:<r1x2#82: | ||
1416 | |||
1417 | # qhasm: h3 += r1x2 | ||
1418 | # asm 1: faddp <r1x2=float80#1,<h3=float80#3 | ||
1419 | # asm 2: faddp <r1x2=%st(0),<h3=%st(2) | ||
1420 | faddp %st(0),%st(2) | ||
1421 | # comment:fpstackfrombottom:<x3#77:<x2#76:<h1#41:<h0#42:<h3#39:<h2#40: | ||
1422 | |||
1423 | # qhasm: r0x2 = *(float64 *) &r0 | ||
1424 | # asm 1: fldl <r0=stack64#14 | ||
1425 | # asm 2: fldl <r0=136(%rsp) | ||
1426 | fldl 136(%rsp) | ||
1427 | # comment:fpstackfrombottom:<x3#77:<x2#76:<h1#41:<h0#42:<h3#39:<h2#40:<r0x2#83: | ||
1428 | |||
1429 | # qhasm: r0x2 *= x2 | ||
1430 | # asm 1: fmul <x2=float80#6,<r0x2=float80#1 | ||
1431 | # asm 2: fmul <x2=%st(5),<r0x2=%st(0) | ||
1432 | fmul %st(5),%st(0) | ||
1433 | # comment:fpstackfrombottom:<x3#77:<x2#76:<h1#41:<h0#42:<h3#39:<h2#40:<r0x2#83: | ||
1434 | |||
1435 | # qhasm: h2 += r0x2 | ||
1436 | # asm 1: faddp <r0x2=float80#1,<h2=float80#2 | ||
1437 | # asm 2: faddp <r0x2=%st(0),<h2=%st(1) | ||
1438 | faddp %st(0),%st(1) | ||
1439 | # comment:fpstackfrombottom:<x3#77:<x2#76:<h1#41:<h0#42:<h3#39:<h2#40: | ||
1440 | |||
1441 | # qhasm: sr3x2 = *(float64 *) &sr3 | ||
1442 | # asm 1: fldl <sr3=stack64#20 | ||
1443 | # asm 2: fldl <sr3=184(%rsp) | ||
1444 | fldl 184(%rsp) | ||
1445 | # comment:fpstackfrombottom:<x3#77:<x2#76:<h1#41:<h0#42:<h3#39:<h2#40:<sr3x2#84: | ||
1446 | |||
1447 | # qhasm: sr3x2 *= x2 | ||
1448 | # asm 1: fmul <x2=float80#6,<sr3x2=float80#1 | ||
1449 | # asm 2: fmul <x2=%st(5),<sr3x2=%st(0) | ||
1450 | fmul %st(5),%st(0) | ||
1451 | # comment:fpstackfrombottom:<x3#77:<x2#76:<h1#41:<h0#42:<h3#39:<h2#40:<sr3x2#84: | ||
1452 | |||
1453 | # qhasm: h1 += sr3x2 | ||
1454 | # asm 1: faddp <sr3x2=float80#1,<h1=float80#5 | ||
1455 | # asm 2: faddp <sr3x2=%st(0),<h1=%st(4) | ||
1456 | faddp %st(0),%st(4) | ||
1457 | # comment:fpstackfrombottom:<x3#77:<x2#76:<h1#41:<h0#42:<h3#39:<h2#40: | ||
1458 | |||
1459 | # qhasm: sr2x2 = *(float64 *) &sr2 | ||
1460 | # asm 1: fldl <sr2=stack64#18 | ||
1461 | # asm 2: fldl <sr2=168(%rsp) | ||
1462 | fldl 168(%rsp) | ||
1463 | # comment:fpstackfrombottom:<x3#77:<x2#76:<h1#41:<h0#42:<h3#39:<h2#40:<sr2x2#85: | ||
1464 | |||
1465 | # qhasm: sr2x2 *= x2 | ||
1466 | # asm 1: fmulp <x2=float80#1,<sr2x2=float80#6 | ||
1467 | # asm 2: fmulp <x2=%st(0),<sr2x2=%st(5) | ||
1468 | fmulp %st(0),%st(5) | ||
1469 | # comment:fpstackfrombottom:<x3#77:<sr2x2#85:<h1#41:<h0#42:<h3#39:<h2#40: | ||
1470 | |||
1471 | # qhasm: internal stacktop sr2x2 | ||
1472 | # asm 1: fxch <sr2x2=float80#5 | ||
1473 | # asm 2: fxch <sr2x2=%st(4) | ||
1474 | fxch %st(4) | ||
1475 | |||
1476 | # qhasm: h0 += sr2x2 | ||
1477 | # asm 1: faddp <sr2x2=float80#1,<h0=float80#3 | ||
1478 | # asm 2: faddp <sr2x2=%st(0),<h0=%st(2) | ||
1479 | faddp %st(0),%st(2) | ||
1480 | # comment:fpstackfrombottom:<x3#77:<h2#40:<h1#41:<h0#42:<h3#39: | ||
1481 | |||
1482 | # qhasm: r0x3 = *(float64 *) &r0 | ||
1483 | # asm 1: fldl <r0=stack64#14 | ||
1484 | # asm 2: fldl <r0=136(%rsp) | ||
1485 | fldl 136(%rsp) | ||
1486 | # comment:fpstackfrombottom:<x3#77:<h2#40:<h1#41:<h0#42:<h3#39:<r0x3#86: | ||
1487 | |||
1488 | # qhasm: r0x3 *= x3 | ||
1489 | # asm 1: fmul <x3=float80#6,<r0x3=float80#1 | ||
1490 | # asm 2: fmul <x3=%st(5),<r0x3=%st(0) | ||
1491 | fmul %st(5),%st(0) | ||
1492 | # comment:fpstackfrombottom:<x3#77:<h2#40:<h1#41:<h0#42:<h3#39:<r0x3#86: | ||
1493 | |||
1494 | # qhasm: h3 += r0x3 | ||
1495 | # asm 1: faddp <r0x3=float80#1,<h3=float80#2 | ||
1496 | # asm 2: faddp <r0x3=%st(0),<h3=%st(1) | ||
1497 | faddp %st(0),%st(1) | ||
1498 | # comment:fpstackfrombottom:<x3#77:<h2#40:<h1#41:<h0#42:<h3#39: | ||
1499 | |||
1500 | # qhasm: sr3x3 = *(float64 *) &sr3 | ||
1501 | # asm 1: fldl <sr3=stack64#20 | ||
1502 | # asm 2: fldl <sr3=184(%rsp) | ||
1503 | fldl 184(%rsp) | ||
1504 | # comment:fpstackfrombottom:<x3#77:<h2#40:<h1#41:<h0#42:<h3#39:<sr3x3#87: | ||
1505 | |||
1506 | # qhasm: sr3x3 *= x3 | ||
1507 | # asm 1: fmul <x3=float80#6,<sr3x3=float80#1 | ||
1508 | # asm 2: fmul <x3=%st(5),<sr3x3=%st(0) | ||
1509 | fmul %st(5),%st(0) | ||
1510 | # comment:fpstackfrombottom:<x3#77:<h2#40:<h1#41:<h0#42:<h3#39:<sr3x3#87: | ||
1511 | |||
1512 | # qhasm: h2 += sr3x3 | ||
1513 | # asm 1: faddp <sr3x3=float80#1,<h2=float80#5 | ||
1514 | # asm 2: faddp <sr3x3=%st(0),<h2=%st(4) | ||
1515 | faddp %st(0),%st(4) | ||
1516 | # comment:fpstackfrombottom:<x3#77:<h2#40:<h1#41:<h0#42:<h3#39: | ||
1517 | |||
1518 | # qhasm: sr2x3 = *(float64 *) &sr2 | ||
1519 | # asm 1: fldl <sr2=stack64#18 | ||
1520 | # asm 2: fldl <sr2=168(%rsp) | ||
1521 | fldl 168(%rsp) | ||
1522 | # comment:fpstackfrombottom:<x3#77:<h2#40:<h1#41:<h0#42:<h3#39:<sr2x3#88: | ||
1523 | |||
1524 | # qhasm: sr2x3 *= x3 | ||
1525 | # asm 1: fmul <x3=float80#6,<sr2x3=float80#1 | ||
1526 | # asm 2: fmul <x3=%st(5),<sr2x3=%st(0) | ||
1527 | fmul %st(5),%st(0) | ||
1528 | # comment:fpstackfrombottom:<x3#77:<h2#40:<h1#41:<h0#42:<h3#39:<sr2x3#88: | ||
1529 | |||
1530 | # qhasm: h1 += sr2x3 | ||
1531 | # asm 1: faddp <sr2x3=float80#1,<h1=float80#4 | ||
1532 | # asm 2: faddp <sr2x3=%st(0),<h1=%st(3) | ||
1533 | faddp %st(0),%st(3) | ||
1534 | # comment:fpstackfrombottom:<x3#77:<h2#40:<h1#41:<h0#42:<h3#39: | ||
1535 | |||
1536 | # qhasm: sr1x3 = *(float64 *) &sr1 | ||
1537 | # asm 1: fldl <sr1=stack64#16 | ||
1538 | # asm 2: fldl <sr1=152(%rsp) | ||
1539 | fldl 152(%rsp) | ||
1540 | # comment:fpstackfrombottom:<x3#77:<h2#40:<h1#41:<h0#42:<h3#39:<sr1x3#89: | ||
1541 | |||
1542 | # qhasm: sr1x3 *= x3 | ||
1543 | # asm 1: fmulp <x3=float80#1,<sr1x3=float80#6 | ||
1544 | # asm 2: fmulp <x3=%st(0),<sr1x3=%st(5) | ||
1545 | fmulp %st(0),%st(5) | ||
1546 | # comment:fpstackfrombottom:<sr1x3#89:<h2#40:<h1#41:<h0#42:<h3#39: | ||
1547 | |||
1548 | # qhasm: internal stacktop sr1x3 | ||
1549 | # asm 1: fxch <sr1x3=float80#5 | ||
1550 | # asm 2: fxch <sr1x3=%st(4) | ||
1551 | fxch %st(4) | ||
1552 | |||
1553 | # qhasm: h0 += sr1x3 | ||
1554 | # asm 1: faddp <sr1x3=float80#1,<h0=float80#2 | ||
1555 | # asm 2: faddp <sr1x3=%st(0),<h0=%st(1) | ||
1556 | faddp %st(0),%st(1) | ||
1557 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
1558 | # comment:fp stack unchanged by fallthrough | ||
1559 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
1560 | |||
1561 | # qhasm: addatmost15bytes: | ||
1562 | ._addatmost15bytes: | ||
1563 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
1564 | |||
1565 | # qhasm: =? l - 0 | ||
1566 | # asm 1: cmp $0,<l=int64#3 | ||
1567 | # asm 2: cmp $0,<l=%rdx | ||
1568 | cmp $0,%rdx | ||
1569 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
1570 | # comment:fp stack unchanged by jump | ||
1571 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
1572 | |||
1573 | # qhasm: goto nomorebytes if = | ||
1574 | je ._nomorebytes | ||
1575 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
1576 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
1577 | |||
1578 | # qhasm: stack128 lastchunk | ||
1579 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
1580 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
1581 | |||
1582 | # qhasm: int64 destination | ||
1583 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
1584 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
1585 | |||
1586 | # qhasm: int64 numbytes | ||
1587 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
1588 | |||
1589 | # qhasm: ((uint32 *)&lastchunk)[0] = 0 | ||
1590 | # asm 1: movl $0,>lastchunk=stack128#1 | ||
1591 | # asm 2: movl $0,>lastchunk=0(%rsp) | ||
1592 | movl $0,0(%rsp) | ||
1593 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
1594 | |||
1595 | # qhasm: ((uint32 *)&lastchunk)[1] = 0 | ||
1596 | # asm 1: movl $0,4+<lastchunk=stack128#1 | ||
1597 | # asm 2: movl $0,4+<lastchunk=0(%rsp) | ||
1598 | movl $0,4+0(%rsp) | ||
1599 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
1600 | |||
1601 | # qhasm: ((uint32 *)&lastchunk)[2] = 0 | ||
1602 | # asm 1: movl $0,8+<lastchunk=stack128#1 | ||
1603 | # asm 2: movl $0,8+<lastchunk=0(%rsp) | ||
1604 | movl $0,8+0(%rsp) | ||
1605 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
1606 | |||
1607 | # qhasm: ((uint32 *)&lastchunk)[3] = 0 | ||
1608 | # asm 1: movl $0,12+<lastchunk=stack128#1 | ||
1609 | # asm 2: movl $0,12+<lastchunk=0(%rsp) | ||
1610 | movl $0,12+0(%rsp) | ||
1611 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
1612 | |||
1613 | # qhasm: destination = &lastchunk | ||
1614 | # asm 1: leaq <lastchunk=stack128#1,>destination=int64#1 | ||
1615 | # asm 2: leaq <lastchunk=0(%rsp),>destination=%rdi | ||
1616 | leaq 0(%rsp),%rdi | ||
1617 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
1618 | |||
1619 | # qhasm: numbytes = l | ||
1620 | # asm 1: mov <l=int64#3,>numbytes=int64#4 | ||
1621 | # asm 2: mov <l=%rdx,>numbytes=%rcx | ||
1622 | mov %rdx,%rcx | ||
1623 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
1624 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
1625 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
1626 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
1627 | |||
1628 | # qhasm: while (numbytes) { *destination++ = *m++; --numbytes } | ||
1629 | rep movsb | ||
1630 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
1631 | |||
1632 | # qhasm: *(uint8 *) (destination + 0) = 1 | ||
1633 | # asm 1: movb $1,0(<destination=int64#1) | ||
1634 | # asm 2: movb $1,0(<destination=%rdi) | ||
1635 | movb $1,0(%rdi) | ||
1636 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
1637 | |||
1638 | # qhasm: m3 = ((uint32 *)&lastchunk)[3] | ||
1639 | # asm 1: movl 12+<lastchunk=stack128#1,>m3=int64#1d | ||
1640 | # asm 2: movl 12+<lastchunk=0(%rsp),>m3=%edi | ||
1641 | movl 12+0(%rsp),%edi | ||
1642 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
1643 | |||
1644 | # qhasm: m2 = ((uint32 *)&lastchunk)[2] | ||
1645 | # asm 1: movl 8+<lastchunk=stack128#1,>m2=int64#2d | ||
1646 | # asm 2: movl 8+<lastchunk=0(%rsp),>m2=%esi | ||
1647 | movl 8+0(%rsp),%esi | ||
1648 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
1649 | |||
1650 | # qhasm: m1 = ((uint32 *)&lastchunk)[1] | ||
1651 | # asm 1: movl 4+<lastchunk=stack128#1,>m1=int64#3d | ||
1652 | # asm 2: movl 4+<lastchunk=0(%rsp),>m1=%edx | ||
1653 | movl 4+0(%rsp),%edx | ||
1654 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
1655 | |||
1656 | # qhasm: m0 = ((uint32 *)&lastchunk)[0] | ||
1657 | # asm 1: movl <lastchunk=stack128#1,>m0=int64#4d | ||
1658 | # asm 2: movl <lastchunk=0(%rsp),>m0=%ecx | ||
1659 | movl 0(%rsp),%ecx | ||
1660 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
1661 | |||
1662 | # qhasm: inplace d3 bottom = m3 | ||
1663 | # asm 1: movl <m3=int64#1d,<d3=stack64#13 | ||
1664 | # asm 2: movl <m3=%edi,<d3=128(%rsp) | ||
1665 | movl %edi,128(%rsp) | ||
1666 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
1667 | |||
1668 | # qhasm: inplace d2 bottom = m2 | ||
1669 | # asm 1: movl <m2=int64#2d,<d2=stack64#12 | ||
1670 | # asm 2: movl <m2=%esi,<d2=120(%rsp) | ||
1671 | movl %esi,120(%rsp) | ||
1672 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
1673 | |||
1674 | # qhasm: inplace d1 bottom = m1 | ||
1675 | # asm 1: movl <m1=int64#3d,<d1=stack64#11 | ||
1676 | # asm 2: movl <m1=%edx,<d1=112(%rsp) | ||
1677 | movl %edx,112(%rsp) | ||
1678 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
1679 | |||
1680 | # qhasm: inplace d0 bottom = m0 | ||
1681 | # asm 1: movl <m0=int64#4d,<d0=stack64#10 | ||
1682 | # asm 2: movl <m0=%ecx,<d0=104(%rsp) | ||
1683 | movl %ecx,104(%rsp) | ||
1684 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
1685 | |||
1686 | # qhasm: internal stacktop h3 | ||
1687 | # asm 1: fxch <h3=float80#4 | ||
1688 | # asm 2: fxch <h3=%st(3) | ||
1689 | fxch %st(3) | ||
1690 | |||
1691 | # qhasm: h3 += *(float64 *) &d3 | ||
1692 | # asm 1: faddl <d3=stack64#13 | ||
1693 | # asm 2: faddl <d3=128(%rsp) | ||
1694 | faddl 128(%rsp) | ||
1695 | # comment:fpstackfrombottom:<h0#42:<h2#40:<h1#41:<h3#39: | ||
1696 | |||
1697 | # qhasm: h3 -= *(float64 *) &crypto_onetimeauth_poly1305_amd64_doffset3 | ||
1698 | fsubl crypto_onetimeauth_poly1305_amd64_doffset3(%rip) | ||
1699 | # comment:fpstackfrombottom:<h0#42:<h2#40:<h1#41:<h3#39: | ||
1700 | |||
1701 | # qhasm: internal stacktop h2 | ||
1702 | # asm 1: fxch <h2=float80#3 | ||
1703 | # asm 2: fxch <h2=%st(2) | ||
1704 | fxch %st(2) | ||
1705 | |||
1706 | # qhasm: h2 += *(float64 *) &d2 | ||
1707 | # asm 1: faddl <d2=stack64#12 | ||
1708 | # asm 2: faddl <d2=120(%rsp) | ||
1709 | faddl 120(%rsp) | ||
1710 | # comment:fpstackfrombottom:<h0#42:<h3#39:<h1#41:<h2#40: | ||
1711 | |||
1712 | # qhasm: h2 -= *(float64 *) &crypto_onetimeauth_poly1305_amd64_doffset2 | ||
1713 | fsubl crypto_onetimeauth_poly1305_amd64_doffset2(%rip) | ||
1714 | # comment:fpstackfrombottom:<h0#42:<h3#39:<h1#41:<h2#40: | ||
1715 | |||
1716 | # qhasm: internal stacktop h1 | ||
1717 | # asm 1: fxch <h1=float80#2 | ||
1718 | # asm 2: fxch <h1=%st(1) | ||
1719 | fxch %st(1) | ||
1720 | |||
1721 | # qhasm: h1 += *(float64 *) &d1 | ||
1722 | # asm 1: faddl <d1=stack64#11 | ||
1723 | # asm 2: faddl <d1=112(%rsp) | ||
1724 | faddl 112(%rsp) | ||
1725 | # comment:fpstackfrombottom:<h0#42:<h3#39:<h2#40:<h1#41: | ||
1726 | |||
1727 | # qhasm: h1 -= *(float64 *) &crypto_onetimeauth_poly1305_amd64_doffset1 | ||
1728 | fsubl crypto_onetimeauth_poly1305_amd64_doffset1(%rip) | ||
1729 | # comment:fpstackfrombottom:<h0#42:<h3#39:<h2#40:<h1#41: | ||
1730 | |||
1731 | # qhasm: internal stacktop h0 | ||
1732 | # asm 1: fxch <h0=float80#4 | ||
1733 | # asm 2: fxch <h0=%st(3) | ||
1734 | fxch %st(3) | ||
1735 | |||
1736 | # qhasm: h0 += *(float64 *) &d0 | ||
1737 | # asm 1: faddl <d0=stack64#10 | ||
1738 | # asm 2: faddl <d0=104(%rsp) | ||
1739 | faddl 104(%rsp) | ||
1740 | # comment:fpstackfrombottom:<h1#41:<h3#39:<h2#40:<h0#42: | ||
1741 | |||
1742 | # qhasm: h0 -= *(float64 *) &crypto_onetimeauth_poly1305_amd64_doffset0 | ||
1743 | fsubl crypto_onetimeauth_poly1305_amd64_doffset0(%rip) | ||
1744 | # comment:fpstackfrombottom:<h1#41:<h3#39:<h2#40:<h0#42: | ||
1745 | |||
1746 | # qhasm: x0 = *(float64 *) &crypto_onetimeauth_poly1305_amd64_alpha130 | ||
1747 | fldl crypto_onetimeauth_poly1305_amd64_alpha130(%rip) | ||
1748 | # comment:fpstackfrombottom:<h1#41:<h3#39:<h2#40:<h0#42:<x0#98: | ||
1749 | |||
1750 | # qhasm: x0 += h3 | ||
1751 | # asm 1: fadd <h3=float80#4,<x0=float80#1 | ||
1752 | # asm 2: fadd <h3=%st(3),<x0=%st(0) | ||
1753 | fadd %st(3),%st(0) | ||
1754 | # comment:fpstackfrombottom:<h1#41:<h3#39:<h2#40:<h0#42:<x0#98: | ||
1755 | |||
1756 | # qhasm: x0 -= *(float64 *) &crypto_onetimeauth_poly1305_amd64_alpha130 | ||
1757 | fsubl crypto_onetimeauth_poly1305_amd64_alpha130(%rip) | ||
1758 | # comment:fpstackfrombottom:<h1#41:<h3#39:<h2#40:<h0#42:<x0#98: | ||
1759 | |||
1760 | # qhasm: h3 -= x0 | ||
1761 | # asm 1: fsubr <x0=float80#1,<h3=float80#4 | ||
1762 | # asm 2: fsubr <x0=%st(0),<h3=%st(3) | ||
1763 | fsubr %st(0),%st(3) | ||
1764 | # comment:fpstackfrombottom:<h1#41:<h3#39:<h2#40:<h0#42:<x0#98: | ||
1765 | |||
1766 | # qhasm: x0 *= *(float64 *) &crypto_onetimeauth_poly1305_amd64_scale | ||
1767 | fmull crypto_onetimeauth_poly1305_amd64_scale(%rip) | ||
1768 | # comment:fpstackfrombottom:<h1#41:<h3#39:<h2#40:<h0#42:<x0#98: | ||
1769 | |||
1770 | # qhasm: x1 = *(float64 *) &crypto_onetimeauth_poly1305_amd64_alpha32 | ||
1771 | fldl crypto_onetimeauth_poly1305_amd64_alpha32(%rip) | ||
1772 | # comment:fpstackfrombottom:<h1#41:<h3#39:<h2#40:<h0#42:<x0#98:<x1#99: | ||
1773 | |||
1774 | # qhasm: x1 += h0 | ||
1775 | # asm 1: fadd <h0=float80#3,<x1=float80#1 | ||
1776 | # asm 2: fadd <h0=%st(2),<x1=%st(0) | ||
1777 | fadd %st(2),%st(0) | ||
1778 | # comment:fpstackfrombottom:<h1#41:<h3#39:<h2#40:<h0#42:<x0#98:<x1#99: | ||
1779 | |||
1780 | # qhasm: x1 -= *(float64 *) &crypto_onetimeauth_poly1305_amd64_alpha32 | ||
1781 | fsubl crypto_onetimeauth_poly1305_amd64_alpha32(%rip) | ||
1782 | # comment:fpstackfrombottom:<h1#41:<h3#39:<h2#40:<h0#42:<x0#98:<x1#99: | ||
1783 | |||
1784 | # qhasm: h0 -= x1 | ||
1785 | # asm 1: fsubr <x1=float80#1,<h0=float80#3 | ||
1786 | # asm 2: fsubr <x1=%st(0),<h0=%st(2) | ||
1787 | fsubr %st(0),%st(2) | ||
1788 | # comment:fpstackfrombottom:<h1#41:<h3#39:<h2#40:<h0#42:<x0#98:<x1#99: | ||
1789 | |||
1790 | # qhasm: x2 = *(float64 *) &crypto_onetimeauth_poly1305_amd64_alpha64 | ||
1791 | fldl crypto_onetimeauth_poly1305_amd64_alpha64(%rip) | ||
1792 | # comment:fpstackfrombottom:<h1#41:<h3#39:<h2#40:<h0#42:<x0#98:<x1#99:<x2#100: | ||
1793 | |||
1794 | # qhasm: x2 += h1 | ||
1795 | # asm 1: fadd <h1=float80#7,<x2=float80#1 | ||
1796 | # asm 2: fadd <h1=%st(6),<x2=%st(0) | ||
1797 | fadd %st(6),%st(0) | ||
1798 | # comment:fpstackfrombottom:<h1#41:<h3#39:<h2#40:<h0#42:<x0#98:<x1#99:<x2#100: | ||
1799 | |||
1800 | # qhasm: x2 -= *(float64 *) &crypto_onetimeauth_poly1305_amd64_alpha64 | ||
1801 | fsubl crypto_onetimeauth_poly1305_amd64_alpha64(%rip) | ||
1802 | # comment:fpstackfrombottom:<h1#41:<h3#39:<h2#40:<h0#42:<x0#98:<x1#99:<x2#100: | ||
1803 | |||
1804 | # qhasm: h1 -= x2 | ||
1805 | # asm 1: fsubr <x2=float80#1,<h1=float80#7 | ||
1806 | # asm 2: fsubr <x2=%st(0),<h1=%st(6) | ||
1807 | fsubr %st(0),%st(6) | ||
1808 | # comment:fpstackfrombottom:<h1#41:<h3#39:<h2#40:<h0#42:<x0#98:<x1#99:<x2#100: | ||
1809 | |||
1810 | # qhasm: x3 = *(float64 *) &crypto_onetimeauth_poly1305_amd64_alpha96 | ||
1811 | fldl crypto_onetimeauth_poly1305_amd64_alpha96(%rip) | ||
1812 | # comment:fpstackfrombottom:<h1#41:<h3#39:<h2#40:<h0#42:<x0#98:<x1#99:<x2#100:<x3#101: | ||
1813 | |||
1814 | # qhasm: x3 += h2 | ||
1815 | # asm 1: fadd <h2=float80#6,<x3=float80#1 | ||
1816 | # asm 2: fadd <h2=%st(5),<x3=%st(0) | ||
1817 | fadd %st(5),%st(0) | ||
1818 | # comment:fpstackfrombottom:<h1#41:<h3#39:<h2#40:<h0#42:<x0#98:<x1#99:<x2#100:<x3#101: | ||
1819 | |||
1820 | # qhasm: x3 -= *(float64 *) &crypto_onetimeauth_poly1305_amd64_alpha96 | ||
1821 | fsubl crypto_onetimeauth_poly1305_amd64_alpha96(%rip) | ||
1822 | # comment:fpstackfrombottom:<h1#41:<h3#39:<h2#40:<h0#42:<x0#98:<x1#99:<x2#100:<x3#101: | ||
1823 | |||
1824 | # qhasm: h2 -= x3 | ||
1825 | # asm 1: fsubr <x3=float80#1,<h2=float80#6 | ||
1826 | # asm 2: fsubr <x3=%st(0),<h2=%st(5) | ||
1827 | fsubr %st(0),%st(5) | ||
1828 | # comment:fpstackfrombottom:<h1#41:<h3#39:<h2#40:<h0#42:<x0#98:<x1#99:<x2#100:<x3#101: | ||
1829 | |||
1830 | # qhasm: internal stacktop h0 | ||
1831 | # asm 1: fxch <h0=float80#5 | ||
1832 | # asm 2: fxch <h0=%st(4) | ||
1833 | fxch %st(4) | ||
1834 | |||
1835 | # qhasm: x0 += h0 | ||
1836 | # asm 1: faddp <h0=float80#1,<x0=float80#4 | ||
1837 | # asm 2: faddp <h0=%st(0),<x0=%st(3) | ||
1838 | faddp %st(0),%st(3) | ||
1839 | # comment:fpstackfrombottom:<h1#41:<h3#39:<h2#40:<x3#101:<x0#98:<x1#99:<x2#100: | ||
1840 | |||
1841 | # qhasm: internal stacktop h1 | ||
1842 | # asm 1: fxch <h1=float80#7 | ||
1843 | # asm 2: fxch <h1=%st(6) | ||
1844 | fxch %st(6) | ||
1845 | |||
1846 | # qhasm: x1 += h1 | ||
1847 | # asm 1: faddp <h1=float80#1,<x1=float80#2 | ||
1848 | # asm 2: faddp <h1=%st(0),<x1=%st(1) | ||
1849 | faddp %st(0),%st(1) | ||
1850 | # comment:fpstackfrombottom:<x2#100:<h3#39:<h2#40:<x3#101:<x0#98:<x1#99: | ||
1851 | |||
1852 | # qhasm: internal stacktop h2 | ||
1853 | # asm 1: fxch <h2=float80#4 | ||
1854 | # asm 2: fxch <h2=%st(3) | ||
1855 | fxch %st(3) | ||
1856 | |||
1857 | # qhasm: x2 += h2 | ||
1858 | # asm 1: faddp <h2=float80#1,<x2=float80#6 | ||
1859 | # asm 2: faddp <h2=%st(0),<x2=%st(5) | ||
1860 | faddp %st(0),%st(5) | ||
1861 | # comment:fpstackfrombottom:<x2#100:<h3#39:<x1#99:<x3#101:<x0#98: | ||
1862 | |||
1863 | # qhasm: internal stacktop h3 | ||
1864 | # asm 1: fxch <h3=float80#4 | ||
1865 | # asm 2: fxch <h3=%st(3) | ||
1866 | fxch %st(3) | ||
1867 | |||
1868 | # qhasm: x3 += h3 | ||
1869 | # asm 1: faddp <h3=float80#1,<x3=float80#2 | ||
1870 | # asm 2: faddp <h3=%st(0),<x3=%st(1) | ||
1871 | faddp %st(0),%st(1) | ||
1872 | # comment:fpstackfrombottom:<x2#100:<x0#98:<x1#99:<x3#101: | ||
1873 | |||
1874 | # qhasm: h3 = *(float64 *) &r3 | ||
1875 | # asm 1: fldl <r3=stack64#19 | ||
1876 | # asm 2: fldl <r3=176(%rsp) | ||
1877 | fldl 176(%rsp) | ||
1878 | # comment:fpstackfrombottom:<x2#100:<x0#98:<x1#99:<x3#101:<h3#39: | ||
1879 | |||
1880 | # qhasm: h3 *= x0 | ||
1881 | # asm 1: fmul <x0=float80#4,<h3=float80#1 | ||
1882 | # asm 2: fmul <x0=%st(3),<h3=%st(0) | ||
1883 | fmul %st(3),%st(0) | ||
1884 | # comment:fpstackfrombottom:<x2#100:<x0#98:<x1#99:<x3#101:<h3#39: | ||
1885 | |||
1886 | # qhasm: h2 = *(float64 *) &r2 | ||
1887 | # asm 1: fldl <r2=stack64#17 | ||
1888 | # asm 2: fldl <r2=160(%rsp) | ||
1889 | fldl 160(%rsp) | ||
1890 | # comment:fpstackfrombottom:<x2#100:<x0#98:<x1#99:<x3#101:<h3#39:<h2#40: | ||
1891 | |||
1892 | # qhasm: h2 *= x0 | ||
1893 | # asm 1: fmul <x0=float80#5,<h2=float80#1 | ||
1894 | # asm 2: fmul <x0=%st(4),<h2=%st(0) | ||
1895 | fmul %st(4),%st(0) | ||
1896 | # comment:fpstackfrombottom:<x2#100:<x0#98:<x1#99:<x3#101:<h3#39:<h2#40: | ||
1897 | |||
1898 | # qhasm: h1 = *(float64 *) &r1 | ||
1899 | # asm 1: fldl <r1=stack64#15 | ||
1900 | # asm 2: fldl <r1=144(%rsp) | ||
1901 | fldl 144(%rsp) | ||
1902 | # comment:fpstackfrombottom:<x2#100:<x0#98:<x1#99:<x3#101:<h3#39:<h2#40:<h1#41: | ||
1903 | |||
1904 | # qhasm: h1 *= x0 | ||
1905 | # asm 1: fmul <x0=float80#6,<h1=float80#1 | ||
1906 | # asm 2: fmul <x0=%st(5),<h1=%st(0) | ||
1907 | fmul %st(5),%st(0) | ||
1908 | # comment:fpstackfrombottom:<x2#100:<x0#98:<x1#99:<x3#101:<h3#39:<h2#40:<h1#41: | ||
1909 | |||
1910 | # qhasm: h0 = *(float64 *) &r0 | ||
1911 | # asm 1: fldl <r0=stack64#14 | ||
1912 | # asm 2: fldl <r0=136(%rsp) | ||
1913 | fldl 136(%rsp) | ||
1914 | # comment:fpstackfrombottom:<x2#100:<x0#98:<x1#99:<x3#101:<h3#39:<h2#40:<h1#41:<h0#42: | ||
1915 | |||
1916 | # qhasm: h0 *= x0 | ||
1917 | # asm 1: fmulp <x0=float80#1,<h0=float80#7 | ||
1918 | # asm 2: fmulp <x0=%st(0),<h0=%st(6) | ||
1919 | fmulp %st(0),%st(6) | ||
1920 | # comment:fpstackfrombottom:<x2#100:<h0#42:<x1#99:<x3#101:<h3#39:<h2#40:<h1#41: | ||
1921 | |||
1922 | # qhasm: r2x1 = *(float64 *) &r2 | ||
1923 | # asm 1: fldl <r2=stack64#17 | ||
1924 | # asm 2: fldl <r2=160(%rsp) | ||
1925 | fldl 160(%rsp) | ||
1926 | # comment:fpstackfrombottom:<x2#100:<h0#42:<x1#99:<x3#101:<h3#39:<h2#40:<h1#41:<r2x1#102: | ||
1927 | |||
1928 | # qhasm: r2x1 *= x1 | ||
1929 | # asm 1: fmul <x1=float80#6,<r2x1=float80#1 | ||
1930 | # asm 2: fmul <x1=%st(5),<r2x1=%st(0) | ||
1931 | fmul %st(5),%st(0) | ||
1932 | # comment:fpstackfrombottom:<x2#100:<h0#42:<x1#99:<x3#101:<h3#39:<h2#40:<h1#41:<r2x1#102: | ||
1933 | |||
1934 | # qhasm: h3 += r2x1 | ||
1935 | # asm 1: faddp <r2x1=float80#1,<h3=float80#4 | ||
1936 | # asm 2: faddp <r2x1=%st(0),<h3=%st(3) | ||
1937 | faddp %st(0),%st(3) | ||
1938 | # comment:fpstackfrombottom:<x2#100:<h0#42:<x1#99:<x3#101:<h3#39:<h2#40:<h1#41: | ||
1939 | |||
1940 | # qhasm: r1x1 = *(float64 *) &r1 | ||
1941 | # asm 1: fldl <r1=stack64#15 | ||
1942 | # asm 2: fldl <r1=144(%rsp) | ||
1943 | fldl 144(%rsp) | ||
1944 | # comment:fpstackfrombottom:<x2#100:<h0#42:<x1#99:<x3#101:<h3#39:<h2#40:<h1#41:<r1x1#103: | ||
1945 | |||
1946 | # qhasm: r1x1 *= x1 | ||
1947 | # asm 1: fmul <x1=float80#6,<r1x1=float80#1 | ||
1948 | # asm 2: fmul <x1=%st(5),<r1x1=%st(0) | ||
1949 | fmul %st(5),%st(0) | ||
1950 | # comment:fpstackfrombottom:<x2#100:<h0#42:<x1#99:<x3#101:<h3#39:<h2#40:<h1#41:<r1x1#103: | ||
1951 | |||
1952 | # qhasm: h2 += r1x1 | ||
1953 | # asm 1: faddp <r1x1=float80#1,<h2=float80#3 | ||
1954 | # asm 2: faddp <r1x1=%st(0),<h2=%st(2) | ||
1955 | faddp %st(0),%st(2) | ||
1956 | # comment:fpstackfrombottom:<x2#100:<h0#42:<x1#99:<x3#101:<h3#39:<h2#40:<h1#41: | ||
1957 | |||
1958 | # qhasm: r0x1 = *(float64 *) &r0 | ||
1959 | # asm 1: fldl <r0=stack64#14 | ||
1960 | # asm 2: fldl <r0=136(%rsp) | ||
1961 | fldl 136(%rsp) | ||
1962 | # comment:fpstackfrombottom:<x2#100:<h0#42:<x1#99:<x3#101:<h3#39:<h2#40:<h1#41:<r0x1#104: | ||
1963 | |||
1964 | # qhasm: r0x1 *= x1 | ||
1965 | # asm 1: fmul <x1=float80#6,<r0x1=float80#1 | ||
1966 | # asm 2: fmul <x1=%st(5),<r0x1=%st(0) | ||
1967 | fmul %st(5),%st(0) | ||
1968 | # comment:fpstackfrombottom:<x2#100:<h0#42:<x1#99:<x3#101:<h3#39:<h2#40:<h1#41:<r0x1#104: | ||
1969 | |||
1970 | # qhasm: h1 += r0x1 | ||
1971 | # asm 1: faddp <r0x1=float80#1,<h1=float80#2 | ||
1972 | # asm 2: faddp <r0x1=%st(0),<h1=%st(1) | ||
1973 | faddp %st(0),%st(1) | ||
1974 | # comment:fpstackfrombottom:<x2#100:<h0#42:<x1#99:<x3#101:<h3#39:<h2#40:<h1#41: | ||
1975 | |||
1976 | # qhasm: sr3x1 = *(float64 *) &sr3 | ||
1977 | # asm 1: fldl <sr3=stack64#20 | ||
1978 | # asm 2: fldl <sr3=184(%rsp) | ||
1979 | fldl 184(%rsp) | ||
1980 | # comment:fpstackfrombottom:<x2#100:<h0#42:<x1#99:<x3#101:<h3#39:<h2#40:<h1#41:<sr3x1#105: | ||
1981 | |||
1982 | # qhasm: sr3x1 *= x1 | ||
1983 | # asm 1: fmulp <x1=float80#1,<sr3x1=float80#6 | ||
1984 | # asm 2: fmulp <x1=%st(0),<sr3x1=%st(5) | ||
1985 | fmulp %st(0),%st(5) | ||
1986 | # comment:fpstackfrombottom:<x2#100:<h0#42:<sr3x1#105:<x3#101:<h3#39:<h2#40:<h1#41: | ||
1987 | |||
1988 | # qhasm: internal stacktop sr3x1 | ||
1989 | # asm 1: fxch <sr3x1=float80#5 | ||
1990 | # asm 2: fxch <sr3x1=%st(4) | ||
1991 | fxch %st(4) | ||
1992 | |||
1993 | # qhasm: h0 += sr3x1 | ||
1994 | # asm 1: faddp <sr3x1=float80#1,<h0=float80#6 | ||
1995 | # asm 2: faddp <sr3x1=%st(0),<h0=%st(5) | ||
1996 | faddp %st(0),%st(5) | ||
1997 | # comment:fpstackfrombottom:<x2#100:<h0#42:<h1#41:<x3#101:<h3#39:<h2#40: | ||
1998 | |||
1999 | # qhasm: r1x2 = *(float64 *) &r1 | ||
2000 | # asm 1: fldl <r1=stack64#15 | ||
2001 | # asm 2: fldl <r1=144(%rsp) | ||
2002 | fldl 144(%rsp) | ||
2003 | # comment:fpstackfrombottom:<x2#100:<h0#42:<h1#41:<x3#101:<h3#39:<h2#40:<r1x2#106: | ||
2004 | |||
2005 | # qhasm: r1x2 *= x2 | ||
2006 | # asm 1: fmul <x2=float80#7,<r1x2=float80#1 | ||
2007 | # asm 2: fmul <x2=%st(6),<r1x2=%st(0) | ||
2008 | fmul %st(6),%st(0) | ||
2009 | # comment:fpstackfrombottom:<x2#100:<h0#42:<h1#41:<x3#101:<h3#39:<h2#40:<r1x2#106: | ||
2010 | |||
2011 | # qhasm: h3 += r1x2 | ||
2012 | # asm 1: faddp <r1x2=float80#1,<h3=float80#3 | ||
2013 | # asm 2: faddp <r1x2=%st(0),<h3=%st(2) | ||
2014 | faddp %st(0),%st(2) | ||
2015 | # comment:fpstackfrombottom:<x2#100:<h0#42:<h1#41:<x3#101:<h3#39:<h2#40: | ||
2016 | |||
2017 | # qhasm: r0x2 = *(float64 *) &r0 | ||
2018 | # asm 1: fldl <r0=stack64#14 | ||
2019 | # asm 2: fldl <r0=136(%rsp) | ||
2020 | fldl 136(%rsp) | ||
2021 | # comment:fpstackfrombottom:<x2#100:<h0#42:<h1#41:<x3#101:<h3#39:<h2#40:<r0x2#107: | ||
2022 | |||
2023 | # qhasm: r0x2 *= x2 | ||
2024 | # asm 1: fmul <x2=float80#7,<r0x2=float80#1 | ||
2025 | # asm 2: fmul <x2=%st(6),<r0x2=%st(0) | ||
2026 | fmul %st(6),%st(0) | ||
2027 | # comment:fpstackfrombottom:<x2#100:<h0#42:<h1#41:<x3#101:<h3#39:<h2#40:<r0x2#107: | ||
2028 | |||
2029 | # qhasm: h2 += r0x2 | ||
2030 | # asm 1: faddp <r0x2=float80#1,<h2=float80#2 | ||
2031 | # asm 2: faddp <r0x2=%st(0),<h2=%st(1) | ||
2032 | faddp %st(0),%st(1) | ||
2033 | # comment:fpstackfrombottom:<x2#100:<h0#42:<h1#41:<x3#101:<h3#39:<h2#40: | ||
2034 | |||
2035 | # qhasm: sr3x2 = *(float64 *) &sr3 | ||
2036 | # asm 1: fldl <sr3=stack64#20 | ||
2037 | # asm 2: fldl <sr3=184(%rsp) | ||
2038 | fldl 184(%rsp) | ||
2039 | # comment:fpstackfrombottom:<x2#100:<h0#42:<h1#41:<x3#101:<h3#39:<h2#40:<sr3x2#108: | ||
2040 | |||
2041 | # qhasm: sr3x2 *= x2 | ||
2042 | # asm 1: fmul <x2=float80#7,<sr3x2=float80#1 | ||
2043 | # asm 2: fmul <x2=%st(6),<sr3x2=%st(0) | ||
2044 | fmul %st(6),%st(0) | ||
2045 | # comment:fpstackfrombottom:<x2#100:<h0#42:<h1#41:<x3#101:<h3#39:<h2#40:<sr3x2#108: | ||
2046 | |||
2047 | # qhasm: h1 += sr3x2 | ||
2048 | # asm 1: faddp <sr3x2=float80#1,<h1=float80#5 | ||
2049 | # asm 2: faddp <sr3x2=%st(0),<h1=%st(4) | ||
2050 | faddp %st(0),%st(4) | ||
2051 | # comment:fpstackfrombottom:<x2#100:<h0#42:<h1#41:<x3#101:<h3#39:<h2#40: | ||
2052 | |||
2053 | # qhasm: sr2x2 = *(float64 *) &sr2 | ||
2054 | # asm 1: fldl <sr2=stack64#18 | ||
2055 | # asm 2: fldl <sr2=168(%rsp) | ||
2056 | fldl 168(%rsp) | ||
2057 | # comment:fpstackfrombottom:<x2#100:<h0#42:<h1#41:<x3#101:<h3#39:<h2#40:<sr2x2#109: | ||
2058 | |||
2059 | # qhasm: sr2x2 *= x2 | ||
2060 | # asm 1: fmulp <x2=float80#1,<sr2x2=float80#7 | ||
2061 | # asm 2: fmulp <x2=%st(0),<sr2x2=%st(6) | ||
2062 | fmulp %st(0),%st(6) | ||
2063 | # comment:fpstackfrombottom:<sr2x2#109:<h0#42:<h1#41:<x3#101:<h3#39:<h2#40: | ||
2064 | |||
2065 | # qhasm: internal stacktop sr2x2 | ||
2066 | # asm 1: fxch <sr2x2=float80#6 | ||
2067 | # asm 2: fxch <sr2x2=%st(5) | ||
2068 | fxch %st(5) | ||
2069 | |||
2070 | # qhasm: h0 += sr2x2 | ||
2071 | # asm 1: faddp <sr2x2=float80#1,<h0=float80#5 | ||
2072 | # asm 2: faddp <sr2x2=%st(0),<h0=%st(4) | ||
2073 | faddp %st(0),%st(4) | ||
2074 | # comment:fpstackfrombottom:<h2#40:<h0#42:<h1#41:<x3#101:<h3#39: | ||
2075 | |||
2076 | # qhasm: r0x3 = *(float64 *) &r0 | ||
2077 | # asm 1: fldl <r0=stack64#14 | ||
2078 | # asm 2: fldl <r0=136(%rsp) | ||
2079 | fldl 136(%rsp) | ||
2080 | # comment:fpstackfrombottom:<h2#40:<h0#42:<h1#41:<x3#101:<h3#39:<r0x3#110: | ||
2081 | |||
2082 | # qhasm: r0x3 *= x3 | ||
2083 | # asm 1: fmul <x3=float80#3,<r0x3=float80#1 | ||
2084 | # asm 2: fmul <x3=%st(2),<r0x3=%st(0) | ||
2085 | fmul %st(2),%st(0) | ||
2086 | # comment:fpstackfrombottom:<h2#40:<h0#42:<h1#41:<x3#101:<h3#39:<r0x3#110: | ||
2087 | |||
2088 | # qhasm: h3 += r0x3 | ||
2089 | # asm 1: faddp <r0x3=float80#1,<h3=float80#2 | ||
2090 | # asm 2: faddp <r0x3=%st(0),<h3=%st(1) | ||
2091 | faddp %st(0),%st(1) | ||
2092 | # comment:fpstackfrombottom:<h2#40:<h0#42:<h1#41:<x3#101:<h3#39: | ||
2093 | |||
2094 | # qhasm: sr3x3 = *(float64 *) &sr3 | ||
2095 | # asm 1: fldl <sr3=stack64#20 | ||
2096 | # asm 2: fldl <sr3=184(%rsp) | ||
2097 | fldl 184(%rsp) | ||
2098 | # comment:fpstackfrombottom:<h2#40:<h0#42:<h1#41:<x3#101:<h3#39:<sr3x3#111: | ||
2099 | |||
2100 | # qhasm: sr3x3 *= x3 | ||
2101 | # asm 1: fmul <x3=float80#3,<sr3x3=float80#1 | ||
2102 | # asm 2: fmul <x3=%st(2),<sr3x3=%st(0) | ||
2103 | fmul %st(2),%st(0) | ||
2104 | # comment:fpstackfrombottom:<h2#40:<h0#42:<h1#41:<x3#101:<h3#39:<sr3x3#111: | ||
2105 | |||
2106 | # qhasm: h2 += sr3x3 | ||
2107 | # asm 1: faddp <sr3x3=float80#1,<h2=float80#6 | ||
2108 | # asm 2: faddp <sr3x3=%st(0),<h2=%st(5) | ||
2109 | faddp %st(0),%st(5) | ||
2110 | # comment:fpstackfrombottom:<h2#40:<h0#42:<h1#41:<x3#101:<h3#39: | ||
2111 | |||
2112 | # qhasm: sr2x3 = *(float64 *) &sr2 | ||
2113 | # asm 1: fldl <sr2=stack64#18 | ||
2114 | # asm 2: fldl <sr2=168(%rsp) | ||
2115 | fldl 168(%rsp) | ||
2116 | # comment:fpstackfrombottom:<h2#40:<h0#42:<h1#41:<x3#101:<h3#39:<sr2x3#112: | ||
2117 | |||
2118 | # qhasm: sr2x3 *= x3 | ||
2119 | # asm 1: fmul <x3=float80#3,<sr2x3=float80#1 | ||
2120 | # asm 2: fmul <x3=%st(2),<sr2x3=%st(0) | ||
2121 | fmul %st(2),%st(0) | ||
2122 | # comment:fpstackfrombottom:<h2#40:<h0#42:<h1#41:<x3#101:<h3#39:<sr2x3#112: | ||
2123 | |||
2124 | # qhasm: h1 += sr2x3 | ||
2125 | # asm 1: faddp <sr2x3=float80#1,<h1=float80#4 | ||
2126 | # asm 2: faddp <sr2x3=%st(0),<h1=%st(3) | ||
2127 | faddp %st(0),%st(3) | ||
2128 | # comment:fpstackfrombottom:<h2#40:<h0#42:<h1#41:<x3#101:<h3#39: | ||
2129 | |||
2130 | # qhasm: sr1x3 = *(float64 *) &sr1 | ||
2131 | # asm 1: fldl <sr1=stack64#16 | ||
2132 | # asm 2: fldl <sr1=152(%rsp) | ||
2133 | fldl 152(%rsp) | ||
2134 | # comment:fpstackfrombottom:<h2#40:<h0#42:<h1#41:<x3#101:<h3#39:<sr1x3#113: | ||
2135 | |||
2136 | # qhasm: sr1x3 *= x3 | ||
2137 | # asm 1: fmulp <x3=float80#1,<sr1x3=float80#3 | ||
2138 | # asm 2: fmulp <x3=%st(0),<sr1x3=%st(2) | ||
2139 | fmulp %st(0),%st(2) | ||
2140 | # comment:fpstackfrombottom:<h2#40:<h0#42:<h1#41:<sr1x3#113:<h3#39: | ||
2141 | |||
2142 | # qhasm: internal stacktop sr1x3 | ||
2143 | # asm 1: fxch <sr1x3=float80#2 | ||
2144 | # asm 2: fxch <sr1x3=%st(1) | ||
2145 | fxch %st(1) | ||
2146 | |||
2147 | # qhasm: h0 += sr1x3 | ||
2148 | # asm 1: faddp <sr1x3=float80#1,<h0=float80#4 | ||
2149 | # asm 2: faddp <sr1x3=%st(0),<h0=%st(3) | ||
2150 | faddp %st(0),%st(3) | ||
2151 | # comment:fpstackfrombottom:<h2#40:<h0#42:<h1#41:<h3#39: | ||
2152 | # comment:automatically reorganizing fp stack for fallthrough | ||
2153 | |||
2154 | # qhasm: internal stacktop h2 | ||
2155 | # asm 1: fxch <h2=float80#4 | ||
2156 | # asm 2: fxch <h2=%st(3) | ||
2157 | fxch %st(3) | ||
2158 | # comment:fpstackfrombottom:<h3#39:<h0#42:<h1#41:<h2#40: | ||
2159 | |||
2160 | # qhasm: internal stacktop h0 | ||
2161 | # asm 1: fxch <h0=float80#3 | ||
2162 | # asm 2: fxch <h0=%st(2) | ||
2163 | fxch %st(2) | ||
2164 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
2165 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
2166 | |||
2167 | # qhasm: nomorebytes: | ||
2168 | ._nomorebytes: | ||
2169 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42: | ||
2170 | |||
2171 | # qhasm: x0 = *(float64 *) &crypto_onetimeauth_poly1305_amd64_alpha130 | ||
2172 | fldl crypto_onetimeauth_poly1305_amd64_alpha130(%rip) | ||
2173 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42:<x0#114: | ||
2174 | |||
2175 | # qhasm: x0 += h3 | ||
2176 | # asm 1: fadd <h3=float80#5,<x0=float80#1 | ||
2177 | # asm 2: fadd <h3=%st(4),<x0=%st(0) | ||
2178 | fadd %st(4),%st(0) | ||
2179 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42:<x0#114: | ||
2180 | |||
2181 | # qhasm: x0 -= *(float64 *) &crypto_onetimeauth_poly1305_amd64_alpha130 | ||
2182 | fsubl crypto_onetimeauth_poly1305_amd64_alpha130(%rip) | ||
2183 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42:<x0#114: | ||
2184 | |||
2185 | # qhasm: h3 -= x0 | ||
2186 | # asm 1: fsubr <x0=float80#1,<h3=float80#5 | ||
2187 | # asm 2: fsubr <x0=%st(0),<h3=%st(4) | ||
2188 | fsubr %st(0),%st(4) | ||
2189 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42:<x0#114: | ||
2190 | |||
2191 | # qhasm: x0 *= *(float64 *) &crypto_onetimeauth_poly1305_amd64_scale | ||
2192 | fmull crypto_onetimeauth_poly1305_amd64_scale(%rip) | ||
2193 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42:<x0#114: | ||
2194 | |||
2195 | # qhasm: x1 = *(float64 *) &crypto_onetimeauth_poly1305_amd64_alpha32 | ||
2196 | fldl crypto_onetimeauth_poly1305_amd64_alpha32(%rip) | ||
2197 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42:<x0#114:<x1#115: | ||
2198 | |||
2199 | # qhasm: x1 += h0 | ||
2200 | # asm 1: fadd <h0=float80#3,<x1=float80#1 | ||
2201 | # asm 2: fadd <h0=%st(2),<x1=%st(0) | ||
2202 | fadd %st(2),%st(0) | ||
2203 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42:<x0#114:<x1#115: | ||
2204 | |||
2205 | # qhasm: x1 -= *(float64 *) &crypto_onetimeauth_poly1305_amd64_alpha32 | ||
2206 | fsubl crypto_onetimeauth_poly1305_amd64_alpha32(%rip) | ||
2207 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42:<x0#114:<x1#115: | ||
2208 | |||
2209 | # qhasm: h0 -= x1 | ||
2210 | # asm 1: fsubr <x1=float80#1,<h0=float80#3 | ||
2211 | # asm 2: fsubr <x1=%st(0),<h0=%st(2) | ||
2212 | fsubr %st(0),%st(2) | ||
2213 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42:<x0#114:<x1#115: | ||
2214 | |||
2215 | # qhasm: x2 = *(float64 *) &crypto_onetimeauth_poly1305_amd64_alpha64 | ||
2216 | fldl crypto_onetimeauth_poly1305_amd64_alpha64(%rip) | ||
2217 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42:<x0#114:<x1#115:<x2#116: | ||
2218 | |||
2219 | # qhasm: x2 += h1 | ||
2220 | # asm 1: fadd <h1=float80#5,<x2=float80#1 | ||
2221 | # asm 2: fadd <h1=%st(4),<x2=%st(0) | ||
2222 | fadd %st(4),%st(0) | ||
2223 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42:<x0#114:<x1#115:<x2#116: | ||
2224 | |||
2225 | # qhasm: x2 -= *(float64 *) &crypto_onetimeauth_poly1305_amd64_alpha64 | ||
2226 | fsubl crypto_onetimeauth_poly1305_amd64_alpha64(%rip) | ||
2227 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42:<x0#114:<x1#115:<x2#116: | ||
2228 | |||
2229 | # qhasm: h1 -= x2 | ||
2230 | # asm 1: fsubr <x2=float80#1,<h1=float80#5 | ||
2231 | # asm 2: fsubr <x2=%st(0),<h1=%st(4) | ||
2232 | fsubr %st(0),%st(4) | ||
2233 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42:<x0#114:<x1#115:<x2#116: | ||
2234 | |||
2235 | # qhasm: x3 = *(float64 *) &crypto_onetimeauth_poly1305_amd64_alpha96 | ||
2236 | fldl crypto_onetimeauth_poly1305_amd64_alpha96(%rip) | ||
2237 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42:<x0#114:<x1#115:<x2#116:<x3#117: | ||
2238 | |||
2239 | # qhasm: x3 += h2 | ||
2240 | # asm 1: fadd <h2=float80#7,<x3=float80#1 | ||
2241 | # asm 2: fadd <h2=%st(6),<x3=%st(0) | ||
2242 | fadd %st(6),%st(0) | ||
2243 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42:<x0#114:<x1#115:<x2#116:<x3#117: | ||
2244 | |||
2245 | # qhasm: x3 -= *(float64 *) &crypto_onetimeauth_poly1305_amd64_alpha96 | ||
2246 | fsubl crypto_onetimeauth_poly1305_amd64_alpha96(%rip) | ||
2247 | # comment:fpstackfrombottom:<h3#39:<h2#40:<h1#41:<h0#42:<x0#114:<x1#115:<x2#116:<x3#117: | ||
2248 | |||
2249 | # qhasm: stacktop h2 | ||
2250 | # asm 1: fxch <h2=float80#7 | ||
2251 | # asm 2: fxch <h2=%st(6) | ||
2252 | fxch %st(6) | ||
2253 | # comment:fpstackfrombottom:<h3#39:<x3#117:<h1#41:<h0#42:<x0#114:<x1#115:<x2#116:<h2#40: | ||
2254 | |||
2255 | # qhasm: h2 -= x3 | ||
2256 | # asm 1: fsub <x3=float80#7,<h2=float80#1 | ||
2257 | # asm 2: fsub <x3=%st(6),<h2=%st(0) | ||
2258 | fsub %st(6),%st(0) | ||
2259 | # comment:fpstackfrombottom:<h3#39:<x3#117:<h1#41:<h0#42:<x0#114:<x1#115:<x2#116:<h2#40: | ||
2260 | |||
2261 | # qhasm: internal stacktop h0 | ||
2262 | # asm 1: fxch <h0=float80#5 | ||
2263 | # asm 2: fxch <h0=%st(4) | ||
2264 | fxch %st(4) | ||
2265 | |||
2266 | # qhasm: x0 += h0 | ||
2267 | # asm 1: faddp <h0=float80#1,<x0=float80#4 | ||
2268 | # asm 2: faddp <h0=%st(0),<x0=%st(3) | ||
2269 | faddp %st(0),%st(3) | ||
2270 | # comment:fpstackfrombottom:<h3#39:<x3#117:<h1#41:<h2#40:<x0#114:<x1#115:<x2#116: | ||
2271 | |||
2272 | # qhasm: internal stacktop h1 | ||
2273 | # asm 1: fxch <h1=float80#5 | ||
2274 | # asm 2: fxch <h1=%st(4) | ||
2275 | fxch %st(4) | ||
2276 | |||
2277 | # qhasm: x1 += h1 | ||
2278 | # asm 1: faddp <h1=float80#1,<x1=float80#2 | ||
2279 | # asm 2: faddp <h1=%st(0),<x1=%st(1) | ||
2280 | faddp %st(0),%st(1) | ||
2281 | # comment:fpstackfrombottom:<h3#39:<x3#117:<x2#116:<h2#40:<x0#114:<x1#115: | ||
2282 | |||
2283 | # qhasm: internal stacktop h2 | ||
2284 | # asm 1: fxch <h2=float80#3 | ||
2285 | # asm 2: fxch <h2=%st(2) | ||
2286 | fxch %st(2) | ||
2287 | |||
2288 | # qhasm: x2 += h2 | ||
2289 | # asm 1: faddp <h2=float80#1,<x2=float80#4 | ||
2290 | # asm 2: faddp <h2=%st(0),<x2=%st(3) | ||
2291 | faddp %st(0),%st(3) | ||
2292 | # comment:fpstackfrombottom:<h3#39:<x3#117:<x2#116:<x1#115:<x0#114: | ||
2293 | |||
2294 | # qhasm: internal stacktop h3 | ||
2295 | # asm 1: fxch <h3=float80#5 | ||
2296 | # asm 2: fxch <h3=%st(4) | ||
2297 | fxch %st(4) | ||
2298 | |||
2299 | # qhasm: x3 += h3 | ||
2300 | # asm 1: faddp <h3=float80#1,<x3=float80#4 | ||
2301 | # asm 2: faddp <h3=%st(0),<x3=%st(3) | ||
2302 | faddp %st(0),%st(3) | ||
2303 | # comment:fpstackfrombottom:<x0#114:<x3#117:<x2#116:<x1#115: | ||
2304 | |||
2305 | # qhasm: internal stacktop x0 | ||
2306 | # asm 1: fxch <x0=float80#4 | ||
2307 | # asm 2: fxch <x0=%st(3) | ||
2308 | fxch %st(3) | ||
2309 | |||
2310 | # qhasm: x0 += *(float64 *) &crypto_onetimeauth_poly1305_amd64_hoffset0 | ||
2311 | faddl crypto_onetimeauth_poly1305_amd64_hoffset0(%rip) | ||
2312 | # comment:fpstackfrombottom:<x1#115:<x3#117:<x2#116:<x0#114: | ||
2313 | |||
2314 | # qhasm: internal stacktop x1 | ||
2315 | # asm 1: fxch <x1=float80#4 | ||
2316 | # asm 2: fxch <x1=%st(3) | ||
2317 | fxch %st(3) | ||
2318 | |||
2319 | # qhasm: x1 += *(float64 *) &crypto_onetimeauth_poly1305_amd64_hoffset1 | ||
2320 | faddl crypto_onetimeauth_poly1305_amd64_hoffset1(%rip) | ||
2321 | # comment:fpstackfrombottom:<x0#114:<x3#117:<x2#116:<x1#115: | ||
2322 | |||
2323 | # qhasm: internal stacktop x2 | ||
2324 | # asm 1: fxch <x2=float80#2 | ||
2325 | # asm 2: fxch <x2=%st(1) | ||
2326 | fxch %st(1) | ||
2327 | |||
2328 | # qhasm: x2 += *(float64 *) &crypto_onetimeauth_poly1305_amd64_hoffset2 | ||
2329 | faddl crypto_onetimeauth_poly1305_amd64_hoffset2(%rip) | ||
2330 | # comment:fpstackfrombottom:<x0#114:<x3#117:<x1#115:<x2#116: | ||
2331 | |||
2332 | # qhasm: internal stacktop x3 | ||
2333 | # asm 1: fxch <x3=float80#3 | ||
2334 | # asm 2: fxch <x3=%st(2) | ||
2335 | fxch %st(2) | ||
2336 | |||
2337 | # qhasm: x3 += *(float64 *) &crypto_onetimeauth_poly1305_amd64_hoffset3 | ||
2338 | faddl crypto_onetimeauth_poly1305_amd64_hoffset3(%rip) | ||
2339 | # comment:fpstackfrombottom:<x0#114:<x2#116:<x1#115:<x3#117: | ||
2340 | |||
2341 | # qhasm: internal stacktop x0 | ||
2342 | # asm 1: fxch <x0=float80#4 | ||
2343 | # asm 2: fxch <x0=%st(3) | ||
2344 | fxch %st(3) | ||
2345 | |||
2346 | # qhasm: *(float64 *) &d0 = x0 | ||
2347 | # asm 1: fstpl >d0=stack64#10 | ||
2348 | # asm 2: fstpl >d0=104(%rsp) | ||
2349 | fstpl 104(%rsp) | ||
2350 | # comment:fpstackfrombottom:<x3#117:<x2#116:<x1#115: | ||
2351 | |||
2352 | # qhasm: *(float64 *) &d1 = x1 | ||
2353 | # asm 1: fstpl >d1=stack64#11 | ||
2354 | # asm 2: fstpl >d1=112(%rsp) | ||
2355 | fstpl 112(%rsp) | ||
2356 | # comment:fpstackfrombottom:<x3#117:<x2#116: | ||
2357 | |||
2358 | # qhasm: *(float64 *) &d2 = x2 | ||
2359 | # asm 1: fstpl >d2=stack64#12 | ||
2360 | # asm 2: fstpl >d2=120(%rsp) | ||
2361 | fstpl 120(%rsp) | ||
2362 | # comment:fpstackfrombottom:<x3#117: | ||
2363 | |||
2364 | # qhasm: *(float64 *) &d3 = x3 | ||
2365 | # asm 1: fstpl >d3=stack64#13 | ||
2366 | # asm 2: fstpl >d3=128(%rsp) | ||
2367 | fstpl 128(%rsp) | ||
2368 | # comment:fpstackfrombottom: | ||
2369 | |||
2370 | # qhasm: int64 f0 | ||
2371 | |||
2372 | # qhasm: int64 f1 | ||
2373 | |||
2374 | # qhasm: int64 f2 | ||
2375 | |||
2376 | # qhasm: int64 f3 | ||
2377 | |||
2378 | # qhasm: int64 f4 | ||
2379 | |||
2380 | # qhasm: int64 g0 | ||
2381 | |||
2382 | # qhasm: int64 g1 | ||
2383 | |||
2384 | # qhasm: int64 g2 | ||
2385 | |||
2386 | # qhasm: int64 g3 | ||
2387 | |||
2388 | # qhasm: int64 f | ||
2389 | |||
2390 | # qhasm: int64 notf | ||
2391 | |||
2392 | # qhasm: stack64 f1_stack | ||
2393 | |||
2394 | # qhasm: stack64 f2_stack | ||
2395 | |||
2396 | # qhasm: stack64 f3_stack | ||
2397 | |||
2398 | # qhasm: stack64 f4_stack | ||
2399 | |||
2400 | # qhasm: stack64 g0_stack | ||
2401 | |||
2402 | # qhasm: stack64 g1_stack | ||
2403 | |||
2404 | # qhasm: stack64 g2_stack | ||
2405 | |||
2406 | # qhasm: stack64 g3_stack | ||
2407 | |||
2408 | # qhasm: g0 = top d0 | ||
2409 | # asm 1: movl <d0=stack64#10,>g0=int64#1d | ||
2410 | # asm 2: movl <d0=108(%rsp),>g0=%edi | ||
2411 | movl 108(%rsp),%edi | ||
2412 | |||
2413 | # qhasm: (uint32) g0 &= 63 | ||
2414 | # asm 1: and $63,<g0=int64#1d | ||
2415 | # asm 2: and $63,<g0=%edi | ||
2416 | and $63,%edi | ||
2417 | |||
2418 | # qhasm: g1 = top d1 | ||
2419 | # asm 1: movl <d1=stack64#11,>g1=int64#2d | ||
2420 | # asm 2: movl <d1=116(%rsp),>g1=%esi | ||
2421 | movl 116(%rsp),%esi | ||
2422 | |||
2423 | # qhasm: (uint32) g1 &= 63 | ||
2424 | # asm 1: and $63,<g1=int64#2d | ||
2425 | # asm 2: and $63,<g1=%esi | ||
2426 | and $63,%esi | ||
2427 | |||
2428 | # qhasm: g2 = top d2 | ||
2429 | # asm 1: movl <d2=stack64#12,>g2=int64#3d | ||
2430 | # asm 2: movl <d2=124(%rsp),>g2=%edx | ||
2431 | movl 124(%rsp),%edx | ||
2432 | |||
2433 | # qhasm: (uint32) g2 &= 63 | ||
2434 | # asm 1: and $63,<g2=int64#3d | ||
2435 | # asm 2: and $63,<g2=%edx | ||
2436 | and $63,%edx | ||
2437 | |||
2438 | # qhasm: g3 = top d3 | ||
2439 | # asm 1: movl <d3=stack64#13,>g3=int64#4d | ||
2440 | # asm 2: movl <d3=132(%rsp),>g3=%ecx | ||
2441 | movl 132(%rsp),%ecx | ||
2442 | |||
2443 | # qhasm: (uint32) g3 &= 63 | ||
2444 | # asm 1: and $63,<g3=int64#4d | ||
2445 | # asm 2: and $63,<g3=%ecx | ||
2446 | and $63,%ecx | ||
2447 | |||
2448 | # qhasm: f1 = bottom d1 | ||
2449 | # asm 1: movl <d1=stack64#11,>f1=int64#5d | ||
2450 | # asm 2: movl <d1=112(%rsp),>f1=%r8d | ||
2451 | movl 112(%rsp),%r8d | ||
2452 | |||
2453 | # qhasm: carry? (uint32) f1 += g0 | ||
2454 | # asm 1: add <g0=int64#1d,<f1=int64#5d | ||
2455 | # asm 2: add <g0=%edi,<f1=%r8d | ||
2456 | add %edi,%r8d | ||
2457 | |||
2458 | # qhasm: f1_stack = f1 | ||
2459 | # asm 1: movq <f1=int64#5,>f1_stack=stack64#11 | ||
2460 | # asm 2: movq <f1=%r8,>f1_stack=112(%rsp) | ||
2461 | movq %r8,112(%rsp) | ||
2462 | |||
2463 | # qhasm: f2 = bottom d2 | ||
2464 | # asm 1: movl <d2=stack64#12,>f2=int64#1d | ||
2465 | # asm 2: movl <d2=120(%rsp),>f2=%edi | ||
2466 | movl 120(%rsp),%edi | ||
2467 | |||
2468 | # qhasm: carry? (uint32) f2 += g1 + carry | ||
2469 | # asm 1: adc <g1=int64#2d,<f2=int64#1d | ||
2470 | # asm 2: adc <g1=%esi,<f2=%edi | ||
2471 | adc %esi,%edi | ||
2472 | |||
2473 | # qhasm: f2_stack = f2 | ||
2474 | # asm 1: movq <f2=int64#1,>f2_stack=stack64#12 | ||
2475 | # asm 2: movq <f2=%rdi,>f2_stack=120(%rsp) | ||
2476 | movq %rdi,120(%rsp) | ||
2477 | |||
2478 | # qhasm: f3 = bottom d3 | ||
2479 | # asm 1: movl <d3=stack64#13,>f3=int64#1d | ||
2480 | # asm 2: movl <d3=128(%rsp),>f3=%edi | ||
2481 | movl 128(%rsp),%edi | ||
2482 | |||
2483 | # qhasm: carry? (uint32) f3 += g2 + carry | ||
2484 | # asm 1: adc <g2=int64#3d,<f3=int64#1d | ||
2485 | # asm 2: adc <g2=%edx,<f3=%edi | ||
2486 | adc %edx,%edi | ||
2487 | |||
2488 | # qhasm: f3_stack = f3 | ||
2489 | # asm 1: movq <f3=int64#1,>f3_stack=stack64#13 | ||
2490 | # asm 2: movq <f3=%rdi,>f3_stack=128(%rsp) | ||
2491 | movq %rdi,128(%rsp) | ||
2492 | |||
2493 | # qhasm: f4 = 0 | ||
2494 | # asm 1: mov $0,>f4=int64#1 | ||
2495 | # asm 2: mov $0,>f4=%rdi | ||
2496 | mov $0,%rdi | ||
2497 | |||
2498 | # qhasm: carry? (uint32) f4 += g3 + carry | ||
2499 | # asm 1: adc <g3=int64#4d,<f4=int64#1d | ||
2500 | # asm 2: adc <g3=%ecx,<f4=%edi | ||
2501 | adc %ecx,%edi | ||
2502 | |||
2503 | # qhasm: f4_stack = f4 | ||
2504 | # asm 1: movq <f4=int64#1,>f4_stack=stack64#14 | ||
2505 | # asm 2: movq <f4=%rdi,>f4_stack=136(%rsp) | ||
2506 | movq %rdi,136(%rsp) | ||
2507 | |||
2508 | # qhasm: g0 = 5 | ||
2509 | # asm 1: mov $5,>g0=int64#1 | ||
2510 | # asm 2: mov $5,>g0=%rdi | ||
2511 | mov $5,%rdi | ||
2512 | |||
2513 | # qhasm: f0 = bottom d0 | ||
2514 | # asm 1: movl <d0=stack64#10,>f0=int64#2d | ||
2515 | # asm 2: movl <d0=104(%rsp),>f0=%esi | ||
2516 | movl 104(%rsp),%esi | ||
2517 | |||
2518 | # qhasm: carry? (uint32) g0 += f0 | ||
2519 | # asm 1: add <f0=int64#2d,<g0=int64#1d | ||
2520 | # asm 2: add <f0=%esi,<g0=%edi | ||
2521 | add %esi,%edi | ||
2522 | |||
2523 | # qhasm: g0_stack = g0 | ||
2524 | # asm 1: movq <g0=int64#1,>g0_stack=stack64#10 | ||
2525 | # asm 2: movq <g0=%rdi,>g0_stack=104(%rsp) | ||
2526 | movq %rdi,104(%rsp) | ||
2527 | |||
2528 | # qhasm: g1 = 0 | ||
2529 | # asm 1: mov $0,>g1=int64#1 | ||
2530 | # asm 2: mov $0,>g1=%rdi | ||
2531 | mov $0,%rdi | ||
2532 | |||
2533 | # qhasm: f1 = f1_stack | ||
2534 | # asm 1: movq <f1_stack=stack64#11,>f1=int64#3 | ||
2535 | # asm 2: movq <f1_stack=112(%rsp),>f1=%rdx | ||
2536 | movq 112(%rsp),%rdx | ||
2537 | |||
2538 | # qhasm: carry? (uint32) g1 += f1 + carry | ||
2539 | # asm 1: adc <f1=int64#3d,<g1=int64#1d | ||
2540 | # asm 2: adc <f1=%edx,<g1=%edi | ||
2541 | adc %edx,%edi | ||
2542 | |||
2543 | # qhasm: g1_stack = g1 | ||
2544 | # asm 1: movq <g1=int64#1,>g1_stack=stack64#11 | ||
2545 | # asm 2: movq <g1=%rdi,>g1_stack=112(%rsp) | ||
2546 | movq %rdi,112(%rsp) | ||
2547 | |||
2548 | # qhasm: g2 = 0 | ||
2549 | # asm 1: mov $0,>g2=int64#1 | ||
2550 | # asm 2: mov $0,>g2=%rdi | ||
2551 | mov $0,%rdi | ||
2552 | |||
2553 | # qhasm: f2 = f2_stack | ||
2554 | # asm 1: movq <f2_stack=stack64#12,>f2=int64#4 | ||
2555 | # asm 2: movq <f2_stack=120(%rsp),>f2=%rcx | ||
2556 | movq 120(%rsp),%rcx | ||
2557 | |||
2558 | # qhasm: carry? (uint32) g2 += f2 + carry | ||
2559 | # asm 1: adc <f2=int64#4d,<g2=int64#1d | ||
2560 | # asm 2: adc <f2=%ecx,<g2=%edi | ||
2561 | adc %ecx,%edi | ||
2562 | |||
2563 | # qhasm: g2_stack = g2 | ||
2564 | # asm 1: movq <g2=int64#1,>g2_stack=stack64#12 | ||
2565 | # asm 2: movq <g2=%rdi,>g2_stack=120(%rsp) | ||
2566 | movq %rdi,120(%rsp) | ||
2567 | |||
2568 | # qhasm: g3 = 0 | ||
2569 | # asm 1: mov $0,>g3=int64#1 | ||
2570 | # asm 2: mov $0,>g3=%rdi | ||
2571 | mov $0,%rdi | ||
2572 | |||
2573 | # qhasm: f3 = f3_stack | ||
2574 | # asm 1: movq <f3_stack=stack64#13,>f3=int64#5 | ||
2575 | # asm 2: movq <f3_stack=128(%rsp),>f3=%r8 | ||
2576 | movq 128(%rsp),%r8 | ||
2577 | |||
2578 | # qhasm: carry? (uint32) g3 += f3 + carry | ||
2579 | # asm 1: adc <f3=int64#5d,<g3=int64#1d | ||
2580 | # asm 2: adc <f3=%r8d,<g3=%edi | ||
2581 | adc %r8d,%edi | ||
2582 | |||
2583 | # qhasm: g3_stack = g3 | ||
2584 | # asm 1: movq <g3=int64#1,>g3_stack=stack64#13 | ||
2585 | # asm 2: movq <g3=%rdi,>g3_stack=128(%rsp) | ||
2586 | movq %rdi,128(%rsp) | ||
2587 | |||
2588 | # qhasm: f = 0xfffffffc | ||
2589 | # asm 1: mov $0xfffffffc,>f=int64#1 | ||
2590 | # asm 2: mov $0xfffffffc,>f=%rdi | ||
2591 | mov $0xfffffffc,%rdi | ||
2592 | |||
2593 | # qhasm: f4 = f4_stack | ||
2594 | # asm 1: movq <f4_stack=stack64#14,>f4=int64#6 | ||
2595 | # asm 2: movq <f4_stack=136(%rsp),>f4=%r9 | ||
2596 | movq 136(%rsp),%r9 | ||
2597 | |||
2598 | # qhasm: carry? (uint32) f += f4 + carry | ||
2599 | # asm 1: adc <f4=int64#6d,<f=int64#1d | ||
2600 | # asm 2: adc <f4=%r9d,<f=%edi | ||
2601 | adc %r9d,%edi | ||
2602 | |||
2603 | # qhasm: (int32) f >>= 16 | ||
2604 | # asm 1: sar $16,<f=int64#1d | ||
2605 | # asm 2: sar $16,<f=%edi | ||
2606 | sar $16,%edi | ||
2607 | |||
2608 | # qhasm: notf = f | ||
2609 | # asm 1: mov <f=int64#1,>notf=int64#6 | ||
2610 | # asm 2: mov <f=%rdi,>notf=%r9 | ||
2611 | mov %rdi,%r9 | ||
2612 | |||
2613 | # qhasm: (uint32) notf ^= 0xffffffff | ||
2614 | # asm 1: xor $0xffffffff,<notf=int64#6d | ||
2615 | # asm 2: xor $0xffffffff,<notf=%r9d | ||
2616 | xor $0xffffffff,%r9d | ||
2617 | |||
2618 | # qhasm: f0 &= f | ||
2619 | # asm 1: and <f=int64#1,<f0=int64#2 | ||
2620 | # asm 2: and <f=%rdi,<f0=%rsi | ||
2621 | and %rdi,%rsi | ||
2622 | |||
2623 | # qhasm: g0 = g0_stack | ||
2624 | # asm 1: movq <g0_stack=stack64#10,>g0=int64#7 | ||
2625 | # asm 2: movq <g0_stack=104(%rsp),>g0=%rax | ||
2626 | movq 104(%rsp),%rax | ||
2627 | |||
2628 | # qhasm: g0 &= notf | ||
2629 | # asm 1: and <notf=int64#6,<g0=int64#7 | ||
2630 | # asm 2: and <notf=%r9,<g0=%rax | ||
2631 | and %r9,%rax | ||
2632 | |||
2633 | # qhasm: f0 |= g0 | ||
2634 | # asm 1: or <g0=int64#7,<f0=int64#2 | ||
2635 | # asm 2: or <g0=%rax,<f0=%rsi | ||
2636 | or %rax,%rsi | ||
2637 | |||
2638 | # qhasm: f1 &= f | ||
2639 | # asm 1: and <f=int64#1,<f1=int64#3 | ||
2640 | # asm 2: and <f=%rdi,<f1=%rdx | ||
2641 | and %rdi,%rdx | ||
2642 | |||
2643 | # qhasm: g1 = g1_stack | ||
2644 | # asm 1: movq <g1_stack=stack64#11,>g1=int64#7 | ||
2645 | # asm 2: movq <g1_stack=112(%rsp),>g1=%rax | ||
2646 | movq 112(%rsp),%rax | ||
2647 | |||
2648 | # qhasm: g1 &= notf | ||
2649 | # asm 1: and <notf=int64#6,<g1=int64#7 | ||
2650 | # asm 2: and <notf=%r9,<g1=%rax | ||
2651 | and %r9,%rax | ||
2652 | |||
2653 | # qhasm: f1 |= g1 | ||
2654 | # asm 1: or <g1=int64#7,<f1=int64#3 | ||
2655 | # asm 2: or <g1=%rax,<f1=%rdx | ||
2656 | or %rax,%rdx | ||
2657 | |||
2658 | # qhasm: f2 &= f | ||
2659 | # asm 1: and <f=int64#1,<f2=int64#4 | ||
2660 | # asm 2: and <f=%rdi,<f2=%rcx | ||
2661 | and %rdi,%rcx | ||
2662 | |||
2663 | # qhasm: g2 = g2_stack | ||
2664 | # asm 1: movq <g2_stack=stack64#12,>g2=int64#7 | ||
2665 | # asm 2: movq <g2_stack=120(%rsp),>g2=%rax | ||
2666 | movq 120(%rsp),%rax | ||
2667 | |||
2668 | # qhasm: g2 &= notf | ||
2669 | # asm 1: and <notf=int64#6,<g2=int64#7 | ||
2670 | # asm 2: and <notf=%r9,<g2=%rax | ||
2671 | and %r9,%rax | ||
2672 | |||
2673 | # qhasm: f2 |= g2 | ||
2674 | # asm 1: or <g2=int64#7,<f2=int64#4 | ||
2675 | # asm 2: or <g2=%rax,<f2=%rcx | ||
2676 | or %rax,%rcx | ||
2677 | |||
2678 | # qhasm: f3 &= f | ||
2679 | # asm 1: and <f=int64#1,<f3=int64#5 | ||
2680 | # asm 2: and <f=%rdi,<f3=%r8 | ||
2681 | and %rdi,%r8 | ||
2682 | |||
2683 | # qhasm: g3 = g3_stack | ||
2684 | # asm 1: movq <g3_stack=stack64#13,>g3=int64#1 | ||
2685 | # asm 2: movq <g3_stack=128(%rsp),>g3=%rdi | ||
2686 | movq 128(%rsp),%rdi | ||
2687 | |||
2688 | # qhasm: g3 &= notf | ||
2689 | # asm 1: and <notf=int64#6,<g3=int64#1 | ||
2690 | # asm 2: and <notf=%r9,<g3=%rdi | ||
2691 | and %r9,%rdi | ||
2692 | |||
2693 | # qhasm: f3 |= g3 | ||
2694 | # asm 1: or <g3=int64#1,<f3=int64#5 | ||
2695 | # asm 2: or <g3=%rdi,<f3=%r8 | ||
2696 | or %rdi,%r8 | ||
2697 | |||
2698 | # qhasm: out = out_stack | ||
2699 | # asm 1: movq <out_stack=stack64#8,>out=int64#1 | ||
2700 | # asm 2: movq <out_stack=88(%rsp),>out=%rdi | ||
2701 | movq 88(%rsp),%rdi | ||
2702 | |||
2703 | # qhasm: k = k_stack | ||
2704 | # asm 1: movq <k_stack=stack64#9,>k=int64#6 | ||
2705 | # asm 2: movq <k_stack=96(%rsp),>k=%r9 | ||
2706 | movq 96(%rsp),%r9 | ||
2707 | |||
2708 | # qhasm: carry? (uint32) f0 += *(uint32 *) (k + 16) | ||
2709 | # asm 1: addl 16(<k=int64#6),<f0=int64#2d | ||
2710 | # asm 2: addl 16(<k=%r9),<f0=%esi | ||
2711 | addl 16(%r9),%esi | ||
2712 | |||
2713 | # qhasm: carry? (uint32) f1 += *(uint32 *) (k + 20) + carry | ||
2714 | # asm 1: adcl 20(<k=int64#6),<f1=int64#3d | ||
2715 | # asm 2: adcl 20(<k=%r9),<f1=%edx | ||
2716 | adcl 20(%r9),%edx | ||
2717 | |||
2718 | # qhasm: carry? (uint32) f2 += *(uint32 *) (k + 24) + carry | ||
2719 | # asm 1: adcl 24(<k=int64#6),<f2=int64#4d | ||
2720 | # asm 2: adcl 24(<k=%r9),<f2=%ecx | ||
2721 | adcl 24(%r9),%ecx | ||
2722 | |||
2723 | # qhasm: carry? (uint32) f3 += *(uint32 *) (k + 28) + carry | ||
2724 | # asm 1: adcl 28(<k=int64#6),<f3=int64#5d | ||
2725 | # asm 2: adcl 28(<k=%r9),<f3=%r8d | ||
2726 | adcl 28(%r9),%r8d | ||
2727 | |||
2728 | # qhasm: *(uint32 *) (out + 0) = f0 | ||
2729 | # asm 1: movl <f0=int64#2d,0(<out=int64#1) | ||
2730 | # asm 2: movl <f0=%esi,0(<out=%rdi) | ||
2731 | movl %esi,0(%rdi) | ||
2732 | |||
2733 | # qhasm: *(uint32 *) (out + 4) = f1 | ||
2734 | # asm 1: movl <f1=int64#3d,4(<out=int64#1) | ||
2735 | # asm 2: movl <f1=%edx,4(<out=%rdi) | ||
2736 | movl %edx,4(%rdi) | ||
2737 | |||
2738 | # qhasm: *(uint32 *) (out + 8) = f2 | ||
2739 | # asm 1: movl <f2=int64#4d,8(<out=int64#1) | ||
2740 | # asm 2: movl <f2=%ecx,8(<out=%rdi) | ||
2741 | movl %ecx,8(%rdi) | ||
2742 | |||
2743 | # qhasm: *(uint32 *) (out + 12) = f3 | ||
2744 | # asm 1: movl <f3=int64#5d,12(<out=int64#1) | ||
2745 | # asm 2: movl <f3=%r8d,12(<out=%rdi) | ||
2746 | movl %r8d,12(%rdi) | ||
2747 | |||
2748 | # qhasm: r11_caller = r11_stack | ||
2749 | # asm 1: movq <r11_stack=stack64#1,>r11_caller=int64#9 | ||
2750 | # asm 2: movq <r11_stack=32(%rsp),>r11_caller=%r11 | ||
2751 | movq 32(%rsp),%r11 | ||
2752 | |||
2753 | # qhasm: r12_caller = r12_stack | ||
2754 | # asm 1: movq <r12_stack=stack64#2,>r12_caller=int64#10 | ||
2755 | # asm 2: movq <r12_stack=40(%rsp),>r12_caller=%r12 | ||
2756 | movq 40(%rsp),%r12 | ||
2757 | |||
2758 | # qhasm: r13_caller = r13_stack | ||
2759 | # asm 1: movq <r13_stack=stack64#3,>r13_caller=int64#11 | ||
2760 | # asm 2: movq <r13_stack=48(%rsp),>r13_caller=%r13 | ||
2761 | movq 48(%rsp),%r13 | ||
2762 | |||
2763 | # qhasm: r14_caller = r14_stack | ||
2764 | # asm 1: movq <r14_stack=stack64#4,>r14_caller=int64#12 | ||
2765 | # asm 2: movq <r14_stack=56(%rsp),>r14_caller=%r14 | ||
2766 | movq 56(%rsp),%r14 | ||
2767 | |||
2768 | # qhasm: r15_caller = r15_stack | ||
2769 | # asm 1: movq <r15_stack=stack64#5,>r15_caller=int64#13 | ||
2770 | # asm 2: movq <r15_stack=64(%rsp),>r15_caller=%r15 | ||
2771 | movq 64(%rsp),%r15 | ||
2772 | |||
2773 | # qhasm: rbx_caller = rbx_stack | ||
2774 | # asm 1: movq <rbx_stack=stack64#6,>rbx_caller=int64#14 | ||
2775 | # asm 2: movq <rbx_stack=72(%rsp),>rbx_caller=%rbx | ||
2776 | movq 72(%rsp),%rbx | ||
2777 | |||
2778 | # qhasm: rbp_caller = rbp_stack | ||
2779 | # asm 1: movq <rbp_stack=stack64#7,>rbp_caller=int64#15 | ||
2780 | # asm 2: movq <rbp_stack=80(%rsp),>rbp_caller=%rbp | ||
2781 | movq 80(%rsp),%rbp | ||
2782 | |||
2783 | # qhasm: leave | ||
2784 | add %r11,%rsp | ||
2785 | xor %rax,%rax | ||
2786 | xor %rdx,%rdx | ||
2787 | ret | ||
diff --git a/nacl/crypto_onetimeauth/poly1305/amd64/constants.s b/nacl/crypto_onetimeauth/poly1305/amd64/constants.s deleted file mode 100644 index 1bfb0be9..00000000 --- a/nacl/crypto_onetimeauth/poly1305/amd64/constants.s +++ /dev/null | |||
@@ -1,85 +0,0 @@ | |||
1 | # version 20080913 | ||
2 | # D. J. Bernstein | ||
3 | # Public domain. | ||
4 | |||
5 | .data | ||
6 | .section .rodata | ||
7 | .p2align 5 | ||
8 | |||
9 | .globl _crypto_onetimeauth_poly1305_amd64_constants | ||
10 | .globl crypto_onetimeauth_poly1305_amd64_constants | ||
11 | .globl crypto_onetimeauth_poly1305_amd64_scale | ||
12 | .globl crypto_onetimeauth_poly1305_amd64_two32 | ||
13 | .globl crypto_onetimeauth_poly1305_amd64_two64 | ||
14 | .globl crypto_onetimeauth_poly1305_amd64_two96 | ||
15 | .globl crypto_onetimeauth_poly1305_amd64_alpha32 | ||
16 | .globl crypto_onetimeauth_poly1305_amd64_alpha64 | ||
17 | .globl crypto_onetimeauth_poly1305_amd64_alpha96 | ||
18 | .globl crypto_onetimeauth_poly1305_amd64_alpha130 | ||
19 | .globl crypto_onetimeauth_poly1305_amd64_doffset0 | ||
20 | .globl crypto_onetimeauth_poly1305_amd64_doffset1 | ||
21 | .globl crypto_onetimeauth_poly1305_amd64_doffset2 | ||
22 | .globl crypto_onetimeauth_poly1305_amd64_doffset3 | ||
23 | .globl crypto_onetimeauth_poly1305_amd64_doffset3minustwo128 | ||
24 | .globl crypto_onetimeauth_poly1305_amd64_hoffset0 | ||
25 | .globl crypto_onetimeauth_poly1305_amd64_hoffset1 | ||
26 | .globl crypto_onetimeauth_poly1305_amd64_hoffset2 | ||
27 | .globl crypto_onetimeauth_poly1305_amd64_hoffset3 | ||
28 | .globl crypto_onetimeauth_poly1305_amd64_rounding | ||
29 | |||
30 | _crypto_onetimeauth_poly1305_amd64_constants: | ||
31 | crypto_onetimeauth_poly1305_amd64_constants: | ||
32 | crypto_onetimeauth_poly1305_amd64_scale: | ||
33 | .long 0x0,0x37f40000 | ||
34 | |||
35 | crypto_onetimeauth_poly1305_amd64_two32: | ||
36 | .long 0x0,0x41f00000 | ||
37 | |||
38 | crypto_onetimeauth_poly1305_amd64_two64: | ||
39 | .long 0x0,0x43f00000 | ||
40 | |||
41 | crypto_onetimeauth_poly1305_amd64_two96: | ||
42 | .long 0x0,0x45f00000 | ||
43 | |||
44 | crypto_onetimeauth_poly1305_amd64_alpha32: | ||
45 | .long 0x0,0x45e80000 | ||
46 | |||
47 | crypto_onetimeauth_poly1305_amd64_alpha64: | ||
48 | .long 0x0,0x47e80000 | ||
49 | |||
50 | crypto_onetimeauth_poly1305_amd64_alpha96: | ||
51 | .long 0x0,0x49e80000 | ||
52 | |||
53 | crypto_onetimeauth_poly1305_amd64_alpha130: | ||
54 | .long 0x0,0x4c080000 | ||
55 | |||
56 | crypto_onetimeauth_poly1305_amd64_doffset0: | ||
57 | .long 0x0,0x43300000 | ||
58 | |||
59 | crypto_onetimeauth_poly1305_amd64_doffset1: | ||
60 | .long 0x0,0x45300000 | ||
61 | |||
62 | crypto_onetimeauth_poly1305_amd64_doffset2: | ||
63 | .long 0x0,0x47300000 | ||
64 | |||
65 | crypto_onetimeauth_poly1305_amd64_doffset3: | ||
66 | .long 0x0,0x49300000 | ||
67 | |||
68 | crypto_onetimeauth_poly1305_amd64_doffset3minustwo128: | ||
69 | .long 0x0,0x492ffffe | ||
70 | |||
71 | crypto_onetimeauth_poly1305_amd64_hoffset0: | ||
72 | .long 0xfffffffb,0x43300001 | ||
73 | |||
74 | crypto_onetimeauth_poly1305_amd64_hoffset1: | ||
75 | .long 0xfffffffe,0x45300001 | ||
76 | |||
77 | crypto_onetimeauth_poly1305_amd64_hoffset2: | ||
78 | .long 0xfffffffe,0x47300001 | ||
79 | |||
80 | crypto_onetimeauth_poly1305_amd64_hoffset3: | ||
81 | .long 0xfffffffe,0x49300003 | ||
82 | |||
83 | crypto_onetimeauth_poly1305_amd64_rounding: | ||
84 | .byte 0x7f | ||
85 | .byte 0x13 | ||
diff --git a/nacl/crypto_onetimeauth/poly1305/amd64/verify.c b/nacl/crypto_onetimeauth/poly1305/amd64/verify.c deleted file mode 100644 index c7e063f1..00000000 --- a/nacl/crypto_onetimeauth/poly1305/amd64/verify.c +++ /dev/null | |||
@@ -1,9 +0,0 @@ | |||
1 | #include "crypto_verify_16.h" | ||
2 | #include "crypto_onetimeauth.h" | ||
3 | |||
4 | int crypto_onetimeauth_verify(const unsigned char *h,const unsigned char *in,unsigned long long inlen,const unsigned char *k) | ||
5 | { | ||
6 | unsigned char correct[16]; | ||
7 | crypto_onetimeauth(correct,in,inlen,k); | ||
8 | return crypto_verify_16(h,correct); | ||
9 | } | ||
diff --git a/nacl/crypto_onetimeauth/poly1305/checksum b/nacl/crypto_onetimeauth/poly1305/checksum deleted file mode 100644 index a713ea40..00000000 --- a/nacl/crypto_onetimeauth/poly1305/checksum +++ /dev/null | |||
@@ -1 +0,0 @@ | |||
1 | e836d5ca58cf673fca2b4910f23f3990 | ||
diff --git a/nacl/crypto_onetimeauth/poly1305/ref/api.h b/nacl/crypto_onetimeauth/poly1305/ref/api.h deleted file mode 100644 index acc133ed..00000000 --- a/nacl/crypto_onetimeauth/poly1305/ref/api.h +++ /dev/null | |||
@@ -1,2 +0,0 @@ | |||
1 | #define CRYPTO_BYTES 16 | ||
2 | #define CRYPTO_KEYBYTES 32 | ||
diff --git a/nacl/crypto_onetimeauth/poly1305/ref/auth.c b/nacl/crypto_onetimeauth/poly1305/ref/auth.c deleted file mode 100644 index 06cf115d..00000000 --- a/nacl/crypto_onetimeauth/poly1305/ref/auth.c +++ /dev/null | |||
@@ -1,104 +0,0 @@ | |||
1 | /* | ||
2 | 20080912 | ||
3 | D. J. Bernstein | ||
4 | Public domain. | ||
5 | */ | ||
6 | |||
7 | #include "crypto_onetimeauth.h" | ||
8 | |||
9 | static void add(unsigned int h[17],const unsigned int c[17]) | ||
10 | { | ||
11 | unsigned int j; | ||
12 | unsigned int u; | ||
13 | u = 0; | ||
14 | for (j = 0;j < 17;++j) { u += h[j] + c[j]; h[j] = u & 255; u >>= 8; } | ||
15 | } | ||
16 | |||
17 | static void squeeze(unsigned int h[17]) | ||
18 | { | ||
19 | unsigned int j; | ||
20 | unsigned int u; | ||
21 | u = 0; | ||
22 | for (j = 0;j < 16;++j) { u += h[j]; h[j] = u & 255; u >>= 8; } | ||
23 | u += h[16]; h[16] = u & 3; | ||
24 | u = 5 * (u >> 2); | ||
25 | for (j = 0;j < 16;++j) { u += h[j]; h[j] = u & 255; u >>= 8; } | ||
26 | u += h[16]; h[16] = u; | ||
27 | } | ||
28 | |||
29 | static const unsigned int minusp[17] = { | ||
30 | 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 252 | ||
31 | } ; | ||
32 | |||
33 | static void freeze(unsigned int h[17]) | ||
34 | { | ||
35 | unsigned int horig[17]; | ||
36 | unsigned int j; | ||
37 | unsigned int negative; | ||
38 | for (j = 0;j < 17;++j) horig[j] = h[j]; | ||
39 | add(h,minusp); | ||
40 | negative = -(h[16] >> 7); | ||
41 | for (j = 0;j < 17;++j) h[j] ^= negative & (horig[j] ^ h[j]); | ||
42 | } | ||
43 | |||
44 | static void mulmod(unsigned int h[17],const unsigned int r[17]) | ||
45 | { | ||
46 | unsigned int hr[17]; | ||
47 | unsigned int i; | ||
48 | unsigned int j; | ||
49 | unsigned int u; | ||
50 | |||
51 | for (i = 0;i < 17;++i) { | ||
52 | u = 0; | ||
53 | for (j = 0;j <= i;++j) u += h[j] * r[i - j]; | ||
54 | for (j = i + 1;j < 17;++j) u += 320 * h[j] * r[i + 17 - j]; | ||
55 | hr[i] = u; | ||
56 | } | ||
57 | for (i = 0;i < 17;++i) h[i] = hr[i]; | ||
58 | squeeze(h); | ||
59 | } | ||
60 | |||
61 | int crypto_onetimeauth(unsigned char *out,const unsigned char *in,unsigned long long inlen,const unsigned char *k) | ||
62 | { | ||
63 | unsigned int j; | ||
64 | unsigned int r[17]; | ||
65 | unsigned int h[17]; | ||
66 | unsigned int c[17]; | ||
67 | |||
68 | r[0] = k[0]; | ||
69 | r[1] = k[1]; | ||
70 | r[2] = k[2]; | ||
71 | r[3] = k[3] & 15; | ||
72 | r[4] = k[4] & 252; | ||
73 | r[5] = k[5]; | ||
74 | r[6] = k[6]; | ||
75 | r[7] = k[7] & 15; | ||
76 | r[8] = k[8] & 252; | ||
77 | r[9] = k[9]; | ||
78 | r[10] = k[10]; | ||
79 | r[11] = k[11] & 15; | ||
80 | r[12] = k[12] & 252; | ||
81 | r[13] = k[13]; | ||
82 | r[14] = k[14]; | ||
83 | r[15] = k[15] & 15; | ||
84 | r[16] = 0; | ||
85 | |||
86 | for (j = 0;j < 17;++j) h[j] = 0; | ||
87 | |||
88 | while (inlen > 0) { | ||
89 | for (j = 0;j < 17;++j) c[j] = 0; | ||
90 | for (j = 0;(j < 16) && (j < inlen);++j) c[j] = in[j]; | ||
91 | c[j] = 1; | ||
92 | in += j; inlen -= j; | ||
93 | add(h,c); | ||
94 | mulmod(h,r); | ||
95 | } | ||
96 | |||
97 | freeze(h); | ||
98 | |||
99 | for (j = 0;j < 16;++j) c[j] = k[j + 16]; | ||
100 | c[16] = 0; | ||
101 | add(h,c); | ||
102 | for (j = 0;j < 16;++j) out[j] = h[j]; | ||
103 | return 0; | ||
104 | } | ||
diff --git a/nacl/crypto_onetimeauth/poly1305/ref/verify.c b/nacl/crypto_onetimeauth/poly1305/ref/verify.c deleted file mode 100644 index c7e063f1..00000000 --- a/nacl/crypto_onetimeauth/poly1305/ref/verify.c +++ /dev/null | |||
@@ -1,9 +0,0 @@ | |||
1 | #include "crypto_verify_16.h" | ||
2 | #include "crypto_onetimeauth.h" | ||
3 | |||
4 | int crypto_onetimeauth_verify(const unsigned char *h,const unsigned char *in,unsigned long long inlen,const unsigned char *k) | ||
5 | { | ||
6 | unsigned char correct[16]; | ||
7 | crypto_onetimeauth(correct,in,inlen,k); | ||
8 | return crypto_verify_16(h,correct); | ||
9 | } | ||
diff --git a/nacl/crypto_onetimeauth/poly1305/selected b/nacl/crypto_onetimeauth/poly1305/selected deleted file mode 100644 index e69de29b..00000000 --- a/nacl/crypto_onetimeauth/poly1305/selected +++ /dev/null | |||
diff --git a/nacl/crypto_onetimeauth/poly1305/used b/nacl/crypto_onetimeauth/poly1305/used deleted file mode 100644 index e69de29b..00000000 --- a/nacl/crypto_onetimeauth/poly1305/used +++ /dev/null | |||
diff --git a/nacl/crypto_onetimeauth/poly1305/x86/api.h b/nacl/crypto_onetimeauth/poly1305/x86/api.h deleted file mode 100644 index acc133ed..00000000 --- a/nacl/crypto_onetimeauth/poly1305/x86/api.h +++ /dev/null | |||
@@ -1,2 +0,0 @@ | |||
1 | #define CRYPTO_BYTES 16 | ||
2 | #define CRYPTO_KEYBYTES 32 | ||
diff --git a/nacl/crypto_onetimeauth/poly1305/x86/auth.s b/nacl/crypto_onetimeauth/poly1305/x86/auth.s deleted file mode 100644 index acb8c51c..00000000 --- a/nacl/crypto_onetimeauth/poly1305/x86/auth.s +++ /dev/null | |||
@@ -1,2779 +0,0 @@ | |||
1 | |||
2 | # qhasm: stack32 arg_out | ||
3 | |||
4 | # qhasm: stack32 arg_m | ||
5 | |||
6 | # qhasm: stack32 arg_l | ||
7 | |||
8 | # qhasm: stack32 arg_ltop | ||
9 | |||
10 | # qhasm: stack32 arg_k | ||
11 | |||
12 | # qhasm: input arg_out | ||
13 | |||
14 | # qhasm: input arg_m | ||
15 | |||
16 | # qhasm: input arg_l | ||
17 | |||
18 | # qhasm: input arg_ltop | ||
19 | |||
20 | # qhasm: input arg_k | ||
21 | |||
22 | # qhasm: int32 eax | ||
23 | |||
24 | # qhasm: int32 ebx | ||
25 | |||
26 | # qhasm: int32 esi | ||
27 | |||
28 | # qhasm: int32 edi | ||
29 | |||
30 | # qhasm: int32 ebp | ||
31 | |||
32 | # qhasm: caller eax | ||
33 | |||
34 | # qhasm: caller ebx | ||
35 | |||
36 | # qhasm: caller esi | ||
37 | |||
38 | # qhasm: caller edi | ||
39 | |||
40 | # qhasm: caller ebp | ||
41 | |||
42 | # qhasm: stack32 eax_stack | ||
43 | |||
44 | # qhasm: stack32 ebx_stack | ||
45 | |||
46 | # qhasm: stack32 esi_stack | ||
47 | |||
48 | # qhasm: stack32 edi_stack | ||
49 | |||
50 | # qhasm: stack32 ebp_stack | ||
51 | |||
52 | # qhasm: int32 out | ||
53 | |||
54 | # qhasm: stack32 out_stack | ||
55 | |||
56 | # qhasm: int32 k | ||
57 | |||
58 | # qhasm: stack32 k_stack | ||
59 | |||
60 | # qhasm: int32 m | ||
61 | |||
62 | # qhasm: int32 l | ||
63 | |||
64 | # qhasm: int32 m0 | ||
65 | |||
66 | # qhasm: int32 m1 | ||
67 | |||
68 | # qhasm: int32 m2 | ||
69 | |||
70 | # qhasm: int32 m3 | ||
71 | |||
72 | # qhasm: float80 a0 | ||
73 | |||
74 | # qhasm: float80 a1 | ||
75 | |||
76 | # qhasm: float80 a2 | ||
77 | |||
78 | # qhasm: float80 a3 | ||
79 | |||
80 | # qhasm: float80 h0 | ||
81 | |||
82 | # qhasm: float80 h1 | ||
83 | |||
84 | # qhasm: float80 h2 | ||
85 | |||
86 | # qhasm: float80 h3 | ||
87 | |||
88 | # qhasm: float80 x0 | ||
89 | |||
90 | # qhasm: float80 x1 | ||
91 | |||
92 | # qhasm: float80 x2 | ||
93 | |||
94 | # qhasm: float80 x3 | ||
95 | |||
96 | # qhasm: float80 y0 | ||
97 | |||
98 | # qhasm: float80 y1 | ||
99 | |||
100 | # qhasm: float80 y2 | ||
101 | |||
102 | # qhasm: float80 y3 | ||
103 | |||
104 | # qhasm: float80 r0x0 | ||
105 | |||
106 | # qhasm: float80 r1x0 | ||
107 | |||
108 | # qhasm: float80 r2x0 | ||
109 | |||
110 | # qhasm: float80 r3x0 | ||
111 | |||
112 | # qhasm: float80 r0x1 | ||
113 | |||
114 | # qhasm: float80 r1x1 | ||
115 | |||
116 | # qhasm: float80 r2x1 | ||
117 | |||
118 | # qhasm: float80 sr3x1 | ||
119 | |||
120 | # qhasm: float80 r0x2 | ||
121 | |||
122 | # qhasm: float80 r1x2 | ||
123 | |||
124 | # qhasm: float80 sr2x2 | ||
125 | |||
126 | # qhasm: float80 sr3x2 | ||
127 | |||
128 | # qhasm: float80 r0x3 | ||
129 | |||
130 | # qhasm: float80 sr1x3 | ||
131 | |||
132 | # qhasm: float80 sr2x3 | ||
133 | |||
134 | # qhasm: float80 sr3x3 | ||
135 | |||
136 | # qhasm: stack64 d0 | ||
137 | |||
138 | # qhasm: stack64 d1 | ||
139 | |||
140 | # qhasm: stack64 d2 | ||
141 | |||
142 | # qhasm: stack64 d3 | ||
143 | |||
144 | # qhasm: stack64 r0 | ||
145 | |||
146 | # qhasm: stack64 r1 | ||
147 | |||
148 | # qhasm: stack64 r2 | ||
149 | |||
150 | # qhasm: stack64 r3 | ||
151 | |||
152 | # qhasm: stack64 sr1 | ||
153 | |||
154 | # qhasm: stack64 sr2 | ||
155 | |||
156 | # qhasm: stack64 sr3 | ||
157 | |||
158 | # qhasm: enter crypto_onetimeauth_poly1305_x86 stackaligned4096 crypto_onetimeauth_poly1305_x86_constants | ||
159 | .text | ||
160 | .p2align 5 | ||
161 | .globl _crypto_onetimeauth_poly1305_x86 | ||
162 | .globl crypto_onetimeauth_poly1305_x86 | ||
163 | _crypto_onetimeauth_poly1305_x86: | ||
164 | crypto_onetimeauth_poly1305_x86: | ||
165 | mov %esp,%eax | ||
166 | sub $crypto_onetimeauth_poly1305_x86_constants,%eax | ||
167 | and $4095,%eax | ||
168 | add $192,%eax | ||
169 | sub %eax,%esp | ||
170 | |||
171 | # qhasm: eax_stack = eax | ||
172 | # asm 1: movl <eax=int32#1,>eax_stack=stack32#1 | ||
173 | # asm 2: movl <eax=%eax,>eax_stack=0(%esp) | ||
174 | movl %eax,0(%esp) | ||
175 | |||
176 | # qhasm: ebx_stack = ebx | ||
177 | # asm 1: movl <ebx=int32#4,>ebx_stack=stack32#2 | ||
178 | # asm 2: movl <ebx=%ebx,>ebx_stack=4(%esp) | ||
179 | movl %ebx,4(%esp) | ||
180 | |||
181 | # qhasm: esi_stack = esi | ||
182 | # asm 1: movl <esi=int32#5,>esi_stack=stack32#3 | ||
183 | # asm 2: movl <esi=%esi,>esi_stack=8(%esp) | ||
184 | movl %esi,8(%esp) | ||
185 | |||
186 | # qhasm: edi_stack = edi | ||
187 | # asm 1: movl <edi=int32#6,>edi_stack=stack32#4 | ||
188 | # asm 2: movl <edi=%edi,>edi_stack=12(%esp) | ||
189 | movl %edi,12(%esp) | ||
190 | |||
191 | # qhasm: ebp_stack = ebp | ||
192 | # asm 1: movl <ebp=int32#7,>ebp_stack=stack32#5 | ||
193 | # asm 2: movl <ebp=%ebp,>ebp_stack=16(%esp) | ||
194 | movl %ebp,16(%esp) | ||
195 | |||
196 | # qhasm: round *(uint16 *) &crypto_onetimeauth_poly1305_x86_rounding | ||
197 | fldcw crypto_onetimeauth_poly1305_x86_rounding | ||
198 | |||
199 | # qhasm: k = arg_k | ||
200 | # asm 1: movl <arg_k=stack32#-5,>k=int32#3 | ||
201 | # asm 2: movl <arg_k=20(%esp,%eax),>k=%edx | ||
202 | movl 20(%esp,%eax),%edx | ||
203 | |||
204 | # qhasm: m0 = *(uint32 *) (k + 0) | ||
205 | # asm 1: movl 0(<k=int32#3),>m0=int32#2 | ||
206 | # asm 2: movl 0(<k=%edx),>m0=%ecx | ||
207 | movl 0(%edx),%ecx | ||
208 | |||
209 | # qhasm: m1 = *(uint32 *) (k + 4) | ||
210 | # asm 1: movl 4(<k=int32#3),>m1=int32#4 | ||
211 | # asm 2: movl 4(<k=%edx),>m1=%ebx | ||
212 | movl 4(%edx),%ebx | ||
213 | |||
214 | # qhasm: m2 = *(uint32 *) (k + 8) | ||
215 | # asm 1: movl 8(<k=int32#3),>m2=int32#5 | ||
216 | # asm 2: movl 8(<k=%edx),>m2=%esi | ||
217 | movl 8(%edx),%esi | ||
218 | |||
219 | # qhasm: m3 = *(uint32 *) (k + 12) | ||
220 | # asm 1: movl 12(<k=int32#3),>m3=int32#6 | ||
221 | # asm 2: movl 12(<k=%edx),>m3=%edi | ||
222 | movl 12(%edx),%edi | ||
223 | |||
224 | # qhasm: d0 top = 0x43300000 | ||
225 | # asm 1: movl $0x43300000,>d0=stack64#1 | ||
226 | # asm 2: movl $0x43300000,>d0=100(%esp) | ||
227 | movl $0x43300000,100(%esp) | ||
228 | |||
229 | # qhasm: d1 top = 0x45300000 | ||
230 | # asm 1: movl $0x45300000,>d1=stack64#2 | ||
231 | # asm 2: movl $0x45300000,>d1=108(%esp) | ||
232 | movl $0x45300000,108(%esp) | ||
233 | |||
234 | # qhasm: d2 top = 0x47300000 | ||
235 | # asm 1: movl $0x47300000,>d2=stack64#3 | ||
236 | # asm 2: movl $0x47300000,>d2=116(%esp) | ||
237 | movl $0x47300000,116(%esp) | ||
238 | |||
239 | # qhasm: d3 top = 0x49300000 | ||
240 | # asm 1: movl $0x49300000,>d3=stack64#4 | ||
241 | # asm 2: movl $0x49300000,>d3=124(%esp) | ||
242 | movl $0x49300000,124(%esp) | ||
243 | |||
244 | # qhasm: m0 &= 0x0fffffff | ||
245 | # asm 1: and $0x0fffffff,<m0=int32#2 | ||
246 | # asm 2: and $0x0fffffff,<m0=%ecx | ||
247 | and $0x0fffffff,%ecx | ||
248 | |||
249 | # qhasm: m1 &= 0x0ffffffc | ||
250 | # asm 1: and $0x0ffffffc,<m1=int32#4 | ||
251 | # asm 2: and $0x0ffffffc,<m1=%ebx | ||
252 | and $0x0ffffffc,%ebx | ||
253 | |||
254 | # qhasm: m2 &= 0x0ffffffc | ||
255 | # asm 1: and $0x0ffffffc,<m2=int32#5 | ||
256 | # asm 2: and $0x0ffffffc,<m2=%esi | ||
257 | and $0x0ffffffc,%esi | ||
258 | |||
259 | # qhasm: m3 &= 0x0ffffffc | ||
260 | # asm 1: and $0x0ffffffc,<m3=int32#6 | ||
261 | # asm 2: and $0x0ffffffc,<m3=%edi | ||
262 | and $0x0ffffffc,%edi | ||
263 | |||
264 | # qhasm: inplace d0 bottom = m0 | ||
265 | # asm 1: movl <m0=int32#2,<d0=stack64#1 | ||
266 | # asm 2: movl <m0=%ecx,<d0=96(%esp) | ||
267 | movl %ecx,96(%esp) | ||
268 | |||
269 | # qhasm: inplace d1 bottom = m1 | ||
270 | # asm 1: movl <m1=int32#4,<d1=stack64#2 | ||
271 | # asm 2: movl <m1=%ebx,<d1=104(%esp) | ||
272 | movl %ebx,104(%esp) | ||
273 | |||
274 | # qhasm: inplace d2 bottom = m2 | ||
275 | # asm 1: movl <m2=int32#5,<d2=stack64#3 | ||
276 | # asm 2: movl <m2=%esi,<d2=112(%esp) | ||
277 | movl %esi,112(%esp) | ||
278 | |||
279 | # qhasm: inplace d3 bottom = m3 | ||
280 | # asm 1: movl <m3=int32#6,<d3=stack64#4 | ||
281 | # asm 2: movl <m3=%edi,<d3=120(%esp) | ||
282 | movl %edi,120(%esp) | ||
283 | |||
284 | # qhasm: a0 = *(float64 *) &d0 | ||
285 | # asm 1: fldl <d0=stack64#1 | ||
286 | # asm 2: fldl <d0=96(%esp) | ||
287 | fldl 96(%esp) | ||
288 | # comment:fpstackfrombottom:<a0#24: | ||
289 | |||
290 | # qhasm: a0 -= *(float64 *) &crypto_onetimeauth_poly1305_x86_doffset0 | ||
291 | fsubl crypto_onetimeauth_poly1305_x86_doffset0 | ||
292 | # comment:fpstackfrombottom:<a0#24: | ||
293 | |||
294 | # qhasm: a1 = *(float64 *) &d1 | ||
295 | # asm 1: fldl <d1=stack64#2 | ||
296 | # asm 2: fldl <d1=104(%esp) | ||
297 | fldl 104(%esp) | ||
298 | # comment:fpstackfrombottom:<a0#24:<a1#25: | ||
299 | |||
300 | # qhasm: a1 -= *(float64 *) &crypto_onetimeauth_poly1305_x86_doffset1 | ||
301 | fsubl crypto_onetimeauth_poly1305_x86_doffset1 | ||
302 | # comment:fpstackfrombottom:<a0#24:<a1#25: | ||
303 | |||
304 | # qhasm: a2 = *(float64 *) &d2 | ||
305 | # asm 1: fldl <d2=stack64#3 | ||
306 | # asm 2: fldl <d2=112(%esp) | ||
307 | fldl 112(%esp) | ||
308 | # comment:fpstackfrombottom:<a0#24:<a1#25:<a2#26: | ||
309 | |||
310 | # qhasm: a2 -= *(float64 *) &crypto_onetimeauth_poly1305_x86_doffset2 | ||
311 | fsubl crypto_onetimeauth_poly1305_x86_doffset2 | ||
312 | # comment:fpstackfrombottom:<a0#24:<a1#25:<a2#26: | ||
313 | |||
314 | # qhasm: a3 = *(float64 *) &d3 | ||
315 | # asm 1: fldl <d3=stack64#4 | ||
316 | # asm 2: fldl <d3=120(%esp) | ||
317 | fldl 120(%esp) | ||
318 | # comment:fpstackfrombottom:<a0#24:<a1#25:<a2#26:<a3#27: | ||
319 | |||
320 | # qhasm: a3 -= *(float64 *) &crypto_onetimeauth_poly1305_x86_doffset3 | ||
321 | fsubl crypto_onetimeauth_poly1305_x86_doffset3 | ||
322 | # comment:fpstackfrombottom:<a0#24:<a1#25:<a2#26:<a3#27: | ||
323 | |||
324 | # qhasm: internal stacktop a0 | ||
325 | # asm 1: fxch <a0=float80#4 | ||
326 | # asm 2: fxch <a0=%st(3) | ||
327 | fxch %st(3) | ||
328 | |||
329 | # qhasm: *(float64 *) &r0 = a0 | ||
330 | # asm 1: fstpl >r0=stack64#5 | ||
331 | # asm 2: fstpl >r0=128(%esp) | ||
332 | fstpl 128(%esp) | ||
333 | # comment:fpstackfrombottom:<a3#27:<a1#25:<a2#26: | ||
334 | |||
335 | # qhasm: internal stacktop a1 | ||
336 | # asm 1: fxch <a1=float80#2 | ||
337 | # asm 2: fxch <a1=%st(1) | ||
338 | fxch %st(1) | ||
339 | |||
340 | # qhasm: *(float64 *) &r1 = a1 | ||
341 | # asm 1: fstl >r1=stack64#6 | ||
342 | # asm 2: fstl >r1=136(%esp) | ||
343 | fstl 136(%esp) | ||
344 | # comment:fpstackfrombottom:<a3#27:<a2#26:<a1#25: | ||
345 | |||
346 | # qhasm: a1 *= *(float64 *) &crypto_onetimeauth_poly1305_x86_scale | ||
347 | fmull crypto_onetimeauth_poly1305_x86_scale | ||
348 | # comment:fpstackfrombottom:<a3#27:<a2#26:<a1#25: | ||
349 | |||
350 | # qhasm: *(float64 *) &sr1 = a1 | ||
351 | # asm 1: fstpl >sr1=stack64#7 | ||
352 | # asm 2: fstpl >sr1=144(%esp) | ||
353 | fstpl 144(%esp) | ||
354 | # comment:fpstackfrombottom:<a3#27:<a2#26: | ||
355 | |||
356 | # qhasm: *(float64 *) &r2 = a2 | ||
357 | # asm 1: fstl >r2=stack64#8 | ||
358 | # asm 2: fstl >r2=152(%esp) | ||
359 | fstl 152(%esp) | ||
360 | # comment:fpstackfrombottom:<a3#27:<a2#26: | ||
361 | |||
362 | # qhasm: a2 *= *(float64 *) &crypto_onetimeauth_poly1305_x86_scale | ||
363 | fmull crypto_onetimeauth_poly1305_x86_scale | ||
364 | # comment:fpstackfrombottom:<a3#27:<a2#26: | ||
365 | |||
366 | # qhasm: *(float64 *) &sr2 = a2 | ||
367 | # asm 1: fstpl >sr2=stack64#9 | ||
368 | # asm 2: fstpl >sr2=160(%esp) | ||
369 | fstpl 160(%esp) | ||
370 | # comment:fpstackfrombottom:<a3#27: | ||
371 | |||
372 | # qhasm: *(float64 *) &r3 = a3 | ||
373 | # asm 1: fstl >r3=stack64#10 | ||
374 | # asm 2: fstl >r3=168(%esp) | ||
375 | fstl 168(%esp) | ||
376 | # comment:fpstackfrombottom:<a3#27: | ||
377 | |||
378 | # qhasm: a3 *= *(float64 *) &crypto_onetimeauth_poly1305_x86_scale | ||
379 | fmull crypto_onetimeauth_poly1305_x86_scale | ||
380 | # comment:fpstackfrombottom:<a3#27: | ||
381 | |||
382 | # qhasm: *(float64 *) &sr3 = a3 | ||
383 | # asm 1: fstpl >sr3=stack64#11 | ||
384 | # asm 2: fstpl >sr3=176(%esp) | ||
385 | fstpl 176(%esp) | ||
386 | # comment:fpstackfrombottom: | ||
387 | |||
388 | # qhasm: out = arg_out | ||
389 | # asm 1: movl <arg_out=stack32#-1,>out=int32#4 | ||
390 | # asm 2: movl <arg_out=4(%esp,%eax),>out=%ebx | ||
391 | movl 4(%esp,%eax),%ebx | ||
392 | |||
393 | # qhasm: m = arg_m | ||
394 | # asm 1: movl <arg_m=stack32#-2,>m=int32#5 | ||
395 | # asm 2: movl <arg_m=8(%esp,%eax),>m=%esi | ||
396 | movl 8(%esp,%eax),%esi | ||
397 | |||
398 | # qhasm: l = arg_l | ||
399 | # asm 1: movl <arg_l=stack32#-3,>l=int32#2 | ||
400 | # asm 2: movl <arg_l=12(%esp,%eax),>l=%ecx | ||
401 | movl 12(%esp,%eax),%ecx | ||
402 | |||
403 | # qhasm: h3 = 0 | ||
404 | fldz | ||
405 | # comment:fpstackfrombottom:<h3#38: | ||
406 | |||
407 | # qhasm: h2 = 0 | ||
408 | fldz | ||
409 | # comment:fpstackfrombottom:<h3#38:<h2#39: | ||
410 | |||
411 | # qhasm: h1 = 0 | ||
412 | fldz | ||
413 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40: | ||
414 | |||
415 | # qhasm: h0 = 0 | ||
416 | fldz | ||
417 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
418 | |||
419 | # qhasm: k_stack = k | ||
420 | # asm 1: movl <k=int32#3,>k_stack=stack32#6 | ||
421 | # asm 2: movl <k=%edx,>k_stack=20(%esp) | ||
422 | movl %edx,20(%esp) | ||
423 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
424 | |||
425 | # qhasm: out_stack = out | ||
426 | # asm 1: movl <out=int32#4,>out_stack=stack32#7 | ||
427 | # asm 2: movl <out=%ebx,>out_stack=24(%esp) | ||
428 | movl %ebx,24(%esp) | ||
429 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
430 | |||
431 | # qhasm: unsigned<? l - 16 | ||
432 | # asm 1: cmp $16,<l=int32#2 | ||
433 | # asm 2: cmp $16,<l=%ecx | ||
434 | cmp $16,%ecx | ||
435 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
436 | # comment:fp stack unchanged by jump | ||
437 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
438 | |||
439 | # qhasm: goto addatmost15bytes if unsigned< | ||
440 | jb ._addatmost15bytes | ||
441 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
442 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
443 | |||
444 | # qhasm: initialatleast16bytes: | ||
445 | ._initialatleast16bytes: | ||
446 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
447 | |||
448 | # qhasm: m3 = *(uint32 *) (m + 12) | ||
449 | # asm 1: movl 12(<m=int32#5),>m3=int32#1 | ||
450 | # asm 2: movl 12(<m=%esi),>m3=%eax | ||
451 | movl 12(%esi),%eax | ||
452 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
453 | |||
454 | # qhasm: m2 = *(uint32 *) (m + 8) | ||
455 | # asm 1: movl 8(<m=int32#5),>m2=int32#3 | ||
456 | # asm 2: movl 8(<m=%esi),>m2=%edx | ||
457 | movl 8(%esi),%edx | ||
458 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
459 | |||
460 | # qhasm: m1 = *(uint32 *) (m + 4) | ||
461 | # asm 1: movl 4(<m=int32#5),>m1=int32#4 | ||
462 | # asm 2: movl 4(<m=%esi),>m1=%ebx | ||
463 | movl 4(%esi),%ebx | ||
464 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
465 | |||
466 | # qhasm: m0 = *(uint32 *) (m + 0) | ||
467 | # asm 1: movl 0(<m=int32#5),>m0=int32#6 | ||
468 | # asm 2: movl 0(<m=%esi),>m0=%edi | ||
469 | movl 0(%esi),%edi | ||
470 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
471 | |||
472 | # qhasm: inplace d3 bottom = m3 | ||
473 | # asm 1: movl <m3=int32#1,<d3=stack64#4 | ||
474 | # asm 2: movl <m3=%eax,<d3=120(%esp) | ||
475 | movl %eax,120(%esp) | ||
476 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
477 | |||
478 | # qhasm: inplace d2 bottom = m2 | ||
479 | # asm 1: movl <m2=int32#3,<d2=stack64#3 | ||
480 | # asm 2: movl <m2=%edx,<d2=112(%esp) | ||
481 | movl %edx,112(%esp) | ||
482 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
483 | |||
484 | # qhasm: inplace d1 bottom = m1 | ||
485 | # asm 1: movl <m1=int32#4,<d1=stack64#2 | ||
486 | # asm 2: movl <m1=%ebx,<d1=104(%esp) | ||
487 | movl %ebx,104(%esp) | ||
488 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
489 | |||
490 | # qhasm: inplace d0 bottom = m0 | ||
491 | # asm 1: movl <m0=int32#6,<d0=stack64#1 | ||
492 | # asm 2: movl <m0=%edi,<d0=96(%esp) | ||
493 | movl %edi,96(%esp) | ||
494 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
495 | |||
496 | # qhasm: m += 16 | ||
497 | # asm 1: add $16,<m=int32#5 | ||
498 | # asm 2: add $16,<m=%esi | ||
499 | add $16,%esi | ||
500 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
501 | |||
502 | # qhasm: l -= 16 | ||
503 | # asm 1: sub $16,<l=int32#2 | ||
504 | # asm 2: sub $16,<l=%ecx | ||
505 | sub $16,%ecx | ||
506 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
507 | |||
508 | # qhasm: internal stacktop h3 | ||
509 | # asm 1: fxch <h3=float80#4 | ||
510 | # asm 2: fxch <h3=%st(3) | ||
511 | fxch %st(3) | ||
512 | |||
513 | # qhasm: h3 += *(float64 *) &d3 | ||
514 | # asm 1: faddl <d3=stack64#4 | ||
515 | # asm 2: faddl <d3=120(%esp) | ||
516 | faddl 120(%esp) | ||
517 | # comment:fpstackfrombottom:<h0#41:<h2#39:<h1#40:<h3#38: | ||
518 | |||
519 | # qhasm: h3 -= *(float64 *) &crypto_onetimeauth_poly1305_x86_doffset3minustwo128 | ||
520 | fsubl crypto_onetimeauth_poly1305_x86_doffset3minustwo128 | ||
521 | # comment:fpstackfrombottom:<h0#41:<h2#39:<h1#40:<h3#38: | ||
522 | |||
523 | # qhasm: internal stacktop h1 | ||
524 | # asm 1: fxch <h1=float80#2 | ||
525 | # asm 2: fxch <h1=%st(1) | ||
526 | fxch %st(1) | ||
527 | |||
528 | # qhasm: h1 += *(float64 *) &d1 | ||
529 | # asm 1: faddl <d1=stack64#2 | ||
530 | # asm 2: faddl <d1=104(%esp) | ||
531 | faddl 104(%esp) | ||
532 | # comment:fpstackfrombottom:<h0#41:<h2#39:<h3#38:<h1#40: | ||
533 | |||
534 | # qhasm: h1 -= *(float64 *) &crypto_onetimeauth_poly1305_x86_doffset1 | ||
535 | fsubl crypto_onetimeauth_poly1305_x86_doffset1 | ||
536 | # comment:fpstackfrombottom:<h0#41:<h2#39:<h3#38:<h1#40: | ||
537 | |||
538 | # qhasm: internal stacktop h2 | ||
539 | # asm 1: fxch <h2=float80#3 | ||
540 | # asm 2: fxch <h2=%st(2) | ||
541 | fxch %st(2) | ||
542 | |||
543 | # qhasm: h2 += *(float64 *) &d2 | ||
544 | # asm 1: faddl <d2=stack64#3 | ||
545 | # asm 2: faddl <d2=112(%esp) | ||
546 | faddl 112(%esp) | ||
547 | # comment:fpstackfrombottom:<h0#41:<h1#40:<h3#38:<h2#39: | ||
548 | |||
549 | # qhasm: h2 -= *(float64 *) &crypto_onetimeauth_poly1305_x86_doffset2 | ||
550 | fsubl crypto_onetimeauth_poly1305_x86_doffset2 | ||
551 | # comment:fpstackfrombottom:<h0#41:<h1#40:<h3#38:<h2#39: | ||
552 | |||
553 | # qhasm: internal stacktop h0 | ||
554 | # asm 1: fxch <h0=float80#4 | ||
555 | # asm 2: fxch <h0=%st(3) | ||
556 | fxch %st(3) | ||
557 | |||
558 | # qhasm: h0 += *(float64 *) &d0 | ||
559 | # asm 1: faddl <d0=stack64#1 | ||
560 | # asm 2: faddl <d0=96(%esp) | ||
561 | faddl 96(%esp) | ||
562 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41: | ||
563 | |||
564 | # qhasm: h0 -= *(float64 *) &crypto_onetimeauth_poly1305_x86_doffset0 | ||
565 | fsubl crypto_onetimeauth_poly1305_x86_doffset0 | ||
566 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41: | ||
567 | |||
568 | # qhasm: unsigned<? l - 16 | ||
569 | # asm 1: cmp $16,<l=int32#2 | ||
570 | # asm 2: cmp $16,<l=%ecx | ||
571 | cmp $16,%ecx | ||
572 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41: | ||
573 | # comment:fp stack unchanged by jump | ||
574 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41: | ||
575 | |||
576 | # qhasm: goto multiplyaddatmost15bytes if unsigned< | ||
577 | jb ._multiplyaddatmost15bytes | ||
578 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41: | ||
579 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41: | ||
580 | |||
581 | # qhasm: multiplyaddatleast16bytes: | ||
582 | ._multiplyaddatleast16bytes: | ||
583 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41: | ||
584 | |||
585 | # qhasm: m3 = *(uint32 *) (m + 12) | ||
586 | # asm 1: movl 12(<m=int32#5),>m3=int32#1 | ||
587 | # asm 2: movl 12(<m=%esi),>m3=%eax | ||
588 | movl 12(%esi),%eax | ||
589 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41: | ||
590 | |||
591 | # qhasm: m2 = *(uint32 *) (m + 8) | ||
592 | # asm 1: movl 8(<m=int32#5),>m2=int32#3 | ||
593 | # asm 2: movl 8(<m=%esi),>m2=%edx | ||
594 | movl 8(%esi),%edx | ||
595 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41: | ||
596 | |||
597 | # qhasm: m1 = *(uint32 *) (m + 4) | ||
598 | # asm 1: movl 4(<m=int32#5),>m1=int32#4 | ||
599 | # asm 2: movl 4(<m=%esi),>m1=%ebx | ||
600 | movl 4(%esi),%ebx | ||
601 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41: | ||
602 | |||
603 | # qhasm: m0 = *(uint32 *) (m + 0) | ||
604 | # asm 1: movl 0(<m=int32#5),>m0=int32#6 | ||
605 | # asm 2: movl 0(<m=%esi),>m0=%edi | ||
606 | movl 0(%esi),%edi | ||
607 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41: | ||
608 | |||
609 | # qhasm: inplace d3 bottom = m3 | ||
610 | # asm 1: movl <m3=int32#1,<d3=stack64#4 | ||
611 | # asm 2: movl <m3=%eax,<d3=120(%esp) | ||
612 | movl %eax,120(%esp) | ||
613 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41: | ||
614 | |||
615 | # qhasm: inplace d2 bottom = m2 | ||
616 | # asm 1: movl <m2=int32#3,<d2=stack64#3 | ||
617 | # asm 2: movl <m2=%edx,<d2=112(%esp) | ||
618 | movl %edx,112(%esp) | ||
619 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41: | ||
620 | |||
621 | # qhasm: inplace d1 bottom = m1 | ||
622 | # asm 1: movl <m1=int32#4,<d1=stack64#2 | ||
623 | # asm 2: movl <m1=%ebx,<d1=104(%esp) | ||
624 | movl %ebx,104(%esp) | ||
625 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41: | ||
626 | |||
627 | # qhasm: inplace d0 bottom = m0 | ||
628 | # asm 1: movl <m0=int32#6,<d0=stack64#1 | ||
629 | # asm 2: movl <m0=%edi,<d0=96(%esp) | ||
630 | movl %edi,96(%esp) | ||
631 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41: | ||
632 | |||
633 | # qhasm: m += 16 | ||
634 | # asm 1: add $16,<m=int32#5 | ||
635 | # asm 2: add $16,<m=%esi | ||
636 | add $16,%esi | ||
637 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41: | ||
638 | |||
639 | # qhasm: l -= 16 | ||
640 | # asm 1: sub $16,<l=int32#2 | ||
641 | # asm 2: sub $16,<l=%ecx | ||
642 | sub $16,%ecx | ||
643 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41: | ||
644 | |||
645 | # qhasm: x0 = *(float64 *) &crypto_onetimeauth_poly1305_x86_alpha130 | ||
646 | fldl crypto_onetimeauth_poly1305_x86_alpha130 | ||
647 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41:<x0#54: | ||
648 | |||
649 | # qhasm: x0 += h3 | ||
650 | # asm 1: fadd <h3=float80#3,<x0=float80#1 | ||
651 | # asm 2: fadd <h3=%st(2),<x0=%st(0) | ||
652 | fadd %st(2),%st(0) | ||
653 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41:<x0#54: | ||
654 | |||
655 | # qhasm: x0 -= *(float64 *) &crypto_onetimeauth_poly1305_x86_alpha130 | ||
656 | fsubl crypto_onetimeauth_poly1305_x86_alpha130 | ||
657 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41:<x0#54: | ||
658 | |||
659 | # qhasm: h3 -= x0 | ||
660 | # asm 1: fsubr <x0=float80#1,<h3=float80#3 | ||
661 | # asm 2: fsubr <x0=%st(0),<h3=%st(2) | ||
662 | fsubr %st(0),%st(2) | ||
663 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41:<x0#54: | ||
664 | |||
665 | # qhasm: x0 *= *(float64 *) &crypto_onetimeauth_poly1305_x86_scale | ||
666 | fmull crypto_onetimeauth_poly1305_x86_scale | ||
667 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41:<x0#54: | ||
668 | |||
669 | # qhasm: x1 = *(float64 *) &crypto_onetimeauth_poly1305_x86_alpha32 | ||
670 | fldl crypto_onetimeauth_poly1305_x86_alpha32 | ||
671 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41:<x0#54:<x1#55: | ||
672 | |||
673 | # qhasm: x1 += h0 | ||
674 | # asm 1: fadd <h0=float80#3,<x1=float80#1 | ||
675 | # asm 2: fadd <h0=%st(2),<x1=%st(0) | ||
676 | fadd %st(2),%st(0) | ||
677 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41:<x0#54:<x1#55: | ||
678 | |||
679 | # qhasm: x1 -= *(float64 *) &crypto_onetimeauth_poly1305_x86_alpha32 | ||
680 | fsubl crypto_onetimeauth_poly1305_x86_alpha32 | ||
681 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41:<x0#54:<x1#55: | ||
682 | |||
683 | # qhasm: h0 -= x1 | ||
684 | # asm 1: fsubr <x1=float80#1,<h0=float80#3 | ||
685 | # asm 2: fsubr <x1=%st(0),<h0=%st(2) | ||
686 | fsubr %st(0),%st(2) | ||
687 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41:<x0#54:<x1#55: | ||
688 | |||
689 | # qhasm: internal stacktop h0 | ||
690 | # asm 1: fxch <h0=float80#3 | ||
691 | # asm 2: fxch <h0=%st(2) | ||
692 | fxch %st(2) | ||
693 | |||
694 | # qhasm: x0 += h0 | ||
695 | # asm 1: faddp <h0=float80#1,<x0=float80#2 | ||
696 | # asm 2: faddp <h0=%st(0),<x0=%st(1) | ||
697 | faddp %st(0),%st(1) | ||
698 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<x1#55:<x0#54: | ||
699 | |||
700 | # qhasm: x2 = *(float64 *) &crypto_onetimeauth_poly1305_x86_alpha64 | ||
701 | fldl crypto_onetimeauth_poly1305_x86_alpha64 | ||
702 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<x1#55:<x0#54:<x2#56: | ||
703 | |||
704 | # qhasm: x2 += h1 | ||
705 | # asm 1: fadd <h1=float80#5,<x2=float80#1 | ||
706 | # asm 2: fadd <h1=%st(4),<x2=%st(0) | ||
707 | fadd %st(4),%st(0) | ||
708 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<x1#55:<x0#54:<x2#56: | ||
709 | |||
710 | # qhasm: x2 -= *(float64 *) &crypto_onetimeauth_poly1305_x86_alpha64 | ||
711 | fsubl crypto_onetimeauth_poly1305_x86_alpha64 | ||
712 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<x1#55:<x0#54:<x2#56: | ||
713 | |||
714 | # qhasm: h1 -= x2 | ||
715 | # asm 1: fsubr <x2=float80#1,<h1=float80#5 | ||
716 | # asm 2: fsubr <x2=%st(0),<h1=%st(4) | ||
717 | fsubr %st(0),%st(4) | ||
718 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<x1#55:<x0#54:<x2#56: | ||
719 | |||
720 | # qhasm: x3 = *(float64 *) &crypto_onetimeauth_poly1305_x86_alpha96 | ||
721 | fldl crypto_onetimeauth_poly1305_x86_alpha96 | ||
722 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<x1#55:<x0#54:<x2#56:<x3#57: | ||
723 | |||
724 | # qhasm: x3 += h2 | ||
725 | # asm 1: fadd <h2=float80#7,<x3=float80#1 | ||
726 | # asm 2: fadd <h2=%st(6),<x3=%st(0) | ||
727 | fadd %st(6),%st(0) | ||
728 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<x1#55:<x0#54:<x2#56:<x3#57: | ||
729 | |||
730 | # qhasm: x3 -= *(float64 *) &crypto_onetimeauth_poly1305_x86_alpha96 | ||
731 | fsubl crypto_onetimeauth_poly1305_x86_alpha96 | ||
732 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<x1#55:<x0#54:<x2#56:<x3#57: | ||
733 | |||
734 | # qhasm: h2 -= x3 | ||
735 | # asm 1: fsubr <x3=float80#1,<h2=float80#7 | ||
736 | # asm 2: fsubr <x3=%st(0),<h2=%st(6) | ||
737 | fsubr %st(0),%st(6) | ||
738 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<x1#55:<x0#54:<x2#56:<x3#57: | ||
739 | |||
740 | # qhasm: internal stacktop h2 | ||
741 | # asm 1: fxch <h2=float80#7 | ||
742 | # asm 2: fxch <h2=%st(6) | ||
743 | fxch %st(6) | ||
744 | |||
745 | # qhasm: x2 += h2 | ||
746 | # asm 1: faddp <h2=float80#1,<x2=float80#2 | ||
747 | # asm 2: faddp <h2=%st(0),<x2=%st(1) | ||
748 | faddp %st(0),%st(1) | ||
749 | # comment:fpstackfrombottom:<x3#57:<h1#40:<h3#38:<x1#55:<x0#54:<x2#56: | ||
750 | |||
751 | # qhasm: internal stacktop h3 | ||
752 | # asm 1: fxch <h3=float80#4 | ||
753 | # asm 2: fxch <h3=%st(3) | ||
754 | fxch %st(3) | ||
755 | |||
756 | # qhasm: x3 += h3 | ||
757 | # asm 1: faddp <h3=float80#1,<x3=float80#6 | ||
758 | # asm 2: faddp <h3=%st(0),<x3=%st(5) | ||
759 | faddp %st(0),%st(5) | ||
760 | # comment:fpstackfrombottom:<x3#57:<h1#40:<x2#56:<x1#55:<x0#54: | ||
761 | |||
762 | # qhasm: internal stacktop h1 | ||
763 | # asm 1: fxch <h1=float80#4 | ||
764 | # asm 2: fxch <h1=%st(3) | ||
765 | fxch %st(3) | ||
766 | |||
767 | # qhasm: x1 += h1 | ||
768 | # asm 1: faddp <h1=float80#1,<x1=float80#2 | ||
769 | # asm 2: faddp <h1=%st(0),<x1=%st(1) | ||
770 | faddp %st(0),%st(1) | ||
771 | # comment:fpstackfrombottom:<x3#57:<x0#54:<x2#56:<x1#55: | ||
772 | |||
773 | # qhasm: h3 = *(float64 *) &r3 | ||
774 | # asm 1: fldl <r3=stack64#10 | ||
775 | # asm 2: fldl <r3=168(%esp) | ||
776 | fldl 168(%esp) | ||
777 | # comment:fpstackfrombottom:<x3#57:<x0#54:<x2#56:<x1#55:<h3#38: | ||
778 | |||
779 | # qhasm: h3 *= x0 | ||
780 | # asm 1: fmul <x0=float80#4,<h3=float80#1 | ||
781 | # asm 2: fmul <x0=%st(3),<h3=%st(0) | ||
782 | fmul %st(3),%st(0) | ||
783 | # comment:fpstackfrombottom:<x3#57:<x0#54:<x2#56:<x1#55:<h3#38: | ||
784 | |||
785 | # qhasm: h2 = *(float64 *) &r2 | ||
786 | # asm 1: fldl <r2=stack64#8 | ||
787 | # asm 2: fldl <r2=152(%esp) | ||
788 | fldl 152(%esp) | ||
789 | # comment:fpstackfrombottom:<x3#57:<x0#54:<x2#56:<x1#55:<h3#38:<h2#39: | ||
790 | |||
791 | # qhasm: h2 *= x0 | ||
792 | # asm 1: fmul <x0=float80#5,<h2=float80#1 | ||
793 | # asm 2: fmul <x0=%st(4),<h2=%st(0) | ||
794 | fmul %st(4),%st(0) | ||
795 | # comment:fpstackfrombottom:<x3#57:<x0#54:<x2#56:<x1#55:<h3#38:<h2#39: | ||
796 | |||
797 | # qhasm: h1 = *(float64 *) &r1 | ||
798 | # asm 1: fldl <r1=stack64#6 | ||
799 | # asm 2: fldl <r1=136(%esp) | ||
800 | fldl 136(%esp) | ||
801 | # comment:fpstackfrombottom:<x3#57:<x0#54:<x2#56:<x1#55:<h3#38:<h2#39:<h1#40: | ||
802 | |||
803 | # qhasm: h1 *= x0 | ||
804 | # asm 1: fmul <x0=float80#6,<h1=float80#1 | ||
805 | # asm 2: fmul <x0=%st(5),<h1=%st(0) | ||
806 | fmul %st(5),%st(0) | ||
807 | # comment:fpstackfrombottom:<x3#57:<x0#54:<x2#56:<x1#55:<h3#38:<h2#39:<h1#40: | ||
808 | |||
809 | # qhasm: h0 = *(float64 *) &r0 | ||
810 | # asm 1: fldl <r0=stack64#5 | ||
811 | # asm 2: fldl <r0=128(%esp) | ||
812 | fldl 128(%esp) | ||
813 | # comment:fpstackfrombottom:<x3#57:<x0#54:<x2#56:<x1#55:<h3#38:<h2#39:<h1#40:<h0#41: | ||
814 | |||
815 | # qhasm: h0 *= x0 | ||
816 | # asm 1: fmulp <x0=float80#1,<h0=float80#7 | ||
817 | # asm 2: fmulp <x0=%st(0),<h0=%st(6) | ||
818 | fmulp %st(0),%st(6) | ||
819 | # comment:fpstackfrombottom:<x3#57:<h0#41:<x2#56:<x1#55:<h3#38:<h2#39:<h1#40: | ||
820 | |||
821 | # qhasm: r2x1 = *(float64 *) &r2 | ||
822 | # asm 1: fldl <r2=stack64#8 | ||
823 | # asm 2: fldl <r2=152(%esp) | ||
824 | fldl 152(%esp) | ||
825 | # comment:fpstackfrombottom:<x3#57:<h0#41:<x2#56:<x1#55:<h3#38:<h2#39:<h1#40:<r2x1#58: | ||
826 | |||
827 | # qhasm: r2x1 *= x1 | ||
828 | # asm 1: fmul <x1=float80#5,<r2x1=float80#1 | ||
829 | # asm 2: fmul <x1=%st(4),<r2x1=%st(0) | ||
830 | fmul %st(4),%st(0) | ||
831 | # comment:fpstackfrombottom:<x3#57:<h0#41:<x2#56:<x1#55:<h3#38:<h2#39:<h1#40:<r2x1#58: | ||
832 | |||
833 | # qhasm: h3 += r2x1 | ||
834 | # asm 1: faddp <r2x1=float80#1,<h3=float80#4 | ||
835 | # asm 2: faddp <r2x1=%st(0),<h3=%st(3) | ||
836 | faddp %st(0),%st(3) | ||
837 | # comment:fpstackfrombottom:<x3#57:<h0#41:<x2#56:<x1#55:<h3#38:<h2#39:<h1#40: | ||
838 | |||
839 | # qhasm: r1x1 = *(float64 *) &r1 | ||
840 | # asm 1: fldl <r1=stack64#6 | ||
841 | # asm 2: fldl <r1=136(%esp) | ||
842 | fldl 136(%esp) | ||
843 | # comment:fpstackfrombottom:<x3#57:<h0#41:<x2#56:<x1#55:<h3#38:<h2#39:<h1#40:<r1x1#59: | ||
844 | |||
845 | # qhasm: r1x1 *= x1 | ||
846 | # asm 1: fmul <x1=float80#5,<r1x1=float80#1 | ||
847 | # asm 2: fmul <x1=%st(4),<r1x1=%st(0) | ||
848 | fmul %st(4),%st(0) | ||
849 | # comment:fpstackfrombottom:<x3#57:<h0#41:<x2#56:<x1#55:<h3#38:<h2#39:<h1#40:<r1x1#59: | ||
850 | |||
851 | # qhasm: h2 += r1x1 | ||
852 | # asm 1: faddp <r1x1=float80#1,<h2=float80#3 | ||
853 | # asm 2: faddp <r1x1=%st(0),<h2=%st(2) | ||
854 | faddp %st(0),%st(2) | ||
855 | # comment:fpstackfrombottom:<x3#57:<h0#41:<x2#56:<x1#55:<h3#38:<h2#39:<h1#40: | ||
856 | |||
857 | # qhasm: r0x1 = *(float64 *) &r0 | ||
858 | # asm 1: fldl <r0=stack64#5 | ||
859 | # asm 2: fldl <r0=128(%esp) | ||
860 | fldl 128(%esp) | ||
861 | # comment:fpstackfrombottom:<x3#57:<h0#41:<x2#56:<x1#55:<h3#38:<h2#39:<h1#40:<r0x1#60: | ||
862 | |||
863 | # qhasm: r0x1 *= x1 | ||
864 | # asm 1: fmul <x1=float80#5,<r0x1=float80#1 | ||
865 | # asm 2: fmul <x1=%st(4),<r0x1=%st(0) | ||
866 | fmul %st(4),%st(0) | ||
867 | # comment:fpstackfrombottom:<x3#57:<h0#41:<x2#56:<x1#55:<h3#38:<h2#39:<h1#40:<r0x1#60: | ||
868 | |||
869 | # qhasm: h1 += r0x1 | ||
870 | # asm 1: faddp <r0x1=float80#1,<h1=float80#2 | ||
871 | # asm 2: faddp <r0x1=%st(0),<h1=%st(1) | ||
872 | faddp %st(0),%st(1) | ||
873 | # comment:fpstackfrombottom:<x3#57:<h0#41:<x2#56:<x1#55:<h3#38:<h2#39:<h1#40: | ||
874 | |||
875 | # qhasm: sr3x1 = *(float64 *) &sr3 | ||
876 | # asm 1: fldl <sr3=stack64#11 | ||
877 | # asm 2: fldl <sr3=176(%esp) | ||
878 | fldl 176(%esp) | ||
879 | # comment:fpstackfrombottom:<x3#57:<h0#41:<x2#56:<x1#55:<h3#38:<h2#39:<h1#40:<sr3x1#61: | ||
880 | |||
881 | # qhasm: sr3x1 *= x1 | ||
882 | # asm 1: fmulp <x1=float80#1,<sr3x1=float80#5 | ||
883 | # asm 2: fmulp <x1=%st(0),<sr3x1=%st(4) | ||
884 | fmulp %st(0),%st(4) | ||
885 | # comment:fpstackfrombottom:<x3#57:<h0#41:<x2#56:<sr3x1#61:<h3#38:<h2#39:<h1#40: | ||
886 | |||
887 | # qhasm: internal stacktop sr3x1 | ||
888 | # asm 1: fxch <sr3x1=float80#4 | ||
889 | # asm 2: fxch <sr3x1=%st(3) | ||
890 | fxch %st(3) | ||
891 | |||
892 | # qhasm: h0 += sr3x1 | ||
893 | # asm 1: faddp <sr3x1=float80#1,<h0=float80#6 | ||
894 | # asm 2: faddp <sr3x1=%st(0),<h0=%st(5) | ||
895 | faddp %st(0),%st(5) | ||
896 | # comment:fpstackfrombottom:<x3#57:<h0#41:<x2#56:<h1#40:<h3#38:<h2#39: | ||
897 | |||
898 | # qhasm: r1x2 = *(float64 *) &r1 | ||
899 | # asm 1: fldl <r1=stack64#6 | ||
900 | # asm 2: fldl <r1=136(%esp) | ||
901 | fldl 136(%esp) | ||
902 | # comment:fpstackfrombottom:<x3#57:<h0#41:<x2#56:<h1#40:<h3#38:<h2#39:<r1x2#62: | ||
903 | |||
904 | # qhasm: r1x2 *= x2 | ||
905 | # asm 1: fmul <x2=float80#5,<r1x2=float80#1 | ||
906 | # asm 2: fmul <x2=%st(4),<r1x2=%st(0) | ||
907 | fmul %st(4),%st(0) | ||
908 | # comment:fpstackfrombottom:<x3#57:<h0#41:<x2#56:<h1#40:<h3#38:<h2#39:<r1x2#62: | ||
909 | |||
910 | # qhasm: h3 += r1x2 | ||
911 | # asm 1: faddp <r1x2=float80#1,<h3=float80#3 | ||
912 | # asm 2: faddp <r1x2=%st(0),<h3=%st(2) | ||
913 | faddp %st(0),%st(2) | ||
914 | # comment:fpstackfrombottom:<x3#57:<h0#41:<x2#56:<h1#40:<h3#38:<h2#39: | ||
915 | |||
916 | # qhasm: r0x2 = *(float64 *) &r0 | ||
917 | # asm 1: fldl <r0=stack64#5 | ||
918 | # asm 2: fldl <r0=128(%esp) | ||
919 | fldl 128(%esp) | ||
920 | # comment:fpstackfrombottom:<x3#57:<h0#41:<x2#56:<h1#40:<h3#38:<h2#39:<r0x2#63: | ||
921 | |||
922 | # qhasm: r0x2 *= x2 | ||
923 | # asm 1: fmul <x2=float80#5,<r0x2=float80#1 | ||
924 | # asm 2: fmul <x2=%st(4),<r0x2=%st(0) | ||
925 | fmul %st(4),%st(0) | ||
926 | # comment:fpstackfrombottom:<x3#57:<h0#41:<x2#56:<h1#40:<h3#38:<h2#39:<r0x2#63: | ||
927 | |||
928 | # qhasm: h2 += r0x2 | ||
929 | # asm 1: faddp <r0x2=float80#1,<h2=float80#2 | ||
930 | # asm 2: faddp <r0x2=%st(0),<h2=%st(1) | ||
931 | faddp %st(0),%st(1) | ||
932 | # comment:fpstackfrombottom:<x3#57:<h0#41:<x2#56:<h1#40:<h3#38:<h2#39: | ||
933 | |||
934 | # qhasm: sr3x2 = *(float64 *) &sr3 | ||
935 | # asm 1: fldl <sr3=stack64#11 | ||
936 | # asm 2: fldl <sr3=176(%esp) | ||
937 | fldl 176(%esp) | ||
938 | # comment:fpstackfrombottom:<x3#57:<h0#41:<x2#56:<h1#40:<h3#38:<h2#39:<sr3x2#64: | ||
939 | |||
940 | # qhasm: sr3x2 *= x2 | ||
941 | # asm 1: fmul <x2=float80#5,<sr3x2=float80#1 | ||
942 | # asm 2: fmul <x2=%st(4),<sr3x2=%st(0) | ||
943 | fmul %st(4),%st(0) | ||
944 | # comment:fpstackfrombottom:<x3#57:<h0#41:<x2#56:<h1#40:<h3#38:<h2#39:<sr3x2#64: | ||
945 | |||
946 | # qhasm: h1 += sr3x2 | ||
947 | # asm 1: faddp <sr3x2=float80#1,<h1=float80#4 | ||
948 | # asm 2: faddp <sr3x2=%st(0),<h1=%st(3) | ||
949 | faddp %st(0),%st(3) | ||
950 | # comment:fpstackfrombottom:<x3#57:<h0#41:<x2#56:<h1#40:<h3#38:<h2#39: | ||
951 | |||
952 | # qhasm: sr2x2 = *(float64 *) &sr2 | ||
953 | # asm 1: fldl <sr2=stack64#9 | ||
954 | # asm 2: fldl <sr2=160(%esp) | ||
955 | fldl 160(%esp) | ||
956 | # comment:fpstackfrombottom:<x3#57:<h0#41:<x2#56:<h1#40:<h3#38:<h2#39:<sr2x2#65: | ||
957 | |||
958 | # qhasm: sr2x2 *= x2 | ||
959 | # asm 1: fmulp <x2=float80#1,<sr2x2=float80#5 | ||
960 | # asm 2: fmulp <x2=%st(0),<sr2x2=%st(4) | ||
961 | fmulp %st(0),%st(4) | ||
962 | # comment:fpstackfrombottom:<x3#57:<h0#41:<sr2x2#65:<h1#40:<h3#38:<h2#39: | ||
963 | |||
964 | # qhasm: internal stacktop sr2x2 | ||
965 | # asm 1: fxch <sr2x2=float80#4 | ||
966 | # asm 2: fxch <sr2x2=%st(3) | ||
967 | fxch %st(3) | ||
968 | |||
969 | # qhasm: h0 += sr2x2 | ||
970 | # asm 1: faddp <sr2x2=float80#1,<h0=float80#5 | ||
971 | # asm 2: faddp <sr2x2=%st(0),<h0=%st(4) | ||
972 | faddp %st(0),%st(4) | ||
973 | # comment:fpstackfrombottom:<x3#57:<h0#41:<h2#39:<h1#40:<h3#38: | ||
974 | |||
975 | # qhasm: r0x3 = *(float64 *) &r0 | ||
976 | # asm 1: fldl <r0=stack64#5 | ||
977 | # asm 2: fldl <r0=128(%esp) | ||
978 | fldl 128(%esp) | ||
979 | # comment:fpstackfrombottom:<x3#57:<h0#41:<h2#39:<h1#40:<h3#38:<r0x3#66: | ||
980 | |||
981 | # qhasm: r0x3 *= x3 | ||
982 | # asm 1: fmul <x3=float80#6,<r0x3=float80#1 | ||
983 | # asm 2: fmul <x3=%st(5),<r0x3=%st(0) | ||
984 | fmul %st(5),%st(0) | ||
985 | # comment:fpstackfrombottom:<x3#57:<h0#41:<h2#39:<h1#40:<h3#38:<r0x3#66: | ||
986 | |||
987 | # qhasm: h3 += r0x3 | ||
988 | # asm 1: faddp <r0x3=float80#1,<h3=float80#2 | ||
989 | # asm 2: faddp <r0x3=%st(0),<h3=%st(1) | ||
990 | faddp %st(0),%st(1) | ||
991 | # comment:fpstackfrombottom:<x3#57:<h0#41:<h2#39:<h1#40:<h3#38: | ||
992 | |||
993 | # qhasm: stacktop h0 | ||
994 | # asm 1: fxch <h0=float80#4 | ||
995 | # asm 2: fxch <h0=%st(3) | ||
996 | fxch %st(3) | ||
997 | # comment:fpstackfrombottom:<x3#57:<h3#38:<h2#39:<h1#40:<h0#41: | ||
998 | |||
999 | # qhasm: sr3x3 = *(float64 *) &sr3 | ||
1000 | # asm 1: fldl <sr3=stack64#11 | ||
1001 | # asm 2: fldl <sr3=176(%esp) | ||
1002 | fldl 176(%esp) | ||
1003 | # comment:fpstackfrombottom:<x3#57:<h3#38:<h2#39:<h1#40:<h0#41:<sr3x3#67: | ||
1004 | |||
1005 | # qhasm: sr3x3 *= x3 | ||
1006 | # asm 1: fmul <x3=float80#6,<sr3x3=float80#1 | ||
1007 | # asm 2: fmul <x3=%st(5),<sr3x3=%st(0) | ||
1008 | fmul %st(5),%st(0) | ||
1009 | # comment:fpstackfrombottom:<x3#57:<h3#38:<h2#39:<h1#40:<h0#41:<sr3x3#67: | ||
1010 | |||
1011 | # qhasm: h2 += sr3x3 | ||
1012 | # asm 1: faddp <sr3x3=float80#1,<h2=float80#4 | ||
1013 | # asm 2: faddp <sr3x3=%st(0),<h2=%st(3) | ||
1014 | faddp %st(0),%st(3) | ||
1015 | # comment:fpstackfrombottom:<x3#57:<h3#38:<h2#39:<h1#40:<h0#41: | ||
1016 | |||
1017 | # qhasm: stacktop h1 | ||
1018 | # asm 1: fxch <h1=float80#2 | ||
1019 | # asm 2: fxch <h1=%st(1) | ||
1020 | fxch %st(1) | ||
1021 | # comment:fpstackfrombottom:<x3#57:<h3#38:<h2#39:<h0#41:<h1#40: | ||
1022 | |||
1023 | # qhasm: sr2x3 = *(float64 *) &sr2 | ||
1024 | # asm 1: fldl <sr2=stack64#9 | ||
1025 | # asm 2: fldl <sr2=160(%esp) | ||
1026 | fldl 160(%esp) | ||
1027 | # comment:fpstackfrombottom:<x3#57:<h3#38:<h2#39:<h0#41:<h1#40:<sr2x3#68: | ||
1028 | |||
1029 | # qhasm: sr2x3 *= x3 | ||
1030 | # asm 1: fmul <x3=float80#6,<sr2x3=float80#1 | ||
1031 | # asm 2: fmul <x3=%st(5),<sr2x3=%st(0) | ||
1032 | fmul %st(5),%st(0) | ||
1033 | # comment:fpstackfrombottom:<x3#57:<h3#38:<h2#39:<h0#41:<h1#40:<sr2x3#68: | ||
1034 | |||
1035 | # qhasm: h1 += sr2x3 | ||
1036 | # asm 1: faddp <sr2x3=float80#1,<h1=float80#2 | ||
1037 | # asm 2: faddp <sr2x3=%st(0),<h1=%st(1) | ||
1038 | faddp %st(0),%st(1) | ||
1039 | # comment:fpstackfrombottom:<x3#57:<h3#38:<h2#39:<h0#41:<h1#40: | ||
1040 | |||
1041 | # qhasm: sr1x3 = *(float64 *) &sr1 | ||
1042 | # asm 1: fldl <sr1=stack64#7 | ||
1043 | # asm 2: fldl <sr1=144(%esp) | ||
1044 | fldl 144(%esp) | ||
1045 | # comment:fpstackfrombottom:<x3#57:<h3#38:<h2#39:<h0#41:<h1#40:<sr1x3#69: | ||
1046 | |||
1047 | # qhasm: sr1x3 *= x3 | ||
1048 | # asm 1: fmulp <x3=float80#1,<sr1x3=float80#6 | ||
1049 | # asm 2: fmulp <x3=%st(0),<sr1x3=%st(5) | ||
1050 | fmulp %st(0),%st(5) | ||
1051 | # comment:fpstackfrombottom:<sr1x3#69:<h3#38:<h2#39:<h0#41:<h1#40: | ||
1052 | |||
1053 | # qhasm: internal stacktop sr1x3 | ||
1054 | # asm 1: fxch <sr1x3=float80#5 | ||
1055 | # asm 2: fxch <sr1x3=%st(4) | ||
1056 | fxch %st(4) | ||
1057 | |||
1058 | # qhasm: h0 += sr1x3 | ||
1059 | # asm 1: faddp <sr1x3=float80#1,<h0=float80#2 | ||
1060 | # asm 2: faddp <sr1x3=%st(0),<h0=%st(1) | ||
1061 | faddp %st(0),%st(1) | ||
1062 | # comment:fpstackfrombottom:<h1#40:<h3#38:<h2#39:<h0#41: | ||
1063 | |||
1064 | # qhasm: unsigned<? l - 16 | ||
1065 | # asm 1: cmp $16,<l=int32#2 | ||
1066 | # asm 2: cmp $16,<l=%ecx | ||
1067 | cmp $16,%ecx | ||
1068 | # comment:fpstackfrombottom:<h1#40:<h3#38:<h2#39:<h0#41: | ||
1069 | |||
1070 | # qhasm: stacktop h3 | ||
1071 | # asm 1: fxch <h3=float80#3 | ||
1072 | # asm 2: fxch <h3=%st(2) | ||
1073 | fxch %st(2) | ||
1074 | # comment:fpstackfrombottom:<h1#40:<h0#41:<h2#39:<h3#38: | ||
1075 | |||
1076 | # qhasm: y3 = *(float64 *) &d3 | ||
1077 | # asm 1: fldl <d3=stack64#4 | ||
1078 | # asm 2: fldl <d3=120(%esp) | ||
1079 | fldl 120(%esp) | ||
1080 | # comment:fpstackfrombottom:<h1#40:<h0#41:<h2#39:<h3#38:<y3#71: | ||
1081 | |||
1082 | # qhasm: y3 -= *(float64 *) &crypto_onetimeauth_poly1305_x86_doffset3minustwo128 | ||
1083 | fsubl crypto_onetimeauth_poly1305_x86_doffset3minustwo128 | ||
1084 | # comment:fpstackfrombottom:<h1#40:<h0#41:<h2#39:<h3#38:<y3#71: | ||
1085 | |||
1086 | # qhasm: h3 += y3 | ||
1087 | # asm 1: faddp <y3=float80#1,<h3=float80#2 | ||
1088 | # asm 2: faddp <y3=%st(0),<h3=%st(1) | ||
1089 | faddp %st(0),%st(1) | ||
1090 | # comment:fpstackfrombottom:<h1#40:<h0#41:<h2#39:<h3#38: | ||
1091 | |||
1092 | # qhasm: stacktop h2 | ||
1093 | # asm 1: fxch <h2=float80#2 | ||
1094 | # asm 2: fxch <h2=%st(1) | ||
1095 | fxch %st(1) | ||
1096 | # comment:fpstackfrombottom:<h1#40:<h0#41:<h3#38:<h2#39: | ||
1097 | |||
1098 | # qhasm: y2 = *(float64 *) &d2 | ||
1099 | # asm 1: fldl <d2=stack64#3 | ||
1100 | # asm 2: fldl <d2=112(%esp) | ||
1101 | fldl 112(%esp) | ||
1102 | # comment:fpstackfrombottom:<h1#40:<h0#41:<h3#38:<h2#39:<y2#72: | ||
1103 | |||
1104 | # qhasm: y2 -= *(float64 *) &crypto_onetimeauth_poly1305_x86_doffset2 | ||
1105 | fsubl crypto_onetimeauth_poly1305_x86_doffset2 | ||
1106 | # comment:fpstackfrombottom:<h1#40:<h0#41:<h3#38:<h2#39:<y2#72: | ||
1107 | |||
1108 | # qhasm: h2 += y2 | ||
1109 | # asm 1: faddp <y2=float80#1,<h2=float80#2 | ||
1110 | # asm 2: faddp <y2=%st(0),<h2=%st(1) | ||
1111 | faddp %st(0),%st(1) | ||
1112 | # comment:fpstackfrombottom:<h1#40:<h0#41:<h3#38:<h2#39: | ||
1113 | |||
1114 | # qhasm: stacktop h1 | ||
1115 | # asm 1: fxch <h1=float80#4 | ||
1116 | # asm 2: fxch <h1=%st(3) | ||
1117 | fxch %st(3) | ||
1118 | # comment:fpstackfrombottom:<h2#39:<h0#41:<h3#38:<h1#40: | ||
1119 | |||
1120 | # qhasm: y1 = *(float64 *) &d1 | ||
1121 | # asm 1: fldl <d1=stack64#2 | ||
1122 | # asm 2: fldl <d1=104(%esp) | ||
1123 | fldl 104(%esp) | ||
1124 | # comment:fpstackfrombottom:<h2#39:<h0#41:<h3#38:<h1#40:<y1#73: | ||
1125 | |||
1126 | # qhasm: y1 -= *(float64 *) &crypto_onetimeauth_poly1305_x86_doffset1 | ||
1127 | fsubl crypto_onetimeauth_poly1305_x86_doffset1 | ||
1128 | # comment:fpstackfrombottom:<h2#39:<h0#41:<h3#38:<h1#40:<y1#73: | ||
1129 | |||
1130 | # qhasm: h1 += y1 | ||
1131 | # asm 1: faddp <y1=float80#1,<h1=float80#2 | ||
1132 | # asm 2: faddp <y1=%st(0),<h1=%st(1) | ||
1133 | faddp %st(0),%st(1) | ||
1134 | # comment:fpstackfrombottom:<h2#39:<h0#41:<h3#38:<h1#40: | ||
1135 | |||
1136 | # qhasm: stacktop h0 | ||
1137 | # asm 1: fxch <h0=float80#3 | ||
1138 | # asm 2: fxch <h0=%st(2) | ||
1139 | fxch %st(2) | ||
1140 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41: | ||
1141 | |||
1142 | # qhasm: y0 = *(float64 *) &d0 | ||
1143 | # asm 1: fldl <d0=stack64#1 | ||
1144 | # asm 2: fldl <d0=96(%esp) | ||
1145 | fldl 96(%esp) | ||
1146 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41:<y0#74: | ||
1147 | |||
1148 | # qhasm: y0 -= *(float64 *) &crypto_onetimeauth_poly1305_x86_doffset0 | ||
1149 | fsubl crypto_onetimeauth_poly1305_x86_doffset0 | ||
1150 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41:<y0#74: | ||
1151 | |||
1152 | # qhasm: h0 += y0 | ||
1153 | # asm 1: faddp <y0=float80#1,<h0=float80#2 | ||
1154 | # asm 2: faddp <y0=%st(0),<h0=%st(1) | ||
1155 | faddp %st(0),%st(1) | ||
1156 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41: | ||
1157 | # comment:fp stack unchanged by jump | ||
1158 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41: | ||
1159 | |||
1160 | # qhasm: goto multiplyaddatleast16bytes if !unsigned< | ||
1161 | jae ._multiplyaddatleast16bytes | ||
1162 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41: | ||
1163 | # comment:fp stack unchanged by fallthrough | ||
1164 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41: | ||
1165 | |||
1166 | # qhasm: multiplyaddatmost15bytes: | ||
1167 | ._multiplyaddatmost15bytes: | ||
1168 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41: | ||
1169 | |||
1170 | # qhasm: x0 = *(float64 *) &crypto_onetimeauth_poly1305_x86_alpha130 | ||
1171 | fldl crypto_onetimeauth_poly1305_x86_alpha130 | ||
1172 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41:<x0#75: | ||
1173 | |||
1174 | # qhasm: x0 += h3 | ||
1175 | # asm 1: fadd <h3=float80#3,<x0=float80#1 | ||
1176 | # asm 2: fadd <h3=%st(2),<x0=%st(0) | ||
1177 | fadd %st(2),%st(0) | ||
1178 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41:<x0#75: | ||
1179 | |||
1180 | # qhasm: x0 -= *(float64 *) &crypto_onetimeauth_poly1305_x86_alpha130 | ||
1181 | fsubl crypto_onetimeauth_poly1305_x86_alpha130 | ||
1182 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41:<x0#75: | ||
1183 | |||
1184 | # qhasm: h3 -= x0 | ||
1185 | # asm 1: fsubr <x0=float80#1,<h3=float80#3 | ||
1186 | # asm 2: fsubr <x0=%st(0),<h3=%st(2) | ||
1187 | fsubr %st(0),%st(2) | ||
1188 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41:<x0#75: | ||
1189 | |||
1190 | # qhasm: x0 *= *(float64 *) &crypto_onetimeauth_poly1305_x86_scale | ||
1191 | fmull crypto_onetimeauth_poly1305_x86_scale | ||
1192 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41:<x0#75: | ||
1193 | |||
1194 | # qhasm: x1 = *(float64 *) &crypto_onetimeauth_poly1305_x86_alpha32 | ||
1195 | fldl crypto_onetimeauth_poly1305_x86_alpha32 | ||
1196 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41:<x0#75:<x1#76: | ||
1197 | |||
1198 | # qhasm: x1 += h0 | ||
1199 | # asm 1: fadd <h0=float80#3,<x1=float80#1 | ||
1200 | # asm 2: fadd <h0=%st(2),<x1=%st(0) | ||
1201 | fadd %st(2),%st(0) | ||
1202 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41:<x0#75:<x1#76: | ||
1203 | |||
1204 | # qhasm: x1 -= *(float64 *) &crypto_onetimeauth_poly1305_x86_alpha32 | ||
1205 | fsubl crypto_onetimeauth_poly1305_x86_alpha32 | ||
1206 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41:<x0#75:<x1#76: | ||
1207 | |||
1208 | # qhasm: h0 -= x1 | ||
1209 | # asm 1: fsubr <x1=float80#1,<h0=float80#3 | ||
1210 | # asm 2: fsubr <x1=%st(0),<h0=%st(2) | ||
1211 | fsubr %st(0),%st(2) | ||
1212 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41:<x0#75:<x1#76: | ||
1213 | |||
1214 | # qhasm: x2 = *(float64 *) &crypto_onetimeauth_poly1305_x86_alpha64 | ||
1215 | fldl crypto_onetimeauth_poly1305_x86_alpha64 | ||
1216 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41:<x0#75:<x1#76:<x2#77: | ||
1217 | |||
1218 | # qhasm: x2 += h1 | ||
1219 | # asm 1: fadd <h1=float80#6,<x2=float80#1 | ||
1220 | # asm 2: fadd <h1=%st(5),<x2=%st(0) | ||
1221 | fadd %st(5),%st(0) | ||
1222 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41:<x0#75:<x1#76:<x2#77: | ||
1223 | |||
1224 | # qhasm: x2 -= *(float64 *) &crypto_onetimeauth_poly1305_x86_alpha64 | ||
1225 | fsubl crypto_onetimeauth_poly1305_x86_alpha64 | ||
1226 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41:<x0#75:<x1#76:<x2#77: | ||
1227 | |||
1228 | # qhasm: h1 -= x2 | ||
1229 | # asm 1: fsubr <x2=float80#1,<h1=float80#6 | ||
1230 | # asm 2: fsubr <x2=%st(0),<h1=%st(5) | ||
1231 | fsubr %st(0),%st(5) | ||
1232 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41:<x0#75:<x1#76:<x2#77: | ||
1233 | |||
1234 | # qhasm: x3 = *(float64 *) &crypto_onetimeauth_poly1305_x86_alpha96 | ||
1235 | fldl crypto_onetimeauth_poly1305_x86_alpha96 | ||
1236 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41:<x0#75:<x1#76:<x2#77:<x3#78: | ||
1237 | |||
1238 | # qhasm: x3 += h2 | ||
1239 | # asm 1: fadd <h2=float80#8,<x3=float80#1 | ||
1240 | # asm 2: fadd <h2=%st(7),<x3=%st(0) | ||
1241 | fadd %st(7),%st(0) | ||
1242 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41:<x0#75:<x1#76:<x2#77:<x3#78: | ||
1243 | |||
1244 | # qhasm: x3 -= *(float64 *) &crypto_onetimeauth_poly1305_x86_alpha96 | ||
1245 | fsubl crypto_onetimeauth_poly1305_x86_alpha96 | ||
1246 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41:<x0#75:<x1#76:<x2#77:<x3#78: | ||
1247 | |||
1248 | # qhasm: h2 -= x3 | ||
1249 | # asm 1: fsubr <x3=float80#1,<h2=float80#8 | ||
1250 | # asm 2: fsubr <x3=%st(0),<h2=%st(7) | ||
1251 | fsubr %st(0),%st(7) | ||
1252 | # comment:fpstackfrombottom:<h2#39:<h1#40:<h3#38:<h0#41:<x0#75:<x1#76:<x2#77:<x3#78: | ||
1253 | |||
1254 | # qhasm: internal stacktop h2 | ||
1255 | # asm 1: fxch <h2=float80#8 | ||
1256 | # asm 2: fxch <h2=%st(7) | ||
1257 | fxch %st(7) | ||
1258 | |||
1259 | # qhasm: x2 += h2 | ||
1260 | # asm 1: faddp <h2=float80#1,<x2=float80#2 | ||
1261 | # asm 2: faddp <h2=%st(0),<x2=%st(1) | ||
1262 | faddp %st(0),%st(1) | ||
1263 | # comment:fpstackfrombottom:<x3#78:<h1#40:<h3#38:<h0#41:<x0#75:<x1#76:<x2#77: | ||
1264 | |||
1265 | # qhasm: internal stacktop h1 | ||
1266 | # asm 1: fxch <h1=float80#6 | ||
1267 | # asm 2: fxch <h1=%st(5) | ||
1268 | fxch %st(5) | ||
1269 | |||
1270 | # qhasm: x1 += h1 | ||
1271 | # asm 1: faddp <h1=float80#1,<x1=float80#2 | ||
1272 | # asm 2: faddp <h1=%st(0),<x1=%st(1) | ||
1273 | faddp %st(0),%st(1) | ||
1274 | # comment:fpstackfrombottom:<x3#78:<x2#77:<h3#38:<h0#41:<x0#75:<x1#76: | ||
1275 | |||
1276 | # qhasm: internal stacktop h3 | ||
1277 | # asm 1: fxch <h3=float80#4 | ||
1278 | # asm 2: fxch <h3=%st(3) | ||
1279 | fxch %st(3) | ||
1280 | |||
1281 | # qhasm: x3 += h3 | ||
1282 | # asm 1: faddp <h3=float80#1,<x3=float80#6 | ||
1283 | # asm 2: faddp <h3=%st(0),<x3=%st(5) | ||
1284 | faddp %st(0),%st(5) | ||
1285 | # comment:fpstackfrombottom:<x3#78:<x2#77:<x1#76:<h0#41:<x0#75: | ||
1286 | |||
1287 | # qhasm: x0 += h0 | ||
1288 | # asm 1: faddp <h0=float80#1,<x0=float80#2 | ||
1289 | # asm 2: faddp <h0=%st(0),<x0=%st(1) | ||
1290 | faddp %st(0),%st(1) | ||
1291 | # comment:fpstackfrombottom:<x3#78:<x2#77:<x1#76:<x0#75: | ||
1292 | |||
1293 | # qhasm: h3 = *(float64 *) &r3 | ||
1294 | # asm 1: fldl <r3=stack64#10 | ||
1295 | # asm 2: fldl <r3=168(%esp) | ||
1296 | fldl 168(%esp) | ||
1297 | # comment:fpstackfrombottom:<x3#78:<x2#77:<x1#76:<x0#75:<h3#38: | ||
1298 | |||
1299 | # qhasm: h3 *= x0 | ||
1300 | # asm 1: fmul <x0=float80#2,<h3=float80#1 | ||
1301 | # asm 2: fmul <x0=%st(1),<h3=%st(0) | ||
1302 | fmul %st(1),%st(0) | ||
1303 | # comment:fpstackfrombottom:<x3#78:<x2#77:<x1#76:<x0#75:<h3#38: | ||
1304 | |||
1305 | # qhasm: h2 = *(float64 *) &r2 | ||
1306 | # asm 1: fldl <r2=stack64#8 | ||
1307 | # asm 2: fldl <r2=152(%esp) | ||
1308 | fldl 152(%esp) | ||
1309 | # comment:fpstackfrombottom:<x3#78:<x2#77:<x1#76:<x0#75:<h3#38:<h2#39: | ||
1310 | |||
1311 | # qhasm: h2 *= x0 | ||
1312 | # asm 1: fmul <x0=float80#3,<h2=float80#1 | ||
1313 | # asm 2: fmul <x0=%st(2),<h2=%st(0) | ||
1314 | fmul %st(2),%st(0) | ||
1315 | # comment:fpstackfrombottom:<x3#78:<x2#77:<x1#76:<x0#75:<h3#38:<h2#39: | ||
1316 | |||
1317 | # qhasm: h1 = *(float64 *) &r1 | ||
1318 | # asm 1: fldl <r1=stack64#6 | ||
1319 | # asm 2: fldl <r1=136(%esp) | ||
1320 | fldl 136(%esp) | ||
1321 | # comment:fpstackfrombottom:<x3#78:<x2#77:<x1#76:<x0#75:<h3#38:<h2#39:<h1#40: | ||
1322 | |||
1323 | # qhasm: h1 *= x0 | ||
1324 | # asm 1: fmul <x0=float80#4,<h1=float80#1 | ||
1325 | # asm 2: fmul <x0=%st(3),<h1=%st(0) | ||
1326 | fmul %st(3),%st(0) | ||
1327 | # comment:fpstackfrombottom:<x3#78:<x2#77:<x1#76:<x0#75:<h3#38:<h2#39:<h1#40: | ||
1328 | |||
1329 | # qhasm: h0 = *(float64 *) &r0 | ||
1330 | # asm 1: fldl <r0=stack64#5 | ||
1331 | # asm 2: fldl <r0=128(%esp) | ||
1332 | fldl 128(%esp) | ||
1333 | # comment:fpstackfrombottom:<x3#78:<x2#77:<x1#76:<x0#75:<h3#38:<h2#39:<h1#40:<h0#41: | ||
1334 | |||
1335 | # qhasm: h0 *= x0 | ||
1336 | # asm 1: fmulp <x0=float80#1,<h0=float80#5 | ||
1337 | # asm 2: fmulp <x0=%st(0),<h0=%st(4) | ||
1338 | fmulp %st(0),%st(4) | ||
1339 | # comment:fpstackfrombottom:<x3#78:<x2#77:<x1#76:<h0#41:<h3#38:<h2#39:<h1#40: | ||
1340 | |||
1341 | # qhasm: r2x1 = *(float64 *) &r2 | ||
1342 | # asm 1: fldl <r2=stack64#8 | ||
1343 | # asm 2: fldl <r2=152(%esp) | ||
1344 | fldl 152(%esp) | ||
1345 | # comment:fpstackfrombottom:<x3#78:<x2#77:<x1#76:<h0#41:<h3#38:<h2#39:<h1#40:<r2x1#79: | ||
1346 | |||
1347 | # qhasm: r2x1 *= x1 | ||
1348 | # asm 1: fmul <x1=float80#6,<r2x1=float80#1 | ||
1349 | # asm 2: fmul <x1=%st(5),<r2x1=%st(0) | ||
1350 | fmul %st(5),%st(0) | ||
1351 | # comment:fpstackfrombottom:<x3#78:<x2#77:<x1#76:<h0#41:<h3#38:<h2#39:<h1#40:<r2x1#79: | ||
1352 | |||
1353 | # qhasm: h3 += r2x1 | ||
1354 | # asm 1: faddp <r2x1=float80#1,<h3=float80#4 | ||
1355 | # asm 2: faddp <r2x1=%st(0),<h3=%st(3) | ||
1356 | faddp %st(0),%st(3) | ||
1357 | # comment:fpstackfrombottom:<x3#78:<x2#77:<x1#76:<h0#41:<h3#38:<h2#39:<h1#40: | ||
1358 | |||
1359 | # qhasm: r1x1 = *(float64 *) &r1 | ||
1360 | # asm 1: fldl <r1=stack64#6 | ||
1361 | # asm 2: fldl <r1=136(%esp) | ||
1362 | fldl 136(%esp) | ||
1363 | # comment:fpstackfrombottom:<x3#78:<x2#77:<x1#76:<h0#41:<h3#38:<h2#39:<h1#40:<r1x1#80: | ||
1364 | |||
1365 | # qhasm: r1x1 *= x1 | ||
1366 | # asm 1: fmul <x1=float80#6,<r1x1=float80#1 | ||
1367 | # asm 2: fmul <x1=%st(5),<r1x1=%st(0) | ||
1368 | fmul %st(5),%st(0) | ||
1369 | # comment:fpstackfrombottom:<x3#78:<x2#77:<x1#76:<h0#41:<h3#38:<h2#39:<h1#40:<r1x1#80: | ||
1370 | |||
1371 | # qhasm: h2 += r1x1 | ||
1372 | # asm 1: faddp <r1x1=float80#1,<h2=float80#3 | ||
1373 | # asm 2: faddp <r1x1=%st(0),<h2=%st(2) | ||
1374 | faddp %st(0),%st(2) | ||
1375 | # comment:fpstackfrombottom:<x3#78:<x2#77:<x1#76:<h0#41:<h3#38:<h2#39:<h1#40: | ||
1376 | |||
1377 | # qhasm: r0x1 = *(float64 *) &r0 | ||
1378 | # asm 1: fldl <r0=stack64#5 | ||
1379 | # asm 2: fldl <r0=128(%esp) | ||
1380 | fldl 128(%esp) | ||
1381 | # comment:fpstackfrombottom:<x3#78:<x2#77:<x1#76:<h0#41:<h3#38:<h2#39:<h1#40:<r0x1#81: | ||
1382 | |||
1383 | # qhasm: r0x1 *= x1 | ||
1384 | # asm 1: fmul <x1=float80#6,<r0x1=float80#1 | ||
1385 | # asm 2: fmul <x1=%st(5),<r0x1=%st(0) | ||
1386 | fmul %st(5),%st(0) | ||
1387 | # comment:fpstackfrombottom:<x3#78:<x2#77:<x1#76:<h0#41:<h3#38:<h2#39:<h1#40:<r0x1#81: | ||
1388 | |||
1389 | # qhasm: h1 += r0x1 | ||
1390 | # asm 1: faddp <r0x1=float80#1,<h1=float80#2 | ||
1391 | # asm 2: faddp <r0x1=%st(0),<h1=%st(1) | ||
1392 | faddp %st(0),%st(1) | ||
1393 | # comment:fpstackfrombottom:<x3#78:<x2#77:<x1#76:<h0#41:<h3#38:<h2#39:<h1#40: | ||
1394 | |||
1395 | # qhasm: sr3x1 = *(float64 *) &sr3 | ||
1396 | # asm 1: fldl <sr3=stack64#11 | ||
1397 | # asm 2: fldl <sr3=176(%esp) | ||
1398 | fldl 176(%esp) | ||
1399 | # comment:fpstackfrombottom:<x3#78:<x2#77:<x1#76:<h0#41:<h3#38:<h2#39:<h1#40:<sr3x1#82: | ||
1400 | |||
1401 | # qhasm: sr3x1 *= x1 | ||
1402 | # asm 1: fmulp <x1=float80#1,<sr3x1=float80#6 | ||
1403 | # asm 2: fmulp <x1=%st(0),<sr3x1=%st(5) | ||
1404 | fmulp %st(0),%st(5) | ||
1405 | # comment:fpstackfrombottom:<x3#78:<x2#77:<sr3x1#82:<h0#41:<h3#38:<h2#39:<h1#40: | ||
1406 | |||
1407 | # qhasm: internal stacktop sr3x1 | ||
1408 | # asm 1: fxch <sr3x1=float80#5 | ||
1409 | # asm 2: fxch <sr3x1=%st(4) | ||
1410 | fxch %st(4) | ||
1411 | |||
1412 | # qhasm: h0 += sr3x1 | ||
1413 | # asm 1: faddp <sr3x1=float80#1,<h0=float80#4 | ||
1414 | # asm 2: faddp <sr3x1=%st(0),<h0=%st(3) | ||
1415 | faddp %st(0),%st(3) | ||
1416 | # comment:fpstackfrombottom:<x3#78:<x2#77:<h1#40:<h0#41:<h3#38:<h2#39: | ||
1417 | |||
1418 | # qhasm: r1x2 = *(float64 *) &r1 | ||
1419 | # asm 1: fldl <r1=stack64#6 | ||
1420 | # asm 2: fldl <r1=136(%esp) | ||
1421 | fldl 136(%esp) | ||
1422 | # comment:fpstackfrombottom:<x3#78:<x2#77:<h1#40:<h0#41:<h3#38:<h2#39:<r1x2#83: | ||
1423 | |||
1424 | # qhasm: r1x2 *= x2 | ||
1425 | # asm 1: fmul <x2=float80#6,<r1x2=float80#1 | ||
1426 | # asm 2: fmul <x2=%st(5),<r1x2=%st(0) | ||
1427 | fmul %st(5),%st(0) | ||
1428 | # comment:fpstackfrombottom:<x3#78:<x2#77:<h1#40:<h0#41:<h3#38:<h2#39:<r1x2#83: | ||
1429 | |||
1430 | # qhasm: h3 += r1x2 | ||
1431 | # asm 1: faddp <r1x2=float80#1,<h3=float80#3 | ||
1432 | # asm 2: faddp <r1x2=%st(0),<h3=%st(2) | ||
1433 | faddp %st(0),%st(2) | ||
1434 | # comment:fpstackfrombottom:<x3#78:<x2#77:<h1#40:<h0#41:<h3#38:<h2#39: | ||
1435 | |||
1436 | # qhasm: r0x2 = *(float64 *) &r0 | ||
1437 | # asm 1: fldl <r0=stack64#5 | ||
1438 | # asm 2: fldl <r0=128(%esp) | ||
1439 | fldl 128(%esp) | ||
1440 | # comment:fpstackfrombottom:<x3#78:<x2#77:<h1#40:<h0#41:<h3#38:<h2#39:<r0x2#84: | ||
1441 | |||
1442 | # qhasm: r0x2 *= x2 | ||
1443 | # asm 1: fmul <x2=float80#6,<r0x2=float80#1 | ||
1444 | # asm 2: fmul <x2=%st(5),<r0x2=%st(0) | ||
1445 | fmul %st(5),%st(0) | ||
1446 | # comment:fpstackfrombottom:<x3#78:<x2#77:<h1#40:<h0#41:<h3#38:<h2#39:<r0x2#84: | ||
1447 | |||
1448 | # qhasm: h2 += r0x2 | ||
1449 | # asm 1: faddp <r0x2=float80#1,<h2=float80#2 | ||
1450 | # asm 2: faddp <r0x2=%st(0),<h2=%st(1) | ||
1451 | faddp %st(0),%st(1) | ||
1452 | # comment:fpstackfrombottom:<x3#78:<x2#77:<h1#40:<h0#41:<h3#38:<h2#39: | ||
1453 | |||
1454 | # qhasm: sr3x2 = *(float64 *) &sr3 | ||
1455 | # asm 1: fldl <sr3=stack64#11 | ||
1456 | # asm 2: fldl <sr3=176(%esp) | ||
1457 | fldl 176(%esp) | ||
1458 | # comment:fpstackfrombottom:<x3#78:<x2#77:<h1#40:<h0#41:<h3#38:<h2#39:<sr3x2#85: | ||
1459 | |||
1460 | # qhasm: sr3x2 *= x2 | ||
1461 | # asm 1: fmul <x2=float80#6,<sr3x2=float80#1 | ||
1462 | # asm 2: fmul <x2=%st(5),<sr3x2=%st(0) | ||
1463 | fmul %st(5),%st(0) | ||
1464 | # comment:fpstackfrombottom:<x3#78:<x2#77:<h1#40:<h0#41:<h3#38:<h2#39:<sr3x2#85: | ||
1465 | |||
1466 | # qhasm: h1 += sr3x2 | ||
1467 | # asm 1: faddp <sr3x2=float80#1,<h1=float80#5 | ||
1468 | # asm 2: faddp <sr3x2=%st(0),<h1=%st(4) | ||
1469 | faddp %st(0),%st(4) | ||
1470 | # comment:fpstackfrombottom:<x3#78:<x2#77:<h1#40:<h0#41:<h3#38:<h2#39: | ||
1471 | |||
1472 | # qhasm: sr2x2 = *(float64 *) &sr2 | ||
1473 | # asm 1: fldl <sr2=stack64#9 | ||
1474 | # asm 2: fldl <sr2=160(%esp) | ||
1475 | fldl 160(%esp) | ||
1476 | # comment:fpstackfrombottom:<x3#78:<x2#77:<h1#40:<h0#41:<h3#38:<h2#39:<sr2x2#86: | ||
1477 | |||
1478 | # qhasm: sr2x2 *= x2 | ||
1479 | # asm 1: fmulp <x2=float80#1,<sr2x2=float80#6 | ||
1480 | # asm 2: fmulp <x2=%st(0),<sr2x2=%st(5) | ||
1481 | fmulp %st(0),%st(5) | ||
1482 | # comment:fpstackfrombottom:<x3#78:<sr2x2#86:<h1#40:<h0#41:<h3#38:<h2#39: | ||
1483 | |||
1484 | # qhasm: internal stacktop sr2x2 | ||
1485 | # asm 1: fxch <sr2x2=float80#5 | ||
1486 | # asm 2: fxch <sr2x2=%st(4) | ||
1487 | fxch %st(4) | ||
1488 | |||
1489 | # qhasm: h0 += sr2x2 | ||
1490 | # asm 1: faddp <sr2x2=float80#1,<h0=float80#3 | ||
1491 | # asm 2: faddp <sr2x2=%st(0),<h0=%st(2) | ||
1492 | faddp %st(0),%st(2) | ||
1493 | # comment:fpstackfrombottom:<x3#78:<h2#39:<h1#40:<h0#41:<h3#38: | ||
1494 | |||
1495 | # qhasm: r0x3 = *(float64 *) &r0 | ||
1496 | # asm 1: fldl <r0=stack64#5 | ||
1497 | # asm 2: fldl <r0=128(%esp) | ||
1498 | fldl 128(%esp) | ||
1499 | # comment:fpstackfrombottom:<x3#78:<h2#39:<h1#40:<h0#41:<h3#38:<r0x3#87: | ||
1500 | |||
1501 | # qhasm: r0x3 *= x3 | ||
1502 | # asm 1: fmul <x3=float80#6,<r0x3=float80#1 | ||
1503 | # asm 2: fmul <x3=%st(5),<r0x3=%st(0) | ||
1504 | fmul %st(5),%st(0) | ||
1505 | # comment:fpstackfrombottom:<x3#78:<h2#39:<h1#40:<h0#41:<h3#38:<r0x3#87: | ||
1506 | |||
1507 | # qhasm: h3 += r0x3 | ||
1508 | # asm 1: faddp <r0x3=float80#1,<h3=float80#2 | ||
1509 | # asm 2: faddp <r0x3=%st(0),<h3=%st(1) | ||
1510 | faddp %st(0),%st(1) | ||
1511 | # comment:fpstackfrombottom:<x3#78:<h2#39:<h1#40:<h0#41:<h3#38: | ||
1512 | |||
1513 | # qhasm: sr3x3 = *(float64 *) &sr3 | ||
1514 | # asm 1: fldl <sr3=stack64#11 | ||
1515 | # asm 2: fldl <sr3=176(%esp) | ||
1516 | fldl 176(%esp) | ||
1517 | # comment:fpstackfrombottom:<x3#78:<h2#39:<h1#40:<h0#41:<h3#38:<sr3x3#88: | ||
1518 | |||
1519 | # qhasm: sr3x3 *= x3 | ||
1520 | # asm 1: fmul <x3=float80#6,<sr3x3=float80#1 | ||
1521 | # asm 2: fmul <x3=%st(5),<sr3x3=%st(0) | ||
1522 | fmul %st(5),%st(0) | ||
1523 | # comment:fpstackfrombottom:<x3#78:<h2#39:<h1#40:<h0#41:<h3#38:<sr3x3#88: | ||
1524 | |||
1525 | # qhasm: h2 += sr3x3 | ||
1526 | # asm 1: faddp <sr3x3=float80#1,<h2=float80#5 | ||
1527 | # asm 2: faddp <sr3x3=%st(0),<h2=%st(4) | ||
1528 | faddp %st(0),%st(4) | ||
1529 | # comment:fpstackfrombottom:<x3#78:<h2#39:<h1#40:<h0#41:<h3#38: | ||
1530 | |||
1531 | # qhasm: sr2x3 = *(float64 *) &sr2 | ||
1532 | # asm 1: fldl <sr2=stack64#9 | ||
1533 | # asm 2: fldl <sr2=160(%esp) | ||
1534 | fldl 160(%esp) | ||
1535 | # comment:fpstackfrombottom:<x3#78:<h2#39:<h1#40:<h0#41:<h3#38:<sr2x3#89: | ||
1536 | |||
1537 | # qhasm: sr2x3 *= x3 | ||
1538 | # asm 1: fmul <x3=float80#6,<sr2x3=float80#1 | ||
1539 | # asm 2: fmul <x3=%st(5),<sr2x3=%st(0) | ||
1540 | fmul %st(5),%st(0) | ||
1541 | # comment:fpstackfrombottom:<x3#78:<h2#39:<h1#40:<h0#41:<h3#38:<sr2x3#89: | ||
1542 | |||
1543 | # qhasm: h1 += sr2x3 | ||
1544 | # asm 1: faddp <sr2x3=float80#1,<h1=float80#4 | ||
1545 | # asm 2: faddp <sr2x3=%st(0),<h1=%st(3) | ||
1546 | faddp %st(0),%st(3) | ||
1547 | # comment:fpstackfrombottom:<x3#78:<h2#39:<h1#40:<h0#41:<h3#38: | ||
1548 | |||
1549 | # qhasm: sr1x3 = *(float64 *) &sr1 | ||
1550 | # asm 1: fldl <sr1=stack64#7 | ||
1551 | # asm 2: fldl <sr1=144(%esp) | ||
1552 | fldl 144(%esp) | ||
1553 | # comment:fpstackfrombottom:<x3#78:<h2#39:<h1#40:<h0#41:<h3#38:<sr1x3#90: | ||
1554 | |||
1555 | # qhasm: sr1x3 *= x3 | ||
1556 | # asm 1: fmulp <x3=float80#1,<sr1x3=float80#6 | ||
1557 | # asm 2: fmulp <x3=%st(0),<sr1x3=%st(5) | ||
1558 | fmulp %st(0),%st(5) | ||
1559 | # comment:fpstackfrombottom:<sr1x3#90:<h2#39:<h1#40:<h0#41:<h3#38: | ||
1560 | |||
1561 | # qhasm: internal stacktop sr1x3 | ||
1562 | # asm 1: fxch <sr1x3=float80#5 | ||
1563 | # asm 2: fxch <sr1x3=%st(4) | ||
1564 | fxch %st(4) | ||
1565 | |||
1566 | # qhasm: h0 += sr1x3 | ||
1567 | # asm 1: faddp <sr1x3=float80#1,<h0=float80#2 | ||
1568 | # asm 2: faddp <sr1x3=%st(0),<h0=%st(1) | ||
1569 | faddp %st(0),%st(1) | ||
1570 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
1571 | # comment:fp stack unchanged by fallthrough | ||
1572 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
1573 | |||
1574 | # qhasm: addatmost15bytes: | ||
1575 | ._addatmost15bytes: | ||
1576 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
1577 | |||
1578 | # qhasm: =? l - 0 | ||
1579 | # asm 1: cmp $0,<l=int32#2 | ||
1580 | # asm 2: cmp $0,<l=%ecx | ||
1581 | cmp $0,%ecx | ||
1582 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
1583 | # comment:fp stack unchanged by jump | ||
1584 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
1585 | |||
1586 | # qhasm: goto nomorebytes if = | ||
1587 | je ._nomorebytes | ||
1588 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
1589 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
1590 | |||
1591 | # qhasm: stack128 lastchunk | ||
1592 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
1593 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
1594 | |||
1595 | # qhasm: int32 destination | ||
1596 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
1597 | |||
1598 | # qhasm: ((uint32 *)&lastchunk)[0] = 0 | ||
1599 | # asm 1: movl $0,>lastchunk=stack128#1 | ||
1600 | # asm 2: movl $0,>lastchunk=64(%esp) | ||
1601 | movl $0,64(%esp) | ||
1602 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
1603 | |||
1604 | # qhasm: ((uint32 *)&lastchunk)[1] = 0 | ||
1605 | # asm 1: movl $0,4+<lastchunk=stack128#1 | ||
1606 | # asm 2: movl $0,4+<lastchunk=64(%esp) | ||
1607 | movl $0,4+64(%esp) | ||
1608 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
1609 | |||
1610 | # qhasm: ((uint32 *)&lastchunk)[2] = 0 | ||
1611 | # asm 1: movl $0,8+<lastchunk=stack128#1 | ||
1612 | # asm 2: movl $0,8+<lastchunk=64(%esp) | ||
1613 | movl $0,8+64(%esp) | ||
1614 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
1615 | |||
1616 | # qhasm: ((uint32 *)&lastchunk)[3] = 0 | ||
1617 | # asm 1: movl $0,12+<lastchunk=stack128#1 | ||
1618 | # asm 2: movl $0,12+<lastchunk=64(%esp) | ||
1619 | movl $0,12+64(%esp) | ||
1620 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
1621 | |||
1622 | # qhasm: destination = &lastchunk | ||
1623 | # asm 1: leal <lastchunk=stack128#1,>destination=int32#6 | ||
1624 | # asm 2: leal <lastchunk=64(%esp),>destination=%edi | ||
1625 | leal 64(%esp),%edi | ||
1626 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
1627 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
1628 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
1629 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
1630 | |||
1631 | # qhasm: while (l) { *destination++ = *m++; --l } | ||
1632 | rep movsb | ||
1633 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
1634 | |||
1635 | # qhasm: *(uint8 *) (destination + 0) = 1 | ||
1636 | # asm 1: movb $1,0(<destination=int32#6) | ||
1637 | # asm 2: movb $1,0(<destination=%edi) | ||
1638 | movb $1,0(%edi) | ||
1639 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
1640 | |||
1641 | # qhasm: m3 = ((uint32 *)&lastchunk)[3] | ||
1642 | # asm 1: movl 12+<lastchunk=stack128#1,>m3=int32#1 | ||
1643 | # asm 2: movl 12+<lastchunk=64(%esp),>m3=%eax | ||
1644 | movl 12+64(%esp),%eax | ||
1645 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
1646 | |||
1647 | # qhasm: m2 = ((uint32 *)&lastchunk)[2] | ||
1648 | # asm 1: movl 8+<lastchunk=stack128#1,>m2=int32#2 | ||
1649 | # asm 2: movl 8+<lastchunk=64(%esp),>m2=%ecx | ||
1650 | movl 8+64(%esp),%ecx | ||
1651 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
1652 | |||
1653 | # qhasm: m1 = ((uint32 *)&lastchunk)[1] | ||
1654 | # asm 1: movl 4+<lastchunk=stack128#1,>m1=int32#3 | ||
1655 | # asm 2: movl 4+<lastchunk=64(%esp),>m1=%edx | ||
1656 | movl 4+64(%esp),%edx | ||
1657 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
1658 | |||
1659 | # qhasm: m0 = ((uint32 *)&lastchunk)[0] | ||
1660 | # asm 1: movl <lastchunk=stack128#1,>m0=int32#4 | ||
1661 | # asm 2: movl <lastchunk=64(%esp),>m0=%ebx | ||
1662 | movl 64(%esp),%ebx | ||
1663 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
1664 | |||
1665 | # qhasm: inplace d3 bottom = m3 | ||
1666 | # asm 1: movl <m3=int32#1,<d3=stack64#4 | ||
1667 | # asm 2: movl <m3=%eax,<d3=120(%esp) | ||
1668 | movl %eax,120(%esp) | ||
1669 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
1670 | |||
1671 | # qhasm: inplace d2 bottom = m2 | ||
1672 | # asm 1: movl <m2=int32#2,<d2=stack64#3 | ||
1673 | # asm 2: movl <m2=%ecx,<d2=112(%esp) | ||
1674 | movl %ecx,112(%esp) | ||
1675 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
1676 | |||
1677 | # qhasm: inplace d1 bottom = m1 | ||
1678 | # asm 1: movl <m1=int32#3,<d1=stack64#2 | ||
1679 | # asm 2: movl <m1=%edx,<d1=104(%esp) | ||
1680 | movl %edx,104(%esp) | ||
1681 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
1682 | |||
1683 | # qhasm: inplace d0 bottom = m0 | ||
1684 | # asm 1: movl <m0=int32#4,<d0=stack64#1 | ||
1685 | # asm 2: movl <m0=%ebx,<d0=96(%esp) | ||
1686 | movl %ebx,96(%esp) | ||
1687 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
1688 | |||
1689 | # qhasm: internal stacktop h3 | ||
1690 | # asm 1: fxch <h3=float80#4 | ||
1691 | # asm 2: fxch <h3=%st(3) | ||
1692 | fxch %st(3) | ||
1693 | |||
1694 | # qhasm: h3 += *(float64 *) &d3 | ||
1695 | # asm 1: faddl <d3=stack64#4 | ||
1696 | # asm 2: faddl <d3=120(%esp) | ||
1697 | faddl 120(%esp) | ||
1698 | # comment:fpstackfrombottom:<h0#41:<h2#39:<h1#40:<h3#38: | ||
1699 | |||
1700 | # qhasm: h3 -= *(float64 *) &crypto_onetimeauth_poly1305_x86_doffset3 | ||
1701 | fsubl crypto_onetimeauth_poly1305_x86_doffset3 | ||
1702 | # comment:fpstackfrombottom:<h0#41:<h2#39:<h1#40:<h3#38: | ||
1703 | |||
1704 | # qhasm: internal stacktop h2 | ||
1705 | # asm 1: fxch <h2=float80#3 | ||
1706 | # asm 2: fxch <h2=%st(2) | ||
1707 | fxch %st(2) | ||
1708 | |||
1709 | # qhasm: h2 += *(float64 *) &d2 | ||
1710 | # asm 1: faddl <d2=stack64#3 | ||
1711 | # asm 2: faddl <d2=112(%esp) | ||
1712 | faddl 112(%esp) | ||
1713 | # comment:fpstackfrombottom:<h0#41:<h3#38:<h1#40:<h2#39: | ||
1714 | |||
1715 | # qhasm: h2 -= *(float64 *) &crypto_onetimeauth_poly1305_x86_doffset2 | ||
1716 | fsubl crypto_onetimeauth_poly1305_x86_doffset2 | ||
1717 | # comment:fpstackfrombottom:<h0#41:<h3#38:<h1#40:<h2#39: | ||
1718 | |||
1719 | # qhasm: internal stacktop h1 | ||
1720 | # asm 1: fxch <h1=float80#2 | ||
1721 | # asm 2: fxch <h1=%st(1) | ||
1722 | fxch %st(1) | ||
1723 | |||
1724 | # qhasm: h1 += *(float64 *) &d1 | ||
1725 | # asm 1: faddl <d1=stack64#2 | ||
1726 | # asm 2: faddl <d1=104(%esp) | ||
1727 | faddl 104(%esp) | ||
1728 | # comment:fpstackfrombottom:<h0#41:<h3#38:<h2#39:<h1#40: | ||
1729 | |||
1730 | # qhasm: h1 -= *(float64 *) &crypto_onetimeauth_poly1305_x86_doffset1 | ||
1731 | fsubl crypto_onetimeauth_poly1305_x86_doffset1 | ||
1732 | # comment:fpstackfrombottom:<h0#41:<h3#38:<h2#39:<h1#40: | ||
1733 | |||
1734 | # qhasm: internal stacktop h0 | ||
1735 | # asm 1: fxch <h0=float80#4 | ||
1736 | # asm 2: fxch <h0=%st(3) | ||
1737 | fxch %st(3) | ||
1738 | |||
1739 | # qhasm: h0 += *(float64 *) &d0 | ||
1740 | # asm 1: faddl <d0=stack64#1 | ||
1741 | # asm 2: faddl <d0=96(%esp) | ||
1742 | faddl 96(%esp) | ||
1743 | # comment:fpstackfrombottom:<h1#40:<h3#38:<h2#39:<h0#41: | ||
1744 | |||
1745 | # qhasm: h0 -= *(float64 *) &crypto_onetimeauth_poly1305_x86_doffset0 | ||
1746 | fsubl crypto_onetimeauth_poly1305_x86_doffset0 | ||
1747 | # comment:fpstackfrombottom:<h1#40:<h3#38:<h2#39:<h0#41: | ||
1748 | |||
1749 | # qhasm: x0 = *(float64 *) &crypto_onetimeauth_poly1305_x86_alpha130 | ||
1750 | fldl crypto_onetimeauth_poly1305_x86_alpha130 | ||
1751 | # comment:fpstackfrombottom:<h1#40:<h3#38:<h2#39:<h0#41:<x0#98: | ||
1752 | |||
1753 | # qhasm: x0 += h3 | ||
1754 | # asm 1: fadd <h3=float80#4,<x0=float80#1 | ||
1755 | # asm 2: fadd <h3=%st(3),<x0=%st(0) | ||
1756 | fadd %st(3),%st(0) | ||
1757 | # comment:fpstackfrombottom:<h1#40:<h3#38:<h2#39:<h0#41:<x0#98: | ||
1758 | |||
1759 | # qhasm: x0 -= *(float64 *) &crypto_onetimeauth_poly1305_x86_alpha130 | ||
1760 | fsubl crypto_onetimeauth_poly1305_x86_alpha130 | ||
1761 | # comment:fpstackfrombottom:<h1#40:<h3#38:<h2#39:<h0#41:<x0#98: | ||
1762 | |||
1763 | # qhasm: h3 -= x0 | ||
1764 | # asm 1: fsubr <x0=float80#1,<h3=float80#4 | ||
1765 | # asm 2: fsubr <x0=%st(0),<h3=%st(3) | ||
1766 | fsubr %st(0),%st(3) | ||
1767 | # comment:fpstackfrombottom:<h1#40:<h3#38:<h2#39:<h0#41:<x0#98: | ||
1768 | |||
1769 | # qhasm: x0 *= *(float64 *) &crypto_onetimeauth_poly1305_x86_scale | ||
1770 | fmull crypto_onetimeauth_poly1305_x86_scale | ||
1771 | # comment:fpstackfrombottom:<h1#40:<h3#38:<h2#39:<h0#41:<x0#98: | ||
1772 | |||
1773 | # qhasm: x1 = *(float64 *) &crypto_onetimeauth_poly1305_x86_alpha32 | ||
1774 | fldl crypto_onetimeauth_poly1305_x86_alpha32 | ||
1775 | # comment:fpstackfrombottom:<h1#40:<h3#38:<h2#39:<h0#41:<x0#98:<x1#99: | ||
1776 | |||
1777 | # qhasm: x1 += h0 | ||
1778 | # asm 1: fadd <h0=float80#3,<x1=float80#1 | ||
1779 | # asm 2: fadd <h0=%st(2),<x1=%st(0) | ||
1780 | fadd %st(2),%st(0) | ||
1781 | # comment:fpstackfrombottom:<h1#40:<h3#38:<h2#39:<h0#41:<x0#98:<x1#99: | ||
1782 | |||
1783 | # qhasm: x1 -= *(float64 *) &crypto_onetimeauth_poly1305_x86_alpha32 | ||
1784 | fsubl crypto_onetimeauth_poly1305_x86_alpha32 | ||
1785 | # comment:fpstackfrombottom:<h1#40:<h3#38:<h2#39:<h0#41:<x0#98:<x1#99: | ||
1786 | |||
1787 | # qhasm: h0 -= x1 | ||
1788 | # asm 1: fsubr <x1=float80#1,<h0=float80#3 | ||
1789 | # asm 2: fsubr <x1=%st(0),<h0=%st(2) | ||
1790 | fsubr %st(0),%st(2) | ||
1791 | # comment:fpstackfrombottom:<h1#40:<h3#38:<h2#39:<h0#41:<x0#98:<x1#99: | ||
1792 | |||
1793 | # qhasm: x2 = *(float64 *) &crypto_onetimeauth_poly1305_x86_alpha64 | ||
1794 | fldl crypto_onetimeauth_poly1305_x86_alpha64 | ||
1795 | # comment:fpstackfrombottom:<h1#40:<h3#38:<h2#39:<h0#41:<x0#98:<x1#99:<x2#100: | ||
1796 | |||
1797 | # qhasm: x2 += h1 | ||
1798 | # asm 1: fadd <h1=float80#7,<x2=float80#1 | ||
1799 | # asm 2: fadd <h1=%st(6),<x2=%st(0) | ||
1800 | fadd %st(6),%st(0) | ||
1801 | # comment:fpstackfrombottom:<h1#40:<h3#38:<h2#39:<h0#41:<x0#98:<x1#99:<x2#100: | ||
1802 | |||
1803 | # qhasm: x2 -= *(float64 *) &crypto_onetimeauth_poly1305_x86_alpha64 | ||
1804 | fsubl crypto_onetimeauth_poly1305_x86_alpha64 | ||
1805 | # comment:fpstackfrombottom:<h1#40:<h3#38:<h2#39:<h0#41:<x0#98:<x1#99:<x2#100: | ||
1806 | |||
1807 | # qhasm: h1 -= x2 | ||
1808 | # asm 1: fsubr <x2=float80#1,<h1=float80#7 | ||
1809 | # asm 2: fsubr <x2=%st(0),<h1=%st(6) | ||
1810 | fsubr %st(0),%st(6) | ||
1811 | # comment:fpstackfrombottom:<h1#40:<h3#38:<h2#39:<h0#41:<x0#98:<x1#99:<x2#100: | ||
1812 | |||
1813 | # qhasm: x3 = *(float64 *) &crypto_onetimeauth_poly1305_x86_alpha96 | ||
1814 | fldl crypto_onetimeauth_poly1305_x86_alpha96 | ||
1815 | # comment:fpstackfrombottom:<h1#40:<h3#38:<h2#39:<h0#41:<x0#98:<x1#99:<x2#100:<x3#101: | ||
1816 | |||
1817 | # qhasm: x3 += h2 | ||
1818 | # asm 1: fadd <h2=float80#6,<x3=float80#1 | ||
1819 | # asm 2: fadd <h2=%st(5),<x3=%st(0) | ||
1820 | fadd %st(5),%st(0) | ||
1821 | # comment:fpstackfrombottom:<h1#40:<h3#38:<h2#39:<h0#41:<x0#98:<x1#99:<x2#100:<x3#101: | ||
1822 | |||
1823 | # qhasm: x3 -= *(float64 *) &crypto_onetimeauth_poly1305_x86_alpha96 | ||
1824 | fsubl crypto_onetimeauth_poly1305_x86_alpha96 | ||
1825 | # comment:fpstackfrombottom:<h1#40:<h3#38:<h2#39:<h0#41:<x0#98:<x1#99:<x2#100:<x3#101: | ||
1826 | |||
1827 | # qhasm: h2 -= x3 | ||
1828 | # asm 1: fsubr <x3=float80#1,<h2=float80#6 | ||
1829 | # asm 2: fsubr <x3=%st(0),<h2=%st(5) | ||
1830 | fsubr %st(0),%st(5) | ||
1831 | # comment:fpstackfrombottom:<h1#40:<h3#38:<h2#39:<h0#41:<x0#98:<x1#99:<x2#100:<x3#101: | ||
1832 | |||
1833 | # qhasm: internal stacktop h0 | ||
1834 | # asm 1: fxch <h0=float80#5 | ||
1835 | # asm 2: fxch <h0=%st(4) | ||
1836 | fxch %st(4) | ||
1837 | |||
1838 | # qhasm: x0 += h0 | ||
1839 | # asm 1: faddp <h0=float80#1,<x0=float80#4 | ||
1840 | # asm 2: faddp <h0=%st(0),<x0=%st(3) | ||
1841 | faddp %st(0),%st(3) | ||
1842 | # comment:fpstackfrombottom:<h1#40:<h3#38:<h2#39:<x3#101:<x0#98:<x1#99:<x2#100: | ||
1843 | |||
1844 | # qhasm: internal stacktop h1 | ||
1845 | # asm 1: fxch <h1=float80#7 | ||
1846 | # asm 2: fxch <h1=%st(6) | ||
1847 | fxch %st(6) | ||
1848 | |||
1849 | # qhasm: x1 += h1 | ||
1850 | # asm 1: faddp <h1=float80#1,<x1=float80#2 | ||
1851 | # asm 2: faddp <h1=%st(0),<x1=%st(1) | ||
1852 | faddp %st(0),%st(1) | ||
1853 | # comment:fpstackfrombottom:<x2#100:<h3#38:<h2#39:<x3#101:<x0#98:<x1#99: | ||
1854 | |||
1855 | # qhasm: internal stacktop h2 | ||
1856 | # asm 1: fxch <h2=float80#4 | ||
1857 | # asm 2: fxch <h2=%st(3) | ||
1858 | fxch %st(3) | ||
1859 | |||
1860 | # qhasm: x2 += h2 | ||
1861 | # asm 1: faddp <h2=float80#1,<x2=float80#6 | ||
1862 | # asm 2: faddp <h2=%st(0),<x2=%st(5) | ||
1863 | faddp %st(0),%st(5) | ||
1864 | # comment:fpstackfrombottom:<x2#100:<h3#38:<x1#99:<x3#101:<x0#98: | ||
1865 | |||
1866 | # qhasm: internal stacktop h3 | ||
1867 | # asm 1: fxch <h3=float80#4 | ||
1868 | # asm 2: fxch <h3=%st(3) | ||
1869 | fxch %st(3) | ||
1870 | |||
1871 | # qhasm: x3 += h3 | ||
1872 | # asm 1: faddp <h3=float80#1,<x3=float80#2 | ||
1873 | # asm 2: faddp <h3=%st(0),<x3=%st(1) | ||
1874 | faddp %st(0),%st(1) | ||
1875 | # comment:fpstackfrombottom:<x2#100:<x0#98:<x1#99:<x3#101: | ||
1876 | |||
1877 | # qhasm: h3 = *(float64 *) &r3 | ||
1878 | # asm 1: fldl <r3=stack64#10 | ||
1879 | # asm 2: fldl <r3=168(%esp) | ||
1880 | fldl 168(%esp) | ||
1881 | # comment:fpstackfrombottom:<x2#100:<x0#98:<x1#99:<x3#101:<h3#38: | ||
1882 | |||
1883 | # qhasm: h3 *= x0 | ||
1884 | # asm 1: fmul <x0=float80#4,<h3=float80#1 | ||
1885 | # asm 2: fmul <x0=%st(3),<h3=%st(0) | ||
1886 | fmul %st(3),%st(0) | ||
1887 | # comment:fpstackfrombottom:<x2#100:<x0#98:<x1#99:<x3#101:<h3#38: | ||
1888 | |||
1889 | # qhasm: h2 = *(float64 *) &r2 | ||
1890 | # asm 1: fldl <r2=stack64#8 | ||
1891 | # asm 2: fldl <r2=152(%esp) | ||
1892 | fldl 152(%esp) | ||
1893 | # comment:fpstackfrombottom:<x2#100:<x0#98:<x1#99:<x3#101:<h3#38:<h2#39: | ||
1894 | |||
1895 | # qhasm: h2 *= x0 | ||
1896 | # asm 1: fmul <x0=float80#5,<h2=float80#1 | ||
1897 | # asm 2: fmul <x0=%st(4),<h2=%st(0) | ||
1898 | fmul %st(4),%st(0) | ||
1899 | # comment:fpstackfrombottom:<x2#100:<x0#98:<x1#99:<x3#101:<h3#38:<h2#39: | ||
1900 | |||
1901 | # qhasm: h1 = *(float64 *) &r1 | ||
1902 | # asm 1: fldl <r1=stack64#6 | ||
1903 | # asm 2: fldl <r1=136(%esp) | ||
1904 | fldl 136(%esp) | ||
1905 | # comment:fpstackfrombottom:<x2#100:<x0#98:<x1#99:<x3#101:<h3#38:<h2#39:<h1#40: | ||
1906 | |||
1907 | # qhasm: h1 *= x0 | ||
1908 | # asm 1: fmul <x0=float80#6,<h1=float80#1 | ||
1909 | # asm 2: fmul <x0=%st(5),<h1=%st(0) | ||
1910 | fmul %st(5),%st(0) | ||
1911 | # comment:fpstackfrombottom:<x2#100:<x0#98:<x1#99:<x3#101:<h3#38:<h2#39:<h1#40: | ||
1912 | |||
1913 | # qhasm: h0 = *(float64 *) &r0 | ||
1914 | # asm 1: fldl <r0=stack64#5 | ||
1915 | # asm 2: fldl <r0=128(%esp) | ||
1916 | fldl 128(%esp) | ||
1917 | # comment:fpstackfrombottom:<x2#100:<x0#98:<x1#99:<x3#101:<h3#38:<h2#39:<h1#40:<h0#41: | ||
1918 | |||
1919 | # qhasm: h0 *= x0 | ||
1920 | # asm 1: fmulp <x0=float80#1,<h0=float80#7 | ||
1921 | # asm 2: fmulp <x0=%st(0),<h0=%st(6) | ||
1922 | fmulp %st(0),%st(6) | ||
1923 | # comment:fpstackfrombottom:<x2#100:<h0#41:<x1#99:<x3#101:<h3#38:<h2#39:<h1#40: | ||
1924 | |||
1925 | # qhasm: r2x1 = *(float64 *) &r2 | ||
1926 | # asm 1: fldl <r2=stack64#8 | ||
1927 | # asm 2: fldl <r2=152(%esp) | ||
1928 | fldl 152(%esp) | ||
1929 | # comment:fpstackfrombottom:<x2#100:<h0#41:<x1#99:<x3#101:<h3#38:<h2#39:<h1#40:<r2x1#102: | ||
1930 | |||
1931 | # qhasm: r2x1 *= x1 | ||
1932 | # asm 1: fmul <x1=float80#6,<r2x1=float80#1 | ||
1933 | # asm 2: fmul <x1=%st(5),<r2x1=%st(0) | ||
1934 | fmul %st(5),%st(0) | ||
1935 | # comment:fpstackfrombottom:<x2#100:<h0#41:<x1#99:<x3#101:<h3#38:<h2#39:<h1#40:<r2x1#102: | ||
1936 | |||
1937 | # qhasm: h3 += r2x1 | ||
1938 | # asm 1: faddp <r2x1=float80#1,<h3=float80#4 | ||
1939 | # asm 2: faddp <r2x1=%st(0),<h3=%st(3) | ||
1940 | faddp %st(0),%st(3) | ||
1941 | # comment:fpstackfrombottom:<x2#100:<h0#41:<x1#99:<x3#101:<h3#38:<h2#39:<h1#40: | ||
1942 | |||
1943 | # qhasm: r1x1 = *(float64 *) &r1 | ||
1944 | # asm 1: fldl <r1=stack64#6 | ||
1945 | # asm 2: fldl <r1=136(%esp) | ||
1946 | fldl 136(%esp) | ||
1947 | # comment:fpstackfrombottom:<x2#100:<h0#41:<x1#99:<x3#101:<h3#38:<h2#39:<h1#40:<r1x1#103: | ||
1948 | |||
1949 | # qhasm: r1x1 *= x1 | ||
1950 | # asm 1: fmul <x1=float80#6,<r1x1=float80#1 | ||
1951 | # asm 2: fmul <x1=%st(5),<r1x1=%st(0) | ||
1952 | fmul %st(5),%st(0) | ||
1953 | # comment:fpstackfrombottom:<x2#100:<h0#41:<x1#99:<x3#101:<h3#38:<h2#39:<h1#40:<r1x1#103: | ||
1954 | |||
1955 | # qhasm: h2 += r1x1 | ||
1956 | # asm 1: faddp <r1x1=float80#1,<h2=float80#3 | ||
1957 | # asm 2: faddp <r1x1=%st(0),<h2=%st(2) | ||
1958 | faddp %st(0),%st(2) | ||
1959 | # comment:fpstackfrombottom:<x2#100:<h0#41:<x1#99:<x3#101:<h3#38:<h2#39:<h1#40: | ||
1960 | |||
1961 | # qhasm: r0x1 = *(float64 *) &r0 | ||
1962 | # asm 1: fldl <r0=stack64#5 | ||
1963 | # asm 2: fldl <r0=128(%esp) | ||
1964 | fldl 128(%esp) | ||
1965 | # comment:fpstackfrombottom:<x2#100:<h0#41:<x1#99:<x3#101:<h3#38:<h2#39:<h1#40:<r0x1#104: | ||
1966 | |||
1967 | # qhasm: r0x1 *= x1 | ||
1968 | # asm 1: fmul <x1=float80#6,<r0x1=float80#1 | ||
1969 | # asm 2: fmul <x1=%st(5),<r0x1=%st(0) | ||
1970 | fmul %st(5),%st(0) | ||
1971 | # comment:fpstackfrombottom:<x2#100:<h0#41:<x1#99:<x3#101:<h3#38:<h2#39:<h1#40:<r0x1#104: | ||
1972 | |||
1973 | # qhasm: h1 += r0x1 | ||
1974 | # asm 1: faddp <r0x1=float80#1,<h1=float80#2 | ||
1975 | # asm 2: faddp <r0x1=%st(0),<h1=%st(1) | ||
1976 | faddp %st(0),%st(1) | ||
1977 | # comment:fpstackfrombottom:<x2#100:<h0#41:<x1#99:<x3#101:<h3#38:<h2#39:<h1#40: | ||
1978 | |||
1979 | # qhasm: sr3x1 = *(float64 *) &sr3 | ||
1980 | # asm 1: fldl <sr3=stack64#11 | ||
1981 | # asm 2: fldl <sr3=176(%esp) | ||
1982 | fldl 176(%esp) | ||
1983 | # comment:fpstackfrombottom:<x2#100:<h0#41:<x1#99:<x3#101:<h3#38:<h2#39:<h1#40:<sr3x1#105: | ||
1984 | |||
1985 | # qhasm: sr3x1 *= x1 | ||
1986 | # asm 1: fmulp <x1=float80#1,<sr3x1=float80#6 | ||
1987 | # asm 2: fmulp <x1=%st(0),<sr3x1=%st(5) | ||
1988 | fmulp %st(0),%st(5) | ||
1989 | # comment:fpstackfrombottom:<x2#100:<h0#41:<sr3x1#105:<x3#101:<h3#38:<h2#39:<h1#40: | ||
1990 | |||
1991 | # qhasm: internal stacktop sr3x1 | ||
1992 | # asm 1: fxch <sr3x1=float80#5 | ||
1993 | # asm 2: fxch <sr3x1=%st(4) | ||
1994 | fxch %st(4) | ||
1995 | |||
1996 | # qhasm: h0 += sr3x1 | ||
1997 | # asm 1: faddp <sr3x1=float80#1,<h0=float80#6 | ||
1998 | # asm 2: faddp <sr3x1=%st(0),<h0=%st(5) | ||
1999 | faddp %st(0),%st(5) | ||
2000 | # comment:fpstackfrombottom:<x2#100:<h0#41:<h1#40:<x3#101:<h3#38:<h2#39: | ||
2001 | |||
2002 | # qhasm: r1x2 = *(float64 *) &r1 | ||
2003 | # asm 1: fldl <r1=stack64#6 | ||
2004 | # asm 2: fldl <r1=136(%esp) | ||
2005 | fldl 136(%esp) | ||
2006 | # comment:fpstackfrombottom:<x2#100:<h0#41:<h1#40:<x3#101:<h3#38:<h2#39:<r1x2#106: | ||
2007 | |||
2008 | # qhasm: r1x2 *= x2 | ||
2009 | # asm 1: fmul <x2=float80#7,<r1x2=float80#1 | ||
2010 | # asm 2: fmul <x2=%st(6),<r1x2=%st(0) | ||
2011 | fmul %st(6),%st(0) | ||
2012 | # comment:fpstackfrombottom:<x2#100:<h0#41:<h1#40:<x3#101:<h3#38:<h2#39:<r1x2#106: | ||
2013 | |||
2014 | # qhasm: h3 += r1x2 | ||
2015 | # asm 1: faddp <r1x2=float80#1,<h3=float80#3 | ||
2016 | # asm 2: faddp <r1x2=%st(0),<h3=%st(2) | ||
2017 | faddp %st(0),%st(2) | ||
2018 | # comment:fpstackfrombottom:<x2#100:<h0#41:<h1#40:<x3#101:<h3#38:<h2#39: | ||
2019 | |||
2020 | # qhasm: r0x2 = *(float64 *) &r0 | ||
2021 | # asm 1: fldl <r0=stack64#5 | ||
2022 | # asm 2: fldl <r0=128(%esp) | ||
2023 | fldl 128(%esp) | ||
2024 | # comment:fpstackfrombottom:<x2#100:<h0#41:<h1#40:<x3#101:<h3#38:<h2#39:<r0x2#107: | ||
2025 | |||
2026 | # qhasm: r0x2 *= x2 | ||
2027 | # asm 1: fmul <x2=float80#7,<r0x2=float80#1 | ||
2028 | # asm 2: fmul <x2=%st(6),<r0x2=%st(0) | ||
2029 | fmul %st(6),%st(0) | ||
2030 | # comment:fpstackfrombottom:<x2#100:<h0#41:<h1#40:<x3#101:<h3#38:<h2#39:<r0x2#107: | ||
2031 | |||
2032 | # qhasm: h2 += r0x2 | ||
2033 | # asm 1: faddp <r0x2=float80#1,<h2=float80#2 | ||
2034 | # asm 2: faddp <r0x2=%st(0),<h2=%st(1) | ||
2035 | faddp %st(0),%st(1) | ||
2036 | # comment:fpstackfrombottom:<x2#100:<h0#41:<h1#40:<x3#101:<h3#38:<h2#39: | ||
2037 | |||
2038 | # qhasm: sr3x2 = *(float64 *) &sr3 | ||
2039 | # asm 1: fldl <sr3=stack64#11 | ||
2040 | # asm 2: fldl <sr3=176(%esp) | ||
2041 | fldl 176(%esp) | ||
2042 | # comment:fpstackfrombottom:<x2#100:<h0#41:<h1#40:<x3#101:<h3#38:<h2#39:<sr3x2#108: | ||
2043 | |||
2044 | # qhasm: sr3x2 *= x2 | ||
2045 | # asm 1: fmul <x2=float80#7,<sr3x2=float80#1 | ||
2046 | # asm 2: fmul <x2=%st(6),<sr3x2=%st(0) | ||
2047 | fmul %st(6),%st(0) | ||
2048 | # comment:fpstackfrombottom:<x2#100:<h0#41:<h1#40:<x3#101:<h3#38:<h2#39:<sr3x2#108: | ||
2049 | |||
2050 | # qhasm: h1 += sr3x2 | ||
2051 | # asm 1: faddp <sr3x2=float80#1,<h1=float80#5 | ||
2052 | # asm 2: faddp <sr3x2=%st(0),<h1=%st(4) | ||
2053 | faddp %st(0),%st(4) | ||
2054 | # comment:fpstackfrombottom:<x2#100:<h0#41:<h1#40:<x3#101:<h3#38:<h2#39: | ||
2055 | |||
2056 | # qhasm: sr2x2 = *(float64 *) &sr2 | ||
2057 | # asm 1: fldl <sr2=stack64#9 | ||
2058 | # asm 2: fldl <sr2=160(%esp) | ||
2059 | fldl 160(%esp) | ||
2060 | # comment:fpstackfrombottom:<x2#100:<h0#41:<h1#40:<x3#101:<h3#38:<h2#39:<sr2x2#109: | ||
2061 | |||
2062 | # qhasm: sr2x2 *= x2 | ||
2063 | # asm 1: fmulp <x2=float80#1,<sr2x2=float80#7 | ||
2064 | # asm 2: fmulp <x2=%st(0),<sr2x2=%st(6) | ||
2065 | fmulp %st(0),%st(6) | ||
2066 | # comment:fpstackfrombottom:<sr2x2#109:<h0#41:<h1#40:<x3#101:<h3#38:<h2#39: | ||
2067 | |||
2068 | # qhasm: internal stacktop sr2x2 | ||
2069 | # asm 1: fxch <sr2x2=float80#6 | ||
2070 | # asm 2: fxch <sr2x2=%st(5) | ||
2071 | fxch %st(5) | ||
2072 | |||
2073 | # qhasm: h0 += sr2x2 | ||
2074 | # asm 1: faddp <sr2x2=float80#1,<h0=float80#5 | ||
2075 | # asm 2: faddp <sr2x2=%st(0),<h0=%st(4) | ||
2076 | faddp %st(0),%st(4) | ||
2077 | # comment:fpstackfrombottom:<h2#39:<h0#41:<h1#40:<x3#101:<h3#38: | ||
2078 | |||
2079 | # qhasm: r0x3 = *(float64 *) &r0 | ||
2080 | # asm 1: fldl <r0=stack64#5 | ||
2081 | # asm 2: fldl <r0=128(%esp) | ||
2082 | fldl 128(%esp) | ||
2083 | # comment:fpstackfrombottom:<h2#39:<h0#41:<h1#40:<x3#101:<h3#38:<r0x3#110: | ||
2084 | |||
2085 | # qhasm: r0x3 *= x3 | ||
2086 | # asm 1: fmul <x3=float80#3,<r0x3=float80#1 | ||
2087 | # asm 2: fmul <x3=%st(2),<r0x3=%st(0) | ||
2088 | fmul %st(2),%st(0) | ||
2089 | # comment:fpstackfrombottom:<h2#39:<h0#41:<h1#40:<x3#101:<h3#38:<r0x3#110: | ||
2090 | |||
2091 | # qhasm: h3 += r0x3 | ||
2092 | # asm 1: faddp <r0x3=float80#1,<h3=float80#2 | ||
2093 | # asm 2: faddp <r0x3=%st(0),<h3=%st(1) | ||
2094 | faddp %st(0),%st(1) | ||
2095 | # comment:fpstackfrombottom:<h2#39:<h0#41:<h1#40:<x3#101:<h3#38: | ||
2096 | |||
2097 | # qhasm: sr3x3 = *(float64 *) &sr3 | ||
2098 | # asm 1: fldl <sr3=stack64#11 | ||
2099 | # asm 2: fldl <sr3=176(%esp) | ||
2100 | fldl 176(%esp) | ||
2101 | # comment:fpstackfrombottom:<h2#39:<h0#41:<h1#40:<x3#101:<h3#38:<sr3x3#111: | ||
2102 | |||
2103 | # qhasm: sr3x3 *= x3 | ||
2104 | # asm 1: fmul <x3=float80#3,<sr3x3=float80#1 | ||
2105 | # asm 2: fmul <x3=%st(2),<sr3x3=%st(0) | ||
2106 | fmul %st(2),%st(0) | ||
2107 | # comment:fpstackfrombottom:<h2#39:<h0#41:<h1#40:<x3#101:<h3#38:<sr3x3#111: | ||
2108 | |||
2109 | # qhasm: h2 += sr3x3 | ||
2110 | # asm 1: faddp <sr3x3=float80#1,<h2=float80#6 | ||
2111 | # asm 2: faddp <sr3x3=%st(0),<h2=%st(5) | ||
2112 | faddp %st(0),%st(5) | ||
2113 | # comment:fpstackfrombottom:<h2#39:<h0#41:<h1#40:<x3#101:<h3#38: | ||
2114 | |||
2115 | # qhasm: sr2x3 = *(float64 *) &sr2 | ||
2116 | # asm 1: fldl <sr2=stack64#9 | ||
2117 | # asm 2: fldl <sr2=160(%esp) | ||
2118 | fldl 160(%esp) | ||
2119 | # comment:fpstackfrombottom:<h2#39:<h0#41:<h1#40:<x3#101:<h3#38:<sr2x3#112: | ||
2120 | |||
2121 | # qhasm: sr2x3 *= x3 | ||
2122 | # asm 1: fmul <x3=float80#3,<sr2x3=float80#1 | ||
2123 | # asm 2: fmul <x3=%st(2),<sr2x3=%st(0) | ||
2124 | fmul %st(2),%st(0) | ||
2125 | # comment:fpstackfrombottom:<h2#39:<h0#41:<h1#40:<x3#101:<h3#38:<sr2x3#112: | ||
2126 | |||
2127 | # qhasm: h1 += sr2x3 | ||
2128 | # asm 1: faddp <sr2x3=float80#1,<h1=float80#4 | ||
2129 | # asm 2: faddp <sr2x3=%st(0),<h1=%st(3) | ||
2130 | faddp %st(0),%st(3) | ||
2131 | # comment:fpstackfrombottom:<h2#39:<h0#41:<h1#40:<x3#101:<h3#38: | ||
2132 | |||
2133 | # qhasm: sr1x3 = *(float64 *) &sr1 | ||
2134 | # asm 1: fldl <sr1=stack64#7 | ||
2135 | # asm 2: fldl <sr1=144(%esp) | ||
2136 | fldl 144(%esp) | ||
2137 | # comment:fpstackfrombottom:<h2#39:<h0#41:<h1#40:<x3#101:<h3#38:<sr1x3#113: | ||
2138 | |||
2139 | # qhasm: sr1x3 *= x3 | ||
2140 | # asm 1: fmulp <x3=float80#1,<sr1x3=float80#3 | ||
2141 | # asm 2: fmulp <x3=%st(0),<sr1x3=%st(2) | ||
2142 | fmulp %st(0),%st(2) | ||
2143 | # comment:fpstackfrombottom:<h2#39:<h0#41:<h1#40:<sr1x3#113:<h3#38: | ||
2144 | |||
2145 | # qhasm: internal stacktop sr1x3 | ||
2146 | # asm 1: fxch <sr1x3=float80#2 | ||
2147 | # asm 2: fxch <sr1x3=%st(1) | ||
2148 | fxch %st(1) | ||
2149 | |||
2150 | # qhasm: h0 += sr1x3 | ||
2151 | # asm 1: faddp <sr1x3=float80#1,<h0=float80#4 | ||
2152 | # asm 2: faddp <sr1x3=%st(0),<h0=%st(3) | ||
2153 | faddp %st(0),%st(3) | ||
2154 | # comment:fpstackfrombottom:<h2#39:<h0#41:<h1#40:<h3#38: | ||
2155 | # comment:automatically reorganizing fp stack for fallthrough | ||
2156 | |||
2157 | # qhasm: internal stacktop h2 | ||
2158 | # asm 1: fxch <h2=float80#4 | ||
2159 | # asm 2: fxch <h2=%st(3) | ||
2160 | fxch %st(3) | ||
2161 | # comment:fpstackfrombottom:<h3#38:<h0#41:<h1#40:<h2#39: | ||
2162 | |||
2163 | # qhasm: internal stacktop h0 | ||
2164 | # asm 1: fxch <h0=float80#3 | ||
2165 | # asm 2: fxch <h0=%st(2) | ||
2166 | fxch %st(2) | ||
2167 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
2168 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
2169 | |||
2170 | # qhasm: nomorebytes: | ||
2171 | ._nomorebytes: | ||
2172 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41: | ||
2173 | |||
2174 | # qhasm: x0 = *(float64 *) &crypto_onetimeauth_poly1305_x86_alpha130 | ||
2175 | fldl crypto_onetimeauth_poly1305_x86_alpha130 | ||
2176 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41:<x0#114: | ||
2177 | |||
2178 | # qhasm: x0 += h3 | ||
2179 | # asm 1: fadd <h3=float80#5,<x0=float80#1 | ||
2180 | # asm 2: fadd <h3=%st(4),<x0=%st(0) | ||
2181 | fadd %st(4),%st(0) | ||
2182 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41:<x0#114: | ||
2183 | |||
2184 | # qhasm: x0 -= *(float64 *) &crypto_onetimeauth_poly1305_x86_alpha130 | ||
2185 | fsubl crypto_onetimeauth_poly1305_x86_alpha130 | ||
2186 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41:<x0#114: | ||
2187 | |||
2188 | # qhasm: h3 -= x0 | ||
2189 | # asm 1: fsubr <x0=float80#1,<h3=float80#5 | ||
2190 | # asm 2: fsubr <x0=%st(0),<h3=%st(4) | ||
2191 | fsubr %st(0),%st(4) | ||
2192 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41:<x0#114: | ||
2193 | |||
2194 | # qhasm: x0 *= *(float64 *) &crypto_onetimeauth_poly1305_x86_scale | ||
2195 | fmull crypto_onetimeauth_poly1305_x86_scale | ||
2196 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41:<x0#114: | ||
2197 | |||
2198 | # qhasm: x1 = *(float64 *) &crypto_onetimeauth_poly1305_x86_alpha32 | ||
2199 | fldl crypto_onetimeauth_poly1305_x86_alpha32 | ||
2200 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41:<x0#114:<x1#115: | ||
2201 | |||
2202 | # qhasm: x1 += h0 | ||
2203 | # asm 1: fadd <h0=float80#3,<x1=float80#1 | ||
2204 | # asm 2: fadd <h0=%st(2),<x1=%st(0) | ||
2205 | fadd %st(2),%st(0) | ||
2206 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41:<x0#114:<x1#115: | ||
2207 | |||
2208 | # qhasm: x1 -= *(float64 *) &crypto_onetimeauth_poly1305_x86_alpha32 | ||
2209 | fsubl crypto_onetimeauth_poly1305_x86_alpha32 | ||
2210 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41:<x0#114:<x1#115: | ||
2211 | |||
2212 | # qhasm: h0 -= x1 | ||
2213 | # asm 1: fsubr <x1=float80#1,<h0=float80#3 | ||
2214 | # asm 2: fsubr <x1=%st(0),<h0=%st(2) | ||
2215 | fsubr %st(0),%st(2) | ||
2216 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41:<x0#114:<x1#115: | ||
2217 | |||
2218 | # qhasm: x2 = *(float64 *) &crypto_onetimeauth_poly1305_x86_alpha64 | ||
2219 | fldl crypto_onetimeauth_poly1305_x86_alpha64 | ||
2220 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41:<x0#114:<x1#115:<x2#116: | ||
2221 | |||
2222 | # qhasm: x2 += h1 | ||
2223 | # asm 1: fadd <h1=float80#5,<x2=float80#1 | ||
2224 | # asm 2: fadd <h1=%st(4),<x2=%st(0) | ||
2225 | fadd %st(4),%st(0) | ||
2226 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41:<x0#114:<x1#115:<x2#116: | ||
2227 | |||
2228 | # qhasm: x2 -= *(float64 *) &crypto_onetimeauth_poly1305_x86_alpha64 | ||
2229 | fsubl crypto_onetimeauth_poly1305_x86_alpha64 | ||
2230 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41:<x0#114:<x1#115:<x2#116: | ||
2231 | |||
2232 | # qhasm: h1 -= x2 | ||
2233 | # asm 1: fsubr <x2=float80#1,<h1=float80#5 | ||
2234 | # asm 2: fsubr <x2=%st(0),<h1=%st(4) | ||
2235 | fsubr %st(0),%st(4) | ||
2236 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41:<x0#114:<x1#115:<x2#116: | ||
2237 | |||
2238 | # qhasm: x3 = *(float64 *) &crypto_onetimeauth_poly1305_x86_alpha96 | ||
2239 | fldl crypto_onetimeauth_poly1305_x86_alpha96 | ||
2240 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41:<x0#114:<x1#115:<x2#116:<x3#117: | ||
2241 | |||
2242 | # qhasm: x3 += h2 | ||
2243 | # asm 1: fadd <h2=float80#7,<x3=float80#1 | ||
2244 | # asm 2: fadd <h2=%st(6),<x3=%st(0) | ||
2245 | fadd %st(6),%st(0) | ||
2246 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41:<x0#114:<x1#115:<x2#116:<x3#117: | ||
2247 | |||
2248 | # qhasm: x3 -= *(float64 *) &crypto_onetimeauth_poly1305_x86_alpha96 | ||
2249 | fsubl crypto_onetimeauth_poly1305_x86_alpha96 | ||
2250 | # comment:fpstackfrombottom:<h3#38:<h2#39:<h1#40:<h0#41:<x0#114:<x1#115:<x2#116:<x3#117: | ||
2251 | |||
2252 | # qhasm: stacktop h2 | ||
2253 | # asm 1: fxch <h2=float80#7 | ||
2254 | # asm 2: fxch <h2=%st(6) | ||
2255 | fxch %st(6) | ||
2256 | # comment:fpstackfrombottom:<h3#38:<x3#117:<h1#40:<h0#41:<x0#114:<x1#115:<x2#116:<h2#39: | ||
2257 | |||
2258 | # qhasm: h2 -= x3 | ||
2259 | # asm 1: fsub <x3=float80#7,<h2=float80#1 | ||
2260 | # asm 2: fsub <x3=%st(6),<h2=%st(0) | ||
2261 | fsub %st(6),%st(0) | ||
2262 | # comment:fpstackfrombottom:<h3#38:<x3#117:<h1#40:<h0#41:<x0#114:<x1#115:<x2#116:<h2#39: | ||
2263 | |||
2264 | # qhasm: internal stacktop h0 | ||
2265 | # asm 1: fxch <h0=float80#5 | ||
2266 | # asm 2: fxch <h0=%st(4) | ||
2267 | fxch %st(4) | ||
2268 | |||
2269 | # qhasm: x0 += h0 | ||
2270 | # asm 1: faddp <h0=float80#1,<x0=float80#4 | ||
2271 | # asm 2: faddp <h0=%st(0),<x0=%st(3) | ||
2272 | faddp %st(0),%st(3) | ||
2273 | # comment:fpstackfrombottom:<h3#38:<x3#117:<h1#40:<h2#39:<x0#114:<x1#115:<x2#116: | ||
2274 | |||
2275 | # qhasm: internal stacktop h1 | ||
2276 | # asm 1: fxch <h1=float80#5 | ||
2277 | # asm 2: fxch <h1=%st(4) | ||
2278 | fxch %st(4) | ||
2279 | |||
2280 | # qhasm: x1 += h1 | ||
2281 | # asm 1: faddp <h1=float80#1,<x1=float80#2 | ||
2282 | # asm 2: faddp <h1=%st(0),<x1=%st(1) | ||
2283 | faddp %st(0),%st(1) | ||
2284 | # comment:fpstackfrombottom:<h3#38:<x3#117:<x2#116:<h2#39:<x0#114:<x1#115: | ||
2285 | |||
2286 | # qhasm: internal stacktop h2 | ||
2287 | # asm 1: fxch <h2=float80#3 | ||
2288 | # asm 2: fxch <h2=%st(2) | ||
2289 | fxch %st(2) | ||
2290 | |||
2291 | # qhasm: x2 += h2 | ||
2292 | # asm 1: faddp <h2=float80#1,<x2=float80#4 | ||
2293 | # asm 2: faddp <h2=%st(0),<x2=%st(3) | ||
2294 | faddp %st(0),%st(3) | ||
2295 | # comment:fpstackfrombottom:<h3#38:<x3#117:<x2#116:<x1#115:<x0#114: | ||
2296 | |||
2297 | # qhasm: internal stacktop h3 | ||
2298 | # asm 1: fxch <h3=float80#5 | ||
2299 | # asm 2: fxch <h3=%st(4) | ||
2300 | fxch %st(4) | ||
2301 | |||
2302 | # qhasm: x3 += h3 | ||
2303 | # asm 1: faddp <h3=float80#1,<x3=float80#4 | ||
2304 | # asm 2: faddp <h3=%st(0),<x3=%st(3) | ||
2305 | faddp %st(0),%st(3) | ||
2306 | # comment:fpstackfrombottom:<x0#114:<x3#117:<x2#116:<x1#115: | ||
2307 | |||
2308 | # qhasm: internal stacktop x0 | ||
2309 | # asm 1: fxch <x0=float80#4 | ||
2310 | # asm 2: fxch <x0=%st(3) | ||
2311 | fxch %st(3) | ||
2312 | |||
2313 | # qhasm: x0 += *(float64 *) &crypto_onetimeauth_poly1305_x86_hoffset0 | ||
2314 | faddl crypto_onetimeauth_poly1305_x86_hoffset0 | ||
2315 | # comment:fpstackfrombottom:<x1#115:<x3#117:<x2#116:<x0#114: | ||
2316 | |||
2317 | # qhasm: internal stacktop x1 | ||
2318 | # asm 1: fxch <x1=float80#4 | ||
2319 | # asm 2: fxch <x1=%st(3) | ||
2320 | fxch %st(3) | ||
2321 | |||
2322 | # qhasm: x1 += *(float64 *) &crypto_onetimeauth_poly1305_x86_hoffset1 | ||
2323 | faddl crypto_onetimeauth_poly1305_x86_hoffset1 | ||
2324 | # comment:fpstackfrombottom:<x0#114:<x3#117:<x2#116:<x1#115: | ||
2325 | |||
2326 | # qhasm: internal stacktop x2 | ||
2327 | # asm 1: fxch <x2=float80#2 | ||
2328 | # asm 2: fxch <x2=%st(1) | ||
2329 | fxch %st(1) | ||
2330 | |||
2331 | # qhasm: x2 += *(float64 *) &crypto_onetimeauth_poly1305_x86_hoffset2 | ||
2332 | faddl crypto_onetimeauth_poly1305_x86_hoffset2 | ||
2333 | # comment:fpstackfrombottom:<x0#114:<x3#117:<x1#115:<x2#116: | ||
2334 | |||
2335 | # qhasm: internal stacktop x3 | ||
2336 | # asm 1: fxch <x3=float80#3 | ||
2337 | # asm 2: fxch <x3=%st(2) | ||
2338 | fxch %st(2) | ||
2339 | |||
2340 | # qhasm: x3 += *(float64 *) &crypto_onetimeauth_poly1305_x86_hoffset3 | ||
2341 | faddl crypto_onetimeauth_poly1305_x86_hoffset3 | ||
2342 | # comment:fpstackfrombottom:<x0#114:<x2#116:<x1#115:<x3#117: | ||
2343 | |||
2344 | # qhasm: internal stacktop x0 | ||
2345 | # asm 1: fxch <x0=float80#4 | ||
2346 | # asm 2: fxch <x0=%st(3) | ||
2347 | fxch %st(3) | ||
2348 | |||
2349 | # qhasm: *(float64 *) &d0 = x0 | ||
2350 | # asm 1: fstpl >d0=stack64#1 | ||
2351 | # asm 2: fstpl >d0=96(%esp) | ||
2352 | fstpl 96(%esp) | ||
2353 | # comment:fpstackfrombottom:<x3#117:<x2#116:<x1#115: | ||
2354 | |||
2355 | # qhasm: *(float64 *) &d1 = x1 | ||
2356 | # asm 1: fstpl >d1=stack64#2 | ||
2357 | # asm 2: fstpl >d1=104(%esp) | ||
2358 | fstpl 104(%esp) | ||
2359 | # comment:fpstackfrombottom:<x3#117:<x2#116: | ||
2360 | |||
2361 | # qhasm: *(float64 *) &d2 = x2 | ||
2362 | # asm 1: fstpl >d2=stack64#3 | ||
2363 | # asm 2: fstpl >d2=112(%esp) | ||
2364 | fstpl 112(%esp) | ||
2365 | # comment:fpstackfrombottom:<x3#117: | ||
2366 | |||
2367 | # qhasm: *(float64 *) &d3 = x3 | ||
2368 | # asm 1: fstpl >d3=stack64#4 | ||
2369 | # asm 2: fstpl >d3=120(%esp) | ||
2370 | fstpl 120(%esp) | ||
2371 | # comment:fpstackfrombottom: | ||
2372 | |||
2373 | # qhasm: int32 f0 | ||
2374 | |||
2375 | # qhasm: int32 f1 | ||
2376 | |||
2377 | # qhasm: int32 f2 | ||
2378 | |||
2379 | # qhasm: int32 f3 | ||
2380 | |||
2381 | # qhasm: int32 f4 | ||
2382 | |||
2383 | # qhasm: int32 g0 | ||
2384 | |||
2385 | # qhasm: int32 g1 | ||
2386 | |||
2387 | # qhasm: int32 g2 | ||
2388 | |||
2389 | # qhasm: int32 g3 | ||
2390 | |||
2391 | # qhasm: int32 f | ||
2392 | |||
2393 | # qhasm: int32 notf | ||
2394 | |||
2395 | # qhasm: stack32 f1_stack | ||
2396 | |||
2397 | # qhasm: stack32 f2_stack | ||
2398 | |||
2399 | # qhasm: stack32 f3_stack | ||
2400 | |||
2401 | # qhasm: stack32 f4_stack | ||
2402 | |||
2403 | # qhasm: stack32 g0_stack | ||
2404 | |||
2405 | # qhasm: stack32 g1_stack | ||
2406 | |||
2407 | # qhasm: stack32 g2_stack | ||
2408 | |||
2409 | # qhasm: stack32 g3_stack | ||
2410 | |||
2411 | # qhasm: g0 = top d0 | ||
2412 | # asm 1: movl <d0=stack64#1,>g0=int32#1 | ||
2413 | # asm 2: movl <d0=100(%esp),>g0=%eax | ||
2414 | movl 100(%esp),%eax | ||
2415 | |||
2416 | # qhasm: g0 &= 63 | ||
2417 | # asm 1: and $63,<g0=int32#1 | ||
2418 | # asm 2: and $63,<g0=%eax | ||
2419 | and $63,%eax | ||
2420 | |||
2421 | # qhasm: g1 = top d1 | ||
2422 | # asm 1: movl <d1=stack64#2,>g1=int32#2 | ||
2423 | # asm 2: movl <d1=108(%esp),>g1=%ecx | ||
2424 | movl 108(%esp),%ecx | ||
2425 | |||
2426 | # qhasm: g1 &= 63 | ||
2427 | # asm 1: and $63,<g1=int32#2 | ||
2428 | # asm 2: and $63,<g1=%ecx | ||
2429 | and $63,%ecx | ||
2430 | |||
2431 | # qhasm: g2 = top d2 | ||
2432 | # asm 1: movl <d2=stack64#3,>g2=int32#3 | ||
2433 | # asm 2: movl <d2=116(%esp),>g2=%edx | ||
2434 | movl 116(%esp),%edx | ||
2435 | |||
2436 | # qhasm: g2 &= 63 | ||
2437 | # asm 1: and $63,<g2=int32#3 | ||
2438 | # asm 2: and $63,<g2=%edx | ||
2439 | and $63,%edx | ||
2440 | |||
2441 | # qhasm: g3 = top d3 | ||
2442 | # asm 1: movl <d3=stack64#4,>g3=int32#4 | ||
2443 | # asm 2: movl <d3=124(%esp),>g3=%ebx | ||
2444 | movl 124(%esp),%ebx | ||
2445 | |||
2446 | # qhasm: g3 &= 63 | ||
2447 | # asm 1: and $63,<g3=int32#4 | ||
2448 | # asm 2: and $63,<g3=%ebx | ||
2449 | and $63,%ebx | ||
2450 | |||
2451 | # qhasm: f1 = bottom d1 | ||
2452 | # asm 1: movl <d1=stack64#2,>f1=int32#5 | ||
2453 | # asm 2: movl <d1=104(%esp),>f1=%esi | ||
2454 | movl 104(%esp),%esi | ||
2455 | |||
2456 | # qhasm: carry? f1 += g0 | ||
2457 | # asm 1: addl <g0=int32#1,<f1=int32#5 | ||
2458 | # asm 2: addl <g0=%eax,<f1=%esi | ||
2459 | addl %eax,%esi | ||
2460 | |||
2461 | # qhasm: f1_stack = f1 | ||
2462 | # asm 1: movl <f1=int32#5,>f1_stack=stack32#8 | ||
2463 | # asm 2: movl <f1=%esi,>f1_stack=28(%esp) | ||
2464 | movl %esi,28(%esp) | ||
2465 | |||
2466 | # qhasm: f2 = bottom d2 | ||
2467 | # asm 1: movl <d2=stack64#3,>f2=int32#1 | ||
2468 | # asm 2: movl <d2=112(%esp),>f2=%eax | ||
2469 | movl 112(%esp),%eax | ||
2470 | |||
2471 | # qhasm: carry? f2 += g1 + carry | ||
2472 | # asm 1: adcl <g1=int32#2,<f2=int32#1 | ||
2473 | # asm 2: adcl <g1=%ecx,<f2=%eax | ||
2474 | adcl %ecx,%eax | ||
2475 | |||
2476 | # qhasm: f2_stack = f2 | ||
2477 | # asm 1: movl <f2=int32#1,>f2_stack=stack32#9 | ||
2478 | # asm 2: movl <f2=%eax,>f2_stack=32(%esp) | ||
2479 | movl %eax,32(%esp) | ||
2480 | |||
2481 | # qhasm: f3 = bottom d3 | ||
2482 | # asm 1: movl <d3=stack64#4,>f3=int32#1 | ||
2483 | # asm 2: movl <d3=120(%esp),>f3=%eax | ||
2484 | movl 120(%esp),%eax | ||
2485 | |||
2486 | # qhasm: carry? f3 += g2 + carry | ||
2487 | # asm 1: adcl <g2=int32#3,<f3=int32#1 | ||
2488 | # asm 2: adcl <g2=%edx,<f3=%eax | ||
2489 | adcl %edx,%eax | ||
2490 | |||
2491 | # qhasm: f3_stack = f3 | ||
2492 | # asm 1: movl <f3=int32#1,>f3_stack=stack32#10 | ||
2493 | # asm 2: movl <f3=%eax,>f3_stack=36(%esp) | ||
2494 | movl %eax,36(%esp) | ||
2495 | |||
2496 | # qhasm: f4 = 0 | ||
2497 | # asm 1: mov $0,>f4=int32#1 | ||
2498 | # asm 2: mov $0,>f4=%eax | ||
2499 | mov $0,%eax | ||
2500 | |||
2501 | # qhasm: carry? f4 += g3 + carry | ||
2502 | # asm 1: adcl <g3=int32#4,<f4=int32#1 | ||
2503 | # asm 2: adcl <g3=%ebx,<f4=%eax | ||
2504 | adcl %ebx,%eax | ||
2505 | |||
2506 | # qhasm: f4_stack = f4 | ||
2507 | # asm 1: movl <f4=int32#1,>f4_stack=stack32#11 | ||
2508 | # asm 2: movl <f4=%eax,>f4_stack=40(%esp) | ||
2509 | movl %eax,40(%esp) | ||
2510 | |||
2511 | # qhasm: g0 = 5 | ||
2512 | # asm 1: mov $5,>g0=int32#1 | ||
2513 | # asm 2: mov $5,>g0=%eax | ||
2514 | mov $5,%eax | ||
2515 | |||
2516 | # qhasm: f0 = bottom d0 | ||
2517 | # asm 1: movl <d0=stack64#1,>f0=int32#2 | ||
2518 | # asm 2: movl <d0=96(%esp),>f0=%ecx | ||
2519 | movl 96(%esp),%ecx | ||
2520 | |||
2521 | # qhasm: carry? g0 += f0 | ||
2522 | # asm 1: addl <f0=int32#2,<g0=int32#1 | ||
2523 | # asm 2: addl <f0=%ecx,<g0=%eax | ||
2524 | addl %ecx,%eax | ||
2525 | |||
2526 | # qhasm: g0_stack = g0 | ||
2527 | # asm 1: movl <g0=int32#1,>g0_stack=stack32#12 | ||
2528 | # asm 2: movl <g0=%eax,>g0_stack=44(%esp) | ||
2529 | movl %eax,44(%esp) | ||
2530 | |||
2531 | # qhasm: g1 = 0 | ||
2532 | # asm 1: mov $0,>g1=int32#1 | ||
2533 | # asm 2: mov $0,>g1=%eax | ||
2534 | mov $0,%eax | ||
2535 | |||
2536 | # qhasm: f1 = f1_stack | ||
2537 | # asm 1: movl <f1_stack=stack32#8,>f1=int32#3 | ||
2538 | # asm 2: movl <f1_stack=28(%esp),>f1=%edx | ||
2539 | movl 28(%esp),%edx | ||
2540 | |||
2541 | # qhasm: carry? g1 += f1 + carry | ||
2542 | # asm 1: adcl <f1=int32#3,<g1=int32#1 | ||
2543 | # asm 2: adcl <f1=%edx,<g1=%eax | ||
2544 | adcl %edx,%eax | ||
2545 | |||
2546 | # qhasm: g1_stack = g1 | ||
2547 | # asm 1: movl <g1=int32#1,>g1_stack=stack32#8 | ||
2548 | # asm 2: movl <g1=%eax,>g1_stack=28(%esp) | ||
2549 | movl %eax,28(%esp) | ||
2550 | |||
2551 | # qhasm: g2 = 0 | ||
2552 | # asm 1: mov $0,>g2=int32#1 | ||
2553 | # asm 2: mov $0,>g2=%eax | ||
2554 | mov $0,%eax | ||
2555 | |||
2556 | # qhasm: f2 = f2_stack | ||
2557 | # asm 1: movl <f2_stack=stack32#9,>f2=int32#4 | ||
2558 | # asm 2: movl <f2_stack=32(%esp),>f2=%ebx | ||
2559 | movl 32(%esp),%ebx | ||
2560 | |||
2561 | # qhasm: carry? g2 += f2 + carry | ||
2562 | # asm 1: adcl <f2=int32#4,<g2=int32#1 | ||
2563 | # asm 2: adcl <f2=%ebx,<g2=%eax | ||
2564 | adcl %ebx,%eax | ||
2565 | |||
2566 | # qhasm: g2_stack = g2 | ||
2567 | # asm 1: movl <g2=int32#1,>g2_stack=stack32#9 | ||
2568 | # asm 2: movl <g2=%eax,>g2_stack=32(%esp) | ||
2569 | movl %eax,32(%esp) | ||
2570 | |||
2571 | # qhasm: g3 = 0 | ||
2572 | # asm 1: mov $0,>g3=int32#1 | ||
2573 | # asm 2: mov $0,>g3=%eax | ||
2574 | mov $0,%eax | ||
2575 | |||
2576 | # qhasm: f3 = f3_stack | ||
2577 | # asm 1: movl <f3_stack=stack32#10,>f3=int32#5 | ||
2578 | # asm 2: movl <f3_stack=36(%esp),>f3=%esi | ||
2579 | movl 36(%esp),%esi | ||
2580 | |||
2581 | # qhasm: carry? g3 += f3 + carry | ||
2582 | # asm 1: adcl <f3=int32#5,<g3=int32#1 | ||
2583 | # asm 2: adcl <f3=%esi,<g3=%eax | ||
2584 | adcl %esi,%eax | ||
2585 | |||
2586 | # qhasm: g3_stack = g3 | ||
2587 | # asm 1: movl <g3=int32#1,>g3_stack=stack32#10 | ||
2588 | # asm 2: movl <g3=%eax,>g3_stack=36(%esp) | ||
2589 | movl %eax,36(%esp) | ||
2590 | |||
2591 | # qhasm: f = 0xfffffffc | ||
2592 | # asm 1: mov $0xfffffffc,>f=int32#1 | ||
2593 | # asm 2: mov $0xfffffffc,>f=%eax | ||
2594 | mov $0xfffffffc,%eax | ||
2595 | |||
2596 | # qhasm: f4 = f4_stack | ||
2597 | # asm 1: movl <f4_stack=stack32#11,>f4=int32#6 | ||
2598 | # asm 2: movl <f4_stack=40(%esp),>f4=%edi | ||
2599 | movl 40(%esp),%edi | ||
2600 | |||
2601 | # qhasm: carry? f += f4 + carry | ||
2602 | # asm 1: adcl <f4=int32#6,<f=int32#1 | ||
2603 | # asm 2: adcl <f4=%edi,<f=%eax | ||
2604 | adcl %edi,%eax | ||
2605 | |||
2606 | # qhasm: (int32) f >>= 16 | ||
2607 | # asm 1: sar $16,<f=int32#1 | ||
2608 | # asm 2: sar $16,<f=%eax | ||
2609 | sar $16,%eax | ||
2610 | |||
2611 | # qhasm: notf = f | ||
2612 | # asm 1: mov <f=int32#1,>notf=int32#6 | ||
2613 | # asm 2: mov <f=%eax,>notf=%edi | ||
2614 | mov %eax,%edi | ||
2615 | |||
2616 | # qhasm: notf ^= 0xffffffff | ||
2617 | # asm 1: xor $0xffffffff,<notf=int32#6 | ||
2618 | # asm 2: xor $0xffffffff,<notf=%edi | ||
2619 | xor $0xffffffff,%edi | ||
2620 | |||
2621 | # qhasm: f0 &= f | ||
2622 | # asm 1: andl <f=int32#1,<f0=int32#2 | ||
2623 | # asm 2: andl <f=%eax,<f0=%ecx | ||
2624 | andl %eax,%ecx | ||
2625 | |||
2626 | # qhasm: g0 = g0_stack | ||
2627 | # asm 1: movl <g0_stack=stack32#12,>g0=int32#7 | ||
2628 | # asm 2: movl <g0_stack=44(%esp),>g0=%ebp | ||
2629 | movl 44(%esp),%ebp | ||
2630 | |||
2631 | # qhasm: g0 &= notf | ||
2632 | # asm 1: andl <notf=int32#6,<g0=int32#7 | ||
2633 | # asm 2: andl <notf=%edi,<g0=%ebp | ||
2634 | andl %edi,%ebp | ||
2635 | |||
2636 | # qhasm: f0 |= g0 | ||
2637 | # asm 1: orl <g0=int32#7,<f0=int32#2 | ||
2638 | # asm 2: orl <g0=%ebp,<f0=%ecx | ||
2639 | orl %ebp,%ecx | ||
2640 | |||
2641 | # qhasm: f1 &= f | ||
2642 | # asm 1: andl <f=int32#1,<f1=int32#3 | ||
2643 | # asm 2: andl <f=%eax,<f1=%edx | ||
2644 | andl %eax,%edx | ||
2645 | |||
2646 | # qhasm: g1 = g1_stack | ||
2647 | # asm 1: movl <g1_stack=stack32#8,>g1=int32#7 | ||
2648 | # asm 2: movl <g1_stack=28(%esp),>g1=%ebp | ||
2649 | movl 28(%esp),%ebp | ||
2650 | |||
2651 | # qhasm: g1 &= notf | ||
2652 | # asm 1: andl <notf=int32#6,<g1=int32#7 | ||
2653 | # asm 2: andl <notf=%edi,<g1=%ebp | ||
2654 | andl %edi,%ebp | ||
2655 | |||
2656 | # qhasm: f1 |= g1 | ||
2657 | # asm 1: orl <g1=int32#7,<f1=int32#3 | ||
2658 | # asm 2: orl <g1=%ebp,<f1=%edx | ||
2659 | orl %ebp,%edx | ||
2660 | |||
2661 | # qhasm: f2 &= f | ||
2662 | # asm 1: andl <f=int32#1,<f2=int32#4 | ||
2663 | # asm 2: andl <f=%eax,<f2=%ebx | ||
2664 | andl %eax,%ebx | ||
2665 | |||
2666 | # qhasm: g2 = g2_stack | ||
2667 | # asm 1: movl <g2_stack=stack32#9,>g2=int32#7 | ||
2668 | # asm 2: movl <g2_stack=32(%esp),>g2=%ebp | ||
2669 | movl 32(%esp),%ebp | ||
2670 | |||
2671 | # qhasm: g2 &= notf | ||
2672 | # asm 1: andl <notf=int32#6,<g2=int32#7 | ||
2673 | # asm 2: andl <notf=%edi,<g2=%ebp | ||
2674 | andl %edi,%ebp | ||
2675 | |||
2676 | # qhasm: f2 |= g2 | ||
2677 | # asm 1: orl <g2=int32#7,<f2=int32#4 | ||
2678 | # asm 2: orl <g2=%ebp,<f2=%ebx | ||
2679 | orl %ebp,%ebx | ||
2680 | |||
2681 | # qhasm: f3 &= f | ||
2682 | # asm 1: andl <f=int32#1,<f3=int32#5 | ||
2683 | # asm 2: andl <f=%eax,<f3=%esi | ||
2684 | andl %eax,%esi | ||
2685 | |||
2686 | # qhasm: g3 = g3_stack | ||
2687 | # asm 1: movl <g3_stack=stack32#10,>g3=int32#1 | ||
2688 | # asm 2: movl <g3_stack=36(%esp),>g3=%eax | ||
2689 | movl 36(%esp),%eax | ||
2690 | |||
2691 | # qhasm: g3 &= notf | ||
2692 | # asm 1: andl <notf=int32#6,<g3=int32#1 | ||
2693 | # asm 2: andl <notf=%edi,<g3=%eax | ||
2694 | andl %edi,%eax | ||
2695 | |||
2696 | # qhasm: f3 |= g3 | ||
2697 | # asm 1: orl <g3=int32#1,<f3=int32#5 | ||
2698 | # asm 2: orl <g3=%eax,<f3=%esi | ||
2699 | orl %eax,%esi | ||
2700 | |||
2701 | # qhasm: k = k_stack | ||
2702 | # asm 1: movl <k_stack=stack32#6,>k=int32#1 | ||
2703 | # asm 2: movl <k_stack=20(%esp),>k=%eax | ||
2704 | movl 20(%esp),%eax | ||
2705 | |||
2706 | # qhasm: carry? f0 += *(uint32 *) (k + 16) | ||
2707 | # asm 1: addl 16(<k=int32#1),<f0=int32#2 | ||
2708 | # asm 2: addl 16(<k=%eax),<f0=%ecx | ||
2709 | addl 16(%eax),%ecx | ||
2710 | |||
2711 | # qhasm: carry? f1 += *(uint32 *) (k + 20) + carry | ||
2712 | # asm 1: adcl 20(<k=int32#1),<f1=int32#3 | ||
2713 | # asm 2: adcl 20(<k=%eax),<f1=%edx | ||
2714 | adcl 20(%eax),%edx | ||
2715 | |||
2716 | # qhasm: carry? f2 += *(uint32 *) (k + 24) + carry | ||
2717 | # asm 1: adcl 24(<k=int32#1),<f2=int32#4 | ||
2718 | # asm 2: adcl 24(<k=%eax),<f2=%ebx | ||
2719 | adcl 24(%eax),%ebx | ||
2720 | |||
2721 | # qhasm: carry? f3 += *(uint32 *) (k + 28) + carry | ||
2722 | # asm 1: adcl 28(<k=int32#1),<f3=int32#5 | ||
2723 | # asm 2: adcl 28(<k=%eax),<f3=%esi | ||
2724 | adcl 28(%eax),%esi | ||
2725 | |||
2726 | # qhasm: out = out_stack | ||
2727 | # asm 1: movl <out_stack=stack32#7,>out=int32#1 | ||
2728 | # asm 2: movl <out_stack=24(%esp),>out=%eax | ||
2729 | movl 24(%esp),%eax | ||
2730 | |||
2731 | # qhasm: *(uint32 *) (out + 0) = f0 | ||
2732 | # asm 1: movl <f0=int32#2,0(<out=int32#1) | ||
2733 | # asm 2: movl <f0=%ecx,0(<out=%eax) | ||
2734 | movl %ecx,0(%eax) | ||
2735 | |||
2736 | # qhasm: *(uint32 *) (out + 4) = f1 | ||
2737 | # asm 1: movl <f1=int32#3,4(<out=int32#1) | ||
2738 | # asm 2: movl <f1=%edx,4(<out=%eax) | ||
2739 | movl %edx,4(%eax) | ||
2740 | |||
2741 | # qhasm: *(uint32 *) (out + 8) = f2 | ||
2742 | # asm 1: movl <f2=int32#4,8(<out=int32#1) | ||
2743 | # asm 2: movl <f2=%ebx,8(<out=%eax) | ||
2744 | movl %ebx,8(%eax) | ||
2745 | |||
2746 | # qhasm: *(uint32 *) (out + 12) = f3 | ||
2747 | # asm 1: movl <f3=int32#5,12(<out=int32#1) | ||
2748 | # asm 2: movl <f3=%esi,12(<out=%eax) | ||
2749 | movl %esi,12(%eax) | ||
2750 | |||
2751 | # qhasm: eax = eax_stack | ||
2752 | # asm 1: movl <eax_stack=stack32#1,>eax=int32#1 | ||
2753 | # asm 2: movl <eax_stack=0(%esp),>eax=%eax | ||
2754 | movl 0(%esp),%eax | ||
2755 | |||
2756 | # qhasm: ebx = ebx_stack | ||
2757 | # asm 1: movl <ebx_stack=stack32#2,>ebx=int32#4 | ||
2758 | # asm 2: movl <ebx_stack=4(%esp),>ebx=%ebx | ||
2759 | movl 4(%esp),%ebx | ||
2760 | |||
2761 | # qhasm: esi = esi_stack | ||
2762 | # asm 1: movl <esi_stack=stack32#3,>esi=int32#5 | ||
2763 | # asm 2: movl <esi_stack=8(%esp),>esi=%esi | ||
2764 | movl 8(%esp),%esi | ||
2765 | |||
2766 | # qhasm: edi = edi_stack | ||
2767 | # asm 1: movl <edi_stack=stack32#4,>edi=int32#6 | ||
2768 | # asm 2: movl <edi_stack=12(%esp),>edi=%edi | ||
2769 | movl 12(%esp),%edi | ||
2770 | |||
2771 | # qhasm: ebp = ebp_stack | ||
2772 | # asm 1: movl <ebp_stack=stack32#5,>ebp=int32#7 | ||
2773 | # asm 2: movl <ebp_stack=16(%esp),>ebp=%ebp | ||
2774 | movl 16(%esp),%ebp | ||
2775 | |||
2776 | # qhasm: leave | ||
2777 | add %eax,%esp | ||
2778 | xor %eax,%eax | ||
2779 | ret | ||
diff --git a/nacl/crypto_onetimeauth/poly1305/x86/constants.s b/nacl/crypto_onetimeauth/poly1305/x86/constants.s deleted file mode 100644 index ab2456c3..00000000 --- a/nacl/crypto_onetimeauth/poly1305/x86/constants.s +++ /dev/null | |||
@@ -1,85 +0,0 @@ | |||
1 | # version 20080912 | ||
2 | # D. J. Bernstein | ||
3 | # Public domain. | ||
4 | |||
5 | .data | ||
6 | .section .rodata | ||
7 | .p2align 5 | ||
8 | |||
9 | .globl _crypto_onetimeauth_poly1305_x86_constants | ||
10 | .globl crypto_onetimeauth_poly1305_x86_constants | ||
11 | .globl crypto_onetimeauth_poly1305_x86_scale | ||
12 | .globl crypto_onetimeauth_poly1305_x86_two32 | ||
13 | .globl crypto_onetimeauth_poly1305_x86_two64 | ||
14 | .globl crypto_onetimeauth_poly1305_x86_two96 | ||
15 | .globl crypto_onetimeauth_poly1305_x86_alpha32 | ||
16 | .globl crypto_onetimeauth_poly1305_x86_alpha64 | ||
17 | .globl crypto_onetimeauth_poly1305_x86_alpha96 | ||
18 | .globl crypto_onetimeauth_poly1305_x86_alpha130 | ||
19 | .globl crypto_onetimeauth_poly1305_x86_doffset0 | ||
20 | .globl crypto_onetimeauth_poly1305_x86_doffset1 | ||
21 | .globl crypto_onetimeauth_poly1305_x86_doffset2 | ||
22 | .globl crypto_onetimeauth_poly1305_x86_doffset3 | ||
23 | .globl crypto_onetimeauth_poly1305_x86_doffset3minustwo128 | ||
24 | .globl crypto_onetimeauth_poly1305_x86_hoffset0 | ||
25 | .globl crypto_onetimeauth_poly1305_x86_hoffset1 | ||
26 | .globl crypto_onetimeauth_poly1305_x86_hoffset2 | ||
27 | .globl crypto_onetimeauth_poly1305_x86_hoffset3 | ||
28 | .globl crypto_onetimeauth_poly1305_x86_rounding | ||
29 | |||
30 | _crypto_onetimeauth_poly1305_x86_constants: | ||
31 | crypto_onetimeauth_poly1305_x86_constants: | ||
32 | crypto_onetimeauth_poly1305_x86_scale: | ||
33 | .long 0x0,0x37f40000 | ||
34 | |||
35 | crypto_onetimeauth_poly1305_x86_two32: | ||
36 | .long 0x0,0x41f00000 | ||
37 | |||
38 | crypto_onetimeauth_poly1305_x86_two64: | ||
39 | .long 0x0,0x43f00000 | ||
40 | |||
41 | crypto_onetimeauth_poly1305_x86_two96: | ||
42 | .long 0x0,0x45f00000 | ||
43 | |||
44 | crypto_onetimeauth_poly1305_x86_alpha32: | ||
45 | .long 0x0,0x45e80000 | ||
46 | |||
47 | crypto_onetimeauth_poly1305_x86_alpha64: | ||
48 | .long 0x0,0x47e80000 | ||
49 | |||
50 | crypto_onetimeauth_poly1305_x86_alpha96: | ||
51 | .long 0x0,0x49e80000 | ||
52 | |||
53 | crypto_onetimeauth_poly1305_x86_alpha130: | ||
54 | .long 0x0,0x4c080000 | ||
55 | |||
56 | crypto_onetimeauth_poly1305_x86_doffset0: | ||
57 | .long 0x0,0x43300000 | ||
58 | |||
59 | crypto_onetimeauth_poly1305_x86_doffset1: | ||
60 | .long 0x0,0x45300000 | ||
61 | |||
62 | crypto_onetimeauth_poly1305_x86_doffset2: | ||
63 | .long 0x0,0x47300000 | ||
64 | |||
65 | crypto_onetimeauth_poly1305_x86_doffset3: | ||
66 | .long 0x0,0x49300000 | ||
67 | |||
68 | crypto_onetimeauth_poly1305_x86_doffset3minustwo128: | ||
69 | .long 0x0,0x492ffffe | ||
70 | |||
71 | crypto_onetimeauth_poly1305_x86_hoffset0: | ||
72 | .long 0xfffffffb,0x43300001 | ||
73 | |||
74 | crypto_onetimeauth_poly1305_x86_hoffset1: | ||
75 | .long 0xfffffffe,0x45300001 | ||
76 | |||
77 | crypto_onetimeauth_poly1305_x86_hoffset2: | ||
78 | .long 0xfffffffe,0x47300001 | ||
79 | |||
80 | crypto_onetimeauth_poly1305_x86_hoffset3: | ||
81 | .long 0xfffffffe,0x49300003 | ||
82 | |||
83 | crypto_onetimeauth_poly1305_x86_rounding: | ||
84 | .byte 0x7f | ||
85 | .byte 0x13 | ||
diff --git a/nacl/crypto_onetimeauth/poly1305/x86/verify.c b/nacl/crypto_onetimeauth/poly1305/x86/verify.c deleted file mode 100644 index c7e063f1..00000000 --- a/nacl/crypto_onetimeauth/poly1305/x86/verify.c +++ /dev/null | |||
@@ -1,9 +0,0 @@ | |||
1 | #include "crypto_verify_16.h" | ||
2 | #include "crypto_onetimeauth.h" | ||
3 | |||
4 | int crypto_onetimeauth_verify(const unsigned char *h,const unsigned char *in,unsigned long long inlen,const unsigned char *k) | ||
5 | { | ||
6 | unsigned char correct[16]; | ||
7 | crypto_onetimeauth(correct,in,inlen,k); | ||
8 | return crypto_verify_16(h,correct); | ||
9 | } | ||
diff --git a/nacl/crypto_onetimeauth/try.c b/nacl/crypto_onetimeauth/try.c deleted file mode 100644 index 54f4396d..00000000 --- a/nacl/crypto_onetimeauth/try.c +++ /dev/null | |||
@@ -1,119 +0,0 @@ | |||
1 | /* | ||
2 | * crypto_onetimeauth/try.c version 20090118 | ||
3 | * D. J. Bernstein | ||
4 | * Public domain. | ||
5 | */ | ||
6 | |||
7 | #include "crypto_hash_sha256.h" | ||
8 | #include "crypto_onetimeauth.h" | ||
9 | |||
10 | extern unsigned char *alignedcalloc(unsigned long long); | ||
11 | |||
12 | const char *primitiveimplementation = crypto_onetimeauth_IMPLEMENTATION; | ||
13 | |||
14 | #define MAXTEST_BYTES 10000 | ||
15 | #define CHECKSUM_BYTES 4096 | ||
16 | #define TUNE_BYTES 1536 | ||
17 | |||
18 | static unsigned char *h; | ||
19 | static unsigned char *m; | ||
20 | static unsigned char *k; | ||
21 | static unsigned char *h2; | ||
22 | static unsigned char *m2; | ||
23 | static unsigned char *k2; | ||
24 | |||
25 | void preallocate(void) | ||
26 | { | ||
27 | } | ||
28 | |||
29 | void allocate(void) | ||
30 | { | ||
31 | h = alignedcalloc(crypto_onetimeauth_BYTES); | ||
32 | m = alignedcalloc(MAXTEST_BYTES); | ||
33 | k = alignedcalloc(crypto_onetimeauth_KEYBYTES); | ||
34 | h2 = alignedcalloc(crypto_onetimeauth_BYTES); | ||
35 | m2 = alignedcalloc(MAXTEST_BYTES + crypto_onetimeauth_BYTES); | ||
36 | k2 = alignedcalloc(crypto_onetimeauth_KEYBYTES + crypto_onetimeauth_BYTES); | ||
37 | } | ||
38 | |||
39 | void predoit(void) | ||
40 | { | ||
41 | } | ||
42 | |||
43 | void doit(void) | ||
44 | { | ||
45 | crypto_onetimeauth(h,m,TUNE_BYTES,k); | ||
46 | crypto_onetimeauth_verify(h,m,TUNE_BYTES,k); | ||
47 | } | ||
48 | |||
49 | char checksum[crypto_onetimeauth_BYTES * 2 + 1]; | ||
50 | |||
51 | const char *checksum_compute(void) | ||
52 | { | ||
53 | long long i; | ||
54 | long long j; | ||
55 | |||
56 | for (i = 0;i < CHECKSUM_BYTES;++i) { | ||
57 | long long mlen = i; | ||
58 | long long klen = crypto_onetimeauth_KEYBYTES; | ||
59 | long long hlen = crypto_onetimeauth_BYTES; | ||
60 | |||
61 | for (j = -16;j < 0;++j) h[j] = random(); | ||
62 | for (j = -16;j < 0;++j) k[j] = random(); | ||
63 | for (j = -16;j < 0;++j) m[j] = random(); | ||
64 | for (j = hlen;j < hlen + 16;++j) h[j] = random(); | ||
65 | for (j = klen;j < klen + 16;++j) k[j] = random(); | ||
66 | for (j = mlen;j < mlen + 16;++j) m[j] = random(); | ||
67 | for (j = -16;j < hlen + 16;++j) h2[j] = h[j]; | ||
68 | for (j = -16;j < klen + 16;++j) k2[j] = k[j]; | ||
69 | for (j = -16;j < mlen + 16;++j) m2[j] = m[j]; | ||
70 | |||
71 | if (crypto_onetimeauth(h,m,mlen,k) != 0) return "crypto_onetimeauth returns nonzero"; | ||
72 | |||
73 | for (j = -16;j < klen + 16;++j) if (k[j] != k2[j]) return "crypto_onetimeauth overwrites k"; | ||
74 | for (j = -16;j < mlen + 16;++j) if (m[j] != m2[j]) return "crypto_onetimeauth overwrites m"; | ||
75 | for (j = -16;j < 0;++j) if (h[j] != h2[j]) return "crypto_onetimeauth writes before output"; | ||
76 | for (j = hlen;j < hlen + 16;++j) if (h[j] != h2[j]) return "crypto_onetimeauth writes after output"; | ||
77 | |||
78 | for (j = -16;j < 0;++j) h[j] = random(); | ||
79 | for (j = -16;j < 0;++j) k[j] = random(); | ||
80 | for (j = -16;j < 0;++j) m[j] = random(); | ||
81 | for (j = hlen;j < hlen + 16;++j) h[j] = random(); | ||
82 | for (j = klen;j < klen + 16;++j) k[j] = random(); | ||
83 | for (j = mlen;j < mlen + 16;++j) m[j] = random(); | ||
84 | for (j = -16;j < hlen + 16;++j) h2[j] = h[j]; | ||
85 | for (j = -16;j < klen + 16;++j) k2[j] = k[j]; | ||
86 | for (j = -16;j < mlen + 16;++j) m2[j] = m[j]; | ||
87 | |||
88 | if (crypto_onetimeauth(m2,m2,mlen,k) != 0) return "crypto_onetimeauth returns nonzero"; | ||
89 | for (j = 0;j < hlen;++j) if (m2[j] != h[j]) return "crypto_onetimeauth does not handle m overlap"; | ||
90 | for (j = 0;j < hlen;++j) m2[j] = m[j]; | ||
91 | if (crypto_onetimeauth(k2,m2,mlen,k2) != 0) return "crypto_onetimeauth returns nonzero"; | ||
92 | for (j = 0;j < hlen;++j) if (k2[j] != h[j]) return "crypto_onetimeauth does not handle k overlap"; | ||
93 | for (j = 0;j < hlen;++j) k2[j] = k[j]; | ||
94 | |||
95 | if (crypto_onetimeauth_verify(h,m,mlen,k) != 0) return "crypto_onetimeauth_verify returns nonzero"; | ||
96 | |||
97 | for (j = -16;j < hlen + 16;++j) if (h[j] != h2[j]) return "crypto_onetimeauth overwrites h"; | ||
98 | for (j = -16;j < klen + 16;++j) if (k[j] != k2[j]) return "crypto_onetimeauth overwrites k"; | ||
99 | for (j = -16;j < mlen + 16;++j) if (m[j] != m2[j]) return "crypto_onetimeauth overwrites m"; | ||
100 | |||
101 | crypto_hash_sha256(h2,h,hlen); | ||
102 | for (j = 0;j < klen;++j) k[j] ^= h2[j % 32]; | ||
103 | if (crypto_onetimeauth(h,m,mlen,k) != 0) return "crypto_onetimeauth returns nonzero"; | ||
104 | if (crypto_onetimeauth_verify(h,m,mlen,k) != 0) return "crypto_onetimeauth_verify returns nonzero"; | ||
105 | |||
106 | crypto_hash_sha256(h2,h,hlen); | ||
107 | for (j = 0;j < mlen;++j) m[j] ^= h2[j % 32]; | ||
108 | m[mlen] = h2[0]; | ||
109 | } | ||
110 | if (crypto_onetimeauth(h,m,CHECKSUM_BYTES,k) != 0) return "crypto_onetimeauth returns nonzero"; | ||
111 | if (crypto_onetimeauth_verify(h,m,CHECKSUM_BYTES,k) != 0) return "crypto_onetimeauth_verify returns nonzero"; | ||
112 | |||
113 | for (i = 0;i < crypto_onetimeauth_BYTES;++i) { | ||
114 | checksum[2 * i] = "0123456789abcdef"[15 & (h[i] >> 4)]; | ||
115 | checksum[2 * i + 1] = "0123456789abcdef"[15 & h[i]]; | ||
116 | } | ||
117 | checksum[2 * i] = 0; | ||
118 | return 0; | ||
119 | } | ||
diff --git a/nacl/crypto_onetimeauth/wrapper-auth.cpp b/nacl/crypto_onetimeauth/wrapper-auth.cpp deleted file mode 100644 index f4279607..00000000 --- a/nacl/crypto_onetimeauth/wrapper-auth.cpp +++ /dev/null | |||
@@ -1,11 +0,0 @@ | |||
1 | #include <string> | ||
2 | using std::string; | ||
3 | #include "crypto_onetimeauth.h" | ||
4 | |||
5 | string crypto_onetimeauth(const string &m,const string &k) | ||
6 | { | ||
7 | if (k.size() != crypto_onetimeauth_KEYBYTES) throw "incorrect key length"; | ||
8 | unsigned char a[crypto_onetimeauth_BYTES]; | ||
9 | crypto_onetimeauth(a,(const unsigned char *) m.c_str(),m.size(),(const unsigned char *) k.c_str()); | ||
10 | return string((char *) a,crypto_onetimeauth_BYTES); | ||
11 | } | ||
diff --git a/nacl/crypto_onetimeauth/wrapper-verify.cpp b/nacl/crypto_onetimeauth/wrapper-verify.cpp deleted file mode 100644 index 248239ee..00000000 --- a/nacl/crypto_onetimeauth/wrapper-verify.cpp +++ /dev/null | |||
@@ -1,14 +0,0 @@ | |||
1 | #include <string> | ||
2 | using std::string; | ||
3 | #include "crypto_onetimeauth.h" | ||
4 | |||
5 | void crypto_onetimeauth_verify(const string &a,const string &m,const string &k) | ||
6 | { | ||
7 | if (k.size() != crypto_onetimeauth_KEYBYTES) throw "incorrect key length"; | ||
8 | if (a.size() != crypto_onetimeauth_BYTES) throw "incorrect authenticator length"; | ||
9 | if (crypto_onetimeauth_verify( | ||
10 | (const unsigned char *) a.c_str(), | ||
11 | (const unsigned char *) m.c_str(),m.size(), | ||
12 | (const unsigned char *) k.c_str()) == 0) return; | ||
13 | throw "invalid authenticator"; | ||
14 | } | ||