![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fp_lipsq.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_lipsq.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 "lipsq.s" ! 26: ! 27: .ident "@(#)kern-fp:lipsq.s 1.1" ! 28: ! 29: // *************************************************************************** ! 30: // ! 31: // l i p s q . m o d ! 32: // ================= ! 33: // ! 34: // =============================================================== ! 35: // intel corporation proprietary information ! 36: // this software is supplied under the terms of a license ! 37: // agreement or non-disclosure agreement with intel corporation ! 38: // and may not be copied nor disclosed except in accordance with ! 39: // the terms of that agreement. ! 40: // =============================================================== ! 41: // ! 42: // functions: ! 43: // implements the loading of the constants: ! 44: // one, log base 2 of ten, log base 2 of e, pi, ! 45: // log base 10 of 2, log base e of 2, and zero. ! 46: // implements the 80387 square root instruction. ! 47: // implements the 80387 integer part instruction. ! 48: // ! 49: // public procedures: ! 50: // load_con sqrt intpt ! 51: // ! 52: // ***************************************************************************** ! 53: // ! 54: //...september 16, 1983... ! 55: // ! 56: // .file *a_mli* ! 57: // ! 58: //$nolist ! 59: #include "fp_e80387.h" ! 60: //$list ! 61: .text //a_med segment er public ! 62: // ! 63: // extrn put_si_result,sticky_right_shift,round ! 64: // extrn addition_normalize,left_shift,getx ! 65: // extrn set_up_indefinite,clear_6w,set_6w ! 66: // extrn test_4w,left_shift_result_cl ! 67: // extrn left_shift_frac1_cl,left_shift_frac2_cl ! 68: // extrn add_to_frac_2,gradual_underflow ! 69: // extrn subtraction_normalize,put_indefinite ! 70: // extrn i_masked_,set_i_masked_,set_d_masked_ ! 71: // extrn affine_infinity_,get_precision ! 72: // ! 73: .globl load_con ! 74: .globl intpt ! 75: .globl sqrt ! 76: // ! 77: // temp real floating point numbers for push constant instructions ! 78: // ! 79: treal_table: ! 80: .value 0x00000,0x00000,0x00000,0x00000,0x08000,0x03fff //treal_one ! 81: .value 0x04000,0x08afe,0x0cd1b,0x0784b,0x0d49a,0x04000 //treal_l2t ! 82: .value 0x0c000,0x0f0bb,0x05c17,0x03b29,0x0b8aa,0x03fff //treal_l2e ! 83: .value 0x0c000,0x0c234,0x02168,0x0daa2,0x0c90f,0x04000 //treal_pi ! 84: .value 0x0a000,0x0f798,0x0fbcf,0x09a84,0x09a20,0x03ffd //treal_lg2 ! 85: .value 0x0e000,0x079ab,0x0d1cf,0x017f7,0x0b172,0x03ffe //treal_ln2 ! 86: .value 0x00000,0x00000,0x00000,0x00000,0x00000,0x00000 //treal_0 ! 87: //$eject ! 88: // *************************************************************** ! 89: // load_con ! 90: // ****** ! 91: // function: ! 92: // implements the load constants instructions. ! 93: // ! 94: // inputs: ! 95: // offset of fpn pointer in bx register. ! 96: // ! 97: // outputs: ! 98: // constant value on top of stack ! 99: // ! 100: // data accessed: ! 101: // - offset_result ! 102: // ! 103: // data changed: ! 104: // - mem_operand_pointer ! 105: // ! 106: // procedures called: ! 107: // getx ! 108: // ! 109: // ******************************************************************* ! 110: // all load constant instructions use the same entry point. ! 111: // ! 112: ALIGN ! 113: load_con: //proc near ! 114: // ! 115: // the contents of bx is used as an index to treal_table. ! 116: // getx unpacks the extended floating point number and put_result ! 117: // pushes the value to the top of the 80387 stack. ! 118: // ! 119: shrb $1,%bl //take care of extra shi ! 120: mov $0x06,%eax //treal_table ptr = cs: ! 121: mulb %bl // index * 6 - (6 * 2) ! 122: add $(treal_table-(load_1_op*12)),%eax // * (load_1_op) ! 123: mov %eax, %esi ! 124: movl $0, result_dword_frac(%ebp) ! 125: movw %cs:(%esi), %ax ! 126: movw %ax, result_dword_frac+frac80(%ebp) ! 127: mov %cs:2(%esi), %eax ! 128: mov %eax, result_dword_frac+frac64(%ebp) ! 129: mov %cs:6(%esi), %eax ! 130: mov %eax, result_dword_frac+frac32(%ebp) ! 131: movzwl %cs:10(%esi), %eax ! 132: mov %eax, dword_result_expon ! 133: xor %eax, %eax ! 134: mov %eax, result_sign(%ebp) ! 135: movb prec64, %dl ! 136: mov $offset_result, %edi ! 137: call round ! 138: mov $offset_result, %edi ! 139: call addition_normalize ! 140: andb $~a_mask, %gs:sr_flags ! 141: xor %eax, %eax ! 142: mov before_error_signals(%ebp), %eax ! 143: lahf ! 144: mov $offset_result, %edi ! 145: jmp put_si_result ! 146: //load_con endp ! 147: //$eject ! 148: // *********************************************************************** ! 149: // intpt: ! 150: // ***** ! 151: // function: ! 152: // implements 80387 integer part instruction ! 153: // ! 154: // inputs: ! 155: // ! 156: // outputs: ! 157: // ! 158: // data accessed: ! 159: // - offset_result offset_operand1 ! 160: // - tag1 expon1 ! 161: // - word_frac1 ! 162: // ! 163: // data changed: ! 164: // - tag1 expon1 ! 165: // - result ! 166: // ! 167: // procedures called: ! 168: // get_operand gradual_underflow ! 169: // round subtraction_normalize ! 170: // put_si_result test_4w ! 171: // i_masked? set_i_masked? ! 172: // set_d_masked? ! 173: // ! 174: // ************************************************************************** ! 175: ALIGN ! 176: intpt: //proc ! 177: // movb true,%ah / load constant ! 178: jz separate_cases // branch if no stack error ! 179: call set_stk_u_error ! 180: testb invalid_mask, %gs:sr_masks ! 181: jz intpt_done ! 182: jmp put_op1_result //math stack error, so return indef ! 183: ALIGN ! 184: separate_cases: ! 185: andb $~a_mask, %gs:sr_flags //initialize a-bit to zero ! 186: movb tag1(%ebp), %al // load op1 tag ! 187: cmpb valid,%al ! 188: je valid_case ! 189: cmpb denormd,%al ! 190: je denormalized_operand ! 191: cmpb unsupp,%al ! 192: jne check_nan ! 193: movl $offset_operand1, %edi ! 194: call set_up_indefinite ! 195: set_i_err: ! 196: orb invalid_mask, %gs:sr_errors ! 197: testb invalid_mask, %gs:sr_masks ! 198: jz intpt_done ! 199: jmp put_op1_result // masked_i error so return indef ! 200: ALIGN ! 201: intpt_done: ! 202: ret ! 203: ALIGN ! 204: check_nan: ! 205: cmpb inv, %al ! 206: je kind_of_nan_ ! 207: jmp put_op1_result //infinity or zero, same answer ! 208: ALIGN ! 209: kind_of_nan_: ! 210: testb $0x40, msb_frac1 ! 211: jz make_qnan ! 212: jmp put_op1_result // op1 is a qnan so pass it through ! 213: ALIGN ! 214: make_qnan: ! 215: orb $0x40, msb_frac1 //op1 is an snan so make it a qnan ! 216: jmp set_i_err //and signal i_error ! 217: ALIGN ! 218: denormalized_operand: ! 219: orb denorm_mask, %gs:sr_errors ! 220: testb denorm_mask, %gs:sr_masks ! 221: jz intpt_done ! 222: movw $0x0001,expon1(%ebp) //if masked d-error, make valid ! 223: movb valid,tag1(%ebp) ! 224: valid_case: ! 225: movl $0x403e,%eax ! 226: cmpl %eax,dword_expon1 //if expon >=63, then number ! 227: jge give_op1 // is already an integer ! 228: mov $offset_operand1,%edi //gradual uflow until expon=63 ! 229: push %edi ! 230: call gradual_underflow ! 231: pop %edi //round to precision 64 ! 232: movb prec64,%dl ! 233: movb false,%al ! 234: call round ! 235: cmpb true, rnd1_inexact ! 236: jne detect_zero ! 237: orb $inexact_mask, %gs:sr_errors ! 238: cmpb true,added_one ! 239: jne detect_zero ! 240: orb $a_mask, %gs:sr_flags ! 241: detect_zero: ! 242: xor %eax,%eax ! 243: movl $dword_frac1+4,%edi //if fraction = 0, result = 0 ! 244: call test_4w ! 245: jz zero_result ! 246: mov $offset_operand1,%edi //normalize ! 247: call subtraction_normalize ! 248: jmp put_op1_result ! 249: ALIGN ! 250: zero_result: ! 251: movl %eax,dword_expon1 //set result to true zero ! 252: movb special,tag1(%ebp) ! 253: give_op1: ! 254: jmp put_op1_result ! 255: //intpt endp ! 256: //$eject ! 257: // *************************************************************************** ! 258: // sqrtx: ! 259: // ! 260: // function: ! 261: // fractional square root routine. ! 262: // ! 263: // inputs: ! 264: // assumes valid, non-zero,positive, normalized ! 265: // fraction is in frac1. ! 266: // ! 267: // outputs ! 268: // leaves fractional square root in result. ! 269: // ! 270: // data accessed: ! 271: // - offset_operand1 lsb_frac1 ! 272: // - offset_operand2 word_frac2 ! 273: // - offset_result lsb_frac2 ! 274: // - result_word_frac lsb_result ! 275: // - msb_frac1 ! 276: // ! 277: // data changed: ! 278: // - word_frac2 lsb_frac2 ! 279: // - result_word_frac lsb_result ! 280: // ! 281: // procedures called: ! 282: // left_shift_result_cl left_shift_frac1_cl ! 283: // left_shift_frac2_cl clear_6w ! 284: // set_6w add_to_frac_2 ! 285: // ! 286: // *********************************************************************** ! 287: ALIGN ! 288: sqrtx: //proc ! 289: movl $result_dword_frac,%edi //during this computation, ! 290: call clear_6w //the lsb of the result will ! 291: mov $dword_frac2,%edi // hold g and s, and the msb ! 292: call set_6w // will hold carry-out bits ! 293: and $0x000000ff,%ecx //clear high word ! 294: stc //cf holds the quotient bit ! 295: push $65 // iterate 65 times ! 296: pushf // stack the quotient bit ! 297: jmp enter_sqrt_loop ! 298: ALIGN ! 299: sqrt_loop: ! 300: push %ecx ! 301: pushf // stack the q_bit ! 302: movb $1,%cl ! 303: call left_shift_result_cl //shift result left one bit ! 304: popf // inject the new q_bit into ! 305: pushf // the least significant byte ! 306: adcb %cl,%cl ! 307: orb %cl,1+lsb_result ! 308: movb $2,%cl // into the lsb ! 309: call left_shift_frac2_cl //shift frac2 left 2 bits ! 310: enter_sqrt_loop: ! 311: movb msb_frac1,%al //g and s bits of frac2 <-- ! 312: andb $0x0c0,%al // top 2 bits of frac1 ! 313: movb %al,lsb_frac2 ! 314: movb $2,%cl // shift frac1 left 2 ! 315: call left_shift_frac1_cl ! 316: movb $0x0c0,%al ! 317: movb 1+lsb_result,%ah ! 318: popf //test q_bit ! 319: jc q_bit_set ! 320: shl $16,%eax ! 321: call add_to_frac2 //frac2.gs <-- frac2.gs + ! 322: jmp set_q_bit //result.11 ! 323: q_bit_set: ! 324: notb %ah //frac2.gs <-- frac2.gs + ! 325: shl $16,%eax //take care of extra low word ! 326: add %eax,dword_frac2(%ebp) //not(result).11 ! 327: mov result_dword_frac+frac64(%ebp),%eax ! 328: not %eax ! 329: adc %eax,dword_frac2+frac64(%ebp) ! 330: mov result_dword_frac+frac32(%ebp),%eax ! 331: not %eax ! 332: adc %eax,dword_frac2+frac32(%ebp) ! 333: set_q_bit: ! 334: pop %ecx // reload loop count ! 335: loop sqrt_loop // loop until done ! 336: rcrb $1,%cl // set g bit of result to q_bit ! 337: orb %cl,lsb_result ! 338: movw result_word_frac,%ax //frac2 <- frac2 + ! 339: incb %ah // result + 1 ! 340: shl $16,%eax ! 341: call add_to_frac2 ! 342: mov $dword_frac2+frac64,%edi //if frac2 = 0 then ! 343: xor %eax,%eax //s_bit of result = 0, ! 344: call test_4w //otherwise 1. ! 345: orb 1+lsb_frac2,%al ! 346: jz left_adjust_result ! 347: orb $0x40,lsb_result ! 348: left_adjust_result: ! 349: movb $8,%cl //shift result left 8 bits ! 350: jmp left_shift_result_cl // to eliminate carry ! 351: add_to_frac2: ! 352: mov $result_dword_frac,%esi // si points to the addend ! 353: mov $dword_frac2,%edi // di points to the result ! 354: jmp add_to_frac_2 // add result frac to frac2 ! 355: //sqrtx endp ! 356: //$eject ! 357: // *********************************************************************** ! 358: // sqrt: ! 359: // ! 360: // function: ! 361: // implements the 80387 sqrt instruction ! 362: // ! 363: // inputs: ! 364: // assume op1 is set up ! 365: // ! 366: // outputs: ! 367: // result ! 368: // ! 369: // data accessed: ! 370: // - result_record_offset result_expon ! 371: // - offset_operand1 tag1 ! 372: // - sign1 expon1 ! 373: // - msb_frac1 offset_operand1 ! 374: // - offset_result result_sign ! 375: // - result_tag ! 376: // ! 377: // data changed: ! 378: // - expon1 result_sign ! 379: // - result_tag result_expon ! 380: // ! 381: // procedures called: ! 382: // set_up_indefinite sticky_right_shift ! 383: // sqrtx round ! 384: // addition_normalize affine_infinity? ! 385: // set_i_masked? get_precision ! 386: // set_d_masked? put_si_result ! 387: // ! 388: // *********************************************************************** ! 389: ALIGN ! 390: sqrt: //proc ! 391: jz sqrt_cont // if stack error, sqrt done ! 392: call set_stk_u_error ! 393: testb invalid_mask, %gs:sr_masks ! 394: jnz put_op1 //masked stack error, so return indef ! 395: sqrt_done: ! 396: ret ! 397: ALIGN ! 398: sqrt_cont: ! 399: andb $~a_mask, %gs:sr_flags ! 400: movb tag1(%ebp),%al // load tag for op1 ! 401: cmpb valid,%al ! 402: jne op1_denorm_ ! 403: cmpb positive, sign1(%ebp) ! 404: jne i_error ! 405: jmp sqrt_valid_case ! 406: op1_denorm_: ! 407: cmpb denormd,%al //if op1 denormalized, then give ! 408: jne op1_zero_ ! 409: cmpb positive, sign1(%ebp) ! 410: jne i_error ! 411: jmp d_error ! 412: op1_zero_: ! 413: cmpb special,%al //if op1 = 0, then give 0 as the ! 414: je put_op1 //result ! 415: cmpb unsupp,%al ! 416: je i_error ! 417: cmpb inv,%al //if op1 inv, then give i_error ! 418: jne inf_op1 ! 419: jmp kind_of_nan_ ! 420: inf_op1: ! 421: cmpb positive, sign1(%ebp) //infinity case ! 422: je put_op1 // -infinity is invalid ! 423: i_error: ! 424: call set_i_masked_ //denormalized, unnormalized, ! 425: jz sqrt_done // negative, or proj +infinity ! 426: mov $offset_result,%edi ! 427: call set_up_indefinite //if masked i_error, then give ! 428: jmp sqrt_give_result //indefinite ! 429: put_op1: //if op1 = zero, nan, or +inf, ! 430: jmp give_op1 // then give op1 as the result ! 431: d_error: ! 432: call set_d_masked_ //op1 is denormalized ! 433: jz sqrt_done ! 434: movl $offset_operand1, %edi ! 435: call norm_denorm //if d_error masked, make valid ! 436: sqrt_valid_case: ! 437: subl $exponent_bias,dword_expon1 ! 438: testl $0x0001,dword_expon1 ! 439: jz even_expon ! 440: decl dword_expon1 //if expon1 odd, then expon1 <-- ! 441: jmp halve_exponent // expon1 - 1 ! 442: even_expon: ! 443: movb $1,%cl //if expon1 even, then shift ! 444: xorb %al,%al // frac1 right one bit ! 445: mov $offset_operand1,%edi ! 446: call sticky_right_shift ! 447: halve_exponent: ! 448: movl dword_expon1,%eax ! 449: sarl $1,%eax ! 450: addl $exponent_bias,%eax ! 451: movl %eax,dword_result_expon ! 452: call sqrtx // calculate fraction ! 453: sqrt_round_result: ! 454: xorl %eax,%eax // not second rounding ! 455: movl %eax,result_sign(%ebp) // set sign and tag ! 456: movl $offset_result,%edi // round result ! 457: call get_precision ! 458: call round ! 459: mov $offset_result,%edi ! 460: call addition_normalize //(possible renormalize) ! 461: cmpb true, rnd1_inexact ! 462: jne sqrt_give_result ! 463: orb $inexact_mask, %gs:sr_errors ! 464: cmpb true, added_one ! 465: jne sqrt_give_result ! 466: orb $a_mask, %gs:sr_flags ! 467: sqrt_give_result: ! 468: mov $offset_result,%edi ! 469: jmp put_si_result ! 470: //sqrt endp ! 471: // ! 472: //a_med ends ! 473: // ! 474: // end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.