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)
((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;
(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;
}
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,
}
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;
}
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];
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;
}
ast_expression_codegen *cgen;
ir_block *elide;
ir_value *dummy;
- bool istrue = (fold_immvalue_float(condval) == 1.0f && branch->on_true);
+ bool istrue = (fold_immvalue_float(condval) != 0.0f && branch->on_true);
bool isfalse = (fold_immvalue_float(condval) == 0.0f && branch->on_false);
ast_expression *path = (istrue) ? branch->on_true :
(isfalse) ? branch->on_false : NULL;