dnl AMD K6 mpn_mul_1 -- mpn by limb multiply. dnl Copyright 1999, 2000, 2002, 2005 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 P5 C P6 model 0-8,10-12 5.5 C P6 model 9 (Banias) C P6 model 13 (Dothan) 4.87 C P4 model 0 (Willamette) C P4 model 1 (?) C P4 model 2 (Northwood) C P4 model 3 (Prescott) C P4 model 4 (Nocona) C AMD K6 6.25 C AMD K7 C AMD K8 C mp_limb_t mpn_mul_1 (mp_ptr dst, mp_srcptr src, mp_size_t size, C mp_limb_t multiplier); C mp_limb_t mpn_mul_1c (mp_ptr dst, mp_srcptr src, mp_size_t size, C mp_limb_t multiplier, mp_limb_t carry); C C Multiply src,size by mult and store the result in dst,size. C Return the carry limb from the top of the result. C C mpn_mul_1c() accepts an initial carry for the calculation, it's added into C the low limb of the result. defframe(PARAM_CARRY, 20) defframe(PARAM_MULTIPLIER,16) defframe(PARAM_SIZE, 12) defframe(PARAM_SRC, 8) defframe(PARAM_DST, 4) dnl minimum 5 because the unrolled code can't handle less deflit(UNROLL_THRESHOLD, 5) TEXT ALIGN(32) PROLOGUE(mpn_mul_1c) pushl %esi deflit(`FRAME',4) movl PARAM_CARRY, %esi jmp L(start_nc) EPILOGUE() PROLOGUE(mpn_mul_1) push %esi deflit(`FRAME',4) xorl %esi, %esi C initial carry L(start_nc): mov PARAM_SIZE, %ecx push %ebx FRAME_pushl() movl PARAM_SRC, %ebx push %edi FRAME_pushl() movl PARAM_DST, %edi pushl %ebp FRAME_pushl() cmpl $UNROLL_THRESHOLD, %ecx movl PARAM_MULTIPLIER, %ebp jae L(unroll) C code offset 0x22 here, close enough to aligned L(simple): C eax scratch C ebx src C ecx counter C edx scratch C esi carry C edi dst C ebp multiplier C C this loop 8 cycles/limb movl (%ebx), %eax addl $4, %ebx mull %ebp addl %esi, %eax movl $0, %esi adcl %edx, %esi movl %eax, (%edi) addl $4, %edi loop L(simple) popl %ebp popl %edi popl %ebx movl %esi, %eax popl %esi ret C ----------------------------------------------------------------------------- C The code for each limb is 6 cycles, with instruction decoding being the C limiting factor. At 4 limbs/loop and 1 cycle/loop of overhead it's 6.25 C cycles/limb in total. C C The secret ingredient to get 6.25 is to start the loop with the mul and C have the load/store pair at the end. Rotating the load/store to the top C is an 0.5 c/l slowdown. (Some address generation effect probably.) C C The whole unrolled loop fits nicely in exactly 80 bytes. ALIGN(16) C already aligned to 16 here actually L(unroll): movl (%ebx), %eax leal -16(%ebx,%ecx,4), %ebx leal -16(%edi,%ecx,4), %edi subl $4, %ecx negl %ecx ALIGN(16) C one byte nop for this alignment L(top): C eax scratch C ebx &src[size-4] C ecx counter C edx scratch C esi carry C edi &dst[size-4] C ebp multiplier mull %ebp addl %esi, %eax movl $0, %esi adcl %edx, %esi movl %eax, (%edi,%ecx,4) movl 4(%ebx,%ecx,4), %eax mull %ebp addl %esi, %eax movl $0, %esi adcl %edx, %esi movl %eax, 4(%edi,%ecx,4) movl 8(%ebx,%ecx,4), %eax mull %ebp addl %esi, %eax movl $0, %esi adcl %edx, %esi movl %eax, 8(%edi,%ecx,4) movl 12(%ebx,%ecx,4), %eax mull %ebp addl %esi, %eax movl $0, %esi adcl %edx, %esi movl %eax, 12(%edi,%ecx,4) movl 16(%ebx,%ecx,4), %eax addl $4, %ecx js L(top) C eax next src limb C ebx &src[size-4] C ecx 0 to 3 representing respectively 4 to 1 further limbs C edx C esi carry C edi &dst[size-4] testb $2, %cl jnz L(finish_not_two) mull %ebp addl %esi, %eax movl $0, %esi adcl %edx, %esi movl %eax, (%edi,%ecx,4) movl 4(%ebx,%ecx,4), %eax mull %ebp addl %esi, %eax movl $0, %esi adcl %edx, %esi movl %eax, 4(%edi,%ecx,4) movl 8(%ebx,%ecx,4), %eax addl $2, %ecx L(finish_not_two): testb $1, %cl jnz L(finish_not_one) mull %ebp addl %esi, %eax movl $0, %esi adcl %edx, %esi movl %eax, 8(%edi) movl 12(%ebx), %eax L(finish_not_one): mull %ebp addl %esi, %eax popl %ebp adcl $0, %edx movl %eax, 12(%edi) popl %edi popl %ebx movl %edx, %eax popl %esi ret EPILOGUE()