mirror of
https://github.com/torvalds/linux.git
synced 2024-11-23 12:42:02 +00:00
3d0d14f983
lindent these files:
errors lines of code errors/KLOC
arch/x86/math-emu/ 2236 9424 237.2
arch/x86/math-emu/ 128 8706 14.7
no other changes. No code changed:
text data bss dec hex filename
5589802 612739 3833856 10036397 9924ad vmlinux.before
5589802 612739 3833856 10036397 9924ad vmlinux.after
the intent of this patch is to ease the automated tracking of kernel
code quality - it's just much easier for us to maintain it if every file
in arch/x86 is supposed to be clean.
NOTE: it is a known problem of lindent that it causes some style damage
of its own, but it's a safe tool (well, except for the gcc array range
initializers extension), so we did the bulk of the changes via lindent,
and did the manual fixups in a followup patch.
the resulting math-emu code has been tested by Thomas Gleixner on a real
386 DX CPU as well, and it works fine.
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
334 lines
8.6 KiB
C
334 lines
8.6 KiB
C
/*---------------------------------------------------------------------------+
|
|
| reg_add_sub.c |
|
|
| |
|
|
| Functions to add or subtract two registers and put the result in a third. |
|
|
| |
|
|
| Copyright (C) 1992,1993,1997 |
|
|
| W. Metzenthen, 22 Parker St, Ormond, Vic 3163, Australia |
|
|
| E-mail billm@suburbia.net |
|
|
| |
|
|
| |
|
|
+---------------------------------------------------------------------------*/
|
|
|
|
/*---------------------------------------------------------------------------+
|
|
| For each function, the destination may be any FPU_REG, including one of |
|
|
| the source FPU_REGs. |
|
|
| Each function returns 0 if the answer is o.k., otherwise a non-zero |
|
|
| value is returned, indicating either an exception condition or an |
|
|
| internal error. |
|
|
+---------------------------------------------------------------------------*/
|
|
|
|
#include "exception.h"
|
|
#include "reg_constant.h"
|
|
#include "fpu_emu.h"
|
|
#include "control_w.h"
|
|
#include "fpu_system.h"
|
|
|
|
static
|
|
int 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);
|
|
|
|
/*
|
|
Operates on st(0) and st(n), or on st(0) and temporary data.
|
|
The destination must be one of the source st(x).
|
|
*/
|
|
int FPU_add(FPU_REG const *b, u_char tagb, int deststnr, int control_w)
|
|
{
|
|
FPU_REG *a = &st(0);
|
|
FPU_REG *dest = &st(deststnr);
|
|
u_char signb = getsign(b);
|
|
u_char taga = FPU_gettag0();
|
|
u_char signa = getsign(a);
|
|
u_char saved_sign = getsign(dest);
|
|
int diff, tag, expa, expb;
|
|
|
|
if (!(taga | tagb)) {
|
|
expa = exponent(a);
|
|
expb = exponent(b);
|
|
|
|
valid_add:
|
|
/* Both registers are valid */
|
|
if (!(signa ^ signb)) {
|
|
/* signs are the same */
|
|
tag =
|
|
FPU_u_add(a, b, dest, control_w, signa, expa, expb);
|
|
} else {
|
|
/* The signs are different, so do a subtraction */
|
|
diff = expa - expb;
|
|
if (!diff) {
|
|
diff = a->sigh - b->sigh; /* This works only if the ms bits
|
|
are identical. */
|
|
if (!diff) {
|
|
diff = a->sigl > b->sigl;
|
|
if (!diff)
|
|
diff = -(a->sigl < b->sigl);
|
|
}
|
|
}
|
|
|
|
if (diff > 0) {
|
|
tag =
|
|
FPU_u_sub(a, b, dest, control_w, signa,
|
|
expa, expb);
|
|
} else if (diff < 0) {
|
|
tag =
|
|
FPU_u_sub(b, a, dest, control_w, signb,
|
|
expb, expa);
|
|
} else {
|
|
FPU_copy_to_regi(&CONST_Z, TAG_Zero, deststnr);
|
|
/* sign depends upon rounding mode */
|
|
setsign(dest, ((control_w & CW_RC) != RC_DOWN)
|
|
? SIGN_POS : SIGN_NEG);
|
|
return TAG_Zero;
|
|
}
|
|
}
|
|
|
|
if (tag < 0) {
|
|
setsign(dest, saved_sign);
|
|
return tag;
|
|
}
|
|
FPU_settagi(deststnr, tag);
|
|
return tag;
|
|
}
|
|
|
|
if (taga == TAG_Special)
|
|
taga = FPU_Special(a);
|
|
if (tagb == TAG_Special)
|
|
tagb = FPU_Special(b);
|
|
|
|
if (((taga == TAG_Valid) && (tagb == TW_Denormal))
|
|
|| ((taga == TW_Denormal) && (tagb == TAG_Valid))
|
|
|| ((taga == TW_Denormal) && (tagb == TW_Denormal))) {
|
|
FPU_REG x, y;
|
|
|
|
if (denormal_operand() < 0)
|
|
return FPU_Exception;
|
|
|
|
FPU_to_exp16(a, &x);
|
|
FPU_to_exp16(b, &y);
|
|
a = &x;
|
|
b = &y;
|
|
expa = exponent16(a);
|
|
expb = exponent16(b);
|
|
goto valid_add;
|
|
}
|
|
|
|
if ((taga == TW_NaN) || (tagb == TW_NaN)) {
|
|
if (deststnr == 0)
|
|
return real_2op_NaN(b, tagb, deststnr, a);
|
|
else
|
|
return real_2op_NaN(a, taga, deststnr, a);
|
|
}
|
|
|
|
return add_sub_specials(a, taga, signa, b, tagb, signb,
|
|
dest, deststnr, control_w);
|
|
}
|
|
|
|
/* Subtract b from a. (a-b) -> dest */
|
|
int FPU_sub(int flags, int rm, int control_w)
|
|
{
|
|
FPU_REG const *a, *b;
|
|
FPU_REG *dest;
|
|
u_char taga, tagb, signa, signb, saved_sign, sign;
|
|
int diff, tag = 0, expa, expb, deststnr;
|
|
|
|
a = &st(0);
|
|
taga = FPU_gettag0();
|
|
|
|
deststnr = 0;
|
|
if (flags & LOADED) {
|
|
b = (FPU_REG *) rm;
|
|
tagb = flags & 0x0f;
|
|
} else {
|
|
b = &st(rm);
|
|
tagb = FPU_gettagi(rm);
|
|
|
|
if (flags & DEST_RM)
|
|
deststnr = rm;
|
|
}
|
|
|
|
signa = getsign(a);
|
|
signb = getsign(b);
|
|
|
|
if (flags & REV) {
|
|
signa ^= SIGN_NEG;
|
|
signb ^= SIGN_NEG;
|
|
}
|
|
|
|
dest = &st(deststnr);
|
|
saved_sign = getsign(dest);
|
|
|
|
if (!(taga | tagb)) {
|
|
expa = exponent(a);
|
|
expb = exponent(b);
|
|
|
|
valid_subtract:
|
|
/* Both registers are valid */
|
|
|
|
diff = expa - expb;
|
|
|
|
if (!diff) {
|
|
diff = a->sigh - b->sigh; /* Works only if ms bits are identical */
|
|
if (!diff) {
|
|
diff = a->sigl > b->sigl;
|
|
if (!diff)
|
|
diff = -(a->sigl < b->sigl);
|
|
}
|
|
}
|
|
|
|
switch ((((int)signa) * 2 + signb) / SIGN_NEG) {
|
|
case 0: /* P - P */
|
|
case 3: /* N - N */
|
|
if (diff > 0) {
|
|
/* |a| > |b| */
|
|
tag =
|
|
FPU_u_sub(a, b, dest, control_w, signa,
|
|
expa, expb);
|
|
} else if (diff == 0) {
|
|
FPU_copy_to_regi(&CONST_Z, TAG_Zero, deststnr);
|
|
|
|
/* sign depends upon rounding mode */
|
|
setsign(dest, ((control_w & CW_RC) != RC_DOWN)
|
|
? SIGN_POS : SIGN_NEG);
|
|
return TAG_Zero;
|
|
} else {
|
|
sign = signa ^ SIGN_NEG;
|
|
tag =
|
|
FPU_u_sub(b, a, dest, control_w, sign, expb,
|
|
expa);
|
|
}
|
|
break;
|
|
case 1: /* P - N */
|
|
tag =
|
|
FPU_u_add(a, b, dest, control_w, SIGN_POS, expa,
|
|
expb);
|
|
break;
|
|
case 2: /* N - P */
|
|
tag =
|
|
FPU_u_add(a, b, dest, control_w, SIGN_NEG, expa,
|
|
expb);
|
|
break;
|
|
#ifdef PARANOID
|
|
default:
|
|
EXCEPTION(EX_INTERNAL | 0x111);
|
|
return -1;
|
|
#endif
|
|
}
|
|
if (tag < 0) {
|
|
setsign(dest, saved_sign);
|
|
return tag;
|
|
}
|
|
FPU_settagi(deststnr, tag);
|
|
return tag;
|
|
}
|
|
|
|
if (taga == TAG_Special)
|
|
taga = FPU_Special(a);
|
|
if (tagb == TAG_Special)
|
|
tagb = FPU_Special(b);
|
|
|
|
if (((taga == TAG_Valid) && (tagb == TW_Denormal))
|
|
|| ((taga == TW_Denormal) && (tagb == TAG_Valid))
|
|
|| ((taga == TW_Denormal) && (tagb == TW_Denormal))) {
|
|
FPU_REG x, y;
|
|
|
|
if (denormal_operand() < 0)
|
|
return FPU_Exception;
|
|
|
|
FPU_to_exp16(a, &x);
|
|
FPU_to_exp16(b, &y);
|
|
a = &x;
|
|
b = &y;
|
|
expa = exponent16(a);
|
|
expb = exponent16(b);
|
|
|
|
goto valid_subtract;
|
|
}
|
|
|
|
if ((taga == TW_NaN) || (tagb == TW_NaN)) {
|
|
FPU_REG const *d1, *d2;
|
|
if (flags & REV) {
|
|
d1 = b;
|
|
d2 = a;
|
|
} else {
|
|
d1 = a;
|
|
d2 = b;
|
|
}
|
|
if (flags & LOADED)
|
|
return real_2op_NaN(b, tagb, deststnr, d1);
|
|
if (flags & DEST_RM)
|
|
return real_2op_NaN(a, taga, deststnr, d2);
|
|
else
|
|
return real_2op_NaN(b, tagb, deststnr, d2);
|
|
}
|
|
|
|
return add_sub_specials(a, taga, signa, b, tagb, signb ^ SIGN_NEG,
|
|
dest, deststnr, control_w);
|
|
}
|
|
|
|
static
|
|
int 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)
|
|
{
|
|
if (((taga == TW_Denormal) || (tagb == TW_Denormal))
|
|
&& (denormal_operand() < 0))
|
|
return FPU_Exception;
|
|
|
|
if (taga == TAG_Zero) {
|
|
if (tagb == TAG_Zero) {
|
|
/* Both are zero, result will be zero. */
|
|
u_char different_signs = signa ^ signb;
|
|
|
|
FPU_copy_to_regi(a, TAG_Zero, deststnr);
|
|
if (different_signs) {
|
|
/* Signs are different. */
|
|
/* Sign of answer depends upon rounding mode. */
|
|
setsign(dest, ((control_w & CW_RC) != RC_DOWN)
|
|
? SIGN_POS : SIGN_NEG);
|
|
} else
|
|
setsign(dest, signa); /* signa may differ from the sign of a. */
|
|
return TAG_Zero;
|
|
} else {
|
|
reg_copy(b, dest);
|
|
if ((tagb == TW_Denormal) && (b->sigh & 0x80000000)) {
|
|
/* A pseudoDenormal, convert it. */
|
|
addexponent(dest, 1);
|
|
tagb = TAG_Valid;
|
|
} else if (tagb > TAG_Empty)
|
|
tagb = TAG_Special;
|
|
setsign(dest, signb); /* signb may differ from the sign of b. */
|
|
FPU_settagi(deststnr, tagb);
|
|
return tagb;
|
|
}
|
|
} else if (tagb == TAG_Zero) {
|
|
reg_copy(a, dest);
|
|
if ((taga == TW_Denormal) && (a->sigh & 0x80000000)) {
|
|
/* A pseudoDenormal */
|
|
addexponent(dest, 1);
|
|
taga = TAG_Valid;
|
|
} else if (taga > TAG_Empty)
|
|
taga = TAG_Special;
|
|
setsign(dest, signa); /* signa may differ from the sign of a. */
|
|
FPU_settagi(deststnr, taga);
|
|
return taga;
|
|
} else if (taga == TW_Infinity) {
|
|
if ((tagb != TW_Infinity) || (signa == signb)) {
|
|
FPU_copy_to_regi(a, TAG_Special, deststnr);
|
|
setsign(dest, signa); /* signa may differ from the sign of a. */
|
|
return taga;
|
|
}
|
|
/* Infinity-Infinity is undefined. */
|
|
return arith_invalid(deststnr);
|
|
} else if (tagb == TW_Infinity) {
|
|
FPU_copy_to_regi(b, TAG_Special, deststnr);
|
|
setsign(dest, signb); /* signb may differ from the sign of b. */
|
|
return tagb;
|
|
}
|
|
#ifdef PARANOID
|
|
EXCEPTION(EX_INTERNAL | 0x101);
|
|
#endif
|
|
|
|
return FPU_Exception;
|
|
}
|