X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=fold.c;h=7b87dc280ad55378cb82a38e6c2cd0acf300dbe4;hb=806850e4083d3a993fdb941cddb5c257d37f3617;hp=7e336b7834ed3f8433ce4e0c1af8d687c249bb5f;hpb=1497191e3ce1da4de07884f6fe13be3e2faaa261;p=xonotic%2Fgmqcc.git diff --git a/fold.c b/fold.c index 7e336b7..7b87dc2 100644 --- a/fold.c +++ b/fold.c @@ -29,6 +29,10 @@ #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 @@ -48,6 +52,7 @@ typedef union { } sfloat_cast_t; typedef enum { + SFLOAT_NOEXCEPT = 0, SFLOAT_INVALID = 1, SFLOAT_DIVBYZERO = 4, SFLOAT_OVERFLOW = 8, @@ -119,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. @@ -488,6 +493,12 @@ static GMQCC_INLINE void sfloat_check(lex_ctx_t ctx, sfloat_state_t *state, cons compile_error(ctx, "arithmetic underflow"); } +static GMQCC_INLINE void sfloat_init(sfloat_state_t *state) { + state->exceptionflags = SFLOAT_NOEXCEPT; + 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 @@ -500,6 +511,7 @@ static GMQCC_INLINE void sfloat_check(lex_ctx_t ctx, sfloat_state_t *state, cons #define isfloat(X) (((ast_expression*)(X))->vtype == TYPE_FLOAT) #define isvector(X) (((ast_expression*)(X))->vtype == TYPE_VECTOR) #define isstring(X) (((ast_expression*)(X))->vtype == TYPE_STRING) +#define isarray(X) (((ast_expression*)(X))->vtype == TYPE_ARRAY) #define isfloats(X,Y) (isfloat (X) && isfloat (Y)) /* @@ -550,11 +562,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, @@ -563,6 +575,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; + + 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"); @@ -651,12 +671,64 @@ static GMQCC_INLINE vec3_t vec3_not(vec3_t a) { 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; @@ -685,8 +757,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; @@ -942,11 +1056,9 @@ static bool fold_check_except_float(sfloat_t (*callback)(sfloat_state_t *, sfloa 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) @@ -1004,7 +1116,7 @@ static GMQCC_INLINE ast_expression *fold_op_mul(fold_t *fold, ast_value *a, ast_ 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); @@ -1014,10 +1126,10 @@ static GMQCC_INLINE ast_expression *fold_op_mul(fold_t *fold, ast_value *a, ast_ } 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; @@ -1049,7 +1161,7 @@ static GMQCC_INLINE ast_expression *fold_op_div(fold_t *fold, ast_value *a, ast_ } } 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), @@ -1220,7 +1332,17 @@ 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; +} + +static GMQCC_INLINE ast_expression *fold_op_length(fold_t *fold, ast_value *a) { + if (fold_can_1(a) && isstring(a)) + return fold_constgen_float(fold, strlen(fold_immvalue_string(a)), false); + if (isarray(a)) + return fold_constgen_float(fold, vec_size(a->initlist), false); return NULL; } @@ -1261,29 +1383,30 @@ ast_expression *fold_op(fold_t *fold, const oper_info *info, ast_expression **op return e switch(info->id) { - fold_op_case(2, ('-', 'P'), neg, (fold, a)); - fold_op_case(2, ('!', 'P'), not, (fold, a)); - fold_op_case(1, ('+'), add, (fold, a, b)); - fold_op_case(1, ('-'), sub, (fold, a, b)); - fold_op_case(1, ('*'), mul, (fold, a, b)); - fold_op_case(1, ('/'), div, (fold, a, b)); - fold_op_case(1, ('%'), mod, (fold, a, b)); - fold_op_case(1, ('|'), bor, (fold, a, b)); - fold_op_case(1, ('&'), band, (fold, a, b)); - fold_op_case(1, ('^'), xor, (fold, a, b)); - fold_op_case(1, ('<'), ltgt, (fold, a, b, true)); - fold_op_case(1, ('>'), ltgt, (fold, a, b, false)); - fold_op_case(2, ('<', '<'), lshift, (fold, a, b)); - fold_op_case(2, ('>', '>'), rshift, (fold, a, b)); - fold_op_case(2, ('|', '|'), andor, (fold, a, b, true)); - fold_op_case(2, ('&', '&'), andor, (fold, a, b, false)); - fold_op_case(2, ('?', ':'), tern, (fold, a, b, c)); - fold_op_case(2, ('*', '*'), exp, (fold, a, b)); - fold_op_case(3, ('<','=','>'), lteqgt, (fold, a, b)); - fold_op_case(2, ('!', '='), cmp, (fold, a, b, true)); - fold_op_case(2, ('=', '='), cmp, (fold, a, b, false)); - fold_op_case(2, ('~', 'P'), bnot, (fold, a)); - fold_op_case(2, ('>', '<'), cross, (fold, a, b)); + fold_op_case(2, ('-', 'P'), neg, (fold, a)); + fold_op_case(2, ('!', 'P'), not, (fold, a)); + fold_op_case(1, ('+'), add, (fold, a, b)); + fold_op_case(1, ('-'), sub, (fold, a, b)); + fold_op_case(1, ('*'), mul, (fold, a, b)); + fold_op_case(1, ('/'), div, (fold, a, b)); + fold_op_case(1, ('%'), mod, (fold, a, b)); + fold_op_case(1, ('|'), bor, (fold, a, b)); + fold_op_case(1, ('&'), band, (fold, a, b)); + fold_op_case(1, ('^'), xor, (fold, a, b)); + fold_op_case(1, ('<'), ltgt, (fold, a, b, true)); + fold_op_case(1, ('>'), ltgt, (fold, a, b, false)); + fold_op_case(2, ('<', '<'), lshift, (fold, a, b)); + fold_op_case(2, ('>', '>'), rshift, (fold, a, b)); + fold_op_case(2, ('|', '|'), andor, (fold, a, b, true)); + fold_op_case(2, ('&', '&'), andor, (fold, a, b, false)); + fold_op_case(2, ('?', ':'), tern, (fold, a, b, c)); + fold_op_case(2, ('*', '*'), exp, (fold, a, b)); + fold_op_case(3, ('<','=','>'), lteqgt, (fold, a, b)); + fold_op_case(2, ('!', '='), cmp, (fold, a, b, true)); + fold_op_case(2, ('=', '='), cmp, (fold, a, b, false)); + fold_op_case(2, ('~', 'P'), bnot, (fold, a)); + fold_op_case(2, ('>', '<'), cross, (fold, a, b)); + fold_op_case(3, ('l', 'e', 'n'), length, (fold, a)); } #undef fold_op_case compile_error(fold_ctx(fold), "internal error: attempted to constant-fold for unsupported operator");