EXPLODEXDP;
        EXPLODEYDP;
 
-       CLEARCX;
+       ieee754_clearcx();
 
        FLUSHXDP;
        FLUSHYDP;
        case CLPAIR(IEEE754_CLASS_SNAN, IEEE754_CLASS_NORM):
        case CLPAIR(IEEE754_CLASS_SNAN, IEEE754_CLASS_DNORM):
        case CLPAIR(IEEE754_CLASS_SNAN, IEEE754_CLASS_INF):
-               SETCX(IEEE754_INVALID_OPERATION);
+               ieee754_setcx(IEEE754_INVALID_OPERATION);
                return ieee754dp_nanxcpt(ieee754dp_indef(), "add", x, y);
 
        case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_QNAN):
        case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_INF):
                if (xs == ys)
                        return x;
-               SETCX(IEEE754_INVALID_OPERATION);
+               ieee754_setcx(IEEE754_INVALID_OPERATION);
                return ieee754dp_xcpt(ieee754dp_indef(), "add", x, y);
 
        case CLPAIR(IEEE754_CLASS_NORM, IEEE754_CLASS_INF):
 
        EXPLODEYDP;
        FLUSHXDP;
        FLUSHYDP;
-       CLEARCX;        /* Even clear inexact flag here */
+       ieee754_clearcx();      /* Even clear inexact flag here */
 
        if (ieee754dp_isnan(x) || ieee754dp_isnan(y)) {
                if (sig || xc == IEEE754_CLASS_SNAN || yc == IEEE754_CLASS_SNAN)
-                       SETCX(IEEE754_INVALID_OPERATION);
+                       ieee754_setcx(IEEE754_INVALID_OPERATION);
                if (cmp & IEEE754_CUN)
                        return 1;
                if (cmp & (IEEE754_CLT | IEEE754_CGT)) {
-                       if (sig && SETANDTESTCX(IEEE754_INVALID_OPERATION))
+                       if (sig && ieee754_setandtestcx(IEEE754_INVALID_OPERATION))
                                return ieee754si_xcpt(0, "fcmpf", x);
                }
                return 0;
 
        EXPLODEXDP;
        EXPLODEYDP;
 
-       CLEARCX;
+       ieee754_clearcx();
 
        FLUSHXDP;
        FLUSHYDP;
        case CLPAIR(IEEE754_CLASS_SNAN, IEEE754_CLASS_NORM):
        case CLPAIR(IEEE754_CLASS_SNAN, IEEE754_CLASS_DNORM):
        case CLPAIR(IEEE754_CLASS_SNAN, IEEE754_CLASS_INF):
-               SETCX(IEEE754_INVALID_OPERATION);
+               ieee754_setcx(IEEE754_INVALID_OPERATION);
                return ieee754dp_nanxcpt(ieee754dp_indef(), "div", x, y);
 
        case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_QNAN):
                 */
 
        case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_INF):
-               SETCX(IEEE754_INVALID_OPERATION);
+               ieee754_setcx(IEEE754_INVALID_OPERATION);
                return ieee754dp_xcpt(ieee754dp_indef(), "div", x, y);
 
        case CLPAIR(IEEE754_CLASS_NORM, IEEE754_CLASS_INF):
                 */
 
        case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_ZERO):
-               SETCX(IEEE754_INVALID_OPERATION);
+               ieee754_setcx(IEEE754_INVALID_OPERATION);
                return ieee754dp_xcpt(ieee754dp_indef(), "div", x, y);
 
        case CLPAIR(IEEE754_CLASS_NORM, IEEE754_CLASS_ZERO):
        case CLPAIR(IEEE754_CLASS_DNORM, IEEE754_CLASS_ZERO):
-               SETCX(IEEE754_ZERO_DIVIDE);
+               ieee754_setcx(IEEE754_ZERO_DIVIDE);
                return ieee754dp_xcpt(ieee754dp_inf(xs ^ ys), "div", x, y);
 
        case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_NORM):
 
        int xe;
        int xs;
 
-       CLEARCX;
+       ieee754_clearcx();
 
        if (x == 0)
                return ieee754dp_zero(0);
 
        int xe;
        int xs;
 
-       CLEARCX;
+       ieee754_clearcx();
 
        if (x == 0)
                return ieee754dp_zero(0);
 
 union ieee754dp ieee754dp_frexp(union ieee754dp x, int *eptr)
 {
        COMPXDP;
-       CLEARCX;
+       ieee754_clearcx();
        EXPLODEXDP;
 
        switch (xc) {
 
 
        EXPLODEXSP;
 
-       CLEARCX;
+       ieee754_clearcx();
 
        FLUSHXSP;
 
        switch (xc) {
        case IEEE754_CLASS_SNAN:
-               SETCX(IEEE754_INVALID_OPERATION);
+               ieee754_setcx(IEEE754_INVALID_OPERATION);
                return ieee754dp_nanxcpt(ieee754dp_indef(), "fsp");
        case IEEE754_CLASS_QNAN:
                return ieee754dp_nanxcpt(builddp(xs,
 
 {
        COMPXDP;
 
-       CLEARCX;
+       ieee754_clearcx();
 
        EXPLODEXDP;
 
 
 {
        COMPXDP;
 
-       CLEARCX;
+       ieee754_clearcx();
 
        EXPLODEXDP;
 
 
        EXPLODEXDP;
        EXPLODEYDP;
 
-       CLEARCX;
+       ieee754_clearcx();
 
        FLUSHXDP;
        FLUSHYDP;
        case CLPAIR(IEEE754_CLASS_SNAN, IEEE754_CLASS_NORM):
        case CLPAIR(IEEE754_CLASS_SNAN, IEEE754_CLASS_DNORM):
        case CLPAIR(IEEE754_CLASS_SNAN, IEEE754_CLASS_INF):
-               SETCX(IEEE754_INVALID_OPERATION);
+               ieee754_setcx(IEEE754_INVALID_OPERATION);
                return ieee754dp_nanxcpt(ieee754dp_indef(), "mul", x, y);
 
        case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_QNAN):
 
        case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_ZERO):
        case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_INF):
-               SETCX(IEEE754_INVALID_OPERATION);
+               ieee754_setcx(IEEE754_INVALID_OPERATION);
                return ieee754dp_xcpt(ieee754dp_indef(), "mul", x, y);
 
        case CLPAIR(IEEE754_CLASS_NORM, IEEE754_CLASS_INF):
 
 {
        COMPXDP;
 
-       CLEARCX;
+       ieee754_clearcx();
 
        EXPLODEXDP;
 
 
 
 union ieee754dp ieee754dp_copysign(union ieee754dp x, union ieee754dp y)
 {
-       CLEARCX;
+       ieee754_clearcx();
        DPSIGN(x) = DPSIGN(y);
        return x;
 }
        COMPXDP;
 
        EXPLODEXDP;
-       CLEARCX;
+       ieee754_clearcx();
        FLUSHXDP;
 
        /*
 
        if (xc == IEEE754_CLASS_SNAN) {
                union ieee754dp y = ieee754dp_indef();
-               SETCX(IEEE754_INVALID_OPERATION);
+               ieee754_setcx(IEEE754_INVALID_OPERATION);
                DPSIGN(y) = DPSIGN(x);
                return ieee754dp_nanxcpt(y, "neg");
        }
        COMPXDP;
 
        EXPLODEXDP;
-       CLEARCX;
+       ieee754_clearcx();
        FLUSHXDP;
 
        /* Clear sign ALWAYS, irrespective of NaN */
        DPSIGN(x) = 0;
 
        if (xc == IEEE754_CLASS_SNAN) {
-               SETCX(IEEE754_INVALID_OPERATION);
+               ieee754_setcx(IEEE754_INVALID_OPERATION);
                return ieee754dp_nanxcpt(ieee754dp_indef(), "abs");
        }
 
 
        COMPXDP;
 
        EXPLODEXDP;
-       CLEARCX;
+       ieee754_clearcx();
        FLUSHXDP;
 
        /* x == INF or NAN? */
                /* sqrt(Nan) = Nan */
                return ieee754dp_nanxcpt(x, "sqrt");
        case IEEE754_CLASS_SNAN:
-               SETCX(IEEE754_INVALID_OPERATION);
+               ieee754_setcx(IEEE754_INVALID_OPERATION);
                return ieee754dp_nanxcpt(ieee754dp_indef(), "sqrt");
        case IEEE754_CLASS_ZERO:
                /* sqrt(0) = 0 */
        case IEEE754_CLASS_INF:
                if (xs) {
                        /* sqrt(-Inf) = Nan */
-                       SETCX(IEEE754_INVALID_OPERATION);
+                       ieee754_setcx(IEEE754_INVALID_OPERATION);
                        return ieee754dp_nanxcpt(ieee754dp_indef(), "sqrt");
                }
                /* sqrt(+Inf) = Inf */
        case IEEE754_CLASS_NORM:
                if (xs) {
                        /* sqrt(-x) = Nan */
-                       SETCX(IEEE754_INVALID_OPERATION);
+                       ieee754_setcx(IEEE754_INVALID_OPERATION);
                        return ieee754dp_nanxcpt(ieee754dp_indef(), "sqrt");
                }
                break;
 
        EXPLODEXDP;
        EXPLODEYDP;
 
-       CLEARCX;
+       ieee754_clearcx();
 
        FLUSHXDP;
        FLUSHYDP;
        case CLPAIR(IEEE754_CLASS_SNAN, IEEE754_CLASS_NORM):
        case CLPAIR(IEEE754_CLASS_SNAN, IEEE754_CLASS_DNORM):
        case CLPAIR(IEEE754_CLASS_SNAN, IEEE754_CLASS_INF):
-               SETCX(IEEE754_INVALID_OPERATION);
+               ieee754_setcx(IEEE754_INVALID_OPERATION);
                return ieee754dp_nanxcpt(ieee754dp_indef(), "sub", x, y);
 
        case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_QNAN):
        case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_INF):
                if (xs != ys)
                        return x;
-               SETCX(IEEE754_INVALID_OPERATION);
+               ieee754_setcx(IEEE754_INVALID_OPERATION);
                return ieee754dp_xcpt(ieee754dp_indef(), "sub", x, y);
 
        case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_INF):
 
 {
        COMPXDP;
 
-       CLEARCX;
+       ieee754_clearcx();
 
        EXPLODEXDP;
        FLUSHXDP;
        case IEEE754_CLASS_SNAN:
        case IEEE754_CLASS_QNAN:
        case IEEE754_CLASS_INF:
-               SETCX(IEEE754_INVALID_OPERATION);
+               ieee754_setcx(IEEE754_INVALID_OPERATION);
                return ieee754si_xcpt(ieee754si_indef(), "dp_tint", x);
        case IEEE754_CLASS_ZERO:
                return 0;
        if (xe > 31) {
                /* Set invalid. We will only use overflow for floating
                   point overflow */
-               SETCX(IEEE754_INVALID_OPERATION);
+               ieee754_setcx(IEEE754_INVALID_OPERATION);
                return ieee754si_xcpt(ieee754si_indef(), "dp_tint", x);
        }
        /* oh gawd */
                /* look for valid corner case 0x80000000 */
                if ((xm >> 31) != 0 && (xs == 0 || xm != 0x80000000)) {
                        /* This can happen after rounding */
-                       SETCX(IEEE754_INVALID_OPERATION);
+                       ieee754_setcx(IEEE754_INVALID_OPERATION);
                        return ieee754si_xcpt(ieee754si_indef(), "dp_tint", x);
                }
                if (round || sticky)
-                       SETCX(IEEE754_INEXACT);
+                       ieee754_setcx(IEEE754_INEXACT);
        }
        if (xs)
                return -xm;
 
 {
        COMPXDP;
 
-       CLEARCX;
+       ieee754_clearcx();
 
        EXPLODEXDP;
        FLUSHXDP;
        case IEEE754_CLASS_SNAN:
        case IEEE754_CLASS_QNAN:
        case IEEE754_CLASS_INF:
-               SETCX(IEEE754_INVALID_OPERATION);
+               ieee754_setcx(IEEE754_INVALID_OPERATION);
                return ieee754di_xcpt(ieee754di_indef(), "dp_tlong", x);
        case IEEE754_CLASS_ZERO:
                return 0;
                        return -0x8000000000000000LL;
                /* Set invalid. We will only use overflow for floating
                   point overflow */
-               SETCX(IEEE754_INVALID_OPERATION);
+               ieee754_setcx(IEEE754_INVALID_OPERATION);
                return ieee754di_xcpt(ieee754di_indef(), "dp_tlong", x);
        }
        /* oh gawd */
                }
                if ((xm >> 63) != 0) {
                        /* This can happen after rounding */
-                       SETCX(IEEE754_INVALID_OPERATION);
+                       ieee754_setcx(IEEE754_INVALID_OPERATION);
                        return ieee754di_xcpt(ieee754di_indef(), "dp_tlong", x);
                }
                if (round || sticky)
-                       SETCX(IEEE754_INEXACT);
+                       ieee754_setcx(IEEE754_INEXACT);
        }
        if (xs)
                return -xm;
 
 {
        struct ieee754xctx ax;
 
-       if (!TSTX())
+       if (!ieee754_tstx())
                return r;
        ax.op = op;
        ax.rt = IEEE754_RT_SI;
 {
        struct ieee754xctx ax;
 
-       if (!TSTX())
+       if (!ieee754_tstx())
                return r;
        ax.op = op;
        ax.rt = IEEE754_RT_DI;
 
 
 /* 5 types of floating point number
 */
-#define IEEE754_CLASS_NORM     0x00
-#define IEEE754_CLASS_ZERO     0x01
-#define IEEE754_CLASS_DNORM    0x02
-#define IEEE754_CLASS_INF      0x03
-#define IEEE754_CLASS_SNAN     0x04
-#define IEEE754_CLASS_QNAN     0x05
+enum {
+       IEEE754_CLASS_NORM      = 0x00,
+       IEEE754_CLASS_ZERO      = 0x01,
+       IEEE754_CLASS_DNORM     = 0x02,
+       IEEE754_CLASS_INF       = 0x03,
+       IEEE754_CLASS_SNAN      = 0x04,
+       IEEE754_CLASS_QNAN      = 0x05,
+};
 
 /* exception numbers */
 #define IEEE754_INEXACT                        0x01
 
 union ieee754dp __cold ieee754dp_xcpt(union ieee754dp r, const char *op, ...)
 {
        struct ieee754xctx ax;
-       if (!TSTX())
+       if (!ieee754_tstx())
                return r;
 
        ax.op = op;
        if (!ieee754dp_issnan(r))       /* QNAN does not cause invalid op !! */
                return r;
 
-       if (!SETANDTESTCX(IEEE754_INVALID_OPERATION)) {
+       if (!ieee754_setandtestcx(IEEE754_INVALID_OPERATION)) {
                /* not enabled convert to a quiet NaN */
                DPMANT(r) &= (~DP_MBIT(DP_MBITS-1));
                if (ieee754dp_isnan(r))
                int es = DP_EMIN - xe;
 
                if (ieee754_csr.nod) {
-                       SETCX(IEEE754_UNDERFLOW);
-                       SETCX(IEEE754_INEXACT);
+                       ieee754_setcx(IEEE754_UNDERFLOW);
+                       ieee754_setcx(IEEE754_INEXACT);
 
                        switch(ieee754_csr.rm) {
                        case IEEE754_RN:
                                && get_rounding(sn, xm) >> (DP_MBITS + 1 + 3))
                {
                        /* Not tiny after rounding */
-                       SETCX(IEEE754_INEXACT);
+                       ieee754_setcx(IEEE754_INEXACT);
                        xm = get_rounding(sn, xm);
                        xm >>= 1;
                        /* Clear grs bits */
                }
        }
        if (xm & (DP_MBIT(3) - 1)) {
-               SETCX(IEEE754_INEXACT);
+               ieee754_setcx(IEEE754_INEXACT);
                if ((xm & (DP_HIDDEN_BIT << 3)) == 0) {
-                       SETCX(IEEE754_UNDERFLOW);
+                       ieee754_setcx(IEEE754_UNDERFLOW);
                }
 
                /* inexact must round of 3 bits
        assert(xe >= DP_EMIN);
 
        if (xe > DP_EMAX) {
-               SETCX(IEEE754_OVERFLOW);
-               SETCX(IEEE754_INEXACT);
+               ieee754_setcx(IEEE754_OVERFLOW);
+               ieee754_setcx(IEEE754_INEXACT);
                /* -O can be table indexed by (rm,sn) */
                switch (ieee754_csr.rm) {
                case IEEE754_RN:
                /* we underflow (tiny/zero) */
                assert(xe == DP_EMIN);
                if (ieee754_csr.mx & IEEE754_UNDERFLOW)
-                       SETCX(IEEE754_UNDERFLOW);
+                       ieee754_setcx(IEEE754_UNDERFLOW);
                return builddp(sn, DP_EMIN - 1 + DP_EBIAS, xm);
        } else {
                assert((xm >> (DP_MBITS + 1)) == 0);    /* no execess */
 
 #define DPNORMRET2(s, e, m, name, a0, a1)                              \
 {                                                                      \
        union ieee754dp V = ieee754dp_format(s, e, m);                  \
-       if (TSTX())                                                     \
+       if (ieee754_tstx())                                             \
                return ieee754dp_xcpt(V, name, a0, a1);                 \
        else                                                            \
                return V;                                               \
 
 
 #define CLPAIR(x, y)   ((x)*6+(y))
 
-#define CLEARCX \
-       (ieee754_csr.cx = 0)
+static inline void ieee754_clearcx(void)
+{
+       ieee754_csr.cx = 0;
+}
 
-#define SETCX(x) \
-       (ieee754_csr.cx |= (x), ieee754_csr.sx |= (x))
+static inline void ieee754_setcx(const unsigned int flags)
+{
+       ieee754_csr.cx |= flags;
+       ieee754_csr.sx |= flags;
+}
 
-#define SETANDTESTCX(x) \
-       (SETCX(x), ieee754_csr.mx & (x))
+static inline int ieee754_setandtestcx(const unsigned int x)
+{
+       ieee754_setcx(x);
 
-#define TSTX() \
-       (ieee754_csr.cx & ieee754_csr.mx)
+       return ieee754_csr.mx & x;
+}
 
+static inline int ieee754_tstx(void)
+{
+       return ieee754_csr.cx & ieee754_csr.mx;
+}
 
 #define COMPXSP \
        unsigned xm; int xe; int xs __maybe_unused; int xc
 #define FLUSHDP(v, vc, vs, ve, vm)                                     \
        if (vc==IEEE754_CLASS_DNORM) {                                  \
                if (ieee754_csr.nod) {                                  \
-                       SETCX(IEEE754_INEXACT);                         \
+                       ieee754_setcx(IEEE754_INEXACT);                 \
                        vc = IEEE754_CLASS_ZERO;                        \
                        ve = DP_EMIN-1+DP_EBIAS;                        \
                        vm = 0;                                         \
 #define FLUSHSP(v, vc, vs, ve, vm)                                     \
        if (vc==IEEE754_CLASS_DNORM) {                                  \
                if (ieee754_csr.nod) {                                  \
-                       SETCX(IEEE754_INEXACT);                         \
+                       ieee754_setcx(IEEE754_INEXACT);                 \
                        vc = IEEE754_CLASS_ZERO;                        \
                        ve = SP_EMIN-1+SP_EBIAS;                        \
                        vm = 0;                                         \
 
 {
        struct ieee754xctx ax;
 
-       if (!TSTX())
+       if (!ieee754_tstx())
                return r;
 
        ax.op = op;
        if (!ieee754sp_issnan(r))       /* QNAN does not cause invalid op !! */
                return r;
 
-       if (!SETANDTESTCX(IEEE754_INVALID_OPERATION)) {
+       if (!ieee754_setandtestcx(IEEE754_INVALID_OPERATION)) {
                /* not enabled convert to a quiet NaN */
                SPMANT(r) &= (~SP_MBIT(SP_MBITS-1));
                if (ieee754sp_isnan(r))
                int es = SP_EMIN - xe;
 
                if (ieee754_csr.nod) {
-                       SETCX(IEEE754_UNDERFLOW);
-                       SETCX(IEEE754_INEXACT);
+                       ieee754_setcx(IEEE754_UNDERFLOW);
+                       ieee754_setcx(IEEE754_INEXACT);
 
                        switch(ieee754_csr.rm) {
                        case IEEE754_RN:
                                && get_rounding(sn, xm) >> (SP_MBITS + 1 + 3))
                {
                        /* Not tiny after rounding */
-                       SETCX(IEEE754_INEXACT);
+                       ieee754_setcx(IEEE754_INEXACT);
                        xm = get_rounding(sn, xm);
                        xm >>= 1;
                        /* Clear grs bits */
                }
        }
        if (xm & (SP_MBIT(3) - 1)) {
-               SETCX(IEEE754_INEXACT);
+               ieee754_setcx(IEEE754_INEXACT);
                if ((xm & (SP_HIDDEN_BIT << 3)) == 0) {
-                       SETCX(IEEE754_UNDERFLOW);
+                       ieee754_setcx(IEEE754_UNDERFLOW);
                }
 
                /* inexact must round of 3 bits
        assert(xe >= SP_EMIN);
 
        if (xe > SP_EMAX) {
-               SETCX(IEEE754_OVERFLOW);
-               SETCX(IEEE754_INEXACT);
+               ieee754_setcx(IEEE754_OVERFLOW);
+               ieee754_setcx(IEEE754_INEXACT);
                /* -O can be table indexed by (rm,sn) */
                switch (ieee754_csr.rm) {
                case IEEE754_RN:
                /* we underflow (tiny/zero) */
                assert(xe == SP_EMIN);
                if (ieee754_csr.mx & IEEE754_UNDERFLOW)
-                       SETCX(IEEE754_UNDERFLOW);
+                       ieee754_setcx(IEEE754_UNDERFLOW);
                return buildsp(sn, SP_EMIN - 1 + SP_EBIAS, xm);
        } else {
                assert((xm >> (SP_MBITS + 1)) == 0);    /* no execess */
 
 {                                                                      \
        union ieee754sp V = ieee754sp_format(s, e, m);                  \
                                                                        \
-       if (TSTX())                                                     \
+       if (ieee754_tstx())                                             \
                return ieee754sp_xcpt(V, name, a0, a1);                 \
        else                                                            \
                return V;                                               \
 
        EXPLODEXSP;
        EXPLODEYSP;
 
-       CLEARCX;
+       ieee754_clearcx();
 
        FLUSHXSP;
        FLUSHYSP;
        case CLPAIR(IEEE754_CLASS_SNAN, IEEE754_CLASS_NORM):
        case CLPAIR(IEEE754_CLASS_SNAN, IEEE754_CLASS_DNORM):
        case CLPAIR(IEEE754_CLASS_SNAN, IEEE754_CLASS_INF):
-               SETCX(IEEE754_INVALID_OPERATION);
+               ieee754_setcx(IEEE754_INVALID_OPERATION);
                return ieee754sp_nanxcpt(ieee754sp_indef(), "add", x, y);
 
        case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_QNAN):
        case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_INF):
                if (xs == ys)
                        return x;
-               SETCX(IEEE754_INVALID_OPERATION);
+               ieee754_setcx(IEEE754_INVALID_OPERATION);
                return ieee754sp_xcpt(ieee754sp_indef(), "add", x, y);
 
        case CLPAIR(IEEE754_CLASS_NORM, IEEE754_CLASS_INF):
 
        EXPLODEYSP;
        FLUSHXSP;
        FLUSHYSP;
-       CLEARCX;        /* Even clear inexact flag here */
+       ieee754_clearcx();      /* Even clear inexact flag here */
 
        if (ieee754sp_isnan(x) || ieee754sp_isnan(y)) {
                if (sig || xc == IEEE754_CLASS_SNAN || yc == IEEE754_CLASS_SNAN)
-                       SETCX(IEEE754_INVALID_OPERATION);
+                       ieee754_setcx(IEEE754_INVALID_OPERATION);
                if (cmp & IEEE754_CUN)
                        return 1;
                if (cmp & (IEEE754_CLT | IEEE754_CGT)) {
-                       if (sig && SETANDTESTCX(IEEE754_INVALID_OPERATION))
+                       if (sig && ieee754_setandtestcx(IEEE754_INVALID_OPERATION))
                                return ieee754si_xcpt(0, "fcmpf", x);
                }
                return 0;
 
        EXPLODEXSP;
        EXPLODEYSP;
 
-       CLEARCX;
+       ieee754_clearcx();
 
        FLUSHXSP;
        FLUSHYSP;
        case CLPAIR(IEEE754_CLASS_SNAN, IEEE754_CLASS_NORM):
        case CLPAIR(IEEE754_CLASS_SNAN, IEEE754_CLASS_DNORM):
        case CLPAIR(IEEE754_CLASS_SNAN, IEEE754_CLASS_INF):
-               SETCX(IEEE754_INVALID_OPERATION);
+               ieee754_setcx(IEEE754_INVALID_OPERATION);
                return ieee754sp_nanxcpt(ieee754sp_indef(), "div", x, y);
 
        case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_QNAN):
                 */
 
        case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_INF):
-               SETCX(IEEE754_INVALID_OPERATION);
+               ieee754_setcx(IEEE754_INVALID_OPERATION);
                return ieee754sp_xcpt(ieee754sp_indef(), "div", x, y);
 
        case CLPAIR(IEEE754_CLASS_NORM, IEEE754_CLASS_INF):
                 */
 
        case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_ZERO):
-               SETCX(IEEE754_INVALID_OPERATION);
+               ieee754_setcx(IEEE754_INVALID_OPERATION);
                return ieee754sp_xcpt(ieee754sp_indef(), "div", x, y);
 
        case CLPAIR(IEEE754_CLASS_NORM, IEEE754_CLASS_ZERO):
        case CLPAIR(IEEE754_CLASS_DNORM, IEEE754_CLASS_ZERO):
-               SETCX(IEEE754_ZERO_DIVIDE);
+               ieee754_setcx(IEEE754_ZERO_DIVIDE);
                return ieee754sp_xcpt(ieee754sp_inf(xs ^ ys), "div", x, y);
 
        case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_NORM):
 
 
        EXPLODEXDP;
 
-       CLEARCX;
+       ieee754_clearcx();
 
        FLUSHXDP;
 
        switch (xc) {
        case IEEE754_CLASS_SNAN:
-               SETCX(IEEE754_INVALID_OPERATION);
+               ieee754_setcx(IEEE754_INVALID_OPERATION);
                return ieee754sp_nanxcpt(ieee754sp_indef(), "fdp");
        case IEEE754_CLASS_QNAN:
                nan = buildsp(xs, SP_EMAX + 1 + SP_EBIAS, (u32)
                return ieee754sp_zero(xs);
        case IEEE754_CLASS_DNORM:
                /* can't possibly be sp representable */
-               SETCX(IEEE754_UNDERFLOW);
-               SETCX(IEEE754_INEXACT);
+               ieee754_setcx(IEEE754_UNDERFLOW);
+               ieee754_setcx(IEEE754_INEXACT);
                if ((ieee754_csr.rm == IEEE754_RU && !xs) ||
                                (ieee754_csr.rm == IEEE754_RD && xs))
                        return ieee754sp_xcpt(ieee754sp_mind(xs), "fdp", x);
 
        int xe;
        int xs;
 
-       CLEARCX;
+       ieee754_clearcx();
 
        if (x == 0)
                return ieee754sp_zero(0);
 
        int xe;
        int xs;
 
-       CLEARCX;
+       ieee754_clearcx();
 
        if (x == 0)
                return ieee754sp_zero(0);
 
 union ieee754sp ieee754sp_frexp(union ieee754sp x, int *eptr)
 {
        COMPXSP;
-       CLEARCX;
+       ieee754_clearcx();
        EXPLODEXSP;
 
        switch (xc) {
 
 {
        COMPXSP;
 
-       CLEARCX;
+       ieee754_clearcx();
 
        EXPLODEXSP;
 
 
 {
        COMPXSP;
 
-       CLEARCX;
+       ieee754_clearcx();
 
        EXPLODEXSP;
 
 
        EXPLODEXSP;
        EXPLODEYSP;
 
-       CLEARCX;
+       ieee754_clearcx();
 
        FLUSHXSP;
        FLUSHYSP;
        case CLPAIR(IEEE754_CLASS_SNAN, IEEE754_CLASS_NORM):
        case CLPAIR(IEEE754_CLASS_SNAN, IEEE754_CLASS_DNORM):
        case CLPAIR(IEEE754_CLASS_SNAN, IEEE754_CLASS_INF):
-               SETCX(IEEE754_INVALID_OPERATION);
+               ieee754_setcx(IEEE754_INVALID_OPERATION);
                return ieee754sp_nanxcpt(ieee754sp_indef(), "mul", x, y);
 
        case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_QNAN):
 
        case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_ZERO):
        case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_INF):
-               SETCX(IEEE754_INVALID_OPERATION);
+               ieee754_setcx(IEEE754_INVALID_OPERATION);
                return ieee754sp_xcpt(ieee754sp_indef(), "mul", x, y);
 
        case CLPAIR(IEEE754_CLASS_NORM, IEEE754_CLASS_INF):
 
 {
        COMPXSP;
 
-       CLEARCX;
+       ieee754_clearcx();
 
        EXPLODEXSP;
 
 
 
 union ieee754sp ieee754sp_copysign(union ieee754sp x, union ieee754sp y)
 {
-       CLEARCX;
+       ieee754_clearcx();
        SPSIGN(x) = SPSIGN(y);
        return x;
 }
        COMPXSP;
 
        EXPLODEXSP;
-       CLEARCX;
+       ieee754_clearcx();
        FLUSHXSP;
 
        /*
 
        if (xc == IEEE754_CLASS_SNAN) {
                union ieee754sp y = ieee754sp_indef();
-               SETCX(IEEE754_INVALID_OPERATION);
+               ieee754_setcx(IEEE754_INVALID_OPERATION);
                SPSIGN(y) = SPSIGN(x);
                return ieee754sp_nanxcpt(y, "neg");
        }
        COMPXSP;
 
        EXPLODEXSP;
-       CLEARCX;
+       ieee754_clearcx();
        FLUSHXSP;
 
        /* Clear sign ALWAYS, irrespective of NaN */
        SPSIGN(x) = 0;
 
        if (xc == IEEE754_CLASS_SNAN) {
-               SETCX(IEEE754_INVALID_OPERATION);
+               ieee754_setcx(IEEE754_INVALID_OPERATION);
                return ieee754sp_nanxcpt(ieee754sp_indef(), "abs");
        }
 
 
        /* take care of Inf and NaN */
 
        EXPLODEXSP;
-       CLEARCX;
+       ieee754_clearcx();
        FLUSHXSP;
 
        /* x == INF or NAN? */
                /* sqrt(Nan) = Nan */
                return ieee754sp_nanxcpt(x, "sqrt");
        case IEEE754_CLASS_SNAN:
-               SETCX(IEEE754_INVALID_OPERATION);
+               ieee754_setcx(IEEE754_INVALID_OPERATION);
                return ieee754sp_nanxcpt(ieee754sp_indef(), "sqrt");
        case IEEE754_CLASS_ZERO:
                /* sqrt(0) = 0 */
        case IEEE754_CLASS_INF:
                if (xs) {
                        /* sqrt(-Inf) = Nan */
-                       SETCX(IEEE754_INVALID_OPERATION);
+                       ieee754_setcx(IEEE754_INVALID_OPERATION);
                        return ieee754sp_nanxcpt(ieee754sp_indef(), "sqrt");
                }
                /* sqrt(+Inf) = Inf */
        case IEEE754_CLASS_NORM:
                if (xs) {
                        /* sqrt(-x) = Nan */
-                       SETCX(IEEE754_INVALID_OPERATION);
+                       ieee754_setcx(IEEE754_INVALID_OPERATION);
                        return ieee754sp_nanxcpt(ieee754sp_indef(), "sqrt");
                }
                break;
        }
 
        if (ix != 0) {
-               SETCX(IEEE754_INEXACT);
+               ieee754_setcx(IEEE754_INEXACT);
                switch (ieee754_csr.rm) {
                case IEEE754_RP:
                        q += 2;
 
        EXPLODEXSP;
        EXPLODEYSP;
 
-       CLEARCX;
+       ieee754_clearcx();
 
        FLUSHXSP;
        FLUSHYSP;
        case CLPAIR(IEEE754_CLASS_SNAN, IEEE754_CLASS_NORM):
        case CLPAIR(IEEE754_CLASS_SNAN, IEEE754_CLASS_DNORM):
        case CLPAIR(IEEE754_CLASS_SNAN, IEEE754_CLASS_INF):
-               SETCX(IEEE754_INVALID_OPERATION);
+               ieee754_setcx(IEEE754_INVALID_OPERATION);
                return ieee754sp_nanxcpt(ieee754sp_indef(), "sub", x, y);
 
        case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_QNAN):
        case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_INF):
                if (xs != ys)
                        return x;
-               SETCX(IEEE754_INVALID_OPERATION);
+               ieee754_setcx(IEEE754_INVALID_OPERATION);
                return ieee754sp_xcpt(ieee754sp_indef(), "sub", x, y);
 
        case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_INF):
 
 {
        COMPXSP;
 
-       CLEARCX;
+       ieee754_clearcx();
 
        EXPLODEXSP;
        FLUSHXSP;
        case IEEE754_CLASS_SNAN:
        case IEEE754_CLASS_QNAN:
        case IEEE754_CLASS_INF:
-               SETCX(IEEE754_INVALID_OPERATION);
+               ieee754_setcx(IEEE754_INVALID_OPERATION);
                return ieee754si_xcpt(ieee754si_indef(), "sp_tint", x);
        case IEEE754_CLASS_ZERO:
                return 0;
                        return -0x80000000;
                /* Set invalid. We will only use overflow for floating
                   point overflow */
-               SETCX(IEEE754_INVALID_OPERATION);
+               ieee754_setcx(IEEE754_INVALID_OPERATION);
                return ieee754si_xcpt(ieee754si_indef(), "sp_tint", x);
        }
        /* oh gawd */
                }
                if ((xm >> 31) != 0) {
                        /* This can happen after rounding */
-                       SETCX(IEEE754_INVALID_OPERATION);
+                       ieee754_setcx(IEEE754_INVALID_OPERATION);
                        return ieee754si_xcpt(ieee754si_indef(), "sp_tint", x);
                }
                if (round || sticky)
-                       SETCX(IEEE754_INEXACT);
+                       ieee754_setcx(IEEE754_INEXACT);
        }
        if (xs)
                return -xm;
 
 {
        COMPXDP;                /* <-- need 64-bit mantissa tmp */
 
-       CLEARCX;
+       ieee754_clearcx();
 
        EXPLODEXSP;
        FLUSHXSP;
        case IEEE754_CLASS_SNAN:
        case IEEE754_CLASS_QNAN:
        case IEEE754_CLASS_INF:
-               SETCX(IEEE754_INVALID_OPERATION);
+               ieee754_setcx(IEEE754_INVALID_OPERATION);
                return ieee754di_xcpt(ieee754di_indef(), "sp_tlong", x);
        case IEEE754_CLASS_ZERO:
                return 0;
                        return -0x8000000000000000LL;
                /* Set invalid. We will only use overflow for floating
                   point overflow */
-               SETCX(IEEE754_INVALID_OPERATION);
+               ieee754_setcx(IEEE754_INVALID_OPERATION);
                return ieee754di_xcpt(ieee754di_indef(), "sp_tlong", x);
        }
        /* oh gawd */
                }
                if ((xm >> 63) != 0) {
                        /* This can happen after rounding */
-                       SETCX(IEEE754_INVALID_OPERATION);
+                       ieee754_setcx(IEEE754_INVALID_OPERATION);
                        return ieee754di_xcpt(ieee754di_indef(), "sp_tlong", x);
                }
                if (round || sticky)
-                       SETCX(IEEE754_INEXACT);
+                       ieee754_setcx(IEEE754_INEXACT);
        }
        if (xs)
                return -xm;