compile_error(ctx, "arithmetic overflow in `%s' component", vec);
if (state->exceptionflags & SFLOAT_UNDERFLOW)
compile_error(ctx, "arithmetic underflow in `%s' component", vec);
- return;
+ return;
}
if (state->exceptionflags & SFLOAT_DIVBYZERO)
compile_error(ctx, "division by zero");
* This file is thus, split into two parts.
*/
-#define isfloat(X) (((ast_expression*)(X))->m_vtype == TYPE_FLOAT)
-#define isvector(X) (((ast_expression*)(X))->m_vtype == TYPE_VECTOR)
-#define isstring(X) (((ast_expression*)(X))->m_vtype == TYPE_STRING)
-#define isarray(X) (((ast_expression*)(X))->m_vtype == TYPE_ARRAY)
+#define isfloat(X) (((X))->m_vtype == TYPE_FLOAT)
+#define isvector(X) (((X))->m_vtype == TYPE_VECTOR)
+#define isstring(X) (((X))->m_vtype == TYPE_STRING)
+#define isarray(X) (((X))->m_vtype == TYPE_ARRAY)
#define isfloats(X,Y) (isfloat (X) && isfloat (Y))
/*
/* Handy macros to determine if an ast_value can be constant folded. */
#define fold_can_1(X) \
- (ast_istype(((ast_expression*)(X)), ast_value) && (X)->m_hasvalue && ((X)->m_cvq == CV_CONST) && \
- ((ast_expression*)(X))->m_vtype != TYPE_FUNCTION)
+ (ast_istype(((X)), ast_value) && (X)->m_hasvalue && ((X)->m_cvq == CV_CONST) && \
+ ((X))->m_vtype != TYPE_FUNCTION)
#define fold_can_2(X, Y) (fold_can_1(X) && fold_can_1(Y))
ast_expression *fold::constgen_float(qcfloat_t value, bool inexact) {
for (auto &it : m_imm_float)
if (!memcmp(&it->m_constval.vfloat, &value, sizeof(qcfloat_t)))
- return (ast_expression*)it;
+ return it;
ast_value *out = new ast_value(ctx(), "#IMMEDIATE", TYPE_FLOAT);
out->m_cvq = CV_CONST;
m_imm_float.push_back(out);
- return (ast_expression*)out;
+ return out;
}
ast_expression *fold::constgen_vector(vec3_t value) {
for (auto &it : m_imm_vector)
if (vec3_cmp(it->m_constval.vvec, value))
- return (ast_expression*)it;
+ return it;
ast_value *out = new ast_value(ctx(), "#IMMEDIATE", TYPE_VECTOR);
out->m_cvq = CV_CONST;
m_imm_vector.push_back(out);
- return (ast_expression*)out;
+ return out;
}
ast_expression *fold::constgen_string(const char *str, bool translate) {
size_t hash = util_hthash(table, str);
if ((out = (ast_value*)util_htgeth(table, str, hash)))
- return (ast_expression*)out;
+ return out;
if (translate) {
char name[32];
m_imm_string.push_back(out);
util_htseth(table, str, hash, out);
- return (ast_expression*)out;
+ return out;
}
ast_expression *fold::constgen_string(const std::string &str, bool translate) {
if (!y && !z) {
ast_expression *out;
++opts_optimizationcount[OPTIM_VECTOR_COMPONENTS];
- out = ast_member::make(ctx(), (ast_expression*)sel, set[0]-'x', nullptr);
+ out = ast_member::make(ctx(), sel, set[0]-'x', "");
out->m_keep_node = false;
((ast_member*)out)->m_rvalue = true;
if (x != -1.0f)
return new ast_binary(
ctx(),
INSTR_MUL_F,
- (ast_expression*)a,
+ a,
constgen_float(1.0f / immvalue_float(b), false)
);
}
return new ast_binary(
ctx(),
INSTR_MUL_VF,
- (ast_expression*)a,
+ a,
(fold_can_1(b))
- ? (ast_expression*)constgen_float(1.0f / immvalue_float(b), false)
+ ? constgen_float(1.0f / immvalue_float(b), false)
: new ast_binary(ctx(),
INSTR_DIV_F,
- (ast_expression*)m_imm_float[1],
- (ast_expression*)b
+ m_imm_float[1],
+ b
)
);
}
if (fold_can_2(a, b)) {
if (OPTS_FLAG(PERL_LOGIC)) {
if (expr)
- return immediate_true(a) ? (ast_expression*)a : (ast_expression*)b;
+ return immediate_true(a) ? a : b;
else
- return immediate_true(a) ? (ast_expression*)b : (ast_expression*)a;
+ return immediate_true(a) ? b : a;
} else {
return constgen_float(
((expr) ? (immediate_true(a) || immediate_true(b))
ast_expression *fold::op_tern(ast_value *a, ast_value *b, ast_value *c) {
if (fold_can_1(a)) {
return immediate_true(a)
- ? (ast_expression*)b
- : (ast_expression*)c;
+ ? b
+ : c;
}
return nullptr;
}
ast_expression *fold::op_lteqgt(ast_value *a, ast_value *b) {
if (fold_can_2(a,b)) {
check_inexact_float(a, b);
- if (immvalue_float(a) < immvalue_float(b)) return (ast_expression*)m_imm_float[2];
- if (immvalue_float(a) == immvalue_float(b)) return (ast_expression*)m_imm_float[0];
- if (immvalue_float(a) > immvalue_float(b)) return (ast_expression*)m_imm_float[1];
+ if (immvalue_float(a) < immvalue_float(b)) return m_imm_float[2];
+ if (immvalue_float(a) == immvalue_float(b)) return m_imm_float[0];
+ if (immvalue_float(a) > immvalue_float(b)) return m_imm_float[1];
}
return nullptr;
}
ast_expression *fold::op_ltgt(ast_value *a, ast_value *b, bool lt) {
if (fold_can_2(a, b)) {
check_inexact_float(a, b);
- return (lt) ? (ast_expression*)m_imm_float[!!(immvalue_float(a) < immvalue_float(b))]
- : (ast_expression*)m_imm_float[!!(immvalue_float(a) > immvalue_float(b))];
+ return (lt) ? m_imm_float[!!(immvalue_float(a) < immvalue_float(b))]
+ : m_imm_float[!!(immvalue_float(a) > immvalue_float(b))];
}
return nullptr;
}
float la = immvalue_float(a);
float lb = immvalue_float(b);
check_inexact_float(a, b);
- return (ast_expression*)m_imm_float[!(ne ? la == lb : la != lb)];
- } if (isvector(a) && isvector(b)) {
+ return m_imm_float[ne ? la != lb : la == lb];
+ } else if (isvector(a) && isvector(b)) {
vec3_t la = immvalue_vector(a);
vec3_t lb = immvalue_vector(b);
- return (ast_expression*)m_imm_float[!(ne ? vec3_cmp(la, lb) : !vec3_cmp(la, lb))];
+ bool compare = vec3_cmp(la, lb);
+ return m_imm_float[ne ? !compare : compare];
+ } else if (isstring(a) && isstring(b)) {
+ bool compare = !strcmp(immvalue_string(a), immvalue_string(b));
+ return m_imm_float[ne ? !compare : compare];
}
}
return nullptr;
return nullptr;
switch(info->operands) {
- case 3: if(!c) return nullptr;
- case 2: if(!b) return nullptr;
+ case 3: if(!c) return nullptr; [[fallthrough]];
+ case 2: if(!b) return nullptr; [[fallthrough]];
case 1:
if(!a) {
compile_error(ctx(), "internal error: fold_op no operands to fold\n");
ast_expression *fold::intrinsic_fabs(ast_value *a) {
return constgen_float(fabsf(immvalue_float(a)), false);
}
+ast_expression* fold::intrinsic_nan(void) {
+ return constgen_float(0.0f / 0.0f, false);
+}
+ast_expression* fold::intrinsic_epsilon(void) {
+ static bool calculated = false;
+ static float eps = 1.0f;
+ if (!calculated) {
+ do {
+ eps /= 2.0f;
+ } while ((1.0f + (eps / 2.0f)) != 1.0f);
+ calculated = true;
+ }
+ return constgen_float(eps, false);
+}
-ast_expression *fold::intrinsic(const char *intrinsic, ast_expression **arg) {
+ast_expression* fold::intrinsic_inf(void) {
+ return constgen_float(1.0f / 0.0f, false);
+}
+
+ast_expression *fold::intrinsic(const char *intrinsic, size_t n_args, ast_expression **args) {
ast_expression *ret = nullptr;
- ast_value *a = (ast_value*)arg[0];
- ast_value *b = (ast_value*)arg[1];
-
- if (!strcmp(intrinsic, "isfinite")) ret = intrinsic_isfinite(a);
- if (!strcmp(intrinsic, "isinf")) ret = intrinsic_isinf(a);
- if (!strcmp(intrinsic, "isnan")) ret = intrinsic_isnan(a);
- if (!strcmp(intrinsic, "isnormal")) ret = intrinsic_isnormal(a);
- if (!strcmp(intrinsic, "signbit")) ret = intrinsic_signbit(a);
- if (!strcmp(intrinsic, "acosh")) ret = intrinsic_acosh(a);
- if (!strcmp(intrinsic, "asinh")) ret = intrinsic_asinh(a);
- if (!strcmp(intrinsic, "atanh")) ret = intrinsic_atanh(a);
- if (!strcmp(intrinsic, "exp")) ret = intrinsic_exp(a);
- if (!strcmp(intrinsic, "exp2")) ret = intrinsic_exp2(a);
- if (!strcmp(intrinsic, "expm1")) ret = intrinsic_expm1(a);
- if (!strcmp(intrinsic, "mod")) ret = intrinsic_mod(a, b);
- if (!strcmp(intrinsic, "pow")) ret = intrinsic_pow(a, b);
- if (!strcmp(intrinsic, "fabs")) ret = intrinsic_fabs(a);
- if (ret)
+ if (n_args) {
+ ast_value *a = (ast_value*)args[0];
+ ast_value *b = (ast_value*)args[1];
+ if (!strcmp(intrinsic, "isfinite")) ret = intrinsic_isfinite(a);
+ if (!strcmp(intrinsic, "isinf")) ret = intrinsic_isinf(a);
+ if (!strcmp(intrinsic, "isnan")) ret = intrinsic_isnan(a);
+ if (!strcmp(intrinsic, "isnormal")) ret = intrinsic_isnormal(a);
+ if (!strcmp(intrinsic, "signbit")) ret = intrinsic_signbit(a);
+ if (!strcmp(intrinsic, "acosh")) ret = intrinsic_acosh(a);
+ if (!strcmp(intrinsic, "asinh")) ret = intrinsic_asinh(a);
+ if (!strcmp(intrinsic, "atanh")) ret = intrinsic_atanh(a);
+ if (!strcmp(intrinsic, "exp")) ret = intrinsic_exp(a);
+ if (!strcmp(intrinsic, "exp2")) ret = intrinsic_exp2(a);
+ if (!strcmp(intrinsic, "expm1")) ret = intrinsic_expm1(a);
+ if (!strcmp(intrinsic, "mod")) ret = intrinsic_mod(a, b);
+ if (!strcmp(intrinsic, "pow")) ret = intrinsic_pow(a, b);
+ if (!strcmp(intrinsic, "fabs")) ret = intrinsic_fabs(a);
+ } else {
+ if (!strcmp(intrinsic, "nan")) ret = intrinsic_nan();
+ if (!strcmp(intrinsic, "epsilon")) ret = intrinsic_epsilon();
+ if (!strcmp(intrinsic, "inf")) ret = intrinsic_inf();
+ }
+
+ if (ret) {
++opts_optimizationcount[OPTIM_CONST_FOLD];
+ }
return ret;
}
case INSTR_DIV_F:
if (swapped)
return nullptr;
+ [[fallthrough]];
case INSTR_MUL_F:
if (immvalue_float(load) == 1.0f) {
++opts_optimizationcount[OPTIM_PEEPHOLE];
case INSTR_SUB_F:
if (swapped)
return nullptr;
+ [[fallthrough]];
case INSTR_ADD_F:
if (immvalue_float(load) == 0.0f) {
++opts_optimizationcount[OPTIM_PEEPHOLE];
case INSTR_SUB_V:
if (swapped)
return nullptr;
+ [[fallthrough]];
case INSTR_ADD_V:
if (vec3_cmp(immvalue_vector(load), vec3_create(0, 0, 0))) {
++opts_optimizationcount[OPTIM_PEEPHOLE];
projects / xonotic / gmqcc.git / blobdiff