/*
- * Copyright (C) 2012, 2013, 2014
+ * Copyright (C) 2012, 2013, 2014, 2015
* Dale Weiler
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
#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
- * unit for these exceptions because setting FPU control words might not
- * work. Systems can set and enforce FPU modes of operation. It's also valid
- * for libc's to simply ignore FPU exceptions. For instance ARM CPUs in
- * glibc. We implement some trivial and IEE 754 conformant functions which
- * emulate those operations. This is an entierly optional compiler feature
- * which shouldn't be enabled for anything other than performing strict
- * passes on constant expressions since it's quite slow.
+ * Comparing float values is an unsafe operation when the operands to the
+ * comparison are floating point values that are inexact. For instance 1/3 is an
+ * inexact value. The FPU is meant to raise exceptions when these sorts of things
+ * happen, including division by zero, underflows and overflows. The C standard
+ * library provides us with the <fenv.h> header to gain access to the floating-
+ * point environment and lets us set the rounding mode and check for these exceptions.
+ * The problem is the standard C library allows an implementation to leave these
+ * stubbed out and does not require they be implemented. Furthermore, depending
+ * on implementations there is no control over the FPU. This is an IEE 754
+ * conforming implementation in software to compensate.
*/
typedef uint32_t sfloat_t;
sfloat_t s;
} sfloat_cast_t;
+/* Exception flags */
typedef enum {
+ SFLOAT_NOEXCEPT = 0,
SFLOAT_INVALID = 1,
SFLOAT_DIVBYZERO = 4,
SFLOAT_OVERFLOW = 8,
SFLOAT_INEXACT = 32
} sfloat_exceptionflags_t;
+/* Rounding modes */
typedef enum {
SFLOAT_ROUND_NEAREST_EVEN,
SFLOAT_ROUND_DOWN,
SFLOAT_ROUND_TO_ZERO
} sfloat_roundingmode_t;
+/* Underflow tininess-detection mode */
typedef enum {
SFLOAT_TAFTER,
SFLOAT_TBEFORE
sfloat_tdetect_t tiny;
} sfloat_state_t;
-/* Count of leading zero bits before the most-significand 1 bit. */
+/* Counts the number of leading zero bits before the most-significand one bit. */
#ifdef _MSC_VER
/* MSVC has an intrinsic for this */
static GMQCC_INLINE uint32_t sfloat_clz(uint32_t x) {
#endif
/* The value of a NaN */
-#define SFLOAT_NAN 0xFFC00000
+#define SFLOAT_NAN 0xFFFFFFFF
/* Test if NaN */
#define SFLOAT_ISNAN(A) \
(0xFF000000 < (uint32_t)((A) << 1))
(((((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.
+ * Shifts `A' right by the number of bits given in `COUNT'. If any non-zero bits
+ * are shifted off they are forced into the least significand bit of the result
+ * by setting it to one. As a result of this, the value of `COUNT' can be
+ * arbitrarily large; if `COUNT' is greater than 32, the result will be either
+ * zero or one, depending on whether `A' is a zero or non-zero. The result is
+ * stored into the value pointed by `Z'.
*/
#define SFLOAT_SHIFT(SIZE, A, COUNT, Z) \
*(Z) = ((COUNT) == 0) \
: (((COUNT) < (SIZE)) \
? ((A) >> (COUNT)) | (((A) << ((-(COUNT)) & ((SIZE) - 1))) != 0) \
: ((A) != 0))
+
/* Extract fractional component */
#define SFLOAT_EXTRACT_FRAC(X) \
((uint32_t)((X) & 0x007FFFFF))
/* Extract sign bit */
#define SFLOAT_EXTRACT_SIGN(X) \
((X) >> 31)
-/* Normalize a subnormal */
+/*
+ * Normalizes the subnormal value represented by the denormalized significand
+ * `SA'. The normalized exponent and significand are stored at the locations
+ * pointed by `Z' and `SZ' respectively.
+ */
#define SFLOAT_SUBNORMALIZE(SA, Z, SZ) \
- (void)(*(SZ) = (SA) << SFLOAT_CLZ((SA), 8), *(SZ) = 1 - SFLOAT_CLZ((SA), 8))
+ (void)(*(SZ) = (SA) << SFLOAT_CLZ((SA), 8), *(Z) = 1 - SFLOAT_CLZ((SA), 8))
/*
- * Pack sign, exponent and significand and produce a float.
+ * Packs the sign `SIGN', exponent `EXP' and significand `SIG' into the value
+ * giving the result.
*
- * Integer portions of the significand are added to the exponent. The
- * exponent input should be one less than the result exponent whenever
- * the significand is normalized since normalized significand will
- * always have an integer portion of value one.
+ * After the shifting into their proper positions, the fields are added together
+ * to form the result. This means any integer portion of `SIG' will be added
+ * to the exponent. Similarly, because a properly normalized significand will
+ * always have an integer portion equal to one, the exponent input `EXP' should
+ * be one less than the desired result exponent whenever the significant input
+ * `SIG' is a complete, normalized significand.
*/
#define SFLOAT_PACK(SIGN, EXP, SIG) \
(sfloat_t)((((uint32_t)(SIGN)) << 31) + (((uint32_t)(EXP)) << 23) + (SIG))
-/* Calculate NaN. If either operands are signaling then raise invalid */
+/*
+ * Takes two values `a' and `b', one of which is a NaN, and returns the appropriate
+ * NaN result. If either `a' or `b' is a signaling NaN than an invalid exception is
+ * raised.
+ */
static sfloat_t sfloat_propagate_nan(sfloat_state_t *state, sfloat_t a, sfloat_t b) {
bool isnan_a = SFLOAT_ISNAN(a);
bool issnan_a = SFLOAT_ISSNAN(a);
b |= 0x00400000;
if (issnan_a | issnan_b)
- SFLOAT_RAISE(state, SFLOAT_INEXACT);
- if (issnan_a) {
- if (issnan_b)
- goto larger;
- return isnan_b ? b : a;
- } else if (isnan_a) {
- if (issnan_b | !isnan_b)
- return a;
-larger:
- if ((uint32_t)(a << 1) < (uint32_t)(b << 1)) return b;
- if ((uint32_t)(b << 1) < (uint32_t)(a << 1)) return a;
- return (a < b) ? a : b;
- }
+ SFLOAT_RAISE(state, SFLOAT_INVALID);
+ if (isnan_a)
+ return (issnan_a & isnan_b) ? b : a;
return b;
}
-/* Round and pack */
+/*
+ * Takes an abstract value having sign `sign_z', exponent `exp_z', and significand
+ * `sig_z' and returns the appropriate value corresponding to the abstract input.
+ *
+ * The abstract value is simply rounded and packed into the format. If the abstract
+ * input cannot be represented exactly an inexact exception is raised. If the
+ * abstract input is too large, the overflow and inexact exceptions are both raised
+ * and an infinity or maximal finite value is returned. If the abstract value is
+ * too small, the value is rounded to a subnormal and the underflow and inexact
+ * exceptions are only raised if the value cannot be represented exactly with
+ * a subnormal.
+ *
+ * The input significand `sig_z' has it's binary point between bits 30 and 29,
+ * this is seven bits to the left of its usual location. The shifted significand
+ * must be normalized or smaller than this. If it's not normalized then the exponent
+ * `exp_z' must be zero; in that case, the result returned is a subnormal number
+ * which must not require rounding. In the more usual case where the significand
+ * is normalized, the exponent must be one less than the *true* exponent.
+ *
+ * The handling of underflow and overflow is otherwise in alignment with IEC/IEEE.
+ */
static sfloat_t SFLOAT_PACK_round(sfloat_state_t *state, bool sign_z, int16_t exp_z, uint32_t sig_z) {
sfloat_roundingmode_t mode = state->roundingmode;
bool even = !!(mode == SFLOAT_ROUND_NEAREST_EVEN);
SFLOAT_RAISE(state, SFLOAT_UNDERFLOW);
}
}
-
- /*
- * Significand has point between bits 30 and 29, 7 bits to the left of
- * the usual place. This shifted significand has to be normalized
- * or smaller, if it isn't the exponent must be zero, in which case
- * no rounding occurs since the result will be a subnormal.
- */
if (bits)
SFLOAT_RAISE(state, SFLOAT_INEXACT);
sig_z = (sig_z + increment) >> 7;
return SFLOAT_PACK(sign_z, exp_z, sig_z);
}
-/* Normalized round and pack */
+/*
+ * Takes an abstract value having sign `sign_z', exponent `exp_z' and significand
+ * `sig_z' and returns the appropriate value corresponding to the abstract input.
+ * This function is exactly like `PACK_round' except the significand does not have
+ * to be normalized.
+ *
+ * Bit 31 of the significand must be zero and the exponent must be one less than
+ * the *true* exponent.
+ */
static sfloat_t SFLOAT_PACK_normal(sfloat_state_t *state, bool sign_z, int16_t exp_z, uint32_t sig_z) {
unsigned char c = SFLOAT_CLZ(sig_z, 1);
return SFLOAT_PACK_round(state, sign_z, exp_z - c, sig_z << c);
}
+/*
+ * Returns the result of adding the absolute values of `a' and `b'. The sign
+ * `sign_z' is ignored if the result is a NaN.
+ */
static sfloat_t sfloat_add_impl(sfloat_state_t *state, sfloat_t a, sfloat_t b, bool sign_z) {
int16_t exp_a = SFLOAT_EXTRACT_EXP(a);
int16_t exp_b = SFLOAT_EXTRACT_EXP(b);
return SFLOAT_PACK_round(state, sign_z, exp_z, sig_z);
}
+/*
+ * Returns the result of subtracting the absolute values of `a' and `b'. If the
+ * sign `sign_z' is one, the difference is negated before being returned. The
+ * sign is ignored if the result is a NaN.
+ */
static sfloat_t sfloat_sub_impl(sfloat_state_t *state, sfloat_t a, sfloat_t b, bool sign_z) {
int16_t exp_a = SFLOAT_EXTRACT_EXP(a);
int16_t exp_b = SFLOAT_EXTRACT_EXP(b);
return SFLOAT_PACK_round(state, sign_z, exp_z, sig_z);
}
+static sfloat_t sfloat_neg(sfloat_state_t *state, sfloat_t a) {
+ sfloat_cast_t neg;
+ neg.f = -1;
+ return sfloat_mul(state, a, neg.s);
+}
+
static GMQCC_INLINE void sfloat_check(lex_ctx_t ctx, sfloat_state_t *state, const char *vec) {
/* Exception comes from vector component */
if (vec) {
}
static GMQCC_INLINE void sfloat_init(sfloat_state_t *state) {
- state->exceptionflags = 0;
+ 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
+ * stage constant folding, where, with the help of the AST, operator
* usages can be constant folded. Then there is the constant folding
* in the IR for things like eliding if statements, can occur.
*
#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))
/*
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,
sfloat_t (*callback)(sfloat_state_t *, sfloat_t, sfloat_t))
{
vec3_soft_state_t state;
- sfloat_init(&state.state[0]);
- sfloat_init(&state.state[1]);
- sfloat_init(&state.state[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 vec3_t vec3_neg(vec3_t a) {
- vec3_t out;
+static GMQCC_INLINE vec3_t vec3_neg(lex_ctx_t ctx, vec3_t a) {
+ vec3_t out;
+ sfloat_cast_t v[3];
+ sfloat_state_t s[3];
+
+ if (!OPTS_FLAG(ARITHMETIC_EXCEPTIONS))
+ goto end;
+
+ v[0].f = a.x;
+ v[1].f = a.y;
+ v[2].f = a.z;
+
+ sfloat_init(&s[0]);
+ sfloat_init(&s[1]);
+ sfloat_init(&s[2]);
+
+ sfloat_neg(&s[0], v[0].s);
+ sfloat_neg(&s[1], v[1].s);
+ sfloat_neg(&s[2], v[2].s);
+
+ sfloat_check(ctx, &s[0], NULL);
+ sfloat_check(ctx, &s[1], NULL);
+ sfloat_check(ctx, &s[2], NULL);
+
+end:
out.x = -a.x;
out.y = -a.y;
out.z = -a.z;
}
static GMQCC_INLINE qcfloat_t vec3_mulvv(lex_ctx_t ctx, vec3_t a, vec3_t b) {
- vec3_soft_t sa = vec3_soft_convert(a);
- vec3_soft_t sb = vec3_soft_convert(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_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(lex_ctx_t ctx, vec3_t a, qcfloat_t b) {
vec3_t out;
- vec3_soft_t sa = vec3_soft_convert(a);
+ 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_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;
return (ast_expression*)out;
}
+typedef union {
+ void (*callback)(void);
+ sfloat_t (*binary)(sfloat_state_t *, sfloat_t, sfloat_t);
+ sfloat_t (*unary)(sfloat_state_t *, sfloat_t);
+} float_check_callback_t;
+
+static bool fold_check_except_float_impl(void (*callback)(void),
+ fold_t *fold,
+ ast_value *a,
+ ast_value *b)
+{
+ float_check_callback_t call;
+ sfloat_state_t s;
+ sfloat_cast_t ca;
+
+ if (!OPTS_FLAG(ARITHMETIC_EXCEPTIONS) && !OPTS_WARN(WARN_INEXACT_COMPARES))
+ return false;
+
+ call.callback = callback;
+ sfloat_init(&s);
+ ca.f = fold_immvalue_float(a);
+ if (b) {
+ sfloat_cast_t cb;
+ cb.f = fold_immvalue_float(b);
+ call.binary(&s, ca.s, cb.s);
+ } else {
+ call.unary(&s, ca.s);
+ }
+
+ if (s.exceptionflags == 0)
+ return false;
+
+ if (!OPTS_FLAG(ARITHMETIC_EXCEPTIONS))
+ goto inexact_possible;
+
+ sfloat_check(fold_ctx(fold), &s, NULL);
+
+inexact_possible:
+ return s.exceptionflags & SFLOAT_INEXACT;
+}
+
+#define fold_check_except_float(CALLBACK, FOLD, A, B) \
+ fold_check_except_float_impl(((void (*)(void))(CALLBACK)), (FOLD), (A), (B))
+
+static bool fold_check_inexact_float(fold_t *fold, ast_value *a, ast_value *b) {
+ lex_ctx_t ctx = fold_ctx(fold);
+ if (!OPTS_WARN(WARN_INEXACT_COMPARES))
+ return false;
+ if (!a->inexact && !b->inexact)
+ return false;
+ return compile_warning(ctx, WARN_INEXACT_COMPARES, "inexact value in comparison");
+}
static GMQCC_INLINE ast_expression *fold_op_mul_vec(fold_t *fold, vec3_t vec, ast_value *sel, const char *set) {
- /*
- * vector-component constant folding works by matching the component sets
- * to eliminate expensive operations on whole-vectors (3 components at runtime).
- * to achive this effect in a clean manner this function generalizes the
- * values through the use of a set paramater, which is used as an indexing method
- * for creating the elided ast binary expression.
- *
- * Consider 'n 0 0' where y, and z need to be tested for 0, and x is
- * used as the value in a binary operation generating an INSTR_MUL instruction,
- * to acomplish the indexing of the correct component value we use set[0], set[1], set[2]
- * as x, y, z, where the values of those operations return 'x', 'y', 'z'. Because
- * of how ASCII works we can easily deliniate:
- * vec.z is the same as set[2]-'x' for when set[2] is 'z', 'z'-'x' results in a
- * literal value of 2, using this 2, we know that taking the address of vec->x (float)
- * and indxing it with this literal will yeild the immediate address of that component
- *
- * Of course more work needs to be done to generate the correct index for the ast_member_new
- * call, which is no problem: set[0]-'x' suffices that job.
- */
qcfloat_t x = (&vec.x)[set[0]-'x'];
qcfloat_t y = (&vec.x)[set[1]-'x'];
qcfloat_t z = (&vec.x)[set[2]-'x'];
-
if (!y && !z) {
ast_expression *out;
++opts_optimizationcount[OPTIM_VECTOR_COMPONENTS];
static GMQCC_INLINE ast_expression *fold_op_neg(fold_t *fold, ast_value *a) {
if (isfloat(a)) {
- if (fold_can_1(a))
- return fold_constgen_float(fold, -fold_immvalue_float(a), false);
+ if (fold_can_1(a)) {
+ /* Negation can produce inexact as well */
+ bool inexact = fold_check_except_float(&sfloat_neg, fold, a, NULL);
+ return fold_constgen_float(fold, -fold_immvalue_float(a), inexact);
+ }
} else if (isvector(a)) {
if (fold_can_1(a))
- return fold_constgen_vector(fold, vec3_neg(fold_immvalue_vector(a)));
+ return fold_constgen_vector(fold, vec3_neg(fold_ctx(fold), fold_immvalue_vector(a)));
}
return NULL;
}
return NULL;
}
-static bool fold_check_except_float(sfloat_t (*callback)(sfloat_state_t *, sfloat_t, sfloat_t),
- fold_t *fold,
- ast_value *a,
- ast_value *b)
-{
- sfloat_state_t s;
- sfloat_cast_t ca;
- sfloat_cast_t cb;
-
- if (!OPTS_FLAG(ARITHMETIC_EXCEPTIONS) && !OPTS_WARN(WARN_INEXACT_COMPARES))
- return false;
-
- 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)
- return false;
-
- if (!OPTS_FLAG(ARITHMETIC_EXCEPTIONS))
- goto inexact_possible;
-
- sfloat_check(fold_ctx(fold), &s, NULL);
-
-inexact_possible:
- return s.exceptionflags & SFLOAT_INEXACT;
-}
-
-static bool fold_check_inexact_float(fold_t *fold, ast_value *a, ast_value *b) {
- lex_ctx_t ctx = fold_ctx(fold);
- if (!OPTS_WARN(WARN_INEXACT_COMPARES))
- return false;
- if (!a->inexact && !b->inexact)
- return false;
- return compile_warning(ctx, WARN_INEXACT_COMPARES, "inexact value in comparison");
-}
-
static GMQCC_INLINE ast_expression *fold_op_add(fold_t *fold, ast_value *a, ast_value *b) {
if (isfloat(a)) {
if (fold_can_2(a, b)) {
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;
}
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");
}
/*
- * Constant folding for compiler intrinsics, simaler approach to operator
- * folding, primarly: individual functions for each intrinsics to fold,
+ * Constant folding for compiler intrinsics, similar approach to operator
+ * folding, primarily: individual functions for each intrinsics to fold,
* and a generic selection function.
*/
static GMQCC_INLINE ast_expression *fold_intrin_isfinite(fold_t *fold, ast_value *a) {
projects / xonotic / gmqcc.git / blobdiff