![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fp_store.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_store.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 "store.s" ! 26: ! 27: .ident "@(#)kern-fp:store.s 1.1" ! 28: ! 29: //$tt(*80387 emulator+++s t o r e+++*) ! 30: // *************************************************************************** ! 31: // ! 32: // s t o r e . m o d ! 33: // ================== ! 34: // ! 35: // ============================================================= ! 36: // intel corporation proprietary information ! 37: // this software is supplied under the terms of a license ! 38: // agreement or non-disclosure agreement with intel corporation ! 39: // and may not be copied nor disclosed except in accordance with ! 40: // the terms of that agreement. ! 41: // =============================================================== ! 42: // ! 43: // function: ! 44: // implements 80387 store, fix, and storex instructions. ! 45: // ! 46: // public procedures: ! 47: // store fix16 fix32 fix64 move_op_to_op ! 48: // ! 49: // internal procedures: ! 50: // extended_store bcd_store ! 51: // single_real_store double_real_store ! 52: // store_valid int64_store ! 53: // int16_store int32_store ! 54: // ! 55: // ************************************************************************ ! 56: // ! 57: //...december 12, 1986.. ! 58: // ! 59: //$nolist ! 60: #include "fp_e80387.h" ! 61: //$list ! 62: .data //a_msr segment rw public ! 63: // extrn %gs:sr_masks,%gs:sr_flags,%gs:sr_errors,%gs:sr_controls ! 64: //a_msr ends ! 65: // ! 66: // assume %ds:a_msr ! 67: // ! 68: .text //a_med segment er public ! 69: // ! 70: // extrn pop_free,clear_6w,test_3w,subadd ! 71: // extrn gradual_underflow,right_shift_frac2_cl ! 72: // extrn special_round_test,directed_round_test ! 73: // extrn right_shift_result_cl,set_up_indefinite ! 74: // extrn right_shift_frac1_cl,sticky_right_shift ! 75: // extrn left_shift_frac1_cl,left_shift_result_cl ! 76: // extrn put_op1_result,divid,addition_normalize ! 77: // extrn round,get_precision,get_rnd_control ! 78: // extrn store_precision,set_i_error,i_masked_ ! 79: // extrn set_o_error,o_masked_,set_p_error ! 80: // extrn set_u_error,test_4w,subtraction_normalize ! 81: // extrn p_error_,clear_p_error,add_to_frac ! 82: // extrn move_constant,set_stk_u_error,norm_denorm ! 83: // extrn %gs:sr_mem_offset ! 84: // --------to be added for unix ! 85: //.. extrn fpfulong:far,fpfushort:far,fpsulong:far,fpsushort:far ! 86: // ! 87: .globl store ! 88: .globl fix16 ! 89: .globl fix32 ! 90: .globl fix64 ! 91: .globl move_op_to_op ! 92: // ! 93: store_routine: ! 94: .long single_real_store,double_real_store,int16_store ! 95: .long int32_store,int64_store,extended_store ! 96: .long int16_store,int16_store,bcd_store ! 97: // ! 98: // ************************************************************************* ! 99: // store: ! 100: // ****** ! 101: // function: ! 102: // implements all store instructions . ! 103: // ! 104: // inputs: ! 105: // operand1; format of result. ! 106: // ! 107: // outputs: ! 108: // operand in *result_format* stored in memory ! 109: // destination pointed to by es:di. ! 110: // ! 111: // data accessed: ! 112: // - result_rec_offset result_format ! 113: // - offset_operand1 ! 114: // ! 115: // data changed: ! 116: // - result record ! 117: // ! 118: // procedures called: ! 119: // set_up_indefinite store routine (result format) ! 120: // i_masked? ! 121: // ! 122: // **************************************************************************** ! 123: ALIGN ! 124: store: //proc ! 125: jz no_unmasked_stack_error // branch if no stack error ! 126: call set_stk_u_error // stack underflow occurred ! 127: testb invalid_mask,%gs:sr_masks // if unmasked, just exit ! 128: jz return // else, store indef set up ! 129: no_unmasked_stack_error: // in operand1 by fetch_an_op ! 130: andb $~a_mask,%gs:sr_flags // clear a-bit ! 131: get_result_loc: ! 132: cmpb $reg,result_location(%ebp) ! 133: jne store_to_memory // branch if memop ! 134: call put_op1_result // give opnd1 as result ! 135: jmp pop_free ! 136: ALIGN ! 137: store_to_memory: ! 138: movzbl result_format(%ebp),%ebx// call a different rtn ! 139: shll $2,%ebx // for each of the ! 140: cmp $8,%ebx ! 141: jge go_to_storer // do store of temporary real ! 142: cmpb unsupp,tag1(%ebp) // detect unsupported pattern ! 143: jne go_to_storer ! 144: orb invalid_mask,%gs:sr_errors // set i_error ! 145: testb invalid_mask,%gs:sr_masks // if unmasked, just exit ! 146: jz return // else, set up indef in ! 147: mov $offset_operand1,%edi // operand1. ! 148: call set_up_indefinite ! 149: go_to_storer: ! 150: jmp *%cs:store_routine(%ebx) // output formats ! 151: //store endp ! 152: // ! 153: // **************************************************************************** ! 154: // move_op_to_op: ! 155: // ! 156: // function: ! 157: // moves operand record (op1,op2,result_op,result2_op) to ! 158: // another op. ! 159: // ! 160: // inputs: ! 161: // ss:esi points to the source, and ! 162: // ss:edi points to the destination ! 163: // outputs: ! 164: // operand record in destination ! 165: // ! 166: // data accessed: ! 167: // operand or result variables ! 168: // ! 169: // data changed: ! 170: // operand or result variables ! 171: // ! 172: // ***************************************************************************** ! 173: ALIGN ! 174: move_op_to_op: //proc ! 175: // push %ds // save a?msr ! 176: // push %ss ! 177: // pop %ds ! 178: push %ss ! 179: pop %es ! 180: mov $((sign2-sign1)>> 2),%ecx / set record length ! 181: ! 182: /* FAST_MOVSL */ ! 183: push %eax ! 184: 1: ! 185: movl %ss:0(%esi),%eax ! 186: movl %eax,%es:0(%edi) ! 187: addl $4,%esi ! 188: addl $4,%edi ! 189: decl %ecx ! 190: testl %ecx,%ecx ! 191: jg 1b ! 192: ! 193: pop %eax ! 194: // pop %ds // reload a?msr ! 195: return: ! 196: ret ! 197: //move_op_to_op endp ! 198: // ! 199: // *************************************************************************** ! 200: // extended_store: ! 201: // *************** ! 202: // function: ! 203: // stores into double extended format. ! 204: // ! 205: // inputs: ! 206: // operand1 ! 207: // ! 208: // outputs: ! 209: // double extended operand in memory. ! 210: // stack popped if indicated ! 211: // ! 212: // data accessed: ! 213: // - mem_operand_pointer sign1 ! 214: // - expon1 word_frac1 ! 215: // ! 216: // data changed: ! 217: // ! 218: // procedures called: ! 219: // pop_free ! 220: // ! 221: // ***************************************************************************** ! 222: ALIGN ! 223: extended_store: //proc ! 224: les mem_operand_pointer(%ebp),%edi //move frac to memory ! 225: // push %ds // save a?msr ! 226: // push %ss ! 227: // pop %ds // set up source pointer ! 228: lea 2+word_frac1,%esi ! 229: ! 230: /* FAST_MOVSL */ ! 231: movl %ss:0(%esi),%ecx ! 232: movl %ecx,%es:0(%edi) ! 233: movl %ss:4(%esi),%ecx ! 234: movl %ecx,%es:4(%edi) ! 235: // addl $8,%esi ! 236: // addl $8,%edi ! 237: // movl $0,%ecx ! 238: ! 239: // pop %ds // reload a?msr ! 240: movb sign1(%ebp),%ah // merge sign & exponent ! 241: andw $0x8000,%ax // and move to memory ! 242: orw expon1(%ebp),%ax ! 243: movw %ax,%es:8(%edi) ! 244: ! 245: //.. ! 246: //.. pushad ! 247: //.. push es ! 248: //.. push edi ! 249: //.. push ax ! 250: //.. call fpsushort ! 251: //.. add esp,12 ! 252: //.. popad ! 253: //.. cld ! 254: jmp pop_free // pop stack, if needed ! 255: //extended_store endp ! 256: // ! 257: // **************************************************************************** ! 258: // bcd_store: ! 259: // ********** ! 260: // function: ! 261: // stores into bcd format ! 262: // ! 263: // inputs: ! 264: // operand1 ! 265: // ! 266: // outputs: ! 267: // bcd operand in memory; stack popped ! 268: // ! 269: // data accessed: ! 270: // - mem_operand_pointer operation_type ! 271: // - offset_operand1 sign1 ! 272: // - tag1 word_frac1 ! 273: // - msb_frac1 offset_operand1 ! 274: // - offset_operand2 sign2 ! 275: // - expon2 word_frac2 ! 276: // - offset_operand2 offset_result ! 277: // - result_expon result_word_frac ! 278: // - msb_result offset_result ! 279: // ! 280: // data changed: ! 281: // - operation_type word_frac1 ! 282: // - msb_frac1 sign2 ! 283: // - expon2 word_frac2 ! 284: // - result_word_frac msb_result ! 285: // ! 286: // procedures called: ! 287: // move_op_to_op right_shift_frac1_cl ! 288: // right_shift_frac2_cl right_shift_result_cl ! 289: // left_shift_frac1_cl left_shift_result_cl ! 290: // divid clear_6w ! 291: // pop_free test_4w ! 292: // add_to_frac move_constant ! 293: // ! 294: // ************************************************************************** ! 295: ten_18: ! 296: .value 0x0000,0x0000,0x0000,0x7640,0x6b3a,0x0de0b// frac for 10**18 ! 297: // ! 298: ALIGN ! 299: bcd_store: //proc ! 300: push %gs:sr_masks // save current precision ! 301: orb prec64,%gs:sr_controls // and set to 64-bit ! 302: cmpb special,tag1(%ebp) // separate bcd cases ! 303: jne finite_value_ ! 304: jmp store_signed_bcd ! 305: ALIGN ! 306: finite_value_: ! 307: cmpl $0x07fff,dword_expon1 // is it a finite number? ! 308: jne check_bcd_denorm // yes, branch to valid ! 309: invalid_bcd: ! 310: orb invalid_mask,%gs:sr_errors // set i_error ! 311: testb invalid_mask,%gs:sr_masks // is i_error unmasked? ! 312: jnz store_bcd_indef ! 313: jmp bcd_store_done // no, so exit at once ! 314: ALIGN ! 315: store_bcd_indef: // yes, store bcd_indef ! 316: movl $0, dword_frac1+frac80(%ebp) // clear low frac ! 317: movl $0x80000000, dword_frac1+6(%ebp)// set only ms bit of hi frac ! 318: movw $0x0ffff, 8+word_frac1 //set msw to all ones, ! 319: jmp store_bcd_result // and give as answer ! 320: ALIGN ! 321: check_bcd_denorm: ! 322: cmpb denormd,tag1(%ebp) // separate bcd cases ! 323: jne round_to_int ! 324: movl $0x0001,dword_expon1 // if masked d-error, make valid ! 325: movb valid,tag1(%ebp) ! 326: round_to_int: ! 327: mov $0x403e,%eax ! 328: cmp %eax,dword_expon1 // if expon >= 63, then number ! 329: jge invalid_bcd // is already too big for bcd ! 330: mov $offset_operand1,%edi // gradual uflow until expon=63 ! 331: push %edi ! 332: call gradual_underflow ! 333: pop %edi // round to precision 64 ! 334: movb prec64,%dl ! 335: movb false,%al ! 336: call round ! 337: detect_zero: ! 338: xor %eax,%eax ! 339: mov $dword_frac1+4,%edi // if fraction = 0, result = 0 ! 340: call test_4w ! 341: jnz below_10_to_18_ ! 342: mov %eax,dword_expon1 // set result to true zero ! 343: movb special,tag1(%ebp) ! 344: jmp store_bcd_round_data ! 345: ALIGN ! 346: below_10_to_18_: ! 347: mov 4(%ebp,%edi),%edx ! 348: cmp $0x0de0b6b3,%edx ! 349: ja invalid_bcd ! 350: mov (%ebp,%edi),%eax ! 351: jb divide_by_10_to_9 ! 352: cmp $0x0a7640000,%eax ! 353: jae invalid_bcd ! 354: divide_by_10_to_9: ! 355: movl $0,4(%ebp,%edi) // clear high dword of frac1 ! 356: movl $0,(%ebp,%edi)// clear low dword of 8 byte frac1 ! 357: sub $2,%edi // make edi point to 10 byte frac1 ! 358: mov $0x3b9aca00,%ebx // ten to the 9th, as hex ordinal ! 359: div %ebx ! 360: push %eax // save quotient ! 361: mov $4,%ecx ! 362: mov $100,%ebx ! 363: FALLSTHRU ! 364: next_pair_nibbles: ! 365: mov %edx,%eax ! 366: xor %edx,%edx ! 367: div %ebx ! 368: xchgl %edx,%eax ! 369: aam ! 370: second_half_loop_start: ! 371: shlb $4,%ah ! 372: orb %ah,%al ! 373: movb %al,(%ebp,%edi) ! 374: inc %edi ! 375: LOOP(next_pair_nibbles) ! 376: do_second_half_: ! 377: pop %eax ! 378: or %eax,%eax // is eax 0? ! 379: movb %dl,(%ebp,%edi) ! 380: jz store_bcd_round_data ! 381: push %edx ! 382: xor %edx,%edx ! 383: mov $10,%ecx ! 384: div %ecx ! 385: xchgl %edx,%eax ! 386: pop %ecx ! 387: movb %al, %ah ! 388: movb %cl, %al ! 389: push $0 ! 390: mov $5, %ecx ! 391: jmp second_half_loop_start ! 392: ALIGN ! 393: store_bcd_round_data: ! 394: cmpb true,rnd1_inexact ! 395: jne store_signed_bcd ! 396: orb $inexact_mask,%gs:sr_errors ! 397: cmpb true,added_one ! 398: jne store_signed_bcd ! 399: orb $a_mask,%gs:sr_flags ! 400: store_signed_bcd: ! 401: movb sign1(%ebp),%ah // set sign in bcd number ! 402: andb $0x080,%ah ! 403: movb %ah,msb_frac1 ! 404: store_bcd_result: ! 405: les %gs:sr_mem_offset,%edi //move frac1 to memory ! 406: // push %ds // save a?msr ! 407: // push %ss ! 408: // pop %ds ! 409: lea word_frac1,%esi ! 410: ! 411: /* FAST_MOVSL */ ! 412: movl %ss:0(%esi),%ecx ! 413: movl %ecx,%es:0(%edi) ! 414: movl %ss:4(%esi),%ecx ! 415: movl %ecx,%es:4(%edi) ! 416: movw %ss:8(%esi),%cx ! 417: movw %cx,%es:8(%edi) ! 418: // addl $10,%esi ! 419: // addl $10,%edi ! 420: // movl $0,%ecx ! 421: ! 422: // pop %ds // reload a?msr ! 423: call pop_free ! 424: bcd_store_done: ! 425: pop %gs:sr_masks // restore old setting ! 426: ret ! 427: //bcd_store endp ! 428: // ! 429: // ***************************************************************************** ! 430: // single_real_store: ! 431: // ****************** ! 432: // function: ! 433: // implements store to single-precision real format ! 434: // ! 435: // inputs: ! 436: // operand1 ! 437: // ! 438: // outputs: ! 439: // single_precision real in memory; ! 440: // stack popped if indicated. ! 441: // ! 442: // data accessed: ! 443: // - mem_operand_pointer offset_operand1 ! 444: // - sign1 tag1 ! 445: // - expon1 word_frac ! 446: // - msb_frac1 ! 447: // ! 448: // data changed: ! 449: // ! 450: // procedures called: ! 451: // round store_valid ! 452: // addition_normalized special_round_test ! 453: // directed_round_test gradual_underflow ! 454: // pop_free test_3w ! 455: // u_masked? set_o_error ! 456: // o_masked? set_p_error ! 457: // set_u_error set_i_masked? ! 458: // store_denormd ! 459: // ! 460: // ************************************************************************ ! 461: ALIGN ! 462: single_real_store: //proc ! 463: push $pop_free // return to pop_free ! 464: les mem_operand_pointer(%ebp),%edi //set es:di to memop ! 465: mov low_extended_expon_for_single,%esi ! 466: movb prec24,%dl // 24-bit precision ! 467: movb tag1(%ebp),%al // load op1 tag ! 468: cmpb valid,%al ! 469: je single_valid // detect valid, infinity, ! 470: cmpb denormd,%al // denormd, invalid, and ! 471: je single_denormd // special cases ! 472: cmpb inv,%al // check whether op1 is nan ! 473: jne single_special // branch unless op1 is nan ! 474: testb $0x40,msb_frac1 // check whether nan is quiet ! 475: jnz single_special // branch if nan is quiet ! 476: orb invalid_mask,%gs:sr_errors // set i_error for snan ! 477: testb invalid_mask,%gs:sr_masks // if unmasked, just exit ! 478: jz special_return // else, change to qnan ! 479: orb $0x40,msb_frac1 ! 480: single_special: ! 481: mov dword_frac1+frac32+1(%ebp),%ecx ! 482: and $0x807fffff,%ecx ! 483: movzbl expon1(%ebp),%eax ! 484: shl $23,%eax ! 485: or %ecx,%eax ! 486: mov %eax,%es:(%edi) ! 487: //.. ! 488: //.. pushad ! 489: //.. push es ! 490: //.. push edi ! 491: //.. push eax ! 492: //.. call fpsulong ! 493: //.. add esp, 12 ! 494: //.. popad ! 495: //.. cld ! 496: //.. ! 497: special_return: ! 498: ret ! 499: ALIGN ! 500: ! 501: single_denormd: ! 502: mov $offset_operand1,%edi // op1 is denormal or pseudo-denormal ! 503: call norm_denorm // dont set d_error; just normalize ! 504: single_valid: ! 505: mov high_extended_expon_for_single,%edi // load parameter ! 506: call store_valid ! 507: les mem_operand_pointer(%ebp),%edi // es:edi --> memop ! 508: jz single_infinity // zf = 1 => store infinity ! 509: js single_max // sf = 1 => store max ! 510: jc single_qnan // cf = 1 => store qnan ! 511: single_store: ! 512: mov dword_frac1+frac32+1(%ebp),%eax ! 513: and $0x80ffffff,%eax ! 514: test $0x00ffffff,%eax ! 515: jz single_store_it ! 516: and $0x807fffff,%eax ! 517: movzbl expon1(%ebp),%ecx ! 518: addb $0x80,%cl ! 519: shl $23,%ecx ! 520: or %ecx,%eax ! 521: single_store_it: ! 522: mov %eax,%es:(%edi) ! 523: //.. ! 524: //.. pushad ! 525: //.. push es ! 526: //.. push edi ! 527: //.. push eax ! 528: //.. call fpsulong ! 529: //.. add esp,12 ! 530: //.. popad ! 531: //.. cld ! 532: //.. ! 533: ret //do needed pop or free ! 534: ALIGN ! 535: ! 536: single_max: ! 537: mov $0x7fffff7f,%eax ! 538: jmp single_sign_on ! 539: ALIGN ! 540: single_infinity: ! 541: mov $0x8000007f,%eax ! 542: single_sign_on: ! 543: orb sign1(%ebp),%al ! 544: ror $8,%eax ! 545: jmp single_store_it ! 546: ALIGN ! 547: single_qnan: ! 548: movl $0xffffffff,%es:(%edi) ! 549: pop %eax // skip pop or free ! 550: ret // since this happens on error ! 551: ALIGN ! 552: ! 553: store_valid: ! 554: push %edi // stack high_expon ! 555: push %esi // stack low_expon ! 556: push %edx // stack prec control ! 557: movb false,%al // not second rounding ! 558: mov $offset_operand1,%edi // round to prec (dl) ! 559: // push edi ; round preserves edi ! 560: call round ! 561: // pop edi ! 562: call addition_normalize // and renormalize ! 563: pop %edx // unstack prec control ! 564: pop %esi // unstack low_expon ! 565: pop %edi // unstack high_expon ! 566: cmp %esi,dword_expon1 // is underflow possible? ! 567: jl store_underflow_ // < low_expon, so underflow possible ! 568: je decrement_exponent // no, = low_expon? ! 569: cmp %edi,dword_expon1 // no, > high_expon? ! 570: jle do_store_valid // no, store number ! 571: orb overflow_mask,%gs:sr_errors // set o_error ! 572: testb overflow_mask,%gs:sr_masks // if unmasked, violate ieee standard ! 573: jnz masked_overflow // and abort without rounding source ! 574: unmasked_ov_underflow: ! 575: // ! 576: // the commentized instructions immediately following are appropriate for ! 577: // unmasked over/underflow response in accord with the ieee standard. on the ! 578: // 80387, unmasked over/underflows on conversion leave for the trap handler the ! 579: // source operand, unmodified by rounding, exponent rebiasing, or anything else. ! 580: // therefore, to report that preliminary rounding was inexact or achieved by ! 581: // increasing the source seems inconsistent with the 80387s philosophy ! 582: // of entering an over/underflow trap handler with the 80387s state changed ! 583: // only insofar as the over/underflow flag has been set, so skip that report. ! 584: // ! 585: // cmp rnd1_inexact, true ; detect inexact result ! 586: // jne move_op1_to_87_tos ; if exact, branch to replace source ! 587: // or %gs:sr_errors, inexact_mask ; else, set i_error ! 588: // cmp added_one, true ; was rounding done by adding one? ! 589: // jne move_op1_to_87_tos ; if not, branch to replace source ! 590: // or %gs:sr_flags, a_mask ; else, set a_bit ! 591: //move_op1_to_87_tos: ! 592: // mov (ebp).result_location, stack_top ! 593: // pop %edi ; discard callers return address ! 594: // pop %edi ; discard pop_free address ! 595: // jmp put_op1_result ! 596: // ! 597: // Instead, we return a special error condition (sf=0 zf=0 cf=1) ! 598: // to our caller, to cause a quiet NaN to be generated, as the 80387 does. ! 599: movb $1, %ah ! 600: sahf ! 601: ret ! 602: ALIGN ! 603: ! 604: masked_overflow: ! 605: orb $inexact_mask,%gs:sr_errors // set inexact_error ! 606: movb %gs:sr_controls,%al // load control byte ! 607: andb $rnd_control_mask,%al // mask in rounding control ! 608: movb rnd_up,%ah ! 609: cmpb %al,%ah ! 610: js store_valid_done // branch if zf = 0 & sf = 1 ! 611: movb sign1(%ebp),%al // get sign of op1 ! 612: call special_round_test // after round test, cf=0 ! 613: pushf // (zf=0 sf=1)/(zf=1 sf=0) ! 614: js pop_store_valid_done // sf = 1 => store max ! 615: orb $a_mask,%gs:sr_flags // set a_bit ! 616: pop_store_valid_done: ! 617: popf // reload flags ! 618: store_valid_done: ! 619: ret // exit ! 620: ALIGN ! 621: store_underflow_: ! 622: testb underflow_mask,%gs:sr_masks // if underflow masked, ! 623: jnz check_masked_underflow // then branch to check for inexact ! 624: orb underflow_mask,%gs:sr_errors// else, set u_error ! 625: // ! 626: // after the underflow exception has been set, the response to unmasked ! 627: // underflow ought to be the same as that to unmasked overflow. ! 628: jmp unmasked_ov_underflow ! 629: ALIGN ! 630: ! 631: check_masked_underflow: ! 632: mov $offset_operand1,%edi // load op1 offset ! 633: mov %esi,%eax // load low exponent ! 634: push %edi // save op1 offset ! 635: push %edx // save prec control ! 636: call gradual_underflow // do gradual underflow ! 637: pop %edx // reload prec control ! 638: pop %edi // reload op1 offset ! 639: movb true,%al // perform second round ! 640: call round ! 641: cmpw $0,rnd_history // signal_u_error? ! 642: je decrement_exponent ! 643: orb underflow_mask+inexact_mask,%gs:sr_errors ! 644: decrement_exponent: ! 645: testb $0x80,msb_frac1 // test msb of fraction ! 646: jnz do_store_valid // dont decrement if 800..0h ! 647: decw expon1(%ebp) // else, decrement expon ! 648: do_store_valid: ! 649: cmpw $0,rnd_history // signal_p_error? ! 650: je adjust_flags ! 651: orb $inexact_mask,%gs:sr_errors // signal_p_error. ! 652: cmpb true,added_one // was rounding done by adding one? ! 653: jne adjust_flags // if not, branch to adjust flags ! 654: orb $a_mask,%gs:sr_flags // else, set a_bit ! 655: adjust_flags: ! 656: xor %eax,%eax // cf = 0, sf = 0, zf = 0 for ! 657: inc %eax // store valid exit ! 658: ret ! 659: ! 660: //single_real_store endp ! 661: // ! 662: // ************************************************************************ ! 663: // double_real_store: ! 664: // ****************** ! 665: // function: ! 666: // implements store to double-precision real format ! 667: // ! 668: // inputs: ! 669: // operand1 ! 670: // ! 671: // outputs: ! 672: // double precision real in memory; ! 673: // stack popped if indicated. ! 674: // ! 675: // data accessed: ! 676: // - mem_operand_pointer offset_operand1 ! 677: // - sign1 tag1 ! 678: // - expon1 word_frac1 ! 679: // - msb_frac1 offset_operand1 ! 680: // ! 681: // data changed: ! 682: // - sign1 word_frac1 ! 683: // ! 684: // procedures called: ! 685: // test_3w store_valid ! 686: // right_shift_frac1_cl pop_free ! 687: // double_zero double_fill ! 688: // store_denormd double_frac_mem ! 689: // ! 690: // *************************************************************************** ! 691: ALIGN ! 692: double_real_store: //proc ! 693: push $pop_free // return to pop_free ! 694: mov low_extended_expon_for_double,%esi ! 695: movb prec53,%dl // 53-bit precision ! 696: movb tag1(%ebp),%al // separate special cases ! 697: cmpb valid,%al ! 698: je double_valid ! 699: cmpb denormd,%al ! 700: je double_denormd ! 701: cmpb special,%al ! 702: jne inv_or_inf ! 703: movw $0x3c00,expon1(%ebp) ! 704: jmp double_frac_mem ! 705: ALIGN ! 706: inv_or_inf: ! 707: cmpb inv,%al ! 708: jne double_special ! 709: testb $0x40,msb_frac1 // check whether nan is quiet ! 710: jnz double_special // branch if nan is quiet ! 711: orb invalid_mask,%gs:sr_errors // set i_error for snan ! 712: testb invalid_mask,%gs:sr_masks // if unmasked, just exit ! 713: jnz make_dbl_qnan // else, change to qnan ! 714: dbl_special_return: ! 715: ret ! 716: ALIGN ! 717: make_dbl_qnan: ! 718: orb $0x40,msb_frac1 ! 719: double_special: ! 720: movw $0x3c00+0x07ff,expon1(%ebp) ! 721: jmp double_frac_mem // store frac to memory ! 722: ALIGN ! 723: double_denormd: ! 724: mov $offset_operand1,%edi // op1 is denormal or pseudo-denormal ! 725: call norm_denorm // dont set d_error; just normalize ! 726: double_valid: ! 727: mov high_extended_expon_for_double,%edi ! 728: call store_valid ! 729: jz double_infinity // zf = 1 ==> store infinity ! 730: js double_max // sf = 1 ==> store max ! 731: jc double_qnan // cf = 1 ==> store qnan ! 732: double_store: ! 733: movb 3+lsb_frac1,%al // else store double ! 734: cbtw ! 735: mov $dword_frac1+6,%edi ! 736: call test_3w ! 737: jz double_zero // store signed zero ! 738: double_frac_mem: ! 739: movb $3,%cl // start by shifting ! 740: call right_shift_frac1_cl // fraction right 3 bits ! 741: les mem_operand_pointer(%ebp),%edi // es:edi points to memop ! 742: // push %ds // save a?msr ! 743: // push %ss ! 744: // pop %ds // set up source pointer ! 745: lea 3+word_frac1,%esi // move frac to memory ! 746: ! 747: /* FAST_MOVSL */ ! 748: movl %ss:0(%esi),%ecx ! 749: movl %ecx,%es:0(%edi) ! 750: movw %ss:4(%esi),%ecx ! 751: movw %ecx,%es:4(%edi) ! 752: // addl $6,%esi ! 753: // addl $6,%edi ! 754: // movl $0,%ecx ! 755: ! 756: // pop %ds // reload a?msr ! 757: movw expon1(%ebp),%ax // fetch high-order word, ! 758: subw $0x3c00,%ax // with expon, sign, and ! 759: shlw $4,%ax // top 4 bits of fraction ! 760: andb $0x0f,msb_frac1 ! 761: orb msb_frac1,%al ! 762: andb $0x80,sign1(%ebp) ! 763: orb sign1(%ebp),%ah ! 764: movw %ax,%es:6(%edi) // es:di points to expon ! 765: //.. ! 766: //.. pushad ! 767: //.. push es ! 768: //.. push edi ! 769: //.. push ax ! 770: //.. call fpsushort ! 771: //.. add esp,12 ! 772: //.. popad ! 773: //.. cld ! 774: //.. ! 775: ! 776: ret // do pop or free ! 777: ALIGN ! 778: ! 779: double_zero: ! 780: xor %eax,%eax // store +/- 0 to memory ! 781: double_fill: ! 782: les mem_operand_pointer(%ebp),%edi // es:edi points to memop ! 783: mov %eax,%es:(%edi) ! 784: //.. ! 785: //.. pushad ! 786: //.. push es ! 787: //.. push edi ! 788: //.. push eax ! 789: //.. call fpsulong ! 790: //.. add esp,12 ! 791: //.. ! 792: ! 793: movw %ax,%es:4(%edi) ! 794: //.. ! 795: //.. push es ! 796: //.. push edi+4 ! 797: //.. push ax ! 798: //.. call fpsushort ! 799: //.. add esp,12 ! 800: //.. popad ! 801: //.. cld ! 802: //.. ! 803: movb sign1(%ebp),%ah ! 804: andb $0x80,%ah ! 805: double_expon: ! 806: movw %ax,%es:6(%edi) // store the exponent ! 807: //.. ! 808: //.. pushad ! 809: //.. push es ! 810: //.. push edi+12 ! 811: //.. push ax ! 812: //.. call fpsushort ! 813: //.. add esp,12 ! 814: //.. popad ! 815: //.. cld ! 816: //.. ! 817: ret ! 818: ALIGN ! 819: ! 820: double_max: ! 821: mov $0x0ffffffff,%eax // set fraction to ff..f ! 822: call double_fill ! 823: movw $0x7fef,%ax // set exponent to 7feh ! 824: orb sign1(%ebp),%ah // or sign bit ! 825: jmp double_expon ! 826: ALIGN ! 827: double_infinity: ! 828: call double_zero // first clear the memop ! 829: orw $0x7ff0,%es:6(%edi) // es:di -> memop ! 830: //.. ! 831: //.. pushad ! 832: //.. push es ! 833: //.. push edi+6 ! 834: //.. call fpfushort ! 835: //.. or ax,7ff0h ! 836: //.. push ax ! 837: //.. call fpsushort ! 838: //.. add esp,12 ! 839: //.. popad ! 840: //.. cld ! 841: //.. ! 842: ret ! 843: ALIGN ! 844: double_qnan: ! 845: mov $0xffffffff,%eax // set fraction to ff..f ! 846: call double_fill ! 847: movw $0xffff,%es:6(%edi) // es:di -> memop (set exp to ff..f) ! 848: pop %eax // skip pop or free ! 849: ret // since this happens on error ! 850: //double_real_store endp ! 851: // ! 852: // *********************************************************************** ! 853: // fix16: ! 854: // ! 855: // function: ! 856: // fixes valid number to a 16-bit integer. ! 857: // ! 858: // inputs: ! 859: // operand1 ! 860: // ! 861: // outputs: ! 862: // 16-bit integer in word_frac1 + 8; ! 863: // overflow indication in zf (zf:1 => no overflow) ! 864: // ! 865: // data accessed: ! 866: // - offset_operand1 sign1 ! 867: // - expon1 word_frac1 ! 868: // - offset_operand1 ! 869: // ! 870: // data changed: ! 871: // - word_frac1 extra_word_reg ! 872: // ! 873: // procedures called: ! 874: // sticky_right_shift round ! 875: // careful_round p_error? ! 876: // ! 877: // *************************************************************************** ! 878: ALIGN ! 879: fix16: //proc ! 880: mov high_int16_exponent,%ecx // calc shift amount ! 881: sub dword_expon1,%ecx // if expon1 > high expon ! 882: js no_fix16_ovf // then overflow (zf=0) ! 883: cmp max_int16_shift,%ecx // dont let shift amount ! 884: jbe do_shift_16 // exceed max_int16_shift ! 885: mov max_int16_shift,%ecx ! 886: do_shift_16: ! 887: mov $offset_operand1,%edi // shift frac1 by cl ! 888: xorb %al,%al ! 889: call sticky_right_shift ! 890: mov $offset_operand1,%edi // round to 16-bit prec ! 891: movb prec16,%dl ! 892: movb false,%al ! 893: call round ! 894: cmpb false,%al // overflow if al=true ! 895: jnz no_fix16_ovf // round cy out (zf=1) ! 896: cmpw $0x8000,8+word_frac1 ! 897: jb check_sign_16 // no overflow if < 8000h ! 898: ja no_fix16_ovf // else, overflow (zf=0) ! 899: cmpb negative,sign1(%ebp) // oflow if = 8000h and ! 900: jnz no_fix16_ovf // sign1 = pos (zf=0) ! 901: check_sign_16: ! 902: movb positive,%al // al is overflow flag ! 903: cmpb sign1(%ebp),%al // negate integer if ! 904: jz no_fix16_ovf // sign is neg (zf=1) ! 905: negw 8+word_frac1 ! 906: xorb %al,%al // no overflow (zf=1) ! 907: no_fix16_ovf: ! 908: ret ! 909: //fix16 endp ! 910: // ! 911: // *********************************************************************** ! 912: // int16_store: ! 913: // ! 914: // function: ! 915: // stores into 16-bit integer format ! 916: // ! 917: // inputs: ! 918: // operand1 ! 919: // ! 920: // outputs: ! 921: // 16-bit integer in memory operand location ! 922: // ! 923: // data accessed: ! 924: // - mem_operand_pointer tag1 ! 925: // - word_frac1 msb_frac1 ! 926: // - offset_operand1 extra_word_reg ! 927: // ! 928: // data changed: ! 929: // ! 930: // procedures called: ! 931: // fix16 pop_free ! 932: // invalid_or_special get_rnd_control ! 933: // set_i_error i_masked? ! 934: // set_p_error clear_p_error ! 935: // ! 936: // ************************************************************************ ! 937: ALIGN ! 938: int16_store: //proc ! 939: // ! 940: cmpb valid,tag1(%ebp) ! 941: je valid_16 ! 942: cmpb denormd,tag1(%ebp) ! 943: jne special_16 ! 944: valid_16: ! 945: call fix16 // make op1 a 16-bit int ! 946: jnz special_16 // if zf=0, oflow on fix ! 947: cmpw $0,rnd_history ! 948: je store_16 ! 949: orb $inexact_mask,%gs:sr_errors ! 950: cmpb true,added_one ! 951: jne store_16 ! 952: orb $a_mask,%gs:sr_flags ! 953: store_16: ! 954: movw 8+word_frac1,%ax // move integer to memory ! 955: pointer_16: ! 956: les mem_operand_pointer(%ebp),%edi //set es:di to location ! 957: finish_16: ! 958: movw %ax,%es:(%edi) // store integer to mem ! 959: //.. ! 960: //.. pushad ! 961: //.. push es ! 962: //.. push edi ! 963: //.. push ax ! 964: //.. call fpsushort ! 965: //.. add esp,12 ! 966: //.. popad ! 967: //.. cld ! 968: //.. ! 969: jmp pop_free // pop stack and go home ! 970: ALIGN ! 971: special_16: ! 972: xorw %ax,%ax ! 973: cmpb special,tag1(%ebp) // is operand tagged special? ! 974: je pointer_16 // yes, load memop ptr and exit ! 975: orb invalid_mask,%gs:sr_errors// no, set invalid error ! 976: movw $0x8000,%ax // load inv constant into ax ! 977: testb invalid_mask,%gs:sr_masks// is invalid error masked? ! 978: jnz pointer_16 // yes, store invalid constant ! 979: ret ! 980: //int16_store endp ! 981: // ! 982: // *********************************************************************** ! 983: // fix32: ! 984: // ! 985: // function: ! 986: // fixes valid number to a 32-bit integer. ! 987: // ! 988: // inputs: ! 989: // operand1 ! 990: // ! 991: // outputs: ! 992: // 32-bit integer in word_frac1 + 6; ! 993: // overflow indication in zf (zf:1 => no overflow) ! 994: // ! 995: // data accessed: ! 996: // - offset_operand1 sign1 ! 997: // - dword_expon1 word_frac1 ! 998: // - offset_operand1 ! 999: // ! 1000: // data changed: ! 1001: // - word_frac1 ! 1002: // ! 1003: // procedures called: ! 1004: // sticky_right_shift round ! 1005: // ! 1006: // *************************************************************************** ! 1007: ALIGN ! 1008: fix32: //proc ! 1009: mov high_int32_exponent,%ecx // calc shift amount ! 1010: sub dword_expon1,%ecx // if expon1 > high expon ! 1011: js no_fix32_ovf // then overflow (zf=0) ! 1012: cmp max_int32_shift,%ecx // dont let shift amount ! 1013: jbe do_shift_32 // exceed max_int32_shift ! 1014: mov max_int32_shift,%ecx ! 1015: do_shift_32: ! 1016: mov $offset_operand1,%edi // shift frac1 by cl ! 1017: xorb %al,%al ! 1018: call sticky_right_shift ! 1019: mov $offset_operand1,%edi // round to 16-bit prec ! 1020: movb prec32,%dl ! 1021: movb false,%al ! 1022: call round ! 1023: cmpb false,%al // overflow if al=true ! 1024: jnz no_fix32_ovf // round cy out (zf=1) ! 1025: cmpl $0x080000000,dword_frac1+frac32(%ebp) ! 1026: jb check_sign_32 // no overflow if < 80000000h ! 1027: ja no_fix32_ovf // else, overflow (zf=0) ! 1028: cmpb negative,sign1(%ebp) // oflow if = 80000000h and ! 1029: jnz no_fix32_ovf // sign1 = pos (zf=0) ! 1030: check_sign_32: ! 1031: movb positive,%al // al is overflow flag ! 1032: cmpb sign1(%ebp),%al // negate integer if ! 1033: jz no_fix32_ovf // sign is neg (zf=1) ! 1034: negl dword_frac1+frac32(%ebp) ! 1035: xorb %al,%al // no overflow (zf=1) ! 1036: no_fix32_ovf: ! 1037: ret ! 1038: //fix32 endp ! 1039: // ! 1040: // ************************************************************************** ! 1041: // int32_store: ! 1042: // ! 1043: // function: ! 1044: // stores into 32-bit integer format ! 1045: // ! 1046: // input: ! 1047: // operand1 ! 1048: // ! 1049: // output: ! 1050: // 32-bit integer in location pointed to by es:di. ! 1051: // ! 1052: // data accessed: ! 1053: // - mem_operand_pointer offset_operand1 ! 1054: // - sign1 tag1 ! 1055: // - expon1 word_frac1 ! 1056: // - msb_frac1 offset_operand1 ! 1057: // ! 1058: // data changed: ! 1059: // - word_frac1 ! 1060: // ! 1061: // procedures called: ! 1062: // pop_free ! 1063: // fix32 ! 1064: // ! 1065: // ************************************************************************** ! 1066: ALIGN ! 1067: int32_store: //proc ! 1068: cmpb valid,tag1(%ebp) ! 1069: je valid_32 ! 1070: cmpb denormd,tag1(%ebp) ! 1071: jne special_32 ! 1072: valid_32: ! 1073: call fix32 // make op1 a 32-bit int ! 1074: jnz special_32 // if zf=0, oflow on fix ! 1075: cmpw $0,rnd_history ! 1076: je store_32 ! 1077: orb $inexact_mask,%gs:sr_errors ! 1078: cmpb true,added_one ! 1079: jne store_32 ! 1080: orb $a_mask,%gs:sr_flags ! 1081: store_32: ! 1082: mov dword_frac1+frac32(%ebp),%eax // move integer to eax ! 1083: pointer_32: ! 1084: les mem_operand_pointer(%ebp),%edi //set es:di to location ! 1085: finish_32: ! 1086: mov %eax,%es:(%edi) // store integer to mem ! 1087: //.. ! 1088: //.. pushad ! 1089: //.. push es ! 1090: //.. push edi ! 1091: //.. push eax ! 1092: //.. call fpsulong ! 1093: //.. add esp,12 ! 1094: //.. popad ! 1095: //.. cld ! 1096: //.. ! 1097: jmp pop_free // pop stack and go home ! 1098: ALIGN ! 1099: special_32: ! 1100: xor %eax,%eax ! 1101: cmpb special,tag1(%ebp) // is operand tagged special? ! 1102: je pointer_32 // yes, load memop ptr and exit ! 1103: orb invalid_mask,%gs:sr_errors// no, set invalid error ! 1104: mov $0x080000000,%eax // load inv constant into ax ! 1105: testb invalid_mask,%gs:sr_masks// is invalid error masked? ! 1106: jnz pointer_32 // yes, store invalid constant ! 1107: ret ! 1108: //int32_store endp ! 1109: // ! 1110: // *********************************************************************** ! 1111: // fix64: ! 1112: // ! 1113: // function: ! 1114: // fixes valid number to a 64-bit integer. ! 1115: // ! 1116: // inputs: ! 1117: // operand1 ! 1118: // ! 1119: // outputs: ! 1120: // 64-bit integer in word_frac1 + 2; ! 1121: // overflow indication in zf (zf:1 => no overflow) ! 1122: // ! 1123: // data accessed: ! 1124: // - offset_operand1 sign1 ! 1125: // - dword_expon1 word_frac1 ! 1126: // - offset_operand1 ! 1127: // ! 1128: // data changed: ! 1129: // - word_frac1 ! 1130: // ! 1131: // procedures called: ! 1132: // sticky_right_shift round ! 1133: // ! 1134: // *************************************************************************** ! 1135: ALIGN ! 1136: fix64: //proc ! 1137: mov high_int64_exponent,%ecx // calc shift amount ! 1138: sub dword_expon1,%ecx // if expon1 > high expon ! 1139: js no_fix64_ovf // then overflow (zf=0) ! 1140: cmp max_int64_shift,%ecx // dont let shift amount ! 1141: jbe do_shift_64 // exceed max_int64_shift ! 1142: mov max_int64_shift,%ecx ! 1143: do_shift_64: ! 1144: mov $offset_operand1,%edi // shift frac1 by cl ! 1145: xorb %al,%al ! 1146: call sticky_right_shift ! 1147: mov $offset_operand1,%edi // round to 64-bit prec ! 1148: movb prec64,%dl ! 1149: movb false,%al ! 1150: call round ! 1151: cmpb false,%al // overflow if al=true ! 1152: jnz no_fix64_ovf // round cy out (zf=1) ! 1153: cmpl $0x080000000,dword_frac1+frac32(%ebp) ! 1154: jb check_sign_64 // no overflow if < 80000000h ! 1155: ja no_fix64_ovf // else, overflow (zf=0) ! 1156: cmp $0,dword_frac1+frac64(%ebp) ! 1157: jnz no_fix64_ovf ! 1158: cmpb negative,sign1(%ebp) // oflow if = 800..0h and ! 1159: jnz no_fix64_ovf // sign1 = pos (zf=0) ! 1160: check_sign_64: ! 1161: movb positive,%al // al is overflow flag ! 1162: cmpb sign1(%ebp),%al // negate integer if ! 1163: jz no_fix64_ovf // sign is neg (zf=1) ! 1164: xor %eax,%eax ! 1165: negl dword_frac1+frac64(%ebp) ! 1166: sbb dword_frac1+frac32(%ebp),%eax ! 1167: mov %eax,dword_frac1+frac32(%ebp) ! 1168: xorb %al,%al // no overflow (zf=1) ! 1169: no_fix64_ovf: ! 1170: ret ! 1171: //fix64 endp ! 1172: // ! 1173: // ***************************************************************************** ! 1174: // int64_store: ! 1175: // ************ ! 1176: // function: ! 1177: // stores into 64-bit integer format ! 1178: // ! 1179: // input: ! 1180: // operand1 ! 1181: // ! 1182: // output: ! 1183: // 64-bit integer in memory location pointed to by es:edi. ! 1184: // ! 1185: // data accessed: ! 1186: // - mem_operand_pointer offset_operand1 ! 1187: // - sign1 tag1 ! 1188: // - expon1 word_frac1 ! 1189: // - msb_frac1 offset_operand1 ! 1190: // ! 1191: // data changed: ! 1192: // - word_frac1 ! 1193: // ! 1194: // procedures called: ! 1195: // pop_free ! 1196: // ! 1197: // *************************************************************************** ! 1198: ALIGN ! 1199: int64_store: //proc ! 1200: cmpb valid,tag1(%ebp) ! 1201: je valid_64 ! 1202: cmpb denormd,tag1(%ebp) ! 1203: jne special_64 ! 1204: valid_64: ! 1205: call fix64 // make op1 a 64-bit int ! 1206: jnz special_64 // if zf=0, oflow on fix ! 1207: cmpw $0,rnd_history ! 1208: je store_64 ! 1209: orb $inexact_mask,%gs:sr_errors ! 1210: cmpb true,added_one ! 1211: jne store_64 ! 1212: orb $a_mask,%gs:sr_flags ! 1213: store_64: ! 1214: mov dword_frac1+frac64(%ebp),%eax // move integer to edx:eax ! 1215: mov dword_frac1+frac32(%ebp),%edx // move integer to edx:eax ! 1216: pointer_64: ! 1217: les mem_operand_pointer(%ebp),%edi //set es:edi to location ! 1218: finish_64: ! 1219: mov %eax,%es:(%edi) // store low integer to low mem ! 1220: //.. ! 1221: //.. pushad ! 1222: //.. push es ! 1223: //.. push edi ! 1224: //.. push eax ! 1225: //.. call fpsulong ! 1226: //.. add esp,12 ! 1227: //.. popad ! 1228: //.. cld ! 1229: //.. ! 1230: mov %edx,%es:4(%edi) // store high integer to high mem ! 1231: //.. ! 1232: //.. pushad ! 1233: //.. push es ! 1234: //.. push edi ! 1235: //.. push edx ! 1236: //.. call fpsulong ! 1237: //.. add esp,12 ! 1238: //.. popad ! 1239: //.. cld ! 1240: //.. ! 1241: jmp pop_free // pop stack and go home ! 1242: ALIGN ! 1243: special_64: ! 1244: xor %eax,%eax ! 1245: cltd ! 1246: cmpb special,tag1(%ebp) // is operand tagged special? ! 1247: je pointer_64 // yes, load memop ptr and exit ! 1248: orb invalid_mask,%gs:sr_errors// no, set invalid error ! 1249: mov $0x080000000,%edx // load inv constant into ax ! 1250: testb invalid_mask,%gs:sr_masks// is invalid error masked? ! 1251: jnz pointer_64 // yes, store invalid constant ! 1252: ret ! 1253: ! 1254: //int64_store endp ! 1255: // ! 1256: //a_med ends ! 1257: // ! 1258: // end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.