Manual formatting tweaks to Curve448 code
[openssl.git] / crypto / ec / curve448 / arch_arm_32 / f_impl.c
1 /*
2  * Copyright 2017 The OpenSSL Project Authors. All Rights Reserved.
3  * Copyright 2014 Cryptography Research, Inc.
4  *
5  * Licensed under the OpenSSL license (the "License").  You may not use
6  * this file except in compliance with the License.  You can obtain a copy
7  * in the file LICENSE in the source distribution or at
8  * https://www.openssl.org/source/license.html
9  *
10  * Originally written by Mike Hamburg
11  */
12
13 #include "f_field.h"
14
15 static inline void __attribute__ ((gnu_inline, always_inline))
16     smlal(uint64_t *acc, const uint32_t a, const uint32_t b)
17 {
18
19 #ifdef  __ARMEL__
20     uint32_t lo = *acc, hi = (*acc) >> 32;
21
22     __asm__ __volatile__ ("smlal %[lo], %[hi], %[a], %[b]"
23                           : [lo]"+&r"(lo), [hi]"+&r"(hi)
24                           : [a]"r"(a), [b]"r"(b));
25
26
27     *acc = lo + (((uint64_t)hi) << 32);
28 #else
29     *acc += (int64_t)(int32_t)a *(int64_t)(int32_t)b;
30 #endif
31 }
32
33 static inline void __attribute__ ((gnu_inline, always_inline))
34     smlal2(uint64_t *acc, const uint32_t a, const uint32_t b)
35 {
36 #ifdef __ARMEL__
37     uint32_t lo = *acc, hi = (*acc) >> 32;
38
39     __asm__ __volatile__ ("smlal %[lo], %[hi], %[a], %[b]"
40                           : [lo]"+&r"(lo), [hi]"+&r"(hi)
41                           : [a]"r"(a), [b]"r"(2 * b));
42
43
44
45     *acc = lo + (((uint64_t)hi) << 32);
46 #else
47     *acc += (int64_t)(int32_t)a *(int64_t)(int32_t)(b * 2);
48 #endif
49 }
50
51 static inline void __attribute__ ((gnu_inline, always_inline))
52     smull(uint64_t *acc, const uint32_t a, const uint32_t b)
53 {
54 #ifdef __ARMEL__
55     uint32_t lo, hi;
56
57     __asm__ __volatile__ ("smull %[lo], %[hi], %[a], %[b]"
58                           : [lo]"=&r"(lo), [hi]"=&r"(hi)
59                           : [a]"r"(a), [b]"r"(b));
60
61     *acc = lo + (((uint64_t)hi) << 32);
62 #else
63     *acc = (int64_t)(int32_t)a *(int64_t)(int32_t)b;
64 #endif
65 }
66
67 static inline void __attribute__ ((gnu_inline, always_inline))
68     smull2(uint64_t *acc, const uint32_t a, const uint32_t b)
69 {
70 #ifdef __ARMEL__
71     uint32_t lo, hi;
72
73     __asm__ /*__volatile__*/ ("smull %[lo], %[hi], %[a], %[b]"
74                               : [lo]"=&r"(lo), [hi]"=&r"(hi)
75                               : [a]"r"(a), [b]"r"(2*b));
76
77     *acc = lo + (((uint64_t)hi) << 32);
78 #else
79     *acc = (int64_t)(int32_t)a *(int64_t)(int32_t)(b * 2);
80 #endif
81 }
82
83 void gf_mul(gf_s * __restrict__ cs, const gf as, const gf bs)
84 {
85
86     const uint32_t *a = as->limb, *b = bs->limb;
87     uint32_t *c = cs->limb;
88
89     uint64_t accum0 = 0, accum1 = 0, accum2, accum3, accumC0, accumC1;
90     uint32_t mask = (1 << 28) - 1;
91
92     uint32_t aa[8], bm[8];
93
94     int i;
95     for (i = 0; i < 8; i++) {
96         aa[i] = a[i] + a[i + 8];
97         bm[i] = b[i] - b[i + 8];
98     }
99
100     uint32_t ax, bx;
101     {
102         /* t^3 terms */
103         smull(&accum1, ax = aa[1], bx = b[15]);
104         smull(&accum3, ax = aa[2], bx);
105         smlal(&accum1, ax, bx = b[14]);
106         smlal(&accum3, ax = aa[3], bx);
107         smlal(&accum1, ax, bx = b[13]);
108         smlal(&accum3, ax = aa[4], bx);
109         smlal(&accum1, ax, bx = b[12]);
110         smlal(&accum3, ax = aa[5], bx);
111         smlal(&accum1, ax, bx = b[11]);
112         smlal(&accum3, ax = aa[6], bx);
113         smlal(&accum1, ax, bx = b[10]);
114         smlal(&accum3, ax = aa[7], bx);
115         smlal(&accum1, ax, bx = b[9]);
116
117         accum0 = accum1;
118         accum2 = accum3;
119
120         /* t^2 terms */
121         smlal(&accum2, ax = aa[0], bx);
122         smlal(&accum0, ax, bx = b[8]);
123         smlal(&accum2, ax = aa[1], bx);
124
125         smlal(&accum0, ax = a[9], bx = b[7]);
126         smlal(&accum2, ax = a[10], bx);
127         smlal(&accum0, ax, bx = b[6]);
128         smlal(&accum2, ax = a[11], bx);
129         smlal(&accum0, ax, bx = b[5]);
130         smlal(&accum2, ax = a[12], bx);
131         smlal(&accum0, ax, bx = b[4]);
132         smlal(&accum2, ax = a[13], bx);
133         smlal(&accum0, ax, bx = b[3]);
134         smlal(&accum2, ax = a[14], bx);
135         smlal(&accum0, ax, bx = b[2]);
136         smlal(&accum2, ax = a[15], bx);
137         smlal(&accum0, ax, bx = b[1]);
138
139         /* t terms */
140         accum1 += accum0;
141         accum3 += accum2;
142         smlal(&accum3, ax = a[8], bx);
143         smlal(&accum1, ax, bx = b[0]);
144         smlal(&accum3, ax = a[9], bx);
145
146         smlal(&accum1, ax = a[1], bx = bm[7]);
147         smlal(&accum3, ax = a[2], bx);
148         smlal(&accum1, ax, bx = bm[6]);
149         smlal(&accum3, ax = a[3], bx);
150         smlal(&accum1, ax, bx = bm[5]);
151         smlal(&accum3, ax = a[4], bx);
152         smlal(&accum1, ax, bx = bm[4]);
153         smlal(&accum3, ax = a[5], bx);
154         smlal(&accum1, ax, bx = bm[3]);
155         smlal(&accum3, ax = a[6], bx);
156         smlal(&accum1, ax, bx = bm[2]);
157         smlal(&accum3, ax = a[7], bx);
158         smlal(&accum1, ax, bx = bm[1]);
159
160         /* 1 terms */
161         smlal(&accum2, ax = a[0], bx);
162         smlal(&accum0, ax, bx = bm[0]);
163         smlal(&accum2, ax = a[1], bx);
164
165         accum2 += accum0 >> 28;
166         accum3 += accum1 >> 28;
167
168         c[0] = ((uint32_t)(accum0)) & mask;
169         c[1] = ((uint32_t)(accum2)) & mask;
170         c[8] = ((uint32_t)(accum1)) & mask;
171         c[9] = ((uint32_t)(accum3)) & mask;
172
173         accumC0 = accum2 >> 28;
174         accumC1 = accum3 >> 28;
175     }
176     {
177         /* t^3 terms */
178         smull(&accum1, ax = aa[3], bx = b[15]);
179         smull(&accum3, ax = aa[4], bx);
180         smlal(&accum1, ax, bx = b[14]);
181         smlal(&accum3, ax = aa[5], bx);
182         smlal(&accum1, ax, bx = b[13]);
183         smlal(&accum3, ax = aa[6], bx);
184         smlal(&accum1, ax, bx = b[12]);
185         smlal(&accum3, ax = aa[7], bx);
186         smlal(&accum1, ax, bx = b[11]);
187
188         accum0 = accum1;
189         accum2 = accum3;
190
191         /* t^2 terms */
192         smlal(&accum2, ax = aa[0], bx);
193         smlal(&accum0, ax, bx = b[10]);
194         smlal(&accum2, ax = aa[1], bx);
195         smlal(&accum0, ax, bx = b[9]);
196         smlal(&accum2, ax = aa[2], bx);
197         smlal(&accum0, ax, bx = b[8]);
198         smlal(&accum2, ax = aa[3], bx);
199
200         smlal(&accum0, ax = a[11], bx = b[7]);
201         smlal(&accum2, ax = a[12], bx);
202         smlal(&accum0, ax, bx = b[6]);
203         smlal(&accum2, ax = a[13], bx);
204         smlal(&accum0, ax, bx = b[5]);
205         smlal(&accum2, ax = a[14], bx);
206         smlal(&accum0, ax, bx = b[4]);
207         smlal(&accum2, ax = a[15], bx);
208         smlal(&accum0, ax, bx = b[3]);
209
210         /* t terms */
211         accum1 += accum0;
212         accum3 += accum2;
213         smlal(&accum3, ax = a[8], bx);
214         smlal(&accum1, ax, bx = b[2]);
215         smlal(&accum3, ax = a[9], bx);
216         smlal(&accum1, ax, bx = b[1]);
217         smlal(&accum3, ax = a[10], bx);
218         smlal(&accum1, ax, bx = b[0]);
219         smlal(&accum3, ax = a[11], bx);
220
221         smlal(&accum1, ax = a[3], bx = bm[7]);
222         smlal(&accum3, ax = a[4], bx);
223         smlal(&accum1, ax, bx = bm[6]);
224         smlal(&accum3, ax = a[5], bx);
225         smlal(&accum1, ax, bx = bm[5]);
226         smlal(&accum3, ax = a[6], bx);
227         smlal(&accum1, ax, bx = bm[4]);
228         smlal(&accum3, ax = a[7], bx);
229         smlal(&accum1, ax, bx = bm[3]);
230
231         /* 1 terms */
232         smlal(&accum2, ax = a[0], bx);
233         smlal(&accum0, ax, bx = bm[2]);
234         smlal(&accum2, ax = a[1], bx);
235         smlal(&accum0, ax, bx = bm[1]);
236         smlal(&accum2, ax = a[2], bx);
237         smlal(&accum0, ax, bx = bm[0]);
238         smlal(&accum2, ax = a[3], bx);
239
240         accum0 += accumC0;
241         accum1 += accumC1;
242         accum2 += accum0 >> 28;
243         accum3 += accum1 >> 28;
244
245         c[2] = ((uint32_t)(accum0)) & mask;
246         c[3] = ((uint32_t)(accum2)) & mask;
247         c[10] = ((uint32_t)(accum1)) & mask;
248         c[11] = ((uint32_t)(accum3)) & mask;
249
250         accumC0 = accum2 >> 28;
251         accumC1 = accum3 >> 28;
252     }
253     {
254
255         /* t^3 terms */
256         smull(&accum1, ax = aa[5], bx = b[15]);
257         smull(&accum3, ax = aa[6], bx);
258         smlal(&accum1, ax, bx = b[14]);
259         smlal(&accum3, ax = aa[7], bx);
260         smlal(&accum1, ax, bx = b[13]);
261
262         accum0 = accum1;
263         accum2 = accum3;
264
265         /* t^2 terms */
266
267         smlal(&accum2, ax = aa[0], bx);
268         smlal(&accum0, ax, bx = b[12]);
269         smlal(&accum2, ax = aa[1], bx);
270         smlal(&accum0, ax, bx = b[11]);
271         smlal(&accum2, ax = aa[2], bx);
272         smlal(&accum0, ax, bx = b[10]);
273         smlal(&accum2, ax = aa[3], bx);
274         smlal(&accum0, ax, bx = b[9]);
275         smlal(&accum2, ax = aa[4], bx);
276         smlal(&accum0, ax, bx = b[8]);
277         smlal(&accum2, ax = aa[5], bx);
278
279         smlal(&accum0, ax = a[13], bx = b[7]);
280         smlal(&accum2, ax = a[14], bx);
281         smlal(&accum0, ax, bx = b[6]);
282         smlal(&accum2, ax = a[15], bx);
283         smlal(&accum0, ax, bx = b[5]);
284
285         /* t terms */
286         accum1 += accum0;
287         accum3 += accum2;
288
289         smlal(&accum3, ax = a[8], bx);
290         smlal(&accum1, ax, bx = b[4]);
291         smlal(&accum3, ax = a[9], bx);
292         smlal(&accum1, ax, bx = b[3]);
293         smlal(&accum3, ax = a[10], bx);
294         smlal(&accum1, ax, bx = b[2]);
295         smlal(&accum3, ax = a[11], bx);
296         smlal(&accum1, ax, bx = b[1]);
297         smlal(&accum3, ax = a[12], bx);
298         smlal(&accum1, ax, bx = b[0]);
299         smlal(&accum3, ax = a[13], bx);
300
301         smlal(&accum1, ax = a[5], bx = bm[7]);
302         smlal(&accum3, ax = a[6], bx);
303         smlal(&accum1, ax, bx = bm[6]);
304         smlal(&accum3, ax = a[7], bx);
305         smlal(&accum1, ax, bx = bm[5]);
306
307         /* 1 terms */
308
309         smlal(&accum2, ax = a[0], bx);
310         smlal(&accum0, ax, bx = bm[4]);
311         smlal(&accum2, ax = a[1], bx);
312         smlal(&accum0, ax, bx = bm[3]);
313         smlal(&accum2, ax = a[2], bx);
314         smlal(&accum0, ax, bx = bm[2]);
315         smlal(&accum2, ax = a[3], bx);
316         smlal(&accum0, ax, bx = bm[1]);
317         smlal(&accum2, ax = a[4], bx);
318         smlal(&accum0, ax, bx = bm[0]);
319         smlal(&accum2, ax = a[5], bx);
320
321         accum0 += accumC0;
322         accum1 += accumC1;
323         accum2 += accum0 >> 28;
324         accum3 += accum1 >> 28;
325
326         c[4] = ((uint32_t)(accum0)) & mask;
327         c[5] = ((uint32_t)(accum2)) & mask;
328         c[12] = ((uint32_t)(accum1)) & mask;
329         c[13] = ((uint32_t)(accum3)) & mask;
330
331         accumC0 = accum2 >> 28;
332         accumC1 = accum3 >> 28;
333     }
334     {
335
336         /* t^3 terms */
337         smull(&accum1, ax = aa[7], bx = b[15]);
338         accum0 = accum1;
339
340         /* t^2 terms */
341
342         smull(&accum2, ax = aa[0], bx);
343         smlal(&accum0, ax, bx = b[14]);
344         smlal(&accum2, ax = aa[1], bx);
345         smlal(&accum0, ax, bx = b[13]);
346         smlal(&accum2, ax = aa[2], bx);
347         smlal(&accum0, ax, bx = b[12]);
348         smlal(&accum2, ax = aa[3], bx);
349         smlal(&accum0, ax, bx = b[11]);
350         smlal(&accum2, ax = aa[4], bx);
351         smlal(&accum0, ax, bx = b[10]);
352         smlal(&accum2, ax = aa[5], bx);
353         smlal(&accum0, ax, bx = b[9]);
354         smlal(&accum2, ax = aa[6], bx);
355         smlal(&accum0, ax, bx = b[8]);
356         smlal(&accum2, ax = aa[7], bx);
357
358         smlal(&accum0, ax = a[15], bx = b[7]);
359
360         /* t terms */
361         accum1 += accum0;
362         accum3 = accum2;
363
364         smlal(&accum3, ax = a[8], bx);
365         smlal(&accum1, ax, bx = b[6]);
366         smlal(&accum3, ax = a[9], bx);
367         smlal(&accum1, ax, bx = b[5]);
368         smlal(&accum3, ax = a[10], bx);
369         smlal(&accum1, ax, bx = b[4]);
370         smlal(&accum3, ax = a[11], bx);
371         smlal(&accum1, ax, bx = b[3]);
372         smlal(&accum3, ax = a[12], bx);
373         smlal(&accum1, ax, bx = b[2]);
374         smlal(&accum3, ax = a[13], bx);
375         smlal(&accum1, ax, bx = b[1]);
376         smlal(&accum3, ax = a[14], bx);
377         smlal(&accum1, ax, bx = b[0]);
378         smlal(&accum3, ax = a[15], bx);
379
380         smlal(&accum1, ax = a[7], bx = bm[7]);
381
382         /* 1 terms */
383
384         smlal(&accum2, ax = a[0], bx);
385         smlal(&accum0, ax, bx = bm[6]);
386         smlal(&accum2, ax = a[1], bx);
387         smlal(&accum0, ax, bx = bm[5]);
388         smlal(&accum2, ax = a[2], bx);
389         smlal(&accum0, ax, bx = bm[4]);
390         smlal(&accum2, ax = a[3], bx);
391         smlal(&accum0, ax, bx = bm[3]);
392         smlal(&accum2, ax = a[4], bx);
393         smlal(&accum0, ax, bx = bm[2]);
394         smlal(&accum2, ax = a[5], bx);
395         smlal(&accum0, ax, bx = bm[1]);
396         smlal(&accum2, ax = a[6], bx);
397         smlal(&accum0, ax, bx = bm[0]);
398         smlal(&accum2, ax = a[7], bx);
399
400         accum0 += accumC0;
401         accum1 += accumC1;
402         accum2 += accum0 >> 28;
403         accum3 += accum1 >> 28;
404
405         c[6] = ((uint32_t)(accum0)) & mask;
406         c[7] = ((uint32_t)(accum2)) & mask;
407         c[14] = ((uint32_t)(accum1)) & mask;
408         c[15] = ((uint32_t)(accum3)) & mask;
409
410         accum0 = accum2 >> 28;
411         accum1 = accum3 >> 28;
412     }
413
414     accum0 += accum1;
415     accum0 += c[8];
416     accum1 += c[0];
417     c[8] = ((uint32_t)(accum0)) & mask;
418     c[0] = ((uint32_t)(accum1)) & mask;
419
420     accum0 >>= 28;
421     accum1 >>= 28;
422     c[9] += ((uint32_t)(accum0));
423     c[1] += ((uint32_t)(accum1));
424 }
425
426 void gf_sqr(gf_s * __restrict__ cs, const gf as)
427 {
428     const uint32_t *a = as->limb;
429     uint32_t *c = cs->limb;
430
431     uint64_t accum0 = 0, accum1 = 0, accum2, accum3, accumC0, accumC1, tmp;
432     uint32_t mask = (1 << 28) - 1;
433
434     uint32_t bm[8];
435
436     int i;
437     for (i = 0; i < 8; i++) {
438         bm[i] = a[i] - a[i + 8];
439     }
440
441     uint32_t ax, bx;
442     {
443         /* t^3 terms */
444         smull2(&accum1, ax = a[9], bx = a[15]);
445         smull2(&accum3, ax = a[10], bx);
446         smlal2(&accum1, ax, bx = a[14]);
447         smlal2(&accum3, ax = a[11], bx);
448         smlal2(&accum1, ax, bx = a[13]);
449         smlal2(&accum3, ax = a[12], bx);
450         smlal(&accum1, ax, ax);
451
452         accum0 = accum1;
453         accum2 = accum3;
454
455         /* t^2 terms */
456         smlal2(&accum2, ax = a[8], a[9]);
457         smlal(&accum0, ax, ax);
458
459         smlal2(&accum0, ax = a[1], bx = a[7]);
460         smlal2(&accum2, ax = a[2], bx);
461         smlal2(&accum0, ax, bx = a[6]);
462         smlal2(&accum2, ax = a[3], bx);
463         smlal2(&accum0, ax, bx = a[5]);
464         smlal2(&accum2, ax = a[4], bx);
465         smlal(&accum0, ax, ax);
466
467         /* t terms */
468         accum1 += accum0;
469         accum3 += accum2;
470         smlal2(&accum3, ax = a[0], bx = a[1]);
471         smlal(&accum1, ax, ax);
472
473         accum1 = -accum1;
474         accum3 = -accum3;
475         accum2 = -accum2;
476         accum0 = -accum0;
477
478         smlal2(&accum1, ax = bm[1], bx = bm[7]);
479         smlal2(&accum3, ax = bm[2], bx);
480         smlal2(&accum1, ax, bx = bm[6]);
481         smlal2(&accum3, ax = bm[3], bx);
482         smlal2(&accum1, ax, bx = bm[5]);
483         smlal2(&accum3, ax = bm[4], bx);
484         smlal(&accum1, ax, ax);
485
486         /* 1 terms */
487         smlal2(&accum2, ax = bm[0], bx = bm[1]);
488         smlal(&accum0, ax, ax);
489
490         tmp = -accum3;
491         accum3 = tmp - accum2;
492         accum2 = tmp;
493         tmp = -accum1;
494         accum1 = tmp - accum0;
495         accum0 = tmp;
496
497         accum2 += accum0 >> 28;
498         accum3 += accum1 >> 28;
499
500         c[0] = ((uint32_t)(accum0)) & mask;
501         c[1] = ((uint32_t)(accum2)) & mask;
502         c[8] = ((uint32_t)(accum1)) & mask;
503         c[9] = ((uint32_t)(accum3)) & mask;
504
505         accumC0 = accum2 >> 28;
506         accumC1 = accum3 >> 28;
507     }
508     {
509         /* t^3 terms */
510         smull2(&accum1, ax = a[11], bx = a[15]);
511         smull2(&accum3, ax = a[12], bx);
512         smlal2(&accum1, ax, bx = a[14]);
513         smlal2(&accum3, ax = a[13], bx);
514         smlal(&accum1, ax, ax);
515
516         accum0 = accum1;
517         accum2 = accum3;
518
519         /* t^2 terms */
520         smlal2(&accum2, ax = a[8], bx = a[11]);
521         smlal2(&accum0, ax, bx = a[10]);
522         smlal2(&accum2, ax = a[9], bx);
523         smlal(&accum0, ax, ax);
524
525         smlal2(&accum0, ax = a[3], bx = a[7]);
526         smlal2(&accum2, ax = a[4], bx);
527         smlal2(&accum0, ax, bx = a[6]);
528         smlal2(&accum2, ax = a[5], bx);
529         smlal(&accum0, ax, ax);
530
531         /* t terms */
532         accum1 += accum0;
533         accum3 += accum2;
534         smlal2(&accum3, ax = a[0], bx = a[3]);
535         smlal2(&accum1, ax, bx = a[2]);
536         smlal2(&accum3, ax = a[1], bx);
537         smlal(&accum1, ax, ax);
538
539         accum1 = -accum1;
540         accum3 = -accum3;
541         accum2 = -accum2;
542         accum0 = -accum0;
543
544         smlal2(&accum1, ax = bm[3], bx = bm[7]);
545         smlal2(&accum3, ax = bm[4], bx);
546         smlal2(&accum1, ax, bx = bm[6]);
547         smlal2(&accum3, ax = bm[5], bx);
548         smlal(&accum1, ax, ax);
549
550         /* 1 terms */
551         smlal2(&accum2, ax = bm[0], bx = bm[3]);
552         smlal2(&accum0, ax, bx = bm[2]);
553         smlal2(&accum2, ax = bm[1], bx);
554         smlal(&accum0, ax, ax);
555
556         tmp = -accum3;
557         accum3 = tmp - accum2;
558         accum2 = tmp;
559         tmp = -accum1;
560         accum1 = tmp - accum0;
561         accum0 = tmp;
562
563         accum0 += accumC0;
564         accum1 += accumC1;
565         accum2 += accum0 >> 28;
566         accum3 += accum1 >> 28;
567
568         c[2] = ((uint32_t)(accum0)) & mask;
569         c[3] = ((uint32_t)(accum2)) & mask;
570         c[10] = ((uint32_t)(accum1)) & mask;
571         c[11] = ((uint32_t)(accum3)) & mask;
572
573         accumC0 = accum2 >> 28;
574         accumC1 = accum3 >> 28;
575     }
576     {
577
578         /* t^3 terms */
579         smull2(&accum1, ax = a[13], bx = a[15]);
580         smull2(&accum3, ax = a[14], bx);
581         smlal(&accum1, ax, ax);
582
583         accum0 = accum1;
584         accum2 = accum3;
585
586         /* t^2 terms */
587
588         smlal2(&accum2, ax = a[8], bx = a[13]);
589         smlal2(&accum0, ax, bx = a[12]);
590         smlal2(&accum2, ax = a[9], bx);
591         smlal2(&accum0, ax, bx = a[11]);
592         smlal2(&accum2, ax = a[10], bx);
593         smlal(&accum0, ax, ax);
594
595         smlal2(&accum0, ax = a[5], bx = a[7]);
596         smlal2(&accum2, ax = a[6], bx);
597         smlal(&accum0, ax, ax);
598
599         /* t terms */
600         accum1 += accum0;
601         accum3 += accum2;
602
603         smlal2(&accum3, ax = a[0], bx = a[5]);
604         smlal2(&accum1, ax, bx = a[4]);
605         smlal2(&accum3, ax = a[1], bx);
606         smlal2(&accum1, ax, bx = a[3]);
607         smlal2(&accum3, ax = a[2], bx);
608         smlal(&accum1, ax, ax);
609
610         accum1 = -accum1;
611         accum3 = -accum3;
612         accum2 = -accum2;
613         accum0 = -accum0;
614
615         smlal2(&accum1, ax = bm[5], bx = bm[7]);
616         smlal2(&accum3, ax = bm[6], bx);
617         smlal(&accum1, ax, ax);
618
619         /* 1 terms */
620
621         smlal2(&accum2, ax = bm[0], bx = bm[5]);
622         smlal2(&accum0, ax, bx = bm[4]);
623         smlal2(&accum2, ax = bm[1], bx);
624         smlal2(&accum0, ax, bx = bm[3]);
625         smlal2(&accum2, ax = bm[2], bx);
626         smlal(&accum0, ax, ax);
627
628         tmp = -accum3;
629         accum3 = tmp - accum2;
630         accum2 = tmp;
631         tmp = -accum1;
632         accum1 = tmp - accum0;
633         accum0 = tmp;
634
635         accum0 += accumC0;
636         accum1 += accumC1;
637         accum2 += accum0 >> 28;
638         accum3 += accum1 >> 28;
639
640         c[4] = ((uint32_t)(accum0)) & mask;
641         c[5] = ((uint32_t)(accum2)) & mask;
642         c[12] = ((uint32_t)(accum1)) & mask;
643         c[13] = ((uint32_t)(accum3)) & mask;
644
645         accumC0 = accum2 >> 28;
646         accumC1 = accum3 >> 28;
647     }
648     {
649
650         /* t^3 terms */
651         smull(&accum1, ax = a[15], bx = a[15]);
652         accum0 = accum1;
653
654         /* t^2 terms */
655
656         smull2(&accum2, ax = a[8], bx);
657         smlal2(&accum0, ax, bx = a[14]);
658         smlal2(&accum2, ax = a[9], bx);
659         smlal2(&accum0, ax, bx = a[13]);
660         smlal2(&accum2, ax = a[10], bx);
661         smlal2(&accum0, ax, bx = a[12]);
662         smlal2(&accum2, ax = a[11], bx);
663         smlal(&accum0, ax, ax);
664
665         smlal(&accum0, ax = a[7], bx = a[7]);
666
667         /* t terms */
668         accum1 += accum0;
669         accum3 = accum2;
670
671         smlal2(&accum3, ax = a[0], bx);
672         smlal2(&accum1, ax, bx = a[6]);
673         smlal2(&accum3, ax = a[1], bx);
674         smlal2(&accum1, ax, bx = a[5]);
675         smlal2(&accum3, ax = a[2], bx);
676         smlal2(&accum1, ax, bx = a[4]);
677         smlal2(&accum3, ax = a[3], bx);
678         smlal(&accum1, ax, ax);
679
680         accum1 = -accum1;
681         accum3 = -accum3;
682         accum2 = -accum2;
683         accum0 = -accum0;
684
685         bx = bm[7];
686         smlal(&accum1, bx, bx);
687
688         /* 1 terms */
689
690         smlal2(&accum2, ax = bm[0], bx);
691         smlal2(&accum0, ax, bx = bm[6]);
692         smlal2(&accum2, ax = bm[1], bx);
693         smlal2(&accum0, ax, bx = bm[5]);
694         smlal2(&accum2, ax = bm[2], bx);
695         smlal2(&accum0, ax, bx = bm[4]);
696         smlal2(&accum2, ax = bm[3], bx);
697         smlal(&accum0, ax, ax);
698
699         tmp = -accum3;
700         accum3 = tmp - accum2;
701         accum2 = tmp;
702         tmp = -accum1;
703         accum1 = tmp - accum0;
704         accum0 = tmp;
705
706         accum0 += accumC0;
707         accum1 += accumC1;
708         accum2 += accum0 >> 28;
709         accum3 += accum1 >> 28;
710
711         c[6] = ((uint32_t)(accum0)) & mask;
712         c[7] = ((uint32_t)(accum2)) & mask;
713         c[14] = ((uint32_t)(accum1)) & mask;
714         c[15] = ((uint32_t)(accum3)) & mask;
715
716         accum0 = accum2 >> 28;
717         accum1 = accum3 >> 28;
718     }
719
720     accum0 += accum1;
721     accum0 += c[8];
722     accum1 += c[0];
723     c[8] = ((uint32_t)(accum0)) & mask;
724     c[0] = ((uint32_t)(accum1)) & mask;
725
726     accum0 >>= 28;
727     accum1 >>= 28;
728     c[9] += ((uint32_t)(accum0));
729     c[1] += ((uint32_t)(accum1));
730 }
731
732 void gf_mulw_unsigned(gf_s * __restrict__ cs, const gf as, uint32_t b)
733 {
734     uint32_t mask = (1ull << 28) - 1;
735     const uint32_t *a = as->limb;
736     uint32_t *c = cs->limb;
737     uint64_t accum0, accum8;
738     int i;
739     uint32_t c0, c8, n0, n8;
740
741     assert(b <= mask);
742
743     c0 = a[0];
744     c8 = a[8];
745     accum0 = widemul(b, c0);
746     accum8 = widemul(b, c8);
747
748     c[0] = accum0 & mask;
749     accum0 >>= 28;
750     c[8] = accum8 & mask;
751     accum8 >>= 28;
752
753     i = 1;
754     {
755         n0 = a[i];
756         n8 = a[i + 8];
757         smlal(&accum0, b, n0);
758         smlal(&accum8, b, n8);
759
760         c[i] = accum0 & mask;
761         accum0 >>= 28;
762         c[i + 8] = accum8 & mask;
763         accum8 >>= 28;
764         i++;
765     }
766     {
767         c0 = a[i];
768         c8 = a[i + 8];
769         smlal(&accum0, b, c0);
770         smlal(&accum8, b, c8);
771
772         c[i] = accum0 & mask;
773         accum0 >>= 28;
774         c[i + 8] = accum8 & mask;
775         accum8 >>= 28;
776         i++;
777     }
778     {
779         n0 = a[i];
780         n8 = a[i + 8];
781         smlal(&accum0, b, n0);
782         smlal(&accum8, b, n8);
783
784         c[i] = accum0 & mask;
785         accum0 >>= 28;
786         c[i + 8] = accum8 & mask;
787         accum8 >>= 28;
788         i++;
789     }
790     {
791         c0 = a[i];
792         c8 = a[i + 8];
793         smlal(&accum0, b, c0);
794         smlal(&accum8, b, c8);
795
796         c[i] = accum0 & mask;
797         accum0 >>= 28;
798         c[i + 8] = accum8 & mask;
799         accum8 >>= 28;
800         i++;
801     }
802     {
803         n0 = a[i];
804         n8 = a[i + 8];
805         smlal(&accum0, b, n0);
806         smlal(&accum8, b, n8);
807
808         c[i] = accum0 & mask;
809         accum0 >>= 28;
810         c[i + 8] = accum8 & mask;
811         accum8 >>= 28;
812         i++;
813     }
814     {
815         c0 = a[i];
816         c8 = a[i + 8];
817         smlal(&accum0, b, c0);
818         smlal(&accum8, b, c8);
819
820         c[i] = accum0 & mask;
821         accum0 >>= 28;
822         c[i + 8] = accum8 & mask;
823         accum8 >>= 28;
824         i++;
825     }
826     {
827         n0 = a[i];
828         n8 = a[i + 8];
829         smlal(&accum0, b, n0);
830         smlal(&accum8, b, n8);
831
832         c[i] = accum0 & mask;
833         accum0 >>= 28;
834         c[i + 8] = accum8 & mask;
835         accum8 >>= 28;
836         i++;
837     }
838
839     accum0 += accum8 + c[8];
840     c[8] = accum0 & mask;
841     c[9] += accum0 >> 28;
842
843     accum8 += c[0];
844     c[0] = accum8 & mask;
845     c[1] += accum8 >> 28;
846 }