~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/x86/math-emu/reg_add_sub.c

Version: ~ [ linux-5.13-rc5 ] ~ [ linux-5.12.9 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.42 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.124 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.193 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.235 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.271 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.271 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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   */
 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 */
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
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 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp