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