mpn/x86_64/sqr_basecase.asm

   1 dnl  AMD64 mpn_sqr_basecase.
   2
   3 dnl  Contributed to the GNU project by Torbjorn Granlund.
   4
   5 dnl  Copyright 2008, 2009 Free Software Foundation, Inc.
   6
   7 dnl  This file is part of the GNU MP Library.
   8
   9 dnl  The GNU MP Library is free software; you can redistribute it and/or modify
  10 dnl  it under the terms of the GNU Lesser General Public License as published
  11 dnl  by the Free Software Foundation; either version 3 of the License, or (at
  12 dnl  your option) any later version.
  13
  14 dnl  The GNU MP Library is distributed in the hope that it will be useful, but
  15 dnl  WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  16 dnl  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  17 dnl  License for more details.
  18
  19 dnl  You should have received a copy of the GNU Lesser General Public License
  20 dnl  along with the GNU MP Library.  If not, see http://www.gnu.org/licenses/.
  21
  22 include(`../config.m4')
  23
  24 C The inner loops of this code are the result of running a code generation and
  25 C optimization tool suite written by David Harvey and Torbjorn Granlund.
  26
  27 C NOTES
  28 C   * This code only handles operands up to SQR_TOOM2_THRESHOLD_MAX.  That
  29 C     means we can safely use 32-bit operations for all sizes, unlike in e.g.,
  30 C     mpn_addmul_1.
  31 C   * The jump table could probably be optimized, at least for non-pic.
  32 C   * The special code for n=1,2,3 was quickly written.  It is probably too
  33 C     large and unnecessarily slow.
  34 C   * Consider combining small cases code so that the n=k-1 code jumps into
  35 C     the middle of the n=k code.
  36 C   * Avoid saving registers for small cases code.
  37 C   * Needed variables:
  38 C    n   r11  input size
  39 C    i   r8   work left, initially n
  40 C    j   r9   inner loop count
  41 C        r15  unused
  42 C    v0  r13
  43 C    v1  r14
  44 C    rp  rdi
  45 C    up  rsi
  46 C    w0  rbx
  47 C    w1  rcx
  48 C    w2  rbp
  49 C    w3  r10
  50 C    tp  r12
  51 C    lo  rax
  52 C    hi  rdx
  53 C        rsp
  54
  55 C INPUT PARAMETERS
  56 define(`rp',      `%rdi')
  57 define(`up',      `%rsi')
  58 define(`n_param', `%rdx')
  59
  60 C We should really trim this, for better spatial locality.  Alternatively,
  61 C we could grab the upper part of the stack area, leaving the lower part
  62 C instead of the upper part unused.
  63 deflit(SQR_TOOM2_THRESHOLD_MAX, 80)
  64 define(`STACK_ALLOC', eval(8*2*SQR_TOOM2_THRESHOLD_MAX))
  65
  66 define(`n',     `%r11')
  67 define(`tp',    `%r12')
  68 define(`i',     `%r8')
  69 define(`j',     `%r9')
  70 define(`v0',    `%r13')
  71 define(`v1',    `%r14')
  72 define(`w0',    `%rbx')
  73 define(`w1',    `%rcx')
  74 define(`w2',    `%rbp')
  75 define(`w3',    `%r10')
  76
  77
  78 ASM_START()
  79         TEXT
  80         ALIGN(16)
  81
  82 PROLOGUE(mpn_sqr_basecase)
  83         add     $-48, %rsp
  84         mov     %rbx, 40(%rsp)
  85         mov     %rbp, 32(%rsp)
  86         mov     %r12, 24(%rsp)
  87         mov     %r13, 16(%rsp)
  88         mov     %r14, 8(%rsp)
  89
  90         mov     R32(n_param), R32(n)            C free original n register (rdx)
  91         mov     R32(n_param), R32(%rcx)
  92         and     $3, R32(%rcx)
  93         lea     4(%rcx), %rbx
  94         cmp     $4, R32(n_param)
  95         cmovg   %rbx, %rcx
  96         lea     L(jmptab)(%rip), %rax
  97         jmp     *(%rax,%rcx,8)
  98         JUMPTABSECT
  99         ALIGN(8)
 100 L(jmptab):
 101         .quad   L(4)
 102         .quad   L(1)
 103         .quad   L(2)
 104         .quad   L(3)
 105         .quad   L(0m4)
 106         .quad   L(1m4)
 107         .quad   L(2m4)
 108         .quad   L(3m4)
 109         TEXT
 110
 111 L(1):   mov     (up), %rax
 112         mul     %rax
 113         mov     %rax, (rp)
 114         mov     %rdx, 8(rp)
 115         add     $40, %rsp
 116         pop     %rbx
 117         ret
 118
 119 L(2):   mov     (up), %rax
 120         mul     %rax
 121         mov     %rax, (rp)
 122         mov     %rdx, %r9
 123         mov     8(up), %rax
 124         mul     %rax
 125         mov     %rax, %r10
 126         mov     %rdx, %r11
 127         mov     8(up), %rax
 128         mov     (up), %rbx
 129         mul     %rbx
 130         add     %rax, %r9
 131         adc     %rdx, %r10
 132         adc     $0, %r11
 133         add     %rax, %r9
 134         mov     %r9, 8(rp)
 135         adc     %rdx, %r10
 136         mov     %r10, 16(rp)
 137         adc     $0, %r11
 138         mov     %r11, 24(rp)
 139         add     $40, %rsp
 140         pop     %rbx
 141         ret
 142
 143 L(3):   mov     (up), %rax
 144         mul     %rax
 145         mov     %rax, (rp)
 146         mov     %rdx, 8(rp)
 147         mov     8(up), %rax
 148         mul     %rax
 149         mov     %rax, 16(rp)
 150         mov     %rdx, 24(rp)
 151         mov     16(up), %rax
 152         mul     %rax
 153         mov     %rax, 32(rp)
 154         mov     %rdx, 40(rp)
 155
 156         mov     (up), %rbx
 157         mov     8(up), %rax
 158         mul     %rbx
 159         mov     %rax, %r8
 160         mov     %rdx, %r9
 161         mov     16(up), %rax
 162         mul     %rbx
 163         xor     R32(%r10), R32(%r10)
 164         add     %rax, %r9
 165         adc     %rdx, %r10
 166
 167         mov     8(up), %rbx
 168         mov     16(up), %rax
 169         mul     %rbx
 170         xor     R32(%r11), R32(%r11)
 171         add     %rax, %r10
 172         adc     %rdx, %r11
 173         add     %r8, %r8
 174         adc     %r9, %r9
 175         adc     %r10, %r10
 176         adc     %r11, %r11
 177         mov     $0, R32(%rbx)
 178         adc     %rbx, %rbx
 179         add     %r8, 8(rp)
 180         adc     %r9, 16(rp)
 181         adc     %r10, 24(rp)
 182         adc     %r11, 32(rp)
 183         adc     %rbx, 40(rp)
 184         add     $40, %rsp
 185         pop     %rbx
 186         ret
 187
 188 L(4):   mov     (up), %rax
 189         mul     %rax
 190         mov     %rax, (rp)
 191         mov     %rdx, 8(rp)
 192         mov     8(up), %rax
 193         mul     %rax
 194         mov     %rax, 16(rp)
 195         mov     %rdx, 24(rp)
 196         mov     16(up), %rax
 197         mul     %rax
 198         mov     %rax, 32(rp)
 199         mov     %rdx, 40(rp)
 200         mov     24(up), %rax
 201         mul     %rax
 202         mov     %rax, 48(rp)
 203         mov     %rdx, 56(rp)
 204
 205         mov     (up), %rbx
 206         mov     8(up), %rax
 207         mul     %rbx
 208         mov     %rax, %r8
 209         mov     %rdx, %r9
 210         mov     16(up), %rax
 211         mul     %rbx
 212         xor     R32(%r10), R32(%r10)
 213         add     %rax, %r9
 214         adc     %rdx, %r10
 215         mov     24(up), %rax
 216         mul     %rbx
 217         xor     R32(%r11), R32(%r11)
 218         add     %rax, %r10
 219         adc     %rdx, %r11
 220         mov     8(up), %rbx
 221         mov     16(up), %rax
 222         mul     %rbx
 223         xor     R32(%r12), R32(%r12)
 224         add     %rax, %r10
 225         adc     %rdx, %r11
 226         adc     $0, %r12
 227         mov     24(up), %rax
 228         mul     %rbx
 229         add     %rax, %r11
 230         adc     %rdx, %r12
 231         mov     16(up), %rbx
 232         mov     24(up), %rax
 233         mul     %rbx
 234         xor     R32(%rbp), R32(%rbp)
 235         add     %rax, %r12
 236         adc     %rdx, %rbp
 237
 238         add     %r8, %r8
 239         adc     %r9, %r9
 240         adc     %r10, %r10
 241         adc     %r11, %r11
 242         adc     %r12, %r12
 243         mov     $0, R32(%rbx)
 244         adc     %rbp, %rbp
 245
 246         adc     %rbx, %rbx
 247         add     %r8, 8(rp)
 248         adc     %r9, 16(rp)
 249         adc     %r10, 24(rp)
 250         adc     %r11, 32(rp)
 251         adc     %r12, 40(rp)
 252         adc     %rbp, 48(rp)
 253         adc     %rbx, 56(rp)
 254         add     $24, %rsp
 255         pop     %r12
 256         pop     %rbp
 257         pop     %rbx
 258         ret
 259
 260
 261 L(0m4): add     $-STACK_ALLOC, %rsp
 262         lea     -24(%rsp,n,8), tp               C point tp in middle of result operand
 263         mov     (up), v0
 264         mov     8(up), %rax
 265         lea     (up,n,8), up            C point up at end of input operand
 266
 267         lea     -4(n), i
 268 C Function mpn_mul_1_m3(tp, up - i, i, up[-i - 1])
 269         xor     R32(j), R32(j)
 270         sub     n, j
 271
 272         mul     v0
 273         xor     R32(w2), R32(w2)
 274         mov     %rax, w0
 275         mov     16(up,j,8), %rax
 276         mov     %rdx, w3
 277         jmp     L(L3)
 278
 279         ALIGN(16)
 280 L(mul_1_m3_top):
 281         add     %rax, w2
 282         mov     w3, (tp,j,8)
 283         mov     (up,j,8), %rax
 284         adc     %rdx, w1
 285         xor     R32(w0), R32(w0)
 286         mul     v0
 287         xor     R32(w3), R32(w3)
 288         mov     w2, 8(tp,j,8)
 289         add     %rax, w1
 290         adc     %rdx, w0
 291         mov     8(up,j,8), %rax
 292         mov     w1, 16(tp,j,8)
 293         xor     R32(w2), R32(w2)
 294         mul     v0
 295         add     %rax, w0
 296         mov     16(up,j,8), %rax
 297         adc     %rdx, w3
 298 L(L3):  xor     R32(w1), R32(w1)
 299         mul     v0
 300         add     %rax, w3
 301         mov     24(up,j,8), %rax
 302         adc     %rdx, w2
 303         mov     w0, 24(tp,j,8)
 304         mul     v0
 305         add     $4, j
 306         js      L(mul_1_m3_top)
 307
 308         add     %rax, w2
 309         mov     w3, (tp)
 310         adc     %rdx, w1
 311         mov     w2, 8(tp)
 312         mov     w1, 16(tp)
 313
 314         lea     eval(2*8)(tp), tp       C tp += 2
 315         lea     -8(up), up
 316         jmp     L(dowhile)
 317
 318
 319 L(1m4): add     $-STACK_ALLOC, %rsp
 320         lea     (%rsp,n,8), tp          C point tp in middle of result operand
 321         mov     (up), v0                C u0
 322         mov     8(up), %rax             C u1
 323         lea     8(up,n,8), up           C point up at end of input operand
 324
 325         lea     -3(n), i
 326 C Function mpn_mul_2s_m0(tp, up - i, i, up - i - 1)
 327         lea     -3(n), j
 328         neg     j
 329
 330         mov     %rax, v1                C u1
 331         mul     v0                      C u0 * u1
 332         mov     %rdx, w1
 333         xor     R32(w2), R32(w2)
 334         mov     %rax, (%rsp)
 335         jmp     L(m0)
 336
 337         ALIGN(16)
 338 L(mul_2_m0_top):
 339         mul     v1
 340         add     %rax, w0
 341         adc     %rdx, w1
 342         mov     -24(up,j,8), %rax
 343         mov     $0, R32(w2)
 344         mul     v0
 345         add     %rax, w0
 346         mov     -24(up,j,8), %rax
 347         adc     %rdx, w1
 348         adc     $0, R32(w2)
 349         mul     v1                      C v1 * u0
 350         add     %rax, w1
 351         mov     w0, -24(tp,j,8)
 352         adc     %rdx, w2
 353 L(m0):  mov     -16(up,j,8), %rax       C u2, u6 ...
 354         mul     v0                      C u0 * u2
 355         mov     $0, R32(w3)
 356         add     %rax, w1
 357         adc     %rdx, w2
 358         mov     -16(up,j,8), %rax
 359         adc     $0, R32(w3)
 360         mov     $0, R32(w0)
 361         mov     w1, -16(tp,j,8)
 362         mul     v1
 363         add     %rax, w2
 364         mov     -8(up,j,8), %rax
 365         adc     %rdx, w3
 366         mov     $0, R32(w1)
 367         mul     v0
 368         add     %rax, w2
 369         mov     -8(up,j,8), %rax
 370         adc     %rdx, w3
 371         adc     $0, R32(w0)
 372         mul     v1
 373         add     %rax, w3
 374         mov     w2, -8(tp,j,8)
 375         adc     %rdx, w0
 376 L(m2x): mov     (up,j,8), %rax
 377         mul     v0
 378         add     %rax, w3
 379         adc     %rdx, w0
 380         adc     $0, R32(w1)
 381         add     $4, j
 382         mov     -32(up,j,8), %rax
 383         mov     w3, -32(tp,j,8)
 384         js      L(mul_2_m0_top)
 385
 386         mul     v1
 387         add     %rax, w0
 388         adc     %rdx, w1
 389         mov     w0, -8(tp)
 390         mov     w1, (tp)
 391
 392         lea     -16(up), up
 393         lea     eval(3*8-24)(tp), tp    C tp += 3
 394         jmp     L(dowhile_end)
 395
 396
 397 L(2m4): add     $-STACK_ALLOC, %rsp
 398         lea     -24(%rsp,n,8), tp       C point tp in middle of result operand
 399         mov     (up), v0
 400         mov     8(up), %rax
 401         lea     (up,n,8), up            C point up at end of input operand
 402
 403         lea     -4(n), i
 404 C Function mpn_mul_1_m1(tp, up - (i - 1), i - 1, up[-i])
 405         lea     -2(n), j
 406         neg     j
 407
 408         mul     v0
 409         mov     %rax, w2
 410         mov     (up,j,8), %rax
 411         mov     %rdx, w1
 412         jmp     L(L1)
 413
 414         ALIGN(16)
 415 L(mul_1_m1_top):
 416         add     %rax, w2
 417         mov     w3, (tp,j,8)
 418         mov     (up,j,8), %rax
 419         adc     %rdx, w1
 420 L(L1):  xor     R32(w0), R32(w0)
 421         mul     v0
 422         xor     R32(w3), R32(w3)
 423         mov     w2, 8(tp,j,8)
 424         add     %rax, w1
 425         adc     %rdx, w0
 426         mov     8(up,j,8), %rax
 427         mov     w1, 16(tp,j,8)
 428         xor     R32(w2), R32(w2)
 429         mul     v0
 430         add     %rax, w0
 431         mov     16(up,j,8), %rax
 432         adc     %rdx, w3
 433         xor     R32(w1), R32(w1)
 434         mul     v0
 435         add     %rax, w3
 436         mov     24(up,j,8), %rax
 437         adc     %rdx, w2
 438         mov     w0, 24(tp,j,8)
 439         mul     v0
 440         add     $4, j
 441         js      L(mul_1_m1_top)
 442
 443         add     %rax, w2
 444         mov     w3, (tp)
 445         adc     %rdx, w1
 446         mov     w2, 8(tp)
 447         mov     w1, 16(tp)
 448
 449         lea     eval(2*8)(tp), tp       C tp += 2
 450         lea     -8(up), up
 451         jmp     L(dowhile_mid)
 452
 453
 454 L(3m4): add     $-STACK_ALLOC, %rsp
 455         lea     (%rsp,n,8), tp          C point tp in middle of result operand
 456         mov     (up), v0                C u0
 457         mov     8(up), %rax             C u1
 458         lea     8(up,n,8), up           C point up at end of input operand
 459
 460         lea     -5(n), i
 461 C Function mpn_mul_2s_m2(tp, up - i + 1, i - 1, up - i)
 462         lea     -1(n), j
 463         neg     j
 464
 465         mov     %rax, v1                C u1
 466         mul     v0                      C u0 * u1
 467         mov     %rdx, w3
 468         xor     R32(w0), R32(w0)
 469         xor     R32(w1), R32(w1)
 470         mov     %rax, (%rsp)
 471         jmp     L(m2)
 472
 473         ALIGN(16)
 474 L(mul_2_m2_top):
 475         mul     v1
 476         add     %rax, w0
 477         adc     %rdx, w1
 478         mov     -24(up,j,8), %rax
 479         mov     $0, R32(w2)
 480         mul     v0
 481         add     %rax, w0
 482         mov     -24(up,j,8), %rax
 483         adc     %rdx, w1
 484         adc     $0, R32(w2)
 485         mul     v1                      C v1 * u0
 486         add     %rax, w1
 487         mov     w0, -24(tp,j,8)
 488         adc     %rdx, w2
 489         mov     -16(up,j,8), %rax
 490         mul     v0
 491         mov     $0, R32(w3)
 492         add     %rax, w1
 493         adc     %rdx, w2
 494         mov     -16(up,j,8), %rax
 495         adc     $0, R32(w3)
 496         mov     $0, R32(w0)
 497         mov     w1, -16(tp,j,8)
 498         mul     v1
 499         add     %rax, w2
 500         mov     -8(up,j,8), %rax
 501         adc     %rdx, w3
 502         mov     $0, R32(w1)
 503         mul     v0
 504         add     %rax, w2
 505         mov     -8(up,j,8), %rax
 506         adc     %rdx, w3
 507         adc     $0, R32(w0)
 508         mul     v1
 509         add     %rax, w3
 510         mov     w2, -8(tp,j,8)
 511         adc     %rdx, w0
 512 L(m2):  mov     (up,j,8), %rax
 513         mul     v0
 514         add     %rax, w3
 515         adc     %rdx, w0
 516         adc     $0, R32(w1)
 517         add     $4, j
 518         mov     -32(up,j,8), %rax
 519         mov     w3, -32(tp,j,8)
 520         js      L(mul_2_m2_top)
 521
 522         mul     v1
 523         add     %rax, w0
 524         adc     %rdx, w1
 525         mov     w0, -8(tp)
 526         mov     w1, (tp)
 527
 528         lea     -16(up), up
 529         jmp     L(dowhile_mid)
 530
 531 L(dowhile):
 532 C Function mpn_addmul_2s_m2(tp, up - (i - 1), i - 1, up - i)
 533         lea     4(i), j
 534         neg     j
 535
 536         mov     16(up,j,8), v0
 537         mov     24(up,j,8), v1
 538         mov     24(up,j,8), %rax
 539         mul     v0
 540         xor     R32(w3), R32(w3)
 541         add     %rax, 24(tp,j,8)
 542         adc     %rdx, w3
 543         xor     R32(w0), R32(w0)
 544         xor     R32(w1), R32(w1)
 545         jmp     L(am2)
 546
 547         ALIGN(16)
 548 L(addmul_2_m2_top):
 549         add     w3, (tp,j,8)
 550         adc     %rax, w0
 551         mov     8(up,j,8), %rax
 552         adc     %rdx, w1
 553         mov     $0, R32(w2)
 554         mul     v0
 555         add     %rax, w0
 556         mov     8(up,j,8), %rax
 557         adc     %rdx, w1
 558         adc     $0, R32(w2)
 559         mul     v1                              C v1 * u0
 560         add     w0, 8(tp,j,8)
 561         adc     %rax, w1
 562         adc     %rdx, w2
 563         mov     16(up,j,8), %rax
 564         mov     $0, R32(w3)
 565         mul     v0                              C v0 * u1
 566         add     %rax, w1
 567         mov     16(up,j,8), %rax
 568         adc     %rdx, w2
 569         adc     $0, R32(w3)
 570         mul     v1                              C v1 * u1
 571         add     w1, 16(tp,j,8)
 572         adc     %rax, w2
 573         mov     24(up,j,8), %rax
 574         adc     %rdx, w3
 575         mul     v0
 576         mov     $0, R32(w0)
 577         add     %rax, w2
 578         adc     %rdx, w3
 579         mov     $0, R32(w1)
 580         mov     24(up,j,8), %rax
 581         adc     $0, R32(w0)
 582         mul     v1
 583         add     w2, 24(tp,j,8)
 584         adc     %rax, w3
 585         adc     %rdx, w0
 586 L(am2): mov     32(up,j,8), %rax
 587         mul     v0
 588         add     %rax, w3
 589         mov     32(up,j,8), %rax
 590         adc     %rdx, w0
 591         adc     $0, R32(w1)
 592         mul     v1
 593         add     $4, j
 594         js      L(addmul_2_m2_top)
 595
 596         add     w3, (tp)
 597         adc     %rax, w0
 598         adc     %rdx, w1
 599         mov     w0, 8(tp)
 600         mov     w1, 16(tp)
 601
 602         lea     eval(2*8)(tp), tp       C tp += 2
 603
 604         add     $-2, R32(i)             C i -= 2
 605
 606 L(dowhile_mid):
 607 C Function mpn_addmul_2s_m0(tp, up - (i - 1), i - 1, up - i)
 608         lea     2(i), j
 609         neg     j
 610
 611         mov     (up,j,8), v0
 612         mov     8(up,j,8), v1
 613         mov     8(up,j,8), %rax
 614         mul     v0
 615         xor     R32(w1), R32(w1)
 616         add     %rax, 8(tp,j,8)
 617         adc     %rdx, w1
 618         xor     R32(w2), R32(w2)
 619         jmp     L(20)
 620
 621         ALIGN(16)
 622 L(addmul_2_m0_top):
 623         add     w3, (tp,j,8)
 624         adc     %rax, w0
 625         mov     8(up,j,8), %rax
 626         adc     %rdx, w1
 627         mov     $0, R32(w2)
 628         mul     v0
 629         add     %rax, w0
 630         mov     8(up,j,8), %rax
 631         adc     %rdx, w1
 632         adc     $0, R32(w2)
 633         mul     v1                              C v1 * u0
 634         add     w0, 8(tp,j,8)
 635         adc     %rax, w1
 636         adc     %rdx, w2
 637 L(20):  mov     16(up,j,8), %rax
 638         mov     $0, R32(w3)
 639         mul     v0                              C v0 * u1
 640         add     %rax, w1
 641         mov     16(up,j,8), %rax
 642         adc     %rdx, w2
 643         adc     $0, R32(w3)
 644         mul     v1                              C v1 * u1
 645         add     w1, 16(tp,j,8)
 646         adc     %rax, w2
 647         mov     24(up,j,8), %rax
 648         adc     %rdx, w3
 649         mul     v0
 650         mov     $0, R32(w0)
 651         add     %rax, w2
 652         adc     %rdx, w3
 653         mov     $0, R32(w1)
 654         mov     24(up,j,8), %rax
 655         adc     $0, R32(w0)
 656         mul     v1
 657         add     w2, 24(tp,j,8)
 658         adc     %rax, w3
 659         adc     %rdx, w0
 660         mov     32(up,j,8), %rax
 661         mul     v0
 662         add     %rax, w3
 663         mov     32(up,j,8), %rax
 664         adc     %rdx, w0
 665         adc     $0, R32(w1)
 666         mul     v1
 667         add     $4, j
 668         js      L(addmul_2_m0_top)
 669
 670         add     w3, (tp)
 671         adc     %rax, w0
 672         adc     %rdx, w1
 673         mov     w0, 8(tp)
 674         mov     w1, 16(tp)
 675
 676         lea     eval(2*8)(tp), tp       C tp += 2
 677 L(dowhile_end):
 678
 679         add     $-2, R32(i)             C i -= 2
 680         jne     L(dowhile)
 681
 682 C Function mpn_addmul_2s_2
 683         mov     -16(up), v0
 684         mov     -8(up), v1
 685         mov     -8(up), %rax
 686         mul     v0
 687         xor     R32(w3), R32(w3)
 688         add     %rax, -8(tp)
 689         adc     %rdx, w3
 690         xor     R32(w0), R32(w0)
 691         xor     R32(w1), R32(w1)
 692         mov     (up), %rax
 693         mul     v0
 694         add     %rax, w3
 695         mov     (up), %rax
 696         adc     %rdx, w0
 697         mul     v1
 698         add     w3, (tp)
 699         adc     %rax, w0
 700         adc     %rdx, w1
 701         mov     w0, 8(tp)
 702         mov     w1, 16(tp)
 703
 704 C Function mpn_sqr_diag_addlsh1
 705         lea     -4(n,n), j
 706
 707         mov     (%rsp), %r11
 708
 709         lea     (rp,j,8), rp
 710         lea     -8(up), up
 711         lea     8(%rsp,j,8), tp
 712         neg     j
 713         mov     (up,j,4), %rax
 714         mul     %rax
 715         test    $2, R8(j)
 716         jnz     L(odd)
 717
 718 L(evn): add     %r11, %r11
 719         sbb     R32(%rbx), R32(%rbx)            C save CF
 720         add     %rdx, %r11
 721         mov     %rax, (rp,j,8)
 722         jmp     L(d0)
 723
 724 L(odd): add     %r11, %r11
 725         sbb     R32(%rbp), R32(%rbp)            C save CF
 726         add     %rdx, %r11
 727         mov     %rax, (rp,j,8)
 728         lea     -2(j), j
 729         jmp     L(d1)
 730
 731         ALIGN(16)
 732 L(top): mov     (up,j,4), %rax
 733         mul     %rax
 734         add     R32(%rbp), R32(%rbp)            C restore carry
 735         adc     %rax, %r10
 736         adc     %rdx, %r11
 737         mov     %r10, (rp,j,8)
 738 L(d0):  mov     %r11, 8(rp,j,8)
 739         mov     (tp,j,8), %r10
 740         adc     %r10, %r10
 741         mov     8(tp,j,8), %r11
 742         adc     %r11, %r11
 743         nop
 744         sbb     R32(%rbp), R32(%rbp)            C save CF
 745         mov     8(up,j,4), %rax
 746         mul     %rax
 747         add     R32(%rbx), R32(%rbx)            C restore carry
 748         adc     %rax, %r10
 749         adc     %rdx, %r11
 750         mov     %r10, 16(rp,j,8)
 751 L(d1):  mov     %r11, 24(rp,j,8)
 752         mov     16(tp,j,8), %r10
 753         adc     %r10, %r10
 754         mov     24(tp,j,8), %r11
 755         adc     %r11, %r11
 756         sbb     R32(%rbx), R32(%rbx)            C save CF
 757         add     $4, j
 758         js      L(top)
 759
 760         mov     (up), %rax
 761         mul     %rax
 762         add     R32(%rbp), R32(%rbp)            C restore carry
 763         adc     %rax, %r10
 764         adc     %rdx, %r11
 765         mov     %r10, (rp)
 766         mov     %r11, 8(rp)
 767         mov     (tp), %r10
 768         adc     %r10, %r10
 769         sbb     R32(%rbp), R32(%rbp)            C save CF
 770         neg     R32(%rbp)
 771         mov     8(up), %rax
 772         mul     %rax
 773         add     R32(%rbx), R32(%rbx)            C restore carry
 774         adc     %rax, %r10
 775         adc     %rbp, %rdx
 776         mov     %r10, 16(rp)
 777         mov     %rdx, 24(rp)
 778
 779         add     $eval(8+STACK_ALLOC), %rsp
 780         pop     %r14
 781         pop     %r13
 782         pop     %r12
 783         pop     %rbp
 784         pop     %rbx
 785         ret
 786 EPILOGUE()