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
sfloat_t (*callback)(sfloat_state_t *, sfloat_t, sfloat_t))
{
vec3_soft_state_t state;
- state.state[0].exceptionflags = 0;
- state.state[0].roundingmode = FOLD_ROUNDING;
- state.state[0].tiny = FOLD_TINYNESS;
- memcpy(&state.state[1], &state.state[0], sizeof(sfloat_state_t) * 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");
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;
if (!OPTS_FLAG(ARITHMETIC_EXCEPTIONS) && !OPTS_WARN(WARN_INEXACT_COMPARES))
return false;
- s.roundingmode = FOLD_ROUNDING;
- s.tiny = FOLD_TINYNESS;
- 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)
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