diff options
Diffstat (limited to 'c/src/lib/libcpu/m68k/m68040/fpsp/util.s')
-rw-r--r-- | c/src/lib/libcpu/m68k/m68040/fpsp/util.s | 748 |
1 files changed, 748 insertions, 0 deletions
diff --git a/c/src/lib/libcpu/m68k/m68040/fpsp/util.s b/c/src/lib/libcpu/m68k/m68040/fpsp/util.s new file mode 100644 index 0000000000..c6f6570437 --- /dev/null +++ b/c/src/lib/libcpu/m68k/m68040/fpsp/util.s @@ -0,0 +1,748 @@ +// +// util.sa 3.7 7/29/91 +// +// This file contains routines used by other programs. +// +// ovf_res: used by overflow to force the correct +// result. ovf_r_k, ovf_r_x2, ovf_r_x3 are +// derivatives of this routine. +// get_fline: get user's opcode word +// g_dfmtou: returns the destination format. +// g_opcls: returns the opclass of the float instruction. +// g_rndpr: returns the rounding precision. +// reg_dest: write byte, word, or long data to Dn +// +// +// Copyright (C) Motorola, Inc. 1990 +// All Rights Reserved +// +// THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA +// The copyright notice above does not evidence any +// actual or intended publication of such source code. + +//UTIL idnt 2,1 | Motorola 040 Floating Point Software Package + + |section 8 + + .include "fpsp.defs" + + |xref mem_read + + .global g_dfmtou + .global g_opcls + .global g_rndpr + .global get_fline + .global reg_dest + +// +// Final result table for ovf_res. Note that the negative counterparts +// are unnecessary as ovf_res always returns the sign separately from +// the exponent. +// ;+inf +EXT_PINF: .long 0x7fff0000,0x00000000,0x00000000,0x00000000 +// ;largest +ext +EXT_PLRG: .long 0x7ffe0000,0xffffffff,0xffffffff,0x00000000 +// ;largest magnitude +sgl in ext +SGL_PLRG: .long 0x407e0000,0xffffff00,0x00000000,0x00000000 +// ;largest magnitude +dbl in ext +DBL_PLRG: .long 0x43fe0000,0xffffffff,0xfffff800,0x00000000 +// ;largest -ext + +tblovfl: + .long EXT_RN + .long EXT_RZ + .long EXT_RM + .long EXT_RP + .long SGL_RN + .long SGL_RZ + .long SGL_RM + .long SGL_RP + .long DBL_RN + .long DBL_RZ + .long DBL_RM + .long DBL_RP + .long error + .long error + .long error + .long error + + +// +// ovf_r_k --- overflow result calculation +// +// This entry point is used by kernel_ex. +// +// This forces the destination precision to be extended +// +// Input: operand in ETEMP +// Output: a result is in ETEMP (internal extended format) +// + .global ovf_r_k +ovf_r_k: + lea ETEMP(%a6),%a0 //a0 points to source operand + bclrb #sign_bit,ETEMP_EX(%a6) + sne ETEMP_SGN(%a6) //convert to internal IEEE format + +// +// ovf_r_x2 --- overflow result calculation +// +// This entry point used by x_ovfl. (opclass 0 and 2) +// +// Input a0 points to an operand in the internal extended format +// Output a0 points to the result in the internal extended format +// +// This sets the round precision according to the user's FPCR unless the +// instruction is fsgldiv or fsglmul or fsadd, fdadd, fsub, fdsub, fsmul, +// fdmul, fsdiv, fddiv, fssqrt, fsmove, fdmove, fsabs, fdabs, fsneg, fdneg. +// If the instruction is fsgldiv of fsglmul, the rounding precision must be +// extended. If the instruction is not fsgldiv or fsglmul but a force- +// precision instruction, the rounding precision is then set to the force +// precision. + + .global ovf_r_x2 +ovf_r_x2: + btstb #E3,E_BYTE(%a6) //check for nu exception + beql ovf_e1_exc //it is cu exception +ovf_e3_exc: + movew CMDREG3B(%a6),%d0 //get the command word + andiw #0x00000060,%d0 //clear all bits except 6 and 5 + cmpil #0x00000040,%d0 + beql ovff_sgl //force precision is single + cmpil #0x00000060,%d0 + beql ovff_dbl //force precision is double + movew CMDREG3B(%a6),%d0 //get the command word again + andil #0x7f,%d0 //clear all except operation + cmpil #0x33,%d0 + beql ovf_fsgl //fsglmul or fsgldiv + cmpil #0x30,%d0 + beql ovf_fsgl + bra ovf_fpcr //instruction is none of the above +// ;use FPCR +ovf_e1_exc: + movew CMDREG1B(%a6),%d0 //get command word + andil #0x00000044,%d0 //clear all bits except 6 and 2 + cmpil #0x00000040,%d0 + beql ovff_sgl //the instruction is force single + cmpil #0x00000044,%d0 + beql ovff_dbl //the instruction is force double + movew CMDREG1B(%a6),%d0 //again get the command word + andil #0x0000007f,%d0 //clear all except the op code + cmpil #0x00000027,%d0 + beql ovf_fsgl //fsglmul + cmpil #0x00000024,%d0 + beql ovf_fsgl //fsgldiv + bra ovf_fpcr //none of the above, use FPCR +// +// +// Inst is either fsgldiv or fsglmul. Force extended precision. +// +ovf_fsgl: + clrl %d0 + bras ovf_res + +ovff_sgl: + movel #0x00000001,%d0 //set single + bras ovf_res +ovff_dbl: + movel #0x00000002,%d0 //set double + bras ovf_res +// +// The precision is in the fpcr. +// +ovf_fpcr: + bfextu FPCR_MODE(%a6){#0:#2},%d0 //set round precision + bras ovf_res + +// +// +// ovf_r_x3 --- overflow result calculation +// +// This entry point used by x_ovfl. (opclass 3 only) +// +// Input a0 points to an operand in the internal extended format +// Output a0 points to the result in the internal extended format +// +// This sets the round precision according to the destination size. +// + .global ovf_r_x3 +ovf_r_x3: + bsr g_dfmtou //get dest fmt in d0{1:0} +// ;for fmovout, the destination format +// ;is the rounding precision + +// +// ovf_res --- overflow result calculation +// +// Input: +// a0 points to operand in internal extended format +// Output: +// a0 points to result in internal extended format +// + .global ovf_res +ovf_res: + lsll #2,%d0 //move round precision to d0{3:2} + bfextu FPCR_MODE(%a6){#2:#2},%d1 //set round mode + orl %d1,%d0 //index is fmt:mode in d0{3:0} + leal tblovfl,%a1 //load a1 with table address + movel %a1@(%d0:l:4),%a1 //use d0 as index to the table + jmp (%a1) //go to the correct routine +// +//case DEST_FMT = EXT +// +EXT_RN: + leal EXT_PINF,%a1 //answer is +/- infinity + bsetb #inf_bit,FPSR_CC(%a6) + bra set_sign //now go set the sign +EXT_RZ: + leal EXT_PLRG,%a1 //answer is +/- large number + bra set_sign //now go set the sign +EXT_RM: + tstb LOCAL_SGN(%a0) //if negative overflow + beqs e_rm_pos +e_rm_neg: + leal EXT_PINF,%a1 //answer is negative infinity + orl #neginf_mask,USER_FPSR(%a6) + bra end_ovfr +e_rm_pos: + leal EXT_PLRG,%a1 //answer is large positive number + bra end_ovfr +EXT_RP: + tstb LOCAL_SGN(%a0) //if negative overflow + beqs e_rp_pos +e_rp_neg: + leal EXT_PLRG,%a1 //answer is large negative number + bsetb #neg_bit,FPSR_CC(%a6) + bra end_ovfr +e_rp_pos: + leal EXT_PINF,%a1 //answer is positive infinity + bsetb #inf_bit,FPSR_CC(%a6) + bra end_ovfr +// +//case DEST_FMT = DBL +// +DBL_RN: + leal EXT_PINF,%a1 //answer is +/- infinity + bsetb #inf_bit,FPSR_CC(%a6) + bra set_sign +DBL_RZ: + leal DBL_PLRG,%a1 //answer is +/- large number + bra set_sign //now go set the sign +DBL_RM: + tstb LOCAL_SGN(%a0) //if negative overflow + beqs d_rm_pos +d_rm_neg: + leal EXT_PINF,%a1 //answer is negative infinity + orl #neginf_mask,USER_FPSR(%a6) + bra end_ovfr //inf is same for all precisions (ext,dbl,sgl) +d_rm_pos: + leal DBL_PLRG,%a1 //answer is large positive number + bra end_ovfr +DBL_RP: + tstb LOCAL_SGN(%a0) //if negative overflow + beqs d_rp_pos +d_rp_neg: + leal DBL_PLRG,%a1 //answer is large negative number + bsetb #neg_bit,FPSR_CC(%a6) + bra end_ovfr +d_rp_pos: + leal EXT_PINF,%a1 //answer is positive infinity + bsetb #inf_bit,FPSR_CC(%a6) + bra end_ovfr +// +//case DEST_FMT = SGL +// +SGL_RN: + leal EXT_PINF,%a1 //answer is +/- infinity + bsetb #inf_bit,FPSR_CC(%a6) + bras set_sign +SGL_RZ: + leal SGL_PLRG,%a1 //answer is +/- large number + bras set_sign +SGL_RM: + tstb LOCAL_SGN(%a0) //if negative overflow + beqs s_rm_pos +s_rm_neg: + leal EXT_PINF,%a1 //answer is negative infinity + orl #neginf_mask,USER_FPSR(%a6) + bras end_ovfr +s_rm_pos: + leal SGL_PLRG,%a1 //answer is large positive number + bras end_ovfr +SGL_RP: + tstb LOCAL_SGN(%a0) //if negative overflow + beqs s_rp_pos +s_rp_neg: + leal SGL_PLRG,%a1 //answer is large negative number + bsetb #neg_bit,FPSR_CC(%a6) + bras end_ovfr +s_rp_pos: + leal EXT_PINF,%a1 //answer is positive infinity + bsetb #inf_bit,FPSR_CC(%a6) + bras end_ovfr + +set_sign: + tstb LOCAL_SGN(%a0) //if negative overflow + beqs end_ovfr +neg_sign: + bsetb #neg_bit,FPSR_CC(%a6) + +end_ovfr: + movew LOCAL_EX(%a1),LOCAL_EX(%a0) //do not overwrite sign + movel LOCAL_HI(%a1),LOCAL_HI(%a0) + movel LOCAL_LO(%a1),LOCAL_LO(%a0) + rts + + +// +// ERROR +// +error: + rts +// +// get_fline --- get f-line opcode of interrupted instruction +// +// Returns opcode in the low word of d0. +// +get_fline: + movel USER_FPIAR(%a6),%a0 //opcode address + movel #0,-(%a7) //reserve a word on the stack + leal 2(%a7),%a1 //point to low word of temporary + movel #2,%d0 //count + bsrl mem_read + movel (%a7)+,%d0 + rts +// +// g_rndpr --- put rounding precision in d0{1:0} +// +// valid return codes are: +// 00 - extended +// 01 - single +// 10 - double +// +// begin +// get rounding precision (cmdreg3b{6:5}) +// begin +// case opclass = 011 (move out) +// get destination format - this is the also the rounding precision +// +// case opclass = 0x0 +// if E3 +// *case RndPr(from cmdreg3b{6:5} = 11 then RND_PREC = DBL +// *case RndPr(from cmdreg3b{6:5} = 10 then RND_PREC = SGL +// case RndPr(from cmdreg3b{6:5} = 00 | 01 +// use precision from FPCR{7:6} +// case 00 then RND_PREC = EXT +// case 01 then RND_PREC = SGL +// case 10 then RND_PREC = DBL +// else E1 +// use precision in FPCR{7:6} +// case 00 then RND_PREC = EXT +// case 01 then RND_PREC = SGL +// case 10 then RND_PREC = DBL +// end +// +g_rndpr: + bsr g_opcls //get opclass in d0{2:0} + cmpw #0x0003,%d0 //check for opclass 011 + bnes op_0x0 + +// +// For move out instructions (opclass 011) the destination format +// is the same as the rounding precision. Pass results from g_dfmtou. +// + bsr g_dfmtou + rts +op_0x0: + btstb #E3,E_BYTE(%a6) + beql unf_e1_exc //branch to e1 underflow +unf_e3_exc: + movel CMDREG3B(%a6),%d0 //rounding precision in d0{10:9} + bfextu %d0{#9:#2},%d0 //move the rounding prec bits to d0{1:0} + cmpil #0x2,%d0 + beql unff_sgl //force precision is single + cmpil #0x3,%d0 //force precision is double + beql unff_dbl + movew CMDREG3B(%a6),%d0 //get the command word again + andil #0x7f,%d0 //clear all except operation + cmpil #0x33,%d0 + beql unf_fsgl //fsglmul or fsgldiv + cmpil #0x30,%d0 + beql unf_fsgl //fsgldiv or fsglmul + bra unf_fpcr +unf_e1_exc: + movel CMDREG1B(%a6),%d0 //get 32 bits off the stack, 1st 16 bits +// ;are the command word + andil #0x00440000,%d0 //clear all bits except bits 6 and 2 + cmpil #0x00400000,%d0 + beql unff_sgl //force single + cmpil #0x00440000,%d0 //force double + beql unff_dbl + movel CMDREG1B(%a6),%d0 //get the command word again + andil #0x007f0000,%d0 //clear all bits except the operation + cmpil #0x00270000,%d0 + beql unf_fsgl //fsglmul + cmpil #0x00240000,%d0 + beql unf_fsgl //fsgldiv + bra unf_fpcr + +// +// Convert to return format. The values from cmdreg3b and the return +// values are: +// cmdreg3b return precision +// -------- ------ --------- +// 00,01 0 ext +// 10 1 sgl +// 11 2 dbl +// Force single +// +unff_sgl: + movel #1,%d0 //return 1 + rts +// +// Force double +// +unff_dbl: + movel #2,%d0 //return 2 + rts +// +// Force extended +// +unf_fsgl: + movel #0,%d0 + rts +// +// Get rounding precision set in FPCR{7:6}. +// +unf_fpcr: + movel USER_FPCR(%a6),%d0 //rounding precision bits in d0{7:6} + bfextu %d0{#24:#2},%d0 //move the rounding prec bits to d0{1:0} + rts +// +// g_opcls --- put opclass in d0{2:0} +// +g_opcls: + btstb #E3,E_BYTE(%a6) + beqs opc_1b //if set, go to cmdreg1b +opc_3b: + clrl %d0 //if E3, only opclass 0x0 is possible + rts +opc_1b: + movel CMDREG1B(%a6),%d0 + bfextu %d0{#0:#3},%d0 //shift opclass bits d0{31:29} to d0{2:0} + rts +// +// g_dfmtou --- put destination format in d0{1:0} +// +// If E1, the format is from cmdreg1b{12:10} +// If E3, the format is extended. +// +// Dest. Fmt. +// extended 010 -> 00 +// single 001 -> 01 +// double 101 -> 10 +// +g_dfmtou: + btstb #E3,E_BYTE(%a6) + beqs op011 + clrl %d0 //if E1, size is always ext + rts +op011: + movel CMDREG1B(%a6),%d0 + bfextu %d0{#3:#3},%d0 //dest fmt from cmdreg1b{12:10} + cmpb #1,%d0 //check for single + bnes not_sgl + movel #1,%d0 + rts +not_sgl: + cmpb #5,%d0 //check for double + bnes not_dbl + movel #2,%d0 + rts +not_dbl: + clrl %d0 //must be extended + rts + +// +// +// Final result table for unf_sub. Note that the negative counterparts +// are unnecessary as unf_sub always returns the sign separately from +// the exponent. +// ;+zero +EXT_PZRO: .long 0x00000000,0x00000000,0x00000000,0x00000000 +// ;+zero +SGL_PZRO: .long 0x3f810000,0x00000000,0x00000000,0x00000000 +// ;+zero +DBL_PZRO: .long 0x3c010000,0x00000000,0x00000000,0x00000000 +// ;smallest +ext denorm +EXT_PSML: .long 0x00000000,0x00000000,0x00000001,0x00000000 +// ;smallest +sgl denorm +SGL_PSML: .long 0x3f810000,0x00000100,0x00000000,0x00000000 +// ;smallest +dbl denorm +DBL_PSML: .long 0x3c010000,0x00000000,0x00000800,0x00000000 +// +// UNF_SUB --- underflow result calculation +// +// Input: +// d0 contains round precision +// a0 points to input operand in the internal extended format +// +// Output: +// a0 points to correct internal extended precision result. +// + +tblunf: + .long uEXT_RN + .long uEXT_RZ + .long uEXT_RM + .long uEXT_RP + .long uSGL_RN + .long uSGL_RZ + .long uSGL_RM + .long uSGL_RP + .long uDBL_RN + .long uDBL_RZ + .long uDBL_RM + .long uDBL_RP + .long uDBL_RN + .long uDBL_RZ + .long uDBL_RM + .long uDBL_RP + + .global unf_sub +unf_sub: + lsll #2,%d0 //move round precision to d0{3:2} + bfextu FPCR_MODE(%a6){#2:#2},%d1 //set round mode + orl %d1,%d0 //index is fmt:mode in d0{3:0} + leal tblunf,%a1 //load a1 with table address + movel %a1@(%d0:l:4),%a1 //use d0 as index to the table + jmp (%a1) //go to the correct routine +// +//case DEST_FMT = EXT +// +uEXT_RN: + leal EXT_PZRO,%a1 //answer is +/- zero + bsetb #z_bit,FPSR_CC(%a6) + bra uset_sign //now go set the sign +uEXT_RZ: + leal EXT_PZRO,%a1 //answer is +/- zero + bsetb #z_bit,FPSR_CC(%a6) + bra uset_sign //now go set the sign +uEXT_RM: + tstb LOCAL_SGN(%a0) //if negative underflow + beqs ue_rm_pos +ue_rm_neg: + leal EXT_PSML,%a1 //answer is negative smallest denorm + bsetb #neg_bit,FPSR_CC(%a6) + bra end_unfr +ue_rm_pos: + leal EXT_PZRO,%a1 //answer is positive zero + bsetb #z_bit,FPSR_CC(%a6) + bra end_unfr +uEXT_RP: + tstb LOCAL_SGN(%a0) //if negative underflow + beqs ue_rp_pos +ue_rp_neg: + leal EXT_PZRO,%a1 //answer is negative zero + oril #negz_mask,USER_FPSR(%a6) + bra end_unfr +ue_rp_pos: + leal EXT_PSML,%a1 //answer is positive smallest denorm + bra end_unfr +// +//case DEST_FMT = DBL +// +uDBL_RN: + leal DBL_PZRO,%a1 //answer is +/- zero + bsetb #z_bit,FPSR_CC(%a6) + bra uset_sign +uDBL_RZ: + leal DBL_PZRO,%a1 //answer is +/- zero + bsetb #z_bit,FPSR_CC(%a6) + bra uset_sign //now go set the sign +uDBL_RM: + tstb LOCAL_SGN(%a0) //if negative overflow + beqs ud_rm_pos +ud_rm_neg: + leal DBL_PSML,%a1 //answer is smallest denormalized negative + bsetb #neg_bit,FPSR_CC(%a6) + bra end_unfr +ud_rm_pos: + leal DBL_PZRO,%a1 //answer is positive zero + bsetb #z_bit,FPSR_CC(%a6) + bra end_unfr +uDBL_RP: + tstb LOCAL_SGN(%a0) //if negative overflow + beqs ud_rp_pos +ud_rp_neg: + leal DBL_PZRO,%a1 //answer is negative zero + oril #negz_mask,USER_FPSR(%a6) + bra end_unfr +ud_rp_pos: + leal DBL_PSML,%a1 //answer is smallest denormalized negative + bra end_unfr +// +//case DEST_FMT = SGL +// +uSGL_RN: + leal SGL_PZRO,%a1 //answer is +/- zero + bsetb #z_bit,FPSR_CC(%a6) + bras uset_sign +uSGL_RZ: + leal SGL_PZRO,%a1 //answer is +/- zero + bsetb #z_bit,FPSR_CC(%a6) + bras uset_sign +uSGL_RM: + tstb LOCAL_SGN(%a0) //if negative overflow + beqs us_rm_pos +us_rm_neg: + leal SGL_PSML,%a1 //answer is smallest denormalized negative + bsetb #neg_bit,FPSR_CC(%a6) + bras end_unfr +us_rm_pos: + leal SGL_PZRO,%a1 //answer is positive zero + bsetb #z_bit,FPSR_CC(%a6) + bras end_unfr +uSGL_RP: + tstb LOCAL_SGN(%a0) //if negative overflow + beqs us_rp_pos +us_rp_neg: + leal SGL_PZRO,%a1 //answer is negative zero + oril #negz_mask,USER_FPSR(%a6) + bras end_unfr +us_rp_pos: + leal SGL_PSML,%a1 //answer is smallest denormalized positive + bras end_unfr + +uset_sign: + tstb LOCAL_SGN(%a0) //if negative overflow + beqs end_unfr +uneg_sign: + bsetb #neg_bit,FPSR_CC(%a6) + +end_unfr: + movew LOCAL_EX(%a1),LOCAL_EX(%a0) //be careful not to overwrite sign + movel LOCAL_HI(%a1),LOCAL_HI(%a0) + movel LOCAL_LO(%a1),LOCAL_LO(%a0) + rts +// +// reg_dest --- write byte, word, or long data to Dn +// +// +// Input: +// L_SCR1: Data +// d1: data size and dest register number formatted as: +// +// 32 5 4 3 2 1 0 +// ----------------------------------------------- +// | 0 | Size | Dest Reg # | +// ----------------------------------------------- +// +// Size is: +// 0 - Byte +// 1 - Word +// 2 - Long/Single +// +pregdst: + .long byte_d0 + .long byte_d1 + .long byte_d2 + .long byte_d3 + .long byte_d4 + .long byte_d5 + .long byte_d6 + .long byte_d7 + .long word_d0 + .long word_d1 + .long word_d2 + .long word_d3 + .long word_d4 + .long word_d5 + .long word_d6 + .long word_d7 + .long long_d0 + .long long_d1 + .long long_d2 + .long long_d3 + .long long_d4 + .long long_d5 + .long long_d6 + .long long_d7 + +reg_dest: + leal pregdst,%a0 + movel %a0@(%d1:l:4),%a0 + jmp (%a0) + +byte_d0: + moveb L_SCR1(%a6),USER_D0+3(%a6) + rts +byte_d1: + moveb L_SCR1(%a6),USER_D1+3(%a6) + rts +byte_d2: + moveb L_SCR1(%a6),%d2 + rts +byte_d3: + moveb L_SCR1(%a6),%d3 + rts +byte_d4: + moveb L_SCR1(%a6),%d4 + rts +byte_d5: + moveb L_SCR1(%a6),%d5 + rts +byte_d6: + moveb L_SCR1(%a6),%d6 + rts +byte_d7: + moveb L_SCR1(%a6),%d7 + rts +word_d0: + movew L_SCR1(%a6),USER_D0+2(%a6) + rts +word_d1: + movew L_SCR1(%a6),USER_D1+2(%a6) + rts +word_d2: + movew L_SCR1(%a6),%d2 + rts +word_d3: + movew L_SCR1(%a6),%d3 + rts +word_d4: + movew L_SCR1(%a6),%d4 + rts +word_d5: + movew L_SCR1(%a6),%d5 + rts +word_d6: + movew L_SCR1(%a6),%d6 + rts +word_d7: + movew L_SCR1(%a6),%d7 + rts +long_d0: + movel L_SCR1(%a6),USER_D0(%a6) + rts +long_d1: + movel L_SCR1(%a6),USER_D1(%a6) + rts +long_d2: + movel L_SCR1(%a6),%d2 + rts +long_d3: + movel L_SCR1(%a6),%d3 + rts +long_d4: + movel L_SCR1(%a6),%d4 + rts +long_d5: + movel L_SCR1(%a6),%d5 + rts +long_d6: + movel L_SCR1(%a6),%d6 + rts +long_d7: + movel L_SCR1(%a6),%d7 + rts + |end |