URL
https://opencores.org/ocsvn/or1k_soc_on_altera_embedded_dev_kit/or1k_soc_on_altera_embedded_dev_kit/trunk
Subversion Repositories or1k_soc_on_altera_embedded_dev_kit
[/] [or1k_soc_on_altera_embedded_dev_kit/] [trunk/] [linux-2.6/] [linux-2.6.24/] [arch/] [m68k/] [ifpsp060/] [src/] [fplsp.S] - Rev 3
Compare with Previous | Blame | View Log
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~MOTOROLA MICROPROCESSOR & MEMORY TECHNOLOGY GROUPM68000 Hi-Performance Microprocessor DivisionM68060 Software PackageProduction Release P1.00 -- October 10, 1994M68060 Software Package Copyright © 1993, 1994 Motorola Inc. All rights reserved.THE SOFTWARE is provided on an "AS IS" basis and without warranty.To the maximum extent permitted by applicable law,MOTOROLA DISCLAIMS ALL WARRANTIES WHETHER EXPRESS OR IMPLIED,INCLUDING IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSEand any warranty against infringement with regard to the SOFTWARE(INCLUDING ANY MODIFIED VERSIONS THEREOF) and any accompanying written materials.To the maximum extent permitted by applicable law,IN NO EVENT SHALL MOTOROLA BE LIABLE FOR ANY DAMAGES WHATSOEVER(INCLUDING WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR OTHER PECUNIARY LOSS)ARISING OF THE USE OR INABILITY TO USE THE SOFTWARE.Motorola assumes no responsibility for the maintenance and support of the SOFTWARE.You are hereby granted a copyright license to use, modify, and distribute the SOFTWAREso long as this entire notice is retained without alteration in any modified and/orredistributed versions, and that such modified versions are clearly identified as such.No licenses are granted by implication, estoppel or otherwise under any patentsor trademarks of Motorola, Inc.~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~## lfptop.s:# This file is appended to the top of the 060ILSP package# and contains the entry points into the package. The user, in# effect, branches to one of the branch table entries located here.#bra.l _facoss_short 0x0000bra.l _facosd_short 0x0000bra.l _facosx_short 0x0000bra.l _fasins_short 0x0000bra.l _fasind_short 0x0000bra.l _fasinx_short 0x0000bra.l _fatans_short 0x0000bra.l _fatand_short 0x0000bra.l _fatanx_short 0x0000bra.l _fatanhs_short 0x0000bra.l _fatanhd_short 0x0000bra.l _fatanhx_short 0x0000bra.l _fcoss_short 0x0000bra.l _fcosd_short 0x0000bra.l _fcosx_short 0x0000bra.l _fcoshs_short 0x0000bra.l _fcoshd_short 0x0000bra.l _fcoshx_short 0x0000bra.l _fetoxs_short 0x0000bra.l _fetoxd_short 0x0000bra.l _fetoxx_short 0x0000bra.l _fetoxm1s_short 0x0000bra.l _fetoxm1d_short 0x0000bra.l _fetoxm1x_short 0x0000bra.l _fgetexps_short 0x0000bra.l _fgetexpd_short 0x0000bra.l _fgetexpx_short 0x0000bra.l _fgetmans_short 0x0000bra.l _fgetmand_short 0x0000bra.l _fgetmanx_short 0x0000bra.l _flog10s_short 0x0000bra.l _flog10d_short 0x0000bra.l _flog10x_short 0x0000bra.l _flog2s_short 0x0000bra.l _flog2d_short 0x0000bra.l _flog2x_short 0x0000bra.l _flogns_short 0x0000bra.l _flognd_short 0x0000bra.l _flognx_short 0x0000bra.l _flognp1s_short 0x0000bra.l _flognp1d_short 0x0000bra.l _flognp1x_short 0x0000bra.l _fmods_short 0x0000bra.l _fmodd_short 0x0000bra.l _fmodx_short 0x0000bra.l _frems_short 0x0000bra.l _fremd_short 0x0000bra.l _fremx_short 0x0000bra.l _fscales_short 0x0000bra.l _fscaled_short 0x0000bra.l _fscalex_short 0x0000bra.l _fsins_short 0x0000bra.l _fsind_short 0x0000bra.l _fsinx_short 0x0000bra.l _fsincoss_short 0x0000bra.l _fsincosd_short 0x0000bra.l _fsincosx_short 0x0000bra.l _fsinhs_short 0x0000bra.l _fsinhd_short 0x0000bra.l _fsinhx_short 0x0000bra.l _ftans_short 0x0000bra.l _ftand_short 0x0000bra.l _ftanx_short 0x0000bra.l _ftanhs_short 0x0000bra.l _ftanhd_short 0x0000bra.l _ftanhx_short 0x0000bra.l _ftentoxs_short 0x0000bra.l _ftentoxd_short 0x0000bra.l _ftentoxx_short 0x0000bra.l _ftwotoxs_short 0x0000bra.l _ftwotoxd_short 0x0000bra.l _ftwotoxx_short 0x0000bra.l _fabss_short 0x0000bra.l _fabsd_short 0x0000bra.l _fabsx_short 0x0000bra.l _fadds_short 0x0000bra.l _faddd_short 0x0000bra.l _faddx_short 0x0000bra.l _fdivs_short 0x0000bra.l _fdivd_short 0x0000bra.l _fdivx_short 0x0000bra.l _fints_short 0x0000bra.l _fintd_short 0x0000bra.l _fintx_short 0x0000bra.l _fintrzs_short 0x0000bra.l _fintrzd_short 0x0000bra.l _fintrzx_short 0x0000bra.l _fmuls_short 0x0000bra.l _fmuld_short 0x0000bra.l _fmulx_short 0x0000bra.l _fnegs_short 0x0000bra.l _fnegd_short 0x0000bra.l _fnegx_short 0x0000bra.l _fsqrts_short 0x0000bra.l _fsqrtd_short 0x0000bra.l _fsqrtx_short 0x0000bra.l _fsubs_short 0x0000bra.l _fsubd_short 0x0000bra.l _fsubx_short 0x0000# leave room for future possible additionsalign 0x400## This file contains a set of define statements for constants# in order to promote readability within the corecode itself.#set LOCAL_SIZE, 192 # stack frame size(bytes)set LV, -LOCAL_SIZE # stack offsetset EXC_SR, 0x4 # stack status registerset EXC_PC, 0x6 # stack pcset EXC_VOFF, 0xa # stacked vector offsetset EXC_EA, 0xc # stacked <ea>set EXC_FP, 0x0 # frame pointerset EXC_AREGS, -68 # offset of all address regsset EXC_DREGS, -100 # offset of all data regsset EXC_FPREGS, -36 # offset of all fp regsset EXC_A7, EXC_AREGS+(7*4) # offset of saved a7set OLD_A7, EXC_AREGS+(6*4) # extra copy of saved a7set EXC_A6, EXC_AREGS+(6*4) # offset of saved a6set EXC_A5, EXC_AREGS+(5*4)set EXC_A4, EXC_AREGS+(4*4)set EXC_A3, EXC_AREGS+(3*4)set EXC_A2, EXC_AREGS+(2*4)set EXC_A1, EXC_AREGS+(1*4)set EXC_A0, EXC_AREGS+(0*4)set EXC_D7, EXC_DREGS+(7*4)set EXC_D6, EXC_DREGS+(6*4)set EXC_D5, EXC_DREGS+(5*4)set EXC_D4, EXC_DREGS+(4*4)set EXC_D3, EXC_DREGS+(3*4)set EXC_D2, EXC_DREGS+(2*4)set EXC_D1, EXC_DREGS+(1*4)set EXC_D0, EXC_DREGS+(0*4)set EXC_FP0, EXC_FPREGS+(0*12) # offset of saved fp0set EXC_FP1, EXC_FPREGS+(1*12) # offset of saved fp1set EXC_FP2, EXC_FPREGS+(2*12) # offset of saved fp2 (not used)set FP_SCR1, LV+80 # fp scratch 1set FP_SCR1_EX, FP_SCR1+0set FP_SCR1_SGN, FP_SCR1+2set FP_SCR1_HI, FP_SCR1+4set FP_SCR1_LO, FP_SCR1+8set FP_SCR0, LV+68 # fp scratch 0set FP_SCR0_EX, FP_SCR0+0set FP_SCR0_SGN, FP_SCR0+2set FP_SCR0_HI, FP_SCR0+4set FP_SCR0_LO, FP_SCR0+8set FP_DST, LV+56 # fp destination operandset FP_DST_EX, FP_DST+0set FP_DST_SGN, FP_DST+2set FP_DST_HI, FP_DST+4set FP_DST_LO, FP_DST+8set FP_SRC, LV+44 # fp source operandset FP_SRC_EX, FP_SRC+0set FP_SRC_SGN, FP_SRC+2set FP_SRC_HI, FP_SRC+4set FP_SRC_LO, FP_SRC+8set USER_FPIAR, LV+40 # FP instr address registerset USER_FPSR, LV+36 # FP status registerset FPSR_CC, USER_FPSR+0 # FPSR condition codesset FPSR_QBYTE, USER_FPSR+1 # FPSR qoutient byteset FPSR_EXCEPT, USER_FPSR+2 # FPSR exception status byteset FPSR_AEXCEPT, USER_FPSR+3 # FPSR accrued exception byteset USER_FPCR, LV+32 # FP control registerset FPCR_ENABLE, USER_FPCR+2 # FPCR exception enableset FPCR_MODE, USER_FPCR+3 # FPCR rounding mode controlset L_SCR3, LV+28 # integer scratch 3set L_SCR2, LV+24 # integer scratch 2set L_SCR1, LV+20 # integer scratch 1set STORE_FLG, LV+19 # flag: operand store (ie. not fcmp/ftst)set EXC_TEMP2, LV+24 # temporary spaceset EXC_TEMP, LV+16 # temporary spaceset DTAG, LV+15 # destination operand typeset STAG, LV+14 # source operand typeset SPCOND_FLG, LV+10 # flag: special case (see below)set EXC_CC, LV+8 # saved condition codesset EXC_EXTWPTR, LV+4 # saved current PC (active)set EXC_EXTWORD, LV+2 # saved extension wordset EXC_CMDREG, LV+2 # saved extension wordset EXC_OPWORD, LV+0 # saved operation word################################# Helpful macrosset FTEMP, 0 # offsets within anset FTEMP_EX, 0 # extended precisionset FTEMP_SGN, 2 # value saved in memory.set FTEMP_HI, 4set FTEMP_LO, 8set FTEMP_GRS, 12set LOCAL, 0 # offsets within anset LOCAL_EX, 0 # extended precisionset LOCAL_SGN, 2 # value saved in memory.set LOCAL_HI, 4set LOCAL_LO, 8set LOCAL_GRS, 12set DST, 0 # offsets within anset DST_EX, 0 # extended precisionset DST_HI, 4 # value saved in memory.set DST_LO, 8set SRC, 0 # offsets within anset SRC_EX, 0 # extended precisionset SRC_HI, 4 # value saved in memory.set SRC_LO, 8set SGL_LO, 0x3f81 # min sgl prec exponentset SGL_HI, 0x407e # max sgl prec exponentset DBL_LO, 0x3c01 # min dbl prec exponentset DBL_HI, 0x43fe # max dbl prec exponentset EXT_LO, 0x0 # min ext prec exponentset EXT_HI, 0x7ffe # max ext prec exponentset EXT_BIAS, 0x3fff # extended precision biasset SGL_BIAS, 0x007f # single precision biasset DBL_BIAS, 0x03ff # double precision biasset NORM, 0x00 # operand type for STAG/DTAGset ZERO, 0x01 # operand type for STAG/DTAGset INF, 0x02 # operand type for STAG/DTAGset QNAN, 0x03 # operand type for STAG/DTAGset DENORM, 0x04 # operand type for STAG/DTAGset SNAN, 0x05 # operand type for STAG/DTAGset UNNORM, 0x06 # operand type for STAG/DTAG################### FPSR/FPCR bits ###################set neg_bit, 0x3 # negative resultset z_bit, 0x2 # zero resultset inf_bit, 0x1 # infinite resultset nan_bit, 0x0 # NAN resultset q_sn_bit, 0x7 # sign bit of quotient byteset bsun_bit, 7 # branch on unorderedset snan_bit, 6 # signalling NANset operr_bit, 5 # operand errorset ovfl_bit, 4 # overflowset unfl_bit, 3 # underflowset dz_bit, 2 # divide by zeroset inex2_bit, 1 # inexact result 2set inex1_bit, 0 # inexact result 1set aiop_bit, 7 # accrued inexact operation bitset aovfl_bit, 6 # accrued overflow bitset aunfl_bit, 5 # accrued underflow bitset adz_bit, 4 # accrued dz bitset ainex_bit, 3 # accrued inexact bit############################## FPSR individual bit masks ##############################set neg_mask, 0x08000000 # negative bit mask (lw)set inf_mask, 0x02000000 # infinity bit mask (lw)set z_mask, 0x04000000 # zero bit mask (lw)set nan_mask, 0x01000000 # nan bit mask (lw)set neg_bmask, 0x08 # negative bit mask (byte)set inf_bmask, 0x02 # infinity bit mask (byte)set z_bmask, 0x04 # zero bit mask (byte)set nan_bmask, 0x01 # nan bit mask (byte)set bsun_mask, 0x00008000 # bsun exception maskset snan_mask, 0x00004000 # snan exception maskset operr_mask, 0x00002000 # operr exception maskset ovfl_mask, 0x00001000 # overflow exception maskset unfl_mask, 0x00000800 # underflow exception maskset dz_mask, 0x00000400 # dz exception maskset inex2_mask, 0x00000200 # inex2 exception maskset inex1_mask, 0x00000100 # inex1 exception maskset aiop_mask, 0x00000080 # accrued illegal operationset aovfl_mask, 0x00000040 # accrued overflowset aunfl_mask, 0x00000020 # accrued underflowset adz_mask, 0x00000010 # accrued divide by zeroset ainex_mask, 0x00000008 # accrued inexact####################################### FPSR combinations used in the FPSP #######################################set dzinf_mask, inf_mask+dz_mask+adz_maskset opnan_mask, nan_mask+operr_mask+aiop_maskset nzi_mask, 0x01ffffff #clears N, Z, and Iset unfinx_mask, unfl_mask+inex2_mask+aunfl_mask+ainex_maskset unf2inx_mask, unfl_mask+inex2_mask+ainex_maskset ovfinx_mask, ovfl_mask+inex2_mask+aovfl_mask+ainex_maskset inx1a_mask, inex1_mask+ainex_maskset inx2a_mask, inex2_mask+ainex_maskset snaniop_mask, nan_mask+snan_mask+aiop_maskset snaniop2_mask, snan_mask+aiop_maskset naniop_mask, nan_mask+aiop_maskset neginf_mask, neg_mask+inf_maskset infaiop_mask, inf_mask+aiop_maskset negz_mask, neg_mask+z_maskset opaop_mask, operr_mask+aiop_maskset unfl_inx_mask, unfl_mask+aunfl_mask+ainex_maskset ovfl_inx_mask, ovfl_mask+aovfl_mask+ainex_mask########## misc. ##########set rnd_stky_bit, 29 # stky bit pos in longwordset sign_bit, 0x7 # sign bitset signan_bit, 0x6 # signalling nan bitset sgl_thresh, 0x3f81 # minimum sgl exponentset dbl_thresh, 0x3c01 # minimum dbl exponentset x_mode, 0x0 # extended precisionset s_mode, 0x4 # single precisionset d_mode, 0x8 # double precisionset rn_mode, 0x0 # round-to-nearestset rz_mode, 0x1 # round-to-zeroset rm_mode, 0x2 # round-tp-minus-infinityset rp_mode, 0x3 # round-to-plus-infinityset mantissalen, 64 # length of mantissa in bitsset BYTE, 1 # len(byte) == 1 byteset WORD, 2 # len(word) == 2 bytesset LONG, 4 # len(longword) == 2 bytesset BSUN_VEC, 0xc0 # bsun vector offsetset INEX_VEC, 0xc4 # inexact vector offsetset DZ_VEC, 0xc8 # dz vector offsetset UNFL_VEC, 0xcc # unfl vector offsetset OPERR_VEC, 0xd0 # operr vector offsetset OVFL_VEC, 0xd4 # ovfl vector offsetset SNAN_VEC, 0xd8 # snan vector offset############################ SPecial CONDition FLaGs ############################set ftrapcc_flg, 0x01 # flag bit: ftrapcc exceptionset fbsun_flg, 0x02 # flag bit: bsun exceptionset mia7_flg, 0x04 # flag bit: (a7)+ <ea>set mda7_flg, 0x08 # flag bit: -(a7) <ea>set fmovm_flg, 0x40 # flag bit: fmovm instructionset immed_flg, 0x80 # flag bit: &<data> <ea>set ftrapcc_bit, 0x0set fbsun_bit, 0x1set mia7_bit, 0x2set mda7_bit, 0x3set immed_bit, 0x7################################### TRANSCENDENTAL "LAST-OP" FLAGS ###################################set FMUL_OP, 0x0 # fmul instr performed lastset FDIV_OP, 0x1 # fdiv performed lastset FADD_OP, 0x2 # fadd performed lastset FMOV_OP, 0x3 # fmov performed last############## CONSTANTS ##############T1: long 0x40C62D38,0xD3D64634 # 16381 LOG2 LEADT2: long 0x3D6F90AE,0xB1E75CC7 # 16381 LOG2 TRAILPI: long 0x40000000,0xC90FDAA2,0x2168C235,0x00000000PIBY2: long 0x3FFF0000,0xC90FDAA2,0x2168C235,0x00000000TWOBYPI:long 0x3FE45F30,0x6DC9C883########################################################################## MONADIC TEMPLATE ##########################################################################global _fsins__fsins_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.s 0x8(%a6),%fp0 # load sgl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L0_2sbsr.l ssin # operand is a NORMbra.b _L0_6s_L0_2s:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L0_3s # nobsr.l src_zero # yesbra.b _L0_6s_L0_3s:cmpi.b %d1,&INF # is operand an INF?bne.b _L0_4s # nobsr.l t_operr # yesbra.b _L0_6s_L0_4s:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L0_5s # nobsr.l src_qnan # yesbra.b _L0_6s_L0_5s:bsr.l ssind # operand is a DENORM_L0_6s:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _fsind__fsind_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.d 0x8(%a6),%fp0 # load dbl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,precmov.b %d1,STAG(%a6)tst.b %d1bne.b _L0_2dbsr.l ssin # operand is a NORMbra.b _L0_6d_L0_2d:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L0_3d # nobsr.l src_zero # yesbra.b _L0_6d_L0_3d:cmpi.b %d1,&INF # is operand an INF?bne.b _L0_4d # nobsr.l t_operr # yesbra.b _L0_6d_L0_4d:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L0_5d # nobsr.l src_qnan # yesbra.b _L0_6d_L0_5d:bsr.l ssind # operand is a DENORM_L0_6d:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _fsinx__fsinx_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#lea FP_SRC(%a6),%a0mov.l 0x8+0x0(%a6),0x0(%a0) # load ext inputmov.l 0x8+0x4(%a6),0x4(%a0)mov.l 0x8+0x8(%a6),0x8(%a0)bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L0_2xbsr.l ssin # operand is a NORMbra.b _L0_6x_L0_2x:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L0_3x # nobsr.l src_zero # yesbra.b _L0_6x_L0_3x:cmpi.b %d1,&INF # is operand an INF?bne.b _L0_4x # nobsr.l t_operr # yesbra.b _L0_6x_L0_4x:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L0_5x # nobsr.l src_qnan # yesbra.b _L0_6x_L0_5x:bsr.l ssind # operand is a DENORM_L0_6x:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rts########################################################################## MONADIC TEMPLATE ##########################################################################global _fcoss__fcoss_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.s 0x8(%a6),%fp0 # load sgl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L1_2sbsr.l scos # operand is a NORMbra.b _L1_6s_L1_2s:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L1_3s # nobsr.l ld_pone # yesbra.b _L1_6s_L1_3s:cmpi.b %d1,&INF # is operand an INF?bne.b _L1_4s # nobsr.l t_operr # yesbra.b _L1_6s_L1_4s:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L1_5s # nobsr.l src_qnan # yesbra.b _L1_6s_L1_5s:bsr.l scosd # operand is a DENORM_L1_6s:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _fcosd__fcosd_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.d 0x8(%a6),%fp0 # load dbl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,precmov.b %d1,STAG(%a6)tst.b %d1bne.b _L1_2dbsr.l scos # operand is a NORMbra.b _L1_6d_L1_2d:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L1_3d # nobsr.l ld_pone # yesbra.b _L1_6d_L1_3d:cmpi.b %d1,&INF # is operand an INF?bne.b _L1_4d # nobsr.l t_operr # yesbra.b _L1_6d_L1_4d:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L1_5d # nobsr.l src_qnan # yesbra.b _L1_6d_L1_5d:bsr.l scosd # operand is a DENORM_L1_6d:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _fcosx__fcosx_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#lea FP_SRC(%a6),%a0mov.l 0x8+0x0(%a6),0x0(%a0) # load ext inputmov.l 0x8+0x4(%a6),0x4(%a0)mov.l 0x8+0x8(%a6),0x8(%a0)bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L1_2xbsr.l scos # operand is a NORMbra.b _L1_6x_L1_2x:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L1_3x # nobsr.l ld_pone # yesbra.b _L1_6x_L1_3x:cmpi.b %d1,&INF # is operand an INF?bne.b _L1_4x # nobsr.l t_operr # yesbra.b _L1_6x_L1_4x:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L1_5x # nobsr.l src_qnan # yesbra.b _L1_6x_L1_5x:bsr.l scosd # operand is a DENORM_L1_6x:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rts########################################################################## MONADIC TEMPLATE ##########################################################################global _fsinhs__fsinhs_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.s 0x8(%a6),%fp0 # load sgl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L2_2sbsr.l ssinh # operand is a NORMbra.b _L2_6s_L2_2s:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L2_3s # nobsr.l src_zero # yesbra.b _L2_6s_L2_3s:cmpi.b %d1,&INF # is operand an INF?bne.b _L2_4s # nobsr.l src_inf # yesbra.b _L2_6s_L2_4s:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L2_5s # nobsr.l src_qnan # yesbra.b _L2_6s_L2_5s:bsr.l ssinhd # operand is a DENORM_L2_6s:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _fsinhd__fsinhd_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.d 0x8(%a6),%fp0 # load dbl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,precmov.b %d1,STAG(%a6)tst.b %d1bne.b _L2_2dbsr.l ssinh # operand is a NORMbra.b _L2_6d_L2_2d:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L2_3d # nobsr.l src_zero # yesbra.b _L2_6d_L2_3d:cmpi.b %d1,&INF # is operand an INF?bne.b _L2_4d # nobsr.l src_inf # yesbra.b _L2_6d_L2_4d:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L2_5d # nobsr.l src_qnan # yesbra.b _L2_6d_L2_5d:bsr.l ssinhd # operand is a DENORM_L2_6d:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _fsinhx__fsinhx_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#lea FP_SRC(%a6),%a0mov.l 0x8+0x0(%a6),0x0(%a0) # load ext inputmov.l 0x8+0x4(%a6),0x4(%a0)mov.l 0x8+0x8(%a6),0x8(%a0)bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L2_2xbsr.l ssinh # operand is a NORMbra.b _L2_6x_L2_2x:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L2_3x # nobsr.l src_zero # yesbra.b _L2_6x_L2_3x:cmpi.b %d1,&INF # is operand an INF?bne.b _L2_4x # nobsr.l src_inf # yesbra.b _L2_6x_L2_4x:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L2_5x # nobsr.l src_qnan # yesbra.b _L2_6x_L2_5x:bsr.l ssinhd # operand is a DENORM_L2_6x:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rts########################################################################## MONADIC TEMPLATE ##########################################################################global _flognp1s__flognp1s_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.s 0x8(%a6),%fp0 # load sgl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L3_2sbsr.l slognp1 # operand is a NORMbra.b _L3_6s_L3_2s:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L3_3s # nobsr.l src_zero # yesbra.b _L3_6s_L3_3s:cmpi.b %d1,&INF # is operand an INF?bne.b _L3_4s # nobsr.l sopr_inf # yesbra.b _L3_6s_L3_4s:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L3_5s # nobsr.l src_qnan # yesbra.b _L3_6s_L3_5s:bsr.l slognp1d # operand is a DENORM_L3_6s:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _flognp1d__flognp1d_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.d 0x8(%a6),%fp0 # load dbl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,precmov.b %d1,STAG(%a6)tst.b %d1bne.b _L3_2dbsr.l slognp1 # operand is a NORMbra.b _L3_6d_L3_2d:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L3_3d # nobsr.l src_zero # yesbra.b _L3_6d_L3_3d:cmpi.b %d1,&INF # is operand an INF?bne.b _L3_4d # nobsr.l sopr_inf # yesbra.b _L3_6d_L3_4d:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L3_5d # nobsr.l src_qnan # yesbra.b _L3_6d_L3_5d:bsr.l slognp1d # operand is a DENORM_L3_6d:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _flognp1x__flognp1x_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#lea FP_SRC(%a6),%a0mov.l 0x8+0x0(%a6),0x0(%a0) # load ext inputmov.l 0x8+0x4(%a6),0x4(%a0)mov.l 0x8+0x8(%a6),0x8(%a0)bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L3_2xbsr.l slognp1 # operand is a NORMbra.b _L3_6x_L3_2x:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L3_3x # nobsr.l src_zero # yesbra.b _L3_6x_L3_3x:cmpi.b %d1,&INF # is operand an INF?bne.b _L3_4x # nobsr.l sopr_inf # yesbra.b _L3_6x_L3_4x:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L3_5x # nobsr.l src_qnan # yesbra.b _L3_6x_L3_5x:bsr.l slognp1d # operand is a DENORM_L3_6x:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rts########################################################################## MONADIC TEMPLATE ##########################################################################global _fetoxm1s__fetoxm1s_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.s 0x8(%a6),%fp0 # load sgl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L4_2sbsr.l setoxm1 # operand is a NORMbra.b _L4_6s_L4_2s:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L4_3s # nobsr.l src_zero # yesbra.b _L4_6s_L4_3s:cmpi.b %d1,&INF # is operand an INF?bne.b _L4_4s # nobsr.l setoxm1i # yesbra.b _L4_6s_L4_4s:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L4_5s # nobsr.l src_qnan # yesbra.b _L4_6s_L4_5s:bsr.l setoxm1d # operand is a DENORM_L4_6s:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _fetoxm1d__fetoxm1d_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.d 0x8(%a6),%fp0 # load dbl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,precmov.b %d1,STAG(%a6)tst.b %d1bne.b _L4_2dbsr.l setoxm1 # operand is a NORMbra.b _L4_6d_L4_2d:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L4_3d # nobsr.l src_zero # yesbra.b _L4_6d_L4_3d:cmpi.b %d1,&INF # is operand an INF?bne.b _L4_4d # nobsr.l setoxm1i # yesbra.b _L4_6d_L4_4d:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L4_5d # nobsr.l src_qnan # yesbra.b _L4_6d_L4_5d:bsr.l setoxm1d # operand is a DENORM_L4_6d:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _fetoxm1x__fetoxm1x_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#lea FP_SRC(%a6),%a0mov.l 0x8+0x0(%a6),0x0(%a0) # load ext inputmov.l 0x8+0x4(%a6),0x4(%a0)mov.l 0x8+0x8(%a6),0x8(%a0)bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L4_2xbsr.l setoxm1 # operand is a NORMbra.b _L4_6x_L4_2x:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L4_3x # nobsr.l src_zero # yesbra.b _L4_6x_L4_3x:cmpi.b %d1,&INF # is operand an INF?bne.b _L4_4x # nobsr.l setoxm1i # yesbra.b _L4_6x_L4_4x:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L4_5x # nobsr.l src_qnan # yesbra.b _L4_6x_L4_5x:bsr.l setoxm1d # operand is a DENORM_L4_6x:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rts########################################################################## MONADIC TEMPLATE ##########################################################################global _ftanhs__ftanhs_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.s 0x8(%a6),%fp0 # load sgl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L5_2sbsr.l stanh # operand is a NORMbra.b _L5_6s_L5_2s:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L5_3s # nobsr.l src_zero # yesbra.b _L5_6s_L5_3s:cmpi.b %d1,&INF # is operand an INF?bne.b _L5_4s # nobsr.l src_one # yesbra.b _L5_6s_L5_4s:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L5_5s # nobsr.l src_qnan # yesbra.b _L5_6s_L5_5s:bsr.l stanhd # operand is a DENORM_L5_6s:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _ftanhd__ftanhd_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.d 0x8(%a6),%fp0 # load dbl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,precmov.b %d1,STAG(%a6)tst.b %d1bne.b _L5_2dbsr.l stanh # operand is a NORMbra.b _L5_6d_L5_2d:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L5_3d # nobsr.l src_zero # yesbra.b _L5_6d_L5_3d:cmpi.b %d1,&INF # is operand an INF?bne.b _L5_4d # nobsr.l src_one # yesbra.b _L5_6d_L5_4d:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L5_5d # nobsr.l src_qnan # yesbra.b _L5_6d_L5_5d:bsr.l stanhd # operand is a DENORM_L5_6d:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _ftanhx__ftanhx_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#lea FP_SRC(%a6),%a0mov.l 0x8+0x0(%a6),0x0(%a0) # load ext inputmov.l 0x8+0x4(%a6),0x4(%a0)mov.l 0x8+0x8(%a6),0x8(%a0)bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L5_2xbsr.l stanh # operand is a NORMbra.b _L5_6x_L5_2x:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L5_3x # nobsr.l src_zero # yesbra.b _L5_6x_L5_3x:cmpi.b %d1,&INF # is operand an INF?bne.b _L5_4x # nobsr.l src_one # yesbra.b _L5_6x_L5_4x:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L5_5x # nobsr.l src_qnan # yesbra.b _L5_6x_L5_5x:bsr.l stanhd # operand is a DENORM_L5_6x:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rts########################################################################## MONADIC TEMPLATE ##########################################################################global _fatans__fatans_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.s 0x8(%a6),%fp0 # load sgl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L6_2sbsr.l satan # operand is a NORMbra.b _L6_6s_L6_2s:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L6_3s # nobsr.l src_zero # yesbra.b _L6_6s_L6_3s:cmpi.b %d1,&INF # is operand an INF?bne.b _L6_4s # nobsr.l spi_2 # yesbra.b _L6_6s_L6_4s:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L6_5s # nobsr.l src_qnan # yesbra.b _L6_6s_L6_5s:bsr.l satand # operand is a DENORM_L6_6s:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _fatand__fatand_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.d 0x8(%a6),%fp0 # load dbl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,precmov.b %d1,STAG(%a6)tst.b %d1bne.b _L6_2dbsr.l satan # operand is a NORMbra.b _L6_6d_L6_2d:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L6_3d # nobsr.l src_zero # yesbra.b _L6_6d_L6_3d:cmpi.b %d1,&INF # is operand an INF?bne.b _L6_4d # nobsr.l spi_2 # yesbra.b _L6_6d_L6_4d:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L6_5d # nobsr.l src_qnan # yesbra.b _L6_6d_L6_5d:bsr.l satand # operand is a DENORM_L6_6d:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _fatanx__fatanx_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#lea FP_SRC(%a6),%a0mov.l 0x8+0x0(%a6),0x0(%a0) # load ext inputmov.l 0x8+0x4(%a6),0x4(%a0)mov.l 0x8+0x8(%a6),0x8(%a0)bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L6_2xbsr.l satan # operand is a NORMbra.b _L6_6x_L6_2x:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L6_3x # nobsr.l src_zero # yesbra.b _L6_6x_L6_3x:cmpi.b %d1,&INF # is operand an INF?bne.b _L6_4x # nobsr.l spi_2 # yesbra.b _L6_6x_L6_4x:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L6_5x # nobsr.l src_qnan # yesbra.b _L6_6x_L6_5x:bsr.l satand # operand is a DENORM_L6_6x:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rts########################################################################## MONADIC TEMPLATE ##########################################################################global _fasins__fasins_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.s 0x8(%a6),%fp0 # load sgl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L7_2sbsr.l sasin # operand is a NORMbra.b _L7_6s_L7_2s:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L7_3s # nobsr.l src_zero # yesbra.b _L7_6s_L7_3s:cmpi.b %d1,&INF # is operand an INF?bne.b _L7_4s # nobsr.l t_operr # yesbra.b _L7_6s_L7_4s:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L7_5s # nobsr.l src_qnan # yesbra.b _L7_6s_L7_5s:bsr.l sasind # operand is a DENORM_L7_6s:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _fasind__fasind_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.d 0x8(%a6),%fp0 # load dbl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,precmov.b %d1,STAG(%a6)tst.b %d1bne.b _L7_2dbsr.l sasin # operand is a NORMbra.b _L7_6d_L7_2d:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L7_3d # nobsr.l src_zero # yesbra.b _L7_6d_L7_3d:cmpi.b %d1,&INF # is operand an INF?bne.b _L7_4d # nobsr.l t_operr # yesbra.b _L7_6d_L7_4d:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L7_5d # nobsr.l src_qnan # yesbra.b _L7_6d_L7_5d:bsr.l sasind # operand is a DENORM_L7_6d:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _fasinx__fasinx_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#lea FP_SRC(%a6),%a0mov.l 0x8+0x0(%a6),0x0(%a0) # load ext inputmov.l 0x8+0x4(%a6),0x4(%a0)mov.l 0x8+0x8(%a6),0x8(%a0)bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L7_2xbsr.l sasin # operand is a NORMbra.b _L7_6x_L7_2x:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L7_3x # nobsr.l src_zero # yesbra.b _L7_6x_L7_3x:cmpi.b %d1,&INF # is operand an INF?bne.b _L7_4x # nobsr.l t_operr # yesbra.b _L7_6x_L7_4x:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L7_5x # nobsr.l src_qnan # yesbra.b _L7_6x_L7_5x:bsr.l sasind # operand is a DENORM_L7_6x:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rts########################################################################## MONADIC TEMPLATE ##########################################################################global _fatanhs__fatanhs_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.s 0x8(%a6),%fp0 # load sgl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L8_2sbsr.l satanh # operand is a NORMbra.b _L8_6s_L8_2s:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L8_3s # nobsr.l src_zero # yesbra.b _L8_6s_L8_3s:cmpi.b %d1,&INF # is operand an INF?bne.b _L8_4s # nobsr.l t_operr # yesbra.b _L8_6s_L8_4s:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L8_5s # nobsr.l src_qnan # yesbra.b _L8_6s_L8_5s:bsr.l satanhd # operand is a DENORM_L8_6s:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _fatanhd__fatanhd_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.d 0x8(%a6),%fp0 # load dbl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,precmov.b %d1,STAG(%a6)tst.b %d1bne.b _L8_2dbsr.l satanh # operand is a NORMbra.b _L8_6d_L8_2d:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L8_3d # nobsr.l src_zero # yesbra.b _L8_6d_L8_3d:cmpi.b %d1,&INF # is operand an INF?bne.b _L8_4d # nobsr.l t_operr # yesbra.b _L8_6d_L8_4d:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L8_5d # nobsr.l src_qnan # yesbra.b _L8_6d_L8_5d:bsr.l satanhd # operand is a DENORM_L8_6d:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _fatanhx__fatanhx_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#lea FP_SRC(%a6),%a0mov.l 0x8+0x0(%a6),0x0(%a0) # load ext inputmov.l 0x8+0x4(%a6),0x4(%a0)mov.l 0x8+0x8(%a6),0x8(%a0)bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L8_2xbsr.l satanh # operand is a NORMbra.b _L8_6x_L8_2x:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L8_3x # nobsr.l src_zero # yesbra.b _L8_6x_L8_3x:cmpi.b %d1,&INF # is operand an INF?bne.b _L8_4x # nobsr.l t_operr # yesbra.b _L8_6x_L8_4x:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L8_5x # nobsr.l src_qnan # yesbra.b _L8_6x_L8_5x:bsr.l satanhd # operand is a DENORM_L8_6x:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rts########################################################################## MONADIC TEMPLATE ##########################################################################global _ftans__ftans_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.s 0x8(%a6),%fp0 # load sgl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L9_2sbsr.l stan # operand is a NORMbra.b _L9_6s_L9_2s:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L9_3s # nobsr.l src_zero # yesbra.b _L9_6s_L9_3s:cmpi.b %d1,&INF # is operand an INF?bne.b _L9_4s # nobsr.l t_operr # yesbra.b _L9_6s_L9_4s:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L9_5s # nobsr.l src_qnan # yesbra.b _L9_6s_L9_5s:bsr.l stand # operand is a DENORM_L9_6s:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _ftand__ftand_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.d 0x8(%a6),%fp0 # load dbl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,precmov.b %d1,STAG(%a6)tst.b %d1bne.b _L9_2dbsr.l stan # operand is a NORMbra.b _L9_6d_L9_2d:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L9_3d # nobsr.l src_zero # yesbra.b _L9_6d_L9_3d:cmpi.b %d1,&INF # is operand an INF?bne.b _L9_4d # nobsr.l t_operr # yesbra.b _L9_6d_L9_4d:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L9_5d # nobsr.l src_qnan # yesbra.b _L9_6d_L9_5d:bsr.l stand # operand is a DENORM_L9_6d:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _ftanx__ftanx_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#lea FP_SRC(%a6),%a0mov.l 0x8+0x0(%a6),0x0(%a0) # load ext inputmov.l 0x8+0x4(%a6),0x4(%a0)mov.l 0x8+0x8(%a6),0x8(%a0)bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L9_2xbsr.l stan # operand is a NORMbra.b _L9_6x_L9_2x:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L9_3x # nobsr.l src_zero # yesbra.b _L9_6x_L9_3x:cmpi.b %d1,&INF # is operand an INF?bne.b _L9_4x # nobsr.l t_operr # yesbra.b _L9_6x_L9_4x:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L9_5x # nobsr.l src_qnan # yesbra.b _L9_6x_L9_5x:bsr.l stand # operand is a DENORM_L9_6x:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rts########################################################################## MONADIC TEMPLATE ##########################################################################global _fetoxs__fetoxs_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.s 0x8(%a6),%fp0 # load sgl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L10_2sbsr.l setox # operand is a NORMbra.b _L10_6s_L10_2s:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L10_3s # nobsr.l ld_pone # yesbra.b _L10_6s_L10_3s:cmpi.b %d1,&INF # is operand an INF?bne.b _L10_4s # nobsr.l szr_inf # yesbra.b _L10_6s_L10_4s:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L10_5s # nobsr.l src_qnan # yesbra.b _L10_6s_L10_5s:bsr.l setoxd # operand is a DENORM_L10_6s:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _fetoxd__fetoxd_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.d 0x8(%a6),%fp0 # load dbl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,precmov.b %d1,STAG(%a6)tst.b %d1bne.b _L10_2dbsr.l setox # operand is a NORMbra.b _L10_6d_L10_2d:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L10_3d # nobsr.l ld_pone # yesbra.b _L10_6d_L10_3d:cmpi.b %d1,&INF # is operand an INF?bne.b _L10_4d # nobsr.l szr_inf # yesbra.b _L10_6d_L10_4d:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L10_5d # nobsr.l src_qnan # yesbra.b _L10_6d_L10_5d:bsr.l setoxd # operand is a DENORM_L10_6d:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _fetoxx__fetoxx_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#lea FP_SRC(%a6),%a0mov.l 0x8+0x0(%a6),0x0(%a0) # load ext inputmov.l 0x8+0x4(%a6),0x4(%a0)mov.l 0x8+0x8(%a6),0x8(%a0)bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L10_2xbsr.l setox # operand is a NORMbra.b _L10_6x_L10_2x:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L10_3x # nobsr.l ld_pone # yesbra.b _L10_6x_L10_3x:cmpi.b %d1,&INF # is operand an INF?bne.b _L10_4x # nobsr.l szr_inf # yesbra.b _L10_6x_L10_4x:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L10_5x # nobsr.l src_qnan # yesbra.b _L10_6x_L10_5x:bsr.l setoxd # operand is a DENORM_L10_6x:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rts########################################################################## MONADIC TEMPLATE ##########################################################################global _ftwotoxs__ftwotoxs_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.s 0x8(%a6),%fp0 # load sgl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L11_2sbsr.l stwotox # operand is a NORMbra.b _L11_6s_L11_2s:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L11_3s # nobsr.l ld_pone # yesbra.b _L11_6s_L11_3s:cmpi.b %d1,&INF # is operand an INF?bne.b _L11_4s # nobsr.l szr_inf # yesbra.b _L11_6s_L11_4s:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L11_5s # nobsr.l src_qnan # yesbra.b _L11_6s_L11_5s:bsr.l stwotoxd # operand is a DENORM_L11_6s:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _ftwotoxd__ftwotoxd_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.d 0x8(%a6),%fp0 # load dbl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,precmov.b %d1,STAG(%a6)tst.b %d1bne.b _L11_2dbsr.l stwotox # operand is a NORMbra.b _L11_6d_L11_2d:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L11_3d # nobsr.l ld_pone # yesbra.b _L11_6d_L11_3d:cmpi.b %d1,&INF # is operand an INF?bne.b _L11_4d # nobsr.l szr_inf # yesbra.b _L11_6d_L11_4d:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L11_5d # nobsr.l src_qnan # yesbra.b _L11_6d_L11_5d:bsr.l stwotoxd # operand is a DENORM_L11_6d:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _ftwotoxx__ftwotoxx_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#lea FP_SRC(%a6),%a0mov.l 0x8+0x0(%a6),0x0(%a0) # load ext inputmov.l 0x8+0x4(%a6),0x4(%a0)mov.l 0x8+0x8(%a6),0x8(%a0)bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L11_2xbsr.l stwotox # operand is a NORMbra.b _L11_6x_L11_2x:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L11_3x # nobsr.l ld_pone # yesbra.b _L11_6x_L11_3x:cmpi.b %d1,&INF # is operand an INF?bne.b _L11_4x # nobsr.l szr_inf # yesbra.b _L11_6x_L11_4x:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L11_5x # nobsr.l src_qnan # yesbra.b _L11_6x_L11_5x:bsr.l stwotoxd # operand is a DENORM_L11_6x:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rts########################################################################## MONADIC TEMPLATE ##########################################################################global _ftentoxs__ftentoxs_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.s 0x8(%a6),%fp0 # load sgl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L12_2sbsr.l stentox # operand is a NORMbra.b _L12_6s_L12_2s:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L12_3s # nobsr.l ld_pone # yesbra.b _L12_6s_L12_3s:cmpi.b %d1,&INF # is operand an INF?bne.b _L12_4s # nobsr.l szr_inf # yesbra.b _L12_6s_L12_4s:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L12_5s # nobsr.l src_qnan # yesbra.b _L12_6s_L12_5s:bsr.l stentoxd # operand is a DENORM_L12_6s:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _ftentoxd__ftentoxd_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.d 0x8(%a6),%fp0 # load dbl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,precmov.b %d1,STAG(%a6)tst.b %d1bne.b _L12_2dbsr.l stentox # operand is a NORMbra.b _L12_6d_L12_2d:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L12_3d # nobsr.l ld_pone # yesbra.b _L12_6d_L12_3d:cmpi.b %d1,&INF # is operand an INF?bne.b _L12_4d # nobsr.l szr_inf # yesbra.b _L12_6d_L12_4d:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L12_5d # nobsr.l src_qnan # yesbra.b _L12_6d_L12_5d:bsr.l stentoxd # operand is a DENORM_L12_6d:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _ftentoxx__ftentoxx_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#lea FP_SRC(%a6),%a0mov.l 0x8+0x0(%a6),0x0(%a0) # load ext inputmov.l 0x8+0x4(%a6),0x4(%a0)mov.l 0x8+0x8(%a6),0x8(%a0)bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L12_2xbsr.l stentox # operand is a NORMbra.b _L12_6x_L12_2x:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L12_3x # nobsr.l ld_pone # yesbra.b _L12_6x_L12_3x:cmpi.b %d1,&INF # is operand an INF?bne.b _L12_4x # nobsr.l szr_inf # yesbra.b _L12_6x_L12_4x:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L12_5x # nobsr.l src_qnan # yesbra.b _L12_6x_L12_5x:bsr.l stentoxd # operand is a DENORM_L12_6x:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rts########################################################################## MONADIC TEMPLATE ##########################################################################global _flogns__flogns_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.s 0x8(%a6),%fp0 # load sgl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L13_2sbsr.l slogn # operand is a NORMbra.b _L13_6s_L13_2s:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L13_3s # nobsr.l t_dz2 # yesbra.b _L13_6s_L13_3s:cmpi.b %d1,&INF # is operand an INF?bne.b _L13_4s # nobsr.l sopr_inf # yesbra.b _L13_6s_L13_4s:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L13_5s # nobsr.l src_qnan # yesbra.b _L13_6s_L13_5s:bsr.l slognd # operand is a DENORM_L13_6s:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _flognd__flognd_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.d 0x8(%a6),%fp0 # load dbl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,precmov.b %d1,STAG(%a6)tst.b %d1bne.b _L13_2dbsr.l slogn # operand is a NORMbra.b _L13_6d_L13_2d:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L13_3d # nobsr.l t_dz2 # yesbra.b _L13_6d_L13_3d:cmpi.b %d1,&INF # is operand an INF?bne.b _L13_4d # nobsr.l sopr_inf # yesbra.b _L13_6d_L13_4d:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L13_5d # nobsr.l src_qnan # yesbra.b _L13_6d_L13_5d:bsr.l slognd # operand is a DENORM_L13_6d:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _flognx__flognx_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#lea FP_SRC(%a6),%a0mov.l 0x8+0x0(%a6),0x0(%a0) # load ext inputmov.l 0x8+0x4(%a6),0x4(%a0)mov.l 0x8+0x8(%a6),0x8(%a0)bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L13_2xbsr.l slogn # operand is a NORMbra.b _L13_6x_L13_2x:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L13_3x # nobsr.l t_dz2 # yesbra.b _L13_6x_L13_3x:cmpi.b %d1,&INF # is operand an INF?bne.b _L13_4x # nobsr.l sopr_inf # yesbra.b _L13_6x_L13_4x:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L13_5x # nobsr.l src_qnan # yesbra.b _L13_6x_L13_5x:bsr.l slognd # operand is a DENORM_L13_6x:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rts########################################################################## MONADIC TEMPLATE ##########################################################################global _flog10s__flog10s_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.s 0x8(%a6),%fp0 # load sgl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L14_2sbsr.l slog10 # operand is a NORMbra.b _L14_6s_L14_2s:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L14_3s # nobsr.l t_dz2 # yesbra.b _L14_6s_L14_3s:cmpi.b %d1,&INF # is operand an INF?bne.b _L14_4s # nobsr.l sopr_inf # yesbra.b _L14_6s_L14_4s:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L14_5s # nobsr.l src_qnan # yesbra.b _L14_6s_L14_5s:bsr.l slog10d # operand is a DENORM_L14_6s:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _flog10d__flog10d_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.d 0x8(%a6),%fp0 # load dbl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,precmov.b %d1,STAG(%a6)tst.b %d1bne.b _L14_2dbsr.l slog10 # operand is a NORMbra.b _L14_6d_L14_2d:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L14_3d # nobsr.l t_dz2 # yesbra.b _L14_6d_L14_3d:cmpi.b %d1,&INF # is operand an INF?bne.b _L14_4d # nobsr.l sopr_inf # yesbra.b _L14_6d_L14_4d:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L14_5d # nobsr.l src_qnan # yesbra.b _L14_6d_L14_5d:bsr.l slog10d # operand is a DENORM_L14_6d:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _flog10x__flog10x_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#lea FP_SRC(%a6),%a0mov.l 0x8+0x0(%a6),0x0(%a0) # load ext inputmov.l 0x8+0x4(%a6),0x4(%a0)mov.l 0x8+0x8(%a6),0x8(%a0)bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L14_2xbsr.l slog10 # operand is a NORMbra.b _L14_6x_L14_2x:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L14_3x # nobsr.l t_dz2 # yesbra.b _L14_6x_L14_3x:cmpi.b %d1,&INF # is operand an INF?bne.b _L14_4x # nobsr.l sopr_inf # yesbra.b _L14_6x_L14_4x:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L14_5x # nobsr.l src_qnan # yesbra.b _L14_6x_L14_5x:bsr.l slog10d # operand is a DENORM_L14_6x:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rts########################################################################## MONADIC TEMPLATE ##########################################################################global _flog2s__flog2s_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.s 0x8(%a6),%fp0 # load sgl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L15_2sbsr.l slog2 # operand is a NORMbra.b _L15_6s_L15_2s:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L15_3s # nobsr.l t_dz2 # yesbra.b _L15_6s_L15_3s:cmpi.b %d1,&INF # is operand an INF?bne.b _L15_4s # nobsr.l sopr_inf # yesbra.b _L15_6s_L15_4s:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L15_5s # nobsr.l src_qnan # yesbra.b _L15_6s_L15_5s:bsr.l slog2d # operand is a DENORM_L15_6s:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _flog2d__flog2d_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.d 0x8(%a6),%fp0 # load dbl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,precmov.b %d1,STAG(%a6)tst.b %d1bne.b _L15_2dbsr.l slog2 # operand is a NORMbra.b _L15_6d_L15_2d:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L15_3d # nobsr.l t_dz2 # yesbra.b _L15_6d_L15_3d:cmpi.b %d1,&INF # is operand an INF?bne.b _L15_4d # nobsr.l sopr_inf # yesbra.b _L15_6d_L15_4d:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L15_5d # nobsr.l src_qnan # yesbra.b _L15_6d_L15_5d:bsr.l slog2d # operand is a DENORM_L15_6d:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _flog2x__flog2x_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#lea FP_SRC(%a6),%a0mov.l 0x8+0x0(%a6),0x0(%a0) # load ext inputmov.l 0x8+0x4(%a6),0x4(%a0)mov.l 0x8+0x8(%a6),0x8(%a0)bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L15_2xbsr.l slog2 # operand is a NORMbra.b _L15_6x_L15_2x:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L15_3x # nobsr.l t_dz2 # yesbra.b _L15_6x_L15_3x:cmpi.b %d1,&INF # is operand an INF?bne.b _L15_4x # nobsr.l sopr_inf # yesbra.b _L15_6x_L15_4x:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L15_5x # nobsr.l src_qnan # yesbra.b _L15_6x_L15_5x:bsr.l slog2d # operand is a DENORM_L15_6x:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rts########################################################################## MONADIC TEMPLATE ##########################################################################global _fcoshs__fcoshs_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.s 0x8(%a6),%fp0 # load sgl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L16_2sbsr.l scosh # operand is a NORMbra.b _L16_6s_L16_2s:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L16_3s # nobsr.l ld_pone # yesbra.b _L16_6s_L16_3s:cmpi.b %d1,&INF # is operand an INF?bne.b _L16_4s # nobsr.l ld_pinf # yesbra.b _L16_6s_L16_4s:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L16_5s # nobsr.l src_qnan # yesbra.b _L16_6s_L16_5s:bsr.l scoshd # operand is a DENORM_L16_6s:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _fcoshd__fcoshd_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.d 0x8(%a6),%fp0 # load dbl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,precmov.b %d1,STAG(%a6)tst.b %d1bne.b _L16_2dbsr.l scosh # operand is a NORMbra.b _L16_6d_L16_2d:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L16_3d # nobsr.l ld_pone # yesbra.b _L16_6d_L16_3d:cmpi.b %d1,&INF # is operand an INF?bne.b _L16_4d # nobsr.l ld_pinf # yesbra.b _L16_6d_L16_4d:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L16_5d # nobsr.l src_qnan # yesbra.b _L16_6d_L16_5d:bsr.l scoshd # operand is a DENORM_L16_6d:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _fcoshx__fcoshx_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#lea FP_SRC(%a6),%a0mov.l 0x8+0x0(%a6),0x0(%a0) # load ext inputmov.l 0x8+0x4(%a6),0x4(%a0)mov.l 0x8+0x8(%a6),0x8(%a0)bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L16_2xbsr.l scosh # operand is a NORMbra.b _L16_6x_L16_2x:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L16_3x # nobsr.l ld_pone # yesbra.b _L16_6x_L16_3x:cmpi.b %d1,&INF # is operand an INF?bne.b _L16_4x # nobsr.l ld_pinf # yesbra.b _L16_6x_L16_4x:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L16_5x # nobsr.l src_qnan # yesbra.b _L16_6x_L16_5x:bsr.l scoshd # operand is a DENORM_L16_6x:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rts########################################################################## MONADIC TEMPLATE ##########################################################################global _facoss__facoss_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.s 0x8(%a6),%fp0 # load sgl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L17_2sbsr.l sacos # operand is a NORMbra.b _L17_6s_L17_2s:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L17_3s # nobsr.l ld_ppi2 # yesbra.b _L17_6s_L17_3s:cmpi.b %d1,&INF # is operand an INF?bne.b _L17_4s # nobsr.l t_operr # yesbra.b _L17_6s_L17_4s:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L17_5s # nobsr.l src_qnan # yesbra.b _L17_6s_L17_5s:bsr.l sacosd # operand is a DENORM_L17_6s:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _facosd__facosd_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.d 0x8(%a6),%fp0 # load dbl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,precmov.b %d1,STAG(%a6)tst.b %d1bne.b _L17_2dbsr.l sacos # operand is a NORMbra.b _L17_6d_L17_2d:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L17_3d # nobsr.l ld_ppi2 # yesbra.b _L17_6d_L17_3d:cmpi.b %d1,&INF # is operand an INF?bne.b _L17_4d # nobsr.l t_operr # yesbra.b _L17_6d_L17_4d:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L17_5d # nobsr.l src_qnan # yesbra.b _L17_6d_L17_5d:bsr.l sacosd # operand is a DENORM_L17_6d:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _facosx__facosx_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#lea FP_SRC(%a6),%a0mov.l 0x8+0x0(%a6),0x0(%a0) # load ext inputmov.l 0x8+0x4(%a6),0x4(%a0)mov.l 0x8+0x8(%a6),0x8(%a0)bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L17_2xbsr.l sacos # operand is a NORMbra.b _L17_6x_L17_2x:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L17_3x # nobsr.l ld_ppi2 # yesbra.b _L17_6x_L17_3x:cmpi.b %d1,&INF # is operand an INF?bne.b _L17_4x # nobsr.l t_operr # yesbra.b _L17_6x_L17_4x:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L17_5x # nobsr.l src_qnan # yesbra.b _L17_6x_L17_5x:bsr.l sacosd # operand is a DENORM_L17_6x:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rts########################################################################## MONADIC TEMPLATE ##########################################################################global _fgetexps__fgetexps_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.s 0x8(%a6),%fp0 # load sgl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L18_2sbsr.l sgetexp # operand is a NORMbra.b _L18_6s_L18_2s:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L18_3s # nobsr.l src_zero # yesbra.b _L18_6s_L18_3s:cmpi.b %d1,&INF # is operand an INF?bne.b _L18_4s # nobsr.l t_operr # yesbra.b _L18_6s_L18_4s:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L18_5s # nobsr.l src_qnan # yesbra.b _L18_6s_L18_5s:bsr.l sgetexpd # operand is a DENORM_L18_6s:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _fgetexpd__fgetexpd_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.d 0x8(%a6),%fp0 # load dbl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,precmov.b %d1,STAG(%a6)tst.b %d1bne.b _L18_2dbsr.l sgetexp # operand is a NORMbra.b _L18_6d_L18_2d:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L18_3d # nobsr.l src_zero # yesbra.b _L18_6d_L18_3d:cmpi.b %d1,&INF # is operand an INF?bne.b _L18_4d # nobsr.l t_operr # yesbra.b _L18_6d_L18_4d:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L18_5d # nobsr.l src_qnan # yesbra.b _L18_6d_L18_5d:bsr.l sgetexpd # operand is a DENORM_L18_6d:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _fgetexpx__fgetexpx_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#lea FP_SRC(%a6),%a0mov.l 0x8+0x0(%a6),0x0(%a0) # load ext inputmov.l 0x8+0x4(%a6),0x4(%a0)mov.l 0x8+0x8(%a6),0x8(%a0)bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L18_2xbsr.l sgetexp # operand is a NORMbra.b _L18_6x_L18_2x:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L18_3x # nobsr.l src_zero # yesbra.b _L18_6x_L18_3x:cmpi.b %d1,&INF # is operand an INF?bne.b _L18_4x # nobsr.l t_operr # yesbra.b _L18_6x_L18_4x:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L18_5x # nobsr.l src_qnan # yesbra.b _L18_6x_L18_5x:bsr.l sgetexpd # operand is a DENORM_L18_6x:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rts########################################################################## MONADIC TEMPLATE ##########################################################################global _fgetmans__fgetmans_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.s 0x8(%a6),%fp0 # load sgl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L19_2sbsr.l sgetman # operand is a NORMbra.b _L19_6s_L19_2s:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L19_3s # nobsr.l src_zero # yesbra.b _L19_6s_L19_3s:cmpi.b %d1,&INF # is operand an INF?bne.b _L19_4s # nobsr.l t_operr # yesbra.b _L19_6s_L19_4s:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L19_5s # nobsr.l src_qnan # yesbra.b _L19_6s_L19_5s:bsr.l sgetmand # operand is a DENORM_L19_6s:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _fgetmand__fgetmand_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.d 0x8(%a6),%fp0 # load dbl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,precmov.b %d1,STAG(%a6)tst.b %d1bne.b _L19_2dbsr.l sgetman # operand is a NORMbra.b _L19_6d_L19_2d:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L19_3d # nobsr.l src_zero # yesbra.b _L19_6d_L19_3d:cmpi.b %d1,&INF # is operand an INF?bne.b _L19_4d # nobsr.l t_operr # yesbra.b _L19_6d_L19_4d:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L19_5d # nobsr.l src_qnan # yesbra.b _L19_6d_L19_5d:bsr.l sgetmand # operand is a DENORM_L19_6d:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _fgetmanx__fgetmanx_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#lea FP_SRC(%a6),%a0mov.l 0x8+0x0(%a6),0x0(%a0) # load ext inputmov.l 0x8+0x4(%a6),0x4(%a0)mov.l 0x8+0x8(%a6),0x8(%a0)bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L19_2xbsr.l sgetman # operand is a NORMbra.b _L19_6x_L19_2x:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L19_3x # nobsr.l src_zero # yesbra.b _L19_6x_L19_3x:cmpi.b %d1,&INF # is operand an INF?bne.b _L19_4x # nobsr.l t_operr # yesbra.b _L19_6x_L19_4x:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L19_5x # nobsr.l src_qnan # yesbra.b _L19_6x_L19_5x:bsr.l sgetmand # operand is a DENORM_L19_6x:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rts########################################################################## MONADIC TEMPLATE ##########################################################################global _fsincoss__fsincoss_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.s 0x8(%a6),%fp0 # load sgl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L20_2sbsr.l ssincos # operand is a NORMbra.b _L20_6s_L20_2s:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L20_3s # nobsr.l ssincosz # yesbra.b _L20_6s_L20_3s:cmpi.b %d1,&INF # is operand an INF?bne.b _L20_4s # nobsr.l ssincosi # yesbra.b _L20_6s_L20_4s:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L20_5s # nobsr.l ssincosqnan # yesbra.b _L20_6s_L20_5s:bsr.l ssincosd # operand is a DENORM_L20_6s:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x &0x03,-(%sp) # store off fp0/fp1fmovm.x (%sp)+,&0x40 # fp0 now in fp1fmovm.x (%sp)+,&0x80 # fp1 now in fp0unlk %a6rtsglobal _fsincosd__fsincosd_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.d 0x8(%a6),%fp0 # load dbl inputfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,precmov.b %d1,STAG(%a6)tst.b %d1bne.b _L20_2dbsr.l ssincos # operand is a NORMbra.b _L20_6d_L20_2d:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L20_3d # nobsr.l ssincosz # yesbra.b _L20_6d_L20_3d:cmpi.b %d1,&INF # is operand an INF?bne.b _L20_4d # nobsr.l ssincosi # yesbra.b _L20_6d_L20_4d:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L20_5d # nobsr.l ssincosqnan # yesbra.b _L20_6d_L20_5d:bsr.l ssincosd # operand is a DENORM_L20_6d:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x &0x03,-(%sp) # store off fp0/fp1fmovm.x (%sp)+,&0x40 # fp0 now in fp1fmovm.x (%sp)+,&0x80 # fp1 now in fp0unlk %a6rtsglobal _fsincosx__fsincosx_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#lea FP_SRC(%a6),%a0mov.l 0x8+0x0(%a6),0x0(%a0) # load ext inputmov.l 0x8+0x4(%a6),0x4(%a0)mov.l 0x8+0x8(%a6),0x8(%a0)bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.b %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prectst.b %d1bne.b _L20_2xbsr.l ssincos # operand is a NORMbra.b _L20_6x_L20_2x:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L20_3x # nobsr.l ssincosz # yesbra.b _L20_6x_L20_3x:cmpi.b %d1,&INF # is operand an INF?bne.b _L20_4x # nobsr.l ssincosi # yesbra.b _L20_6x_L20_4x:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L20_5x # nobsr.l ssincosqnan # yesbra.b _L20_6x_L20_5x:bsr.l ssincosd # operand is a DENORM_L20_6x:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x &0x03,-(%sp) # store off fp0/fp1fmovm.x (%sp)+,&0x40 # fp0 now in fp1fmovm.x (%sp)+,&0x80 # fp1 now in fp0unlk %a6rts########################################################################## DYADIC TEMPLATE ##########################################################################global _frems__frems_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.s 0x8(%a6),%fp0 # load sgl dstfmov.x %fp0,FP_DST(%a6)lea FP_DST(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,DTAG(%a6)fmov.s 0xc(%a6),%fp0 # load sgl srcfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.l %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,preclea FP_SRC(%a6),%a0 # pass ptr to srclea FP_DST(%a6),%a1 # pass ptr to dsttst.b %d1bne.b _L21_2sbsr.l srem_snorm # operand is a NORMbra.b _L21_6s_L21_2s:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L21_3s # nobsr.l srem_szero # yesbra.b _L21_6s_L21_3s:cmpi.b %d1,&INF # is operand an INF?bne.b _L21_4s # nobsr.l srem_sinf # yesbra.b _L21_6s_L21_4s:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L21_5s # nobsr.l sop_sqnan # yesbra.b _L21_6s_L21_5s:bsr.l srem_sdnrm # operand is a DENORM_L21_6s:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _fremd__fremd_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.d 0x8(%a6),%fp0 # load dbl dstfmov.x %fp0,FP_DST(%a6)lea FP_DST(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,DTAG(%a6)fmov.d 0x10(%a6),%fp0 # load dbl srcfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.l %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,preclea FP_SRC(%a6),%a0 # pass ptr to srclea FP_DST(%a6),%a1 # pass ptr to dsttst.b %d1bne.b _L21_2dbsr.l srem_snorm # operand is a NORMbra.b _L21_6d_L21_2d:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L21_3d # nobsr.l srem_szero # yesbra.b _L21_6d_L21_3d:cmpi.b %d1,&INF # is operand an INF?bne.b _L21_4d # nobsr.l srem_sinf # yesbra.b _L21_6d_L21_4d:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L21_5d # nobsr.l sop_sqnan # yesbra.b _L21_6d_L21_5d:bsr.l srem_sdnrm # operand is a DENORM_L21_6d:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _fremx__fremx_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#lea FP_DST(%a6),%a0mov.l 0x8+0x0(%a6),0x0(%a0) # load ext dstmov.l 0x8+0x4(%a6),0x4(%a0)mov.l 0x8+0x8(%a6),0x8(%a0)bsr.l tag # fetch operand typemov.b %d0,DTAG(%a6)lea FP_SRC(%a6),%a0mov.l 0x14+0x0(%a6),0x0(%a0) # load ext srcmov.l 0x14+0x4(%a6),0x4(%a0)mov.l 0x14+0x8(%a6),0x8(%a0)bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.l %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,preclea FP_SRC(%a6),%a0 # pass ptr to srclea FP_DST(%a6),%a1 # pass ptr to dsttst.b %d1bne.b _L21_2xbsr.l srem_snorm # operand is a NORMbra.b _L21_6x_L21_2x:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L21_3x # nobsr.l srem_szero # yesbra.b _L21_6x_L21_3x:cmpi.b %d1,&INF # is operand an INF?bne.b _L21_4x # nobsr.l srem_sinf # yesbra.b _L21_6x_L21_4x:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L21_5x # nobsr.l sop_sqnan # yesbra.b _L21_6x_L21_5x:bsr.l srem_sdnrm # operand is a DENORM_L21_6x:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rts########################################################################## DYADIC TEMPLATE ##########################################################################global _fmods__fmods_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.s 0x8(%a6),%fp0 # load sgl dstfmov.x %fp0,FP_DST(%a6)lea FP_DST(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,DTAG(%a6)fmov.s 0xc(%a6),%fp0 # load sgl srcfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.l %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,preclea FP_SRC(%a6),%a0 # pass ptr to srclea FP_DST(%a6),%a1 # pass ptr to dsttst.b %d1bne.b _L22_2sbsr.l smod_snorm # operand is a NORMbra.b _L22_6s_L22_2s:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L22_3s # nobsr.l smod_szero # yesbra.b _L22_6s_L22_3s:cmpi.b %d1,&INF # is operand an INF?bne.b _L22_4s # nobsr.l smod_sinf # yesbra.b _L22_6s_L22_4s:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L22_5s # nobsr.l sop_sqnan # yesbra.b _L22_6s_L22_5s:bsr.l smod_sdnrm # operand is a DENORM_L22_6s:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _fmodd__fmodd_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.d 0x8(%a6),%fp0 # load dbl dstfmov.x %fp0,FP_DST(%a6)lea FP_DST(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,DTAG(%a6)fmov.d 0x10(%a6),%fp0 # load dbl srcfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.l %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,preclea FP_SRC(%a6),%a0 # pass ptr to srclea FP_DST(%a6),%a1 # pass ptr to dsttst.b %d1bne.b _L22_2dbsr.l smod_snorm # operand is a NORMbra.b _L22_6d_L22_2d:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L22_3d # nobsr.l smod_szero # yesbra.b _L22_6d_L22_3d:cmpi.b %d1,&INF # is operand an INF?bne.b _L22_4d # nobsr.l smod_sinf # yesbra.b _L22_6d_L22_4d:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L22_5d # nobsr.l sop_sqnan # yesbra.b _L22_6d_L22_5d:bsr.l smod_sdnrm # operand is a DENORM_L22_6d:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _fmodx__fmodx_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#lea FP_DST(%a6),%a0mov.l 0x8+0x0(%a6),0x0(%a0) # load ext dstmov.l 0x8+0x4(%a6),0x4(%a0)mov.l 0x8+0x8(%a6),0x8(%a0)bsr.l tag # fetch operand typemov.b %d0,DTAG(%a6)lea FP_SRC(%a6),%a0mov.l 0x14+0x0(%a6),0x0(%a0) # load ext srcmov.l 0x14+0x4(%a6),0x4(%a0)mov.l 0x14+0x8(%a6),0x8(%a0)bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.l %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,preclea FP_SRC(%a6),%a0 # pass ptr to srclea FP_DST(%a6),%a1 # pass ptr to dsttst.b %d1bne.b _L22_2xbsr.l smod_snorm # operand is a NORMbra.b _L22_6x_L22_2x:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L22_3x # nobsr.l smod_szero # yesbra.b _L22_6x_L22_3x:cmpi.b %d1,&INF # is operand an INF?bne.b _L22_4x # nobsr.l smod_sinf # yesbra.b _L22_6x_L22_4x:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L22_5x # nobsr.l sop_sqnan # yesbra.b _L22_6x_L22_5x:bsr.l smod_sdnrm # operand is a DENORM_L22_6x:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rts########################################################################## DYADIC TEMPLATE ##########################################################################global _fscales__fscales_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.s 0x8(%a6),%fp0 # load sgl dstfmov.x %fp0,FP_DST(%a6)lea FP_DST(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,DTAG(%a6)fmov.s 0xc(%a6),%fp0 # load sgl srcfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.l %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,preclea FP_SRC(%a6),%a0 # pass ptr to srclea FP_DST(%a6),%a1 # pass ptr to dsttst.b %d1bne.b _L23_2sbsr.l sscale_snorm # operand is a NORMbra.b _L23_6s_L23_2s:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L23_3s # nobsr.l sscale_szero # yesbra.b _L23_6s_L23_3s:cmpi.b %d1,&INF # is operand an INF?bne.b _L23_4s # nobsr.l sscale_sinf # yesbra.b _L23_6s_L23_4s:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L23_5s # nobsr.l sop_sqnan # yesbra.b _L23_6s_L23_5s:bsr.l sscale_sdnrm # operand is a DENORM_L23_6s:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _fscaled__fscaled_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#fmov.d 0x8(%a6),%fp0 # load dbl dstfmov.x %fp0,FP_DST(%a6)lea FP_DST(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,DTAG(%a6)fmov.d 0x10(%a6),%fp0 # load dbl srcfmov.x %fp0,FP_SRC(%a6)lea FP_SRC(%a6),%a0bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.l %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,preclea FP_SRC(%a6),%a0 # pass ptr to srclea FP_DST(%a6),%a1 # pass ptr to dsttst.b %d1bne.b _L23_2dbsr.l sscale_snorm # operand is a NORMbra.b _L23_6d_L23_2d:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L23_3d # nobsr.l sscale_szero # yesbra.b _L23_6d_L23_3d:cmpi.b %d1,&INF # is operand an INF?bne.b _L23_4d # nobsr.l sscale_sinf # yesbra.b _L23_6d_L23_4d:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L23_5d # nobsr.l sop_sqnan # yesbra.b _L23_6d_L23_5d:bsr.l sscale_sdnrm # operand is a DENORM_L23_6d:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rtsglobal _fscalex__fscalex_:link %a6,&-LOCAL_SIZEmovm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regsfmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1fmov.l &0x0,%fpcr # zero FPCR## copy, convert, and tag input argument#lea FP_DST(%a6),%a0mov.l 0x8+0x0(%a6),0x0(%a0) # load ext dstmov.l 0x8+0x4(%a6),0x4(%a0)mov.l 0x8+0x8(%a6),0x8(%a0)bsr.l tag # fetch operand typemov.b %d0,DTAG(%a6)lea FP_SRC(%a6),%a0mov.l 0x14+0x0(%a6),0x0(%a0) # load ext srcmov.l 0x14+0x4(%a6),0x4(%a0)mov.l 0x14+0x8(%a6),0x8(%a0)bsr.l tag # fetch operand typemov.b %d0,STAG(%a6)mov.l %d0,%d1andi.l &0x00ff00ff,USER_FPSR(%a6)clr.l %d0mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,preclea FP_SRC(%a6),%a0 # pass ptr to srclea FP_DST(%a6),%a1 # pass ptr to dsttst.b %d1bne.b _L23_2xbsr.l sscale_snorm # operand is a NORMbra.b _L23_6x_L23_2x:cmpi.b %d1,&ZERO # is operand a ZERO?bne.b _L23_3x # nobsr.l sscale_szero # yesbra.b _L23_6x_L23_3x:cmpi.b %d1,&INF # is operand an INF?bne.b _L23_4x # nobsr.l sscale_sinf # yesbra.b _L23_6x_L23_4x:cmpi.b %d1,&QNAN # is operand a QNAN?bne.b _L23_5x # nobsr.l sop_sqnan # yesbra.b _L23_6x_L23_5x:bsr.l sscale_sdnrm # operand is a DENORM_L23_6x:## Result is now in FP0#movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regsfmovm.x EXC_FP1(%a6),&0x40 # restore fp1unlk %a6rts########################################################################## ssin(): computes the sine of a normalized input ## ssind(): computes the sine of a denormalized input ## scos(): computes the cosine of a normalized input ## scosd(): computes the cosine of a denormalized input ## ssincos(): computes the sine and cosine of a normalized input ## ssincosd(): computes the sine and cosine of a denormalized input ## ## INPUT *************************************************************** ## a0 = pointer to extended precision input ## d0 = round precision,mode ## ## OUTPUT ************************************************************** ## fp0 = sin(X) or cos(X) ## ## For ssincos(X): ## fp0 = sin(X) ## fp1 = cos(X) ## ## ACCURACY and MONOTONICITY ******************************************* ## The returned result is within 1 ulp in 64 significant bit, i.e. ## within 0.5001 ulp to 53 bits if the result is subsequently ## rounded to double precision. The result is provably monotonic ## in double precision. ## ## ALGORITHM *********************************************************** ## ## SIN and COS: ## 1. If SIN is invoked, set AdjN := 0; otherwise, set AdjN := 1. ## ## 2. If |X| >= 15Pi or |X| < 2**(-40), go to 7. ## ## 3. Decompose X as X = N(Pi/2) + r where |r| <= Pi/4. Let ## k = N mod 4, so in particular, k = 0,1,2,or 3. ## Overwrite k by k := k + AdjN. ## ## 4. If k is even, go to 6. ## ## 5. (k is odd) Set j := (k-1)/2, sgn := (-1)**j. ## Return sgn*cos(r) where cos(r) is approximated by an ## even polynomial in r, 1 + r*r*(B1+s*(B2+ ... + s*B8)), ## s = r*r. ## Exit. ## ## 6. (k is even) Set j := k/2, sgn := (-1)**j. Return sgn*sin(r) ## where sin(r) is approximated by an odd polynomial in r ## r + r*s*(A1+s*(A2+ ... + s*A7)), s = r*r. ## Exit. ## ## 7. If |X| > 1, go to 9. ## ## 8. (|X|<2**(-40)) If SIN is invoked, return X; ## otherwise return 1. ## ## 9. Overwrite X by X := X rem 2Pi. Now that |X| <= Pi, ## go back to 3. ## ## SINCOS: ## 1. If |X| >= 15Pi or |X| < 2**(-40), go to 6. ## ## 2. Decompose X as X = N(Pi/2) + r where |r| <= Pi/4. Let ## k = N mod 4, so in particular, k = 0,1,2,or 3. ## ## 3. If k is even, go to 5. ## ## 4. (k is odd) Set j1 := (k-1)/2, j2 := j1 (EOR) (k mod 2), ie. ## j1 exclusive or with the l.s.b. of k. ## sgn1 := (-1)**j1, sgn2 := (-1)**j2. ## SIN(X) = sgn1 * cos(r) and COS(X) = sgn2*sin(r) where ## sin(r) and cos(r) are computed as odd and even ## polynomials in r, respectively. Exit ## ## 5. (k is even) Set j1 := k/2, sgn1 := (-1)**j1. ## SIN(X) = sgn1 * sin(r) and COS(X) = sgn1*cos(r) where ## sin(r) and cos(r) are computed as odd and even ## polynomials in r, respectively. Exit ## ## 6. If |X| > 1, go to 8. ## ## 7. (|X|<2**(-40)) SIN(X) = X and COS(X) = 1. Exit. ## ## 8. Overwrite X by X := X rem 2Pi. Now that |X| <= Pi, ## go back to 2. ## ##########################################################################SINA7: long 0xBD6AAA77,0xCCC994F5SINA6: long 0x3DE61209,0x7AAE8DA1SINA5: long 0xBE5AE645,0x2A118AE4SINA4: long 0x3EC71DE3,0xA5341531SINA3: long 0xBF2A01A0,0x1A018B59,0x00000000,0x00000000SINA2: long 0x3FF80000,0x88888888,0x888859AF,0x00000000SINA1: long 0xBFFC0000,0xAAAAAAAA,0xAAAAAA99,0x00000000COSB8: long 0x3D2AC4D0,0xD6011EE3COSB7: long 0xBDA9396F,0x9F45AC19COSB6: long 0x3E21EED9,0x0612C972COSB5: long 0xBE927E4F,0xB79D9FCFCOSB4: long 0x3EFA01A0,0x1A01D423,0x00000000,0x00000000COSB3: long 0xBFF50000,0xB60B60B6,0x0B61D438,0x00000000COSB2: long 0x3FFA0000,0xAAAAAAAA,0xAAAAAB5ECOSB1: long 0xBF000000set INARG,FP_SCR0set X,FP_SCR0# set XDCARE,X+2set XFRAC,X+4set RPRIME,FP_SCR0set SPRIME,FP_SCR1set POSNEG1,L_SCR1set TWOTO63,L_SCR1set ENDFLAG,L_SCR2set INT,L_SCR2set ADJN,L_SCR3############################################global ssinssin:mov.l &0,ADJN(%a6) # yes; SET ADJN TO 0bra.b SINBGN############################################global scosscos:mov.l &1,ADJN(%a6) # yes; SET ADJN TO 1############################################SINBGN:#--SAVE FPCR, FP1. CHECK IF |X| IS TOO SMALL OR LARGEfmov.x (%a0),%fp0 # LOAD INPUTfmov.x %fp0,X(%a6) # save input at X# "COMPACTIFY" Xmov.l (%a0),%d1 # put exp in hi wordmov.w 4(%a0),%d1 # fetch hi(man)and.l &0x7FFFFFFF,%d1 # strip signcmpi.l %d1,&0x3FD78000 # is |X| >= 2**(-40)?bge.b SOK1 # nobra.w SINSM # yes; input is very smallSOK1:cmp.l %d1,&0x4004BC7E # is |X| < 15 PI?blt.b SINMAIN # nobra.w SREDUCEX # yes; input is very large#--THIS IS THE USUAL CASE, |X| <= 15 PI.#--THE ARGUMENT REDUCTION IS DONE BY TABLE LOOK UP.SINMAIN:fmov.x %fp0,%fp1fmul.d TWOBYPI(%pc),%fp1 # X*2/PIlea PITBL+0x200(%pc),%a1 # TABLE OF N*PI/2, N = -32,...,32fmov.l %fp1,INT(%a6) # CONVERT TO INTEGERmov.l INT(%a6),%d1 # make a copy of Nasl.l &4,%d1 # N *= 16add.l %d1,%a1 # tbl_addr = a1 + (N*16)# A1 IS THE ADDRESS OF N*PIBY2# ...WHICH IS IN TWO PIECES Y1 & Y2fsub.x (%a1)+,%fp0 # X-Y1fsub.s (%a1),%fp0 # fp0 = R = (X-Y1)-Y2SINCONT:#--continuation from REDUCEX#--GET N+ADJN AND SEE IF SIN(R) OR COS(R) IS NEEDEDmov.l INT(%a6),%d1add.l ADJN(%a6),%d1 # SEE IF D0 IS ODD OR EVENror.l &1,%d1 # D0 WAS ODD IFF D0 IS NEGATIVEcmp.l %d1,&0blt.w COSPOLY#--LET J BE THE LEAST SIG. BIT OF D0, LET SGN := (-1)**J.#--THEN WE RETURN SGN*SIN(R). SGN*SIN(R) IS COMPUTED BY#--R' + R'*S*(A1 + S(A2 + S(A3 + S(A4 + ... + SA7)))), WHERE#--R' = SGN*R, S=R*R. THIS CAN BE REWRITTEN AS#--R' + R'*S*( [A1+T(A3+T(A5+TA7))] + [S(A2+T(A4+TA6))])#--WHERE T=S*S.#--NOTE THAT A3 THROUGH A7 ARE STORED IN DOUBLE PRECISION#--WHILE A1 AND A2 ARE IN DOUBLE-EXTENDED FORMAT.SINPOLY:fmovm.x &0x0c,-(%sp) # save fp2/fp3fmov.x %fp0,X(%a6) # X IS Rfmul.x %fp0,%fp0 # FP0 IS Sfmov.d SINA7(%pc),%fp3fmov.d SINA6(%pc),%fp2fmov.x %fp0,%fp1fmul.x %fp1,%fp1 # FP1 IS Tror.l &1,%d1and.l &0x80000000,%d1# ...LEAST SIG. BIT OF D0 IN SIGN POSITIONeor.l %d1,X(%a6) # X IS NOW R'= SGN*Rfmul.x %fp1,%fp3 # TA7fmul.x %fp1,%fp2 # TA6fadd.d SINA5(%pc),%fp3 # A5+TA7fadd.d SINA4(%pc),%fp2 # A4+TA6fmul.x %fp1,%fp3 # T(A5+TA7)fmul.x %fp1,%fp2 # T(A4+TA6)fadd.d SINA3(%pc),%fp3 # A3+T(A5+TA7)fadd.x SINA2(%pc),%fp2 # A2+T(A4+TA6)fmul.x %fp3,%fp1 # T(A3+T(A5+TA7))fmul.x %fp0,%fp2 # S(A2+T(A4+TA6))fadd.x SINA1(%pc),%fp1 # A1+T(A3+T(A5+TA7))fmul.x X(%a6),%fp0 # R'*Sfadd.x %fp2,%fp1 # [A1+T(A3+T(A5+TA7))]+[S(A2+T(A4+TA6))]fmul.x %fp1,%fp0 # SIN(R')-R'fmovm.x (%sp)+,&0x30 # restore fp2/fp3fmov.l %d0,%fpcr # restore users round mode,precfadd.x X(%a6),%fp0 # last inst - possible exception setbra t_inx2#--LET J BE THE LEAST SIG. BIT OF D0, LET SGN := (-1)**J.#--THEN WE RETURN SGN*COS(R). SGN*COS(R) IS COMPUTED BY#--SGN + S'*(B1 + S(B2 + S(B3 + S(B4 + ... + SB8)))), WHERE#--S=R*R AND S'=SGN*S. THIS CAN BE REWRITTEN AS#--SGN + S'*([B1+T(B3+T(B5+TB7))] + [S(B2+T(B4+T(B6+TB8)))])#--WHERE T=S*S.#--NOTE THAT B4 THROUGH B8 ARE STORED IN DOUBLE PRECISION#--WHILE B2 AND B3 ARE IN DOUBLE-EXTENDED FORMAT, B1 IS -1/2#--AND IS THEREFORE STORED AS SINGLE PRECISION.COSPOLY:fmovm.x &0x0c,-(%sp) # save fp2/fp3fmul.x %fp0,%fp0 # FP0 IS Sfmov.d COSB8(%pc),%fp2fmov.d COSB7(%pc),%fp3fmov.x %fp0,%fp1fmul.x %fp1,%fp1 # FP1 IS Tfmov.x %fp0,X(%a6) # X IS Sror.l &1,%d1and.l &0x80000000,%d1# ...LEAST SIG. BIT OF D0 IN SIGN POSITIONfmul.x %fp1,%fp2 # TB8eor.l %d1,X(%a6) # X IS NOW S'= SGN*Sand.l &0x80000000,%d1fmul.x %fp1,%fp3 # TB7or.l &0x3F800000,%d1 # D0 IS SGN IN SINGLEmov.l %d1,POSNEG1(%a6)fadd.d COSB6(%pc),%fp2 # B6+TB8fadd.d COSB5(%pc),%fp3 # B5+TB7fmul.x %fp1,%fp2 # T(B6+TB8)fmul.x %fp1,%fp3 # T(B5+TB7)fadd.d COSB4(%pc),%fp2 # B4+T(B6+TB8)fadd.x COSB3(%pc),%fp3 # B3+T(B5+TB7)fmul.x %fp1,%fp2 # T(B4+T(B6+TB8))fmul.x %fp3,%fp1 # T(B3+T(B5+TB7))fadd.x COSB2(%pc),%fp2 # B2+T(B4+T(B6+TB8))fadd.s COSB1(%pc),%fp1 # B1+T(B3+T(B5+TB7))fmul.x %fp2,%fp0 # S(B2+T(B4+T(B6+TB8)))fadd.x %fp1,%fp0fmul.x X(%a6),%fp0fmovm.x (%sp)+,&0x30 # restore fp2/fp3fmov.l %d0,%fpcr # restore users round mode,precfadd.s POSNEG1(%a6),%fp0 # last inst - possible exception setbra t_inx2############################################### SINe: Big OR Small?#--IF |X| > 15PI, WE USE THE GENERAL ARGUMENT REDUCTION.#--IF |X| < 2**(-40), RETURN X OR 1.SINBORS:cmp.l %d1,&0x3FFF8000bgt.l SREDUCEXSINSM:mov.l ADJN(%a6),%d1cmp.l %d1,&0bgt.b COSTINY# here, the operation may underflow iff the precision is sgl or dbl.# extended denorms are handled through another entry point.SINTINY:# mov.w &0x0000,XDCARE(%a6) # JUST IN CASEfmov.l %d0,%fpcr # restore users round mode,precmov.b &FMOV_OP,%d1 # last inst is MOVEfmov.x X(%a6),%fp0 # last inst - possible exception setbra t_catchCOSTINY:fmov.s &0x3F800000,%fp0 # fp0 = 1.0fmov.l %d0,%fpcr # restore users round mode,precfadd.s &0x80800000,%fp0 # last inst - possible exception setbra t_pinx2################################################global ssind#--SIN(X) = X FOR DENORMALIZED Xssind:bra t_extdnrm############################################global scosd#--COS(X) = 1 FOR DENORMALIZED Xscosd:fmov.s &0x3F800000,%fp0 # fp0 = 1.0bra t_pinx2##################################################global ssincosssincos:#--SET ADJN TO 4mov.l &4,ADJN(%a6)fmov.x (%a0),%fp0 # LOAD INPUTfmov.x %fp0,X(%a6)mov.l (%a0),%d1mov.w 4(%a0),%d1and.l &0x7FFFFFFF,%d1 # COMPACTIFY Xcmp.l %d1,&0x3FD78000 # |X| >= 2**(-40)?bge.b SCOK1bra.w SCSMSCOK1:cmp.l %d1,&0x4004BC7E # |X| < 15 PI?blt.b SCMAINbra.w SREDUCEX#--THIS IS THE USUAL CASE, |X| <= 15 PI.#--THE ARGUMENT REDUCTION IS DONE BY TABLE LOOK UP.SCMAIN:fmov.x %fp0,%fp1fmul.d TWOBYPI(%pc),%fp1 # X*2/PIlea PITBL+0x200(%pc),%a1 # TABLE OF N*PI/2, N = -32,...,32fmov.l %fp1,INT(%a6) # CONVERT TO INTEGERmov.l INT(%a6),%d1asl.l &4,%d1add.l %d1,%a1 # ADDRESS OF N*PIBY2, IN Y1, Y2fsub.x (%a1)+,%fp0 # X-Y1fsub.s (%a1),%fp0 # FP0 IS R = (X-Y1)-Y2SCCONT:#--continuation point from REDUCEXmov.l INT(%a6),%d1ror.l &1,%d1cmp.l %d1,&0 # D0 < 0 IFF N IS ODDbge.w NEVENSNODD:#--REGISTERS SAVED SO FAR: D0, A0, FP2.fmovm.x &0x04,-(%sp) # save fp2fmov.x %fp0,RPRIME(%a6)fmul.x %fp0,%fp0 # FP0 IS S = R*Rfmov.d SINA7(%pc),%fp1 # A7fmov.d COSB8(%pc),%fp2 # B8fmul.x %fp0,%fp1 # SA7fmul.x %fp0,%fp2 # SB8mov.l %d2,-(%sp)mov.l %d1,%d2ror.l &1,%d2and.l &0x80000000,%d2eor.l %d1,%d2and.l &0x80000000,%d2fadd.d SINA6(%pc),%fp1 # A6+SA7fadd.d COSB7(%pc),%fp2 # B7+SB8fmul.x %fp0,%fp1 # S(A6+SA7)eor.l %d2,RPRIME(%a6)mov.l (%sp)+,%d2fmul.x %fp0,%fp2 # S(B7+SB8)ror.l &1,%d1and.l &0x80000000,%d1mov.l &0x3F800000,POSNEG1(%a6)eor.l %d1,POSNEG1(%a6)fadd.d SINA5(%pc),%fp1 # A5+S(A6+SA7)fadd.d COSB6(%pc),%fp2 # B6+S(B7+SB8)fmul.x %fp0,%fp1 # S(A5+S(A6+SA7))fmul.x %fp0,%fp2 # S(B6+S(B7+SB8))fmov.x %fp0,SPRIME(%a6)fadd.d SINA4(%pc),%fp1 # A4+S(A5+S(A6+SA7))eor.l %d1,SPRIME(%a6)fadd.d COSB5(%pc),%fp2 # B5+S(B6+S(B7+SB8))fmul.x %fp0,%fp1 # S(A4+...)fmul.x %fp0,%fp2 # S(B5+...)fadd.d SINA3(%pc),%fp1 # A3+S(A4+...)fadd.d COSB4(%pc),%fp2 # B4+S(B5+...)fmul.x %fp0,%fp1 # S(A3+...)fmul.x %fp0,%fp2 # S(B4+...)fadd.x SINA2(%pc),%fp1 # A2+S(A3+...)fadd.x COSB3(%pc),%fp2 # B3+S(B4+...)fmul.x %fp0,%fp1 # S(A2+...)fmul.x %fp0,%fp2 # S(B3+...)fadd.x SINA1(%pc),%fp1 # A1+S(A2+...)fadd.x COSB2(%pc),%fp2 # B2+S(B3+...)fmul.x %fp0,%fp1 # S(A1+...)fmul.x %fp2,%fp0 # S(B2+...)fmul.x RPRIME(%a6),%fp1 # R'S(A1+...)fadd.s COSB1(%pc),%fp0 # B1+S(B2...)fmul.x SPRIME(%a6),%fp0 # S'(B1+S(B2+...))fmovm.x (%sp)+,&0x20 # restore fp2fmov.l %d0,%fpcrfadd.x RPRIME(%a6),%fp1 # COS(X)bsr sto_cos # store cosine resultfadd.s POSNEG1(%a6),%fp0 # SIN(X)bra t_inx2NEVEN:#--REGISTERS SAVED SO FAR: FP2.fmovm.x &0x04,-(%sp) # save fp2fmov.x %fp0,RPRIME(%a6)fmul.x %fp0,%fp0 # FP0 IS S = R*Rfmov.d COSB8(%pc),%fp1 # B8fmov.d SINA7(%pc),%fp2 # A7fmul.x %fp0,%fp1 # SB8fmov.x %fp0,SPRIME(%a6)fmul.x %fp0,%fp2 # SA7ror.l &1,%d1and.l &0x80000000,%d1fadd.d COSB7(%pc),%fp1 # B7+SB8fadd.d SINA6(%pc),%fp2 # A6+SA7eor.l %d1,RPRIME(%a6)eor.l %d1,SPRIME(%a6)fmul.x %fp0,%fp1 # S(B7+SB8)or.l &0x3F800000,%d1mov.l %d1,POSNEG1(%a6)fmul.x %fp0,%fp2 # S(A6+SA7)fadd.d COSB6(%pc),%fp1 # B6+S(B7+SB8)fadd.d SINA5(%pc),%fp2 # A5+S(A6+SA7)fmul.x %fp0,%fp1 # S(B6+S(B7+SB8))fmul.x %fp0,%fp2 # S(A5+S(A6+SA7))fadd.d COSB5(%pc),%fp1 # B5+S(B6+S(B7+SB8))fadd.d SINA4(%pc),%fp2 # A4+S(A5+S(A6+SA7))fmul.x %fp0,%fp1 # S(B5+...)fmul.x %fp0,%fp2 # S(A4+...)fadd.d COSB4(%pc),%fp1 # B4+S(B5+...)fadd.d SINA3(%pc),%fp2 # A3+S(A4+...)fmul.x %fp0,%fp1 # S(B4+...)fmul.x %fp0,%fp2 # S(A3+...)fadd.x COSB3(%pc),%fp1 # B3+S(B4+...)fadd.x SINA2(%pc),%fp2 # A2+S(A3+...)fmul.x %fp0,%fp1 # S(B3+...)fmul.x %fp0,%fp2 # S(A2+...)fadd.x COSB2(%pc),%fp1 # B2+S(B3+...)fadd.x SINA1(%pc),%fp2 # A1+S(A2+...)fmul.x %fp0,%fp1 # S(B2+...)fmul.x %fp2,%fp0 # s(a1+...)fadd.s COSB1(%pc),%fp1 # B1+S(B2...)fmul.x RPRIME(%a6),%fp0 # R'S(A1+...)fmul.x SPRIME(%a6),%fp1 # S'(B1+S(B2+...))fmovm.x (%sp)+,&0x20 # restore fp2fmov.l %d0,%fpcrfadd.s POSNEG1(%a6),%fp1 # COS(X)bsr sto_cos # store cosine resultfadd.x RPRIME(%a6),%fp0 # SIN(X)bra t_inx2################################################SCBORS:cmp.l %d1,&0x3FFF8000bgt.w SREDUCEX################################################SCSM:# mov.w &0x0000,XDCARE(%a6)fmov.s &0x3F800000,%fp1fmov.l %d0,%fpcrfsub.s &0x00800000,%fp1bsr sto_cos # store cosine resultfmov.l %fpcr,%d0 # d0 must have fpcr,toomov.b &FMOV_OP,%d1 # last inst is MOVEfmov.x X(%a6),%fp0bra t_catch##############################################global ssincosd#--SIN AND COS OF X FOR DENORMALIZED Xssincosd:mov.l %d0,-(%sp) # save d0fmov.s &0x3F800000,%fp1bsr sto_cos # store cosine resultmov.l (%sp)+,%d0 # restore d0bra t_extdnrm#############################################--WHEN REDUCEX IS USED, THE CODE WILL INEVITABLY BE SLOW.#--THIS REDUCTION METHOD, HOWEVER, IS MUCH FASTER THAN USING#--THE REMAINDER INSTRUCTION WHICH IS NOW IN SOFTWARE.SREDUCEX:fmovm.x &0x3c,-(%sp) # save {fp2-fp5}mov.l %d2,-(%sp) # save d2fmov.s &0x00000000,%fp1 # fp1 = 0#--If compact form of abs(arg) in d0=$7ffeffff, argument is so large that#--there is a danger of unwanted overflow in first LOOP iteration. In this#--case, reduce argument by one remainder step to make subsequent reduction#--safe.cmp.l %d1,&0x7ffeffff # is arg dangerously large?bne.b SLOOP # no# yes; create 2**16383*PI/2mov.w &0x7ffe,FP_SCR0_EX(%a6)mov.l &0xc90fdaa2,FP_SCR0_HI(%a6)clr.l FP_SCR0_LO(%a6)# create low half of 2**16383*PI/2 at FP_SCR1mov.w &0x7fdc,FP_SCR1_EX(%a6)mov.l &0x85a308d3,FP_SCR1_HI(%a6)clr.l FP_SCR1_LO(%a6)ftest.x %fp0 # test sign of argumentfblt.w sred_negor.b &0x80,FP_SCR0_EX(%a6) # positive argor.b &0x80,FP_SCR1_EX(%a6)sred_neg:fadd.x FP_SCR0(%a6),%fp0 # high part of reduction is exactfmov.x %fp0,%fp1 # save high result in fp1fadd.x FP_SCR1(%a6),%fp0 # low part of reductionfsub.x %fp0,%fp1 # determine low component of resultfadd.x FP_SCR1(%a6),%fp1 # fp0/fp1 are reduced argument.#--ON ENTRY, FP0 IS X, ON RETURN, FP0 IS X REM PI/2, |X| <= PI/4.#--integer quotient will be stored in N#--Intermeditate remainder is 66-bit long; (R,r) in (FP0,FP1)SLOOP:fmov.x %fp0,INARG(%a6) # +-2**K * F, 1 <= F < 2mov.w INARG(%a6),%d1mov.l %d1,%a1 # save a copy of D0and.l &0x00007FFF,%d1sub.l &0x00003FFF,%d1 # d0 = Kcmp.l %d1,&28ble.b SLASTLOOPSCONTLOOP:sub.l &27,%d1 # d0 = L := K-27mov.b &0,ENDFLAG(%a6)bra.b SWORKSLASTLOOP:clr.l %d1 # d0 = L := 0mov.b &1,ENDFLAG(%a6)SWORK:#--FIND THE REMAINDER OF (R,r) W.R.T. 2**L * (PI/2). L IS SO CHOSEN#--THAT INT( X * (2/PI) / 2**(L) ) < 2**29.#--CREATE 2**(-L) * (2/PI), SIGN(INARG)*2**(63),#--2**L * (PIby2_1), 2**L * (PIby2_2)mov.l &0x00003FFE,%d2 # BIASED EXP OF 2/PIsub.l %d1,%d2 # BIASED EXP OF 2**(-L)*(2/PI)mov.l &0xA2F9836E,FP_SCR0_HI(%a6)mov.l &0x4E44152A,FP_SCR0_LO(%a6)mov.w %d2,FP_SCR0_EX(%a6) # FP_SCR0 = 2**(-L)*(2/PI)fmov.x %fp0,%fp2fmul.x FP_SCR0(%a6),%fp2 # fp2 = X * 2**(-L)*(2/PI)#--WE MUST NOW FIND INT(FP2). SINCE WE NEED THIS VALUE IN#--FLOATING POINT FORMAT, THE TWO FMOVE'S FMOVE.L FP <--> N#--WILL BE TOO INEFFICIENT. THE WAY AROUND IT IS THAT#--(SIGN(INARG)*2**63 + FP2) - SIGN(INARG)*2**63 WILL GIVE#--US THE DESIRED VALUE IN FLOATING POINT.mov.l %a1,%d2swap %d2and.l &0x80000000,%d2or.l &0x5F000000,%d2 # d2 = SIGN(INARG)*2**63 IN SGLmov.l %d2,TWOTO63(%a6)fadd.s TWOTO63(%a6),%fp2 # THE FRACTIONAL PART OF FP1 IS ROUNDEDfsub.s TWOTO63(%a6),%fp2 # fp2 = N# fint.x %fp2#--CREATING 2**(L)*Piby2_1 and 2**(L)*Piby2_2mov.l %d1,%d2 # d2 = Ladd.l &0x00003FFF,%d2 # BIASED EXP OF 2**L * (PI/2)mov.w %d2,FP_SCR0_EX(%a6)mov.l &0xC90FDAA2,FP_SCR0_HI(%a6)clr.l FP_SCR0_LO(%a6) # FP_SCR0 = 2**(L) * Piby2_1add.l &0x00003FDD,%d1mov.w %d1,FP_SCR1_EX(%a6)mov.l &0x85A308D3,FP_SCR1_HI(%a6)clr.l FP_SCR1_LO(%a6) # FP_SCR1 = 2**(L) * Piby2_2mov.b ENDFLAG(%a6),%d1#--We are now ready to perform (R+r) - N*P1 - N*P2, P1 = 2**(L) * Piby2_1 and#--P2 = 2**(L) * Piby2_2fmov.x %fp2,%fp4 # fp4 = Nfmul.x FP_SCR0(%a6),%fp4 # fp4 = W = N*P1fmov.x %fp2,%fp5 # fp5 = Nfmul.x FP_SCR1(%a6),%fp5 # fp5 = w = N*P2fmov.x %fp4,%fp3 # fp3 = W = N*P1#--we want P+p = W+w but |p| <= half ulp of P#--Then, we need to compute A := R-P and a := r-pfadd.x %fp5,%fp3 # fp3 = Pfsub.x %fp3,%fp4 # fp4 = W-Pfsub.x %fp3,%fp0 # fp0 = A := R - Pfadd.x %fp5,%fp4 # fp4 = p = (W-P)+wfmov.x %fp0,%fp3 # fp3 = Afsub.x %fp4,%fp1 # fp1 = a := r - p#--Now we need to normalize (A,a) to "new (R,r)" where R+r = A+a but#--|r| <= half ulp of R.fadd.x %fp1,%fp0 # fp0 = R := A+a#--No need to calculate r if this is the last loopcmp.b %d1,&0bgt.w SRESTORE#--Need to calculate rfsub.x %fp0,%fp3 # fp3 = A-Rfadd.x %fp3,%fp1 # fp1 = r := (A-R)+abra.w SLOOPSRESTORE:fmov.l %fp2,INT(%a6)mov.l (%sp)+,%d2 # restore d2fmovm.x (%sp)+,&0x3c # restore {fp2-fp5}mov.l ADJN(%a6),%d1cmp.l %d1,&4blt.w SINCONTbra.w SCCONT########################################################################## stan(): computes the tangent of a normalized input ## stand(): computes the tangent of a denormalized input ## ## INPUT *************************************************************** ## a0 = pointer to extended precision input ## d0 = round precision,mode ## ## OUTPUT ************************************************************** ## fp0 = tan(X) ## ## ACCURACY and MONOTONICITY ******************************************* ## The returned result is within 3 ulp in 64 significant bit, i.e. ## within 0.5001 ulp to 53 bits if the result is subsequently ## rounded to double precision. The result is provably monotonic ## in double precision. ## ## ALGORITHM *********************************************************** ## ## 1. If |X| >= 15Pi or |X| < 2**(-40), go to 6. ## ## 2. Decompose X as X = N(Pi/2) + r where |r| <= Pi/4. Let ## k = N mod 2, so in particular, k = 0 or 1. ## ## 3. If k is odd, go to 5. ## ## 4. (k is even) Tan(X) = tan(r) and tan(r) is approximated by a ## rational function U/V where ## U = r + r*s*(P1 + s*(P2 + s*P3)), and ## V = 1 + s*(Q1 + s*(Q2 + s*(Q3 + s*Q4))), s = r*r. ## Exit. ## ## 4. (k is odd) Tan(X) = -cot(r). Since tan(r) is approximated by ## a rational function U/V where ## U = r + r*s*(P1 + s*(P2 + s*P3)), and ## V = 1 + s*(Q1 + s*(Q2 + s*(Q3 + s*Q4))), s = r*r, ## -Cot(r) = -V/U. Exit. ## ## 6. If |X| > 1, go to 8. ## ## 7. (|X|<2**(-40)) Tan(X) = X. Exit. ## ## 8. Overwrite X by X := X rem 2Pi. Now that |X| <= Pi, go back ## to 2. ## ##########################################################################TANQ4:long 0x3EA0B759,0xF50F8688TANP3:long 0xBEF2BAA5,0xA8924F04TANQ3:long 0xBF346F59,0xB39BA65F,0x00000000,0x00000000TANP2:long 0x3FF60000,0xE073D3FC,0x199C4A00,0x00000000TANQ2:long 0x3FF90000,0xD23CD684,0x15D95FA1,0x00000000TANP1:long 0xBFFC0000,0x8895A6C5,0xFB423BCA,0x00000000TANQ1:long 0xBFFD0000,0xEEF57E0D,0xA84BC8CE,0x00000000INVTWOPI:long 0x3FFC0000,0xA2F9836E,0x4E44152A,0x00000000TWOPI1:long 0x40010000,0xC90FDAA2,0x00000000,0x00000000TWOPI2:long 0x3FDF0000,0x85A308D4,0x00000000,0x00000000#--N*PI/2, -32 <= N <= 32, IN A LEADING TERM IN EXT. AND TRAILING#--TERM IN SGL. NOTE THAT PI IS 64-BIT LONG, THUS N*PI/2 IS AT#--MOST 69 BITS LONG.# global PITBLPITBL:long 0xC0040000,0xC90FDAA2,0x2168C235,0x21800000long 0xC0040000,0xC2C75BCD,0x105D7C23,0xA0D00000long 0xC0040000,0xBC7EDCF7,0xFF523611,0xA1E80000long 0xC0040000,0xB6365E22,0xEE46F000,0x21480000long 0xC0040000,0xAFEDDF4D,0xDD3BA9EE,0xA1200000long 0xC0040000,0xA9A56078,0xCC3063DD,0x21FC0000long 0xC0040000,0xA35CE1A3,0xBB251DCB,0x21100000long 0xC0040000,0x9D1462CE,0xAA19D7B9,0xA1580000long 0xC0040000,0x96CBE3F9,0x990E91A8,0x21E00000long 0xC0040000,0x90836524,0x88034B96,0x20B00000long 0xC0040000,0x8A3AE64F,0x76F80584,0xA1880000long 0xC0040000,0x83F2677A,0x65ECBF73,0x21C40000long 0xC0030000,0xFB53D14A,0xA9C2F2C2,0x20000000long 0xC0030000,0xEEC2D3A0,0x87AC669F,0x21380000long 0xC0030000,0xE231D5F6,0x6595DA7B,0xA1300000long 0xC0030000,0xD5A0D84C,0x437F4E58,0x9FC00000long 0xC0030000,0xC90FDAA2,0x2168C235,0x21000000long 0xC0030000,0xBC7EDCF7,0xFF523611,0xA1680000long 0xC0030000,0xAFEDDF4D,0xDD3BA9EE,0xA0A00000long 0xC0030000,0xA35CE1A3,0xBB251DCB,0x20900000long 0xC0030000,0x96CBE3F9,0x990E91A8,0x21600000long 0xC0030000,0x8A3AE64F,0x76F80584,0xA1080000long 0xC0020000,0xFB53D14A,0xA9C2F2C2,0x1F800000long 0xC0020000,0xE231D5F6,0x6595DA7B,0xA0B00000long 0xC0020000,0xC90FDAA2,0x2168C235,0x20800000long 0xC0020000,0xAFEDDF4D,0xDD3BA9EE,0xA0200000long 0xC0020000,0x96CBE3F9,0x990E91A8,0x20E00000long 0xC0010000,0xFB53D14A,0xA9C2F2C2,0x1F000000long 0xC0010000,0xC90FDAA2,0x2168C235,0x20000000long 0xC0010000,0x96CBE3F9,0x990E91A8,0x20600000long 0xC0000000,0xC90FDAA2,0x2168C235,0x1F800000long 0xBFFF0000,0xC90FDAA2,0x2168C235,0x1F000000long 0x00000000,0x00000000,0x00000000,0x00000000long 0x3FFF0000,0xC90FDAA2,0x2168C235,0x9F000000long 0x40000000,0xC90FDAA2,0x2168C235,0x9F800000long 0x40010000,0x96CBE3F9,0x990E91A8,0xA0600000long 0x40010000,0xC90FDAA2,0x2168C235,0xA0000000long 0x40010000,0xFB53D14A,0xA9C2F2C2,0x9F000000long 0x40020000,0x96CBE3F9,0x990E91A8,0xA0E00000long 0x40020000,0xAFEDDF4D,0xDD3BA9EE,0x20200000long 0x40020000,0xC90FDAA2,0x2168C235,0xA0800000long 0x40020000,0xE231D5F6,0x6595DA7B,0x20B00000long 0x40020000,0xFB53D14A,0xA9C2F2C2,0x9F800000long 0x40030000,0x8A3AE64F,0x76F80584,0x21080000long 0x40030000,0x96CBE3F9,0x990E91A8,0xA1600000long 0x40030000,0xA35CE1A3,0xBB251DCB,0xA0900000long 0x40030000,0xAFEDDF4D,0xDD3BA9EE,0x20A00000long 0x40030000,0xBC7EDCF7,0xFF523611,0x21680000long 0x40030000,0xC90FDAA2,0x2168C235,0xA1000000long 0x40030000,0xD5A0D84C,0x437F4E58,0x1FC00000long 0x40030000,0xE231D5F6,0x6595DA7B,0x21300000long 0x40030000,0xEEC2D3A0,0x87AC669F,0xA1380000long 0x40030000,0xFB53D14A,0xA9C2F2C2,0xA0000000long 0x40040000,0x83F2677A,0x65ECBF73,0xA1C40000long 0x40040000,0x8A3AE64F,0x76F80584,0x21880000long 0x40040000,0x90836524,0x88034B96,0xA0B00000long 0x40040000,0x96CBE3F9,0x990E91A8,0xA1E00000long 0x40040000,0x9D1462CE,0xAA19D7B9,0x21580000long 0x40040000,0xA35CE1A3,0xBB251DCB,0xA1100000long 0x40040000,0xA9A56078,0xCC3063DD,0xA1FC0000long 0x40040000,0xAFEDDF4D,0xDD3BA9EE,0x21200000long 0x40040000,0xB6365E22,0xEE46F000,0xA1480000long 0x40040000,0xBC7EDCF7,0xFF523611,0x21E80000long 0x40040000,0xC2C75BCD,0x105D7C23,0x20D00000long 0x40040000,0xC90FDAA2,0x2168C235,0xA1800000set INARG,FP_SCR0set TWOTO63,L_SCR1set INT,L_SCR1set ENDFLAG,L_SCR2global stanstan:fmov.x (%a0),%fp0 # LOAD INPUTmov.l (%a0),%d1mov.w 4(%a0),%d1and.l &0x7FFFFFFF,%d1cmp.l %d1,&0x3FD78000 # |X| >= 2**(-40)?bge.b TANOK1bra.w TANSMTANOK1:cmp.l %d1,&0x4004BC7E # |X| < 15 PI?blt.b TANMAINbra.w REDUCEXTANMAIN:#--THIS IS THE USUAL CASE, |X| <= 15 PI.#--THE ARGUMENT REDUCTION IS DONE BY TABLE LOOK UP.fmov.x %fp0,%fp1fmul.d TWOBYPI(%pc),%fp1 # X*2/PIlea.l PITBL+0x200(%pc),%a1 # TABLE OF N*PI/2, N = -32,...,32fmov.l %fp1,%d1 # CONVERT TO INTEGERasl.l &4,%d1add.l %d1,%a1 # ADDRESS N*PIBY2 IN Y1, Y2fsub.x (%a1)+,%fp0 # X-Y1fsub.s (%a1),%fp0 # FP0 IS R = (X-Y1)-Y2ror.l &5,%d1and.l &0x80000000,%d1 # D0 WAS ODD IFF D0 < 0TANCONT:fmovm.x &0x0c,-(%sp) # save fp2,fp3cmp.l %d1,&0blt.w NODDfmov.x %fp0,%fp1fmul.x %fp1,%fp1 # S = R*Rfmov.d TANQ4(%pc),%fp3fmov.d TANP3(%pc),%fp2fmul.x %fp1,%fp3 # SQ4fmul.x %fp1,%fp2 # SP3fadd.d TANQ3(%pc),%fp3 # Q3+SQ4fadd.x TANP2(%pc),%fp2 # P2+SP3fmul.x %fp1,%fp3 # S(Q3+SQ4)fmul.x %fp1,%fp2 # S(P2+SP3)fadd.x TANQ2(%pc),%fp3 # Q2+S(Q3+SQ4)fadd.x TANP1(%pc),%fp2 # P1+S(P2+SP3)fmul.x %fp1,%fp3 # S(Q2+S(Q3+SQ4))fmul.x %fp1,%fp2 # S(P1+S(P2+SP3))fadd.x TANQ1(%pc),%fp3 # Q1+S(Q2+S(Q3+SQ4))fmul.x %fp0,%fp2 # RS(P1+S(P2+SP3))fmul.x %fp3,%fp1 # S(Q1+S(Q2+S(Q3+SQ4)))fadd.x %fp2,%fp0 # R+RS(P1+S(P2+SP3))fadd.s &0x3F800000,%fp1 # 1+S(Q1+...)fmovm.x (%sp)+,&0x30 # restore fp2,fp3fmov.l %d0,%fpcr # restore users round mode,precfdiv.x %fp1,%fp0 # last inst - possible exception setbra t_inx2NODD:fmov.x %fp0,%fp1fmul.x %fp0,%fp0 # S = R*Rfmov.d TANQ4(%pc),%fp3fmov.d TANP3(%pc),%fp2fmul.x %fp0,%fp3 # SQ4fmul.x %fp0,%fp2 # SP3fadd.d TANQ3(%pc),%fp3 # Q3+SQ4fadd.x TANP2(%pc),%fp2 # P2+SP3fmul.x %fp0,%fp3 # S(Q3+SQ4)fmul.x %fp0,%fp2 # S(P2+SP3)fadd.x TANQ2(%pc),%fp3 # Q2+S(Q3+SQ4)fadd.x TANP1(%pc),%fp2 # P1+S(P2+SP3)fmul.x %fp0,%fp3 # S(Q2+S(Q3+SQ4))fmul.x %fp0,%fp2 # S(P1+S(P2+SP3))fadd.x TANQ1(%pc),%fp3 # Q1+S(Q2+S(Q3+SQ4))fmul.x %fp1,%fp2 # RS(P1+S(P2+SP3))fmul.x %fp3,%fp0 # S(Q1+S(Q2+S(Q3+SQ4)))fadd.x %fp2,%fp1 # R+RS(P1+S(P2+SP3))fadd.s &0x3F800000,%fp0 # 1+S(Q1+...)fmovm.x (%sp)+,&0x30 # restore fp2,fp3fmov.x %fp1,-(%sp)eor.l &0x80000000,(%sp)fmov.l %d0,%fpcr # restore users round mode,precfdiv.x (%sp)+,%fp0 # last inst - possible exception setbra t_inx2TANBORS:#--IF |X| > 15PI, WE USE THE GENERAL ARGUMENT REDUCTION.#--IF |X| < 2**(-40), RETURN X OR 1.cmp.l %d1,&0x3FFF8000bgt.b REDUCEXTANSM:fmov.x %fp0,-(%sp)fmov.l %d0,%fpcr # restore users round mode,precmov.b &FMOV_OP,%d1 # last inst is MOVEfmov.x (%sp)+,%fp0 # last inst - posibble exception setbra t_catchglobal stand#--TAN(X) = X FOR DENORMALIZED Xstand:bra t_extdnrm#--WHEN REDUCEX IS USED, THE CODE WILL INEVITABLY BE SLOW.#--THIS REDUCTION METHOD, HOWEVER, IS MUCH FASTER THAN USING#--THE REMAINDER INSTRUCTION WHICH IS NOW IN SOFTWARE.REDUCEX:fmovm.x &0x3c,-(%sp) # save {fp2-fp5}mov.l %d2,-(%sp) # save d2fmov.s &0x00000000,%fp1 # fp1 = 0#--If compact form of abs(arg) in d0=$7ffeffff, argument is so large that#--there is a danger of unwanted overflow in first LOOP iteration. In this#--case, reduce argument by one remainder step to make subsequent reduction#--safe.cmp.l %d1,&0x7ffeffff # is arg dangerously large?bne.b LOOP # no# yes; create 2**16383*PI/2mov.w &0x7ffe,FP_SCR0_EX(%a6)mov.l &0xc90fdaa2,FP_SCR0_HI(%a6)clr.l FP_SCR0_LO(%a6)# create low half of 2**16383*PI/2 at FP_SCR1mov.w &0x7fdc,FP_SCR1_EX(%a6)mov.l &0x85a308d3,FP_SCR1_HI(%a6)clr.l FP_SCR1_LO(%a6)ftest.x %fp0 # test sign of argumentfblt.w red_negor.b &0x80,FP_SCR0_EX(%a6) # positive argor.b &0x80,FP_SCR1_EX(%a6)red_neg:fadd.x FP_SCR0(%a6),%fp0 # high part of reduction is exactfmov.x %fp0,%fp1 # save high result in fp1fadd.x FP_SCR1(%a6),%fp0 # low part of reductionfsub.x %fp0,%fp1 # determine low component of resultfadd.x FP_SCR1(%a6),%fp1 # fp0/fp1 are reduced argument.#--ON ENTRY, FP0 IS X, ON RETURN, FP0 IS X REM PI/2, |X| <= PI/4.#--integer quotient will be stored in N#--Intermeditate remainder is 66-bit long; (R,r) in (FP0,FP1)LOOP:fmov.x %fp0,INARG(%a6) # +-2**K * F, 1 <= F < 2mov.w INARG(%a6),%d1mov.l %d1,%a1 # save a copy of D0and.l &0x00007FFF,%d1sub.l &0x00003FFF,%d1 # d0 = Kcmp.l %d1,&28ble.b LASTLOOPCONTLOOP:sub.l &27,%d1 # d0 = L := K-27mov.b &0,ENDFLAG(%a6)bra.b WORKLASTLOOP:clr.l %d1 # d0 = L := 0mov.b &1,ENDFLAG(%a6)WORK:#--FIND THE REMAINDER OF (R,r) W.R.T. 2**L * (PI/2). L IS SO CHOSEN#--THAT INT( X * (2/PI) / 2**(L) ) < 2**29.#--CREATE 2**(-L) * (2/PI), SIGN(INARG)*2**(63),#--2**L * (PIby2_1), 2**L * (PIby2_2)mov.l &0x00003FFE,%d2 # BIASED EXP OF 2/PIsub.l %d1,%d2 # BIASED EXP OF 2**(-L)*(2/PI)mov.l &0xA2F9836E,FP_SCR0_HI(%a6)mov.l &0x4E44152A,FP_SCR0_LO(%a6)mov.w %d2,FP_SCR0_EX(%a6) # FP_SCR0 = 2**(-L)*(2/PI)fmov.x %fp0,%fp2fmul.x FP_SCR0(%a6),%fp2 # fp2 = X * 2**(-L)*(2/PI)#--WE MUST NOW FIND INT(FP2). SINCE WE NEED THIS VALUE IN#--FLOATING POINT FORMAT, THE TWO FMOVE'S FMOVE.L FP <--> N#--WILL BE TOO INEFFICIENT. THE WAY AROUND IT IS THAT#--(SIGN(INARG)*2**63 + FP2) - SIGN(INARG)*2**63 WILL GIVE#--US THE DESIRED VALUE IN FLOATING POINT.mov.l %a1,%d2swap %d2and.l &0x80000000,%d2or.l &0x5F000000,%d2 # d2 = SIGN(INARG)*2**63 IN SGLmov.l %d2,TWOTO63(%a6)fadd.s TWOTO63(%a6),%fp2 # THE FRACTIONAL PART OF FP1 IS ROUNDEDfsub.s TWOTO63(%a6),%fp2 # fp2 = N# fintrz.x %fp2,%fp2#--CREATING 2**(L)*Piby2_1 and 2**(L)*Piby2_2mov.l %d1,%d2 # d2 = Ladd.l &0x00003FFF,%d2 # BIASED EXP OF 2**L * (PI/2)mov.w %d2,FP_SCR0_EX(%a6)mov.l &0xC90FDAA2,FP_SCR0_HI(%a6)clr.l FP_SCR0_LO(%a6) # FP_SCR0 = 2**(L) * Piby2_1add.l &0x00003FDD,%d1mov.w %d1,FP_SCR1_EX(%a6)mov.l &0x85A308D3,FP_SCR1_HI(%a6)clr.l FP_SCR1_LO(%a6) # FP_SCR1 = 2**(L) * Piby2_2mov.b ENDFLAG(%a6),%d1#--We are now ready to perform (R+r) - N*P1 - N*P2, P1 = 2**(L) * Piby2_1 and#--P2 = 2**(L) * Piby2_2fmov.x %fp2,%fp4 # fp4 = Nfmul.x FP_SCR0(%a6),%fp4 # fp4 = W = N*P1fmov.x %fp2,%fp5 # fp5 = Nfmul.x FP_SCR1(%a6),%fp5 # fp5 = w = N*P2fmov.x %fp4,%fp3 # fp3 = W = N*P1#--we want P+p = W+w but |p| <= half ulp of P#--Then, we need to compute A := R-P and a := r-pfadd.x %fp5,%fp3 # fp3 = Pfsub.x %fp3,%fp4 # fp4 = W-Pfsub.x %fp3,%fp0 # fp0 = A := R - Pfadd.x %fp5,%fp4 # fp4 = p = (W-P)+wfmov.x %fp0,%fp3 # fp3 = Afsub.x %fp4,%fp1 # fp1 = a := r - p#--Now we need to normalize (A,a) to "new (R,r)" where R+r = A+a but#--|r| <= half ulp of R.fadd.x %fp1,%fp0 # fp0 = R := A+a#--No need to calculate r if this is the last loopcmp.b %d1,&0bgt.w RESTORE#--Need to calculate rfsub.x %fp0,%fp3 # fp3 = A-Rfadd.x %fp3,%fp1 # fp1 = r := (A-R)+abra.w LOOPRESTORE:fmov.l %fp2,INT(%a6)mov.l (%sp)+,%d2 # restore d2fmovm.x (%sp)+,&0x3c # restore {fp2-fp5}mov.l INT(%a6),%d1ror.l &1,%d1bra.w TANCONT########################################################################## satan(): computes the arctangent of a normalized number ## satand(): computes the arctangent of a denormalized number ## ## INPUT *************************************************************** ## a0 = pointer to extended precision input ## d0 = round precision,mode ## ## OUTPUT ************************************************************** ## fp0 = arctan(X) ## ## ACCURACY and MONOTONICITY ******************************************* ## The returned result is within 2 ulps in 64 significant bit, ## i.e. within 0.5001 ulp to 53 bits if the result is subsequently ## rounded to double precision. The result is provably monotonic ## in double precision. ## ## ALGORITHM *********************************************************** ## Step 1. If |X| >= 16 or |X| < 1/16, go to Step 5. ## ## Step 2. Let X = sgn * 2**k * 1.xxxxxxxx...x. ## Note that k = -4, -3,..., or 3. ## Define F = sgn * 2**k * 1.xxxx1, i.e. the first 5 ## significant bits of X with a bit-1 attached at the 6-th ## bit position. Define u to be u = (X-F) / (1 + X*F). ## ## Step 3. Approximate arctan(u) by a polynomial poly. ## ## Step 4. Return arctan(F) + poly, arctan(F) is fetched from a ## table of values calculated beforehand. Exit. ## ## Step 5. If |X| >= 16, go to Step 7. ## ## Step 6. Approximate arctan(X) by an odd polynomial in X. Exit. ## ## Step 7. Define X' = -1/X. Approximate arctan(X') by an odd ## polynomial in X'. ## Arctan(X) = sign(X)*Pi/2 + arctan(X'). Exit. ## ##########################################################################ATANA3: long 0xBFF6687E,0x314987D8ATANA2: long 0x4002AC69,0x34A26DB3ATANA1: long 0xBFC2476F,0x4E1DA28EATANB6: long 0x3FB34444,0x7F876989ATANB5: long 0xBFB744EE,0x7FAF45DBATANB4: long 0x3FBC71C6,0x46940220ATANB3: long 0xBFC24924,0x921872F9ATANB2: long 0x3FC99999,0x99998FA9ATANB1: long 0xBFD55555,0x55555555ATANC5: long 0xBFB70BF3,0x98539E6AATANC4: long 0x3FBC7187,0x962D1D7DATANC3: long 0xBFC24924,0x827107B8ATANC2: long 0x3FC99999,0x9996263EATANC1: long 0xBFD55555,0x55555536PPIBY2: long 0x3FFF0000,0xC90FDAA2,0x2168C235,0x00000000NPIBY2: long 0xBFFF0000,0xC90FDAA2,0x2168C235,0x00000000PTINY: long 0x00010000,0x80000000,0x00000000,0x00000000NTINY: long 0x80010000,0x80000000,0x00000000,0x00000000ATANTBL:long 0x3FFB0000,0x83D152C5,0x060B7A51,0x00000000long 0x3FFB0000,0x8BC85445,0x65498B8B,0x00000000long 0x3FFB0000,0x93BE4060,0x17626B0D,0x00000000long 0x3FFB0000,0x9BB3078D,0x35AEC202,0x00000000long 0x3FFB0000,0xA3A69A52,0x5DDCE7DE,0x00000000long 0x3FFB0000,0xAB98E943,0x62765619,0x00000000long 0x3FFB0000,0xB389E502,0xF9C59862,0x00000000long 0x3FFB0000,0xBB797E43,0x6B09E6FB,0x00000000long 0x3FFB0000,0xC367A5C7,0x39E5F446,0x00000000long 0x3FFB0000,0xCB544C61,0xCFF7D5C6,0x00000000long 0x3FFB0000,0xD33F62F8,0x2488533E,0x00000000long 0x3FFB0000,0xDB28DA81,0x62404C77,0x00000000long 0x3FFB0000,0xE310A407,0x8AD34F18,0x00000000long 0x3FFB0000,0xEAF6B0A8,0x188EE1EB,0x00000000long 0x3FFB0000,0xF2DAF194,0x9DBE79D5,0x00000000long 0x3FFB0000,0xFABD5813,0x61D47E3E,0x00000000long 0x3FFC0000,0x8346AC21,0x0959ECC4,0x00000000long 0x3FFC0000,0x8B232A08,0x304282D8,0x00000000long 0x3FFC0000,0x92FB70B8,0xD29AE2F9,0x00000000long 0x3FFC0000,0x9ACF476F,0x5CCD1CB4,0x00000000long 0x3FFC0000,0xA29E7630,0x4954F23F,0x00000000long 0x3FFC0000,0xAA68C5D0,0x8AB85230,0x00000000long 0x3FFC0000,0xB22DFFFD,0x9D539F83,0x00000000long 0x3FFC0000,0xB9EDEF45,0x3E900EA5,0x00000000long 0x3FFC0000,0xC1A85F1C,0xC75E3EA5,0x00000000long 0x3FFC0000,0xC95D1BE8,0x28138DE6,0x00000000long 0x3FFC0000,0xD10BF300,0x840D2DE4,0x00000000long 0x3FFC0000,0xD8B4B2BA,0x6BC05E7A,0x00000000long 0x3FFC0000,0xE0572A6B,0xB42335F6,0x00000000long 0x3FFC0000,0xE7F32A70,0xEA9CAA8F,0x00000000long 0x3FFC0000,0xEF888432,0x64ECEFAA,0x00000000long 0x3FFC0000,0xF7170A28,0xECC06666,0x00000000long 0x3FFD0000,0x812FD288,0x332DAD32,0x00000000long 0x3FFD0000,0x88A8D1B1,0x218E4D64,0x00000000long 0x3FFD0000,0x9012AB3F,0x23E4AEE8,0x00000000long 0x3FFD0000,0x976CC3D4,0x11E7F1B9,0x00000000long 0x3FFD0000,0x9EB68949,0x3889A227,0x00000000long 0x3FFD0000,0xA5EF72C3,0x4487361B,0x00000000long 0x3FFD0000,0xAD1700BA,0xF07A7227,0x00000000long 0x3FFD0000,0xB42CBCFA,0xFD37EFB7,0x00000000long 0x3FFD0000,0xBB303A94,0x0BA80F89,0x00000000long 0x3FFD0000,0xC22115C6,0xFCAEBBAF,0x00000000long 0x3FFD0000,0xC8FEF3E6,0x86331221,0x00000000long 0x3FFD0000,0xCFC98330,0xB4000C70,0x00000000long 0x3FFD0000,0xD6807AA1,0x102C5BF9,0x00000000long 0x3FFD0000,0xDD2399BC,0x31252AA3,0x00000000long 0x3FFD0000,0xE3B2A855,0x6B8FC517,0x00000000long 0x3FFD0000,0xEA2D764F,0x64315989,0x00000000long 0x3FFD0000,0xF3BF5BF8,0xBAD1A21D,0x00000000long 0x3FFE0000,0x801CE39E,0x0D205C9A,0x00000000long 0x3FFE0000,0x8630A2DA,0xDA1ED066,0x00000000long 0x3FFE0000,0x8C1AD445,0xF3E09B8C,0x00000000long 0x3FFE0000,0x91DB8F16,0x64F350E2,0x00000000long 0x3FFE0000,0x97731420,0x365E538C,0x00000000long 0x3FFE0000,0x9CE1C8E6,0xA0B8CDBA,0x00000000long 0x3FFE0000,0xA22832DB,0xCADAAE09,0x00000000long 0x3FFE0000,0xA746F2DD,0xB7602294,0x00000000long 0x3FFE0000,0xAC3EC0FB,0x997DD6A2,0x00000000long 0x3FFE0000,0xB110688A,0xEBDC6F6A,0x00000000long 0x3FFE0000,0xB5BCC490,0x59ECC4B0,0x00000000long 0x3FFE0000,0xBA44BC7D,0xD470782F,0x00000000long 0x3FFE0000,0xBEA94144,0xFD049AAC,0x00000000long 0x3FFE0000,0xC2EB4ABB,0x661628B6,0x00000000long 0x3FFE0000,0xC70BD54C,0xE602EE14,0x00000000long 0x3FFE0000,0xCD000549,0xADEC7159,0x00000000long 0x3FFE0000,0xD48457D2,0xD8EA4EA3,0x00000000long 0x3FFE0000,0xDB948DA7,0x12DECE3B,0x00000000long 0x3FFE0000,0xE23855F9,0x69E8096A,0x00000000long 0x3FFE0000,0xE8771129,0xC4353259,0x00000000long 0x3FFE0000,0xEE57C16E,0x0D379C0D,0x00000000long 0x3FFE0000,0xF3E10211,0xA87C3779,0x00000000long 0x3FFE0000,0xF919039D,0x758B8D41,0x00000000long 0x3FFE0000,0xFE058B8F,0x64935FB3,0x00000000long 0x3FFF0000,0x8155FB49,0x7B685D04,0x00000000long 0x3FFF0000,0x83889E35,0x49D108E1,0x00000000long 0x3FFF0000,0x859CFA76,0x511D724B,0x00000000long 0x3FFF0000,0x87952ECF,0xFF8131E7,0x00000000long 0x3FFF0000,0x89732FD1,0x9557641B,0x00000000long 0x3FFF0000,0x8B38CAD1,0x01932A35,0x00000000long 0x3FFF0000,0x8CE7A8D8,0x301EE6B5,0x00000000long 0x3FFF0000,0x8F46A39E,0x2EAE5281,0x00000000long 0x3FFF0000,0x922DA7D7,0x91888487,0x00000000long 0x3FFF0000,0x94D19FCB,0xDEDF5241,0x00000000long 0x3FFF0000,0x973AB944,0x19D2A08B,0x00000000long 0x3FFF0000,0x996FF00E,0x08E10B96,0x00000000long 0x3FFF0000,0x9B773F95,0x12321DA7,0x00000000long 0x3FFF0000,0x9D55CC32,0x0F935624,0x00000000long 0x3FFF0000,0x9F100575,0x006CC571,0x00000000long 0x3FFF0000,0xA0A9C290,0xD97CC06C,0x00000000long 0x3FFF0000,0xA22659EB,0xEBC0630A,0x00000000long 0x3FFF0000,0xA388B4AF,0xF6EF0EC9,0x00000000long 0x3FFF0000,0xA4D35F10,0x61D292C4,0x00000000long 0x3FFF0000,0xA60895DC,0xFBE3187E,0x00000000long 0x3FFF0000,0xA72A51DC,0x7367BEAC,0x00000000long 0x3FFF0000,0xA83A5153,0x0956168F,0x00000000long 0x3FFF0000,0xA93A2007,0x7539546E,0x00000000long 0x3FFF0000,0xAA9E7245,0x023B2605,0x00000000long 0x3FFF0000,0xAC4C84BA,0x6FE4D58F,0x00000000long 0x3FFF0000,0xADCE4A4A,0x606B9712,0x00000000long 0x3FFF0000,0xAF2A2DCD,0x8D263C9C,0x00000000long 0x3FFF0000,0xB0656F81,0xF22265C7,0x00000000long 0x3FFF0000,0xB1846515,0x0F71496A,0x00000000long 0x3FFF0000,0xB28AAA15,0x6F9ADA35,0x00000000long 0x3FFF0000,0xB37B44FF,0x3766B895,0x00000000long 0x3FFF0000,0xB458C3DC,0xE9630433,0x00000000long 0x3FFF0000,0xB525529D,0x562246BD,0x00000000long 0x3FFF0000,0xB5E2CCA9,0x5F9D88CC,0x00000000long 0x3FFF0000,0xB692CADA,0x7ACA1ADA,0x00000000long 0x3FFF0000,0xB736AEA7,0xA6925838,0x00000000long 0x3FFF0000,0xB7CFAB28,0x7E9F7B36,0x00000000long 0x3FFF0000,0xB85ECC66,0xCB219835,0x00000000long 0x3FFF0000,0xB8E4FD5A,0x20A593DA,0x00000000long 0x3FFF0000,0xB99F41F6,0x4AFF9BB5,0x00000000long 0x3FFF0000,0xBA7F1E17,0x842BBE7B,0x00000000long 0x3FFF0000,0xBB471285,0x7637E17D,0x00000000long 0x3FFF0000,0xBBFABE8A,0x4788DF6F,0x00000000long 0x3FFF0000,0xBC9D0FAD,0x2B689D79,0x00000000long 0x3FFF0000,0xBD306A39,0x471ECD86,0x00000000long 0x3FFF0000,0xBDB6C731,0x856AF18A,0x00000000long 0x3FFF0000,0xBE31CAC5,0x02E80D70,0x00000000long 0x3FFF0000,0xBEA2D55C,0xE33194E2,0x00000000long 0x3FFF0000,0xBF0B10B7,0xC03128F0,0x00000000long 0x3FFF0000,0xBF6B7A18,0xDACB778D,0x00000000long 0x3FFF0000,0xBFC4EA46,0x63FA18F6,0x00000000long 0x3FFF0000,0xC0181BDE,0x8B89A454,0x00000000long 0x3FFF0000,0xC065B066,0xCFBF6439,0x00000000long 0x3FFF0000,0xC0AE345F,0x56340AE6,0x00000000long 0x3FFF0000,0xC0F22291,0x9CB9E6A7,0x00000000set X,FP_SCR0set XDCARE,X+2set XFRAC,X+4set XFRACLO,X+8set ATANF,FP_SCR1set ATANFHI,ATANF+4set ATANFLO,ATANF+8global satan#--ENTRY POINT FOR ATAN(X), HERE X IS FINITE, NON-ZERO, AND NOT NAN'Ssatan:fmov.x (%a0),%fp0 # LOAD INPUTmov.l (%a0),%d1mov.w 4(%a0),%d1fmov.x %fp0,X(%a6)and.l &0x7FFFFFFF,%d1cmp.l %d1,&0x3FFB8000 # |X| >= 1/16?bge.b ATANOK1bra.w ATANSMATANOK1:cmp.l %d1,&0x4002FFFF # |X| < 16 ?ble.b ATANMAINbra.w ATANBIG#--THE MOST LIKELY CASE, |X| IN [1/16, 16). WE USE TABLE TECHNIQUE#--THE IDEA IS ATAN(X) = ATAN(F) + ATAN( [X-F] / [1+XF] ).#--SO IF F IS CHOSEN TO BE CLOSE TO X AND ATAN(F) IS STORED IN#--A TABLE, ALL WE NEED IS TO APPROXIMATE ATAN(U) WHERE#--U = (X-F)/(1+XF) IS SMALL (REMEMBER F IS CLOSE TO X). IT IS#--TRUE THAT A DIVIDE IS NOW NEEDED, BUT THE APPROXIMATION FOR#--ATAN(U) IS A VERY SHORT POLYNOMIAL AND THE INDEXING TO#--FETCH F AND SAVING OF REGISTERS CAN BE ALL HIDED UNDER THE#--DIVIDE. IN THE END THIS METHOD IS MUCH FASTER THAN A TRADITIONAL#--ONE. NOTE ALSO THAT THE TRADITIONAL SCHEME THAT APPROXIMATE#--ATAN(X) DIRECTLY WILL NEED TO USE A RATIONAL APPROXIMATION#--(DIVISION NEEDED) ANYWAY BECAUSE A POLYNOMIAL APPROXIMATION#--WILL INVOLVE A VERY LONG POLYNOMIAL.#--NOW WE SEE X AS +-2^K * 1.BBBBBBB....B <- 1. + 63 BITS#--WE CHOSE F TO BE +-2^K * 1.BBBB1#--THAT IS IT MATCHES THE EXPONENT AND FIRST 5 BITS OF X, THE#--SIXTH BITS IS SET TO BE 1. SINCE K = -4, -3, ..., 3, THERE#--ARE ONLY 8 TIMES 16 = 2^7 = 128 |F|'S. SINCE ATAN(-|F|) IS#-- -ATAN(|F|), WE NEED TO STORE ONLY ATAN(|F|).ATANMAIN:and.l &0xF8000000,XFRAC(%a6) # FIRST 5 BITSor.l &0x04000000,XFRAC(%a6) # SET 6-TH BIT TO 1mov.l &0x00000000,XFRACLO(%a6) # LOCATION OF X IS NOW Ffmov.x %fp0,%fp1 # FP1 IS Xfmul.x X(%a6),%fp1 # FP1 IS X*F, NOTE THAT X*F > 0fsub.x X(%a6),%fp0 # FP0 IS X-Ffadd.s &0x3F800000,%fp1 # FP1 IS 1 + X*Ffdiv.x %fp1,%fp0 # FP0 IS U = (X-F)/(1+X*F)#--WHILE THE DIVISION IS TAKING ITS TIME, WE FETCH ATAN(|F|)#--CREATE ATAN(F) AND STORE IT IN ATANF, AND#--SAVE REGISTERS FP2.mov.l %d2,-(%sp) # SAVE d2 TEMPORARILYmov.l %d1,%d2 # THE EXP AND 16 BITS OF Xand.l &0x00007800,%d1 # 4 VARYING BITS OF F'S FRACTIONand.l &0x7FFF0000,%d2 # EXPONENT OF Fsub.l &0x3FFB0000,%d2 # K+4asr.l &1,%d2add.l %d2,%d1 # THE 7 BITS IDENTIFYING Fasr.l &7,%d1 # INDEX INTO TBL OF ATAN(|F|)lea ATANTBL(%pc),%a1add.l %d1,%a1 # ADDRESS OF ATAN(|F|)mov.l (%a1)+,ATANF(%a6)mov.l (%a1)+,ATANFHI(%a6)mov.l (%a1)+,ATANFLO(%a6) # ATANF IS NOW ATAN(|F|)mov.l X(%a6),%d1 # LOAD SIGN AND EXPO. AGAINand.l &0x80000000,%d1 # SIGN(F)or.l %d1,ATANF(%a6) # ATANF IS NOW SIGN(F)*ATAN(|F|)mov.l (%sp)+,%d2 # RESTORE d2#--THAT'S ALL I HAVE TO DO FOR NOW,#--BUT ALAS, THE DIVIDE IS STILL CRANKING!#--U IN FP0, WE ARE NOW READY TO COMPUTE ATAN(U) AS#--U + A1*U*V*(A2 + V*(A3 + V)), V = U*U#--THE POLYNOMIAL MAY LOOK STRANGE, BUT IS NEVERTHELESS CORRECT.#--THE NATURAL FORM IS U + U*V*(A1 + V*(A2 + V*A3))#--WHAT WE HAVE HERE IS MERELY A1 = A3, A2 = A1/A3, A3 = A2/A3.#--THE REASON FOR THIS REARRANGEMENT IS TO MAKE THE INDEPENDENT#--PARTS A1*U*V AND (A2 + ... STUFF) MORE LOAD-BALANCEDfmovm.x &0x04,-(%sp) # save fp2fmov.x %fp0,%fp1fmul.x %fp1,%fp1fmov.d ATANA3(%pc),%fp2fadd.x %fp1,%fp2 # A3+Vfmul.x %fp1,%fp2 # V*(A3+V)fmul.x %fp0,%fp1 # U*Vfadd.d ATANA2(%pc),%fp2 # A2+V*(A3+V)fmul.d ATANA1(%pc),%fp1 # A1*U*Vfmul.x %fp2,%fp1 # A1*U*V*(A2+V*(A3+V))fadd.x %fp1,%fp0 # ATAN(U), FP1 RELEASEDfmovm.x (%sp)+,&0x20 # restore fp2fmov.l %d0,%fpcr # restore users rnd mode,precfadd.x ATANF(%a6),%fp0 # ATAN(X)bra t_inx2ATANBORS:#--|X| IS IN d0 IN COMPACT FORM. FP1, d0 SAVED.#--FP0 IS X AND |X| <= 1/16 OR |X| >= 16.cmp.l %d1,&0x3FFF8000bgt.w ATANBIG # I.E. |X| >= 16ATANSM:#--|X| <= 1/16#--IF |X| < 2^(-40), RETURN X AS ANSWER. OTHERWISE, APPROXIMATE#--ATAN(X) BY X + X*Y*(B1+Y*(B2+Y*(B3+Y*(B4+Y*(B5+Y*B6)))))#--WHICH IS X + X*Y*( [B1+Z*(B3+Z*B5)] + [Y*(B2+Z*(B4+Z*B6)] )#--WHERE Y = X*X, AND Z = Y*Y.cmp.l %d1,&0x3FD78000blt.w ATANTINY#--COMPUTE POLYNOMIALfmovm.x &0x0c,-(%sp) # save fp2/fp3fmul.x %fp0,%fp0 # FPO IS Y = X*Xfmov.x %fp0,%fp1fmul.x %fp1,%fp1 # FP1 IS Z = Y*Yfmov.d ATANB6(%pc),%fp2fmov.d ATANB5(%pc),%fp3fmul.x %fp1,%fp2 # Z*B6fmul.x %fp1,%fp3 # Z*B5fadd.d ATANB4(%pc),%fp2 # B4+Z*B6fadd.d ATANB3(%pc),%fp3 # B3+Z*B5fmul.x %fp1,%fp2 # Z*(B4+Z*B6)fmul.x %fp3,%fp1 # Z*(B3+Z*B5)fadd.d ATANB2(%pc),%fp2 # B2+Z*(B4+Z*B6)fadd.d ATANB1(%pc),%fp1 # B1+Z*(B3+Z*B5)fmul.x %fp0,%fp2 # Y*(B2+Z*(B4+Z*B6))fmul.x X(%a6),%fp0 # X*Yfadd.x %fp2,%fp1 # [B1+Z*(B3+Z*B5)]+[Y*(B2+Z*(B4+Z*B6))]fmul.x %fp1,%fp0 # X*Y*([B1+Z*(B3+Z*B5)]+[Y*(B2+Z*(B4+Z*B6))])fmovm.x (%sp)+,&0x30 # restore fp2/fp3fmov.l %d0,%fpcr # restore users rnd mode,precfadd.x X(%a6),%fp0bra t_inx2ATANTINY:#--|X| < 2^(-40), ATAN(X) = Xfmov.l %d0,%fpcr # restore users rnd mode,precmov.b &FMOV_OP,%d1 # last inst is MOVEfmov.x X(%a6),%fp0 # last inst - possible exception setbra t_catchATANBIG:#--IF |X| > 2^(100), RETURN SIGN(X)*(PI/2 - TINY). OTHERWISE,#--RETURN SIGN(X)*PI/2 + ATAN(-1/X).cmp.l %d1,&0x40638000bgt.w ATANHUGE#--APPROXIMATE ATAN(-1/X) BY#--X'+X'*Y*(C1+Y*(C2+Y*(C3+Y*(C4+Y*C5)))), X' = -1/X, Y = X'*X'#--THIS CAN BE RE-WRITTEN AS#--X'+X'*Y*( [C1+Z*(C3+Z*C5)] + [Y*(C2+Z*C4)] ), Z = Y*Y.fmovm.x &0x0c,-(%sp) # save fp2/fp3fmov.s &0xBF800000,%fp1 # LOAD -1fdiv.x %fp0,%fp1 # FP1 IS -1/X#--DIVIDE IS STILL CRANKINGfmov.x %fp1,%fp0 # FP0 IS X'fmul.x %fp0,%fp0 # FP0 IS Y = X'*X'fmov.x %fp1,X(%a6) # X IS REALLY X'fmov.x %fp0,%fp1fmul.x %fp1,%fp1 # FP1 IS Z = Y*Yfmov.d ATANC5(%pc),%fp3fmov.d ATANC4(%pc),%fp2fmul.x %fp1,%fp3 # Z*C5fmul.x %fp1,%fp2 # Z*B4fadd.d ATANC3(%pc),%fp3 # C3+Z*C5fadd.d ATANC2(%pc),%fp2 # C2+Z*C4fmul.x %fp3,%fp1 # Z*(C3+Z*C5), FP3 RELEASEDfmul.x %fp0,%fp2 # Y*(C2+Z*C4)fadd.d ATANC1(%pc),%fp1 # C1+Z*(C3+Z*C5)fmul.x X(%a6),%fp0 # X'*Yfadd.x %fp2,%fp1 # [Y*(C2+Z*C4)]+[C1+Z*(C3+Z*C5)]fmul.x %fp1,%fp0 # X'*Y*([B1+Z*(B3+Z*B5)]# ... +[Y*(B2+Z*(B4+Z*B6))])fadd.x X(%a6),%fp0fmovm.x (%sp)+,&0x30 # restore fp2/fp3fmov.l %d0,%fpcr # restore users rnd mode,prectst.b (%a0)bpl.b pos_bigneg_big:fadd.x NPIBY2(%pc),%fp0bra t_minx2pos_big:fadd.x PPIBY2(%pc),%fp0bra t_pinx2ATANHUGE:#--RETURN SIGN(X)*(PIBY2 - TINY) = SIGN(X)*PIBY2 - SIGN(X)*TINYtst.b (%a0)bpl.b pos_hugeneg_huge:fmov.x NPIBY2(%pc),%fp0fmov.l %d0,%fpcrfadd.x PTINY(%pc),%fp0bra t_minx2pos_huge:fmov.x PPIBY2(%pc),%fp0fmov.l %d0,%fpcrfadd.x NTINY(%pc),%fp0bra t_pinx2global satand#--ENTRY POINT FOR ATAN(X) FOR DENORMALIZED ARGUMENTsatand:bra t_extdnrm########################################################################## sasin(): computes the inverse sine of a normalized input ## sasind(): computes the inverse sine of a denormalized input ## ## INPUT *************************************************************** ## a0 = pointer to extended precision input ## d0 = round precision,mode ## ## OUTPUT ************************************************************** ## fp0 = arcsin(X) ## ## ACCURACY and MONOTONICITY ******************************************* ## The returned result is within 3 ulps in 64 significant bit, ## i.e. within 0.5001 ulp to 53 bits if the result is subsequently ## rounded to double precision. The result is provably monotonic ## in double precision. ## ## ALGORITHM *********************************************************** ## ## ASIN ## 1. If |X| >= 1, go to 3. ## ## 2. (|X| < 1) Calculate asin(X) by ## z := sqrt( [1-X][1+X] ) ## asin(X) = atan( x / z ). ## Exit. ## ## 3. If |X| > 1, go to 5. ## ## 4. (|X| = 1) sgn := sign(X), return asin(X) := sgn * Pi/2. Exit.## ## 5. (|X| > 1) Generate an invalid operation by 0 * infinity. ## Exit. ## ##########################################################################global sasinsasin:fmov.x (%a0),%fp0 # LOAD INPUTmov.l (%a0),%d1mov.w 4(%a0),%d1and.l &0x7FFFFFFF,%d1cmp.l %d1,&0x3FFF8000bge.b ASINBIG# This catch is added here for the '060 QSP. Originally, the call to# satan() would handle this case by causing the exception which would# not be caught until gen_except(). Now, with the exceptions being# detected inside of satan(), the exception would have been handled there# instead of inside sasin() as expected.cmp.l %d1,&0x3FD78000blt.w ASINTINY#--THIS IS THE USUAL CASE, |X| < 1#--ASIN(X) = ATAN( X / SQRT( (1-X)(1+X) ) )ASINMAIN:fmov.s &0x3F800000,%fp1fsub.x %fp0,%fp1 # 1-Xfmovm.x &0x4,-(%sp) # {fp2}fmov.s &0x3F800000,%fp2fadd.x %fp0,%fp2 # 1+Xfmul.x %fp2,%fp1 # (1+X)(1-X)fmovm.x (%sp)+,&0x20 # {fp2}fsqrt.x %fp1 # SQRT([1-X][1+X])fdiv.x %fp1,%fp0 # X/SQRT([1-X][1+X])fmovm.x &0x01,-(%sp) # save X/SQRT(...)lea (%sp),%a0 # pass ptr to X/SQRT(...)bsr satanadd.l &0xc,%sp # clear X/SQRT(...) from stackbra t_inx2ASINBIG:fabs.x %fp0 # |X|fcmp.s %fp0,&0x3F800000fbgt t_operr # cause an operr exception#--|X| = 1, ASIN(X) = +- PI/2.ASINONE:fmov.x PIBY2(%pc),%fp0mov.l (%a0),%d1and.l &0x80000000,%d1 # SIGN BIT OF Xor.l &0x3F800000,%d1 # +-1 IN SGL FORMATmov.l %d1,-(%sp) # push SIGN(X) IN SGL-FMTfmov.l %d0,%fpcrfmul.s (%sp)+,%fp0bra t_inx2#--|X| < 2^(-40), ATAN(X) = XASINTINY:fmov.l %d0,%fpcr # restore users rnd mode,precmov.b &FMOV_OP,%d1 # last inst is MOVEfmov.x (%a0),%fp0 # last inst - possible exceptionbra t_catchglobal sasind#--ASIN(X) = X FOR DENORMALIZED Xsasind:bra t_extdnrm########################################################################## sacos(): computes the inverse cosine of a normalized input ## sacosd(): computes the inverse cosine of a denormalized input ## ## INPUT *************************************************************** ## a0 = pointer to extended precision input ## d0 = round precision,mode ## ## OUTPUT ************************************************************** ## fp0 = arccos(X) ## ## ACCURACY and MONOTONICITY ******************************************* ## The returned result is within 3 ulps in 64 significant bit, ## i.e. within 0.5001 ulp to 53 bits if the result is subsequently ## rounded to double precision. The result is provably monotonic ## in double precision. ## ## ALGORITHM *********************************************************** ## ## ACOS ## 1. If |X| >= 1, go to 3. ## ## 2. (|X| < 1) Calculate acos(X) by ## z := (1-X) / (1+X) ## acos(X) = 2 * atan( sqrt(z) ). ## Exit. ## ## 3. If |X| > 1, go to 5. ## ## 4. (|X| = 1) If X > 0, return 0. Otherwise, return Pi. Exit. ## ## 5. (|X| > 1) Generate an invalid operation by 0 * infinity. ## Exit. ## ##########################################################################global sacossacos:fmov.x (%a0),%fp0 # LOAD INPUTmov.l (%a0),%d1 # pack exp w/ upper 16 fractionmov.w 4(%a0),%d1and.l &0x7FFFFFFF,%d1cmp.l %d1,&0x3FFF8000bge.b ACOSBIG#--THIS IS THE USUAL CASE, |X| < 1#--ACOS(X) = 2 * ATAN( SQRT( (1-X)/(1+X) ) )ACOSMAIN:fmov.s &0x3F800000,%fp1fadd.x %fp0,%fp1 # 1+Xfneg.x %fp0 # -Xfadd.s &0x3F800000,%fp0 # 1-Xfdiv.x %fp1,%fp0 # (1-X)/(1+X)fsqrt.x %fp0 # SQRT((1-X)/(1+X))mov.l %d0,-(%sp) # save original users fpcrclr.l %d0fmovm.x &0x01,-(%sp) # save SQRT(...) to stacklea (%sp),%a0 # pass ptr to sqrtbsr satan # ATAN(SQRT([1-X]/[1+X]))add.l &0xc,%sp # clear SQRT(...) from stackfmov.l (%sp)+,%fpcr # restore users round prec,modefadd.x %fp0,%fp0 # 2 * ATAN( STUFF )bra t_pinx2ACOSBIG:fabs.x %fp0fcmp.s %fp0,&0x3F800000fbgt t_operr # cause an operr exception#--|X| = 1, ACOS(X) = 0 OR PItst.b (%a0) # is X positive or negative?bpl.b ACOSP1#--X = -1#Returns PI and inexact exceptionACOSM1:fmov.x PI(%pc),%fp0 # load PIfmov.l %d0,%fpcr # load round mode,precfadd.s &0x00800000,%fp0 # add a small valuebra t_pinx2ACOSP1:bra ld_pzero # answer is positive zeroglobal sacosd#--ACOS(X) = PI/2 FOR DENORMALIZED Xsacosd:fmov.l %d0,%fpcr # load user's rnd mode/precfmov.x PIBY2(%pc),%fp0bra t_pinx2########################################################################## setox(): computes the exponential for a normalized input ## setoxd(): computes the exponential for a denormalized input ## setoxm1(): computes the exponential minus 1 for a normalized input ## setoxm1d(): computes the exponential minus 1 for a denormalized input ## ## INPUT *************************************************************** ## a0 = pointer to extended precision input ## d0 = round precision,mode ## ## OUTPUT ************************************************************** ## fp0 = exp(X) or exp(X)-1 ## ## ACCURACY and MONOTONICITY ******************************************* ## The returned result is within 0.85 ulps in 64 significant bit, ## i.e. within 0.5001 ulp to 53 bits if the result is subsequently ## rounded to double precision. The result is provably monotonic ## in double precision. ## ## ALGORITHM and IMPLEMENTATION **************************************** ## ## setoxd ## ------ ## Step 1. Set ans := 1.0 ## ## Step 2. Return ans := ans + sign(X)*2^(-126). Exit. ## Notes: This will always generate one exception -- inexact. ## ## ## setox ## ----- ## ## Step 1. Filter out extreme cases of input argument. ## 1.1 If |X| >= 2^(-65), go to Step 1.3. ## 1.2 Go to Step 7. ## 1.3 If |X| < 16380 log(2), go to Step 2. ## 1.4 Go to Step 8. ## Notes: The usual case should take the branches 1.1 -> 1.3 -> 2.## To avoid the use of floating-point comparisons, a ## compact representation of |X| is used. This format is a ## 32-bit integer, the upper (more significant) 16 bits ## are the sign and biased exponent field of |X|; the ## lower 16 bits are the 16 most significant fraction ## (including the explicit bit) bits of |X|. Consequently, ## the comparisons in Steps 1.1 and 1.3 can be performed ## by integer comparison. Note also that the constant ## 16380 log(2) used in Step 1.3 is also in the compact ## form. Thus taking the branch to Step 2 guarantees ## |X| < 16380 log(2). There is no harm to have a small ## number of cases where |X| is less than, but close to, ## 16380 log(2) and the branch to Step 9 is taken. ## ## Step 2. Calculate N = round-to-nearest-int( X * 64/log2 ). ## 2.1 Set AdjFlag := 0 (indicates the branch 1.3 -> 2 ## was taken) ## 2.2 N := round-to-nearest-integer( X * 64/log2 ). ## 2.3 Calculate J = N mod 64; so J = 0,1,2,..., ## or 63. ## 2.4 Calculate M = (N - J)/64; so N = 64M + J. ## 2.5 Calculate the address of the stored value of ## 2^(J/64). ## 2.6 Create the value Scale = 2^M. ## Notes: The calculation in 2.2 is really performed by ## Z := X * constant ## N := round-to-nearest-integer(Z) ## where ## constant := single-precision( 64/log 2 ). ## ## Using a single-precision constant avoids memory ## access. Another effect of using a single-precision ## "constant" is that the calculated value Z is ## ## Z = X*(64/log2)*(1+eps), |eps| <= 2^(-24). ## ## This error has to be considered later in Steps 3 and 4. ## ## Step 3. Calculate X - N*log2/64. ## 3.1 R := X + N*L1, ## where L1 := single-precision(-log2/64). ## 3.2 R := R + N*L2, ## L2 := extended-precision(-log2/64 - L1).## Notes: a) The way L1 and L2 are chosen ensures L1+L2 ## approximate the value -log2/64 to 88 bits of accuracy. ## b) N*L1 is exact because N is no longer than 22 bits ## and L1 is no longer than 24 bits. ## c) The calculation X+N*L1 is also exact due to ## cancellation. Thus, R is practically X+N(L1+L2) to full ## 64 bits. ## d) It is important to estimate how large can |R| be ## after Step 3.2. ## ## N = rnd-to-int( X*64/log2 (1+eps) ), |eps|<=2^(-24) ## X*64/log2 (1+eps) = N + f, |f| <= 0.5 ## X*64/log2 - N = f - eps*X 64/log2 ## X - N*log2/64 = f*log2/64 - eps*X ## ## ## Now |X| <= 16446 log2, thus ## ## |X - N*log2/64| <= (0.5 + 16446/2^(18))*log2/64 ## <= 0.57 log2/64. ## This bound will be used in Step 4. ## ## Step 4. Approximate exp(R)-1 by a polynomial ## p = R + R*R*(A1 + R*(A2 + R*(A3 + R*(A4 + R*A5)))) ## Notes: a) In order to reduce memory access, the coefficients ## are made as "short" as possible: A1 (which is 1/2), A4 ## and A5 are single precision; A2 and A3 are double ## precision. ## b) Even with the restrictions above, ## |p - (exp(R)-1)| < 2^(-68.8) for all |R| <= 0.0062. ## Note that 0.0062 is slightly bigger than 0.57 log2/64. ## c) To fully utilize the pipeline, p is separated into ## two independent pieces of roughly equal complexities ## p = [ R + R*S*(A2 + S*A4) ] + ## [ S*(A1 + S*(A3 + S*A5)) ] ## where S = R*R. ## ## Step 5. Compute 2^(J/64)*exp(R) = 2^(J/64)*(1+p) by ## ans := T + ( T*p + t) ## where T and t are the stored values for 2^(J/64). ## Notes: 2^(J/64) is stored as T and t where T+t approximates ## 2^(J/64) to roughly 85 bits; T is in extended precision ## and t is in single precision. Note also that T is ## rounded to 62 bits so that the last two bits of T are ## zero. The reason for such a special form is that T-1, ## T-2, and T-8 will all be exact --- a property that will ## give much more accurate computation of the function ## EXPM1. ## ## Step 6. Reconstruction of exp(X) ## exp(X) = 2^M * 2^(J/64) * exp(R). ## 6.1 If AdjFlag = 0, go to 6.3 ## 6.2 ans := ans * AdjScale ## 6.3 Restore the user FPCR ## 6.4 Return ans := ans * Scale. Exit. ## Notes: If AdjFlag = 0, we have X = Mlog2 + Jlog2/64 + R, ## |M| <= 16380, and Scale = 2^M. Moreover, exp(X) will ## neither overflow nor underflow. If AdjFlag = 1, that ## means that ## X = (M1+M)log2 + Jlog2/64 + R, |M1+M| >= 16380. ## Hence, exp(X) may overflow or underflow or neither. ## When that is the case, AdjScale = 2^(M1) where M1 is ## approximately M. Thus 6.2 will never cause ## over/underflow. Possible exception in 6.4 is overflow ## or underflow. The inexact exception is not generated in ## 6.4. Although one can argue that the inexact flag ## should always be raised, to simulate that exception ## cost to much than the flag is worth in practical uses. ## ## Step 7. Return 1 + X. ## 7.1 ans := X ## 7.2 Restore user FPCR. ## 7.3 Return ans := 1 + ans. Exit ## Notes: For non-zero X, the inexact exception will always be ## raised by 7.3. That is the only exception raised by 7.3.## Note also that we use the FMOVEM instruction to move X ## in Step 7.1 to avoid unnecessary trapping. (Although ## the FMOVEM may not seem relevant since X is normalized, ## the precaution will be useful in the library version of ## this code where the separate entry for denormalized ## inputs will be done away with.) ## ## Step 8. Handle exp(X) where |X| >= 16380log2. ## 8.1 If |X| > 16480 log2, go to Step 9. ## (mimic 2.2 - 2.6) ## 8.2 N := round-to-integer( X * 64/log2 ) ## 8.3 Calculate J = N mod 64, J = 0,1,...,63 ## 8.4 K := (N-J)/64, M1 := truncate(K/2), M = K-M1, ## AdjFlag := 1. ## 8.5 Calculate the address of the stored value ## 2^(J/64). ## 8.6 Create the values Scale = 2^M, AdjScale = 2^M1. ## 8.7 Go to Step 3. ## Notes: Refer to notes for 2.2 - 2.6. ## ## Step 9. Handle exp(X), |X| > 16480 log2. ## 9.1 If X < 0, go to 9.3 ## 9.2 ans := Huge, go to 9.4 ## 9.3 ans := Tiny. ## 9.4 Restore user FPCR. ## 9.5 Return ans := ans * ans. Exit. ## Notes: Exp(X) will surely overflow or underflow, depending on ## X's sign. "Huge" and "Tiny" are respectively large/tiny ## extended-precision numbers whose square over/underflow ## with an inexact result. Thus, 9.5 always raises the ## inexact together with either overflow or underflow. ## ## setoxm1d ## -------- ## ## Step 1. Set ans := 0 ## ## Step 2. Return ans := X + ans. Exit. ## Notes: This will return X with the appropriate rounding ## precision prescribed by the user FPCR. ## ## setoxm1 ## ------- ## ## Step 1. Check |X| ## 1.1 If |X| >= 1/4, go to Step 1.3. ## 1.2 Go to Step 7. ## 1.3 If |X| < 70 log(2), go to Step 2. ## 1.4 Go to Step 10. ## Notes: The usual case should take the branches 1.1 -> 1.3 -> 2.## However, it is conceivable |X| can be small very often ## because EXPM1 is intended to evaluate exp(X)-1 ## accurately when |X| is small. For further details on ## the comparisons, see the notes on Step 1 of setox. ## ## Step 2. Calculate N = round-to-nearest-int( X * 64/log2 ). ## 2.1 N := round-to-nearest-integer( X * 64/log2 ). ## 2.2 Calculate J = N mod 64; so J = 0,1,2,..., ## or 63. ## 2.3 Calculate M = (N - J)/64; so N = 64M + J. ## 2.4 Calculate the address of the stored value of ## 2^(J/64). ## 2.5 Create the values Sc = 2^M and ## OnebySc := -2^(-M). ## Notes: See the notes on Step 2 of setox. ## ## Step 3. Calculate X - N*log2/64. ## 3.1 R := X + N*L1, ## where L1 := single-precision(-log2/64). ## 3.2 R := R + N*L2, ## L2 := extended-precision(-log2/64 - L1).## Notes: Applying the analysis of Step 3 of setox in this case ## shows that |R| <= 0.0055 (note that |X| <= 70 log2 in ## this case). ## ## Step 4. Approximate exp(R)-1 by a polynomial ## p = R+R*R*(A1+R*(A2+R*(A3+R*(A4+R*(A5+R*A6))))) ## Notes: a) In order to reduce memory access, the coefficients ## are made as "short" as possible: A1 (which is 1/2), A5 ## and A6 are single precision; A2, A3 and A4 are double ## precision. ## b) Even with the restriction above, ## |p - (exp(R)-1)| < |R| * 2^(-72.7) ## for all |R| <= 0.0055. ## c) To fully utilize the pipeline, p is separated into ## two independent pieces of roughly equal complexity ## p = [ R*S*(A2 + S*(A4 + S*A6)) ] + ## [ R + S*(A1 + S*(A3 + S*A5)) ] ## where S = R*R. ## ## Step 5. Compute 2^(J/64)*p by ## p := T*p ## where T and t are the stored values for 2^(J/64). ## Notes: 2^(J/64) is stored as T and t where T+t approximates ## 2^(J/64) to roughly 85 bits; T is in extended precision ## and t is in single precision. Note also that T is ## rounded to 62 bits so that the last two bits of T are ## zero. The reason for such a special form is that T-1, ## T-2, and T-8 will all be exact --- a property that will ## be exploited in Step 6 below. The total relative error ## in p is no bigger than 2^(-67.7) compared to the final ## result. ## ## Step 6. Reconstruction of exp(X)-1 ## exp(X)-1 = 2^M * ( 2^(J/64) + p - 2^(-M) ). ## 6.1 If M <= 63, go to Step 6.3. ## 6.2 ans := T + (p + (t + OnebySc)). Go to 6.6 ## 6.3 If M >= -3, go to 6.5. ## 6.4 ans := (T + (p + t)) + OnebySc. Go to 6.6 ## 6.5 ans := (T + OnebySc) + (p + t). ## 6.6 Restore user FPCR. ## 6.7 Return ans := Sc * ans. Exit. ## Notes: The various arrangements of the expressions give ## accurate evaluations. ## ## Step 7. exp(X)-1 for |X| < 1/4. ## 7.1 If |X| >= 2^(-65), go to Step 9. ## 7.2 Go to Step 8. ## ## Step 8. Calculate exp(X)-1, |X| < 2^(-65). ## 8.1 If |X| < 2^(-16312), goto 8.3 ## 8.2 Restore FPCR; return ans := X - 2^(-16382). ## Exit. ## 8.3 X := X * 2^(140). ## 8.4 Restore FPCR; ans := ans - 2^(-16382). ## Return ans := ans*2^(140). Exit ## Notes: The idea is to return "X - tiny" under the user ## precision and rounding modes. To avoid unnecessary ## inefficiency, we stay away from denormalized numbers ## the best we can. For |X| >= 2^(-16312), the ## straightforward 8.2 generates the inexact exception as ## the case warrants. ## ## Step 9. Calculate exp(X)-1, |X| < 1/4, by a polynomial ## p = X + X*X*(B1 + X*(B2 + ... + X*B12)) ## Notes: a) In order to reduce memory access, the coefficients ## are made as "short" as possible: B1 (which is 1/2), B9 ## to B12 are single precision; B3 to B8 are double ## precision; and B2 is double extended. ## b) Even with the restriction above, ## |p - (exp(X)-1)| < |X| 2^(-70.6) ## for all |X| <= 0.251. ## Note that 0.251 is slightly bigger than 1/4. ## c) To fully preserve accuracy, the polynomial is ## computed as ## X + ( S*B1 + Q ) where S = X*X and ## Q = X*S*(B2 + X*(B3 + ... + X*B12)) ## d) To fully utilize the pipeline, Q is separated into ## two independent pieces of roughly equal complexity ## Q = [ X*S*(B2 + S*(B4 + ... + S*B12)) ] + ## [ S*S*(B3 + S*(B5 + ... + S*B11)) ] ## ## Step 10. Calculate exp(X)-1 for |X| >= 70 log 2. ## 10.1 If X >= 70log2 , exp(X) - 1 = exp(X) for all ## practical purposes. Therefore, go to Step 1 of setox. ## 10.2 If X <= -70log2, exp(X) - 1 = -1 for all practical ## purposes. ## ans := -1 ## Restore user FPCR ## Return ans := ans + 2^(-126). Exit. ## Notes: 10.2 will always create an inexact and return -1 + tiny ## in the user rounding precision and mode. ## ##########################################################################L2: long 0x3FDC0000,0x82E30865,0x4361C4C6,0x00000000EEXPA3: long 0x3FA55555,0x55554CC1EEXPA2: long 0x3FC55555,0x55554A54EM1A4: long 0x3F811111,0x11174385EM1A3: long 0x3FA55555,0x55554F5AEM1A2: long 0x3FC55555,0x55555555,0x00000000,0x00000000EM1B8: long 0x3EC71DE3,0xA5774682EM1B7: long 0x3EFA01A0,0x19D7CB68EM1B6: long 0x3F2A01A0,0x1A019DF3EM1B5: long 0x3F56C16C,0x16C170E2EM1B4: long 0x3F811111,0x11111111EM1B3: long 0x3FA55555,0x55555555EM1B2: long 0x3FFC0000,0xAAAAAAAA,0xAAAAAAABlong 0x00000000TWO140: long 0x48B00000,0x00000000TWON140:long 0x37300000,0x00000000EEXPTBL:long 0x3FFF0000,0x80000000,0x00000000,0x00000000long 0x3FFF0000,0x8164D1F3,0xBC030774,0x9F841A9Blong 0x3FFF0000,0x82CD8698,0xAC2BA1D8,0x9FC1D5B9long 0x3FFF0000,0x843A28C3,0xACDE4048,0xA0728369long 0x3FFF0000,0x85AAC367,0xCC487B14,0x1FC5C95Clong 0x3FFF0000,0x871F6196,0x9E8D1010,0x1EE85C9Flong 0x3FFF0000,0x88980E80,0x92DA8528,0x9FA20729long 0x3FFF0000,0x8A14D575,0x496EFD9C,0xA07BF9AFlong 0x3FFF0000,0x8B95C1E3,0xEA8BD6E8,0xA0020DCFlong 0x3FFF0000,0x8D1ADF5B,0x7E5BA9E4,0x205A63DAlong 0x3FFF0000,0x8EA4398B,0x45CD53C0,0x1EB70051long 0x3FFF0000,0x9031DC43,0x1466B1DC,0x1F6EB029long 0x3FFF0000,0x91C3D373,0xAB11C338,0xA0781494long 0x3FFF0000,0x935A2B2F,0x13E6E92C,0x9EB319B0long 0x3FFF0000,0x94F4EFA8,0xFEF70960,0x2017457Dlong 0x3FFF0000,0x96942D37,0x20185A00,0x1F11D537long 0x3FFF0000,0x9837F051,0x8DB8A970,0x9FB952DDlong 0x3FFF0000,0x99E04593,0x20B7FA64,0x1FE43087long 0x3FFF0000,0x9B8D39B9,0xD54E5538,0x1FA2A818long 0x3FFF0000,0x9D3ED9A7,0x2CFFB750,0x1FDE494Dlong 0x3FFF0000,0x9EF53260,0x91A111AC,0x20504890long 0x3FFF0000,0xA0B0510F,0xB9714FC4,0xA073691Clong 0x3FFF0000,0xA2704303,0x0C496818,0x1F9B7A05long 0x3FFF0000,0xA43515AE,0x09E680A0,0xA0797126long 0x3FFF0000,0xA5FED6A9,0xB15138EC,0xA071A140long 0x3FFF0000,0xA7CD93B4,0xE9653568,0x204F62DAlong 0x3FFF0000,0xA9A15AB4,0xEA7C0EF8,0x1F283C4Along 0x3FFF0000,0xAB7A39B5,0xA93ED338,0x9F9A7FDClong 0x3FFF0000,0xAD583EEA,0x42A14AC8,0xA05B3FAClong 0x3FFF0000,0xAF3B78AD,0x690A4374,0x1FDF2610long 0x3FFF0000,0xB123F581,0xD2AC2590,0x9F705F90long 0x3FFF0000,0xB311C412,0xA9112488,0x201F678Along 0x3FFF0000,0xB504F333,0xF9DE6484,0x1F32FB13long 0x3FFF0000,0xB6FD91E3,0x28D17790,0x20038B30long 0x3FFF0000,0xB8FBAF47,0x62FB9EE8,0x200DC3CClong 0x3FFF0000,0xBAFF5AB2,0x133E45FC,0x9F8B2AE6long 0x3FFF0000,0xBD08A39F,0x580C36C0,0xA02BBF70long 0x3FFF0000,0xBF1799B6,0x7A731084,0xA00BF518long 0x3FFF0000,0xC12C4CCA,0x66709458,0xA041DD41long 0x3FFF0000,0xC346CCDA,0x24976408,0x9FDF137Blong 0x3FFF0000,0xC5672A11,0x5506DADC,0x201F1568long 0x3FFF0000,0xC78D74C8,0xABB9B15C,0x1FC13A2Elong 0x3FFF0000,0xC9B9BD86,0x6E2F27A4,0xA03F8F03long 0x3FFF0000,0xCBEC14FE,0xF2727C5C,0x1FF4907Dlong 0x3FFF0000,0xCE248C15,0x1F8480E4,0x9E6E53E4long 0x3FFF0000,0xD06333DA,0xEF2B2594,0x1FD6D45Clong 0x3FFF0000,0xD2A81D91,0xF12AE45C,0xA076EDB9long 0x3FFF0000,0xD4F35AAB,0xCFEDFA20,0x9FA6DE21long 0x3FFF0000,0xD744FCCA,0xD69D6AF4,0x1EE69A2Flong 0x3FFF0000,0xD99D15C2,0x78AFD7B4,0x207F439Flong 0x3FFF0000,0xDBFBB797,0xDAF23754,0x201EC207long 0x3FFF0000,0xDE60F482,0x5E0E9124,0x9E8BE175long 0x3FFF0000,0xE0CCDEEC,0x2A94E110,0x20032C4Blong 0x3FFF0000,0xE33F8972,0xBE8A5A50,0x2004DFF5long 0x3FFF0000,0xE5B906E7,0x7C8348A8,0x1E72F47Along 0x3FFF0000,0xE8396A50,0x3C4BDC68,0x1F722F22long 0x3FFF0000,0xEAC0C6E7,0xDD243930,0xA017E945long 0x3FFF0000,0xED4F301E,0xD9942B84,0x1F401A5Blong 0x3FFF0000,0xEFE4B99B,0xDCDAF5CC,0x9FB9A9E3long 0x3FFF0000,0xF281773C,0x59FFB138,0x20744C05long 0x3FFF0000,0xF5257D15,0x2486CC2C,0x1F773A19long 0x3FFF0000,0xF7D0DF73,0x0AD13BB8,0x1FFE90D5long 0x3FFF0000,0xFA83B2DB,0x722A033C,0xA041ED22long 0x3FFF0000,0xFD3E0C0C,0xF486C174,0x1F853F3Aset ADJFLAG,L_SCR2set SCALE,FP_SCR0set ADJSCALE,FP_SCR1set SC,FP_SCR0set ONEBYSC,FP_SCR1global setoxsetox:#--entry point for EXP(X), here X is finite, non-zero, and not NaN's#--Step 1.mov.l (%a0),%d1 # load part of input Xand.l &0x7FFF0000,%d1 # biased expo. of Xcmp.l %d1,&0x3FBE0000 # 2^(-65)bge.b EXPC1 # normal casebra EXPSMEXPC1:#--The case |X| >= 2^(-65)mov.w 4(%a0),%d1 # expo. and partial sig. of |X|cmp.l %d1,&0x400CB167 # 16380 log2 trunc. 16 bitsblt.b EXPMAIN # normal casebra EEXPBIGEXPMAIN:#--Step 2.#--This is the normal branch: 2^(-65) <= |X| < 16380 log2.fmov.x (%a0),%fp0 # load input from (a0)fmov.x %fp0,%fp1fmul.s &0x42B8AA3B,%fp0 # 64/log2 * Xfmovm.x &0xc,-(%sp) # save fp2 {%fp2/%fp3}mov.l &0,ADJFLAG(%a6)fmov.l %fp0,%d1 # N = int( X * 64/log2 )lea EEXPTBL(%pc),%a1fmov.l %d1,%fp0 # convert to floating-formatmov.l %d1,L_SCR1(%a6) # save N temporarilyand.l &0x3F,%d1 # D0 is J = N mod 64lsl.l &4,%d1add.l %d1,%a1 # address of 2^(J/64)mov.l L_SCR1(%a6),%d1asr.l &6,%d1 # D0 is Madd.w &0x3FFF,%d1 # biased expo. of 2^(M)mov.w L2(%pc),L_SCR1(%a6) # prefetch L2, no need in CBEXPCONT1:#--Step 3.#--fp1,fp2 saved on the stack. fp0 is N, fp1 is X,#--a0 points to 2^(J/64), D0 is biased expo. of 2^(M)fmov.x %fp0,%fp2fmul.s &0xBC317218,%fp0 # N * L1, L1 = lead(-log2/64)fmul.x L2(%pc),%fp2 # N * L2, L1+L2 = -log2/64fadd.x %fp1,%fp0 # X + N*L1fadd.x %fp2,%fp0 # fp0 is R, reduced arg.#--Step 4.#--WE NOW COMPUTE EXP(R)-1 BY A POLYNOMIAL#-- R + R*R*(A1 + R*(A2 + R*(A3 + R*(A4 + R*A5))))#--TO FULLY UTILIZE THE PIPELINE, WE COMPUTE S = R*R#--[R+R*S*(A2+S*A4)] + [S*(A1+S*(A3+S*A5))]fmov.x %fp0,%fp1fmul.x %fp1,%fp1 # fp1 IS S = R*Rfmov.s &0x3AB60B70,%fp2 # fp2 IS A5fmul.x %fp1,%fp2 # fp2 IS S*A5fmov.x %fp1,%fp3fmul.s &0x3C088895,%fp3 # fp3 IS S*A4fadd.d EEXPA3(%pc),%fp2 # fp2 IS A3+S*A5fadd.d EEXPA2(%pc),%fp3 # fp3 IS A2+S*A4fmul.x %fp1,%fp2 # fp2 IS S*(A3+S*A5)mov.w %d1,SCALE(%a6) # SCALE is 2^(M) in extendedmov.l &0x80000000,SCALE+4(%a6)clr.l SCALE+8(%a6)fmul.x %fp1,%fp3 # fp3 IS S*(A2+S*A4)fadd.s &0x3F000000,%fp2 # fp2 IS A1+S*(A3+S*A5)fmul.x %fp0,%fp3 # fp3 IS R*S*(A2+S*A4)fmul.x %fp1,%fp2 # fp2 IS S*(A1+S*(A3+S*A5))fadd.x %fp3,%fp0 # fp0 IS R+R*S*(A2+S*A4),fmov.x (%a1)+,%fp1 # fp1 is lead. pt. of 2^(J/64)fadd.x %fp2,%fp0 # fp0 is EXP(R) - 1#--Step 5#--final reconstruction process#--EXP(X) = 2^M * ( 2^(J/64) + 2^(J/64)*(EXP(R)-1) )fmul.x %fp1,%fp0 # 2^(J/64)*(Exp(R)-1)fmovm.x (%sp)+,&0x30 # fp2 restored {%fp2/%fp3}fadd.s (%a1),%fp0 # accurate 2^(J/64)fadd.x %fp1,%fp0 # 2^(J/64) + 2^(J/64)*...mov.l ADJFLAG(%a6),%d1#--Step 6tst.l %d1beq.b NORMALADJUST:fmul.x ADJSCALE(%a6),%fp0NORMAL:fmov.l %d0,%fpcr # restore user FPCRmov.b &FMUL_OP,%d1 # last inst is MULfmul.x SCALE(%a6),%fp0 # multiply 2^(M)bra t_catchEXPSM:#--Step 7fmovm.x (%a0),&0x80 # load Xfmov.l %d0,%fpcrfadd.s &0x3F800000,%fp0 # 1+X in user modebra t_pinx2EEXPBIG:#--Step 8cmp.l %d1,&0x400CB27C # 16480 log2bgt.b EXP2BIG#--Steps 8.2 -- 8.6fmov.x (%a0),%fp0 # load input from (a0)fmov.x %fp0,%fp1fmul.s &0x42B8AA3B,%fp0 # 64/log2 * Xfmovm.x &0xc,-(%sp) # save fp2 {%fp2/%fp3}mov.l &1,ADJFLAG(%a6)fmov.l %fp0,%d1 # N = int( X * 64/log2 )lea EEXPTBL(%pc),%a1fmov.l %d1,%fp0 # convert to floating-formatmov.l %d1,L_SCR1(%a6) # save N temporarilyand.l &0x3F,%d1 # D0 is J = N mod 64lsl.l &4,%d1add.l %d1,%a1 # address of 2^(J/64)mov.l L_SCR1(%a6),%d1asr.l &6,%d1 # D0 is Kmov.l %d1,L_SCR1(%a6) # save K temporarilyasr.l &1,%d1 # D0 is M1sub.l %d1,L_SCR1(%a6) # a1 is Madd.w &0x3FFF,%d1 # biased expo. of 2^(M1)mov.w %d1,ADJSCALE(%a6) # ADJSCALE := 2^(M1)mov.l &0x80000000,ADJSCALE+4(%a6)clr.l ADJSCALE+8(%a6)mov.l L_SCR1(%a6),%d1 # D0 is Madd.w &0x3FFF,%d1 # biased expo. of 2^(M)bra.w EXPCONT1 # go back to Step 3EXP2BIG:#--Step 9tst.b (%a0) # is X positive or negative?bmi t_unfl2bra t_ovfl2global setoxdsetoxd:#--entry point for EXP(X), X is denormalizedmov.l (%a0),-(%sp)andi.l &0x80000000,(%sp)ori.l &0x00800000,(%sp) # sign(X)*2^(-126)fmov.s &0x3F800000,%fp0fmov.l %d0,%fpcrfadd.s (%sp)+,%fp0bra t_pinx2global setoxm1setoxm1:#--entry point for EXPM1(X), here X is finite, non-zero, non-NaN#--Step 1.#--Step 1.1mov.l (%a0),%d1 # load part of input Xand.l &0x7FFF0000,%d1 # biased expo. of Xcmp.l %d1,&0x3FFD0000 # 1/4bge.b EM1CON1 # |X| >= 1/4bra EM1SMEM1CON1:#--Step 1.3#--The case |X| >= 1/4mov.w 4(%a0),%d1 # expo. and partial sig. of |X|cmp.l %d1,&0x4004C215 # 70log2 rounded up to 16 bitsble.b EM1MAIN # 1/4 <= |X| <= 70log2bra EM1BIGEM1MAIN:#--Step 2.#--This is the case: 1/4 <= |X| <= 70 log2.fmov.x (%a0),%fp0 # load input from (a0)fmov.x %fp0,%fp1fmul.s &0x42B8AA3B,%fp0 # 64/log2 * Xfmovm.x &0xc,-(%sp) # save fp2 {%fp2/%fp3}fmov.l %fp0,%d1 # N = int( X * 64/log2 )lea EEXPTBL(%pc),%a1fmov.l %d1,%fp0 # convert to floating-formatmov.l %d1,L_SCR1(%a6) # save N temporarilyand.l &0x3F,%d1 # D0 is J = N mod 64lsl.l &4,%d1add.l %d1,%a1 # address of 2^(J/64)mov.l L_SCR1(%a6),%d1asr.l &6,%d1 # D0 is Mmov.l %d1,L_SCR1(%a6) # save a copy of M#--Step 3.#--fp1,fp2 saved on the stack. fp0 is N, fp1 is X,#--a0 points to 2^(J/64), D0 and a1 both contain Mfmov.x %fp0,%fp2fmul.s &0xBC317218,%fp0 # N * L1, L1 = lead(-log2/64)fmul.x L2(%pc),%fp2 # N * L2, L1+L2 = -log2/64fadd.x %fp1,%fp0 # X + N*L1fadd.x %fp2,%fp0 # fp0 is R, reduced arg.add.w &0x3FFF,%d1 # D0 is biased expo. of 2^M#--Step 4.#--WE NOW COMPUTE EXP(R)-1 BY A POLYNOMIAL#-- R + R*R*(A1 + R*(A2 + R*(A3 + R*(A4 + R*(A5 + R*A6)))))#--TO FULLY UTILIZE THE PIPELINE, WE COMPUTE S = R*R#--[R*S*(A2+S*(A4+S*A6))] + [R+S*(A1+S*(A3+S*A5))]fmov.x %fp0,%fp1fmul.x %fp1,%fp1 # fp1 IS S = R*Rfmov.s &0x3950097B,%fp2 # fp2 IS a6fmul.x %fp1,%fp2 # fp2 IS S*A6fmov.x %fp1,%fp3fmul.s &0x3AB60B6A,%fp3 # fp3 IS S*A5fadd.d EM1A4(%pc),%fp2 # fp2 IS A4+S*A6fadd.d EM1A3(%pc),%fp3 # fp3 IS A3+S*A5mov.w %d1,SC(%a6) # SC is 2^(M) in extendedmov.l &0x80000000,SC+4(%a6)clr.l SC+8(%a6)fmul.x %fp1,%fp2 # fp2 IS S*(A4+S*A6)mov.l L_SCR1(%a6),%d1 # D0 is Mneg.w %d1 # D0 is -Mfmul.x %fp1,%fp3 # fp3 IS S*(A3+S*A5)add.w &0x3FFF,%d1 # biased expo. of 2^(-M)fadd.d EM1A2(%pc),%fp2 # fp2 IS A2+S*(A4+S*A6)fadd.s &0x3F000000,%fp3 # fp3 IS A1+S*(A3+S*A5)fmul.x %fp1,%fp2 # fp2 IS S*(A2+S*(A4+S*A6))or.w &0x8000,%d1 # signed/expo. of -2^(-M)mov.w %d1,ONEBYSC(%a6) # OnebySc is -2^(-M)mov.l &0x80000000,ONEBYSC+4(%a6)clr.l ONEBYSC+8(%a6)fmul.x %fp3,%fp1 # fp1 IS S*(A1+S*(A3+S*A5))fmul.x %fp0,%fp2 # fp2 IS R*S*(A2+S*(A4+S*A6))fadd.x %fp1,%fp0 # fp0 IS R+S*(A1+S*(A3+S*A5))fadd.x %fp2,%fp0 # fp0 IS EXP(R)-1fmovm.x (%sp)+,&0x30 # fp2 restored {%fp2/%fp3}#--Step 5#--Compute 2^(J/64)*pfmul.x (%a1),%fp0 # 2^(J/64)*(Exp(R)-1)#--Step 6#--Step 6.1mov.l L_SCR1(%a6),%d1 # retrieve Mcmp.l %d1,&63ble.b MLE63#--Step 6.2 M >= 64fmov.s 12(%a1),%fp1 # fp1 is tfadd.x ONEBYSC(%a6),%fp1 # fp1 is t+OnebyScfadd.x %fp1,%fp0 # p+(t+OnebySc), fp1 releasedfadd.x (%a1),%fp0 # T+(p+(t+OnebySc))bra EM1SCALEMLE63:#--Step 6.3 M <= 63cmp.l %d1,&-3bge.b MGEN3MLTN3:#--Step 6.4 M <= -4fadd.s 12(%a1),%fp0 # p+tfadd.x (%a1),%fp0 # T+(p+t)fadd.x ONEBYSC(%a6),%fp0 # OnebySc + (T+(p+t))bra EM1SCALEMGEN3:#--Step 6.5 -3 <= M <= 63fmov.x (%a1)+,%fp1 # fp1 is Tfadd.s (%a1),%fp0 # fp0 is p+tfadd.x ONEBYSC(%a6),%fp1 # fp1 is T+OnebyScfadd.x %fp1,%fp0 # (T+OnebySc)+(p+t)EM1SCALE:#--Step 6.6fmov.l %d0,%fpcrfmul.x SC(%a6),%fp0bra t_inx2EM1SM:#--Step 7 |X| < 1/4.cmp.l %d1,&0x3FBE0000 # 2^(-65)bge.b EM1POLYEM1TINY:#--Step 8 |X| < 2^(-65)cmp.l %d1,&0x00330000 # 2^(-16312)blt.b EM12TINY#--Step 8.2mov.l &0x80010000,SC(%a6) # SC is -2^(-16382)mov.l &0x80000000,SC+4(%a6)clr.l SC+8(%a6)fmov.x (%a0),%fp0fmov.l %d0,%fpcrmov.b &FADD_OP,%d1 # last inst is ADDfadd.x SC(%a6),%fp0bra t_catchEM12TINY:#--Step 8.3fmov.x (%a0),%fp0fmul.d TWO140(%pc),%fp0mov.l &0x80010000,SC(%a6)mov.l &0x80000000,SC+4(%a6)clr.l SC+8(%a6)fadd.x SC(%a6),%fp0fmov.l %d0,%fpcrmov.b &FMUL_OP,%d1 # last inst is MULfmul.d TWON140(%pc),%fp0bra t_catchEM1POLY:#--Step 9 exp(X)-1 by a simple polynomialfmov.x (%a0),%fp0 # fp0 is Xfmul.x %fp0,%fp0 # fp0 is S := X*Xfmovm.x &0xc,-(%sp) # save fp2 {%fp2/%fp3}fmov.s &0x2F30CAA8,%fp1 # fp1 is B12fmul.x %fp0,%fp1 # fp1 is S*B12fmov.s &0x310F8290,%fp2 # fp2 is B11fadd.s &0x32D73220,%fp1 # fp1 is B10+S*B12fmul.x %fp0,%fp2 # fp2 is S*B11fmul.x %fp0,%fp1 # fp1 is S*(B10 + ...fadd.s &0x3493F281,%fp2 # fp2 is B9+S*...fadd.d EM1B8(%pc),%fp1 # fp1 is B8+S*...fmul.x %fp0,%fp2 # fp2 is S*(B9+...fmul.x %fp0,%fp1 # fp1 is S*(B8+...fadd.d EM1B7(%pc),%fp2 # fp2 is B7+S*...fadd.d EM1B6(%pc),%fp1 # fp1 is B6+S*...fmul.x %fp0,%fp2 # fp2 is S*(B7+...fmul.x %fp0,%fp1 # fp1 is S*(B6+...fadd.d EM1B5(%pc),%fp2 # fp2 is B5+S*...fadd.d EM1B4(%pc),%fp1 # fp1 is B4+S*...fmul.x %fp0,%fp2 # fp2 is S*(B5+...fmul.x %fp0,%fp1 # fp1 is S*(B4+...fadd.d EM1B3(%pc),%fp2 # fp2 is B3+S*...fadd.x EM1B2(%pc),%fp1 # fp1 is B2+S*...fmul.x %fp0,%fp2 # fp2 is S*(B3+...fmul.x %fp0,%fp1 # fp1 is S*(B2+...fmul.x %fp0,%fp2 # fp2 is S*S*(B3+...)fmul.x (%a0),%fp1 # fp1 is X*S*(B2...fmul.s &0x3F000000,%fp0 # fp0 is S*B1fadd.x %fp2,%fp1 # fp1 is Qfmovm.x (%sp)+,&0x30 # fp2 restored {%fp2/%fp3}fadd.x %fp1,%fp0 # fp0 is S*B1+Qfmov.l %d0,%fpcrfadd.x (%a0),%fp0bra t_inx2EM1BIG:#--Step 10 |X| > 70 log2mov.l (%a0),%d1cmp.l %d1,&0bgt.w EXPC1#--Step 10.2fmov.s &0xBF800000,%fp0 # fp0 is -1fmov.l %d0,%fpcrfadd.s &0x00800000,%fp0 # -1 + 2^(-126)bra t_minx2global setoxm1dsetoxm1d:#--entry point for EXPM1(X), here X is denormalized#--Step 0.bra t_extdnrm########################################################################## sgetexp(): returns the exponent portion of the input argument. ## The exponent bias is removed and the exponent value is ## returned as an extended precision number in fp0. ## sgetexpd(): handles denormalized numbers. ## ## sgetman(): extracts the mantissa of the input argument. The ## mantissa is converted to an extended precision number w/ ## an exponent of $3fff and is returned in fp0. The range of ## the result is [1.0 - 2.0). ## sgetmand(): handles denormalized numbers. ## ## INPUT *************************************************************** ## a0 = pointer to extended precision input ## ## OUTPUT ************************************************************** ## fp0 = exponent(X) or mantissa(X) ## ##########################################################################global sgetexpsgetexp:mov.w SRC_EX(%a0),%d0 # get the exponentbclr &0xf,%d0 # clear the sign bitsubi.w &0x3fff,%d0 # subtract off the biasfmov.w %d0,%fp0 # return exp in fp0blt.b sgetexpn # it's negativertssgetexpn:mov.b &neg_bmask,FPSR_CC(%a6) # set 'N' ccode bitrtsglobal sgetexpdsgetexpd:bsr.l norm # normalizeneg.w %d0 # new exp = -(shft amt)subi.w &0x3fff,%d0 # subtract off the biasfmov.w %d0,%fp0 # return exp in fp0mov.b &neg_bmask,FPSR_CC(%a6) # set 'N' ccode bitrtsglobal sgetmansgetman:mov.w SRC_EX(%a0),%d0 # get the expori.w &0x7fff,%d0 # clear old expbclr &0xe,%d0 # make it the new exp +-3fff# here, we build the result in a tmp location so as not to disturb the inputmov.l SRC_HI(%a0),FP_SCR0_HI(%a6) # copy to tmp locmov.l SRC_LO(%a0),FP_SCR0_LO(%a6) # copy to tmp locmov.w %d0,FP_SCR0_EX(%a6) # insert new exponentfmov.x FP_SCR0(%a6),%fp0 # put new value back in fp0bmi.b sgetmann # it's negativertssgetmann:mov.b &neg_bmask,FPSR_CC(%a6) # set 'N' ccode bitrts## For denormalized numbers, shift the mantissa until the j-bit = 1,# then load the exponent with +/1 $3fff.#global sgetmandsgetmand:bsr.l norm # normalize exponentbra.b sgetman########################################################################## scosh(): computes the hyperbolic cosine of a normalized input ## scoshd(): computes the hyperbolic cosine of a denormalized input ## ## INPUT *************************************************************** ## a0 = pointer to extended precision input ## d0 = round precision,mode ## ## OUTPUT ************************************************************** ## fp0 = cosh(X) ## ## ACCURACY and MONOTONICITY ******************************************* ## The returned result is within 3 ulps in 64 significant bit, ## i.e. within 0.5001 ulp to 53 bits if the result is subsequently ## rounded to double precision. The result is provably monotonic ## in double precision. ## ## ALGORITHM *********************************************************** ## ## COSH ## 1. If |X| > 16380 log2, go to 3. ## ## 2. (|X| <= 16380 log2) Cosh(X) is obtained by the formulae ## y = |X|, z = exp(Y), and ## cosh(X) = (1/2)*( z + 1/z ). ## Exit. ## ## 3. (|X| > 16380 log2). If |X| > 16480 log2, go to 5. ## ## 4. (16380 log2 < |X| <= 16480 log2) ## cosh(X) = sign(X) * exp(|X|)/2. ## However, invoking exp(|X|) may cause premature ## overflow. Thus, we calculate sinh(X) as follows: ## Y := |X| ## Fact := 2**(16380) ## Y' := Y - 16381 log2 ## cosh(X) := Fact * exp(Y'). ## Exit. ## ## 5. (|X| > 16480 log2) sinh(X) must overflow. Return ## Huge*Huge to generate overflow and an infinity with ## the appropriate sign. Huge is the largest finite number ## in extended format. Exit. ## ##########################################################################TWO16380:long 0x7FFB0000,0x80000000,0x00000000,0x00000000global scoshscosh:fmov.x (%a0),%fp0 # LOAD INPUTmov.l (%a0),%d1mov.w 4(%a0),%d1and.l &0x7FFFFFFF,%d1cmp.l %d1,&0x400CB167bgt.b COSHBIG#--THIS IS THE USUAL CASE, |X| < 16380 LOG2#--COSH(X) = (1/2) * ( EXP(X) + 1/EXP(X) )fabs.x %fp0 # |X|mov.l %d0,-(%sp)clr.l %d0fmovm.x &0x01,-(%sp) # save |X| to stacklea (%sp),%a0 # pass ptr to |X|bsr setox # FP0 IS EXP(|X|)add.l &0xc,%sp # erase |X| from stackfmul.s &0x3F000000,%fp0 # (1/2)EXP(|X|)mov.l (%sp)+,%d0fmov.s &0x3E800000,%fp1 # (1/4)fdiv.x %fp0,%fp1 # 1/(2 EXP(|X|))fmov.l %d0,%fpcrmov.b &FADD_OP,%d1 # last inst is ADDfadd.x %fp1,%fp0bra t_catchCOSHBIG:cmp.l %d1,&0x400CB2B3bgt.b COSHHUGEfabs.x %fp0fsub.d T1(%pc),%fp0 # (|X|-16381LOG2_LEAD)fsub.d T2(%pc),%fp0 # |X| - 16381 LOG2, ACCURATEmov.l %d0,-(%sp)clr.l %d0fmovm.x &0x01,-(%sp) # save fp0 to stacklea (%sp),%a0 # pass ptr to fp0bsr setoxadd.l &0xc,%sp # clear fp0 from stackmov.l (%sp)+,%d0fmov.l %d0,%fpcrmov.b &FMUL_OP,%d1 # last inst is MULfmul.x TWO16380(%pc),%fp0bra t_catchCOSHHUGE:bra t_ovfl2global scoshd#--COSH(X) = 1 FOR DENORMALIZED Xscoshd:fmov.s &0x3F800000,%fp0fmov.l %d0,%fpcrfadd.s &0x00800000,%fp0bra t_pinx2########################################################################## ssinh(): computes the hyperbolic sine of a normalized input ## ssinhd(): computes the hyperbolic sine of a denormalized input ## ## INPUT *************************************************************** ## a0 = pointer to extended precision input ## d0 = round precision,mode ## ## OUTPUT ************************************************************** ## fp0 = sinh(X) ## ## ACCURACY and MONOTONICITY ******************************************* ## The returned result is within 3 ulps in 64 significant bit, ## i.e. within 0.5001 ulp to 53 bits if the result is subsequently ## rounded to double precision. The result is provably monotonic ## in double precision. ## ## ALGORITHM *********************************************************** ## ## SINH ## 1. If |X| > 16380 log2, go to 3. ## ## 2. (|X| <= 16380 log2) Sinh(X) is obtained by the formula ## y = |X|, sgn = sign(X), and z = expm1(Y), ## sinh(X) = sgn*(1/2)*( z + z/(1+z) ). ## Exit. ## ## 3. If |X| > 16480 log2, go to 5. ## ## 4. (16380 log2 < |X| <= 16480 log2) ## sinh(X) = sign(X) * exp(|X|)/2. ## However, invoking exp(|X|) may cause premature overflow. ## Thus, we calculate sinh(X) as follows: ## Y := |X| ## sgn := sign(X) ## sgnFact := sgn * 2**(16380) ## Y' := Y - 16381 log2 ## sinh(X) := sgnFact * exp(Y'). ## Exit. ## ## 5. (|X| > 16480 log2) sinh(X) must overflow. Return ## sign(X)*Huge*Huge to generate overflow and an infinity with ## the appropriate sign. Huge is the largest finite number in ## extended format. Exit. ## ##########################################################################global ssinhssinh:fmov.x (%a0),%fp0 # LOAD INPUTmov.l (%a0),%d1mov.w 4(%a0),%d1mov.l %d1,%a1 # save (compacted) operandand.l &0x7FFFFFFF,%d1cmp.l %d1,&0x400CB167bgt.b SINHBIG#--THIS IS THE USUAL CASE, |X| < 16380 LOG2#--Y = |X|, Z = EXPM1(Y), SINH(X) = SIGN(X)*(1/2)*( Z + Z/(1+Z) )fabs.x %fp0 # Y = |X|movm.l &0x8040,-(%sp) # {a1/d0}fmovm.x &0x01,-(%sp) # save Y on stacklea (%sp),%a0 # pass ptr to Yclr.l %d0bsr setoxm1 # FP0 IS Z = EXPM1(Y)add.l &0xc,%sp # clear Y from stackfmov.l &0,%fpcrmovm.l (%sp)+,&0x0201 # {a1/d0}fmov.x %fp0,%fp1fadd.s &0x3F800000,%fp1 # 1+Zfmov.x %fp0,-(%sp)fdiv.x %fp1,%fp0 # Z/(1+Z)mov.l %a1,%d1and.l &0x80000000,%d1or.l &0x3F000000,%d1fadd.x (%sp)+,%fp0mov.l %d1,-(%sp)fmov.l %d0,%fpcrmov.b &FMUL_OP,%d1 # last inst is MULfmul.s (%sp)+,%fp0 # last fp inst - possible exceptions setbra t_catchSINHBIG:cmp.l %d1,&0x400CB2B3bgt t_ovflfabs.x %fp0fsub.d T1(%pc),%fp0 # (|X|-16381LOG2_LEAD)mov.l &0,-(%sp)mov.l &0x80000000,-(%sp)mov.l %a1,%d1and.l &0x80000000,%d1or.l &0x7FFB0000,%d1mov.l %d1,-(%sp) # EXTENDED FMTfsub.d T2(%pc),%fp0 # |X| - 16381 LOG2, ACCURATEmov.l %d0,-(%sp)clr.l %d0fmovm.x &0x01,-(%sp) # save fp0 on stacklea (%sp),%a0 # pass ptr to fp0bsr setoxadd.l &0xc,%sp # clear fp0 from stackmov.l (%sp)+,%d0fmov.l %d0,%fpcrmov.b &FMUL_OP,%d1 # last inst is MULfmul.x (%sp)+,%fp0 # possible exceptionbra t_catchglobal ssinhd#--SINH(X) = X FOR DENORMALIZED Xssinhd:bra t_extdnrm########################################################################## stanh(): computes the hyperbolic tangent of a normalized input ## stanhd(): computes the hyperbolic tangent of a denormalized input ## ## INPUT *************************************************************** ## a0 = pointer to extended precision input ## d0 = round precision,mode ## ## OUTPUT ************************************************************** ## fp0 = tanh(X) ## ## ACCURACY and MONOTONICITY ******************************************* ## The returned result is within 3 ulps in 64 significant bit, ## i.e. within 0.5001 ulp to 53 bits if the result is subsequently ## rounded to double precision. The result is provably monotonic ## in double precision. ## ## ALGORITHM *********************************************************** ## ## TANH ## 1. If |X| >= (5/2) log2 or |X| <= 2**(-40), go to 3. ## ## 2. (2**(-40) < |X| < (5/2) log2) Calculate tanh(X) by ## sgn := sign(X), y := 2|X|, z := expm1(Y), and ## tanh(X) = sgn*( z/(2+z) ). ## Exit. ## ## 3. (|X| <= 2**(-40) or |X| >= (5/2) log2). If |X| < 1, ## go to 7. ## ## 4. (|X| >= (5/2) log2) If |X| >= 50 log2, go to 6. ## ## 5. ((5/2) log2 <= |X| < 50 log2) Calculate tanh(X) by ## sgn := sign(X), y := 2|X|, z := exp(Y), ## tanh(X) = sgn - [ sgn*2/(1+z) ]. ## Exit. ## ## 6. (|X| >= 50 log2) Tanh(X) = +-1 (round to nearest). Thus, we ## calculate Tanh(X) by ## sgn := sign(X), Tiny := 2**(-126), ## tanh(X) := sgn - sgn*Tiny. ## Exit. ## ## 7. (|X| < 2**(-40)). Tanh(X) = X. Exit. ## ##########################################################################set X,FP_SCR0set XFRAC,X+4set SGN,L_SCR3set V,FP_SCR0global stanhstanh:fmov.x (%a0),%fp0 # LOAD INPUTfmov.x %fp0,X(%a6)mov.l (%a0),%d1mov.w 4(%a0),%d1mov.l %d1,X(%a6)and.l &0x7FFFFFFF,%d1cmp.l %d1, &0x3fd78000 # is |X| < 2^(-40)?blt.w TANHBORS # yescmp.l %d1, &0x3fffddce # is |X| > (5/2)LOG2?bgt.w TANHBORS # yes#--THIS IS THE USUAL CASE#--Y = 2|X|, Z = EXPM1(Y), TANH(X) = SIGN(X) * Z / (Z+2).mov.l X(%a6),%d1mov.l %d1,SGN(%a6)and.l &0x7FFF0000,%d1add.l &0x00010000,%d1 # EXPONENT OF 2|X|mov.l %d1,X(%a6)and.l &0x80000000,SGN(%a6)fmov.x X(%a6),%fp0 # FP0 IS Y = 2|X|mov.l %d0,-(%sp)clr.l %d0fmovm.x &0x1,-(%sp) # save Y on stacklea (%sp),%a0 # pass ptr to Ybsr setoxm1 # FP0 IS Z = EXPM1(Y)add.l &0xc,%sp # clear Y from stackmov.l (%sp)+,%d0fmov.x %fp0,%fp1fadd.s &0x40000000,%fp1 # Z+2mov.l SGN(%a6),%d1fmov.x %fp1,V(%a6)eor.l %d1,V(%a6)fmov.l %d0,%fpcr # restore users round prec,modefdiv.x V(%a6),%fp0bra t_inx2TANHBORS:cmp.l %d1,&0x3FFF8000blt.w TANHSMcmp.l %d1,&0x40048AA1bgt.w TANHHUGE#-- (5/2) LOG2 < |X| < 50 LOG2,#--TANH(X) = 1 - (2/[EXP(2X)+1]). LET Y = 2|X|, SGN = SIGN(X),#--TANH(X) = SGN - SGN*2/[EXP(Y)+1].mov.l X(%a6),%d1mov.l %d1,SGN(%a6)and.l &0x7FFF0000,%d1add.l &0x00010000,%d1 # EXPO OF 2|X|mov.l %d1,X(%a6) # Y = 2|X|and.l &0x80000000,SGN(%a6)mov.l SGN(%a6),%d1fmov.x X(%a6),%fp0 # Y = 2|X|mov.l %d0,-(%sp)clr.l %d0fmovm.x &0x01,-(%sp) # save Y on stacklea (%sp),%a0 # pass ptr to Ybsr setox # FP0 IS EXP(Y)add.l &0xc,%sp # clear Y from stackmov.l (%sp)+,%d0mov.l SGN(%a6),%d1fadd.s &0x3F800000,%fp0 # EXP(Y)+1eor.l &0xC0000000,%d1 # -SIGN(X)*2fmov.s %d1,%fp1 # -SIGN(X)*2 IN SGL FMTfdiv.x %fp0,%fp1 # -SIGN(X)2 / [EXP(Y)+1 ]mov.l SGN(%a6),%d1or.l &0x3F800000,%d1 # SGNfmov.s %d1,%fp0 # SGN IN SGL FMTfmov.l %d0,%fpcr # restore users round prec,modemov.b &FADD_OP,%d1 # last inst is ADDfadd.x %fp1,%fp0bra t_inx2TANHSM:fmov.l %d0,%fpcr # restore users round prec,modemov.b &FMOV_OP,%d1 # last inst is MOVEfmov.x X(%a6),%fp0 # last inst - possible exception setbra t_catch#---RETURN SGN(X) - SGN(X)EPSTANHHUGE:mov.l X(%a6),%d1and.l &0x80000000,%d1or.l &0x3F800000,%d1fmov.s %d1,%fp0and.l &0x80000000,%d1eor.l &0x80800000,%d1 # -SIGN(X)*EPSfmov.l %d0,%fpcr # restore users round prec,modefadd.s %d1,%fp0bra t_inx2global stanhd#--TANH(X) = X FOR DENORMALIZED Xstanhd:bra t_extdnrm########################################################################## slogn(): computes the natural logarithm of a normalized input ## slognd(): computes the natural logarithm of a denormalized input ## slognp1(): computes the log(1+X) of a normalized input ## slognp1d(): computes the log(1+X) of a denormalized input ## ## INPUT *************************************************************** ## a0 = pointer to extended precision input ## d0 = round precision,mode ## ## OUTPUT ************************************************************** ## fp0 = log(X) or log(1+X) ## ## ACCURACY and MONOTONICITY ******************************************* ## The returned result is within 2 ulps in 64 significant bit, ## i.e. within 0.5001 ulp to 53 bits if the result is subsequently ## rounded to double precision. The result is provably monotonic ## in double precision. ## ## ALGORITHM *********************************************************** ## LOGN: ## Step 1. If |X-1| < 1/16, approximate log(X) by an odd ## polynomial in u, where u = 2(X-1)/(X+1). Otherwise, ## move on to Step 2. ## ## Step 2. X = 2**k * Y where 1 <= Y < 2. Define F to be the first ## seven significant bits of Y plus 2**(-7), i.e. ## F = 1.xxxxxx1 in base 2 where the six "x" match those ## of Y. Note that |Y-F| <= 2**(-7). ## ## Step 3. Define u = (Y-F)/F. Approximate log(1+u) by a ## polynomial in u, log(1+u) = poly. ## ## Step 4. Reconstruct ## log(X) = log( 2**k * Y ) = k*log(2) + log(F) + log(1+u) ## by k*log(2) + (log(F) + poly). The values of log(F) are ## calculated beforehand and stored in the program. ## ## lognp1: ## Step 1: If |X| < 1/16, approximate log(1+X) by an odd ## polynomial in u where u = 2X/(2+X). Otherwise, move on ## to Step 2. ## ## Step 2: Let 1+X = 2**k * Y, where 1 <= Y < 2. Define F as done ## in Step 2 of the algorithm for LOGN and compute ## log(1+X) as k*log(2) + log(F) + poly where poly ## approximates log(1+u), u = (Y-F)/F. ## ## Implementation Notes: ## Note 1. There are 64 different possible values for F, thus 64 ## log(F)'s need to be tabulated. Moreover, the values of ## 1/F are also tabulated so that the division in (Y-F)/F ## can be performed by a multiplication. ## ## Note 2. In Step 2 of lognp1, in order to preserved accuracy, ## the value Y-F has to be calculated carefully when ## 1/2 <= X < 3/2. ## ## Note 3. To fully exploit the pipeline, polynomials are usually ## separated into two parts evaluated independently before ## being added up. ## ##########################################################################LOGOF2:long 0x3FFE0000,0xB17217F7,0xD1CF79AC,0x00000000one:long 0x3F800000zero:long 0x00000000infty:long 0x7F800000negone:long 0xBF800000LOGA6:long 0x3FC2499A,0xB5E4040BLOGA5:long 0xBFC555B5,0x848CB7DBLOGA4:long 0x3FC99999,0x987D8730LOGA3:long 0xBFCFFFFF,0xFF6F7E97LOGA2:long 0x3FD55555,0x555555A4LOGA1:long 0xBFE00000,0x00000008LOGB5:long 0x3F175496,0xADD7DAD6LOGB4:long 0x3F3C71C2,0xFE80C7E0LOGB3:long 0x3F624924,0x928BCCFFLOGB2:long 0x3F899999,0x999995ECLOGB1:long 0x3FB55555,0x55555555TWO:long 0x40000000,0x00000000LTHOLD:long 0x3f990000,0x80000000,0x00000000,0x00000000LOGTBL:long 0x3FFE0000,0xFE03F80F,0xE03F80FE,0x00000000long 0x3FF70000,0xFF015358,0x833C47E2,0x00000000long 0x3FFE0000,0xFA232CF2,0x52138AC0,0x00000000long 0x3FF90000,0xBDC8D83E,0xAD88D549,0x00000000long 0x3FFE0000,0xF6603D98,0x0F6603DA,0x00000000long 0x3FFA0000,0x9CF43DCF,0xF5EAFD48,0x00000000long 0x3FFE0000,0xF2B9D648,0x0F2B9D65,0x00000000long 0x3FFA0000,0xDA16EB88,0xCB8DF614,0x00000000long 0x3FFE0000,0xEF2EB71F,0xC4345238,0x00000000long 0x3FFB0000,0x8B29B775,0x1BD70743,0x00000000long 0x3FFE0000,0xEBBDB2A5,0xC1619C8C,0x00000000long 0x3FFB0000,0xA8D839F8,0x30C1FB49,0x00000000long 0x3FFE0000,0xE865AC7B,0x7603A197,0x00000000long 0x3FFB0000,0xC61A2EB1,0x8CD907AD,0x00000000long 0x3FFE0000,0xE525982A,0xF70C880E,0x00000000long 0x3FFB0000,0xE2F2A47A,0xDE3A18AF,0x00000000long 0x3FFE0000,0xE1FC780E,0x1FC780E2,0x00000000long 0x3FFB0000,0xFF64898E,0xDF55D551,0x00000000long 0x3FFE0000,0xDEE95C4C,0xA037BA57,0x00000000long 0x3FFC0000,0x8DB956A9,0x7B3D0148,0x00000000long 0x3FFE0000,0xDBEB61EE,0xD19C5958,0x00000000long 0x3FFC0000,0x9B8FE100,0xF47BA1DE,0x00000000long 0x3FFE0000,0xD901B203,0x6406C80E,0x00000000long 0x3FFC0000,0xA9372F1D,0x0DA1BD17,0x00000000long 0x3FFE0000,0xD62B80D6,0x2B80D62C,0x00000000long 0x3FFC0000,0xB6B07F38,0xCE90E46B,0x00000000long 0x3FFE0000,0xD3680D36,0x80D3680D,0x00000000long 0x3FFC0000,0xC3FD0329,0x06488481,0x00000000long 0x3FFE0000,0xD0B69FCB,0xD2580D0B,0x00000000long 0x3FFC0000,0xD11DE0FF,0x15AB18CA,0x00000000long 0x3FFE0000,0xCE168A77,0x25080CE1,0x00000000long 0x3FFC0000,0xDE1433A1,0x6C66B150,0x00000000long 0x3FFE0000,0xCB8727C0,0x65C393E0,0x00000000long 0x3FFC0000,0xEAE10B5A,0x7DDC8ADD,0x00000000long 0x3FFE0000,0xC907DA4E,0x871146AD,0x00000000long 0x3FFC0000,0xF7856E5E,0xE2C9B291,0x00000000long 0x3FFE0000,0xC6980C69,0x80C6980C,0x00000000long 0x3FFD0000,0x82012CA5,0xA68206D7,0x00000000long 0x3FFE0000,0xC4372F85,0x5D824CA6,0x00000000long 0x3FFD0000,0x882C5FCD,0x7256A8C5,0x00000000long 0x3FFE0000,0xC1E4BBD5,0x95F6E947,0x00000000long 0x3FFD0000,0x8E44C60B,0x4CCFD7DE,0x00000000long 0x3FFE0000,0xBFA02FE8,0x0BFA02FF,0x00000000long 0x3FFD0000,0x944AD09E,0xF4351AF6,0x00000000long 0x3FFE0000,0xBD691047,0x07661AA3,0x00000000long 0x3FFD0000,0x9A3EECD4,0xC3EAA6B2,0x00000000long 0x3FFE0000,0xBB3EE721,0xA54D880C,0x00000000long 0x3FFD0000,0xA0218434,0x353F1DE8,0x00000000long 0x3FFE0000,0xB92143FA,0x36F5E02E,0x00000000long 0x3FFD0000,0xA5F2FCAB,0xBBC506DA,0x00000000long 0x3FFE0000,0xB70FBB5A,0x19BE3659,0x00000000long 0x3FFD0000,0xABB3B8BA,0x2AD362A5,0x00000000long 0x3FFE0000,0xB509E68A,0x9B94821F,0x00000000long 0x3FFD0000,0xB1641795,0xCE3CA97B,0x00000000long 0x3FFE0000,0xB30F6352,0x8917C80B,0x00000000long 0x3FFD0000,0xB7047551,0x5D0F1C61,0x00000000long 0x3FFE0000,0xB11FD3B8,0x0B11FD3C,0x00000000long 0x3FFD0000,0xBC952AFE,0xEA3D13E1,0x00000000long 0x3FFE0000,0xAF3ADDC6,0x80AF3ADE,0x00000000long 0x3FFD0000,0xC2168ED0,0xF458BA4A,0x00000000long 0x3FFE0000,0xAD602B58,0x0AD602B6,0x00000000long 0x3FFD0000,0xC788F439,0xB3163BF1,0x00000000long 0x3FFE0000,0xAB8F69E2,0x8359CD11,0x00000000long 0x3FFD0000,0xCCECAC08,0xBF04565D,0x00000000long 0x3FFE0000,0xA9C84A47,0xA07F5638,0x00000000long 0x3FFD0000,0xD2420487,0x2DD85160,0x00000000long 0x3FFE0000,0xA80A80A8,0x0A80A80B,0x00000000long 0x3FFD0000,0xD7894992,0x3BC3588A,0x00000000long 0x3FFE0000,0xA655C439,0x2D7B73A8,0x00000000long 0x3FFD0000,0xDCC2C4B4,0x9887DACC,0x00000000long 0x3FFE0000,0xA4A9CF1D,0x96833751,0x00000000long 0x3FFD0000,0xE1EEBD3E,0x6D6A6B9E,0x00000000long 0x3FFE0000,0xA3065E3F,0xAE7CD0E0,0x00000000long 0x3FFD0000,0xE70D785C,0x2F9F5BDC,0x00000000long 0x3FFE0000,0xA16B312E,0xA8FC377D,0x00000000long 0x3FFD0000,0xEC1F392C,0x5179F283,0x00000000long 0x3FFE0000,0x9FD809FD,0x809FD80A,0x00000000long 0x3FFD0000,0xF12440D3,0xE36130E6,0x00000000long 0x3FFE0000,0x9E4CAD23,0xDD5F3A20,0x00000000long 0x3FFD0000,0xF61CCE92,0x346600BB,0x00000000long 0x3FFE0000,0x9CC8E160,0xC3FB19B9,0x00000000long 0x3FFD0000,0xFB091FD3,0x8145630A,0x00000000long 0x3FFE0000,0x9B4C6F9E,0xF03A3CAA,0x00000000long 0x3FFD0000,0xFFE97042,0xBFA4C2AD,0x00000000long 0x3FFE0000,0x99D722DA,0xBDE58F06,0x00000000long 0x3FFE0000,0x825EFCED,0x49369330,0x00000000long 0x3FFE0000,0x9868C809,0x868C8098,0x00000000long 0x3FFE0000,0x84C37A7A,0xB9A905C9,0x00000000long 0x3FFE0000,0x97012E02,0x5C04B809,0x00000000long 0x3FFE0000,0x87224C2E,0x8E645FB7,0x00000000long 0x3FFE0000,0x95A02568,0x095A0257,0x00000000long 0x3FFE0000,0x897B8CAC,0x9F7DE298,0x00000000long 0x3FFE0000,0x94458094,0x45809446,0x00000000long 0x3FFE0000,0x8BCF55DE,0xC4CD05FE,0x00000000long 0x3FFE0000,0x92F11384,0x0497889C,0x00000000long 0x3FFE0000,0x8E1DC0FB,0x89E125E5,0x00000000long 0x3FFE0000,0x91A2B3C4,0xD5E6F809,0x00000000long 0x3FFE0000,0x9066E68C,0x955B6C9B,0x00000000long 0x3FFE0000,0x905A3863,0x3E06C43B,0x00000000long 0x3FFE0000,0x92AADE74,0xC7BE59E0,0x00000000long 0x3FFE0000,0x8F1779D9,0xFDC3A219,0x00000000long 0x3FFE0000,0x94E9BFF6,0x15845643,0x00000000long 0x3FFE0000,0x8DDA5202,0x37694809,0x00000000long 0x3FFE0000,0x9723A1B7,0x20134203,0x00000000long 0x3FFE0000,0x8CA29C04,0x6514E023,0x00000000long 0x3FFE0000,0x995899C8,0x90EB8990,0x00000000long 0x3FFE0000,0x8B70344A,0x139BC75A,0x00000000long 0x3FFE0000,0x9B88BDAA,0x3A3DAE2F,0x00000000long 0x3FFE0000,0x8A42F870,0x5669DB46,0x00000000long 0x3FFE0000,0x9DB4224F,0xFFE1157C,0x00000000long 0x3FFE0000,0x891AC73A,0xE9819B50,0x00000000long 0x3FFE0000,0x9FDADC26,0x8B7A12DA,0x00000000long 0x3FFE0000,0x87F78087,0xF78087F8,0x00000000long 0x3FFE0000,0xA1FCFF17,0xCE733BD4,0x00000000long 0x3FFE0000,0x86D90544,0x7A34ACC6,0x00000000long 0x3FFE0000,0xA41A9E8F,0x5446FB9F,0x00000000long 0x3FFE0000,0x85BF3761,0x2CEE3C9B,0x00000000long 0x3FFE0000,0xA633CD7E,0x6771CD8B,0x00000000long 0x3FFE0000,0x84A9F9C8,0x084A9F9D,0x00000000long 0x3FFE0000,0xA8489E60,0x0B435A5E,0x00000000long 0x3FFE0000,0x83993052,0x3FBE3368,0x00000000long 0x3FFE0000,0xAA59233C,0xCCA4BD49,0x00000000long 0x3FFE0000,0x828CBFBE,0xB9A020A3,0x00000000long 0x3FFE0000,0xAC656DAE,0x6BCC4985,0x00000000long 0x3FFE0000,0x81848DA8,0xFAF0D277,0x00000000long 0x3FFE0000,0xAE6D8EE3,0x60BB2468,0x00000000long 0x3FFE0000,0x80808080,0x80808081,0x00000000long 0x3FFE0000,0xB07197A2,0x3C46C654,0x00000000set ADJK,L_SCR1set X,FP_SCR0set XDCARE,X+2set XFRAC,X+4set F,FP_SCR1set FFRAC,F+4set KLOG2,FP_SCR0set SAVEU,FP_SCR0global slogn#--ENTRY POINT FOR LOG(X) FOR X FINITE, NON-ZERO, NOT NAN'Sslogn:fmov.x (%a0),%fp0 # LOAD INPUTmov.l &0x00000000,ADJK(%a6)LOGBGN:#--FPCR SAVED AND CLEARED, INPUT IS 2^(ADJK)*FP0, FP0 CONTAINS#--A FINITE, NON-ZERO, NORMALIZED NUMBER.mov.l (%a0),%d1mov.w 4(%a0),%d1mov.l (%a0),X(%a6)mov.l 4(%a0),X+4(%a6)mov.l 8(%a0),X+8(%a6)cmp.l %d1,&0 # CHECK IF X IS NEGATIVEblt.w LOGNEG # LOG OF NEGATIVE ARGUMENT IS INVALID# X IS POSITIVE, CHECK IF X IS NEAR 1cmp.l %d1,&0x3ffef07d # IS X < 15/16?blt.b LOGMAIN # YEScmp.l %d1,&0x3fff8841 # IS X > 17/16?ble.w LOGNEAR1 # NOLOGMAIN:#--THIS SHOULD BE THE USUAL CASE, X NOT VERY CLOSE TO 1#--X = 2^(K) * Y, 1 <= Y < 2. THUS, Y = 1.XXXXXXXX....XX IN BINARY.#--WE DEFINE F = 1.XXXXXX1, I.E. FIRST 7 BITS OF Y AND ATTACH A 1.#--THE IDEA IS THAT LOG(X) = K*LOG2 + LOG(Y)#-- = K*LOG2 + LOG(F) + LOG(1 + (Y-F)/F).#--NOTE THAT U = (Y-F)/F IS VERY SMALL AND THUS APPROXIMATING#--LOG(1+U) CAN BE VERY EFFICIENT.#--ALSO NOTE THAT THE VALUE 1/F IS STORED IN A TABLE SO THAT NO#--DIVISION IS NEEDED TO CALCULATE (Y-F)/F.#--GET K, Y, F, AND ADDRESS OF 1/F.asr.l &8,%d1asr.l &8,%d1 # SHIFTED 16 BITS, BIASED EXPO. OF Xsub.l &0x3FFF,%d1 # THIS IS Kadd.l ADJK(%a6),%d1 # ADJUST K, ORIGINAL INPUT MAY BE DENORM.lea LOGTBL(%pc),%a0 # BASE ADDRESS OF 1/F AND LOG(F)fmov.l %d1,%fp1 # CONVERT K TO FLOATING-POINT FORMAT#--WHILE THE CONVERSION IS GOING ON, WE GET F AND ADDRESS OF 1/Fmov.l &0x3FFF0000,X(%a6) # X IS NOW Y, I.E. 2^(-K)*Xmov.l XFRAC(%a6),FFRAC(%a6)and.l &0xFE000000,FFRAC(%a6) # FIRST 7 BITS OF Yor.l &0x01000000,FFRAC(%a6) # GET F: ATTACH A 1 AT THE EIGHTH BITmov.l FFRAC(%a6),%d1 # READY TO GET ADDRESS OF 1/Fand.l &0x7E000000,%d1asr.l &8,%d1asr.l &8,%d1asr.l &4,%d1 # SHIFTED 20, D0 IS THE DISPLACEMENTadd.l %d1,%a0 # A0 IS THE ADDRESS FOR 1/Ffmov.x X(%a6),%fp0mov.l &0x3fff0000,F(%a6)clr.l F+8(%a6)fsub.x F(%a6),%fp0 # Y-Ffmovm.x &0xc,-(%sp) # SAVE FP2-3 WHILE FP0 IS NOT READY#--SUMMARY: FP0 IS Y-F, A0 IS ADDRESS OF 1/F, FP1 IS K#--REGISTERS SAVED: FPCR, FP1, FP2LP1CONT1:#--AN RE-ENTRY POINT FOR LOGNP1fmul.x (%a0),%fp0 # FP0 IS U = (Y-F)/Ffmul.x LOGOF2(%pc),%fp1 # GET K*LOG2 WHILE FP0 IS NOT READYfmov.x %fp0,%fp2fmul.x %fp2,%fp2 # FP2 IS V=U*Ufmov.x %fp1,KLOG2(%a6) # PUT K*LOG2 IN MEMEORY, FREE FP1#--LOG(1+U) IS APPROXIMATED BY#--U + V*(A1+U*(A2+U*(A3+U*(A4+U*(A5+U*A6))))) WHICH IS#--[U + V*(A1+V*(A3+V*A5))] + [U*V*(A2+V*(A4+V*A6))]fmov.x %fp2,%fp3fmov.x %fp2,%fp1fmul.d LOGA6(%pc),%fp1 # V*A6fmul.d LOGA5(%pc),%fp2 # V*A5fadd.d LOGA4(%pc),%fp1 # A4+V*A6fadd.d LOGA3(%pc),%fp2 # A3+V*A5fmul.x %fp3,%fp1 # V*(A4+V*A6)fmul.x %fp3,%fp2 # V*(A3+V*A5)fadd.d LOGA2(%pc),%fp1 # A2+V*(A4+V*A6)fadd.d LOGA1(%pc),%fp2 # A1+V*(A3+V*A5)fmul.x %fp3,%fp1 # V*(A2+V*(A4+V*A6))add.l &16,%a0 # ADDRESS OF LOG(F)fmul.x %fp3,%fp2 # V*(A1+V*(A3+V*A5))fmul.x %fp0,%fp1 # U*V*(A2+V*(A4+V*A6))fadd.x %fp2,%fp0 # U+V*(A1+V*(A3+V*A5))fadd.x (%a0),%fp1 # LOG(F)+U*V*(A2+V*(A4+V*A6))fmovm.x (%sp)+,&0x30 # RESTORE FP2-3fadd.x %fp1,%fp0 # FP0 IS LOG(F) + LOG(1+U)fmov.l %d0,%fpcrfadd.x KLOG2(%a6),%fp0 # FINAL ADDbra t_inx2LOGNEAR1:# if the input is exactly equal to one, then exit through ld_pzero.# if these 2 lines weren't here, the correct answer would be returned# but the INEX2 bit would be set.fcmp.b %fp0,&0x1 # is it equal to one?fbeq.l ld_pzero # yes#--REGISTERS SAVED: FPCR, FP1. FP0 CONTAINS THE INPUT.fmov.x %fp0,%fp1fsub.s one(%pc),%fp1 # FP1 IS X-1fadd.s one(%pc),%fp0 # FP0 IS X+1fadd.x %fp1,%fp1 # FP1 IS 2(X-1)#--LOG(X) = LOG(1+U/2)-LOG(1-U/2) WHICH IS AN ODD POLYNOMIAL#--IN U, U = 2(X-1)/(X+1) = FP1/FP0LP1CONT2:#--THIS IS AN RE-ENTRY POINT FOR LOGNP1fdiv.x %fp0,%fp1 # FP1 IS Ufmovm.x &0xc,-(%sp) # SAVE FP2-3#--REGISTERS SAVED ARE NOW FPCR,FP1,FP2,FP3#--LET V=U*U, W=V*V, CALCULATE#--U + U*V*(B1 + V*(B2 + V*(B3 + V*(B4 + V*B5)))) BY#--U + U*V*( [B1 + W*(B3 + W*B5)] + [V*(B2 + W*B4)] )fmov.x %fp1,%fp0fmul.x %fp0,%fp0 # FP0 IS Vfmov.x %fp1,SAVEU(%a6) # STORE U IN MEMORY, FREE FP1fmov.x %fp0,%fp1fmul.x %fp1,%fp1 # FP1 IS Wfmov.d LOGB5(%pc),%fp3fmov.d LOGB4(%pc),%fp2fmul.x %fp1,%fp3 # W*B5fmul.x %fp1,%fp2 # W*B4fadd.d LOGB3(%pc),%fp3 # B3+W*B5fadd.d LOGB2(%pc),%fp2 # B2+W*B4fmul.x %fp3,%fp1 # W*(B3+W*B5), FP3 RELEASEDfmul.x %fp0,%fp2 # V*(B2+W*B4)fadd.d LOGB1(%pc),%fp1 # B1+W*(B3+W*B5)fmul.x SAVEU(%a6),%fp0 # FP0 IS U*Vfadd.x %fp2,%fp1 # B1+W*(B3+W*B5) + V*(B2+W*B4), FP2 RELEASEDfmovm.x (%sp)+,&0x30 # FP2-3 RESTOREDfmul.x %fp1,%fp0 # U*V*( [B1+W*(B3+W*B5)] + [V*(B2+W*B4)] )fmov.l %d0,%fpcrfadd.x SAVEU(%a6),%fp0bra t_inx2#--REGISTERS SAVED FPCR. LOG(-VE) IS INVALIDLOGNEG:bra t_operrglobal slogndslognd:#--ENTRY POINT FOR LOG(X) FOR DENORMALIZED INPUTmov.l &-100,ADJK(%a6) # INPUT = 2^(ADJK) * FP0#----normalize the input value by left shifting k bits (k to be determined#----below), adjusting exponent and storing -k to ADJK#----the value TWOTO100 is no longer needed.#----Note that this code assumes the denormalized input is NON-ZERO.movm.l &0x3f00,-(%sp) # save some registers {d2-d7}mov.l (%a0),%d3 # D3 is exponent of smallest norm. #mov.l 4(%a0),%d4mov.l 8(%a0),%d5 # (D4,D5) is (Hi_X,Lo_X)clr.l %d2 # D2 used for holding Ktst.l %d4bne.b Hi_not0Hi_0:mov.l %d5,%d4clr.l %d5mov.l &32,%d2clr.l %d6bfffo %d4{&0:&32},%d6lsl.l %d6,%d4add.l %d6,%d2 # (D3,D4,D5) is normalizedmov.l %d3,X(%a6)mov.l %d4,XFRAC(%a6)mov.l %d5,XFRAC+4(%a6)neg.l %d2mov.l %d2,ADJK(%a6)fmov.x X(%a6),%fp0movm.l (%sp)+,&0xfc # restore registers {d2-d7}lea X(%a6),%a0bra.w LOGBGN # begin regular log(X)Hi_not0:clr.l %d6bfffo %d4{&0:&32},%d6 # find first 1mov.l %d6,%d2 # get klsl.l %d6,%d4mov.l %d5,%d7 # a copy of D5lsl.l %d6,%d5neg.l %d6add.l &32,%d6lsr.l %d6,%d7or.l %d7,%d4 # (D3,D4,D5) normalizedmov.l %d3,X(%a6)mov.l %d4,XFRAC(%a6)mov.l %d5,XFRAC+4(%a6)neg.l %d2mov.l %d2,ADJK(%a6)fmov.x X(%a6),%fp0movm.l (%sp)+,&0xfc # restore registers {d2-d7}lea X(%a6),%a0bra.w LOGBGN # begin regular log(X)global slognp1#--ENTRY POINT FOR LOG(1+X) FOR X FINITE, NON-ZERO, NOT NAN'Sslognp1:fmov.x (%a0),%fp0 # LOAD INPUTfabs.x %fp0 # test magnitudefcmp.x %fp0,LTHOLD(%pc) # compare with min thresholdfbgt.w LP1REAL # if greater, continuefmov.l %d0,%fpcrmov.b &FMOV_OP,%d1 # last inst is MOVEfmov.x (%a0),%fp0 # return signed argumentbra t_catchLP1REAL:fmov.x (%a0),%fp0 # LOAD INPUTmov.l &0x00000000,ADJK(%a6)fmov.x %fp0,%fp1 # FP1 IS INPUT Zfadd.s one(%pc),%fp0 # X := ROUND(1+Z)fmov.x %fp0,X(%a6)mov.w XFRAC(%a6),XDCARE(%a6)mov.l X(%a6),%d1cmp.l %d1,&0ble.w LP1NEG0 # LOG OF ZERO OR -VEcmp.l %d1,&0x3ffe8000 # IS BOUNDS [1/2,3/2]?blt.w LOGMAINcmp.l %d1,&0x3fffc000bgt.w LOGMAIN#--IF 1+Z > 3/2 OR 1+Z < 1/2, THEN X, WHICH IS ROUNDING 1+Z,#--CONTAINS AT LEAST 63 BITS OF INFORMATION OF Z. IN THAT CASE,#--SIMPLY INVOKE LOG(X) FOR LOG(1+Z).LP1NEAR1:#--NEXT SEE IF EXP(-1/16) < X < EXP(1/16)cmp.l %d1,&0x3ffef07dblt.w LP1CAREcmp.l %d1,&0x3fff8841bgt.w LP1CARELP1ONE16:#--EXP(-1/16) < X < EXP(1/16). LOG(1+Z) = LOG(1+U/2) - LOG(1-U/2)#--WHERE U = 2Z/(2+Z) = 2Z/(1+X).fadd.x %fp1,%fp1 # FP1 IS 2Zfadd.s one(%pc),%fp0 # FP0 IS 1+X#--U = FP1/FP0bra.w LP1CONT2LP1CARE:#--HERE WE USE THE USUAL TABLE DRIVEN APPROACH. CARE HAS TO BE#--TAKEN BECAUSE 1+Z CAN HAVE 67 BITS OF INFORMATION AND WE MUST#--PRESERVE ALL THE INFORMATION. BECAUSE 1+Z IS IN [1/2,3/2],#--THERE ARE ONLY TWO CASES.#--CASE 1: 1+Z < 1, THEN K = -1 AND Y-F = (2-F) + 2Z#--CASE 2: 1+Z > 1, THEN K = 0 AND Y-F = (1-F) + Z#--ON RETURNING TO LP1CONT1, WE MUST HAVE K IN FP1, ADDRESS OF#--(1/F) IN A0, Y-F IN FP0, AND FP2 SAVED.mov.l XFRAC(%a6),FFRAC(%a6)and.l &0xFE000000,FFRAC(%a6)or.l &0x01000000,FFRAC(%a6) # F OBTAINEDcmp.l %d1,&0x3FFF8000 # SEE IF 1+Z > 1bge.b KISZEROKISNEG1:fmov.s TWO(%pc),%fp0mov.l &0x3fff0000,F(%a6)clr.l F+8(%a6)fsub.x F(%a6),%fp0 # 2-Fmov.l FFRAC(%a6),%d1and.l &0x7E000000,%d1asr.l &8,%d1asr.l &8,%d1asr.l &4,%d1 # D0 CONTAINS DISPLACEMENT FOR 1/Ffadd.x %fp1,%fp1 # GET 2Zfmovm.x &0xc,-(%sp) # SAVE FP2 {%fp2/%fp3}fadd.x %fp1,%fp0 # FP0 IS Y-F = (2-F)+2Zlea LOGTBL(%pc),%a0 # A0 IS ADDRESS OF 1/Fadd.l %d1,%a0fmov.s negone(%pc),%fp1 # FP1 IS K = -1bra.w LP1CONT1KISZERO:fmov.s one(%pc),%fp0mov.l &0x3fff0000,F(%a6)clr.l F+8(%a6)fsub.x F(%a6),%fp0 # 1-Fmov.l FFRAC(%a6),%d1and.l &0x7E000000,%d1asr.l &8,%d1asr.l &8,%d1asr.l &4,%d1fadd.x %fp1,%fp0 # FP0 IS Y-Ffmovm.x &0xc,-(%sp) # FP2 SAVED {%fp2/%fp3}lea LOGTBL(%pc),%a0add.l %d1,%a0 # A0 IS ADDRESS OF 1/Ffmov.s zero(%pc),%fp1 # FP1 IS K = 0bra.w LP1CONT1LP1NEG0:#--FPCR SAVED. D0 IS X IN COMPACT FORM.cmp.l %d1,&0blt.b LP1NEGLP1ZERO:fmov.s negone(%pc),%fp0fmov.l %d0,%fpcrbra t_dzLP1NEG:fmov.s zero(%pc),%fp0fmov.l %d0,%fpcrbra t_operrglobal slognp1d#--ENTRY POINT FOR LOG(1+Z) FOR DENORMALIZED INPUT# Simply return the denormslognp1d:bra t_extdnrm########################################################################## satanh(): computes the inverse hyperbolic tangent of a norm input ## satanhd(): computes the inverse hyperbolic tangent of a denorm input ## ## INPUT *************************************************************** ## a0 = pointer to extended precision input ## d0 = round precision,mode ## ## OUTPUT ************************************************************** ## fp0 = arctanh(X) ## ## ACCURACY and MONOTONICITY ******************************************* ## The returned result is within 3 ulps in 64 significant bit, ## i.e. within 0.5001 ulp to 53 bits if the result is subsequently ## rounded to double precision. The result is provably monotonic ## in double precision. ## ## ALGORITHM *********************************************************** ## ## ATANH ## 1. If |X| >= 1, go to 3. ## ## 2. (|X| < 1) Calculate atanh(X) by ## sgn := sign(X) ## y := |X| ## z := 2y/(1-y) ## atanh(X) := sgn * (1/2) * logp1(z) ## Exit. ## ## 3. If |X| > 1, go to 5. ## ## 4. (|X| = 1) Generate infinity with an appropriate sign and ## divide-by-zero by ## sgn := sign(X) ## atan(X) := sgn / (+0). ## Exit. ## ## 5. (|X| > 1) Generate an invalid operation by 0 * infinity. ## Exit. ## ##########################################################################global satanhsatanh:mov.l (%a0),%d1mov.w 4(%a0),%d1and.l &0x7FFFFFFF,%d1cmp.l %d1,&0x3FFF8000bge.b ATANHBIG#--THIS IS THE USUAL CASE, |X| < 1#--Y = |X|, Z = 2Y/(1-Y), ATANH(X) = SIGN(X) * (1/2) * LOG1P(Z).fabs.x (%a0),%fp0 # Y = |X|fmov.x %fp0,%fp1fneg.x %fp1 # -Yfadd.x %fp0,%fp0 # 2Yfadd.s &0x3F800000,%fp1 # 1-Yfdiv.x %fp1,%fp0 # 2Y/(1-Y)mov.l (%a0),%d1and.l &0x80000000,%d1or.l &0x3F000000,%d1 # SIGN(X)*HALFmov.l %d1,-(%sp)mov.l %d0,-(%sp) # save rnd prec,modeclr.l %d0 # pass ext prec,RNfmovm.x &0x01,-(%sp) # save Z on stacklea (%sp),%a0 # pass ptr to Zbsr slognp1 # LOG1P(Z)add.l &0xc,%sp # clear Z from stackmov.l (%sp)+,%d0 # fetch old prec,modefmov.l %d0,%fpcr # load itmov.b &FMUL_OP,%d1 # last inst is MULfmul.s (%sp)+,%fp0bra t_catchATANHBIG:fabs.x (%a0),%fp0 # |X|fcmp.s %fp0,&0x3F800000fbgt t_operrbra t_dzglobal satanhd#--ATANH(X) = X FOR DENORMALIZED Xsatanhd:bra t_extdnrm########################################################################## slog10(): computes the base-10 logarithm of a normalized input ## slog10d(): computes the base-10 logarithm of a denormalized input ## slog2(): computes the base-2 logarithm of a normalized input ## slog2d(): computes the base-2 logarithm of a denormalized input ## ## INPUT *************************************************************** ## a0 = pointer to extended precision input ## d0 = round precision,mode ## ## OUTPUT ************************************************************** ## fp0 = log_10(X) or log_2(X) ## ## ACCURACY and MONOTONICITY ******************************************* ## The returned result is within 1.7 ulps in 64 significant bit, ## i.e. within 0.5003 ulp to 53 bits if the result is subsequently ## rounded to double precision. The result is provably monotonic ## in double precision. ## ## ALGORITHM *********************************************************** ## ## slog10d: ## ## Step 0. If X < 0, create a NaN and raise the invalid operation ## flag. Otherwise, save FPCR in D1; set FpCR to default. ## Notes: Default means round-to-nearest mode, no floating-point ## traps, and precision control = double extended. ## ## Step 1. Call slognd to obtain Y = log(X), the natural log of X. ## Notes: Even if X is denormalized, log(X) is always normalized. ## ## Step 2. Compute log_10(X) = log(X) * (1/log(10)). ## 2.1 Restore the user FPCR ## 2.2 Return ans := Y * INV_L10. ## ## slog10: ## ## Step 0. If X < 0, create a NaN and raise the invalid operation ## flag. Otherwise, save FPCR in D1; set FpCR to default. ## Notes: Default means round-to-nearest mode, no floating-point ## traps, and precision control = double extended. ## ## Step 1. Call sLogN to obtain Y = log(X), the natural log of X. ## ## Step 2. Compute log_10(X) = log(X) * (1/log(10)). ## 2.1 Restore the user FPCR ## 2.2 Return ans := Y * INV_L10. ## ## sLog2d: ## ## Step 0. If X < 0, create a NaN and raise the invalid operation ## flag. Otherwise, save FPCR in D1; set FpCR to default. ## Notes: Default means round-to-nearest mode, no floating-point ## traps, and precision control = double extended. ## ## Step 1. Call slognd to obtain Y = log(X), the natural log of X. ## Notes: Even if X is denormalized, log(X) is always normalized. ## ## Step 2. Compute log_10(X) = log(X) * (1/log(2)). ## 2.1 Restore the user FPCR ## 2.2 Return ans := Y * INV_L2. ## ## sLog2: ## ## Step 0. If X < 0, create a NaN and raise the invalid operation ## flag. Otherwise, save FPCR in D1; set FpCR to default. ## Notes: Default means round-to-nearest mode, no floating-point ## traps, and precision control = double extended. ## ## Step 1. If X is not an integer power of two, i.e., X != 2^k, ## go to Step 3. ## ## Step 2. Return k. ## 2.1 Get integer k, X = 2^k. ## 2.2 Restore the user FPCR. ## 2.3 Return ans := convert-to-double-extended(k). ## ## Step 3. Call sLogN to obtain Y = log(X), the natural log of X. ## ## Step 4. Compute log_2(X) = log(X) * (1/log(2)). ## 4.1 Restore the user FPCR ## 4.2 Return ans := Y * INV_L2. ## ##########################################################################INV_L10:long 0x3FFD0000,0xDE5BD8A9,0x37287195,0x00000000INV_L2:long 0x3FFF0000,0xB8AA3B29,0x5C17F0BC,0x00000000global slog10#--entry point for Log10(X), X is normalizedslog10:fmov.b &0x1,%fp0fcmp.x %fp0,(%a0) # if operand == 1,fbeq.l ld_pzero # return an EXACT zeromov.l (%a0),%d1blt.w invalidmov.l %d0,-(%sp)clr.l %d0bsr slogn # log(X), X normal.fmov.l (%sp)+,%fpcrfmul.x INV_L10(%pc),%fp0bra t_inx2global slog10d#--entry point for Log10(X), X is denormalizedslog10d:mov.l (%a0),%d1blt.w invalidmov.l %d0,-(%sp)clr.l %d0bsr slognd # log(X), X denorm.fmov.l (%sp)+,%fpcrfmul.x INV_L10(%pc),%fp0bra t_minx2global slog2#--entry point for Log2(X), X is normalizedslog2:mov.l (%a0),%d1blt.w invalidmov.l 8(%a0),%d1bne.b continue # X is not 2^kmov.l 4(%a0),%d1and.l &0x7FFFFFFF,%d1bne.b continue#--X = 2^k.mov.w (%a0),%d1and.l &0x00007FFF,%d1sub.l &0x3FFF,%d1beq.l ld_pzerofmov.l %d0,%fpcrfmov.l %d1,%fp0bra t_inx2continue:mov.l %d0,-(%sp)clr.l %d0bsr slogn # log(X), X normal.fmov.l (%sp)+,%fpcrfmul.x INV_L2(%pc),%fp0bra t_inx2invalid:bra t_operrglobal slog2d#--entry point for Log2(X), X is denormalizedslog2d:mov.l (%a0),%d1blt.w invalidmov.l %d0,-(%sp)clr.l %d0bsr slognd # log(X), X denorm.fmov.l (%sp)+,%fpcrfmul.x INV_L2(%pc),%fp0bra t_minx2########################################################################## stwotox(): computes 2**X for a normalized input ## stwotoxd(): computes 2**X for a denormalized input ## stentox(): computes 10**X for a normalized input ## stentoxd(): computes 10**X for a denormalized input ## ## INPUT *************************************************************** ## a0 = pointer to extended precision input ## d0 = round precision,mode ## ## OUTPUT ************************************************************** ## fp0 = 2**X or 10**X ## ## ACCURACY and MONOTONICITY ******************************************* ## The returned result is within 2 ulps in 64 significant bit, ## i.e. within 0.5001 ulp to 53 bits if the result is subsequently ## rounded to double precision. The result is provably monotonic ## in double precision. ## ## ALGORITHM *********************************************************** ## ## twotox ## 1. If |X| > 16480, go to ExpBig. ## ## 2. If |X| < 2**(-70), go to ExpSm. ## ## 3. Decompose X as X = N/64 + r where |r| <= 1/128. Furthermore ## decompose N as ## N = 64(M + M') + j, j = 0,1,2,...,63. ## ## 4. Overwrite r := r * log2. Then ## 2**X = 2**(M') * 2**(M) * 2**(j/64) * exp(r). ## Go to expr to compute that expression. ## ## tentox ## 1. If |X| > 16480*log_10(2) (base 10 log of 2), go to ExpBig. ## ## 2. If |X| < 2**(-70), go to ExpSm. ## ## 3. Set y := X*log_2(10)*64 (base 2 log of 10). Set ## N := round-to-int(y). Decompose N as ## N = 64(M + M') + j, j = 0,1,2,...,63. ## ## 4. Define r as ## r := ((X - N*L1)-N*L2) * L10 ## where L1, L2 are the leading and trailing parts of ## log_10(2)/64 and L10 is the natural log of 10. Then ## 10**X = 2**(M') * 2**(M) * 2**(j/64) * exp(r). ## Go to expr to compute that expression. ## ## expr ## 1. Fetch 2**(j/64) from table as Fact1 and Fact2. ## ## 2. Overwrite Fact1 and Fact2 by ## Fact1 := 2**(M) * Fact1 ## Fact2 := 2**(M) * Fact2 ## Thus Fact1 + Fact2 = 2**(M) * 2**(j/64). ## ## 3. Calculate P where 1 + P approximates exp(r): ## P = r + r*r*(A1+r*(A2+...+r*A5)). ## ## 4. Let AdjFact := 2**(M'). Return ## AdjFact * ( Fact1 + ((Fact1*P) + Fact2) ). ## Exit. ## ## ExpBig ## 1. Generate overflow by Huge * Huge if X > 0; otherwise, ## generate underflow by Tiny * Tiny. ## ## ExpSm ## 1. Return 1 + X. ## ##########################################################################L2TEN64:long 0x406A934F,0x0979A371 # 64LOG10/LOG2L10TWO1:long 0x3F734413,0x509F8000 # LOG2/64LOG10L10TWO2:long 0xBFCD0000,0xC0219DC1,0xDA994FD2,0x00000000LOG10: long 0x40000000,0x935D8DDD,0xAAA8AC17,0x00000000LOG2: long 0x3FFE0000,0xB17217F7,0xD1CF79AC,0x00000000EXPA5: long 0x3F56C16D,0x6F7BD0B2EXPA4: long 0x3F811112,0x302C712CEXPA3: long 0x3FA55555,0x55554CC1EXPA2: long 0x3FC55555,0x55554A54EXPA1: long 0x3FE00000,0x00000000,0x00000000,0x00000000TEXPTBL:long 0x3FFF0000,0x80000000,0x00000000,0x3F738000long 0x3FFF0000,0x8164D1F3,0xBC030773,0x3FBEF7CAlong 0x3FFF0000,0x82CD8698,0xAC2BA1D7,0x3FBDF8A9long 0x3FFF0000,0x843A28C3,0xACDE4046,0x3FBCD7C9long 0x3FFF0000,0x85AAC367,0xCC487B15,0xBFBDE8DAlong 0x3FFF0000,0x871F6196,0x9E8D1010,0x3FBDE85Clong 0x3FFF0000,0x88980E80,0x92DA8527,0x3FBEBBF1long 0x3FFF0000,0x8A14D575,0x496EFD9A,0x3FBB80CAlong 0x3FFF0000,0x8B95C1E3,0xEA8BD6E7,0xBFBA8373long 0x3FFF0000,0x8D1ADF5B,0x7E5BA9E6,0xBFBE9670long 0x3FFF0000,0x8EA4398B,0x45CD53C0,0x3FBDB700long 0x3FFF0000,0x9031DC43,0x1466B1DC,0x3FBEEEB0long 0x3FFF0000,0x91C3D373,0xAB11C336,0x3FBBFD6Dlong 0x3FFF0000,0x935A2B2F,0x13E6E92C,0xBFBDB319long 0x3FFF0000,0x94F4EFA8,0xFEF70961,0x3FBDBA2Blong 0x3FFF0000,0x96942D37,0x20185A00,0x3FBE91D5long 0x3FFF0000,0x9837F051,0x8DB8A96F,0x3FBE8D5Along 0x3FFF0000,0x99E04593,0x20B7FA65,0xBFBCDE7Blong 0x3FFF0000,0x9B8D39B9,0xD54E5539,0xBFBEBAAFlong 0x3FFF0000,0x9D3ED9A7,0x2CFFB751,0xBFBD86DAlong 0x3FFF0000,0x9EF53260,0x91A111AE,0xBFBEBEDDlong 0x3FFF0000,0xA0B0510F,0xB9714FC2,0x3FBCC96Elong 0x3FFF0000,0xA2704303,0x0C496819,0xBFBEC90Blong 0x3FFF0000,0xA43515AE,0x09E6809E,0x3FBBD1DBlong 0x3FFF0000,0xA5FED6A9,0xB15138EA,0x3FBCE5EBlong 0x3FFF0000,0xA7CD93B4,0xE965356A,0xBFBEC274long 0x3FFF0000,0xA9A15AB4,0xEA7C0EF8,0x3FBEA83Clong 0x3FFF0000,0xAB7A39B5,0xA93ED337,0x3FBECB00long 0x3FFF0000,0xAD583EEA,0x42A14AC6,0x3FBE9301long 0x3FFF0000,0xAF3B78AD,0x690A4375,0xBFBD8367long 0x3FFF0000,0xB123F581,0xD2AC2590,0xBFBEF05Flong 0x3FFF0000,0xB311C412,0xA9112489,0x3FBDFB3Clong 0x3FFF0000,0xB504F333,0xF9DE6484,0x3FBEB2FBlong 0x3FFF0000,0xB6FD91E3,0x28D17791,0x3FBAE2CBlong 0x3FFF0000,0xB8FBAF47,0x62FB9EE9,0x3FBCDC3Clong 0x3FFF0000,0xBAFF5AB2,0x133E45FB,0x3FBEE9AAlong 0x3FFF0000,0xBD08A39F,0x580C36BF,0xBFBEAEFDlong 0x3FFF0000,0xBF1799B6,0x7A731083,0xBFBCBF51long 0x3FFF0000,0xC12C4CCA,0x66709456,0x3FBEF88Along 0x3FFF0000,0xC346CCDA,0x24976407,0x3FBD83B2long 0x3FFF0000,0xC5672A11,0x5506DADD,0x3FBDF8ABlong 0x3FFF0000,0xC78D74C8,0xABB9B15D,0xBFBDFB17long 0x3FFF0000,0xC9B9BD86,0x6E2F27A3,0xBFBEFE3Clong 0x3FFF0000,0xCBEC14FE,0xF2727C5D,0xBFBBB6F8long 0x3FFF0000,0xCE248C15,0x1F8480E4,0xBFBCEE53long 0x3FFF0000,0xD06333DA,0xEF2B2595,0xBFBDA4AElong 0x3FFF0000,0xD2A81D91,0xF12AE45A,0x3FBC9124long 0x3FFF0000,0xD4F35AAB,0xCFEDFA1F,0x3FBEB243long 0x3FFF0000,0xD744FCCA,0xD69D6AF4,0x3FBDE69Along 0x3FFF0000,0xD99D15C2,0x78AFD7B6,0xBFB8BC61long 0x3FFF0000,0xDBFBB797,0xDAF23755,0x3FBDF610long 0x3FFF0000,0xDE60F482,0x5E0E9124,0xBFBD8BE1long 0x3FFF0000,0xE0CCDEEC,0x2A94E111,0x3FBACB12long 0x3FFF0000,0xE33F8972,0xBE8A5A51,0x3FBB9BFElong 0x3FFF0000,0xE5B906E7,0x7C8348A8,0x3FBCF2F4long 0x3FFF0000,0xE8396A50,0x3C4BDC68,0x3FBEF22Flong 0x3FFF0000,0xEAC0C6E7,0xDD24392F,0xBFBDBF4Along 0x3FFF0000,0xED4F301E,0xD9942B84,0x3FBEC01Along 0x3FFF0000,0xEFE4B99B,0xDCDAF5CB,0x3FBE8CAClong 0x3FFF0000,0xF281773C,0x59FFB13A,0xBFBCBB3Flong 0x3FFF0000,0xF5257D15,0x2486CC2C,0x3FBEF73Along 0x3FFF0000,0xF7D0DF73,0x0AD13BB9,0xBFB8B795long 0x3FFF0000,0xFA83B2DB,0x722A033A,0x3FBEF84Blong 0x3FFF0000,0xFD3E0C0C,0xF486C175,0xBFBEF581set INT,L_SCR1set X,FP_SCR0set XDCARE,X+2set XFRAC,X+4set ADJFACT,FP_SCR0set FACT1,FP_SCR0set FACT1HI,FACT1+4set FACT1LOW,FACT1+8set FACT2,FP_SCR1set FACT2HI,FACT2+4set FACT2LOW,FACT2+8global stwotox#--ENTRY POINT FOR 2**(X), HERE X IS FINITE, NON-ZERO, AND NOT NAN'Sstwotox:fmovm.x (%a0),&0x80 # LOAD INPUTmov.l (%a0),%d1mov.w 4(%a0),%d1fmov.x %fp0,X(%a6)and.l &0x7FFFFFFF,%d1cmp.l %d1,&0x3FB98000 # |X| >= 2**(-70)?bge.b TWOOK1bra.w EXPBORSTWOOK1:cmp.l %d1,&0x400D80C0 # |X| > 16480?ble.b TWOMAINbra.w EXPBORSTWOMAIN:#--USUAL CASE, 2^(-70) <= |X| <= 16480fmov.x %fp0,%fp1fmul.s &0x42800000,%fp1 # 64 * Xfmov.l %fp1,INT(%a6) # N = ROUND-TO-INT(64 X)mov.l %d2,-(%sp)lea TEXPTBL(%pc),%a1 # LOAD ADDRESS OF TABLE OF 2^(J/64)fmov.l INT(%a6),%fp1 # N --> FLOATING FMTmov.l INT(%a6),%d1mov.l %d1,%d2and.l &0x3F,%d1 # D0 IS Jasl.l &4,%d1 # DISPLACEMENT FOR 2^(J/64)add.l %d1,%a1 # ADDRESS FOR 2^(J/64)asr.l &6,%d2 # d2 IS L, N = 64L + Jmov.l %d2,%d1asr.l &1,%d1 # D0 IS Msub.l %d1,%d2 # d2 IS M', N = 64(M+M') + Jadd.l &0x3FFF,%d2#--SUMMARY: a1 IS ADDRESS FOR THE LEADING PORTION OF 2^(J/64),#--D0 IS M WHERE N = 64(M+M') + J. NOTE THAT |M| <= 16140 BY DESIGN.#--ADJFACT = 2^(M').#--REGISTERS SAVED SO FAR ARE (IN ORDER) FPCR, D0, FP1, a1, AND FP2.fmovm.x &0x0c,-(%sp) # save fp2/fp3fmul.s &0x3C800000,%fp1 # (1/64)*Nmov.l (%a1)+,FACT1(%a6)mov.l (%a1)+,FACT1HI(%a6)mov.l (%a1)+,FACT1LOW(%a6)mov.w (%a1)+,FACT2(%a6)fsub.x %fp1,%fp0 # X - (1/64)*INT(64 X)mov.w (%a1)+,FACT2HI(%a6)clr.w FACT2HI+2(%a6)clr.l FACT2LOW(%a6)add.w %d1,FACT1(%a6)fmul.x LOG2(%pc),%fp0 # FP0 IS Radd.w %d1,FACT2(%a6)bra.w exprEXPBORS:#--FPCR, D0 SAVEDcmp.l %d1,&0x3FFF8000bgt.b TEXPBIG#--|X| IS SMALL, RETURN 1 + Xfmov.l %d0,%fpcr # restore users round prec,modefadd.s &0x3F800000,%fp0 # RETURN 1 + Xbra t_pinx2TEXPBIG:#--|X| IS LARGE, GENERATE OVERFLOW IF X > 0; ELSE GENERATE UNDERFLOW#--REGISTERS SAVE SO FAR ARE FPCR AND D0mov.l X(%a6),%d1cmp.l %d1,&0blt.b EXPNEGbra t_ovfl2 # t_ovfl expects positive valueEXPNEG:bra t_unfl2 # t_unfl expects positive valueglobal stwotoxdstwotoxd:#--ENTRY POINT FOR 2**(X) FOR DENORMALIZED ARGUMENTfmov.l %d0,%fpcr # set user's rounding mode/precisionfmov.s &0x3F800000,%fp0 # RETURN 1 + Xmov.l (%a0),%d1or.l &0x00800001,%d1fadd.s %d1,%fp0bra t_pinx2global stentox#--ENTRY POINT FOR 10**(X), HERE X IS FINITE, NON-ZERO, AND NOT NAN'Sstentox:fmovm.x (%a0),&0x80 # LOAD INPUTmov.l (%a0),%d1mov.w 4(%a0),%d1fmov.x %fp0,X(%a6)and.l &0x7FFFFFFF,%d1cmp.l %d1,&0x3FB98000 # |X| >= 2**(-70)?bge.b TENOK1bra.w EXPBORSTENOK1:cmp.l %d1,&0x400B9B07 # |X| <= 16480*log2/log10 ?ble.b TENMAINbra.w EXPBORSTENMAIN:#--USUAL CASE, 2^(-70) <= |X| <= 16480 LOG 2 / LOG 10fmov.x %fp0,%fp1fmul.d L2TEN64(%pc),%fp1 # X*64*LOG10/LOG2fmov.l %fp1,INT(%a6) # N=INT(X*64*LOG10/LOG2)mov.l %d2,-(%sp)lea TEXPTBL(%pc),%a1 # LOAD ADDRESS OF TABLE OF 2^(J/64)fmov.l INT(%a6),%fp1 # N --> FLOATING FMTmov.l INT(%a6),%d1mov.l %d1,%d2and.l &0x3F,%d1 # D0 IS Jasl.l &4,%d1 # DISPLACEMENT FOR 2^(J/64)add.l %d1,%a1 # ADDRESS FOR 2^(J/64)asr.l &6,%d2 # d2 IS L, N = 64L + Jmov.l %d2,%d1asr.l &1,%d1 # D0 IS Msub.l %d1,%d2 # d2 IS M', N = 64(M+M') + Jadd.l &0x3FFF,%d2#--SUMMARY: a1 IS ADDRESS FOR THE LEADING PORTION OF 2^(J/64),#--D0 IS M WHERE N = 64(M+M') + J. NOTE THAT |M| <= 16140 BY DESIGN.#--ADJFACT = 2^(M').#--REGISTERS SAVED SO FAR ARE (IN ORDER) FPCR, D0, FP1, a1, AND FP2.fmovm.x &0x0c,-(%sp) # save fp2/fp3fmov.x %fp1,%fp2fmul.d L10TWO1(%pc),%fp1 # N*(LOG2/64LOG10)_LEADmov.l (%a1)+,FACT1(%a6)fmul.x L10TWO2(%pc),%fp2 # N*(LOG2/64LOG10)_TRAILmov.l (%a1)+,FACT1HI(%a6)mov.l (%a1)+,FACT1LOW(%a6)fsub.x %fp1,%fp0 # X - N L_LEADmov.w (%a1)+,FACT2(%a6)fsub.x %fp2,%fp0 # X - N L_TRAILmov.w (%a1)+,FACT2HI(%a6)clr.w FACT2HI+2(%a6)clr.l FACT2LOW(%a6)fmul.x LOG10(%pc),%fp0 # FP0 IS Radd.w %d1,FACT1(%a6)add.w %d1,FACT2(%a6)expr:#--FPCR, FP2, FP3 ARE SAVED IN ORDER AS SHOWN.#--ADJFACT CONTAINS 2**(M'), FACT1 + FACT2 = 2**(M) * 2**(J/64).#--FP0 IS R. THE FOLLOWING CODE COMPUTES#-- 2**(M'+M) * 2**(J/64) * EXP(R)fmov.x %fp0,%fp1fmul.x %fp1,%fp1 # FP1 IS S = R*Rfmov.d EXPA5(%pc),%fp2 # FP2 IS A5fmov.d EXPA4(%pc),%fp3 # FP3 IS A4fmul.x %fp1,%fp2 # FP2 IS S*A5fmul.x %fp1,%fp3 # FP3 IS S*A4fadd.d EXPA3(%pc),%fp2 # FP2 IS A3+S*A5fadd.d EXPA2(%pc),%fp3 # FP3 IS A2+S*A4fmul.x %fp1,%fp2 # FP2 IS S*(A3+S*A5)fmul.x %fp1,%fp3 # FP3 IS S*(A2+S*A4)fadd.d EXPA1(%pc),%fp2 # FP2 IS A1+S*(A3+S*A5)fmul.x %fp0,%fp3 # FP3 IS R*S*(A2+S*A4)fmul.x %fp1,%fp2 # FP2 IS S*(A1+S*(A3+S*A5))fadd.x %fp3,%fp0 # FP0 IS R+R*S*(A2+S*A4)fadd.x %fp2,%fp0 # FP0 IS EXP(R) - 1fmovm.x (%sp)+,&0x30 # restore fp2/fp3#--FINAL RECONSTRUCTION PROCESS#--EXP(X) = 2^M*2^(J/64) + 2^M*2^(J/64)*(EXP(R)-1) - (1 OR 0)fmul.x FACT1(%a6),%fp0fadd.x FACT2(%a6),%fp0fadd.x FACT1(%a6),%fp0fmov.l %d0,%fpcr # restore users round prec,modemov.w %d2,ADJFACT(%a6) # INSERT EXPONENTmov.l (%sp)+,%d2mov.l &0x80000000,ADJFACT+4(%a6)clr.l ADJFACT+8(%a6)mov.b &FMUL_OP,%d1 # last inst is MULfmul.x ADJFACT(%a6),%fp0 # FINAL ADJUSTMENTbra t_catchglobal stentoxdstentoxd:#--ENTRY POINT FOR 10**(X) FOR DENORMALIZED ARGUMENTfmov.l %d0,%fpcr # set user's rounding mode/precisionfmov.s &0x3F800000,%fp0 # RETURN 1 + Xmov.l (%a0),%d1or.l &0x00800001,%d1fadd.s %d1,%fp0bra t_pinx2########################################################################## sscale(): computes the destination operand scaled by the source ## operand. If the absoulute value of the source operand is ## >= 2^14, an overflow or underflow is returned. ## ## INPUT *************************************************************** ## a0 = pointer to double-extended source operand X ## a1 = pointer to double-extended destination operand Y ## ## OUTPUT ************************************************************** ## fp0 = scale(X,Y) ## ##########################################################################set SIGN, L_SCR1global sscalesscale:mov.l %d0,-(%sp) # store off ctrl bits for nowmov.w DST_EX(%a1),%d1 # get dst exponentsmi.b SIGN(%a6) # use SIGN to hold dst signandi.l &0x00007fff,%d1 # strip sign from dst expmov.w SRC_EX(%a0),%d0 # check src boundsandi.w &0x7fff,%d0 # clr src sign bitcmpi.w %d0,&0x3fff # is src ~ ZERO?blt.w src_small # yescmpi.w %d0,&0x400c # no; is src too big?bgt.w src_out # yes## Source is within 2^14 range.#src_ok:fintrz.x SRC(%a0),%fp0 # calc int of srcfmov.l %fp0,%d0 # int src to d0# don't want any accrued bits from the fintrz showing up later since# we may need to read the fpsr for the last fp op in t_catch2().fmov.l &0x0,%fpsrtst.b DST_HI(%a1) # is dst denormalized?bmi.b sok_norm# the dst is a DENORM. normalize the DENORM and add the adjustment to# the src value. then, jump to the norm part of the routine.sok_dnrm:mov.l %d0,-(%sp) # save src for nowmov.w DST_EX(%a1),FP_SCR0_EX(%a6) # make a copymov.l DST_HI(%a1),FP_SCR0_HI(%a6)mov.l DST_LO(%a1),FP_SCR0_LO(%a6)lea FP_SCR0(%a6),%a0 # pass ptr to DENORMbsr.l norm # normalize the DENORMneg.l %d0add.l (%sp)+,%d0 # add adjustment to srcfmovm.x FP_SCR0(%a6),&0x80 # load normalized DENORMcmpi.w %d0,&-0x3fff # is the shft amt really low?bge.b sok_norm2 # thank goodness no# the multiply factor that we're trying to create should be a denorm# for the multiply to work. therefore, we're going to actually do a# multiply with a denorm which will cause an unimplemented data type# exception to be put into the machine which will be caught and corrected# later. we don't do this with the DENORMs above because this method# is slower. but, don't fret, I don't see it being used much either.fmov.l (%sp)+,%fpcr # restore user fpcrmov.l &0x80000000,%d1 # load normalized mantissasubi.l &-0x3fff,%d0 # how many should we shift?neg.l %d0 # make it positivecmpi.b %d0,&0x20 # is it > 32?bge.b sok_dnrm_32 # yeslsr.l %d0,%d1 # no; bit stays in upper lwclr.l -(%sp) # insert zero low mantissamov.l %d1,-(%sp) # insert new high mantissaclr.l -(%sp) # make zero exponentbra.b sok_norm_contsok_dnrm_32:subi.b &0x20,%d0 # get shift countlsr.l %d0,%d1 # make low mantissa longwordmov.l %d1,-(%sp) # insert new low mantissaclr.l -(%sp) # insert zero high mantissaclr.l -(%sp) # make zero exponentbra.b sok_norm_cont# the src will force the dst to a DENORM value or worse. so, let's# create an fp multiply that will create the result.sok_norm:fmovm.x DST(%a1),&0x80 # load fp0 with normalized srcsok_norm2:fmov.l (%sp)+,%fpcr # restore user fpcraddi.w &0x3fff,%d0 # turn src amt into exp valueswap %d0 # put exponent in high wordclr.l -(%sp) # insert new exponentmov.l &0x80000000,-(%sp) # insert new high mantissamov.l %d0,-(%sp) # insert new lo mantissasok_norm_cont:fmov.l %fpcr,%d0 # d0 needs fpcr for t_catch2mov.b &FMUL_OP,%d1 # last inst is MULfmul.x (%sp)+,%fp0 # do the multiplybra t_catch2 # catch any exceptions## Source is outside of 2^14 range. Test the sign and branch# to the appropriate exception handler.#src_out:mov.l (%sp)+,%d0 # restore ctrl bitsexg %a0,%a1 # swap src,dst ptrstst.b SRC_EX(%a1) # is src negative?bmi t_unfl # yes; underflowbra t_ovfl_sc # no; overflow## The source input is below 1, so we check for denormalized numbers# and set unfl.#src_small:tst.b DST_HI(%a1) # is dst denormalized?bpl.b ssmall_done # yesmov.l (%sp)+,%d0fmov.l %d0,%fpcr # no; load control bitsmov.b &FMOV_OP,%d1 # last inst is MOVEfmov.x DST(%a1),%fp0 # simply return destbra t_catch2ssmall_done:mov.l (%sp)+,%d0 # load control bits into d1mov.l %a1,%a0 # pass ptr to dstbra t_resdnrm########################################################################## smod(): computes the fp MOD of the input values X,Y. ## srem(): computes the fp (IEEE) REM of the input values X,Y. ## ## INPUT *************************************************************** ## a0 = pointer to extended precision input X ## a1 = pointer to extended precision input Y ## d0 = round precision,mode ## ## The input operands X and Y can be either normalized or ## denormalized. ## ## OUTPUT ************************************************************** ## fp0 = FREM(X,Y) or FMOD(X,Y) ## ## ALGORITHM *********************************************************** ## ## Step 1. Save and strip signs of X and Y: signX := sign(X), ## signY := sign(Y), X := |X|, Y := |Y|, ## signQ := signX EOR signY. Record whether MOD or REM ## is requested. ## ## Step 2. Set L := expo(X)-expo(Y), k := 0, Q := 0. ## If (L < 0) then ## R := X, go to Step 4. ## else ## R := 2^(-L)X, j := L. ## endif ## ## Step 3. Perform MOD(X,Y) ## 3.1 If R = Y, go to Step 9. ## 3.2 If R > Y, then { R := R - Y, Q := Q + 1} ## 3.3 If j = 0, go to Step 4. ## 3.4 k := k + 1, j := j - 1, Q := 2Q, R := 2R. Go to ## Step 3.1. ## ## Step 4. At this point, R = X - QY = MOD(X,Y). Set ## Last_Subtract := false (used in Step 7 below). If ## MOD is requested, go to Step 6. ## ## Step 5. R = MOD(X,Y), but REM(X,Y) is requested. ## 5.1 If R < Y/2, then R = MOD(X,Y) = REM(X,Y). Go to ## Step 6. ## 5.2 If R > Y/2, then { set Last_Subtract := true, ## Q := Q + 1, Y := signY*Y }. Go to Step 6. ## 5.3 This is the tricky case of R = Y/2. If Q is odd, ## then { Q := Q + 1, signX := -signX }. ## ## Step 6. R := signX*R. ## ## Step 7. If Last_Subtract = true, R := R - Y. ## ## Step 8. Return signQ, last 7 bits of Q, and R as required. ## ## Step 9. At this point, R = 2^(-j)*X - Q Y = Y. Thus, ## X = 2^(j)*(Q+1)Y. set Q := 2^(j)*(Q+1), ## R := 0. Return signQ, last 7 bits of Q, and R. ## ##########################################################################set Mod_Flag,L_SCR3set Sc_Flag,L_SCR3+1set SignY,L_SCR2set SignX,L_SCR2+2set SignQ,L_SCR3+2set Y,FP_SCR0set Y_Hi,Y+4set Y_Lo,Y+8set R,FP_SCR1set R_Hi,R+4set R_Lo,R+8Scale:long 0x00010000,0x80000000,0x00000000,0x00000000global smodsmod:clr.b FPSR_QBYTE(%a6)mov.l %d0,-(%sp) # save ctrl bitsclr.b Mod_Flag(%a6)bra.b Mod_Remglobal sremsrem:clr.b FPSR_QBYTE(%a6)mov.l %d0,-(%sp) # save ctrl bitsmov.b &0x1,Mod_Flag(%a6)Mod_Rem:#..Save sign of X and Ymovm.l &0x3f00,-(%sp) # save data registersmov.w SRC_EX(%a0),%d3mov.w %d3,SignY(%a6)and.l &0x00007FFF,%d3 # Y := |Y|#mov.l SRC_HI(%a0),%d4mov.l SRC_LO(%a0),%d5 # (D3,D4,D5) is |Y|tst.l %d3bne.b Y_Normalmov.l &0x00003FFE,%d3 # $3FFD + 1tst.l %d4bne.b HiY_not0HiY_0:mov.l %d5,%d4clr.l %d5sub.l &32,%d3clr.l %d6bfffo %d4{&0:&32},%d6lsl.l %d6,%d4sub.l %d6,%d3 # (D3,D4,D5) is normalized# ...with bias $7FFDbra.b Chk_XHiY_not0:clr.l %d6bfffo %d4{&0:&32},%d6sub.l %d6,%d3lsl.l %d6,%d4mov.l %d5,%d7 # a copy of D5lsl.l %d6,%d5neg.l %d6add.l &32,%d6lsr.l %d6,%d7or.l %d7,%d4 # (D3,D4,D5) normalized# ...with bias $7FFDbra.b Chk_XY_Normal:add.l &0x00003FFE,%d3 # (D3,D4,D5) normalized# ...with bias $7FFDChk_X:mov.w DST_EX(%a1),%d0mov.w %d0,SignX(%a6)mov.w SignY(%a6),%d1eor.l %d0,%d1and.l &0x00008000,%d1mov.w %d1,SignQ(%a6) # sign(Q) obtainedand.l &0x00007FFF,%d0mov.l DST_HI(%a1),%d1mov.l DST_LO(%a1),%d2 # (D0,D1,D2) is |X|tst.l %d0bne.b X_Normalmov.l &0x00003FFE,%d0tst.l %d1bne.b HiX_not0HiX_0:mov.l %d2,%d1clr.l %d2sub.l &32,%d0clr.l %d6bfffo %d1{&0:&32},%d6lsl.l %d6,%d1sub.l %d6,%d0 # (D0,D1,D2) is normalized# ...with bias $7FFDbra.b InitHiX_not0:clr.l %d6bfffo %d1{&0:&32},%d6sub.l %d6,%d0lsl.l %d6,%d1mov.l %d2,%d7 # a copy of D2lsl.l %d6,%d2neg.l %d6add.l &32,%d6lsr.l %d6,%d7or.l %d7,%d1 # (D0,D1,D2) normalized# ...with bias $7FFDbra.b InitX_Normal:add.l &0x00003FFE,%d0 # (D0,D1,D2) normalized# ...with bias $7FFDInit:#mov.l %d3,L_SCR1(%a6) # save biased exp(Y)mov.l %d0,-(%sp) # save biased exp(X)sub.l %d3,%d0 # L := expo(X)-expo(Y)clr.l %d6 # D6 := carry <- 0clr.l %d3 # D3 is Qmov.l &0,%a1 # A1 is k; j+k=L, Q=0#..(Carry,D1,D2) is Rtst.l %d0bge.b Mod_Loop_pre#..expo(X) < expo(Y). Thus X = mod(X,Y)#mov.l (%sp)+,%d0 # restore d0bra.w Get_ModMod_Loop_pre:addq.l &0x4,%sp # erase exp(X)#..At this point R = 2^(-L)X; Q = 0; k = 0; and k+j = LMod_Loop:tst.l %d6 # test carry bitbgt.b R_GT_Y#..At this point carry = 0, R = (D1,D2), Y = (D4,D5)cmp.l %d1,%d4 # compare hi(R) and hi(Y)bne.b R_NE_Ycmp.l %d2,%d5 # compare lo(R) and lo(Y)bne.b R_NE_Y#..At this point, R = Ybra.w Rem_is_0R_NE_Y:#..use the borrow of the previous comparebcs.b R_LT_Y # borrow is set iff R < YR_GT_Y:#..If Carry is set, then Y < (Carry,D1,D2) < 2Y. Otherwise, Carry = 0#..and Y < (D1,D2) < 2Y. Either way, perform R - Ysub.l %d5,%d2 # lo(R) - lo(Y)subx.l %d4,%d1 # hi(R) - hi(Y)clr.l %d6 # clear carryaddq.l &1,%d3 # Q := Q + 1R_LT_Y:#..At this point, Carry=0, R < Y. R = 2^(k-L)X - QY; k+j = L; j >= 0.tst.l %d0 # see if j = 0.beq.b PostLoopadd.l %d3,%d3 # Q := 2Qadd.l %d2,%d2 # lo(R) = 2lo(R)roxl.l &1,%d1 # hi(R) = 2hi(R) + carryscs %d6 # set Carry if 2(R) overflowsaddq.l &1,%a1 # k := k+1subq.l &1,%d0 # j := j - 1#..At this point, R=(Carry,D1,D2) = 2^(k-L)X - QY, j+k=L, j >= 0, R < 2Y.bra.b Mod_LoopPostLoop:#..k = L, j = 0, Carry = 0, R = (D1,D2) = X - QY, R < Y.#..normalize R.mov.l L_SCR1(%a6),%d0 # new biased expo of Rtst.l %d1bne.b HiR_not0HiR_0:mov.l %d2,%d1clr.l %d2sub.l &32,%d0clr.l %d6bfffo %d1{&0:&32},%d6lsl.l %d6,%d1sub.l %d6,%d0 # (D0,D1,D2) is normalized# ...with bias $7FFDbra.b Get_ModHiR_not0:clr.l %d6bfffo %d1{&0:&32},%d6bmi.b Get_Mod # already normalizedsub.l %d6,%d0lsl.l %d6,%d1mov.l %d2,%d7 # a copy of D2lsl.l %d6,%d2neg.l %d6add.l &32,%d6lsr.l %d6,%d7or.l %d7,%d1 # (D0,D1,D2) normalized#Get_Mod:cmp.l %d0,&0x000041FEbge.b No_ScaleDo_Scale:mov.w %d0,R(%a6)mov.l %d1,R_Hi(%a6)mov.l %d2,R_Lo(%a6)mov.l L_SCR1(%a6),%d6mov.w %d6,Y(%a6)mov.l %d4,Y_Hi(%a6)mov.l %d5,Y_Lo(%a6)fmov.x R(%a6),%fp0 # no exceptionmov.b &1,Sc_Flag(%a6)bra.b ModOrRemNo_Scale:mov.l %d1,R_Hi(%a6)mov.l %d2,R_Lo(%a6)sub.l &0x3FFE,%d0mov.w %d0,R(%a6)mov.l L_SCR1(%a6),%d6sub.l &0x3FFE,%d6mov.l %d6,L_SCR1(%a6)fmov.x R(%a6),%fp0mov.w %d6,Y(%a6)mov.l %d4,Y_Hi(%a6)mov.l %d5,Y_Lo(%a6)clr.b Sc_Flag(%a6)#ModOrRem:tst.b Mod_Flag(%a6)beq.b Fix_Signmov.l L_SCR1(%a6),%d6 # new biased expo(Y)subq.l &1,%d6 # biased expo(Y/2)cmp.l %d0,%d6blt.b Fix_Signbgt.b Last_Subcmp.l %d1,%d4bne.b Not_EQcmp.l %d2,%d5bne.b Not_EQbra.w Tie_CaseNot_EQ:bcs.b Fix_SignLast_Sub:#fsub.x Y(%a6),%fp0 # no exceptionsaddq.l &1,%d3 # Q := Q + 1#Fix_Sign:#..Get sign of Xmov.w SignX(%a6),%d6bge.b Get_Qfneg.x %fp0#..Get Q#Get_Q:clr.l %d6mov.w SignQ(%a6),%d6 # D6 is sign(Q)mov.l &8,%d7lsr.l %d7,%d6and.l &0x0000007F,%d3 # 7 bits of Qor.l %d6,%d3 # sign and bits of Q# swap %d3# fmov.l %fpsr,%d6# and.l &0xFF00FFFF,%d6# or.l %d3,%d6# fmov.l %d6,%fpsr # put Q in fpsrmov.b %d3,FPSR_QBYTE(%a6) # put Q in fpsr#Restore:movm.l (%sp)+,&0xfc # {%d2-%d7}mov.l (%sp)+,%d0fmov.l %d0,%fpcrtst.b Sc_Flag(%a6)beq.b Finishmov.b &FMUL_OP,%d1 # last inst is MULfmul.x Scale(%pc),%fp0 # may cause underflowbra t_catch2# the '040 package did this apparently to see if the dst operand for the# preceding fmul was a denorm. but, it better not have been since the# algorithm just got done playing with fp0 and expected no exceptions# as a result. trust me...# bra t_avoid_unsupp # check for denorm as a# ;result of the scalingFinish:mov.b &FMOV_OP,%d1 # last inst is MOVEfmov.x %fp0,%fp0 # capture exceptions & roundbra t_catch2Rem_is_0:#..R = 2^(-j)X - Q Y = Y, thus R = 0 and quotient = 2^j (Q+1)addq.l &1,%d3cmp.l %d0,&8 # D0 is jbge.b Q_Biglsl.l %d0,%d3bra.b Set_R_0Q_Big:clr.l %d3Set_R_0:fmov.s &0x00000000,%fp0clr.b Sc_Flag(%a6)bra.w Fix_SignTie_Case:#..Check parity of Qmov.l %d3,%d6and.l &0x00000001,%d6tst.l %d6beq.w Fix_Sign # Q is even#..Q is odd, Q := Q + 1, signX := -signXaddq.l &1,%d3mov.w SignX(%a6),%d6eor.l &0x00008000,%d6mov.w %d6,SignX(%a6)bra.w Fix_Sign########################################################################## XDEF **************************************************************** ## tag(): return the optype of the input ext fp number ## ## This routine is used by the 060FPLSP. ## ## XREF **************************************************************** ## None ## ## INPUT *************************************************************** ## a0 = pointer to extended precision operand ## ## OUTPUT ************************************************************** ## d0 = value of type tag ## one of: NORM, INF, QNAN, SNAN, DENORM, ZERO ## ## ALGORITHM *********************************************************** ## Simply test the exponent, j-bit, and mantissa values to ## determine the type of operand. ## If it's an unnormalized zero, alter the operand and force it ## to be a normal zero. ## ##########################################################################global tagtag:mov.w FTEMP_EX(%a0), %d0 # extract exponentandi.w &0x7fff, %d0 # strip off signcmpi.w %d0, &0x7fff # is (EXP == MAX)?beq.b inf_or_nan_xnot_inf_or_nan_x:btst &0x7,FTEMP_HI(%a0)beq.b not_norm_xis_norm_x:mov.b &NORM, %d0rtsnot_norm_x:tst.w %d0 # is exponent = 0?bne.b is_unnorm_xnot_unnorm_x:tst.l FTEMP_HI(%a0)bne.b is_denorm_xtst.l FTEMP_LO(%a0)bne.b is_denorm_xis_zero_x:mov.b &ZERO, %d0rtsis_denorm_x:mov.b &DENORM, %d0rtsis_unnorm_x:bsr.l unnorm_fix # convert to norm,denorm,or zerortsis_unnorm_reg_x:mov.b &UNNORM, %d0rtsinf_or_nan_x:tst.l FTEMP_LO(%a0)bne.b is_nan_xmov.l FTEMP_HI(%a0), %d0and.l &0x7fffffff, %d0 # msb is a don't care!bne.b is_nan_xis_inf_x:mov.b &INF, %d0rtsis_nan_x:mov.b &QNAN, %d0rts#############################################################qnan: long 0x7fff0000, 0xffffffff, 0xffffffff########################################################################## XDEF **************************************************************** ## t_dz(): Handle 060FPLSP dz exception for "flogn" emulation. ## t_dz2(): Handle 060FPLSP dz exception for "fatanh" emulation. ## ## These rouitnes are used by the 060FPLSP package. ## ## XREF **************************************************************** ## None ## ## INPUT *************************************************************** ## a0 = pointer to extended precision source operand. ## ## OUTPUT ************************************************************** ## fp0 = default DZ result. ## ## ALGORITHM *********************************************************** ## Transcendental emulation for the 060FPLSP has detected that ## a DZ exception should occur for the instruction. If DZ is disabled, ## return the default result. ## If DZ is enabled, the dst operand should be returned unscathed ## in fp0 while fp1 is used to create a DZ exception so that the ## operating system can log that such an event occurred. ## ##########################################################################global t_dzt_dz:tst.b SRC_EX(%a0) # check sign for neg or posbpl.b dz_pinf # branch if pos signglobal t_dz2t_dz2:ori.l &dzinf_mask+neg_mask,USER_FPSR(%a6) # set N/I/DZ/ADZbtst &dz_bit,FPCR_ENABLE(%a6)bne.b dz_minf_ena# dz is disabled. return a -INF.fmov.s &0xff800000,%fp0 # return -INFrts# dz is enabled. create a dz exception so the user can record it# but use fp1 instead. return the dst operand unscathed in fp0.dz_minf_ena:fmovm.x EXC_FP0(%a6),&0x80 # return fp0 unscathedfmov.l USER_FPCR(%a6),%fpcrfmov.s &0xbf800000,%fp1 # load -1fdiv.s &0x00000000,%fp1 # -1 / 0rtsdz_pinf:ori.l &dzinf_mask,USER_FPSR(%a6) # set I/DZ/ADZbtst &dz_bit,FPCR_ENABLE(%a6)bne.b dz_pinf_ena# dz is disabled. return a +INF.fmov.s &0x7f800000,%fp0 # return +INFrts# dz is enabled. create a dz exception so the user can record it# but use fp1 instead. return the dst operand unscathed in fp0.dz_pinf_ena:fmovm.x EXC_FP0(%a6),&0x80 # return fp0 unscathedfmov.l USER_FPCR(%a6),%fpcrfmov.s &0x3f800000,%fp1 # load +1fdiv.s &0x00000000,%fp1 # +1 / 0rts########################################################################## XDEF **************************************************************** ## t_operr(): Handle 060FPLSP OPERR exception during emulation. ## ## This routine is used by the 060FPLSP package. ## ## XREF **************************************************************** ## None. ## ## INPUT *************************************************************** ## fp1 = source operand ## ## OUTPUT ************************************************************** ## fp0 = default result ## fp1 = unchanged ## ## ALGORITHM *********************************************************** ## An operand error should occur as the result of transcendental ## emulation in the 060FPLSP. If OPERR is disabled, just return a NAN ## in fp0. If OPERR is enabled, return the dst operand unscathed in fp0 ## and the source operand in fp1. Use fp2 to create an OPERR exception ## so that the operating system can log the event. ## ##########################################################################global t_operrt_operr:ori.l &opnan_mask,USER_FPSR(%a6) # set NAN/OPERR/AIOPbtst &operr_bit,FPCR_ENABLE(%a6)bne.b operr_ena# operr is disabled. return a QNAN in fp0fmovm.x qnan(%pc),&0x80 # return QNANrts# operr is enabled. create an operr exception so the user can record it# but use fp2 instead. return the dst operand unscathed in fp0.operr_ena:fmovm.x EXC_FP0(%a6),&0x80 # return fp0 unscathedfmov.l USER_FPCR(%a6),%fpcrfmovm.x &0x04,-(%sp) # save fp2fmov.s &0x7f800000,%fp2 # load +INFfmul.s &0x00000000,%fp2 # +INF x 0fmovm.x (%sp)+,&0x20 # restore fp2rtspls_huge:long 0x7ffe0000,0xffffffff,0xffffffffmns_huge:long 0xfffe0000,0xffffffff,0xffffffffpls_tiny:long 0x00000000,0x80000000,0x00000000mns_tiny:long 0x80000000,0x80000000,0x00000000########################################################################## XDEF **************************************************************** ## t_unfl(): Handle 060FPLSP underflow exception during emulation. ## t_unfl2(): Handle 060FPLSP underflow exception during ## emulation. result always positive. ## ## This routine is used by the 060FPLSP package. ## ## XREF **************************************************************** ## None. ## ## INPUT *************************************************************** ## a0 = pointer to extended precision source operand ## ## OUTPUT ************************************************************** ## fp0 = default underflow result ## ## ALGORITHM *********************************************************** ## An underflow should occur as the result of transcendental ## emulation in the 060FPLSP. Create an underflow by using "fmul" ## and two very small numbers of appropriate sign so the operating ## system can log the event. ## ##########################################################################global t_unflt_unfl:tst.b SRC_EX(%a0)bpl.b unf_posglobal t_unfl2t_unfl2:ori.l &unfinx_mask+neg_mask,USER_FPSR(%a6) # set N/UNFL/INEX2/AUNFL/AINEXfmov.l USER_FPCR(%a6),%fpcrfmovm.x mns_tiny(%pc),&0x80fmul.x pls_tiny(%pc),%fp0fmov.l %fpsr,%d0rol.l &0x8,%d0mov.b %d0,FPSR_CC(%a6)rtsunf_pos:ori.w &unfinx_mask,FPSR_EXCEPT(%a6) # set UNFL/INEX2/AUNFL/AINEXfmov.l USER_FPCR(%a6),%fpcrfmovm.x pls_tiny(%pc),&0x80fmul.x %fp0,%fp0fmov.l %fpsr,%d0rol.l &0x8,%d0mov.b %d0,FPSR_CC(%a6)rts########################################################################## XDEF **************************************************************** ## t_ovfl(): Handle 060FPLSP overflow exception during emulation. ## (monadic) ## t_ovfl2(): Handle 060FPLSP overflow exception during ## emulation. result always positive. (dyadic) ## t_ovfl_sc(): Handle 060FPLSP overflow exception during ## emulation for "fscale". ## ## This routine is used by the 060FPLSP package. ## ## XREF **************************************************************** ## None. ## ## INPUT *************************************************************** ## a0 = pointer to extended precision source operand ## ## OUTPUT ************************************************************** ## fp0 = default underflow result ## ## ALGORITHM *********************************************************** ## An overflow should occur as the result of transcendental ## emulation in the 060FPLSP. Create an overflow by using "fmul" ## and two very lareg numbers of appropriate sign so the operating ## system can log the event. ## For t_ovfl_sc() we take special care not to lose the INEX2 bit. ## ##########################################################################global t_ovfl_sct_ovfl_sc:ori.l &ovfl_inx_mask,USER_FPSR(%a6) # set OVFL/AOVFL/AINEXmov.b %d0,%d1 # fetch rnd prec,modeandi.b &0xc0,%d1 # extract precbeq.w ovfl_work# dst op is a DENORM. we have to normalize the mantissa to see if the# result would be inexact for the given precision. make a copy of the# dst so we don't screw up the version passed to us.mov.w LOCAL_EX(%a0),FP_SCR0_EX(%a6)mov.l LOCAL_HI(%a0),FP_SCR0_HI(%a6)mov.l LOCAL_LO(%a0),FP_SCR0_LO(%a6)lea FP_SCR0(%a6),%a0 # pass ptr to FP_SCR0movm.l &0xc080,-(%sp) # save d0-d1/a0bsr.l norm # normalize mantissamovm.l (%sp)+,&0x0103 # restore d0-d1/a0cmpi.b %d1,&0x40 # is precision sgl?bne.b ovfl_sc_dbl # no; dblovfl_sc_sgl:tst.l LOCAL_LO(%a0) # is lo lw of sgl set?bne.b ovfl_sc_inx # yestst.b 3+LOCAL_HI(%a0) # is lo byte of hi lw set?bne.b ovfl_sc_inx # yesbra.w ovfl_work # don't set INEX2ovfl_sc_dbl:mov.l LOCAL_LO(%a0),%d1 # are any of lo 11 bits ofandi.l &0x7ff,%d1 # dbl mantissa set?beq.w ovfl_work # no; don't set INEX2ovfl_sc_inx:ori.l &inex2_mask,USER_FPSR(%a6) # set INEX2bra.b ovfl_work # continueglobal t_ovflt_ovfl:ori.w &ovfinx_mask,FPSR_EXCEPT(%a6) # set OVFL/INEX2/AOVFL/AINEXovfl_work:tst.b SRC_EX(%a0)bpl.b ovfl_povfl_m:fmov.l USER_FPCR(%a6),%fpcrfmovm.x mns_huge(%pc),&0x80fmul.x pls_huge(%pc),%fp0fmov.l %fpsr,%d0rol.l &0x8,%d0ori.b &neg_mask,%d0mov.b %d0,FPSR_CC(%a6)rtsovfl_p:fmov.l USER_FPCR(%a6),%fpcrfmovm.x pls_huge(%pc),&0x80fmul.x pls_huge(%pc),%fp0fmov.l %fpsr,%d0rol.l &0x8,%d0mov.b %d0,FPSR_CC(%a6)rtsglobal t_ovfl2t_ovfl2:ori.w &ovfinx_mask,FPSR_EXCEPT(%a6) # set OVFL/INEX2/AOVFL/AINEXfmov.l USER_FPCR(%a6),%fpcrfmovm.x pls_huge(%pc),&0x80fmul.x pls_huge(%pc),%fp0fmov.l %fpsr,%d0rol.l &0x8,%d0mov.b %d0,FPSR_CC(%a6)rts########################################################################## XDEF **************************************************************** ## t_catch(): Handle 060FPLSP OVFL,UNFL,or INEX2 exception during ## emulation. ## t_catch2(): Handle 060FPLSP OVFL,UNFL,or INEX2 exception during ## emulation. ## ## These routines are used by the 060FPLSP package. ## ## XREF **************************************************************** ## None. ## ## INPUT *************************************************************** ## fp0 = default underflow or overflow result ## ## OUTPUT ************************************************************** ## fp0 = default result ## ## ALGORITHM *********************************************************** ## If an overflow or underflow occurred during the last ## instruction of transcendental 060FPLSP emulation, then it has already ## occurred and has been logged. Now we need to see if an inexact ## exception should occur. ## ##########################################################################global t_catch2t_catch2:fmov.l %fpsr,%d0or.l %d0,USER_FPSR(%a6)bra.b inx2_workglobal t_catcht_catch:fmov.l %fpsr,%d0or.l %d0,USER_FPSR(%a6)########################################################################## XDEF **************************************************************** ## t_inx2(): Handle inexact 060FPLSP exception during emulation. ## t_pinx2(): Handle inexact 060FPLSP exception for "+" results. ## t_minx2(): Handle inexact 060FPLSP exception for "-" results. ## ## XREF **************************************************************** ## None. ## ## INPUT *************************************************************** ## fp0 = default result ## ## OUTPUT ************************************************************** ## fp0 = default result ## ## ALGORITHM *********************************************************** ## The last instruction of transcendental emulation for the ## 060FPLSP should be inexact. So, if inexact is enabled, then we create ## the event here by adding a large and very small number together ## so that the operating system can log the event. ## Must check, too, if the result was zero, in which case we just ## set the FPSR bits and return. ## ##########################################################################global t_inx2t_inx2:fblt.w t_minx2fbeq.w inx2_zeroglobal t_pinx2t_pinx2:ori.w &inx2a_mask,FPSR_EXCEPT(%a6) # set INEX2/AINEXbra.b inx2_workglobal t_minx2t_minx2:ori.l &inx2a_mask+neg_mask,USER_FPSR(%a6)inx2_work:btst &inex2_bit,FPCR_ENABLE(%a6) # is inexact enabled?bne.b inx2_work_ena # yesrtsinx2_work_ena:fmov.l USER_FPCR(%a6),%fpcr # insert user's exceptionsfmov.s &0x3f800000,%fp1 # load +1fadd.x pls_tiny(%pc),%fp1 # cause exceptionrtsinx2_zero:mov.b &z_bmask,FPSR_CC(%a6)ori.w &inx2a_mask,2+USER_FPSR(%a6) # set INEX/AINEXrts########################################################################## XDEF **************************************************************** ## t_extdnrm(): Handle DENORM inputs in 060FPLSP. ## t_resdnrm(): Handle DENORM inputs in 060FPLSP for "fscale". ## ## This routine is used by the 060FPLSP package. ## ## XREF **************************************************************** ## None. ## ## INPUT *************************************************************** ## a0 = pointer to extended precision input operand ## ## OUTPUT ************************************************************** ## fp0 = default result ## ## ALGORITHM *********************************************************** ## For all functions that have a denormalized input and that ## f(x)=x, this is the entry point. ## DENORM value is moved using "fmove" which triggers an exception ## if enabled so the operating system can log the event. ## ##########################################################################global t_extdnrmt_extdnrm:fmov.l USER_FPCR(%a6),%fpcrfmov.x SRC_EX(%a0),%fp0fmov.l %fpsr,%d0ori.l &unfinx_mask,%d0or.l %d0,USER_FPSR(%a6)rtsglobal t_resdnrmt_resdnrm:fmov.l USER_FPCR(%a6),%fpcrfmov.x SRC_EX(%a0),%fp0fmov.l %fpsr,%d0or.l %d0,USER_FPSR(%a6)rts############################################ sto_cos:# This is used by fsincos library emulation. The correct# values are already in fp0 and fp1 so we do nothing here.#global sto_cossto_cos:rts############################################ dst_qnan --- force result when destination is a NaN#global dst_qnandst_qnan:fmov.x DST(%a1),%fp0tst.b DST_EX(%a1)bmi.b dst_qnan_mdst_qnan_p:mov.b &nan_bmask,FPSR_CC(%a6)rtsdst_qnan_m:mov.b &nan_bmask+neg_bmask,FPSR_CC(%a6)rts## src_qnan --- force result when source is a NaN#global src_qnansrc_qnan:fmov.x SRC(%a0),%fp0tst.b SRC_EX(%a0)bmi.b src_qnan_msrc_qnan_p:mov.b &nan_bmask,FPSR_CC(%a6)rtssrc_qnan_m:mov.b &nan_bmask+neg_bmask,FPSR_CC(%a6)rts############################################ Native instruction support## Some systems may need entry points even for 68060 native# instructions. These routines are provided for# convenience.#global _fadds__fadds_:fmov.l %fpcr,-(%sp) # save fpcrfmov.l &0x00000000,%fpcr # clear fpcr for loadfmov.s 0x8(%sp),%fp0 # load sgl dstfmov.l (%sp)+,%fpcr # restore fpcrfadd.s 0x8(%sp),%fp0 # fadd w/ sgl srcrtsglobal _faddd__faddd_:fmov.l %fpcr,-(%sp) # save fpcrfmov.l &0x00000000,%fpcr # clear fpcr for loadfmov.d 0x8(%sp),%fp0 # load dbl dstfmov.l (%sp)+,%fpcr # restore fpcrfadd.d 0xc(%sp),%fp0 # fadd w/ dbl srcrtsglobal _faddx__faddx_:fmovm.x 0x4(%sp),&0x80 # load ext dstfadd.x 0x10(%sp),%fp0 # fadd w/ ext srcrtsglobal _fsubs__fsubs_:fmov.l %fpcr,-(%sp) # save fpcrfmov.l &0x00000000,%fpcr # clear fpcr for loadfmov.s 0x8(%sp),%fp0 # load sgl dstfmov.l (%sp)+,%fpcr # restore fpcrfsub.s 0x8(%sp),%fp0 # fsub w/ sgl srcrtsglobal _fsubd__fsubd_:fmov.l %fpcr,-(%sp) # save fpcrfmov.l &0x00000000,%fpcr # clear fpcr for loadfmov.d 0x8(%sp),%fp0 # load dbl dstfmov.l (%sp)+,%fpcr # restore fpcrfsub.d 0xc(%sp),%fp0 # fsub w/ dbl srcrtsglobal _fsubx__fsubx_:fmovm.x 0x4(%sp),&0x80 # load ext dstfsub.x 0x10(%sp),%fp0 # fsub w/ ext srcrtsglobal _fmuls__fmuls_:fmov.l %fpcr,-(%sp) # save fpcrfmov.l &0x00000000,%fpcr # clear fpcr for loadfmov.s 0x8(%sp),%fp0 # load sgl dstfmov.l (%sp)+,%fpcr # restore fpcrfmul.s 0x8(%sp),%fp0 # fmul w/ sgl srcrtsglobal _fmuld__fmuld_:fmov.l %fpcr,-(%sp) # save fpcrfmov.l &0x00000000,%fpcr # clear fpcr for loadfmov.d 0x8(%sp),%fp0 # load dbl dstfmov.l (%sp)+,%fpcr # restore fpcrfmul.d 0xc(%sp),%fp0 # fmul w/ dbl srcrtsglobal _fmulx__fmulx_:fmovm.x 0x4(%sp),&0x80 # load ext dstfmul.x 0x10(%sp),%fp0 # fmul w/ ext srcrtsglobal _fdivs__fdivs_:fmov.l %fpcr,-(%sp) # save fpcrfmov.l &0x00000000,%fpcr # clear fpcr for loadfmov.s 0x8(%sp),%fp0 # load sgl dstfmov.l (%sp)+,%fpcr # restore fpcrfdiv.s 0x8(%sp),%fp0 # fdiv w/ sgl srcrtsglobal _fdivd__fdivd_:fmov.l %fpcr,-(%sp) # save fpcrfmov.l &0x00000000,%fpcr # clear fpcr for loadfmov.d 0x8(%sp),%fp0 # load dbl dstfmov.l (%sp)+,%fpcr # restore fpcrfdiv.d 0xc(%sp),%fp0 # fdiv w/ dbl srcrtsglobal _fdivx__fdivx_:fmovm.x 0x4(%sp),&0x80 # load ext dstfdiv.x 0x10(%sp),%fp0 # fdiv w/ ext srcrtsglobal _fabss__fabss_:fabs.s 0x4(%sp),%fp0 # fabs w/ sgl srcrtsglobal _fabsd__fabsd_:fabs.d 0x4(%sp),%fp0 # fabs w/ dbl srcrtsglobal _fabsx__fabsx_:fabs.x 0x4(%sp),%fp0 # fabs w/ ext srcrtsglobal _fnegs__fnegs_:fneg.s 0x4(%sp),%fp0 # fneg w/ sgl srcrtsglobal _fnegd__fnegd_:fneg.d 0x4(%sp),%fp0 # fneg w/ dbl srcrtsglobal _fnegx__fnegx_:fneg.x 0x4(%sp),%fp0 # fneg w/ ext srcrtsglobal _fsqrts__fsqrts_:fsqrt.s 0x4(%sp),%fp0 # fsqrt w/ sgl srcrtsglobal _fsqrtd__fsqrtd_:fsqrt.d 0x4(%sp),%fp0 # fsqrt w/ dbl srcrtsglobal _fsqrtx__fsqrtx_:fsqrt.x 0x4(%sp),%fp0 # fsqrt w/ ext srcrtsglobal _fints__fints_:fint.s 0x4(%sp),%fp0 # fint w/ sgl srcrtsglobal _fintd__fintd_:fint.d 0x4(%sp),%fp0 # fint w/ dbl srcrtsglobal _fintx__fintx_:fint.x 0x4(%sp),%fp0 # fint w/ ext srcrtsglobal _fintrzs__fintrzs_:fintrz.s 0x4(%sp),%fp0 # fintrz w/ sgl srcrtsglobal _fintrzd__fintrzd_:fintrz.d 0x4(%sp),%fp0 # fintrx w/ dbl srcrtsglobal _fintrzx__fintrzx_:fintrz.x 0x4(%sp),%fp0 # fintrz w/ ext srcrts################################################################################################################################################## src_zero(): Return signed zero according to sign of src operand. ##########################################################################global src_zerosrc_zero:tst.b SRC_EX(%a0) # get sign of src operandbmi.b ld_mzero # if neg, load neg zero## ld_pzero(): return a positive zero.#global ld_pzerold_pzero:fmov.s &0x00000000,%fp0 # load +0mov.b &z_bmask,FPSR_CC(%a6) # set 'Z' ccode bitrts# ld_mzero(): return a negative zero.global ld_mzerold_mzero:fmov.s &0x80000000,%fp0 # load -0mov.b &neg_bmask+z_bmask,FPSR_CC(%a6) # set 'N','Z' ccode bitsrts########################################################################## dst_zero(): Return signed zero according to sign of dst operand. ##########################################################################global dst_zerodst_zero:tst.b DST_EX(%a1) # get sign of dst operandbmi.b ld_mzero # if neg, load neg zerobra.b ld_pzero # load positive zero########################################################################## src_inf(): Return signed inf according to sign of src operand. ##########################################################################global src_infsrc_inf:tst.b SRC_EX(%a0) # get sign of src operandbmi.b ld_minf # if negative branch## ld_pinf(): return a positive infinity.#global ld_pinfld_pinf:fmov.s &0x7f800000,%fp0 # load +INFmov.b &inf_bmask,FPSR_CC(%a6) # set 'INF' ccode bitrts## ld_minf():return a negative infinity.#global ld_minfld_minf:fmov.s &0xff800000,%fp0 # load -INFmov.b &neg_bmask+inf_bmask,FPSR_CC(%a6) # set 'N','I' ccode bitsrts########################################################################## dst_inf(): Return signed inf according to sign of dst operand. ##########################################################################global dst_infdst_inf:tst.b DST_EX(%a1) # get sign of dst operandbmi.b ld_minf # if negative branchbra.b ld_pinfglobal szr_inf################################################################## szr_inf(): Return +ZERO for a negative src operand or ## +INF for a positive src operand. ## Routine used for fetox, ftwotox, and ftentox. ##################################################################szr_inf:tst.b SRC_EX(%a0) # check sign of sourcebmi.b ld_pzerobra.b ld_pinf########################################################################## sopr_inf(): Return +INF for a positive src operand or ## jump to operand error routine for a negative src operand. ## Routine used for flogn, flognp1, flog10, and flog2. ##########################################################################global sopr_infsopr_inf:tst.b SRC_EX(%a0) # check sign of sourcebmi.w t_operrbra.b ld_pinf################################################################## setoxm1i(): Return minus one for a negative src operand or ## positive infinity for a positive src operand. ## Routine used for fetoxm1. ##################################################################global setoxm1isetoxm1i:tst.b SRC_EX(%a0) # check sign of sourcebmi.b ld_monebra.b ld_pinf########################################################################## src_one(): Return signed one according to sign of src operand. ##########################################################################global src_onesrc_one:tst.b SRC_EX(%a0) # check sign of sourcebmi.b ld_mone## ld_pone(): return positive one.#global ld_poneld_pone:fmov.s &0x3f800000,%fp0 # load +1clr.b FPSR_CC(%a6)rts## ld_mone(): return negative one.#global ld_moneld_mone:fmov.s &0xbf800000,%fp0 # load -1mov.b &neg_bmask,FPSR_CC(%a6) # set 'N' ccode bitrtsppiby2: long 0x3fff0000, 0xc90fdaa2, 0x2168c235mpiby2: long 0xbfff0000, 0xc90fdaa2, 0x2168c235################################################################## spi_2(): Return signed PI/2 according to sign of src operand. ##################################################################global spi_2spi_2:tst.b SRC_EX(%a0) # check sign of sourcebmi.b ld_mpi2## ld_ppi2(): return positive PI/2.#global ld_ppi2ld_ppi2:fmov.l %d0,%fpcrfmov.x ppiby2(%pc),%fp0 # load +pi/2bra.w t_pinx2 # set INEX2## ld_mpi2(): return negative PI/2.#global ld_mpi2ld_mpi2:fmov.l %d0,%fpcrfmov.x mpiby2(%pc),%fp0 # load -pi/2bra.w t_minx2 # set INEX2##################################################### The following routines give support for fsincos. ####################################################### ssincosz(): When the src operand is ZERO, store a one in the# cosine register and return a ZERO in fp0 w/ the same sign# as the src operand.#global ssincoszssincosz:fmov.s &0x3f800000,%fp1tst.b SRC_EX(%a0) # test signbpl.b sincoszpfmov.s &0x80000000,%fp0 # return sin result in fp0mov.b &z_bmask+neg_bmask,FPSR_CC(%a6)rtssincoszp:fmov.s &0x00000000,%fp0 # return sin result in fp0mov.b &z_bmask,FPSR_CC(%a6)rts## ssincosi(): When the src operand is INF, store a QNAN in the cosine# register and jump to the operand error routine for negative# src operands.#global ssincosissincosi:fmov.x qnan(%pc),%fp1 # load NANbra.w t_operr## ssincosqnan(): When the src operand is a QNAN, store the QNAN in the cosine# register and branch to the src QNAN routine.#global ssincosqnanssincosqnan:fmov.x LOCAL_EX(%a0),%fp1bra.w src_qnan########################################################################global smod_sdnrmglobal smod_snormsmod_sdnrm:smod_snorm:mov.b DTAG(%a6),%d1beq.l smodcmpi.b %d1,&ZERObeq.w smod_zrocmpi.b %d1,&INFbeq.l t_operrcmpi.b %d1,&DENORMbeq.l smodbra.l dst_qnanglobal smod_szerosmod_szero:mov.b DTAG(%a6),%d1beq.l t_operrcmpi.b %d1,&ZERObeq.l t_operrcmpi.b %d1,&INFbeq.l t_operrcmpi.b %d1,&DENORMbeq.l t_operrbra.l dst_qnanglobal smod_sinfsmod_sinf:mov.b DTAG(%a6),%d1beq.l smod_fpncmpi.b %d1,&ZERObeq.l smod_zrocmpi.b %d1,&INFbeq.l t_operrcmpi.b %d1,&DENORMbeq.l smod_fpnbra.l dst_qnansmod_zro:srem_zro:mov.b SRC_EX(%a0),%d1 # get src signmov.b DST_EX(%a1),%d0 # get dst signeor.b %d0,%d1 # get qbyte signandi.b &0x80,%d1mov.b %d1,FPSR_QBYTE(%a6)tst.b %d0bpl.w ld_pzerobra.w ld_mzerosmod_fpn:srem_fpn:clr.b FPSR_QBYTE(%a6)mov.l %d0,-(%sp)mov.b SRC_EX(%a0),%d1 # get src signmov.b DST_EX(%a1),%d0 # get dst signeor.b %d0,%d1 # get qbyte signandi.b &0x80,%d1mov.b %d1,FPSR_QBYTE(%a6)cmpi.b DTAG(%a6),&DENORMbne.b smod_nrmlea DST(%a1),%a0mov.l (%sp)+,%d0bra t_resdnrmsmod_nrm:fmov.l (%sp)+,%fpcrfmov.x DST(%a1),%fp0tst.b DST_EX(%a1)bmi.b smod_nrm_negrtssmod_nrm_neg:mov.b &neg_bmask,FPSR_CC(%a6) # set 'N' coderts#########################################################################global srem_snormglobal srem_sdnrmsrem_sdnrm:srem_snorm:mov.b DTAG(%a6),%d1beq.l sremcmpi.b %d1,&ZERObeq.w srem_zrocmpi.b %d1,&INFbeq.l t_operrcmpi.b %d1,&DENORMbeq.l srembra.l dst_qnanglobal srem_szerosrem_szero:mov.b DTAG(%a6),%d1beq.l t_operrcmpi.b %d1,&ZERObeq.l t_operrcmpi.b %d1,&INFbeq.l t_operrcmpi.b %d1,&DENORMbeq.l t_operrbra.l dst_qnanglobal srem_sinfsrem_sinf:mov.b DTAG(%a6),%d1beq.w srem_fpncmpi.b %d1,&ZERObeq.w srem_zrocmpi.b %d1,&INFbeq.l t_operrcmpi.b %d1,&DENORMbeq.l srem_fpnbra.l dst_qnan#########################################################################global sscale_snormglobal sscale_sdnrmsscale_snorm:sscale_sdnrm:mov.b DTAG(%a6),%d1beq.l sscalecmpi.b %d1,&ZERObeq.l dst_zerocmpi.b %d1,&INFbeq.l dst_infcmpi.b %d1,&DENORMbeq.l sscalebra.l dst_qnanglobal sscale_szerosscale_szero:mov.b DTAG(%a6),%d1beq.l sscalecmpi.b %d1,&ZERObeq.l dst_zerocmpi.b %d1,&INFbeq.l dst_infcmpi.b %d1,&DENORMbeq.l sscalebra.l dst_qnanglobal sscale_sinfsscale_sinf:mov.b DTAG(%a6),%d1beq.l t_operrcmpi.b %d1,&QNANbeq.l dst_qnanbra.l t_operr########################################################################global sop_sqnansop_sqnan:mov.b DTAG(%a6),%d1cmpi.b %d1,&QNANbeq.l dst_qnanbra.l src_qnan########################################################################## norm(): normalize the mantissa of an extended precision input. the ## input operand should not be normalized already. ## ## XDEF **************************************************************** ## norm() ## ## XREF **************************************************************** ## none ## ## INPUT *************************************************************** ## a0 = pointer fp extended precision operand to normalize ## ## OUTPUT ************************************************************** ## d0 = number of bit positions the mantissa was shifted ## a0 = the input operand's mantissa is normalized; the exponent ## is unchanged. ## ##########################################################################global normnorm:mov.l %d2, -(%sp) # create some temp regsmov.l %d3, -(%sp)mov.l FTEMP_HI(%a0), %d0 # load hi(mantissa)mov.l FTEMP_LO(%a0), %d1 # load lo(mantissa)bfffo %d0{&0:&32}, %d2 # how many places to shift?beq.b norm_lo # hi(man) is all zeroes!norm_hi:lsl.l %d2, %d0 # left shift hi(man)bfextu %d1{&0:%d2}, %d3 # extract lo bitsor.l %d3, %d0 # create hi(man)lsl.l %d2, %d1 # create lo(man)mov.l %d0, FTEMP_HI(%a0) # store new hi(man)mov.l %d1, FTEMP_LO(%a0) # store new lo(man)mov.l %d2, %d0 # return shift amountmov.l (%sp)+, %d3 # restore temp regsmov.l (%sp)+, %d2rtsnorm_lo:bfffo %d1{&0:&32}, %d2 # how many places to shift?lsl.l %d2, %d1 # shift lo(man)add.l &32, %d2 # add 32 to shft amountmov.l %d1, FTEMP_HI(%a0) # store hi(man)clr.l FTEMP_LO(%a0) # lo(man) is now zeromov.l %d2, %d0 # return shift amountmov.l (%sp)+, %d3 # restore temp regsmov.l (%sp)+, %d2rts########################################################################## unnorm_fix(): - changes an UNNORM to one of NORM, DENORM, or ZERO ## - returns corresponding optype tag ## ## XDEF **************************************************************** ## unnorm_fix() ## ## XREF **************************************************************** ## norm() - normalize the mantissa ## ## INPUT *************************************************************** ## a0 = pointer to unnormalized extended precision number ## ## OUTPUT ************************************************************** ## d0 = optype tag - is corrected to one of NORM, DENORM, or ZERO ## a0 = input operand has been converted to a norm, denorm, or ## zero; both the exponent and mantissa are changed. ## ##########################################################################global unnorm_fixunnorm_fix:bfffo FTEMP_HI(%a0){&0:&32}, %d0 # how many shifts are needed?bne.b unnorm_shift # hi(man) is not all zeroes## hi(man) is all zeroes so see if any bits in lo(man) are set#unnorm_chk_lo:bfffo FTEMP_LO(%a0){&0:&32}, %d0 # is operand really a zero?beq.w unnorm_zero # yesadd.w &32, %d0 # no; fix shift distance## d0 = # shifts needed for complete normalization#unnorm_shift:clr.l %d1 # clear top wordmov.w FTEMP_EX(%a0), %d1 # extract exponentand.w &0x7fff, %d1 # strip off sgncmp.w %d0, %d1 # will denorm push exp < 0?bgt.b unnorm_nrm_zero # yes; denorm only until exp = 0## exponent would not go < 0. therefore, number stays normalized#sub.w %d0, %d1 # shift exponent valuemov.w FTEMP_EX(%a0), %d0 # load old exponentand.w &0x8000, %d0 # save old signor.w %d0, %d1 # {sgn,new exp}mov.w %d1, FTEMP_EX(%a0) # insert new exponentbsr.l norm # normalize UNNORMmov.b &NORM, %d0 # return new optype tagrts## exponent would go < 0, so only denormalize until exp = 0#unnorm_nrm_zero:cmp.b %d1, &32 # is exp <= 32?bgt.b unnorm_nrm_zero_lrg # no; go handle large exponentbfextu FTEMP_HI(%a0){%d1:&32}, %d0 # extract new hi(man)mov.l %d0, FTEMP_HI(%a0) # save new hi(man)mov.l FTEMP_LO(%a0), %d0 # fetch old lo(man)lsl.l %d1, %d0 # extract new lo(man)mov.l %d0, FTEMP_LO(%a0) # save new lo(man)and.w &0x8000, FTEMP_EX(%a0) # set exp = 0mov.b &DENORM, %d0 # return new optype tagrts## only mantissa bits set are in lo(man)#unnorm_nrm_zero_lrg:sub.w &32, %d1 # adjust shft amt by 32mov.l FTEMP_LO(%a0), %d0 # fetch old lo(man)lsl.l %d1, %d0 # left shift lo(man)mov.l %d0, FTEMP_HI(%a0) # store new hi(man)clr.l FTEMP_LO(%a0) # lo(man) = 0and.w &0x8000, FTEMP_EX(%a0) # set exp = 0mov.b &DENORM, %d0 # return new optype tagrts## whole mantissa is zero so this UNNORM is actually a zero#unnorm_zero:and.w &0x8000, FTEMP_EX(%a0) # force exponent to zeromov.b &ZERO, %d0 # fix optype tagrts