vec_push(intrin->parser->globals, (ast_expression*)value);
}
-#define QC_M_E 2.71828182845905f
+#define QC_M_E 2.718281828459045f
+#define QC_POW_EPSILON 0.00001f
-static ast_expression *intrin_pow (intrin_t *intrin) {
+/*
+ * since some intrinsics depend on each other there is the possibility
+ * that an intrinsic will fail to get a 'depended' function that a
+ * builtin needs, causing some dependency in the chain to have a NULL
+ * function. This will cause a segmentation fault at code generation,
+ * even though an error was raised. To contiue to allow it (instead
+ * of stopping compilation right away). We need to return from the
+ * parser, before compilation stops after all the collected errors.
+ */
+static ast_expression *intrin_func_self(intrin_t *intrin, const char *name, const char *from);
+static ast_expression *intrin_nullfunc(intrin_t *intrin) {
+ ast_value *value = NULL;
+ ast_function *func = intrin_value(intrin, &value, NULL, TYPE_VOID);
+ intrin_reg(intrin, value, func);
+ return (ast_expression*)value;
+}
+
+static ast_expression *intrin_pow(intrin_t *intrin) {
/*
- * float pow(float x, float y) {
- * float local = 1.0f;
- * while (y > 0) {
- * while (!(y & 1)) {
- * y >>= 2;
- * x *= x;
+ *
+ * float pow(float base, float exp) {
+ * float result;
+ * float low;
+ * float high;
+ * float mid;
+ * float square;
+ * float accumulate;
+ *
+ * if (exp == 0.0)
+ * return base;
+ * if (exp < 0)
+ * return 1.0 / pow(base, -exp);
+ * if (exp >= 1) {
+ * result = pow(base, exp / 2);
+ * return result * result;
+ * }
+ *
+ * low = 0.0f;
+ * high = 1.0f;
+ * square = sqrt(base);
+ * accumulate = square;
+ * mid = high / 2.0f
+ *
+ * while (fabs(mid - exp) > QC_POW_EPSILON) {
+ * square = sqrt(square);
+ * if (mid < exp) {
+ * low = mid;
+ * accumulate *= square;
+ * } else {
+ * high = mid;
+ * accumulate *= (1.0f / square);
+ * }
+ * mid = (low + high) / 2;
* }
- * y--;
- * local *= x;
- * }
- * return local;
+ * return accumulate;
* }
*/
ast_value *value = NULL;
- ast_value *arg1 = ast_value_new(intrin_ctx(intrin), "x", TYPE_FLOAT);
- ast_value *arg2 = ast_value_new(intrin_ctx(intrin), "y", TYPE_FLOAT);
- ast_value *local = ast_value_new(intrin_ctx(intrin), "local", TYPE_FLOAT);
- ast_block *body = ast_block_new(intrin_ctx(intrin));
- ast_block *l1b = ast_block_new(intrin_ctx(intrin)); /* loop 1 body */
- ast_block *l2b = ast_block_new(intrin_ctx(intrin)); /* loop 2 body */
- ast_loop *loop1 = NULL;
- ast_loop *loop2 = NULL;
- ast_function *func = intrin_value(intrin, &value, "pow", TYPE_FLOAT);
+ ast_function *func = intrin_value(intrin, &value, "pow", TYPE_FLOAT);
+
+ /* prepare some calls for later */
+ ast_call *callpow1 = ast_call_new(intrin_ctx(intrin), (ast_expression*)value); /* for pow(base, -exp) */
+ ast_call *callpow2 = ast_call_new(intrin_ctx(intrin), (ast_expression*)value); /* for pow(vase, exp / 2) */
+ ast_call *callsqrt1 = ast_call_new(intrin_ctx(intrin), intrin_func_self(intrin, "sqrt", "pow")); /* for sqrt(base) */
+ ast_call *callsqrt2 = ast_call_new(intrin_ctx(intrin), intrin_func_self(intrin, "sqrt", "pow")); /* for sqrt(square) */
+ ast_call *callfabs = ast_call_new(intrin_ctx(intrin), intrin_func_self(intrin, "fabs", "pow")); /* for fabs(mid - exp) */
+
+ /* prepare some blocks for later */
+ ast_block *expgt1 = ast_block_new(intrin_ctx(intrin));
+ ast_block *midltexp = ast_block_new(intrin_ctx(intrin));
+ ast_block *midltexpelse = ast_block_new(intrin_ctx(intrin));
+ ast_block *whileblock = ast_block_new(intrin_ctx(intrin));
+
+ /* float pow(float base, float exp) */
+ ast_value *base = ast_value_new(intrin_ctx(intrin), "base", TYPE_FLOAT);
+ ast_value *exp = ast_value_new(intrin_ctx(intrin), "exp", TYPE_FLOAT);
+ /* { */
+ ast_block *body = ast_block_new(intrin_ctx(intrin));
- /* arguments */
- vec_push(value->expression.params, arg1);
- vec_push(value->expression.params, arg2);
+ /*
+ * float result;
+ * float low;
+ * float high;
+ * float square;
+ * float accumulate;
+ * float mid;
+ */
+ ast_value *result = ast_value_new(intrin_ctx(intrin), "result", TYPE_FLOAT);
+ ast_value *low = ast_value_new(intrin_ctx(intrin), "low", TYPE_FLOAT);
+ ast_value *high = ast_value_new(intrin_ctx(intrin), "high", TYPE_FLOAT);
+ ast_value *square = ast_value_new(intrin_ctx(intrin), "square", TYPE_FLOAT);
+ ast_value *accumulate = ast_value_new(intrin_ctx(intrin), "accumulate", TYPE_FLOAT);
+ ast_value *mid = ast_value_new(intrin_ctx(intrin), "mid", TYPE_FLOAT);
+ vec_push(body->locals, result);
+ vec_push(body->locals, low);
+ vec_push(body->locals, high);
+ vec_push(body->locals, square);
+ vec_push(body->locals, accumulate);
+ vec_push(body->locals, mid);
+
+ vec_push(value->expression.params, base);
+ vec_push(value->expression.params, exp);
- /* local */
- vec_push(body->locals, local);
+ /*
+ * if (exp == 0.0)
+ * return base;
+ */
+ vec_push(body->exprs,
+ (ast_expression*)ast_ifthen_new(
+ intrin_ctx(intrin),
+ (ast_expression*)ast_binary_new(
+ intrin_ctx(intrin),
+ INSTR_EQ_F,
+ (ast_expression*)exp,
+ (ast_expression*)intrin->fold->imm_float[0]
+ ),
+ (ast_expression*)ast_return_new(
+ intrin_ctx(intrin),
+ (ast_expression*)base
+ ),
+ NULL
+ )
+ );
+
+ /* <callpow1> = pow(base, -exp) */
+ vec_push(callpow1->params, (ast_expression*)base);
+ vec_push(callpow1->params,
+ (ast_expression*)ast_unary_new(
+ intrin_ctx(intrin),
+ VINSTR_NEG_F,
+ (ast_expression*)exp
+ )
+ );
- /* assignment to local of value 1.0f */
+ /*
+ * if (exp < 0)
+ * return 1.0 / <callpow1>;
+ */
vec_push(body->exprs,
- (ast_expression*)ast_store_new (
+ (ast_expression*)ast_ifthen_new(
+ intrin_ctx(intrin),
+ (ast_expression*)ast_binary_new(
+ intrin_ctx(intrin),
+ INSTR_LT,
+ (ast_expression*)exp,
+ (ast_expression*)intrin->fold->imm_float[0]
+ ),
+ (ast_expression*)ast_return_new(
+ intrin_ctx(intrin),
+ (ast_expression*)ast_binary_new(
+ intrin_ctx(intrin),
+ INSTR_DIV_F,
+ (ast_expression*)intrin->fold->imm_float[1],
+ (ast_expression*)callpow1
+ )
+ ),
+ NULL
+ )
+ );
+
+ /* <callpow2> = pow(base, exp / 2) */
+ vec_push(callpow2->params, (ast_expression*)base);
+ vec_push(callpow2->params,
+ (ast_expression*)ast_binary_new(
+ intrin_ctx(intrin),
+ INSTR_DIV_F,
+ (ast_expression*)exp,
+ (ast_expression*)fold_constgen_float(intrin->fold, 2.0f)
+ )
+ );
+
+ /*
+ * <expgt1> = {
+ * result = <callpow2>;
+ * return result * result;
+ * }
+ */
+ vec_push(expgt1->exprs,
+ (ast_expression*)ast_store_new(
intrin_ctx(intrin),
INSTR_STORE_F,
- (ast_expression*)local,
- (ast_expression*)intrin->fold->imm_float[1] /* 1 == 1.0f */
+ (ast_expression*)result,
+ (ast_expression*)callpow2
+ )
+ );
+ vec_push(expgt1->exprs,
+ (ast_expression*)ast_return_new(
+ intrin_ctx(intrin),
+ (ast_expression*)ast_binary_new(
+ intrin_ctx(intrin),
+ INSTR_MUL_F,
+ (ast_expression*)result,
+ (ast_expression*)result
+ )
+ )
+ );
+
+ /*
+ * if (exp >= 1) {
+ * <expgt1>
+ * }
+ */
+ vec_push(body->exprs,
+ (ast_expression*)ast_ifthen_new(
+ intrin_ctx(intrin),
+ (ast_expression*)ast_binary_new(
+ intrin_ctx(intrin),
+ INSTR_GE,
+ (ast_expression*)exp,
+ (ast_expression*)intrin->fold->imm_float[1]
+ ),
+ (ast_expression*)expgt1,
+ NULL
)
);
- /* y >>= 2 */
- vec_push(l2b->exprs,
- (ast_expression*)ast_binstore_new (
+ /*
+ * <callsqrt1> = sqrt(base)
+ */
+ vec_push(callsqrt1->params, (ast_expression*)base);
+
+ /*
+ * low = 0.0f;
+ * high = 1.0f;
+ * square = sqrt(base);
+ * accumulate = square;
+ * mid = high / 2.0f;
+ */
+ vec_push(body->exprs,
+ (ast_expression*)ast_store_new(intrin_ctx(intrin),
+ INSTR_STORE_F,
+ (ast_expression*)low,
+ (ast_expression*)intrin->fold->imm_float[0]
+ )
+ );
+ vec_push(body->exprs,
+ (ast_expression*)ast_store_new(
intrin_ctx(intrin),
INSTR_STORE_F,
- INSTR_MUL_F,
- (ast_expression*)arg2,
- (ast_expression*)fold_constgen_float(intrin->parser->fold, 0.25f)
+ (ast_expression*)high,
+ (ast_expression*)intrin->fold->imm_float[1]
+ )
+ );
+ vec_push(body->exprs,
+ (ast_expression*)ast_store_new(
+ intrin_ctx(intrin),
+ INSTR_STORE_F,
+ (ast_expression*)square,
+ (ast_expression*)callsqrt1
+ )
+ );
+ vec_push(body->exprs,
+ (ast_expression*)ast_store_new(
+ intrin_ctx(intrin),
+ INSTR_STORE_F,
+ (ast_expression*)accumulate,
+ (ast_expression*)square
+ )
+ );
+ vec_push(body->exprs,
+ (ast_expression*)ast_store_new(
+ intrin_ctx(intrin),
+ INSTR_STORE_F,
+ (ast_expression*)mid,
+ (ast_expression*)ast_binary_new(
+ intrin_ctx(intrin),
+ INSTR_DIV_F,
+ (ast_expression*)high,
+ (ast_expression*)fold_constgen_float(intrin->fold, 2.0f)
+ )
)
);
- /* x *= x */
- vec_push(l2b->exprs,
- (ast_expression*)ast_binstore_new (
+ /*
+ * <midltexp> = {
+ * low = mid;
+ * accumulate *= square;
+ * }
+ */
+ vec_push(midltexp->exprs,
+ (ast_expression*)ast_store_new(
+ intrin_ctx(intrin),
+ INSTR_STORE_F,
+ (ast_expression*)low,
+ (ast_expression*)mid
+ )
+ );
+ vec_push(midltexp->exprs,
+ (ast_expression*)ast_binstore_new(
intrin_ctx(intrin),
INSTR_STORE_F,
INSTR_MUL_F,
- (ast_expression*)arg1,
- (ast_expression*)arg1
+ (ast_expression*)accumulate,
+ (ast_expression*)square
)
);
- /* while (!(y&1)) */
- loop2 = ast_loop_new (
- intrin_ctx(intrin),
- NULL,
- (ast_expression*)ast_binary_new (
+ /*
+ * <midltexpelse> = {
+ * high = mid;
+ * accumulate *= (1.0 / square);
+ * }
+ */
+ vec_push(midltexpelse->exprs,
+ (ast_expression*)ast_store_new(
+ intrin_ctx(intrin),
+ INSTR_STORE_F,
+ (ast_expression*)high,
+ (ast_expression*)mid
+ )
+ );
+ vec_push(midltexpelse->exprs,
+ (ast_expression*)ast_binstore_new(
intrin_ctx(intrin),
- INSTR_AND,
- (ast_expression*)arg2,
- (ast_expression*)intrin->fold->imm_float[1] /* 1 == 1.0f */
- ),
- true, /* ! not */
- NULL,
- false,
- NULL,
- (ast_expression*)l2b
+ INSTR_STORE_F,
+ INSTR_MUL_F,
+ (ast_expression*)accumulate,
+ (ast_expression*)ast_binary_new(
+ intrin_ctx(intrin),
+ INSTR_DIV_F,
+ (ast_expression*)intrin->fold->imm_float[1],
+ (ast_expression*)square
+ )
+ )
);
- /* push nested loop into loop expressions */
- vec_push(l1b->exprs, (ast_expression*)loop2);
+ /*
+ * <callsqrt2> = sqrt(square)
+ */
+ vec_push(callsqrt2->params, (ast_expression*)square);
- /* y-- */
- vec_push(l1b->exprs,
- (ast_expression*)ast_binstore_new (
+ /*
+ * <whileblock> = {
+ * square = <callsqrt2>;
+ * if (mid < exp)
+ * <midltexp>;
+ * else
+ * <midltexpelse>;
+ *
+ * mid = (low + high) / 2;
+ * }
+ */
+ vec_push(whileblock->exprs,
+ (ast_expression*)ast_store_new(
intrin_ctx(intrin),
INSTR_STORE_F,
- INSTR_SUB_F,
- (ast_expression*)arg2,
- (ast_expression*)intrin->fold->imm_float[1] /* 1 == 1.0f */
+ (ast_expression*)square,
+ (ast_expression*)callsqrt2
+ )
+ );
+ vec_push(whileblock->exprs,
+ (ast_expression*)ast_ifthen_new(
+ intrin_ctx(intrin),
+ (ast_expression*)ast_binary_new(
+ intrin_ctx(intrin),
+ INSTR_LT,
+ (ast_expression*)mid,
+ (ast_expression*)exp
+ ),
+ (ast_expression*)midltexp,
+ (ast_expression*)midltexpelse
)
);
- /* local *= x */
- vec_push(l1b->exprs,
- (ast_expression*)ast_binstore_new (
+ vec_push(whileblock->exprs,
+ (ast_expression*)ast_store_new(
intrin_ctx(intrin),
INSTR_STORE_F,
- INSTR_MUL_F,
- (ast_expression*)local,
- (ast_expression*)arg1
+ (ast_expression*)mid,
+ (ast_expression*)ast_binary_new(
+ intrin_ctx(intrin),
+ INSTR_DIV_F,
+ (ast_expression*)ast_binary_new(
+ intrin_ctx(intrin),
+ INSTR_ADD_F,
+ (ast_expression*)low,
+ (ast_expression*)high
+ ),
+ (ast_expression*)fold_constgen_float(intrin->fold, 2.0f)
+ )
)
);
- /* while (y > 0) */
- loop1 = ast_loop_new (
- intrin_ctx(intrin),
- NULL,
- (ast_expression*)ast_binary_new (
+ /*
+ * <callabs> = fabs(mid - exp)
+ */
+ vec_push(callfabs->params,
+ (ast_expression*)ast_binary_new(
intrin_ctx(intrin),
- INSTR_GT,
- (ast_expression*)arg2,
- (ast_expression*)intrin->fold->imm_float[0] /* 0 == 0.0f */
- ),
- false,
- NULL,
- false,
- NULL,
- (ast_expression*)l1b
+ INSTR_SUB_F,
+ (ast_expression*)mid,
+ (ast_expression*)exp
+ )
);
- /* push the loop1 into the body for the function */
- vec_push(body->exprs, (ast_expression*)loop1);
+ /*
+ * while (<callfabs> > epsilon)
+ * <whileblock>
+ */
+ vec_push(body->exprs,
+ (ast_expression*)ast_loop_new(
+ intrin_ctx(intrin),
+ /* init */
+ NULL,
+ /* pre condition */
+ (ast_expression*)ast_binary_new(
+ intrin_ctx(intrin),
+ INSTR_GT,
+ (ast_expression*)callfabs,
+ (ast_expression*)fold_constgen_float(intrin->fold, QC_POW_EPSILON)
+ ),
+ /* pre not */
+ false,
+ /* post condition */
+ NULL,
+ /* post not */
+ false,
+ /* increment expression */
+ NULL,
+ /* code block */
+ (ast_expression*)whileblock
+ )
+ );
- /* return local; */
+ /* return midvalue */
vec_push(body->exprs,
- (ast_expression*)ast_return_new (
+ (ast_expression*)ast_return_new(
intrin_ctx(intrin),
- (ast_expression*)local
+ (ast_expression*)accumulate
)
);
- /* push block and register intrin for codegen */
+ /* } */
vec_push(func->blocks, body);
intrin_reg(intrin, value, func);
-
return (ast_expression*)value;
}
* }
*/
ast_value *value = NULL;
- ast_call *call = ast_call_new (intrin_ctx(intrin), intrin_func(intrin, "floor"));
+ ast_call *call = ast_call_new (intrin_ctx(intrin), intrin_func_self(intrin, "floor", "mod"));
ast_value *a = ast_value_new(intrin_ctx(intrin), "a", TYPE_FLOAT);
ast_value *b = ast_value_new(intrin_ctx(intrin), "b", TYPE_FLOAT);
ast_value *div = ast_value_new(intrin_ctx(intrin), "div", TYPE_FLOAT);
static ast_expression *intrin_exp(intrin_t *intrin) {
/*
* float exp(float x) {
- * return pow(QC_M_E, x);
+ * // mul 10 to round increments of 0.1f
+ * return floor((pow(QC_M_E, x) * 10) + 0.5) / 10;
* }
*/
- ast_value *value = NULL;
- ast_call *call = ast_call_new (intrin_ctx(intrin), intrin_func(intrin, "pow"));
- ast_value *arg1 = ast_value_new(intrin_ctx(intrin), "x", TYPE_FLOAT);
- ast_block *body = ast_block_new(intrin_ctx(intrin));
- ast_function *func = intrin_value(intrin, &value, "exp", TYPE_FLOAT);
+ ast_value *value = NULL;
+ ast_call *callpow = ast_call_new (intrin_ctx(intrin), intrin_func_self(intrin, "pow", "exp"));
+ ast_call *callfloor = ast_call_new (intrin_ctx(intrin), intrin_func_self(intrin, "floor", "exp"));
+ ast_value *arg1 = ast_value_new(intrin_ctx(intrin), "x", TYPE_FLOAT);
+ ast_block *body = ast_block_new(intrin_ctx(intrin));
+ ast_function *func = intrin_value(intrin, &value, "exp", TYPE_FLOAT);
+
+ vec_push(value->expression.params, arg1);
- /* push arguments for params to call */
- vec_push(call->params, (ast_expression*)fold_constgen_float(intrin->fold, QC_M_E));
- vec_push(call->params, (ast_expression*)arg1);
+ vec_push(callpow->params, (ast_expression*)fold_constgen_float(intrin->fold, QC_M_E));
+ vec_push(callpow->params, (ast_expression*)arg1);
+ vec_push(callfloor->params,
+ (ast_expression*)ast_binary_new(
+ intrin_ctx(intrin),
+ INSTR_ADD_F,
+ (ast_expression*)ast_binary_new(
+ intrin_ctx(intrin),
+ INSTR_MUL_F,
+ (ast_expression*)callpow,
+ (ast_expression*)fold_constgen_float(intrin->fold, 10.0f)
+ ),
+ (ast_expression*)fold_constgen_float(intrin->fold, 0.5f)
+ )
+ );
- /* return pow(QC_M_E, x) */
+ /* return <callfloor> / 10.0f */
vec_push(body->exprs,
(ast_expression*)ast_return_new(
intrin_ctx(intrin),
- (ast_expression*)call
+ (ast_expression*)ast_binary_new(
+ intrin_ctx(intrin),
+ INSTR_DIV_F,
+ (ast_expression*)callfloor,
+ (ast_expression*)fold_constgen_float(intrin->fold, 10.0f)
+ )
)
);
- vec_push(value->expression.params, arg1); /* float x (for param) */
-
- vec_push(func->blocks, body); /* {{{ body }}} */
+ vec_push(func->blocks, body); /* {{{ body }}} */
intrin_reg(intrin, value, func);
-
return (ast_expression*)value;
}
(ast_expression*)arg1,
(ast_expression*)intrin->fold->imm_float[0]
),
- (ast_expression*)ast_binary_new(
+ (ast_expression*)ast_unary_new(
intrin_ctx(intrin),
- INSTR_SUB_F,
- (ast_expression*)intrin->fold->imm_float[0],
+ VINSTR_NEG_F,
(ast_expression*)arg1
),
(ast_expression*)arg1
}
static const intrin_func_t intrinsics[] = {
- {&intrin_exp, "__builtin_exp", "exp", 1},
- {&intrin_mod, "__builtin_mod", "mod", 2},
- {&intrin_pow, "__builtin_pow", "pow", 2},
- {&intrin_isnan, "__builtin_isnan", "isnan", 1},
- {&intrin_fabs, "__builtin_fabs", "fabs", 1},
- {&intrin_debug_typestring, "__builtin_debug_typestring", "", 0}
+ {&intrin_exp, "__builtin_exp", "exp", 1},
+ {&intrin_mod, "__builtin_mod", "mod", 2},
+ {&intrin_pow, "__builtin_pow", "pow", 2},
+ {&intrin_isnan, "__builtin_isnan", "isnan", 1},
+ {&intrin_fabs, "__builtin_fabs", "fabs", 1},
+ {&intrin_debug_typestring, "__builtin_debug_typestring", "", 0},
+ {&intrin_nullfunc, "#nullfunc", "", 0}
};
static void intrin_error(intrin_t *intrin, const char *fmt, ...) {
return NULL;
}
-ast_expression *intrin_func(intrin_t *intrin, const char *name) {
+static ast_expression *intrin_func_self(intrin_t *intrin, const char *name, const char *from) {
size_t i;
ast_expression *find;
if ((find = intrin_func_try(intrin, offsetof(intrin_func_t, alias), name)))
return find;
- intrin_error(intrin, "need function: `%s` compiler depends on it", name);
- return NULL;
+ if (from)
+ intrin_error(intrin, "need function `%s', compiler depends on it for `__builtin_%s'", name, from);
+ else
+ intrin_error(intrin, "need function `%s', compiler depends on it", name);
+
+ return intrin_func(intrin, "#nullfunc");
+}
+
+ast_expression *intrin_func(intrin_t *intrin, const char *name) {
+ return intrin_func_self(intrin, name, NULL);
}
projects / xonotic / gmqcc.git / blobdiff