/* * Copyright (C) 2012, 2013 * Dale Weiler * * Permission is hereby granted, free of charge, to any person obtaining a copy of * this software and associated documentation files (the "Software"), to deal in * the Software without restriction, including without limitation the rights to * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies * of the Software, and to permit persons to whom the Software is furnished to do * so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all * copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #include #include "parser.h" /* * Provides all the "intrinsics" / "builtins" for GMQCC. These can do * a few things, they can provide fall back implementations for math * functions if the definitions don't exist for some given engine. Or * then can determine definitions for existing builtins, and simply * wrap back to them instead. This is like a "portable" intrface that * is entered when -fintrin is used (causing all existing builtins to * be ignored by the compiler and instead interface through here. */ #define intrin_ctx(I) parser_ctx((I)->parser) static GMQCC_INLINE ast_function *intrin_value(intrin_t *intrin, ast_value **out, const char *name, qcint_t vtype) { ast_value *value = NULL; ast_function *func = NULL; char buffer[1024]; char stype [1024]; util_snprintf(buffer, sizeof(buffer), "__builtin_%s", name); util_snprintf(stype, sizeof(stype), "<%s>", type_name[vtype]); value = ast_value_new(intrin_ctx(intrin), buffer, TYPE_FUNCTION); value->intrinsic = true; value->expression.next = (ast_expression*)ast_value_new(intrin_ctx(intrin), stype, vtype); func = ast_function_new(intrin_ctx(intrin), buffer, value); value->expression.flags |= AST_FLAG_ERASEABLE; *out = value; return func; } static GMQCC_INLINE void intrin_reg(intrin_t *intrin, ast_value *const value, ast_function *const func) { vec_push(intrin->parser->functions, func); vec_push(intrin->parser->globals, (ast_expression*)value); } #define QC_POW_EPSILON 0.00001f /* * 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_isfinite(intrin_t *intrin) { /* * float isfinite(float x) { * return !(isnan(x) || isinf(x)); * } */ ast_value *value = NULL; ast_value *x = ast_value_new(intrin_ctx(intrin), "x", TYPE_FLOAT); ast_function *func = intrin_value(intrin, &value, "isfinite", TYPE_FLOAT); ast_call *callisnan = ast_call_new(intrin_ctx(intrin), intrin_func_self(intrin, "isnan", "isfinite")); ast_call *callisinf = ast_call_new(intrin_ctx(intrin), intrin_func_self(intrin, "isinf", "isfinite")); ast_block *block = ast_block_new(intrin_ctx(intrin)); /* float x; */ vec_push(value->expression.params, x); /* = isnan(x); */ vec_push(callisnan->params, (ast_expression*)x); /* = isinf(x); */ vec_push(callisinf->params, (ast_expression*)x); /* return (! || ); */ vec_push(block->exprs, (ast_expression*)ast_return_new( intrin_ctx(intrin), (ast_expression*)ast_unary_new( intrin_ctx(intrin), INSTR_NOT_F, (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_OR, (ast_expression*)callisnan, (ast_expression*)callisinf ) ) ) ); vec_push(func->blocks, block); intrin_reg(intrin, value, func); return (ast_expression*)value;; } static ast_expression *intrin_isinf(intrin_t *intrin) { /* * float isinf(float x) { * return (x != 0.0) && (x + x == x); * } */ ast_value *value = NULL; ast_value *x = 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, "isinf", TYPE_FLOAT); vec_push(body->exprs, (ast_expression*)ast_return_new( intrin_ctx(intrin), (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_AND, (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_NE_F, (ast_expression*)x, (ast_expression*)intrin->fold->imm_float[0] ), (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_EQ_F, (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_ADD_F, (ast_expression*)x, (ast_expression*)x ), (ast_expression*)x ) ) ) ); vec_push(value->expression.params, x); vec_push(func->blocks, body); intrin_reg(intrin, value, func); return (ast_expression*)value; } static ast_expression *intrin_isnan(intrin_t *intrin) { /* * float isnan(float x) { * float local; * local = x; * * return (x != local); * } */ ast_value *value = NULL; ast_value *arg1 = ast_value_new(intrin_ctx(intrin), "x", TYPE_FLOAT); ast_value *local = ast_value_new(intrin_ctx(intrin), "local", TYPE_FLOAT); ast_block *body = ast_block_new(intrin_ctx(intrin)); ast_function *func = intrin_value(intrin, &value, "isnan", TYPE_FLOAT); vec_push(body->locals, local); vec_push(body->exprs, (ast_expression*)ast_store_new( intrin_ctx(intrin), INSTR_STORE_F, (ast_expression*)local, (ast_expression*)arg1 ) ); vec_push(body->exprs, (ast_expression*)ast_return_new( intrin_ctx(intrin), (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_NE_F, (ast_expression*)arg1, (ast_expression*)local ) ) ); vec_push(value->expression.params, arg1); vec_push(func->blocks, body); intrin_reg(intrin, value, func); return (ast_expression*)value; } static ast_expression *intrin_isnormal(intrin_t *intrin) { /* * float isnormal(float x) { * return isfinite(x); * } */ ast_value *value = NULL; ast_call *callisfinite = ast_call_new (intrin_ctx(intrin), intrin_func_self(intrin, "isfinite", "isnormal")); ast_value *x = 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, "isnormal", TYPE_FLOAT); vec_push(value->expression.params, x); vec_push(callisfinite->params, (ast_expression*)x); /* return */ vec_push(body->exprs, (ast_expression*)ast_return_new( intrin_ctx(intrin), (ast_expression*)callisfinite ) ); vec_push(func->blocks, body); intrin_reg(intrin, value, func); return (ast_expression*)value; } static ast_expression *intrin_signbit(intrin_t *intrin) { /* * float signbit(float x) { * return (x < 0); * } */ ast_value *value = NULL; ast_value *x = 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, "signbit", TYPE_FLOAT); vec_push(value->expression.params, x); /* return (x < 0); */ vec_push(body->exprs, (ast_expression*)ast_return_new( intrin_ctx(intrin), (ast_expression*)ast_ternary_new( intrin_ctx(intrin), (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_LT, (ast_expression*)x, (ast_expression*)intrin->fold->imm_float[0] ), (ast_expression*)intrin->fold->imm_float[1], (ast_expression*)intrin->fold->imm_float[0] ) ) ); vec_push(func->blocks, body); intrin_reg(intrin, value, func); return (ast_expression*)value; } static ast_expression *intrin_acosh(intrin_t *intrin) { /* * float acosh(float x) { * return log(x + sqrt((x * x) - 1)); * } */ ast_value *value = NULL; ast_value *x = ast_value_new(intrin_ctx(intrin), "x", TYPE_FLOAT); ast_call *calllog = ast_call_new(intrin_ctx(intrin), intrin_func_self(intrin, "log", "acosh")); ast_call *callsqrt = ast_call_new(intrin_ctx(intrin), intrin_func_self(intrin, "sqrt", "acosh")); ast_block *body = ast_block_new(intrin_ctx(intrin)); ast_function *func = intrin_value(intrin, &value, "acosh", TYPE_FLOAT); vec_push(value->expression.params, x); /* = sqrt((x * x) - 1); */ vec_push(callsqrt->params, (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_SUB_F, (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_MUL_F, (ast_expression*)x, (ast_expression*)x ), (ast_expression*)intrin->fold->imm_float[1] ) ); /* = log(x + ); */ vec_push(calllog->params, (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_ADD_F, (ast_expression*)x, (ast_expression*)callsqrt ) ); /* return ; */ vec_push(body->exprs, (ast_expression*)ast_return_new( intrin_ctx(intrin), (ast_expression*)calllog ) ); vec_push(func->blocks, body); intrin_reg(intrin, value, func); return (ast_expression*)value; } static ast_expression *intrin_asinh(intrin_t *intrin) { /* * float asinh(float x) { * return log(x + sqrt((x * x) + 1)); * } */ ast_value *value = NULL; ast_value *x = ast_value_new(intrin_ctx(intrin), "x", TYPE_FLOAT); ast_call *calllog = ast_call_new(intrin_ctx(intrin), intrin_func_self(intrin, "log", "asinh")); ast_call *callsqrt = ast_call_new(intrin_ctx(intrin), intrin_func_self(intrin, "sqrt", "asinh")); ast_block *body = ast_block_new(intrin_ctx(intrin)); ast_function *func = intrin_value(intrin, &value, "asinh", TYPE_FLOAT); vec_push(value->expression.params, x); /* = sqrt((x * x) + 1); */ vec_push(callsqrt->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*)x, (ast_expression*)x ), (ast_expression*)intrin->fold->imm_float[1] ) ); /* = log(x + ); */ vec_push(calllog->params, (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_ADD_F, (ast_expression*)x, (ast_expression*)callsqrt ) ); /* return ; */ vec_push(body->exprs, (ast_expression*)ast_return_new( intrin_ctx(intrin), (ast_expression*)calllog ) ); vec_push(func->blocks, body); intrin_reg(intrin, value, func); return (ast_expression*)value; } static ast_expression *intrin_atanh(intrin_t *intrin) { /* * float atanh(float x) { * return 0.5 * log((1 + x) / (1 - x)) * } */ ast_value *value = NULL; ast_value *x = ast_value_new(intrin_ctx(intrin), "x", TYPE_FLOAT); ast_call *calllog = ast_call_new(intrin_ctx(intrin), intrin_func_self(intrin, "log", "atanh")); ast_block *body = ast_block_new(intrin_ctx(intrin)); ast_function *func = intrin_value(intrin, &value, "atanh", TYPE_FLOAT); vec_push(value->expression.params, x); /* = log((1 + x) / (1 - x)); */ vec_push(calllog->params, (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_DIV_F, (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_ADD_F, (ast_expression*)intrin->fold->imm_float[1], (ast_expression*)x ), (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_SUB_F, (ast_expression*)intrin->fold->imm_float[1], (ast_expression*)x ) ) ); /* return 0.5 * ; */ vec_push(body->exprs, (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_MUL_F, (ast_expression*)fold_constgen_float(intrin->fold, 0.5), (ast_expression*)calllog ) ); vec_push(func->blocks, body); intrin_reg(intrin, value, func); return (ast_expression*)value; } static ast_expression *intrin_exp(intrin_t *intrin) { /* * float exp(float x) { * float sum = 1.0; * float acc = 1.0; * float i; * for (i = 1; i < 200; ++i) * sum += (acc *= x / i); * * return sum; * } */ ast_value *value = NULL; ast_value *x = ast_value_new(intrin_ctx(intrin), "x", TYPE_FLOAT); ast_value *sum = ast_value_new(intrin_ctx(intrin), "sum", TYPE_FLOAT); ast_value *acc = ast_value_new(intrin_ctx(intrin), "acc", TYPE_FLOAT); ast_value *i = ast_value_new(intrin_ctx(intrin), "i", 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, x); vec_push(body->locals, sum); vec_push(body->locals, acc); vec_push(body->locals, i); /* sum = 1.0; */ vec_push(body->exprs, (ast_expression*)ast_store_new( intrin_ctx(intrin), INSTR_STORE_F, (ast_expression*)sum, (ast_expression*)intrin->fold->imm_float[1] ) ); /* acc = 1.0; */ vec_push(body->exprs, (ast_expression*)ast_store_new( intrin_ctx(intrin), INSTR_STORE_F, (ast_expression*)acc, (ast_expression*)intrin->fold->imm_float[1] ) ); /* * for (i = 1; i < 200; ++i) * sum += (acc *= x / i); */ vec_push(body->exprs, (ast_expression*)ast_loop_new( intrin_ctx(intrin), /* i = 1; */ (ast_expression*)ast_store_new( intrin_ctx(intrin), INSTR_STORE_F, (ast_expression*)i, (ast_expression*)intrin->fold->imm_float[1] ), /* i < 200; */ (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_LT, (ast_expression*)i, (ast_expression*)fold_constgen_float(intrin->fold, 200.0f) ), false, NULL, false, /* ++i; */ (ast_expression*)ast_binstore_new( intrin_ctx(intrin), INSTR_STORE_F, INSTR_ADD_F, (ast_expression*)i, (ast_expression*)intrin->fold->imm_float[1] ), /* sum += (acc *= (x / i)) */ (ast_expression*)ast_binstore_new( intrin_ctx(intrin), INSTR_STORE_F, INSTR_ADD_F, (ast_expression*)sum, (ast_expression*)ast_binstore_new( intrin_ctx(intrin), INSTR_STORE_F, INSTR_MUL_F, (ast_expression*)acc, (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_DIV_F, (ast_expression*)x, (ast_expression*)i ) ) ) ) ); /* return sum; */ vec_push(body->exprs, (ast_expression*)ast_return_new( intrin_ctx(intrin), (ast_expression*)sum ) ); vec_push(func->blocks, body); intrin_reg(intrin, value, func); return (ast_expression*)value; } static ast_expression *intrin_exp2(intrin_t *intrin) { /* * float exp2(float x) { * return pow(2, x); * } */ ast_value *value = NULL; ast_call *callpow = ast_call_new (intrin_ctx(intrin), intrin_func_self(intrin, "pow", "exp2")); 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, "exp2", TYPE_FLOAT); vec_push(value->expression.params, arg1); vec_push(callpow->params, (ast_expression*)fold_constgen_float(intrin->fold, 2.0f)); vec_push(callpow->params, (ast_expression*)arg1); /* return */ vec_push(body->exprs, (ast_expression*)ast_return_new( intrin_ctx(intrin), (ast_expression*)callpow ) ); vec_push(func->blocks, body); intrin_reg(intrin, value, func); return (ast_expression*)value; } static ast_expression *intrin_expm1(intrin_t *intrin) { /* * float expm1(float x) { * return exp(x) - 1; * } */ ast_value *value = NULL; ast_call *callexp = ast_call_new (intrin_ctx(intrin), intrin_func_self(intrin, "exp", "expm1")); ast_value *x = 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, "expm1", TYPE_FLOAT); vec_push(value->expression.params, x); /* = exp(x); */ vec_push(callexp->params, (ast_expression*)x); /* return - 1; */ vec_push(body->exprs, (ast_expression*)ast_return_new( intrin_ctx(intrin), (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_SUB_F, (ast_expression*)callexp, (ast_expression*)intrin->fold->imm_float[1] ) ) ); vec_push(func->blocks, body); intrin_reg(intrin, value, func); return (ast_expression*)value; } static ast_expression *intrin_pow(intrin_t *intrin) { /* * * float pow(float base, float exp) { * float result; * float low; * float high; * float mid; * float square; * float accumulate; * * if (exp == 0.0) * return 1; * if (exp == 1.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; * } * return accumulate; * } */ ast_value *value = NULL; 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)); /* * 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); /* * if (exp == 0.0) * return 1; */ 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*)intrin->fold->imm_float[1] ), NULL ) ); /* * if (exp == 1.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[1] ), (ast_expression*)ast_return_new( intrin_ctx(intrin), (ast_expression*)base ), NULL ) ); /* = 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 ) ); /* * if (exp < 0) * return 1.0 / ; */ vec_push(body->exprs, (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 ) ); /* = 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*)intrin->fold->imm_float[3] /* 2.0f */ ) ); /* * = { * result = ; * return result * result; * } */ vec_push(expgt1->exprs, (ast_expression*)ast_store_new( intrin_ctx(intrin), INSTR_STORE_F, (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) { * * } */ 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 ) ); /* * = 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, (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*)intrin->fold->imm_float[3] /* 2.0f */ ) ) ); /* * = { * 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*)accumulate, (ast_expression*)square ) ); /* * = { * 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_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 ) ) ); /* * = sqrt(square) */ vec_push(callsqrt2->params, (ast_expression*)square); /* * = { * square = ; * if (mid < exp) * ; * else * ; * * mid = (low + high) / 2; * } */ vec_push(whileblock->exprs, (ast_expression*)ast_store_new( intrin_ctx(intrin), INSTR_STORE_F, (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 ) ); vec_push(whileblock->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*)ast_binary_new( intrin_ctx(intrin), INSTR_ADD_F, (ast_expression*)low, (ast_expression*)high ), (ast_expression*)intrin->fold->imm_float[3] /* 2.0f */ ) ) ); /* * = fabs(mid - exp) */ vec_push(callfabs->params, (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_SUB_F, (ast_expression*)mid, (ast_expression*)exp ) ); /* * while ( > epsilon) * */ 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 accumulate */ vec_push(body->exprs, (ast_expression*)ast_return_new( intrin_ctx(intrin), (ast_expression*)accumulate ) ); /* } */ vec_push(func->blocks, body); intrin_reg(intrin, value, func); return (ast_expression*)value; } static ast_expression *intrin_mod(intrin_t *intrin) { /* * float mod(float a, float b) { * float div = a / b; * float sign = (div < 0.0f) ? -1 : 1; * return a - b * sign * floor(sign * div); * } */ ast_value *value = NULL; 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); ast_value *sign = ast_value_new(intrin_ctx(intrin), "sign", TYPE_FLOAT); ast_block *body = ast_block_new(intrin_ctx(intrin)); ast_function *func = intrin_value(intrin, &value, "mod", TYPE_FLOAT); vec_push(value->expression.params, a); vec_push(value->expression.params, b); vec_push(body->locals, div); vec_push(body->locals, sign); /* div = a / b; */ vec_push(body->exprs, (ast_expression*)ast_store_new( intrin_ctx(intrin), INSTR_STORE_F, (ast_expression*)div, (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_DIV_F, (ast_expression*)a, (ast_expression*)b ) ) ); /* sign = (div < 0.0f) ? -1 : 1; */ vec_push(body->exprs, (ast_expression*)ast_store_new( intrin_ctx(intrin), INSTR_STORE_F, (ast_expression*)sign, (ast_expression*)ast_ternary_new( intrin_ctx(intrin), (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_LT, (ast_expression*)div, (ast_expression*)intrin->fold->imm_float[0] ), (ast_expression*)intrin->fold->imm_float[2], (ast_expression*)intrin->fold->imm_float[1] ) ) ); /* floor(sign * div) */ vec_push(call->params, (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_MUL_F, (ast_expression*)sign, (ast_expression*)div ) ); /* return a - b * sign * */ vec_push(body->exprs, (ast_expression*)ast_return_new( intrin_ctx(intrin), (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_SUB_F, (ast_expression*)a, (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_MUL_F, (ast_expression*)b, (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_MUL_F, (ast_expression*)sign, (ast_expression*)call ) ) ) ) ); vec_push(func->blocks, body); intrin_reg(intrin, value, func); return (ast_expression*)value; } static ast_expression *intrin_fabs(intrin_t *intrin) { /* * float fabs(float x) { * return x < 0 ? -x : x; * } */ ast_value *value = NULL; 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, "fabs", TYPE_FLOAT); vec_push(body->exprs, (ast_expression*)ast_return_new( intrin_ctx(intrin), (ast_expression*)ast_ternary_new( intrin_ctx(intrin), (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_LE, (ast_expression*)arg1, (ast_expression*)intrin->fold->imm_float[0] ), (ast_expression*)ast_unary_new( intrin_ctx(intrin), VINSTR_NEG_F, (ast_expression*)arg1 ), (ast_expression*)arg1 ) ) ); vec_push(value->expression.params, arg1); vec_push(func->blocks, body); intrin_reg(intrin, value, func); return (ast_expression*)value; } static ast_expression *intrin_epsilon(intrin_t *intrin) { /* * float epsilon(void) { * float eps = 1.0f; * do { eps /= 2.0f; } while ((1.0f + (eps / 2.0f)) != 1.0f); * return eps; * } */ ast_value *value = NULL; ast_value *eps = ast_value_new(intrin_ctx(intrin), "eps", TYPE_FLOAT); ast_block *body = ast_block_new(intrin_ctx(intrin)); ast_function *func = intrin_value(intrin, &value, "epsilon", TYPE_FLOAT); vec_push(body->locals, eps); /* eps = 1.0f; */ vec_push(body->exprs, (ast_expression*)ast_store_new( intrin_ctx(intrin), INSTR_STORE_F, (ast_expression*)eps, (ast_expression*)intrin->fold->imm_float[0] ) ); vec_push(body->exprs, (ast_expression*)ast_loop_new( intrin_ctx(intrin), NULL, NULL, false, (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_NE_F, (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_ADD_F, (ast_expression*)intrin->fold->imm_float[1], (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_MUL_F, (ast_expression*)eps, (ast_expression*)intrin->fold->imm_float[3] /* 2.0f */ ) ), (ast_expression*)intrin->fold->imm_float[1] ), false, NULL, (ast_expression*)ast_binstore_new( intrin_ctx(intrin), INSTR_STORE_F, INSTR_DIV_F, (ast_expression*)eps, (ast_expression*)intrin->fold->imm_float[3] /* 2.0f */ ) ) ); /* return eps; */ vec_push(body->exprs, (ast_expression*)ast_return_new( intrin_ctx(intrin), (ast_expression*)eps ) ); vec_push(func->blocks, body); intrin_reg(intrin, value, func); return (ast_expression*)value; } static ast_expression *intrin_nan(intrin_t *intrin) { /* * float nan(void) { * float x = 0.0f; * return x / x; * } */ ast_value *value = NULL; ast_value *x = ast_value_new(intrin_ctx(intrin), "x", TYPE_FLOAT); ast_function *func = intrin_value(intrin, &value, "nan", TYPE_FLOAT); ast_block *block = ast_block_new(intrin_ctx(intrin)); vec_push(block->locals, x); vec_push(block->exprs, (ast_expression*)ast_store_new( intrin_ctx(intrin), INSTR_STORE_F, (ast_expression*)x, (ast_expression*)intrin->fold->imm_float[0] ) ); vec_push(block->exprs, (ast_expression*)ast_return_new( intrin_ctx(intrin), (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_DIV_F, (ast_expression*)x, (ast_expression*)x ) ) ); vec_push(func->blocks, block); intrin_reg(intrin, value, func); return (ast_expression*)value; } static ast_expression *intrin_inf(intrin_t *intrin) { /* * float nan(void) { * float x = 1.0f; * float y = 0.0f; * return x / y; * } */ ast_value *value = NULL; ast_value *x = ast_value_new(intrin_ctx(intrin), "x", TYPE_FLOAT); ast_value *y = ast_value_new(intrin_ctx(intrin), "y", TYPE_FLOAT); ast_function *func = intrin_value(intrin, &value, "inf", TYPE_FLOAT); ast_block *block = ast_block_new(intrin_ctx(intrin)); size_t i; vec_push(block->locals, x); vec_push(block->locals, y); /* to keep code size down */ for (i = 0; i <= 1; i++) { vec_push(block->exprs, (ast_expression*)ast_store_new( intrin_ctx(intrin), INSTR_STORE_F, (ast_expression*)((i == 0) ? x : y), (ast_expression*)intrin->fold->imm_float[i] ) ); } vec_push(block->exprs, (ast_expression*)ast_return_new( intrin_ctx(intrin), (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_DIV_F, (ast_expression*)x, (ast_expression*)y ) ) ); vec_push(func->blocks, block); intrin_reg(intrin, value, func); return (ast_expression*)value; } static ast_expression *intrin_ln(intrin_t *intrin) { /* * float log(float power, float base) { * float whole; * float nth * float sign = 1.0f; * float eps = epsilon(); * * if (power <= 1.0f || bbase <= 1.0) { * if (power <= 0.0f || base <= 0.0f) * return nan(); * * if (power < 1.0f) { * power = 1.0f / power; * sign *= -1.0f; * } * * if (base < 1.0f) { * sign *= -1.0f; * base = 1.0f / base; * } * } * * float out; * float A_i = 1; * float B_i = 0; * float A_iminus1 = 0; * float B_iminus1 = 1; * * for (;;) { * whole = power; * nth = 0.0f; * * while (whole >= base) { * whole /= base; * nth++; * } * * float b_iplus1 = n; * float A_iplus1 = b_iplus1 * A_i + A_iminus1; * float B_iplus1 = b_iplus1 * B_i + B_iminus1; * * A_iminus1 = A_i; * B_iminus1 = B_i; * A_i = A_iplus1; * B_i = B_iplus1; * * if (whole <= 1.0f + eps) * break; * * power = base; * bower = whole; * } * return sign * A_i / B_i; * } */ ast_value *value = NULL; ast_value *power = ast_value_new(intrin_ctx(intrin), "power", TYPE_FLOAT); ast_value *base = ast_value_new(intrin_ctx(intrin), "base", TYPE_FLOAT); ast_value *whole = ast_value_new(intrin_ctx(intrin), "whole", TYPE_FLOAT); ast_value *nth = ast_value_new(intrin_ctx(intrin), "nth", TYPE_FLOAT); ast_value *sign = ast_value_new(intrin_ctx(intrin), "sign", TYPE_FLOAT); ast_value *out = ast_value_new(intrin_ctx(intrin), "out", TYPE_FLOAT); ast_value *A_i = ast_value_new(intrin_ctx(intrin), "A_i", TYPE_FLOAT); ast_value *B_i = ast_value_new(intrin_ctx(intrin), "B_i", TYPE_FLOAT); ast_value *A_iminus1 = ast_value_new(intrin_ctx(intrin), "A_iminus1", TYPE_FLOAT); ast_value *B_iminus1 = ast_value_new(intrin_ctx(intrin), "B_iminus1", TYPE_FLOAT); ast_value *b_iplus1 = ast_value_new(intrin_ctx(intrin), "b_iplus1", TYPE_FLOAT); ast_value *A_iplus1 = ast_value_new(intrin_ctx(intrin), "A_iplus1", TYPE_FLOAT); ast_value *B_iplus1 = ast_value_new(intrin_ctx(intrin), "B_iplus1", TYPE_FLOAT); ast_value *eps = ast_value_new(intrin_ctx(intrin), "eps", TYPE_FLOAT); ast_block *block = ast_block_new(intrin_ctx(intrin)); ast_block *plt1orblt1 = ast_block_new(intrin_ctx(intrin)); /* (power <= 1.0f || base <= 1.0f) */ ast_block *plt1 = ast_block_new(intrin_ctx(intrin)); /* (power < 1.0f) */ ast_block *blt1 = ast_block_new(intrin_ctx(intrin)); /* (base < 1.0f) */ ast_block *forloop = ast_block_new(intrin_ctx(intrin)); /* for(;;) */ ast_block *whileloop = ast_block_new(intrin_ctx(intrin)); /* while (whole >= base) */ ast_function *func = intrin_value(intrin, &value, "ln", TYPE_FLOAT); size_t i; vec_push(value->expression.params, power); vec_push(value->expression.params, base); vec_push(block->locals, whole); vec_push(block->locals, nth); vec_push(block->locals, sign); vec_push(block->locals, eps); vec_push(block->locals, out); vec_push(block->locals, A_i); vec_push(block->locals, B_i); vec_push(block->locals, A_iminus1); vec_push(block->locals, B_iminus1); /* sign = 1.0f; */ vec_push(block->exprs, (ast_expression*)ast_store_new( intrin_ctx(intrin), INSTR_STORE_F, (ast_expression*)sign, (ast_expression*)intrin->fold->imm_float[1] ) ); /* eps = __builtin_epsilon(); */ vec_push(block->exprs, (ast_expression*)ast_store_new( intrin_ctx(intrin), INSTR_STORE_F, (ast_expression*)eps, (ast_expression*)ast_call_new( intrin_ctx(intrin), intrin_func_self(intrin, "__builtin_epsilon", "ln") ) ) ); /* * A_i = 1; * B_i = 0; * A_iminus1 = 0; * B_iminus1 = 1; */ for (i = 0; i <= 1; i++) { int j; for (j = 1; j >= 0; j--) { vec_push(block->exprs, (ast_expression*)ast_store_new( intrin_ctx(intrin), INSTR_STORE_F, (ast_expression*)((j) ? ((i) ? B_iminus1 : A_i) : ((i) ? A_iminus1 : B_i)), (ast_expression*)intrin->fold->imm_float[j] ) ); } } /* * = { * power = 1.0f / power; * sign *= -1.0f; * } * = { * base = 1.0f / base; * sign *= -1.0f; * } */ for (i = 0; i <= 1; i++) { vec_push(((i) ? blt1 : plt1)->exprs, (ast_expression*)ast_store_new( intrin_ctx(intrin), INSTR_STORE_F, (ast_expression*)((i) ? base : power), (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_DIV_F, (ast_expression*)intrin->fold->imm_float[1], (ast_expression*)((i) ? base : power) ) ) ); vec_push(plt1->exprs, (ast_expression*)ast_binstore_new( intrin_ctx(intrin), INSTR_STORE_F, INSTR_MUL_F, (ast_expression*)sign, (ast_expression*)intrin->fold->imm_float[2] ) ); } /* * = { * if (power <= 0.0 || base <= 0.0f) * return __builtin_nan(); * if (power < 1.0f) * * if (base < 1.0f) * * } */ vec_push(plt1orblt1->exprs, (ast_expression*)ast_ifthen_new( intrin_ctx(intrin), (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_OR, (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_LE, (ast_expression*)power, (ast_expression*)intrin->fold->imm_float[0] ), (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_LE, (ast_expression*)base, (ast_expression*)intrin->fold->imm_float[0] ) ), (ast_expression*)ast_return_new( intrin_ctx(intrin), (ast_expression*)ast_call_new( intrin_ctx(intrin), intrin_func_self(intrin, "__builtin_nan", "ln") ) ), NULL ) ); for (i = 0; i <= 1; i++) { vec_push(plt1orblt1->exprs, (ast_expression*)ast_ifthen_new( intrin_ctx(intrin), (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_LT, (ast_expression*)((i) ? base : power), (ast_expression*)intrin->fold->imm_float[1] ), (ast_expression*)((i) ? blt1 : plt1), NULL ) ); } vec_push(block->exprs, (ast_expression*)plt1orblt1); /* whole = power; */ vec_push(forloop->exprs, (ast_expression*)ast_store_new( intrin_ctx(intrin), INSTR_STORE_F, (ast_expression*)whole, (ast_expression*)power ) ); /* nth = 0.0f; */ vec_push(forloop->exprs, (ast_expression*)ast_store_new( intrin_ctx(intrin), INSTR_STORE_F, (ast_expression*)nth, (ast_expression*)intrin->fold->imm_float[0] ) ); /* whole /= base; */ vec_push(whileloop->exprs, (ast_expression*)ast_binstore_new( intrin_ctx(intrin), INSTR_STORE_F, INSTR_DIV_F, (ast_expression*)whole, (ast_expression*)base ) ); /* nth ++; */ vec_push(whileloop->exprs, (ast_expression*)ast_binstore_new( intrin_ctx(intrin), INSTR_STORE_F, INSTR_ADD_F, (ast_expression*)nth, (ast_expression*)intrin->fold->imm_float[1] ) ); /* while (whole >= base) */ vec_push(forloop->exprs, (ast_expression*)ast_loop_new( intrin_ctx(intrin), NULL, (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_GE, (ast_expression*)whole, (ast_expression*)base ), false, NULL, false, NULL, (ast_expression*)whileloop ) ); vec_push(forloop->locals, b_iplus1); vec_push(forloop->locals, A_iplus1); vec_push(forloop->locals, B_iplus1); /* b_iplus1 = nth; */ vec_push(forloop->exprs, (ast_expression*)ast_store_new( intrin_ctx(intrin), INSTR_STORE_F, (ast_expression*)b_iplus1, (ast_expression*)nth ) ); /* * A_iplus1 = b_iplus1 * A_i + A_iminus1; * B_iplus1 = b_iplus1 * B_i + B_iminus1; */ for (i = 0; i <= 1; i++) { vec_push(forloop->exprs, (ast_expression*)ast_store_new( intrin_ctx(intrin), INSTR_STORE_F, (ast_expression*)((i) ? B_iplus1 : A_iplus1), (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_ADD_F, (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_MUL_F, (ast_expression*)b_iplus1, (ast_expression*) ((i) ? B_i : A_i) ), (ast_expression*)((i) ? B_iminus1 : A_iminus1) ) ) ); } /* * A_iminus1 = A_i; * B_iminus1 = B_i; */ for (i = 0; i <= 1; i++) { vec_push(forloop->exprs, (ast_expression*)ast_store_new( intrin_ctx(intrin), INSTR_STORE_F, (ast_expression*)((i) ? B_iminus1 : A_iminus1), (ast_expression*)((i) ? B_i : A_i) ) ); } /* * A_i = A_iplus1; * B_i = B_iplus1; */ for (i = 0; i <= 1; i++) { vec_push(forloop->exprs, (ast_expression*)ast_store_new( intrin_ctx(intrin), INSTR_STORE_F, (ast_expression*)((i) ? B_i : A_i), (ast_expression*)((i) ? B_iplus1 : A_iplus1) ) ); } /* * if (whole <= 1.0f + eps) * break; */ vec_push(forloop->exprs, (ast_expression*)ast_ifthen_new( intrin_ctx(intrin), (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_LE, (ast_expression*)whole, (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_ADD_F, (ast_expression*)intrin->fold->imm_float[1], (ast_expression*)eps ) ), (ast_expression*)ast_breakcont_new( intrin_ctx(intrin), false, 0 ), NULL ) ); /* * power = base; * base = whole; */ for (i = 0; i <= 1; i++) { vec_push(forloop->exprs, (ast_expression*)ast_store_new( intrin_ctx(intrin), INSTR_STORE_F, (ast_expression*)((i) ? base : power), (ast_expression*)((i) ? whole : base) ) ); } /* add the for loop block */ vec_push(block->exprs, (ast_expression*)ast_loop_new( intrin_ctx(intrin), NULL, /* for(; 1; ) ?? (can this be NULL too?) */ (ast_expression*)intrin->fold->imm_float[1], false, NULL, false, NULL, (ast_expression*)forloop ) ); /* return sign * A_i / B_il */ vec_push(block->exprs, (ast_expression*)ast_return_new( intrin_ctx(intrin), (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_MUL_F, (ast_expression*)sign, (ast_expression*)ast_binary_new( intrin_ctx(intrin), INSTR_DIV_F, (ast_expression*)A_i, (ast_expression*)B_i ) ) ) ); vec_push(func->blocks, block); intrin_reg(intrin, value, func); return (ast_expression*)value; } #define LOG_VARIANT(NAME, BASE) \ static ast_expression *intrin_##NAME(intrin_t *intrin) { \ ast_value *value = NULL; \ ast_call *callln = ast_call_new (intrin_ctx(intrin), intrin_func_self(intrin, "__builtin_ln", #NAME)); \ 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, #NAME, TYPE_FLOAT); \ vec_push(value->expression.params, arg1); \ vec_push(callln->params, (ast_expression*)arg1); \ vec_push(callln->params, (ast_expression*)fold_constgen_float(intrin->fold, BASE)); \ vec_push(body->exprs, \ (ast_expression*)ast_return_new( \ intrin_ctx(intrin), \ (ast_expression*)callln \ ) \ ); \ vec_push(func->blocks, body); \ intrin_reg(intrin, value, func); \ return (ast_expression*)value; \ } LOG_VARIANT(log, 2.7182818284590452354) LOG_VARIANT(log10, 10) LOG_VARIANT(log2, 2) LOG_VARIANT(logb, 2) /* FLT_RADIX == 2 for now */ #undef LOG_VARIANT /* * TODO: make static (and handle ast_type_string) here for the builtin * instead of in SYA parse close. */ ast_expression *intrin_debug_typestring(intrin_t *intrin) { (void)intrin; return (ast_expression*)0x1; } static const intrin_func_t intrinsics[] = { {&intrin_isfinite, "__builtin_isfinite", "isfinite", 1}, {&intrin_isinf, "__builtin_isinf", "isinf", 1}, {&intrin_isnan, "__builtin_isnan", "isnan", 1}, {&intrin_isnormal, "__builtin_isnormal", "isnormal", 1}, {&intrin_signbit, "__builtin_signbit", "signbit", 1}, {&intrin_acosh, "__builtin_acosh", "acosh", 1}, {&intrin_asinh, "__builtin_asinh", "asinh", 1}, {&intrin_atanh, "__builtin_atanh", "atanh", 1}, {&intrin_exp, "__builtin_exp", "exp", 1}, {&intrin_exp2, "__builtin_exp2", "exp2", 1}, {&intrin_expm1, "__builtin_expm1", "expm1", 1}, {&intrin_mod, "__builtin_mod", "mod", 2}, {&intrin_pow, "__builtin_pow", "pow", 2}, {&intrin_fabs, "__builtin_fabs", "fabs", 1}, {&intrin_epsilon, "__builtin_epsilon", "", 0}, {&intrin_nan, "__builtin_nan", "", 0}, {&intrin_inf, "__builtin_inf", "", 0}, {&intrin_ln, "__builtin_ln", "", 2}, {&intrin_log, "__builtin_log", "log", 1}, {&intrin_log10, "__builtin_log10", "log10", 1}, {&intrin_log2, "__builtin_log2", "log2", 1}, {&intrin_logb, "__builtin_logb", "logb", 1}, {&intrin_debug_typestring, "__builtin_debug_typestring", "", 0}, {&intrin_nullfunc, "#nullfunc", "", 0} }; static void intrin_error(intrin_t *intrin, const char *fmt, ...) { va_list ap; va_start(ap, fmt); vcompile_error(intrin->parser->lex->tok.ctx, fmt, ap); va_end(ap); } /* exposed */ intrin_t *intrin_init(parser_t *parser) { intrin_t *intrin = (intrin_t*)mem_a(sizeof(intrin_t)); size_t i; intrin->parser = parser; intrin->fold = parser->fold; intrin->intrinsics = NULL; intrin->generated = NULL; vec_append(intrin->intrinsics, GMQCC_ARRAY_COUNT(intrinsics), intrinsics); /* populate with null pointers for tracking generation */ for (i = 0; i < GMQCC_ARRAY_COUNT(intrinsics); i++) vec_push(intrin->generated, NULL); return intrin; } void intrin_cleanup(intrin_t *intrin) { vec_free(intrin->intrinsics); vec_free(intrin->generated); mem_d(intrin); } ast_expression *intrin_fold(intrin_t *intrin, ast_value *value, ast_expression **exprs) { size_t i; if (!value || !value->name) return NULL; for (i = 0; i < vec_size(intrin->intrinsics); i++) if (!strcmp(value->name, intrin->intrinsics[i].name)) return (vec_size(exprs) != intrin->intrinsics[i].args) ? NULL : fold_intrin(intrin->fold, value->name + 10, exprs); return NULL; } static GMQCC_INLINE ast_expression *intrin_func_try(intrin_t *intrin, size_t offset, const char *compare) { size_t i; for (i = 0; i < vec_size(intrin->intrinsics); i++) { if (strcmp(*(char **)((char *)&intrin->intrinsics[i] + offset), compare)) continue; if (intrin->generated[i]) return intrin->generated[i]; return intrin->generated[i] = intrin->intrinsics[i].intrin(intrin); } return NULL; } static ast_expression *intrin_func_self(intrin_t *intrin, const char *name, const char *from) { size_t i; ast_expression *find; /* try current first */ if ((find = parser_find_global(intrin->parser, name)) && ((ast_value*)find)->expression.vtype == TYPE_FUNCTION) for (i = 0; i < vec_size(intrin->parser->functions); ++i) if (((ast_value*)find)->name && !strcmp(intrin->parser->functions[i]->name, ((ast_value*)find)->name) && intrin->parser->functions[i]->builtin < 0) return find; /* try name second */ if ((find = intrin_func_try(intrin, offsetof(intrin_func_t, name), name))) return find; /* try alias third */ if ((find = intrin_func_try(intrin, offsetof(intrin_func_t, alias), name))) return find; if (from) { intrin_error(intrin, "need function `%s', compiler depends on it for `__builtin_%s'", name, from); return intrin_func_self(intrin, "#nullfunc", NULL); } return NULL; } ast_expression *intrin_func(intrin_t *intrin, const char *name) { return intrin_func_self(intrin, name, NULL); }