![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fp_reg.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_reg.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 "reg.s" ! 26: ! 27: .ident "@(#)kern-fp:reg.s 1.1" ! 28: ! 29: // **************************************************************************** ! 30: // ! 31: // r e g . m o d ! 32: // ============= ! 33: // ! 34: // =============================================================== ! 35: // intel corporation proprietary information ! 36: // this software is supplied under the terms of a license ! 37: // agreement or non-disclosure agreement with intel corporation ! 38: // and may not be copied nor disclosed except in accordance with ! 39: // the terms of that agreement. ! 40: // =============================================================== ! 41: // ! 42: // function: ! 43: // operation cluster for the 80387 register stack. ! 44: // ! 45: // public procedures: ! 46: // put_result stack_full? float_int16 ! 47: // save_regs restore_regs set_up_indefinite ! 48: // getx fetch_an_op exchange exam ! 49: // fxtrac abs_value chsign put_op1_result ! 50: // put_si_result do_exchange ! 51: // ! 52: // internal procedures: ! 53: // extend_single extend_double get_bcd fetch_an_op ! 54: // float16 float32 float64 ! 55: // ! 56: // ***************************************************************************** ! 57: // ! 58: //...March 3, 1987... ! 59: // ! 60: //$nolist ! 61: #include "fp_e80387.h" ! 62: //$list ! 63: //...declare status register segment... ! 64: // ! 65: .data //a_msr segment rw public ! 66: // extrn %gs:sr_masks,%gs:sr_errors,%gs:sr_flags,%gs:sr_regstack ! 67: //a_msr ends ! 68: // ! 69: // assume %ds:a_msr ! 70: // ! 71: .text //a_med segment er public ! 72: // ! 73: // extrn store_reg_tag,decr_top,left_shift ! 74: // extrn subtraction_normalize,clear_6w,test_3w ! 75: // extrn move_op_to_result,save_status,set_z_bit ! 76: // extrn restore_status,init,test_4w,test_6w ! 77: // extrn left_shift_frac2_cl,left_shift_frac1_1 ! 78: // extrn left_shift_result_cl,get_top,set_i_error ! 79: // extrn get_reg_tag,set_s_bit,set_d_error ! 80: // extrn i_masked_,clear_c_bit,clear_cond_bits ! 81: // extrn set_c_bit,set_a_bit,set_i_masked_ ! 82: // extrn move_op_to_op,set_stk_u_error,set_stk_o_error ! 83: // extrn norm_denorm,correct_tag_word ! 84: // --------to be added for unix ! 85: //.. extrn fpfulong:far,fpfushort:far,fpsulong:far,fpsushort:far ! 86: // ! 87: .globl getx ! 88: .globl fetch_an_op ! 89: .globl put_result ! 90: .globl stack_full_ ! 91: .globl fxtrac ! 92: .globl float_int16 ! 93: .globl save ! 94: .globl save_regs ! 95: .globl restore_regs ! 96: .globl restore ! 97: .globl set_up_indefinite ! 98: .globl exchange ! 99: .globl exam ! 100: .globl decompose ! 101: .globl load ! 102: .globl abs_value ! 103: .globl chsign ! 104: .globl put_op1_result ! 105: .globl do_exchange ! 106: .globl put_si_result ! 107: .globl do_exchange_leave_a_bit ! 108: // ! 109: // ***************************************************************************** ! 110: // extend_single: ! 111: // ************** ! 112: // function: ! 113: // retrieves a single real operand from memory, ! 114: // extends its parts, and puts them in the operand ! 115: // ! 116: // inputs: ! 117: // assumes mem_operand_pointer set up ! 118: // edi points to operand1 or operand2 ! 119: // ! 120: // outputs: ! 121: // extended operand in operand ! 122: // ! 123: // data accessed: ! 124: // - mem_operand_pointer ! 125: // ! 126: // data changed: ! 127: // - operands ! 128: // ! 129: // procedures called: ! 130: // set_d_error ! 131: // ! 132: // *************************************************************************** ! 133: ALIGN ! 134: extend_single: //proc ! 135: les mem_operand_pointer(%ebp),%ebx ! 136: xor %eax,%eax ! 137: mov %eax,frac64(%ebp,%edi) //clear low 5 bytes of ! 138: movb %al,frac32(%ebp,%edi) //fraction to 0 ! 139: // ---- replace following line for unix ! 140: mov %es:(%ebx),%eax // move 3 fraction ! 141: ! 142: //.. ! 143: //.. pushad ! 144: //.. push es ! 145: //.. push ebx ! 146: //.. call fpfulong ! 147: //.. add esp,8 ! 148: //.. popad ! 149: //.. cld ! 150: //.. ! 151: mov %eax,frac32+1(%ebp,%edi) // bytes from memory ! 152: sar $23,%eax // get short real exponent in al ! 153: movb %ah,sign(%ebp,%edi) // transfer sign to operand ! 154: and $0x000000ff,%eax // strip sign bits (here, b8-b31) ! 155: movl $0,before_error_signals(%ebp) // initialize all to false ! 156: jnz single_invalid_ ! 157: movb frac64+7(%ebp,%edi),%al // zero or denormalized? ! 158: orw frac64+5(%ebp,%edi),%ax ! 159: jnz single_denormalized ! 160: zero_return: ! 161: movb special,tag(%ebp,%edi) // set tag to special, ! 162: mov %eax,expon(%ebp,%edi) // expon to 0 ! 163: ret ! 164: ALIGN ! 165: single_denormalized: ! 166: movb denormd,tag(%ebp,%edi) // set tag to denormd ! 167: movb true,signal_d_error_ ! 168: testb denorm_mask,%gs:sr_masks // short cut for unmasked d-error ! 169: jnz sngl_d_error_masked ! 170: ret ! 171: ALIGN ! 172: sngl_d_error_masked: ! 173: movl single_exp_offset+1,expon(%ebp,%edi) ! 174: bsrl frac32(%ebp,%edi),%ecx ! 175: sub $31,%ecx ! 176: neg %ecx ! 177: shll %cl,frac32(%ebp,%edi) ! 178: sub %ecx,expon(%ebp,%edi) // adjust exponent ! 179: ret ! 180: ALIGN ! 181: single_invalid_: ! 182: cmpb true,%al ! 183: jne single_operand_is_valid ! 184: movl $0x7fff,expon(%ebp,%edi) //operand is inv/inf ! 185: testl $0x7fffffff,frac32(%ebp,%edi) ! 186: movb infinty,tag(%ebp,%edi) ! 187: jz sngl_exit ! 188: movb inv,tag(%ebp,%edi) //invalid operand ! 189: testb $0x40,msb(%ebp,%edi) ! 190: jnz sngl_qnan ! 191: movb true,signal_i_error_ ! 192: sngl_qnan: ! 193: sngl_exit: ! 194: ret //set tag to invalid ! 195: ALIGN ! 196: single_operand_is_valid: ! 197: movb valid,tag(%ebp,%edi) //set tag to valid ! 198: add single_exp_offset,%eax //single_exp_offset, ! 199: mov %eax,expon(%ebp,%edi) //implicit bit to 1 ! 200: orb $0x80,frac64+7(%ebp,%edi) ! 201: ret ! 202: ALIGN ! 203: //extend_single endp ! 204: // ! 205: // *********************************************************************** ! 206: // extend_double: ! 207: // ************** ! 208: // function: ! 209: // retrieves a double real operand from memory, ! 210: // extends its parts, and puts them in the operand ! 211: // ! 212: // inputs: ! 213: // assumes mem_operand_pointer is set up ! 214: // edi points to operand1 or operand2 ! 215: // ! 216: // outputs: ! 217: // expanded operand in operand ! 218: // ! 219: // data accessed: ! 220: // - mem_operand_pointer ! 221: // ! 222: // data changed: ! 223: // - operand ! 224: // ! 225: // procedures called: ! 226: // ! 227: // ! 228: // ********************************************************************* ! 229: ALIGN ! 230: extend_double: //proc ! 231: // push %ds // save a?msr ! 232: les mem_operand_pointer(%ebp),%ebx ! 233: movb $0,frac64(%ebp,%edi) //clear low byte of ! 234: mov %es:(%ebx),%eax //fraction to 0 ! 235: ! 236: //.. ! 237: //.. pushad ! 238: //.. push ds ! 239: //.. push ebx ! 240: //.. call fpfulong ! 241: //.. pop ebx ! 242: //.. ! 243: mov %eax,frac64+1(%ebp,%edi) //move 7 fraction bytes ! 244: mov %es:4(%ebx),%eax // from memory ! 245: //.. ! 246: //.. push ebx+4 ! 247: //.. call fpfulong ! 248: //.. add esp, 8 ! 249: //.. popad ! 250: //.. cld ! 251: ! 252: // pop %ds // reload a?msr ! 253: mov %eax,frac32+1(%ebp,%edi) ! 254: sar $20,%eax ! 255: cwtd ! 256: movb %dl,sign(%ebp,%edi) // transfer sign to operand ! 257: and $0x000007ff,%eax // strip sign bits (here, ! 258: // b11 - b31) ! 259: movl $0,before_error_signals(%ebp) // initialize both to false ! 260: jnz double_invalid_ ! 261: mov frac64(%ebp,%edi),%eax // exp=0 : is fraction 0? ! 262: or frac32(%ebp,%edi),%eax ! 263: jnz double_denormalized ! 264: jmp zero_return ! 265: ALIGN ! 266: double_denormalized: ! 267: movb denormd,tag(%ebp,%edi) // set tag to denormd ! 268: movb true,signal_d_error_ ! 269: testb denorm_mask,%gs:sr_masks // short cut for unmasked d-error ! 270: jnz dubl_d_error_masked ! 271: ret ! 272: ALIGN ! 273: dubl_d_error_masked: ! 274: movl double_exp_offset+1+3,expon(%ebp,%edi) ! 275: bsrl frac32(%ebp,%edi),%ecx ! 276: jz top_28_zero ! 277: mov frac64(%ebp,%edi),%eax ! 278: sub $31,%ecx ! 279: neg %ecx ! 280: shldl %cl,%eax,frac32(%ebp,%edi) ! 281: shll %cl,frac64(%ebp,%edi) ! 282: dubl_denorm_expon: ! 283: sub %ecx,expon(%ebp,%edi) // adjust exponent ! 284: ret ! 285: ALIGN ! 286: top_28_zero: ! 287: mov frac64(%ebp,%edi),%eax ! 288: bsrl %eax,%ecx ! 289: sub $31,%ecx ! 290: neg %ecx ! 291: shll %cl,%eax ! 292: mov %eax,frac32(%ebp,%edi) ! 293: movl $0,frac64(%ebp,%edi) ! 294: add $32,%ecx ! 295: jmp dubl_denorm_expon ! 296: ALIGN ! 297: double_invalid_: ! 298: cmpw $0x07ff,%ax ! 299: jne double_operand_is_valid ! 300: movl $0x7fff,expon(%ebp,%edi) // operand is nan or ! 301: andl $0x0fffffff,frac32(%ebp,%edi) // inf. set exponent. ! 302: mov frac32(%ebp,%edi),%eax // mask expon bits ! 303: or frac64(%ebp,%edi),%eax ! 304: movb infinty,tag(%ebp,%edi) ! 305: jz dubl_msb_set ! 306: movb inv,tag(%ebp,%edi) // invalid operand ! 307: testb $0x08,msb(%ebp,%edi) ! 308: jnz dubl_qnan ! 309: movb true,signal_i_error_ ! 310: testb invalid_mask,%gs:sr_masks ! 311: jz dubl_exit ! 312: dubl_qnan: ! 313: jmp norm_dubl_sgnfcnd ! 314: ALIGN ! 315: double_operand_is_valid: ! 316: add double_exp_offset,%eax // double_exp_offset ! 317: mov %eax,expon(%ebp,%edi) ! 318: movb valid,tag(%ebp,%edi) // set operand tag ! 319: norm_dubl_sgnfcnd: ! 320: mov frac64(%ebp,%edi),%eax ! 321: .byte 0x0f,0xa4,0x44,0x3d,0x08,0x03 //implements following inst. ! 322: // shldl $3,%eax,frac32(%ebp,%edi) ! 323: shll $3,frac64(%ebp,%edi) ! 324: dubl_msb_set: ! 325: orb $0x80,frac64+7(%ebp,%edi) //set leading bit ! 326: dubl_exit: ! 327: ret ! 328: //extend_double endp ! 329: // ! 330: // **************************************************************************** ! 331: // getx: ! 332: // ***** ! 333: // function: ! 334: // fetches extended-format fp number from memory, unpacks it, ! 335: // and sets its tag ! 336: // ! 337: // inputs: ! 338: // assumes mem_operand_pointer is set up ! 339: // edi points to operand1 or operand2 ! 340: // ! 341: // outputs: ! 342: // if number is valid, then exponent and msb set to all ones ! 343: // ! 344: // data accessed: ! 345: // - mem_operand_pointer extra_word_reg ! 346: // ! 347: // data changed: ! 348: // - operand extra_word_reg ! 349: // ! 350: // procedures called: ! 351: // test_4w test_3w ! 352: // set_d_error ! 353: // ! 354: // **************************************************************************** ! 355: ALIGN ! 356: getx: //proc ! 357: // push %ds // save a?msr ! 358: les mem_operand_pointer(%ebp),%esi // ds:esi ==> memop ! 359: // ! 360: getx_stackreg: ! 361: // push %ss ! 362: // pop %es // es:edi ==> operand ! 363: ! 364: add $frac64,%edi // bump di to frac64 ! 365: push %edi // save operand offset ! 366: lea (%ebp,%edi),%edi ! 367: // mov $0x0002,%ecx // move first four words ! 368: /* FAST_MOVSL */ ! 369: ! 370: movl %es:0(%esi),%ecx ! 371: movl %ecx,%ss:0(%edi) ! 372: movl %es:4(%esi),%ecx ! 373: movl %ecx,%ss:4(%edi) ! 374: // addl $8,%esi ! 375: // movl $0,%ecx ! 376: ! 377: movw %es:8(%esi),%ax // get sign/expon word ! 378: //.. pushad ! 379: //.. push ds ! 380: //..rep_loop: ! 381: //.. push esi ! 382: //.. call fpfulong ! 383: //.. pop esi ! 384: //.. stosd ! 385: //.. add esi,4 ! 386: //.. loop rep_loop ! 387: //.. push esi ! 388: //.. call fpfushort ! 389: //.. add esp,8 ! 390: //.. popad ! 391: //.. cld ! 392: //.. ! 393: pop %edi // reload operand offset ! 394: // pop %ds // reload a?msr ! 395: cwtd // transmit sign to dx ! 396: movb %dl,sign-frac64(%ebp,%edi)// and to operand ! 397: and $0x7fff,%eax // strip off sign bit ! 398: mov %eax,expon-frac64(%ebp,%edi) // store to operand ! 399: movl $0,before_error_signals(%ebp) // initialize both to false ! 400: jz expon_zero // branch if exponent 0 ! 401: testb $0x80,msb-frac64(%ebp,%edi) ! 402: jnz max_expon_ ! 403: movb unsupp,%dl // we have an ! 404: jmp getx_set_tag // unsupported format ! 405: ALIGN ! 406: max_expon_: ! 407: cmpw $0x7fff,%ax // check for invalid ! 408: je not_validx // or infinity ! 409: movb valid,%dl // operand is valid ! 410: getx_set_tag: ! 411: movb %dl,tag-frac64(%ebp,%edi) // set operand tag ! 412: xor %eax,%eax // (for stackreg return) ! 413: ret ! 414: ALIGN ! 415: not_validx: ! 416: movb infinty,%dl ! 417: mov frac32-frac64(%ebp,%edi),%eax ! 418: and $0x07fffffff,%eax ! 419: or (%ebp,%edi),%eax ! 420: jz getx_set_tag ! 421: movb inv,%dl // set tag to invalid ! 422: jmp getx_set_tag ! 423: ALIGN ! 424: expon_zero: ! 425: mov frac32-frac64(%ebp,%edi),%eax ! 426: or (%ebp,%edi),%eax ! 427: movb special,%dl // set tag to special ! 428: jz getx_set_tag // if number is +/- 0 ! 429: movb denormd,%dl // set tag to denormd ! 430: jmp getx_set_tag ! 431: ALIGN ! 432: //getx endp ! 433: // ! 434: // **************************************************************************** ! 435: // fetch_an_op: ! 436: // *********** ! 437: // function: ! 438: // fetches one operand(op1 or op2) and puts its parts ! 439: // in operand1 or operand2 ! 440: // ! 441: // inputs: ! 442: // location of op info in esi ! 443: // location of the operand in edi ! 444: // ! 445: // outputs: ! 446: // operand parts in operand1 or operand2 ! 447: // ! 448: // procedures called: ! 449: // mem_fetch_routine set_up_indefinite ! 450: // get_top ! 451: // getx_stackreg ! 452: // ! 453: // *************************************************************************** ! 454: fetch_location: ! 455: .long from_memory,from_stack_top,from_stack_minus_1 ! 456: .long from_stack_plus_1,from_reg ! 457: mem_fetch_routine: ! 458: .long extend_single,extend_double,float16,float32 ! 459: .long float64,getx,float16,float16,get_bcd ! 460: ALIGN ! 461: fetch_an_op: //proc ! 462: cmpb $null,format(%ebp,%esi)// if format = null, ! 463: je no_stack_error_on_fetch // then no operand to get ! 464: xor %ebx,%ebx ! 465: mov %ebx,(%ebp,%edi) // set low order dword of ! 466: movb location(%ebp,%esi),%bl // fraction to zero ! 467: shl $2,%ebx // handle each operand ! 468: jmp *%cs:fetch_location(%ebx) // location case separate ! 469: ALIGN ! 470: from_memory: ! 471: movb format(%ebp,%esi),%bl // form table offset ! 472: shl $2,%ebx ! 473: call *%cs:mem_fetch_routine(%ebx) // call routine to fetch ! 474: no_stack_error_on_fetch: ! 475: xor %eax,%eax // eax = 00000000h ! 476: ret ! 477: ALIGN ! 478: from_stack_top: ! 479: call get_top // get reg num in al ! 480: unpack_reg: ! 481: call reg_full_ // zf=1 (empty) cx=top ! 482: jz from_stack_plus_1 // error if reg empty ! 483: mov %ebx,%esi // reg_full returns ebx as pointer ! 484: // to stackoffset = ! 485: // (10*regnum) + offset regstack ! 486: // thus, ds:esi ==> regstack ! 487: // ! 488: // push %ds // stack a copy of a?msr ! 489: push %gs // set ds to address register stack ! 490: pop %es ! 491: jmp getx_stackreg // unpack register ! 492: ALIGN ! 493: from_stack_minus_1: ! 494: call get_top ! 495: incw %ax ! 496: jmp unpack_reg ! 497: ALIGN ! 498: from_reg: ! 499: call get_top ! 500: addb reg_num(%ebp),%al ! 501: jmp unpack_reg ! 502: ALIGN ! 503: from_stack_plus_1: ! 504: call set_up_indefinite // store indefinite opr ! 505: incw %ax // indicate stack error on return ! 506: ret ! 507: ! 508: //fetch_an_op endp ! 509: // ! 510: // ************************************************************************* ! 511: // get_bcd: ! 512: // ******** ! 513: // function: ! 514: // fetches a bcd number and converts it to an unpacked ! 515: // tempreal in operand1. ! 516: // inputs: ! 517: // assumes mem_operand_pointer is set up. ! 518: // ignores di and uses operand2 and result fields. ! 519: // ! 520: // outputs: ! 521: // unpacked operand in operand1 ! 522: // ! 523: // data accessed: ! 524: // - mem_operand_pointer expon1 ! 525: // - offset_operand1 sign1 ! 526: // - tag1 word_frac1 ! 527: // - offset_operand1 word_frac2 ! 528: // - lsb__frac2 offset_operand2 ! 529: // - result_word_frac offset_result ! 530: // ! 531: // data changed: ! 532: // - sign1 tag1 ! 533: // - expon1 word_frac1 ! 534: // - word_frac2 result_word_frac ! 535: // ! 536: // procedures called: ! 537: // left_shift move_op_to_result ! 538: // subtraction_normalize test_6w ! 539: // ! 540: // ****************************************************************************** ! 541: ALIGN ! 542: get_bcd: //proc ! 543: // push %ds // save a?msr ! 544: les mem_operand_pointer(%ebp),%esi ! 545: // push %ss // set up destination pointer ! 546: // pop %es ! 547: lea word_frac2,%edi // es:di ==> word_frac2 ! 548: // mov $0x0005,%ecx ! 549: ! 550: /* FAST_MOVSW */ ! 551: movl %es:0(%esi),%ecx ! 552: movl %ecx,%ss:0(%edi) ! 553: movl %es:4(%esi),%ecx ! 554: movl %ecx,%ss:4(%edi) ! 555: movw %es:8(%esi),%cx ! 556: movw %cx,%ss:8(%edi) ! 557: // addl $10,%esi ! 558: // movl $0,%ecx ! 559: ! 560: //.. ! 561: //.. pushad ! 562: //.. push ds ! 563: //..getbcd_loop: ! 564: //.. push esi ! 565: //.. call fpfushort ! 566: //.. pop esi ! 567: //.. stosw ! 568: //.. add esi,2 ! 569: //.. loop getbcd_loop ! 570: //.. pop ds ! 571: //.. popad ! 572: //.. cld ! 573: //.. ! 574: // pop %ds // reload a?msr ! 575: cmpw $0x0ffff,dword_frac1+10(%ebp) ! 576: jne accept_bcd ! 577: mov $offset_operand1,%edi ! 578: call set_up_indefinite ! 579: ret ! 580: ALIGN ! 581: accept_bcd: ! 582: movb msb_frac2,%al // get most significant byte ! 583: cbtw // and transmit sign to ah ! 584: movb %ah,sign1(%ebp) // store sign into operand ! 585: mov $offset_operand1,%edi // set frac1 to 0 ! 586: call clear_6w ! 587: movb $18,%cl //set loop count to 18 digits ! 588: FALLSTHRU ! 589: convert_loop: ! 590: push %ecx ! 591: movb $4,%cl //shift frac2 left 4 bits to ! 592: call left_shift_frac2_cl // the next digit ! 593: and $0x0f,msb_frac2 //clear previous digit ! 594: call left_shift_frac1_1 // frac1 <= 10*frac1 + frac2(9): ! 595: mov $offset_operand1,%esi // 1) frac1 <= frac1 * 2 ! 596: call move_op_to_result // 2) result_frac <= frac1 * 4 ! 597: movb $2,%cl ! 598: call left_shift_result_cl ! 599: // mov ax,(ebp).result_word_frac ; 3) frac1 <-- frac1 + ! 600: // add word_frac1,ax ; result_frac ! 601: // mov ax,(ebp).result_word_frac + 2 ! 602: // adc (ebp).word_frac1 + 2,ax ! 603: // mov ax,(ebp).result_word_frac + 4 ! 604: // adc (ebp).word_frac1 + 4,ax ! 605: // mov ax,(ebp).result_word_frac + 6 ! 606: // adc (ebp).word_frac1 + 6,ax ! 607: // mov ax,(ebp).result_word_frac + 8 ! 608: // adc (ebp).word_frac1 + 8,ax ! 609: // ! 610: mov result_dword_frac(%ebp),%eax // 3) frac1 <-- frac1 + ! 611: xorw %ax,%ax ! 612: add %eax,dword_frac1(%ebp) // result_frac ! 613: mov result_dword_frac+4(%ebp),%eax ! 614: adc %eax,dword_frac1+4(%ebp) ! 615: mov result_dword_frac+8(%ebp),%eax ! 616: adc %eax,dword_frac1+8(%ebp) ! 617: xor %eax,%eax // 4) frac1 <-- frac1 + frac(9) ! 618: movb msb_frac2,%al ! 619: addw %ax,word_frac1 ! 620: movb $0,%al ! 621: adc %eax,dword_frac1+4(%ebp) ! 622: adc %eax,dword_frac1+8(%ebp) ! 623: pop %ecx //and loop ! 624: LOOP(convert_loop) ! 625: mov $dword_frac1,%edi ! 626: call test_6w //frac1 = 0? ! 627: jnz make_floating_point ! 628: mov %eax,dword_expon1 //set expon and tag for zero ! 629: movb special,tag1(%ebp) ! 630: ret ! 631: ALIGN ! 632: make_floating_point: ! 633: movl $0x404e,dword_expon1 //set expon1 and normalize ! 634: mov $offset_operand1,%edi ! 635: call subtraction_normalize ! 636: movb valid,tag1(%ebp) //set tag to valid ! 637: ret ! 638: //get_bcd endp ! 639: // ! 640: // ****************************************************************************** ! 641: // put_result: ! 642: // ! 643: // function: ! 644: // puts result on 80387 stack or in 80387 register. ! 645: // implements 80387 load instruction. ! 646: // ! 647: // inputs: ! 648: // address of data parts (in edi register) ! 649: // address of result info (in esi). ! 650: // (ebp).before_error_signals ! 651: // outputs: ! 652: // stack error indication (in al register). ! 653: // ! 654: // data accessed: ! 655: // ! 656: // data changed: ! 657: // ! 658: // procedures called: ! 659: // decr_top stack_full? ! 660: // set_up_indefinite store_reg_tag ! 661: // get_top ! 662: // ! 663: // *************************************************************************** ! 664: location_case: ! 665: .long push_onto_stack ! 666: .long put_in_stack_top ! 667: .long put_in_stack_top_minus_1 ! 668: .long push_onto_stack ! 669: .long put_in_reg ! 670: // ! 671: ALIGN ! 672: load: //proc ! 673: jz put_zf_in_ah // if zf set, no stack error ! 674: call set_stk_u_error ! 675: testb invalid_mask,%gs:sr_masks // else, stack underflow error ! 676: jnz put_zf_in_ah // if i_error masked, continue ! 677: ret // else, return ! 678: ALIGN ! 679: put_zf_in_ah: // if zf is set here, no stack ! 680: lahf // underflow occurred. however, ! 681: // if zf is clear, stack underflow ! 682: // occurred and invalid is masked. ! 683: jnz put_op1_result ! 684: common_clear_a_bit: ! 685: andb $~a_mask,%gs:sr_flags ! 686: put_op1_result: ! 687: mov $offset_operand1,%edi // edi points to result record ! 688: put_si_result: ! 689: mov offset_result_rec,%esi // merge with put_result ! 690: put_result: ! 691: movzbl location(%ebp,%esi),%ebx //handle cases separately ! 692: shl $2,%ebx ! 693: jmp *%cs:location_case(%ebx) ! 694: ALIGN ! 695: put_in_stack_top_minus_1: ! 696: call get_top // put reg num of top-1 in al ! 697: incw %ax ! 698: jmp mask_top ! 699: ALIGN ! 700: push_onto_stack: ! 701: sahf // zf clear iff stack underflow occurred with ! 702: jnz push_value // invalid exception masked ! 703: call stack_full_ // is top - 1 full? ! 704: jz other_before_error_ // no, so detect other before errors. ! 705: call set_stk_o_error // set invalid error, stack bit, and ! 706: // c1 (a) bit ! 707: testb invalid_mask,%gs:sr_masks ! 708: jz exit_load // unmasked, so done with load ! 709: call set_up_indefinite // push indefinite as the result ! 710: jmp push_value ! 711: ALIGN ! 712: other_before_error_: ! 713: mov before_error_signals(%ebp),%eax ! 714: or %eax,%eax ! 715: jz push_value ! 716: orb %al,%al ! 717: jz check_z_error ! 718: orb invalid_mask,%gs:sr_errors ! 719: testb invalid_mask,%gs:sr_masks ! 720: jz exit_load // unmasked, so done with load ! 721: orb $0x40,msb(%ebp,%edi) ! 722: jmp push_value ! 723: ALIGN ! 724: check_z_error: ! 725: orb %ah,%ah ! 726: jz signal_d_error ! 727: orb zero_divide_mask,%gs:sr_errors ! 728: testb zero_divide_mask,%gs:sr_masks ! 729: jz exit_load // unmasked, so done with load ! 730: jmp push_value ! 731: ALIGN ! 732: signal_d_error: ! 733: orb denorm_mask,%gs:sr_errors ! 734: testb denorm_mask,%gs:sr_masks ! 735: jz exit_load // unmasked, so done with load ! 736: // the following seven instructions were added to cope with a load from ! 737: // memory to (new) 87 stack top of a short_real or long_real operand. ! 738: // otherwise, such loads of a denormal source operand while the denormal ! 739: // exception is masked would incorrectly tag the loaded, normalized ! 740: // temporary_real operand as invalid, instead of valid. the first four ! 741: // of these seven instructions have been commented out, because the ! 742: // executive procedure e80387 in the module *dcode* always initializes ! 743: // the op1_format field, even when its contents are deducible from the ! 744: // operation_type and op1_location fields, so it is enough to check ! 745: // whether the format field is single_real or double_real. ! 746: // cmp (ebp).operation_type, load_op ! 747: // jne push value ! 748: // cmp (ebp).op1_location, memory_opnd ! 749: // jne push_value ! 750: cmpb $double_real,op1_format(%ebp) ! 751: ja push_value ! 752: movb valid,tag(%ebp,%edi) ! 753: push_value: ! 754: call decr_top // decrement top for push ! 755: put_in_stack_top: ! 756: call get_top // put reg num of stack top in al ! 757: jmp mask_top ! 758: ALIGN ! 759: put_in_reg: ! 760: call get_top // put reg num specified in ! 761: addb reg_num(%ebp),%al // instruction in al ! 762: mask_top: ! 763: and $0x0007,%eax ! 764: mov %eax,%ecx // save reg num word in cx ! 765: movb tag(%ebp,%edi),%al // put new tag in al ! 766: call store_reg_tag ! 767: lea frac64(%ebp,%edi),%esi// ds:esi ==> operand frac64 ! 768: mov $sr_regstack,%edi // form offset within %gs:sr_regstack ! 769: add %ecx,%edi // for result (10 * reg num) ! 770: shl $2,%ecx ! 771: add %ecx,%edi // es:edi ==> treal st(reg num) ! 772: // mov $0x02,%ecx // count = 2 dwords ! 773: // push %gs // set segment registers ! 774: // pop %es ! 775: // push %ds ! 776: // push %ss ! 777: // pop %ds ! 778: ! 779: /* FAST_MOVSL */ ! 780: movl %ss:0(%esi),%ecx ! 781: movl %ecx,%gs:0(%edi) ! 782: movl %ss:4(%esi),%ecx ! 783: movl %ecx,%gs:4(%edi) ! 784: // addl $8,%esi ! 785: // addl $8,%edi ! 786: // movl $0,%ecx ! 787: ! 788: movb %ss:8(%esi),%ah // ah = sign of operand ! 789: andw $0x8000,%ax // form tempreal exponent ! 790: orw %ss:12(%esi),%ax ! 791: // pop %ds // reload a?msr into ds ! 792: movw %ax,%gs:8(%edi) // exponent => %gs:sr_regstack ! 793: exit_load: ! 794: ret ! 795: //load endp ! 796: // ! 797: // ***************************************************************************** ! 798: // stack_full?: ! 799: // ! 800: // function: ! 801: // checks stack to see if an attempted push will ! 802: // generate a stack error. ! 803: // ! 804: // inputs: ! 805: // tag for register on top of stack ! 806: // ! 807: // outputs: ! 808: // zf = true if stack is empty; zf = false if stack is full. ! 809: // ! 810: // procedures called: ! 811: // get_top get_reg_tag ! 812: // ! 813: // ***************************************************************************** ! 814: ALIGN ! 815: stack_full_: //proc ! 816: call get_top // determine reg no. of (top-1) ! 817: decw %ax ! 818: reg_full_: ! 819: andb $0x07,%al ! 820: call get_reg_tag ! 821: cmpb $empty,%al // if (top-1) is not empty, ! 822: return: ! 823: ret // then stack is full ! 824: //stack_full_ endp ! 825: // ! 826: // ************************************************************************ ! 827: // decompose: ! 828: // ! 829: // function: ! 830: // decomposes op1 into two parts ! 831: // ! 832: // inputs: ! 833: // assumes op1 is set up, with tag1 /= unsupp and tag1 /= inv ! 834: // ! 835: // outputs: ! 836: // puts the exponent, floated in op1; the fraction in op2 ! 837: // ! 838: // data accessed: ! 839: // - offset_operand sign1 ! 840: // - tag1 expon1 ! 841: // - offset_operand2 sign2 ! 842: // - tag2 expon2 ! 843: // ! 844: // data changed: ! 845: // - sign2 expon2 ! 846: // ! 847: // procedures called: ! 848: // float_int32 move_op_to_op ! 849: // ! 850: // **************************************************************************** ! 851: ALIGN ! 852: decompose: //proc ! 853: lea dword_frac1(%ebp),%esi // move op1 to op2 ! 854: lea dword_frac2(%ebp),%edi ! 855: call move_op_to_op ! 856: cmpb valid,tag1(%ebp) ! 857: jne is_op1_denorm_ ! 858: put_sig_in_op2: ! 859: movl $exponent_bias,dword_expon2 // set op2 exponent=bias ! 860: put_exp_in_op1: ! 861: mov dword_expon1,%eax // float exp into op1 ! 862: unbias_expon: ! 863: sub $exponent_bias,%eax // first unbias it ! 864: mov $offset_operand1,%edi ! 865: jmp float_int32 ! 866: ALIGN ! 867: is_op1_denorm_: ! 868: cmpb denormd,tag1(%ebp) ! 869: jne op1_zero_or_inf ! 870: movb true,signal_d_error_ ! 871: testb denorm_mask,%gs:sr_masks // short cut if unmasked d-error ! 872: jz interim_exit ! 873: mov $offset_operand2,%edi ! 874: call norm_denorm ! 875: mov dword_expon2,%eax ! 876: movl $exponent_bias,dword_expon2 // set op2 exponent=bias ! 877: jmp unbias_expon ! 878: ALIGN ! 879: op1_zero_or_inf: ! 880: cmpb special,tag1(%ebp) ! 881: je op1_zero // op1 and op2 are infinite ! 882: movb positive,sign1(%ebp) ! 883: interim_exit: ! 884: ret ! 885: ALIGN ! 886: op1_zero: ! 887: movb true,signal_z_error_ // if number=0, signal z-error ! 888: testb zero_divide_mask,%gs:sr_masks // if z_error is unmasked ! 889: jz interim_exit // then just return ! 890: make_op1_negative_inf: ! 891: movl $0x07fff,dword_expon1 // else, make op1 -infinity ! 892: movb $0x80,msb_frac1 ! 893: movl infinty*0x10000+NEGATIVE,sign1(%ebp) ! 894: ret ! 895: //decompose endp ! 896: // ! 897: // ************************************************************************** ! 898: // float16: ! 899: // ! 900: // function: ! 901: // retrieves a 16-bit, 2s complement integer from memory, ! 902: // and fills in the operand ! 903: // ! 904: // inputs: ! 905: // assumes mem_operand_pointer is set up ! 906: // edi points to operand1 or operand2 ! 907: // ! 908: // outputs: ! 909: // operand ! 910: // ! 911: // data accessed: ! 912: // - mem_operand_pointer ! 913: // ! 914: // data changed: ! 915: // - operand ! 916: // ! 917: // procedures called: ! 918: // float_int32 ! 919: // ! 920: // *************************************************************************** ! 921: ALIGN ! 922: float16: //proc ! 923: les mem_operand_pointer(%ebp),%ebx // fetch the ! 924: // 16-bit integer ! 925: movw %es:(%ebx),%ax ! 926: //.. ! 927: //.. pushad ! 928: //.. push es ! 929: //.. push ebx ! 930: //.. call fpfushort ! 931: //.. add esp,8 ! 932: //.. popad ! 933: //.. cld ! 934: //.. ! 935: float_int16: ! 936: movswl %ax,%eax ! 937: jmp float_int32 ! 938: ALIGN ! 939: // ! 940: // ! 941: // ! 942: // ***************************************************************************** ! 943: // float32: ! 944: // ! 945: // function: ! 946: // retrieves a 32-bit, 2s complement integer from memory ! 947: // and fills in the operand ! 948: // ! 949: // inputs: ! 950: // assumes mem_operand_pointer is set up ! 951: // edi points to operand1 or operand2 ! 952: // ! 953: // outputs: ! 954: // operand ! 955: // ! 956: // data accessed: ! 957: // - mem_operand_pointer ! 958: // ! 959: // data changed: ! 960: // - operand ! 961: // ! 962: // procedures called: ! 963: // ! 964: // ! 965: // ***************************************************************************** ! 966: float32: ! 967: les mem_operand_pointer(%ebp),%ebx ! 968: ! 969: mov %es:(%ebx),%eax // move from memory to eax ! 970: ! 971: //.. ! 972: //.. pushad ! 973: //.. push es ! 974: //.. push ebx ! 975: //.. call fpfulong ! 976: //.. add esp,8 ! 977: //.. popad ! 978: //.. cld ! 979: ! 980: float_int32: ! 981: mov %eax,%edx // save integer in edx ! 982: xor %eax,%eax // clear low 8 bytes ! 983: mov %eax,(%ebp,%edi) ! 984: mov %eax,frac64(%ebp,%edi) ! 985: or %edx,%eax // if integer is zero, ! 986: jnz get_sign_and_mag_32 // then load +0 ! 987: mov %eax,frac32(%ebp,%edi) ! 988: movb %al,sign(%ebp,%edi) ! 989: movb special,tag(%ebp,%edi) ! 990: mov %eax,expon(%ebp,%edi) ! 991: ret ! 992: ALIGN ! 993: get_sign_and_mag_32: ! 994: cltd // transmit sign to edx ! 995: movb %dl,sign(%ebp,%edi) // and store to operand ! 996: jns positive_int // branch if positive ! 997: neg %eax // negate if negative ! 998: positive_int: ! 999: bsrl %eax,%ecx ! 1000: sub $31,%ecx ! 1001: neg %ecx ! 1002: shl %cl,%eax ! 1003: mov %eax,frac32(%ebp,%edi) // store normalized{abs(int)} ! 1004: mov $0x401e,%eax // load valid exponent ! 1005: sub %ecx,%eax ! 1006: mov %eax,expon(%ebp,%edi) ! 1007: movb valid,tag(%ebp,%edi) ! 1008: ret ! 1009: ALIGN ! 1010: //float16 endp ! 1011: // ! 1012: // ****************************************************************************** ! 1013: // float64: ! 1014: // ! 1015: // function: ! 1016: // retrieves a 64-bit, 2s complement integer from memory ! 1017: // and fills in the operand ! 1018: // ! 1019: // inputs: ! 1020: // assumes mem_operand_pointer is set up ! 1021: // edi points to operand1 or operand2 ! 1022: // ! 1023: // outputs: ! 1024: // operand ! 1025: // ! 1026: // data accessed: ! 1027: // - mem_operand_pointer ! 1028: // ! 1029: // data changed: ! 1030: // - operand ! 1031: // ! 1032: // procedures called: ! 1033: // ! 1034: // ! 1035: // **************************************************************************** ! 1036: ALIGN ! 1037: float64: //proc ! 1038: // push %ds // save a?msr ! 1039: les mem_operand_pointer(%ebp),%esi ! 1040: // push %ss ! 1041: // pop %es // es:edi ==> operand ! 1042: push %edi // save op? offset ! 1043: lea frac64(%ebp,%edi),%edi // set operand offset ! 1044: // mov $0x0002,%ecx // move fraction from ! 1045: ! 1046: /* FAST_MOVSL */ ! 1047: movl %es:0(%esi),%ecx ! 1048: movl %ecx,%ss:0(%edi) ! 1049: movl %es:4(%esi),%ecx ! 1050: movl %ecx,%ss:4(%edi) ! 1051: // addl $8,%esi ! 1052: // addl $8,%edi ! 1053: // movl $0,%ecx ! 1054: ! 1055: //.. ! 1056: //.. pushad ! 1057: //.. push ds ! 1058: //..float64_loop: ! 1059: //.. push esi ! 1060: //.. call fpfulong ! 1061: //.. pop esi ! 1062: //.. add esi,4 ! 1063: //.. stosd ! 1064: //.. loop float64_loop ! 1065: //.. pop ds ! 1066: //.. popad ! 1067: //.. cld ! 1068: //.. ! 1069: pop %edi // reload operand offset ! 1070: // pop %ds // reload a?msr ! 1071: mov frac32(%ebp,%edi),%eax // get long integer sign ! 1072: cltd // transmit sign to edx ! 1073: movb %dl,sign(%ebp,%edi) // and store to operand ! 1074: inc %edx // test for '-' fract ! 1075: jnz detect_zero_64 ! 1076: notl frac64(%ebp,%edi) // '-', so form 2s ! 1077: add $1,frac64(%ebp,%edi) // complement ! 1078: notl frac32(%ebp,%edi) ! 1079: adc $0,frac32(%ebp,%edi) ! 1080: jmp set_expon_64 ! 1081: ALIGN ! 1082: detect_zero_64: ! 1083: or frac64(%ebp,%edi),%eax ! 1084: jnz set_expon_64 ! 1085: mov %eax,expon(%ebp,%edi) // set expon = zero ! 1086: movb special,tag(%ebp,%edi) ! 1087: ret ! 1088: ALIGN ! 1089: set_expon_64: ! 1090: movl $0x403e,expon(%ebp,%edi) //set expon = 63 ! 1091: bsrl frac32(%ebp,%edi),%ecx ! 1092: jz top_32_zero ! 1093: mov frac64(%ebp,%edi),%eax ! 1094: sub $31,%ecx ! 1095: neg %ecx ! 1096: shldl %cl,%eax,frac32(%ebp,%edi) ! 1097: shl %cl,frac64(%ebp,%edi) ! 1098: adjust_norm_expon: ! 1099: sub %ecx,expon(%ebp,%edi) // adjust exponent ! 1100: ret ! 1101: ALIGN ! 1102: top_32_zero: ! 1103: mov frac64(%ebp,%edi),%eax ! 1104: bsrl %eax,%ecx ! 1105: sub $31,%ecx ! 1106: neg %ecx ! 1107: shl %cl,%eax ! 1108: mov %eax,frac32(%ebp,%edi) ! 1109: movl $0,frac64(%ebp,%edi) ! 1110: add $32,%ecx ! 1111: jmp adjust_norm_expon ! 1112: ALIGN ! 1113: //float64 endp ! 1114: // ! 1115: // *************************************************************************** ! 1116: // save: ! 1117: // ! 1118: // function: ! 1119: // implements 80387 save instruction ! 1120: // ! 1121: // inputs: ! 1122: // ! 1123: // outputs: ! 1124: // ! 1125: // data accessed: ! 1126: // - mem_operand_pointer result_rec_offset ! 1127: // ! 1128: // data changed: ! 1129: // ! 1130: // procedures called: ! 1131: // save_status save_regs init ! 1132: // ! 1133: // ************************************************************************** ! 1134: ALIGN ! 1135: save: //proc ! 1136: call save_status ! 1137: call save_regs ! 1138: jmp init // initialize environment ! 1139: //save endp ! 1140: // ! 1141: // ************************************************************************* ! 1142: // save_regs: ! 1143: // ! 1144: // function: ! 1145: // saves all registers in contiguous memory locations. ! 1146: // ! 1147: // inputs: ! 1148: // memory operand pointer (in es:(di)) ! 1149: // ! 1150: // outputs: ! 1151: // ! 1152: // data accessed: ! 1153: // ! 1154: // data changed: ! 1155: // ! 1156: // procedures called: ! 1157: // get_top ! 1158: // ! 1159: // *************************************************************************** ! 1160: ALIGN ! 1161: save_regs: //proc ! 1162: movb $5,%cl // 5 words per register ! 1163: call get_top // ax = top * 5 ! 1164: push %ds // set source seg register ! 1165: push %gs ! 1166: pop %ds ! 1167: mulb %cl ! 1168: movw $40,%cx // number words to move ! 1169: subw %ax,%cx // from top of stack = ! 1170: mov $sr_regstack,%esi // 40 - top*5 ! 1171: push %esi // starting address = ! 1172: cwtl ! 1173: add %eax,%esi // %gs:sr_regstack + top*5 ! 1174: add %eax,%esi // *2 bytes/word ! 1175: movzwl %cx,%ecx ! 1176: FAST_MOVSW ! 1177: movw %ax,%cx // move (top * 5) words ! 1178: pop %esi // load starting address ! 1179: FAST_MOVSW ! 1180: pop %ds // restore %ds ! 1181: ret ! 1182: //save_regs endp ! 1183: // ! 1184: // ***************************************************************************** ! 1185: // restore_regs: ! 1186: // ! 1187: // function: ! 1188: // loads all registers from contiguous memory locations ! 1189: // implements 80387 restore instruction ! 1190: // ! 1191: // inputs: ! 1192: // mem_operand_pointer ! 1193: // ! 1194: // outputs: ! 1195: // loads the %gs:sr_regstack area of a?msr from memory ! 1196: // ! 1197: // data accessed: ! 1198: // ! 1199: // data changed: ! 1200: // - operand ! 1201: // ! 1202: // procedures called: ! 1203: // restore_status get_top ! 1204: // ! 1205: // ************************************************************************* ! 1206: ALIGN ! 1207: restore: //proc ! 1208: call restore_status // this call defines es ! 1209: restore_regs: ! 1210: movb $5,%cl // 5 words per register ! 1211: call get_top ! 1212: push %ds // save a?msr ! 1213: // pop %es ! 1214: // push %ds ! 1215: mulb %cl // ax = top*5 ! 1216: mov $40,%ecx // number words to move ! 1217: subw %ax,%cx // from top of stack = ! 1218: mov $sr_regstack,%edi // 40 - top*5 ! 1219: push %edi // starting address = ! 1220: cwtl ! 1221: add %eax,%edi // %gs:sr_regstack + top*5 ! 1222: add %eax,%edi // *2 bytes/word ! 1223: lds mem_operand_pointer(%ebp),%esi // source is in memory ! 1224: add $14,%esi ! 1225: cmpb $1,oprnd_siz32(%ebp) //is it a 32 bit operand ! 1226: jne status16 //no restore 16 bit status ! 1227: add $14,%esi // skip the environment ! 1228: // --------replace following line for unix ! 1229: status16: ! 1230: FAST_MOVSW ! 1231: ! 1232: //.. ! 1233: //.. pushad ! 1234: //.. push ds ! 1235: //..restor_loop: ! 1236: //.. push esi ! 1237: //.. call fpfushort ! 1238: //.. pop esi ! 1239: //.. stosw ! 1240: //.. add esi,2 ! 1241: //.. loop restor_loop ! 1242: //.. pop ds ! 1243: //.. popad ! 1244: //.. cld ! 1245: //.. ! 1246: movw %ax,%cx ! 1247: pop %edi // load starting address ! 1248: FAST_MOVSW ! 1249: pop %ds // reload a?msr ! 1250: jmp correct_tag_word ! 1251: ! 1252: // ret ! 1253: //restore endp ! 1254: // ! 1255: // ***************************************************************************** ! 1256: // set_up_indefinite: ! 1257: // ! 1258: // function: ! 1259: // puts indefinite in the operand pointed to by edi ! 1260: // ! 1261: // input: ! 1262: // edi points to operand ! 1263: // ! 1264: // output: ! 1265: // indefinite in operand, eax = 0, zf set (zf = 1) ! 1266: // ! 1267: // data accessed: ! 1268: // - operand ! 1269: // ! 1270: // data changed: ! 1271: // - operand ! 1272: // ! 1273: // **************************************************************************** ! 1274: ALIGN ! 1275: set_up_indefinite: //proc ! 1276: xor %eax,%eax ! 1277: mov %eax,frac64(%ebp,%edi) //set up indef fraction ! 1278: movl $0x0c0000000,frac32(%ebp,%edi) ! 1279: movb negative,sign(%ebp,%edi) //set sign negative ! 1280: movl $0x7fff,expon(%ebp,%edi) //set exponent to 7fffh ! 1281: movb inv,tag(%ebp,%edi) //set tag to invalid ! 1282: common_return: ! 1283: ret ! 1284: ALIGN ! 1285: //set_up_indefinite endp ! 1286: // ! 1287: // *********************************************************************** ! 1288: // exchange ! 1289: // ! 1290: // ! 1291: // function: ! 1292: // implements 80387 exchange instruction ! 1293: // ! 1294: // inputs: ! 1295: // operand(s) in operands ! 1296: // ! 1297: // outputs: ! 1298: // result(s) on stack ! 1299: // ! 1300: // data accessed: ! 1301: // - result_rec_offset offset_operand1 ! 1302: // ! 1303: // data changed: ! 1304: // ! 1305: // procedures called: ! 1306: // put_result set_stk_u_error ! 1307: // ! 1308: // ************************************************************************* ! 1309: ALIGN ! 1310: exchange: //proc ! 1311: jz do_exchange // if zf clear, then stack error ! 1312: call set_stk_u_error ! 1313: testb invalid_mask,%gs:sr_masks ! 1314: jz common_return // if unmasked error, do nothing ! 1315: do_exchange: ! 1316: // call common_clear_a_bit / put op1(top) in result(reg) ! 1317: and $~a_mask,%gs:sr_flags ! 1318: do_exchange_leave_a_bit: ! 1319: call put_op1_result ! 1320: set_zf_put_second_result: ! 1321: xor %eax,%eax // set 86 zf ! 1322: lahf // save set zf in ah ! 1323: put_second_result: ! 1324: mov $offset_operand2,%edi // put op2(reg) in res2(top) ! 1325: mov offset_result2_rec,%esi ! 1326: jmp put_result ! 1327: //exchange endp ! 1328: // ! 1329: // *********************************************************************** ! 1330: // exam: ! 1331: // ! 1332: // function: ! 1333: // implements 80387 fxam instruction ! 1334: // ! 1335: // inputs: ! 1336: // operand1 ! 1337: // ! 1338: // outputs: ! 1339: // operand type indicators set ! 1340: // ! 1341: // data accessed: ! 1342: // - tag1 sign1 ! 1343: // - msb_frac1 ! 1344: // ! 1345: // data changed: ! 1346: // ! 1347: // procedures called: ! 1348: // ! 1349: // *********************************************************************** ! 1350: ALIGN ! 1351: exam: //proc ! 1352: jz something_on_stack // branch on no stack error ! 1353: orb $(zero_mask+sign_mask),%gs:sr_flags // set s and z bits ! 1354: andb $~(a_mask+c_mask),%gs:sr_flags // clear a and c bits ! 1355: jmp check_a_bit ! 1356: ALIGN ! 1357: something_on_stack: ! 1358: andb $~(zero_mask+c_mask+a_mask+sign_mask),%gs:sr_flags ! 1359: // clear condition code bits ! 1360: movb tag1(%ebp),%al ! 1361: cmpb unsupp,%al ! 1362: je check_a_bit ! 1363: cmpb inv,%al // remove special cases ! 1364: je check_z_s_a_bits ! 1365: cmpb infinty,%al ! 1366: je set_c_to_one ! 1367: cmpb denormd,%al ! 1368: jne valid_or_zero ! 1369: orb $(zero_mask+c_mask),%gs:sr_flags // set s, z, c to 0, 1, 1 ! 1370: // for denormalized op ! 1371: jmp check_a_bit ! 1372: ALIGN ! 1373: valid_or_zero: ! 1374: testb $0x80,msb_frac1 // for valid or zero, ! 1375: jz check_z_s_a_bits // set c to msb of frac ! 1376: set_c_to_one: ! 1377: orb $c_mask,%gs:sr_flags ! 1378: check_z_s_a_bits: ! 1379: rorb $1,%al // set z-bit to lsb of tag1 ! 1380: jnc check_s_a_bits ! 1381: orb $zero_mask,%gs:sr_flags ! 1382: check_s_a_bits: ! 1383: rorb $1,%al // set s-bit to lsb-1 of tag1 ! 1384: jnc check_a_bit ! 1385: orb $sign_mask,%gs:sr_flags ! 1386: check_a_bit: ! 1387: testb $0x01,sign1(%ebp) // set a-bit to sign bit ! 1388: jz exchange_return ! 1389: orb $a_mask,%gs:sr_flags // set_a_bit ! 1390: exchange_return: ! 1391: ret ! 1392: //exam endp ! 1393: // ! 1394: // *********************************************************************** ! 1395: // fxtrac: ! 1396: // ! 1397: // function: ! 1398: // implements the 80387 fxtrac instruction ! 1399: // ! 1400: // inputs: ! 1401: // ! 1402: // outputs: ! 1403: // decomposed results in results ! 1404: // ! 1405: // data accessed: ! 1406: // - result_rec_offset result2_rec_offset ! 1407: // - offset_operand1 tag1 ! 1408: // - offset_operand2 ! 1409: // ! 1410: // data changed: ! 1411: // ! 1412: // procedures called: ! 1413: // set_up_indefinite decompose ! 1414: // do_exchange ! 1415: // ! 1416: // *********************************************************************** ! 1417: ALIGN ! 1418: fxtrac: //proc ! 1419: jz detect_i_error // branch if no stack error ! 1420: call set_stk_u_error // set invalid error and stack bit, but ! 1421: // clear c1 (a) bit ! 1422: testb invalid_mask,%gs:sr_masks ! 1423: jz quick_out // branch if error unmasked ! 1424: mov $offset_operand2,%edi // for masked invalid error, ! 1425: call set_up_indefinite // set op2 to indefinite ! 1426: orb true,%al // clear zf to indicate that ! 1427: lahf // stack underflow occurred. ! 1428: jmp put_second_result ! 1429: ALIGN ! 1430: detect_i_error: ! 1431: call stack_full_ ! 1432: jz other_i_error_ ! 1433: jmp set_zf_put_second_result ! 1434: ALIGN ! 1435: other_i_error_: ! 1436: andb $~a_mask,%gs:sr_flags // clear a-bit ! 1437: movl $0,before_error_signals(%ebp) // initialize all to zero ! 1438: movb tag1(%ebp),%al // load operand tag ! 1439: cmpb unsupp,%al ! 1440: jne is_op1_nan_ ! 1441: testb invalid_mask,%gs:sr_masks // short cut if unmasked i-error ! 1442: jnz put_indef_in_op1 ! 1443: unmasked_i_error: ! 1444: orb invalid_mask, %gs:sr_errors ! 1445: quick_out: ! 1446: ret // return if unmasked error ! 1447: ALIGN ! 1448: put_indef_in_op1: ! 1449: mov $offset_operand1, %edi ! 1450: call set_up_indefinite ! 1451: jmp masked_i_error ! 1452: ALIGN ! 1453: is_op1_nan_: ! 1454: cmpb inv,%al ! 1455: jne do_decompose ! 1456: testb $0x40,msb_frac1 // is op1 a signaling nan? ! 1457: jnz op1_is_qnan ! 1458: testb invalid_mask,%gs:sr_masks ! 1459: jz unmasked_i_error ! 1460: orb $0x40,msb_frac1 // make op1 a quiet nan ! 1461: masked_i_error: ! 1462: movb true, signal_i_error_ ! 1463: op1_is_qnan: ! 1464: lea dword_frac1(%ebp),%esi // move op1 to op2 ! 1465: lea dword_frac2(%ebp),%edi ! 1466: call move_op_to_op ! 1467: call put_op1_result // no push occurs here ! 1468: jmp set_zf_put_second_result // put both results ! 1469: ALIGN ! 1470: do_decompose: ! 1471: call decompose ! 1472: jmp do_exchange // put both results ! 1473: ALIGN ! 1474: //fxtrac endp ! 1475: // ! 1476: // *********************************************************************** ! 1477: // abs_value: ! 1478: // ! 1479: // function: ! 1480: // implements the 80387 absolute value instruction ! 1481: // ! 1482: // inputs: ! 1483: // assumes operand is set up ! 1484: // ! 1485: // outputs: ! 1486: // absolute value of operand in result ! 1487: // ! 1488: // procedures called: ! 1489: // set_stk_u_error ! 1490: // ! 1491: // *************************************************************************** ! 1492: ALIGN ! 1493: abs_value: //proc ! 1494: jz do_abs_value // branch if no stack error ! 1495: call set_stk_u_error // set invalid error and stack bit, ! 1496: // but clear c1 (a) bit ! 1497: testb invalid_mask,%gs:sr_masks ! 1498: jnz abs_value_result // masked error, so give indef already ! 1499: common_exit: // set up in operand1 by fetch_an_op. ! 1500: ret // unmasked error ! 1501: ALIGN ! 1502: do_abs_value: ! 1503: movb positive,sign1(%ebp)// set sign to positive ! 1504: abs_value_result: ! 1505: jmp common_clear_a_bit // put result on stack ! 1506: //abs_value endp ! 1507: // ! 1508: // *********************************************************************** ! 1509: // chsign: ! 1510: // ! 1511: // function: ! 1512: // implement the 80387 chsign instruction ! 1513: // ! 1514: // inputs: ! 1515: // operand1 ! 1516: // ! 1517: // outputs: ! 1518: // result <== -(operand1) ! 1519: // ! 1520: // procedures called: ! 1521: // set_stk_u_error ! 1522: // ! 1523: // ************************************************************************ ! 1524: ALIGN ! 1525: chsign: //proc ! 1526: jz do_chsign // branch if no stack error ! 1527: call set_stk_u_error // set invalid error and stack bit, but ! 1528: // clear c1 (a) bit ! 1529: testb invalid_mask,%gs:sr_masks ! 1530: jnz chsign_result // put op1, set up as qnan indefinite ! 1531: ret // by fetch_an_op, into result ! 1532: ALIGN ! 1533: do_chsign: ! 1534: notb sign1(%ebp) // complement sign ! 1535: chsign_result: ! 1536: jmp common_clear_a_bit // put op1 into result ! 1537: ALIGN ! 1538: //chsign endp ! 1539: // ! 1540: //a_med ends ! 1541: // ! 1542: // end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.