GNU Linux-libre 4.14.266-gnu1
[releases.git] / arch / x86 / math-emu / reg_add_sub.c
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   */
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 */
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
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 }