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   */
FPU_div(int flags,int rm,int control_w)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