X-Git-Url: https://git.xonotic.org/?p=xonotic%2Fgmqcc.git;a=blobdiff_plain;f=fold.c;h=98e637ae0e62177fe580fbcb180495898d3e3540;hp=f8a143ceb7f7f4ab772c99323d7a96336965bf84;hb=c52ad67a7cefc602a1a415eca0f92cd23beaf28f;hpb=51ef277e210afeace2c1500f4c22c17b8e47d2d5 diff --git a/fold.c b/fold.c index f8a143c..98e637a 100644 --- a/fold.c +++ b/fold.c @@ -163,6 +163,14 @@ 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; + 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; + return out; +} + static lex_ctx_t fold_ctx(fold_t *fold) { lex_ctx_t ctx; if (fold->parser->lex) @@ -201,11 +209,25 @@ static GMQCC_INLINE bool fold_immediate_true(fold_t *fold, ast_value *v) { ((ast_expression*)(X))->vtype != TYPE_FUNCTION) #define fold_can_2(X, Y) (fold_can_1(X) && fold_can_1(Y)) +#define fold_can_div(X) (fold_immvalue_float(X) != 0.0f) #define fold_immvalue_float(E) ((E)->constval.vfloat) #define fold_immvalue_vector(E) ((E)->constval.vvec) #define fold_immvalue_string(E) ((E)->constval.vstring) +#ifdef INFINITY +# define fold_infinity_float INFINITY +#else +# define fold_infinity_float (1.0 / 0.0) +#endif /*! INFINITY */ + +#define fold_infinity_vector \ + vec3_create( \ + fold_infinity_float, \ + fold_infinity_float, \ + fold_infinity_float \ + ) + fold_t *fold_init(parser_t *parser) { fold_t *fold = (fold_t*)mem_a(sizeof(fold_t)); fold->parser = parser; @@ -222,9 +244,11 @@ fold_t *fold_init(parser_t *parser) { (void)fold_constgen_float (fold, 0.0f); (void)fold_constgen_float (fold, 1.0f); (void)fold_constgen_float (fold, -1.0f); + (void)fold_constgen_float (fold, fold_infinity_float); /* +inf */ (void)fold_constgen_vector(fold, vec3_create(0.0f, 0.0f, 0.0f)); (void)fold_constgen_vector(fold, vec3_create(-1.0f, -1.0f, -1.0f)); + (void)fold_constgen_vector(fold, fold_infinity_vector); /* +inf */ return fold; } @@ -454,12 +478,23 @@ static GMQCC_INLINE ast_expression *fold_op_mul(fold_t *fold, ast_value *a, ast_ static GMQCC_INLINE ast_expression *fold_op_div(fold_t *fold, ast_value *a, ast_value *b) { if (isfloat(a)) { - if (fold_can_2(a, b)) - return fold_constgen_float(fold, fold_immvalue_float(a) / fold_immvalue_float(b)); + if (fold_can_2(a, b)) { + if (fold_can_div(b)) + return fold_constgen_float(fold, fold_immvalue_float(a) / fold_immvalue_float(b)); + else + return (ast_expression*)fold->imm_float[3]; /* inf */ + } } 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))); - else { + if (fold_can_2(a, b)) { + if (fold_can_div(b)) { + printf("hit wrong logic\n"); + return fold_constgen_vector(fold, vec3_mulvf(fold_immvalue_vector(a), 1.0f / fold_immvalue_float(b))); + } + else { + printf("hit logic\n"); + return (ast_expression*)fold->imm_vector[2]; /* inf */ + } + } else { return (ast_expression*)ast_binary_new( fold_ctx(fold), INSTR_MUL_VF, @@ -479,8 +514,12 @@ static GMQCC_INLINE ast_expression *fold_op_div(fold_t *fold, ast_value *a, ast_ } static GMQCC_INLINE ast_expression *fold_op_mod(fold_t *fold, ast_value *a, ast_value *b) { - if (fold_can_2(a, b)) - return fold_constgen_float(fold, (qcfloat_t)(((qcint_t)fold_immvalue_float(a)) % ((qcint_t)fold_immvalue_float(b)))); + if (fold_can_2(a, b)) { + if (fold_can_div(b)) + return fold_constgen_float(fold, (qcfloat_t)(((qcint_t)fold_immvalue_float(a)) % ((qcint_t)fold_immvalue_float(b)))); + else + return (ast_expression*)fold->imm_float[3]; /* inf */ + } return NULL; } @@ -610,6 +649,12 @@ static GMQCC_INLINE ast_expression *fold_op_bnot(fold_t *fold, ast_value *a) { return NULL; } +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 NULL; +} + ast_expression *fold_op(fold_t *fold, const oper_info *info, ast_expression **opexprs) { ast_value *a = (ast_value*)opexprs[0]; ast_value *b = (ast_value*)opexprs[1]; @@ -667,69 +712,56 @@ ast_expression *fold_op(fold_t *fold, const oper_info *info, ast_expression **op 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)); } #undef fold_op_case compile_error(fold_ctx(fold), "internal error: attempted to constant-fold for unsupported operator"); return NULL; } -#define expect(X) \ - do { \ - if (vec_size(params) != (X)) { \ - compile_error( \ - fold_ctx(fold), \ - "internal error: attempted to constant-fold with invalid paramaters for intrinsic `%s`", \ - intrin \ - ); \ - return NULL; \ - } \ - } while (0) - -ast_expression *fold_intrin(fold_t *fold, const char *intrin, ast_expression **params) { - if (!fold) return NULL; - if (!intrin) return NULL; - - if (!strcmp(intrin, "__builtin_exp")) { - expect(1); - ++opts_optimizationcount[OPTIM_CONST_FOLD]; - return fold_constgen_float(fold, exp(fold_immvalue_float((ast_value*)params[0]))); - } +/* + * Constant folding for compiler intrinsics, simaler approach to operator + * folding, primarly: individual functions for each intrinsics to fold, + * and a generic selection function. + */ +static GMQCC_INLINE ast_expression *fold_intrin_mod(fold_t *fold, ast_value *lhs, ast_value *rhs) { + return fold_constgen_float( + fold, + fmodf( + fold_immvalue_float(lhs), + fold_immvalue_float(rhs) + ) + ); +} - if (!strcmp(intrin, "__builtin_mod")) { - expect(2); - ++opts_optimizationcount[OPTIM_CONST_FOLD]; - return fold_constgen_float( - fold, - fmodf( - fold_immvalue_float((ast_value*)params[0]), - fold_immvalue_float((ast_value*)params[1]) - ) - ); - } +static GMQCC_INLINE ast_expression *fold_intrin_pow(fold_t *fold, ast_value *lhs, ast_value *rhs) { + return fold_constgen_float( + fold, + powf( + fold_immvalue_float(lhs), + fold_immvalue_float(rhs) + ) + ); +} - if (!strcmp(intrin, "__builtin_pow")) { - expect(2); - ++opts_optimizationcount[OPTIM_CONST_FOLD]; - return fold_constgen_float( - fold, - powf( - fold_immvalue_float((ast_value*)params[0]), - fold_immvalue_float((ast_value*)params[1]) - ) - ); - } +static GMQCC_INLINE ast_expression *fold_intrin_exp(fold_t *fold, ast_value *value) { + return fold_constgen_float(fold, exp(fold_immvalue_float(value))); +} - if (!strcmp(intrin, "__builtin_isnan")) { - expect(1); - ++opts_optimizationcount[OPTIM_CONST_FOLD]; - return fold_constgen_float(fold, isnan(fold_immvalue_float((ast_value*)params[0])) != 0.0f); - } +static GMQCC_INLINE ast_expression *fold_intrin_isnan(fold_t *fold, ast_value *value) { + return fold_constgen_float(fold, isnan(fold_immvalue_float(value)) != 0.0f); +} - if (!strcmp(intrin, "__builtin_fabs")) { - expect(1); - ++opts_optimizationcount[OPTIM_CONST_FOLD]; - return fold_constgen_float(fold, fabs(fold_immvalue_float((ast_value*)params[0]))); - } +static GMQCC_INLINE ast_expression *fold_intrin_fabs(fold_t *fold, ast_value *value) { + return fold_constgen_float(fold, fabs(fold_immvalue_float(value))); +} + +ast_expression *fold_intrin(fold_t *fold, const char *intrin, ast_expression **arg) { + if (!strcmp(intrin, "mod")) return fold_intrin_mod (fold, (ast_value*)arg[0], (ast_value*)arg[1]); + if (!strcmp(intrin, "pow")) return fold_intrin_pow (fold, (ast_value*)arg[0], (ast_value*)arg[1]); + if (!strcmp(intrin, "exp")) return fold_intrin_exp (fold, (ast_value*)arg[0]); + if (!strcmp(intrin, "isnan")) return fold_intrin_isnan(fold, (ast_value*)arg[0]); + if (!strcmp(intrin, "fabs")) return fold_intrin_fabs (fold, (ast_value*)arg[0]); return NULL; }