![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fp_divmul.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_divmul.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 "divmul.s" ! 26: ! 27: .ident "@(#)kern-fp:divmul.s 1.1" ! 28: ! 29: // *********************************************************************** ! 30: // ! 31: // m u l d i v . 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: // preforms floating-point divide of unpacked ! 44: // non-zero, valid numbers. ! 45: // performs floating-point multiply of unpacked ! 46: // non-zero, valid numbers. ! 47: // ! 48: // public procedures: ! 49: // mulx mult ! 50: // divx divid ! 51: // ! 52: // **************************************************************************** ! 53: // ! 54: //...september 16, 1983... ! 55: // ! 56: // .file *a_mdm* ! 57: //$nolist ! 58: #include "fp_e80387.h" ! 59: //$list ! 60: .text //a_med segment er public ! 61: // ! 62: // extrn sticky_right_shift,one_left_normalize ! 63: // extrn clear_5w,test_5w,test_3w,set_5w ! 64: // extrn get_precision,set_i_error ! 65: // extrn left_shift_result_cl ! 66: // ! 67: .globl accel_divx ! 68: .globl divx ! 69: .globl divid ! 70: .globl log_divx ! 71: .globl mulx ! 72: .globl mult ! 73: // ! 74: ALIGN ! 75: quotient_length: ! 76: .byte 28,36,57,68 // incremented and changed to ! 77: log_quotient_length: ! 78: .byte 28,36,60,68 // a byte table on 12/02/82. ! 79: // for unknown reasons, divx ! 80: // doesnt work with 53-bit ! 81: // precision from log function ! 82: low_quotient_byte: ! 83: .byte offset_result+6,offset_result+4 ! 84: .byte offset_result+2,offset_result+1 ! 85: //$eject ! 86: // ********************************************************************* ! 87: // accel_divx: ! 88: // ********** ! 89: // function: ! 90: // fractional divide. result_frac <-- frac1/frac2. ! 91: // ! 92: // inputs: ! 93: // frac2 is assumed to be normalized and non-zero. ! 94: // ! 95: // outputs: ! 96: // the sticky bit is set for result_frac ! 97: // the remainder for ((frac1)/2)mod(frac2) is left in frac1 ! 98: // ! 99: // data accessed: ! 100: // - dword_frac1 offset_operand2 ! 101: // - dword_frac2 result_dword_frac ! 102: // - lsb_result offset_operand1 ! 103: // ! 104: // data changed: ! 105: // - dword_frac1 result_dword_frac ! 106: // - lsb_result ! 107: // ! 108: // procedures called: ! 109: // sticky_right_shift get_precision ! 110: // ! 111: // ********************************************************************* ! 112: ALIGN ! 113: divisor_dwords: ! 114: .byte 1,2,2,2 ! 115: quotient_dwords: ! 116: .byte 1,2,2,3 ! 117: ! 118: #define r_apprx_j extra_dword_reg(%ebp) ! 119: #define q_apprx_j extra_dword_reg+4(%ebp) ! 120: #define carry extra_dword_reg+8(%ebp) ! 121: ! 122: ALIGN ! 123: accel_divx: //proc ! 124: clr_quo: ! 125: mov $offset_result,%edi ! 126: call clear_6w // clears eax as well. ! 127: mov $offset_operand1,%edi // shift frac1 (here, the dividend) ! 128: movb $1,%cl // right by 1 bit ! 129: call sticky_right_shift ! 130: call get_precision ! 131: cmpb prec64,%dl ! 132: je prec_to_base ! 133: movb dword_frac1+3(%ebp),%cl ! 134: movb %cl,lsb_result ! 135: prec_to_base: ! 136: movzbl %dl,%ebx ! 137: movl $quotient_dwords,%edi //(edi) has offset quotient_dwords table ! 138: movzbl %cs:(%ebx,%edi),%ecx // q holds the number of dwords ! 139: movb %cl,q // to be produced for the quotient. ! 140: lea dword_frac1+frac64(%ebp),%esi ! 141: push %ss:4(%esi) ! 142: ! 143: testb $1, is16bit(%ebp) ! 144: jz prec_32 ! 145: movzwl %sp, %edx ! 146: jmp prec_32c ! 147: ALIGN ! 148: prec_32: ! 149: mov %esp,%edx // edx holds the offset relative to ss of the ! 150: // interim partial remainders highest dword. ! 151: prec_32c: ! 152: dec %ecx ! 153: jnz push_dvdnd ! 154: inc %ecx ! 155: FALLSTHRU ! 156: push_dvdnd: ! 157: push %ss:(%esi) ! 158: sub $4,%esi ! 159: LOOP(push_dvdnd) ! 160: set_up_push_dvsr: ! 161: mov %ecx,%eax // ecx is 0 here. ! 162: movl $divisor_dwords,%edi ! 163: movb %cs:(%ebx,%edi),%cl // bit_ct holds the number of ! 164: movb %cl,bit_ct // dwords in the divisor. ! 165: FALLSTHRU ! 166: push_zeroes: ! 167: push %eax ! 168: LOOP(push_zeroes) ! 169: mov %edx,%ebx // ebx holds the offset relative to ss of the ! 170: // interim partial remainders highest word. ! 171: mov %eax,%edi // edi is index to words of quotient. ! 172: movb q,%cl ! 173: main_loop: ! 174: push %ecx ! 175: mov %ss:(%ebx),%edx ! 176: cmp dword_frac2+frac32(%ebp),%edx // is dvsr(1) = prem(j)? ! 177: jne do_divide ! 178: movl $0x0ffffffff,%eax // eax <-- apprx_q(j) = 2**32 - 1 ! 179: movl %ss:-4(%ebx),%edx // edx <-- prem(j+1) ! 180: jmp get_r_apprx_j ! 181: ALIGN ! 182: do_divide: ! 183: movl %ss:-4(%ebx),%eax // (edx,eax) <-- prem(j) * 2**32 + prem(j+1) ! 184: divl dword_frac2+frac32(%ebp) ! 185: mov %eax,q_apprx_j ! 186: mov %edx,r_apprx_j ! 187: jmp test_q_apprx_j ! 188: ALIGN ! 189: dec_q_apprx_j: ! 190: mov q_apprx_j,%eax ! 191: dec %eax ! 192: mov r_apprx_j,%edx ! 193: get_r_apprx_j: ! 194: mov %eax,q_apprx_j ! 195: add dword_frac2+frac32(%ebp),%edx // r_apprx_j <-- edx + dvsr(1) ! 196: jc adjst_prem ! 197: mov %edx,r_apprx_j ! 198: test_q_apprx_j: ! 199: mov q_apprx_j,%eax ! 200: mull dword_frac2+frac64(%ebp) // (edx,eax) <-- dvsr(2)*q_apprx_j ! 201: cmp r_apprx_j,%edx ! 202: jb adjst_prem ! 203: ja dec_q_apprx_j ! 204: cmp %ss:-8(%ebx),%eax // is eax > prem(j+2)? ! 205: ja dec_q_apprx_j ! 206: adjst_prem: ! 207: xor %eax,%eax ! 208: mov %eax,carry ! 209: movb bit_ct,%al ! 210: mov %eax,%ecx ! 211: shl $2,%eax ! 212: neg %eax ! 213: mov %eax,%esi ! 214: FALLSTHRU ! 215: prem_loop: ! 216: mov sign2(%ebp,%esi),%eax ! 217: mull q_apprx_j ! 218: sub %eax,%ss:(%ebx,%esi) ! 219: jnc sbtrct_carry ! 220: inc %edx ! 221: sbtrct_carry: ! 222: mov carry,%eax ! 223: sub %eax,%ss:(%ebx,%esi) ! 224: jnc next_carry ! 225: inc %edx ! 226: next_carry: ! 227: mov %edx,carry ! 228: add $4,%esi ! 229: LOOP(prem_loop) ! 230: // ! 231: sub %edx,%ss:(%ebx,%esi) // here, esi = 0. ! 232: jnc next_j ! 233: decl q_apprx_j ! 234: movb bit_ct,%cl ! 235: mov %ecx,%eax ! 236: shl $2,%eax ! 237: neg %eax ! 238: mov %eax,%esi ! 239: clc ! 240: FALLSTHRU ! 241: fix_prem_loop: ! 242: mov sign2(%ebp,%esi),%eax ! 243: adc %eax,%ss:(%ebx,%esi) ! 244: add $4,%esi ! 245: LOOP(fix_prem_loop) ! 246: // ! 247: adc %ecx,%ss:(%ebx,%esi) ! 248: next_j: ! 249: mov q_apprx_j,%eax ! 250: mov %eax,result_dword_frac+frac32(%ebp,%edi) ! 251: pop %ecx ! 252: dec %ecx ! 253: jz get_sticky_bit ! 254: sub $4,%ebx ! 255: sub $4,%edi ! 256: jmp main_loop ! 257: ALIGN ! 258: // ! 259: get_sticky_bit: ! 260: mov %ecx,%eax ! 261: mov %eax,%esi ! 262: movb bit_ct,%cl ! 263: shlb $1,%cl ! 264: FALLSTHRU ! 265: sticky_loop: ! 266: // orw %ax,%ss:(%ebx+%esi-2) // bug in asm386 hardcoded ! 267: .byte 0x066,0x36,0x00b,0x44,0x33,0x0fe ! 268: ! 269: sub $2,%esi ! 270: LOOP(sticky_loop) ! 271: orb %al,%ah ! 272: orb %ah,lsb_result ! 273: mov %ecx,%esi ! 274: movb bit_ct,%cl ! 275: // ! 276: FALLSTHRU ! 277: stor_rmndr: ! 278: // movl %eax,%ss:(%ebx+%esi-4) // bug in asm386 hard coded ! 279: .byte 0x36,0x8b,0x44,0x33,0x0fc ! 280: ! 281: mov %eax,dword_frac1+frac32(%ebp,%esi) ! 282: sub $4,%esi ! 283: LOOP(stor_rmndr) ! 284: // ! 285: movb q,%cl ! 286: addb bit_ct,%cl ! 287: cmpb $2,%cl ! 288: jne get_stack_dwords ! 289: inc %ecx ! 290: get_stack_dwords: ! 291: shl $2,%ecx ! 292: add %ecx,%esp // restore stack ! 293: // ! 294: ret ! 295: //accel_divx endp ! 296: // ********************************************************************* ! 297: // divx: ! 298: // **** ! 299: // function: ! 300: // fractional divide. result_frac <-- frac1/frac2. ! 301: // ! 302: // inputs: ! 303: // frac2 is assumed to be normalized and non-zero. ! 304: // ! 305: // outputs: ! 306: // the sticky bit is set for result_frac ! 307: // the remainder is left in frac1 ! 308: // ! 309: // data accessed: ! 310: // - word_frac1 offset_operand2 ! 311: // - word_frac2 result_word_frac ! 312: // - lsb_result ! 313: // ! 314: // data changed: ! 315: // - word_frac1 result_word_frac ! 316: // - lsb_result ! 317: // ! 318: // procedures called: ! 319: // sticky_right_shift get_precision ! 320: // ! 321: // ********************************************************************* ! 322: ALIGN ! 323: divx: //proc ! 324: push $quotient_length // set normal entry ptr ! 325: jmp clear_quotient ! 326: ALIGN ! 327: log_divx: ! 328: push $log_quotient_length // set log entry ptr ! 329: clear_quotient: ! 330: mov $offset_result,%edi ! 331: call clear_6w ! 332: mov $offset_operand2,%edi //shift frac2 (divisor) ! 333: movb $1,%cl //right by 1 bit ! 334: call sticky_right_shift ! 335: call get_precision ! 336: movzbl %dl, %ebx ! 337: pop %edi //retrieve offset quotient length table ! 338: movb %cs:(%ebx,%edi),%al // bit_ct holds ! 339: movb %al,bit_ct // the quotient bits ! 340: movzbl %cs:low_quotient_byte(%ebx),%eax //(edi) points to low- ! 341: //order byte of quotient ! 342: mov %eax,%edi ! 343: movl dword_frac1(%ebp),%eax //load dividend (frac1) ! 344: movl dword_frac1+frac64(%ebp),%ebx // in frac1 ! 345: movl dword_frac1+frac32(%ebp),%edx ! 346: .long 0x02d8ac0f //shrd eax, ebx, 2 ! 347: .long 0x02d3ac0f //shrd ebx, edx, 2 ! 348: shrl $2,%edx //shift dvdnd rt 2 bits ! 349: jmp subtract_divisor ! 350: ALIGN ! 351: frac_divide_loop: ! 352: shll $1,%eax //shift dvdnd (partial ! 353: rcll $1,%ebx //remainder) lft one bit ! 354: rcll $1,%edx ! 355: jc quotient_bit_0 //jump if cy from shift ! 356: orb $0x20,frac80(%ebp,%edi) // *shift in* a 1-bit ! 357: subtract_divisor: ! 358: subl dword_frac2(%ebp),%eax //subtract divisor from ! 359: sbbl dword_frac2+frac64(%ebp),%ebx //partial remainder ! 360: sbbl dword_frac2+frac32(%ebp),%edx ! 361: jmp shift_quotient_left ! 362: ALIGN ! 363: quotient_bit_0: ! 364: call add_divisor // add divisor to prem ! 365: shift_quotient_left: ! 366: call shift_result_left ! 367: decb bit_ct // decrement bit count ! 368: jnz frac_divide_loop // next quotient bit ! 369: andl %edx,%edx // branch if remainder ! 370: js adjust_remainder // is negative ! 371: orb $0x20,frac80(%ebp,%edi) // *shift in* last 1-bit ! 372: jmp store_remainder ! 373: ALIGN ! 374: adjust_remainder: ! 375: call add_divisor //add divisor to prem ! 376: store_remainder: ! 377: movl %eax,dword_frac1(%ebp) //store partial rmndr ! 378: movl %ebx,dword_frac1+frac64(%ebp) // in frac1 ! 379: movl %edx,dword_frac1+frac32(%ebp) ! 380: orl %ebx,%eax //set sticky bits if ! 381: orl %edx,%eax //partial rmndr non-zero ! 382: .long 0x10c2a40f // shld edx, eax, 16 ! 383: orw %dx, %ax ! 384: orb %al,%ah ! 385: movb %ah,lsb_result ! 386: ret ! 387: ALIGN ! 388: add_divisor: ! 389: addl dword_frac2(%ebp),%eax //store partial rmndr ! 390: adcl dword_frac2+frac64(%ebp),%ebx // in frac1 ! 391: adcl dword_frac2+frac32(%ebp),%edx ! 392: ret ! 393: ALIGN ! 394: shift_result_left: ! 395: shll $1,result_dword_frac(%ebp) ! 396: rcll $1,result_dword_frac+frac64(%ebp) ! 397: rcll $1,result_dword_frac+frac32(%ebp) ! 398: ret ! 399: //divx endp ! 400: //$eject ! 401: // ************************************************************************* ! 402: // divid: ! 403: // ****** ! 404: // function: ! 405: // floating-point divide. ! 406: // ! 407: // inputs: ! 408: // assumes operands are unpacked, non-zero, and valid ! 409: // ! 410: // outputs: ! 411: // calculates unpacked result and returns with al ! 412: // set to true if underflow is possible, false if ! 413: // overflow is possible. the quotient is left in ! 414: // the result, and the remainder is left in frac1. ! 415: // ! 416: // data accessed: ! 417: // - expon1 expon2 ! 418: // - msb_frac2 offset_result ! 419: // - result_sign result_expon ! 420: // - result_word_frac ! 421: // ! 422: // data changed: ! 423: // - result_sign result_expon ! 424: // - result_word_frac ! 425: // ! 426: // procedures called: ! 427: // divx one_left_normalize ! 428: // set_i_error get_precision ! 429: // left_shift_result_cl ! 430: // ! 431: // ************************************************************************* ! 432: ALIGN ! 433: divid: //proc ! 434: movl dword_expon1,%eax // stack underflow possible ! 435: subl dword_expon2,%eax // flag (sign bit) ! 436: addl $exponent_bias,%eax //form biased exponent ! 437: movl %eax,dword_result_expon ! 438: movb sign1(%ebp),%al // sign = '+' if sign1 = sign2 ! 439: xorb sign2(%ebp),%al ! 440: movb %al,result_sign(%ebp) ! 441: fractional_divide: ! 442: call accel_divx ! 443: // The following five lines are not to be used when accel_divx ! 444: // does the division instead of divx. ! 445: // call get_precision ! 446: // cmpb prec53,%dl /if double precision, shift ! 447: // jne norm_quotient / quotient left 3 bits ! 448: // movb $3,%cl ! 449: // call left_shift_result_cl ! 450: norm_quotient: ! 451: mov $offset_result,%edi //normalize by 1 left ! 452: jmp one_left_normalize // shift, if unnormalized ! 453: ALIGN ! 454: //divid endp ! 455: //$eject ! 456: // ********************************************************************** ! 457: // mult: ! 458: // **** ! 459: // function: ! 460: // floating point multiply. ! 461: // ! 462: // inputs: ! 463: // assumes operands are unpacked, valid, non-zero. ! 464: // ! 465: // outputs: ! 466: // calculates unpacked result and returns with al set ! 467: // to true if underflow is possible, false if overflow ! 468: // is possible. ! 469: // ! 470: // data accessed: ! 471: // - sign1 expon1 ! 472: // - sign2 expon2 ! 473: // - offset_result result_sign ! 474: // - result_expon ! 475: // ! 476: // data changed: ! 477: // - result ! 478: // ! 479: // procedures called: ! 480: // mulx norm_quotient ! 481: // ! 482: // **************************************************************************** ! 483: ALIGN ! 484: mult: //proc ! 485: movl dword_expon1,%eax //form doubly-biased exponent ! 486: addl dword_expon2,%eax //if high bit set, underflow ! 487: subl $exponent_bias-1,%eax //form singly-biased exponent ! 488: movl %eax,dword_result_expon ! 489: movb sign1(%ebp),%al // result sign = sign1 xor sign2 ! 490: xorb sign2(%ebp),%al ! 491: movb %al,result_sign(%ebp) ! 492: call mulx ! 493: movl $offset_result, %edi //normalize by 1 left ! 494: jmp one_left_normalize // shift if unnormalized ! 495: //mult endp ! 496: //$eject ! 497: // ********************************************************************** ! 498: // mulx: ! 499: // ***** ! 500: // function: ! 501: // fractional multiply. result_frac <-- frac1 * frac2. ! 502: // ! 503: // inputs: ! 504: // assumes the operands are unpacked, valid, non-zero. ! 505: // ! 506: // outputs: ! 507: // product in result_frac (sticky indicator left in low bit) ! 508: // ! 509: // data accessed: ! 510: // - word_frac1 offset_operand1 ! 511: // - word_frac2 offset_operand2 ! 512: // - extra_word_reg lsb_result ! 513: // - offset_result ! 514: // ! 515: // data changed: ! 516: // - extra_word_reg offset_result ! 517: // ! 518: // procedures called: ! 519: // clear_5w set_5w ! 520: // test_3w test_5w ! 521: // ! 522: // ************************************************************************ ! 523: ALIGN ! 524: mulx: //proc ! 525: push %ds // save a?msr ! 526: movl $extra_dword_reg,%edi // ss:bp+di => extra_word_reg ! 527: push %ss ! 528: pop %ds ! 529: lea (%ebp,%edi),%ebx // ds:bx also => extra_word_reg ! 530: call clear_6w // clear extra_word_reg ! 531: movl $offset_result,%edi // clear result_frac ! 532: call set_6w ! 533: movl $frac32,%ecx // load s.p. offset ! 534: movl $offset_operand2,%edi //di => to multiplier ! 535: call test_4w //if low 3 words <> zero, ! 536: jnz examine_frac1 // branch if non single ! 537: add %ecx,%edi //frac2 is s. p., ! 538: add %ecx,%ebx //so adjust pointers ! 539: examine_frac1: ! 540: movl $offset_operand1,%esi //si points to multiplicand ! 541: movl frac64(%ebp,%esi),%eax //if low 3 words = zero, ! 542: orl (%ebp,%esi),%eax //then single precision ! 543: jnz do_frac_multiply ! 544: add %ecx,%esi //frac1 is s. p., ! 545: add %ecx,%ebx //so adjust pointers ! 546: do_frac_multiply: ! 547: push %edi // save frac2 offset ! 548: movl (%ebp,%edi),%edi // load multiplier ! 549: xorl %ecx,%ecx //clear cx ! 550: movl (%ebp,%esi),%eax // multiply first word ! 551: mull %edi ! 552: addl %eax,(%ebx) //add to partial product ! 553: adcl %edx,%ecx // cx initially 0 ! 554: cmpl $offset_operand1, %esi ! 555: je mult_scnd ! 556: movl %ecx, 4(%ebx) //multiplicand is s. p. so ! 557: jmp end_of_mul_loop //go to multipliers next word ! 558: mult_scnd: ! 559: movl 4(%ebp,%esi),%eax // multiply second word ! 560: mull %edi ! 561: addl %ecx,%eax ! 562: adcl $0,%edx ! 563: xorl %ecx,%ecx ! 564: addl %eax,4(%ebx) //add to partial product ! 565: adcl %edx,%ecx ! 566: movl 8(%ebp,%esi), %eax ! 567: mull %edi ! 568: addl %ecx, %eax ! 569: adcl $0, %edx ! 570: addl %eax, 8(%ebx) ! 571: adcl $0, %edx ! 572: movl %edx, 12(%ebx) ! 573: end_of_mul_loop: ! 574: pop %edi // reload frac2 offset ! 575: addl $4, %ebx //adjust pointers for next iteration ! 576: addl $4, %edi ! 577: cmp $(offset_operand2+12),%edi ! 578: jne do_frac_multiply ! 579: movl $extra_dword_reg,%edi //set sticky bit if any extra ! 580: call test_6w // reg words are nonzero ! 581: jz frac_mult_done ! 582: orb $0x01,lsb_result ! 583: frac_mult_done: ! 584: pop %ds // restore a?msr ! 585: ret ! 586: //mulx endp ! 587: // ! 588: //a_med ends ! 589: // ! 590: // end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.