1 // SPDX-License-Identifier: GPL-2.0 2 /*---------------------------------------------------------------------------+ 3 | reg_divide.c | 4 | | 5 | Divide one FPU_REG by another and put the result in a destination FPU_REG.| 6 | | 7 | Copyright (C) 1996 | 8 | W. Metzenthen, 22 Parker St, Ormond, Vic 3163, Australia | 9 | E-mail billm@jacobi.maths.monash.edu.au | 10 | | 11 | Return value is the tag of the answer, or-ed with FPU_Exception if | 12 | one was raised, or -1 on internal error. | 13 | | 14 +---------------------------------------------------------------------------*/ 15 16 /*---------------------------------------------------------------------------+ 17 | The destination may be any FPU_REG, including one of the source FPU_REGs. | 18 +---------------------------------------------------------------------------*/ 19 20 #include "exception.h" 21 #include "reg_constant.h" 22 #include "fpu_emu.h" 23 #include "fpu_system.h" 24 25 /* 26 Divide one register by another and put the result into a third register. 27 */ 28 int FPU_div(int flags, int rm, int control_w) 29 { 30 FPU_REG x, y; 31 FPU_REG const *a, *b, *st0_ptr, *st_ptr; 32 FPU_REG *dest; 33 u_char taga, tagb, signa, signb, sign, saved_sign; 34 int tag, deststnr; 35 36 if (flags & DEST_RM) 37 deststnr = rm; 38 else 39 deststnr = 0; 40 41 if (flags & REV) { 42 b = &st(0); 43 st0_ptr = b; 44 tagb = FPU_gettag0(); 45 if (flags & LOADED) { 46 a = (FPU_REG *) rm; 47 taga = flags & 0x0f; 48 } else { 49 a = &st(rm); 50 st_ptr = a; 51 taga = FPU_gettagi(rm); 52 } 53 } else { 54 a = &st(0); 55 st0_ptr = a; 56 taga = FPU_gettag0(); 57 if (flags & LOADED) { 58 b = (FPU_REG *) rm; 59 tagb = flags & 0x0f; 60 } else { 61 b = &st(rm); 62 st_ptr = b; 63 tagb = FPU_gettagi(rm); 64 } 65 } 66 67 signa = getsign(a); 68 signb = getsign(b); 69 70 sign = signa ^ signb; 71 72 dest = &st(deststnr); 73 saved_sign = getsign(dest); 74 75 if (!(taga | tagb)) { 76 /* Both regs Valid, this should be the most common case. */ 77 reg_copy(a, &x); 78 reg_copy(b, &y); 79 setpositive(&x); 80 setpositive(&y); 81 tag = FPU_u_div(&x, &y, dest, control_w, sign); 82 83 if (tag < 0) 84 return tag; 85 86 FPU_settagi(deststnr, tag); 87 return tag; 88 } 89 90 if (taga == TAG_Special) 91 taga = FPU_Special(a); 92 if (tagb == TAG_Special) 93 tagb = FPU_Special(b); 94 95 if (((taga == TAG_Valid) && (tagb == TW_Denormal)) 96 || ((taga == TW_Denormal) && (tagb == TAG_Valid)) 97 || ((taga == TW_Denormal) && (tagb == TW_Denormal))) { 98 if (denormal_operand() < 0) 99 return FPU_Exception; 100 101 FPU_to_exp16(a, &x); 102 FPU_to_exp16(b, &y); 103 tag = FPU_u_div(&x, &y, dest, control_w, sign); 104 if (tag < 0) 105 return tag; 106 107 FPU_settagi(deststnr, tag); 108 return tag; 109 } else if ((taga <= TW_Denormal) && (tagb <= TW_Denormal)) { 110 if (tagb != TAG_Zero) { 111 /* Want to find Zero/Valid */ 112 if (tagb == TW_Denormal) { 113 if (denormal_operand() < 0) 114 return FPU_Exception; 115 } 116 117 /* The result is zero. */ 118 FPU_copy_to_regi(&CONST_Z, TAG_Zero, deststnr); 119 setsign(dest, sign); 120 return TAG_Zero; 121 } 122 /* We have an exception condition, either 0/0 or Valid/Zero. */ 123 if (taga == TAG_Zero) { 124 /* 0/0 */ 125 return arith_invalid(deststnr); 126 } 127 /* Valid/Zero */ 128 return FPU_divide_by_zero(deststnr, sign); 129 } 130 /* Must have infinities, NaNs, etc */ 131 else if ((taga == TW_NaN) || (tagb == TW_NaN)) { 132 if (flags & LOADED) 133 return real_2op_NaN((FPU_REG *) rm, flags & 0x0f, 0, 134 st0_ptr); 135 136 if (flags & DEST_RM) { 137 int tag; 138 tag = FPU_gettag0(); 139 if (tag == TAG_Special) 140 tag = FPU_Special(st0_ptr); 141 return real_2op_NaN(st0_ptr, tag, rm, 142 (flags & REV) ? st0_ptr : &st(rm)); 143 } else { 144 int tag; 145 tag = FPU_gettagi(rm); 146 if (tag == TAG_Special) 147 tag = FPU_Special(&st(rm)); 148 return real_2op_NaN(&st(rm), tag, 0, 149 (flags & REV) ? st0_ptr : &st(rm)); 150 } 151 } else if (taga == TW_Infinity) { 152 if (tagb == TW_Infinity) { 153 /* infinity/infinity */ 154 return arith_invalid(deststnr); 155 } else { 156 /* tagb must be Valid or Zero */ 157 if ((tagb == TW_Denormal) && (denormal_operand() < 0)) 158 return FPU_Exception; 159 160 /* Infinity divided by Zero or Valid does 161 not raise and exception, but returns Infinity */ 162 FPU_copy_to_regi(a, TAG_Special, deststnr); 163 setsign(dest, sign); 164 return taga; 165 } 166 } else if (tagb == TW_Infinity) { 167 if ((taga == TW_Denormal) && (denormal_operand() < 0)) 168 return FPU_Exception; 169 170 /* The result is zero. */ 171 FPU_copy_to_regi(&CONST_Z, TAG_Zero, deststnr); 172 setsign(dest, sign); 173 return TAG_Zero; 174 } 175 #ifdef PARANOID 176 else { 177 EXCEPTION(EX_INTERNAL | 0x102); 178 return FPU_Exception; 179 } 180 #endif /* PARANOID */ 181 182 return 0; 183 } 184