![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fp_remsc.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_remsc.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 "remsc.s" ! 26: ! 27: .ident "@(#)kern-fp:remsc.s 1.1" ! 28: ! 29: // ******************************************************************** ! 30: // ! 31: // r e m s c . 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: // functions: ! 43: // implements 80387 fprem instruction. ! 44: // implements 80387 fprem1 instruction. ! 45: // implements 80387 fscale instruction. ! 46: // ! 47: // public procedures: ! 48: // remr scale ! 49: // add_to_frac add_to_frac_2 ! 50: // ! 51: // internal procedures: ! 52: // remrx ! 53: // ! 54: // ************************************************************************ ! 55: // ! 56: //...March 3, 1987... ! 57: // ! 58: // ! 59: //$nolist ! 60: #include "fp_e80387.h" ! 61: //$list ! 62: .data //a_msr segment rw public ! 63: // extrn %gs:sr_masks,%gs:sr_flags,%gs:sr_errors,%gs:sr_controls ! 64: //a_msr ends ! 65: // ! 66: // assume %ds:a_msr ! 67: // ! 68: .text //a_med segment er public ! 69: // ! 70: // extrn put_result,set_up_indefinite,test_4w ! 71: // extrn subtraction_normalize,move_op_to_result ! 72: // extrn underflow_response,right_shift_frac1_cl ! 73: // extrn right_shift_frac2_cl,left_shift_frac1_1 ! 74: // extrn fix32,overflow_response,set_stk_u_error ! 75: // extrn subadd,put_arith_result,set_up_nan_return ! 76: // extrn test_6w,clear_6w,norm_denorm ! 77: // extrn left_shift_frac2_cl ! 78: .globl remr ! 79: .globl add_to_frac ! 80: .globl add_to_frac_2 ! 81: .globl scale ! 82: .globl remrx ! 83: // ! 84: // *************************************************************************** ! 85: // remrx: ! 86: // ****** ! 87: // function: ! 88: // fractional remainder. ! 89: // ! 90: // inputs: ! 91: // assumes dividend is in op1, divisor is in op2, ! 92: // number of quotient bits to generate is in ax, ! 93: // and q is cleared to all zeroes. ! 94: // ! 95: // outputs: ! 96: // it returns the fractional remainder in op1, and ! 97: // the low bits of the quotient in q. ! 98: // ! 99: // data accessed: ! 100: // - offset_operand1 offset_operand2 ! 101: // - offset_result ! 102: // ! 103: // data changed: ! 104: // - frac1 frac2 ! 105: // ! 106: // procedures called: ! 107: // right_shift_frac1_cl right_shift_frac2_cl ! 108: // left_shift_frac1_1 add_to_frac ! 109: // ! 110: // ************************************************************************ ! 111: ALIGN ! 112: remrx: //proc ! 113: push %eax // save the loop count ! 114: movb $1,%cl // shift frac1 right 1 bit ! 115: call right_shift_frac1_cl ! 116: movb $1,%cl // shift frac2 right 1 bit ! 117: call right_shift_frac2_cl // returns cf clear, ch = 0 ! 118: mov $offset_operand2,%esi // result_frac <-- - frac2 ! 119: mov $offset_result,%edi ! 120: movw $0,(%ebp,%esi) // clear extra bytes ! 121: mov $0x03,%ecx // load loop count ! 122: FALLSTHRU ! 123: complement_frac2: ! 124: mov $0x0000,%eax // clear ax, leave cf intact ! 125: sbb (%ebp,%esi),%eax // 0 - frac2 ! 126: mov %eax,(%ebp,%edi) // store into result frac ! 127: inc %esi // bump offsets ! 128: inc %esi // (doesnt affect cf) ! 129: inc %esi ! 130: inc %esi ! 131: inc %edi ! 132: inc %edi ! 133: inc %edi ! 134: inc %edi ! 135: LOOP(complement_frac2) // loop until result = -frac2 ! 136: jmp enter_loop ! 137: ALIGN ! 138: form_next_frac1: ! 139: push %ecx // stack loop count ! 140: call left_shift_frac1_1 // shift frac1 left one bit ! 141: mov $offset_operand2,%esi ! 142: testb $0x01,q // if lsb of q = 1 then ! 143: jz do_add // frac1 <-- frac1 + frac2 ! 144: enter_loop: ! 145: mov $offset_result,%esi // else, frac1 <-- frac1 - frac2 ! 146: do_add: ! 147: mov $offset_operand1,%edi ! 148: call add_to_frac // move carry-out from add ! 149: rclb $1,q // shift carry-out into q ! 150: // adc hi_q, 0 ; hi_q counts non-0 quotient bits ! 151: pop %ecx // above bit b7 of the quotient. ! 152: LOOP(form_next_frac1) // if looping done, ! 153: testb $0x01,q // then one last iteration ! 154: jnz last_shift // frac1 <-- frac1 + frac2 ! 155: mov $offset_operand2,%esi ! 156: mov $offset_operand1,%edi ! 157: call add_to_frac ! 158: last_shift: ! 159: jmp left_shift_frac1_1 // shift frac1 left 1 bit ! 160: //remrx endp ! 161: // ! 162: // ************************************************************************** ! 163: // add_to_frac: ! 164: // *********** ! 165: // function: ! 166: // adds a 10-byte fraction to another 10-byte fraction. ! 167: // ! 168: // inputs: ! 169: // ss:ebp+esi points to the source fraction, and ss:ebp+edi points ! 170: // to the destination fraction. ! 171: // ! 172: // outputs: ! 173: // carry flag set if there was a carry out, else reset. ! 174: // ! 175: // data accessed: ! 176: // ! 177: // data changed: ! 178: // ! 179: // *************************************************************************** ! 180: ALIGN ! 181: add_to_frac: //proc ! 182: mov (%ebp,%esi),%eax ! 183: xorw %ax,%ax ! 184: add_to_frac_2: ! 185: add %eax,(%ebp,%edi) ! 186: mov frac64(%ebp,%esi),%eax ! 187: adc %eax,frac64(%ebp,%edi) ! 188: mov frac32(%ebp,%esi),%eax ! 189: adc %eax,frac32(%ebp,%edi) ! 190: simple_return: ! 191: ret ! 192: ALIGN ! 193: //add_to_frac endp ! 194: // ************************************************************************* ! 195: ALIGN ! 196: mov_esi_edi: //proc ! 197: add %ebp, %edi //add global record offsets ! 198: add %ebp, %esi ! 199: // push %ds //save a_msr ?? ! 200: // push %ss //load source segment register ! 201: // pop %ds ! 202: // push %ss //load destination segment register ! 203: // pop %es //into es ! 204: ! 205: /* FAST_MOVSL */ ! 206: movl %ss:0(%esi),%ecx ! 207: movl %ecx,%ss:0(%esi) ! 208: movl %ss:4(%esi),%ecx ! 209: movl %ecx,%ss:4(%esi) ! 210: movl %ss:8(%esi),%ecx ! 211: movl %ecx,%ss:8(%esi) ! 212: // addl $12,%esi ! 213: // addl $12,%edi ! 214: // movl $0,%ecx ! 215: ! 216: // pop %ds //reload a_msr ! 217: ret ! 218: //mov_esi_edi endp ! 219: // ************************************************************************* ! 220: ! 221: ! 222: // ! 223: // *************************************************************************** ! 224: // remr: ! 225: // ***** ! 226: // function: ! 227: // 80387 remainder instruction ! 228: // ! 229: // inputs: ! 230: // assumes the operand records are set up. ! 231: // ! 232: // outputs: ! 233: // results in result record. ! 234: // ! 235: // data accessed: ! 236: // - result_rec_offset offset_operand1 ! 237: // - tag1 expon1 ! 238: // - word_frac1 tag2 ! 239: // - expon2 msb_frac2 ! 240: // - offset_result ! 241: // ! 242: // data changed: ! 243: // - tag1 expon1 ! 244: // ! 245: // procedures called: ! 246: // set_up_indefinite set_stk_u_error ! 247: // remrx subtraction_normalize ! 248: // move_op_to_result underflow_response ! 249: // put_result test_4w ! 250: // subadd mov_esi_edi ! 251: // ! 252: // *************************************************************************** ! 253: ALIGN ! 254: remr: //proc ! 255: lahf // save stack empty flag (86 z-flag) ! 256: andb $~(a_mask+c_mask),%gs:sr_flags// clear 87 a-flag, and also ! 257: // c-flag for 387 compatibility ! 258: movw $0,exp_tmp // initialize q and hi_q to 0. ! 259: sahf // restore stack empty flag (86 z-flag) ! 260: jz catch_special_cases // branch if no stack error ! 261: call set_stk_u_error // stack underflow occurred ! 262: jmp unmasked_i_error_ ! 263: ALIGN ! 264: catch_special_cases: ! 265: movb tag1(%ebp),%al // both operands valid? ! 266: orb tag2(%ebp),%al ! 267: jnz special_cases_handler // no, branch to handler of special cases ! 268: valid_case: ! 269: mov dword_expon1,%eax // eax <- expon_diff = exp1 - exp2 ! 270: sub dword_expon2,%eax // if expon_diff < zero, ! 271: mov $offset_operand1,%edi // then op1 is the modulus ! 272: jl rem_or_mod_ ! 273: cmp $63,%eax // if expon_diff > 63, ! 274: jle calc_exponent // then set c-bit for incomplete ! 275: orb $c_mask,%gs:sr_flags // reduction and replace expon_diff ! 276: or $32,%eax // by ((expon_diff or 32) mod 64) ! 277: and $63,%eax ! 278: calc_exponent: ! 279: sub %eax,dword_expon1 // expon1 <- remainder exponent ! 280: inc %eax // num_quotient_bits = expon_diff + 1 ! 281: call remrx // calculate remainder fraction ! 282: xor %eax,%eax // detect zero result ! 283: mov $dword_frac1+frac64,%edi ! 284: call test_4w ! 285: jnz do_normalize ! 286: testb $c_mask,%gs:sr_flags // was reduction complete? ! 287: jz remr_zero // if so, process q as well ! 288: movb %al,q // else, make q 0 (value of al) ! 289: jmp remr_zero ! 290: ALIGN ! 291: do_normalize: ! 292: mov $offset_operand1,%edi ! 293: call subtraction_normalize ! 294: // mov (ebp).tag1, valid ; unneeded if denormals retagged ! 295: reduction_incomplete_: ! 296: testb $c_mask,%gs:sr_flags ! 297: jz rem_or_mod_ // rem or mod matters only if complete ! 298: movb $0,q // if incomplete, make q 0. ! 299: jmp check_rem_underflow // branch to check unmasked underflow ! 300: ALIGN ! 301: rem_or_mod_: ! 302: lahf //save zf to indicate whether ! 303: //op2 needs restoration ! 304: cmpb $rem1_op,operation_type(%ebp) ! 305: jne check_rem_underflow ! 306: sahf ! 307: jnz op2_restored ! 308: movb $1, %cl ! 309: call left_shift_frac2_cl ! 310: op2_restored: ! 311: ! 312: decl dword_expon2 ! 313: push sign1(%ebp) ! 314: movb positive,sign2(%ebp) ! 315: movb positive,sign1(%ebp) ! 316: movb $sub_op,operation_type(%ebp) ! 317: mov dword_expon1, %eax ! 318: cmp dword_expon2, %eax ! 319: mov $offset_operand1, %esi ! 320: jle save_shiftable_op ! 321: mov $offset_operand2, %esi ! 322: save_shiftable_op: ! 323: mov $offset_cop, %edi ! 324: call mov_esi_edi ! 325: call subadd ! 326: mov $offset_result,%edi ! 327: call test_6w ! 328: pop sign1(%ebp) ! 329: mov $offset_operand1, %edi ! 330: jnz check_sign ! 331: tiebreaker: ! 332: testb $1,q ! 333: jz check_rem_underflow ! 334: incb q ! 335: notb sign1(%ebp) ! 336: jmp check_rem_underflow ! 337: ALIGN ! 338: check_sign: ! 339: mov $offset_cop, %esi ! 340: cmpb positive,result_sign(%ebp) ! 341: je restore_op2_ ! 342: call mov_esi_edi ! 343: mov $offset_operand1, %edi ! 344: jmp check_rem_underflow ! 345: ALIGN ! 346: restore_op2_: ! 347: mov dword_expon1, %eax ! 348: cmp dword_expon2, %eax ! 349: je reduce_modulus ! 350: mov $offset_operand2, %edi ! 351: call mov_esi_edi ! 352: reduce_modulus: ! 353: incb q ! 354: incl dword_expon2 ! 355: movb sign1(%ebp),%al ! 356: movb %al,sign2(%ebp) ! 357: call subadd ! 358: mov $offset_result,%edi ! 359: check_rem_underflow: ! 360: cmp $0x0001,expon(%ebp,%edi) // if expon1 < 1, then underflow ! 361: jge do_put_result ! 362: mov %edi,%esi // give std underflow response ! 363: call move_op_to_result ! 364: push %gs:sr_masks ! 365: orb prec64,%gs:sr_controls // *or* works only because prec64 ! 366: movb false,rnd1_inexact // sets all bits in the pc field ! 367: call underflow_response ! 368: pop %gs:sr_masks ! 369: move_result_to_result: ! 370: mov $offset_result,%edi ! 371: jmp do_put_result ! 372: ALIGN ! 373: remr_zero: ! 374: mov %eax,dword_expon1 // if remainder fraction = 0, ! 375: movb special,tag1(%ebp) // then set result to 0 ! 376: cmpb $rem1_op,operation_type(%ebp) ! 377: jne put_op1 ! 378: movb positive,sign1(%ebp) ! 379: testb rnd_down,%gs:sr_controls ! 380: jz put_op1 ! 381: testb rnd_up,%gs:sr_controls ! 382: jnz put_op1 ! 383: movb negative,sign1(%ebp) ! 384: put_op1: ! 385: mov $offset_operand1,%edi ! 386: do_put_result: ! 387: mov offset_result_rec,%esi ! 388: call put_result ! 389: andb $~(zero_mask+a_mask+sign_mask),%gs:sr_flags ! 390: movb q,%al ! 391: shlb $6,%al // move 3 low bits of q to ! 392: jnc fix_z_bit // s, z, and a bits ! 393: orb $sign_mask,%gs:sr_flags ! 394: fix_z_bit: ! 395: shlb $1,%al ! 396: jnc fix_a_bit ! 397: orb $zero_mask,%gs:sr_flags ! 398: fix_a_bit: ! 399: shlb $1,%al ! 400: jnc remr_done ! 401: orb $a_mask,%gs:sr_flags ! 402: remr_done: ! 403: ret ! 404: ALIGN ! 405: special_cases_handler: ! 406: testb $0x10,%al // al contains (ebp).tag1 or (ebp).tag2 ! 407: jz op1_nan_ // no branch if at least one op unsupported ! 408: invalid_operand: ! 409: orb invalid_mask,%gs:sr_errors ! 410: unmasked_i_error_: ! 411: testb invalid_mask,%gs:sr_masks// if unmasked, just exit ! 412: jz remr_done // (c-bit remains clear here, ! 413: // to indicate complete reduction.) ! 414: // else, return indefinite ! 415: remr_indef: ! 416: mov $offset_operand1,%edi ! 417: call set_up_indefinite ! 418: load_esi_for_result: ! 419: mov offset_result_rec,%esi ! 420: jmp put_arith_result ! 421: ALIGN ! 422: op1_nan_: // here, neither op is unsupported. ! 423: movb tag2(%ebp),%al ! 424: movb tag1(%ebp),%ah ! 425: cmpb inv,%ah ! 426: je op1_snan_ ! 427: cmpb inv,%al ! 428: jne non_nan_supp_ops ! 429: jmp signal_invalid_ ! 430: ALIGN ! 431: op1_snan_: ! 432: testb $0x40,msb_frac1 ! 433: jz signal_for_snan ! 434: op2_also_nan_: ! 435: cmpb inv,%al ! 436: jne jmp_set_up_nan_return ! 437: signal_invalid_: ! 438: testb $0x40,msb_frac2 ! 439: jnz jmp_set_up_nan_return ! 440: signal_for_snan: ! 441: orb invalid_mask,%gs:sr_errors// set i-error for signaling nan operand ! 442: testb invalid_mask,%gs:sr_masks// if unmasked, return forthwith ! 443: jz remr_done // else, masked, so return max nan. ! 444: jmp_set_up_nan_return: ! 445: jmp set_up_nan_return ! 446: ALIGN ! 447: non_nan_supp_ops: ! 448: cmpb $scale_op,operation_type(%ebp) ! 449: je scale_non_nan_supp_ops ! 450: rem_non_nan_supp_ops: ! 451: cmpb infinty,%ah ! 452: je invalid_operand ! 453: cmpb special,%al ! 454: je invalid_operand ! 455: cmpb denormd,%ah ! 456: jne op2_denorm_ ! 457: orb denorm_mask,%gs:sr_errors ! 458: testb denorm_mask,%gs:sr_masks ! 459: jz remr_done ! 460: mov $offset_operand1,%edi ! 461: cmpb infinty,%al ! 462: jne norm_op1 ! 463: testb $0x80,msb_frac1 ! 464: jz op1_true_denormal ! 465: movl $1,dword_expon1 ! 466: movb valid,tag1(%ebp) ! 467: jmp load_esi_for_result ! 468: ALIGN ! 469: op1_true_denormal: ! 470: testb underflow_mask,%gs:sr_masks ! 471: jnz load_esi_for_result ! 472: call norm_denorm ! 473: addl wrap_around_constant,dword_expon1// add wrap-around ! 474: orb underflow_mask,%gs:sr_errors ! 475: jmp load_esi_for_result ! 476: ALIGN ! 477: norm_op1: ! 478: push %eax ! 479: call norm_denorm ! 480: pop %eax ! 481: op2_denorm_: ! 482: cmpb denormd,%al ! 483: jne non_error_specials ! 484: orb denorm_mask,%gs:sr_errors ! 485: testb denorm_mask,%gs:sr_masks ! 486: jz remr_done ! 487: mov $offset_operand2,%edi ! 488: push %eax ! 489: call norm_denorm ! 490: pop %eax ! 491: non_error_specials: ! 492: cmpb special,%ah ! 493: je put_op1 ! 494: op2_inf_: ! 495: cmpb infinty,%al ! 496: je put_op1 ! 497: jmp valid_case ! 498: ALIGN ! 499: // ! 500: scale_non_nan_supp_ops: ! 501: cmpb infinty,%ah ! 502: jne scaler_denormd_ ! 503: cmpb positive,sign1(%ebp) ! 504: jne op2_also_inf_ ! 505: cmpb special,%al ! 506: je invalid_operand ! 507: cmpb denormd,%al ! 508: jne xfer_sign ! 509: orb denorm_mask,%gs:sr_errors ! 510: testb denorm_mask,%gs:sr_masks ! 511: jz exit_scale ! 512: xfer_sign: ! 513: movb sign2(%ebp),%al ! 514: movb %al,sign1(%ebp) ! 515: mov $offset_operand1,%edi ! 516: jmp put_scaled_result ! 517: ALIGN ! 518: op2_also_inf_: ! 519: cmpb infinty,%al ! 520: je invalid_operand ! 521: cmpb denormd,%al ! 522: jne zero_op2 ! 523: orb denorm_mask,%gs:sr_errors ! 524: testb denorm_mask,%gs:sr_masks ! 525: jz exit_scale ! 526: zero_op2: ! 527: mov $offset_operand2,%edi ! 528: call clear_6w ! 529: mov %eax,dword_expon2 // clear eax ! 530: movb special,tag2(%ebp) ! 531: jmp put_scaled_result ! 532: ALIGN ! 533: scaler_denormd_: ! 534: cmpb denormd,%ah ! 535: jne scalend_denormd_ ! 536: orb denorm_mask,%gs:sr_errors ! 537: testb denorm_mask,%gs:sr_masks ! 538: jnz scalend_denormd_ ! 539: exit_scale: ! 540: ret ! 541: ALIGN ! 542: scalend_denormd_: ! 543: cmpb denormd,%al ! 544: jne give_op2 ! 545: orb denorm_mask, %gs:sr_errors ! 546: testb denorm_mask, %gs:sr_masks ! 547: jz exit_scale ! 548: cmpb valid,%ah ! 549: jne check_unfl_mask ! 550: mov $offset_operand2,%edi ! 551: call norm_denorm ! 552: jmp valid_scale_case ! 553: ALIGN ! 554: check_unfl_mask: ! 555: testb underflow_mask,%gs:sr_masks ! 556: jnz give_op2 ! 557: jmp scale_underflow ! 558: ! 559: //remr endp ! 560: // ! 561: // ! 562: // ********************************************************************** ! 563: // scale: ! 564: // ****** ! 565: // function: ! 566: // emulates the 80387 scale instruction. ! 567: // ! 568: // inputs: ! 569: // scale term (scaler) from st(1) in operand1, and ! 570: // scalend (*to be scaled*) from st(0) in operand2 ! 571: // ! 572: // outputs: ! 573: // scaled operand in operand2 record or result_record. ! 574: // error indicators set. ! 575: // ! 576: // data accessed: ! 577: // - result_rec_offset tag1 ! 578: // - word_frac1 offset_operand2 ! 579: // - tag2 expon2 ! 580: // - offset_result extra_word_reg ! 581: // ! 582: // data changed: ! 583: // - expon2 ! 584: // ! 585: // procedures called: ! 586: // set_up_indefinite fix32 put_result ! 587: // move_op_to_result underflow_response ! 588: // overflow_response ! 589: // ! 590: // ************************************************************************* ! 591: ALIGN ! 592: scale: //proc ! 593: jz catch_spcl_scale_cases // branch if no stack error ! 594: call set_stk_u_error // stack underflow occurred ! 595: jmp unmasked_i_error_ ! 596: ALIGN ! 597: catch_spcl_scale_cases: ! 598: andb $~(a_mask),%gs:sr_flags// clear 87 a-bit ! 599: movb tag1(%ebp),%al // both operands valid? ! 600: orb tag2(%ebp),%al ! 601: jnz special_cases_handler // no, branch to handler of special cases ! 602: valid_scale_case: ! 603: push %gs:sr_masks // save current rounding controls ! 604: orb rnd_to_zero,%gs:sr_controls // institute round by chopping ! 605: // this *or* works only because ! 606: // rnd_to_zero sets entire rc field ! 607: call fix32 // convert scale factor to int32 ! 608: pop %gs:sr_masks // restore rnd control ! 609: jz add_scale_term // if zf=1, no overflow in fix32 ! 610: cmpb positive,sign1(%ebp) ! 611: je get_least_sf_xtrm_ovfl ! 612: jmp get_grtst_sf_xtrm_unfl ! 613: ALIGN ! 614: add_scale_term: ! 615: mov dword_frac1+frac32(%ebp),%eax // int32 scale factor ! 616: cmp least_sf_xtrm_ovfl,%eax ! 617: jle check_xtrm_unfl ! 618: get_least_sf_xtrm_ovfl: ! 619: mov least_sf_xtrm_ovfl,%eax ! 620: jmp add_int32_to_dword_exp ! 621: ALIGN ! 622: check_xtrm_unfl: ! 623: cmp grtst_sf_xtrm_unfl,%eax ! 624: jge add_int32_to_dword_exp ! 625: get_grtst_sf_xtrm_unfl: ! 626: mov grtst_sf_xtrm_unfl,%eax ! 627: add_int32_to_dword_exp: ! 628: add %eax,dword_expon2 // add scale term to op2s expon ! 629: cmpl $0x7ffe,dword_expon2 ! 630: jg scale_overflow ! 631: cmp $1,dword_expon2 ! 632: jl scale_underflow ! 633: give_op2: ! 634: mov $offset_operand2,%edi ! 635: put_scaled_result: ! 636: mov offset_result_rec,%esi ! 637: jmp put_result ! 638: ALIGN ! 639: scale_overflow: ! 640: mov $offset_operand2,%esi // move op2 to result ! 641: call move_op_to_result ! 642: call overflow_response ! 643: jmp set_up_result ! 644: ALIGN ! 645: scale_underflow: ! 646: mov $offset_operand2,%esi // move op2 to result ! 647: call move_op_to_result ! 648: push %gs:sr_masks ! 649: orb prec64,%gs:sr_controls // *or* works only because prec64 ! 650: movb false,rnd1_inexact // sets all bits in the pc field ! 651: call underflow_response ! 652: pop %gs:sr_masks ! 653: set_up_result: ! 654: mov $offset_result,%edi ! 655: jmp put_scaled_result ! 656: ALIGN ! 657: //scale endp ! 658: // ! 659: //a_med ends ! 660: // ! 661: // end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.