For now I'll just disable this

[xonotic/gmqcc.git] / fold.c

diff --git a/fold.c b/fold.c
index 60867e8dda031aceaecb8e5badfbf102447ea9c7..db17601a0ae4c63d0de3315489896debb3027425 100644 (file)
--- a/fold.c
+++ b/fold.c
@@ -52,6 +52,7 @@ typedef union {
 } sfloat_cast_t;
 
 typedef enum {
+    SFLOAT_NOEXCEPT  = 0,
     SFLOAT_INVALID   = 1,
     SFLOAT_DIVBYZERO = 4,
     SFLOAT_OVERFLOW  = 8,
@@ -123,7 +124,7 @@ typedef struct {
     (((((A) >> 22) & 0x1FF) == 0x1FE) && ((A) & 0x003FFFFF))
 /* Raise exception */
 #define SFLOAT_RAISE(STATE, FLAGS) \
-    ((STATE)->exceptionflags |= (FLAGS))
+    ((STATE)->exceptionflags = (sfloat_exceptionflags_t)((STATE)->exceptionflags | (FLAGS)))
 /*
  * Shifts `A' right `COUNT' bits. Non-zero bits are stored in LSB. Size
  * sets the arbitrarly-large limit.
@@ -493,7 +494,7 @@ static GMQCC_INLINE void sfloat_check(lex_ctx_t ctx, sfloat_state_t *state, cons
 }
 
 static GMQCC_INLINE void sfloat_init(sfloat_state_t *state) {
-    state->exceptionflags = 0;
+    state->exceptionflags = SFLOAT_NOEXCEPT;
     state->roundingmode   = FOLD_ROUNDING;
     state->tiny           = FOLD_TINYNESS;
 }
@@ -560,11 +561,11 @@ static GMQCC_INLINE void vec3_soft_eval(vec3_soft_state_t *state,
     vec3_soft_t sa = vec3_soft_convert(a);
     vec3_soft_t sb = vec3_soft_convert(b);
     callback(&state->state[0], sa.x.s, sb.x.s);
-    if (vec3_soft_exception(state, 0)) state->faults |= VEC_COMP_X;
+    if (vec3_soft_exception(state, 0)) state->faults = (vec3_comp_t)(state->faults | VEC_COMP_X);
     callback(&state->state[1], sa.y.s, sb.y.s);
-    if (vec3_soft_exception(state, 1)) state->faults |= VEC_COMP_Y;
+    if (vec3_soft_exception(state, 1)) state->faults = (vec3_comp_t)(state->faults | VEC_COMP_Y);
     callback(&state->state[2], sa.z.s, sb.z.s);
-    if (vec3_soft_exception(state, 2)) state->faults |= VEC_COMP_Z;
+    if (vec3_soft_exception(state, 2)) state->faults = (vec3_comp_t)(state->faults | VEC_COMP_Z);
 }
 
 static GMQCC_INLINE void vec3_check_except(vec3_t     a,
@@ -573,13 +574,14 @@ static GMQCC_INLINE void vec3_check_except(vec3_t     a,
                                            sfloat_t (*callback)(sfloat_state_t *, sfloat_t, sfloat_t))
 {
     vec3_soft_state_t state;
-    sfloat_init(&state.state[0]);
-    sfloat_init(&state.state[1]);
-    sfloat_init(&state.state[2]);
 
     if (!OPTS_FLAG(ARITHMETIC_EXCEPTIONS))
         return;
 
+    sfloat_init(&state.state[0]);
+    sfloat_init(&state.state[1]);
+    sfloat_init(&state.state[2]);
+
     vec3_soft_eval(&state, callback, a, b);
     if (state.faults & VEC_COMP_X) sfloat_check(ctx, &state.state[0], "x");
     if (state.faults & VEC_COMP_Y) sfloat_check(ctx, &state.state[1], "y");
@@ -669,11 +671,17 @@ static GMQCC_INLINE vec3_t vec3_not(vec3_t a) {
 }
 
 static GMQCC_INLINE qcfloat_t vec3_mulvv(lex_ctx_t ctx, vec3_t a, vec3_t b) {
-    vec3_soft_t    sa = vec3_soft_convert(a);
-    vec3_soft_t    sb = vec3_soft_convert(b);
+    vec3_soft_t    sa;
+    vec3_soft_t    sb;
     sfloat_state_t s[5];
     sfloat_t       r[5];
 
+    if (!OPTS_FLAG(ARITHMETIC_EXCEPTIONS))
+        goto end;
+
+    sa = vec3_soft_convert(a);
+    sb = vec3_soft_convert(b);
+
     sfloat_init(&s[0]);
     sfloat_init(&s[1]);
     sfloat_init(&s[2]);
@@ -692,15 +700,20 @@ static GMQCC_INLINE qcfloat_t vec3_mulvv(lex_ctx_t ctx, vec3_t a, vec3_t b) {
     sfloat_check(ctx, &s[3], NULL);
     sfloat_check(ctx, &s[4], NULL);
 
+end:
     return (a.x * b.x + a.y * b.y + a.z * b.z);
 }
 
 static GMQCC_INLINE vec3_t vec3_mulvf(lex_ctx_t ctx, vec3_t a, qcfloat_t b) {
     vec3_t         out;
-    vec3_soft_t    sa = vec3_soft_convert(a);
+    vec3_soft_t    sa;
     sfloat_cast_t  sb;
     sfloat_state_t s[3];
 
+    if (!OPTS_FLAG(ARITHMETIC_EXCEPTIONS))
+        goto end;
+
+    sa   = vec3_soft_convert(a);
     sb.f = b;
     sfloat_init(&s[0]);
     sfloat_init(&s[1]);
@@ -714,6 +727,7 @@ static GMQCC_INLINE vec3_t vec3_mulvf(lex_ctx_t ctx, vec3_t a, qcfloat_t b) {
     sfloat_check(ctx, &s[1], "y");
     sfloat_check(ctx, &s[2], "z");
 
+end:
     out.x = a.x * b;
     out.y = a.y * b;
     out.z = a.z * b;
@@ -742,8 +756,50 @@ static GMQCC_INLINE bool vec3_pbool(vec3_t a) {
     return (a.x || a.y || a.z);
 }
 
-static GMQCC_INLINE vec3_t vec3_cross(vec3_t a, vec3_t b) {
-    vec3_t out;
+static GMQCC_INLINE vec3_t vec3_cross(lex_ctx_t ctx, vec3_t a, vec3_t b) {
+    vec3_t         out;
+    vec3_soft_t    sa;
+    vec3_soft_t    sb;
+    sfloat_t       r[9];
+    sfloat_state_t s[9];
+
+    if (!OPTS_FLAG(ARITHMETIC_EXCEPTIONS))
+        goto end;
+
+    sa = vec3_soft_convert(a);
+    sb = vec3_soft_convert(b);
+
+    sfloat_init(&s[0]);
+    sfloat_init(&s[1]);
+    sfloat_init(&s[2]);
+    sfloat_init(&s[3]);
+    sfloat_init(&s[4]);
+    sfloat_init(&s[5]);
+    sfloat_init(&s[6]);
+    sfloat_init(&s[7]);
+    sfloat_init(&s[8]);
+
+    r[0] = sfloat_mul(&s[0], sa.y.s, sb.z.s);
+    r[1] = sfloat_mul(&s[1], sa.z.s, sb.y.s);
+    r[2] = sfloat_mul(&s[2], sa.z.s, sb.x.s);
+    r[3] = sfloat_mul(&s[3], sa.x.s, sb.z.s);
+    r[4] = sfloat_mul(&s[4], sa.x.s, sb.y.s);
+    r[5] = sfloat_mul(&s[5], sa.y.s, sb.x.s);
+    r[6] = sfloat_sub(&s[6], r[0],   r[1]);
+    r[7] = sfloat_sub(&s[7], r[2],   r[3]);
+    r[8] = sfloat_sub(&s[8], r[4],   r[5]);
+
+    sfloat_check(ctx, &s[0], NULL);
+    sfloat_check(ctx, &s[1], NULL);
+    sfloat_check(ctx, &s[2], NULL);
+    sfloat_check(ctx, &s[3], NULL);
+    sfloat_check(ctx, &s[4], NULL);
+    sfloat_check(ctx, &s[5], NULL);
+    sfloat_check(ctx, &s[6], "x");
+    sfloat_check(ctx, &s[7], "y");
+    sfloat_check(ctx, &s[8], "z");
+
+end:
     out.x = a.y * b.z - a.z * b.y;
     out.y = a.z * b.x - a.x * b.z;
     out.z = a.x * b.y - a.y * b.x;
@@ -1275,7 +1331,9 @@ static GMQCC_INLINE ast_expression *fold_op_bnot(fold_t *fold, ast_value *a) {
 
 static GMQCC_INLINE ast_expression *fold_op_cross(fold_t *fold, ast_value *a, ast_value *b) {
     if (fold_can_2(a, b))
-        return fold_constgen_vector(fold, vec3_cross(fold_immvalue_vector(a), fold_immvalue_vector(b)));
+        return fold_constgen_vector(fold, vec3_cross(fold_ctx(fold),
+                                                     fold_immvalue_vector(a),
+                                                     fold_immvalue_vector(b)));
     return NULL;
 }