dnl Intel Pentium-4 mpn_submul_1 -- Multiply a limb vector with a limb
and
dnl subtract the result from a second limb vector.
dnl Copyright 2001, 2002, 2008, 2010 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
C P6
model 0-8,10-12 -
C P6
model 9 (Banias) 6.8
C P6
model 13 (Dothan) 6.9
C P4
model 0-1 (Willamette) ?
C P4
model 2 (Northwood) 5.87
C P4
model 3-4 (Prescott) 6.5
C
This code represents a step forwards compared to the
code available before
C GMP 5.1, but it is not carefully tuned
for either P6
or P4. In fact, it is
C not good
for P6.
For P4 it saved a bit over 1 c/l
for both Northwood
and
C Prescott compared to the old
code.
C
C The arrangements made here to get a two instruction dependent chain are
C slightly subtle. In the loop the
carry (
or borrow rather) is a negative so
C that a paddq can be used to give a low limb ready to store,
and a high limb
C ready to become the new
carry after a psrlq.
C
C
If the
carry was a simple twos complement negative then the psrlq shift would
C need to bring in 0 bits
or 1 bits according to whether the high was
zero or
C non-zero, since a non-zero value would represent a negative needing
sign
C extension. That wouldn
't be particularly easy to arrange and certainly would
C
add an instruction to the dependent chain, so instead an offset is applied so
C that the high limb will be 0xFFFFFFFF+c. With c in the range -0xFFFFFFFF to
C 0, the value 0xFFFFFFFF+c is in the range 0 to 0xFFFFFFFF
and is therefore
C always positive
and can always have 0 bits shifted in, which is what psrlq
C does.
C
C The extra 0xFFFFFFFF must be subtracted before c is used, but that can be
C done off the dependent chain. The total adjustment then is to
add
C 0xFFFFFFFF00000000 to offset the new
carry,
and subtract 0x00000000FFFFFFFF
C to remove the offset from the current
carry,
for a net
add of
C 0xFFFFFFFE00000001. In the
code this is applied to the destination limb when
C fetched.
C
C It
's also possible to view the 0xFFFFFFFF adjustment as a ones-complement
C negative, which is how it
's undone for the return value, but that doesn't
C seem as clear.
defframe(PARAM_CARRY, 20)
defframe(PARAM_MULTIPLIER,16)
defframe(PARAM_SIZE, 12)
defframe(PARAM_SRC, 8)
defframe(PARAM_DST, 4)
TEXT
ALIGN(16)
PROLOGUE(mpn_submul_1c)
deflit(`FRAME
',0)
movd PARAM_CARRY, %mm1
jmp L(start_1c)
EPILOGUE()
PROLOGUE(mpn_submul_1)
deflit(`FRAME
',0)
pxor %mm1, %mm1 C initial borrow
L(start_1c):
mov PARAM_SRC, %
eax
pcmpeqd %mm0, %mm0
movd PARAM_MULTIPLIER, %mm7
pcmpeqd %mm6, %mm6
mov PARAM_DST, %
edx
psrlq $32, %mm0 C 0x00000000FFFFFFFF
mov PARAM_SIZE, %
ecx
psllq $32, %mm6 C 0xFFFFFFFF00000000
psubq %mm0, %mm6 C 0xFFFFFFFE00000001
psubq %mm1, %mm0 C 0xFFFFFFFF - borrow
movd (%
eax), %mm3 C up
movd (%
edx), %mm4 C rp
add $-1, %
ecx
paddq %mm6, %mm4 C
add 0xFFFFFFFE00000001
pmuludq %mm7, %mm3
jnz L(gt1)
psubq %mm3, %mm4 C prod
paddq %mm4, %mm0 C borrow
movd %mm0, (%
edx) C result
jmp L(rt)
L(gt1):
movd 4(%
eax), %mm1 C up
movd 4(%
edx), %mm2 C rp
add $-1, %
ecx
jz L(eev)
ALIGN(16)
L(top): paddq %mm6, %mm2 C
add 0xFFFFFFFE00000001
pmuludq %mm7, %mm1
psubq %mm3, %mm4 C prod
movd 8(%
eax), %mm3 C up
paddq %mm4, %mm0 C borrow
movd 8(%
edx), %mm4 C rp
movd %mm0, (%
edx) C result
psrlq $32, %mm0
add $-1, %
ecx
jz L(eod)
paddq %mm6, %mm4 C
add 0xFFFFFFFE00000001
pmuludq %mm7, %mm3
psubq %mm1, %mm2 C prod
movd 12(%
eax), %mm1 C up
paddq %mm2, %mm0 C borrow
movd 12(%
edx), %mm2 C rp
movd %mm0, 4(%
edx) C result
psrlq $32, %mm0
lea 8(%
eax), %
eax
lea 8(%
edx), %
edx
add $-1, %
ecx
jnz L(top)
L(eev): paddq %mm6, %mm2 C
add 0xFFFFFFFE00000001
pmuludq %mm7, %mm1
psubq %mm3, %mm4 C prod
paddq %mm4, %mm0 C borrow
movd %mm0, (%
edx) C result
psrlq $32, %mm0
psubq %mm1, %mm2 C prod
paddq %mm2, %mm0 C borrow
movd %mm0, 4(%
edx) C result
L(rt): psrlq $32, %mm0
movd %mm0, %
eax
not %
eax
emms
ret
L(eod): paddq %mm6, %mm4 C
add 0xFFFFFFFE00000001
pmuludq %mm7, %mm3
psubq %mm1, %mm2 C prod
paddq %mm2, %mm0 C borrow
movd %mm0, 4(%
edx) C result
psrlq $32, %mm0
psubq %mm3, %mm4 C prod
paddq %mm4, %mm0 C borrow
movd %mm0, 8(%
edx) C result
jmp L(rt)
EPILOGUE()
