Return to submul_1.asm CVS log

Up to [local] / OpenXM_contrib / gmp / mpn / x86 / pentium4 / sse2

Annotation of OpenXM_contrib/gmp/mpn/x86/pentium4/sse2/submul_1.asm, Revision 1.1

1.1     ! ohara       1: dnl  Intel Pentium-4 mpn_submul_1 -- Multiply a limb vector with a limb and
        !             2: dnl  subtract the result from a second limb vector.
        !             3:
        !             4: dnl  Copyright 2001, 2002 Free Software Foundation, Inc.
        !             5: dnl
        !             6: dnl  This file is part of the GNU MP Library.
        !             7: dnl
        !             8: dnl  The GNU MP Library is free software; you can redistribute it and/or
        !             9: dnl  modify it under the terms of the GNU Lesser General Public License as
        !            10: dnl  published by the Free Software Foundation; either version 2.1 of the
        !            11: dnl  License, or (at your option) any later version.
        !            12: dnl
        !            13: dnl  The GNU MP Library is distributed in the hope that it will be useful,
        !            14: dnl  but WITHOUT ANY WARRANTY; without even the implied warranty of
        !            15: dnl  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
        !            16: dnl  Lesser General Public License for more details.
        !            17: dnl
        !            18: dnl  You should have received a copy of the GNU Lesser General Public
        !            19: dnl  License along with the GNU MP Library; see the file COPYING.LIB.  If
        !            20: dnl  not, write to the Free Software Foundation, Inc., 59 Temple Place -
        !            21: dnl  Suite 330, Boston, MA 02111-1307, USA.
        !            22:
        !            23: include(`../config.m4')
        !            24:
        !            25:
        !            26: C P4: 7 cycles/limb, unstable timing, at least on early Pentium4 silicon
        !            27: C     (stepping 10).
        !            28:
        !            29:
        !            30: C mp_limb_t mpn_submul_1 (mp_ptr dst, mp_srcptr src, mp_size_t size,
        !            31: C                         mp_limb_t mult);
        !            32: C mp_limb_t mpn_submul_1c (mp_ptr dst, mp_srcptr src, mp_size_t size,
        !            33: C                          mp_limb_t mult, mp_limb_t carry);
        !            34: C
        !            35: C This code is not particularly good at 7 c/l.  The dependent chain is only
        !            36: C 4 c/l and there's only 4 MMX unit instructions, so it's not clear why that
        !            37: C speed isn't achieved.
        !            38: C
        !            39: C The arrangements made here to get a two instruction dependent chain are
        !            40: C slightly subtle.  In the loop the carry (or borrow rather) is a negative
        !            41: C so that a paddq can be used to give a low limb ready to store, and a high
        !            42: C limb ready to become the new carry after a psrlq.
        !            43: C
        !            44: C If the carry was a simple twos complement negative then the psrlq shift
        !            45: C would need to bring in 0 bits or 1 bits according to whether the high was
        !            46: C zero or non-zero, since a non-zero value would represent a negative
        !            47: C needing sign extension.  That wouldn't be particularly easy to arrange and
        !            48: C certainly would add an instruction to the dependent chain, so instead an
        !            49: C offset is applied so that the high limb will be 0xFFFFFFFF+c.  With c in
        !            50: C the range -0xFFFFFFFF to 0, the value 0xFFFFFFFF+c is in the range 0 to
        !            51: C 0xFFFFFFFF and is therefore always positive and can always have 0 bits
        !            52: C shifted in, which is what psrlq does.
        !            53: C
        !            54: C The extra 0xFFFFFFFF must be subtracted before c is used, but that can be
        !            55: C done off the dependent chain.  The total adjustment then is to add
        !            56: C 0xFFFFFFFF00000000 to offset the new carry, and subtract
        !            57: C 0x00000000FFFFFFFF to remove the offset from the current carry, for a net
        !            58: C add of 0xFFFFFFFE00000001.  In the code this is applied to the destination
        !            59: C limb when fetched.
        !            60: C
        !            61: C It's also possible to view the 0xFFFFFFFF adjustment as a ones-complement
        !            62: C negative, which is how it's undone for the return value, but that doesn't
        !            63: C seem as clear.
        !            64:
        !            65: defframe(PARAM_CARRY,     20)
        !            66: defframe(PARAM_MULTIPLIER,16)
        !            67: defframe(PARAM_SIZE,      12)
        !            68: defframe(PARAM_SRC,       8)
        !            69: defframe(PARAM_DST,       4)
        !            70:
        !            71:        TEXT
        !            72:        ALIGN(16)
        !            73:
        !            74: PROLOGUE(mpn_submul_1c)
        !            75: deflit(`FRAME',0)
        !            76:        movd    PARAM_CARRY, %mm1
        !            77:        jmp     L(start_1c)
        !            78: EPILOGUE()
        !            79:
        !            80: PROLOGUE(mpn_submul_1)
        !            81: deflit(`FRAME',0)
        !            82:        pxor    %mm1, %mm1              C initial borrow
        !            83:
        !            84: L(start_1c):
        !            85:        movl    PARAM_SRC, %eax
        !            86:        pcmpeqd %mm0, %mm0
        !            87:
        !            88:        movd    PARAM_MULTIPLIER, %mm7
        !            89:        pcmpeqd %mm6, %mm6
        !            90:
        !            91:        movl    PARAM_DST, %edx
        !            92:        psrlq   $32, %mm0               C 0x00000000FFFFFFFF
        !            93:
        !            94:        movl    PARAM_SIZE, %ecx
        !            95:        psllq   $32, %mm6               C 0xFFFFFFFF00000000
        !            96:
        !            97:        psubq   %mm0, %mm6              C 0xFFFFFFFE00000001
        !            98:
        !            99:        psubq   %mm1, %mm0              C 0xFFFFFFFF - borrow
        !           100:
        !           101:
        !           102:        C eax   src, incrementing
        !           103:        C ebx
        !           104:        C ecx   loop counter, decrementing
        !           105:        C edx   dst, incrementing
        !           106:        C
        !           107:        C mm0   0xFFFFFFFF - borrow
        !           108:        C mm6   0xFFFFFFFE00000001
        !           109:        C mm7   multiplier
        !           110:
        !           111: L(loop):
        !           112:        movd    (%eax), %mm1            C src
        !           113:        leal    4(%eax), %eax
        !           114:        movd    (%edx), %mm2            C dst
        !           115:        paddq   %mm6, %mm2              C add 0xFFFFFFFE00000001
        !           116:        pmuludq %mm7, %mm1
        !           117:        psubq   %mm1, %mm2              C prod
        !           118:        paddq   %mm2, %mm0              C borrow
        !           119:        subl    $1, %ecx
        !           120:        movd    %mm0, (%edx)            C result
        !           121:        psrlq   $32, %mm0
        !           122:        leal    4(%edx), %edx
        !           123:        jnz     L(loop)
        !           124:
        !           125:        movd    %mm0, %eax
        !           126:        notl    %eax
        !           127:        emms
        !           128:        ret
        !           129:
        !           130: EPILOGUE()