![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to aorsmul_1.asm CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gmp / mpn / x86 / p6|
Return to aorsmul_1.asm CVS log | Up to [local] / OpenXM_contrib / gmp / mpn / x86 / p6 |
1.1 maekawa 1: dnl Intel P6 mpn_addmul_1/mpn_submul_1 -- add or subtract mpn multiple.
2: dnl
3: dnl P6: 6.35 cycles/limb (at 16 limbs/loop).
4:
5:
6: dnl Copyright (C) 1999, 2000 Free Software Foundation, Inc.
7: dnl
8: dnl This file is part of the GNU MP Library.
9: dnl
10: dnl The GNU MP Library is free software; you can redistribute it and/or
11: dnl modify it under the terms of the GNU Lesser General Public License as
12: dnl published by the Free Software Foundation; either version 2.1 of the
13: dnl License, or (at your option) any later version.
14: dnl
15: dnl The GNU MP Library is distributed in the hope that it will be useful,
16: dnl but WITHOUT ANY WARRANTY; without even the implied warranty of
17: dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18: dnl Lesser General Public License for more details.
19: dnl
20: dnl You should have received a copy of the GNU Lesser General Public
21: dnl License along with the GNU MP Library; see the file COPYING.LIB. If
22: dnl not, write to the Free Software Foundation, Inc., 59 Temple Place -
23: dnl Suite 330, Boston, MA 02111-1307, USA.
24:
25:
26: include(`../config.m4')
27:
28:
29: dnl P6 UNROLL_COUNT cycles/limb
30: dnl 8 6.7
31: dnl 16 6.35
32: dnl 32 6.3
33: dnl 64 6.3
34: dnl Maximum possible with the current code is 64.
35:
36: deflit(UNROLL_COUNT, 16)
37:
38:
39: ifdef(`OPERATION_addmul_1', `
40: define(M4_inst, addl)
41: define(M4_function_1, mpn_addmul_1)
42: define(M4_function_1c, mpn_addmul_1c)
43: define(M4_description, add it to)
44: define(M4_desc_retval, carry)
45: ',`ifdef(`OPERATION_submul_1', `
46: define(M4_inst, subl)
47: define(M4_function_1, mpn_submul_1)
48: define(M4_function_1c, mpn_submul_1c)
49: define(M4_description, subtract it from)
50: define(M4_desc_retval, borrow)
51: ',`m4_error(`Need OPERATION_addmul_1 or OPERATION_submul_1
52: ')')')
53:
54: MULFUNC_PROLOGUE(mpn_addmul_1 mpn_addmul_1c mpn_submul_1 mpn_submul_1c)
55:
56:
57: C mp_limb_t M4_function_1 (mp_ptr dst, mp_srcptr src, mp_size_t size,
58: C mp_limb_t mult);
59: C mp_limb_t M4_function_1c (mp_ptr dst, mp_srcptr src, mp_size_t size,
60: C mp_limb_t mult, mp_limb_t carry);
61: C
62: C Calculate src,size multiplied by mult and M4_description dst,size.
63: C Return the M4_desc_retval limb from the top of the result.
64: C
65: C This code is pretty much the same as the K6 code. The unrolled loop is
66: C the same, but there's just a few scheduling tweaks in the setups and the
67: C simple loop.
68: C
69: C A number of variations have been tried for the unrolled loop, with one or
70: C two carries, and with loads scheduled earlier, but nothing faster than 6
71: C cycles/limb has been found.
72:
73: ifdef(`PIC',`
74: deflit(UNROLL_THRESHOLD, 5)
75: ',`
76: deflit(UNROLL_THRESHOLD, 5)
77: ')
78:
79: defframe(PARAM_CARRY, 20)
80: defframe(PARAM_MULTIPLIER,16)
81: defframe(PARAM_SIZE, 12)
82: defframe(PARAM_SRC, 8)
83: defframe(PARAM_DST, 4)
84:
85: .text
86: ALIGN(32)
87:
88: PROLOGUE(M4_function_1c)
89: pushl %ebx
90: deflit(`FRAME',4)
91: movl PARAM_CARRY, %ebx
92: jmp LF(M4_function_1,start_nc)
93: EPILOGUE()
94:
95: PROLOGUE(M4_function_1)
96: push %ebx
97: deflit(`FRAME',4)
98: xorl %ebx, %ebx C initial carry
99:
100: L(start_nc):
101: movl PARAM_SIZE, %ecx
102: pushl %esi
103: deflit(`FRAME',8)
104:
105: movl PARAM_SRC, %esi
106: pushl %edi
107: deflit(`FRAME',12)
108:
109: movl PARAM_DST, %edi
110: pushl %ebp
111: deflit(`FRAME',16)
112: cmpl $UNROLL_THRESHOLD, %ecx
113:
114: movl PARAM_MULTIPLIER, %ebp
115: jae L(unroll)
116:
117:
118: C simple loop
119: C this is offset 0x22, so close enough to aligned
120: L(simple):
121: C eax scratch
122: C ebx carry
123: C ecx counter
124: C edx scratch
125: C esi src
126: C edi dst
127: C ebp multiplier
128:
129: movl (%esi), %eax
130: addl $4, %edi
131:
132: mull %ebp
133:
134: addl %ebx, %eax
135: adcl $0, %edx
136:
137: M4_inst %eax, -4(%edi)
138: movl %edx, %ebx
139:
140: adcl $0, %ebx
141: decl %ecx
142:
143: leal 4(%esi), %esi
144: jnz L(simple)
145:
146:
147: popl %ebp
148: popl %edi
149:
150: popl %esi
151: movl %ebx, %eax
152:
153: popl %ebx
154: ret
155:
156:
157:
158: C------------------------------------------------------------------------------
159: C VAR_JUMP holds the computed jump temporarily because there's not enough
160: C registers when doing the mul for the initial two carry limbs.
161: C
162: C The add/adc for the initial carry in %ebx is necessary only for the
163: C mpn_add/submul_1c entry points. Duplicating the startup code to
164: C eliminiate this for the plain mpn_add/submul_1 doesn't seem like a good
165: C idea.
166:
167: dnl overlapping with parameters already fetched
168: define(VAR_COUNTER,`PARAM_SIZE')
169: define(VAR_JUMP, `PARAM_DST')
170:
171: C this is offset 0x43, so close enough to aligned
172: L(unroll):
173: C eax
174: C ebx initial carry
175: C ecx size
176: C edx
177: C esi src
178: C edi dst
179: C ebp
180:
181: movl %ecx, %edx
182: decl %ecx
183:
184: subl $2, %edx
185: negl %ecx
186:
187: shrl $UNROLL_LOG2, %edx
188: andl $UNROLL_MASK, %ecx
189:
190: movl %edx, VAR_COUNTER
191: movl %ecx, %edx
192:
193: C 15 code bytes per limb
194: ifdef(`PIC',`
195: call L(pic_calc)
196: L(here):
197: ',`
198: shll $4, %edx
199: negl %ecx
200:
201: leal L(entry) (%edx,%ecx,1), %edx
202: ')
203: movl (%esi), %eax C src low limb
204:
205: movl %edx, VAR_JUMP
206: leal ifelse(UNROLL_BYTES,256,128+) 4(%esi,%ecx,4), %esi
207:
208: mull %ebp
209:
210: addl %ebx, %eax C initial carry (from _1c)
211: adcl $0, %edx
212:
213: movl %edx, %ebx C high carry
214: leal ifelse(UNROLL_BYTES,256,128) (%edi,%ecx,4), %edi
215:
216: movl VAR_JUMP, %edx
217: testl $1, %ecx
218: movl %eax, %ecx C low carry
219:
220: cmovnz( %ebx, %ecx) C high,low carry other way around
221: cmovnz( %eax, %ebx)
222:
223: jmp *%edx
224:
225:
226: ifdef(`PIC',`
227: L(pic_calc):
228: shll $4, %edx
229: negl %ecx
230:
231: C See README.family about old gas bugs
232: leal (%edx,%ecx,1), %edx
233: addl $L(entry)-L(here), %edx
234:
235: addl (%esp), %edx
236:
237: ret
238: ')
239:
240:
241: C -----------------------------------------------------------
242: ALIGN(32)
243: L(top):
244: deflit(`FRAME',16)
245: C eax scratch
246: C ebx carry hi
247: C ecx carry lo
248: C edx scratch
249: C esi src
250: C edi dst
251: C ebp multiplier
252: C
253: C VAR_COUNTER loop counter
254: C
255: C 15 code bytes per limb
256:
257: addl $UNROLL_BYTES, %edi
258:
259: L(entry):
260: deflit(CHUNK_COUNT,2)
261: forloop(`i', 0, UNROLL_COUNT/CHUNK_COUNT-1, `
262: deflit(`disp0', eval(i*4*CHUNK_COUNT ifelse(UNROLL_BYTES,256,-128)))
263: deflit(`disp1', eval(disp0 + 4))
264:
265: Zdisp( movl, disp0,(%esi), %eax)
266: mull %ebp
267: Zdisp( M4_inst,%ecx, disp0,(%edi))
268: adcl %eax, %ebx
269: movl %edx, %ecx
270: adcl $0, %ecx
271:
272: movl disp1(%esi), %eax
273: mull %ebp
274: M4_inst %ebx, disp1(%edi)
275: adcl %eax, %ecx
276: movl %edx, %ebx
277: adcl $0, %ebx
278: ')
279:
280: decl VAR_COUNTER
281: leal UNROLL_BYTES(%esi), %esi
282:
283: jns L(top)
284:
285:
286: deflit(`disp0', eval(UNROLL_BYTES ifelse(UNROLL_BYTES,256,-128)))
287:
288: M4_inst %ecx, disp0(%edi)
289: movl %ebx, %eax
290:
291: popl %ebp
292: popl %edi
293:
294: popl %esi
295: popl %ebx
296: adcl $0, %eax
297:
298: ret
299:
300: EPILOGUE()