![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fp_arith.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_arith.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 "arith.s"
26:
27: .ident "@(#)kern-fp:arith.s 1.1"
28: //$tt(*80387 emulator + + + arithmetic + + +*)
29: // ************************************************************************
30: //
31: // a r i t h . m o d
32: // =================
33: //
34: // ===============================================================
35: // intel corporation proprietary information
36: // this software is supplied under the terms of a license
37: // agreement or non-disclosure agreement with intel corporation
38: // and may not be copied or disclosed except in accordance with
39: // the terms of that agreement.
40: // ===============================================================
41: //
42: // function:
43: // implements add, subtract, multiply, and divide.
44: //
45: // public procedures:
46: // move_op_to_result overflow_response
47: // underflow_response put_max_nan
48: // put_indefinite arith
49: //
50: // *************************************************************************
51: //
52: //...March 3, 1987...
53: //
54: // .file *a_mar*
55: #include "fp_e80387.h"
56: //$eject
57: //...declare status register segment...
58: //
59: .data //a_msr segment rw public
60: // extrn sr_masks
61: //a_msr ends
62: //
63: .text //a_med segment er public
64: // assume %ds:a_med
65: // extrn addition_normalize,round
66: // extrn gradual_underflow,put_result
67: // extrn pop_free,subadd,mult
68: // extrn divid,set_up_indefinite,test_4w
69: // extrn special_round_test,directed_round_test
70: // extrn get_precision,u_masked_,set_i_masked_
71: // extrn d_masked_,affine_infinity_,i_masked_
72: // extrn o_masked_,set_p_error,set_u_error
73: // extrn set_o_error,set_z_masked_,set_d_masked_
74: // extrn set_stk_u_error,d_error_,get_rnd_control
75: //
76: .globl put_indefinite
77: .globl move_op_to_result
78: .globl put_max_nan
79: .globl overflow_response
80: .globl underflow_response
81: .globl arith
82: .globl norm_denorm
83: .globl put_arith_result
84: .globl set_up_nan_return
85: //$eject
86: //
87: //...define some floating point constants...
88: //
89: indefinite_pattern:
90: .value 0,0,0,0x0c000,0x0ffff
91: infinity_pattern:
92: .value 0,0,0,0x8000,0x7fff
93: zero_pattern:
94: .value 0,0,0,0,0
95: max_valid_pattern:
96: .value 0x0ffff,0x0ffff,0x0ffff,0x0ffff,0x7ffe
97: arith_table:
98: .long subadd,subadd,mult,divid
99: //
100: //...the following jump tables refer to the following op1/op2 cases
101: //
102: // (where v=valid, z=zero, f=infinity, and d=denormal):
103: // v/v,v/z,v/f,v/d,z/v,z/z,z/f,z/d,f/v,f/z,f/f,f/d,d/v,d/z,d/f and d/d,
104: // in that order ..
105: //add_table
106: special_table:
107: .long handle_non_special_cases,handle_non_special_cases
108: .long second_operand,only_op2_denormd
109: .long handle_non_special_cases,handle_non_special_cases
110: .long second_operand,only_op2_denormd
111: .long first_operand,first_operand
112: .long add_sub_infinities,derror_with_first_operand
113: .long only_op1_denormd,only_op1_denormd
114: .long derror_with_second_operand,both_ops_denormd
115: //sub_table
116: .long handle_non_special_cases,handle_non_special_cases
117: .long neg_second_operand,only_op2_denormd
118: .long handle_non_special_cases,handle_non_special_cases
119: .long neg_second_operand,only_op2_denormd
120: .long first_operand,first_operand
121: .long add_sub_infinities,derror_with_first_operand
122: .long only_op1_denormd,only_op1_denormd
123: .long derror_with_neg_second_operand,both_ops_denormd
124: //mul_table
125: .long handle_non_special_cases,exor_signed_zero
126: .long exor_signed_infinity,only_op2_denormd
127: .long exor_signed_zero,exor_signed_zero
128: .long invalid_error_detected,denormd_exor_signed_zero
129: .long exor_signed_infinity,invalid_error_detected
130: .long exor_signed_infinity,denormd_exor_signed_infinity
131: .long only_op1_denormd,denormd_exor_signed_zero
132: .long denormd_exor_signed_infinity,both_ops_denormd
133: //div_table
134: .long handle_non_special_cases,divide_by_zero
135: .long exor_signed_zero,only_op2_denormd
136: .long exor_signed_zero,invalid_error_detected
137: .long exor_signed_zero,denormd_exor_signed_zero
138: .long exor_signed_infinity,exor_signed_infinity
139: .long invalid_error_detected,denormd_exor_signed_infinity
140: .long only_op1_denormd,divide_by_zero
141: .long denormd_exor_signed_zero,both_ops_denormd
142: //
143: //$eject
144: // put_indefinite:
145: //
146: // function:
147: // sets unpacked result to indefinite.
148: //
149: // inputs:
150: //
151: // outputs:
152: // result set to indefinite; tag set to invalid.
153: //
154: // data accessed:
155: // - result_sign result_tag
156: //
157: // data changed:
158: // - result
159: //
160: ALIGN
161: put_indefinite: //proc
162: mov $indefinite_pattern,%esi
163: movb negative,result_sign(%ebp)
164: // note that entry points below do not affect result_sign.
165: put_inv_tag:
166: movb inv,result_tag(%ebp) // fall into set_constant_result
167: set_constant_result:
168: lea offset_result+4(%ebp),%edi
169: // push %ds // save a?msr
170: // push %cs
171: // pop %ds
172: // push %ss
173: // pop %es
174:
175: /* FAST_MOVSL */
176: movl %cs:0(%esi),%ecx
177: movl %ecx,%ss:0(%edi)
178: movl %cs:4(%esi),%ecx
179: movl %ecx,%ss:4(%edi)
180: // addl $8,%esi
181:
182: mov %ecx,result_dword_frac(%ebp) // clear ls dword
183: mov %cs:8(%esi),%eax // move exponent
184: movw %ax,result_expon(%ebp) // to result
185: // pop %ds // reload a?msr
186: ret
187: //put_indefinite endp
188: //$eject
189: // move_op_to_result:
190: //
191: // function:
192: // moves operand to result.
193: //
194: // inputs:
195: // assumes ss:(ebp).esi points to op1 or op2
196: //
197: // outputs:
198: // result in result
199: //
200: // data accessed:
201: // - expon1 offset_result
202: // - result_expon
203: //
204: // data changed:
205: // - result
206: //
207: ALIGN
208: move_op_to_result: //proc
209: // push %ds // save a?msr
210: add %ebp,%esi
211: // push %ss
212: // pop %ds
213: // push %ss
214: // pop %es
215: lea offset_result(%ebp),%edi
216: mov $((offset_operand2-offset_operand1)>>2),%ecx
217:
218: /* FAST_MOVSL */
219: 1:
220: movl %ss:0(%esi),%eax
221: movl %eax,%ss:0(%edi)
222: addl $4,%esi
223: addl $4,%edi
224: decl %ecx
225: testl %ecx,%ecx
226: jg 1b
227:
228: // pop %ds // reload a?msr
229: ret
230: //move_op_to_result endp
231: //$eject
232: // overflow_response:
233: //
234: // function:
235: // responds to detected overflow.
236: //
237: // inputs:
238: //
239: // outputs:
240: // overflow error indication(s) set when appropriate
241: // correct masked or unmasked result
242: //
243: // data accessed:
244: // - result_sign result_tag
245: // - result_expon msb_result
246: //
247: // data changed:
248: // - result
249: //
250: // procedures called:
251: // special_round_test set_o_error
252: // o_masked? set_p_error
253: //
254: //
255: ALIGN
256: overflow_response: //proc
257: orb overflow_mask, %gs:sr_errors //set overflow error
258: testb overflow_mask, %gs:sr_masks
259: jnz masked_overflow // branch if ovflw masked
260: // note that p_error may have been set by the first rounding of the result,
261: // and that rounded result will now have its exponents bias adjusted:
262: reduce_exponent:
263: subl wrap_around_constant,dword_result_expon // subtract
264: cmpl $0x7fff, dword_result_expon //wrap around constant
265: jge masked_overflow // bad! should give qnan indefinite
266: unmasked_ov_un_rounds:
267: cmpb true, rnd1_inexact //detect inexact result
268: jne give_valid_o_result // if exact, branch to replace source
269: orb $inexact_mask, %gs:sr_errors // else, set p_error
270: cmpb true, added_one //was rounding done by adding one
271: jne give_valid_o_result // if not branch to replace source
272: orb $a_mask, %gs:sr_flags // else set A_bit
273: jmp give_valid_o_result
274: ALIGN
275: masked_overflow:
276: orb $inexact_mask, %gs:sr_errors //set p_error
277: call get_rnd_control
278: cmpb rnd_to_zero,%al
279: je put_max_valid
280: movb result_sign(%ebp),%al // check for special
281: call special_round_test // rounding case
282: jnz put_max_valid
283: orb $a_mask, %gs:sr_flags //set a_bit
284: put_infinity:
285: mov $infinity_pattern,%esi
286: jmp put_inv_tag
287: ALIGN
288: put_max_valid:
289: // mov (ebp).result_tag, valid
290: movl $0x00007ffe,dword_result_expon
291: movl $0,result_dword_frac(%ebp)
292: movl $0x0ffffffff,result_dword_frac+frac64(%ebp)
293: movl $0x0ffffffff,result_dword_frac+frac32(%ebp)
294: cmpb $add_op,operation_type(%ebp)
295: jl give_valid_o_result
296: cmpb $div_op,operation_type(%ebp)
297: jg give_valid_o_result
298: movb $precision_mask,%dl // load precision field mask
299: andb %gs:sr_controls,%dl // mask in precision control
300: cmpb prec53,%dl
301: jg give_valid_o_result
302: je purge_11_bits
303: movl $0,result_dword_frac+frac64(%ebp)
304: movl $0x0ffffff00,result_dword_frac+frac32(%ebp)
305: jmp give_valid_o_result
306: ALIGN
307: purge_11_bits:
308: andl $0x0fffff800,result_dword_frac+frac64(%ebp)
309:
310: // mov esi, offset max_valid_pattern ; set result to max
311: // jmp set_constant_result ; valid number
312:
313: give_valid_o_result:
314: movb valid,result_tag(%ebp)
315: ret
316: //overflow_response endp
317: //$eject
318: // underflow_response:
319: //
320: // function:
321: // responds to a detected underflow
322: //
323: // inputs:
324: //
325: // outputs:
326: // sets underflow error indication(s) if appropiate
327: // correct masked or unmasked results in result
328: //
329: // data accessed:
330: // - offset_result result_sign
331: // - result_tag result_expon
332: // - result_word_frac
333: //
334: // data changed:
335: // - result
336: //
337: // procedures called:
338: // directed_round_test gradual_underflow
339: // round test_4w
340: // set_u_error u_masked?
341: // get_precision
342: //
343: ALIGN
344: underflow_response: //proc
345: testb underflow_mask, %gs:sr_masks //is underflow masked
346: jnz do_grad_underflow // yes, dont set flag
347: orb underflow_mask, %gs:sr_errors //no, set error flag
348: increase_exponent:
349: addl wrap_around_constant,dword_result_expon // add wrap-around
350: cmp $0, dword_result_expon //wrap_around constant
351: jg unmasked_ov_un_rounds // bad! shuld give qnan indef
352: subl wrap_around_constant, dword_result_expon // subtract
353: do_grad_underflow:
354: mov $offset_result,%edi // do gradual underflow
355: mov $0x0001,%eax // minimum expon is 0001
356: call gradual_underflow
357: call get_precision
358: movb true,%al
359: mov $offset_result,%edi // do second round
360: call round
361: cmpw $0, rnd_history
362: je prepare_zero_expon
363: orb underflow_mask + inexact_mask, %gs:sr_errors //set both errors
364: cmpb true, added_one // was rounding done by adding one
365: jne prepare_zero_expon //if not, branch for zero expon
366: orb $a_mask, %gs:sr_flags //else, set a_bit & if incrementing
367: testb $0x80, msb_result //The significand caused the most
368: jz prepare_zero_expon //significant bit of result_frac to
369: movb valid, result_tag(%ebp) // be set, tag result *valid* & return
370: ret
371: ALIGN
372: prepare_zero_expon:
373: xor %eax, %eax
374: clear_expon:
375: mov %eax,dword_result_expon // set exponent to zero
376: mov $result_dword_frac+4,%edi
377: call test_4w // if fraction nonzero,
378: movb denormd,result_tag(%ebp)
379: jnz accept_tag // tag as denormal
380: movb special,result_tag(%ebp) // else, tag as zero
381: accept_tag:
382: ret
383: //underflow_response endp
384: //$eject
385: // norm_denorm:
386: //
387: // function:
388: // normalizes an unpacked operand presumed to have been tagged
389: // *denormd*. includes case in which operand is so tagged because
390: // it was a single or double format denormal, which has already
391: // been normalized in the course of extending it to unpacked format.
392: // also includes case in which operand is a pseudo-denormal.
393: //
394: // inputs: edi points to the offset of the record to be normalized.
395: //
396: // outputs:
397: // 8 bytes beginning at (ebp + edi + frac64) are left shifted until
398: // the bit in position b63 is set.
399: // the 32 bit exponent field is 1 - shift_count
400: //
401: // data accessed:
402: // - dword ptr (ebp + edi + expon)
403: // - byte ptr (ebp + edi + msb)
404: // - dword ptr (ebp + edi + frac32), dword ptr (ebp + edi + frac64)
405: //
406: // data changed:
407: // - dword ptr (ebp + edi + expon)
408: // - byte ptr (ebp + edi + msb)
409: // - dword ptr (ebp + edi + frac32), dword ptr (ebp + edi + frac64)
410: //
411: // procedures called:
412: //
413: //
414: ALIGN
415: norm_denorm: //proc
416: cmp $0,expon(%ebp,%edi)
417: jne norm_denorm_done
418: movl $1,expon(%ebp,%edi)
419: testb $0x80,msb(%ebp,%edi)
420: jnz norm_denorm_done
421: norm_64_bits:
422: bsrl frac32(%ebp,%edi),%ecx
423: jz top_32_zero
424: mov frac64(%ebp,%edi),%eax
425: sub $31,%ecx
426: neg %ecx
427: shldl %cl,%eax,frac32(%ebp,%edi)
428: shll %cl,frac64(%ebp,%edi)
429: adjust_dword_expon:
430: sub %ecx,expon(%ebp,%edi) // adjust exponent
431: norm_denorm_done:
432: ret
433: ALIGN
434: top_32_zero:
435: mov frac64(%ebp,%edi),%eax
436: bsrl %eax,%ecx
437: sub $31,%ecx
438: neg %ecx
439: shll %cl,%eax
440: mov %eax,frac32(%ebp,%edi)
441: movl $0,frac64(%ebp,%edi)
442: add $32,%ecx
443: jmp adjust_dword_expon
444: //norm_denorm endp
445: //$eject
446: //
447: // arith:
448: //
449: // function:
450: // main procedure for implementation of 80387 add, subtract,
451: // multiply, and divide instructions
452: //
453: // inputs:
454: // assumes operation type, operand(s), and unpacked
455: // status variables are set up
456: //
457: // outputs
458: // result of operation in result
459: //
460: // data accessed:
461: // - operation_type offset_operand1
462: // - sign1 tag1
463: // - expon1 offset_operand2
464: // - sign2 tag2
465: // - expon2 offset_result
466: // - result_sign result_tag
467: // - result_expon result_word_frac
468: //
469: // data changed:
470: // - result
471: //
472: // procedures called:
473: // put_indefinite affine_infinity?
474: // put_max_valid move_op_to_result
475: // overflow_response underflow_response
476: // put_max_nan divid
477: // set_up_indefinite round
478: // addition_normalized put_result
479: // pop_free subadd
480: // mult test_4w
481: // i_masked? d_error?
482: // d_masked? i_error?
483: // get_precision set_i_masked?
484: // set_z_masked? set_d_masked?
485: //
486: //
487: ALIGN
488: arith: //proc
489: // assume %ds:a_msr
490: jz weed_out_special_cases // branch if no stack error
491: call set_stk_u_error // stack underflow occurred
492: testb invalid_mask,%gs:sr_masks
493: jz go_home // if unmasked, return
494: call put_indefinite // otherwise, result = indefinite
495: jmp finish_up
496: ALIGN
497: weed_out_special_cases:
498: andb $~a_mask, %gs:sr_flags //clear a_bit initially
499: movb tag1(%ebp),%al // both operands valid?
500: orb tag2(%ebp),%al
501: jnz special_cases // no, special case
502: handle_non_special_cases:
503: movzbl operation_type(%ebp),%ebx// call sub/add/mul/div
504: subb $add_op,%bl // to do the operation
505: shlw $2,%bx
506: call *%cs:arith_table(%ebx)
507: // the following three instructions are residue of warning mode arithmetic:
508: // call i_error? ; invalid if attempted
509: // jz no_invalid_error; division by denormal
510: // jmp invalid_error_detected
511: no_invalid_error:
512: mov $offset_result,%edi // round result
513: call get_precision // (indicate first, not
514: movb false,%al // second, round)
515: call round
516: mov $offset_result,%edi // re-normalize
517: // movb $4,%ah / (num words in frac=4)
518: call addition_normalize // (al contains overflow
519: mov dword_result_expon,%eax // indication from round)
520: cmp $0x7ffe,%eax // overflow iff
521: jg overflow_happened // expon > 7ffeh
522: cmp $0,%eax // check underflow if
523: jl underflow_happened // expon < 0
524: call give_valid_o_result // set tag to valid
525: and %eax,%eax // check underflow if
526: jnz report_rounds // expon = 0 and frac <> 0
527: mov $result_dword_frac+4,%edi //expon=0
528: call test_4w
529: jnz underflow_happened
530: movb special,result_tag(%ebp) // result is truly zero
531: report_rounds:
532: cmpb true, rnd1_inexact //detect inexact result
533: jne finish_up //if exact, branch
534: orb $inexact_mask, %gs:sr_errors //else, set p_error
535: cmpb true, added_one //was rounding done by adding one
536: jne finish_up //if not, branch
537: orb $a_mask, %gs:sr_flags // else, set a_bit
538: finish_up:
539: mov $offset_result,%edi
540: mov offset_result_rec,%esi
541: jmp put_arith_result
542: ALIGN
543: //
544: both_ops_denormd:
545: orb denorm_mask, %gs:sr_errors
546: testb denorm_mask, %gs:sr_masks
547: jz go_home
548: mov $offset_operand1,%edi
549: call norm_denorm
550: op2_denormd:
551: mov $offset_operand2,%edi
552: call norm_denorm
553: jmp handle_non_special_cases
554: ALIGN
555: only_op1_denormd:
556: orb denorm_mask, %gs:sr_errors
557: testb denorm_mask, %gs:sr_masks
558: jz go_home
559: mov $offset_operand1,%edi
560: call norm_denorm
561: jmp handle_non_special_cases
562: ALIGN
563: only_op2_denormd:
564: orb denorm_mask, %gs:sr_errors
565: testb denorm_mask, %gs:sr_masks
566: jz go_home
567: jmp op2_denormd
568: ALIGN
569: //
570: overflow_happened:
571: call overflow_response // here, overflow is certain.
572: jmp finish_up
573: ALIGN
574: go_home:
575: ret
576: underflow_happened:
577: call underflow_response
578: jmp finish_up
579: ALIGN
580: special_cases:
581: testb $0x10,%al // al contains (ebp).tag1 or (ebp).tag2
582: jz op1_nan_
583: orb invalid_mask, %gs:sr_errors
584: testb invalid_mask, %gs:sr_masks
585: jz go_home
586: mov $offset_operand1,%edi
587: call set_up_indefinite
588: mov offset_result_rec,%esi
589: jmp put_arith_result
590: ALIGN
591: op1_nan_: // here, neither op is unsupported.
592: cmpb inv,tag1(%ebp)
593: je op1_snan_
594: cmpb inv,tag2(%ebp)
595: jne non_nan_supp_ops
596: jmp signal_invalid_
597: ALIGN
598: op1_snan_:
599: testb $0x40,msb_frac1
600: jz invalid_operand
601: op2_also_nan_:
602: cmpb inv,tag2(%ebp)
603: jne set_up_nan_return
604: signal_invalid_:
605: testb $0x40,msb_frac2
606: jnz set_up_nan_return
607: invalid_operand:
608: orb invalid_mask, %gs:sr_errors
609: testb invalid_mask, %gs:sr_masks
610: jz go_home // i-error, if unmasked
611: set_up_nan_return:
612: mov offset_result_rec,%esi // result=max(nan1,nan2)
613: cmpb inv, tag1(%ebp)
614: je check_tag2
615: mov $offset_operand2, %edi
616: jmp install_hi_bits
617: ALIGN
618: check_tag2:
619: cmpb inv, tag2(%ebp)
620: je put_max_nan
621: mov $offset_operand1, %edi
622: jmp install_hi_bits
623: ALIGN
624: put_max_nan:
625: movb sign1(%ebp),%al // set result to larger
626: movb sign2(%ebp),%ah // magnitude result
627: push %eax // save signs
628: andb $0x7f,msb_frac1
629: andb $0x7f,msb_frac2
630: subtract_fracs:
631: movb positive,sign1(%ebp) // subtract the absolute
632: movb positive,sign2(%ebp) // values of the two ops
633: movb $sub_op,operation_type(%ebp)
634: push %esi
635: call subadd
636: pop %esi
637: pop %eax
638: movb %al,sign1(%ebp) // restore sign1 and give
639: mov $offset_operand1,%edi // operand1 as answer
640: cmpb positive,result_sign(%ebp) // if difference is +
641: je install_hi_bits
642: movb %ah,sign2(%ebp) // restore sign2 and give
643: mov $offset_operand2,%edi // operand2 as answer
644: install_hi_bits:
645: orb $0x0c0,msb(%ebp,%edi)
646: put_arith_result:
647: call put_result
648: jmp pop_free
649: ALIGN
650: non_nan_supp_ops:
651: movb tag2(%ebp),%bl
652: movb tag1(%ebp),%bh
653: testb $0x04,%bh
654: jz op2_denorm_
655: movb $3,%bh // indicate op1 is denorm
656: op2_denorm_:
657: testb $0x04,%bl
658: jz get_index
659: movb $3,%bl // indicate op2 is denorm
660: get_index:
661: and $0x0303,%ebx // form index to special operation table
662: // bx=4*(4*masked_tag1 + masked_tag2),
663: // where masked_tag = 0 for valid,
664: shlb $2,%bh // 1 for zero,
665: //2 for infinity
666: addb %bh,%bl // 3 for denormd
667: xorb %bh,%bh
668: shl $2,%ebx
669: mov $0x40fb,%eax // 64 byte/table -add_op
670: addb operation_type(%ebp),%al // al = normalized type
671: mulb %ah // (e)ax = operation offset
672: add %eax,%ebx // (e)bx = case offset
673: jmp *%cs:special_table(%ebx) // jump to special case
674: ALIGN
675: exit_arith:
676: ret
677: derror_with_first_operand:
678: orb denorm_mask, %gs:sr_errors
679: testb denorm_mask, %gs:sr_masks
680: jz exit_arith // if unmasked, return
681: first_operand:
682: mov $offset_operand1,%esi // give first operand as
683: jmp set_result_to_operand // result
684: ALIGN
685: derror_with_neg_second_operand:
686: orb denorm_mask, %gs:sr_errors
687: testb denorm_mask, %gs:sr_masks
688: jz exit_arith // if unmasked, return
689: neg_second_operand:
690: notb sign2(%ebp) // negate second operand
691: jmp second_operand // result
692: ALIGN
693: derror_with_second_operand:
694: orb denorm_mask, %gs:sr_errors
695: testb denorm_mask, %gs:sr_masks
696: jz exit_arith // if unmasked, return
697: second_operand:
698: mov $offset_operand2,%esi //give second operand
699: set_result_to_operand:
700: call move_op_to_result
701: jmp go_to_finish_up
702: ALIGN
703: //divide_into_zero: ; this section, for pseudo-zeroes, was
704: // xor ax,ax ; commented out when they became unsupp.
705: // mov edi,offset word_frac2 + 2 ; if frac2 = 0, invalid
706: // call test_4w ; else, zero and xor
707: // jz invalid_error_detected ; signs as the result
708: denormd_exor_signed_zero:
709: orb denorm_mask, %gs:sr_errors
710: testb denorm_mask, %gs:sr_masks
711: jz exit_arith // if unmasked, return
712: exor_signed_zero:
713: mov $zero_pattern,%esi
714: call set_constant_result
715: movb special,result_tag(%ebp)
716: jmp set_exor_sign
717: ALIGN
718: denormd_exor_signed_infinity:
719: orb denorm_mask, %gs:sr_errors
720: testb denorm_mask, %gs:sr_masks
721: jz exit_arith // if unmasked, return
722: jmp exor_signed_infinity
723: ALIGN
724: divide_by_zero:
725: orb zero_divide_mask, %gs:sr_errors
726: testb zero_divide_mask, %gs:sr_masks
727: jz exit_arith // if unmasked, return
728: exor_signed_infinity:
729: call put_infinity // else, give infinity
730: set_exor_sign:
731: movb positive,result_sign(%ebp) // set sign to exclusive
732: movb sign1(%ebp),%ah // or of operand signs
733: cmpb sign2(%ebp),%ah
734: je go_to_finish_up
735: notb result_sign(%ebp)
736: go_to_finish_up:
737: jmp finish_up
738: ALIGN
739: add_sub_infinities:
740: movb sign2(%ebp),%ah // add or sub magnitude?
741: cmpb $sub_op,operation_type(%ebp) // add mag if add_op and
742: jne add_or_sub_mag_ // signs same, else sub
743: notb %ah // comp sign2 if sub
744: add_or_sub_mag_:
745: cmpb sign1(%ebp),%ah
746: je first_operand // first op res if add_mag
747: invalid_error_detected:
748: orb invalid_mask, %gs:sr_errors
749: testb invalid_mask, %gs:sr_masks
750: jz exit_arith
751: call put_indefinite // if masked, indefinite
752: jmp finish_up // otherwise, just return
753: ALIGN
754: //
755: //arith endp
756: //
757: //a_med ends
758: //
759: // end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.