#define FOLD_STRING_UNTRANSLATE_HTSIZE 1024
#define FOLD_STRING_DOTRANSLATE_HTSIZE 1024
+/* The options to use for inexact and arithmetic exceptions */
+#define FOLD_ROUNDING SFLOAT_ROUND_NEAREST_EVEN
+#define FOLD_TINYNESS SFLOAT_TBEFORE
+
/*
* The constant folder is also responsible for validating if the constant
* expressions produce valid results. We cannot trust the FPU control
} sfloat_cast_t;
typedef enum {
- SFLOAT_INVALID = 1 << 0,
- SFLOAT_DIVBYZERO = 1 << 1,
- SFLOAT_OVERFLOW = 1 << 2,
- SFLOAT_UNDERFLOW = 1 << 3,
- SFLOAT_INEXACT = 1 << 4
+ SFLOAT_INVALID = 1,
+ SFLOAT_DIVBYZERO = 4,
+ SFLOAT_OVERFLOW = 8,
+ SFLOAT_UNDERFLOW = 16,
+ SFLOAT_INEXACT = 32
} sfloat_exceptionflags_t;
typedef enum {
sfloat_tdetect_t tiny;
} sfloat_state_t;
+/* Count of leading zero bits before the most-significand 1 bit. */
+#ifdef _MSC_VER
+/* MSVC has an intrinsic for this */
+ static GMQCC_INLINE uint32_t sfloat_clz(uint32_t x) {
+ int r = 0;
+ _BitScanForward(&r, x);
+ return r;
+ }
+# define SFLOAT_CLZ(X, SUB) \
+ (sfloat_clz((X)) - (SUB))
+#elif defined(__GNUC__) || defined(__CLANG__)
+/* Clang and GCC have a builtin for this */
+# define SFLOAT_CLZ(X, SUB) \
+ (__builtin_clz((X)) - (SUB))
+#else
+/* Native fallback */
+ static GMQCC_INLINE uint32_t sfloat_popcnt(uint32_t x) {
+ x -= ((x >> 1) & 0x55555555);
+ x = (((x >> 2) & 0x33333333) + (x & 0x33333333));
+ x = (((x >> 4) + x) & 0x0F0F0F0F);
+ x += x >> 8;
+ x += x >> 16;
+ return x & 0x0000003F;
+ }
+ static GMQCC_INLINE uint32_t sfloat_clz(uint32_t x) {
+ x |= (x >> 1);
+ x |= (x >> 2);
+ x |= (x >> 4);
+ x |= (x >> 8);
+ x |= (x >> 16);
+ return 32 - sfloat_popcnt(x);
+ }
+# define SFLOAT_CLZ(X, SUB) \
+ (sfloat_clz((X) - (SUB)))
+#endif
+
/* The value of a NaN */
#define SFLOAT_NAN 0xFFC00000
-/* Count of leading zero bits before the most-significand 1 bit. */
-#define SFLOAT_CLZ(X, SUB) \
- (__builtin_clz((X)) - (SUB))
/* Test if NaN */
#define SFLOAT_ISNAN(A) \
(0xFF000000 < (uint32_t)((A) << 1))
return SFLOAT_PACK_round(state, sign_z, exp_z, sig_z);
}
+static GMQCC_INLINE void sfloat_check(lex_ctx_t ctx, sfloat_state_t *state, const char *vec) {
+ /* Exception comes from vector component */
+ if (vec) {
+ if (state->exceptionflags & SFLOAT_DIVBYZERO)
+ compile_error(ctx, "division by zero in `%s' component", vec);
+ if (state->exceptionflags & SFLOAT_INVALID)
+ compile_error(ctx, "undefined (inf) in `%s' component", vec);
+ if (state->exceptionflags & SFLOAT_OVERFLOW)
+ compile_error(ctx, "arithmetic overflow in `%s' component", vec);
+ if (state->exceptionflags & SFLOAT_UNDERFLOW)
+ compile_error(ctx, "arithmetic underflow in `%s' component", vec);
+ return;
+ }
+ if (state->exceptionflags & SFLOAT_DIVBYZERO)
+ compile_error(ctx, "division by zero");
+ if (state->exceptionflags & SFLOAT_INVALID)
+ compile_error(ctx, "undefined (inf)");
+ if (state->exceptionflags & SFLOAT_OVERFLOW)
+ compile_error(ctx, "arithmetic overflow");
+ if (state->exceptionflags & SFLOAT_UNDERFLOW)
+ compile_error(ctx, "arithmetic underflow");
+}
+
+static GMQCC_INLINE void sfloat_init(sfloat_state_t *state) {
+ state->exceptionflags = 0;
+ state->roundingmode = FOLD_ROUNDING;
+ state->tiny = FOLD_TINYNESS;
+}
+
/*
* There is two stages to constant folding in GMQCC: there is the parse
* stage constant folding, where, witht he help of the AST, operator
*
* TODO: gcc/clang hinting for autovectorization
*/
-static GMQCC_INLINE vec3_t vec3_add(vec3_t a, vec3_t b) {
+typedef enum {
+ VEC_COMP_X = 1 << 0,
+ VEC_COMP_Y = 1 << 1,
+ VEC_COMP_Z = 1 << 2
+} vec3_comp_t;
+
+typedef struct {
+ sfloat_cast_t x;
+ sfloat_cast_t y;
+ sfloat_cast_t z;
+} vec3_soft_t;
+
+typedef struct {
+ vec3_comp_t faults;
+ sfloat_state_t state[3];
+} vec3_soft_state_t;
+
+static GMQCC_INLINE vec3_soft_t vec3_soft_convert(vec3_t vec) {
+ vec3_soft_t soft;
+ soft.x.f = vec.x;
+ soft.y.f = vec.y;
+ soft.z.f = vec.z;
+ return soft;
+}
+
+static GMQCC_INLINE bool vec3_soft_exception(vec3_soft_state_t *vstate, size_t index) {
+ sfloat_exceptionflags_t flags = vstate->state[index].exceptionflags;
+ if (flags & SFLOAT_DIVBYZERO) return true;
+ if (flags & SFLOAT_INVALID) return true;
+ if (flags & SFLOAT_OVERFLOW) return true;
+ if (flags & SFLOAT_UNDERFLOW) return true;
+ return false;
+}
+
+static GMQCC_INLINE void vec3_soft_eval(vec3_soft_state_t *state,
+ sfloat_t (*callback)(sfloat_state_t *, sfloat_t, sfloat_t),
+ vec3_t a,
+ vec3_t b)
+{
+ 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;
+ callback(&state->state[1], sa.y.s, sb.y.s);
+ if (vec3_soft_exception(state, 1)) 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;
+}
+
+static GMQCC_INLINE void vec3_check_except(vec3_t a,
+ vec3_t b,
+ lex_ctx_t ctx,
+ sfloat_t (*callback)(sfloat_state_t *, sfloat_t, sfloat_t))
+{
+ vec3_soft_state_t state;
+
+ 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");
+ if (state.faults & VEC_COMP_Z) sfloat_check(ctx, &state.state[2], "z");
+}
+
+static GMQCC_INLINE vec3_t vec3_add(lex_ctx_t ctx, vec3_t a, vec3_t b) {
vec3_t out;
+ vec3_check_except(a, b, ctx, &sfloat_add);
out.x = a.x + b.x;
out.y = a.y + b.y;
out.z = a.z + b.z;
return out;
}
-static GMQCC_INLINE vec3_t vec3_sub(vec3_t a, vec3_t b) {
+static GMQCC_INLINE vec3_t vec3_sub(lex_ctx_t ctx, vec3_t a, vec3_t b) {
vec3_t out;
+ vec3_check_except(a, b, ctx, &sfloat_sub);
out.x = a.x - b.x;
out.y = a.y - b.y;
out.z = a.z - b.z;
return out;
}
-static GMQCC_INLINE qcfloat_t vec3_mulvv(vec3_t a, vec3_t b) {
+static GMQCC_INLINE qcfloat_t vec3_mulvv(lex_ctx_t ctx, vec3_t a, vec3_t 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]);
+ sfloat_init(&s[3]);
+ sfloat_init(&s[4]);
+
+ r[0] = sfloat_mul(&s[0], sa.x.s, sb.x.s);
+ r[1] = sfloat_mul(&s[1], sa.y.s, sb.y.s);
+ r[2] = sfloat_mul(&s[2], sa.z.s, sb.z.s);
+ r[3] = sfloat_add(&s[3], r[0], r[1]);
+ r[4] = sfloat_add(&s[4], r[3], r[2]);
+
+ 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);
+
+end:
return (a.x * b.x + a.y * b.y + a.z * b.z);
}
-static GMQCC_INLINE vec3_t vec3_mulvf(vec3_t a, qcfloat_t b) {
- vec3_t out;
+static GMQCC_INLINE vec3_t vec3_mulvf(lex_ctx_t ctx, vec3_t a, qcfloat_t b) {
+ vec3_t out;
+ 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]);
+ sfloat_init(&s[2]);
+
+ sfloat_mul(&s[0], sa.x.s, sb.s);
+ sfloat_mul(&s[1], sa.y.s, sb.s);
+ sfloat_mul(&s[2], sa.z.s, sb.s);
+
+ sfloat_check(ctx, &s[0], "x");
+ 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;
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;
sfloat_cast_t ca;
sfloat_cast_t cb;
- if (!OPTS_FLAG(ARITHMETIC_EXCEPTIONS))
+ if (!OPTS_FLAG(ARITHMETIC_EXCEPTIONS) && !OPTS_WARN(WARN_INEXACT_COMPARES))
return false;
- s.roundingmode = SFLOAT_ROUND_NEAREST_EVEN;
- s.tiny = SFLOAT_TBEFORE;
- s.exceptionflags = 0;
- ca.f = fold_immvalue_float(a);
- cb.f = fold_immvalue_float(b);
+ sfloat_init(&s);
+ ca.f = fold_immvalue_float(a);
+ cb.f = fold_immvalue_float(b);
callback(&s, ca.s, cb.s);
if (s.exceptionflags == 0)
return false;
- if (s.exceptionflags & SFLOAT_DIVBYZERO)
- compile_error(fold_ctx(fold), "division by zero");
-#if 0
- /*
- * To be enabled once softfloat implementations for stuff like sqrt()
- * exist
- */
- if (s.exceptionflags & SFLOAT_INVALID)
- compile_error(fold_ctx(fold), "invalid argument");
-#endif
+ if (!OPTS_FLAG(ARITHMETIC_EXCEPTIONS))
+ goto inexact_possible;
- if (s.exceptionflags & SFLOAT_OVERFLOW)
- compile_error(fold_ctx(fold), "arithmetic overflow");
- if (s.exceptionflags & SFLOAT_UNDERFLOW)
- compile_error(fold_ctx(fold), "arithmetic underflow");
+ sfloat_check(fold_ctx(fold), &s, NULL);
- return s.exceptionflags == SFLOAT_INEXACT;
+inexact_possible:
+ return s.exceptionflags & SFLOAT_INEXACT;
}
static bool fold_check_inexact_float(fold_t *fold, ast_value *a, ast_value *b) {
lex_ctx_t ctx = fold_ctx(fold);
+ if (!OPTS_WARN(WARN_INEXACT_COMPARES))
+ return false;
if (!a->inexact && !b->inexact)
return false;
return compile_warning(ctx, WARN_INEXACT_COMPARES, "inexact value in comparison");
}
} else if (isvector(a)) {
if (fold_can_2(a, b))
- return fold_constgen_vector(fold, vec3_add(fold_immvalue_vector(a), fold_immvalue_vector(b)));
+ return fold_constgen_vector(fold, vec3_add(fold_ctx(fold),
+ fold_immvalue_vector(a),
+ fold_immvalue_vector(b)));
}
return NULL;
}
}
} else if (isvector(a)) {
if (fold_can_2(a, b))
- return fold_constgen_vector(fold, vec3_sub(fold_immvalue_vector(a), fold_immvalue_vector(b)));
+ return fold_constgen_vector(fold, vec3_sub(fold_ctx(fold),
+ fold_immvalue_vector(a),
+ fold_immvalue_vector(b)));
}
return NULL;
}
if (isfloat(a)) {
if (isvector(b)) {
if (fold_can_2(a, b))
- return fold_constgen_vector(fold, vec3_mulvf(fold_immvalue_vector(b), fold_immvalue_float(a)));
+ return fold_constgen_vector(fold, vec3_mulvf(fold_ctx(fold), fold_immvalue_vector(b), fold_immvalue_float(a)));
} else {
if (fold_can_2(a, b)) {
bool inexact = fold_check_except_float(&sfloat_mul, fold, a, b);
} else if (isvector(a)) {
if (isfloat(b)) {
if (fold_can_2(a, b))
- return fold_constgen_vector(fold, vec3_mulvf(fold_immvalue_vector(a), fold_immvalue_float(b)));
+ return fold_constgen_vector(fold, vec3_mulvf(fold_ctx(fold), fold_immvalue_vector(a), fold_immvalue_float(b)));
} else {
if (fold_can_2(a, b)) {
- return fold_constgen_float(fold, vec3_mulvv(fold_immvalue_vector(a), fold_immvalue_vector(b)), false);
+ return fold_constgen_float(fold, vec3_mulvv(fold_ctx(fold), fold_immvalue_vector(a), fold_immvalue_vector(b)), false);
} else if (OPTS_OPTIMIZATION(OPTIM_VECTOR_COMPONENTS) && fold_can_1(a)) {
ast_expression *out;
if ((out = fold_op_mul_vec(fold, fold_immvalue_vector(a), b, "xyz"))) return out;
}
} else if (isvector(a)) {
if (fold_can_2(a, b)) {
- return fold_constgen_vector(fold, vec3_mulvf(fold_immvalue_vector(a), 1.0f / fold_immvalue_float(b)));
+ return fold_constgen_vector(fold, vec3_mulvf(fold_ctx(fold), fold_immvalue_vector(a), 1.0f / fold_immvalue_float(b)));
} else {
return (ast_expression*)ast_binary_new(
fold_ctx(fold),
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;
}
projects / xonotic / gmqcc.git / blobdiff