Quelle  mul_basecase.asm   Sprache: Masm

dnl  AMD64 mpn_mul_basecase optimised for Intel Broadwell.

dnl  Copyright 2015 Free Software Foundation, Inc.

dnl  This file is part of the GNU MP Library.
dnl
dnl  The GNU MP Library is free software; you can redistribute it and/or modify
dnl  it under the terms of either:
dnl
dnl    * the GNU Lesser General Public License as published by the Free
dnl      Software Foundation; either version 3 of the License, or (at your
dnl      option) any later version.
dnl
dnl  or
dnl
dnl    * the GNU General Public License as published by the Free Software
dnl      Foundation; either version 2 of the License, or (at your option) any
dnl      later version.
dnl
dnl  or both in parallel, as here.
dnl
dnl  The GNU MP Library is distributed in the hope that it will be useful, but
dnl  WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
dnl  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
dnl  for more details.
dnl
dnl  You should have received copies of the GNU General Public License and the
dnl  GNU Lesser General Public License along with the GNU MP Library.  If not,
dnl  see https://www.gnu.org/licenses/.

include(`../config.m4')

C cycles/limb mul_1  addmul_1
C AMD K8,K9 n/a  n/a
C AMD K10 n/a  n/a
C AMD bd1 n/a  n/a
C AMD bd2 n/a  n/a
C AMD bd3 n/a  n/a
C AMD bd4  ?   ?
C AMD zen  ?   ?
C AMD bt1 n/a  n/a
C AMD bt2 n/a  n/a
C Intel P4 n/a  n/a
C Intel PNR n/a  n/a
C Intel NHM n/a  n/a
C Intel SBR n/a  n/a
C Intel IBR n/a  n/a
C Intel HWL  1.68  n/a
C Intel BWL  1.51       1.67-1.74
C Intel SKL  1.52       1.63-1.71
C Intel atom n/a  n/a
C Intel SLM n/a  n/a
C VIA nano n/a  n/a

C The inner loops of this code are the result of running a code generation and
C optimisation tool suite written by David Harvey and Torbjorn Granlund.

C TODO
C  * Do overlapped software pipelining.
C  * When changing this, make sure the code which falls into the inner loops
C    does not execute too many no-ops (for both PIC and non-PIC).

define(`rp', `%rdi')
define(`up', `%rsi')
define(`un_param',`%rdx')
define(`vp_param',`%rcx')
define(`vn', `%r8')

define(`n', `%rcx')
define(`n_save', `%rbp')
define(`vp', `%r14')
define(`unneg', `%rbx')
define(`v0', `%rdx')
define(`jaddr', `%rax')

define(`w0', `%r12')
define(`w1', `%r9')
define(`w2', `%r10')
define(`w3', `%r11')

ABI_SUPPORT(DOS64)
ABI_SUPPORT(STD64)

ASM_START()
 TEXT
 ALIGN(16)
PROLOGUE(mpn_mul_basecase)
 FUNC_ENTRY(4)
IFDOS(` mov 56(%rsp), %r8d ')

 cmp $2, un_param
 ja L(gen)
 mov (vp_param), %rdx
 mulx( (up), %rax, %r9) C 0 1
 je L(s2x)

L(s11): mov %rax, (rp)
 mov %r9, 8(rp)
 FUNC_EXIT()
 ret

L(s2x): cmp $2, vn
 mulx( 8,(up), %r8, %r10) C 1 2
 je L(s22)

L(s21): add %r8, %r9
 adc $0, %r10
 mov %rax, (rp)
 mov %r9, 8(rp)
 mov %r10, 16(rp)
 FUNC_EXIT()
 ret

L(s22): add %r8, %r9  C 1
 adc $0, %r10  C 2
 mov 8(vp_param), %rdx
 mov %rax, (rp)
 mulx( (up), %r8, %r11) C 1 2
 mulx( 8,(up), %rax, %rdx) C 2 3
 add %r11, %rax  C 2
 adc $0, %rdx  C 3
 add %r8, %r9  C 1
 adc %rax, %r10  C 2
 adc $0, %rdx  C 3
 mov %r9, 8(rp)
 mov %r10, 16(rp)
 mov %rdx, 24(rp)
 FUNC_EXIT()
 ret

 ALIGN(16)
L(gen):
 push %rbx
 push %rbp
 push %r12
 push %r14

 mov vp_param, vp
 lea 1(un_param), unneg
 mov un_param, n_save
 mov R32(un_param), R32(%rax)
 and $-8, unneg
 shr $3, n_save  C loop count
 neg unneg
 and $7, R32(%rax)  C clear CF for adc as side-effect
     C note that rax lives very long
 mov n_save, n
 mov (vp), v0
 lea 8(vp), vp

 lea L(mtab)(%rip), %r10
ifdef(`PIC',
` movslq (%r10,%rax,4), %r11
 lea (%r11, %r10), %r10
 jmp *%r10
',`
 jmp *(%r10,%rax,8)
')

L(mf0): mulx( (up), w2, w3)
 lea 56(up), up
 lea -8(rp), rp
 jmp L(mb0)

L(mf3): mulx( (up), w0, w1)
 lea 16(up), up
 lea 16(rp), rp
 inc n
 jmp L(mb3)

L(mf4): mulx( (up), w2, w3)
 lea 24(up), up
 lea 24(rp), rp
 inc n
 jmp L(mb4)

L(mf5): mulx( (up), w0, w1)
 lea 32(up), up
 lea 32(rp), rp
 inc n
 jmp L(mb5)

L(mf6): mulx( (up), w2, w3)
 lea 40(up), up
 lea 40(rp), rp
 inc n
 jmp L(mb6)

L(mf7): mulx( (up), w0, w1)
 lea 48(up), up
 lea 48(rp), rp
 inc n
 jmp L(mb7)

L(mf1): mulx( (up), w0, w1)
 jmp L(mb1)

L(mf2): mulx( (up), w2, w3)
 lea 8(up), up
 lea 8(rp), rp
 mulx( (up), w0, w1)

 ALIGN(16)
L(m1top):
 mov w2, -8(rp)
 adc w3, w0
L(mb1): mulx( 8,(up), w2, w3)
 adc w1, w2
 lea 64(up), up
 mov w0, (rp)
L(mb0): mov w2, 8(rp)
 mulx( -48,(up), w0, w1)
 lea 64(rp), rp
 adc w3, w0
L(mb7): mulx( -40,(up), w2, w3)
 mov w0, -48(rp)
 adc w1, w2
L(mb6): mov w2, -40(rp)
 mulx( -32,(up), w0, w1)
 adc w3, w0
L(mb5): mulx( -24,(up), w2, w3)
 mov w0, -32(rp)
 adc w1, w2
L(mb4): mulx( -16,(up), w0, w1)
 mov w2, -24(rp)
 adc w3, w0
L(mb3): mulx( -8,(up), w2, w3)
 adc w1, w2
 mov w0, -16(rp)
 dec n
 mulx( (up), w0, w1)
 jnz L(m1top)

L(m1end):
 mov w2, -8(rp)
 adc w3, w0
 mov w0, (rp)
 adc %rcx, w1  C relies on rcx = 0
 mov w1, 8(rp)

 dec vn
 jz L(done)

 lea L(atab)(%rip), %r10
ifdef(`PIC',
` movslq (%r10,%rax,4), %rax
 lea (%rax, %r10), jaddr
',`
 mov (%r10,%rax,8), jaddr
')

L(outer):
 lea (up,unneg,8), up
 mov n_save, n
 mov (vp), v0
 lea 8(vp), vp
 jmp *jaddr

L(f0): mulx( 8,(up), w2, w3)
 lea 8(rp,unneg,8), rp
 lea -1(n), n
 jmp L(b0)

L(f3): mulx( -16,(up), w0, w1)
 lea -56(rp,unneg,8), rp
 jmp L(b3)

L(f4): mulx( -24,(up), w2, w3)
 lea -56(rp,unneg,8), rp
 jmp L(b4)

L(f5): mulx( -32,(up), w0, w1)
 lea -56(rp,unneg,8), rp
 jmp L(b5)

L(f6): mulx( -40,(up), w2, w3)
 lea -56(rp,unneg,8), rp
 jmp L(b6)

L(f7): mulx( 16,(up), w0, w1)
 lea 8(rp,unneg,8), rp
 jmp L(b7)

L(f1): mulx( (up), w0, w1)
 lea 8(rp,unneg,8), rp
 jmp L(b1)

L(am1end):
 adox( (rp), w0)
 adox( %rcx, w1)  C relies on rcx = 0
 mov w0, (rp)
 adc %rcx, w1  C relies on rcx = 0
 mov w1, 8(rp)

 dec vn   C clear OF as side-effect
 jnz L(outer)
L(done):
 pop %r14
 pop %r12
 pop %rbp
 pop %rbx
 FUNC_EXIT()
 ret

L(f2): mulx( -8,(up), w2, w3)
 lea 8(rp,unneg,8), rp
 mulx( (up), w0, w1)

 ALIGN(16)
L(am1top):
 adox( -8,(rp), w2)
 adcx( w3, w0)
 mov w2, -8(rp)
 jrcxz L(am1end)
L(b1): mulx( 8,(up), w2, w3)
 adox( (rp), w0)
 lea -1(n), n
 mov w0, (rp)
 adcx( w1, w2)
L(b0): mulx( 16,(up), w0, w1)
 adcx( w3, w0)
 adox( 8,(rp), w2)
 mov w2, 8(rp)
L(b7): mulx( 24,(up), w2, w3)
 lea 64(up), up
 adcx( w1, w2)
 adox( 16,(rp), w0)
 mov w0, 16(rp)
L(b6): mulx( -32,(up), w0, w1)
 adox( 24,(rp), w2)
 adcx( w3, w0)
 mov w2, 24(rp)
L(b5): mulx( -24,(up), w2, w3)
 adcx( w1, w2)
 adox( 32,(rp), w0)
 mov w0, 32(rp)
L(b4): mulx( -16,(up), w0, w1)
 adox( 40,(rp), w2)
 adcx( w3, w0)
 mov w2, 40(rp)
L(b3): adox( 48,(rp), w0)
 mulx( -8,(up), w2, w3)
 mov w0, 48(rp)
 lea 64(rp), rp
 adcx( w1, w2)
 mulx( (up), w0, w1)
 jmp L(am1top)

 JUMPTABSECT
 ALIGN(8)
L(mtab):JMPENT( L(mf0), L(mtab))
 JMPENT( L(mf1), L(mtab))
 JMPENT( L(mf2), L(mtab))
 JMPENT( L(mf3), L(mtab))
 JMPENT( L(mf4), L(mtab))
 JMPENT( L(mf5), L(mtab))
 JMPENT( L(mf6), L(mtab))
 JMPENT( L(mf7), L(mtab))
L(atab):JMPENT( L(f0), L(atab))
 JMPENT( L(f1), L(atab))
 JMPENT( L(f2), L(atab))
 JMPENT( L(f3), L(atab))
 JMPENT( L(f4), L(atab))
 JMPENT( L(f5), L(atab))
 JMPENT( L(f6), L(atab))
 JMPENT( L(f7), L(atab))
 TEXT
EPILOGUE()