![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fp_round.s CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / machdep / i386 / fp_emul|
Return to fp_round.s CVS log | Up to [Apple Darwin 0.x] / kernel / machdep / i386 / fp_emul |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: .file "round.s"
26:
27: .ident "@(#)kern-fp:round.s 1.1"
28:
29: //$tt(*80387 emulator + + + r o u n d + + + *)
30: // **********************************************************************
31: //
32: // r o u n d . m o d
33: // =================
34: //
35: // ===============================================================
36: // intel corporation proprietary information
37: // this software is supplied under the terms of a license
38: // agreement or non-disclosure agreement with intel corporation
39: // and may not be copied nor disclosed except in accordance with
40: // the terms of that agreement.
41: // ===============================================================
42: //
43: // function:
44: // implements all rounding modes for all precisions
45: //
46: // public procedures:
47: // round special_round_test
48: // directed_round_test
49: //
50: // internal procedures:
51: // prec16_case prec24_case
52: // prec32_case prec53_case
53: // prec64_case
54: //
55: // ***************************************************************************
56: //
57: //...october 31, 1986...
58: //
59: // .file *a_mro*
60: //
61: //$nolist
62: #include "fp_e80387.h"
63: //$list
64: //...declare status register segment...
65: //
66: .data //a_msr segment rw public
67: // extrn %gs:sr_flags
68: //a_msr ends
69: //
70: // assume %ds:a_msr
71: //
72: .text //a_med segment er public
73: //
74: // extrn get_rnd_control
75: //
76: .globl round
77: .globl directed_round_test
78: .globl special_round_test
79: //
80: // ***********************************************************************
81: // prec16_case:
82: // ************
83: // function:
84: // sets up for rounding to 16 bits.
85: //
86: // inputs:
87: // assumes edi points to operand record.
88: //
89: // outputs:
90: // sets: dl if round or sticky bit set
91: // dh if guard bit set
92: // ah if lsb set
93: // cl to number of rounded bytes
94: // ch to pattern to add to low byte for rounding
95: // and clears the guard, round, and sticky bytes.
96: // doesnt affect al.
97: //
98: // data accessed:
99: //
100: // data changed:
101: //
102: // procecures called:
103: //
104: // *************************************************************************
105: ALIGN
106: prec16_case: //proc ; initially, assume all guard,
107: xchg frac80+4(%ebp,%edi),%ecx// round, and sticky info zero
108: and %ecx,%ecx // examine and clear grst word
109: jns get_round_sticky_16
110: notb %dh // et guard byte
111: get_round_sticky_16:
112: and $0x7fffffff,%ecx
113: or frac80(%ebp,%edi),%ecx
114: orw (%ebp,%edi),%cx
115: jz get_lsb_16
116: notb %dl // set round-sticky byte
117: get_lsb_16:
118: xorb %ah,%ah // initially, assume lsb is zero
119: testb $0x01,frac80+8(%ebp,%edi)
120: jz set_rnd_info_16
121: notb %ah // set lsb byte
122: movl $0,frac80(%ebp,%edi)
123: movw $0,(%ebp,%edi)
124: set_rnd_info_16:
125: mov $0x0102,%ecx // the rounded result has 2 bytes
126: ret // the pattern to add is 01h
127: //prec16_case endp
128: //
129: // *************************************************************************
130: // prec24_case:
131: // ************
132: // function:
133: // sets up for rounding to 24 bits.
134: //
135: // inputs:
136: // assumes edi points to operand record.
137: //
138: // outputs:
139: // sets: dl if round or sticky bit set
140: // dh if guard bit set
141: // ah if lsb set
142: // cl to number of rounded bytes
143: // ch to pattern to add to low byte for rounding
144: // and clears the guard, round, and sticky bytes.
145: // doesnt affect al.
146: //
147: // data accessed:
148: //
149: // data changed:
150: //
151: // *************************************************************************
152: ALIGN
153: prec24_case: //proc ; initially, assume all guard,
154: xchgb frac32(%ebp,%edi),%cl // round, and sticky info zero
155: andb %cl,%cl // examine and clear grst word
156: jns get_round_sticky_24
157: notb %dh // set guard byte
158: get_round_sticky_24:
159: andb $0x7f,%cl
160: or frac64(%ebp,%edi),%ecx
161: or (%ebp,%edi),%ecx
162: jz get_lsb_24
163: notb %dl // set round-sticky byte
164: get_lsb_24:
165: xorb %ah,%ah // initially, assume lsb is zero
166: testb $0x01,frac32+1(%ebp,%edi)
167: jz clear_sticky_bytes_24
168: notb %ah // set lsb byte
169: clear_sticky_bytes_24:
170: movl $0,frac64(%ebp,%edi)
171: movl $0,(%ebp,%edi)
172: mov $0x0103,%ecx // the rounded result has 3 bytes
173: ret // the pattern to add is 01h
174: //prec24_case endp
175: //
176: // *****************************************************************************
177: // prec32_case:
178: // ************
179: // function:
180: // sets up for rounding to 32 bits.
181: //
182: // inputs:
183: // assumes edi points to operand record.
184: //
185: // outputs:
186: // sets: dl if round or sticky bit set
187: // dh if guard bit set
188: // ah if lsb set
189: // cl to number of rounded bytes
190: // ch to pattern to add to low byte for rounding
191: // and clears the guard, round, and sticky bytes.
192: // doesnt affect al.
193: //
194: // data accessed:
195: //
196: // data changed:
197: //
198: // *************************************************************************
199: ALIGN
200: prec32_case: //proc ; initially, assume all guard,
201: xchg frac64(%ebp,%edi),%ecx // round, and sticky info zero
202: and %ecx,%ecx
203: jns get_round_sticky_32
204: notb %dh // set guard byte
205: get_round_sticky_32:
206: and $0x7fffffff,%ecx
207: or (%ebp,%edi),%ecx
208: jz get_lsb_32
209: notb %dl // set round-sticky byte
210: get_lsb_32:
211: xorb %ah,%ah // initially, assume lsb is zero
212: testb $0x01,frac32(%ebp,%edi)
213: jz clear_sticky_bytes_32
214: not_ah_clear_32:
215: notb %ah // set lsb byte
216: clear_sticky_bytes_32:
217: movl $0,(%ebp,%edi)
218: mov $0x0104,%ecx// the rounded result has 4 bytes
219: ret // the pattern to add is 01h
220: //prec32_case endp
221: //
222: // ***********************************************************************
223: // prec53_case:
224: // ***********
225: // function:
226: // sets up for rounding to 53 bits.
227: //
228: // inputs:
229: // assumes edi points to operand record.
230: //
231: // outputs:
232: // sets: dl if round or sticky bit set
233: // dh if guard bit set
234: // ah if lsb set
235: // cl to number of rounded bytes
236: // ch to pattern to add to low byte for rounding
237: // and clears the guard, round, and sticky bytes.
238: // doesnt affect al.
239: //
240: // data accessed:
241: //
242: // data changed:
243: //
244: // ***************************************************************************
245: ALIGN
246: prec53_case: //proc ; initially, assume all guard,
247: mov frac64(%ebp,%edi),%ecx // round, and sticky info zero
248: testb $0x04,%ch // examine guard bit
249: jz get_round_sticky_53
250: notb %dh // set guard byte
251: get_round_sticky_53:
252: and $0x03ff,%ecx
253: or (%ebp,%edi),%ecx
254: jz get_lsb_53
255: notb %dl // set round-sticky byte
256: get_lsb_53:
257: xorb %ah,%ah // initially, assume lsb is zero
258: testb $0x08,frac64+1(%ebp,%edi)
259: jz clear_grst_bits_53
260: notb %ah // set lsb byte
261: clear_grst_bits_53:
262: movl $0,(%ebp,%edi)
263: andw $0x0f800,frac64(%ebp,%edi)
264: mov $0x0807,%ecx// the rounded result has 7 bytes
265: ret // the pattern to add is 08h
266: //prec53_case endp
267: //
268: // ****************************************************************************
269: // prec64_case:
270: // ************
271: // function:
272: // sets up for rounding to 64 bits.
273: //
274: // inputs:
275: // assumes edi points to operand record.
276: //
277: // outputs:
278: // sets: dl if round or sticky bit set
279: // dh if guard bit set
280: // ah if lsb set
281: // cl to number of rounded bytes
282: // ch to pattern to add to low byte for rounding
283: // and clears the guard, round, and sticky bytes.
284: // doesnt affect al.
285: //
286: // data accessed:
287: //
288: // data changed:
289: //
290: // *************************************************************************
291: ALIGN
292: prec64_case: //proc ; initially assume all guard,
293: xchg (%ebp,%edi),%ecx // round, and sticky info zero
294: and %ecx,%ecx // examine and clear grst word
295: jns get_round_sticky_64
296: notb %dh // set guard byte
297: get_round_sticky_64:
298: and $0x7fffffff,%ecx
299: jz get_lsb_64
300: notb %dl // set round-sticky byte
301: get_lsb_64:
302: xorb %ah,%ah // initially, assume lsb is zero
303: testb $0x01,frac64(%ebp,%edi)
304: jz set_round_info_64
305: notb %ah // set lsb byte
306: set_round_info_64:
307: mov $0x0108,%ecx // rounded result has 8 bytes
308: common_return:
309: ret // the pattern to add is 01h
310: //prec64_case endp
311: //
312: // **********************************************************************
313: // round:
314: // *****
315: // function:
316: // implements rounding.
317: //
318: // inputs:
319: // assumes: edi points to record to round,
320: // dl contains rounding precision,
321: // al is true if second rounding, false if first.
322: //
323: // outputs:
324: // on return, al is true if there was an high-bit carry-out
325: // as a result of incrementing the significand to do the rounding.
326: //
327: // data accessed:
328: // added_one
329: //
330: // data changed:
331: // added_one
332: //
333: // procedures called:
334: // prec16_case prec24_case
335: // prec32_case prec53_case
336: // prec64_case get_rnd_control
337: //
338: // ************************************************************************
339: precn_case:
340: .long prec24_case,prec32_case,prec53_case,prec64_case,prec16_case
341: //
342: rnd_case:
343: .long case_rnd_to_even,case_rnd_down,case_rnd_up,case_rnd_to_zero
344: //
345: ALIGN
346: round: //proc ; access unpacked status info
347: xorb %dh,%dh // set to zero the following:
348: movswl %dx,%esi // cl to num bytes in rnd frac
349: shl $2,%esi // ch to pattern to add to low
350: xorw %dx,%dx // byte in rounding
351: xor %ecx,%ecx // dl if round or sticky set
352: // mov (ebp+edi),dx ;*** zeroing low word
353: call *%cs:precn_case(%esi) // dh if grd set, ah if lsb set
354: andw %dx,%dx // if dl and dh both zero, then
355: jnz inexact_case // result is exact
356: cmpb true,%al
357: movb %dl,%al // no carry out from rounding
358: jne exact_1st_rnd
359: movb %al,rnd2_inexact
360: ret
361: ALIGN
362: exact_1st_rnd:
363: movw %dx,rnd_history
364: movb %al,added_one // clear flag, no overflow
365: ret
366: ALIGN
367: //
368: inexact_case:
369: cmpb true,%al
370: jne inexact_1st_rnd
371: movb %al,rnd2_inexact
372: jmp get_rnd_case
373: ALIGN
374: inexact_1st_rnd:
375: movw true,rnd_history// makes rnd1_inexact true, rnd2_inexact false
376: get_rnd_case:
377: push %eax // save lsb/2nd rounding flags
378: call get_rnd_control // round different rnd_control
379: movzbl %al,%ebx // cases separately
380: pop %eax // reload lsb/2nd rounding flags
381: jmp *%cs:rnd_case(%ebx)
382: ALIGN
383: case_rnd_up:
384: notb %bh //if + increment, else truncate
385: case_rnd_down:
386: cmpb %bh,sign(%ebp,%edi) //increment if neg,
387: jne do_increment // truncate if pos
388: jmp case_rnd_to_zero
389: ALIGN
390: case_rnd_to_even:
391: movb %dl,%bh // save round-sticky info in bh
392: orb %ah,%dl // if guard and (round or sticky
393: cmpb true,%al // or lsb), set dx to round up
394: jne do_add_ // if 2nd round, if ((lsb=added)
395: // mov bl, added_one ; and not (round or sticky)
396: // cmp al, rnd1_inexact ; and ((added=1) or last round
397: // jne p_error_0 ; inexact)), round in opposite
398: // mov bl, al ; al is true (0ffh), hence so is bl
399: // the preceding four instructions are equivalent to the next one
400: movb rnd1_inexact,%bl
401: p_error_0:
402: cmpw $0x00ff,%bx // unless first round was inexact and
403: jne do_add_ // current round-sticky bits are clear,
404: // decide how to round as for first round
405: cmpb added_one,%ah // else, dh (guard) must be true here because
406: // exact second rounds were ruled out earlier
407: jne do_add_ // branch if ah <> added_one
408: incw %dx // here, dh = guard, dl = lsb
409: jz case_rnd_to_zero // truncate
410: jmp do_increment
411: ALIGN
412: do_add_:
413: incw %dx
414: jz do_increment
415: case_rnd_to_zero:
416: movb false,%al // clear flag, indicate nothing
417: movb %al,added_one // added in round (al = false)
418: // and %gs:sr_flags,not a_mask ; clear the a-bit ---> defer
419: jmp set_inexact
420: ALIGN
421: do_increment:
422: // or %gs:sr_flags,a_mask ; set the a-bit ---> defer
423: movb true,added_one // set flag for 1 added in round
424: movb %ch,%dl // put pattern to add in dl
425: xorb %ch,%ch // ecx = num bytes in rounded res
426: mov $12,%ebx
427: sub %ecx,%ebx // ebx = num of low byte
428: add %ebx,%edi // edi = true offset
429: xorb %al,%al
430: addb %dl,(%ebp,%edi) // add pattern to low byte and
431: inc %edi // propogate carries
432: dec %ecx
433: FALLSTHRU
434: inc_loop:
435: adcb %al,(%ebp,%edi)
436: inc %edi
437: LOOP(inc_loop)
438: sbbb %al,%al // set al if carry set
439: sub $12,%edi // restore edi to entry value
440: set_inexact:
441: // jmp set_p_error ---> defer
442: ret
443: //round endp
444: //
445: // ****************************************************************************
446: // special_round_test:
447: // ******************
448: // function:
449: // test for rounding toward zero.
450: //
451: // inputs:
452: // assumes sign to be in al upon entry.
453: //
454: // outputs:
455: // returns true (in al) and clears zf if:
456: // (rnd_down and sign is positive) or
457: // (rnd_up and sign is negative);
458: // else returns false (in al) and sets zf.
459: //
460: // data accessed:
461: //
462: // data changed:
463: //
464: // procedures called:
465: // get_rnd_control
466: //
467: // **************************************************************************
468: ALIGN
469: special_round_test: //proc
470: movb %al,%ah // save sign
471: call get_rnd_control //get rounding mode
472: cmpb rnd_down,%al
473: jne round_up_ // branch if not down
474: andb %ah,%ah
475: jz is_true // true if +rnd_down
476: is_false:
477: xorb %al,%al // sets zf.
478: ret
479: ALIGN
480: round_up_:
481: cmpb rnd_up,%al
482: jne is_false // branch if not up
483: andb %ah,%ah
484: jz is_false // branch if +rnd_up
485: is_true:
486: orb true,%al // clears zf.
487: exit_round_test:
488: ret
489: //special_round_test endp
490: //
491: // **************************************************************************
492: // directed_round_test:
493: // *******************
494: // function:
495: // test for round control (up or down).
496: //
497: // inputs:
498: // none
499: //
500: // outputs:
501: // returns true (in al) and clears zf if the round control
502: // is rnd_up or rnd_down. otherwise, returns false and sets zf.
503: //
504: // data accessed:
505: //
506: // data changed:
507: //
508: // procedures called:
509: // get_rnd_conrol
510: //
511: // *************************************************************************
512: ALIGN
513: directed_round_test: //proc
514: call get_rnd_control
515: cmpb rnd_down,%al
516: je is_true
517: cmpb rnd_up,%al
518: je is_true
519: jmp is_false
520: //directed_round_test endp
521: //
522: //a_med ends
523: //
524: // end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.