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