1// +build amd64_adx 2 3// Copyright 2020 ConsenSys Software Inc. 4// 5// Licensed under the Apache License, Version 2.0 (the "License"); 6// you may not use this file except in compliance with the License. 7// You may obtain a copy of the License at 8// 9// http://www.apache.org/licenses/LICENSE-2.0 10// 11// Unless required by applicable law or agreed to in writing, software 12// distributed under the License is distributed on an "AS IS" BASIS, 13// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14// See the License for the specific language governing permissions and 15// limitations under the License. 16 17#include "textflag.h" 18#include "funcdata.h" 19 20// modulus q 21DATA q<>+0(SB)/8, $0xb9feffffffffaaab 22DATA q<>+8(SB)/8, $0x1eabfffeb153ffff 23DATA q<>+16(SB)/8, $0x6730d2a0f6b0f624 24DATA q<>+24(SB)/8, $0x64774b84f38512bf 25DATA q<>+32(SB)/8, $0x4b1ba7b6434bacd7 26DATA q<>+40(SB)/8, $0x1a0111ea397fe69a 27GLOBL q<>(SB), (RODATA+NOPTR), $48 28 29// qInv0 q'[0] 30DATA qInv0<>(SB)/8, $0x89f3fffcfffcfffd 31GLOBL qInv0<>(SB), (RODATA+NOPTR), $8 32 33#define REDUCE(ra0, ra1, ra2, ra3, ra4, ra5, rb0, rb1, rb2, rb3, rb4, rb5) \ 34 MOVQ ra0, rb0; \ 35 SUBQ q<>(SB), ra0; \ 36 MOVQ ra1, rb1; \ 37 SBBQ q<>+8(SB), ra1; \ 38 MOVQ ra2, rb2; \ 39 SBBQ q<>+16(SB), ra2; \ 40 MOVQ ra3, rb3; \ 41 SBBQ q<>+24(SB), ra3; \ 42 MOVQ ra4, rb4; \ 43 SBBQ q<>+32(SB), ra4; \ 44 MOVQ ra5, rb5; \ 45 SBBQ q<>+40(SB), ra5; \ 46 CMOVQCS rb0, ra0; \ 47 CMOVQCS rb1, ra1; \ 48 CMOVQCS rb2, ra2; \ 49 CMOVQCS rb3, ra3; \ 50 CMOVQCS rb4, ra4; \ 51 CMOVQCS rb5, ra5; \ 52 53TEXT ·addE2(SB), NOSPLIT, $0-24 54 MOVQ x+8(FP), AX 55 MOVQ 0(AX), BX 56 MOVQ 8(AX), SI 57 MOVQ 16(AX), DI 58 MOVQ 24(AX), R8 59 MOVQ 32(AX), R9 60 MOVQ 40(AX), R10 61 MOVQ y+16(FP), DX 62 ADDQ 0(DX), BX 63 ADCQ 8(DX), SI 64 ADCQ 16(DX), DI 65 ADCQ 24(DX), R8 66 ADCQ 32(DX), R9 67 ADCQ 40(DX), R10 68 69 // reduce element(BX,SI,DI,R8,R9,R10) using temp registers (R11,R12,R13,R14,R15,s0-8(SP)) 70 REDUCE(BX,SI,DI,R8,R9,R10,R11,R12,R13,R14,R15,s0-8(SP)) 71 72 MOVQ res+0(FP), CX 73 MOVQ BX, 0(CX) 74 MOVQ SI, 8(CX) 75 MOVQ DI, 16(CX) 76 MOVQ R8, 24(CX) 77 MOVQ R9, 32(CX) 78 MOVQ R10, 40(CX) 79 MOVQ 48(AX), BX 80 MOVQ 56(AX), SI 81 MOVQ 64(AX), DI 82 MOVQ 72(AX), R8 83 MOVQ 80(AX), R9 84 MOVQ 88(AX), R10 85 ADDQ 48(DX), BX 86 ADCQ 56(DX), SI 87 ADCQ 64(DX), DI 88 ADCQ 72(DX), R8 89 ADCQ 80(DX), R9 90 ADCQ 88(DX), R10 91 92 // reduce element(BX,SI,DI,R8,R9,R10) using temp registers (R11,R12,R13,R14,R15,s0-8(SP)) 93 REDUCE(BX,SI,DI,R8,R9,R10,R11,R12,R13,R14,R15,s0-8(SP)) 94 95 MOVQ BX, 48(CX) 96 MOVQ SI, 56(CX) 97 MOVQ DI, 64(CX) 98 MOVQ R8, 72(CX) 99 MOVQ R9, 80(CX) 100 MOVQ R10, 88(CX) 101 RET 102 103TEXT ·doubleE2(SB), NOSPLIT, $0-16 104 MOVQ res+0(FP), DX 105 MOVQ x+8(FP), AX 106 MOVQ 0(AX), CX 107 MOVQ 8(AX), BX 108 MOVQ 16(AX), SI 109 MOVQ 24(AX), DI 110 MOVQ 32(AX), R8 111 MOVQ 40(AX), R9 112 ADDQ CX, CX 113 ADCQ BX, BX 114 ADCQ SI, SI 115 ADCQ DI, DI 116 ADCQ R8, R8 117 ADCQ R9, R9 118 119 // reduce element(CX,BX,SI,DI,R8,R9) using temp registers (R10,R11,R12,R13,R14,R15) 120 REDUCE(CX,BX,SI,DI,R8,R9,R10,R11,R12,R13,R14,R15) 121 122 MOVQ CX, 0(DX) 123 MOVQ BX, 8(DX) 124 MOVQ SI, 16(DX) 125 MOVQ DI, 24(DX) 126 MOVQ R8, 32(DX) 127 MOVQ R9, 40(DX) 128 MOVQ 48(AX), CX 129 MOVQ 56(AX), BX 130 MOVQ 64(AX), SI 131 MOVQ 72(AX), DI 132 MOVQ 80(AX), R8 133 MOVQ 88(AX), R9 134 ADDQ CX, CX 135 ADCQ BX, BX 136 ADCQ SI, SI 137 ADCQ DI, DI 138 ADCQ R8, R8 139 ADCQ R9, R9 140 141 // reduce element(CX,BX,SI,DI,R8,R9) using temp registers (R10,R11,R12,R13,R14,R15) 142 REDUCE(CX,BX,SI,DI,R8,R9,R10,R11,R12,R13,R14,R15) 143 144 MOVQ CX, 48(DX) 145 MOVQ BX, 56(DX) 146 MOVQ SI, 64(DX) 147 MOVQ DI, 72(DX) 148 MOVQ R8, 80(DX) 149 MOVQ R9, 88(DX) 150 RET 151 152TEXT ·subE2(SB), NOSPLIT, $0-24 153 XORQ R9, R9 154 MOVQ x+8(FP), R8 155 MOVQ 0(R8), AX 156 MOVQ 8(R8), DX 157 MOVQ 16(R8), CX 158 MOVQ 24(R8), BX 159 MOVQ 32(R8), SI 160 MOVQ 40(R8), DI 161 MOVQ y+16(FP), R8 162 SUBQ 0(R8), AX 163 SBBQ 8(R8), DX 164 SBBQ 16(R8), CX 165 SBBQ 24(R8), BX 166 SBBQ 32(R8), SI 167 SBBQ 40(R8), DI 168 MOVQ x+8(FP), R8 169 MOVQ $0xb9feffffffffaaab, R10 170 MOVQ $0x1eabfffeb153ffff, R11 171 MOVQ $0x6730d2a0f6b0f624, R12 172 MOVQ $0x64774b84f38512bf, R13 173 MOVQ $0x4b1ba7b6434bacd7, R14 174 MOVQ $0x1a0111ea397fe69a, R15 175 CMOVQCC R9, R10 176 CMOVQCC R9, R11 177 CMOVQCC R9, R12 178 CMOVQCC R9, R13 179 CMOVQCC R9, R14 180 CMOVQCC R9, R15 181 ADDQ R10, AX 182 ADCQ R11, DX 183 ADCQ R12, CX 184 ADCQ R13, BX 185 ADCQ R14, SI 186 ADCQ R15, DI 187 MOVQ res+0(FP), R10 188 MOVQ AX, 0(R10) 189 MOVQ DX, 8(R10) 190 MOVQ CX, 16(R10) 191 MOVQ BX, 24(R10) 192 MOVQ SI, 32(R10) 193 MOVQ DI, 40(R10) 194 MOVQ 48(R8), AX 195 MOVQ 56(R8), DX 196 MOVQ 64(R8), CX 197 MOVQ 72(R8), BX 198 MOVQ 80(R8), SI 199 MOVQ 88(R8), DI 200 MOVQ y+16(FP), R8 201 SUBQ 48(R8), AX 202 SBBQ 56(R8), DX 203 SBBQ 64(R8), CX 204 SBBQ 72(R8), BX 205 SBBQ 80(R8), SI 206 SBBQ 88(R8), DI 207 MOVQ $0xb9feffffffffaaab, R11 208 MOVQ $0x1eabfffeb153ffff, R12 209 MOVQ $0x6730d2a0f6b0f624, R13 210 MOVQ $0x64774b84f38512bf, R14 211 MOVQ $0x4b1ba7b6434bacd7, R15 212 MOVQ $0x1a0111ea397fe69a, R10 213 CMOVQCC R9, R11 214 CMOVQCC R9, R12 215 CMOVQCC R9, R13 216 CMOVQCC R9, R14 217 CMOVQCC R9, R15 218 CMOVQCC R9, R10 219 ADDQ R11, AX 220 ADCQ R12, DX 221 ADCQ R13, CX 222 ADCQ R14, BX 223 ADCQ R15, SI 224 ADCQ R10, DI 225 MOVQ res+0(FP), R8 226 MOVQ AX, 48(R8) 227 MOVQ DX, 56(R8) 228 MOVQ CX, 64(R8) 229 MOVQ BX, 72(R8) 230 MOVQ SI, 80(R8) 231 MOVQ DI, 88(R8) 232 RET 233 234TEXT ·negE2(SB), NOSPLIT, $0-16 235 MOVQ res+0(FP), DX 236 MOVQ x+8(FP), AX 237 MOVQ 0(AX), BX 238 MOVQ 8(AX), SI 239 MOVQ 16(AX), DI 240 MOVQ 24(AX), R8 241 MOVQ 32(AX), R9 242 MOVQ 40(AX), R10 243 MOVQ BX, AX 244 ORQ SI, AX 245 ORQ DI, AX 246 ORQ R8, AX 247 ORQ R9, AX 248 ORQ R10, AX 249 TESTQ AX, AX 250 JNE l1 251 MOVQ AX, 48(DX) 252 MOVQ AX, 56(DX) 253 MOVQ AX, 64(DX) 254 MOVQ AX, 72(DX) 255 MOVQ AX, 80(DX) 256 MOVQ AX, 88(DX) 257 JMP l3 258 259l1: 260 MOVQ $0xb9feffffffffaaab, CX 261 SUBQ BX, CX 262 MOVQ CX, 0(DX) 263 MOVQ $0x1eabfffeb153ffff, CX 264 SBBQ SI, CX 265 MOVQ CX, 8(DX) 266 MOVQ $0x6730d2a0f6b0f624, CX 267 SBBQ DI, CX 268 MOVQ CX, 16(DX) 269 MOVQ $0x64774b84f38512bf, CX 270 SBBQ R8, CX 271 MOVQ CX, 24(DX) 272 MOVQ $0x4b1ba7b6434bacd7, CX 273 SBBQ R9, CX 274 MOVQ CX, 32(DX) 275 MOVQ $0x1a0111ea397fe69a, CX 276 SBBQ R10, CX 277 MOVQ CX, 40(DX) 278 279l3: 280 MOVQ x+8(FP), AX 281 MOVQ 48(AX), BX 282 MOVQ 56(AX), SI 283 MOVQ 64(AX), DI 284 MOVQ 72(AX), R8 285 MOVQ 80(AX), R9 286 MOVQ 88(AX), R10 287 MOVQ BX, AX 288 ORQ SI, AX 289 ORQ DI, AX 290 ORQ R8, AX 291 ORQ R9, AX 292 ORQ R10, AX 293 TESTQ AX, AX 294 JNE l2 295 MOVQ AX, 48(DX) 296 MOVQ AX, 56(DX) 297 MOVQ AX, 64(DX) 298 MOVQ AX, 72(DX) 299 MOVQ AX, 80(DX) 300 MOVQ AX, 88(DX) 301 RET 302 303l2: 304 MOVQ $0xb9feffffffffaaab, CX 305 SUBQ BX, CX 306 MOVQ CX, 48(DX) 307 MOVQ $0x1eabfffeb153ffff, CX 308 SBBQ SI, CX 309 MOVQ CX, 56(DX) 310 MOVQ $0x6730d2a0f6b0f624, CX 311 SBBQ DI, CX 312 MOVQ CX, 64(DX) 313 MOVQ $0x64774b84f38512bf, CX 314 SBBQ R8, CX 315 MOVQ CX, 72(DX) 316 MOVQ $0x4b1ba7b6434bacd7, CX 317 SBBQ R9, CX 318 MOVQ CX, 80(DX) 319 MOVQ $0x1a0111ea397fe69a, CX 320 SBBQ R10, CX 321 MOVQ CX, 88(DX) 322 RET 323 324TEXT ·mulNonResE2(SB), NOSPLIT, $0-16 325 XORQ R15, R15 326 MOVQ x+8(FP), R14 327 MOVQ 0(R14), AX 328 MOVQ 8(R14), DX 329 MOVQ 16(R14), CX 330 MOVQ 24(R14), BX 331 MOVQ 32(R14), SI 332 MOVQ 40(R14), DI 333 SUBQ 48(R14), AX 334 SBBQ 56(R14), DX 335 SBBQ 64(R14), CX 336 SBBQ 72(R14), BX 337 SBBQ 80(R14), SI 338 SBBQ 88(R14), DI 339 MOVQ $0xb9feffffffffaaab, R8 340 MOVQ $0x1eabfffeb153ffff, R9 341 MOVQ $0x6730d2a0f6b0f624, R10 342 MOVQ $0x64774b84f38512bf, R11 343 MOVQ $0x4b1ba7b6434bacd7, R12 344 MOVQ $0x1a0111ea397fe69a, R13 345 CMOVQCC R15, R8 346 CMOVQCC R15, R9 347 CMOVQCC R15, R10 348 CMOVQCC R15, R11 349 CMOVQCC R15, R12 350 CMOVQCC R15, R13 351 ADDQ R8, AX 352 ADCQ R9, DX 353 ADCQ R10, CX 354 ADCQ R11, BX 355 ADCQ R12, SI 356 ADCQ R13, DI 357 MOVQ 48(R14), R8 358 MOVQ 56(R14), R9 359 MOVQ 64(R14), R10 360 MOVQ 72(R14), R11 361 MOVQ 80(R14), R12 362 MOVQ 88(R14), R13 363 ADDQ 0(R14), R8 364 ADCQ 8(R14), R9 365 ADCQ 16(R14), R10 366 ADCQ 24(R14), R11 367 ADCQ 32(R14), R12 368 ADCQ 40(R14), R13 369 MOVQ res+0(FP), R15 370 MOVQ AX, 0(R15) 371 MOVQ DX, 8(R15) 372 MOVQ CX, 16(R15) 373 MOVQ BX, 24(R15) 374 MOVQ SI, 32(R15) 375 MOVQ DI, 40(R15) 376 377 // reduce element(R8,R9,R10,R11,R12,R13) using temp registers (AX,DX,CX,BX,SI,DI) 378 REDUCE(R8,R9,R10,R11,R12,R13,AX,DX,CX,BX,SI,DI) 379 380 MOVQ R8, 48(R15) 381 MOVQ R9, 56(R15) 382 MOVQ R10, 64(R15) 383 MOVQ R11, 72(R15) 384 MOVQ R12, 80(R15) 385 MOVQ R13, 88(R15) 386 RET 387 388TEXT ·squareAdxE2(SB), $48-16 389 NO_LOCAL_POINTERS 390 391 // z.A0 = (x.A0 + x.A1) * (x.A0 - x.A1) 392 // z.A1 = 2 * x.A0 * x.A1 393 394 // 2 * x.A0 * x.A1 395 MOVQ x+8(FP), AX 396 397 // 2 * x.A1[0] -> R14 398 // 2 * x.A1[1] -> R15 399 // 2 * x.A1[2] -> CX 400 // 2 * x.A1[3] -> BX 401 // 2 * x.A1[4] -> SI 402 // 2 * x.A1[5] -> DI 403 MOVQ 48(AX), R14 404 MOVQ 56(AX), R15 405 MOVQ 64(AX), CX 406 MOVQ 72(AX), BX 407 MOVQ 80(AX), SI 408 MOVQ 88(AX), DI 409 ADDQ R14, R14 410 ADCQ R15, R15 411 ADCQ CX, CX 412 ADCQ BX, BX 413 ADCQ SI, SI 414 ADCQ DI, DI 415 416 // A -> BP 417 // t[0] -> R8 418 // t[1] -> R9 419 // t[2] -> R10 420 // t[3] -> R11 421 // t[4] -> R12 422 // t[5] -> R13 423 // clear the flags 424 XORQ AX, AX 425 MOVQ x+8(FP), DX 426 MOVQ 0(DX), DX 427 428 // (A,t[0]) := x[0]*y[0] + A 429 MULXQ R14, R8, R9 430 431 // (A,t[1]) := x[1]*y[0] + A 432 MULXQ R15, AX, R10 433 ADOXQ AX, R9 434 435 // (A,t[2]) := x[2]*y[0] + A 436 MULXQ CX, AX, R11 437 ADOXQ AX, R10 438 439 // (A,t[3]) := x[3]*y[0] + A 440 MULXQ BX, AX, R12 441 ADOXQ AX, R11 442 443 // (A,t[4]) := x[4]*y[0] + A 444 MULXQ SI, AX, R13 445 ADOXQ AX, R12 446 447 // (A,t[5]) := x[5]*y[0] + A 448 MULXQ DI, AX, BP 449 ADOXQ AX, R13 450 451 // A += carries from ADCXQ and ADOXQ 452 MOVQ $0, AX 453 ADOXQ AX, BP 454 PUSHQ BP 455 456 // m := t[0]*q'[0] mod W 457 MOVQ qInv0<>(SB), DX 458 IMULQ R8, DX 459 460 // clear the flags 461 XORQ AX, AX 462 463 // C,_ := t[0] + m*q[0] 464 MULXQ q<>+0(SB), AX, BP 465 ADCXQ R8, AX 466 MOVQ BP, R8 467 POPQ BP 468 469 // (C,t[0]) := t[1] + m*q[1] + C 470 ADCXQ R9, R8 471 MULXQ q<>+8(SB), AX, R9 472 ADOXQ AX, R8 473 474 // (C,t[1]) := t[2] + m*q[2] + C 475 ADCXQ R10, R9 476 MULXQ q<>+16(SB), AX, R10 477 ADOXQ AX, R9 478 479 // (C,t[2]) := t[3] + m*q[3] + C 480 ADCXQ R11, R10 481 MULXQ q<>+24(SB), AX, R11 482 ADOXQ AX, R10 483 484 // (C,t[3]) := t[4] + m*q[4] + C 485 ADCXQ R12, R11 486 MULXQ q<>+32(SB), AX, R12 487 ADOXQ AX, R11 488 489 // (C,t[4]) := t[5] + m*q[5] + C 490 ADCXQ R13, R12 491 MULXQ q<>+40(SB), AX, R13 492 ADOXQ AX, R12 493 494 // t[5] = C + A 495 MOVQ $0, AX 496 ADCXQ AX, R13 497 ADOXQ BP, R13 498 499 // clear the flags 500 XORQ AX, AX 501 MOVQ x+8(FP), DX 502 MOVQ 8(DX), DX 503 504 // (A,t[0]) := t[0] + x[0]*y[1] + A 505 MULXQ R14, AX, BP 506 ADOXQ AX, R8 507 508 // (A,t[1]) := t[1] + x[1]*y[1] + A 509 ADCXQ BP, R9 510 MULXQ R15, AX, BP 511 ADOXQ AX, R9 512 513 // (A,t[2]) := t[2] + x[2]*y[1] + A 514 ADCXQ BP, R10 515 MULXQ CX, AX, BP 516 ADOXQ AX, R10 517 518 // (A,t[3]) := t[3] + x[3]*y[1] + A 519 ADCXQ BP, R11 520 MULXQ BX, AX, BP 521 ADOXQ AX, R11 522 523 // (A,t[4]) := t[4] + x[4]*y[1] + A 524 ADCXQ BP, R12 525 MULXQ SI, AX, BP 526 ADOXQ AX, R12 527 528 // (A,t[5]) := t[5] + x[5]*y[1] + A 529 ADCXQ BP, R13 530 MULXQ DI, AX, BP 531 ADOXQ AX, R13 532 533 // A += carries from ADCXQ and ADOXQ 534 MOVQ $0, AX 535 ADCXQ AX, BP 536 ADOXQ AX, BP 537 PUSHQ BP 538 539 // m := t[0]*q'[0] mod W 540 MOVQ qInv0<>(SB), DX 541 IMULQ R8, DX 542 543 // clear the flags 544 XORQ AX, AX 545 546 // C,_ := t[0] + m*q[0] 547 MULXQ q<>+0(SB), AX, BP 548 ADCXQ R8, AX 549 MOVQ BP, R8 550 POPQ BP 551 552 // (C,t[0]) := t[1] + m*q[1] + C 553 ADCXQ R9, R8 554 MULXQ q<>+8(SB), AX, R9 555 ADOXQ AX, R8 556 557 // (C,t[1]) := t[2] + m*q[2] + C 558 ADCXQ R10, R9 559 MULXQ q<>+16(SB), AX, R10 560 ADOXQ AX, R9 561 562 // (C,t[2]) := t[3] + m*q[3] + C 563 ADCXQ R11, R10 564 MULXQ q<>+24(SB), AX, R11 565 ADOXQ AX, R10 566 567 // (C,t[3]) := t[4] + m*q[4] + C 568 ADCXQ R12, R11 569 MULXQ q<>+32(SB), AX, R12 570 ADOXQ AX, R11 571 572 // (C,t[4]) := t[5] + m*q[5] + C 573 ADCXQ R13, R12 574 MULXQ q<>+40(SB), AX, R13 575 ADOXQ AX, R12 576 577 // t[5] = C + A 578 MOVQ $0, AX 579 ADCXQ AX, R13 580 ADOXQ BP, R13 581 582 // clear the flags 583 XORQ AX, AX 584 MOVQ x+8(FP), DX 585 MOVQ 16(DX), DX 586 587 // (A,t[0]) := t[0] + x[0]*y[2] + A 588 MULXQ R14, AX, BP 589 ADOXQ AX, R8 590 591 // (A,t[1]) := t[1] + x[1]*y[2] + A 592 ADCXQ BP, R9 593 MULXQ R15, AX, BP 594 ADOXQ AX, R9 595 596 // (A,t[2]) := t[2] + x[2]*y[2] + A 597 ADCXQ BP, R10 598 MULXQ CX, AX, BP 599 ADOXQ AX, R10 600 601 // (A,t[3]) := t[3] + x[3]*y[2] + A 602 ADCXQ BP, R11 603 MULXQ BX, AX, BP 604 ADOXQ AX, R11 605 606 // (A,t[4]) := t[4] + x[4]*y[2] + A 607 ADCXQ BP, R12 608 MULXQ SI, AX, BP 609 ADOXQ AX, R12 610 611 // (A,t[5]) := t[5] + x[5]*y[2] + A 612 ADCXQ BP, R13 613 MULXQ DI, AX, BP 614 ADOXQ AX, R13 615 616 // A += carries from ADCXQ and ADOXQ 617 MOVQ $0, AX 618 ADCXQ AX, BP 619 ADOXQ AX, BP 620 PUSHQ BP 621 622 // m := t[0]*q'[0] mod W 623 MOVQ qInv0<>(SB), DX 624 IMULQ R8, DX 625 626 // clear the flags 627 XORQ AX, AX 628 629 // C,_ := t[0] + m*q[0] 630 MULXQ q<>+0(SB), AX, BP 631 ADCXQ R8, AX 632 MOVQ BP, R8 633 POPQ BP 634 635 // (C,t[0]) := t[1] + m*q[1] + C 636 ADCXQ R9, R8 637 MULXQ q<>+8(SB), AX, R9 638 ADOXQ AX, R8 639 640 // (C,t[1]) := t[2] + m*q[2] + C 641 ADCXQ R10, R9 642 MULXQ q<>+16(SB), AX, R10 643 ADOXQ AX, R9 644 645 // (C,t[2]) := t[3] + m*q[3] + C 646 ADCXQ R11, R10 647 MULXQ q<>+24(SB), AX, R11 648 ADOXQ AX, R10 649 650 // (C,t[3]) := t[4] + m*q[4] + C 651 ADCXQ R12, R11 652 MULXQ q<>+32(SB), AX, R12 653 ADOXQ AX, R11 654 655 // (C,t[4]) := t[5] + m*q[5] + C 656 ADCXQ R13, R12 657 MULXQ q<>+40(SB), AX, R13 658 ADOXQ AX, R12 659 660 // t[5] = C + A 661 MOVQ $0, AX 662 ADCXQ AX, R13 663 ADOXQ BP, R13 664 665 // clear the flags 666 XORQ AX, AX 667 MOVQ x+8(FP), DX 668 MOVQ 24(DX), DX 669 670 // (A,t[0]) := t[0] + x[0]*y[3] + A 671 MULXQ R14, AX, BP 672 ADOXQ AX, R8 673 674 // (A,t[1]) := t[1] + x[1]*y[3] + A 675 ADCXQ BP, R9 676 MULXQ R15, AX, BP 677 ADOXQ AX, R9 678 679 // (A,t[2]) := t[2] + x[2]*y[3] + A 680 ADCXQ BP, R10 681 MULXQ CX, AX, BP 682 ADOXQ AX, R10 683 684 // (A,t[3]) := t[3] + x[3]*y[3] + A 685 ADCXQ BP, R11 686 MULXQ BX, AX, BP 687 ADOXQ AX, R11 688 689 // (A,t[4]) := t[4] + x[4]*y[3] + A 690 ADCXQ BP, R12 691 MULXQ SI, AX, BP 692 ADOXQ AX, R12 693 694 // (A,t[5]) := t[5] + x[5]*y[3] + A 695 ADCXQ BP, R13 696 MULXQ DI, AX, BP 697 ADOXQ AX, R13 698 699 // A += carries from ADCXQ and ADOXQ 700 MOVQ $0, AX 701 ADCXQ AX, BP 702 ADOXQ AX, BP 703 PUSHQ BP 704 705 // m := t[0]*q'[0] mod W 706 MOVQ qInv0<>(SB), DX 707 IMULQ R8, DX 708 709 // clear the flags 710 XORQ AX, AX 711 712 // C,_ := t[0] + m*q[0] 713 MULXQ q<>+0(SB), AX, BP 714 ADCXQ R8, AX 715 MOVQ BP, R8 716 POPQ BP 717 718 // (C,t[0]) := t[1] + m*q[1] + C 719 ADCXQ R9, R8 720 MULXQ q<>+8(SB), AX, R9 721 ADOXQ AX, R8 722 723 // (C,t[1]) := t[2] + m*q[2] + C 724 ADCXQ R10, R9 725 MULXQ q<>+16(SB), AX, R10 726 ADOXQ AX, R9 727 728 // (C,t[2]) := t[3] + m*q[3] + C 729 ADCXQ R11, R10 730 MULXQ q<>+24(SB), AX, R11 731 ADOXQ AX, R10 732 733 // (C,t[3]) := t[4] + m*q[4] + C 734 ADCXQ R12, R11 735 MULXQ q<>+32(SB), AX, R12 736 ADOXQ AX, R11 737 738 // (C,t[4]) := t[5] + m*q[5] + C 739 ADCXQ R13, R12 740 MULXQ q<>+40(SB), AX, R13 741 ADOXQ AX, R12 742 743 // t[5] = C + A 744 MOVQ $0, AX 745 ADCXQ AX, R13 746 ADOXQ BP, R13 747 748 // clear the flags 749 XORQ AX, AX 750 MOVQ x+8(FP), DX 751 MOVQ 32(DX), DX 752 753 // (A,t[0]) := t[0] + x[0]*y[4] + A 754 MULXQ R14, AX, BP 755 ADOXQ AX, R8 756 757 // (A,t[1]) := t[1] + x[1]*y[4] + A 758 ADCXQ BP, R9 759 MULXQ R15, AX, BP 760 ADOXQ AX, R9 761 762 // (A,t[2]) := t[2] + x[2]*y[4] + A 763 ADCXQ BP, R10 764 MULXQ CX, AX, BP 765 ADOXQ AX, R10 766 767 // (A,t[3]) := t[3] + x[3]*y[4] + A 768 ADCXQ BP, R11 769 MULXQ BX, AX, BP 770 ADOXQ AX, R11 771 772 // (A,t[4]) := t[4] + x[4]*y[4] + A 773 ADCXQ BP, R12 774 MULXQ SI, AX, BP 775 ADOXQ AX, R12 776 777 // (A,t[5]) := t[5] + x[5]*y[4] + A 778 ADCXQ BP, R13 779 MULXQ DI, AX, BP 780 ADOXQ AX, R13 781 782 // A += carries from ADCXQ and ADOXQ 783 MOVQ $0, AX 784 ADCXQ AX, BP 785 ADOXQ AX, BP 786 PUSHQ BP 787 788 // m := t[0]*q'[0] mod W 789 MOVQ qInv0<>(SB), DX 790 IMULQ R8, DX 791 792 // clear the flags 793 XORQ AX, AX 794 795 // C,_ := t[0] + m*q[0] 796 MULXQ q<>+0(SB), AX, BP 797 ADCXQ R8, AX 798 MOVQ BP, R8 799 POPQ BP 800 801 // (C,t[0]) := t[1] + m*q[1] + C 802 ADCXQ R9, R8 803 MULXQ q<>+8(SB), AX, R9 804 ADOXQ AX, R8 805 806 // (C,t[1]) := t[2] + m*q[2] + C 807 ADCXQ R10, R9 808 MULXQ q<>+16(SB), AX, R10 809 ADOXQ AX, R9 810 811 // (C,t[2]) := t[3] + m*q[3] + C 812 ADCXQ R11, R10 813 MULXQ q<>+24(SB), AX, R11 814 ADOXQ AX, R10 815 816 // (C,t[3]) := t[4] + m*q[4] + C 817 ADCXQ R12, R11 818 MULXQ q<>+32(SB), AX, R12 819 ADOXQ AX, R11 820 821 // (C,t[4]) := t[5] + m*q[5] + C 822 ADCXQ R13, R12 823 MULXQ q<>+40(SB), AX, R13 824 ADOXQ AX, R12 825 826 // t[5] = C + A 827 MOVQ $0, AX 828 ADCXQ AX, R13 829 ADOXQ BP, R13 830 831 // clear the flags 832 XORQ AX, AX 833 MOVQ x+8(FP), DX 834 MOVQ 40(DX), DX 835 836 // (A,t[0]) := t[0] + x[0]*y[5] + A 837 MULXQ R14, AX, BP 838 ADOXQ AX, R8 839 840 // (A,t[1]) := t[1] + x[1]*y[5] + A 841 ADCXQ BP, R9 842 MULXQ R15, AX, BP 843 ADOXQ AX, R9 844 845 // (A,t[2]) := t[2] + x[2]*y[5] + A 846 ADCXQ BP, R10 847 MULXQ CX, AX, BP 848 ADOXQ AX, R10 849 850 // (A,t[3]) := t[3] + x[3]*y[5] + A 851 ADCXQ BP, R11 852 MULXQ BX, AX, BP 853 ADOXQ AX, R11 854 855 // (A,t[4]) := t[4] + x[4]*y[5] + A 856 ADCXQ BP, R12 857 MULXQ SI, AX, BP 858 ADOXQ AX, R12 859 860 // (A,t[5]) := t[5] + x[5]*y[5] + A 861 ADCXQ BP, R13 862 MULXQ DI, AX, BP 863 ADOXQ AX, R13 864 865 // A += carries from ADCXQ and ADOXQ 866 MOVQ $0, AX 867 ADCXQ AX, BP 868 ADOXQ AX, BP 869 PUSHQ BP 870 871 // m := t[0]*q'[0] mod W 872 MOVQ qInv0<>(SB), DX 873 IMULQ R8, DX 874 875 // clear the flags 876 XORQ AX, AX 877 878 // C,_ := t[0] + m*q[0] 879 MULXQ q<>+0(SB), AX, BP 880 ADCXQ R8, AX 881 MOVQ BP, R8 882 POPQ BP 883 884 // (C,t[0]) := t[1] + m*q[1] + C 885 ADCXQ R9, R8 886 MULXQ q<>+8(SB), AX, R9 887 ADOXQ AX, R8 888 889 // (C,t[1]) := t[2] + m*q[2] + C 890 ADCXQ R10, R9 891 MULXQ q<>+16(SB), AX, R10 892 ADOXQ AX, R9 893 894 // (C,t[2]) := t[3] + m*q[3] + C 895 ADCXQ R11, R10 896 MULXQ q<>+24(SB), AX, R11 897 ADOXQ AX, R10 898 899 // (C,t[3]) := t[4] + m*q[4] + C 900 ADCXQ R12, R11 901 MULXQ q<>+32(SB), AX, R12 902 ADOXQ AX, R11 903 904 // (C,t[4]) := t[5] + m*q[5] + C 905 ADCXQ R13, R12 906 MULXQ q<>+40(SB), AX, R13 907 ADOXQ AX, R12 908 909 // t[5] = C + A 910 MOVQ $0, AX 911 ADCXQ AX, R13 912 ADOXQ BP, R13 913 914 // reduce element(R8,R9,R10,R11,R12,R13) using temp registers (R14,R15,CX,BX,SI,DI) 915 REDUCE(R8,R9,R10,R11,R12,R13,R14,R15,CX,BX,SI,DI) 916 917 MOVQ x+8(FP), AX 918 919 // x.A1[0] -> R14 920 // x.A1[1] -> R15 921 // x.A1[2] -> CX 922 // x.A1[3] -> BX 923 // x.A1[4] -> SI 924 // x.A1[5] -> DI 925 MOVQ 48(AX), R14 926 MOVQ 56(AX), R15 927 MOVQ 64(AX), CX 928 MOVQ 72(AX), BX 929 MOVQ 80(AX), SI 930 MOVQ 88(AX), DI 931 MOVQ res+0(FP), DX 932 MOVQ R8, 48(DX) 933 MOVQ R9, 56(DX) 934 MOVQ R10, 64(DX) 935 MOVQ R11, 72(DX) 936 MOVQ R12, 80(DX) 937 MOVQ R13, 88(DX) 938 MOVQ R14, R8 939 MOVQ R15, R9 940 MOVQ CX, R10 941 MOVQ BX, R11 942 MOVQ SI, R12 943 MOVQ DI, R13 944 945 // Add(&x.A0, &x.A1) 946 ADDQ 0(AX), R14 947 ADCQ 8(AX), R15 948 ADCQ 16(AX), CX 949 ADCQ 24(AX), BX 950 ADCQ 32(AX), SI 951 ADCQ 40(AX), DI 952 MOVQ R14, s0-8(SP) 953 MOVQ R15, s1-16(SP) 954 MOVQ CX, s2-24(SP) 955 MOVQ BX, s3-32(SP) 956 MOVQ SI, s4-40(SP) 957 MOVQ DI, s5-48(SP) 958 XORQ BP, BP 959 960 // Sub(&x.A0, &x.A1) 961 MOVQ 0(AX), R14 962 MOVQ 8(AX), R15 963 MOVQ 16(AX), CX 964 MOVQ 24(AX), BX 965 MOVQ 32(AX), SI 966 MOVQ 40(AX), DI 967 SUBQ R8, R14 968 SBBQ R9, R15 969 SBBQ R10, CX 970 SBBQ R11, BX 971 SBBQ R12, SI 972 SBBQ R13, DI 973 MOVQ $0xb9feffffffffaaab, R8 974 MOVQ $0x1eabfffeb153ffff, R9 975 MOVQ $0x6730d2a0f6b0f624, R10 976 MOVQ $0x64774b84f38512bf, R11 977 MOVQ $0x4b1ba7b6434bacd7, R12 978 MOVQ $0x1a0111ea397fe69a, R13 979 CMOVQCC BP, R8 980 CMOVQCC BP, R9 981 CMOVQCC BP, R10 982 CMOVQCC BP, R11 983 CMOVQCC BP, R12 984 CMOVQCC BP, R13 985 ADDQ R8, R14 986 ADCQ R9, R15 987 ADCQ R10, CX 988 ADCQ R11, BX 989 ADCQ R12, SI 990 ADCQ R13, DI 991 992 // A -> BP 993 // t[0] -> R8 994 // t[1] -> R9 995 // t[2] -> R10 996 // t[3] -> R11 997 // t[4] -> R12 998 // t[5] -> R13 999 // clear the flags 1000 XORQ AX, AX 1001 MOVQ s0-8(SP), DX 1002 1003 // (A,t[0]) := x[0]*y[0] + A 1004 MULXQ R14, R8, R9 1005 1006 // (A,t[1]) := x[1]*y[0] + A 1007 MULXQ R15, AX, R10 1008 ADOXQ AX, R9 1009 1010 // (A,t[2]) := x[2]*y[0] + A 1011 MULXQ CX, AX, R11 1012 ADOXQ AX, R10 1013 1014 // (A,t[3]) := x[3]*y[0] + A 1015 MULXQ BX, AX, R12 1016 ADOXQ AX, R11 1017 1018 // (A,t[4]) := x[4]*y[0] + A 1019 MULXQ SI, AX, R13 1020 ADOXQ AX, R12 1021 1022 // (A,t[5]) := x[5]*y[0] + A 1023 MULXQ DI, AX, BP 1024 ADOXQ AX, R13 1025 1026 // A += carries from ADCXQ and ADOXQ 1027 MOVQ $0, AX 1028 ADOXQ AX, BP 1029 PUSHQ BP 1030 1031 // m := t[0]*q'[0] mod W 1032 MOVQ qInv0<>(SB), DX 1033 IMULQ R8, DX 1034 1035 // clear the flags 1036 XORQ AX, AX 1037 1038 // C,_ := t[0] + m*q[0] 1039 MULXQ q<>+0(SB), AX, BP 1040 ADCXQ R8, AX 1041 MOVQ BP, R8 1042 POPQ BP 1043 1044 // (C,t[0]) := t[1] + m*q[1] + C 1045 ADCXQ R9, R8 1046 MULXQ q<>+8(SB), AX, R9 1047 ADOXQ AX, R8 1048 1049 // (C,t[1]) := t[2] + m*q[2] + C 1050 ADCXQ R10, R9 1051 MULXQ q<>+16(SB), AX, R10 1052 ADOXQ AX, R9 1053 1054 // (C,t[2]) := t[3] + m*q[3] + C 1055 ADCXQ R11, R10 1056 MULXQ q<>+24(SB), AX, R11 1057 ADOXQ AX, R10 1058 1059 // (C,t[3]) := t[4] + m*q[4] + C 1060 ADCXQ R12, R11 1061 MULXQ q<>+32(SB), AX, R12 1062 ADOXQ AX, R11 1063 1064 // (C,t[4]) := t[5] + m*q[5] + C 1065 ADCXQ R13, R12 1066 MULXQ q<>+40(SB), AX, R13 1067 ADOXQ AX, R12 1068 1069 // t[5] = C + A 1070 MOVQ $0, AX 1071 ADCXQ AX, R13 1072 ADOXQ BP, R13 1073 1074 // clear the flags 1075 XORQ AX, AX 1076 MOVQ s1-16(SP), DX 1077 1078 // (A,t[0]) := t[0] + x[0]*y[1] + A 1079 MULXQ R14, AX, BP 1080 ADOXQ AX, R8 1081 1082 // (A,t[1]) := t[1] + x[1]*y[1] + A 1083 ADCXQ BP, R9 1084 MULXQ R15, AX, BP 1085 ADOXQ AX, R9 1086 1087 // (A,t[2]) := t[2] + x[2]*y[1] + A 1088 ADCXQ BP, R10 1089 MULXQ CX, AX, BP 1090 ADOXQ AX, R10 1091 1092 // (A,t[3]) := t[3] + x[3]*y[1] + A 1093 ADCXQ BP, R11 1094 MULXQ BX, AX, BP 1095 ADOXQ AX, R11 1096 1097 // (A,t[4]) := t[4] + x[4]*y[1] + A 1098 ADCXQ BP, R12 1099 MULXQ SI, AX, BP 1100 ADOXQ AX, R12 1101 1102 // (A,t[5]) := t[5] + x[5]*y[1] + A 1103 ADCXQ BP, R13 1104 MULXQ DI, AX, BP 1105 ADOXQ AX, R13 1106 1107 // A += carries from ADCXQ and ADOXQ 1108 MOVQ $0, AX 1109 ADCXQ AX, BP 1110 ADOXQ AX, BP 1111 PUSHQ BP 1112 1113 // m := t[0]*q'[0] mod W 1114 MOVQ qInv0<>(SB), DX 1115 IMULQ R8, DX 1116 1117 // clear the flags 1118 XORQ AX, AX 1119 1120 // C,_ := t[0] + m*q[0] 1121 MULXQ q<>+0(SB), AX, BP 1122 ADCXQ R8, AX 1123 MOVQ BP, R8 1124 POPQ BP 1125 1126 // (C,t[0]) := t[1] + m*q[1] + C 1127 ADCXQ R9, R8 1128 MULXQ q<>+8(SB), AX, R9 1129 ADOXQ AX, R8 1130 1131 // (C,t[1]) := t[2] + m*q[2] + C 1132 ADCXQ R10, R9 1133 MULXQ q<>+16(SB), AX, R10 1134 ADOXQ AX, R9 1135 1136 // (C,t[2]) := t[3] + m*q[3] + C 1137 ADCXQ R11, R10 1138 MULXQ q<>+24(SB), AX, R11 1139 ADOXQ AX, R10 1140 1141 // (C,t[3]) := t[4] + m*q[4] + C 1142 ADCXQ R12, R11 1143 MULXQ q<>+32(SB), AX, R12 1144 ADOXQ AX, R11 1145 1146 // (C,t[4]) := t[5] + m*q[5] + C 1147 ADCXQ R13, R12 1148 MULXQ q<>+40(SB), AX, R13 1149 ADOXQ AX, R12 1150 1151 // t[5] = C + A 1152 MOVQ $0, AX 1153 ADCXQ AX, R13 1154 ADOXQ BP, R13 1155 1156 // clear the flags 1157 XORQ AX, AX 1158 MOVQ s2-24(SP), DX 1159 1160 // (A,t[0]) := t[0] + x[0]*y[2] + A 1161 MULXQ R14, AX, BP 1162 ADOXQ AX, R8 1163 1164 // (A,t[1]) := t[1] + x[1]*y[2] + A 1165 ADCXQ BP, R9 1166 MULXQ R15, AX, BP 1167 ADOXQ AX, R9 1168 1169 // (A,t[2]) := t[2] + x[2]*y[2] + A 1170 ADCXQ BP, R10 1171 MULXQ CX, AX, BP 1172 ADOXQ AX, R10 1173 1174 // (A,t[3]) := t[3] + x[3]*y[2] + A 1175 ADCXQ BP, R11 1176 MULXQ BX, AX, BP 1177 ADOXQ AX, R11 1178 1179 // (A,t[4]) := t[4] + x[4]*y[2] + A 1180 ADCXQ BP, R12 1181 MULXQ SI, AX, BP 1182 ADOXQ AX, R12 1183 1184 // (A,t[5]) := t[5] + x[5]*y[2] + A 1185 ADCXQ BP, R13 1186 MULXQ DI, AX, BP 1187 ADOXQ AX, R13 1188 1189 // A += carries from ADCXQ and ADOXQ 1190 MOVQ $0, AX 1191 ADCXQ AX, BP 1192 ADOXQ AX, BP 1193 PUSHQ BP 1194 1195 // m := t[0]*q'[0] mod W 1196 MOVQ qInv0<>(SB), DX 1197 IMULQ R8, DX 1198 1199 // clear the flags 1200 XORQ AX, AX 1201 1202 // C,_ := t[0] + m*q[0] 1203 MULXQ q<>+0(SB), AX, BP 1204 ADCXQ R8, AX 1205 MOVQ BP, R8 1206 POPQ BP 1207 1208 // (C,t[0]) := t[1] + m*q[1] + C 1209 ADCXQ R9, R8 1210 MULXQ q<>+8(SB), AX, R9 1211 ADOXQ AX, R8 1212 1213 // (C,t[1]) := t[2] + m*q[2] + C 1214 ADCXQ R10, R9 1215 MULXQ q<>+16(SB), AX, R10 1216 ADOXQ AX, R9 1217 1218 // (C,t[2]) := t[3] + m*q[3] + C 1219 ADCXQ R11, R10 1220 MULXQ q<>+24(SB), AX, R11 1221 ADOXQ AX, R10 1222 1223 // (C,t[3]) := t[4] + m*q[4] + C 1224 ADCXQ R12, R11 1225 MULXQ q<>+32(SB), AX, R12 1226 ADOXQ AX, R11 1227 1228 // (C,t[4]) := t[5] + m*q[5] + C 1229 ADCXQ R13, R12 1230 MULXQ q<>+40(SB), AX, R13 1231 ADOXQ AX, R12 1232 1233 // t[5] = C + A 1234 MOVQ $0, AX 1235 ADCXQ AX, R13 1236 ADOXQ BP, R13 1237 1238 // clear the flags 1239 XORQ AX, AX 1240 MOVQ s3-32(SP), DX 1241 1242 // (A,t[0]) := t[0] + x[0]*y[3] + A 1243 MULXQ R14, AX, BP 1244 ADOXQ AX, R8 1245 1246 // (A,t[1]) := t[1] + x[1]*y[3] + A 1247 ADCXQ BP, R9 1248 MULXQ R15, AX, BP 1249 ADOXQ AX, R9 1250 1251 // (A,t[2]) := t[2] + x[2]*y[3] + A 1252 ADCXQ BP, R10 1253 MULXQ CX, AX, BP 1254 ADOXQ AX, R10 1255 1256 // (A,t[3]) := t[3] + x[3]*y[3] + A 1257 ADCXQ BP, R11 1258 MULXQ BX, AX, BP 1259 ADOXQ AX, R11 1260 1261 // (A,t[4]) := t[4] + x[4]*y[3] + A 1262 ADCXQ BP, R12 1263 MULXQ SI, AX, BP 1264 ADOXQ AX, R12 1265 1266 // (A,t[5]) := t[5] + x[5]*y[3] + A 1267 ADCXQ BP, R13 1268 MULXQ DI, AX, BP 1269 ADOXQ AX, R13 1270 1271 // A += carries from ADCXQ and ADOXQ 1272 MOVQ $0, AX 1273 ADCXQ AX, BP 1274 ADOXQ AX, BP 1275 PUSHQ BP 1276 1277 // m := t[0]*q'[0] mod W 1278 MOVQ qInv0<>(SB), DX 1279 IMULQ R8, DX 1280 1281 // clear the flags 1282 XORQ AX, AX 1283 1284 // C,_ := t[0] + m*q[0] 1285 MULXQ q<>+0(SB), AX, BP 1286 ADCXQ R8, AX 1287 MOVQ BP, R8 1288 POPQ BP 1289 1290 // (C,t[0]) := t[1] + m*q[1] + C 1291 ADCXQ R9, R8 1292 MULXQ q<>+8(SB), AX, R9 1293 ADOXQ AX, R8 1294 1295 // (C,t[1]) := t[2] + m*q[2] + C 1296 ADCXQ R10, R9 1297 MULXQ q<>+16(SB), AX, R10 1298 ADOXQ AX, R9 1299 1300 // (C,t[2]) := t[3] + m*q[3] + C 1301 ADCXQ R11, R10 1302 MULXQ q<>+24(SB), AX, R11 1303 ADOXQ AX, R10 1304 1305 // (C,t[3]) := t[4] + m*q[4] + C 1306 ADCXQ R12, R11 1307 MULXQ q<>+32(SB), AX, R12 1308 ADOXQ AX, R11 1309 1310 // (C,t[4]) := t[5] + m*q[5] + C 1311 ADCXQ R13, R12 1312 MULXQ q<>+40(SB), AX, R13 1313 ADOXQ AX, R12 1314 1315 // t[5] = C + A 1316 MOVQ $0, AX 1317 ADCXQ AX, R13 1318 ADOXQ BP, R13 1319 1320 // clear the flags 1321 XORQ AX, AX 1322 MOVQ s4-40(SP), DX 1323 1324 // (A,t[0]) := t[0] + x[0]*y[4] + A 1325 MULXQ R14, AX, BP 1326 ADOXQ AX, R8 1327 1328 // (A,t[1]) := t[1] + x[1]*y[4] + A 1329 ADCXQ BP, R9 1330 MULXQ R15, AX, BP 1331 ADOXQ AX, R9 1332 1333 // (A,t[2]) := t[2] + x[2]*y[4] + A 1334 ADCXQ BP, R10 1335 MULXQ CX, AX, BP 1336 ADOXQ AX, R10 1337 1338 // (A,t[3]) := t[3] + x[3]*y[4] + A 1339 ADCXQ BP, R11 1340 MULXQ BX, AX, BP 1341 ADOXQ AX, R11 1342 1343 // (A,t[4]) := t[4] + x[4]*y[4] + A 1344 ADCXQ BP, R12 1345 MULXQ SI, AX, BP 1346 ADOXQ AX, R12 1347 1348 // (A,t[5]) := t[5] + x[5]*y[4] + A 1349 ADCXQ BP, R13 1350 MULXQ DI, AX, BP 1351 ADOXQ AX, R13 1352 1353 // A += carries from ADCXQ and ADOXQ 1354 MOVQ $0, AX 1355 ADCXQ AX, BP 1356 ADOXQ AX, BP 1357 PUSHQ BP 1358 1359 // m := t[0]*q'[0] mod W 1360 MOVQ qInv0<>(SB), DX 1361 IMULQ R8, DX 1362 1363 // clear the flags 1364 XORQ AX, AX 1365 1366 // C,_ := t[0] + m*q[0] 1367 MULXQ q<>+0(SB), AX, BP 1368 ADCXQ R8, AX 1369 MOVQ BP, R8 1370 POPQ BP 1371 1372 // (C,t[0]) := t[1] + m*q[1] + C 1373 ADCXQ R9, R8 1374 MULXQ q<>+8(SB), AX, R9 1375 ADOXQ AX, R8 1376 1377 // (C,t[1]) := t[2] + m*q[2] + C 1378 ADCXQ R10, R9 1379 MULXQ q<>+16(SB), AX, R10 1380 ADOXQ AX, R9 1381 1382 // (C,t[2]) := t[3] + m*q[3] + C 1383 ADCXQ R11, R10 1384 MULXQ q<>+24(SB), AX, R11 1385 ADOXQ AX, R10 1386 1387 // (C,t[3]) := t[4] + m*q[4] + C 1388 ADCXQ R12, R11 1389 MULXQ q<>+32(SB), AX, R12 1390 ADOXQ AX, R11 1391 1392 // (C,t[4]) := t[5] + m*q[5] + C 1393 ADCXQ R13, R12 1394 MULXQ q<>+40(SB), AX, R13 1395 ADOXQ AX, R12 1396 1397 // t[5] = C + A 1398 MOVQ $0, AX 1399 ADCXQ AX, R13 1400 ADOXQ BP, R13 1401 1402 // clear the flags 1403 XORQ AX, AX 1404 MOVQ s5-48(SP), DX 1405 1406 // (A,t[0]) := t[0] + x[0]*y[5] + A 1407 MULXQ R14, AX, BP 1408 ADOXQ AX, R8 1409 1410 // (A,t[1]) := t[1] + x[1]*y[5] + A 1411 ADCXQ BP, R9 1412 MULXQ R15, AX, BP 1413 ADOXQ AX, R9 1414 1415 // (A,t[2]) := t[2] + x[2]*y[5] + A 1416 ADCXQ BP, R10 1417 MULXQ CX, AX, BP 1418 ADOXQ AX, R10 1419 1420 // (A,t[3]) := t[3] + x[3]*y[5] + A 1421 ADCXQ BP, R11 1422 MULXQ BX, AX, BP 1423 ADOXQ AX, R11 1424 1425 // (A,t[4]) := t[4] + x[4]*y[5] + A 1426 ADCXQ BP, R12 1427 MULXQ SI, AX, BP 1428 ADOXQ AX, R12 1429 1430 // (A,t[5]) := t[5] + x[5]*y[5] + A 1431 ADCXQ BP, R13 1432 MULXQ DI, AX, BP 1433 ADOXQ AX, R13 1434 1435 // A += carries from ADCXQ and ADOXQ 1436 MOVQ $0, AX 1437 ADCXQ AX, BP 1438 ADOXQ AX, BP 1439 PUSHQ BP 1440 1441 // m := t[0]*q'[0] mod W 1442 MOVQ qInv0<>(SB), DX 1443 IMULQ R8, DX 1444 1445 // clear the flags 1446 XORQ AX, AX 1447 1448 // C,_ := t[0] + m*q[0] 1449 MULXQ q<>+0(SB), AX, BP 1450 ADCXQ R8, AX 1451 MOVQ BP, R8 1452 POPQ BP 1453 1454 // (C,t[0]) := t[1] + m*q[1] + C 1455 ADCXQ R9, R8 1456 MULXQ q<>+8(SB), AX, R9 1457 ADOXQ AX, R8 1458 1459 // (C,t[1]) := t[2] + m*q[2] + C 1460 ADCXQ R10, R9 1461 MULXQ q<>+16(SB), AX, R10 1462 ADOXQ AX, R9 1463 1464 // (C,t[2]) := t[3] + m*q[3] + C 1465 ADCXQ R11, R10 1466 MULXQ q<>+24(SB), AX, R11 1467 ADOXQ AX, R10 1468 1469 // (C,t[3]) := t[4] + m*q[4] + C 1470 ADCXQ R12, R11 1471 MULXQ q<>+32(SB), AX, R12 1472 ADOXQ AX, R11 1473 1474 // (C,t[4]) := t[5] + m*q[5] + C 1475 ADCXQ R13, R12 1476 MULXQ q<>+40(SB), AX, R13 1477 ADOXQ AX, R12 1478 1479 // t[5] = C + A 1480 MOVQ $0, AX 1481 ADCXQ AX, R13 1482 ADOXQ BP, R13 1483 1484 // reduce element(R8,R9,R10,R11,R12,R13) using temp registers (R14,R15,CX,BX,SI,DI) 1485 REDUCE(R8,R9,R10,R11,R12,R13,R14,R15,CX,BX,SI,DI) 1486 1487 MOVQ res+0(FP), AX 1488 MOVQ R8, 0(AX) 1489 MOVQ R9, 8(AX) 1490 MOVQ R10, 16(AX) 1491 MOVQ R11, 24(AX) 1492 MOVQ R12, 32(AX) 1493 MOVQ R13, 40(AX) 1494 RET 1495 1496TEXT ·mulAdxE2(SB), $96-24 1497 NO_LOCAL_POINTERS 1498 1499 // var a, b, c fp.Element 1500 // a.Add(&x.A0, &x.A1) 1501 // b.Add(&y.A0, &y.A1) 1502 // a.Mul(&a, &b) 1503 // b.Mul(&x.A0, &y.A0) 1504 // c.Mul(&x.A1, &y.A1) 1505 // z.A1.Sub(&a, &b).Sub(&z.A1, &c) 1506 // z.A0.Sub(&b, &c) 1507 1508 MOVQ x+8(FP), AX 1509 MOVQ 48(AX), R14 1510 MOVQ 56(AX), R15 1511 MOVQ 64(AX), CX 1512 MOVQ 72(AX), BX 1513 MOVQ 80(AX), SI 1514 MOVQ 88(AX), DI 1515 1516 // A -> BP 1517 // t[0] -> R8 1518 // t[1] -> R9 1519 // t[2] -> R10 1520 // t[3] -> R11 1521 // t[4] -> R12 1522 // t[5] -> R13 1523 // clear the flags 1524 XORQ AX, AX 1525 MOVQ y+16(FP), DX 1526 MOVQ 48(DX), DX 1527 1528 // (A,t[0]) := x[0]*y[0] + A 1529 MULXQ R14, R8, R9 1530 1531 // (A,t[1]) := x[1]*y[0] + A 1532 MULXQ R15, AX, R10 1533 ADOXQ AX, R9 1534 1535 // (A,t[2]) := x[2]*y[0] + A 1536 MULXQ CX, AX, R11 1537 ADOXQ AX, R10 1538 1539 // (A,t[3]) := x[3]*y[0] + A 1540 MULXQ BX, AX, R12 1541 ADOXQ AX, R11 1542 1543 // (A,t[4]) := x[4]*y[0] + A 1544 MULXQ SI, AX, R13 1545 ADOXQ AX, R12 1546 1547 // (A,t[5]) := x[5]*y[0] + A 1548 MULXQ DI, AX, BP 1549 ADOXQ AX, R13 1550 1551 // A += carries from ADCXQ and ADOXQ 1552 MOVQ $0, AX 1553 ADOXQ AX, BP 1554 PUSHQ BP 1555 1556 // m := t[0]*q'[0] mod W 1557 MOVQ qInv0<>(SB), DX 1558 IMULQ R8, DX 1559 1560 // clear the flags 1561 XORQ AX, AX 1562 1563 // C,_ := t[0] + m*q[0] 1564 MULXQ q<>+0(SB), AX, BP 1565 ADCXQ R8, AX 1566 MOVQ BP, R8 1567 POPQ BP 1568 1569 // (C,t[0]) := t[1] + m*q[1] + C 1570 ADCXQ R9, R8 1571 MULXQ q<>+8(SB), AX, R9 1572 ADOXQ AX, R8 1573 1574 // (C,t[1]) := t[2] + m*q[2] + C 1575 ADCXQ R10, R9 1576 MULXQ q<>+16(SB), AX, R10 1577 ADOXQ AX, R9 1578 1579 // (C,t[2]) := t[3] + m*q[3] + C 1580 ADCXQ R11, R10 1581 MULXQ q<>+24(SB), AX, R11 1582 ADOXQ AX, R10 1583 1584 // (C,t[3]) := t[4] + m*q[4] + C 1585 ADCXQ R12, R11 1586 MULXQ q<>+32(SB), AX, R12 1587 ADOXQ AX, R11 1588 1589 // (C,t[4]) := t[5] + m*q[5] + C 1590 ADCXQ R13, R12 1591 MULXQ q<>+40(SB), AX, R13 1592 ADOXQ AX, R12 1593 1594 // t[5] = C + A 1595 MOVQ $0, AX 1596 ADCXQ AX, R13 1597 ADOXQ BP, R13 1598 1599 // clear the flags 1600 XORQ AX, AX 1601 MOVQ y+16(FP), DX 1602 MOVQ 56(DX), DX 1603 1604 // (A,t[0]) := t[0] + x[0]*y[1] + A 1605 MULXQ R14, AX, BP 1606 ADOXQ AX, R8 1607 1608 // (A,t[1]) := t[1] + x[1]*y[1] + A 1609 ADCXQ BP, R9 1610 MULXQ R15, AX, BP 1611 ADOXQ AX, R9 1612 1613 // (A,t[2]) := t[2] + x[2]*y[1] + A 1614 ADCXQ BP, R10 1615 MULXQ CX, AX, BP 1616 ADOXQ AX, R10 1617 1618 // (A,t[3]) := t[3] + x[3]*y[1] + A 1619 ADCXQ BP, R11 1620 MULXQ BX, AX, BP 1621 ADOXQ AX, R11 1622 1623 // (A,t[4]) := t[4] + x[4]*y[1] + A 1624 ADCXQ BP, R12 1625 MULXQ SI, AX, BP 1626 ADOXQ AX, R12 1627 1628 // (A,t[5]) := t[5] + x[5]*y[1] + A 1629 ADCXQ BP, R13 1630 MULXQ DI, AX, BP 1631 ADOXQ AX, R13 1632 1633 // A += carries from ADCXQ and ADOXQ 1634 MOVQ $0, AX 1635 ADCXQ AX, BP 1636 ADOXQ AX, BP 1637 PUSHQ BP 1638 1639 // m := t[0]*q'[0] mod W 1640 MOVQ qInv0<>(SB), DX 1641 IMULQ R8, DX 1642 1643 // clear the flags 1644 XORQ AX, AX 1645 1646 // C,_ := t[0] + m*q[0] 1647 MULXQ q<>+0(SB), AX, BP 1648 ADCXQ R8, AX 1649 MOVQ BP, R8 1650 POPQ BP 1651 1652 // (C,t[0]) := t[1] + m*q[1] + C 1653 ADCXQ R9, R8 1654 MULXQ q<>+8(SB), AX, R9 1655 ADOXQ AX, R8 1656 1657 // (C,t[1]) := t[2] + m*q[2] + C 1658 ADCXQ R10, R9 1659 MULXQ q<>+16(SB), AX, R10 1660 ADOXQ AX, R9 1661 1662 // (C,t[2]) := t[3] + m*q[3] + C 1663 ADCXQ R11, R10 1664 MULXQ q<>+24(SB), AX, R11 1665 ADOXQ AX, R10 1666 1667 // (C,t[3]) := t[4] + m*q[4] + C 1668 ADCXQ R12, R11 1669 MULXQ q<>+32(SB), AX, R12 1670 ADOXQ AX, R11 1671 1672 // (C,t[4]) := t[5] + m*q[5] + C 1673 ADCXQ R13, R12 1674 MULXQ q<>+40(SB), AX, R13 1675 ADOXQ AX, R12 1676 1677 // t[5] = C + A 1678 MOVQ $0, AX 1679 ADCXQ AX, R13 1680 ADOXQ BP, R13 1681 1682 // clear the flags 1683 XORQ AX, AX 1684 MOVQ y+16(FP), DX 1685 MOVQ 64(DX), DX 1686 1687 // (A,t[0]) := t[0] + x[0]*y[2] + A 1688 MULXQ R14, AX, BP 1689 ADOXQ AX, R8 1690 1691 // (A,t[1]) := t[1] + x[1]*y[2] + A 1692 ADCXQ BP, R9 1693 MULXQ R15, AX, BP 1694 ADOXQ AX, R9 1695 1696 // (A,t[2]) := t[2] + x[2]*y[2] + A 1697 ADCXQ BP, R10 1698 MULXQ CX, AX, BP 1699 ADOXQ AX, R10 1700 1701 // (A,t[3]) := t[3] + x[3]*y[2] + A 1702 ADCXQ BP, R11 1703 MULXQ BX, AX, BP 1704 ADOXQ AX, R11 1705 1706 // (A,t[4]) := t[4] + x[4]*y[2] + A 1707 ADCXQ BP, R12 1708 MULXQ SI, AX, BP 1709 ADOXQ AX, R12 1710 1711 // (A,t[5]) := t[5] + x[5]*y[2] + A 1712 ADCXQ BP, R13 1713 MULXQ DI, AX, BP 1714 ADOXQ AX, R13 1715 1716 // A += carries from ADCXQ and ADOXQ 1717 MOVQ $0, AX 1718 ADCXQ AX, BP 1719 ADOXQ AX, BP 1720 PUSHQ BP 1721 1722 // m := t[0]*q'[0] mod W 1723 MOVQ qInv0<>(SB), DX 1724 IMULQ R8, DX 1725 1726 // clear the flags 1727 XORQ AX, AX 1728 1729 // C,_ := t[0] + m*q[0] 1730 MULXQ q<>+0(SB), AX, BP 1731 ADCXQ R8, AX 1732 MOVQ BP, R8 1733 POPQ BP 1734 1735 // (C,t[0]) := t[1] + m*q[1] + C 1736 ADCXQ R9, R8 1737 MULXQ q<>+8(SB), AX, R9 1738 ADOXQ AX, R8 1739 1740 // (C,t[1]) := t[2] + m*q[2] + C 1741 ADCXQ R10, R9 1742 MULXQ q<>+16(SB), AX, R10 1743 ADOXQ AX, R9 1744 1745 // (C,t[2]) := t[3] + m*q[3] + C 1746 ADCXQ R11, R10 1747 MULXQ q<>+24(SB), AX, R11 1748 ADOXQ AX, R10 1749 1750 // (C,t[3]) := t[4] + m*q[4] + C 1751 ADCXQ R12, R11 1752 MULXQ q<>+32(SB), AX, R12 1753 ADOXQ AX, R11 1754 1755 // (C,t[4]) := t[5] + m*q[5] + C 1756 ADCXQ R13, R12 1757 MULXQ q<>+40(SB), AX, R13 1758 ADOXQ AX, R12 1759 1760 // t[5] = C + A 1761 MOVQ $0, AX 1762 ADCXQ AX, R13 1763 ADOXQ BP, R13 1764 1765 // clear the flags 1766 XORQ AX, AX 1767 MOVQ y+16(FP), DX 1768 MOVQ 72(DX), DX 1769 1770 // (A,t[0]) := t[0] + x[0]*y[3] + A 1771 MULXQ R14, AX, BP 1772 ADOXQ AX, R8 1773 1774 // (A,t[1]) := t[1] + x[1]*y[3] + A 1775 ADCXQ BP, R9 1776 MULXQ R15, AX, BP 1777 ADOXQ AX, R9 1778 1779 // (A,t[2]) := t[2] + x[2]*y[3] + A 1780 ADCXQ BP, R10 1781 MULXQ CX, AX, BP 1782 ADOXQ AX, R10 1783 1784 // (A,t[3]) := t[3] + x[3]*y[3] + A 1785 ADCXQ BP, R11 1786 MULXQ BX, AX, BP 1787 ADOXQ AX, R11 1788 1789 // (A,t[4]) := t[4] + x[4]*y[3] + A 1790 ADCXQ BP, R12 1791 MULXQ SI, AX, BP 1792 ADOXQ AX, R12 1793 1794 // (A,t[5]) := t[5] + x[5]*y[3] + A 1795 ADCXQ BP, R13 1796 MULXQ DI, AX, BP 1797 ADOXQ AX, R13 1798 1799 // A += carries from ADCXQ and ADOXQ 1800 MOVQ $0, AX 1801 ADCXQ AX, BP 1802 ADOXQ AX, BP 1803 PUSHQ BP 1804 1805 // m := t[0]*q'[0] mod W 1806 MOVQ qInv0<>(SB), DX 1807 IMULQ R8, DX 1808 1809 // clear the flags 1810 XORQ AX, AX 1811 1812 // C,_ := t[0] + m*q[0] 1813 MULXQ q<>+0(SB), AX, BP 1814 ADCXQ R8, AX 1815 MOVQ BP, R8 1816 POPQ BP 1817 1818 // (C,t[0]) := t[1] + m*q[1] + C 1819 ADCXQ R9, R8 1820 MULXQ q<>+8(SB), AX, R9 1821 ADOXQ AX, R8 1822 1823 // (C,t[1]) := t[2] + m*q[2] + C 1824 ADCXQ R10, R9 1825 MULXQ q<>+16(SB), AX, R10 1826 ADOXQ AX, R9 1827 1828 // (C,t[2]) := t[3] + m*q[3] + C 1829 ADCXQ R11, R10 1830 MULXQ q<>+24(SB), AX, R11 1831 ADOXQ AX, R10 1832 1833 // (C,t[3]) := t[4] + m*q[4] + C 1834 ADCXQ R12, R11 1835 MULXQ q<>+32(SB), AX, R12 1836 ADOXQ AX, R11 1837 1838 // (C,t[4]) := t[5] + m*q[5] + C 1839 ADCXQ R13, R12 1840 MULXQ q<>+40(SB), AX, R13 1841 ADOXQ AX, R12 1842 1843 // t[5] = C + A 1844 MOVQ $0, AX 1845 ADCXQ AX, R13 1846 ADOXQ BP, R13 1847 1848 // clear the flags 1849 XORQ AX, AX 1850 MOVQ y+16(FP), DX 1851 MOVQ 80(DX), DX 1852 1853 // (A,t[0]) := t[0] + x[0]*y[4] + A 1854 MULXQ R14, AX, BP 1855 ADOXQ AX, R8 1856 1857 // (A,t[1]) := t[1] + x[1]*y[4] + A 1858 ADCXQ BP, R9 1859 MULXQ R15, AX, BP 1860 ADOXQ AX, R9 1861 1862 // (A,t[2]) := t[2] + x[2]*y[4] + A 1863 ADCXQ BP, R10 1864 MULXQ CX, AX, BP 1865 ADOXQ AX, R10 1866 1867 // (A,t[3]) := t[3] + x[3]*y[4] + A 1868 ADCXQ BP, R11 1869 MULXQ BX, AX, BP 1870 ADOXQ AX, R11 1871 1872 // (A,t[4]) := t[4] + x[4]*y[4] + A 1873 ADCXQ BP, R12 1874 MULXQ SI, AX, BP 1875 ADOXQ AX, R12 1876 1877 // (A,t[5]) := t[5] + x[5]*y[4] + A 1878 ADCXQ BP, R13 1879 MULXQ DI, AX, BP 1880 ADOXQ AX, R13 1881 1882 // A += carries from ADCXQ and ADOXQ 1883 MOVQ $0, AX 1884 ADCXQ AX, BP 1885 ADOXQ AX, BP 1886 PUSHQ BP 1887 1888 // m := t[0]*q'[0] mod W 1889 MOVQ qInv0<>(SB), DX 1890 IMULQ R8, DX 1891 1892 // clear the flags 1893 XORQ AX, AX 1894 1895 // C,_ := t[0] + m*q[0] 1896 MULXQ q<>+0(SB), AX, BP 1897 ADCXQ R8, AX 1898 MOVQ BP, R8 1899 POPQ BP 1900 1901 // (C,t[0]) := t[1] + m*q[1] + C 1902 ADCXQ R9, R8 1903 MULXQ q<>+8(SB), AX, R9 1904 ADOXQ AX, R8 1905 1906 // (C,t[1]) := t[2] + m*q[2] + C 1907 ADCXQ R10, R9 1908 MULXQ q<>+16(SB), AX, R10 1909 ADOXQ AX, R9 1910 1911 // (C,t[2]) := t[3] + m*q[3] + C 1912 ADCXQ R11, R10 1913 MULXQ q<>+24(SB), AX, R11 1914 ADOXQ AX, R10 1915 1916 // (C,t[3]) := t[4] + m*q[4] + C 1917 ADCXQ R12, R11 1918 MULXQ q<>+32(SB), AX, R12 1919 ADOXQ AX, R11 1920 1921 // (C,t[4]) := t[5] + m*q[5] + C 1922 ADCXQ R13, R12 1923 MULXQ q<>+40(SB), AX, R13 1924 ADOXQ AX, R12 1925 1926 // t[5] = C + A 1927 MOVQ $0, AX 1928 ADCXQ AX, R13 1929 ADOXQ BP, R13 1930 1931 // clear the flags 1932 XORQ AX, AX 1933 MOVQ y+16(FP), DX 1934 MOVQ 88(DX), DX 1935 1936 // (A,t[0]) := t[0] + x[0]*y[5] + A 1937 MULXQ R14, AX, BP 1938 ADOXQ AX, R8 1939 1940 // (A,t[1]) := t[1] + x[1]*y[5] + A 1941 ADCXQ BP, R9 1942 MULXQ R15, AX, BP 1943 ADOXQ AX, R9 1944 1945 // (A,t[2]) := t[2] + x[2]*y[5] + A 1946 ADCXQ BP, R10 1947 MULXQ CX, AX, BP 1948 ADOXQ AX, R10 1949 1950 // (A,t[3]) := t[3] + x[3]*y[5] + A 1951 ADCXQ BP, R11 1952 MULXQ BX, AX, BP 1953 ADOXQ AX, R11 1954 1955 // (A,t[4]) := t[4] + x[4]*y[5] + A 1956 ADCXQ BP, R12 1957 MULXQ SI, AX, BP 1958 ADOXQ AX, R12 1959 1960 // (A,t[5]) := t[5] + x[5]*y[5] + A 1961 ADCXQ BP, R13 1962 MULXQ DI, AX, BP 1963 ADOXQ AX, R13 1964 1965 // A += carries from ADCXQ and ADOXQ 1966 MOVQ $0, AX 1967 ADCXQ AX, BP 1968 ADOXQ AX, BP 1969 PUSHQ BP 1970 1971 // m := t[0]*q'[0] mod W 1972 MOVQ qInv0<>(SB), DX 1973 IMULQ R8, DX 1974 1975 // clear the flags 1976 XORQ AX, AX 1977 1978 // C,_ := t[0] + m*q[0] 1979 MULXQ q<>+0(SB), AX, BP 1980 ADCXQ R8, AX 1981 MOVQ BP, R8 1982 POPQ BP 1983 1984 // (C,t[0]) := t[1] + m*q[1] + C 1985 ADCXQ R9, R8 1986 MULXQ q<>+8(SB), AX, R9 1987 ADOXQ AX, R8 1988 1989 // (C,t[1]) := t[2] + m*q[2] + C 1990 ADCXQ R10, R9 1991 MULXQ q<>+16(SB), AX, R10 1992 ADOXQ AX, R9 1993 1994 // (C,t[2]) := t[3] + m*q[3] + C 1995 ADCXQ R11, R10 1996 MULXQ q<>+24(SB), AX, R11 1997 ADOXQ AX, R10 1998 1999 // (C,t[3]) := t[4] + m*q[4] + C 2000 ADCXQ R12, R11 2001 MULXQ q<>+32(SB), AX, R12 2002 ADOXQ AX, R11 2003 2004 // (C,t[4]) := t[5] + m*q[5] + C 2005 ADCXQ R13, R12 2006 MULXQ q<>+40(SB), AX, R13 2007 ADOXQ AX, R12 2008 2009 // t[5] = C + A 2010 MOVQ $0, AX 2011 ADCXQ AX, R13 2012 ADOXQ BP, R13 2013 2014 // reduce element(R8,R9,R10,R11,R12,R13) using temp registers (R14,R15,CX,BX,SI,DI) 2015 REDUCE(R8,R9,R10,R11,R12,R13,R14,R15,CX,BX,SI,DI) 2016 2017 MOVQ R8, s6-56(SP) 2018 MOVQ R9, s7-64(SP) 2019 MOVQ R10, s8-72(SP) 2020 MOVQ R11, s9-80(SP) 2021 MOVQ R12, s10-88(SP) 2022 MOVQ R13, s11-96(SP) 2023 MOVQ x+8(FP), AX 2024 MOVQ y+16(FP), DX 2025 MOVQ 48(AX), R14 2026 MOVQ 56(AX), R15 2027 MOVQ 64(AX), CX 2028 MOVQ 72(AX), BX 2029 MOVQ 80(AX), SI 2030 MOVQ 88(AX), DI 2031 ADDQ 0(AX), R14 2032 ADCQ 8(AX), R15 2033 ADCQ 16(AX), CX 2034 ADCQ 24(AX), BX 2035 ADCQ 32(AX), SI 2036 ADCQ 40(AX), DI 2037 MOVQ R14, s0-8(SP) 2038 MOVQ R15, s1-16(SP) 2039 MOVQ CX, s2-24(SP) 2040 MOVQ BX, s3-32(SP) 2041 MOVQ SI, s4-40(SP) 2042 MOVQ DI, s5-48(SP) 2043 MOVQ 0(DX), R14 2044 MOVQ 8(DX), R15 2045 MOVQ 16(DX), CX 2046 MOVQ 24(DX), BX 2047 MOVQ 32(DX), SI 2048 MOVQ 40(DX), DI 2049 ADDQ 48(DX), R14 2050 ADCQ 56(DX), R15 2051 ADCQ 64(DX), CX 2052 ADCQ 72(DX), BX 2053 ADCQ 80(DX), SI 2054 ADCQ 88(DX), DI 2055 2056 // A -> BP 2057 // t[0] -> R8 2058 // t[1] -> R9 2059 // t[2] -> R10 2060 // t[3] -> R11 2061 // t[4] -> R12 2062 // t[5] -> R13 2063 // clear the flags 2064 XORQ AX, AX 2065 MOVQ s0-8(SP), DX 2066 2067 // (A,t[0]) := x[0]*y[0] + A 2068 MULXQ R14, R8, R9 2069 2070 // (A,t[1]) := x[1]*y[0] + A 2071 MULXQ R15, AX, R10 2072 ADOXQ AX, R9 2073 2074 // (A,t[2]) := x[2]*y[0] + A 2075 MULXQ CX, AX, R11 2076 ADOXQ AX, R10 2077 2078 // (A,t[3]) := x[3]*y[0] + A 2079 MULXQ BX, AX, R12 2080 ADOXQ AX, R11 2081 2082 // (A,t[4]) := x[4]*y[0] + A 2083 MULXQ SI, AX, R13 2084 ADOXQ AX, R12 2085 2086 // (A,t[5]) := x[5]*y[0] + A 2087 MULXQ DI, AX, BP 2088 ADOXQ AX, R13 2089 2090 // A += carries from ADCXQ and ADOXQ 2091 MOVQ $0, AX 2092 ADOXQ AX, BP 2093 PUSHQ BP 2094 2095 // m := t[0]*q'[0] mod W 2096 MOVQ qInv0<>(SB), DX 2097 IMULQ R8, DX 2098 2099 // clear the flags 2100 XORQ AX, AX 2101 2102 // C,_ := t[0] + m*q[0] 2103 MULXQ q<>+0(SB), AX, BP 2104 ADCXQ R8, AX 2105 MOVQ BP, R8 2106 POPQ BP 2107 2108 // (C,t[0]) := t[1] + m*q[1] + C 2109 ADCXQ R9, R8 2110 MULXQ q<>+8(SB), AX, R9 2111 ADOXQ AX, R8 2112 2113 // (C,t[1]) := t[2] + m*q[2] + C 2114 ADCXQ R10, R9 2115 MULXQ q<>+16(SB), AX, R10 2116 ADOXQ AX, R9 2117 2118 // (C,t[2]) := t[3] + m*q[3] + C 2119 ADCXQ R11, R10 2120 MULXQ q<>+24(SB), AX, R11 2121 ADOXQ AX, R10 2122 2123 // (C,t[3]) := t[4] + m*q[4] + C 2124 ADCXQ R12, R11 2125 MULXQ q<>+32(SB), AX, R12 2126 ADOXQ AX, R11 2127 2128 // (C,t[4]) := t[5] + m*q[5] + C 2129 ADCXQ R13, R12 2130 MULXQ q<>+40(SB), AX, R13 2131 ADOXQ AX, R12 2132 2133 // t[5] = C + A 2134 MOVQ $0, AX 2135 ADCXQ AX, R13 2136 ADOXQ BP, R13 2137 2138 // clear the flags 2139 XORQ AX, AX 2140 MOVQ s1-16(SP), DX 2141 2142 // (A,t[0]) := t[0] + x[0]*y[1] + A 2143 MULXQ R14, AX, BP 2144 ADOXQ AX, R8 2145 2146 // (A,t[1]) := t[1] + x[1]*y[1] + A 2147 ADCXQ BP, R9 2148 MULXQ R15, AX, BP 2149 ADOXQ AX, R9 2150 2151 // (A,t[2]) := t[2] + x[2]*y[1] + A 2152 ADCXQ BP, R10 2153 MULXQ CX, AX, BP 2154 ADOXQ AX, R10 2155 2156 // (A,t[3]) := t[3] + x[3]*y[1] + A 2157 ADCXQ BP, R11 2158 MULXQ BX, AX, BP 2159 ADOXQ AX, R11 2160 2161 // (A,t[4]) := t[4] + x[4]*y[1] + A 2162 ADCXQ BP, R12 2163 MULXQ SI, AX, BP 2164 ADOXQ AX, R12 2165 2166 // (A,t[5]) := t[5] + x[5]*y[1] + A 2167 ADCXQ BP, R13 2168 MULXQ DI, AX, BP 2169 ADOXQ AX, R13 2170 2171 // A += carries from ADCXQ and ADOXQ 2172 MOVQ $0, AX 2173 ADCXQ AX, BP 2174 ADOXQ AX, BP 2175 PUSHQ BP 2176 2177 // m := t[0]*q'[0] mod W 2178 MOVQ qInv0<>(SB), DX 2179 IMULQ R8, DX 2180 2181 // clear the flags 2182 XORQ AX, AX 2183 2184 // C,_ := t[0] + m*q[0] 2185 MULXQ q<>+0(SB), AX, BP 2186 ADCXQ R8, AX 2187 MOVQ BP, R8 2188 POPQ BP 2189 2190 // (C,t[0]) := t[1] + m*q[1] + C 2191 ADCXQ R9, R8 2192 MULXQ q<>+8(SB), AX, R9 2193 ADOXQ AX, R8 2194 2195 // (C,t[1]) := t[2] + m*q[2] + C 2196 ADCXQ R10, R9 2197 MULXQ q<>+16(SB), AX, R10 2198 ADOXQ AX, R9 2199 2200 // (C,t[2]) := t[3] + m*q[3] + C 2201 ADCXQ R11, R10 2202 MULXQ q<>+24(SB), AX, R11 2203 ADOXQ AX, R10 2204 2205 // (C,t[3]) := t[4] + m*q[4] + C 2206 ADCXQ R12, R11 2207 MULXQ q<>+32(SB), AX, R12 2208 ADOXQ AX, R11 2209 2210 // (C,t[4]) := t[5] + m*q[5] + C 2211 ADCXQ R13, R12 2212 MULXQ q<>+40(SB), AX, R13 2213 ADOXQ AX, R12 2214 2215 // t[5] = C + A 2216 MOVQ $0, AX 2217 ADCXQ AX, R13 2218 ADOXQ BP, R13 2219 2220 // clear the flags 2221 XORQ AX, AX 2222 MOVQ s2-24(SP), DX 2223 2224 // (A,t[0]) := t[0] + x[0]*y[2] + A 2225 MULXQ R14, AX, BP 2226 ADOXQ AX, R8 2227 2228 // (A,t[1]) := t[1] + x[1]*y[2] + A 2229 ADCXQ BP, R9 2230 MULXQ R15, AX, BP 2231 ADOXQ AX, R9 2232 2233 // (A,t[2]) := t[2] + x[2]*y[2] + A 2234 ADCXQ BP, R10 2235 MULXQ CX, AX, BP 2236 ADOXQ AX, R10 2237 2238 // (A,t[3]) := t[3] + x[3]*y[2] + A 2239 ADCXQ BP, R11 2240 MULXQ BX, AX, BP 2241 ADOXQ AX, R11 2242 2243 // (A,t[4]) := t[4] + x[4]*y[2] + A 2244 ADCXQ BP, R12 2245 MULXQ SI, AX, BP 2246 ADOXQ AX, R12 2247 2248 // (A,t[5]) := t[5] + x[5]*y[2] + A 2249 ADCXQ BP, R13 2250 MULXQ DI, AX, BP 2251 ADOXQ AX, R13 2252 2253 // A += carries from ADCXQ and ADOXQ 2254 MOVQ $0, AX 2255 ADCXQ AX, BP 2256 ADOXQ AX, BP 2257 PUSHQ BP 2258 2259 // m := t[0]*q'[0] mod W 2260 MOVQ qInv0<>(SB), DX 2261 IMULQ R8, DX 2262 2263 // clear the flags 2264 XORQ AX, AX 2265 2266 // C,_ := t[0] + m*q[0] 2267 MULXQ q<>+0(SB), AX, BP 2268 ADCXQ R8, AX 2269 MOVQ BP, R8 2270 POPQ BP 2271 2272 // (C,t[0]) := t[1] + m*q[1] + C 2273 ADCXQ R9, R8 2274 MULXQ q<>+8(SB), AX, R9 2275 ADOXQ AX, R8 2276 2277 // (C,t[1]) := t[2] + m*q[2] + C 2278 ADCXQ R10, R9 2279 MULXQ q<>+16(SB), AX, R10 2280 ADOXQ AX, R9 2281 2282 // (C,t[2]) := t[3] + m*q[3] + C 2283 ADCXQ R11, R10 2284 MULXQ q<>+24(SB), AX, R11 2285 ADOXQ AX, R10 2286 2287 // (C,t[3]) := t[4] + m*q[4] + C 2288 ADCXQ R12, R11 2289 MULXQ q<>+32(SB), AX, R12 2290 ADOXQ AX, R11 2291 2292 // (C,t[4]) := t[5] + m*q[5] + C 2293 ADCXQ R13, R12 2294 MULXQ q<>+40(SB), AX, R13 2295 ADOXQ AX, R12 2296 2297 // t[5] = C + A 2298 MOVQ $0, AX 2299 ADCXQ AX, R13 2300 ADOXQ BP, R13 2301 2302 // clear the flags 2303 XORQ AX, AX 2304 MOVQ s3-32(SP), DX 2305 2306 // (A,t[0]) := t[0] + x[0]*y[3] + A 2307 MULXQ R14, AX, BP 2308 ADOXQ AX, R8 2309 2310 // (A,t[1]) := t[1] + x[1]*y[3] + A 2311 ADCXQ BP, R9 2312 MULXQ R15, AX, BP 2313 ADOXQ AX, R9 2314 2315 // (A,t[2]) := t[2] + x[2]*y[3] + A 2316 ADCXQ BP, R10 2317 MULXQ CX, AX, BP 2318 ADOXQ AX, R10 2319 2320 // (A,t[3]) := t[3] + x[3]*y[3] + A 2321 ADCXQ BP, R11 2322 MULXQ BX, AX, BP 2323 ADOXQ AX, R11 2324 2325 // (A,t[4]) := t[4] + x[4]*y[3] + A 2326 ADCXQ BP, R12 2327 MULXQ SI, AX, BP 2328 ADOXQ AX, R12 2329 2330 // (A,t[5]) := t[5] + x[5]*y[3] + A 2331 ADCXQ BP, R13 2332 MULXQ DI, AX, BP 2333 ADOXQ AX, R13 2334 2335 // A += carries from ADCXQ and ADOXQ 2336 MOVQ $0, AX 2337 ADCXQ AX, BP 2338 ADOXQ AX, BP 2339 PUSHQ BP 2340 2341 // m := t[0]*q'[0] mod W 2342 MOVQ qInv0<>(SB), DX 2343 IMULQ R8, DX 2344 2345 // clear the flags 2346 XORQ AX, AX 2347 2348 // C,_ := t[0] + m*q[0] 2349 MULXQ q<>+0(SB), AX, BP 2350 ADCXQ R8, AX 2351 MOVQ BP, R8 2352 POPQ BP 2353 2354 // (C,t[0]) := t[1] + m*q[1] + C 2355 ADCXQ R9, R8 2356 MULXQ q<>+8(SB), AX, R9 2357 ADOXQ AX, R8 2358 2359 // (C,t[1]) := t[2] + m*q[2] + C 2360 ADCXQ R10, R9 2361 MULXQ q<>+16(SB), AX, R10 2362 ADOXQ AX, R9 2363 2364 // (C,t[2]) := t[3] + m*q[3] + C 2365 ADCXQ R11, R10 2366 MULXQ q<>+24(SB), AX, R11 2367 ADOXQ AX, R10 2368 2369 // (C,t[3]) := t[4] + m*q[4] + C 2370 ADCXQ R12, R11 2371 MULXQ q<>+32(SB), AX, R12 2372 ADOXQ AX, R11 2373 2374 // (C,t[4]) := t[5] + m*q[5] + C 2375 ADCXQ R13, R12 2376 MULXQ q<>+40(SB), AX, R13 2377 ADOXQ AX, R12 2378 2379 // t[5] = C + A 2380 MOVQ $0, AX 2381 ADCXQ AX, R13 2382 ADOXQ BP, R13 2383 2384 // clear the flags 2385 XORQ AX, AX 2386 MOVQ s4-40(SP), DX 2387 2388 // (A,t[0]) := t[0] + x[0]*y[4] + A 2389 MULXQ R14, AX, BP 2390 ADOXQ AX, R8 2391 2392 // (A,t[1]) := t[1] + x[1]*y[4] + A 2393 ADCXQ BP, R9 2394 MULXQ R15, AX, BP 2395 ADOXQ AX, R9 2396 2397 // (A,t[2]) := t[2] + x[2]*y[4] + A 2398 ADCXQ BP, R10 2399 MULXQ CX, AX, BP 2400 ADOXQ AX, R10 2401 2402 // (A,t[3]) := t[3] + x[3]*y[4] + A 2403 ADCXQ BP, R11 2404 MULXQ BX, AX, BP 2405 ADOXQ AX, R11 2406 2407 // (A,t[4]) := t[4] + x[4]*y[4] + A 2408 ADCXQ BP, R12 2409 MULXQ SI, AX, BP 2410 ADOXQ AX, R12 2411 2412 // (A,t[5]) := t[5] + x[5]*y[4] + A 2413 ADCXQ BP, R13 2414 MULXQ DI, AX, BP 2415 ADOXQ AX, R13 2416 2417 // A += carries from ADCXQ and ADOXQ 2418 MOVQ $0, AX 2419 ADCXQ AX, BP 2420 ADOXQ AX, BP 2421 PUSHQ BP 2422 2423 // m := t[0]*q'[0] mod W 2424 MOVQ qInv0<>(SB), DX 2425 IMULQ R8, DX 2426 2427 // clear the flags 2428 XORQ AX, AX 2429 2430 // C,_ := t[0] + m*q[0] 2431 MULXQ q<>+0(SB), AX, BP 2432 ADCXQ R8, AX 2433 MOVQ BP, R8 2434 POPQ BP 2435 2436 // (C,t[0]) := t[1] + m*q[1] + C 2437 ADCXQ R9, R8 2438 MULXQ q<>+8(SB), AX, R9 2439 ADOXQ AX, R8 2440 2441 // (C,t[1]) := t[2] + m*q[2] + C 2442 ADCXQ R10, R9 2443 MULXQ q<>+16(SB), AX, R10 2444 ADOXQ AX, R9 2445 2446 // (C,t[2]) := t[3] + m*q[3] + C 2447 ADCXQ R11, R10 2448 MULXQ q<>+24(SB), AX, R11 2449 ADOXQ AX, R10 2450 2451 // (C,t[3]) := t[4] + m*q[4] + C 2452 ADCXQ R12, R11 2453 MULXQ q<>+32(SB), AX, R12 2454 ADOXQ AX, R11 2455 2456 // (C,t[4]) := t[5] + m*q[5] + C 2457 ADCXQ R13, R12 2458 MULXQ q<>+40(SB), AX, R13 2459 ADOXQ AX, R12 2460 2461 // t[5] = C + A 2462 MOVQ $0, AX 2463 ADCXQ AX, R13 2464 ADOXQ BP, R13 2465 2466 // clear the flags 2467 XORQ AX, AX 2468 MOVQ s5-48(SP), DX 2469 2470 // (A,t[0]) := t[0] + x[0]*y[5] + A 2471 MULXQ R14, AX, BP 2472 ADOXQ AX, R8 2473 2474 // (A,t[1]) := t[1] + x[1]*y[5] + A 2475 ADCXQ BP, R9 2476 MULXQ R15, AX, BP 2477 ADOXQ AX, R9 2478 2479 // (A,t[2]) := t[2] + x[2]*y[5] + A 2480 ADCXQ BP, R10 2481 MULXQ CX, AX, BP 2482 ADOXQ AX, R10 2483 2484 // (A,t[3]) := t[3] + x[3]*y[5] + A 2485 ADCXQ BP, R11 2486 MULXQ BX, AX, BP 2487 ADOXQ AX, R11 2488 2489 // (A,t[4]) := t[4] + x[4]*y[5] + A 2490 ADCXQ BP, R12 2491 MULXQ SI, AX, BP 2492 ADOXQ AX, R12 2493 2494 // (A,t[5]) := t[5] + x[5]*y[5] + A 2495 ADCXQ BP, R13 2496 MULXQ DI, AX, BP 2497 ADOXQ AX, R13 2498 2499 // A += carries from ADCXQ and ADOXQ 2500 MOVQ $0, AX 2501 ADCXQ AX, BP 2502 ADOXQ AX, BP 2503 PUSHQ BP 2504 2505 // m := t[0]*q'[0] mod W 2506 MOVQ qInv0<>(SB), DX 2507 IMULQ R8, DX 2508 2509 // clear the flags 2510 XORQ AX, AX 2511 2512 // C,_ := t[0] + m*q[0] 2513 MULXQ q<>+0(SB), AX, BP 2514 ADCXQ R8, AX 2515 MOVQ BP, R8 2516 POPQ BP 2517 2518 // (C,t[0]) := t[1] + m*q[1] + C 2519 ADCXQ R9, R8 2520 MULXQ q<>+8(SB), AX, R9 2521 ADOXQ AX, R8 2522 2523 // (C,t[1]) := t[2] + m*q[2] + C 2524 ADCXQ R10, R9 2525 MULXQ q<>+16(SB), AX, R10 2526 ADOXQ AX, R9 2527 2528 // (C,t[2]) := t[3] + m*q[3] + C 2529 ADCXQ R11, R10 2530 MULXQ q<>+24(SB), AX, R11 2531 ADOXQ AX, R10 2532 2533 // (C,t[3]) := t[4] + m*q[4] + C 2534 ADCXQ R12, R11 2535 MULXQ q<>+32(SB), AX, R12 2536 ADOXQ AX, R11 2537 2538 // (C,t[4]) := t[5] + m*q[5] + C 2539 ADCXQ R13, R12 2540 MULXQ q<>+40(SB), AX, R13 2541 ADOXQ AX, R12 2542 2543 // t[5] = C + A 2544 MOVQ $0, AX 2545 ADCXQ AX, R13 2546 ADOXQ BP, R13 2547 2548 // reduce element(R8,R9,R10,R11,R12,R13) using temp registers (R14,R15,CX,BX,SI,DI) 2549 REDUCE(R8,R9,R10,R11,R12,R13,R14,R15,CX,BX,SI,DI) 2550 2551 MOVQ R8, s0-8(SP) 2552 MOVQ R9, s1-16(SP) 2553 MOVQ R10, s2-24(SP) 2554 MOVQ R11, s3-32(SP) 2555 MOVQ R12, s4-40(SP) 2556 MOVQ R13, s5-48(SP) 2557 MOVQ x+8(FP), AX 2558 MOVQ 0(AX), R14 2559 MOVQ 8(AX), R15 2560 MOVQ 16(AX), CX 2561 MOVQ 24(AX), BX 2562 MOVQ 32(AX), SI 2563 MOVQ 40(AX), DI 2564 2565 // A -> BP 2566 // t[0] -> R8 2567 // t[1] -> R9 2568 // t[2] -> R10 2569 // t[3] -> R11 2570 // t[4] -> R12 2571 // t[5] -> R13 2572 // clear the flags 2573 XORQ AX, AX 2574 MOVQ y+16(FP), DX 2575 MOVQ 0(DX), DX 2576 2577 // (A,t[0]) := x[0]*y[0] + A 2578 MULXQ R14, R8, R9 2579 2580 // (A,t[1]) := x[1]*y[0] + A 2581 MULXQ R15, AX, R10 2582 ADOXQ AX, R9 2583 2584 // (A,t[2]) := x[2]*y[0] + A 2585 MULXQ CX, AX, R11 2586 ADOXQ AX, R10 2587 2588 // (A,t[3]) := x[3]*y[0] + A 2589 MULXQ BX, AX, R12 2590 ADOXQ AX, R11 2591 2592 // (A,t[4]) := x[4]*y[0] + A 2593 MULXQ SI, AX, R13 2594 ADOXQ AX, R12 2595 2596 // (A,t[5]) := x[5]*y[0] + A 2597 MULXQ DI, AX, BP 2598 ADOXQ AX, R13 2599 2600 // A += carries from ADCXQ and ADOXQ 2601 MOVQ $0, AX 2602 ADOXQ AX, BP 2603 PUSHQ BP 2604 2605 // m := t[0]*q'[0] mod W 2606 MOVQ qInv0<>(SB), DX 2607 IMULQ R8, DX 2608 2609 // clear the flags 2610 XORQ AX, AX 2611 2612 // C,_ := t[0] + m*q[0] 2613 MULXQ q<>+0(SB), AX, BP 2614 ADCXQ R8, AX 2615 MOVQ BP, R8 2616 POPQ BP 2617 2618 // (C,t[0]) := t[1] + m*q[1] + C 2619 ADCXQ R9, R8 2620 MULXQ q<>+8(SB), AX, R9 2621 ADOXQ AX, R8 2622 2623 // (C,t[1]) := t[2] + m*q[2] + C 2624 ADCXQ R10, R9 2625 MULXQ q<>+16(SB), AX, R10 2626 ADOXQ AX, R9 2627 2628 // (C,t[2]) := t[3] + m*q[3] + C 2629 ADCXQ R11, R10 2630 MULXQ q<>+24(SB), AX, R11 2631 ADOXQ AX, R10 2632 2633 // (C,t[3]) := t[4] + m*q[4] + C 2634 ADCXQ R12, R11 2635 MULXQ q<>+32(SB), AX, R12 2636 ADOXQ AX, R11 2637 2638 // (C,t[4]) := t[5] + m*q[5] + C 2639 ADCXQ R13, R12 2640 MULXQ q<>+40(SB), AX, R13 2641 ADOXQ AX, R12 2642 2643 // t[5] = C + A 2644 MOVQ $0, AX 2645 ADCXQ AX, R13 2646 ADOXQ BP, R13 2647 2648 // clear the flags 2649 XORQ AX, AX 2650 MOVQ y+16(FP), DX 2651 MOVQ 8(DX), DX 2652 2653 // (A,t[0]) := t[0] + x[0]*y[1] + A 2654 MULXQ R14, AX, BP 2655 ADOXQ AX, R8 2656 2657 // (A,t[1]) := t[1] + x[1]*y[1] + A 2658 ADCXQ BP, R9 2659 MULXQ R15, AX, BP 2660 ADOXQ AX, R9 2661 2662 // (A,t[2]) := t[2] + x[2]*y[1] + A 2663 ADCXQ BP, R10 2664 MULXQ CX, AX, BP 2665 ADOXQ AX, R10 2666 2667 // (A,t[3]) := t[3] + x[3]*y[1] + A 2668 ADCXQ BP, R11 2669 MULXQ BX, AX, BP 2670 ADOXQ AX, R11 2671 2672 // (A,t[4]) := t[4] + x[4]*y[1] + A 2673 ADCXQ BP, R12 2674 MULXQ SI, AX, BP 2675 ADOXQ AX, R12 2676 2677 // (A,t[5]) := t[5] + x[5]*y[1] + A 2678 ADCXQ BP, R13 2679 MULXQ DI, AX, BP 2680 ADOXQ AX, R13 2681 2682 // A += carries from ADCXQ and ADOXQ 2683 MOVQ $0, AX 2684 ADCXQ AX, BP 2685 ADOXQ AX, BP 2686 PUSHQ BP 2687 2688 // m := t[0]*q'[0] mod W 2689 MOVQ qInv0<>(SB), DX 2690 IMULQ R8, DX 2691 2692 // clear the flags 2693 XORQ AX, AX 2694 2695 // C,_ := t[0] + m*q[0] 2696 MULXQ q<>+0(SB), AX, BP 2697 ADCXQ R8, AX 2698 MOVQ BP, R8 2699 POPQ BP 2700 2701 // (C,t[0]) := t[1] + m*q[1] + C 2702 ADCXQ R9, R8 2703 MULXQ q<>+8(SB), AX, R9 2704 ADOXQ AX, R8 2705 2706 // (C,t[1]) := t[2] + m*q[2] + C 2707 ADCXQ R10, R9 2708 MULXQ q<>+16(SB), AX, R10 2709 ADOXQ AX, R9 2710 2711 // (C,t[2]) := t[3] + m*q[3] + C 2712 ADCXQ R11, R10 2713 MULXQ q<>+24(SB), AX, R11 2714 ADOXQ AX, R10 2715 2716 // (C,t[3]) := t[4] + m*q[4] + C 2717 ADCXQ R12, R11 2718 MULXQ q<>+32(SB), AX, R12 2719 ADOXQ AX, R11 2720 2721 // (C,t[4]) := t[5] + m*q[5] + C 2722 ADCXQ R13, R12 2723 MULXQ q<>+40(SB), AX, R13 2724 ADOXQ AX, R12 2725 2726 // t[5] = C + A 2727 MOVQ $0, AX 2728 ADCXQ AX, R13 2729 ADOXQ BP, R13 2730 2731 // clear the flags 2732 XORQ AX, AX 2733 MOVQ y+16(FP), DX 2734 MOVQ 16(DX), DX 2735 2736 // (A,t[0]) := t[0] + x[0]*y[2] + A 2737 MULXQ R14, AX, BP 2738 ADOXQ AX, R8 2739 2740 // (A,t[1]) := t[1] + x[1]*y[2] + A 2741 ADCXQ BP, R9 2742 MULXQ R15, AX, BP 2743 ADOXQ AX, R9 2744 2745 // (A,t[2]) := t[2] + x[2]*y[2] + A 2746 ADCXQ BP, R10 2747 MULXQ CX, AX, BP 2748 ADOXQ AX, R10 2749 2750 // (A,t[3]) := t[3] + x[3]*y[2] + A 2751 ADCXQ BP, R11 2752 MULXQ BX, AX, BP 2753 ADOXQ AX, R11 2754 2755 // (A,t[4]) := t[4] + x[4]*y[2] + A 2756 ADCXQ BP, R12 2757 MULXQ SI, AX, BP 2758 ADOXQ AX, R12 2759 2760 // (A,t[5]) := t[5] + x[5]*y[2] + A 2761 ADCXQ BP, R13 2762 MULXQ DI, AX, BP 2763 ADOXQ AX, R13 2764 2765 // A += carries from ADCXQ and ADOXQ 2766 MOVQ $0, AX 2767 ADCXQ AX, BP 2768 ADOXQ AX, BP 2769 PUSHQ BP 2770 2771 // m := t[0]*q'[0] mod W 2772 MOVQ qInv0<>(SB), DX 2773 IMULQ R8, DX 2774 2775 // clear the flags 2776 XORQ AX, AX 2777 2778 // C,_ := t[0] + m*q[0] 2779 MULXQ q<>+0(SB), AX, BP 2780 ADCXQ R8, AX 2781 MOVQ BP, R8 2782 POPQ BP 2783 2784 // (C,t[0]) := t[1] + m*q[1] + C 2785 ADCXQ R9, R8 2786 MULXQ q<>+8(SB), AX, R9 2787 ADOXQ AX, R8 2788 2789 // (C,t[1]) := t[2] + m*q[2] + C 2790 ADCXQ R10, R9 2791 MULXQ q<>+16(SB), AX, R10 2792 ADOXQ AX, R9 2793 2794 // (C,t[2]) := t[3] + m*q[3] + C 2795 ADCXQ R11, R10 2796 MULXQ q<>+24(SB), AX, R11 2797 ADOXQ AX, R10 2798 2799 // (C,t[3]) := t[4] + m*q[4] + C 2800 ADCXQ R12, R11 2801 MULXQ q<>+32(SB), AX, R12 2802 ADOXQ AX, R11 2803 2804 // (C,t[4]) := t[5] + m*q[5] + C 2805 ADCXQ R13, R12 2806 MULXQ q<>+40(SB), AX, R13 2807 ADOXQ AX, R12 2808 2809 // t[5] = C + A 2810 MOVQ $0, AX 2811 ADCXQ AX, R13 2812 ADOXQ BP, R13 2813 2814 // clear the flags 2815 XORQ AX, AX 2816 MOVQ y+16(FP), DX 2817 MOVQ 24(DX), DX 2818 2819 // (A,t[0]) := t[0] + x[0]*y[3] + A 2820 MULXQ R14, AX, BP 2821 ADOXQ AX, R8 2822 2823 // (A,t[1]) := t[1] + x[1]*y[3] + A 2824 ADCXQ BP, R9 2825 MULXQ R15, AX, BP 2826 ADOXQ AX, R9 2827 2828 // (A,t[2]) := t[2] + x[2]*y[3] + A 2829 ADCXQ BP, R10 2830 MULXQ CX, AX, BP 2831 ADOXQ AX, R10 2832 2833 // (A,t[3]) := t[3] + x[3]*y[3] + A 2834 ADCXQ BP, R11 2835 MULXQ BX, AX, BP 2836 ADOXQ AX, R11 2837 2838 // (A,t[4]) := t[4] + x[4]*y[3] + A 2839 ADCXQ BP, R12 2840 MULXQ SI, AX, BP 2841 ADOXQ AX, R12 2842 2843 // (A,t[5]) := t[5] + x[5]*y[3] + A 2844 ADCXQ BP, R13 2845 MULXQ DI, AX, BP 2846 ADOXQ AX, R13 2847 2848 // A += carries from ADCXQ and ADOXQ 2849 MOVQ $0, AX 2850 ADCXQ AX, BP 2851 ADOXQ AX, BP 2852 PUSHQ BP 2853 2854 // m := t[0]*q'[0] mod W 2855 MOVQ qInv0<>(SB), DX 2856 IMULQ R8, DX 2857 2858 // clear the flags 2859 XORQ AX, AX 2860 2861 // C,_ := t[0] + m*q[0] 2862 MULXQ q<>+0(SB), AX, BP 2863 ADCXQ R8, AX 2864 MOVQ BP, R8 2865 POPQ BP 2866 2867 // (C,t[0]) := t[1] + m*q[1] + C 2868 ADCXQ R9, R8 2869 MULXQ q<>+8(SB), AX, R9 2870 ADOXQ AX, R8 2871 2872 // (C,t[1]) := t[2] + m*q[2] + C 2873 ADCXQ R10, R9 2874 MULXQ q<>+16(SB), AX, R10 2875 ADOXQ AX, R9 2876 2877 // (C,t[2]) := t[3] + m*q[3] + C 2878 ADCXQ R11, R10 2879 MULXQ q<>+24(SB), AX, R11 2880 ADOXQ AX, R10 2881 2882 // (C,t[3]) := t[4] + m*q[4] + C 2883 ADCXQ R12, R11 2884 MULXQ q<>+32(SB), AX, R12 2885 ADOXQ AX, R11 2886 2887 // (C,t[4]) := t[5] + m*q[5] + C 2888 ADCXQ R13, R12 2889 MULXQ q<>+40(SB), AX, R13 2890 ADOXQ AX, R12 2891 2892 // t[5] = C + A 2893 MOVQ $0, AX 2894 ADCXQ AX, R13 2895 ADOXQ BP, R13 2896 2897 // clear the flags 2898 XORQ AX, AX 2899 MOVQ y+16(FP), DX 2900 MOVQ 32(DX), DX 2901 2902 // (A,t[0]) := t[0] + x[0]*y[4] + A 2903 MULXQ R14, AX, BP 2904 ADOXQ AX, R8 2905 2906 // (A,t[1]) := t[1] + x[1]*y[4] + A 2907 ADCXQ BP, R9 2908 MULXQ R15, AX, BP 2909 ADOXQ AX, R9 2910 2911 // (A,t[2]) := t[2] + x[2]*y[4] + A 2912 ADCXQ BP, R10 2913 MULXQ CX, AX, BP 2914 ADOXQ AX, R10 2915 2916 // (A,t[3]) := t[3] + x[3]*y[4] + A 2917 ADCXQ BP, R11 2918 MULXQ BX, AX, BP 2919 ADOXQ AX, R11 2920 2921 // (A,t[4]) := t[4] + x[4]*y[4] + A 2922 ADCXQ BP, R12 2923 MULXQ SI, AX, BP 2924 ADOXQ AX, R12 2925 2926 // (A,t[5]) := t[5] + x[5]*y[4] + A 2927 ADCXQ BP, R13 2928 MULXQ DI, AX, BP 2929 ADOXQ AX, R13 2930 2931 // A += carries from ADCXQ and ADOXQ 2932 MOVQ $0, AX 2933 ADCXQ AX, BP 2934 ADOXQ AX, BP 2935 PUSHQ BP 2936 2937 // m := t[0]*q'[0] mod W 2938 MOVQ qInv0<>(SB), DX 2939 IMULQ R8, DX 2940 2941 // clear the flags 2942 XORQ AX, AX 2943 2944 // C,_ := t[0] + m*q[0] 2945 MULXQ q<>+0(SB), AX, BP 2946 ADCXQ R8, AX 2947 MOVQ BP, R8 2948 POPQ BP 2949 2950 // (C,t[0]) := t[1] + m*q[1] + C 2951 ADCXQ R9, R8 2952 MULXQ q<>+8(SB), AX, R9 2953 ADOXQ AX, R8 2954 2955 // (C,t[1]) := t[2] + m*q[2] + C 2956 ADCXQ R10, R9 2957 MULXQ q<>+16(SB), AX, R10 2958 ADOXQ AX, R9 2959 2960 // (C,t[2]) := t[3] + m*q[3] + C 2961 ADCXQ R11, R10 2962 MULXQ q<>+24(SB), AX, R11 2963 ADOXQ AX, R10 2964 2965 // (C,t[3]) := t[4] + m*q[4] + C 2966 ADCXQ R12, R11 2967 MULXQ q<>+32(SB), AX, R12 2968 ADOXQ AX, R11 2969 2970 // (C,t[4]) := t[5] + m*q[5] + C 2971 ADCXQ R13, R12 2972 MULXQ q<>+40(SB), AX, R13 2973 ADOXQ AX, R12 2974 2975 // t[5] = C + A 2976 MOVQ $0, AX 2977 ADCXQ AX, R13 2978 ADOXQ BP, R13 2979 2980 // clear the flags 2981 XORQ AX, AX 2982 MOVQ y+16(FP), DX 2983 MOVQ 40(DX), DX 2984 2985 // (A,t[0]) := t[0] + x[0]*y[5] + A 2986 MULXQ R14, AX, BP 2987 ADOXQ AX, R8 2988 2989 // (A,t[1]) := t[1] + x[1]*y[5] + A 2990 ADCXQ BP, R9 2991 MULXQ R15, AX, BP 2992 ADOXQ AX, R9 2993 2994 // (A,t[2]) := t[2] + x[2]*y[5] + A 2995 ADCXQ BP, R10 2996 MULXQ CX, AX, BP 2997 ADOXQ AX, R10 2998 2999 // (A,t[3]) := t[3] + x[3]*y[5] + A 3000 ADCXQ BP, R11 3001 MULXQ BX, AX, BP 3002 ADOXQ AX, R11 3003 3004 // (A,t[4]) := t[4] + x[4]*y[5] + A 3005 ADCXQ BP, R12 3006 MULXQ SI, AX, BP 3007 ADOXQ AX, R12 3008 3009 // (A,t[5]) := t[5] + x[5]*y[5] + A 3010 ADCXQ BP, R13 3011 MULXQ DI, AX, BP 3012 ADOXQ AX, R13 3013 3014 // A += carries from ADCXQ and ADOXQ 3015 MOVQ $0, AX 3016 ADCXQ AX, BP 3017 ADOXQ AX, BP 3018 PUSHQ BP 3019 3020 // m := t[0]*q'[0] mod W 3021 MOVQ qInv0<>(SB), DX 3022 IMULQ R8, DX 3023 3024 // clear the flags 3025 XORQ AX, AX 3026 3027 // C,_ := t[0] + m*q[0] 3028 MULXQ q<>+0(SB), AX, BP 3029 ADCXQ R8, AX 3030 MOVQ BP, R8 3031 POPQ BP 3032 3033 // (C,t[0]) := t[1] + m*q[1] + C 3034 ADCXQ R9, R8 3035 MULXQ q<>+8(SB), AX, R9 3036 ADOXQ AX, R8 3037 3038 // (C,t[1]) := t[2] + m*q[2] + C 3039 ADCXQ R10, R9 3040 MULXQ q<>+16(SB), AX, R10 3041 ADOXQ AX, R9 3042 3043 // (C,t[2]) := t[3] + m*q[3] + C 3044 ADCXQ R11, R10 3045 MULXQ q<>+24(SB), AX, R11 3046 ADOXQ AX, R10 3047 3048 // (C,t[3]) := t[4] + m*q[4] + C 3049 ADCXQ R12, R11 3050 MULXQ q<>+32(SB), AX, R12 3051 ADOXQ AX, R11 3052 3053 // (C,t[4]) := t[5] + m*q[5] + C 3054 ADCXQ R13, R12 3055 MULXQ q<>+40(SB), AX, R13 3056 ADOXQ AX, R12 3057 3058 // t[5] = C + A 3059 MOVQ $0, AX 3060 ADCXQ AX, R13 3061 ADOXQ BP, R13 3062 3063 // reduce element(R8,R9,R10,R11,R12,R13) using temp registers (R14,R15,CX,BX,SI,DI) 3064 REDUCE(R8,R9,R10,R11,R12,R13,R14,R15,CX,BX,SI,DI) 3065 3066 XORQ DX, DX 3067 MOVQ s0-8(SP), R14 3068 MOVQ s1-16(SP), R15 3069 MOVQ s2-24(SP), CX 3070 MOVQ s3-32(SP), BX 3071 MOVQ s4-40(SP), SI 3072 MOVQ s5-48(SP), DI 3073 SUBQ R8, R14 3074 SBBQ R9, R15 3075 SBBQ R10, CX 3076 SBBQ R11, BX 3077 SBBQ R12, SI 3078 SBBQ R13, DI 3079 MOVQ R8, s0-8(SP) 3080 MOVQ R9, s1-16(SP) 3081 MOVQ R10, s2-24(SP) 3082 MOVQ R11, s3-32(SP) 3083 MOVQ R12, s4-40(SP) 3084 MOVQ R13, s5-48(SP) 3085 MOVQ $0xb9feffffffffaaab, R8 3086 MOVQ $0x1eabfffeb153ffff, R9 3087 MOVQ $0x6730d2a0f6b0f624, R10 3088 MOVQ $0x64774b84f38512bf, R11 3089 MOVQ $0x4b1ba7b6434bacd7, R12 3090 MOVQ $0x1a0111ea397fe69a, R13 3091 CMOVQCC DX, R8 3092 CMOVQCC DX, R9 3093 CMOVQCC DX, R10 3094 CMOVQCC DX, R11 3095 CMOVQCC DX, R12 3096 CMOVQCC DX, R13 3097 ADDQ R8, R14 3098 ADCQ R9, R15 3099 ADCQ R10, CX 3100 ADCQ R11, BX 3101 ADCQ R12, SI 3102 ADCQ R13, DI 3103 SUBQ s6-56(SP), R14 3104 SBBQ s7-64(SP), R15 3105 SBBQ s8-72(SP), CX 3106 SBBQ s9-80(SP), BX 3107 SBBQ s10-88(SP), SI 3108 SBBQ s11-96(SP), DI 3109 MOVQ $0xb9feffffffffaaab, R8 3110 MOVQ $0x1eabfffeb153ffff, R9 3111 MOVQ $0x6730d2a0f6b0f624, R10 3112 MOVQ $0x64774b84f38512bf, R11 3113 MOVQ $0x4b1ba7b6434bacd7, R12 3114 MOVQ $0x1a0111ea397fe69a, R13 3115 CMOVQCC DX, R8 3116 CMOVQCC DX, R9 3117 CMOVQCC DX, R10 3118 CMOVQCC DX, R11 3119 CMOVQCC DX, R12 3120 CMOVQCC DX, R13 3121 ADDQ R8, R14 3122 ADCQ R9, R15 3123 ADCQ R10, CX 3124 ADCQ R11, BX 3125 ADCQ R12, SI 3126 ADCQ R13, DI 3127 MOVQ z+0(FP), AX 3128 MOVQ R14, 48(AX) 3129 MOVQ R15, 56(AX) 3130 MOVQ CX, 64(AX) 3131 MOVQ BX, 72(AX) 3132 MOVQ SI, 80(AX) 3133 MOVQ DI, 88(AX) 3134 MOVQ s0-8(SP), R8 3135 MOVQ s1-16(SP), R9 3136 MOVQ s2-24(SP), R10 3137 MOVQ s3-32(SP), R11 3138 MOVQ s4-40(SP), R12 3139 MOVQ s5-48(SP), R13 3140 SUBQ s6-56(SP), R8 3141 SBBQ s7-64(SP), R9 3142 SBBQ s8-72(SP), R10 3143 SBBQ s9-80(SP), R11 3144 SBBQ s10-88(SP), R12 3145 SBBQ s11-96(SP), R13 3146 MOVQ $0xb9feffffffffaaab, R14 3147 MOVQ $0x1eabfffeb153ffff, R15 3148 MOVQ $0x6730d2a0f6b0f624, CX 3149 MOVQ $0x64774b84f38512bf, BX 3150 MOVQ $0x4b1ba7b6434bacd7, SI 3151 MOVQ $0x1a0111ea397fe69a, DI 3152 CMOVQCC DX, R14 3153 CMOVQCC DX, R15 3154 CMOVQCC DX, CX 3155 CMOVQCC DX, BX 3156 CMOVQCC DX, SI 3157 CMOVQCC DX, DI 3158 ADDQ R14, R8 3159 ADCQ R15, R9 3160 ADCQ CX, R10 3161 ADCQ BX, R11 3162 ADCQ SI, R12 3163 ADCQ DI, R13 3164 MOVQ R8, 0(AX) 3165 MOVQ R9, 8(AX) 3166 MOVQ R10, 16(AX) 3167 MOVQ R11, 24(AX) 3168 MOVQ R12, 32(AX) 3169 MOVQ R13, 40(AX) 3170 RET 3171