| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| MOTOROLA MICROPROCESSOR & MEMORY TECHNOLOGY GROUP |
| M68000 Hi-Performance Microprocessor Division |
| M68060 Software Package |
| Production Release P1.00 -- October 10, 1994 |
| |
| M68060 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 PURPOSE |
| and 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 SOFTWARE |
| so long as this entire notice is retained without alteration in any modified and/or |
| redistributed versions, and that such modified versions are clearly identified as such. |
| No licenses are granted by implication, estoppel or otherwise under any patents |
| or 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 0x0000 |
| bra.l _facosd_ |
| short 0x0000 |
| bra.l _facosx_ |
| short 0x0000 |
| |
| bra.l _fasins_ |
| short 0x0000 |
| bra.l _fasind_ |
| short 0x0000 |
| bra.l _fasinx_ |
| short 0x0000 |
| |
| bra.l _fatans_ |
| short 0x0000 |
| bra.l _fatand_ |
| short 0x0000 |
| bra.l _fatanx_ |
| short 0x0000 |
| |
| bra.l _fatanhs_ |
| short 0x0000 |
| bra.l _fatanhd_ |
| short 0x0000 |
| bra.l _fatanhx_ |
| short 0x0000 |
| |
| bra.l _fcoss_ |
| short 0x0000 |
| bra.l _fcosd_ |
| short 0x0000 |
| bra.l _fcosx_ |
| short 0x0000 |
| |
| bra.l _fcoshs_ |
| short 0x0000 |
| bra.l _fcoshd_ |
| short 0x0000 |
| bra.l _fcoshx_ |
| short 0x0000 |
| |
| bra.l _fetoxs_ |
| short 0x0000 |
| bra.l _fetoxd_ |
| short 0x0000 |
| bra.l _fetoxx_ |
| short 0x0000 |
| |
| bra.l _fetoxm1s_ |
| short 0x0000 |
| bra.l _fetoxm1d_ |
| short 0x0000 |
| bra.l _fetoxm1x_ |
| short 0x0000 |
| |
| bra.l _fgetexps_ |
| short 0x0000 |
| bra.l _fgetexpd_ |
| short 0x0000 |
| bra.l _fgetexpx_ |
| short 0x0000 |
| |
| bra.l _fgetmans_ |
| short 0x0000 |
| bra.l _fgetmand_ |
| short 0x0000 |
| bra.l _fgetmanx_ |
| short 0x0000 |
| |
| bra.l _flog10s_ |
| short 0x0000 |
| bra.l _flog10d_ |
| short 0x0000 |
| bra.l _flog10x_ |
| short 0x0000 |
| |
| bra.l _flog2s_ |
| short 0x0000 |
| bra.l _flog2d_ |
| short 0x0000 |
| bra.l _flog2x_ |
| short 0x0000 |
| |
| bra.l _flogns_ |
| short 0x0000 |
| bra.l _flognd_ |
| short 0x0000 |
| bra.l _flognx_ |
| short 0x0000 |
| |
| bra.l _flognp1s_ |
| short 0x0000 |
| bra.l _flognp1d_ |
| short 0x0000 |
| bra.l _flognp1x_ |
| short 0x0000 |
| |
| bra.l _fmods_ |
| short 0x0000 |
| bra.l _fmodd_ |
| short 0x0000 |
| bra.l _fmodx_ |
| short 0x0000 |
| |
| bra.l _frems_ |
| short 0x0000 |
| bra.l _fremd_ |
| short 0x0000 |
| bra.l _fremx_ |
| short 0x0000 |
| |
| bra.l _fscales_ |
| short 0x0000 |
| bra.l _fscaled_ |
| short 0x0000 |
| bra.l _fscalex_ |
| short 0x0000 |
| |
| bra.l _fsins_ |
| short 0x0000 |
| bra.l _fsind_ |
| short 0x0000 |
| bra.l _fsinx_ |
| short 0x0000 |
| |
| bra.l _fsincoss_ |
| short 0x0000 |
| bra.l _fsincosd_ |
| short 0x0000 |
| bra.l _fsincosx_ |
| short 0x0000 |
| |
| bra.l _fsinhs_ |
| short 0x0000 |
| bra.l _fsinhd_ |
| short 0x0000 |
| bra.l _fsinhx_ |
| short 0x0000 |
| |
| bra.l _ftans_ |
| short 0x0000 |
| bra.l _ftand_ |
| short 0x0000 |
| bra.l _ftanx_ |
| short 0x0000 |
| |
| bra.l _ftanhs_ |
| short 0x0000 |
| bra.l _ftanhd_ |
| short 0x0000 |
| bra.l _ftanhx_ |
| short 0x0000 |
| |
| bra.l _ftentoxs_ |
| short 0x0000 |
| bra.l _ftentoxd_ |
| short 0x0000 |
| bra.l _ftentoxx_ |
| short 0x0000 |
| |
| bra.l _ftwotoxs_ |
| short 0x0000 |
| bra.l _ftwotoxd_ |
| short 0x0000 |
| bra.l _ftwotoxx_ |
| short 0x0000 |
| |
| bra.l _fabss_ |
| short 0x0000 |
| bra.l _fabsd_ |
| short 0x0000 |
| bra.l _fabsx_ |
| short 0x0000 |
| |
| bra.l _fadds_ |
| short 0x0000 |
| bra.l _faddd_ |
| short 0x0000 |
| bra.l _faddx_ |
| short 0x0000 |
| |
| bra.l _fdivs_ |
| short 0x0000 |
| bra.l _fdivd_ |
| short 0x0000 |
| bra.l _fdivx_ |
| short 0x0000 |
| |
| bra.l _fints_ |
| short 0x0000 |
| bra.l _fintd_ |
| short 0x0000 |
| bra.l _fintx_ |
| short 0x0000 |
| |
| bra.l _fintrzs_ |
| short 0x0000 |
| bra.l _fintrzd_ |
| short 0x0000 |
| bra.l _fintrzx_ |
| short 0x0000 |
| |
| bra.l _fmuls_ |
| short 0x0000 |
| bra.l _fmuld_ |
| short 0x0000 |
| bra.l _fmulx_ |
| short 0x0000 |
| |
| bra.l _fnegs_ |
| short 0x0000 |
| bra.l _fnegd_ |
| short 0x0000 |
| bra.l _fnegx_ |
| short 0x0000 |
| |
| bra.l _fsqrts_ |
| short 0x0000 |
| bra.l _fsqrtd_ |
| short 0x0000 |
| bra.l _fsqrtx_ |
| short 0x0000 |
| |
| bra.l _fsubs_ |
| short 0x0000 |
| bra.l _fsubd_ |
| short 0x0000 |
| bra.l _fsubx_ |
| short 0x0000 |
| |
| # leave room for future possible additions |
| align 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 offset |
| |
| set EXC_SR, 0x4 # stack status register |
| set EXC_PC, 0x6 # stack pc |
| set EXC_VOFF, 0xa # stacked vector offset |
| set EXC_EA, 0xc # stacked <ea> |
| |
| set EXC_FP, 0x0 # frame pointer |
| |
| set EXC_AREGS, -68 # offset of all address regs |
| set EXC_DREGS, -100 # offset of all data regs |
| set EXC_FPREGS, -36 # offset of all fp regs |
| |
| set EXC_A7, EXC_AREGS+(7*4) # offset of saved a7 |
| set OLD_A7, EXC_AREGS+(6*4) # extra copy of saved a7 |
| set EXC_A6, EXC_AREGS+(6*4) # offset of saved a6 |
| set 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 fp0 |
| set EXC_FP1, EXC_FPREGS+(1*12) # offset of saved fp1 |
| set EXC_FP2, EXC_FPREGS+(2*12) # offset of saved fp2 (not used) |
| |
| set FP_SCR1, LV+80 # fp scratch 1 |
| set FP_SCR1_EX, FP_SCR1+0 |
| set FP_SCR1_SGN, FP_SCR1+2 |
| set FP_SCR1_HI, FP_SCR1+4 |
| set FP_SCR1_LO, FP_SCR1+8 |
| |
| set FP_SCR0, LV+68 # fp scratch 0 |
| set FP_SCR0_EX, FP_SCR0+0 |
| set FP_SCR0_SGN, FP_SCR0+2 |
| set FP_SCR0_HI, FP_SCR0+4 |
| set FP_SCR0_LO, FP_SCR0+8 |
| |
| set FP_DST, LV+56 # fp destination operand |
| set FP_DST_EX, FP_DST+0 |
| set FP_DST_SGN, FP_DST+2 |
| set FP_DST_HI, FP_DST+4 |
| set FP_DST_LO, FP_DST+8 |
| |
| set FP_SRC, LV+44 # fp source operand |
| set FP_SRC_EX, FP_SRC+0 |
| set FP_SRC_SGN, FP_SRC+2 |
| set FP_SRC_HI, FP_SRC+4 |
| set FP_SRC_LO, FP_SRC+8 |
| |
| set USER_FPIAR, LV+40 # FP instr address register |
| |
| set USER_FPSR, LV+36 # FP status register |
| set FPSR_CC, USER_FPSR+0 # FPSR condition codes |
| set FPSR_QBYTE, USER_FPSR+1 # FPSR qoutient byte |
| set FPSR_EXCEPT, USER_FPSR+2 # FPSR exception status byte |
| set FPSR_AEXCEPT, USER_FPSR+3 # FPSR accrued exception byte |
| |
| set USER_FPCR, LV+32 # FP control register |
| set FPCR_ENABLE, USER_FPCR+2 # FPCR exception enable |
| set FPCR_MODE, USER_FPCR+3 # FPCR rounding mode control |
| |
| set L_SCR3, LV+28 # integer scratch 3 |
| set L_SCR2, LV+24 # integer scratch 2 |
| set L_SCR1, LV+20 # integer scratch 1 |
| |
| set STORE_FLG, LV+19 # flag: operand store (ie. not fcmp/ftst) |
| |
| set EXC_TEMP2, LV+24 # temporary space |
| set EXC_TEMP, LV+16 # temporary space |
| |
| set DTAG, LV+15 # destination operand type |
| set STAG, LV+14 # source operand type |
| |
| set SPCOND_FLG, LV+10 # flag: special case (see below) |
| |
| set EXC_CC, LV+8 # saved condition codes |
| set EXC_EXTWPTR, LV+4 # saved current PC (active) |
| set EXC_EXTWORD, LV+2 # saved extension word |
| set EXC_CMDREG, LV+2 # saved extension word |
| set EXC_OPWORD, LV+0 # saved operation word |
| |
| ################################ |
| |
| # Helpful macros |
| |
| set FTEMP, 0 # offsets within an |
| set FTEMP_EX, 0 # extended precision |
| set FTEMP_SGN, 2 # value saved in memory. |
| set FTEMP_HI, 4 |
| set FTEMP_LO, 8 |
| set FTEMP_GRS, 12 |
| |
| set LOCAL, 0 # offsets within an |
| set LOCAL_EX, 0 # extended precision |
| set LOCAL_SGN, 2 # value saved in memory. |
| set LOCAL_HI, 4 |
| set LOCAL_LO, 8 |
| set LOCAL_GRS, 12 |
| |
| set DST, 0 # offsets within an |
| set DST_EX, 0 # extended precision |
| set DST_HI, 4 # value saved in memory. |
| set DST_LO, 8 |
| |
| set SRC, 0 # offsets within an |
| set SRC_EX, 0 # extended precision |
| set SRC_HI, 4 # value saved in memory. |
| set SRC_LO, 8 |
| |
| set SGL_LO, 0x3f81 # min sgl prec exponent |
| set SGL_HI, 0x407e # max sgl prec exponent |
| set DBL_LO, 0x3c01 # min dbl prec exponent |
| set DBL_HI, 0x43fe # max dbl prec exponent |
| set EXT_LO, 0x0 # min ext prec exponent |
| set EXT_HI, 0x7ffe # max ext prec exponent |
| |
| set EXT_BIAS, 0x3fff # extended precision bias |
| set SGL_BIAS, 0x007f # single precision bias |
| set DBL_BIAS, 0x03ff # double precision bias |
| |
| set NORM, 0x00 # operand type for STAG/DTAG |
| set ZERO, 0x01 # operand type for STAG/DTAG |
| set INF, 0x02 # operand type for STAG/DTAG |
| set QNAN, 0x03 # operand type for STAG/DTAG |
| set DENORM, 0x04 # operand type for STAG/DTAG |
| set SNAN, 0x05 # operand type for STAG/DTAG |
| set UNNORM, 0x06 # operand type for STAG/DTAG |
| |
| ################## |
| # FPSR/FPCR bits # |
| ################## |
| set neg_bit, 0x3 # negative result |
| set z_bit, 0x2 # zero result |
| set inf_bit, 0x1 # infinite result |
| set nan_bit, 0x0 # NAN result |
| |
| set q_sn_bit, 0x7 # sign bit of quotient byte |
| |
| set bsun_bit, 7 # branch on unordered |
| set snan_bit, 6 # signalling NAN |
| set operr_bit, 5 # operand error |
| set ovfl_bit, 4 # overflow |
| set unfl_bit, 3 # underflow |
| set dz_bit, 2 # divide by zero |
| set inex2_bit, 1 # inexact result 2 |
| set inex1_bit, 0 # inexact result 1 |
| |
| set aiop_bit, 7 # accrued inexact operation bit |
| set aovfl_bit, 6 # accrued overflow bit |
| set aunfl_bit, 5 # accrued underflow bit |
| set adz_bit, 4 # accrued dz bit |
| set 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 mask |
| set snan_mask, 0x00004000 # snan exception mask |
| set operr_mask, 0x00002000 # operr exception mask |
| set ovfl_mask, 0x00001000 # overflow exception mask |
| set unfl_mask, 0x00000800 # underflow exception mask |
| set dz_mask, 0x00000400 # dz exception mask |
| set inex2_mask, 0x00000200 # inex2 exception mask |
| set inex1_mask, 0x00000100 # inex1 exception mask |
| |
| set aiop_mask, 0x00000080 # accrued illegal operation |
| set aovfl_mask, 0x00000040 # accrued overflow |
| set aunfl_mask, 0x00000020 # accrued underflow |
| set adz_mask, 0x00000010 # accrued divide by zero |
| set ainex_mask, 0x00000008 # accrued inexact |
| |
| ###################################### |
| # FPSR combinations used in the FPSP # |
| ###################################### |
| set dzinf_mask, inf_mask+dz_mask+adz_mask |
| set opnan_mask, nan_mask+operr_mask+aiop_mask |
| set nzi_mask, 0x01ffffff #clears N, Z, and I |
| set unfinx_mask, unfl_mask+inex2_mask+aunfl_mask+ainex_mask |
| set unf2inx_mask, unfl_mask+inex2_mask+ainex_mask |
| set ovfinx_mask, ovfl_mask+inex2_mask+aovfl_mask+ainex_mask |
| set inx1a_mask, inex1_mask+ainex_mask |
| set inx2a_mask, inex2_mask+ainex_mask |
| set snaniop_mask, nan_mask+snan_mask+aiop_mask |
| set snaniop2_mask, snan_mask+aiop_mask |
| set naniop_mask, nan_mask+aiop_mask |
| set neginf_mask, neg_mask+inf_mask |
| set infaiop_mask, inf_mask+aiop_mask |
| set negz_mask, neg_mask+z_mask |
| set opaop_mask, operr_mask+aiop_mask |
| set unfl_inx_mask, unfl_mask+aunfl_mask+ainex_mask |
| set ovfl_inx_mask, ovfl_mask+aovfl_mask+ainex_mask |
| |
| ######### |
| # misc. # |
| ######### |
| set rnd_stky_bit, 29 # stky bit pos in longword |
| |
| set sign_bit, 0x7 # sign bit |
| set signan_bit, 0x6 # signalling nan bit |
| |
| set sgl_thresh, 0x3f81 # minimum sgl exponent |
| set dbl_thresh, 0x3c01 # minimum dbl exponent |
| |
| set x_mode, 0x0 # extended precision |
| set s_mode, 0x4 # single precision |
| set d_mode, 0x8 # double precision |
| |
| set rn_mode, 0x0 # round-to-nearest |
| set rz_mode, 0x1 # round-to-zero |
| set rm_mode, 0x2 # round-tp-minus-infinity |
| set rp_mode, 0x3 # round-to-plus-infinity |
| |
| set mantissalen, 64 # length of mantissa in bits |
| |
| set BYTE, 1 # len(byte) == 1 byte |
| set WORD, 2 # len(word) == 2 bytes |
| set LONG, 4 # len(longword) == 2 bytes |
| |
| set BSUN_VEC, 0xc0 # bsun vector offset |
| set INEX_VEC, 0xc4 # inexact vector offset |
| set DZ_VEC, 0xc8 # dz vector offset |
| set UNFL_VEC, 0xcc # unfl vector offset |
| set OPERR_VEC, 0xd0 # operr vector offset |
| set OVFL_VEC, 0xd4 # ovfl vector offset |
| set SNAN_VEC, 0xd8 # snan vector offset |
| |
| ########################### |
| # SPecial CONDition FLaGs # |
| ########################### |
| set ftrapcc_flg, 0x01 # flag bit: ftrapcc exception |
| set fbsun_flg, 0x02 # flag bit: bsun exception |
| set mia7_flg, 0x04 # flag bit: (a7)+ <ea> |
| set mda7_flg, 0x08 # flag bit: -(a7) <ea> |
| set fmovm_flg, 0x40 # flag bit: fmovm instruction |
| set immed_flg, 0x80 # flag bit: &<data> <ea> |
| |
| set ftrapcc_bit, 0x0 |
| set fbsun_bit, 0x1 |
| set mia7_bit, 0x2 |
| set mda7_bit, 0x3 |
| set immed_bit, 0x7 |
| |
| ################################## |
| # TRANSCENDENTAL "LAST-OP" FLAGS # |
| ################################## |
| set FMUL_OP, 0x0 # fmul instr performed last |
| set FDIV_OP, 0x1 # fdiv performed last |
| set FADD_OP, 0x2 # fadd performed last |
| set FMOV_OP, 0x3 # fmov performed last |
| |
| ############# |
| # CONSTANTS # |
| ############# |
| T1: long 0x40C62D38,0xD3D64634 # 16381 LOG2 LEAD |
| T2: long 0x3D6F90AE,0xB1E75CC7 # 16381 LOG2 TRAIL |
| |
| PI: long 0x40000000,0xC90FDAA2,0x2168C235,0x00000000 |
| PIBY2: long 0x3FFF0000,0xC90FDAA2,0x2168C235,0x00000000 |
| |
| TWOBYPI: |
| long 0x3FE45F30,0x6DC9C883 |
| |
| ######################################################################### |
| # MONADIC TEMPLATE # |
| ######################################################################### |
| global _fsins_ |
| _fsins_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| fmov.s 0x8(%a6),%fp0 # load sgl input |
| fmov.x %fp0,FP_SRC(%a6) |
| lea FP_SRC(%a6),%a0 |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| tst.b %d1 |
| bne.b _L0_2s |
| bsr.l ssin # operand is a NORM |
| bra.b _L0_6s |
| _L0_2s: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L0_3s # no |
| bsr.l src_zero # yes |
| bra.b _L0_6s |
| _L0_3s: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L0_4s # no |
| bsr.l t_operr # yes |
| bra.b _L0_6s |
| _L0_4s: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L0_5s # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| global _fsind_ |
| _fsind_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| fmov.d 0x8(%a6),%fp0 # load dbl input |
| fmov.x %fp0,FP_SRC(%a6) |
| lea FP_SRC(%a6),%a0 |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| mov.b %d1,STAG(%a6) |
| tst.b %d1 |
| bne.b _L0_2d |
| bsr.l ssin # operand is a NORM |
| bra.b _L0_6d |
| _L0_2d: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L0_3d # no |
| bsr.l src_zero # yes |
| bra.b _L0_6d |
| _L0_3d: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L0_4d # no |
| bsr.l t_operr # yes |
| bra.b _L0_6d |
| _L0_4d: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L0_5d # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| global _fsinx_ |
| _fsinx_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| lea FP_SRC(%a6),%a0 |
| mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input |
| mov.l 0x8+0x4(%a6),0x4(%a0) |
| mov.l 0x8+0x8(%a6),0x8(%a0) |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| tst.b %d1 |
| bne.b _L0_2x |
| bsr.l ssin # operand is a NORM |
| bra.b _L0_6x |
| _L0_2x: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L0_3x # no |
| bsr.l src_zero # yes |
| bra.b _L0_6x |
| _L0_3x: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L0_4x # no |
| bsr.l t_operr # yes |
| bra.b _L0_6x |
| _L0_4x: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L0_5x # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| |
| ######################################################################### |
| # MONADIC TEMPLATE # |
| ######################################################################### |
| global _fcoss_ |
| _fcoss_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| fmov.s 0x8(%a6),%fp0 # load sgl input |
| fmov.x %fp0,FP_SRC(%a6) |
| lea FP_SRC(%a6),%a0 |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| tst.b %d1 |
| bne.b _L1_2s |
| bsr.l scos # operand is a NORM |
| bra.b _L1_6s |
| _L1_2s: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L1_3s # no |
| bsr.l ld_pone # yes |
| bra.b _L1_6s |
| _L1_3s: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L1_4s # no |
| bsr.l t_operr # yes |
| bra.b _L1_6s |
| _L1_4s: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L1_5s # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| global _fcosd_ |
| _fcosd_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| fmov.d 0x8(%a6),%fp0 # load dbl input |
| fmov.x %fp0,FP_SRC(%a6) |
| lea FP_SRC(%a6),%a0 |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| mov.b %d1,STAG(%a6) |
| tst.b %d1 |
| bne.b _L1_2d |
| bsr.l scos # operand is a NORM |
| bra.b _L1_6d |
| _L1_2d: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L1_3d # no |
| bsr.l ld_pone # yes |
| bra.b _L1_6d |
| _L1_3d: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L1_4d # no |
| bsr.l t_operr # yes |
| bra.b _L1_6d |
| _L1_4d: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L1_5d # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| global _fcosx_ |
| _fcosx_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| lea FP_SRC(%a6),%a0 |
| mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input |
| mov.l 0x8+0x4(%a6),0x4(%a0) |
| mov.l 0x8+0x8(%a6),0x8(%a0) |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| tst.b %d1 |
| bne.b _L1_2x |
| bsr.l scos # operand is a NORM |
| bra.b _L1_6x |
| _L1_2x: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L1_3x # no |
| bsr.l ld_pone # yes |
| bra.b _L1_6x |
| _L1_3x: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L1_4x # no |
| bsr.l t_operr # yes |
| bra.b _L1_6x |
| _L1_4x: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L1_5x # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| |
| ######################################################################### |
| # MONADIC TEMPLATE # |
| ######################################################################### |
| global _fsinhs_ |
| _fsinhs_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| fmov.s 0x8(%a6),%fp0 # load sgl input |
| fmov.x %fp0,FP_SRC(%a6) |
| lea FP_SRC(%a6),%a0 |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| tst.b %d1 |
| bne.b _L2_2s |
| bsr.l ssinh # operand is a NORM |
| bra.b _L2_6s |
| _L2_2s: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L2_3s # no |
| bsr.l src_zero # yes |
| bra.b _L2_6s |
| _L2_3s: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L2_4s # no |
| bsr.l src_inf # yes |
| bra.b _L2_6s |
| _L2_4s: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L2_5s # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| global _fsinhd_ |
| _fsinhd_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| fmov.d 0x8(%a6),%fp0 # load dbl input |
| fmov.x %fp0,FP_SRC(%a6) |
| lea FP_SRC(%a6),%a0 |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| mov.b %d1,STAG(%a6) |
| tst.b %d1 |
| bne.b _L2_2d |
| bsr.l ssinh # operand is a NORM |
| bra.b _L2_6d |
| _L2_2d: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L2_3d # no |
| bsr.l src_zero # yes |
| bra.b _L2_6d |
| _L2_3d: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L2_4d # no |
| bsr.l src_inf # yes |
| bra.b _L2_6d |
| _L2_4d: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L2_5d # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| global _fsinhx_ |
| _fsinhx_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| lea FP_SRC(%a6),%a0 |
| mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input |
| mov.l 0x8+0x4(%a6),0x4(%a0) |
| mov.l 0x8+0x8(%a6),0x8(%a0) |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| tst.b %d1 |
| bne.b _L2_2x |
| bsr.l ssinh # operand is a NORM |
| bra.b _L2_6x |
| _L2_2x: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L2_3x # no |
| bsr.l src_zero # yes |
| bra.b _L2_6x |
| _L2_3x: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L2_4x # no |
| bsr.l src_inf # yes |
| bra.b _L2_6x |
| _L2_4x: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L2_5x # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| |
| ######################################################################### |
| # MONADIC TEMPLATE # |
| ######################################################################### |
| global _flognp1s_ |
| _flognp1s_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| fmov.s 0x8(%a6),%fp0 # load sgl input |
| fmov.x %fp0,FP_SRC(%a6) |
| lea FP_SRC(%a6),%a0 |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| tst.b %d1 |
| bne.b _L3_2s |
| bsr.l slognp1 # operand is a NORM |
| bra.b _L3_6s |
| _L3_2s: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L3_3s # no |
| bsr.l src_zero # yes |
| bra.b _L3_6s |
| _L3_3s: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L3_4s # no |
| bsr.l sopr_inf # yes |
| bra.b _L3_6s |
| _L3_4s: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L3_5s # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| global _flognp1d_ |
| _flognp1d_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| fmov.d 0x8(%a6),%fp0 # load dbl input |
| fmov.x %fp0,FP_SRC(%a6) |
| lea FP_SRC(%a6),%a0 |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| mov.b %d1,STAG(%a6) |
| tst.b %d1 |
| bne.b _L3_2d |
| bsr.l slognp1 # operand is a NORM |
| bra.b _L3_6d |
| _L3_2d: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L3_3d # no |
| bsr.l src_zero # yes |
| bra.b _L3_6d |
| _L3_3d: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L3_4d # no |
| bsr.l sopr_inf # yes |
| bra.b _L3_6d |
| _L3_4d: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L3_5d # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| global _flognp1x_ |
| _flognp1x_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| lea FP_SRC(%a6),%a0 |
| mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input |
| mov.l 0x8+0x4(%a6),0x4(%a0) |
| mov.l 0x8+0x8(%a6),0x8(%a0) |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| tst.b %d1 |
| bne.b _L3_2x |
| bsr.l slognp1 # operand is a NORM |
| bra.b _L3_6x |
| _L3_2x: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L3_3x # no |
| bsr.l src_zero # yes |
| bra.b _L3_6x |
| _L3_3x: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L3_4x # no |
| bsr.l sopr_inf # yes |
| bra.b _L3_6x |
| _L3_4x: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L3_5x # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| |
| ######################################################################### |
| # MONADIC TEMPLATE # |
| ######################################################################### |
| global _fetoxm1s_ |
| _fetoxm1s_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| fmov.s 0x8(%a6),%fp0 # load sgl input |
| fmov.x %fp0,FP_SRC(%a6) |
| lea FP_SRC(%a6),%a0 |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| tst.b %d1 |
| bne.b _L4_2s |
| bsr.l setoxm1 # operand is a NORM |
| bra.b _L4_6s |
| _L4_2s: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L4_3s # no |
| bsr.l src_zero # yes |
| bra.b _L4_6s |
| _L4_3s: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L4_4s # no |
| bsr.l setoxm1i # yes |
| bra.b _L4_6s |
| _L4_4s: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L4_5s # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| global _fetoxm1d_ |
| _fetoxm1d_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| fmov.d 0x8(%a6),%fp0 # load dbl input |
| fmov.x %fp0,FP_SRC(%a6) |
| lea FP_SRC(%a6),%a0 |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| mov.b %d1,STAG(%a6) |
| tst.b %d1 |
| bne.b _L4_2d |
| bsr.l setoxm1 # operand is a NORM |
| bra.b _L4_6d |
| _L4_2d: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L4_3d # no |
| bsr.l src_zero # yes |
| bra.b _L4_6d |
| _L4_3d: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L4_4d # no |
| bsr.l setoxm1i # yes |
| bra.b _L4_6d |
| _L4_4d: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L4_5d # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| global _fetoxm1x_ |
| _fetoxm1x_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| lea FP_SRC(%a6),%a0 |
| mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input |
| mov.l 0x8+0x4(%a6),0x4(%a0) |
| mov.l 0x8+0x8(%a6),0x8(%a0) |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| tst.b %d1 |
| bne.b _L4_2x |
| bsr.l setoxm1 # operand is a NORM |
| bra.b _L4_6x |
| _L4_2x: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L4_3x # no |
| bsr.l src_zero # yes |
| bra.b _L4_6x |
| _L4_3x: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L4_4x # no |
| bsr.l setoxm1i # yes |
| bra.b _L4_6x |
| _L4_4x: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L4_5x # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| |
| ######################################################################### |
| # MONADIC TEMPLATE # |
| ######################################################################### |
| global _ftanhs_ |
| _ftanhs_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| fmov.s 0x8(%a6),%fp0 # load sgl input |
| fmov.x %fp0,FP_SRC(%a6) |
| lea FP_SRC(%a6),%a0 |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| tst.b %d1 |
| bne.b _L5_2s |
| bsr.l stanh # operand is a NORM |
| bra.b _L5_6s |
| _L5_2s: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L5_3s # no |
| bsr.l src_zero # yes |
| bra.b _L5_6s |
| _L5_3s: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L5_4s # no |
| bsr.l src_one # yes |
| bra.b _L5_6s |
| _L5_4s: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L5_5s # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| global _ftanhd_ |
| _ftanhd_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| fmov.d 0x8(%a6),%fp0 # load dbl input |
| fmov.x %fp0,FP_SRC(%a6) |
| lea FP_SRC(%a6),%a0 |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| mov.b %d1,STAG(%a6) |
| tst.b %d1 |
| bne.b _L5_2d |
| bsr.l stanh # operand is a NORM |
| bra.b _L5_6d |
| _L5_2d: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L5_3d # no |
| bsr.l src_zero # yes |
| bra.b _L5_6d |
| _L5_3d: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L5_4d # no |
| bsr.l src_one # yes |
| bra.b _L5_6d |
| _L5_4d: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L5_5d # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| global _ftanhx_ |
| _ftanhx_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| lea FP_SRC(%a6),%a0 |
| mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input |
| mov.l 0x8+0x4(%a6),0x4(%a0) |
| mov.l 0x8+0x8(%a6),0x8(%a0) |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| tst.b %d1 |
| bne.b _L5_2x |
| bsr.l stanh # operand is a NORM |
| bra.b _L5_6x |
| _L5_2x: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L5_3x # no |
| bsr.l src_zero # yes |
| bra.b _L5_6x |
| _L5_3x: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L5_4x # no |
| bsr.l src_one # yes |
| bra.b _L5_6x |
| _L5_4x: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L5_5x # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| |
| ######################################################################### |
| # MONADIC TEMPLATE # |
| ######################################################################### |
| global _fatans_ |
| _fatans_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| fmov.s 0x8(%a6),%fp0 # load sgl input |
| fmov.x %fp0,FP_SRC(%a6) |
| lea FP_SRC(%a6),%a0 |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| tst.b %d1 |
| bne.b _L6_2s |
| bsr.l satan # operand is a NORM |
| bra.b _L6_6s |
| _L6_2s: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L6_3s # no |
| bsr.l src_zero # yes |
| bra.b _L6_6s |
| _L6_3s: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L6_4s # no |
| bsr.l spi_2 # yes |
| bra.b _L6_6s |
| _L6_4s: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L6_5s # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| global _fatand_ |
| _fatand_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| fmov.d 0x8(%a6),%fp0 # load dbl input |
| fmov.x %fp0,FP_SRC(%a6) |
| lea FP_SRC(%a6),%a0 |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| mov.b %d1,STAG(%a6) |
| tst.b %d1 |
| bne.b _L6_2d |
| bsr.l satan # operand is a NORM |
| bra.b _L6_6d |
| _L6_2d: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L6_3d # no |
| bsr.l src_zero # yes |
| bra.b _L6_6d |
| _L6_3d: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L6_4d # no |
| bsr.l spi_2 # yes |
| bra.b _L6_6d |
| _L6_4d: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L6_5d # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| global _fatanx_ |
| _fatanx_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| lea FP_SRC(%a6),%a0 |
| mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input |
| mov.l 0x8+0x4(%a6),0x4(%a0) |
| mov.l 0x8+0x8(%a6),0x8(%a0) |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| tst.b %d1 |
| bne.b _L6_2x |
| bsr.l satan # operand is a NORM |
| bra.b _L6_6x |
| _L6_2x: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L6_3x # no |
| bsr.l src_zero # yes |
| bra.b _L6_6x |
| _L6_3x: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L6_4x # no |
| bsr.l spi_2 # yes |
| bra.b _L6_6x |
| _L6_4x: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L6_5x # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| |
| ######################################################################### |
| # MONADIC TEMPLATE # |
| ######################################################################### |
| global _fasins_ |
| _fasins_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| fmov.s 0x8(%a6),%fp0 # load sgl input |
| fmov.x %fp0,FP_SRC(%a6) |
| lea FP_SRC(%a6),%a0 |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| tst.b %d1 |
| bne.b _L7_2s |
| bsr.l sasin # operand is a NORM |
| bra.b _L7_6s |
| _L7_2s: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L7_3s # no |
| bsr.l src_zero # yes |
| bra.b _L7_6s |
| _L7_3s: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L7_4s # no |
| bsr.l t_operr # yes |
| bra.b _L7_6s |
| _L7_4s: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L7_5s # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| global _fasind_ |
| _fasind_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| fmov.d 0x8(%a6),%fp0 # load dbl input |
| fmov.x %fp0,FP_SRC(%a6) |
| lea FP_SRC(%a6),%a0 |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| mov.b %d1,STAG(%a6) |
| tst.b %d1 |
| bne.b _L7_2d |
| bsr.l sasin # operand is a NORM |
| bra.b _L7_6d |
| _L7_2d: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L7_3d # no |
| bsr.l src_zero # yes |
| bra.b _L7_6d |
| _L7_3d: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L7_4d # no |
| bsr.l t_operr # yes |
| bra.b _L7_6d |
| _L7_4d: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L7_5d # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| global _fasinx_ |
| _fasinx_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| lea FP_SRC(%a6),%a0 |
| mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input |
| mov.l 0x8+0x4(%a6),0x4(%a0) |
| mov.l 0x8+0x8(%a6),0x8(%a0) |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| tst.b %d1 |
| bne.b _L7_2x |
| bsr.l sasin # operand is a NORM |
| bra.b _L7_6x |
| _L7_2x: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L7_3x # no |
| bsr.l src_zero # yes |
| bra.b _L7_6x |
| _L7_3x: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L7_4x # no |
| bsr.l t_operr # yes |
| bra.b _L7_6x |
| _L7_4x: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L7_5x # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| |
| ######################################################################### |
| # MONADIC TEMPLATE # |
| ######################################################################### |
| global _fatanhs_ |
| _fatanhs_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| fmov.s 0x8(%a6),%fp0 # load sgl input |
| fmov.x %fp0,FP_SRC(%a6) |
| lea FP_SRC(%a6),%a0 |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| tst.b %d1 |
| bne.b _L8_2s |
| bsr.l satanh # operand is a NORM |
| bra.b _L8_6s |
| _L8_2s: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L8_3s # no |
| bsr.l src_zero # yes |
| bra.b _L8_6s |
| _L8_3s: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L8_4s # no |
| bsr.l t_operr # yes |
| bra.b _L8_6s |
| _L8_4s: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L8_5s # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| global _fatanhd_ |
| _fatanhd_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| fmov.d 0x8(%a6),%fp0 # load dbl input |
| fmov.x %fp0,FP_SRC(%a6) |
| lea FP_SRC(%a6),%a0 |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| mov.b %d1,STAG(%a6) |
| tst.b %d1 |
| bne.b _L8_2d |
| bsr.l satanh # operand is a NORM |
| bra.b _L8_6d |
| _L8_2d: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L8_3d # no |
| bsr.l src_zero # yes |
| bra.b _L8_6d |
| _L8_3d: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L8_4d # no |
| bsr.l t_operr # yes |
| bra.b _L8_6d |
| _L8_4d: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L8_5d # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| global _fatanhx_ |
| _fatanhx_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| lea FP_SRC(%a6),%a0 |
| mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input |
| mov.l 0x8+0x4(%a6),0x4(%a0) |
| mov.l 0x8+0x8(%a6),0x8(%a0) |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| tst.b %d1 |
| bne.b _L8_2x |
| bsr.l satanh # operand is a NORM |
| bra.b _L8_6x |
| _L8_2x: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L8_3x # no |
| bsr.l src_zero # yes |
| bra.b _L8_6x |
| _L8_3x: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L8_4x # no |
| bsr.l t_operr # yes |
| bra.b _L8_6x |
| _L8_4x: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L8_5x # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| |
| ######################################################################### |
| # MONADIC TEMPLATE # |
| ######################################################################### |
| global _ftans_ |
| _ftans_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| fmov.s 0x8(%a6),%fp0 # load sgl input |
| fmov.x %fp0,FP_SRC(%a6) |
| lea FP_SRC(%a6),%a0 |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| tst.b %d1 |
| bne.b _L9_2s |
| bsr.l stan # operand is a NORM |
| bra.b _L9_6s |
| _L9_2s: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L9_3s # no |
| bsr.l src_zero # yes |
| bra.b _L9_6s |
| _L9_3s: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L9_4s # no |
| bsr.l t_operr # yes |
| bra.b _L9_6s |
| _L9_4s: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L9_5s # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| global _ftand_ |
| _ftand_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| fmov.d 0x8(%a6),%fp0 # load dbl input |
| fmov.x %fp0,FP_SRC(%a6) |
| lea FP_SRC(%a6),%a0 |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| mov.b %d1,STAG(%a6) |
| tst.b %d1 |
| bne.b _L9_2d |
| bsr.l stan # operand is a NORM |
| bra.b _L9_6d |
| _L9_2d: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L9_3d # no |
| bsr.l src_zero # yes |
| bra.b _L9_6d |
| _L9_3d: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L9_4d # no |
| bsr.l t_operr # yes |
| bra.b _L9_6d |
| _L9_4d: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L9_5d # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| global _ftanx_ |
| _ftanx_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| lea FP_SRC(%a6),%a0 |
| mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input |
| mov.l 0x8+0x4(%a6),0x4(%a0) |
| mov.l 0x8+0x8(%a6),0x8(%a0) |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| tst.b %d1 |
| bne.b _L9_2x |
| bsr.l stan # operand is a NORM |
| bra.b _L9_6x |
| _L9_2x: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L9_3x # no |
| bsr.l src_zero # yes |
| bra.b _L9_6x |
| _L9_3x: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L9_4x # no |
| bsr.l t_operr # yes |
| bra.b _L9_6x |
| _L9_4x: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L9_5x # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| |
| ######################################################################### |
| # MONADIC TEMPLATE # |
| ######################################################################### |
| global _fetoxs_ |
| _fetoxs_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| fmov.s 0x8(%a6),%fp0 # load sgl input |
| fmov.x %fp0,FP_SRC(%a6) |
| lea FP_SRC(%a6),%a0 |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| tst.b %d1 |
| bne.b _L10_2s |
| bsr.l setox # operand is a NORM |
| bra.b _L10_6s |
| _L10_2s: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L10_3s # no |
| bsr.l ld_pone # yes |
| bra.b _L10_6s |
| _L10_3s: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L10_4s # no |
| bsr.l szr_inf # yes |
| bra.b _L10_6s |
| _L10_4s: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L10_5s # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| global _fetoxd_ |
| _fetoxd_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| fmov.d 0x8(%a6),%fp0 # load dbl input |
| fmov.x %fp0,FP_SRC(%a6) |
| lea FP_SRC(%a6),%a0 |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| mov.b %d1,STAG(%a6) |
| tst.b %d1 |
| bne.b _L10_2d |
| bsr.l setox # operand is a NORM |
| bra.b _L10_6d |
| _L10_2d: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L10_3d # no |
| bsr.l ld_pone # yes |
| bra.b _L10_6d |
| _L10_3d: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L10_4d # no |
| bsr.l szr_inf # yes |
| bra.b _L10_6d |
| _L10_4d: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L10_5d # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| global _fetoxx_ |
| _fetoxx_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| lea FP_SRC(%a6),%a0 |
| mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input |
| mov.l 0x8+0x4(%a6),0x4(%a0) |
| mov.l 0x8+0x8(%a6),0x8(%a0) |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| tst.b %d1 |
| bne.b _L10_2x |
| bsr.l setox # operand is a NORM |
| bra.b _L10_6x |
| _L10_2x: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L10_3x # no |
| bsr.l ld_pone # yes |
| bra.b _L10_6x |
| _L10_3x: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L10_4x # no |
| bsr.l szr_inf # yes |
| bra.b _L10_6x |
| _L10_4x: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L10_5x # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| |
| ######################################################################### |
| # MONADIC TEMPLATE # |
| ######################################################################### |
| global _ftwotoxs_ |
| _ftwotoxs_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| fmov.s 0x8(%a6),%fp0 # load sgl input |
| fmov.x %fp0,FP_SRC(%a6) |
| lea FP_SRC(%a6),%a0 |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| tst.b %d1 |
| bne.b _L11_2s |
| bsr.l stwotox # operand is a NORM |
| bra.b _L11_6s |
| _L11_2s: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L11_3s # no |
| bsr.l ld_pone # yes |
| bra.b _L11_6s |
| _L11_3s: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L11_4s # no |
| bsr.l szr_inf # yes |
| bra.b _L11_6s |
| _L11_4s: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L11_5s # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| global _ftwotoxd_ |
| _ftwotoxd_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| fmov.d 0x8(%a6),%fp0 # load dbl input |
| fmov.x %fp0,FP_SRC(%a6) |
| lea FP_SRC(%a6),%a0 |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| mov.b %d1,STAG(%a6) |
| tst.b %d1 |
| bne.b _L11_2d |
| bsr.l stwotox # operand is a NORM |
| bra.b _L11_6d |
| _L11_2d: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L11_3d # no |
| bsr.l ld_pone # yes |
| bra.b _L11_6d |
| _L11_3d: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L11_4d # no |
| bsr.l szr_inf # yes |
| bra.b _L11_6d |
| _L11_4d: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L11_5d # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| global _ftwotoxx_ |
| _ftwotoxx_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| lea FP_SRC(%a6),%a0 |
| mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input |
| mov.l 0x8+0x4(%a6),0x4(%a0) |
| mov.l 0x8+0x8(%a6),0x8(%a0) |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| tst.b %d1 |
| bne.b _L11_2x |
| bsr.l stwotox # operand is a NORM |
| bra.b _L11_6x |
| _L11_2x: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L11_3x # no |
| bsr.l ld_pone # yes |
| bra.b _L11_6x |
| _L11_3x: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L11_4x # no |
| bsr.l szr_inf # yes |
| bra.b _L11_6x |
| _L11_4x: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L11_5x # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| |
| ######################################################################### |
| # MONADIC TEMPLATE # |
| ######################################################################### |
| global _ftentoxs_ |
| _ftentoxs_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| fmov.s 0x8(%a6),%fp0 # load sgl input |
| fmov.x %fp0,FP_SRC(%a6) |
| lea FP_SRC(%a6),%a0 |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| tst.b %d1 |
| bne.b _L12_2s |
| bsr.l stentox # operand is a NORM |
| bra.b _L12_6s |
| _L12_2s: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L12_3s # no |
| bsr.l ld_pone # yes |
| bra.b _L12_6s |
| _L12_3s: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L12_4s # no |
| bsr.l szr_inf # yes |
| bra.b _L12_6s |
| _L12_4s: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L12_5s # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| global _ftentoxd_ |
| _ftentoxd_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| fmov.d 0x8(%a6),%fp0 # load dbl input |
| fmov.x %fp0,FP_SRC(%a6) |
| lea FP_SRC(%a6),%a0 |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| mov.b %d1,STAG(%a6) |
| tst.b %d1 |
| bne.b _L12_2d |
| bsr.l stentox # operand is a NORM |
| bra.b _L12_6d |
| _L12_2d: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L12_3d # no |
| bsr.l ld_pone # yes |
| bra.b _L12_6d |
| _L12_3d: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L12_4d # no |
| bsr.l szr_inf # yes |
| bra.b _L12_6d |
| _L12_4d: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L12_5d # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| global _ftentoxx_ |
| _ftentoxx_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| lea FP_SRC(%a6),%a0 |
| mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input |
| mov.l 0x8+0x4(%a6),0x4(%a0) |
| mov.l 0x8+0x8(%a6),0x8(%a0) |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| tst.b %d1 |
| bne.b _L12_2x |
| bsr.l stentox # operand is a NORM |
| bra.b _L12_6x |
| _L12_2x: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L12_3x # no |
| bsr.l ld_pone # yes |
| bra.b _L12_6x |
| _L12_3x: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L12_4x # no |
| bsr.l szr_inf # yes |
| bra.b _L12_6x |
| _L12_4x: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L12_5x # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| |
| ######################################################################### |
| # MONADIC TEMPLATE # |
| ######################################################################### |
| global _flogns_ |
| _flogns_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| fmov.s 0x8(%a6),%fp0 # load sgl input |
| fmov.x %fp0,FP_SRC(%a6) |
| lea FP_SRC(%a6),%a0 |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| tst.b %d1 |
| bne.b _L13_2s |
| bsr.l slogn # operand is a NORM |
| bra.b _L13_6s |
| _L13_2s: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L13_3s # no |
| bsr.l t_dz2 # yes |
| bra.b _L13_6s |
| _L13_3s: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L13_4s # no |
| bsr.l sopr_inf # yes |
| bra.b _L13_6s |
| _L13_4s: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L13_5s # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| global _flognd_ |
| _flognd_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| fmov.d 0x8(%a6),%fp0 # load dbl input |
| fmov.x %fp0,FP_SRC(%a6) |
| lea FP_SRC(%a6),%a0 |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| mov.b %d1,STAG(%a6) |
| tst.b %d1 |
| bne.b _L13_2d |
| bsr.l slogn # operand is a NORM |
| bra.b _L13_6d |
| _L13_2d: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L13_3d # no |
| bsr.l t_dz2 # yes |
| bra.b _L13_6d |
| _L13_3d: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L13_4d # no |
| bsr.l sopr_inf # yes |
| bra.b _L13_6d |
| _L13_4d: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L13_5d # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| global _flognx_ |
| _flognx_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| lea FP_SRC(%a6),%a0 |
| mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input |
| mov.l 0x8+0x4(%a6),0x4(%a0) |
| mov.l 0x8+0x8(%a6),0x8(%a0) |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| tst.b %d1 |
| bne.b _L13_2x |
| bsr.l slogn # operand is a NORM |
| bra.b _L13_6x |
| _L13_2x: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L13_3x # no |
| bsr.l t_dz2 # yes |
| bra.b _L13_6x |
| _L13_3x: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L13_4x # no |
| bsr.l sopr_inf # yes |
| bra.b _L13_6x |
| _L13_4x: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L13_5x # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| |
| ######################################################################### |
| # MONADIC TEMPLATE # |
| ######################################################################### |
| global _flog10s_ |
| _flog10s_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| fmov.s 0x8(%a6),%fp0 # load sgl input |
| fmov.x %fp0,FP_SRC(%a6) |
| lea FP_SRC(%a6),%a0 |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| tst.b %d1 |
| bne.b _L14_2s |
| bsr.l slog10 # operand is a NORM |
| bra.b _L14_6s |
| _L14_2s: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L14_3s # no |
| bsr.l t_dz2 # yes |
| bra.b _L14_6s |
| _L14_3s: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L14_4s # no |
| bsr.l sopr_inf # yes |
| bra.b _L14_6s |
| _L14_4s: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L14_5s # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| global _flog10d_ |
| _flog10d_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| fmov.d 0x8(%a6),%fp0 # load dbl input |
| fmov.x %fp0,FP_SRC(%a6) |
| lea FP_SRC(%a6),%a0 |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| mov.b %d1,STAG(%a6) |
| tst.b %d1 |
| bne.b _L14_2d |
| bsr.l slog10 # operand is a NORM |
| bra.b _L14_6d |
| _L14_2d: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L14_3d # no |
| bsr.l t_dz2 # yes |
| bra.b _L14_6d |
| _L14_3d: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L14_4d # no |
| bsr.l sopr_inf # yes |
| bra.b _L14_6d |
| _L14_4d: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L14_5d # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| global _flog10x_ |
| _flog10x_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| lea FP_SRC(%a6),%a0 |
| mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input |
| mov.l 0x8+0x4(%a6),0x4(%a0) |
| mov.l 0x8+0x8(%a6),0x8(%a0) |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| tst.b %d1 |
| bne.b _L14_2x |
| bsr.l slog10 # operand is a NORM |
| bra.b _L14_6x |
| _L14_2x: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L14_3x # no |
| bsr.l t_dz2 # yes |
| bra.b _L14_6x |
| _L14_3x: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L14_4x # no |
| bsr.l sopr_inf # yes |
| bra.b _L14_6x |
| _L14_4x: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L14_5x # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| |
| ######################################################################### |
| # MONADIC TEMPLATE # |
| ######################################################################### |
| global _flog2s_ |
| _flog2s_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| fmov.s 0x8(%a6),%fp0 # load sgl input |
| fmov.x %fp0,FP_SRC(%a6) |
| lea FP_SRC(%a6),%a0 |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| tst.b %d1 |
| bne.b _L15_2s |
| bsr.l slog2 # operand is a NORM |
| bra.b _L15_6s |
| _L15_2s: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L15_3s # no |
| bsr.l t_dz2 # yes |
| bra.b _L15_6s |
| _L15_3s: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L15_4s # no |
| bsr.l sopr_inf # yes |
| bra.b _L15_6s |
| _L15_4s: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L15_5s # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| global _flog2d_ |
| _flog2d_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| fmov.d 0x8(%a6),%fp0 # load dbl input |
| fmov.x %fp0,FP_SRC(%a6) |
| lea FP_SRC(%a6),%a0 |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| mov.b %d1,STAG(%a6) |
| tst.b %d1 |
| bne.b _L15_2d |
| bsr.l slog2 # operand is a NORM |
| bra.b _L15_6d |
| _L15_2d: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L15_3d # no |
| bsr.l t_dz2 # yes |
| bra.b _L15_6d |
| _L15_3d: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L15_4d # no |
| bsr.l sopr_inf # yes |
| bra.b _L15_6d |
| _L15_4d: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L15_5d # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| global _flog2x_ |
| _flog2x_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| lea FP_SRC(%a6),%a0 |
| mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input |
| mov.l 0x8+0x4(%a6),0x4(%a0) |
| mov.l 0x8+0x8(%a6),0x8(%a0) |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| tst.b %d1 |
| bne.b _L15_2x |
| bsr.l slog2 # operand is a NORM |
| bra.b _L15_6x |
| _L15_2x: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L15_3x # no |
| bsr.l t_dz2 # yes |
| bra.b _L15_6x |
| _L15_3x: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L15_4x # no |
| bsr.l sopr_inf # yes |
| bra.b _L15_6x |
| _L15_4x: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L15_5x # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| |
| ######################################################################### |
| # MONADIC TEMPLATE # |
| ######################################################################### |
| global _fcoshs_ |
| _fcoshs_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| fmov.s 0x8(%a6),%fp0 # load sgl input |
| fmov.x %fp0,FP_SRC(%a6) |
| lea FP_SRC(%a6),%a0 |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| tst.b %d1 |
| bne.b _L16_2s |
| bsr.l scosh # operand is a NORM |
| bra.b _L16_6s |
| _L16_2s: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L16_3s # no |
| bsr.l ld_pone # yes |
| bra.b _L16_6s |
| _L16_3s: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L16_4s # no |
| bsr.l ld_pinf # yes |
| bra.b _L16_6s |
| _L16_4s: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L16_5s # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| global _fcoshd_ |
| _fcoshd_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| fmov.d 0x8(%a6),%fp0 # load dbl input |
| fmov.x %fp0,FP_SRC(%a6) |
| lea FP_SRC(%a6),%a0 |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| mov.b %d1,STAG(%a6) |
| tst.b %d1 |
| bne.b _L16_2d |
| bsr.l scosh # operand is a NORM |
| bra.b _L16_6d |
| _L16_2d: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L16_3d # no |
| bsr.l ld_pone # yes |
| bra.b _L16_6d |
| _L16_3d: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L16_4d # no |
| bsr.l ld_pinf # yes |
| bra.b _L16_6d |
| _L16_4d: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L16_5d # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| global _fcoshx_ |
| _fcoshx_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| lea FP_SRC(%a6),%a0 |
| mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input |
| mov.l 0x8+0x4(%a6),0x4(%a0) |
| mov.l 0x8+0x8(%a6),0x8(%a0) |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| tst.b %d1 |
| bne.b _L16_2x |
| bsr.l scosh # operand is a NORM |
| bra.b _L16_6x |
| _L16_2x: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L16_3x # no |
| bsr.l ld_pone # yes |
| bra.b _L16_6x |
| _L16_3x: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L16_4x # no |
| bsr.l ld_pinf # yes |
| bra.b _L16_6x |
| _L16_4x: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L16_5x # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| |
| ######################################################################### |
| # MONADIC TEMPLATE # |
| ######################################################################### |
| global _facoss_ |
| _facoss_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| fmov.s 0x8(%a6),%fp0 # load sgl input |
| fmov.x %fp0,FP_SRC(%a6) |
| lea FP_SRC(%a6),%a0 |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| tst.b %d1 |
| bne.b _L17_2s |
| bsr.l sacos # operand is a NORM |
| bra.b _L17_6s |
| _L17_2s: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L17_3s # no |
| bsr.l ld_ppi2 # yes |
| bra.b _L17_6s |
| _L17_3s: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L17_4s # no |
| bsr.l t_operr # yes |
| bra.b _L17_6s |
| _L17_4s: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L17_5s # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| global _facosd_ |
| _facosd_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| fmov.d 0x8(%a6),%fp0 # load dbl input |
| fmov.x %fp0,FP_SRC(%a6) |
| lea FP_SRC(%a6),%a0 |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| mov.b %d1,STAG(%a6) |
| tst.b %d1 |
| bne.b _L17_2d |
| bsr.l sacos # operand is a NORM |
| bra.b _L17_6d |
| _L17_2d: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L17_3d # no |
| bsr.l ld_ppi2 # yes |
| bra.b _L17_6d |
| _L17_3d: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L17_4d # no |
| bsr.l t_operr # yes |
| bra.b _L17_6d |
| _L17_4d: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L17_5d # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| global _facosx_ |
| _facosx_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| lea FP_SRC(%a6),%a0 |
| mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input |
| mov.l 0x8+0x4(%a6),0x4(%a0) |
| mov.l 0x8+0x8(%a6),0x8(%a0) |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| tst.b %d1 |
| bne.b _L17_2x |
| bsr.l sacos # operand is a NORM |
| bra.b _L17_6x |
| _L17_2x: |
| cmpi.b %d1,&ZERO # is operand a ZERO? |
| bne.b _L17_3x # no |
| bsr.l ld_ppi2 # yes |
| bra.b _L17_6x |
| _L17_3x: |
| cmpi.b %d1,&INF # is operand an INF? |
| bne.b _L17_4x # no |
| bsr.l t_operr # yes |
| bra.b _L17_6x |
| _L17_4x: |
| cmpi.b %d1,&QNAN # is operand a QNAN? |
| bne.b _L17_5x # no |
| bsr.l src_qnan # yes |
| bra.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-a1 |
| fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs |
| fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 |
| unlk %a6 |
| rts |
| |
| |
| ######################################################################### |
| # MONADIC TEMPLATE # |
| ######################################################################### |
| global _fgetexps_ |
| _fgetexps_: |
| link %a6,&-LOCAL_SIZE |
| |
| movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 |
| fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs |
| fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 |
| |
| fmov.l &0x0,%fpcr # zero FPCR |
| |
| # |
| # copy, convert, and tag input argument |
| # |
| fmov.s 0x8(%a6),%fp0 # load sgl input |
| fmov.x %fp0,FP_SRC(%a6) |
| lea FP_SRC(%a6),%a0 |
| bsr.l tag # fetch operand type |
| mov.b %d0,STAG(%a6) |
| mov.b %d0,%d1 |
| |
| andi.l &0x00ff00ff,USER_FPSR(%a6) |
| |
| clr.l %d0 |
| mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec |
| |
| tst.b %d1 |
| bne.b _L18_2s |
| |
