![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fp_subadd.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_subadd.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 "subadd.s"
26:
27: .ident "@(#)kern-fp:subadd.s 1.1"
28: //$tt(*80387 emulator + + + s u b a d d + + + *)
29: // ************************************************************************
30: //
31: // s u b a d d . 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 nor disclosed except in accordance with
39: // the terms of that agreement.
40: // ===============================================================
41: //
42: // function:
43: // performs floating point add, subtract, or compare
44: // of unpacked, non-zero, valid numbers.
45: //
46: // public procedures:
47: // addx subx subadd
48: // sp_subadd compar mov_neg_frac
49: //
50: // **************************************************************************
51: //
52: //...March 3, 1987...
53: //
54: //$nolist
55: #include "fp_e80387.h"
56: //$list
57: //...declare status register segment...
58: //
59: .data //a_msr segment rw public
60: // extrn %gs:sr_masks,%gs:sr_flags,%gs:sr_errors
61: //a_msr ends
62: //
63: // assume %ds:a_msr
64: .text //a_med segment er public
65: //
66: // extrn sticky_right_shift,right_shift,test_6w
67: // extrn addition_normalize,subtraction_normalize
68: // extrn pop_free,clear_6w,get_rnd_control
69: // extrn set_i_error,affine_infinity_,set_s_bit
70: // extrn clear_s_bit,set_z_bit,clear_z_bit
71: // extrn i_error_,set_d_error,set_stk_u_error
72: //
73: .globl addx
74: .globl subx
75: .globl subadd
76: .globl sp_subadd
77: .globl compar
78: //
79: // ***********************************************************************
80: // addx:
81: // *****
82: // function:
83: // fractional add. result_frac <-- frac1 + frac2.
84: //
85: // inputs:
86: // assumes operand records are set up.
87: //
88: // outputs:
89: // al = 1 if there was a carry-out; al=0 otherwise.
90: //
91: // data accessed:
92: // - word_frac1 word_frac2
93: // - result_word_frac
94: //
95: // data changed:
96: // result_word_frac
97: //
98: // ***********************************************************************
99: ALIGN
100: addx: //proc
101:
102: mov dword_frac1(%ebp),%eax //do fractional add
103: xorw %ax,%ax //clear extra word
104: add dword_frac2(%ebp),%eax
105: mov %eax,result_dword_frac(%ebp)
106: mov dword_frac1+4(%ebp),%eax
107: adc dword_frac2+4(%ebp),%eax
108: mov %eax,result_dword_frac+4(%ebp)
109: mov dword_frac1+8(%ebp),%eax
110: adc dword_frac2+8(%ebp),%eax
111: mov %eax,result_dword_frac+8(%ebp)
112:
113: movb $0,%al
114: rclb $1,%al //put carry into al
115: ret
116: //addx endp
117: //
118: // ****************************************************************************
119: // subx:
120: // ****
121: // function:
122: // 2s complement fractional subtract.
123: // result_frac <-- frac1 - frac2.
124: //
125: // inputs:
126: // assumes operand variables are set up.
127: //
128: // outputs:
129: // al=1 if borrow; al=0 otherwise.
130: //
131: // data accessed:
132: // - word_frac1 word_frac2
133: // - result_word_frac
134: //
135: // data changed:
136: // - result_word_frac
137: //
138: // ***************************************************************************
139: ALIGN
140: subx: //proc
141:
142: mov dword_frac1(%ebp),%eax // fractional subtract
143: andl $0x0ffff0000,dword_frac2(%ebp) // clear low word
144: sub dword_frac2(%ebp),%eax
145: mov %eax,result_dword_frac(%ebp)
146: mov dword_frac1+4(%ebp),%eax
147: sbb dword_frac2+4(%ebp),%eax
148: mov %eax,result_dword_frac+4(%ebp)
149: mov dword_frac1+8(%ebp),%eax
150: sbb dword_frac2+8(%ebp),%eax
151: mov %eax,result_dword_frac+8(%ebp)
152: movb $0,%al //set al to borrow
153: rclb $1,%al
154: ret
155: //subx endp
156: //
157: // ***************************************************************************
158: // subadd:
159: // *******
160: // function:
161: // floating point add or subtract.calculates unpacked result.
162: // sp_subadd is the entry point for log functions.
163: //
164: // inputs:
165: // assumes operands are unpacked, valid, non-zero.
166: //
167: // outputs:
168: //
169: // data accessed:
170: // - operation_type sign1
171: // - expon1 msb_frac
172: // - offset_operand1 sign2
173: // - expon2 msb_frac2
174: // - offset_operand2 offset_result
175: // - result_sign result_expon
176: // - result_word_frac
177: //
178: // data changed:
179: // - result_sign result_expon
180: // - result_word_frac
181: //
182: // procedures called:
183: // sticky_right_shift right_shift
184: // addition_normlized subtraction_normalize
185: // addx subx
186: // test_6w get_rnd_control
187: //
188: // ************************************************************************
189: ALIGN
190: subadd: //proc
191: mov $sticky_right_shift,%esi // load shift proc ptr
192: jmp form_expon_difference // merge with sp_subadd
193: ALIGN
194: sp_subadd:
195: mov $sp_right_shift,%esi // load shift proc ptr
196: form_expon_difference:
197: mov dword_expon1,%ecx
198: sub dword_expon2,%ecx
199: js expon2_larger
200: cmp $67,%ecx //set cl to shift amount =
201: jbe adjust_frac2 //min(67,expon1-expon2)
202: mov $67,%ecx
203: adjust_frac2:
204: movb $0x00,%al //al = bit to inject from left
205: mov $offset_operand2,%edi
206: push %esi
207: call *%esi //shift op2 fraction
208: pop %esi
209: mov expon1(%ebp),%eax //set result expon to expon1
210: mov %eax,result_expon(%ebp)
211: cmpb special, tag1(%ebp)
212: je determine_operation_true
213: testb $0x80,msb_frac1
214: jnz determine_operation_true // branch if frac1 is normal
215: jmp frac2_normal_ // test frac2
216: ALIGN
217: expon2_larger:
218: neg %ecx //set cl to shift amount
219: cmp $67,%ecx
220: jbe adjust_frac1
221: mov $67,%ecx
222: adjust_frac1:
223: push %ecx //save shift amount
224: movb $0x00,%al //al = bit to inject
225: mov $offset_operand1,%edi
226: call *%esi
227: mov expon2(%ebp),%eax //set result expon to expon2
228: mov %eax,result_expon(%ebp)
229: pop %ecx
230: frac2_normal_:
231: cmpb special, tag2(%ebp)
232: je determine_operation_true
233: movb false,%al
234: testb $0x80,msb_frac2 // set al to true if frac2 is
235: jz determine_operation // normalized
236: determine_operation_true:
237: movb true,%al
238: determine_operation:
239: cmpb $sub_op,operation_type(%ebp) //if op=sub_op, negate op2
240: jne add_or_sub_
241: notb sign2(%ebp)
242: add_or_sub_:
243: movb sign1(%ebp),%ah
244: cmpb sign2(%ebp),%ah
245: jne do_subtraction
246: call addx //do fractional add
247: mov $offset_result,%edi
248: call addition_normalize //normalize result after add
249: movb sign1(%ebp),%al
250: movb %al,result_sign(%ebp) //set result sign to sign1
251: testb $0x80, msb_result
252: jnz add_done
253: mov $offset_result, %edi
254: call test_6w
255: jnz norm_result
256: add_done:
257: ret
258: ALIGN
259: do_subtraction:
260: push %eax //save normalization indicator
261: movb sign1(%ebp),%al //initially, set sign to sign1
262: movb %al,result_sign(%ebp)
263: call subx //do fractional subtract
264: mov $offset_result,%edi
265: cmpb $0,%al
266: mov $0,%eax
267: je detect_zero
268:
269: notl (%ebp,%edi) //form 2s comp of result_frac
270: add $1,(%ebp,%edi)
271: notl 4(%ebp,%edi)
272: adc %eax,4(%ebp,%edi)
273: notl 8(%ebp,%edi)
274: adc %eax,8(%ebp,%edi)
275: notb result_sign(%ebp) //and complement result_sign
276: detect_zero:
277: call test_6w //find true zero result
278: jnz do_norm_ // if not zero, test for denorm
279: call get_rnd_control // sign is + unless rnd down
280: xorb rnd_down,%al
281: decw %ax
282: cbtw
283: movb %ah,result_sign(%ebp)
284: pop %eax //if al=true, then result should
285: cmpb true,%al // be true zero
286: jne subtract_done
287: movw $0,result_expon(%ebp)
288: ret
289: ALIGN
290: do_norm_:
291: pop %eax //if al=false, dont normalize
292: cmpb true,%al // the result
293: jne subtract_done
294: norm_result:
295: mov $offset_result,%edi
296: call subtraction_normalize //normalize the result
297: subtract_done:
298: ret
299: ALIGN
300: sp_right_shift:
301: call right_shift
302: mov (%ebp,%edi),%eax // ss:ebp+edi -> dword_frac after call
303: and $0x1fffffff,%eax // mask dword fraction
304: or %eax,%edx // or it to the right_shift output
305: jz sp_nonsticky // if zero, it must be nonsticky
306: orl $0x20000000,(%ebp,%edi) // if nonzero, set bit of dword_frac
307: sp_nonsticky:
308: andl $0x0e0000000,(%ebp,%edi) // now mask off most of dword_frac
309: ret
310: //subadd endp
311: //
312: // ***********************************************************************
313: // compar:
314: // *******
315: //
316: // function:
317: // main procedure for compare and test instructions.
318: //
319: // inputs:
320: // op1 and op2 operand records.
321: //
322: // outputs:
323: // sets zero and sign status bits to indicate the result
324: // of the compare. sets the invalid and denorm error bits
325: // if these errors are detected.
326: //
327: // data accessed:
328: // - operation_type tag1
329: // - expon1 tag2
330: // - expon2 result_sign
331: // - result_word_frac
332: //
333: // data changed:
334: //
335: // procedures called:
336: // pop_free subadd
337: // test_6w clear_6w
338: // set_s_bit clear_s_bit
339: // set_z_bit clear_z_bit
340: //
341: // ***************************************************************************
342: ALIGN
343: compar: //proc
344: jz no_stack_error // branch if no stack error
345: andb $~a_mask,%gs:sr_flags // clear a-bit
346: orb invalid_mask+zero_mask,%gs:sr_errors// clears zf, to 0
347: jmp invalid_error_signal
348: ALIGN
349: no_stack_error:
350: movl $0,before_error_signals(%ebp)
351: andb $~(a_mask+c_mask),%gs:sr_flags
352: cmpb $test_op,operation_type(%ebp) // if not test_op, then
353: jne set_up_check // its compar_op or ucom_op
354: movb positive,sign2(%ebp) // for test_op, set operand2
355: movb special,tag2(%ebp) // to zero
356: mov $dword_frac2,%edi
357: call clear_6w // returns with eax = 0
358: mov %eax,dword_expon2
359: set_up_check:
360: movb tag1(%ebp),%al // both operands valid?
361: orb tag2(%ebp),%al
362: jz ordered_cases // yes, ops are ordered.
363: cmpb special,%al // one op is zero, and the
364: je ordered_cases // other is zero or valid.
365: testb $0x10,%al // is either op unsupported?
366: jnz invalid_error_detected
367: op1_nan_:
368: movb tag1(%ebp),%al // al = value of tag1
369: movb tag2(%ebp),%ah // ah = value of tag2
370: cmpb inv,%al
371: je op1_snan_
372: cmpb inv,%ah
373: jne non_nan_supp_ops
374: jmp signal_invalid_
375: ALIGN
376: op1_snan_:
377: testb $0x40,msb_frac1
378: jz invalid_error_detected
379: op2_also_nan_:
380: cmpb inv,%ah
381: jne set_up_nan_return
382: signal_invalid_:
383: testb $0x40,msb_frac2
384: jz invalid_error_detected
385: set_up_nan_return:
386: cmpb $ucom_op,operation_type(%ebp) // if ucom_op, then
387: je set_uncertain // no invalid signal.
388: jmp invalid_error_detected
389: ALIGN
390: non_nan_supp_ops:
391: cmpb denormd,tag1(%ebp)
392: jne op2_denormd_
393: movb true,signal_d_error_
394: cmp $0,expon1(%ebp)
395: jne op2_denormd_
396: movl $1,expon1(%ebp)
397: op2_denormd_:
398: cmpb denormd,tag2(%ebp)
399: jne ordered_cases
400: movb true,signal_d_error_
401: cmp $0,expon2(%ebp)
402: jne ordered_cases
403: movl $1,expon2(%ebp)
404: ordered_cases:
405: movb $sub_op,operation_type(%ebp) // subtract op2 from op1
406: call subadd
407: mov $offset_result,%edi // detect a zero fraction
408: call test_6w // in result
409: jz operands_equal
410: andb $~(zero_mask+sign_mask),%gs:sr_flags // set zero to false
411: testb $0x01,result_sign(%ebp) // set sign to result
412: jz finish_up
413: orb $sign_mask,%gs:sr_flags
414: finish_up:
415: cmp $0,before_error_signals(%ebp)
416: jne check_i_error
417: jmp pop_free
418: ALIGN
419: check_i_error:
420: cmpb false,signal_i_error_ // recall that false = 00h
421: je set_denorm_error
422: test_invalid_mask:
423: testb invalid_mask,%gs:sr_masks
424: jz unmasked_exit
425: jmp pop_free
426: ALIGN
427: unmasked_exit:
428: ret
429: ALIGN
430: check_d_error:
431: cmpb false,signal_d_error_ // recall that false = 00h
432: jne set_denorm_error
433: jmp pop_free
434: ALIGN
435: set_denorm_error:
436: orb denorm_mask,%gs:sr_errors
437: test_denorm_mask:
438: testb denorm_mask,%gs:sr_masks
439: jz unmasked_exit
440: jmp pop_free
441: ALIGN
442:
443: invalid_error_detected:
444: orb invalid_mask,%gs:sr_errors
445: invalid_error_signal:
446: movl $0x000000ff,before_error_signals(%ebp)
447: jmp set_uncertain
448: ALIGN
449:
450: also_d_error_:
451: cmpb denormd,tag1(%ebp)
452: je d_error_also
453: cmpb denormd,tag2(%ebp)
454: jne set_uncertain
455: d_error_also:
456: movb true, signal_d_error_
457: set_uncertain:
458: orb $(sign_mask + c_mask), %gs:sr_flags
459: jmp zero_true // set zero to true
460: ALIGN
461: operands_equal:
462: andb $~sign_mask,%gs:sr_flags // set sign positive
463: zero_true:
464: orb $zero_mask,%gs:sr_flags
465: jmp finish_up
466: //compar endp
467: //
468: //a_med ends
469: //
470: // end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.