![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lb1spc.asm CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc / config / sparc|
Return to lb1spc.asm CVS log | Up to [GCC 2.x] / gcc / config / sparc |
1.1 root 1: /* This is an assembly language implementation of libgcc1.c for the sparc
2: processor.
3:
4: These routines are derived from the Sparc Architecture Manual, version 8,
5: slightly edited to match the desired calling convention, and also to
6: optimize them for our purposes. */
7:
8: #ifdef L_mulsi3
9: .text
10: .align 4
11: .global .umul
12: .proc 4
13: .umul:
14: or %o0, %o1, %o4 ! logical or of multiplier and multiplicand
15: mov %o0, %y ! multiplier to Y register
16: andncc %o4, 0xfff, %o5 ! mask out lower 12 bits
17: be mul_shortway ! can do it the short way
18: andcc %g0, %g0, %o4 ! zero the partial product and clear NV cc
19: !
20: ! long multiply
21: !
22: mulscc %o4, %o1, %o4 ! first iteration of 33
23: mulscc %o4, %o1, %o4
24: mulscc %o4, %o1, %o4
25: mulscc %o4, %o1, %o4
26: mulscc %o4, %o1, %o4
27: mulscc %o4, %o1, %o4
28: mulscc %o4, %o1, %o4
29: mulscc %o4, %o1, %o4
30: mulscc %o4, %o1, %o4
31: mulscc %o4, %o1, %o4
32: mulscc %o4, %o1, %o4
33: mulscc %o4, %o1, %o4
34: mulscc %o4, %o1, %o4
35: mulscc %o4, %o1, %o4
36: mulscc %o4, %o1, %o4
37: mulscc %o4, %o1, %o4
38: mulscc %o4, %o1, %o4
39: mulscc %o4, %o1, %o4
40: mulscc %o4, %o1, %o4
41: mulscc %o4, %o1, %o4
42: mulscc %o4, %o1, %o4
43: mulscc %o4, %o1, %o4
44: mulscc %o4, %o1, %o4
45: mulscc %o4, %o1, %o4
46: mulscc %o4, %o1, %o4
47: mulscc %o4, %o1, %o4
48: mulscc %o4, %o1, %o4
49: mulscc %o4, %o1, %o4
50: mulscc %o4, %o1, %o4
51: mulscc %o4, %o1, %o4
52: mulscc %o4, %o1, %o4
53: mulscc %o4, %o1, %o4 ! 32nd iteration
54: mulscc %o4, %g0, %o4 ! last iteration only shifts
55: ! the upper 32 bits of product are wrong, but we do not care
56: retl
57: rd %y, %o0
58: !
59: ! short multiply
60: !
61: mul_shortway:
62: mulscc %o4, %o1, %o4 ! first iteration of 13
63: mulscc %o4, %o1, %o4
64: mulscc %o4, %o1, %o4
65: mulscc %o4, %o1, %o4
66: mulscc %o4, %o1, %o4
67: mulscc %o4, %o1, %o4
68: mulscc %o4, %o1, %o4
69: mulscc %o4, %o1, %o4
70: mulscc %o4, %o1, %o4
71: mulscc %o4, %o1, %o4
72: mulscc %o4, %o1, %o4
73: mulscc %o4, %o1, %o4 ! 12th iteration
74: mulscc %o4, %g0, %o4 ! last iteration only shifts
75: rd %y, %o5
76: sll %o4, 12, %o4 ! left shift partial product by 12 bits
77: srl %o5, 20, %o5 ! right shift partial product by 20 bits
78: retl
79: or %o5, %o4, %o0 ! merge for true product
80: #endif
81:
82: #ifdef L_divsi3
83: .text
84: .align 4
85: .global .udiv
86: .proc 4
87: .udiv:
88: save %sp, -64, %sp
89: b divide
90: mov 0, %i2 ! result always positive
91: .global .div
92: .proc 4
93: .div:
94: save %sp, -64, %sp
95: orcc %i1, %i0, %g0 ! is either operand negative
96: bge divide ! if not, skip this junk
97: xor %i1, %i0, %i2 ! record sign of result in sign of %i2
98: tst %i1
99: bge 2f
100: tst %i0
101: ! %i1 < 0
102: bge divide
103: neg %i1
104: 2: ! %i0 < 0
105: neg %i0
106: ! FALL THROUGH
107: divide:
108: ! Compute size of quotient, scale comparand.
109: orcc %i1, %g0, %l1 ! movcc %i1, %l1
110: te 2 ! if %i1 = 0
111: mov %i0, %i3
112: mov 0, %i2
113: sethi %hi(1<<(32-2-1)), %l3
114: cmp %i3, %l3
115: blu not_really_big
116: mov 0, %l0
117: !
118: ! Here, the %i0 is >= 2^(31-3) or so. We must be careful here,
119: ! as our usual 3-at-a-shot divide step will cause overflow and havoc.
120: ! The total number of bits in the result here is 3*%l0+%l4, where
121: ! %l4 <= 3.
122: ! Compute %l0 in an unorthodox manner: know we need to Shift %l1 into
123: ! the top decade: so do not even bother to compare to %i3.
124: 1: cmp %l1, %l3
125: bgeu 3f
126: mov 1, %l4
127: sll %l1, 3, %l1
128: b 1b
129: inc %l0
130: !
131: ! Now compute %l4
132: !
133: 2: addcc %l1, %l1, %l1
134: bcc not_too_big
135: add %l4, 1, %l4
136: !
137: ! We are here if the %i1 overflowed when Shifting.
138: ! This means that %i3 has the high-order bit set.
139: ! Restore %l1 and subtract from %i3.
140: sll %l3, 2, %l3
141: srl %l1, 1, %l1
142: add %l1, %l3, %l1
143: b do_single_div
144: dec %l4
145: not_too_big:
146: 3: cmp %l1, %i3
147: blu 2b
148: nop
149: be do_single_div
150: nop
151: ! %l1 > %i3: went too far: back up 1 step
152: ! srl %l1, 1, %l1
153: ! dec %l4
154: ! do single-bit divide steps
155: !
156: ! We have to be careful here. We know that %i3 >= %l1, so we can do the
157: ! first divide step without thinking. BUT, the others are conditional,
158: ! and are only done if %i3 >= 0. Because both %i3 and %l1 may have the
159: ! high-order bit set in the first step, just falling into the regular
160: ! division loop will mess up the first time around.
161: ! So we unroll slightly...
162: do_single_div:
163: deccc %l4
164: bl end_regular_divide
165: nop
166: sub %i3, %l1, %i3
167: mov 1, %i2
168: b end_single_divloop
169: nop
170: single_divloop:
171: sll %i2, 1, %i2
172: bl 1f
173: srl %l1, 1, %l1
174: ! %i3 >= 0
175: sub %i3, %l1, %i3
176: b 2f
177: inc %i2
178: 1: ! %i3 < 0
179: add %i3, %l1, %i3
180: dec %i2
181: end_single_divloop:
182: 2: deccc %l4
183: bge single_divloop
184: tst %i3
185: b end_regular_divide
186: nop
187: not_really_big:
188: 1: sll %l1, 3, %l1
189: cmp %l1, %i3
190: bleu 1b
191: inccc %l0
192: be got_result
193: dec %l0
194: do_regular_divide:
195: ! Do the main division iteration
196: tst %i3
197: ! Fall through into divide loop
198: divloop:
199: sll %i2, 3, %i2
200: ! depth 1, accumulated bits 0
201: bl L.1.8
202: srl %l1,1,%l1
203: ! remainder is positive
204: subcc %i3,%l1,%i3
205: ! depth 2, accumulated bits 1
206: bl L.2.9
207: srl %l1,1,%l1
208: ! remainder is positive
209: subcc %i3,%l1,%i3
210: ! depth 3, accumulated bits 3
211: bl L.3.11
212: srl %l1,1,%l1
213: ! remainder is positive
214: subcc %i3,%l1,%i3
215: b 9f
216: add %i2, (3*2+1), %i2
217: L.3.11: ! remainder is negative
218: addcc %i3,%l1,%i3
219: b 9f
220: add %i2, (3*2-1), %i2
221: L.2.9: ! remainder is negative
222: addcc %i3,%l1,%i3
223: ! depth 3, accumulated bits 1
224: bl L.3.9
225: srl %l1,1,%l1
226: ! remainder is positive
227: subcc %i3,%l1,%i3
228: b 9f
229: add %i2, (1*2+1), %i2
230: L.3.9: ! remainder is negative
231: addcc %i3,%l1,%i3
232: b 9f
233: add %i2, (1*2-1), %i2
234: L.1.8: ! remainder is negative
235: addcc %i3,%l1,%i3
236: ! depth 2, accumulated bits -1
237: bl L.2.7
238: srl %l1,1,%l1
239: ! remainder is positive
240: subcc %i3,%l1,%i3
241: ! depth 3, accumulated bits -1
242: bl L.3.7
243: srl %l1,1,%l1
244: ! remainder is positive
245: subcc %i3,%l1,%i3
246: b 9f
247: add %i2, (-1*2+1), %i2
248: L.3.7: ! remainder is negative
249: addcc %i3,%l1,%i3
250: b 9f
251: add %i2, (-1*2-1), %i2
252: L.2.7: ! remainder is negative
253: addcc %i3,%l1,%i3
254: ! depth 3, accumulated bits -3
255: bl L.3.5
256: srl %l1,1,%l1
257: ! remainder is positive
258: subcc %i3,%l1,%i3
259: b 9f
260: add %i2, (-3*2+1), %i2
261: L.3.5: ! remainder is negative
262: addcc %i3,%l1,%i3
263: b 9f
264: add %i2, (-3*2-1), %i2
265: end_regular_divide:
266: 9: deccc %l0
267: bge divloop
268: tst %i3
269: bge got_result
270: nop
271: ! non-restoring fixup here
272: dec %i2
273: got_result:
274: tst %i2
275: bge 1f
276: restore
277: ! answer < 0
278: retl ! leaf-routine return
279: neg %o2, %o0 ! quotient <- -%i2
280: 1: retl ! leaf-routine return
281: mov %o2, %o0 ! quotient <- %i2
282: #endif
283:
284: #ifdef L_modsi3
285: .text
286: .align 4
287: .global .urem
288: .proc 4
289: .urem:
290: save %sp, -64, %sp
291: b divide
292: mov 0, %i2 ! result always positive
293: .global .rem
294: .proc 4
295: .rem:
296: save %sp, -64, %sp
297: orcc %i1, %i0, %g0 ! is either operand negative
298: bge divide ! if not, skip this junk
299: mov %i0, %i2 ! record sign of result in sign of %i2
300: tst %i1
301: bge 2f
302: tst %i0
303: ! %i1 < 0
304: bge divide
305: neg %i1
306: 2: ! %i0 < 0
307: neg %i0
308: ! FALL THROUGH
309: divide:
310: ! Compute size of quotient, scale comparand.
311: orcc %i1, %g0, %l1 ! movcc %i1, %l1
312: te 2 ! if %i1 = 0
313: mov %i0, %i3
314: mov 0, %i2
315: sethi %hi(1<<(32-2-1)), %l3
316: cmp %i3, %l3
317: blu not_really_big
318: mov 0, %l0
319: !
320: ! Here, the %i0 is >= 2^(31-3) or so. We must be careful here,
321: ! as our usual 3-at-a-shot divide step will cause overflow and havoc.
322: ! The total number of bits in the result here is 3*%l0+%l4, where
323: ! %l4 <= 3.
324: ! Compute %l0 in an unorthodox manner: know we need to Shift %l1 into
325: ! the top decade: so do not even bother to compare to %i3.
326: 1: cmp %l1, %l3
327: bgeu 3f
328: mov 1, %l4
329: sll %l1, 3, %l1
330: b 1b
331: inc %l0
332: !
333: ! Now compute %l4
334: !
335: 2: addcc %l1, %l1, %l1
336: bcc not_too_big
337: add %l4, 1, %l4
338: !
339: ! We are here if the %i1 overflowed when Shifting.
340: ! This means that %i3 has the high-order bit set.
341: ! Restore %l1 and subtract from %i3.
342: sll %l3, 2, %l3
343: srl %l1, 1, %l1
344: add %l1, %l3, %l1
345: b do_single_div
346: dec %l4
347: not_too_big:
348: 3: cmp %l1, %i3
349: blu 2b
350: nop
351: be do_single_div
352: nop
353: ! %l1 > %i3: went too far: back up 1 step
354: ! srl %l1, 1, %l1
355: ! dec %l4
356: ! do single-bit divide steps
357: !
358: ! We have to be careful here. We know that %i3 >= %l1, so we can do the
359: ! first divide step without thinking. BUT, the others are conditional,
360: ! and are only done if %i3 >= 0. Because both %i3 and %l1 may have the
361: ! high-order bit set in the first step, just falling into the regular
362: ! division loop will mess up the first time around.
363: ! So we unroll slightly...
364: do_single_div:
365: deccc %l4
366: bl end_regular_divide
367: nop
368: sub %i3, %l1, %i3
369: mov 1, %i2
370: b end_single_divloop
371: nop
372: single_divloop:
373: sll %i2, 1, %i2
374: bl 1f
375: srl %l1, 1, %l1
376: ! %i3 >= 0
377: sub %i3, %l1, %i3
378: b 2f
379: inc %i2
380: 1: ! %i3 < 0
381: add %i3, %l1, %i3
382: dec %i2
383: end_single_divloop:
384: 2: deccc %l4
385: bge single_divloop
386: tst %i3
387: b end_regular_divide
388: nop
389: not_really_big:
390: 1: sll %l1, 3, %l1
391: cmp %l1, %i3
392: bleu 1b
393: inccc %l0
394: be got_result
395: dec %l0
396: do_regular_divide:
397: ! Do the main division iteration
398: tst %i3
399: ! Fall through into divide loop
400: divloop:
401: sll %i2, 3, %i2
402: ! depth 1, accumulated bits 0
403: bl L.1.8
404: srl %l1,1,%l1
405: ! remainder is positive
406: subcc %i3,%l1,%i3
407: ! depth 2, accumulated bits 1
408: bl L.2.9
409: srl %l1,1,%l1
410: ! remainder is positive
411: subcc %i3,%l1,%i3
412: ! depth 3, accumulated bits 3
413: bl L.3.11
414: srl %l1,1,%l1
415: ! remainder is positive
416: subcc %i3,%l1,%i3
417: b 9f
418: add %i2, (3*2+1), %i2
419: L.3.11: ! remainder is negative
420: addcc %i3,%l1,%i3
421: b 9f
422: add %i2, (3*2-1), %i2
423: L.2.9: ! remainder is negative
424: addcc %i3,%l1,%i3
425: ! depth 3, accumulated bits 1
426: bl L.3.9
427: srl %l1,1,%l1
428: ! remainder is positive
429: subcc %i3,%l1,%i3
430: b 9f
431: add %i2, (1*2+1), %i2
432: L.3.9: ! remainder is negative
433: addcc %i3,%l1,%i3
434: b 9f
435: add %i2, (1*2-1), %i2
436: L.1.8: ! remainder is negative
437: addcc %i3,%l1,%i3
438: ! depth 2, accumulated bits -1
439: bl L.2.7
440: srl %l1,1,%l1
441: ! remainder is positive
442: subcc %i3,%l1,%i3
443: ! depth 3, accumulated bits -1
444: bl L.3.7
445: srl %l1,1,%l1
446: ! remainder is positive
447: subcc %i3,%l1,%i3
448: b 9f
449: add %i2, (-1*2+1), %i2
450: L.3.7: ! remainder is negative
451: addcc %i3,%l1,%i3
452: b 9f
453: add %i2, (-1*2-1), %i2
454: L.2.7: ! remainder is negative
455: addcc %i3,%l1,%i3
456: ! depth 3, accumulated bits -3
457: bl L.3.5
458: srl %l1,1,%l1
459: ! remainder is positive
460: subcc %i3,%l1,%i3
461: b 9f
462: add %i2, (-3*2+1), %i2
463: L.3.5: ! remainder is negative
464: addcc %i3,%l1,%i3
465: b 9f
466: add %i2, (-3*2-1), %i2
467: end_regular_divide:
468: 9: deccc %l0
469: bge divloop
470: tst %i3
471: bge got_result
472: nop
473: ! non-restoring fixup here
474: add %i3, %i1, %i3
475: got_result:
476: tst %i2
477: bge 1f
478: restore
479: ! answer < 0
480: retl ! leaf-routine return
481: neg %o3, %o0 ! remainder <- -%i3
482: 1: retl ! leaf-routine return
483: mov %o3, %o0 ! remainder <- %i3
484: #endif
485:
486:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.