2 * Copyright (C) 2012, 2013
5 * Permission is hereby granted, free of charge, to any person obtaining a copy of
6 * this software and associated documentation files (the "Software"), to deal in
7 * the Software without restriction, including without limitation the rights to
8 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
9 * of the Software, and to permit persons to whom the Software is furnished to do
10 * so, subject to the following conditions:
12 * The above copyright notice and this permission notice shall be included in all
13 * copies or substantial portions of the Software.
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
27 * Provides all the "intrinsics" / "builtins" for GMQCC. These can do
28 * a few things, they can provide fall back implementations for math
29 * functions if the definitions don't exist for some given engine. Or
30 * then can determine definitions for existing builtins, and simply
31 * wrap back to them instead. This is like a "portable" intrface that
32 * is entered when -fintrin is used (causing all existing builtins to
33 * be ignored by the compiler and instead interface through here.
35 #define intrin_ctx(I) parser_ctx((I)->parser)
37 static GMQCC_INLINE ast_function *intrin_value(intrin_t *intrin, ast_value **out, const char *name, qcint_t vtype) {
38 ast_value *value = NULL;
39 ast_function *func = NULL;
43 util_snprintf(buffer, sizeof(buffer), "__builtin_%s", name);
44 util_snprintf(stype, sizeof(stype), "<%s>", type_name[vtype]);
46 value = ast_value_new(intrin_ctx(intrin), buffer, TYPE_FUNCTION);
47 value->intrinsic = true;
48 value->expression.next = (ast_expression*)ast_value_new(intrin_ctx(intrin), stype, vtype);
49 func = ast_function_new(intrin_ctx(intrin), buffer, value);
50 value->expression.flags |= AST_FLAG_ERASEABLE;
56 static GMQCC_INLINE void intrin_reg(intrin_t *intrin, ast_value *const value, ast_function *const func) {
57 vec_push(intrin->parser->functions, func);
58 vec_push(intrin->parser->globals, (ast_expression*)value);
61 #define QC_POW_EPSILON 0.00001f
64 * since some intrinsics depend on each other there is the possibility
65 * that an intrinsic will fail to get a 'depended' function that a
66 * builtin needs, causing some dependency in the chain to have a NULL
67 * function. This will cause a segmentation fault at code generation,
68 * even though an error was raised. To contiue to allow it (instead
69 * of stopping compilation right away). We need to return from the
70 * parser, before compilation stops after all the collected errors.
72 static ast_expression *intrin_func_self(intrin_t *intrin, const char *name, const char *from);
73 static ast_expression *intrin_nullfunc(intrin_t *intrin) {
74 ast_value *value = NULL;
75 ast_function *func = intrin_value(intrin, &value, NULL, TYPE_VOID);
76 intrin_reg(intrin, value, func);
77 return (ast_expression*)value;
80 static ast_expression *intrin_isfinite(intrin_t *intrin) {
82 * float isfinite(float x) {
83 * return !(isnan(x) || isinf(x));
86 ast_value *value = NULL;
87 ast_value *x = ast_value_new(intrin_ctx(intrin), "x", TYPE_FLOAT);
88 ast_function *func = intrin_value(intrin, &value, "isfinite", TYPE_FLOAT);
89 ast_call *callisnan = ast_call_new(intrin_ctx(intrin), intrin_func_self(intrin, "isnan", "isfinite"));
90 ast_call *callisinf = ast_call_new(intrin_ctx(intrin), intrin_func_self(intrin, "isinf", "isfinite"));
91 ast_block *block = ast_block_new(intrin_ctx(intrin));
94 vec_push(value->expression.params, x);
96 /* <callisnan> = isnan(x); */
97 vec_push(callisnan->params, (ast_expression*)x);
99 /* <callisinf> = isinf(x); */
100 vec_push(callisinf->params, (ast_expression*)x);
102 /* return (!<callisnan> || <callisinf>); */
103 vec_push(block->exprs,
104 (ast_expression*)ast_return_new(
106 (ast_expression*)ast_unary_new(
109 (ast_expression*)ast_binary_new(
112 (ast_expression*)callisnan,
113 (ast_expression*)callisinf
119 vec_push(func->blocks, block);
120 intrin_reg(intrin, value, func);
122 return (ast_expression*)value;;
125 static ast_expression *intrin_isinf(intrin_t *intrin) {
127 * float isinf(float x) {
128 * return (x != 0.0) && (x + x == x);
131 ast_value *value = NULL;
132 ast_value *x = ast_value_new(intrin_ctx(intrin), "x", TYPE_FLOAT);
133 ast_block *body = ast_block_new(intrin_ctx(intrin));
134 ast_function *func = intrin_value(intrin, &value, "isinf", TYPE_FLOAT);
136 vec_push(body->exprs,
137 (ast_expression*)ast_return_new(
139 (ast_expression*)ast_binary_new(
142 (ast_expression*)ast_binary_new(
146 (ast_expression*)intrin->fold->imm_float[0]
148 (ast_expression*)ast_binary_new(
151 (ast_expression*)ast_binary_new(
163 vec_push(value->expression.params, x);
164 vec_push(func->blocks, body);
166 intrin_reg(intrin, value, func);
168 return (ast_expression*)value;
171 static ast_expression *intrin_isnan(intrin_t *intrin) {
173 * float isnan(float x) {
177 * return (x != local);
180 ast_value *value = NULL;
181 ast_value *arg1 = ast_value_new(intrin_ctx(intrin), "x", TYPE_FLOAT);
182 ast_value *local = ast_value_new(intrin_ctx(intrin), "local", TYPE_FLOAT);
183 ast_block *body = ast_block_new(intrin_ctx(intrin));
184 ast_function *func = intrin_value(intrin, &value, "isnan", TYPE_FLOAT);
186 vec_push(body->locals, local);
187 vec_push(body->exprs,
188 (ast_expression*)ast_store_new(
191 (ast_expression*)local,
192 (ast_expression*)arg1
196 vec_push(body->exprs,
197 (ast_expression*)ast_return_new(
199 (ast_expression*)ast_binary_new(
202 (ast_expression*)arg1,
203 (ast_expression*)local
208 vec_push(value->expression.params, arg1);
209 vec_push(func->blocks, body);
211 intrin_reg(intrin, value, func);
213 return (ast_expression*)value;
216 static ast_expression *intrin_isnormal(intrin_t *intrin) {
218 * float isnormal(float x) {
219 * return isfinite(x);
222 ast_value *value = NULL;
223 ast_call *callisfinite = ast_call_new (intrin_ctx(intrin), intrin_func_self(intrin, "isfinite", "isnormal"));
224 ast_value *x = ast_value_new(intrin_ctx(intrin), "x", TYPE_FLOAT);
225 ast_block *body = ast_block_new(intrin_ctx(intrin));
226 ast_function *func = intrin_value(intrin, &value, "isnormal", TYPE_FLOAT);
228 vec_push(value->expression.params, x);
229 vec_push(callisfinite->params, (ast_expression*)x);
231 /* return <callisfinite> */
232 vec_push(body->exprs,
233 (ast_expression*)ast_return_new(
235 (ast_expression*)callisfinite
239 vec_push(func->blocks, body);
240 intrin_reg(intrin, value, func);
241 return (ast_expression*)value;
244 static ast_expression *intrin_signbit(intrin_t *intrin) {
246 * float signbit(float x) {
250 ast_value *value = NULL;
251 ast_value *x = ast_value_new(intrin_ctx(intrin), "x", TYPE_FLOAT);
252 ast_block *body = ast_block_new(intrin_ctx(intrin));
253 ast_function *func = intrin_value(intrin, &value, "signbit", TYPE_FLOAT);
255 vec_push(value->expression.params, x);
257 /* return (x < 0); */
258 vec_push(body->exprs,
259 (ast_expression*)ast_return_new(
261 (ast_expression*)ast_ternary_new(
263 (ast_expression*)ast_binary_new(
267 (ast_expression*)intrin->fold->imm_float[0]
269 (ast_expression*)intrin->fold->imm_float[1],
270 (ast_expression*)intrin->fold->imm_float[0]
275 vec_push(func->blocks, body);
276 intrin_reg(intrin, value, func);
277 return (ast_expression*)value;
280 static ast_expression *intrin_acosh(intrin_t *intrin) {
282 * float acosh(float x) {
283 * return log(x + sqrt((x * x) - 1));
286 ast_value *value = NULL;
287 ast_value *x = ast_value_new(intrin_ctx(intrin), "x", TYPE_FLOAT);
288 ast_call *calllog = ast_call_new(intrin_ctx(intrin), intrin_func_self(intrin, "log", "acosh"));
289 ast_call *callsqrt = ast_call_new(intrin_ctx(intrin), intrin_func_self(intrin, "sqrt", "acosh"));
290 ast_block *body = ast_block_new(intrin_ctx(intrin));
291 ast_function *func = intrin_value(intrin, &value, "acosh", TYPE_FLOAT);
293 vec_push(value->expression.params, x);
295 /* <callsqrt> = sqrt((x * x) - 1); */
296 vec_push(callsqrt->params,
297 (ast_expression*)ast_binary_new(
300 (ast_expression*)ast_binary_new(
306 (ast_expression*)intrin->fold->imm_float[1]
310 /* <calllog> = log(x + <callsqrt>); */
311 vec_push(calllog->params,
312 (ast_expression*)ast_binary_new(
316 (ast_expression*)callsqrt
320 /* return <calllog>; */
321 vec_push(body->exprs,
322 (ast_expression*)ast_return_new(
324 (ast_expression*)calllog
328 vec_push(func->blocks, body);
329 intrin_reg(intrin, value, func);
330 return (ast_expression*)value;
333 static ast_expression *intrin_asinh(intrin_t *intrin) {
335 * float asinh(float x) {
336 * return log(x + sqrt((x * x) + 1));
339 ast_value *value = NULL;
340 ast_value *x = ast_value_new(intrin_ctx(intrin), "x", TYPE_FLOAT);
341 ast_call *calllog = ast_call_new(intrin_ctx(intrin), intrin_func_self(intrin, "log", "asinh"));
342 ast_call *callsqrt = ast_call_new(intrin_ctx(intrin), intrin_func_self(intrin, "sqrt", "asinh"));
343 ast_block *body = ast_block_new(intrin_ctx(intrin));
344 ast_function *func = intrin_value(intrin, &value, "asinh", TYPE_FLOAT);
346 vec_push(value->expression.params, x);
348 /* <callsqrt> = sqrt((x * x) + 1); */
349 vec_push(callsqrt->params,
350 (ast_expression*)ast_binary_new(
353 (ast_expression*)ast_binary_new(
359 (ast_expression*)intrin->fold->imm_float[1]
363 /* <calllog> = log(x + <callsqrt>); */
364 vec_push(calllog->params,
365 (ast_expression*)ast_binary_new(
369 (ast_expression*)callsqrt
373 /* return <calllog>; */
374 vec_push(body->exprs,
375 (ast_expression*)ast_return_new(
377 (ast_expression*)calllog
381 vec_push(func->blocks, body);
382 intrin_reg(intrin, value, func);
383 return (ast_expression*)value;
386 static ast_expression *intrin_atanh(intrin_t *intrin) {
388 * float atanh(float x) {
389 * return 0.5 * log((1 + x) / (1 - x))
392 ast_value *value = NULL;
393 ast_value *x = ast_value_new(intrin_ctx(intrin), "x", TYPE_FLOAT);
394 ast_call *calllog = ast_call_new(intrin_ctx(intrin), intrin_func_self(intrin, "log", "atanh"));
395 ast_block *body = ast_block_new(intrin_ctx(intrin));
396 ast_function *func = intrin_value(intrin, &value, "atanh", TYPE_FLOAT);
398 vec_push(value->expression.params, x);
400 /* <callog> = log((1 + x) / (1 - x)); */
401 vec_push(calllog->params,
402 (ast_expression*)ast_binary_new(
405 (ast_expression*)ast_binary_new(
408 (ast_expression*)intrin->fold->imm_float[1],
411 (ast_expression*)ast_binary_new(
414 (ast_expression*)intrin->fold->imm_float[1],
420 /* return 0.5 * <calllog>; */
421 vec_push(body->exprs,
422 (ast_expression*)ast_binary_new(
425 (ast_expression*)fold_constgen_float(intrin->fold, 0.5),
426 (ast_expression*)calllog
430 vec_push(func->blocks, body);
431 intrin_reg(intrin, value, func);
432 return (ast_expression*)value;
435 static ast_expression *intrin_exp(intrin_t *intrin) {
437 * float exp(float x) {
441 * for (i = 1; i < 200; ++i)
442 * sum += (acc *= x / i);
447 ast_value *value = NULL;
448 ast_value *x = ast_value_new(intrin_ctx(intrin), "x", TYPE_FLOAT);
449 ast_value *sum = ast_value_new(intrin_ctx(intrin), "sum", TYPE_FLOAT);
450 ast_value *acc = ast_value_new(intrin_ctx(intrin), "acc", TYPE_FLOAT);
451 ast_value *i = ast_value_new(intrin_ctx(intrin), "i", TYPE_FLOAT);
452 ast_block *body = ast_block_new(intrin_ctx(intrin));
453 ast_function *func = intrin_value(intrin, &value, "exp", TYPE_FLOAT);
455 vec_push(value->expression.params, x);
456 vec_push(body->locals, sum);
457 vec_push(body->locals, acc);
458 vec_push(body->locals, i);
461 vec_push(body->exprs,
462 (ast_expression*)ast_store_new(
465 (ast_expression*)sum,
466 (ast_expression*)intrin->fold->imm_float[1]
471 vec_push(body->exprs,
472 (ast_expression*)ast_store_new(
475 (ast_expression*)acc,
476 (ast_expression*)intrin->fold->imm_float[1]
481 * for (i = 1; i < 200; ++i)
482 * sum += (acc *= x / i);
484 vec_push(body->exprs,
485 (ast_expression*)ast_loop_new(
488 (ast_expression*)ast_store_new(
492 (ast_expression*)intrin->fold->imm_float[1]
495 (ast_expression*)ast_binary_new(
499 (ast_expression*)fold_constgen_float(intrin->fold, 200.0f)
505 (ast_expression*)ast_binstore_new(
510 (ast_expression*)intrin->fold->imm_float[1]
512 /* sum += (acc *= (x / i)) */
513 (ast_expression*)ast_binstore_new(
517 (ast_expression*)sum,
518 (ast_expression*)ast_binstore_new(
522 (ast_expression*)acc,
523 (ast_expression*)ast_binary_new(
535 vec_push(body->exprs,
536 (ast_expression*)ast_return_new(
542 vec_push(func->blocks, body);
544 intrin_reg(intrin, value, func);
545 return (ast_expression*)value;
548 static ast_expression *intrin_exp2(intrin_t *intrin) {
550 * float exp2(float x) {
554 ast_value *value = NULL;
555 ast_call *callpow = ast_call_new (intrin_ctx(intrin), intrin_func_self(intrin, "pow", "exp2"));
556 ast_value *arg1 = ast_value_new(intrin_ctx(intrin), "x", TYPE_FLOAT);
557 ast_block *body = ast_block_new(intrin_ctx(intrin));
558 ast_function *func = intrin_value(intrin, &value, "exp2", TYPE_FLOAT);
560 vec_push(value->expression.params, arg1);
562 vec_push(callpow->params, (ast_expression*)intrin->fold->imm_float[3]);
563 vec_push(callpow->params, (ast_expression*)arg1);
565 /* return <callpow> */
566 vec_push(body->exprs,
567 (ast_expression*)ast_return_new(
569 (ast_expression*)callpow
573 vec_push(func->blocks, body);
575 intrin_reg(intrin, value, func);
576 return (ast_expression*)value;
579 static ast_expression *intrin_expm1(intrin_t *intrin) {
581 * float expm1(float x) {
585 ast_value *value = NULL;
586 ast_call *callexp = ast_call_new (intrin_ctx(intrin), intrin_func_self(intrin, "exp", "expm1"));
587 ast_value *x = ast_value_new(intrin_ctx(intrin), "x", TYPE_FLOAT);
588 ast_block *body = ast_block_new(intrin_ctx(intrin));
589 ast_function *func = intrin_value(intrin, &value, "expm1", TYPE_FLOAT);
591 vec_push(value->expression.params, x);
593 /* <callexp> = exp(x); */
594 vec_push(callexp->params, (ast_expression*)x);
596 /* return <callexp> - 1; */
597 vec_push(body->exprs,
598 (ast_expression*)ast_return_new(
600 (ast_expression*)ast_binary_new(
603 (ast_expression*)callexp,
604 (ast_expression*)intrin->fold->imm_float[1]
609 vec_push(func->blocks, body);
610 intrin_reg(intrin, value, func);
611 return (ast_expression*)value;
614 static ast_expression *intrin_pow(intrin_t *intrin) {
617 * float pow(float base, float exp) {
630 * return 1.0 / pow(base, -exp);
632 * result = pow(base, exp / 2);
633 * return result * result;
638 * square = sqrt(base);
639 * accumulate = square;
642 * while (fabs(mid - exp) > QC_POW_EPSILON) {
643 * square = sqrt(square);
646 * accumulate *= square;
649 * accumulate *= (1.0f / square);
651 * mid = (low + high) / 2;
656 ast_value *value = NULL;
657 ast_function *func = intrin_value(intrin, &value, "pow", TYPE_FLOAT);
659 /* prepare some calls for later */
660 ast_call *callpow1 = ast_call_new(intrin_ctx(intrin), (ast_expression*)value); /* for pow(base, -exp) */
661 ast_call *callpow2 = ast_call_new(intrin_ctx(intrin), (ast_expression*)value); /* for pow(vase, exp / 2) */
662 ast_call *callsqrt1 = ast_call_new(intrin_ctx(intrin), intrin_func_self(intrin, "sqrt", "pow")); /* for sqrt(base) */
663 ast_call *callsqrt2 = ast_call_new(intrin_ctx(intrin), intrin_func_self(intrin, "sqrt", "pow")); /* for sqrt(square) */
664 ast_call *callfabs = ast_call_new(intrin_ctx(intrin), intrin_func_self(intrin, "fabs", "pow")); /* for fabs(mid - exp) */
666 /* prepare some blocks for later */
667 ast_block *expgt1 = ast_block_new(intrin_ctx(intrin));
668 ast_block *midltexp = ast_block_new(intrin_ctx(intrin));
669 ast_block *midltexpelse = ast_block_new(intrin_ctx(intrin));
670 ast_block *whileblock = ast_block_new(intrin_ctx(intrin));
672 /* float pow(float base, float exp) */
673 ast_value *base = ast_value_new(intrin_ctx(intrin), "base", TYPE_FLOAT);
674 ast_value *exp = ast_value_new(intrin_ctx(intrin), "exp", TYPE_FLOAT);
676 ast_block *body = ast_block_new(intrin_ctx(intrin));
686 ast_value *result = ast_value_new(intrin_ctx(intrin), "result", TYPE_FLOAT);
687 ast_value *low = ast_value_new(intrin_ctx(intrin), "low", TYPE_FLOAT);
688 ast_value *high = ast_value_new(intrin_ctx(intrin), "high", TYPE_FLOAT);
689 ast_value *square = ast_value_new(intrin_ctx(intrin), "square", TYPE_FLOAT);
690 ast_value *accumulate = ast_value_new(intrin_ctx(intrin), "accumulate", TYPE_FLOAT);
691 ast_value *mid = ast_value_new(intrin_ctx(intrin), "mid", TYPE_FLOAT);
692 vec_push(body->locals, result);
693 vec_push(body->locals, low);
694 vec_push(body->locals, high);
695 vec_push(body->locals, square);
696 vec_push(body->locals, accumulate);
697 vec_push(body->locals, mid);
699 vec_push(value->expression.params, base);
700 vec_push(value->expression.params, exp);
706 vec_push(body->exprs,
707 (ast_expression*)ast_ifthen_new(
709 (ast_expression*)ast_binary_new(
712 (ast_expression*)exp,
713 (ast_expression*)intrin->fold->imm_float[0]
715 (ast_expression*)ast_return_new(
717 (ast_expression*)intrin->fold->imm_float[1]
727 vec_push(body->exprs,
728 (ast_expression*)ast_ifthen_new(
730 (ast_expression*)ast_binary_new(
733 (ast_expression*)exp,
734 (ast_expression*)intrin->fold->imm_float[1]
736 (ast_expression*)ast_return_new(
738 (ast_expression*)base
744 /* <callpow1> = pow(base, -exp) */
745 vec_push(callpow1->params, (ast_expression*)base);
746 vec_push(callpow1->params,
747 (ast_expression*)ast_unary_new(
756 * return 1.0 / <callpow1>;
758 vec_push(body->exprs,
759 (ast_expression*)ast_ifthen_new(
761 (ast_expression*)ast_binary_new(
764 (ast_expression*)exp,
765 (ast_expression*)intrin->fold->imm_float[0]
767 (ast_expression*)ast_return_new(
769 (ast_expression*)ast_binary_new(
772 (ast_expression*)intrin->fold->imm_float[1],
773 (ast_expression*)callpow1
780 /* <callpow2> = pow(base, exp / 2) */
781 vec_push(callpow2->params, (ast_expression*)base);
782 vec_push(callpow2->params,
783 (ast_expression*)ast_binary_new(
786 (ast_expression*)exp,
787 (ast_expression*)intrin->fold->imm_float[3] /* 2.0f */
793 * result = <callpow2>;
794 * return result * result;
797 vec_push(expgt1->exprs,
798 (ast_expression*)ast_store_new(
801 (ast_expression*)result,
802 (ast_expression*)callpow2
805 vec_push(expgt1->exprs,
806 (ast_expression*)ast_return_new(
808 (ast_expression*)ast_binary_new(
811 (ast_expression*)result,
812 (ast_expression*)result
822 vec_push(body->exprs,
823 (ast_expression*)ast_ifthen_new(
825 (ast_expression*)ast_binary_new(
828 (ast_expression*)exp,
829 (ast_expression*)intrin->fold->imm_float[1]
831 (ast_expression*)expgt1,
837 * <callsqrt1> = sqrt(base)
839 vec_push(callsqrt1->params, (ast_expression*)base);
844 * square = sqrt(base);
845 * accumulate = square;
848 vec_push(body->exprs,
849 (ast_expression*)ast_store_new(intrin_ctx(intrin),
851 (ast_expression*)low,
852 (ast_expression*)intrin->fold->imm_float[0]
855 vec_push(body->exprs,
856 (ast_expression*)ast_store_new(
859 (ast_expression*)high,
860 (ast_expression*)intrin->fold->imm_float[1]
864 vec_push(body->exprs,
865 (ast_expression*)ast_store_new(
868 (ast_expression*)square,
869 (ast_expression*)callsqrt1
873 vec_push(body->exprs,
874 (ast_expression*)ast_store_new(
877 (ast_expression*)accumulate,
878 (ast_expression*)square
881 vec_push(body->exprs,
882 (ast_expression*)ast_store_new(
885 (ast_expression*)mid,
886 (ast_expression*)ast_binary_new(
889 (ast_expression*)high,
890 (ast_expression*)intrin->fold->imm_float[3] /* 2.0f */
898 * accumulate *= square;
901 vec_push(midltexp->exprs,
902 (ast_expression*)ast_store_new(
905 (ast_expression*)low,
909 vec_push(midltexp->exprs,
910 (ast_expression*)ast_binstore_new(
914 (ast_expression*)accumulate,
915 (ast_expression*)square
922 * accumulate *= (1.0 / square);
925 vec_push(midltexpelse->exprs,
926 (ast_expression*)ast_store_new(
929 (ast_expression*)high,
933 vec_push(midltexpelse->exprs,
934 (ast_expression*)ast_binstore_new(
938 (ast_expression*)accumulate,
939 (ast_expression*)ast_binary_new(
942 (ast_expression*)intrin->fold->imm_float[1],
943 (ast_expression*)square
949 * <callsqrt2> = sqrt(square)
951 vec_push(callsqrt2->params, (ast_expression*)square);
955 * square = <callsqrt2>;
961 * mid = (low + high) / 2;
964 vec_push(whileblock->exprs,
965 (ast_expression*)ast_store_new(
968 (ast_expression*)square,
969 (ast_expression*)callsqrt2
972 vec_push(whileblock->exprs,
973 (ast_expression*)ast_ifthen_new(
975 (ast_expression*)ast_binary_new(
978 (ast_expression*)mid,
981 (ast_expression*)midltexp,
982 (ast_expression*)midltexpelse
985 vec_push(whileblock->exprs,
986 (ast_expression*)ast_store_new(
989 (ast_expression*)mid,
990 (ast_expression*)ast_binary_new(
993 (ast_expression*)ast_binary_new(
996 (ast_expression*)low,
997 (ast_expression*)high
999 (ast_expression*)intrin->fold->imm_float[3] /* 2.0f */
1005 * <callabs> = fabs(mid - exp)
1007 vec_push(callfabs->params,
1008 (ast_expression*)ast_binary_new(
1011 (ast_expression*)mid,
1012 (ast_expression*)exp
1017 * while (<callfabs> > epsilon)
1020 vec_push(body->exprs,
1021 (ast_expression*)ast_loop_new(
1026 (ast_expression*)ast_binary_new(
1029 (ast_expression*)callfabs,
1030 (ast_expression*)fold_constgen_float(intrin->fold, QC_POW_EPSILON)
1034 /* post condition */
1038 /* increment expression */
1041 (ast_expression*)whileblock
1045 /* return accumulate */
1046 vec_push(body->exprs,
1047 (ast_expression*)ast_return_new(
1049 (ast_expression*)accumulate
1054 vec_push(func->blocks, body);
1056 intrin_reg(intrin, value, func);
1057 return (ast_expression*)value;
1060 static ast_expression *intrin_mod(intrin_t *intrin) {
1062 * float mod(float a, float b) {
1063 * float div = a / b;
1064 * float sign = (div < 0.0f) ? -1 : 1;
1065 * return a - b * sign * floor(sign * div);
1068 ast_value *value = NULL;
1069 ast_call *call = ast_call_new (intrin_ctx(intrin), intrin_func_self(intrin, "floor", "mod"));
1070 ast_value *a = ast_value_new(intrin_ctx(intrin), "a", TYPE_FLOAT);
1071 ast_value *b = ast_value_new(intrin_ctx(intrin), "b", TYPE_FLOAT);
1072 ast_value *div = ast_value_new(intrin_ctx(intrin), "div", TYPE_FLOAT);
1073 ast_value *sign = ast_value_new(intrin_ctx(intrin), "sign", TYPE_FLOAT);
1074 ast_block *body = ast_block_new(intrin_ctx(intrin));
1075 ast_function *func = intrin_value(intrin, &value, "mod", TYPE_FLOAT);
1077 vec_push(value->expression.params, a);
1078 vec_push(value->expression.params, b);
1080 vec_push(body->locals, div);
1081 vec_push(body->locals, sign);
1084 vec_push(body->exprs,
1085 (ast_expression*)ast_store_new(
1088 (ast_expression*)div,
1089 (ast_expression*)ast_binary_new(
1098 /* sign = (div < 0.0f) ? -1 : 1; */
1099 vec_push(body->exprs,
1100 (ast_expression*)ast_store_new(
1103 (ast_expression*)sign,
1104 (ast_expression*)ast_ternary_new(
1106 (ast_expression*)ast_binary_new(
1109 (ast_expression*)div,
1110 (ast_expression*)intrin->fold->imm_float[0]
1112 (ast_expression*)intrin->fold->imm_float[2],
1113 (ast_expression*)intrin->fold->imm_float[1]
1118 /* floor(sign * div) */
1119 vec_push(call->params,
1120 (ast_expression*)ast_binary_new(
1123 (ast_expression*)sign,
1124 (ast_expression*)div
1128 /* return a - b * sign * <call> */
1129 vec_push(body->exprs,
1130 (ast_expression*)ast_return_new(
1132 (ast_expression*)ast_binary_new(
1136 (ast_expression*)ast_binary_new(
1140 (ast_expression*)ast_binary_new(
1143 (ast_expression*)sign,
1144 (ast_expression*)call
1151 vec_push(func->blocks, body);
1152 intrin_reg(intrin, value, func);
1154 return (ast_expression*)value;
1157 static ast_expression *intrin_fabs(intrin_t *intrin) {
1159 * float fabs(float x) {
1160 * return x < 0 ? -x : x;
1163 ast_value *value = NULL;
1164 ast_value *arg1 = ast_value_new(intrin_ctx(intrin), "x", TYPE_FLOAT);
1165 ast_block *body = ast_block_new(intrin_ctx(intrin));
1166 ast_function *func = intrin_value(intrin, &value, "fabs", TYPE_FLOAT);
1168 vec_push(body->exprs,
1169 (ast_expression*)ast_return_new(
1171 (ast_expression*)ast_ternary_new(
1173 (ast_expression*)ast_binary_new(
1176 (ast_expression*)arg1,
1177 (ast_expression*)intrin->fold->imm_float[0]
1179 (ast_expression*)ast_unary_new(
1182 (ast_expression*)arg1
1184 (ast_expression*)arg1
1189 vec_push(value->expression.params, arg1);
1190 vec_push(func->blocks, body);
1192 intrin_reg(intrin, value, func);
1194 return (ast_expression*)value;
1197 static ast_expression *intrin_epsilon(intrin_t *intrin) {
1199 * float epsilon(void) {
1201 * do { eps /= 2.0f; } while ((1.0f + (eps / 2.0f)) != 1.0f);
1205 ast_value *value = NULL;
1206 ast_value *eps = ast_value_new(intrin_ctx(intrin), "eps", TYPE_FLOAT);
1207 ast_block *body = ast_block_new(intrin_ctx(intrin));
1208 ast_function *func = intrin_value(intrin, &value, "epsilon", TYPE_FLOAT);
1210 vec_push(body->locals, eps);
1213 vec_push(body->exprs,
1214 (ast_expression*)ast_store_new(
1217 (ast_expression*)eps,
1218 (ast_expression*)intrin->fold->imm_float[0]
1222 vec_push(body->exprs,
1223 (ast_expression*)ast_loop_new(
1228 (ast_expression*)ast_binary_new(
1231 (ast_expression*)ast_binary_new(
1234 (ast_expression*)intrin->fold->imm_float[1],
1235 (ast_expression*)ast_binary_new(
1238 (ast_expression*)eps,
1239 (ast_expression*)intrin->fold->imm_float[3] /* 2.0f */
1242 (ast_expression*)intrin->fold->imm_float[1]
1246 (ast_expression*)ast_binstore_new(
1250 (ast_expression*)eps,
1251 (ast_expression*)intrin->fold->imm_float[3] /* 2.0f */
1257 vec_push(body->exprs,
1258 (ast_expression*)ast_return_new(
1260 (ast_expression*)eps
1264 vec_push(func->blocks, body);
1265 intrin_reg(intrin, value, func);
1267 return (ast_expression*)value;
1270 static ast_expression *intrin_nan(intrin_t *intrin) {
1277 ast_value *value = NULL;
1278 ast_value *x = ast_value_new(intrin_ctx(intrin), "x", TYPE_FLOAT);
1279 ast_function *func = intrin_value(intrin, &value, "nan", TYPE_FLOAT);
1280 ast_block *block = ast_block_new(intrin_ctx(intrin));
1282 vec_push(block->locals, x);
1284 vec_push(block->exprs,
1285 (ast_expression*)ast_store_new(
1289 (ast_expression*)intrin->fold->imm_float[0]
1293 vec_push(block->exprs,
1294 (ast_expression*)ast_return_new(
1296 (ast_expression*)ast_binary_new(
1305 vec_push(func->blocks, block);
1306 intrin_reg(intrin, value, func);
1308 return (ast_expression*)value;
1311 static ast_expression *intrin_inf(intrin_t *intrin) {
1319 ast_value *value = NULL;
1320 ast_value *x = ast_value_new(intrin_ctx(intrin), "x", TYPE_FLOAT);
1321 ast_value *y = ast_value_new(intrin_ctx(intrin), "y", TYPE_FLOAT);
1322 ast_function *func = intrin_value(intrin, &value, "inf", TYPE_FLOAT);
1323 ast_block *block = ast_block_new(intrin_ctx(intrin));
1326 vec_push(block->locals, x);
1327 vec_push(block->locals, y);
1329 /* to keep code size down */
1330 for (i = 0; i <= 1; i++) {
1331 vec_push(block->exprs,
1332 (ast_expression*)ast_store_new(
1335 (ast_expression*)((i == 0) ? x : y),
1336 (ast_expression*)intrin->fold->imm_float[i]
1341 vec_push(block->exprs,
1342 (ast_expression*)ast_return_new(
1344 (ast_expression*)ast_binary_new(
1353 vec_push(func->blocks, block);
1354 intrin_reg(intrin, value, func);
1356 return (ast_expression*)value;
1359 static ast_expression *intrin_ln(intrin_t *intrin) {
1361 * float log(float power, float base) {
1364 * float sign = 1.0f;
1365 * float eps = epsilon();
1367 * if (power <= 1.0f || bbase <= 1.0) {
1368 * if (power <= 0.0f || base <= 0.0f)
1371 * if (power < 1.0f) {
1372 * power = 1.0f / power;
1376 * if (base < 1.0f) {
1378 * base = 1.0f / base;
1384 * float A_iminus1 = 0;
1385 * float B_iminus1 = 1;
1391 * while (whole >= base) {
1392 * float base2 = base;
1394 * float newbase2 = base2 * base2;
1396 * while (whole >= newbase2) {
1399 * newbase2 *= newbase2;
1406 * float b_iplus1 = n;
1407 * float A_iplus1 = b_iplus1 * A_i + A_iminus1;
1408 * float B_iplus1 = b_iplus1 * B_i + B_iminus1;
1415 * if (whole <= 1.0f + eps)
1421 * return sign * A_i / B_i;
1425 ast_value *value = NULL;
1426 ast_value *power = ast_value_new(intrin_ctx(intrin), "power", TYPE_FLOAT);
1427 ast_value *base = ast_value_new(intrin_ctx(intrin), "base", TYPE_FLOAT);
1428 ast_value *whole = ast_value_new(intrin_ctx(intrin), "whole", TYPE_FLOAT);
1429 ast_value *nth = ast_value_new(intrin_ctx(intrin), "nth", TYPE_FLOAT);
1430 ast_value *sign = ast_value_new(intrin_ctx(intrin), "sign", TYPE_FLOAT);
1431 ast_value *A_i = ast_value_new(intrin_ctx(intrin), "A_i", TYPE_FLOAT);
1432 ast_value *B_i = ast_value_new(intrin_ctx(intrin), "B_i", TYPE_FLOAT);
1433 ast_value *A_iminus1 = ast_value_new(intrin_ctx(intrin), "A_iminus1", TYPE_FLOAT);
1434 ast_value *B_iminus1 = ast_value_new(intrin_ctx(intrin), "B_iminus1", TYPE_FLOAT);
1435 ast_value *b_iplus1 = ast_value_new(intrin_ctx(intrin), "b_iplus1", TYPE_FLOAT);
1436 ast_value *A_iplus1 = ast_value_new(intrin_ctx(intrin), "A_iplus1", TYPE_FLOAT);
1437 ast_value *B_iplus1 = ast_value_new(intrin_ctx(intrin), "B_iplus1", TYPE_FLOAT);
1438 ast_value *eps = ast_value_new(intrin_ctx(intrin), "eps", TYPE_FLOAT);
1439 ast_value *base2 = ast_value_new(intrin_ctx(intrin), "base2", TYPE_FLOAT);
1440 ast_value *n2 = ast_value_new(intrin_ctx(intrin), "n2", TYPE_FLOAT);
1441 ast_value *newbase2 = ast_value_new(intrin_ctx(intrin), "newbase2", TYPE_FLOAT);
1442 ast_block *block = ast_block_new(intrin_ctx(intrin));
1443 ast_block *plt1orblt1 = ast_block_new(intrin_ctx(intrin)); /* (power <= 1.0f || base <= 1.0f) */
1444 ast_block *plt1 = ast_block_new(intrin_ctx(intrin)); /* (power < 1.0f) */
1445 ast_block *blt1 = ast_block_new(intrin_ctx(intrin)); /* (base < 1.0f) */
1446 ast_block *forloop = ast_block_new(intrin_ctx(intrin)); /* for(;;) */
1447 ast_block *whileloop = ast_block_new(intrin_ctx(intrin)); /* while (whole >= base) */
1448 ast_block *nestwhile = ast_block_new(intrin_ctx(intrin)); /* while (whole >= newbase2) */
1449 ast_function *func = intrin_value(intrin, &value, "ln", TYPE_FLOAT);
1452 vec_push(value->expression.params, power);
1453 vec_push(value->expression.params, base);
1455 vec_push(block->locals, whole);
1456 vec_push(block->locals, nth);
1457 vec_push(block->locals, sign);
1458 vec_push(block->locals, eps);
1459 vec_push(block->locals, A_i);
1460 vec_push(block->locals, B_i);
1461 vec_push(block->locals, A_iminus1);
1462 vec_push(block->locals, B_iminus1);
1465 vec_push(block->exprs,
1466 (ast_expression*)ast_store_new(
1469 (ast_expression*)sign,
1470 (ast_expression*)intrin->fold->imm_float[1]
1474 /* eps = __builtin_epsilon(); */
1475 vec_push(block->exprs,
1476 (ast_expression*)ast_store_new(
1479 (ast_expression*)eps,
1480 (ast_expression*)ast_call_new(
1482 intrin_func_self(intrin, "__builtin_epsilon", "ln")
1493 for (i = 0; i <= 1; i++) {
1495 for (j = 1; j >= 0; j--) {
1496 vec_push(block->exprs,
1497 (ast_expression*)ast_store_new(
1500 (ast_expression*)((j) ? ((i) ? B_iminus1 : A_i)
1501 : ((i) ? A_iminus1 : B_i)),
1502 (ast_expression*)intrin->fold->imm_float[j]
1510 * power = 1.0f / power;
1514 * base = 1.0f / base;
1518 for (i = 0; i <= 1; i++) {
1519 vec_push(((i) ? blt1 : plt1)->exprs,
1520 (ast_expression*)ast_store_new(
1523 (ast_expression*)((i) ? base : power),
1524 (ast_expression*)ast_binary_new(
1527 (ast_expression*)intrin->fold->imm_float[1],
1528 (ast_expression*)((i) ? base : power)
1532 vec_push(plt1->exprs,
1533 (ast_expression*)ast_binstore_new(
1537 (ast_expression*)sign,
1538 (ast_expression*)intrin->fold->imm_float[2]
1545 * if (power <= 0.0 || base <= 0.0f)
1546 * return __builtin_nan();
1553 vec_push(plt1orblt1->exprs,
1554 (ast_expression*)ast_ifthen_new(
1556 (ast_expression*)ast_binary_new(
1559 (ast_expression*)ast_binary_new(
1562 (ast_expression*)power,
1563 (ast_expression*)intrin->fold->imm_float[0]
1565 (ast_expression*)ast_binary_new(
1568 (ast_expression*)base,
1569 (ast_expression*)intrin->fold->imm_float[0]
1572 (ast_expression*)ast_return_new(
1574 (ast_expression*)ast_call_new(
1576 intrin_func_self(intrin, "__builtin_nan", "ln")
1583 for (i = 0; i <= 1; i++) {
1584 vec_push(plt1orblt1->exprs,
1585 (ast_expression*)ast_ifthen_new(
1587 (ast_expression*)ast_binary_new(
1590 (ast_expression*)((i) ? base : power),
1591 (ast_expression*)intrin->fold->imm_float[1]
1593 (ast_expression*)((i) ? blt1 : plt1),
1599 vec_push(block->exprs, (ast_expression*)plt1orblt1);
1602 /* whole = power; */
1603 vec_push(forloop->exprs,
1604 (ast_expression*)ast_store_new(
1607 (ast_expression*)whole,
1608 (ast_expression*)power
1613 vec_push(forloop->exprs,
1614 (ast_expression*)ast_store_new(
1617 (ast_expression*)nth,
1618 (ast_expression*)intrin->fold->imm_float[0]
1623 vec_push(whileloop->exprs,
1624 (ast_expression*)ast_store_new(
1627 (ast_expression*)base2,
1628 (ast_expression*)base
1633 vec_push(whileloop->exprs,
1634 (ast_expression*)ast_store_new(
1637 (ast_expression*)n2,
1638 (ast_expression*)intrin->fold->imm_float[1]
1642 /* newbase2 = base2 * base2; */
1643 vec_push(whileloop->exprs,
1644 (ast_expression*)ast_store_new(
1647 (ast_expression*)newbase2,
1648 (ast_expression*)ast_binary_new(
1651 (ast_expression*)base2,
1652 (ast_expression*)base2
1657 /* while loop locals */
1658 vec_push(whileloop->locals, base2);
1659 vec_push(whileloop->locals, n2);
1660 vec_push(whileloop->locals, newbase2);
1662 /* base2 = newbase2; */
1663 vec_push(nestwhile->exprs,
1664 (ast_expression*)ast_store_new(
1667 (ast_expression*)base2,
1668 (ast_expression*)newbase2
1673 vec_push(nestwhile->exprs,
1674 (ast_expression*)ast_binstore_new(
1678 (ast_expression*)n2,
1679 (ast_expression*)intrin->fold->imm_float[3] /* 2.0f */
1683 /* newbase2 *= newbase2; */
1684 vec_push(nestwhile->exprs,
1685 (ast_expression*)ast_binstore_new(
1689 (ast_expression*)newbase2,
1690 (ast_expression*)newbase2
1694 /* while (whole >= newbase2) */
1695 vec_push(whileloop->exprs,
1696 (ast_expression*)ast_loop_new(
1699 (ast_expression*)ast_binary_new(
1702 (ast_expression*)whole,
1703 (ast_expression*)newbase2
1709 (ast_expression*)nestwhile
1713 /* whole /= base2; */
1714 vec_push(whileloop->exprs,
1715 (ast_expression*)ast_binstore_new(
1719 (ast_expression*)whole,
1720 (ast_expression*)base2
1725 vec_push(whileloop->exprs,
1726 (ast_expression*)ast_binstore_new(
1730 (ast_expression*)nth,
1735 /* while (whole >= base) */
1736 vec_push(forloop->exprs,
1737 (ast_expression*)ast_loop_new(
1740 (ast_expression*)ast_binary_new(
1743 (ast_expression*)whole,
1744 (ast_expression*)base
1750 (ast_expression*)whileloop
1754 vec_push(forloop->locals, b_iplus1);
1755 vec_push(forloop->locals, A_iplus1);
1756 vec_push(forloop->locals, B_iplus1);
1758 /* b_iplus1 = nth; */
1759 vec_push(forloop->exprs,
1760 (ast_expression*)ast_store_new(
1763 (ast_expression*)b_iplus1,
1764 (ast_expression*)nth
1769 * A_iplus1 = b_iplus1 * A_i + A_iminus1;
1770 * B_iplus1 = b_iplus1 * B_i + B_iminus1;
1772 for (i = 0; i <= 1; i++) {
1773 vec_push(forloop->exprs,
1774 (ast_expression*)ast_store_new(
1777 (ast_expression*)((i) ? B_iplus1 : A_iplus1),
1778 (ast_expression*)ast_binary_new(
1781 (ast_expression*)ast_binary_new(
1784 (ast_expression*)b_iplus1,
1785 (ast_expression*) ((i) ? B_i : A_i)
1787 (ast_expression*)((i) ? B_iminus1 : A_iminus1)
1797 for (i = 0; i <= 1; i++) {
1798 vec_push(forloop->exprs,
1799 (ast_expression*)ast_store_new(
1802 (ast_expression*)((i) ? B_iminus1 : A_iminus1),
1803 (ast_expression*)((i) ? B_i : A_i)
1812 for (i = 0; i <= 1; i++) {
1813 vec_push(forloop->exprs,
1814 (ast_expression*)ast_store_new(
1817 (ast_expression*)((i) ? B_i : A_i),
1818 (ast_expression*)((i) ? B_iplus1 : A_iplus1)
1824 * if (whole <= 1.0f + eps)
1827 vec_push(forloop->exprs,
1828 (ast_expression*)ast_ifthen_new(
1830 (ast_expression*)ast_binary_new(
1833 (ast_expression*)whole,
1834 (ast_expression*)ast_binary_new(
1837 (ast_expression*)intrin->fold->imm_float[1],
1838 (ast_expression*)eps
1841 (ast_expression*)ast_breakcont_new(
1854 for (i = 0; i <= 1; i++) {
1855 vec_push(forloop->exprs,
1856 (ast_expression*)ast_store_new(
1859 (ast_expression*)((i) ? base : power),
1860 (ast_expression*)((i) ? whole : base)
1865 /* add the for loop block */
1866 vec_push(block->exprs,
1867 (ast_expression*)ast_loop_new(
1870 /* for(; 1; ) ?? (can this be NULL too?) */
1871 (ast_expression*)intrin->fold->imm_float[1],
1876 (ast_expression*)forloop
1880 /* return sign * A_i / B_il */
1881 vec_push(block->exprs,
1882 (ast_expression*)ast_return_new(
1884 (ast_expression*)ast_binary_new(
1887 (ast_expression*)sign,
1888 (ast_expression*)ast_binary_new(
1891 (ast_expression*)A_i,
1892 (ast_expression*)B_i
1898 vec_push(func->blocks, block);
1899 intrin_reg(intrin, value, func);
1901 return (ast_expression*)value;
1904 static ast_expression *intrin_log_variant(intrin_t *intrin, const char *name, float base) {
1905 ast_value *value = NULL;
1906 ast_call *callln = ast_call_new (intrin_ctx(intrin), intrin_func_self(intrin, "__builtin_ln", name));
1907 ast_value *arg1 = ast_value_new(intrin_ctx(intrin), "x", TYPE_FLOAT);
1908 ast_block *body = ast_block_new(intrin_ctx(intrin));
1909 ast_function *func = intrin_value(intrin, &value, name, TYPE_FLOAT);
1911 vec_push(value->expression.params, arg1);
1913 vec_push(callln->params, (ast_expression*)arg1);
1914 vec_push(callln->params, (ast_expression*)fold_constgen_float(intrin->fold, base));
1916 vec_push(body->exprs,
1917 (ast_expression*)ast_return_new(
1919 (ast_expression*)callln
1923 vec_push(func->blocks, body);
1924 intrin_reg(intrin, value, func);
1925 return (ast_expression*)value;
1928 static ast_expression *intrin_log(intrin_t *intrin) {
1929 return intrin_log_variant(intrin, "log", 2.7182818284590452354);
1931 static ast_expression *intrin_log10(intrin_t *intrin) {
1932 return intrin_log_variant(intrin, "log10", 10);
1934 static ast_expression *intrin_log2(intrin_t *intrin) {
1935 return intrin_log_variant(intrin, "log2", 2);
1937 static ast_expression *intrin_logb(intrin_t *intrin) {
1938 /* FLT_RADIX == 2 for now */
1939 return intrin_log_variant(intrin, "log2", 2);
1942 static ast_expression *intrin_shift_variant(intrin_t *intrin, const char *name, size_t instr) {
1943 ast_value *value = NULL;
1944 ast_call *callpow = ast_call_new (intrin_ctx(intrin), intrin_func_self(intrin, "pow", name));
1945 ast_value *a = ast_value_new(intrin_ctx(intrin), "a", TYPE_FLOAT);
1946 ast_value *b = ast_value_new(intrin_ctx(intrin), "b", TYPE_FLOAT);
1947 ast_block *body = ast_block_new(intrin_ctx(intrin));
1948 ast_function *func = intrin_value(intrin, &value, name, TYPE_FLOAT);
1950 vec_push(value->expression.params, a);
1951 vec_push(value->expression.params, b);
1953 vec_push(callpow->params, (ast_expression*)intrin->fold->imm_float[3]);
1954 vec_push(callpow->params, (ast_expression*)b);
1956 vec_push(body->exprs,
1957 (ast_expression*)ast_return_new(
1959 (ast_expression*)ast_binary_new(
1963 (ast_expression*)callpow
1968 vec_push(func->blocks, body);
1969 intrin_reg(intrin, value, func);
1970 return (ast_expression*)value;
1973 static ast_expression *intrin_lshift(intrin_t *intrin) {
1974 return intrin_shift_variant(intrin, "lshift", INSTR_MUL_F);
1977 static ast_expression *intrin_rshift(intrin_t *intrin) {
1978 return intrin_shift_variant(intrin, "rshift", INSTR_DIV_F);
1982 * TODO: make static (and handle ast_type_string) here for the builtin
1983 * instead of in SYA parse close.
1985 ast_expression *intrin_debug_typestring(intrin_t *intrin) {
1987 return (ast_expression*)0x1;
1990 static const intrin_func_t intrinsics[] = {
1991 {&intrin_isfinite, "__builtin_isfinite", "isfinite", 1},
1992 {&intrin_isinf, "__builtin_isinf", "isinf", 1},
1993 {&intrin_isnan, "__builtin_isnan", "isnan", 1},
1994 {&intrin_isnormal, "__builtin_isnormal", "isnormal", 1},
1995 {&intrin_signbit, "__builtin_signbit", "signbit", 1},
1996 {&intrin_acosh, "__builtin_acosh", "acosh", 1},
1997 {&intrin_asinh, "__builtin_asinh", "asinh", 1},
1998 {&intrin_atanh, "__builtin_atanh", "atanh", 1},
1999 {&intrin_exp, "__builtin_exp", "exp", 1},
2000 {&intrin_exp2, "__builtin_exp2", "exp2", 1},
2001 {&intrin_expm1, "__builtin_expm1", "expm1", 1},
2002 {&intrin_mod, "__builtin_mod", "mod", 2},
2003 {&intrin_pow, "__builtin_pow", "pow", 2},
2004 {&intrin_fabs, "__builtin_fabs", "fabs", 1},
2005 {&intrin_log, "__builtin_log", "log", 1},
2006 {&intrin_log10, "__builtin_log10", "log10", 1},
2007 {&intrin_log2, "__builtin_log2", "log2", 1},
2008 {&intrin_logb, "__builtin_logb", "logb", 1},
2009 {&intrin_lshift, "__builtin_lshift", "", 2},
2010 {&intrin_rshift, "__builtin_rshift", "", 2},
2011 {&intrin_epsilon, "__builtin_epsilon", "", 0},
2012 {&intrin_nan, "__builtin_nan", "", 0},
2013 {&intrin_inf, "__builtin_inf", "", 0},
2014 {&intrin_ln, "__builtin_ln", "", 2},
2015 {&intrin_debug_typestring, "__builtin_debug_typestring", "", 0},
2016 {&intrin_nullfunc, "#nullfunc", "", 0}
2019 static void intrin_error(intrin_t *intrin, const char *fmt, ...) {
2022 vcompile_error(intrin->parser->lex->tok.ctx, fmt, ap);
2027 intrin_t *intrin_init(parser_t *parser) {
2028 intrin_t *intrin = (intrin_t*)mem_a(sizeof(intrin_t));
2031 intrin->parser = parser;
2032 intrin->fold = parser->fold;
2033 intrin->intrinsics = NULL;
2034 intrin->generated = NULL;
2036 vec_append(intrin->intrinsics, GMQCC_ARRAY_COUNT(intrinsics), intrinsics);
2038 /* populate with null pointers for tracking generation */
2039 for (i = 0; i < GMQCC_ARRAY_COUNT(intrinsics); i++)
2040 vec_push(intrin->generated, NULL);
2045 void intrin_cleanup(intrin_t *intrin) {
2046 vec_free(intrin->intrinsics);
2047 vec_free(intrin->generated);
2051 ast_expression *intrin_fold(intrin_t *intrin, ast_value *value, ast_expression **exprs) {
2053 if (!value || !value->name)
2055 for (i = 0; i < vec_size(intrin->intrinsics); i++)
2056 if (!strcmp(value->name, intrin->intrinsics[i].name))
2057 return (vec_size(exprs) != intrin->intrinsics[i].args)
2059 : fold_intrin(intrin->fold, value->name + 10, exprs);
2063 static GMQCC_INLINE ast_expression *intrin_func_try(intrin_t *intrin, size_t offset, const char *compare) {
2065 for (i = 0; i < vec_size(intrin->intrinsics); i++) {
2066 if (strcmp(*(char **)((char *)&intrin->intrinsics[i] + offset), compare))
2068 if (intrin->generated[i])
2069 return intrin->generated[i];
2070 return intrin->generated[i] = intrin->intrinsics[i].intrin(intrin);
2075 static ast_expression *intrin_func_self(intrin_t *intrin, const char *name, const char *from) {
2077 ast_expression *find;
2079 /* try current first */
2080 if ((find = parser_find_global(intrin->parser, name)) && ((ast_value*)find)->expression.vtype == TYPE_FUNCTION)
2081 for (i = 0; i < vec_size(intrin->parser->functions); ++i)
2082 if (((ast_value*)find)->name && !strcmp(intrin->parser->functions[i]->name, ((ast_value*)find)->name) && intrin->parser->functions[i]->builtin < 0)
2084 /* try name second */
2085 if ((find = intrin_func_try(intrin, offsetof(intrin_func_t, name), name)))
2087 /* try alias third */
2088 if ((find = intrin_func_try(intrin, offsetof(intrin_func_t, alias), name)))
2092 intrin_error(intrin, "need function `%s', compiler depends on it for `__builtin_%s'", name, from);
2093 return intrin_func_self(intrin, "#nullfunc", NULL);
2098 ast_expression *intrin_func(intrin_t *intrin, const char *name) {
2099 return intrin_func_self(intrin, name, NULL);