ir_load.c

/*
 * IR - Lightweight JIT Compilation Framework
 * (IR loader)
 * This file is part of the IR Project distributed under the MIT-style LICENSE.
 * Authors: Dmitry Stogov <dmitry@php.net>
 *
 * This file is generated from "ir.g". Do not edit!
 *
 * To generate ir_load.c use llk <https://github.com/dstogov/llk>:
 * php llk.php ir.g
 */

#ifndef _GNU_SOURCE
# define _GNU_SOURCE
#endif

#include "ir.h"
#include "ir_private.h"
#include "ir_builder.h"

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <math.h>
#include <setjmp.h>
#ifndef _WIN32
# include <unistd.h>
#endif

#define IR_MAX_OPERANDS 512

const unsigned char *yy_buf;
const unsigned char *yy_end;
const unsigned char *yy_pos;
const unsigned char *yy_text;
uint32_t yy_line;

static jmp_buf yy_jmp_buf;

typedef struct _ir_parser_ctx {
	ir_ctx    *ctx;
	uint32_t   undef_count;
	bool       bad_insns; /* some insns that might affect folding had undefined operands */
	uint32_t   value_params_count;
	ir_ref     curr_ref;
	ir_strtab  var_tab;
} ir_parser_ctx;

static ir_parser_ctx *yy_ctx = NULL; /* we keep this global only to cleanum memory on syntax errors */
static ir_strtab op_tab;

#define IR_UNRESOLVED_MASK            0xc0000000
#define IR_UNRESOLVED_LIST_END        ((ir_ref)IR_UNRESOLVED_MASK)

#define IR_IS_UNRESOLVED(ref) \
	((ir_ref)(ref) <= (ir_ref)0xc0000000)
#define IR_ENCODE_UNRESOLVED_REF(ref, op) \
	((ir_ref)0xc0000000 - ((ref) * sizeof(ir_ref) + (op)))
#define IR_DECODE_UNRESOLVED_REF(ref) \
	((ir_ref)0xc0000000 - (ref))

#if defined(IR_TARGET_X64)
# define IR_SET_WIN64_CC(flags)  do {*flags |= IR_CC_X86_64_MS;} while (0)
# define IR_SET_SYSV_CC(flags)   do {*flags |= IR_CC_X86_64_SYSV;} while (0)
# define IR_SET_DARWIN_CC(flags) yy_error("__darwin calling-convention is not supported on this target")
#elif defined(IR_TARGET_AARCH64)
# define IR_SET_WIN64_CC(flags)  yy_error("__win64 calling-convention is not supported on this target")
# define IR_SET_SYSV_CC(flags)   do {*flags |= IR_CC_AARCH64_SYSV;} while (0)
# define IR_SET_DARWIN_CC(flags) do {*flags |= IR_CC_AARCH64_DARWIN;} while (0)
#else
# define IR_SET_WIN64_CC(flags)  yy_error("__win64 calling-convention is not supported on this target")
# define IR_SET_SYSV_CC(flags)   yy_error("__sysv calling-convention is not supported on this target")
# define IR_SET_DARWIN_CC(flags) yy_error("__darwin calling-convention is not supported on this target")
#endif

static ir_ref ir_use_var(ir_parser_ctx *p, uint32_t n, const char *str, size_t len) {
	ir_ref ref;
	uint32_t len32;

	IR_ASSERT(len <= 0xffffffff);
	len32 = (uint32_t)len;
	ref = ir_strtab_find(&p->var_tab, str, len32);
	if (!ref) {
		p->undef_count++;
		/* create a linked list of unresolved references with header in "var_tab" */
		ref = IR_UNRESOLVED_LIST_END; /* list terminator */
		ir_strtab_lookup(&p->var_tab, str, len32, IR_ENCODE_UNRESOLVED_REF(p->curr_ref, n));
	} else if (IR_IS_UNRESOLVED(ref)) {
		/* keep the linked list of unresolved references with header in "var_tab" */
		/* "ref" keeps the tail of the list */
		ir_strtab_update(&p->var_tab, str, len32, IR_ENCODE_UNRESOLVED_REF(p->curr_ref, n));
	}
	return ref;
}

static void ir_define_var(ir_parser_ctx *p, const char *str, size_t len, ir_ref ref) {
	ir_ref old_ref;
	uint32_t len32;

	IR_ASSERT(len <= 0xffffffff);
	len32 = (uint32_t)len;
	old_ref = ir_strtab_lookup(&p->var_tab, str, len32, ref);
	if (ref != old_ref) {
		if (IR_IS_UNRESOLVED(old_ref)) {
			IR_ASSERT(old_ref != IR_UNRESOLVED_LIST_END);
			p->undef_count--;
			/* update the linked list of unresolved references */
			do {
				ir_ref *ptr = ((ir_ref*)(p->ctx->ir_base)) + IR_DECODE_UNRESOLVED_REF(old_ref);
				old_ref = *ptr;
				*ptr = ref;
			} while (old_ref != IR_UNRESOLVED_LIST_END);
			ir_strtab_update(&p->var_tab, str, len32, ref);
		} else {
			fprintf(stderr, "ERROR: Redefined variable `%.*s` on line %d\n", (int)len32, str, yy_line);
			ir_strtab_free(&p->var_tab);
			ir_free(p->ctx);
			yy_ctx = NULL;
			longjmp(yy_jmp_buf, 2);
		}
	}
}

static void report_undefined_var(const char *str, uint32_t len, ir_str val)
{
	if (IR_IS_UNRESOLVED(val)) {
		fprintf(stderr, "ERROR: Undefined variable `%.*s`\n", (int)len, str);
	}
}

static void ir_check_indefined_vars(ir_parser_ctx *p)
{
	ir_strtab_apply(&p->var_tab, report_undefined_var);
	ir_strtab_free(&p->var_tab);
	ir_free(p->ctx);
	yy_ctx = NULL;
	longjmp(yy_jmp_buf, 2);
}

#if __has_attribute(format)
# define YY_PRINTF_FORMAT(fmt_pos, args_pos) __attribute__((format(printf, fmt_pos, args_pos)))
#else
# define YY_PRINTF_FORMAT(fmt_pos, args_pos)
#endif

/* forward declarations */
static void yy_error(const char *msg);
static void yy_error_sym(const char *msg, int sym);
static void yy_error_str(const char *msg, const char *str);
static void yy_error_fmt(const char *fmt, ...) YY_PRINTF_FORMAT(1, 2);
static void yy_error_const_type(const char *kind, ir_type t);

static char yy_unescape_char(const char *str, size_t *len)
{
	char ch;

	switch (*str) {
		case '\\': return '\\';
		case '\'': return '\'';
		case '"':  return '"';
		case 'a':  return '\a';
		case 'b':  return '\b';
		case 'e':  return 27; /* '\e'; */
		case 'f':  return '\f';
		case 'n':  return '\n';
		case 'r':  return '\r';
		case 't':  return '\t';
		case 'v':  return '\v';
		case '?':  return 0x3f;
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
			ch = *str - '0';
			str++;
			if (*str >= '0' && *str <= '7') {
				ch = ch * 8 + (*str - '0');
				str++;
				(*len)++;
				if (*str >= '0' && *str <= '7') {
					ch = ch * 8 + (*str - '0');
					str++;
					(*len)++;
				}
			}
			return ch;
		default:
			yy_error("unsupported escape sequence");
			return 0;
	}
}

static size_t yy_unescape_str(char *buf, const char *str, size_t len)
{
	char *p = buf;

	while (len > 0) {
		if (*str != '\\') {
			*p = *str;
		} else {
			size_t l;

			str++;
			len--;
			if (len == 0) {
				yy_error("bad escape sequence");
			}
			l = 1;
			*p = yy_unescape_char(str, &l);
			p++;
			str += l;
			len -= l;
			continue;
		}
		str++;
		p++;
		len--;
	}
	*p = 0;
	return p - buf;
}

static ir_ref ir_make_const_str(ir_ctx *ctx, const char *str, size_t len)
{
	char *buf = alloca(len + 1);

	len = yy_unescape_str(buf, str, len);
	return ir_const_str(ctx, ir_stringl(ctx, buf, len));
}

static bool ir_loader_sym_data_str(ir_loader *loader, const char *str, size_t len)
{
	char *buf = alloca(len + 1);

	len = yy_unescape_str(buf, str, len);
	return loader->sym_data_str(loader, buf, len);
}

static uint64_t read_dec(const char *p, const char *e)
{
	uint64_t ret;
	int neg = 0;
	char ch = *p;

	if (ch == '-') {
		ch = *(++p);
		neg = 1;
	}
	IR_ASSERT(ch >= '0' && ch <= '9');
	ret = ch - '0';
	while (++p < e) {
		ch = *p;
		IR_ASSERT(ch >= '0' && ch <= '9');
		ret = (ret * 10) + (ch - '0');
	}
	if (neg) {
		ret = ~ret + 1;
	}
	return ret;
}

static uint64_t read_hex(const char *p, const char *e)
{
	uint64_t ret = 0;
	char ch = *p;

	if (ch >= '0' && ch <= '9') {
		ret = ch - '0';
	} else if (ch >= 'a' && ch <= 'f') {
		ret = ch - 'a' + 10;
	} else {
		IR_ASSERT(ch >= 'A' && ch <= 'F');
		ret = ch - 'A' + 10;
	}
	while (++p < e) {
		ch = *p;
		if (ch >= '0' && ch <= '9') {
			ret = (ret << 4) | (ch - '0');
		} else if (ch >= 'a' && ch <= 'f') {
			ret = (ret << 4) | (ch - 'a' + 10);
		} else {
			IR_ASSERT(ch >= 'A' && ch <= 'F');
			ret = (ret << 4) | (ch - 'A' + 10);
		}
	}
	return ret;
}

static void ext_int_const(uint32_t t, ir_val *val)
{
	if (IR_IS_TYPE_INT(t) && ir_type_size[t] < 8) {
		val->u64 = ir_fix_int(t, val->u64);
	}
}

#define YYPOS cpos
#define YYEND cend

#define YY_EOF 0
#define YY_EXTERN 1
#define YY__SEMICOLON 2
#define YY_STATIC 3
#define YY__EQUAL 4
#define YY__LBRACE 5
#define YY__COMMA 6
#define YY__RBRACE 7
#define YY_VAR 8
#define YY_CONST 9
#define YY__LBRACK 10
#define YY__RBRACK 11
#define YY_SYM 12
#define YY__LPAREN 13
#define YY__RPAREN 14
#define YY__PLUS 15
#define YY_FUNC 16
#define YY_NOP 17
#define YY_VOID 18
#define YY__POINT_POINT_POINT 19
#define YY__COLON 20
#define YY___FASTCALL 21
#define YY___PRESERVE_NONE 22
#define YY___WIN64 23
#define YY___SYSV 24
#define YY___DARWIN 25
#define YY___BUILTIN 26
#define YY___PURE 27
#define YY___CONST 28
#define YY__STAR 29
#define YY_LABEL 30
#define YY__SLASH 31
#define YY_BYVAL 32
#define YY_BOOL 33
#define YY_UINT8_T 34
#define YY_UINT16_T 35
#define YY_UINT32_T 36
#define YY_UINT64_T 37
#define YY_UINTPTR_T 38
#define YY_CHAR 39
#define YY_INT8_T 40
#define YY_INT16_T 41
#define YY_INT32_T 42
#define YY_INT64_T 43
#define YY_DOUBLE 44
#define YY_FLOAT 45
#define YY__LESS 46
#define YY__GREATER 47
#define YY_NULL 48
#define YY_INF 49
#define YY_NAN 50
#define YY__MINUS 51
#define YY_ID 52
#define YY_DECNUMBER 53
#define YY_HEXNUMBER 54
#define YY_FLOATNUMBER 55
#define YY_CHARACTER 56
#define YY_STRING 57
#define YY_EOL 58
#define YY_WS 59
#define YY_ONE_LINE_COMMENT 60
#define YY_COMMENT 61

static const char * sym_name[] = {
	"<EOF>",
	"extern",
	";",
	"static",
	"=",
	"{",
	",",
	"}",
	"var",
	"const",
	"[",
	"]",
	"sym",
	"(",
	")",
	"+",
	"func",
	"NOP",
	"void",
	"...",
	":",
	"__fastcall",
	"__preserve_none",
	"__win64",
	"__sysv",
	"__darwin",
	"__builtin",
	"__pure",
	"__const",
	"*",
	"label",
	"/",
	"ByVal",
	"bool",
	"uint8_t",
	"uint16_t",
	"uint32_t",
	"uint64_t",
	"uintptr_t",
	"char",
	"int8_t",
	"int16_t",
	"int32_t",
	"int64_t",
	"double",
	"float",
	"<",
	">",
	"null",
	"inf",
	"nan",
	"-",
	"<ID>",
	"<DECNUMBER>",
	"<HEXNUMBER>",
	"<FLOATNUMBER>",
	"<CHARACTER>",
	"<STRING>",
	"<EOL>",
	"<WS>",
	"<ONE_LINE_COMMENT>",
	"<COMMENT>",
	NULL
};

size_t yy_escape(char *buf, int ch)
{
	switch (ch) {
		case '\\': buf[0] = '\\'; buf[1] = '\\'; return 2;
		case '\'': buf[0] = '\\'; buf[1] = '\''; return 2;
		case '\"': buf[0] = '\\'; buf[1] = '\"'; return 2;
		case '\a': buf[0] = '\\'; buf[1] = '\a'; return 2;
		case '\b': buf[0] = '\\'; buf[1] = '\b'; return 2;
		case 27:   buf[0] = '\\'; buf[1] = 27; return 2;
		case '\f': buf[0] = '\\'; buf[1] = '\f'; return 2;
		case '\n': buf[0] = '\\'; buf[1] = '\n'; return 2;
		case '\r': buf[0] = '\\'; buf[1] = '\r'; return 2;
		case '\t': buf[0] = '\\'; buf[1] = '\t'; return 2;
		case '\v': buf[0] = '\\'; buf[1] = '\v'; return 2;
		case '\?': buf[0] = '\\'; buf[1] = 0x3f; return 2;
		default: break;
	}
	if (ch < 32 || ch >= 127) {
		buf[0] = '\\';
		buf[1] = '0' + ((ch >> 6) % 8);
		buf[2] = '0' + ((ch >> 3) % 8);
		buf[3] = '0' + (ch % 8);
		return 4;
	} else {
		buf[0] = ch;
		return 1;
	}
}

const char *yy_escape_char(char *buf, int ch)
{
	size_t len = yy_escape(buf, ch);
	buf[len] = 0;
	return buf;
}

const char *yy_escape_string(char *buf, size_t size, const unsigned char *str, size_t n)
{
	size_t i = 0;
	size_t pos = 0;
	size_t len;

	while (i < n) {
		if (pos + 8 > size) {
			buf[pos++] = '.';
			buf[pos++] = '.';
			buf[pos++] = '.';
			break;
		}
		len = yy_escape(buf + pos, str[i]);
		i++;
		pos += len;
	}
	buf[pos] = 0;
	return buf;
}

#define YY_IN_SET(sym, set, bitset) \
	(bitset[sym>>3] & (1 << (sym & 0x7)))

static int parse_ir(int sym, ir_loader *loader);
static int parse_ir_sym(int sym, char *buf, uint32_t *flags);
static int parse_ir_sym_size(int sym, size_t *size);
static int parse_ir_sym_data(int sym, ir_loader *loader);
static int parse_ir_func(int sym, ir_parser_ctx *p);
static int parse_ir_func_name(int sym, char *buf);
static int parse_ir_func_proto(int sym, ir_parser_ctx *p, uint32_t *flags, uint8_t *ret_type, uint32_t *params_count, uint8_t *param_types);
static int parse_ir_insn(int sym, ir_parser_ctx *p);
static int parse_ir_modifier(int sym, ir_parser_ctx *p);
static int parse_simple_type(int sym, uint8_t *t);
static int parse_type(int sym, uint8_t *t);
static int parse_func(int sym, uint8_t *op);
static int parse_val(int sym, ir_parser_ctx *p, uint8_t op, uint32_t n, ir_ref *ref);
static int parse_const(int sym, uint8_t t, ir_val *val);
static int parse_ID(int sym, const char **str, size_t *len);
static int parse_DECNUMBER(int sym, uint32_t t, ir_val *val);
static int parse_HEXNUMBER(int sym, uint32_t t, ir_val *val);
static int parse_FLOATNUMBER(int sym, uint32_t t, ir_val *val);
static int parse_CHARACTER(int sym, uint32_t t, ir_val *val);
static int parse_STRING(int sym, const char **str, size_t *len);

static int get_sym(void) {
	char buf[64];
	int ch;
	int ret;
	int accept = -1;
	const unsigned char *accept_pos;
	const unsigned char *cpos = yy_pos;
	const unsigned char *cend = yy_end;

_yy_state_start:
	yy_text = YYPOS;
	ch = *YYPOS;
	switch (ch) {
		case 'e':
			ch = *++YYPOS;
			if (ch != 'x') goto _yy_tunnel_5;
			ch = *++YYPOS;
			if (ch != 't') goto _yy_tunnel_5;
			ch = *++YYPOS;
			if (ch != 'e') goto _yy_tunnel_5;
			ch = *++YYPOS;
			if (ch != 'r') goto _yy_tunnel_5;
			ch = *++YYPOS;
			if (ch != 'n') goto _yy_tunnel_5;
			ret = YY_EXTERN;
			goto _yy_state_226;
		case 'v':
			ch = *++YYPOS;
			if (ch == 'a') {
				ch = *++YYPOS;
				if (ch != 'r') goto _yy_tunnel_5;
				ret = YY_VAR;
				goto _yy_state_226;
			} else if (ch == 'o') {
				ch = *++YYPOS;
				if (ch != 'i') goto _yy_tunnel_5;
				ch = *++YYPOS;
				if (ch != 'd') goto _yy_tunnel_5;
				ret = YY_VOID;
				goto _yy_state_226;
			} else {
				goto _yy_tunnel_5;
			}
		case 'c':
			ch = *++YYPOS;
			if (ch == 'o') {
				ch = *++YYPOS;
				if (ch != 'n') goto _yy_tunnel_5;
				ch = *++YYPOS;
				if (ch != 's') goto _yy_tunnel_5;
				ch = *++YYPOS;
				if (ch != 't') goto _yy_tunnel_5;
				ret = YY_CONST;
				goto _yy_state_226;
			} else if (ch == 'h') {
				ch = *++YYPOS;
				if (ch != 'a') goto _yy_tunnel_5;
				ch = *++YYPOS;
				if (ch != 'r') goto _yy_tunnel_5;
				ret = YY_CHAR;
				goto _yy_state_226;
			} else {
				goto _yy_tunnel_5;
			}
		case '@':
			ch = *++YYPOS;
			if (ch == '$' || (ch >= 'A' && ch <= 'Z') || ch == '_' || (ch >= 'a' && ch <= 'z')) {
				goto _yy_state_5;
			} else {
				goto _yy_state_error;
			}
		case 'A':
		case 'C':
		case 'D':
		case 'E':
		case 'F':
		case 'G':
		case 'H':
		case 'I':
		case 'J':
		case 'K':
		case 'L':
		case 'M':
		case 'O':
		case 'P':
		case 'Q':
		case 'R':
		case 'S':
		case 'T':
		case 'U':
		case 'V':
		case 'W':
		case 'X':
		case 'Y':
		case 'Z':
		case 'a':
		case 'g':
		case 'h':
		case 'j':
		case 'k':
		case 'm':
		case 'o':
		case 'p':
		case 'q':
		case 'r':
		case 't':
		case 'w':
		case 'x':
		case 'y':
		case 'z':
		case '$':
			goto _yy_state_5;
		case 'B':
			ch = *++YYPOS;
			if (ch != 'y') goto _yy_tunnel_5;
			ch = *++YYPOS;
			if (ch != 'V') goto _yy_tunnel_5;
			ch = *++YYPOS;
			if (ch != 'a') goto _yy_tunnel_5;
			ch = *++YYPOS;
			if (ch != 'l') goto _yy_tunnel_5;
			ret = YY_BYVAL;
			goto _yy_state_226;
		case 'N':
			ch = *++YYPOS;
			if (ch != 'O') goto _yy_tunnel_5;
			ch = *++YYPOS;
			if (ch != 'P') goto _yy_tunnel_5;
			ret = YY_NOP;
			goto _yy_state_226;
		case 'b':
			ch = *++YYPOS;
			if (ch != 'o') goto _yy_tunnel_5;
			ch = *++YYPOS;
			if (ch != 'o') goto _yy_tunnel_5;
			ch = *++YYPOS;
			if (ch != 'l') goto _yy_tunnel_5;
			ret = YY_BOOL;
			goto _yy_state_226;
		case 'd':
			ch = *++YYPOS;
			if (ch != 'o') goto _yy_tunnel_5;
			ch = *++YYPOS;
			if (ch != 'u') goto _yy_tunnel_5;
			ch = *++YYPOS;
			if (ch != 'b') goto _yy_tunnel_5;
			ch = *++YYPOS;
			if (ch != 'l') goto _yy_tunnel_5;
			ch = *++YYPOS;
			if (ch != 'e') goto _yy_tunnel_5;
			ret = YY_DOUBLE;
			goto _yy_state_226;
		case 'f':
			ch = *++YYPOS;
			if (ch == 'l') {
				ch = *++YYPOS;
				if (ch != 'o') goto _yy_tunnel_5;
				ch = *++YYPOS;
				if (ch != 'a') goto _yy_tunnel_5;
				ch = *++YYPOS;
				if (ch != 't') goto _yy_tunnel_5;
				ret = YY_FLOAT;
				goto _yy_state_226;
			} else if (ch == 'u') {
				ch = *++YYPOS;
				if (ch != 'n') goto _yy_tunnel_5;
				ch = *++YYPOS;
				if (ch != 'c') goto _yy_tunnel_5;
				ret = YY_FUNC;
				goto _yy_state_226;
			} else {
				goto _yy_tunnel_5;
			}
		case 'i':
			ch = *++YYPOS;
			if (ch != 'n') goto _yy_tunnel_5;
			ch = *++YYPOS;
			if (ch == 'f') {
				ret = YY_INF;
				goto _yy_state_226;
			} else if (ch == 't') {
				ch = *++YYPOS;
				if (ch == '1') {
					ch = *++YYPOS;
					if (ch != '6') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != '_') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != 't') goto _yy_tunnel_5;
					ret = YY_INT16_T;
					goto _yy_state_226;
				} else if (ch == '3') {
					ch = *++YYPOS;
					if (ch != '2') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != '_') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != 't') goto _yy_tunnel_5;
					ret = YY_INT32_T;
					goto _yy_state_226;
				} else if (ch == '6') {
					ch = *++YYPOS;
					if (ch != '4') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != '_') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != 't') goto _yy_tunnel_5;
					ret = YY_INT64_T;
					goto _yy_state_226;
				} else if (ch == '8') {
					ch = *++YYPOS;
					if (ch != '_') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != 't') goto _yy_tunnel_5;
					ret = YY_INT8_T;
					goto _yy_state_226;
				} else {
					goto _yy_tunnel_5;
				}
			} else {
				goto _yy_tunnel_5;
			}
		case 'l':
			ch = *++YYPOS;
			if (ch != 'a') goto _yy_tunnel_5;
			ch = *++YYPOS;
			if (ch != 'b') goto _yy_tunnel_5;
			ch = *++YYPOS;
			if (ch != 'e') goto _yy_tunnel_5;
			ch = *++YYPOS;
			if (ch != 'l') goto _yy_tunnel_5;
			ret = YY_LABEL;
			goto _yy_state_226;
		case 'n':
			ch = *++YYPOS;
			if (ch == 'a') {
				ch = *++YYPOS;
				if (ch != 'n') goto _yy_tunnel_5;
				ret = YY_NAN;
				goto _yy_state_226;
			} else if (ch == 'u') {
				ch = *++YYPOS;
				if (ch != 'l') goto _yy_tunnel_5;
				ch = *++YYPOS;
				if (ch != 'l') goto _yy_tunnel_5;
				ret = YY_NULL;
				goto _yy_state_226;
			} else {
				goto _yy_tunnel_5;
			}
		case 's':
			ch = *++YYPOS;
			if (ch == 't') {
				ch = *++YYPOS;
				if (ch != 'a') goto _yy_tunnel_5;
				ch = *++YYPOS;
				if (ch != 't') goto _yy_tunnel_5;
				ch = *++YYPOS;
				if (ch != 'i') goto _yy_tunnel_5;
				ch = *++YYPOS;
				if (ch != 'c') goto _yy_tunnel_5;
				ret = YY_STATIC;
				goto _yy_state_226;
			} else if (ch == 'y') {
				ch = *++YYPOS;
				if (ch != 'm') goto _yy_tunnel_5;
				ret = YY_SYM;
				goto _yy_state_226;
			} else {
				goto _yy_tunnel_5;
			}
		case 'u':
			ch = *++YYPOS;
			if (ch != 'i') goto _yy_tunnel_5;
			ch = *++YYPOS;
			if (ch != 'n') goto _yy_tunnel_5;
			ch = *++YYPOS;
			if (ch != 't') goto _yy_tunnel_5;
			ch = *++YYPOS;
			switch (ch) {
				case 'p':
					ch = *++YYPOS;
					if (ch != 't') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != 'r') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != '_') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != 't') goto _yy_tunnel_5;
					ret = YY_UINTPTR_T;
					goto _yy_state_226;
				case '1':
					ch = *++YYPOS;
					if (ch != '6') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != '_') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != 't') goto _yy_tunnel_5;
					ret = YY_UINT16_T;
					goto _yy_state_226;
				case '3':
					ch = *++YYPOS;
					if (ch != '2') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != '_') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != 't') goto _yy_tunnel_5;
					ret = YY_UINT32_T;
					goto _yy_state_226;
				case '6':
					ch = *++YYPOS;
					if (ch != '4') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != '_') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != 't') goto _yy_tunnel_5;
					ret = YY_UINT64_T;
					goto _yy_state_226;
				case '8':
					ch = *++YYPOS;
					if (ch != '_') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != 't') goto _yy_tunnel_5;
					ret = YY_UINT8_T;
					goto _yy_state_226;
				default:
					goto _yy_tunnel_5;
			}
		case '_':
			ch = *++YYPOS;
			if (ch != '_') goto _yy_tunnel_5;
			ch = *++YYPOS;
			switch (ch) {
				case 'b':
					ch = *++YYPOS;
					if (ch != 'u') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != 'i') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != 'l') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != 't') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != 'i') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != 'n') goto _yy_tunnel_5;
					ret = YY___BUILTIN;
					goto _yy_state_226;
				case 'c':
					ch = *++YYPOS;
					if (ch != 'o') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != 'n') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != 's') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != 't') goto _yy_tunnel_5;
					ret = YY___CONST;
					goto _yy_state_226;
				case 'd':
					ch = *++YYPOS;
					if (ch != 'a') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != 'r') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != 'w') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != 'i') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != 'n') goto _yy_tunnel_5;
					ret = YY___DARWIN;
					goto _yy_state_226;
				case 'f':
					ch = *++YYPOS;
					if (ch != 'a') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != 's') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != 't') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != 'c') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != 'a') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != 'l') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != 'l') goto _yy_tunnel_5;
					ret = YY___FASTCALL;
					goto _yy_state_226;
				case 'p':
					ch = *++YYPOS;
					if (ch == 'r') {
						ch = *++YYPOS;
						if (ch != 'e') goto _yy_tunnel_5;
						ch = *++YYPOS;
						if (ch != 's') goto _yy_tunnel_5;
						ch = *++YYPOS;
						if (ch != 'e') goto _yy_tunnel_5;
						ch = *++YYPOS;
						if (ch != 'r') goto _yy_tunnel_5;
						ch = *++YYPOS;
						if (ch != 'v') goto _yy_tunnel_5;
						ch = *++YYPOS;
						if (ch != 'e') goto _yy_tunnel_5;
						ch = *++YYPOS;
						if (ch != '_') goto _yy_tunnel_5;
						ch = *++YYPOS;
						if (ch != 'n') goto _yy_tunnel_5;
						ch = *++YYPOS;
						if (ch != 'o') goto _yy_tunnel_5;
						ch = *++YYPOS;
						if (ch != 'n') goto _yy_tunnel_5;
						ch = *++YYPOS;
						if (ch != 'e') goto _yy_tunnel_5;
						ret = YY___PRESERVE_NONE;
						goto _yy_state_226;
					} else if (ch == 'u') {
						ch = *++YYPOS;
						if (ch != 'r') goto _yy_tunnel_5;
						ch = *++YYPOS;
						if (ch != 'e') goto _yy_tunnel_5;
						ret = YY___PURE;
						goto _yy_state_226;
					} else {
						goto _yy_tunnel_5;
					}
				case 's':
					ch = *++YYPOS;
					if (ch != 'y') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != 's') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != 'v') goto _yy_tunnel_5;
					ret = YY___SYSV;
					goto _yy_state_226;
				case 'w':
					ch = *++YYPOS;
					if (ch != 'i') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != 'n') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != '6') goto _yy_tunnel_5;
					ch = *++YYPOS;
					if (ch != '4') goto _yy_tunnel_5;
					ret = YY___WIN64;
					goto _yy_state_226;
				default:
					goto _yy_tunnel_5;
			}
		case ';':
			YYPOS++;
			ret = YY__SEMICOLON;
			goto _yy_fin;
		case '(':
			YYPOS++;
			ret = YY__LPAREN;
			goto _yy_fin;
		case '.':
			ch = *++YYPOS;
			if (ch == '.') {
				ch = *++YYPOS;
				if (ch == '.') {
					YYPOS++;
					ret = YY__POINT_POINT_POINT;
					goto _yy_fin;
				} else {
					goto _yy_state_error;
				}
			} else if ((ch >= '0' && ch <= '9')) {
				goto _yy_state_64;
			} else {
				goto _yy_state_error;
			}
		case '<':
			YYPOS++;
			ret = YY__LESS;
			goto _yy_fin;
		case '*':
			YYPOS++;
			ret = YY__STAR;
			goto _yy_fin;
		case '-':
			ch = *++YYPOS;
			accept = YY__MINUS;
			accept_pos = YYPOS;
			if ((ch >= '0' && ch <= '9')) {
				goto _yy_state_24;
			} else if (ch == '.') {
				ch = *++YYPOS;
				if ((ch >= '0' && ch <= '9')) {
					goto _yy_state_64;
				} else {
					goto _yy_state_error;
				}
			} else {
				ret = YY__MINUS;
				goto _yy_fin;
			}
		case '0':
			ch = *++YYPOS;
			if (ch != 'x') goto _yy_tunnel_24;
			ch = *++YYPOS;
			if ((ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'F') || (ch >= 'a' && ch <= 'f')) {
				goto _yy_state_109;
			} else {
				goto _yy_state_error;
			}
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
			goto _yy_state_24;
		case '>':
			YYPOS++;
			ret = YY__GREATER;
			goto _yy_fin;
		case ',':
			YYPOS++;
			ret = YY__COMMA;
			goto _yy_fin;
		case ')':
			YYPOS++;
			ret = YY__RPAREN;
			goto _yy_fin;
		case ':':
			YYPOS++;
			ret = YY__COLON;
			goto _yy_fin;
		case '[':
			YYPOS++;
			ret = YY__LBRACK;
			goto _yy_fin;
		case ']':
			YYPOS++;
			ret = YY__RBRACK;
			goto _yy_fin;
		case '=':
			YYPOS++;
			ret = YY__EQUAL;
			goto _yy_fin;
		case '{':
			YYPOS++;
			ret = YY__LBRACE;
			goto _yy_fin;
		case '+':
			YYPOS++;
			ret = YY__PLUS;
			goto _yy_fin;
		case '\'':
			goto _yy_state_34;
		case '}':
			YYPOS++;
			ret = YY__RBRACE;
			goto _yy_fin;
		case '"':
			goto _yy_state_36;
		case '/':
			ch = *++YYPOS;
			accept = YY__SLASH;
			accept_pos = YYPOS;
			if (ch == '*') {
				goto _yy_state_76;
			} else if (ch == '/') {
				goto _yy_state_41;
			} else {
				ret = YY__SLASH;
				goto _yy_fin;
			}
		case '\r':
			ch = *++YYPOS;
			if (ch == '\n') {
				yy_line++;
				YYPOS++;
				goto _yy_state_start;
			} else {
				goto _yy_state_start;
			}
		case '\n':
			yy_line++;
			YYPOS++;
			goto _yy_state_start;
		case ' ':
		case '\t':
		case '\f':
		case '\v':
			goto _yy_state_40;
		case '#':
			goto _yy_state_41;
		case '\0':
			if (ch == 0 && YYPOS < YYEND) goto _yy_state_error;
			YYPOS++;
			ret = YY_EOF;
			goto _yy_fin;
		default:
			goto _yy_state_error;
	}
_yy_state_5:
	ch = *++YYPOS;
_yy_tunnel_5:
	if (ch == '$' || ch == '.' || (ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'Z') || ch == '_' || (ch >= 'a' && ch <= 'z')) {
		goto _yy_state_5;
	} else {
		ret = YY_ID;
		goto _yy_fin;
	}
_yy_state_24:
	ch = *++YYPOS;
_yy_tunnel_24:
	accept = YY_DECNUMBER;
	accept_pos = YYPOS;
	if ((ch >= '0' && ch <= '9')) {
		goto _yy_state_24;
	} else if (ch == 'E' || ch == 'e') {
		goto _yy_state_68;
	} else if (ch == '.') {
		goto _yy_state_64;
	} else {
		ret = YY_DECNUMBER;
		goto _yy_fin;
	}
_yy_state_34:
	ch = *++YYPOS;
	if (ch == '\\') {
		ch = *++YYPOS;
		if (YYPOS < YYEND) {
			if (ch == '\n') {
				yy_line++;
			}
			goto _yy_state_34;
		} else {
			goto _yy_state_error;
		}
	} else if (ch == '\'') {
		YYPOS++;
		ret = YY_CHARACTER;
		goto _yy_fin;
	} else if (YYPOS < YYEND && (ch <= '&' || (ch >= '(' && ch <= '[') || ch >= ']')) {
		if (ch == '\n') {
			yy_line++;
		}
		goto _yy_state_34;
	} else {
		goto _yy_state_error;
	}
_yy_state_36:
	ch = *++YYPOS;
	if (ch == '\\') {
		ch = *++YYPOS;
		if (YYPOS < YYEND) {
			if (ch == '\n') {
				yy_line++;
			}
			goto _yy_state_36;
		} else {
			goto _yy_state_error;
		}
	} else if (ch == '"') {
		YYPOS++;
		ret = YY_STRING;
		goto _yy_fin;
	} else if (YYPOS < YYEND && (ch <= '!' || (ch >= '#' && ch <= '[') || ch >= ']')) {
		if (ch == '\n') {
			yy_line++;
		}
		goto _yy_state_36;
	} else {
		goto _yy_state_error;
	}
_yy_state_40:
	ch = *++YYPOS;
	if (ch == '\t' || ch == '\v' || ch == '\f' || ch == ' ') {
		goto _yy_state_40;
	} else {
		goto _yy_state_start;
	}
_yy_state_41:
	ch = *++YYPOS;
	if (ch == '\r') {
		ch = *++YYPOS;
		if (ch == '\n') {
			yy_line++;
			YYPOS++;
			goto _yy_state_start;
		} else {
			goto _yy_state_start;
		}
	} else if (ch == '\n') {
		yy_line++;
		YYPOS++;
		goto _yy_state_start;
	} else if (YYPOS < YYEND && (ch <= '\t' || ch == '\v' || ch == '\f' || ch >= '\016')) {
		goto _yy_state_41;
	} else {
		goto _yy_state_error;
	}
_yy_state_64:
	ch = *++YYPOS;
	accept = YY_FLOATNUMBER;
	accept_pos = YYPOS;
	if ((ch >= '0' && ch <= '9')) {
		goto _yy_state_64;
	} else if (ch == 'E' || ch == 'e') {
		goto _yy_state_68;
	} else {
		ret = YY_FLOATNUMBER;
		goto _yy_fin;
	}
_yy_state_68:
	ch = *++YYPOS;
	if (ch == '+' || ch == '-') {
		ch = *++YYPOS;
		if ((ch >= '0' && ch <= '9')) {
			goto _yy_state_112;
		} else {
			goto _yy_state_error;
		}
	} else if ((ch >= '0' && ch <= '9')) {
		goto _yy_state_112;
	} else {
		goto _yy_state_error;
	}
_yy_state_76:
	ch = *++YYPOS;
_yy_tunnel_76:
	if (ch == '*') {
		ch = *++YYPOS;
		if (ch != '/') goto _yy_tunnel_76;
		YYPOS++;
		goto _yy_state_start;
	} else if (YYPOS < YYEND && (ch <= ')' || ch >= '+')) {
		if (ch == '\n') {
			yy_line++;
		}
		goto _yy_state_76;
	} else {
		goto _yy_state_error;
	}
_yy_state_109:
	ch = *++YYPOS;
	if ((ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'F') || (ch >= 'a' && ch <= 'f')) {
		goto _yy_state_109;
	} else {
		ret = YY_HEXNUMBER;
		goto _yy_fin;
	}
_yy_state_112:
	ch = *++YYPOS;
	if ((ch >= '0' && ch <= '9')) {
		goto _yy_state_112;
	} else {
		ret = YY_FLOATNUMBER;
		goto _yy_fin;
	}
_yy_state_226:
	ch = *++YYPOS;
	if (ch == '$' || ch == '.' || (ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'Z') || ch == '_' || (ch >= 'a' && ch <= 'z')) {
		goto _yy_state_5;
	} else {
		goto _yy_fin;
	}
_yy_state_error:
	if (accept >= 0) {
		yy_pos = accept_pos;
		return accept;
	}
	if (YYPOS >= YYEND) {
		yy_error("unexpected <EOF>");
	} else if (YYPOS == yy_text) {
		yy_error_str("unexpected character",  yy_escape_char(buf, ch));
	} else {
		yy_error_str("unexpected sequence", yy_escape_string(buf, sizeof(buf), yy_text, 1 + YYPOS - yy_text));
	}
	YYPOS++;
	goto _yy_state_start;
_yy_fin:
	yy_pos = YYPOS;
	return ret;
}

static int parse_ir(int sym, ir_loader *loader) {
	int   sym2;
	const unsigned char *save_pos;
	const unsigned char *save_text;
	int save_line;
	int alt13;
	int alt9;
	ir_parser_ctx p;
	ir_ctx ctx;
	uint8_t ret_type;
	char name[256];
	uint32_t flags = 0;
	size_t size;
	uint32_t params_count;
	uint8_t param_types[256];
	p.ctx = &ctx;
	const char *str;
	size_t len;
	if (YY_IN_SET(sym, (YY_EXTERN,YY_STATIC,YY_VAR,YY_CONST,YY_FUNC), "\012\003\001\000\000\000\000\000")) {
		do {
			if (sym == YY_EXTERN) {
				sym = get_sym();
				flags = 0;
				if (sym == YY_VAR || sym == YY_CONST) {
					sym = parse_ir_sym(sym, name, &flags);
					if (sym != YY__SEMICOLON) {
						yy_error_sym("';' expected, got", sym);
					}
					sym = get_sym();
					if (loader->external_sym_dcl
					 && !loader->external_sym_dcl(loader, name, flags)) {
						yy_error_str("Unresolved extrnal symbol", name);
					}
				} else if (sym == YY_FUNC) {
					flags = 0;
					sym = parse_ir_func_name(sym, name);
					sym = parse_ir_func_proto(sym, &p, &flags, &ret_type, &params_count, param_types);
					if (sym != YY__SEMICOLON) {
						yy_error_sym("';' expected, got", sym);
					}
					sym = get_sym();
					if (loader->external_func_dcl
					 && !loader->external_func_dcl(loader, name, flags, ret_type, params_count, param_types)) {
						yy_error_str("Unresolved extenral function", name);
					}
				} else {
					yy_error_sym("unexpected", sym);
				}
			} else if (sym == YY_STATIC || sym == YY_VAR || sym == YY_CONST || sym == YY_FUNC) {
				flags = 0;
				if (sym == YY_STATIC) {
					sym = get_sym();
					flags |= IR_STATIC;
				}
				if (sym == YY_VAR || sym == YY_CONST) {
					sym = parse_ir_sym(sym, name, &flags);
					sym = parse_ir_sym_size(sym, &size);
					save_pos  = yy_pos;
					save_text = yy_text;
					save_line = yy_line;
					alt9 = -2;
					sym2 = sym;
					if (sym2 == YY__SEMICOLON) {
						alt9 = 10;
						goto _yy_state_9;
					} else if (sym2 == YY__EQUAL) {
						sym2 = get_sym();
						goto _yy_state_9_2;
					} else {
						yy_error_sym("unexpected", sym2);
					}
_yy_state_9_2:
					if (sym2 == YY__LBRACE) {
						alt9 = 11;
						goto _yy_state_9;
					} else if (sym2 == YY_STRING) {
						alt9 = 19;
						goto _yy_state_9;
					} else {
						yy_error_sym("unexpected", sym2);
					}
_yy_state_9:
					yy_pos  = save_pos;
					yy_text = save_text;
					yy_line = save_line;
					if (alt9 == 10) {
						if (loader->sym_dcl && !loader->sym_dcl(loader, name, flags, size)) {
							yy_error("sym_dcl error");
						}
						sym = get_sym();
					} else if (alt9 == 11) {
						flags |= IR_INITIALIZED;
						if (loader->sym_dcl && !loader->sym_dcl(loader, name, flags, size)) {
							yy_error("sym_dcl error");
						}
						sym = get_sym();
						if (sym != YY__LBRACE) {
							yy_error_sym("'{' expected, got", sym);
						}
						sym = get_sym();
						if (YY_IN_SET(sym, (YY_BOOL,YY_UINT8_T,YY_UINT16_T,YY_UINT32_T,YY_UINT64_T,YY_UINTPTR_T,YY_CHAR,YY_INT8_T,YY_INT16_T,YY_INT32_T,YY_INT64_T,YY_DOUBLE,YY_FLOAT,YY__LESS), "\000\000\000\000\376\177\000\000")) {
							sym = parse_ir_sym_data(sym, loader);
							while (1) {
								save_pos  = yy_pos;
								save_text = yy_text;
								save_line = yy_line;
								alt13 = -2;
								sym2 = sym;
								if (sym2 == YY__COMMA) {
									sym2 = get_sym();
									goto _yy_state_13_1;
								} else if (sym2 == YY__RBRACE) {
									alt13 = 17;
									goto _yy_state_13;
								} else {
									yy_error_sym("unexpected", sym2);
								}
_yy_state_13_1:
								if (YY_IN_SET(sym2, (YY__LESS,YY_BOOL,YY_UINT8_T,YY_UINT16_T,YY_UINT32_T,YY_UINT64_T,YY_UINTPTR_T,YY_CHAR,YY_INT8_T,YY_INT16_T,YY_INT32_T,YY_INT64_T,YY_DOUBLE,YY_FLOAT), "\000\000\000\000\376\177\000\000")) {
									alt13 = 14;
									goto _yy_state_13;
								} else if (sym2 == YY__RBRACE) {
									alt13 = 16;
									goto _yy_state_13;
								} else {
									yy_error_sym("unexpected", sym2);
								}
_yy_state_13:
								yy_pos  = save_pos;
								yy_text = save_text;
								yy_line = save_line;
								if (alt13 != 14) {
									break;
								}
								sym = get_sym();
								sym = parse_ir_sym_data(sym, loader);
							}
							if (alt13 == 16) {
								sym = get_sym();
							}
						}
						if (sym != YY__RBRACE) {
							yy_error_sym("'}' expected, got", sym);
						}
						sym = get_sym();
						if (sym != YY__SEMICOLON) {
							yy_error_sym("';' expected, got", sym);
						}
						sym = get_sym();
						if (loader->sym_data_end && !loader->sym_data_end(loader, flags)) {
							yy_error("sym_data_end error");
						}
					} else if (alt9 == 19) {
						flags |= IR_INITIALIZED | IR_CONST_STRING;
						if (loader->sym_dcl && !loader->sym_dcl(loader, name, flags, size)) {
							yy_error("sym_dcl error");
						}
						sym = get_sym();
						sym = parse_STRING(sym, &str, &len);
						if (sym != YY__SEMICOLON) {
							yy_error_sym("';' expected, got", sym);
						}
						sym = get_sym();
						if (loader->sym_data_str && !ir_loader_sym_data_str(loader, str, len)) {
							yy_error("sym_data_str error");
						}
						if (loader->sym_data_end && !loader->sym_data_end(loader, flags)) {
							yy_error("sym_data_end error");
						}
					} else {
						yy_error_sym("unexpected", sym);
					}
				} else if (sym == YY_FUNC) {
					sym = parse_ir_func_name(sym, name);
					sym = parse_ir_func_proto(sym, &p, &flags, &ret_type, &params_count, param_types);
					if (sym == YY__SEMICOLON) {
						sym = get_sym();
						if (loader->forward_func_dcl
						 && !loader->forward_func_dcl(loader, name, flags, ret_type, params_count, param_types)) {
							yy_error("forward_func_decl error");
						}
					} else if (sym == YY__LBRACE) {
						if (!loader->func_init(loader, &ctx, name)) yy_error("init_func error");
						ctx.flags |= flags;
						ctx.ret_type = ret_type;
						sym = parse_ir_func(sym, &p);
						if (!ir_check_prototype(&ctx, flags, ret_type, params_count, param_types)) {
							ir_free(&ctx);
							yy_error_str("function signature mismatch for", name);
						}
						bool ok = loader->func_process(loader, &ctx, name);
						ir_free(&ctx);
						if (!ok) yy_error("process_func error");
					} else {
						yy_error_sym("unexpected", sym);
					}
				} else {
					yy_error_sym("unexpected", sym);
				}
			} else {
				yy_error_sym("unexpected", sym);
			}
		} while (YY_IN_SET(sym, (YY_EXTERN,YY_STATIC,YY_VAR,YY_CONST,YY_FUNC), "\012\003\001\000\000\000\000\000"));
	} else if (sym == YY__LBRACE) {
		if (!loader->func_init(loader, &ctx, NULL)) yy_error("ini_func error");
		ctx.ret_type = -1;
		sym = parse_ir_func(sym, &p);
		bool ok = loader->func_process(loader, &ctx, NULL);
		ir_free(&ctx);
		if (!ok) yy_error("process_func error");
	} else {
		yy_error_sym("unexpected", sym);
	}
	return sym;
}

static int parse_ir_sym(int sym, char *buf, uint32_t *flags) {
	const char *name;
	size_t len;
	if (sym == YY_VAR) {
		sym = get_sym();
	} else if (sym == YY_CONST) {
		sym = get_sym();
		*flags |= IR_CONST;
	} else {
		yy_error_sym("unexpected", sym);
	}
	sym = parse_ID(sym, &name, &len);
	if (len > 255) yy_error("name too long");
	memcpy(buf, name, len);
	buf[len] = 0;
	return sym;
}

static int parse_ir_sym_size(int sym, size_t *size) {
	ir_val val;
	if (sym != YY__LBRACK) {
		yy_error_sym("'[' expected, got", sym);
	}
	sym = get_sym();
	sym = parse_DECNUMBER(sym, IR_U64, &val);
	if (sym != YY__RBRACK) {
		yy_error_sym("']' expected, got", sym);
	}
	sym = get_sym();
	*size = (size_t)val.u64;
	return sym;
}

static int parse_ir_sym_data(int sym, ir_loader *loader) {
	uint8_t t = 0;
	ir_val val;
	void *p = NULL;
	const char *name;
	size_t name_len;
	char buf[256];
	uintptr_t offset = 0;
	sym = parse_type(sym, &t);
	if (sym == YY_SYM) {
		sym = get_sym();
		if (sym != YY__LPAREN) {
			yy_error_sym("'(' expected, got", sym);
		}
		sym = get_sym();
		sym = parse_ID(sym, &name, &name_len);
		if (sym != YY__RPAREN) {
			yy_error_sym("')' expected, got", sym);
		}
		sym = get_sym();
		if (sym == YY__PLUS) {
			sym = get_sym();
			sym = parse_const(sym, t, &val);
			offset = (uintptr_t)val.addr;
		}
		if (loader->sym_data_ref) {
			if (name_len > 255) yy_error("name too long");
			memcpy(buf, name, name_len);
			buf[name_len] = 0;
			if (!loader->sym_data_ref(loader, IR_SYM, buf, offset)) {
				yy_error("sym_data_ref error");
			}
		}
	} else if (sym == YY_FUNC) {
		sym = get_sym();
		if (sym != YY__LPAREN) {
			yy_error_sym("'(' expected, got", sym);
		}
		sym = get_sym();
		sym = parse_ID(sym, &name, &name_len);
		if (sym != YY__RPAREN) {
			yy_error_sym("')' expected, got", sym);
		}
		sym = get_sym();
		if (loader->sym_data_ref) {
			if (name_len > 255) yy_error("name too long");
			memcpy(buf, name, name_len);
			buf[name_len] = 0;
			if (!loader->sym_data_ref(loader, IR_FUNC, buf, 0)) {
				yy_error("sym_data_ref error");
			}
		}
	} else if (YY_IN_SET(sym, (YY_DECNUMBER,YY_HEXNUMBER,YY_FLOATNUMBER,YY_CHARACTER,YY_INF,YY_NAN,YY__MINUS), "\000\000\000\000\000\000\356\001")) {
		sym = parse_const(sym, t, &val);
		if (loader->sym_data) {
			switch (ir_type_size[t]) {
				case 1: p = &val.i8;  break;
				case 2: p = &val.i16; break;
				case 4: p = &val.i32; break;
				case 8: p = &val.i64; break;
				default:
					IR_ASSERT(0);
					break;
			}
			if (!loader->sym_data(loader, t, 1, p)) {
				yy_error("sym_data error");
			}
		}
	} else {
		yy_error_sym("unexpected", sym);
	}
	return sym;
}

static int parse_ir_func(int sym, ir_parser_ctx *p) {
	p->undef_count = 0;
	p->bad_insns = 0;
	ir_strtab_init(&p->var_tab, 256, 4096);
	yy_ctx = p;
	if (sym != YY__LBRACE) {
		yy_error_sym("'{' expected, got", sym);
	}
	sym = get_sym();
	while (YY_IN_SET(sym, (YY_NOP,YY_BOOL,YY_UINT8_T,YY_UINT16_T,YY_UINT32_T,YY_UINT64_T,YY_UINTPTR_T,YY_CHAR,YY_INT8_T,YY_INT16_T,YY_INT32_T,YY_INT64_T,YY_DOUBLE,YY_FLOAT,YY__LESS,YY_ID), "\000\000\002\000\376\177\020\000")) {
		if (sym == YY_NOP) {
			sym = get_sym();
		} else {
			sym = parse_ir_insn(sym, p);
			if (sym == YY_BYVAL) {
				sym = parse_ir_modifier(sym, p);
			}
		}
		if (sym != YY__SEMICOLON) {
			yy_error_sym("';' expected, got", sym);
		}
		sym = get_sym();
	}
	if (sym != YY__RBRACE) {
		yy_error_sym("'}' expected, got", sym);
	}
	sym = get_sym();
	if (p->undef_count) ir_check_indefined_vars(p);
	if (p->bad_insns) p->ctx->flags |= IR_OPT_FOLDING;
	yy_ctx = NULL;
	ir_strtab_free(&p->var_tab);
	if (p->ctx->value_params) {
		uint32_t param_num = 1;
		while (p->ctx->ir_base[param_num + 2].op == IR_PARAM) param_num++;
		if (param_num != p->value_params_count) {
			p->ctx->value_params = ir_mem_realloc(p->ctx->value_params, param_num * sizeof(ir_value_param));
			memset(p->ctx->value_params + p->value_params_count, 0,
				(param_num - p->value_params_count) * sizeof(ir_value_param));
		}
	}
	return sym;
}

static int parse_ir_func_name(int sym, char *buf) {
	const char *name;
	size_t len;
	if (sym != YY_FUNC) {
		yy_error_sym("'func' expected, got", sym);
	}
	sym = get_sym();
	sym = parse_ID(sym, &name, &len);
	if (len > 255) yy_error("name too long");
	memcpy(buf, name, len);
	buf[len] = 0;
	return sym;
}

static int parse_ir_func_proto(int sym, ir_parser_ctx *p, uint32_t *flags, uint8_t *ret_type, uint32_t *params_count, uint8_t *param_types) {
	int   sym2;
	const unsigned char *save_pos;
	const unsigned char *save_text;
	int save_line;
	int alt98;
	uint8_t t = 0;
	uint32_t n = 0;
	if (sym != YY__LPAREN) {
		yy_error_sym("'(' expected, got", sym);
	}
	sym = get_sym();
	if (YY_IN_SET(sym, (YY_VOID,YY__POINT_POINT_POINT,YY_BOOL,YY_UINT8_T,YY_UINT16_T,YY_UINT32_T,YY_UINT64_T,YY_UINTPTR_T,YY_CHAR,YY_INT8_T,YY_INT16_T,YY_INT32_T,YY_INT64_T,YY_DOUBLE,YY_FLOAT,YY__LESS), "\000\000\014\000\376\177\000\000")) {
		if (sym == YY_VOID) {
			sym = get_sym();
		} else if (sym == YY__POINT_POINT_POINT) {
			sym = get_sym();
			*flags |= IR_VARARG_FUNC;
		} else {
			sym = parse_type(sym, &t);
			param_types[n++] = t;
			while (1) {
				save_pos  = yy_pos;
				save_text = yy_text;
				save_line = yy_line;
				alt98 = -2;
				sym2 = sym;
				if (sym2 == YY__COMMA) {
					sym2 = get_sym();
					goto _yy_state_98_1;
				} else if (sym2 == YY__RPAREN) {
					alt98 = 103;
					goto _yy_state_98;
				} else {
					yy_error_sym("unexpected", sym2);
				}
_yy_state_98_1:
				if (YY_IN_SET(sym2, (YY__LESS,YY_BOOL,YY_UINT8_T,YY_UINT16_T,YY_UINT32_T,YY_UINT64_T,YY_UINTPTR_T,YY_CHAR,YY_INT8_T,YY_INT16_T,YY_INT32_T,YY_INT64_T,YY_DOUBLE,YY_FLOAT), "\000\000\000\000\376\177\000\000")) {
					alt98 = 99;
					goto _yy_state_98;
				} else if (sym2 == YY__POINT_POINT_POINT) {
					alt98 = 101;
					goto _yy_state_98;
				} else {
					yy_error_sym("unexpected", sym2);
				}
_yy_state_98:
				yy_pos  = save_pos;
				yy_text = save_text;
				yy_line = save_line;
				if (alt98 != 99) {
					break;
				}
				sym = get_sym();
				sym = parse_type(sym, &t);
				param_types[n++] = t;
				if (n > 256) yy_error("name too params");
			}
			if (alt98 == 101) {
				sym = get_sym();
				if (sym != YY__POINT_POINT_POINT) {
					yy_error_sym("'...' expected, got", sym);
				}
				sym = get_sym();
				*flags |= IR_VARARG_FUNC;
			}
		}
	}
	if (sym != YY__RPAREN) {
		yy_error_sym("')' expected, got", sym);
	}
	sym = get_sym();
	if (sym != YY__COLON) {
		yy_error_sym("':' expected, got", sym);
	}
	sym = get_sym();
	if (YY_IN_SET(sym, (YY_BOOL,YY_UINT8_T,YY_UINT16_T,YY_UINT32_T,YY_UINT64_T,YY_UINTPTR_T,YY_CHAR,YY_INT8_T,YY_INT16_T,YY_INT32_T,YY_INT64_T,YY_DOUBLE,YY_FLOAT,YY__LESS), "\000\000\000\000\376\177\000\000")) {
		sym = parse_type(sym, ret_type);
	} else if (sym == YY_VOID) {
		sym = get_sym();
		*ret_type = IR_VOID;
	} else {
		yy_error_sym("unexpected", sym);
	}
	if (YY_IN_SET(sym, (YY___FASTCALL,YY___PRESERVE_NONE,YY___WIN64,YY___SYSV,YY___DARWIN,YY___BUILTIN), "\000\000\340\007\000\000\000\000")) {
		switch (sym) {
			case YY___FASTCALL:
				sym = get_sym();
				*flags |= IR_CC_FASTCALL;
				break;
			case YY___PRESERVE_NONE:
				sym = get_sym();
				*flags |= IR_CC_PRESERVE_NONE;
				break;
			case YY___WIN64:
				sym = get_sym();
				IR_SET_WIN64_CC(flags);
				break;
			case YY___SYSV:
				sym = get_sym();
				IR_SET_SYSV_CC(flags);
				break;
			case YY___DARWIN:
				sym = get_sym();
				IR_SET_DARWIN_CC(flags);
				break;
			default:
				sym = get_sym();
				*flags |= IR_CC_BUILTIN;
				break;
		}
	}
	if (sym == YY___PURE || sym == YY___CONST) {
		if (sym == YY___PURE) {
			sym = get_sym();
			*flags |= IR_PURE_FUNC;
		} else {
			sym = get_sym();
			*flags |= IR_CONST_FUNC;
		}
	}
	*params_count = n;
	return sym;
}

static int parse_ir_insn(int sym, ir_parser_ctx *p) {
	const char *str, *str2 = NULL, *func;
	size_t len, len2 = 0, func_len;
	uint8_t op;
	uint8_t t = 0;
	ir_ref op1 = IR_UNUSED;
	ir_ref op2 = IR_UNUSED;
	ir_ref op3 = IR_UNUSED;
	ir_ref ref = IR_UNUSED;
	ir_ref ref2 = IR_UNUSED;
	ir_val val;
	ir_val count;
	int32_t n;
	uint8_t ret_type;
	uint32_t flags;
	uint32_t params_count;
	uint8_t param_types[IR_MAX_OPERANDS + 1];
	void *ptr, *end;
	ir_type t2;
	if (YY_IN_SET(sym, (YY_BOOL,YY_UINT8_T,YY_UINT16_T,YY_UINT32_T,YY_UINT64_T,YY_UINTPTR_T,YY_CHAR,YY_INT8_T,YY_INT16_T,YY_INT32_T,YY_INT64_T,YY_DOUBLE,YY_FLOAT,YY__LESS), "\000\000\000\000\376\177\000\000")) {
		sym = parse_type(sym, &t);
		sym = parse_ID(sym, &str, &len);
		if (sym == YY__COMMA) {
			sym = get_sym();
			sym = parse_ID(sym, &str2, &len2);
		}
	} else if (sym == YY_ID) {
		sym = parse_ID(sym, &str, &len);
	} else {
		yy_error_sym("unexpected", sym);
	}
	if (sym != YY__EQUAL) {
		yy_error_sym("'=' expected, got", sym);
	}
	sym = get_sym();
	switch (sym) {
		case YY_DECNUMBER:
		case YY_HEXNUMBER:
		case YY_FLOATNUMBER:
		case YY_CHARACTER:
		case YY_INF:
		case YY_NAN:
		case YY__MINUS:
			if (t == IR_VOID) yy_error_fmt("constant '%.*s' has no type", (int)len, str);
			if (IR_IS_TYPE_VECTOR(t)) yy_error_const_type("scalar", t);
			val.u64 = 0;
			sym = parse_const(sym, t, &val);
			ref = ir_const(p->ctx, val, t);
			break;
		case YY__LBRACE:
			sym = get_sym();
			if (!IR_IS_TYPE_VECTOR(t)) yy_error_const_type("vector", t);
			ref = ir_const_vector(p->ctx, t);
			ptr = ir_long_const_ptr(p->ctx, ref);
			memset(ptr, 0, IR_VECTOR_SIZE(t));
			end = (char*)ptr + IR_VECTOR_SIZE(t);
			t2 = IR_VECTOR_BASE_TYPE(t);
			if (YY_IN_SET(sym, (YY_DECNUMBER,YY_HEXNUMBER,YY_FLOATNUMBER,YY_CHARACTER,YY_INF,YY_NAN,YY__MINUS), "\000\000\000\000\000\000\356\001")) {
				sym = parse_const(sym, t2, &val);
				switch (ir_type_size[t2]) {
					case 1: *(uint8_t*)ptr  = val.u8;  ptr = (char*)ptr + 1; break;
					case 2: *(uint16_t*)ptr = val.u16; ptr = (char*)ptr + 2; break;
					case 4: *(uint32_t*)ptr = val.u32; ptr = (char*)ptr + 4; break;
					case 8: *(uint64_t*)ptr = val.u64; ptr = (char*)ptr + 8; break;
					default:
						IR_ASSERT(0);
						break;
				}
				while (sym == YY__COMMA) {
					sym = get_sym();
					if (ptr == end) yy_error_fmt("too many elements in <%s*%d> constant",
					ir_type_cname[t2], IR_VECTOR_LENGTH(t));
					sym = parse_const(sym, t2, &val);
					switch (ir_type_size[t2]) {
						case 1: *(uint8_t*)ptr  = val.u8;  ptr = (char*)ptr + 1; break;
						case 2: *(uint16_t*)ptr = val.u16; ptr = (char*)ptr + 2; break;
						case 4: *(uint32_t*)ptr = val.u32; ptr = (char*)ptr + 4; break;
						case 8: *(uint64_t*)ptr = val.u64; ptr = (char*)ptr + 8; break;
						default:
							IR_ASSERT(0);
							break;
					}
				}
			}
			if (sym != YY__RBRACE) {
				yy_error_sym("'}' expected, got", sym);
			}
			sym = get_sym();
			ref = ir_long_const_commit(p->ctx, ref);
			break;
		case YY_FUNC:
			sym = get_sym();
			if (t != IR_VOID && t != IR_ADDR) yy_error_const_type("function address", t);
			if (sym == YY_ID) {
				sym = parse_ID(sym, &func, &func_len);
				flags = 0;
				sym = parse_ir_func_proto(sym, p, &flags, &ret_type, &params_count, param_types);
				ref = ir_proto(p->ctx, flags, ret_type, params_count, param_types);
				ref = ir_const_func(p->ctx, ir_stringl(p->ctx, func, func_len), ref);
			} else if (sym == YY__STAR) {
				sym = get_sym();
				if (sym == YY_DECNUMBER) {
					sym = parse_DECNUMBER(sym, IR_ADDR, &val);
				} else if (sym == YY_HEXNUMBER) {
					sym = parse_HEXNUMBER(sym, IR_ADDR, &val);
				} else {
					yy_error_sym("unexpected", sym);
				}
				flags = 0;
				sym = parse_ir_func_proto(sym, p, &flags, &ret_type, &params_count, param_types);
				ref = ir_proto(p->ctx, flags, ret_type, params_count, param_types);
				ref = ir_const_func_addr(p->ctx, val.addr, ref);
			} else {
				yy_error_sym("unexpected", sym);
			}
			break;
		case YY_SYM:
			sym = get_sym();
			if (t != IR_VOID && t != IR_ADDR) yy_error_const_type("symbol address", t);
			if (sym != YY__LPAREN) {
				yy_error_sym("'(' expected, got", sym);
			}
			sym = get_sym();
			sym = parse_ID(sym, &func, &func_len);
			if (sym != YY__RPAREN) {
				yy_error_sym("')' expected, got", sym);
			}
			sym = get_sym();
			ref = ir_const_sym(p->ctx, ir_stringl(p->ctx, func, func_len));
			break;
		case YY_LABEL:
			sym = get_sym();
			if (t != IR_VOID && t != IR_ADDR) yy_error_const_type("label address", t);
			if (sym != YY__LPAREN) {
				yy_error_sym("'(' expected, got", sym);
			}
			sym = get_sym();
			sym = parse_ID(sym, &func, &func_len);
			if (sym != YY__RPAREN) {
				yy_error_sym("')' expected, got", sym);
			}
			sym = get_sym();
			ref = ir_const_label(p->ctx, ir_stringl(p->ctx, func, func_len));
			break;
		case YY_STRING:
			sym = parse_STRING(sym, &func, &func_len);
			if (t != IR_VOID && t != IR_ADDR) yy_error_const_type("string", t);
			ref = ir_make_const_str(p->ctx, func, func_len);
			break;
		case YY_ID:
			sym = parse_func(sym, &op);
			switch (ir_op_flags[op] & (IR_OP_FLAG_DATA|IR_OP_FLAG_CONTROL|IR_OP_FLAG_MEM|IR_OP_FLAG_MEM_MASK)) {
				case IR_OP_FLAG_DATA:
					if (t == IR_VOID) yy_error_fmt("instruction %s has no type", ir_op_name[op]);
					if (str2) yy_error_fmt("instruction %s must not have control output", ir_op_name[op]);
					break;
				case IR_OP_FLAG_CONTROL|IR_OP_FLAG_MEM|IR_OP_FLAG_MEM_LOAD:
				case IR_OP_FLAG_CONTROL|IR_OP_FLAG_MEM|IR_OP_FLAG_MEM_ALLOC:
					if (t == IR_VOID) yy_error_fmt("instruction %s has no type", ir_op_name[op]);
					if (!str) yy_error_fmt("instruction %s has no control output", ir_op_name[op]);
					break;
				case IR_OP_FLAG_CONTROL:
				case IR_OP_FLAG_CONTROL|IR_OP_FLAG_MEM|IR_OP_FLAG_MEM_STORE:
					if (t != IR_VOID) yy_error_fmt("instruction %s must not have data output", ir_op_name[op]);
					break;
			}
			if (sym == YY__SLASH) {
				sym = get_sym();
				sym = parse_DECNUMBER(sym, IR_I32, &count);
				if (op == IR_PHI || op == IR_SNAPSHOT) count.i32++;
				if (op == IR_CALL || op == IR_TAILCALL || op == IR_ASM) count.i32+=2;
				if (count.i32 < 0) yy_error("negative number of operands");
				if (count.i32 > IR_MAX_OPERANDS) yy_error("too many operands");
				ref = ref2 = ir_emit_N(p->ctx, IR_OPT(op, t), count.i32);
				if (sym == YY__LPAREN) {
					sym = get_sym();
					if (YY_IN_SET(sym, (YY_ID,YY_STRING,YY_DECNUMBER,YY_NULL,YY_FUNC), "\000\000\001\000\000\000\061\002")) {
						p->curr_ref = ref;
						sym = parse_val(sym, p, op, 1, &op1);
						n = 1;
						if (n > count.i32) yy_error("too many operands");
						if (op == IR_CALL
						 && IR_IS_UNRESOLVED(op1)
						 && (p->ctx->flags & IR_OPT_FOLDING)) {
							/* TODO: Disabling folding completely is too agressive. Try to find another solution. */
							p->ctx->flags &= ~IR_OPT_FOLDING;
							p->bad_insns = 1;
						}
						ir_set_op(p->ctx, ref, n, op1);
						while (sym == YY__COMMA) {
							sym = get_sym();
							sym = parse_val(sym, p, op, n + 1, &op1);
							n++;
							if (n > count.i32) yy_error("too many operands");
							if (op == IR_CALL
							 && n == 2
							 && IR_IS_UNRESOLVED(op1)
							 && (p->ctx->flags & IR_OPT_FOLDING)) {
								/* TODO: Disabling folding completely is too agressive. Try to find another solution. */
								p->ctx->flags &= ~IR_OPT_FOLDING;
								p->bad_insns = 1;
							}
							ir_set_op(p->ctx, ref, n, op1);
						}
					}
					if (sym != YY__RPAREN) {
						yy_error_sym("')' expected, got", sym);
					}
					sym = get_sym();
				}
			} else if (sym == YY__LPAREN || sym == YY_BYVAL || sym == YY__SEMICOLON) {
				n = 0;
				if (sym == YY__LPAREN) {
					sym = get_sym();
					if (YY_IN_SET(sym, (YY_ID,YY_STRING,YY_DECNUMBER,YY_NULL,YY_FUNC), "\000\000\001\000\000\000\061\002")) {
						p->curr_ref = p->ctx->insns_count;
						sym = parse_val(sym, p, op, 1, &op1);
						n = 1;
						if (sym == YY__COMMA) {
							sym = get_sym();
							sym = parse_val(sym, p, op, 2, &op2);
							n = 2;
							if (sym == YY__COMMA) {
								sym = get_sym();
								sym = parse_val(sym, p, op, 3, &op3);
								n = 3;
							}
						}
					}
					if (sym != YY__RPAREN) {
						yy_error_sym("')' expected, got", sym);
					}
					sym = get_sym();
				}
				if (IR_IS_FOLDABLE_OP(op)) {
					if (IR_IS_UNRESOLVED(op1) || IR_IS_UNRESOLVED(op2) || IR_IS_UNRESOLVED(op3)) {
						if (op == IR_PHI) {
							goto emit;
						} else {
							goto fallback;
						}
					}
					ref = ir_fold(p->ctx, IR_OPT(op, t), op1, op2, op3);
				/* Folding for control and memory instructions */
#if 0
				} else if (op == IR_BEGIN) {
					if (IR_IS_UNRESOLVED(op1)) {
						goto fallback;
					}
					p->ctx->control = IR_UNUSED;
					_ir_BEGIN(p->ctx, op1);
					ref = p->ctx->control;
					p->ctx->control = IR_UNUSED;
#endif
				} else if (op == IR_IF) {
					if (IR_IS_UNRESOLVED(op1) || IR_IS_UNRESOLVED(op2)) {
						goto fallback;
					}
					p->ctx->control = op1;
					ref = _ir_IF(p->ctx, op2);
					p->ctx->control = IR_UNUSED;
				} else if (op == IR_GUARD) {
					if (IR_IS_UNRESOLVED(op1) || IR_IS_UNRESOLVED(op2) || IR_IS_UNRESOLVED(op3)) {
						goto fallback;
					}
					p->ctx->control = op1;
					_ir_GUARD(p->ctx, op2, op3);
					ref = p->ctx->control;
					p->ctx->control = IR_UNUSED;
				} else if (op == IR_GUARD_NOT) {
					if (IR_IS_UNRESOLVED(op1) || IR_IS_UNRESOLVED(op2) || IR_IS_UNRESOLVED(op3)) {
						goto fallback;
					}
					p->ctx->control = op1;
					_ir_GUARD_NOT(p->ctx, op2, op3);
					ref = p->ctx->control;
					p->ctx->control = IR_UNUSED;
				} else if (op == IR_VLOAD) {
					if (IR_IS_UNRESOLVED(op1) || IR_IS_UNRESOLVED(op2)) {
						goto fallback;
					}
					p->ctx->control = op1;
					ref = _ir_VLOAD(p->ctx, t, op2);
					ref2 = p->ctx->control;
					p->ctx->control = IR_UNUSED;
				} else if (op == IR_VSTORE) {
					if (IR_IS_UNRESOLVED(op1) || IR_IS_UNRESOLVED(op2) || IR_IS_UNRESOLVED(op3)) {
						goto fallback;
					}
					p->ctx->control = op1;
					_ir_VSTORE(p->ctx, op2, op3);
					ref = p->ctx->control;
					p->ctx->control = IR_UNUSED;
				} else if (op == IR_LOAD) {
					if (IR_IS_UNRESOLVED(op1) || IR_IS_UNRESOLVED(op2)) {
						goto fallback;
					}
					p->ctx->control = op1;
					ref = _ir_LOAD(p->ctx, t, op2);
					ref2 = p->ctx->control;
					p->ctx->control = IR_UNUSED;
				} else if (op == IR_STORE) {
					if (IR_IS_UNRESOLVED(op1) || IR_IS_UNRESOLVED(op2) || IR_IS_UNRESOLVED(op3)) {
						goto fallback;
					}
					p->ctx->control = op1;
					_ir_STORE(p->ctx, op2, op3);
					ref = p->ctx->control;
					p->ctx->control = IR_UNUSED;
				} else if (op == IR_CALL) {
					if (IR_IS_UNRESOLVED(op1) || IR_IS_UNRESOLVED(op2)) {
						goto fallback;
					}
					goto emit;
				} else if (ir_op_flags[op] & IR_OP_FLAG_CONTROL) {
					if (op != IR_LOOP_BEGIN && op != IR_MERGE && op != IR_START && IR_IS_UNRESOLVED(op1)) {
						goto fallback;
					}
					goto emit;
				} else {
					uint32_t opt;

					if (0) {
fallback:
						if (p->ctx->flags & IR_OPT_FOLDING) {
							/* TODO: Disabling folding completely is too agressive. Try to find another solution. */
							p->ctx->flags &= ~IR_OPT_FOLDING;
							p->bad_insns = 1;
						}
					}
emit:
					if (!IR_OP_HAS_VAR_INPUTS(ir_op_flags[op])) {
						opt = IR_OPT(op, t);
					} else {
						opt = IR_OPTX(op, t, n);
					}
					ref = ref2 = ir_emit(p->ctx, opt, op1, op2, op3);
				}
			} else {
				yy_error_sym("unexpected", sym);
			}
			break;
		default:
			yy_error_sym("unexpected", sym);
	}
	ir_define_var(p, str, len, ref);
	if (str2) {
		if (!ref2) {
			if (IR_IS_CONST_REF(ref)) {
				yy_error("constant must not have control output");
			} else {
				yy_error_fmt("instruction %s must have control output", ir_op_name[op]);
			}
		}
		ir_define_var(p, str2, len2, ref2);
	}
	return sym;
}

static int parse_ir_modifier(int sym, ir_parser_ctx *p) {
	ir_val size, align;
	if (sym != YY_BYVAL) {
		yy_error_sym("'ByVal' expected, got", sym);
	}
	sym = get_sym();
	if (sym != YY__LPAREN) {
		yy_error_sym("'(' expected, got", sym);
	}
	sym = get_sym();
	sym = parse_const(sym, IR_I32, &size);
	if (sym != YY__COMMA) {
		yy_error_sym("',' expected, got", sym);
	}
	sym = get_sym();
	sym = parse_const(sym, IR_I32, &align);
	if (sym != YY__RPAREN) {
		yy_error_sym("')' expected, got", sym);
	}
	sym = get_sym();
	ir_ref param_ref = p->ctx->insns_count - 1;
	ir_ref param_num = param_ref - 1;

	if (p->ctx->ir_base[param_ref].op != IR_PARAM) yy_error("unexpected ByVal modifier");
	IR_ASSERT(param_num == p->ctx->ir_base[param_ref].op3);
	if (!p->ctx->value_params) {
		p->ctx->value_params = ir_mem_calloc(param_num, sizeof(ir_value_param));
	} else {
		p->ctx->value_params = ir_mem_realloc(p->ctx->value_params, param_num * sizeof(ir_value_param));
		memset(p->ctx->value_params + p->value_params_count, 0,
			(param_num - p->value_params_count) * sizeof(ir_value_param));
	}
	p->value_params_count = param_num;
	p->ctx->value_params[param_num - 1].size = size.i32;
	p->ctx->value_params[param_num - 1].align = align.i32 ? align.i32 : 1;
	return sym;
}

static int parse_simple_type(int sym, uint8_t *t) {
	switch (sym) {
		case YY_BOOL:
			sym = get_sym();
			*t = IR_BOOL;
			break;
		case YY_UINT8_T:
			sym = get_sym();
			*t = IR_U8;
			break;
		case YY_UINT16_T:
			sym = get_sym();
			*t = IR_U16;
			break;
		case YY_UINT32_T:
			sym = get_sym();
			*t = IR_U32;
			break;
		case YY_UINT64_T:
			sym = get_sym();
			*t = IR_U64;
			break;
		case YY_UINTPTR_T:
			sym = get_sym();
			*t = IR_ADDR;
			break;
		case YY_CHAR:
			sym = get_sym();
			*t = IR_CHAR;
			break;
		case YY_INT8_T:
			sym = get_sym();
			*t = IR_I8;
			break;
		case YY_INT16_T:
			sym = get_sym();
			*t = IR_I16;
			break;
		case YY_INT32_T:
			sym = get_sym();
			*t = IR_I32;
			break;
		case YY_INT64_T:
			sym = get_sym();
			*t = IR_I64;
			break;
		case YY_DOUBLE:
			sym = get_sym();
			*t = IR_DOUBLE;
			break;
		case YY_FLOAT:
			sym = get_sym();
			*t = IR_FLOAT;
			break;
		default:
			yy_error_sym("unexpected", sym);
	}
	return sym;
}

static int parse_type(int sym, uint8_t *t) {
	if (YY_IN_SET(sym, (YY_BOOL,YY_UINT8_T,YY_UINT16_T,YY_UINT32_T,YY_UINT64_T,YY_UINTPTR_T,YY_CHAR,YY_INT8_T,YY_INT16_T,YY_INT32_T,YY_INT64_T,YY_DOUBLE,YY_FLOAT), "\000\000\000\000\376\077\000\000")) {
		sym = parse_simple_type(sym, t);
	} else if (sym == YY__LESS) {
		ir_val val;
		sym = get_sym();
		sym = parse_simple_type(sym, t);
		if (sym != YY__STAR) {
			yy_error_sym("'*' expected, got", sym);
		}
		sym = get_sym();
		sym = parse_DECNUMBER(sym, IR_I32, &val);
		if (sym != YY__GREATER) {
			yy_error_sym("'>' expected, got", sym);
		}
		sym = get_sym();
		if (*t == IR_ADDR) yy_error_fmt("unsupported vector element type %s", ir_type_cname[*t]);
		if (val.u64 == 0 || val.u64 > 64 || (val.u64 & (val.u64 - 1)) != 0) yy_error("unsupported vector length");
		*t = ir_make_vector_type(*t, val.u32);
	} else {
		yy_error_sym("unexpected", sym);
	}
	return sym;
}

static int parse_func(int sym, uint8_t *op) {
	const char *str;
	size_t len;
	ir_ref ref;
	sym = parse_ID(sym, &str, &len);
	IR_ASSERT(len <= 0xffffffff);
	ref = ir_strtab_find(&op_tab, str, (uint32_t)len);
	if (!ref) yy_error("invalid op");
	*op = ref - 1;
	return sym;
}

static int parse_val(int sym, ir_parser_ctx *p, uint8_t op, uint32_t n, ir_ref *ref) {
	const char *str;
	size_t len;
	ir_val val;
	uint32_t kind = IR_OPND_KIND(ir_op_flags[op], n);
	uint8_t ret_type;
	uint32_t flags;
	uint32_t params_count;
	uint8_t param_types[256];
	switch (sym) {
		case YY_ID:
			sym = parse_ID(sym, &str, &len);
			if (!IR_IS_REF_OPND_KIND(kind)) yy_error("unexpected reference");
			*ref = ir_use_var(p, n, str, len);
			break;
		case YY_STRING:
			sym = parse_STRING(sym, &str, &len);
			if (kind != IR_OPND_STR) yy_error("unexpected string");
			*ref = ir_stringl(p->ctx, str, len);
			break;
		case YY_DECNUMBER:
			sym = parse_DECNUMBER(sym, IR_I32, &val);
			if (kind != IR_OPND_NUM && kind != IR_OPND_OPT) yy_error("unexpected number");
			if (val.i64 < (int32_t)0x80000000 || val.i64 > 0x7fffffff) yy_error("number out of range");
			*ref = val.i32;
			break;
		case YY_NULL:
			sym = get_sym();
			*ref = IR_UNUSED;
			break;
		case YY_FUNC:
			sym = get_sym();
			if (kind != IR_OPND_PROTO) yy_error("unexpected function prototype");
			flags = 0;
			sym = parse_ir_func_proto(sym, p, &flags, &ret_type, &params_count, param_types);
			*ref = ir_proto(p->ctx, flags, ret_type, params_count, param_types);
			break;
		default:
			yy_error_sym("unexpected", sym);
	}
	return sym;
}

static int parse_const(int sym, uint8_t t, ir_val *val) {
	switch (sym) {
		case YY_DECNUMBER:
			sym = parse_DECNUMBER(sym, t, val);
			break;
		case YY_HEXNUMBER:
			sym = parse_HEXNUMBER(sym, t, val);
			break;
		case YY_FLOATNUMBER:
			sym = parse_FLOATNUMBER(sym, t, val);
			break;
		case YY_CHARACTER:
			sym = parse_CHARACTER(sym, t, val);
			break;
		case YY_INF:
			sym = get_sym();
			if (t == IR_DOUBLE) val->d = INFINITY;
		else if (t == IR_FLOAT) {val->f = INFINITY; val->u32_hi = 0;}
		else yy_error_const_type("floating-point", t);
			break;
		case YY_NAN:
			sym = get_sym();
			if (sym == YY__LPAREN) {
				ir_type t2 = (t == IR_DOUBLE) ? IR_U64 : IR_U32;
				sym = get_sym();
				sym = parse_HEXNUMBER(sym, t2, val);
				if (sym != YY__RPAREN) {
					yy_error_sym("')' expected, got", sym);
				}
				sym = get_sym();
			} else if (YY_IN_SET(sym, (YY__COMMA,YY__RBRACE,YY__RPAREN,YY_BYVAL,YY__SEMICOLON), "\304\100\000\000\001\000\000\000")) {
				if (t == IR_DOUBLE) val->d = NAN;
			else if (t == IR_FLOAT) {val->f = NAN; val->u32_hi = 0;}
			else yy_error_const_type("floating-point", t);
			} else {
				yy_error_sym("unexpected", sym);
			}
			break;
		case YY__MINUS:
			sym = get_sym();
			if (sym == YY_INF) {
				sym = get_sym();
				if (t == IR_DOUBLE) val->d = -INFINITY;
			else if (t == IR_FLOAT) {val->f = -INFINITY; val->u32_hi = 0;}
			else yy_error_const_type("floating-point", t);
			} else if (sym == YY_NAN) {
				sym = get_sym();
				if (t == IR_DOUBLE) val->d = -NAN;
			else if (t == IR_FLOAT) {val->f = -NAN; val->u32_hi = 0;}
			else yy_error_const_type("floating-point", t);
			} else {
				yy_error_sym("unexpected", sym);
			}
			break;
		default:
			yy_error_sym("unexpected", sym);
	}
	return sym;
}

static int parse_ID(int sym, const char **str, size_t *len) {
	if (sym != YY_ID) {
		yy_error_sym("<ID> expected, got", sym);
	}
	if (yy_text[0] == '@') {*str = (const char*)yy_text + 1; *len = yy_pos - yy_text - 1;} else {*str = (const char*)yy_text; *len = yy_pos - yy_text;}
	sym = get_sym();
	return sym;
}

static int parse_DECNUMBER(int sym, uint32_t t, ir_val *val) {
	if (sym != YY_DECNUMBER) {
		yy_error_sym("<DECNUMBER> expected, got", sym);
	}
	if (t == IR_DOUBLE) val->d = atof((const char*)yy_text);
	else if (t == IR_FLOAT) {val->f = strtof((const char*)yy_text, NULL); val->u32_hi = 0;}
	else {val->u64 = read_dec((const char*)yy_text, (const char*)yy_pos); ext_int_const(t, val);}
	sym = get_sym();
	return sym;
}

static int parse_HEXNUMBER(int sym, uint32_t t, ir_val *val) {
	if (sym != YY_HEXNUMBER) {
		yy_error_sym("<HEXNUMBER> expected, got", sym);
	}
	val->u64 = read_hex((const char*)yy_text + 2, (const char*)yy_pos); ext_int_const(t, val);
	sym = get_sym();
	return sym;
}

static int parse_FLOATNUMBER(int sym, uint32_t t, ir_val *val) {
	if (sym != YY_FLOATNUMBER) {
		yy_error_sym("<FLOATNUMBER> expected, got", sym);
	}
	if (t == IR_DOUBLE) val->d = atof((const char*)yy_text);
	else if (t == IR_FLOAT) {val->f = strtof((const char*)yy_text, NULL); val->u32_hi = 0;}
	else yy_error_const_type("floating-point", t);
	sym = get_sym();
	return sym;
}

static int parse_CHARACTER(int sym, uint32_t t, ir_val *val) {
	if (sym != YY_CHARACTER) {
		yy_error_sym("<CHARACTER> expected, got", sym);
	}
	if (!IR_IS_TYPE_INT(t)) yy_error_const_type("character", t);
	if ((char)yy_text[1] != '\\') {
		val->i64 = (signed char)yy_text[1];
	} else {
		size_t l = 1;
		val->i64 = (signed char)yy_unescape_char((const char*)yy_text + 2, &l);
	}
	ext_int_const(t, val);
	sym = get_sym();
	return sym;
}

static int parse_STRING(int sym, const char **str, size_t *len) {
	if (sym != YY_STRING) {
		yy_error_sym("<STRING> expected, got", sym);
	}
	*str = (const char*)yy_text + 1; *len = yy_pos - yy_text - 2;
	sym = get_sym();
	return sym;
}

static void parse(ir_loader *loader) {
	int sym;

	yy_pos = yy_text = yy_buf;
	yy_line = 1;
	sym = parse_ir(get_sym(), loader);
	if (sym != YY_EOF) {
		yy_error_sym("<EOF> expected, got", sym);
	}
}

static void yy_error(const char *msg) {
	fprintf(stderr, "ERROR: %s at line %d\n", msg, yy_line);
	if (yy_ctx) {
		ir_strtab_free(&yy_ctx->var_tab);
		ir_free(yy_ctx->ctx);
		yy_ctx = NULL;
	}
	longjmp(yy_jmp_buf, 2);
}

static void yy_error_sym(const char *msg, int sym) {
	fprintf(stderr, "ERROR: %s '%s' at line %d\n", msg, sym_name[sym], yy_line);
	if (yy_ctx) {
		ir_strtab_free(&yy_ctx->var_tab);
		ir_free(yy_ctx->ctx);
		yy_ctx = NULL;
	}
	longjmp(yy_jmp_buf, 2);
}

static void yy_error_str(const char *msg, const char *str) {
	fprintf(stderr, "ERROR: %s '%s' at line %d\n", msg, str, yy_line);
	if (yy_ctx) {
		ir_strtab_free(&yy_ctx->var_tab);
		ir_free(yy_ctx->ctx);
		yy_ctx = NULL;
	}
	longjmp(yy_jmp_buf, 2);
}

static void yy_error_fmt(const char *fmt, ...) {
	va_list args;

	va_start(args, fmt);
	fprintf(stderr, "ERROR: ");
	vfprintf(stderr, fmt, args);
	fprintf(stderr, " at line %d\n", yy_line);
	va_end(args);
	if (yy_ctx) {
		ir_strtab_free(&yy_ctx->var_tab);
		ir_free(yy_ctx->ctx);
		yy_ctx = NULL;
	}
	longjmp(yy_jmp_buf, 2);
}

static void yy_error_const_type(const char *kind, ir_type t) {
	if (IR_IS_TYPE_VECTOR(t)) {
		yy_error_fmt("%s constant is incompatible with <%s*%d>", kind,
			ir_type_cname[IR_VECTOR_BASE_TYPE(t)], IR_VECTOR_LENGTH(t));
	} else {
		yy_error_fmt("%s constant is incompatible with %s", kind, ir_type_cname[t]);
	}
}

int ir_load(ir_loader *loader, FILE *f) {
	long pos, end;
	int ret;

	pos = ftell(f);
	fseek(f, 0, SEEK_END);
	end = ftell(f);
	fseek(f, pos, SEEK_SET);
	yy_buf = ir_mem_malloc(end - pos + 1);
	if (!yy_buf) {
		fprintf(stderr, "ERROR: Cannot load IR file. Insufficient memory.\n");
		return 0;
	}
	yy_end = yy_buf + (end - pos);
	fread((void*)yy_buf, (end - pos), 1, f);
	*(unsigned char*)yy_end = 0;

	if (setjmp(yy_jmp_buf) == 0) {
		yy_ctx = NULL;
		parse(loader);
		ret = 1;
	} else {
		ret = 0;
	}

	ir_mem_free((void*)yy_buf);

	return ret;
}

void ir_loader_init(void)
{
	ir_ref i;

	ir_strtab_init(&op_tab, IR_LAST_OP, 0);
	for (i = 0; i < IR_LAST_OP; i++) {
		ir_strtab_lookup(&op_tab, ir_op_name[i], (uint32_t)strlen(ir_op_name[i]), i + 1);
	}
}

void ir_loader_free(void)
{
	ir_strtab_free(&op_tab);
}