1 // SPDX-License-Identifier: GPL-2.0
2 /*---------------------------------------------------------------------------+
3  |  reg_add_sub.c                                                            |
4  |                                                                           |
5  | Functions to add or subtract two registers and put the result in a third. |
6  |                                                                           |
7  | Copyright (C) 1992,1993,1997                                              |
8  |                  W. Metzenthen, 22 Parker St, Ormond, Vic 3163, Australia |
9  |                  E-mail   billm@suburbia.net                              |
10  |                                                                           |
11  |                                                                           |
12  +---------------------------------------------------------------------------*/
13 
14 /*---------------------------------------------------------------------------+
15  |  For each function, the destination may be any FPU_REG, including one of  |
16  | the source FPU_REGs.                                                      |
17  |  Each function returns 0 if the answer is o.k., otherwise a non-zero      |
18  | value is returned, indicating either an exception condition or an         |
19  | internal error.                                                           |
20  +---------------------------------------------------------------------------*/
21 
22 #include "exception.h"
23 #include "reg_constant.h"
24 #include "fpu_emu.h"
25 #include "control_w.h"
26 #include "fpu_system.h"
27 
28 static
29 int add_sub_specials(FPU_REG const *a, u_char taga, u_char signa,
30 		     FPU_REG const *b, u_char tagb, u_char signb,
31 		     FPU_REG * dest, int deststnr, int control_w);
32 
33 /*
34   Operates on st(0) and st(n), or on st(0) and temporary data.
35   The destination must be one of the source st(x).
36   */
FPU_add(FPU_REG const * b,u_char tagb,int deststnr,int control_w)37 int FPU_add(FPU_REG const *b, u_char tagb, int deststnr, int control_w)
38 {
39 	FPU_REG *a = &st(0);
40 	FPU_REG *dest = &st(deststnr);
41 	u_char signb = getsign(b);
42 	u_char taga = FPU_gettag0();
43 	u_char signa = getsign(a);
44 	u_char saved_sign = getsign(dest);
45 	int diff, tag, expa, expb;
46 
47 	if (!(taga | tagb)) {
48 		expa = exponent(a);
49 		expb = exponent(b);
50 
51 	      valid_add:
52 		/* Both registers are valid */
53 		if (!(signa ^ signb)) {
54 			/* signs are the same */
55 			tag =
56 			    FPU_u_add(a, b, dest, control_w, signa, expa, expb);
57 		} else {
58 			/* The signs are different, so do a subtraction */
59 			diff = expa - expb;
60 			if (!diff) {
61 				diff = a->sigh - b->sigh;	/* This works only if the ms bits
62 								   are identical. */
63 				if (!diff) {
64 					diff = a->sigl > b->sigl;
65 					if (!diff)
66 						diff = -(a->sigl < b->sigl);
67 				}
68 			}
69 
70 			if (diff > 0) {
71 				tag =
72 				    FPU_u_sub(a, b, dest, control_w, signa,
73 					      expa, expb);
74 			} else if (diff < 0) {
75 				tag =
76 				    FPU_u_sub(b, a, dest, control_w, signb,
77 					      expb, expa);
78 			} else {
79 				FPU_copy_to_regi(&CONST_Z, TAG_Zero, deststnr);
80 				/* sign depends upon rounding mode */
81 				setsign(dest, ((control_w & CW_RC) != RC_DOWN)
82 					? SIGN_POS : SIGN_NEG);
83 				return TAG_Zero;
84 			}
85 		}
86 
87 		if (tag < 0) {
88 			setsign(dest, saved_sign);
89 			return tag;
90 		}
91 		FPU_settagi(deststnr, tag);
92 		return tag;
93 	}
94 
95 	if (taga == TAG_Special)
96 		taga = FPU_Special(a);
97 	if (tagb == TAG_Special)
98 		tagb = FPU_Special(b);
99 
100 	if (((taga == TAG_Valid) && (tagb == TW_Denormal))
101 	    || ((taga == TW_Denormal) && (tagb == TAG_Valid))
102 	    || ((taga == TW_Denormal) && (tagb == TW_Denormal))) {
103 		FPU_REG x, y;
104 
105 		if (denormal_operand() < 0)
106 			return FPU_Exception;
107 
108 		FPU_to_exp16(a, &x);
109 		FPU_to_exp16(b, &y);
110 		a = &x;
111 		b = &y;
112 		expa = exponent16(a);
113 		expb = exponent16(b);
114 		goto valid_add;
115 	}
116 
117 	if ((taga == TW_NaN) || (tagb == TW_NaN)) {
118 		if (deststnr == 0)
119 			return real_2op_NaN(b, tagb, deststnr, a);
120 		else
121 			return real_2op_NaN(a, taga, deststnr, a);
122 	}
123 
124 	return add_sub_specials(a, taga, signa, b, tagb, signb,
125 				dest, deststnr, control_w);
126 }
127 
128 /* Subtract b from a.  (a-b) -> dest */
FPU_sub(int flags,int rm,int control_w)129 int FPU_sub(int flags, int rm, int control_w)
130 {
131 	FPU_REG const *a, *b;
132 	FPU_REG *dest;
133 	u_char taga, tagb, signa, signb, saved_sign, sign;
134 	int diff, tag = 0, expa, expb, deststnr;
135 
136 	a = &st(0);
137 	taga = FPU_gettag0();
138 
139 	deststnr = 0;
140 	if (flags & LOADED) {
141 		b = (FPU_REG *) rm;
142 		tagb = flags & 0x0f;
143 	} else {
144 		b = &st(rm);
145 		tagb = FPU_gettagi(rm);
146 
147 		if (flags & DEST_RM)
148 			deststnr = rm;
149 	}
150 
151 	signa = getsign(a);
152 	signb = getsign(b);
153 
154 	if (flags & REV) {
155 		signa ^= SIGN_NEG;
156 		signb ^= SIGN_NEG;
157 	}
158 
159 	dest = &st(deststnr);
160 	saved_sign = getsign(dest);
161 
162 	if (!(taga | tagb)) {
163 		expa = exponent(a);
164 		expb = exponent(b);
165 
166 	      valid_subtract:
167 		/* Both registers are valid */
168 
169 		diff = expa - expb;
170 
171 		if (!diff) {
172 			diff = a->sigh - b->sigh;	/* Works only if ms bits are identical */
173 			if (!diff) {
174 				diff = a->sigl > b->sigl;
175 				if (!diff)
176 					diff = -(a->sigl < b->sigl);
177 			}
178 		}
179 
180 		switch ((((int)signa) * 2 + signb) / SIGN_NEG) {
181 		case 0:	/* P - P */
182 		case 3:	/* N - N */
183 			if (diff > 0) {
184 				/* |a| > |b| */
185 				tag =
186 				    FPU_u_sub(a, b, dest, control_w, signa,
187 					      expa, expb);
188 			} else if (diff == 0) {
189 				FPU_copy_to_regi(&CONST_Z, TAG_Zero, deststnr);
190 
191 				/* sign depends upon rounding mode */
192 				setsign(dest, ((control_w & CW_RC) != RC_DOWN)
193 					? SIGN_POS : SIGN_NEG);
194 				return TAG_Zero;
195 			} else {
196 				sign = signa ^ SIGN_NEG;
197 				tag =
198 				    FPU_u_sub(b, a, dest, control_w, sign, expb,
199 					      expa);
200 			}
201 			break;
202 		case 1:	/* P - N */
203 			tag =
204 			    FPU_u_add(a, b, dest, control_w, SIGN_POS, expa,
205 				      expb);
206 			break;
207 		case 2:	/* N - P */
208 			tag =
209 			    FPU_u_add(a, b, dest, control_w, SIGN_NEG, expa,
210 				      expb);
211 			break;
212 #ifdef PARANOID
213 		default:
214 			EXCEPTION(EX_INTERNAL | 0x111);
215 			return -1;
216 #endif
217 		}
218 		if (tag < 0) {
219 			setsign(dest, saved_sign);
220 			return tag;
221 		}
222 		FPU_settagi(deststnr, tag);
223 		return tag;
224 	}
225 
226 	if (taga == TAG_Special)
227 		taga = FPU_Special(a);
228 	if (tagb == TAG_Special)
229 		tagb = FPU_Special(b);
230 
231 	if (((taga == TAG_Valid) && (tagb == TW_Denormal))
232 	    || ((taga == TW_Denormal) && (tagb == TAG_Valid))
233 	    || ((taga == TW_Denormal) && (tagb == TW_Denormal))) {
234 		FPU_REG x, y;
235 
236 		if (denormal_operand() < 0)
237 			return FPU_Exception;
238 
239 		FPU_to_exp16(a, &x);
240 		FPU_to_exp16(b, &y);
241 		a = &x;
242 		b = &y;
243 		expa = exponent16(a);
244 		expb = exponent16(b);
245 
246 		goto valid_subtract;
247 	}
248 
249 	if ((taga == TW_NaN) || (tagb == TW_NaN)) {
250 		FPU_REG const *d1, *d2;
251 		if (flags & REV) {
252 			d1 = b;
253 			d2 = a;
254 		} else {
255 			d1 = a;
256 			d2 = b;
257 		}
258 		if (flags & LOADED)
259 			return real_2op_NaN(b, tagb, deststnr, d1);
260 		if (flags & DEST_RM)
261 			return real_2op_NaN(a, taga, deststnr, d2);
262 		else
263 			return real_2op_NaN(b, tagb, deststnr, d2);
264 	}
265 
266 	return add_sub_specials(a, taga, signa, b, tagb, signb ^ SIGN_NEG,
267 				dest, deststnr, control_w);
268 }
269 
270 static
add_sub_specials(FPU_REG const * a,u_char taga,u_char signa,FPU_REG const * b,u_char tagb,u_char signb,FPU_REG * dest,int deststnr,int control_w)271 int add_sub_specials(FPU_REG const *a, u_char taga, u_char signa,
272 		     FPU_REG const *b, u_char tagb, u_char signb,
273 		     FPU_REG * dest, int deststnr, int control_w)
274 {
275 	if (((taga == TW_Denormal) || (tagb == TW_Denormal))
276 	    && (denormal_operand() < 0))
277 		return FPU_Exception;
278 
279 	if (taga == TAG_Zero) {
280 		if (tagb == TAG_Zero) {
281 			/* Both are zero, result will be zero. */
282 			u_char different_signs = signa ^ signb;
283 
284 			FPU_copy_to_regi(a, TAG_Zero, deststnr);
285 			if (different_signs) {
286 				/* Signs are different. */
287 				/* Sign of answer depends upon rounding mode. */
288 				setsign(dest, ((control_w & CW_RC) != RC_DOWN)
289 					? SIGN_POS : SIGN_NEG);
290 			} else
291 				setsign(dest, signa);	/* signa may differ from the sign of a. */
292 			return TAG_Zero;
293 		} else {
294 			reg_copy(b, dest);
295 			if ((tagb == TW_Denormal) && (b->sigh & 0x80000000)) {
296 				/* A pseudoDenormal, convert it. */
297 				addexponent(dest, 1);
298 				tagb = TAG_Valid;
299 			} else if (tagb > TAG_Empty)
300 				tagb = TAG_Special;
301 			setsign(dest, signb);	/* signb may differ from the sign of b. */
302 			FPU_settagi(deststnr, tagb);
303 			return tagb;
304 		}
305 	} else if (tagb == TAG_Zero) {
306 		reg_copy(a, dest);
307 		if ((taga == TW_Denormal) && (a->sigh & 0x80000000)) {
308 			/* A pseudoDenormal */
309 			addexponent(dest, 1);
310 			taga = TAG_Valid;
311 		} else if (taga > TAG_Empty)
312 			taga = TAG_Special;
313 		setsign(dest, signa);	/* signa may differ from the sign of a. */
314 		FPU_settagi(deststnr, taga);
315 		return taga;
316 	} else if (taga == TW_Infinity) {
317 		if ((tagb != TW_Infinity) || (signa == signb)) {
318 			FPU_copy_to_regi(a, TAG_Special, deststnr);
319 			setsign(dest, signa);	/* signa may differ from the sign of a. */
320 			return taga;
321 		}
322 		/* Infinity-Infinity is undefined. */
323 		return arith_invalid(deststnr);
324 	} else if (tagb == TW_Infinity) {
325 		FPU_copy_to_regi(b, TAG_Special, deststnr);
326 		setsign(dest, signb);	/* signb may differ from the sign of b. */
327 		return tagb;
328 	}
329 #ifdef PARANOID
330 	EXCEPTION(EX_INTERNAL | 0x101);
331 #endif
332 
333 	return FPU_Exception;
334 }
335