mpn/x86/mul_1.asm

   1 dnl  x86 mpn_mul_1 (for 386, 486, and Pentium Pro) -- Multiply a limb vector
   2 dnl  with a limb and store the result in a second limb vector.
   3
   4 dnl  Copyright 1992, 1994, 1997, 1998, 1999, 2000, 2001, 2002, 2005 Free
   5 dnl  Software Foundation, Inc.
   6 dnl
   7 dnl  This file is part of the GNU MP Library.
   8 dnl
   9 dnl  The GNU MP Library is free software; you can redistribute it and/or
  10 dnl  modify it under the terms of the GNU Lesser General Public License as
  11 dnl  published by the Free Software Foundation; either version 3 of the
  12 dnl  License, or (at your option) any later version.
  13 dnl
  14 dnl  The GNU MP Library is distributed in the hope that it will be useful,
  15 dnl  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 dnl  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17 dnl  Lesser General Public License for more details.
  18 dnl
  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
  25 C                           cycles/limb
  26 C P5:                           12.5
  27 C P6 model 0-8,10-12)            5.5
  28 C P6 model 9  (Banias)
  29 C P6 model 13 (Dothan)           5.25
  30 C P4 model 0  (Willamette)      19.0
  31 C P4 model 1  (?)               19.0
  32 C P4 model 2  (Northwood)       19.0
  33 C P4 model 3  (Prescott)
  34 C P4 model 4  (Nocona)
  35 C K6:                           10.5
  36 C K7:                            4.5
  37 C K8:
  38
  39
  40 C mp_limb_t mpn_mul_1 (mp_ptr dst, mp_srcptr src, mp_size_t size,
  41 C                      mp_limb_t multiplier);
  42
  43 defframe(PARAM_MULTIPLIER,16)
  44 defframe(PARAM_SIZE,      12)
  45 defframe(PARAM_SRC,       8)
  46 defframe(PARAM_DST,       4)
  47
  48         TEXT
  49         ALIGN(8)
  50 PROLOGUE(mpn_mul_1)
  51 deflit(`FRAME',0)
  52
  53         pushl   %edi
  54         pushl   %esi
  55         pushl   %ebx
  56         pushl   %ebp
  57 deflit(`FRAME',16)
  58
  59         movl    PARAM_DST,%edi
  60         movl    PARAM_SRC,%esi
  61         movl    PARAM_SIZE,%ecx
  62
  63         xorl    %ebx,%ebx
  64         andl    $3,%ecx
  65         jz      L(end0)
  66
  67 L(oop0):
  68         movl    (%esi),%eax
  69         mull    PARAM_MULTIPLIER
  70         leal    4(%esi),%esi
  71         addl    %ebx,%eax
  72         movl    $0,%ebx
  73         adcl    %ebx,%edx
  74         movl    %eax,(%edi)
  75         movl    %edx,%ebx       C propagate carry into cylimb
  76
  77         leal    4(%edi),%edi
  78         decl    %ecx
  79         jnz     L(oop0)
  80
  81 L(end0):
  82         movl    PARAM_SIZE,%ecx
  83         shrl    $2,%ecx
  84         jz      L(end)
  85
  86
  87         ALIGN(8)
  88 L(oop): movl    (%esi),%eax
  89         mull    PARAM_MULTIPLIER
  90         addl    %eax,%ebx
  91         movl    $0,%ebp
  92         adcl    %edx,%ebp
  93
  94         movl    4(%esi),%eax
  95         mull    PARAM_MULTIPLIER
  96         movl    %ebx,(%edi)
  97         addl    %eax,%ebp       C new lo + cylimb
  98         movl    $0,%ebx
  99         adcl    %edx,%ebx
 100
 101         movl    8(%esi),%eax
 102         mull    PARAM_MULTIPLIER
 103         movl    %ebp,4(%edi)
 104         addl    %eax,%ebx       C new lo + cylimb
 105         movl    $0,%ebp
 106         adcl    %edx,%ebp
 107
 108         movl    12(%esi),%eax
 109         mull    PARAM_MULTIPLIER
 110         movl    %ebx,8(%edi)
 111         addl    %eax,%ebp       C new lo + cylimb
 112         movl    $0,%ebx
 113         adcl    %edx,%ebx
 114
 115         movl    %ebp,12(%edi)
 116
 117         leal    16(%esi),%esi
 118         leal    16(%edi),%edi
 119         decl    %ecx
 120         jnz     L(oop)
 121
 122 L(end): movl    %ebx,%eax
 123
 124         popl    %ebp
 125         popl    %ebx
 126         popl    %esi
 127         popl    %edi
 128         ret
 129
 130 EPILOGUE()