![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to reg_u_div.S CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / kernel / emulator|
Return to reg_u_div.S CVS log | Up to [MW Coherent from dump] / coherent / b / kernel / emulator |
1.1 root 1: .file "reg_u_div.S"
2: /*---------------------------------------------------------------------------+
3: | reg_u_div.S |
4: | |
5: | Core division routines |
6: | |
7: | Copyright (C) 1992 W. Metzenthen, 22 Parker St, Ormond, Vic 3163, |
8: | Australia. E-mail [email protected] |
9: | |
10: | |
11: +---------------------------------------------------------------------------*/
12:
13: /*---------------------------------------------------------------------------+
14: | Kernel for the division routines. |
15: | |
16: | void reg_u_div(unsigned long long *a, unsigned long long *a, |
17: | FPU_REG *dest) |
18: | |
19: | Does not compute the destination exponent, but does adjust it. |
20: +---------------------------------------------------------------------------*/
21:
22: #include "exception.h"
23: #include "fpu_asm.h"
24:
25:
26: #define dSIGL(x) (x)
27: #define dSIGH(x) 4(x)
28:
29:
30: .data
31: /*
32: Local storage:
33: Result: accum_3:accum_2:accum_1:accum_0
34: Overflow flag: ovfl_flag
35: */
36: .align 2,0
37: accum_3:
38: .long 0
39: accum_2:
40: .long 0
41: accum_1:
42: .long 0
43: accum_0:
44: .long 0
45: result_1:
46: .long 0
47: result_2:
48: .long 0
49: ovfl_flag:
50: .byte 0
51:
52:
53: .text
54: .align 2,144
55:
56: .globl reg_u_div
57:
58: .globl divide_kernel
59:
60: reg_u_div:
61: pushl %ebp
62: movl %esp,%ebp
63:
64: pushl %esi
65: pushl %edi
66: pushl %ebx
67:
68: movl PARAM1,%esi /* pointer to num */
69: movl PARAM2,%ebx /* pointer to denom */
70: movl PARAM3,%edi /* pointer to answer */
71:
72: divide_kernel:
73: #ifdef PARANOID
74: // testl $0x80000000, dSIGH(%esi)
75: // je xL_bugged
76: testl $0x80000000, dSIGH(%ebx)
77: je xL_bugged
78: #endif PARANOID
79:
80: /* Check if the denominator can be treated as having just 32 bits */
81: cmpl $0,dSIGL(%ebx)
82: jnz L_Full_Division /* Can't do a quick divide */
83:
84: /* We should be able to zip through the division here */
85: movl dSIGH(%ebx),%ecx /* The denominator */
86: movl dSIGH(%esi),%edx /* Get the current num */
87: movl dSIGL(%esi),%eax /* Get the current num */
88:
89: cmpl %ecx,%edx
90: setae ovfl_flag /* Keep a record */
91: jb xL_no_adjust
92:
93: subl %ecx,%edx /* Prevent the overflow */
94:
95: xL_no_adjust:
96: /* Divide the 64 bit number by the 32 bit denominator */
97: divl %ecx
98: movl %eax,SIGH(%edi) /* Put the result in the answer */
99:
100: /* Work on the remainder of the first division */
101: xorl %eax,%eax
102: divl %ecx
103: movl %eax,SIGL(%edi) /* Put the result in the answer */
104:
105: /* Work on the remainder of the 64 bit division */
106: xorl %eax,%eax
107: divl %ecx
108:
109: testb $255,ovfl_flag /* was the num > denom ? */
110: je xL_no_overflow
111:
112: /* Do the shifting here */
113: /* increase the exponent */
114: incl EXP(%edi)
115:
116: /* shift the mantissa right one bit */
117: stc /* To set the ms bit */
118: rcrl $1,SIGH(%edi)
119: rcrl $1,SIGL(%edi)
120: rcrl $1,%eax
121:
122: xL_no_overflow:
123: cmpl $0x80000000,%eax
124: jc xL_no_round
125: jnz xL_round_up
126:
127: /* "round to even" used */
128: testb $1,SIGL(%edi)
129: jz xL_no_round
130:
131: xL_round_up:
132: addl $1,SIGL(%edi)
133: adcl $0,SIGH(%edi)
134:
135: #ifdef PARANOID
136: jc xL_bugged2
137: #endif PARANOID
138:
139: xL_no_round:
140: jmp xL_done
141:
142:
143: #ifdef PARANOID
144: xL_bugged:
145: pushl EX_INTERNAL|0x203
146: call EXCEPTION
147: pop %ebx
148: jmp xL_exit
149:
150: xL_bugged2:
151: pushl EX_INTERNAL|0x204
152: call EXCEPTION
153: pop %ebx
154: jmp xL_exit
155: #endif PARANOID
156:
157:
158: /*---------------------------------------------------------------------------+
159: | Divide: Return arg1/arg2 to arg3. |
160: | |
161: | This routine does not use the exponents of arg1 and arg2, but does |
162: | adjust the exponent of arg3. |
163: | |
164: | The maximum returned value is (ignoring exponents) |
165: | .ffffffff ffffffff |
166: | ------------------ = 1.ffffffff fffffffe |
167: | .80000000 00000000 |
168: | and the minimum is |
169: | .80000000 00000000 |
170: | ------------------ = .80000000 00000001 (rounded) |
171: | .ffffffff ffffffff |
172: | |
173: +---------------------------------------------------------------------------*/
174:
175:
176: L_Full_Division:
177: movl dSIGL(%esi),%eax /* Save extended num in local register */
178: movl %eax,accum_2
179: movl dSIGH(%esi),%eax
180: movl %eax,accum_3
181: xorl %eax,%eax
182: movl %eax,accum_1 /* zero the extension */
183: movl %eax,accum_0 /* zero the extension */
184:
185: movl dSIGL(%esi),%eax /* Get the current num */
186: movl dSIGH(%esi),%edx
187:
188: /*----------------------------------------------------------------------*/
189: /* Initialization done */
190: /* Do the first 32 bits */
191:
192: movb $0,ovfl_flag
193: cmpl dSIGH(%ebx),%edx /* Test for imminent overflow */
194: jb L02
195: ja L01
196:
197: cmpl dSIGL(%ebx),%eax
198: jb L02
199:
200: L01:
201: /* The numerator is greater or equal, would cause overflow */
202: setae ovfl_flag /* Keep a record */
203:
204: subl dSIGL(%ebx),%eax
205: sbbl dSIGH(%ebx),%edx /* Prevent the overflow */
206: movl %eax,accum_2
207: movl %edx,accum_3
208:
209: L02:
210: /* At this point, we have a num < denom, with a record of
211: adjustment in ovfl_flag */
212:
213: /* We will divide by a number which is too large */
214: movl dSIGH(%ebx),%ecx
215: addl $1,%ecx
216: jnc L04
217:
218: /* here we need to divide by 100000000h,
219: i.e., no division at all.. */
220:
221: mov %edx,%eax
222: jmp L05
223:
224: L04:
225: divl %ecx /* Divide the numerator by the augmented
226: denom ms dw */
227:
228: L05:
229: movl %eax,result_2 /* Put the result in the answer */
230:
231: mull dSIGH(%ebx) /* mul by the ms dw of the denom */
232:
233: subl %eax,accum_2 /* Subtract from the num local reg */
234: sbbl %edx,accum_3
235:
236: movl result_2,%eax /* Get the result back */
237: mull dSIGL(%ebx) /* now mul the ls dw of the denom */
238:
239: subl %eax,accum_1 /* Subtract from the num local reg */
240: sbbl %edx,accum_2
241: sbbl $0,accum_3
242: je L10 /* Must check for non-zero result here */
243:
244: #ifdef PARANOID
245: jb L_bugged
246: #endif PARANOID
247:
248: /* need to subtract another once of the denom */
249: incl result_2 /* Correct the answer */
250:
251: movl dSIGL(%ebx),%eax
252: movl dSIGH(%ebx),%edx
253: subl %eax,accum_1 /* Subtract from the num local reg */
254: sbbl %edx,accum_2
255:
256: #ifdef PARANOID
257: sbbl $0,accum_3
258: jne L_bugged /* Must check for non-zero result here */
259: #endif PARANOID
260:
261: /*----------------------------------------------------------------------*/
262: /* Half of the main problem is done, there is just a reduced numerator
263: to handle now */
264: /* Work with the second 32 bits, accum_0 not used from now on */
265: L10:
266: movl accum_2,%edx /* get the reduced num */
267: movl accum_1,%eax
268:
269: /* need to check for possible subsequent overflow */
270: cmpl dSIGH(%ebx),%edx
271: jb L22
272: ja L21
273:
274: cmpl dSIGL(%ebx),%eax
275: jb L22
276:
277: L21:
278: /* The numerator is greater or equal, would cause overflow */
279: /* prevent overflow */
280: subl dSIGL(%ebx),%eax
281: sbbl dSIGH(%ebx),%edx
282: movl %edx,accum_2
283: movl %eax,accum_1
284:
285: incl result_2 /* Reflect the subtraction in the answer */
286:
287: #ifdef PARANOID
288: je L_bugged
289: #endif PARANOID
290:
291: L22:
292: cmpl $0,%ecx
293: jnz L24
294:
295: /* %ecx == 0, we are dividing by 1.0 */
296: mov %edx,%eax
297: jmp L25
298:
299: L24:
300: divl %ecx /* Divide the numerator by the denom ms dw */
301:
302: L25:
303: movl %eax,result_1 /* Put the result in the answer */
304:
305: mull dSIGH(%ebx) /* mul by the ms dw of the denom */
306:
307: subl %eax,accum_1 /* Subtract from the num local reg */
308: sbbl %edx,accum_2
309:
310: #ifdef PARANOID
311: jc L_bugged
312: #endif PARANOID
313:
314: movl result_1,%eax /* Get the result back */
315: mull dSIGL(%ebx) /* now mul the ls dw of the denom */
316:
317: /* Here we are throwing away some ls bits */
318: subl %eax,accum_0 /* Subtract from the num local reg */
319: sbbl %edx,accum_1 /* Subtract from the num local reg */
320: sbbl $0,accum_2
321:
322: #ifdef PARANOID
323: jc L_bugged
324: #endif PARANOID
325:
326: jz L35 /* Just deal with rounding now */
327:
328: #ifdef PARANOID
329: cmpl $1,accum_2
330: jne L_bugged
331: #endif PARANOID
332:
333: L32:
334: /* need to subtract another once of the denom */
335: movl dSIGL(%ebx),%eax
336: movl dSIGH(%ebx),%edx
337: subl %eax,accum_0 /* Subtract from the num local reg */
338: sbbl %edx,accum_1
339: sbbl $0,accum_2
340:
341: #ifdef PARANOID
342: jc L_bugged
343: jne L_bugged
344: #endif PARANOID
345:
346: addl $1,result_1 /* Correct the answer */
347: adcl $0,result_2
348:
349: #ifdef PARANOID
350: /* Do we ever really need this check? ***** */
351: jc L_bugged /* Must check for non-zero result here */
352: #endif PARANOID
353:
354: /*----------------------------------------------------------------------*/
355: /* The division is essentially finished here, we just need to perform
356: tidying operations. */
357: /* deal with the 3rd 32 bits */
358: L35:
359: movl accum_1,%edx /* get the reduced num */
360: movl accum_0,%eax
361:
362: /* need to check for possible subsequent overflow */
363: cmpl dSIGH(%ebx),%edx
364: jb L42
365: ja L41
366:
367: cmpl dSIGL(%ebx),%eax
368: jb L42
369:
370: L41:
371: /* prevent overflow */
372: subl dSIGL(%ebx),%eax
373: sbbl dSIGH(%ebx),%edx
374: movl %edx,accum_1
375: movl %eax,accum_0 /* ***** not needed unless extended rounding */
376:
377: addl $1,result_1 /* Reflect the subtraction in the answer */
378: adcl $0,result_2
379: jne L42
380: jnc L42
381:
382: /* This is a tricky spot, there is an overflow of the answer */
383: movb $255,ovfl_flag /* Overflow -> 1.000 */
384:
385: L42:
386: /* Now test for rounding */
387: movl accum_1,%edx /* ms byte of accum extension */
388:
389: L44:
390: cmpl $0,%ecx
391: jnz L241
392:
393: /* %ecx == 0, we are dividing by 1.0 */
394: mov %edx,%eax
395: jmp L251
396:
397: L241:
398: divl %ecx /* Divide the numerator by the denom ms dw */
399:
400: L251:
401: /* We are now ready to deal with rounding, but first we must get
402: the bits properly aligned */
403: testb $255,ovfl_flag /* was the num > denom ? */
404: je L45
405:
406: incl EXP(%edi)
407:
408: /* shift the mantissa right one bit */
409: stc // Will set the ms bit
410: rcrl $1,result_2
411: rcrl $1,result_1
412: rcrl $1,%eax
413:
414: L45:
415: cmpl $0x80000000,%eax
416: jc xL_no_round_2 // No round up
417: jnz xL_round_up_2
418:
419: /* "round to even" used here for now... */
420: testb $1,result_1
421: jz xL_no_round_2 // No round up
422:
423: xL_round_up_2:
424: addl $1,result_1
425: adcl $0,result_2
426:
427: #ifdef PARANOID
428: jc L_bugged
429: #endif PARANOID
430:
431: xL_no_round_2:
432: movl result_1,%eax
433: movl %eax,SIGL(%edi)
434: movl result_2,%eax
435: movl %eax,SIGH(%edi)
436:
437: xL_done:
438: decl EXP(%edi) /* binary point between 1st & 2nd bits */
439:
440: xL_check_exponent:
441: cmpl EXP_OVER,EXP(%edi)
442: jge xL_overflow
443:
444: cmpl EXP_UNDER,EXP(%edi)
445: jle xL_underflow
446:
447: xL_exit:
448: popl %ebx
449: popl %edi
450: popl %esi
451:
452: leave
453: ret
454:
455:
456: xL_overflow:
457: pushl %edi
458: call arith_overflow
459: popl %ebx
460: jmp xL_exit
461:
462: xL_underflow:
463: pushl %edi
464: call arith_underflow
465: popl %ebx
466: jmp xL_exit
467:
468:
469: #ifdef PARANOID
470: /* The logic is wrong if we got here */
471: L_bugged:
472: pushl EX_INTERNAL|0x202
473: call EXCEPTION
474: pop %ebx
475: jmp xL_exit
476: #endif PARANOID
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.