![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fp_trans.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_trans.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 "trans.s" ! 26: ! 27: .ident "@(#)kern-fp:trans.s 1.1" ! 28: // ***************************************************************************** ! 29: // ! 30: // t r a n s . m o d ! 31: // ================= ! 32: // ! 33: // =============================================================== ! 34: // intel corporation proprietary information ! 35: // this software is supplied under the terms of a license ! 36: // agreement or non-disclosure agreement with intel corporation ! 37: // and may not be copied nor disclosed except in accordance with ! 38: // the terms of that agreement. ! 39: // =============================================================== ! 40: // ! 41: // public procedures: ! 42: // arctan, exp, log, splog, tan, move_10_bytes ! 43: // move_constant, test_5w, ,test_6w, test_4w, test_3w, clear_5w, clear_6w ! 44: // set_5w, set_6w,set_4w, set_3w, left_shift_result_cl ! 45: // left_shift_frac1_cl, left_shift_frac2_cl ! 46: // right_shift_result_cl,right_shift_frac1_cl ! 47: // right_shift_frac2_cl,right_shift,left_shift ! 48: // sticky_right_shift,addition_normalize ! 49: // subtraction_normalize,one_left_normalize ! 50: // gradual_underflow,left_shift_frac1_1,sin,cos,sincos ! 51: // ! 52: // ***************************************************************************** ! 53: // ! 54: // ! 55: //...october 16, 1986... ! 56: // ! 57: //$nolist ! 58: #include "fp_e80387.h" ! 59: //$list ! 60: .text //a_med segment er public ! 61: // ! 62: // extrn put_si_result,do_exchange,addx,subx ! 63: // extrn divx,divid,round,underflow_response ! 64: // extrn log_divx,decompose,mult,mulx ! 65: // extrn overflow_response,sp_subadd,stack_full_ ! 66: // extrn pop_free,put_op1_result,set_p_error ! 67: // extrn set_u_error,get_precision,do_exchange_leave_a_bit ! 68: // ! 69: .globl two_arg_trans ! 70: .globl exp ! 71: .globl log ! 72: .globl splog ! 73: .globl move_10_bytes ! 74: .globl tan ! 75: .globl move_constant ! 76: .globl test_5w ! 77: .globl test_6w ! 78: .globl test_4w ! 79: .globl test_3w ! 80: .globl clear_5w ! 81: .globl clear_6w ! 82: .globl set_5w ! 83: .globl set_6w ! 84: .globl set_4w ! 85: .globl set_3w ! 86: .globl left_shift_frac1_cl ! 87: .globl left_shift_result_cl ! 88: .globl left_shift_frac2_cl ! 89: .globl right_shift_frac1_cl ! 90: .globl right_shift_frac2_cl ! 91: .globl right_shift_result_cl ! 92: .globl right_shift ! 93: .globl left_shift ! 94: .globl gradual_underflow ! 95: .globl addition_normalize ! 96: .globl sticky_right_shift ! 97: .globl one_left_normalize ! 98: .globl subtraction_normalize ! 99: .globl left_shift_frac1_1 ! 100: .globl sin ! 101: .globl cos ! 102: .globl sincos ! 103: // ! 104: // ! 105: add_half_pattern: ! 106: .value 0x80,0,0,0,0 ! 107: add_half_pattern_1: ! 108: .value 0x8000,0,0,0,0 ! 109: constant_ln2_ov_6: ! 110: .value 0,0,0,0x1ff5,0x0ec98 ! 111: constant_2_ov_ln2: ! 112: .value 0x0bbc0,0x17f0,0x295c,0x0aa3b,0x00b8 ! 113: constant_one: ! 114: .value 0,0,0,0,0x100 ! 115: constant_six: ! 116: .value 0,0,0,0,0x0c000 ! 117: constant_sqrt_of_2: ! 118: .value 0x8400,0x0de64,0x33f9,0x04f3,0x0b5 ! 119: constant_3_ov_ln2: ! 120: .value 0,0x0f48d,0x0511,0x0ac5f,0x8a7f ! 121: constant_one_1: ! 122: .value 0,0,0,0,0x8000 ! 123: // ! 124: // this constant has been decreased by 1 to compensate ! 125: // for the bits lost during right shift. ! 126: // ! 127: constant_c0h: ! 128: .value 0x0ff00,0x0ffff,0x0ffff,0x0ffff,0x0bf ! 129: // ! 130: log_constant: ! 131: .value 0x09fa0,0x0d687,0x039fb,0x0c01a,0x095 //1 ! 132: .value 0x0f260,0x0dc57,0x05e68,0x0d3c2,0x0a4 //2 ! 133: .value 0x0fd20,0x0b43c,0x0cfde,0x000d1,0x0ae //3 ! 134: .value 0x0e680,0x098b3,0x0d648,0x01fb7,0x0b3 //4 ! 135: .value 0x089c0,0x0ec39,0x0ac77,0x0d69b,0x0b5 //5 ! 136: .value 0x05380,0x0914c,0x02e16,0x03cb4,0x0b7 //6 ! 137: .value 0x0fc80,0x0428b,0x0b778,0x0f285,0x0b7 //7 ! 138: .value 0x056e0,0x063ba,0x06bd5,0x04e23,0x0b8 //8 ! 139: .value 0x031e0,0x0ab26,0x0f853,0x07c1f,0x0b8 //9 ! 140: .value 0x0fd60,0x0a2a0,0x0ba1f,0x09329,0x0b8 //a ! 141: .value 0x057c0,0x0be18,0x07bca,0x09eb1,0x0b8 //b ! 142: .value 0x070a0,0x0fe44,0x0150d,0x0a476,0x0b8 //c ! 143: .value 0x0aa60,0x09b1b,0x08fd2,0x0a758,0x0b8 //d ! 144: .value 0x09460,0x09ae9,0x0d8be,0x0a8c9,0x0b8 //e ! 145: .value 0x03380,0x02572,0x08017,0x0a982,0x0b8 //f ! 146: // ! 147: tan_constant: ! 148: .value 0x034c0,0x068c2,0x0a221,0x00fda,0x0c9 //0 ! 149: .value 0x04580,0x0da7b,0x02b0d,0x06338,0x0ed //1 ! 150: .value 0x01560,0x006eb,0x0c964,0x0dbaf,0x0fa //2 ! 151: .value 0x032c0,0x07b6e,0x0d561,0x0add4,0x0fe //3 ! 152: .value 0x036c0,0x0ef4e,0x0b967,0x0aadd,0x0ff //4 ! 153: .value 0x04280,0x0b125,0x0dd4b,0x0eaad,0x0ff //5 ! 154: .value 0x0bbe0,0x094d5,0x0dddb,0x0faaa,0x0ff //6 ! 155: .value 0x06800,0x0d4b9,0x0addd,0x0feaa,0x0ff //7 ! 156: .value 0x04bc0,0x0ddb9,0x0aadd,0x0ffaa,0x0ff //8 ! 157: .value 0x04ba0,0x0dddd,0x0aaad,0x0ffea,0x0ff //9 ! 158: .value 0x0dba0,0x0dddd,0x0aaaa,0x0fffa,0x0ff //a ! 159: .value 0x0dde0,0x0addd,0x0aaaa,0x0fffe,0x0ff //b ! 160: .value 0x0dde0,0x0aadd,0x0aaaa,0x0ffff,0x0ff //c ! 161: .value 0x0dde0,0x0aaad,0x0eaaa,0x0ffff,0x0ff //d ! 162: .value 0x0dde0,0x0aaaa,0x0faaa,0x0ffff,0x0ff //e ! 163: .value 0x0ade0,0x0aaaa,0x0feaa,0x0ffff,0x0ff //f ! 164: // ! 165: // ******************************************************************************* ! 166: // ! 167: at_case_table: ! 168: .long at_round,case_1,case_2,case_3 ! 169: // ! 170: two_arg_trans_table: ! 171: .long at_non_0,log,splog ! 172: // ! 173: //...the following jump tables refer to the following op1/op2 cases ! 174: // ! 175: // (where v=valid, z=zero, f=infinity, and d=denormal): ! 176: // 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, ! 177: // in that order .. ! 178: // ! 179: // arctan2_table is first ! 180: // ! 181: special_table: ! 182: .long handle_non_special_cases,sign_y_hapi ! 183: .long sign_y_pi_or_0,only_op2_denormd ! 184: .long sign_y_pi_or_0,at_both_0 ! 185: .long sign_y_pi_or_0,derror_sign_y_pi_or_0 ! 186: .long sign_y_hapi,sign_y_hapi ! 187: .long handle_non_special_cases,derror_sign_y_hapi ! 188: .long only_op1_denormd,derror_sign_y_hapi ! 189: .long derror_sign_y_pi_or_0,both_ops_denormd ! 190: // ! 191: // log_table is second, 64 bytes after arctan2_table ! 192: // ! 193: .long handle_non_special_cases,op2_signed_by_op1_vs_1 ! 194: .long inv_or_op2_signed_by_op1_vs_1,only_op2_denormd ! 195: .long zerror_flip_sign_y_inf,op_unsupp ! 196: .long zerror_flip_sign_op2,zerror_flip_sign_y_inf ! 197: .long sign_y_op1,op_unsupp ! 198: .long op2,derror_sign_y_op1 ! 199: .long only_op1_denormd,derror_flip_sign_op2 ! 200: .long derror_flip_sign_op2,both_ops_denormd ! 201: // ! 202: // splog_table is third (and last), 128 bytes after arctan2_table ! 203: // ! 204: .long handle_non_special_cases,exor_signed_op2 ! 205: .long exor_signed_op2,only_op2_denormd ! 206: .long exor_signed_op1,exor_signed_op2 ! 207: .long op_unsupp,derror_exor_signed_op1 ! 208: .long sign_y_op1,op_unsupp ! 209: .long op2,derror_sign_y_op1 ! 210: .long only_op1_denormd,derror_exor_signed_op2 ! 211: .long derror_exor_signed_op2,both_ops_denormd ! 212: // ! 213: // ***************************************************************************** ! 214: // ! 215: // *********************************************************************** ! 216: // atan_core: ! 217: // ********* ! 218: // ! 219: // function: ! 220: // calculates arc tangent of (y/x), where ! 221: // 0 < y/x < 1 ; op2 = x, op1 = y. ! 222: // ! 223: // inputs: ! 224: // assumes that operand1 and operand2 are set up. ! 225: // ! 226: // outputs: ! 227: // result in global record 12; possible underflow ! 228: // and inexact errors. ! 229: // ! 230: // data accessed: ! 231: // - expon1 word_frac1 ! 232: // - lsb_frac1 msb_frac1 ! 233: // - offset_operand1 expon2 ! 234: // - lsb_frac2 offset_operand2 ! 235: // - offset_result result_sign ! 236: // - result_tag result_expon ! 237: // - result_word_frac msb_result ! 238: // - offset_of_result_frac offset_cop ! 239: // - offset_dop siso ! 240: // ! 241: // data changed: ! 242: // - expon1 frac1 ! 243: // - frac2 result_sign ! 244: // - result_expon result_frac ! 245: // - siso ! 246: // ! 247: // procedures called: ! 248: // put_si_result right_shift left_shift ! 249: // move_10_bytes move_constant addx ! 250: //subx mulx accel_divx (replaces divx) ! 251: // divid one_left_normalize round ! 252: // addition_normalize underflow_response pop_free ! 253: // test_5w set_p_error set_u_error ! 254: // ! 255: // ********************************************************************** ! 256: ALIGN ! 257: atan_core: //proc ! 258: push %gs:sr_masks // save precision control ! 259: // and dword ptr %gs:sr_masks, 0fffff3ffh; set rounding control to nearest ! 260: orl $0x0300,%gs:sr_masks // set precision control to prec64 ! 261: orb $inexact_mask,%gs:sr_errors // always inexact ! 262: movb positive,result_sign(%ebp)// result is always positive ! 263: movw $0,siso // clear siso ! 264: mov dword_expon2,%eax ! 265: sub dword_expon1,%eax ! 266: mov %eax,dword_exp_tmp ! 267: cmp $15,%eax ! 268: jle atn_pseudo_div ! 269: cmp $63,%eax ! 270: // ! 271: //tiny argument ! 272: // ! 273: jg atn_divide ! 274: jmp atn_rat_appx ! 275: ALIGN ! 276: atn_divide: ! 277: call divid // floating-point divide ! 278: // ! 279: //post operation rounding ! 280: // ! 281: call post_op_round // d.e. precision rounding ! 282: // ! 283: //error check ! 284: // ! 285: mov dword_result_expon,%eax ! 286: cmp $0,%eax ! 287: jg atn_put_atn_f ! 288: jl atn_put_atn // underflow of core has occurred. ! 289: mov $offset_result+frac64,%edi ! 290: call test_4w // note that ax is 0 here. ! 291: jnz atn_put_atn // underflow of core has occurred. ! 292: atn_zero: ! 293: movb special,result_tag(%ebp) ! 294: jmp atn_put_atn ! 295: ALIGN ! 296: // ! 297: atn_pseudo_div: ! 298: call right_shift_frac2_8 ! 299: call right_shift_frac1_8 ! 300: atn_loop_back_1: ! 301: call subx ! 302: shlw $1,siso ! 303: cmpb $0,msb_result ! 304: jnz atn_shift_left ! 305: call move_result_cop // cop is 67 bits temp ! 306: mov $offset_operand1,%edi ! 307: call right_shift_dword_exp_tmp ! 308: call addx ! 309: call move_result_frac1 ! 310: mov $add_half_pattern,%esi ! 311: call add_frac2 // add 1/2 round ! 312: call move_result_frac2 ! 313: andl $0x0ff000000,dword_frac2(%ebp) // frac2 = 64 bits x ! 314: call move_cop_frac1 // frac1 = 67 bits y ! 315: incw siso ! 316: cmpb $0,msb_result ! 317: je atn_shift_left ! 318: mov $1,%ecx ! 319: call right_shift_frac2_cl ! 320: andl $0x0ff000000,dword_frac2(%ebp) ! 321: jmp atn_merge_0 ! 322: ALIGN ! 323: atn_shift_left: ! 324: call left_shift_frac1_1 ! 325: atn_merge_0: ! 326: incl dword_exp_tmp ! 327: cmp $15,dword_exp_tmp ! 328: jna atn_loop_back_1 ! 329: mov $7,%ecx ! 330: call left_shift_frac1_cl ! 331: andl $0x0e0000000,dword_frac1(%ebp) ! 332: movl $15,dword_exp_tmp ! 333: call left_shift_frac2_8 ! 334: atn_rat_appx: ! 335: // the following call used to be to divx instead of accel_divx: ! 336: call accel_divx // y/x --> z (67) ! 337: call move_result_frac1 ! 338: mov $9,%ecx ! 339: call right_shift_frac1_cl ! 340: andl $0x0ffe00000,dword_frac1(%ebp) ! 341: call move_result_frac2 ! 342: call right_shift_frac2_8 ! 343: andl $0x0ffe00000,dword_frac2(%ebp) ! 344: andl $0x0e0000000,result_dword_frac(%ebp)// mask result frac ! 345: call move_result_cop ! 346: call addx ! 347: call move_result_dop //dop = new y (67) ! 348: call move_cop_frac1 ! 349: call move_cop_frac2 ! 350: mov $30,%ecx ! 351: call right_shift_frac1_cl // perform short multiply ! 352: movl $0,dword_frac1(%ebp) ! 353: mov $30,%ecx ! 354: call left_shift_frac1_cl ! 355: call mulx ! 356: mov $offset_result,%edi ! 357: call right_shift_dword_exp_tmp ! 358: movb $0x0c0,msb_result ! 359: call move_result_frac2 // new x (64) ! 360: andl $0x0e0000000,dword_frac2(%ebp) ! 361: cmpb $0,msb_dop ! 362: movb $1,%al ! 363: mov $7,%ecx ! 364: jne atn_merge_1 ! 365: movb $0,%al ! 366: mov $8,%ecx ! 367: atn_merge_1: ! 368: push %eax //save al ! 369: mov $offset_dop+frac80,%edi ! 370: call left_shift ! 371: call move_dop_frac1 ! 372: // the following call used to be to divx instead of accel_divx: ! 373: call accel_divx ! 374: andl $0x0e0000000,result_dword_frac(%ebp)// theta is here ! 375: pop %eax ! 376: shrb $1,%al ! 377: mov $7,%ecx ! 378: jnb atn_merge_2 ! 379: mov $6,%ecx ! 380: atn_merge_2: ! 381: call right_shift_result_cl ! 382: call move_result_frac1 ! 383: atn_loop_back_2: ! 384: shrw $1,siso ! 385: jnb atn_q_bit_not_set ! 386: mov $10,%eax ! 387: mull dword_exp_tmp ! 388: add $tan_constant,%eax ! 389: mov %eax,%esi ! 390: call add_frac2 ! 391: call move_result_frac1 ! 392: atn_q_bit_not_set: ! 393: cmpw $0,siso ! 394: jz atn_end_loop ! 395: mov $1,%ecx ! 396: call right_shift_frac1_cl ! 397: andl $0x0ffe00000,dword_frac1(%ebp) ! 398: decl dword_exp_tmp ! 399: jmp atn_loop_back_2 ! 400: ALIGN ! 401: atn_end_loop: ! 402: cmpb $0,msb_frac1 ! 403: mov $8,%ecx ! 404: je atn_merge_3 ! 405: mov $7,%ecx ! 406: decl dword_exp_tmp ! 407: atn_merge_3: ! 408: call left_shift_frac1_cl ! 409: movl $0x3ffe,dword_expon1 ! 410: mov dword_exp_tmp,%eax ! 411: sub %eax,dword_expon1 ! 412: mov $offset_operand1,%edi ! 413: call one_left_normalize ! 414: call move_frac1_result// added when add_half1_frac below was cut ! 415: mov dword_expon1,%eax ! 416: mov %eax,dword_result_expon ! 417: // call add_half1_frac2 ! 418: atn_put_atn_f: ! 419: movb valid,result_tag(%ebp) // valid result ! 420: atn_put_atn: ! 421: pop %gs:sr_masks // restore precision control ! 422: ret ! 423: //atan_core endp ! 424: // ! 425: // ! 426: // ******************************************************************************* ! 427: // ! 428: ALIGN ! 429: move_unpacked_0_to_edi: //proc ! 430: ! 431: movl $0,(%ebp,%edi) ! 432: movl $0,frac64(%ebp,%edi) ! 433: movl $0,frac32(%ebp,%edi) ! 434: movl $0x10000*SPECIAL+POSITIVE,sign(%ebp,%edi) ! 435: movl $0,expon(%ebp,%edi) ! 436: ret ! 437: ! 438: //move_unpacked_0_to_edi endp ! 439: // ! 440: // ******************************************************************************* ! 441: // ! 442: ALIGN ! 443: move_unpacked_hapi_to_edi: //proc ! 444: ! 445: movl $0,(%ebp,%edi) ! 446: movl $0x2168c235,frac64(%ebp,%edi) ! 447: movl $0x0c90fdaa2,frac32(%ebp,%edi) ! 448: movl $0x10000*VALID+POSITIVE,sign(%ebp,%edi) ! 449: movl $0x3fff,expon(%ebp,%edi) ! 450: ret ! 451: ! 452: //move_unpacked_hapi_to_edi endp ! 453: // ! 454: // ******************************************************************************* ! 455: // ! 456: // ! 457: // ******************************************************************************* ! 458: ! 459: ALIGN ! 460: at_non_0: //proc ! 461: ! 462: movb sign1(%ebp),%dl ! 463: movb sign2(%ebp),%dh ! 464: movb positive,sign1(%ebp) ! 465: movb positive,sign2(%ebp) ! 466: movb %dh,%bl ! 467: and $8,%ebx ! 468: at_cmpr_ops: // this compare assumes same- ! 469: // signed, normalized comparands ! 470: mov dword_expon2,%eax ! 471: cmp dword_expon1,%eax ! 472: jg take_atan ! 473: jl at_switch_ops ! 474: mov dword_frac1+frac32(%ebp),%eax ! 475: cmp dword_frac2+frac32(%ebp),%eax ! 476: jg take_atan ! 477: jl at_switch_ops ! 478: mov dword_frac1+frac64(%ebp),%eax ! 479: cmp dword_frac2+frac64(%ebp),%eax ! 480: jg take_atan ! 481: jl at_switch_ops ! 482: at_ops_eql: ! 483: mov $offset_result,%edi ! 484: call move_unpacked_hapi_to_edi ! 485: decl dword_result_expon // make pi/4 ! 486: or %ebx,%ebx ! 487: jz at_sign_adjust ! 488: jmp hapi_to_op1 ! 489: ALIGN ! 490: at_switch_ops: ! 491: push %ebx ! 492: call swap_ops // edx preserved ! 493: pop %ebx ! 494: or $4,%ebx ! 495: take_atan: ! 496: push %ebx // save operand signs ! 497: push %edx // save table index ! 498: call atan_core ! 499: pop %edx ! 500: pop %ebx ! 501: or %ebx,%ebx ! 502: jnz hapi_to_op1 ! 503: at_underflow_: ! 504: mov dword_result_expon,%eax ! 505: cmp $0,%eax ! 506: jg at_round ! 507: jl at_underflow ! 508: cmpb special,result_tag(%ebp) ! 509: je at_round_report ! 510: at_underflow: // underflow ! 511: push %edx // save sign info ! 512: call underflow_response ! 513: pop %edx // restore sign info ! 514: orb underflow_mask,%gs:sr_errors ! 515: jmp at_sign_adjust ! 516: ALIGN ! 517: hapi_to_op1: ! 518: mov $offset_operand1,%edi ! 519: call move_unpacked_hapi_to_edi ! 520: jmp *%cs:at_case_table(%ebx) ! 521: ALIGN ! 522: // ! 523: case_3: ! 524: movb $add_op,operation_type(%ebp) ! 525: jmp at_to_op2 ! 526: ALIGN ! 527: case_2: ! 528: incl dword_expon1 // make pi ! 529: case_1: ! 530: movb $sub_op,operation_type(%ebp) ! 531: at_to_op2: ! 532: push %edx ! 533: // push ebx ! 534: lea dword_frac2(%ebp),%edi ! 535: lea result_dword_frac(%ebp),%esi ! 536: call move_op_to_op ! 537: call subadd ! 538: // pop ebx ! 539: pop %edx ! 540: at_round: ! 541: push %gs:sr_masks ! 542: orl $0x0300,%gs:sr_masks // set precision control to prec64 ! 543: push %edx ! 544: call post_op_round ! 545: pop %edx ! 546: pop %gs:sr_masks ! 547: at_round_report: ! 548: cmpw $0,rnd_history ! 549: je at_sign_adjust ! 550: orb $inexact_mask,%gs:sr_errors ! 551: cmpb true,added_one ! 552: jne at_sign_adjust ! 553: orb $a_mask,%gs:sr_flags ! 554: at_sign_adjust: ! 555: movb %dl,result_sign(%ebp) ! 556: at_exit: ! 557: ret ! 558: ! 559: //at_non_0 endp ! 560: // ! 561: // ******************************************************************************* ! 562: // ! 563: // ! 564: ALIGN ! 565: two_arg_trans: //proc ! 566: ! 567: jz two_arg_special_case_ // branch if no stack error ! 568: call set_stk_u_error // stack underflow occurred ! 569: testb invalid_mask,%gs:sr_masks// if unmasked, just return ! 570: jnz return_indef // else, return indefinite ! 571: two_arg_unmasked_exit: ! 572: ret ! 573: ALIGN ! 574: return_indef: ! 575: call put_indefinite ! 576: jmp get_result_ptr ! 577: ALIGN ! 578: two_arg_special_case_: ! 579: andb $~a_mask,%gs:sr_flags // clear a-bit initially ! 580: movzbl tag1(%ebp),%ebx // both operands valid? ! 581: orb tag2(%ebp),%bl ! 582: jnz two_arg_special_case ! 583: handle_non_special_cases: ! 584: movzbl operation_type(%ebp),%ebx// call log/splog/arctan2 ! 585: subb $arctan_op,%bl // to do the operation ! 586: je main_call // ebx has offset of at_non_0 container ! 587: cmpb $log_op-arctan_op,%bl ! 588: je log_of_neg_num_ ! 589: cmpl $0x3fff,dword_expon1 ! 590: jg op_unsupp ! 591: jl get_splog_offset ! 592: weed_out_neg_1: ! 593: cmpb positive,sign1(%ebp) ! 594: je op_unsupp ! 595: cmpl $0x080000000,dword_frac1+frac32(%ebp) ! 596: jne op_unsupp ! 597: cmp $0,dword_frac1+frac64(%ebp) ! 598: jne op_unsupp ! 599: jmp zerror_flip_sign_y_inf ! 600: ALIGN ! 601: get_splog_offset: ! 602: mov $8,%ebx // ebx has offset of splog container ! 603: jmp main_call ! 604: ALIGN ! 605: log_of_neg_num_: ! 606: cmpb positive,sign1(%ebp) ! 607: jne op_unsupp ! 608: mov $4,%ebx // ebx has offset of log container ! 609: main_call: ! 610: call *%cs:two_arg_trans_table(%ebx) ! 611: get_result_ptr: ! 612: mov $offset_result,%edi ! 613: got_result_ptr: ! 614: mov offset_result_rec,%esi ! 615: jmp put_arith_result ! 616: ALIGN ! 617: // ! 618: both_ops_denormd: ! 619: orb denorm_mask,%gs:sr_errors ! 620: testb denorm_mask,%gs:sr_masks ! 621: jz two_arg_unmasked_exit ! 622: mov $offset_operand1,%edi ! 623: call norm_denorm ! 624: op2_denormd: ! 625: mov $offset_operand2,%edi ! 626: call norm_denorm ! 627: jmp handle_non_special_cases ! 628: ALIGN ! 629: only_op1_denormd: ! 630: orb denorm_mask,%gs:sr_errors ! 631: testb denorm_mask,%gs:sr_masks ! 632: jz two_arg_unmasked_exit ! 633: mov $offset_operand1,%edi ! 634: call norm_denorm ! 635: jmp handle_non_special_cases ! 636: ALIGN ! 637: only_op2_denormd: ! 638: orb denorm_mask,%gs:sr_errors ! 639: testb denorm_mask,%gs:sr_masks ! 640: jz two_arg_unmasked_exit ! 641: jmp op2_denormd ! 642: ALIGN ! 643: // ! 644: two_arg_special_case: ! 645: testb $0x10,%bl // al contains (ebp).tag1 or (ebp).tag2 ! 646: jz op1_nan_ ! 647: op_unsupp: ! 648: orb invalid_mask,%gs:sr_errors// here, at least one op is unsupported. ! 649: testb invalid_mask,%gs:sr_masks ! 650: jz two_arg_unmasked_exit ! 651: jmp return_indef ! 652: ALIGN ! 653: op1_nan_: // here, neither op is unsupported. ! 654: cmpb inv,tag1(%ebp) ! 655: je op1_snan_ ! 656: cmpb inv,tag2(%ebp) ! 657: jne non_nan_supp_ops ! 658: jmp signal_invalid_ ! 659: ALIGN ! 660: op1_snan_: ! 661: testb $0x40,msb_frac1 ! 662: jz invalid_operand ! 663: op2_also_nan_: ! 664: cmpb inv,tag2(%ebp) ! 665: jne jmp_set_up_nan_return ! 666: signal_invalid_: ! 667: testb $0x40,msb_frac2 ! 668: jnz jmp_set_up_nan_return ! 669: invalid_operand: ! 670: orb invalid_mask,%gs:sr_errors// invalid operand sets ! 671: testb invalid_mask,%gs:sr_masks ! 672: jz two_arg_unmasked_exit // i-error, if unmasked ! 673: jmp_set_up_nan_return: ! 674: jmp set_up_nan_return ! 675: ALIGN ! 676: non_nan_supp_ops: ! 677: movb tag1(%ebp),%bh ! 678: movzbl operation_type(%ebp),%eax ! 679: subb $arctan_op,%al ! 680: je get_tag2 // eax now holds base of arctan table ! 681: cmpb $log_op-arctan_op,%al ! 682: je only_neg_0_ok ! 683: cmpl $0x3fff,dword_expon1 ! 684: jl get_splog_table ! 685: je weed_out_neg_1 ! 686: cmpl $0x7fff,dword_expon1 ! 687: jne op_unsupp ! 688: cmpb positive,sign1(%ebp) ! 689: jne op_unsupp ! 690: get_splog_table: ! 691: mov $128,%eax // eax now holds base of splog table ! 692: jmp get_tag2 ! 693: ALIGN ! 694: only_neg_0_ok: ! 695: cmpb positive,sign1(%ebp) ! 696: je log_table_base_to_eax ! 697: cmpb special,%bh ! 698: jne op_unsupp ! 699: log_table_base_to_eax: ! 700: mov $64,%eax // eax now holds base of log table ! 701: get_tag2: ! 702: movb tag2(%ebp),%bl ! 703: testb $0x04,%bh ! 704: jz op2_denorm_ ! 705: movb $3,%bh // indicate op1 is denorm ! 706: op2_denorm_: ! 707: testb $0x04,%bl ! 708: jz get_index ! 709: movb $3,%bl // indicate op2 is denorm ! 710: get_index: ! 711: and $0x0303,%ebx // form index to special operation table ! 712: // bx=4*(4*masked_tag1 + masked_tag2), ! 713: // where masked_tag = 0 for valid, ! 714: shlb $2,%bh //1 for zero, ! 715: //2 for infinity ! 716: addb %bh,%bl //3 for denormd ! 717: xorb %bh,%bh ! 718: shl $2,%ebx ! 719: add_base: ! 720: add %eax,%ebx // (e)bx = case offset ! 721: jmp *%cs:special_table(%ebx) // jump to special case ! 722: ALIGN ! 723: // ! 724: derror_sign_y_pi_or_0: ! 725: orb denorm_mask,%gs:sr_errors ! 726: testb denorm_mask,%gs:sr_masks ! 727: jz two_arg_unmasked_exit // if unmasked, return ! 728: sign_y_pi_or_0: ! 729: cmpb positive,sign2(%ebp) ! 730: je sign_y_0 ! 731: sign_y_pi: ! 732: mov $offset_result,%edi ! 733: call move_unpacked_hapi_to_edi ! 734: incl dword_result_expon // make pi ! 735: jmp at_spcl_sign_adjust ! 736: ALIGN ! 737: ! 738: derror_sign_y_hapi: ! 739: orb denorm_mask,%gs:sr_errors ! 740: testb denorm_mask,%gs:sr_masks ! 741: jz two_arg_unmasked_exit // if unmasked, return ! 742: sign_y_hapi: ! 743: mov $offset_result,%edi ! 744: call move_unpacked_hapi_to_edi ! 745: jmp at_spcl_sign_adjust ! 746: ALIGN ! 747: ! 748: at_both_0: ! 749: cmpb positive,sign2(%ebp) ! 750: jne sign_y_pi ! 751: sign_y_0: ! 752: mov $offset_result,%edi ! 753: call move_unpacked_0_to_edi ! 754: ! 755: at_spcl_sign_adjust: ! 756: movb sign1(%ebp),%dl ! 757: movb %dl,result_sign(%ebp) ! 758: jmp get_result_ptr ! 759: ALIGN ! 760: ! 761: zerror_flip_sign_y_inf: ! 762: orb zero_divide_mask,%gs:sr_errors ! 763: testb zero_divide_mask,%gs:sr_masks ! 764: jz two_arg_unmasked_exit ! 765: flip_sign_y_inf: ! 766: movl $0x080000000,dword_frac1+frac32(%ebp) ! 767: movl $0x10000*INFINITY+POSITIVE,sign1(%ebp) ! 768: movl $0x7fff,dword_expon1 ! 769: flip_sign_y_op1: ! 770: mov $offset_operand1,%edi ! 771: flip_sign_y_to_edi: ! 772: movb sign2(%ebp),%dl ! 773: notb %dl ! 774: movb %dl,sign(%ebp,%edi) ! 775: jmp got_result_ptr ! 776: ALIGN ! 777: ! 778: //zerror_derror_flip_sign_y_inf: ! 779: // or %gs:sr_errors, zero_divide_mask ! 780: // test %gs:sr_masks, zero_divide_mask ! 781: // jz two_arg_unmasked_exit ! 782: // or %gs:sr_errors, denorm_mask ! 783: // test %gs:sr_masks, denorm_mask ! 784: // jz two_arg_unmasked_exit ! 785: // jmp short flip_sign_y_inf ! 786: ! 787: derror_sign_y_op1: ! 788: orb denorm_mask,%gs:sr_errors ! 789: testb denorm_mask,%gs:sr_masks ! 790: jz two_arg_unmasked_exit ! 791: sign_y_op1: ! 792: mov $offset_operand1,%edi ! 793: sign_y_to_edi: ! 794: movb sign2(%ebp),%dl ! 795: movb %dl,sign(%ebp,%edi) ! 796: jmp got_result_ptr ! 797: ALIGN ! 798: ! 799: inv_or_op2_signed_by_op1_vs_1: ! 800: cmpl $0x3fff,dword_expon1 ! 801: jg op2 ! 802: jl flip_sign_op2 ! 803: cmpl $0x80000000,dword_frac1+frac32(%ebp) ! 804: ja op2 ! 805: cmp $0,dword_frac1+frac64(%ebp) ! 806: jne op2 ! 807: jmp op_unsupp ! 808: ALIGN ! 809: ! 810: zerror_flip_sign_op2: ! 811: orb zero_divide_mask,%gs:sr_errors ! 812: testb zero_divide_mask,%gs:sr_masks ! 813: jz two_arg_unmasked_exit ! 814: jmp flip_sign_op2 ! 815: ALIGN ! 816: ! 817: op2_signed_by_op1_vs_1: ! 818: cmpl $0x3fff,dword_expon1 ! 819: jge op2 ! 820: flip_sign_op2: ! 821: notb sign2(%ebp) ! 822: op2: ! 823: mov $offset_operand2,%edi ! 824: jmp got_result_ptr ! 825: ALIGN ! 826: ! 827: derror_flip_sign_op2: ! 828: orb denorm_mask,%gs:sr_errors ! 829: testb denorm_mask,%gs:sr_masks ! 830: jz two_arg_unmasked_exit ! 831: jmp flip_sign_op2 ! 832: ALIGN ! 833: ! 834: derror_exor_signed_op2: ! 835: orb denorm_mask,%gs:sr_errors ! 836: testb denorm_mask,%gs:sr_masks ! 837: jz two_arg_unmasked_exit ! 838: exor_signed_op2: ! 839: movb sign1(%ebp),%dl ! 840: xorb %dl,sign2(%ebp) ! 841: jmp op2 ! 842: ALIGN ! 843: ! 844: derror_exor_signed_op1: ! 845: orb denorm_mask,%gs:sr_errors ! 846: testb denorm_mask,%gs:sr_masks ! 847: jz two_arg_unmasked_exit ! 848: exor_signed_op1: ! 849: movb sign2(%ebp),%dl ! 850: xorb %dl,sign1(%ebp) ! 851: op1: ! 852: mov $offset_operand1,%edi ! 853: jmp got_result_ptr ! 854: ALIGN ! 855: ! 856: //two_arg_trans endp ! 857: // ! 858: ALIGN ! 859: push_5_dw_at_esi: //proc ! 860: ! 861: pop %ebx // ebx <-- return address ! 862: push (%ebp,%esi) ! 863: push frac64(%ebp,%esi) ! 864: push frac32(%ebp,%esi) ! 865: push sign(%ebp,%esi) ! 866: push expon(%ebp,%esi) ! 867: jmp *%ebx ! 868: ! 869: //push_5_dw_at_esi endp ! 870: ! 871: // ********************************************************************** ! 872: // ********************************************************************** ! 873: ! 874: ALIGN ! 875: pop_5_dw_at_esi: //proc ! 876: ! 877: pop %ebx // ebx <-- return address ! 878: pop expon(%ebp,%esi) ! 879: pop sign(%ebp,%esi) ! 880: pop frac32(%ebp,%esi) ! 881: pop frac64(%ebp,%esi) ! 882: pop (%ebp,%esi) ! 883: jmp *%ebx ! 884: ! 885: //pop_5_dw_at_esi endp ! 886: ! 887: // ********************************************************************** ! 888: ALIGN ! 889: move_unpacked_1_to_esi: //proc ! 890: ! 891: movl $0,(%ebp,%esi) ! 892: movl $0,frac64(%ebp,%esi) ! 893: movl $0x080000000,frac32(%ebp,%esi) ! 894: // mov positive+0x10000*valid,sign(%ebp,%esi) ! 895: movl $0x10000*VALID+POSITIVE,sign(%ebp,%esi) ! 896: movl $0x3fff,expon(%ebp,%esi) ! 897: ret ! 898: ! 899: //move_unpacked_1_to_esi endp ! 900: // ********************************************************************** ! 901: // *********************************************************************** ! 902: // exp: ! 903: // *** ! 904: // function: ! 905: // calculates 2**x - 1, where 0 <= x < 1/2. ! 906: // inputs: ! 907: // assumes that operand1 is set up. ! 908: // ! 909: // outputs: ! 910: // result in global record 12; possible underflow ! 911: // and inexact errors. ! 912: // ! 913: // data accessed: ! 914: // - offset_operand1 tag1 ! 915: // - expon1 word_frac1 ! 916: // - lsb_frac1 offset_operand1 ! 917: // - sign2 expon2 ! 918: // - offset_operand2 offset_result ! 919: // - result_tag result_expon ! 920: // - lsb_result msb_result ! 921: // - offset_result siso ! 922: // - offset_cop ! 923: // ! 924: // data changed: ! 925: // - expon1 lsb_frac1 ! 926: // - sign2 expon2 ! 927: // - result_tag msb_result ! 928: // - siso ! 929: // ! 930: // procedures called: ! 931: // put_si_result right_shift left_shift ! 932: // move_10_bytes move_constant addx ! 933: // subx mulx divx ! 934: // addition_normalize round divid ! 935: // log_constant underflow_response set_p_error ! 936: // ! 937: // *********************************************************************** ! 938: ALIGN ! 939: exp_core: //proc ! 940: // ! 941: //pseudo_division ! 942: // ! 943: movw $0,siso // clear siso ! 944: mov $0x3fff,%eax ! 945: sub dword_expon1,%eax // dword_expon1 < 3fffh ! 946: cmp $63,%eax ! 947: jg exp_tiny_argument ! 948: mov %eax,dword_expon1 ! 949: cmp $15,%eax ! 950: ja exp_rat_appx // impossible that eax <= 0 ! 951: call right_shift_frac1_8 ! 952: exp_loop_back_1: ! 953: mov $10,%eax ! 954: mull dword_expon1 ! 955: add $log_constant-10,%eax ! 956: mov %eax,%esi ! 957: call sub_frac2 ! 958: shlw $1,siso ! 959: cmpb $0,msb_result ! 960: jne exp_merge_0 ! 961: call move_result_frac1 ! 962: andl $0x0ffe00000,dword_frac1(%ebp) ! 963: incw siso ! 964: exp_merge_0: ! 965: incl dword_expon1 ! 966: cmp $15,dword_expon1 ! 967: ja exp_branch_1 ! 968: call left_shift_frac1_1 ! 969: jmp exp_loop_back_1 ! 970: ALIGN ! 971: exp_tiny_argument: ! 972: movb positive,sign2(%ebp) ! 973: movl $0x3fff,dword_expon2 ! 974: mov $constant_2_ov_ln2,%esi ! 975: call move_constant_frac2 ! 976: call left_shift_frac2_8 // tiny argument ! 977: call divid // floating-point divide ! 978: call post_op_round ! 979: exp_put_exp_jmp: ! 980: jmp exp_put_exp_f ! 981: ALIGN ! 982: // ! 983: //pre_rat_appx ! 984: // ! 985: exp_branch_1: ! 986: movl $15,dword_expon1 ! 987: call left_shift_frac1_8 ! 988: exp_rat_appx: ! 989: call move_frac1_cop ! 990: // ! 991: //80287 short multiply (does 67-bit by 34-bit multiplication only). ! 992: // ! 993: movb $30,%cl ! 994: call right_shift_frac1_cl ! 995: and $0,dword_frac1(%ebp) ! 996: movb $30,%cl ! 997: call left_shift_frac1_cl ! 998: call mulx ! 999: call move_result_frac1 ! 1000: andl $0x0e0000000,dword_frac1(%ebp) ! 1001: mov $constant_ln2_ov_6,%esi ! 1002: call mul_frac2 ! 1003: mov dword_expon1,%ecx ! 1004: add $10,%ecx ! 1005: call right_shift_result_cl ! 1006: andl $0x0ffe00000,result_dword_frac(%ebp) ! 1007: call move_cop_frac1 ! 1008: call right_shift_frac1_8 ! 1009: call move_result_frac2 ! 1010: call subx ! 1011: mov dword_expon1,%ecx ! 1012: inc %ecx ! 1013: call right_shift_result_cl ! 1014: andl $0x0ffe00000,result_dword_frac(%ebp) ! 1015: call move_result_frac2 ! 1016: mov $constant_2_ov_ln2,%esi ! 1017: call sub_frac1 ! 1018: call move_cop_frac1 ! 1019: call move_result_frac2 ! 1020: call left_shift_frac2_8 ! 1021: // the following call used to be to divx instead of accel_divx: ! 1022: call accel_divx ! 1023: mov $8,%ecx ! 1024: call right_shift_result_cl ! 1025: andl $0x0ffe00000,result_dword_frac(%ebp) ! 1026: ! 1027: // ! 1028: //pseudo_multiply ! 1029: // ! 1030: exp_loop_back_2: ! 1031: shrw $1,siso ! 1032: jnb exp_merge_2 ! 1033: call move_result_frac1 ! 1034: call move_result_frac2 ! 1035: mov dword_expon1,%ecx ! 1036: call right_shift_frac2_cl ! 1037: andl $0x0ffe00000,dword_frac2(%ebp) ! 1038: orw $0x80,8+word_frac2 ! 1039: call addx ! 1040: exp_merge_2: ! 1041: cmpw $0,siso ! 1042: je exp_almost_end ! 1043: call right_shift_result_1 ! 1044: andl $0x0ffe00000,result_dword_frac(%ebp) ! 1045: decl dword_expon1 ! 1046: jmp exp_loop_back_2 ! 1047: ALIGN ! 1048: exp_almost_end: ! 1049: movb $8,%cl ! 1050: cmpb $0,msb_result ! 1051: je exp_merge_3 ! 1052: movb $7,%cl ! 1053: decl dword_expon1 ! 1054: exp_merge_3: ! 1055: call left_shift_result_cl ! 1056: mov $0x3fff,%eax ! 1057: sub dword_expon1,%eax ! 1058: mov %eax,dword_result_expon ! 1059: // mov positive+valid\*0x10000,result_sign(%ebp) ! 1060: movl $0x10000*VALID+POSITIVE,result_sign(%ebp) ! 1061: testb $0x80,msb_result ! 1062: jne exp_add_half_round ! 1063: // ! 1064: //normalize x ! 1065: // ! 1066: movb $1,%cl ! 1067: call left_shift_result_cl ! 1068: decl dword_result_expon ! 1069: exp_add_half_round: ! 1070: call move_result_frac1 ! 1071: call add_half1_frac2 ! 1072: exp_put_exp_f: ! 1073: ret ! 1074: ! 1075: //exp_core endp ! 1076: // ********************************************************************** ! 1077: ALIGN ! 1078: neg_exp_core: //proc ! 1079: notb sign1(%ebp) ! 1080: call exp_core ! 1081: lea result_dword_frac(%ebp),%esi ! 1082: lea dword_frac2(%ebp),%edi ! 1083: call move_op_to_op ! 1084: mov $offset_operand1,%esi ! 1085: call move_unpacked_1_to_esi ! 1086: movb negative,sign1(%ebp) ! 1087: movb $sub_op,operation_type(%ebp) ! 1088: mov $offset_result,%esi ! 1089: call push_5_dw_at_esi ! 1090: call subadd ! 1091: call post_op_round ! 1092: lea result_dword_frac(%ebp),%esi ! 1093: lea dword_frac2(%ebp),%edi ! 1094: call move_op_to_op ! 1095: mov $offset_operand1,%esi ! 1096: call pop_5_dw_at_esi ! 1097: call divid // floating-point divide ! 1098: call post_op_round ! 1099: exp_neg_core_exit: ! 1100: ret ! 1101: ! 1102: //neg_exp_core endp ! 1103: // ********************************************************************** ! 1104: ALIGN ! 1105: exp: //proc ! 1106: call one_result_op1_chk ! 1107: jnz exp_non_zero ! 1108: garb_out: ! 1109: jmp put_op1_result ! 1110: ALIGN ! 1111: // ! 1112: exp_non_zero: ! 1113: cmpl $0x3fff,dword_expon1 ! 1114: jg garb_out ! 1115: jl more_than_half_ ! 1116: more_than_1_: ! 1117: cmpl $0x080000000,dword_frac1+frac32(%ebp) ! 1118: ja garb_out ! 1119: cmp $0,dword_frac1+frac64(%ebp) ! 1120: jne garb_out ! 1121: cmpb positive,sign1(%ebp) ! 1122: je garb_out // answer is 1, already in op1 ! 1123: decl dword_expon1 ! 1124: jmp garb_out // answer is -1/2. ! 1125: ALIGN ! 1126: more_than_half_: ! 1127: orb $inexact_mask,%gs:sr_errors // set inexact error flag ! 1128: push %gs:sr_masks // save precision control ! 1129: orl $0x0300,%gs:sr_masks // set precision control to prec64 ! 1130: andl $0x0fffff3ff,%gs:sr_masks // set rc = to_nearest ! 1131: cmpl $0x3ffe,dword_expon1 ! 1132: je maybe_half ! 1133: cmpb positive,sign1(%ebp) ! 1134: jne tween_neg_half_and_0 ! 1135: jmp tween_0_and_half ! 1136: ALIGN ! 1137: maybe_half: ! 1138: cmpl $0x080000000,dword_frac1+frac32(%ebp) ! 1139: ja tween_half_and_1 ! 1140: cmp $0,dword_frac1+frac64(%ebp) ! 1141: jne tween_half_and_1 ! 1142: cmpb positive,sign1(%ebp) ! 1143: jne tween_neg_half_and_0 ! 1144: tween_0_and_half: ! 1145: call exp_core ! 1146: // ! 1147: //error checking ! 1148: // ! 1149: exp_uflow_: ! 1150: mov dword_result_expon,%ecx ! 1151: cmp $0,%ecx ! 1152: jle exp_underflow ! 1153: movb valid,result_tag(%ebp) //valid result ! 1154: jmp exp_exit ! 1155: ALIGN ! 1156: exp_underflow: ! 1157: call underflow_response ! 1158: orb underflow_mask,%gs:sr_errors ! 1159: exp_exit: ! 1160: cmpb true,added_one ! 1161: jne exp_restore ! 1162: orb $a_mask,%gs:sr_flags ! 1163: exp_restore: ! 1164: pop %gs:sr_masks // restore precision and rounding controls ! 1165: mov $offset_result,%edi ! 1166: jmp put_si_result ! 1167: ALIGN ! 1168: tween_neg_half_and_0: ! 1169: call neg_exp_core ! 1170: jmp exp_uflow_ ! 1171: ALIGN ! 1172: tween_half_and_1: ! 1173: cmpb positive,sign1(%ebp) ! 1174: jne tween_neg_1_and_neg_half ! 1175: mov $offset_operand2,%esi ! 1176: call move_unpacked_1_to_esi ! 1177: movb $sub_op,operation_type(%ebp) ! 1178: call subadd ! 1179: call post_op_round ! 1180: lea result_dword_frac(%ebp),%esi ! 1181: lea dword_frac1(%ebp),%edi ! 1182: call move_op_to_op ! 1183: call neg_exp_core ! 1184: lea result_dword_frac(%ebp),%esi ! 1185: lea dword_frac1(%ebp),%edi ! 1186: call move_op_to_op ! 1187: mov $offset_operand2,%esi ! 1188: call move_unpacked_1_to_esi ! 1189: movb $add_op,operation_type(%ebp) ! 1190: call subadd ! 1191: call post_op_round ! 1192: incl dword_result_expon ! 1193: lea result_dword_frac(%ebp),%esi ! 1194: lea dword_frac1(%ebp),%edi ! 1195: call move_op_to_op ! 1196: mov $offset_operand2,%esi ! 1197: call move_unpacked_1_to_esi ! 1198: movb $sub_op,operation_type(%ebp) ! 1199: call subadd ! 1200: call post_op_round ! 1201: jmp exp_exit ! 1202: ALIGN ! 1203: tween_neg_1_and_neg_half: ! 1204: mov $offset_operand2,%esi ! 1205: call move_unpacked_1_to_esi ! 1206: movb $add_op,operation_type(%ebp) ! 1207: call subadd ! 1208: call post_op_round ! 1209: lea result_dword_frac(%ebp),%esi ! 1210: lea dword_frac1(%ebp),%edi ! 1211: call move_op_to_op ! 1212: call exp_core ! 1213: lea result_dword_frac(%ebp),%esi ! 1214: lea dword_frac1(%ebp),%edi ! 1215: call move_op_to_op ! 1216: mov $offset_operand2,%esi ! 1217: call move_unpacked_1_to_esi ! 1218: movb $add_op,operation_type(%ebp) ! 1219: call subadd ! 1220: call post_op_round ! 1221: lea result_dword_frac(%ebp),%esi ! 1222: lea dword_frac1(%ebp),%edi ! 1223: call move_op_to_op ! 1224: decl dword_expon1 ! 1225: mov $offset_operand2,%esi ! 1226: call move_unpacked_1_to_esi ! 1227: movb $sub_op,operation_type(%ebp) ! 1228: call subadd ! 1229: call post_op_round ! 1230: jmp exp_exit ! 1231: ALIGN ! 1232: ! 1233: //exp endp ! 1234: // *********************************************************************** ! 1235: // ! 1236: // *************************************************************************** ! 1237: // log: ! 1238: // *** ! 1239: // function: ! 1240: // calculates y times log(x) or y times log(1 + x). ! 1241: // ! 1242: // inputs: ! 1243: // assumes that operand1 and operand2 are set up; ! 1244: // op1 = x, op2 = y. ! 1245: // ! 1246: // outputs: ! 1247: // possible underflow, overflow, or inexact errors ! 1248: // ! 1249: // data accessed: ! 1250: // - operation_type offset_result_rec ! 1251: // - sign1 expon1 ! 1252: // - offset_operand1 offset_operand2 ! 1253: // - tag2 sign2 ! 1254: // - expon2 word_frac2 ! 1255: // - msb_frac2 offset_operand2 ! 1256: // - offset_result result_tag ! 1257: // - result_sign result_expon ! 1258: // - result_word_frac msb_result ! 1259: // - msb_result offset_result ! 1260: // - result2_tag result2_sign ! 1261: // - msb_result2 log_loop_ct ! 1262: // - offset_cop offset_dop ! 1263: // - siso ! 1264: // ! 1265: // data changed: ! 1266: // - sign1 sign2 ! 1267: // - msb_frac2 word_frac2 ! 1268: // - result_tag result_sign ! 1269: // - result_frac offset_result ! 1270: // - result2_tag result2_sign ! 1271: // - msb_result2 log_loop_ct ! 1272: // - siso ! 1273: // ! 1274: // procedures called: ! 1275: // put_result right_shift left_shift ! 1276: // move_10_bytes move_constant addx ! 1277: // subx mulx accel_divx (for log_divx) ! 1278: // one_left_normalize addition_normalize log_constant ! 1279: // test_5w subtraction_normalize test_4w ! 1280: // underflow_response overflow_response decompose ! 1281: // pop_free sp_subadd mult ! 1282: // round get_precision set_p_error ! 1283: // ! 1284: // *********************************************************************** ! 1285: ALIGN ! 1286: log: //proc ! 1287: movb valid,result2_tag(%ebp) ! 1288: jmp log_entry ! 1289: ALIGN ! 1290: splog: ! 1291: movb special,result2_tag(%ebp) // flag for special log ! 1292: log_entry: ! 1293: push %gs:sr_masks // save precision control ! 1294: // and dword ptr %gs:sr_masks, 0fffff3ffh; set rounding control to nearest ! 1295: orl $0x0300,%gs:sr_masks // set precision control to prec64 ! 1296: mov $offset_cop+frac80,%edi ! 1297: call move_frac2 // temp store y, cop <- frac(y) ! 1298: movb tag2(%ebp),%al ! 1299: movb %al,lsb_cop ! 1300: mov dword_expon2,%eax // log_loop_ct <- expo(y) ! 1301: mov %eax,log_loop_ct ! 1302: movb sign2(%ebp),%al // lsb_result2 <- sign2 ! 1303: movb %al,lsb_result2 ! 1304: movb positive,result2_sign(%ebp)// used for sign of result ! 1305: cmpb valid,result2_tag(%ebp) // after log core ! 1306: jnz log_special_log // result sign same as result2 ! 1307: call right_shift_frac1_8 ! 1308: mov $constant_sqrt_of_2,%esi ! 1309: call sub_frac2 ! 1310: cmpb $0,msb_result ! 1311: jne log_small_lg ! 1312: jmp log_large_lg ! 1313: ALIGN ! 1314: log_sp_negative_x: ! 1315: call move_frac1_result ! 1316: movb negative,result2_sign(%ebp) ! 1317: jmp log_core ! 1318: ALIGN ! 1319: log_special_log: ! 1320: // mov edi, offset_operand1 ; weed out the special case ! 1321: // call test_6w ; where x = 0. result should ! 1322: // jz log_splog_zero ; be exact signed zero. ! 1323: mov dword_expon1,%eax // log x not 0 ! 1324: mov %eax,dword_result_expon ! 1325: cmpb positive,sign1(%ebp) ! 1326: jne log_sp_negative_x ! 1327: call move_frac1_frac2 ! 1328: mov $0x3fff,%ecx ! 1329: sub dword_expon1,%ecx ! 1330: cmp $72,%ecx ! 1331: jbe log_sp_label_1 ! 1332: mov $72,%ecx ! 1333: log_sp_label_1: ! 1334: call right_shift_frac2_cl ! 1335: movw word_frac2,%cx ! 1336: and $0x1fff,%ecx ! 1337: or %ecx,%edx ! 1338: jz log_non_sticky ! 1339: orw $0x2000,word_frac2 ! 1340: log_non_sticky: ! 1341: orb $0x80,msb_frac2 ! 1342: andl $0x0e0000000,dword_frac2(%ebp) ! 1343: jmp log_div ! 1344: ALIGN ! 1345: // ! 1346: // frac(x) < sqrt(2) ! 1347: // ! 1348: log_small_lg: ! 1349: call left_shift_frac1_8 ! 1350: call move_frac1_result ! 1351: mov $1,%ecx ! 1352: call left_shift_result_cl ! 1353: mov $offset_result+frac80,%edi ! 1354: call test_5w ! 1355: jz log_power_of_two ! 1356: movl $0x3ffe,dword_result_expon ! 1357: mov $offset_result,%edi ! 1358: call subtraction_normalize ! 1359: call move_frac1_frac2 ! 1360: call move_result_frac1 ! 1361: log_div: ! 1362: // the following call used to be to log_divx instead of accel_divx: ! 1363: push log_loop_ct ! 1364: call accel_divx ! 1365: pop log_loop_ct ! 1366: andl $0x0e0000000,result_dword_frac(%ebp)// mask result frac ! 1367: jmp log_merge_lg ! 1368: ALIGN ! 1369: // ! 1370: // x = 2 ** n ! 1371: // ! 1372: log_power_of_two: ! 1373: call decompose ! 1374: log_mul: ! 1375: mov $offset_operand1+frac80,%edi ! 1376: call test_5w ! 1377: jnz log_x_not_0 ! 1378: // call log_round ; round the result ! 1379: log_splog_zero: ! 1380: movb special,tag1(%ebp) // zero tag ! 1381: movb lsb_result2,%al ! 1382: xorb %al,sign1(%ebp) ! 1383: lea dword_frac1(%ebp),%esi ! 1384: lea result_dword_frac(%ebp),%edi ! 1385: call move_op_to_op ! 1386: jmp log_restore_user_controls ! 1387: ALIGN ! 1388: log_x_not_0: ! 1389: // cmp lsb_cop, special ! 1390: // jne log_y_not_zero ! 1391: // ! 1392: //y=0 ! 1393: // ! 1394: // xor eax, eax ! 1395: // mov edi, offset result_dword_frac + 4 ! 1396: // call set_4w ! 1397: // mov dword_result_expon, eax ! 1398: // mov dword ptr (ebp).result_sign, special*10000h ! 1399: // mov al, (ebp).sign1 ! 1400: // xor al, lsb_result2 ! 1401: // mov (ebp).result_sign, al ! 1402: // jmp short log_finish_up ! 1403: //log_y_not_zero: ! 1404: andl $0x0ff000000,dword_cop(%ebp) ! 1405: call move_cop_frac2 // restore y into op2 ! 1406: mov log_loop_ct,%eax ! 1407: mov %eax,dword_expon2 ! 1408: movb lsb_result2,%al ! 1409: movb %al,sign2(%ebp) ! 1410: call mult ! 1411: call post_op_round // round the result ! 1412: // ! 1413: //error checking ! 1414: // ! 1415: mov dword_result_expon,%eax ! 1416: cmp $0x7ffe,%eax ! 1417: jg log_overflow ! 1418: cmp $0,%eax ! 1419: jl log_underflow ! 1420: jg log_set_tag_valid ! 1421: mov $offset_result+frac64,%edi ! 1422: call test_4w // eax = 0 here ! 1423: jnz log_underflow ! 1424: // ! 1425: //zero result ! 1426: // ! 1427: movb special,result_tag(%ebp) ! 1428: jmp log_round_report ! 1429: ALIGN ! 1430: log_set_tag_valid: ! 1431: movb valid,result_tag(%ebp) ! 1432: log_round_report: ! 1433: cmpw $0,rnd_history ! 1434: je log_restore_user_controls ! 1435: orb $inexact_mask,%gs:sr_errors ! 1436: cmpb true,added_one ! 1437: jne log_restore_user_controls ! 1438: orb $a_mask,%gs:sr_flags ! 1439: log_restore_user_controls: ! 1440: pop %gs:sr_masks ! 1441: log_exit: ! 1442: ret ! 1443: ALIGN ! 1444: // ! 1445: log_overflow: ! 1446: call overflow_response ! 1447: jmp log_restore_user_controls ! 1448: ALIGN ! 1449: log_underflow: ! 1450: call underflow_response ! 1451: jmp log_restore_user_controls ! 1452: ALIGN ! 1453: // ! 1454: //frac(x) > sqrt(2) ! 1455: // ! 1456: log_large_lg: ! 1457: incl dword_expon1 ! 1458: call move_frac1_frac2 ! 1459: mov $constant_one,%esi ! 1460: call sub_frac1 ! 1461: mov $7,%ecx ! 1462: call left_shift_result_cl ! 1463: movb negative,result2_sign(%ebp) // set flag for large log ! 1464: movl $0x3fff,dword_result_expon ! 1465: log_merge_lg: ! 1466: mov $offset_result+frac80,%edi // dont normalize a zero ! 1467: call test_5w // is the result zero? ! 1468: jz log_core // yes, no need to normalize ! 1469: mov $offset_result,%edi ! 1470: call subtraction_normalize ! 1471: log_core: ! 1472: call move_result_frac2 ! 1473: movw $0,siso // clear siso ! 1474: mov $0x3fff,%eax ! 1475: sub dword_result_expon,%eax ! 1476: mov %eax,dword_exp_tmp ! 1477: cmp $15,%eax ! 1478: ja log_rat_apx ! 1479: call move_result_frac1 // log pseudo divide ! 1480: mov $7,%ecx ! 1481: add dword_exp_tmp,%ecx ! 1482: call right_shift_frac1_cl ! 1483: call right_shift_frac2_8 ! 1484: call addx ! 1485: cmpb $0,msb_result ! 1486: je log_loop_back_1 ! 1487: andl $0x0ffe00000,result_dword_frac(%ebp) ! 1488: movb $0,msb_result ! 1489: call move_result_frac2 ! 1490: movw $1,siso ! 1491: log_loop_back_1: ! 1492: shlw $1,siso ! 1493: call move_frac2_frac1 ! 1494: mov dword_exp_tmp,%ecx ! 1495: call right_shift_frac1_cl ! 1496: orl $0x00800000,dword_frac1+frac32(%ebp) ! 1497: call addx ! 1498: cmpb $0,msb_result ! 1499: je log_merge_2 ! 1500: andl $0x0ffe00000,result_dword_frac(%ebp) ! 1501: movb $0,msb_result ! 1502: call move_result_frac2 ! 1503: incw siso ! 1504: log_merge_2: ! 1505: mov $1,%ecx ! 1506: call left_shift_frac2_cl ! 1507: incl dword_exp_tmp ! 1508: cmp $15,dword_exp_tmp ! 1509: jbe log_loop_back_1 ! 1510: call left_shift_frac2_8 ! 1511: // ! 1512: //rational approximation ! 1513: // ! 1514: log_rat_apx: ! 1515: orb $inexact_mask,%gs:sr_errors // set p flag ! 1516: call move_frac2_frac1 ! 1517: call mulx ! 1518: mov dword_exp_tmp,%ecx ! 1519: cmp $72,%ecx ! 1520: jbe log_label_4 ! 1521: mov $72,%ecx ! 1522: log_label_4: ! 1523: call right_shift_result_cl ! 1524: andl $0x0e0000000,result_dword_frac(%ebp)// mask result frac ! 1525: call move_result_frac2 ! 1526: call subx ! 1527: call move_result_dop ! 1528: mov dword_exp_tmp,%ecx ! 1529: cmp $72,%ecx ! 1530: jbe log_label_5 ! 1531: mov $72,%ecx ! 1532: log_label_5: ! 1533: call right_shift_frac1_cl ! 1534: andl $0x0e0000000,dword_frac1(%ebp) ! 1535: call move_frac1_frac2 ! 1536: mov $constant_six,%esi ! 1537: call sub_frac1 ! 1538: call move_result_frac1 ! 1539: call move_dop_frac2 ! 1540: mov dword_exp_tmp,%ecx ! 1541: inc %ecx ! 1542: cmp $72,%ecx ! 1543: jbe log_label_6 ! 1544: mov $72,%ecx ! 1545: log_label_6: ! 1546: call right_shift_frac2_cl ! 1547: andl $0x0f0000000,dword_frac2(%ebp) ! 1548: call subx ! 1549: andl $0x0e0000000,result_dword_frac(%ebp)// mask result frac ! 1550: call move_dop_frac1 ! 1551: call move_result_frac2 ! 1552: // the following call used to be to log_divx instead of accel_divx: ! 1553: push log_loop_ct ! 1554: call accel_divx ! 1555: pop log_loop_ct ! 1556: andl $0x0e0000000,result_dword_frac(%ebp)// mask result frac ! 1557: call move_result_frac1 ! 1558: mov $constant_3_ov_ln2,%esi ! 1559: call mul_frac2 ! 1560: mov $7,%ecx ! 1561: call right_shift_result_cl ! 1562: decl dword_exp_tmp ! 1563: log_loop_back_2: ! 1564: shrw $1,siso ! 1565: jnb log_no_carry ! 1566: mov dword_exp_tmp,%esi ! 1567: dec %esi ! 1568: mov $10,%eax ! 1569: mul %esi ! 1570: mov %eax,%esi ! 1571: add $log_constant,%esi ! 1572: call move_constant_frac2 ! 1573: call move_result_frac1 ! 1574: call addx ! 1575: log_no_carry: ! 1576: cmpw $0,siso ! 1577: jz log_end_loop ! 1578: call right_shift_result_1 ! 1579: decl dword_exp_tmp ! 1580: jmp log_loop_back_2 ! 1581: ALIGN ! 1582: log_end_loop: ! 1583: mov $0x4007,%eax //4007 = 3fff + 8 ! 1584: sub dword_exp_tmp,%eax ! 1585: mov %eax,dword_result_expon ! 1586: andl $0x0ffe00000,result_dword_frac(%ebp) ! 1587: mov $offset_result,%edi // dont normalize a zero ! 1588: call test_6w // is the result zero? ! 1589: jz log_end_log_core // yes, no need to normalize ! 1590: mov $offset_result,%edi ! 1591: call subtraction_normalize ! 1592: log_end_log_core: ! 1593: cmpb valid,result2_tag(%ebp) ! 1594: jnz log_special_log_end ! 1595: call decompose ! 1596: call move_result_frac2 ! 1597: mov dword_result_expon,%eax ! 1598: mov %eax,dword_expon2 ! 1599: movb $add_op,operation_type(%ebp) ! 1600: movb result2_sign(%ebp),%al ! 1601: movb %al,sign2(%ebp) ! 1602: call sp_subadd ! 1603: log_merge_4: ! 1604: call move_result_frac1 ! 1605: movb result_sign(%ebp),%al ! 1606: movb %al,sign1(%ebp) ! 1607: mov dword_result_expon,%eax ! 1608: mov %eax,dword_expon1 ! 1609: jmp log_mul ! 1610: ALIGN ! 1611: log_special_log_end: ! 1612: movb result2_sign(%ebp),%al ! 1613: movb %al,result_sign(%ebp) ! 1614: jmp log_merge_4 ! 1615: ALIGN ! 1616: // ! 1617: //do round ; made into common subroutine for all ! 1618: // ! 1619: log_round: ! 1620: movb $1,lsb_result // fixed up such that ! 1621: // call get_precision ! 1622: post_op_round: ! 1623: movb prec64,%dl ! 1624: mov $offset_result,%edi // s = 1 always ! 1625: movb false,%al // not second rounding ! 1626: call round ! 1627: mov $offset_result,%edi ! 1628: movb $4,%ah // fall through ! 1629: //log endp ! 1630: // ! 1631: // ! 1632: // addition_normalize: ! 1633: // ! 1634: // function: ! 1635: // performs normalization after addition if necessary. ! 1636: // ! 1637: // inputs: ! 1638: // carry-out from addition in al upon entry. ! 1639: // fraction offset in di. ! 1640: // ! 1641: // outputs: ! 1642: // increments exponent and shifts 1 bit in from left if al=1. ! 1643: // ! 1644: // data accessed: ! 1645: // ! 1646: // data changed: ! 1647: // ! 1648: // procedures called: ! 1649: // sticky_right_shift ! 1650: // ! 1651: // ************************************************************************* ! 1652: FALLSTHRU ! 1653: addition_normalize: //proc ! 1654: testb $0x01,%al //if low bit of al = 1, ! 1655: jnz right_shift_1 // then shift right 1 ! 1656: ret // else, exit ! 1657: ALIGN ! 1658: right_shift_1: ! 1659: incl expon(%ebp,%edi) //increment exponent ! 1660: movb $1,%cl //shift right 1 bit ! 1661: //addition_normalize endp ; sticky_right_shift ! 1662: // ! 1663: // *********************************************************************** ! 1664: // sticky_right_shift: ! 1665: // ****************** ! 1666: // function: ! 1667: // shifts a 10-byte number right by amount in ! 1668: // cl register. di contains offset of number. ! 1669: // ! 1670: // inputs: ! 1671: // low bit of al contains bit to inject from left. ! 1672: // (for shifts of more than one, the result is undefined ! 1673: // unless al contains zero). ! 1674: // ! 1675: // outputs: ! 1676: // the low-order bit of the number is *sticky*, ie, it is ! 1677: // left as a one if any ones were shifted out. ! 1678: // ! 1679: // data accessed: ! 1680: // ! 1681: // data changed: ! 1682: // ! 1683: // procedures called: ! 1684: // right_shift ! 1685: // ! 1686: // *************************************************************************** ! 1687: FALLSTHRU ! 1688: sticky_right_shift: //proc ! 1689: call right_shift //do right shift ! 1690: and %edx,%edx //edx <> 0 if 1s lost ! 1691: jz sticky_right_shift_done //done if no 1s lost ! 1692: orb $0x01,frac80(%ebp,%edi) //else, set sticky bit ! 1693: sticky_right_shift_done: ! 1694: ret ! 1695: //sticky_right_shift endp ! 1696: // ! 1697: // ************************************************************************ ! 1698: // gradual_underflow: ! 1699: // ! 1700: // function: ! 1701: // changes an *underflowed* number to a legal, ! 1702: // denormalized number. ! 1703: // ! 1704: // input: ! 1705: // address of exponent and fraction in operands or result ! 1706: // (ptr in di register); minimum legal exponent(in ! 1707: // ax register). ! 1708: // ! 1709: // output: ! 1710: // denormalized fraction and adjusted exponent (in input ! 1711: // record) ! 1712: // ! 1713: // data accessed:; - expon word_frac ! 1714: // ! 1715: // data changed: ! 1716: // - expon word_frac ! 1717: // ! 1718: // procedures called: ! 1719: // sticky_right_shift ! 1720: // ! 1721: // *********************************************************************** ! 1722: ALIGN ! 1723: gradual_underflow: //proc ! 1724: mov %eax,%ecx // set exponent to minimum ! 1725: xchg expon(%ebp,%edi),%eax ! 1726: sub %eax,%ecx // form shift amount ! 1727: cmp $67,%ecx // (exponent - minimum exponent) ! 1728: jle do_right_shift ! 1729: mov $67,%ecx // shift amount must be <= 67 ! 1730: do_right_shift: ! 1731: xorb %al,%al // byte to be shifted in from ! 1732: jmp sticky_right_shift // the left ! 1733: ALIGN ! 1734: //gradual_underflow endp ! 1735: ! 1736: ! 1737: // ****************************************************************************** ! 1738: // two_result_op1_chk ! 1739: // ! 1740: // action: ! 1741: // for sincos and (two result) tan, checks the following and responds as ! 1742: // described: ! 1743: // 1. whether fetch_an_op discovered that the source from which ! 1744: // operand1 was to have been taken was empty. if so, sets stack ! 1745: // underflow exception, clears c-flag (indicating not incomplete ! 1746: // reduction), pops the return address of its caller so that it ! 1747: // returns directly to the e80387 executive routine, and, if the ! 1748: // invalid exception is unmasked, makes that return forthwith. ! 1749: // if the invalid exception is masked, this procedure prepares to ! 1750: // return via a jump to put_result by first setting edi so that ! 1751: // the nan indefinite put in operand1 by fetch_an_op will be ! 1752: // returned, and setting esi so that this returned value will be ! 1753: // pushed onto the stack. note that after this push, the former ! 1754: // stack top is unchanged; i.e., if it was empty as stack top, its ! 1755: // still empty as st(1). ! 1756: // 2. if operand1 was fetched from a non-empty source, clears ! 1757: // c-flag (indicating not incomplete reduction) and then checks ! 1758: // whether a push will be to a full position. if so, sets zf so ! 1759: // that return to e80387 executive after popping callers return ! 1760: // address and jumping to put_result does not falsely signal ! 1761: // masked stack underflow instead of correctly signaling stack ! 1762: // overflow. ! 1763: // 3. if push would be to an empty position, initializes the ! 1764: // before_error_signals used by put_result, clears the a-flag, ! 1765: // and checks tag of operand1. ! 1766: // a. if tag is unsupp or infinty, replaces operand1 by ! 1767: // the nan indefinite, then checks whether invalid operation ! 1768: // is masked. if not masked, sets invalid operation exception ! 1769: // flag and pops callers return address so that return is to ! 1770: // e80387 executive. if masked, copies the quiet nan in ! 1771: // operand1 to operand2, sets the signal_i_error? component of ! 1772: // before_error_signals to true, and returns to e80387 ! 1773: // executive by popping callers return address and jumping to ! 1774: // do_exchange. ! 1775: // b. if tag is inv, checks whether the nan in operand1 is ! 1776: // signaling. if not, sets zf, pops callers return address, ! 1777: // sets edi and esi so that jump to put_result causes the ! 1778: // quiet nan in operand1 to be pushed onto 87 stack. if the ! 1779: // nan is signaling, sets its leading fraction bit, thereby ! 1780: // *quieting* it, and proceeds as in *a* above, but with the ! 1781: // *quietized* nan in place of the nan indefinite. ! 1782: // c. if tag is denormd, checks whether denormal exception ! 1783: // is masked. if not masked, sets denormal exception flag and ! 1784: // pops callers return address so that return is to e80387 ! 1785: // executive. if masked, sets the signal_d_error component of ! 1786: // before_error_signals to true, normalizes operand1 and forces ! 1787: // zf = 0 (indicating non-zero operand1) before returning to ! 1788: // caller. ! 1789: // d. if tag is valid or special (signed, true zero), returns ! 1790: // to caller with zf clear or set, respectively. ! 1791: // ! 1792: // ! 1793: // **************************************************************************** ! 1794: ALIGN ! 1795: two_result_op1_chk: //proc ! 1796: jz is_stack_full_ // if no stack underflow, go on ! 1797: call set_stk_u_error // else, prepare for error exit ! 1798: andb $~c_mask,%gs:sr_flags // clear 87 c-flag ! 1799: testb invalid_mask,%gs:sr_masks ! 1800: jnz push_op1 // masked stack error, so return indef ! 1801: unmasked_exit: ! 1802: pop %eax // pop address of transcendental caller so ! 1803: two_res_quik_exit: // return is to e80387 executive procedure. ! 1804: ret ! 1805: ALIGN ! 1806: push_op1: ! 1807: mov $offset_operand1,%edi ! 1808: mov offset_result2_rec,%esi ! 1809: pop %eax // pop address of transcendental caller ! 1810: lahf // save zf to show if masked stack underflow ! 1811: jmp put_result // return is to e80387 executive procedure. ! 1812: ALIGN ! 1813: is_stack_full_: ! 1814: andb $~c_mask,%gs:sr_flags // clear 87 c-flag ! 1815: call stack_full_ ! 1816: jz cntnu_chk ! 1817: set_zf: ! 1818: xor %eax,%eax ! 1819: jmp push_op1 ! 1820: ALIGN ! 1821: cntnu_chk: ! 1822: movl $0,before_error_signals(%ebp) ! 1823: andb $~a_mask,%gs:sr_flags ! 1824: movb tag1(%ebp),%al // load tag for op1 ! 1825: cmpb special,%al ! 1826: jbe ok_op ! 1827: cmpb denormd,%al ! 1828: jb inv_op ! 1829: je signal_d_error // elsif denormalized, then signal d_error ! 1830: mov $offset_operand1,%edi // infinity or unsupported, ! 1831: call set_up_indefinite // set up masked result ! 1832: jmp test_invalid_mask ! 1833: ALIGN ! 1834: inv_op: ! 1835: testb $0x40,msb_frac1 // elsif op1 nan, find what kind ! 1836: jnz set_zf // op1 is a qnan, so load it to tos ! 1837: orb $0x40,msb_frac1 // make nan quiet ! 1838: test_invalid_mask: ! 1839: testb invalid_mask,%gs:sr_masks ! 1840: jnz copy_nan ! 1841: orb invalid_mask,%gs:sr_errors ! 1842: jmp unmasked_exit ! 1843: ALIGN ! 1844: copy_nan: ! 1845: lea dword_frac1(%ebp),%esi // copy op1 to op2 ! 1846: lea dword_frac2(%ebp),%edi ! 1847: call move_op_to_op ! 1848: signal_i_error: ! 1849: movb true,signal_i_error_ ! 1850: pop %eax ! 1851: jmp do_exchange ! 1852: ALIGN ! 1853: signal_d_error: ! 1854: testb denorm_mask,%gs:sr_masks ! 1855: jnz set_up_d_error ! 1856: orb denorm_mask,%gs:sr_errors ! 1857: jmp unmasked_exit ! 1858: ALIGN ! 1859: set_up_d_error: ! 1860: movb true,signal_d_error_// op1 is denormal or pseudo-denormal ! 1861: mov $offset_operand1,%edi ! 1862: call norm_denorm // if d_error masked, make valid ! 1863: or $1,%eax // force zf = 0 ! 1864: ok_op: ! 1865: ret // zf = 1 iff op1 is true zero ! 1866: ! 1867: //two_result_op1_chk endp ! 1868: // ! 1869: // ****************************************************************************** ! 1870: // one_result_op1_chk ! 1871: // ! 1872: // action: ! 1873: // for sin and cos, checks the following and responds as ! 1874: // described: ! 1875: // 1. whether fetch_an_op discovered that the source from which ! 1876: // operand1 was to have been taken was empty. if so, sets stack ! 1877: // underflow exception, clears c-flag (indicating not incomplete ! 1878: // reduction), pops the return address of its caller so that it ! 1879: // returns directly to the e80387 executive routine, and, if the ! 1880: // invalid exception is unmasked, makes that return forthwith. ! 1881: // if the invalid exception is masked, this procedure prepares to ! 1882: // return via a jump to put_result by first setting edi so that ! 1883: // the nan indefinite put in operand1 by fetch_an_op will be ! 1884: // returned, and setting esi so that this returned value will be ! 1885: // pushed onto the stack. note that after this push, the former ! 1886: // stack top is unchanged; i.e., if it was empty as stack top, its ! 1887: // still empty as st(1). ! 1888: // 2. if operand1 was fetched from a non-empty source, clears ! 1889: // c-flag (indicating not incomplete reduction) and then checks ! 1890: // whether a push will be to a full position. if so, sets zf so ! 1891: // that return to e80387 executive after popping callers return ! 1892: // address and jumping to put_result does not falsely signal ! 1893: // masked stack underflow instead of correctly signaling stack ! 1894: // overflow. ! 1895: // 3. if push would be to an empty position, initializes the ! 1896: // before_error_signals used by put_result, clears the a-flag, ! 1897: // and checks tag of operand1. ! 1898: // a. if tag is unsupp or infinty, replaces operand1 by ! 1899: // the nan indefinite, then checks whether invalid operation ! 1900: // is masked. if not masked, sets invalid operation exception ! 1901: // flag and pops callers return address so that return is to ! 1902: // e80387 executive. if masked, copies the quiet nan in ! 1903: // operand1 to operand2, sets the signal_i_error? component of ! 1904: // before_error_signals to true, and returns to e80387 ! 1905: // executive by popping callers return address and jumping to ! 1906: // do_exchange. ! 1907: // b. if tag is inv, checks whether the nan in operand1 is ! 1908: // signaling. if not, sets zf, pops callers return address, ! 1909: // sets edi and esi so that jump to put_result causes the ! 1910: // quiet nan in operand1 to be pushed onto 87 stack. if the ! 1911: // nan is signaling, sets its leading fraction bit, thereby ! 1912: // *quieting* it, and proceeds as in *a* above, but with the ! 1913: // *quietized* nan in place of the nan indefinite. ! 1914: // c. if tag is denormd, checks whether denormal exception ! 1915: // is masked. if not masked, sets denormal exception flag and ! 1916: // pops callers return address so that return is to e80387 ! 1917: // executive. if masked, sets the signal_d_error component of ! 1918: // before_error_signals to true, normalizes operand1 and forces ! 1919: // zf = 0 (indicating non-zero operand1) before returning to ! 1920: // caller. ! 1921: // d. if tag is valid or special (signed, true zero), returns ! 1922: // to caller with zf clear or set, respectively. ! 1923: // ! 1924: // ! 1925: // **************************************************************************** ! 1926: ALIGN ! 1927: one_result_op1_chk: //proc ! 1928: jz check_tag1 // if no stack underflow, go on ! 1929: call set_stk_u_error // else, prepare for error exit ! 1930: andb $~c_mask,%gs:sr_flags // clear 87 c-flag ! 1931: testb invalid_mask,%gs:sr_masks ! 1932: jnz give_op1 // masked stack error, so return indef ! 1933: one_res_unmasked_exit: ! 1934: pop %eax // pop address of transcendental caller so ! 1935: one_res_quik_exit: // return is to e80387 executive procedure. ! 1936: ret ! 1937: ALIGN ! 1938: give_op1: ! 1939: pop %eax // pop address of transcendental caller so ! 1940: jmp put_op1_result // return is to e80387 executive procedure. ! 1941: ALIGN ! 1942: check_tag1: ! 1943: andb $~(a_mask+c_mask),%gs:sr_flags ! 1944: movb tag1(%ebp),%al // load tag for op1 ! 1945: cmpb special,%al ! 1946: jle op1_ok ! 1947: cmpb denormd,%al ! 1948: jl op1_inv ! 1949: je op1_den // elsif denormalized, then signal d_error ! 1950: cmpb $exp_op,operation_type(%ebp) ! 1951: jne one_res_unsup ! 1952: cmpb unsupp,%al ! 1953: je one_res_unsup ! 1954: cmpb positive,sign1(%ebp) // op1 is +/- infinity ! 1955: je give_op1 ! 1956: movl $0x3fff,dword_expon1 ! 1957: jmp give_op1 ! 1958: ALIGN ! 1959: one_res_unsup: ! 1960: mov $offset_operand1,%edi // infinity or unsupported, ! 1961: call set_up_indefinite // set up masked result ! 1962: jmp invalid_masked_ ! 1963: ALIGN ! 1964: op1_inv: ! 1965: testb $0x40,msb_frac1 // elsif op1 nan, find what kind ! 1966: jnz give_op1 // op1 is a qnan, so return it ! 1967: orb $0x40,msb_frac1 // make nan quiet ! 1968: invalid_masked_: ! 1969: orb invalid_mask,%gs:sr_errors ! 1970: testb invalid_mask,%gs:sr_masks ! 1971: jz one_res_unmasked_exit ! 1972: jmp give_op1 ! 1973: ALIGN ! 1974: op1_den: ! 1975: orb denorm_mask,%gs:sr_errors ! 1976: testb denorm_mask,%gs:sr_masks ! 1977: jz one_res_unmasked_exit ! 1978: mov $offset_operand1,%edi ! 1979: call norm_denorm // if d_error masked, make valid ! 1980: or $1,%eax // force zf = 0 ! 1981: op1_ok: ! 1982: ret // zf = 1 iff op1 is true zero ! 1983: ! 1984: //one_result_op1_chk endp ! 1985: // **************************************************************************** ! 1986: ALIGN ! 1987: mod_qrtr_pi: //proc ! 1988: // 87 c-flag has been cleared by this point ! 1989: xor %eax,%eax ! 1990: movb operation_type(%ebp),%al ! 1991: movb sign1(%ebp),%ah ! 1992: mov %eax,trans_info // initialize cofunc_flag false (00h) ! 1993: // and cos_sign positive (00h) ! 1994: movb positive,sign1(%ebp)// take absolute value of op1 ! 1995: movw $0,exp_tmp // initialize q and hi_q to 0. ! 1996: mov dword_expon1,%eax ! 1997: sub $0x3ffe,%eax ! 1998: jl reduction_done ! 1999: cmp $63,%eax ! 2000: jle do_reduction ! 2001: orb $c_mask,%gs:sr_flags // indicate incomplete reduction ! 2002: pop %eax // get rid of callers return address ! 2003: ret ! 2004: ALIGN ! 2005: do_reduction: ! 2006: movl $0x2168c235,dword_frac2+frac64(%ebp) ! 2007: movl $0x0c90fdaa2,dword_frac2+frac32(%ebp) ! 2008: movl $0x10000*VALID+POSITIVE,dword_frac2+sign(%ebp) ! 2009: movl $0x3ffe,dword_expon2 ! 2010: sub %eax,dword_expon1 ! 2011: inc %eax ! 2012: call remrx ! 2013: mov dword_frac1+frac64(%ebp),%eax ! 2014: or dword_frac1+frac32(%ebp),%eax ! 2015: jnz mod_not_0 ! 2016: mov %eax,dword_frac1(%ebp) // here, eax = 0 ! 2017: mov %eax,dword_expon1 ! 2018: movl special,dword_frac1+tag(%ebp) ! 2019: jmp reduce_pi ! 2020: ALIGN ! 2021: mod_not_0: ! 2022: mov $offset_operand1,%edi ! 2023: call subtraction_normalize // returns with zf = 0. ! 2024: reduction_done: ! 2025: orb $inexact_mask,%gs:sr_errors // precision error unless zero mod ! 2026: //check_for_tan_op: ! 2027: // cmpb op_type, tan_op ! 2028: // je reduce_hapi ! 2029: reduce_pi: ! 2030: testb $4,q ! 2031: jz reduce_hapi ! 2032: notw res_signs // flip sign for both sin and cos ! 2033: reduce_hapi: ! 2034: testb $2,q ! 2035: jz reduce_qrpi ! 2036: notb cofunc_flag ! 2037: notb cos_sign ! 2038: // cmpb op_type, tan_op ! 2039: // jne reduce_qrpi ! 2040: // not sin_sign ; use sin_sign as tan_sign ! 2041: reduce_qrpi: ! 2042: testb $1,q ! 2043: jnz last_reduc ! 2044: ret // zf is set here ! 2045: ALIGN ! 2046: last_reduc: ! 2047: notb cofunc_flag // a zero mod will be changed here ! 2048: cmpb special,tag1(%ebp) ! 2049: jne mod_set_inexact ! 2050: cmpb $tan_op,op_type ! 2051: // je complementary_angle ! 2052: jne mod_set_inexact ! 2053: movb $0x80,msb_frac1 ! 2054: movb valid,tag1(%ebp) ! 2055: movl $0x3fff,dword_expon1 ! 2056: mov $offset_operand2,%esi ! 2057: call move_unpacked_1_to_esi ! 2058: add $4,%esp // get rid of return address ! 2059: jmp adjust_sign ! 2060: ALIGN ! 2061: mod_set_inexact: // a zero mod will be changed here ! 2062: orb $inexact_mask,%gs:sr_errors // to qrtr_pi, so precision error ! 2063: complementary_angle: ! 2064: movl $0,dword_frac2(%ebp) ! 2065: movl $0x2168c235,dword_frac2+frac64(%ebp) ! 2066: movl $0x0c90fdaa2,dword_frac2+frac32(%ebp) ! 2067: movl $0x10000*VALID+POSITIVE,dword_frac2+sign(%ebp) ! 2068: movl $0x3ffe,dword_expon2 ! 2069: movb negative,sign1(%ebp) ! 2070: movb $add_op,operation_type(%ebp) ! 2071: call subadd ! 2072: push %gs:sr_masks ! 2073: andl $0x0fffff3ff,%gs:sr_masks // set rc = to_nearest ! 2074: call post_op_round ! 2075: pop %gs:sr_masks ! 2076: lea result_dword_frac(%ebp),%esi ! 2077: lea dword_frac1(%ebp),%edi ! 2078: call move_op_to_op ! 2079: ret ! 2080: //mod_qrtr_pi endp ! 2081: // ! 2082: // ****************************************************************************** ! 2083: ALIGN ! 2084: tan_pseudo_divide: //proc ! 2085: ! 2086: movw $0,siso // clear siso ! 2087: mov %eax,dword_expon1 ! 2088: cmp $16,%eax ! 2089: jg tan_rat_appx ! 2090: decl dword_expon1 // decrement expon1 ! 2091: call right_shift_frac1_8 ! 2092: tan_loop_back_1: ! 2093: mov $10,%eax ! 2094: mull dword_expon1 ! 2095: add $tan_constant,%eax ! 2096: mov %eax,%esi ! 2097: call sub_frac2 ! 2098: shlw $1,siso ! 2099: cmpb $0,msb_result ! 2100: jne tan_merge_0 ! 2101: call move_result_frac1 ! 2102: andl $0x0ffe00000,dword_frac1(%ebp) ! 2103: incw siso ! 2104: tan_merge_0: ! 2105: incl dword_expon1 ! 2106: cmp $15,dword_expon1 ! 2107: ja tan_branch_1 ! 2108: call left_shift_frac1_1 ! 2109: jmp tan_loop_back_1 ! 2110: ALIGN ! 2111: tan_branch_1: ! 2112: call left_shift_frac1_8 ! 2113: movl $0,dword_frac1(%ebp) ! 2114: tan_rat_appx: ! 2115: call move_frac1_cop // cop <- theta, cop tmp ! 2116: call mulx // theta * theta ! 2117: mov dword_expon1,%ecx ! 2118: shl $1,%ecx ! 2119: add $8,%ecx ! 2120: call right_shift_result_cl ! 2121: andl $0x0ff000000,result_dword_frac(%ebp) // 64 bits only ! 2122: call move_result_frac2 ! 2123: mov $constant_c0h,%esi ! 2124: call sub_frac1 // x <- 1.1 - theta*theta ! 2125: call move_cop_frac2 ! 2126: call right_shift_frac2_8 ! 2127: call move_cop_frac1 ! 2128: movb $9,%cl ! 2129: call right_shift_frac1_cl ! 2130: call move_result_cop // cop <- x ! 2131: call addx // y <- y + theta ! 2132: call right_shift_result_1 ! 2133: call move_result_dop // dop <- y, dop ! 2134: decl dword_expon1 // is a 67 bits temp ! 2135: // ! 2136: //pseudo_multiply ! 2137: // ! 2138: tan_loop_back_2: ! 2139: shrw $1,siso ! 2140: jnb tan_merge_2 ! 2141: call move_cop_frac1 // x ! 2142: call move_dop_frac2 // y ! 2143: call addx // x + y ! 2144: call move_result_dop // -> dop ! 2145: mov dword_expon1,%ecx ! 2146: shl $1,%ecx ! 2147: call right_shift_frac2_cl ! 2148: andl $0x0ffe00000,dword_frac2(%ebp) ! 2149: call subx // x - y*2(-2exp) ! 2150: call move_result_cop // -> cop ! 2151: andl $0x0ff000000,dword_cop(%ebp) ! 2152: tan_merge_2: ! 2153: cmpw $0,siso ! 2154: je tan_almost_end ! 2155: movb $1,%cl ! 2156: mov $offset_dop,%edi ! 2157: call right_shift_al0 ! 2158: andl $0x0ffe00000,dword_dop(%ebp) ! 2159: decl dword_expon1 ! 2160: jmp tan_loop_back_2 ! 2161: ALIGN ! 2162: tan_almost_end: ! 2163: movb $8,%cl ! 2164: cmpb $0,msb_dop ! 2165: je tan_merge_3 ! 2166: movb $7,%cl ! 2167: decl dword_expon1 ! 2168: tan_merge_3: ! 2169: mov $offset_dop+frac80,%edi ! 2170: call left_shift ! 2171: call move_dop_frac1 ! 2172: mov $0x3fff,%eax ! 2173: sub dword_expon1,%eax ! 2174: mov %eax,dword_expon1 ! 2175: // ! 2176: //normalize y ! 2177: // ! 2178: mov $offset_operand1,%edi ! 2179: call subtraction_normalize ! 2180: // ! 2181: //now x ! 2182: // ! 2183: call move_cop_frac2 ! 2184: call left_shift_frac2_8 ! 2185: movl $0x3fff,dword_expon2 ! 2186: movl $0x10000*VALID+POSITIVE,sign2(%ebp) ! 2187: // ! 2188: //normalize x ! 2189: // ! 2190: mov $offset_operand2,%edi ! 2191: call subtraction_normalize ! 2192: ret ! 2193: //tan_pseudo_divide endp ! 2194: // ! 2195: // ****************************************************************************** ! 2196: // ! 2197: // tan: ! 2198: // ! 2199: // function: ! 2200: // calculates y and x such that y/x = tan(theta) ! 2201: // ! 2202: // inputs: ! 2203: // assumes that operand1 is set up (theta). ! 2204: // ! 2205: // outputs: ! 2206: // results in result records; y = result, x = result2. ! 2207: // error checking done. ! 2208: // ! 2209: // data accessed: ! 2210: // - result_rec_offset result2_rec_offset ! 2211: // - offset_operand1 expon1 ! 2212: // - word_frac1 lsb_frac1 ! 2213: // - offset_operand1 offset_operand2 ! 2214: // - sign2 tag2 ! 2215: // - expon2 lsb_frac2 ! 2216: // - msb_frac2 offset_operand2 ! 2217: // - lsb_result msb_result ! 2218: // - offset_result siso ! 2219: // - offset_cop lsb_cop ! 2220: // - offset_dop lsb_dop ! 2221: // - msb_dop ! 2222: // ! 2223: // data changed: ! 2224: // - expon1 word_frac1 ! 2225: // - lsb_frac1 sign2 ! 2226: // - tag2 expon2 ! 2227: // - lsb_frac2 msb_result ! 2228: // - lsb_cop lsb_dop ! 2229: // - siso ! 2230: // ! 2231: // procedures called: ! 2232: // do_exchange stack_full? right_shift ! 2233: // left_shift move_10_bytes move_constant ! 2234: // addx subx mulx ! 2235: // subtraction_normalize test_5w set_p_error ! 2236: // ! 2237: // *********************************************************************** ! 2238: ALIGN ! 2239: tan: //proc ! 2240: call two_result_op1_chk ! 2241: get_report: ! 2242: jnz reduce_op1 ! 2243: zero_modulus: ! 2244: mov $offset_operand2,%esi ! 2245: call move_unpacked_1_to_esi ! 2246: jmp do_exchange ! 2247: ALIGN ! 2248: reduce_op1: ! 2249: call mod_qrtr_pi ! 2250: cmpb special,tag1(%ebp) ! 2251: jne tan_tiny_ ! 2252: cmpb true,cofunc_flag ! 2253: jne zero_modulus ! 2254: movl $0,dword_frac1(%ebp) ! 2255: movl $0,dword_frac1+frac64(%ebp) ! 2256: movl $0x080000000,dword_frac1+frac32(%ebp) ! 2257: movl $0x10000*INFINITY+POSITIVE,dword_frac1+sign(%ebp) ! 2258: movl $0x7fff,dword_frac1+expon(%ebp) ! 2259: movb true,signal_z_error_ ! 2260: jmp zero_modulus ! 2261: ALIGN ! 2262: tan_tiny_: ! 2263: mov $0x3fff,%eax ! 2264: sub dword_expon1,%eax ! 2265: cmp $63,%eax ! 2266: jle tan_calc ! 2267: tan_tiny_argument: ! 2268: cmp $0x3fff,%eax ! 2269: jl op2_gets_1 ! 2270: movb sin_sign,%al ! 2271: movb %al,sign1(%ebp) ! 2272: orb underflow_mask,%gs:sr_errors ! 2273: testb underflow_mask,%gs:sr_masks ! 2274: jnz need_grad_uflow ! 2275: addl wrap_around_constant,dword_expon1 ! 2276: jmp zero_modulus ! 2277: ALIGN ! 2278: need_grad_uflow: ! 2279: mov $offset_operand1,%edi ! 2280: mov $1,%eax ! 2281: call gradual_underflow ! 2282: movl $0,dword_expon1 ! 2283: movb denormd,tag1(%ebp) ! 2284: jmp zero_modulus ! 2285: ALIGN ! 2286: op2_gets_1: ! 2287: mov $offset_operand2,%esi ! 2288: call move_unpacked_1_to_esi ! 2289: cmpb true,cofunc_flag ! 2290: jne adjust_sign // straight divide superfluous ! 2291: movw res_signs,%ax ! 2292: movb %al,sign1(%ebp) ! 2293: movb %ah,sign2(%ebp) ! 2294: push %gs:sr_masks ! 2295: // and dword ptr %gs:sr_masks, 0fffff3ffh ; set rc = to_nearest ! 2296: orl $0x0300,%gs:sr_masks // set precision control to prec64 ! 2297: push trans_info ! 2298: jmp reverse_div ! 2299: ALIGN ! 2300: tan_calc: ! 2301: push %gs:sr_masks ! 2302: // and dword ptr %gs:sr_masks, 0fffff3ffh ; set rc = to_nearest ! 2303: orl $0x0300,%gs:sr_masks // set precision control to prec64 ! 2304: push trans_info ! 2305: call tan_pseudo_divide ! 2306: pop trans_info ! 2307: cotan_: ! 2308: movw res_signs,%ax ! 2309: movb %al,sign1(%ebp) ! 2310: movb %ah,sign2(%ebp) ! 2311: push trans_info ! 2312: cmpb true,cofunc_flag ! 2313: jne straight_div ! 2314: reverse_div: ! 2315: call op1_into_op2 ! 2316: jmp get_a_bit ! 2317: ALIGN ! 2318: straight_div: ! 2319: call op2_into_op1 ! 2320: get_a_bit: ! 2321: cmpb true,added_one ! 2322: jne move_tan_result ! 2323: orb $a_mask,%gs:sr_flags ! 2324: move_tan_result: ! 2325: lea result_dword_frac(%ebp),%esi ! 2326: lea dword_frac1(%ebp),%edi ! 2327: call move_op_to_op ! 2328: mov $offset_operand2,%esi ! 2329: call move_unpacked_1_to_esi ! 2330: pop trans_info ! 2331: pop %gs:sr_masks ! 2332: adjust_sign: ! 2333: movb sin_sign,%al ! 2334: xorb cos_sign,%al ! 2335: movb %al,sign1(%ebp) ! 2336: jump_do_exchange: ! 2337: jmp do_exchange_leave_a_bit ! 2338: ALIGN ! 2339: //tan endp ! 2340: // ! 2341: // ********************************************************************** ! 2342: // ! 2343: ALIGN ! 2344: swap_ops: //proc ! 2345: mov $offset_operand1,%esi ! 2346: call push_5_dw_at_esi ! 2347: lea dword_frac2(%ebp),%esi ! 2348: lea dword_frac1(%ebp),%edi ! 2349: call move_op_to_op ! 2350: mov $offset_operand2,%esi ! 2351: call pop_5_dw_at_esi ! 2352: ret ! 2353: //swap_ops endp ! 2354: // ! 2355: // ********************************************************************** ! 2356: // ! 2357: ALIGN ! 2358: op1_into_op2: //proc ! 2359: call swap_ops ! 2360: op2_into_op1: ! 2361: push %gs:sr_masks ! 2362: orl $0x0300,%gs:sr_masks // set precision control to prec64 ! 2363: call divid // floating-point divide ! 2364: call post_op_round ! 2365: pop %gs:sr_masks ! 2366: ret ! 2367: ! 2368: //op1_into_op2 endp ! 2369: // ! 2370: // ********************************************************************** ! 2371: // ! 2372: // ! 2373: ALIGN ! 2374: sin_specific: //proc ! 2375: ! 2376: mov $offset_result,%esi ! 2377: call push_5_dw_at_esi // save (x/y) ! 2378: call op2_into_op1 // result <-- (y/x) ! 2379: lea result_dword_frac(%ebp),%esi ! 2380: lea dword_frac1(%ebp),%edi ! 2381: call move_op_to_op // op1 <-- (y/x) ! 2382: mov $offset_operand2,%esi ! 2383: call pop_5_dw_at_esi // op2 <-- (x/y) ! 2384: orl $0x0f00,%gs:sr_masks // set rc to chop! ! 2385: movb $add_op,operation_type(%ebp) ! 2386: call subadd ! 2387: call post_op_round ! 2388: lea result_dword_frac(%ebp),%esi ! 2389: lea dword_frac2(%ebp),%edi ! 2390: call move_op_to_op // op2 <-- chop(x/y + y/x) ! 2391: mov $offset_operand1,%esi ! 2392: call move_unpacked_1_to_esi // op1 <-- 1 ! 2393: incl dword_expon1 // op1 <-- 2 ! 2394: call op2_into_op1 // res <-- chop{2/chop(x/y + y/x)} ! 2395: ret ! 2396: ! 2397: //sin_specific endp ! 2398: // ! 2399: // ! 2400: // ***************************************************************************** ! 2401: // ! 2402: // sin: ! 2403: // ! 2404: ALIGN ! 2405: sin: //proc ! 2406: call one_result_op1_chk ! 2407: sin_report: ! 2408: jnz sin_reduce_op1 ! 2409: movb $sin_op,op_type ! 2410: movb sign1(%ebp),%al ! 2411: movb %al,sin_sign ! 2412: sin_0_modulus: ! 2413: lea dword_frac1(%ebp),%esi ! 2414: lea result_dword_frac(%ebp),%edi ! 2415: call move_op_to_op ! 2416: jmp check_op_type ! 2417: ALIGN ! 2418: sin_reduce_op1: ! 2419: call mod_qrtr_pi ! 2420: cmpb special,tag1(%ebp) ! 2421: jne sin_tiny_ ! 2422: // testb q, 1 ; was operand (2k+1)*qrtr_pi? ! 2423: // jz sin_cofunc? ; if so, set precision error ! 2424: // orb %gs:sr_errors, inexact_mask ! 2425: //sin_cofunc?: ! 2426: cmpb true,cofunc_flag ! 2427: jne sin_0_modulus ! 2428: jmp cos_0_modulus ! 2429: ALIGN ! 2430: sin_tiny_: ! 2431: cmpb true,cofunc_flag ! 2432: je check_cos_lim ! 2433: check_sin_lim: ! 2434: mov $0x3fff,%eax ! 2435: sub dword_expon1,%eax ! 2436: cmp $30,%eax ! 2437: jl sin_calc ! 2438: jg sin_tiny_argument ! 2439: cmpl $0x08d100000,dword_frac1+frac32(%ebp) ! 2440: ja sin_calc ! 2441: jb sin_0_modulus ! 2442: cmp $0,dword_frac1+frac64(%ebp) ! 2443: je sin_0_modulus ! 2444: sin_tiny_argument: ! 2445: cmp $0x3fff,%eax ! 2446: jl sin_0_modulus ! 2447: orb underflow_mask,%gs:sr_errors ! 2448: testb underflow_mask,%gs:sr_masks ! 2449: jnz sin_grad_uflow ! 2450: addl wrap_around_constant,dword_expon1 ! 2451: jmp sin_0_modulus ! 2452: ALIGN ! 2453: sin_grad_uflow: ! 2454: mov $offset_operand1,%edi ! 2455: mov $1,%eax ! 2456: call gradual_underflow ! 2457: movl $0,dword_expon1 ! 2458: movb denormd,tag1(%ebp) ! 2459: jmp sin_0_modulus ! 2460: ALIGN ! 2461: sin_calc: ! 2462: push trans_info ! 2463: push %gs:sr_masks ! 2464: andl $0x0fffff3ff,%gs:sr_masks // set rc = to_nearest ! 2465: orl $0x0300,%gs:sr_masks // set precision control to prec64 ! 2466: // dec dword_expon1 ; compute tan((op1)/2) ! 2467: inc %eax // eax holds -(true_expon) ! 2468: call tan_pseudo_divide ! 2469: mov $offset_operand1,%esi ! 2470: call push_5_dw_at_esi // save y ! 2471: mov $offset_operand2,%esi ! 2472: call push_5_dw_at_esi // save x ! 2473: call op1_into_op2 // result <-- x/y ! 2474: mov $offset_operand2,%esi ! 2475: call pop_5_dw_at_esi // op2 <-- x ! 2476: mov $offset_operand1,%esi ! 2477: call pop_5_dw_at_esi // op1 <-- y ! 2478: call sin_specific ! 2479: pop %gs:sr_masks ! 2480: pop trans_info ! 2481: andb $~a_mask,%gs:sr_flags ! 2482: cmpb true,added_one ! 2483: jne check_op_type ! 2484: orb $a_mask,%gs:sr_flags ! 2485: jmp check_op_type ! 2486: ALIGN ! 2487: ! 2488: //sin endp ! 2489: // ! 2490: //----------------------------------------------------------------------- ! 2491: // cos: ! 2492: // ! 2493: //----------------------------------------------------------------------- ! 2494: // ! 2495: ALIGN ! 2496: cos_specific: //proc ! 2497: ! 2498: lea dword_frac1(%ebp),%esi ! 2499: lea dword_frac2(%ebp),%edi ! 2500: call move_op_to_op // op2 <-- x/y ! 2501: call mult // res <-- (x/y)**2 ! 2502: call post_op_round ! 2503: lea result_dword_frac(%ebp),%esi ! 2504: lea dword_frac1(%ebp),%edi ! 2505: call move_op_to_op // op1 <-- (x/y)**2 ! 2506: mov $offset_operand2,%esi ! 2507: call move_unpacked_1_to_esi // op2 <-- 1 ! 2508: movb $add_op,operation_type(%ebp) ! 2509: call subadd ! 2510: call post_op_round // res <-- 1 + (x/y)**2 ! 2511: lea result_dword_frac(%ebp),%esi ! 2512: lea dword_frac2(%ebp),%edi ! 2513: call move_op_to_op // op2 <-- 1 + (x/y)**2 ! 2514: mov $offset_operand1,%esi ! 2515: call move_unpacked_1_to_esi // op1 <-- 1 ! 2516: incl dword_expon1 // op1 <-- 2 ! 2517: call op2_into_op1 // res <-- 2/(1 + (x/y)**2) ! 2518: lea result_dword_frac(%ebp),%esi ! 2519: lea dword_frac2(%ebp),%edi ! 2520: call move_op_to_op // op2 <-- 2/(1 + (x/y)**2) ! 2521: mov $offset_operand1,%esi ! 2522: call move_unpacked_1_to_esi // op1 <-- 1 ! 2523: movb $sub_op,operation_type(%ebp) ! 2524: call subadd ! 2525: call post_op_round // res <-- 1 - {2/(1 + (x/y)**2)} ! 2526: ret ! 2527: ! 2528: //cos_specific endp ! 2529: // ! 2530: //----------------------------------------------------------------------- ! 2531: // ! 2532: ALIGN ! 2533: cos: //proc ! 2534: call one_result_op1_chk ! 2535: cos_report: ! 2536: jnz cos_reduce_op1 ! 2537: movb $cos_op,op_type ! 2538: movb positive,cos_sign ! 2539: cos_0_modulus: ! 2540: mov $offset_result,%esi ! 2541: call move_unpacked_1_to_esi ! 2542: check_op_type: ! 2543: cmpb $cos_op,op_type ! 2544: je attach_cos_sign ! 2545: attach_sin_sign: ! 2546: movb sin_sign,%al ! 2547: jmp sign_done ! 2548: ALIGN ! 2549: attach_cos_sign: ! 2550: movb cos_sign,%al ! 2551: sign_done: ! 2552: movb %al,result_sign(%ebp) ! 2553: send_result: ! 2554: mov $offset_result,%edi ! 2555: jmp put_si_result ! 2556: ALIGN ! 2557: cos_reduce_op1: ! 2558: call mod_qrtr_pi ! 2559: cmpb special,tag1(%ebp) ! 2560: jne cos_tiny_ ! 2561: // testb q, 1 ; was operand (2k+1)*qrtr_pi? ! 2562: // jz cos_cofunc? ; if so, set precision error ! 2563: // orb %gs:sr_errors, inexact_mask ! 2564: //cos_cofunc?: ! 2565: cmpb true,cofunc_flag ! 2566: jne cos_0_modulus ! 2567: movl $0,result_dword_frac(%ebp) ! 2568: movl $0,result_dword_frac+frac64(%ebp) ! 2569: movl $0,result_dword_frac+frac32(%ebp) ! 2570: movl $0x10000*SPECIAL+POSITIVE,result_sign(%ebp) ! 2571: movl $0,dword_result_expon ! 2572: jmp attach_cos_sign ! 2573: ALIGN ! 2574: cos_tiny_: ! 2575: cmpb true,cofunc_flag ! 2576: je check_sin_lim ! 2577: check_cos_lim: ! 2578: mov $0x3fff,%eax ! 2579: sub dword_expon1,%eax ! 2580: cmp $62,%eax ! 2581: jl cos_calc ! 2582: jg cos_0_modulus ! 2583: cmpl $0x080000000,dword_frac1+frac32(%ebp) ! 2584: ja cos_calc ! 2585: cmp $0,dword_frac1+frac64(%ebp) ! 2586: je cos_0_modulus ! 2587: cos_calc: ! 2588: push trans_info ! 2589: push %gs:sr_masks ! 2590: andl $0x0fffff3ff,%gs:sr_masks // set rc = to_nearest ! 2591: orl $0x0300,%gs:sr_masks // set precision control to prec64 ! 2592: // dec dword_expon1 ; compute tan((op1)/2) ! 2593: inc %eax // eax holds -(true_expon) ! 2594: call tan_pseudo_divide ! 2595: call op1_into_op2 // result <-- x/y ! 2596: lea result_dword_frac(%ebp),%esi ! 2597: lea dword_frac1(%ebp),%edi ! 2598: call move_op_to_op // op1 <-- x/y ! 2599: call cos_specific // result <-- cos ! 2600: pop %gs:sr_masks ! 2601: pop trans_info ! 2602: andb $~a_mask,%gs:sr_flags ! 2603: cmpb true,added_one ! 2604: jne check_op_type ! 2605: orb $a_mask,%gs:sr_flags ! 2606: jmp check_op_type ! 2607: ! 2608: //cos endp ! 2609: // ! 2610: // ! 2611: // *********************************************************************** ! 2612: // sincos: ! 2613: ! 2614: ALIGN ! 2615: sincos: //proc ! 2616: call two_result_op1_chk ! 2617: combo_get_report: ! 2618: jnz combo_reduce_op1 ! 2619: xor %eax,%eax ! 2620: movb sign1(%ebp),%ah ! 2621: mov %eax,trans_info ! 2622: combo_0_mod: ! 2623: mov $offset_operand2,%esi ! 2624: call move_unpacked_1_to_esi ! 2625: combo_cofunc_: ! 2626: cmpb true,cofunc_flag ! 2627: jne attach_signs ! 2628: switch_ops: ! 2629: call swap_ops ! 2630: attach_signs: ! 2631: movw res_signs,%ax ! 2632: movb %al,sign1(%ebp) ! 2633: movb %ah,sign2(%ebp) ! 2634: results_sent: ! 2635: jmp do_exchange ! 2636: ALIGN ! 2637: combo_reduce_op1: ! 2638: call mod_qrtr_pi ! 2639: cmpb special,tag1(%ebp) ! 2640: // jne combo_tiny? ! 2641: // testb q, 1 ! 2642: jz combo_0_mod ! 2643: // orb %gs:sr_errors, inexact_mask ! 2644: // jmp short combo_0_mod ! 2645: combo_tiny_: ! 2646: mov $0x3fff,%eax ! 2647: sub dword_expon1,%eax ! 2648: cmp $62,%eax ! 2649: jl combo_sin_calc ! 2650: jg combo_tiny_arg ! 2651: cmpl $0x080000000,dword_frac1+frac32(%ebp) ! 2652: ja combo_sin_calc ! 2653: cmp $0,dword_frac1+frac64(%ebp) ! 2654: jne combo_sin_calc ! 2655: combo_tiny_arg: ! 2656: cmp $0x3fff,%eax ! 2657: jl combo_0_mod ! 2658: orb underflow_mask,%gs:sr_errors ! 2659: testb underflow_mask,%gs:sr_masks ! 2660: jnz combo_grad_uflow ! 2661: addl wrap_around_constant,dword_expon1 ! 2662: jmp combo_0_mod ! 2663: ALIGN ! 2664: combo_grad_uflow: ! 2665: mov $offset_operand1,%edi ! 2666: mov $1,%eax ! 2667: call gradual_underflow ! 2668: movl $0,dword_expon1 ! 2669: movb denormd,tag1(%ebp) ! 2670: jmp combo_0_mod ! 2671: ALIGN ! 2672: combo_sin_calc: ! 2673: push trans_info ! 2674: push %gs:sr_masks ! 2675: andl $0x0fffff3ff,%gs:sr_masks // set rc = to_nearest ! 2676: orl $0x0300,%gs:sr_masks // set precision control to prec64 ! 2677: cmp $30,%eax ! 2678: jl push_flags ! 2679: jg force_zf_1 ! 2680: cmpl $0x08d100000,dword_frac1+frac32(%ebp) ! 2681: ja push_flags ! 2682: jb force_zf_1 ! 2683: cmp $0,dword_frac1+frac64(%ebp) ! 2684: jne push_flags ! 2685: force_zf_1: ! 2686: xor %ebx,%ebx // zf set iff arg is tiny for sin ! 2687: mov $offset_operand1,%esi // save tiny op1 as sin(op1) ! 2688: call push_5_dw_at_esi // does not affect flags or eax ! 2689: push_flags: ! 2690: pushf ! 2691: // dec dword_expon1 ; compute tan((op1)/2) ! 2692: inc %eax // eax holds -(true_expon) ! 2693: call tan_pseudo_divide ! 2694: popf ! 2695: jz calc_x_over_y ! 2696: mov $offset_operand1,%esi ! 2697: call push_5_dw_at_esi // save y ! 2698: mov $offset_operand2,%esi ! 2699: call push_5_dw_at_esi // save x ! 2700: calc_x_over_y: ! 2701: pushf ! 2702: call op1_into_op2 // result <-- x/y ! 2703: popf ! 2704: jz save_x_over_y ! 2705: mov $offset_operand2,%esi ! 2706: call pop_5_dw_at_esi // op2 <-- x ! 2707: mov $offset_operand1,%esi ! 2708: call pop_5_dw_at_esi // op1 <-- y ! 2709: save_x_over_y: ! 2710: mov $offset_result,%esi ! 2711: call push_5_dw_at_esi // save x/y ! 2712: jz combo_cos_calc ! 2713: pushf ! 2714: call sin_specific // result <-- sin ! 2715: popf ! 2716: combo_cos_calc: ! 2717: mov $offset_operand1,%esi ! 2718: call pop_5_dw_at_esi // op1 <-- x/y ! 2719: jz tiny_sin_cos_entry ! 2720: mov $offset_result,%esi ! 2721: call push_5_dw_at_esi // save computed sin ! 2722: tiny_sin_cos_entry: ! 2723: call cos_specific // result <-- cos ! 2724: mov $offset_operand1,%esi ! 2725: call pop_5_dw_at_esi // op1 <-- sin ! 2726: lea result_dword_frac(%ebp),%esi ! 2727: lea dword_frac2(%ebp),%edi ! 2728: call move_op_to_op // op2 <-- cos ! 2729: pop %gs:sr_masks ! 2730: pop trans_info ! 2731: jmp combo_cofunc_ ! 2732: ! 2733: //sincos endp ! 2734: // ! 2735: // ! 2736: // *********************************************************************** ! 2737: // test_5w, test_4w, test_3w ! 2738: // ! 2739: // function: ! 2740: // test 3, 4, or 5 consecutive words for zero ! 2741: // ! 2742: // inputs: ! 2743: // least significant word pointed to by ss:(bp + di) ! 2744: // ax must be clear upon entry for test_4w and test_3w ! 2745: // ! 2746: // outputs: ! 2747: // if variable = 0, ax = 00000h; zf = 1 ! 2748: // otherwise, ax = 0ffffh; zf = 0 ! 2749: // ! 2750: // data accessed: ! 2751: // ! 2752: // data changed: ! 2753: // ! 2754: // ************************************************************************* ! 2755: ALIGN ! 2756: test_5w: //proc ! 2757: movw 8(%ebp,%edi),%ax // dump the data into ax ! 2758: test_4w: ! 2759: orw 6(%ebp,%edi),%ax ! 2760: test_3w: ! 2761: orw 4(%ebp,%edi),%ax ! 2762: orw 2(%ebp,%edi),%ax ! 2763: orw (%ebp,%edi),%ax ! 2764: jnz its_not_zero // branch if the number is nonzero ! 2765: ret // return with ax = 00000h, zf = 1 ! 2766: ALIGN ! 2767: its_not_zero: ! 2768: movw $0x0ffff,%ax // return with ax = 0ffffh, zf = 0 ! 2769: ret ! 2770: //test_5w endp ! 2771: // ! 2772: ALIGN ! 2773: test_6w: //proc ! 2774: mov (%ebp,%edi),%eax // dump the data into ax ! 2775: or 4(%ebp,%edi),%eax ! 2776: or 8(%ebp,%edi),%eax ! 2777: jnz non_0 // branch if the number is nonzero ! 2778: ret // return with eax = 000000000h, zf = 1 ! 2779: ALIGN ! 2780: non_0: ! 2781: mov $0x0ffffffff,%eax // return with eax = 0ffffffffh, zf = 0 ! 2782: ret ! 2783: //test_6w endp ! 2784: // ! 2785: // *********************************************************************** ! 2786: // clear_5w, set_5w, set__4w, set_3w ! 2787: // ! 2788: // function: ! 2789: // sets 3, 4, or 5 consecutive words to zero or given value ! 2790: // ! 2791: // inputs: ! 2792: // least significant word pointed to by ss:(ebp + edi) ! 2793: // ax contains value given to store for set routines ! 2794: // ! 2795: // outputs: ! 2796: // ax contains zero for the clear_5w routine ! 2797: // eax * * * * clear_6w * ! 2798: // data accessed: ! 2799: // ! 2800: // data changed: ! 2801: // ! 2802: // ************************************************************************* ! 2803: ALIGN ! 2804: clear_6w: //proc ! 2805: xor %eax,%eax ! 2806: set_6w: ! 2807: mov %eax,(%ebp,%edi) // store the value in eax ! 2808: mov %eax,4(%ebp,%edi) ! 2809: mov %eax,8(%ebp,%edi) ! 2810: ret ! 2811: ALIGN ! 2812: //clear_6w endp ! 2813: // ! 2814: ALIGN ! 2815: clear_5w: //proc ! 2816: xorw %ax,%ax ! 2817: set_5w: ! 2818: movw %ax,8(%ebp,%edi) // store the value in ax ! 2819: set_4w: ! 2820: movw %ax,6(%ebp,%edi) ! 2821: set_3w: ! 2822: movw %ax,4(%ebp,%edi) ! 2823: movw %ax,2(%ebp,%edi) ! 2824: movw %ax,(%ebp,%edi) ! 2825: ret ! 2826: //clear_5w endp ! 2827: // ! 2828: // ! 2829: // common entries to shift and move subroutines ! 2830: // ! 2831: // right_shift group ! 2832: // ! 2833: right_shift_dword_exp_tmp: ! 2834: mov dword_exp_tmp,%ecx ! 2835: shlb $1,%cl ! 2836: jmp right_shift_al0 ! 2837: ALIGN ! 2838: right_shift_result_1: ! 2839: movb $1,%cl ! 2840: right_shift_result_cl: ! 2841: mov $offset_result,%edi ! 2842: jmp right_shift_al0 ! 2843: ALIGN ! 2844: right_shift_frac2_8: ! 2845: movb $8,%cl ! 2846: right_shift_frac2_cl: ! 2847: mov $offset_operand2,%edi ! 2848: jmp right_shift_al0 ! 2849: ALIGN ! 2850: right_shift_frac1_8: ! 2851: movb $8,%cl ! 2852: right_shift_frac1_cl: ! 2853: mov $offset_operand1,%edi ! 2854: right_shift_al0: ! 2855: movb $0,%al ! 2856: // ********************************************************************** ! 2857: // right_shift: ! 2858: // ! 2859: // function: ! 2860: // shifts a 12-byte number right by amount in ecx register. ! 2861: // ! 2862: // inputs: ! 2863: // low bit of al contains bit to inject from left. ! 2864: // edi contains the offset of the least significant byte ! 2865: // of the 12-byte number. ! 2866: // ! 2867: // outputs: ! 2868: // on return, edx is non-zero if any ones have been shifted out. ! 2869: // edi has the same value it had upon entry. ! 2870: // data accessed: ! 2871: // ! 2872: // data changed: ! 2873: // ! 2874: // *************************************************************************** ! 2875: FALLSTHRU ! 2876: right_shift: //proc ! 2877: xor %edx,%edx // initialize edx, the *sticky word* ! 2878: rorb $1,%al // move lsb to msb ! 2879: movsbl %al,%eax // transmit sign to ah and hi_word(eax) ! 2880: push %eax // stack insert bit replica ! 2881: movb $2,%ch // one less than # of dwords to get bit-shifted ! 2882: cmpb $32,%cl // does shift_count exceed 31? ! 2883: jb bits_shft_rt // if not, just do the bit shifting; ! 2884: cmpb $96,%cl // does shift_count exceed 95? ! 2885: jb dwords_shft_rt // if not, proceed with dword shifts; ! 2886: je get_out_shfts // else, if shift_count exceeds 96 ! 2887: orw %ax,%dx // then bit shifted in is also shifted out ! 2888: get_out_shfts: ! 2889: or (%ebp,%edi),%edx // all 3 dwords are *shifted out,* ! 2890: or 4(%ebp,%edi),%edx // and ord to edx ! 2891: or 8(%ebp,%edi),%edx ! 2892: movb %ah,%al // copy insert bit throughout eax ! 2893: mov %eax,(%ebp,%edi) // ! 2894: mov %eax,4(%ebp,%edi) // ! 2895: mov %eax,8(%ebp,%edi) // replace all 96 bits by insert bit. ! 2896: pop %eax ! 2897: ret ! 2898: ALIGN ! 2899: // ! 2900: dwords_shft_rt: ! 2901: push %ds // save a?msr ! 2902: push %ss // copy stack segment ! 2903: pop %ds // to ds ! 2904: // push %ss ! 2905: // pop %es // and es ! 2906: add %ebp,%edi ! 2907: mov %edi,%esi ! 2908: movb %cl,%bl // save bit_shft_count in bl ! 2909: and $0x60,%ecx // get dword_shft_count ! 2910: shr $5,%ecx // normalize dword_shft_count ! 2911: movb %cl,%al // save dword_shft_count in al ! 2912: dword_shft_chk: ! 2913: or (%esi),%edx ! 2914: add $4,%esi ! 2915: LOOP(dword_shft_chk) ! 2916: movl $3,%cx ! 2917: subb %al,%cl ! 2918: movb %cl,%bh ! 2919: push %eax ! 2920: FAST_MOVSL ! 2921: pop %eax ! 2922: movb %al,%cl ! 2923: movb %ah,%al ! 2924: FAST_STOSL ! 2925: sub $12,%edi // adjust edi ! 2926: sub %ebp,%edi // to value it had at entry ! 2927: pop %ds ! 2928: movw %bx,%cx ! 2929: bits_shft_rt: ! 2930: pop %eax ! 2931: push %edi ! 2932: push %eax ! 2933: mov (%ebp,%edi),%eax ! 2934: xor %ebx,%ebx ! 2935: shrdl %cl,%eax,%ebx // cl is interpreted mod 32 ! 2936: or %ebx,%edx ! 2937: bit_shft_loop: ! 2938: mov 4(%ebp,%edi),%eax ! 2939: shrdl %cl,%eax,(%ebp,%edi) ! 2940: add $4,%edi ! 2941: decb %ch ! 2942: jnz bit_shft_loop ! 2943: pop %eax ! 2944: movb %ah,%al ! 2945: shrdl %cl,%eax,(%ebp,%edi) ! 2946: pop %edi ! 2947: right_shift_done: ! 2948: clc ! 2949: ret ! 2950: ALIGN ! 2951: // ! 2952: //right_shift endp ! 2953: // ! 2954: // ! 2955: // left_shift group ! 2956: // ! 2957: left_shift_result_cl: ! 2958: mov $offset_result+frac80,%edi ! 2959: jmp left_shift ! 2960: ALIGN ! 2961: left_shift_frac2_8: ! 2962: movb $8,%cl ! 2963: left_shift_frac2_cl: ! 2964: mov $offset_operand2+frac80,%edi ! 2965: jmp left_shift ! 2966: ALIGN ! 2967: left_shift_frac1_8: ! 2968: movb $8,%cl ! 2969: jmp left_shift_frac1_cl ! 2970: ALIGN ! 2971: left_shift_frac1_1: ! 2972: movb $1,%cl ! 2973: left_shift_frac1_cl: ! 2974: mov $offset_operand1+frac80,%edi ! 2975: // ************************************************************************** ! 2976: // left_shift: ! 2977: // ! 2978: // function: ! 2979: // shifts a 10-byte number left by amount in cl reg. ! 2980: // ! 2981: // input: ! 2982: // di contains offset of low-byte. ! 2983: // ! 2984: // outputs: ! 2985: // bits shifted off the left end are lost. ! 2986: // ! 2987: // data accessed: ! 2988: // ! 2989: // data changed: ! 2990: // ! 2991: // **************************************************************************** ! 2992: FALLSTHRU ! 2993: left_shift: //proc ! 2994: cmpb $80,%cl // more than 80 bits? ! 2995: jle left_count // no, form left count ! 2996: movb $80,%cl // yes, 80 is the max ! 2997: left_count: ! 2998: movb %cl,%al // form byte count ! 2999: andb $0x78,%al // = bits 3-6 of amount ! 3000: jz leftover_bits // branch if count < 8 ! 3001: push %ecx // stack bit count ! 3002: push %edi // stack frac offset ! 3003: push %ds // save a?msr ! 3004: cbtw // clear ah ! 3005: shrw $3,%ax // normalize byte count ! 3006: decw %ax ! 3007: mov $0x0009,%ecx // count = 10 - ax ! 3008: add %ecx,%edi ! 3009: movswl %ax,%eax ! 3010: sub %eax,%ecx // dest = ss:bp+si ! 3011: add %ebp,%edi ! 3012: mov %edi,%esi // dest = ss:bp+di ! 3013: sub %eax,%esi ! 3014: dec %esi ! 3015: push %ss // copy ss to ds and es ! 3016: pop %ds ! 3017: // push %ss ! 3018: // pop %es ! 3019: /* Note direction is not appropriate for FAST_MOVSB */ ! 3020: push %eax ! 3021: 1: ! 3022: movb 0(%esi),%al ! 3023: movb %al,0(%edi) ! 3024: dec %esi ! 3025: dec %edi ! 3026: decl %ecx ! 3027: testl %ecx,%ecx ! 3028: jg 1b ! 3029: ! 3030: movb %cl,(%edi) // clear next byte ! 3031: pop %eax ! 3032: mov %eax,%ecx // form zero count ! 3033: mov %edi,%esi // form string offsets ! 3034: dec %edi ! 3035: /* Note direction is not appropriate for FAST_MOVSB */ ! 3036: push %eax ! 3037: 1: ! 3038: movb 0(%esi),%al ! 3039: movb %al,0(%edi) ! 3040: dec %esi ! 3041: dec %edi ! 3042: decl %ecx ! 3043: testl %ecx,%ecx ! 3044: jg 1b ! 3045: ! 3046: pop %eax ! 3047: pop %ds // reload a?msr ! 3048: pop %edi // reload frac offset ! 3049: pop %ecx // reload bit count ! 3050: leftover_bits: ! 3051: and $0x00000007,%ecx // bits 0-2 = bit count ! 3052: jz left_shift_done // exit if all done ! 3053: FALLSTHRU ! 3054: left_shift_bits: ! 3055: shlw $1,(%ebp,%edi) // shift five words ! 3056: rclw $1,2(%ebp,%edi) // one bit left, using ! 3057: rclw $1,4(%ebp,%edi) // the carry flag out ! 3058: rclw $1,6(%ebp,%edi) ! 3059: rclw $1,8(%ebp,%edi) ! 3060: LOOP(left_shift_bits) // loop bit count times ! 3061: left_shift_done: ! 3062: ret ! 3063: //left_shift endp ! 3064: // ! 3065: // ************************************************************************ ! 3066: // one_left_normalize: ! 3067: // ! 3068: // function: ! 3069: // normalizes following a multiplication. ! 3070: // ! 3071: // inputs: ! 3072: // assumes fraction is not zero. di = frac offset. ! 3073: // ! 3074: // outputs: ! 3075: // shifts fraction left and decrements exponent until ! 3076: // fraction normalized, but no more than one left shift. ! 3077: // zf is reset if the fraction is normalized upon return. ! 3078: // ! 3079: // data accessed: ! 3080: // ! 3081: // data changed: ! 3082: // ! 3083: // ************************************************************************** ! 3084: ALIGN ! 3085: one_left_normalize: //proc ! 3086: testb $0x80,frac80+9(%ebp,%edi) //normalized? ! 3087: jnz one_left_norm_done //quit if normalized. ! 3088: push %edi // save frac offset ! 3089: mov $0x00000001,%ecx // load loop count ! 3090: add $2,%edi ! 3091: call left_shift_bits //shift 5 words left 1 ! 3092: pop %edi // reload frac offset ! 3093: decl expon(%ebp,%edi) //decrement exponent ! 3094: testb $0x80,frac80+9(%ebp,%edi) //normalized? ! 3095: one_left_norm_done: ! 3096: ret ! 3097: //one_left_normalize endp ! 3098: // *********************************************************************** ! 3099: // subtraction_normalize: ! 3100: // ! 3101: // function: ! 3102: // normalizes following a subtraction. ! 3103: // ! 3104: // inputs: ! 3105: // assumes fraction is not zero. di = frac offset ! 3106: // ! 3107: // outputs: ! 3108: // shifts fraction left and decrements exponent ! 3109: // until fraction normalized. ! 3110: // ! 3111: // data accessed: ! 3112: // ! 3113: // data changed: ! 3114: // ! 3115: // ************************************************************************* ! 3116: ALIGN ! 3117: subtraction_normalize: //proc ! 3118: call one_left_normalize // normalize one bit ! 3119: jz subtraction_normalize //quit when normalized. ! 3120: ret ! 3121: //subtraction_normalize endp ! 3122: // ! 3123: // ! 3124: // move_10_bytes group ! 3125: // ! 3126: move_frac2_frac1: ! 3127: mov $offset_operand1+2,%edi ! 3128: move_frac2: ! 3129: mov $offset_operand2+2,%esi ! 3130: jmp move_10_bytes ! 3131: ALIGN ! 3132: move_frac1_result: ! 3133: mov $offset_result+2,%edi ! 3134: jmp move_frac1 ! 3135: ALIGN ! 3136: move_frac1_cop: ! 3137: mov $offset_cop+2,%edi ! 3138: call move_frac1 ! 3139: move_frac1_frac2: ! 3140: mov $offset_operand2+2,%edi ! 3141: move_frac1: ! 3142: mov $offset_operand1+2,%esi ! 3143: jmp move_10_bytes ! 3144: ALIGN ! 3145: move_dop_frac2: ! 3146: mov $offset_operand2+2,%edi ! 3147: jmp move_dop ! 3148: ALIGN ! 3149: move_dop_frac1: ! 3150: mov $offset_operand1+2,%edi ! 3151: move_dop: ! 3152: mov $offset_dop+2,%esi ! 3153: jmp move_10_bytes ! 3154: ALIGN ! 3155: move_cop_frac2: ! 3156: mov $offset_operand2+2,%edi ! 3157: jmp move_cop ! 3158: ALIGN ! 3159: move_cop_frac1: ! 3160: mov $offset_operand1+2,%edi ! 3161: move_cop: ! 3162: mov $offset_cop+2,%esi ! 3163: jmp move_10_bytes ! 3164: ALIGN ! 3165: move_result_cop: ! 3166: mov $offset_cop+2,%edi ! 3167: jmp move_result ! 3168: ALIGN ! 3169: move_result_dop: ! 3170: mov $offset_dop+2,%edi ! 3171: jmp move_result ! 3172: ALIGN ! 3173: move_result_frac2: ! 3174: mov $offset_operand2+2,%edi ! 3175: jmp move_result ! 3176: ALIGN ! 3177: move_result_frac1: ! 3178: mov $offset_operand1+2,%edi ! 3179: move_result: ! 3180: mov $offset_result+2,%esi ! 3181: move_10_bytes: ! 3182: add %ebp,%esi // add global record offset ! 3183: push %ds // save a?msr ! 3184: push %ss // load source segment register ! 3185: set_destination: ! 3186: pop %ds ! 3187: // push %ss // load destination segment register ! 3188: // pop %es // into es ! 3189: add %ebp,%edi // add global record offset ! 3190: ! 3191: /* FAST_MOVSW */ ! 3192: movl 0(%esi),%ecx ! 3193: movl %ecx,%ss:0(%edi) ! 3194: movl 4(%esi),%ecx ! 3195: movl %ecx,%ss:4(%edi) ! 3196: movw 8(%esi),%ecx ! 3197: movw %ecx,%ss:8(%edi) ! 3198: // addl $10,%esi ! 3199: // addl $10,%edi ! 3200: // movl $0,%ecx ! 3201: ! 3202: pop %ds // reload a?msr ! 3203: ret ! 3204: ALIGN ! 3205: // ! 3206: // add, sub, mul, move_constant group ! 3207: // ! 3208: add_half1_frac2: ! 3209: mov $add_half_pattern_1,%esi ! 3210: call add_frac2 ! 3211: mov $offset_result,%edi ! 3212: jmp addition_normalize ! 3213: ALIGN ! 3214: add_frac2: ! 3215: call move_constant_frac2 ! 3216: jmp addx ! 3217: ALIGN ! 3218: sub_frac1: ! 3219: mov $offset_operand1+2,%edi ! 3220: sub_constant: ! 3221: call move_constant ! 3222: jmp subx ! 3223: ALIGN ! 3224: sub_frac2: ! 3225: mov $offset_operand2+2,%edi ! 3226: jmp sub_constant ! 3227: ALIGN ! 3228: mul_frac2: ! 3229: call move_constant_frac2 ! 3230: jmp mulx ! 3231: ALIGN ! 3232: move_constant_frac2: ! 3233: mov $offset_operand2+2,%edi ! 3234: move_constant: ! 3235: push %ds // save a?msr ! 3236: push %cs // load code segment base into ds ! 3237: jmp set_destination // move five words ! 3238: ALIGN ! 3239: // .byte 'bernard verreau,san francisco,ca . 1983' ! 3240: // ! 3241: //a_med ends ! 3242: // ! 3243: // end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.