darkplaces/gmqcc
0
0
Fork 0
mirror of https://github.com/DarkPlacesEngine/gmqcc.git synced 2025-03-21 10:21:03 +00:00
Code Issues Projects Releases Packages Wiki Activity

No more globals for codegen

Browse source
This commit is contained in:
Dale Weiler 2013-04-25 09:35:30 +00:00
parent 73070395eb
commit 785ab7c072
5 changed files with 325 additions and 310 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

230
code.c
View file

@ -23,61 +23,56 @@
*/
#include "gmqcc.h"
prog_section_statement *code_statements;
int *code_linenums;
prog_section_def *code_defs;
prog_section_field *code_fields;
prog_section_function *code_functions;
int *code_globals;
char *code_chars;
uint16_t code_crc;
static uint32_t code_entfields;
/* This is outrageous! */
#define QCINT_ENTRY void*
#define QCINT_TO_HASH_ENTRY(q) ((void*)(uintptr_t)(q))
#define HASH_ENTRY_TO_QCINT(h) ((qcint)(uintptr_t)(h))
static ht code_string_cache;
static qcint code_string_cached_empty;
void code_push_statement(prog_section_statement *stmt, int linenum)
void code_push_statement(code_t *code, prog_section_statement *stmt, int linenum)
{
vec_push(code_statements, *stmt);
vec_push(code_linenums, linenum);
vec_push(code->statements, *stmt);
vec_push(code->linenums, linenum);
}
void code_pop_statement()
void code_pop_statement(code_t *code)
{
vec_pop(code_statements);
vec_pop(code_linenums);
vec_pop(code->statements);
vec_pop(code->linenums);
}
void code_init() {
prog_section_function empty_function = {0,0,0,0,0,0,0,{0,0,0,0,0,0,0,0}};
prog_section_statement empty_statement = {0,{0},{0},{0}};
prog_section_def empty_def = {0, 0, 0};
int i = 0;
code_t *code_init() {
static prog_section_function empty_function = {0,0,0,0,0,0,0,{0,0,0,0,0,0,0,0}};
static prog_section_statement empty_statement = {0,{0},{0},{0}};
static prog_section_def empty_def = {0, 0, 0};
code_entfields = 0;
code_t *code = (code_t*)mem_a(sizeof(code_t));
int i = 0;
code_string_cache = util_htnew(OPTS_OPTIMIZATION(OPTIM_OVERLAP_STRINGS) ? 0x100 : 1024);
memset(code, 0, sizeof(code_t));
code->entfields = 0;
code->string_cache = util_htnew(OPTS_OPTIMIZATION(OPTIM_OVERLAP_STRINGS) ? 0x100 : 1024);
/*
* The way progs.dat is suppose to work is odd, there needs to be
* some null (empty) statements, functions, and 28 globals
*/
for(; i < 28; i++)
vec_push(code_globals, 0);
vec_push(code->globals, 0);
vec_push(code_chars, '\0');
vec_push(code_functions, empty_function);
code_push_statement(&empty_statement, 0);
vec_push(code_defs, empty_def);
vec_push(code_fields, empty_def);
vec_push(code->chars, '\0');
vec_push(code->functions, empty_function);
code_push_statement(code, &empty_statement, 0);
vec_push(code->defs, empty_def);
vec_push(code->fields, empty_def);
return code;
}
void *code_util_str_htgeth(hash_table_t *ht, const char *key, size_t bin);
uint32_t code_genstring(const char *str)
uint32_t code_genstring(code_t *code, const char *str)
{
uint32_t off;
size_t hash;
@ -87,69 +82,70 @@ uint32_t code_genstring(const char *str)
return 0;
if (!*str) {
if (!code_string_cached_empty) {
code_string_cached_empty = vec_size(code_chars);
vec_push(code_chars, 0);
if (!code->string_cached_empty) {
code->string_cached_empty = vec_size(code->chars);
vec_push(code->chars, 0);
}
return code_string_cached_empty;
return code->string_cached_empty;
}
if (OPTS_OPTIMIZATION(OPTIM_OVERLAP_STRINGS)) {
hash = ((unsigned char*)str)[strlen(str)-1];
existing = code_util_str_htgeth(code_string_cache, str, hash);
hash = ((unsigned char*)str)[strlen(str)-1];
existing = code_util_str_htgeth(code->string_cache, str, hash);
} else {
hash = util_hthash(code_string_cache, str);
existing = util_htgeth(code_string_cache, str, hash);
hash = util_hthash(code->string_cache, str);
existing = util_htgeth(code->string_cache, str, hash);
}
if (existing)
return HASH_ENTRY_TO_QCINT(existing);
off = vec_size(code_chars);
vec_upload(code_chars, str, strlen(str)+1);
off = vec_size(code->chars);
vec_upload(code->chars, str, strlen(str)+1);
util_htseth(code_string_cache, str, hash, QCINT_TO_HASH_ENTRY(off));
util_htseth(code->string_cache, str, hash, QCINT_TO_HASH_ENTRY(off));
return off;
}
qcint code_alloc_field (size_t qcsize)
qcint code_alloc_field (code_t *code, size_t qcsize)
{
qcint pos = (qcint)code_entfields;
code_entfields += qcsize;
qcint pos = (qcint)code->entfields;
code->entfields += qcsize;
return pos;
}
bool code_write(const char *filename, const char *lnofile) {
bool code_write(code_t *code, const char *filename, const char *lnofile) {
prog_header code_header;
FILE *fp = NULL;
size_t it = 2;
code_header.statements.offset = sizeof(prog_header);
code_header.statements.length = vec_size(code_statements);
code_header.defs.offset = code_header.statements.offset + (sizeof(prog_section_statement) * vec_size(code_statements));
code_header.defs.length = vec_size(code_defs);
code_header.fields.offset = code_header.defs.offset + (sizeof(prog_section_def) * vec_size(code_defs));
code_header.fields.length = vec_size(code_fields);
code_header.functions.offset = code_header.fields.offset + (sizeof(prog_section_field) * vec_size(code_fields));
code_header.functions.length = vec_size(code_functions);
code_header.globals.offset = code_header.functions.offset + (sizeof(prog_section_function) * vec_size(code_functions));
code_header.globals.length = vec_size(code_globals);
code_header.strings.offset = code_header.globals.offset + (sizeof(int32_t) * vec_size(code_globals));
code_header.strings.length = vec_size(code_chars);
code_header.statements.length = vec_size(code->statements);
code_header.defs.offset = code_header.statements.offset + (sizeof(prog_section_statement) * vec_size(code->statements));
code_header.defs.length = vec_size(code->defs);
code_header.fields.offset = code_header.defs.offset + (sizeof(prog_section_def) * vec_size(code->defs));
code_header.fields.length = vec_size(code->fields);
code_header.functions.offset = code_header.fields.offset + (sizeof(prog_section_field) * vec_size(code->fields));
code_header.functions.length = vec_size(code->functions);
code_header.globals.offset = code_header.functions.offset + (sizeof(prog_section_function) * vec_size(code->functions));
code_header.globals.length = vec_size(code->globals);
code_header.strings.offset = code_header.globals.offset + (sizeof(int32_t) * vec_size(code->globals));
code_header.strings.length = vec_size(code->chars);
code_header.version = 6;
if (OPTS_OPTION_BOOL(OPTION_FORCECRC))
code_header.crc16 = OPTS_OPTION_U16(OPTION_FORCED_CRC);
else
code_header.crc16 = code_crc;
code_header.entfield = code_entfields;
code_header.crc16 = code->crc;
code_header.entfield = code->entfields;
if (OPTS_FLAG(DARKPLACES_STRING_TABLE_BUG)) {
util_debug("GEN", "Patching stringtable for -fdarkplaces-stringtablebug\n");
/* >= + P */
vec_push(code_chars, '\0'); /* > */
vec_push(code_chars, '\0'); /* = */
vec_push(code_chars, '\0'); /* P */
vec_push(code->chars, '\0'); /* > */
vec_push(code->chars, '\0'); /* = */
vec_push(code->chars, '\0'); /* P */
}
/* ensure all data is in LE format */
@ -162,11 +158,11 @@ bool code_write(const char *filename, const char *lnofile) {
util_endianswap(&code_header.strings, 2, sizeof(code_header.statements.offset));
util_endianswap(&code_header.globals, 2, sizeof(code_header.statements.offset));
util_endianswap(&code_header.entfield, 1, sizeof(code_header.entfield));
util_endianswap(code_statements, vec_size(code_statements), sizeof(prog_section_statement));
util_endianswap(code_defs, vec_size(code_defs), sizeof(prog_section_def));
util_endianswap(code_fields, vec_size(code_fields), sizeof(prog_section_field));
util_endianswap(code_functions, vec_size(code_functions), sizeof(prog_section_function));
util_endianswap(code_globals, vec_size(code_globals), sizeof(int32_t));
util_endianswap(code->statements, vec_size(code->statements), sizeof(prog_section_statement));
util_endianswap(code->defs, vec_size(code->defs), sizeof(prog_section_def));
util_endianswap(code->fields, vec_size(code->fields), sizeof(prog_section_field));
util_endianswap(code->functions, vec_size(code->functions), sizeof(prog_section_function));
util_endianswap(code->globals, vec_size(code->globals), sizeof(int32_t));
if (lnofile) {
uint32_t version = 1;
@ -175,17 +171,17 @@ bool code_write(const char *filename, const char *lnofile) {
if (!fp)
return false;
util_endianswap(&version, 1, sizeof(version));
util_endianswap(code_linenums, vec_size(code_linenums), sizeof(code_linenums[0]));
util_endianswap(&version, 1, sizeof(version));
util_endianswap(code->linenums, vec_size(code->linenums), sizeof(code->linenums[0]));
if (fs_file_write("LNOF", 4, 1, fp) != 1 ||
fs_file_write(&version, sizeof(version), 1, fp) != 1 ||
fs_file_write(&code_header.defs.length, sizeof(code_header.defs.length), 1, fp) != 1 ||
fs_file_write(&code_header.globals.length, sizeof(code_header.globals.length), 1, fp) != 1 ||
fs_file_write(&code_header.fields.length, sizeof(code_header.fields.length), 1, fp) != 1 ||
fs_file_write(&code_header.statements.length, sizeof(code_header.statements.length), 1, fp) != 1 ||
fs_file_write(code_linenums, sizeof(code_linenums[0]), vec_size(code_linenums), fp) != vec_size(code_linenums))
if (fs_file_write("LNOF", 4, 1, fp) != 1 ||
fs_file_write(&version, sizeof(version), 1, fp) != 1 ||
fs_file_write(&code_header.defs.length, sizeof(code_header.defs.length), 1, fp) != 1 ||
fs_file_write(&code_header.globals.length, sizeof(code_header.globals.length), 1, fp) != 1 ||
fs_file_write(&code_header.fields.length, sizeof(code_header.fields.length), 1, fp) != 1 ||
fs_file_write(&code_header.statements.length, sizeof(code_header.statements.length), 1, fp) != 1 ||
fs_file_write(code->linenums, sizeof(code->linenums[0]), vec_size(code->linenums), fp) != vec_size(code->linenums))
{
con_err("failed to write lno file\n");
}
@ -198,13 +194,13 @@ bool code_write(const char *filename, const char *lnofile) {
if (!fp)
return false;
if (1 != fs_file_write(&code_header, sizeof(prog_header) , 1 , fp) ||
vec_size(code_statements) != fs_file_write(code_statements, sizeof(prog_section_statement), vec_size(code_statements), fp) ||
vec_size(code_defs) != fs_file_write(code_defs, sizeof(prog_section_def) , vec_size(code_defs) , fp) ||
vec_size(code_fields) != fs_file_write(code_fields, sizeof(prog_section_field) , vec_size(code_fields) , fp) ||
vec_size(code_functions) != fs_file_write(code_functions, sizeof(prog_section_function) , vec_size(code_functions) , fp) ||
vec_size(code_globals) != fs_file_write(code_globals, sizeof(int32_t) , vec_size(code_globals) , fp) ||
vec_size(code_chars) != fs_file_write(code_chars, 1 , vec_size(code_chars) , fp))
if (1 != fs_file_write(&code_header, sizeof(prog_header) , 1 , fp) ||
vec_size(code->statements) != fs_file_write(code->statements, sizeof(prog_section_statement), vec_size(code->statements), fp) ||
vec_size(code->defs) != fs_file_write(code->defs, sizeof(prog_section_def) , vec_size(code->defs) , fp) ||
vec_size(code->fields) != fs_file_write(code->fields, sizeof(prog_section_field) , vec_size(code->fields) , fp) ||
vec_size(code->functions) != fs_file_write(code->functions, sizeof(prog_section_function) , vec_size(code->functions) , fp) ||
vec_size(code->globals) != fs_file_write(code->globals, sizeof(int32_t) , vec_size(code->globals) , fp) ||
vec_size(code->chars) != fs_file_write(code->chars, 1 , vec_size(code->chars) , fp))
{
fs_file_close(fp);
return false;
@ -223,37 +219,37 @@ bool code_write(const char *filename, const char *lnofile) {
/* FUNCTIONS */
util_debug("GEN", "FUNCTIONS:\n");
for (; it < vec_size(code_functions); it++) {
size_t j = code_functions[it].entry;
for (; it < vec_size(code->functions); it++) {
size_t j = code->functions[it].entry;
util_debug("GEN", " {.entry =% 5d, .firstlocal =% 5d, .locals =% 5d, .profile =% 5d, .name =% 5d, .file =% 5d, .nargs =% 5d, .argsize ={%d,%d,%d,%d,%d,%d,%d,%d} }\n",
code_functions[it].entry,
code_functions[it].firstlocal,
code_functions[it].locals,
code_functions[it].profile,
code_functions[it].name,
code_functions[it].file,
code_functions[it].nargs,
code_functions[it].argsize[0],
code_functions[it].argsize[1],
code_functions[it].argsize[2],
code_functions[it].argsize[3],
code_functions[it].argsize[4],
code_functions[it].argsize[5],
code_functions[it].argsize[6],
code_functions[it].argsize[7]
code->functions[it].entry,
code->functions[it].firstlocal,
code->functions[it].locals,
code->functions[it].profile,
code->functions[it].name,
code->functions[it].file,
code->functions[it].nargs,
code->functions[it].argsize[0],
code->functions[it].argsize[1],
code->functions[it].argsize[2],
code->functions[it].argsize[3],
code->functions[it].argsize[4],
code->functions[it].argsize[5],
code->functions[it].argsize[6],
code->functions[it].argsize[7]
);
util_debug("GEN", " NAME: %s\n", &code_chars[code_functions[it].name]);
util_debug("GEN", " NAME: %s\n", &code->chars[code->functions[it].name]);
/* Internal functions have no code */
if (code_functions[it].entry >= 0) {
if (code->functions[it].entry >= 0) {
util_debug("GEN", " CODE:\n");
for (;;) {
if (code_statements[j].opcode != INSTR_DONE)
if (code->statements[j].opcode != INSTR_DONE)
util_debug("GEN", " %-12s {% 5i,% 5i,% 5i}\n",
asm_instr[code_statements[j].opcode].m,
code_statements[j].o1.s1,
code_statements[j].o2.s1,
code_statements[j].o3.s1
asm_instr[code->statements[j].opcode].m,
code->statements[j].o1.s1,
code->statements[j].o2.s1,
code->statements[j].o3.s1
);
else {
util_debug("GEN", " DONE {0x00000,0x00000,0x00000}\n");
@ -264,15 +260,17 @@ bool code_write(const char *filename, const char *lnofile) {
}
}
vec_free(code_statements);
vec_free(code_linenums);
vec_free(code_defs);
vec_free(code_fields);
vec_free(code_functions);
vec_free(code_globals);
vec_free(code_chars);
util_htdel(code_string_cache);
vec_free(code->statements);
vec_free(code->linenums);
vec_free(code->defs);
vec_free(code->fields);
vec_free(code->functions);
vec_free(code->globals);
vec_free(code->chars);
util_htdel(code->string_cache);
fs_file_close(fp);
mem_d(code);
return true;
}

48
gmqcc.h
View file

@ -703,32 +703,38 @@ enum {
VINSTR_NRCALL
};
/* TODO: cleanup this mess */
extern prog_section_statement *code_statements;
extern int *code_linenums;
extern prog_section_def *code_defs;
extern prog_section_field *code_fields;
extern prog_section_function *code_functions;
extern int *code_globals;
extern char *code_chars;
extern uint16_t code_crc;
/* uhh? */
typedef float qcfloat;
typedef int32_t qcint;
/*
* code_write -- writes out the compiled file
* code_init -- prepares the code file
*/
bool code_write (const char *filename, const char *lno);
void code_init ();
uint32_t code_genstring (const char *string);
qcint code_alloc_field (size_t qcsize);
typedef struct {
prog_section_statement *statements;
int *linenums;
prog_section_def *defs;
prog_section_field *fields;
prog_section_function *functions;
int *globals;
char *chars;
uint16_t crc;
uint32_t entfields;
ht string_cache;
qcint string_cached_empty;
} code_t;
/* this function is used to keep statements and linenumbers together */
void code_push_statement(prog_section_statement *stmt, int linenum);
void code_pop_statement();
/*
* code_write -- writes out the compiled file
* code_init -- prepares the code file
* code_genstrin -- generates string for code
* code_alloc_field -- allocated a field
* code_push_statement -- keeps statements and linenumbers together
* code_pop_statement -- keeps statements and linenumbers together
*/
bool code_write (code_t *, const char *filename, const char *lno);
code_t *code_init (void);
uint32_t code_genstring (code_t *, const char *string);
qcint code_alloc_field (code_t *, size_t qcsize);
void code_push_statement(code_t *, prog_section_statement *stmt, int linenum);
void code_pop_statement (code_t *);
/*
* A shallow copy of a lex_file to remember where which ast node

342
ir.c
View file

@ -212,7 +212,7 @@ const uint16_t type_not_instr[TYPE_COUNT] = {
/* protos */
static ir_value* ir_gen_extparam_proto(ir_builder *ir);
static void ir_gen_extparam (ir_builder *ir);
static void ir_gen_extparam (code_t *, ir_builder *ir);
/* error functions */
@ -2618,9 +2618,9 @@ bool ir_function_calculate_liferanges(ir_function *self)
*
* Breaking conventions is annoying...
*/
static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool islocal);
static bool ir_builder_gen_global(code_t *, ir_builder *self, ir_value *global, bool islocal);
static bool gen_global_field(ir_value *global)
static bool gen_global_field(code_t *code, ir_value *global)
{
if (global->hasvalue)
{
@ -2631,20 +2631,20 @@ static bool gen_global_field(ir_value *global)
}
/* copy the field's value */
ir_value_code_setaddr(global, vec_size(code_globals));
vec_push(code_globals, fld->code.fieldaddr);
ir_value_code_setaddr(global, vec_size(code->globals));
vec_push(code->globals, fld->code.fieldaddr);
if (global->fieldtype == TYPE_VECTOR) {
vec_push(code_globals, fld->code.fieldaddr+1);
vec_push(code_globals, fld->code.fieldaddr+2);
vec_push(code->globals, fld->code.fieldaddr+1);
vec_push(code->globals, fld->code.fieldaddr+2);
}
}
else
{
ir_value_code_setaddr(global, vec_size(code_globals));
vec_push(code_globals, 0);
ir_value_code_setaddr(global, vec_size(code->globals));
vec_push(code->globals, 0);
if (global->fieldtype == TYPE_VECTOR) {
vec_push(code_globals, 0);
vec_push(code_globals, 0);
vec_push(code->globals, 0);
vec_push(code->globals, 0);
}
}
if (global->code.globaladdr < 0)
@ -2652,7 +2652,7 @@ static bool gen_global_field(ir_value *global)
return true;
}
static bool gen_global_pointer(ir_value *global)
static bool gen_global_pointer(code_t *code, ir_value *global)
{
if (global->hasvalue)
{
@ -2678,20 +2678,20 @@ static bool gen_global_pointer(ir_value *global)
return false;
}
ir_value_code_setaddr(global, vec_size(code_globals));
vec_push(code_globals, target->code.globaladdr);
ir_value_code_setaddr(global, vec_size(code->globals));
vec_push(code->globals, target->code.globaladdr);
}
else
{
ir_value_code_setaddr(global, vec_size(code_globals));
vec_push(code_globals, 0);
ir_value_code_setaddr(global, vec_size(code->globals));
vec_push(code->globals, 0);
}
if (global->code.globaladdr < 0)
return false;
return true;
}
static bool gen_blocks_recursive(ir_function *func, ir_block *block)
static bool gen_blocks_recursive(code_t *code, ir_function *func, ir_block *block)
{
prog_section_statement stmt;
ir_instr *instr;
@ -2702,7 +2702,7 @@ static bool gen_blocks_recursive(ir_function *func, ir_block *block)
size_t i;
block->generated = true;
block->code_start = vec_size(code_statements);
block->code_start = vec_size(code->statements);
for (i = 0; i < vec_size(block->instr); ++i)
{
instr = block->instr[i];
@ -2718,15 +2718,15 @@ static bool gen_blocks_recursive(ir_function *func, ir_block *block)
* yet, we generate them right here.
*/
if (!target->generated)
return gen_blocks_recursive(func, target);
return gen_blocks_recursive(code, func, target);
/* otherwise we generate a jump instruction */
stmt.opcode = INSTR_GOTO;
stmt.o1.s1 = (target->code_start) - vec_size(code_statements);
stmt.o1.s1 = (target->code_start) - vec_size(code->statements);
stmt.o2.s1 = 0;
stmt.o3.s1 = 0;
if (stmt.o1.s1 != 1)
code_push_statement(&stmt, instr->context.line);
code_push_statement(code, &stmt, instr->context.line);
/* no further instructions can be in this block */
return true;
@ -2745,23 +2745,23 @@ static bool gen_blocks_recursive(ir_function *func, ir_block *block)
if (ontrue->generated) {
stmt.opcode = INSTR_IF;
stmt.o2.s1 = (ontrue->code_start) - vec_size(code_statements);
stmt.o2.s1 = (ontrue->code_start) - vec_size(code->statements);
if (stmt.o2.s1 != 1)
code_push_statement(&stmt, instr->context.line);
code_push_statement(code, &stmt, instr->context.line);
}
if (onfalse->generated) {
stmt.opcode = INSTR_IFNOT;
stmt.o2.s1 = (onfalse->code_start) - vec_size(code_statements);
stmt.o2.s1 = (onfalse->code_start) - vec_size(code->statements);
if (stmt.o2.s1 != 1)
code_push_statement(&stmt, instr->context.line);
code_push_statement(code, &stmt, instr->context.line);
}
if (!ontrue->generated) {
if (onfalse->generated)
return gen_blocks_recursive(func, ontrue);
return gen_blocks_recursive(code, func, ontrue);
}
if (!onfalse->generated) {
if (ontrue->generated)
return gen_blocks_recursive(func, onfalse);
return gen_blocks_recursive(code, func, onfalse);
}
/* neither ontrue nor onfalse exist */
stmt.opcode = INSTR_IFNOT;
@ -2772,24 +2772,24 @@ static bool gen_blocks_recursive(ir_function *func, ir_block *block)
onfalse = ontrue;
ontrue = tmp;
}
stidx = vec_size(code_statements);
code_push_statement(&stmt, instr->context.line);
stidx = vec_size(code->statements);
code_push_statement(code, &stmt, instr->context.line);
/* on false we jump, so add ontrue-path */
if (!gen_blocks_recursive(func, ontrue))
if (!gen_blocks_recursive(code, func, ontrue))
return false;
/* fixup the jump address */
code_statements[stidx].o2.s1 = vec_size(code_statements) - stidx;
code->statements[stidx].o2.s1 = vec_size(code->statements) - stidx;
/* generate onfalse path */
if (onfalse->generated) {
/* fixup the jump address */
code_statements[stidx].o2.s1 = (onfalse->code_start) - (stidx);
if (stidx+2 == vec_size(code_statements) && code_statements[stidx].o2.s1 == 1) {
code_statements[stidx] = code_statements[stidx+1];
if (code_statements[stidx].o1.s1 < 0)
code_statements[stidx].o1.s1++;
code_pop_statement();
code->statements[stidx].o2.s1 = (onfalse->code_start) - (stidx);
if (stidx+2 == vec_size(code->statements) && code->statements[stidx].o2.s1 == 1) {
code->statements[stidx] = code->statements[stidx+1];
if (code->statements[stidx].o1.s1 < 0)
code->statements[stidx].o1.s1++;
code_pop_statement(code);
}
stmt.opcode = vec_last(code_statements).opcode;
stmt.opcode = vec_last(code->statements).opcode;
if (stmt.opcode == INSTR_GOTO ||
stmt.opcode == INSTR_IF ||
stmt.opcode == INSTR_IFNOT ||
@ -2801,21 +2801,21 @@ static bool gen_blocks_recursive(ir_function *func, ir_block *block)
}
/* may have been generated in the previous recursive call */
stmt.opcode = INSTR_GOTO;
stmt.o1.s1 = (onfalse->code_start) - vec_size(code_statements);
stmt.o1.s1 = (onfalse->code_start) - vec_size(code->statements);
stmt.o2.s1 = 0;
stmt.o3.s1 = 0;
if (stmt.o1.s1 != 1)
code_push_statement(&stmt, instr->context.line);
code_push_statement(code, &stmt, instr->context.line);
return true;
}
else if (stidx+2 == vec_size(code_statements) && code_statements[stidx].o2.s1 == 1) {
code_statements[stidx] = code_statements[stidx+1];
if (code_statements[stidx].o1.s1 < 0)
code_statements[stidx].o1.s1++;
code_pop_statement();
else if (stidx+2 == vec_size(code->statements) && code->statements[stidx].o2.s1 == 1) {
code->statements[stidx] = code->statements[stidx+1];
if (code->statements[stidx].o1.s1 < 0)
code->statements[stidx].o1.s1++;
code_pop_statement(code);
}
/* if not, generate now */
return gen_blocks_recursive(func, onfalse);
return gen_blocks_recursive(code, func, onfalse);
}
if ( (instr->opcode >= INSTR_CALL0 && instr->opcode <= INSTR_CALL8)
@ -2844,7 +2844,7 @@ static bool gen_blocks_recursive(ir_function *func, ir_block *block)
stmt.opcode = type_store_instr[param->vtype];
stmt.o1.u1 = ir_value_code_addr(param);
stmt.o2.u1 = OFS_PARM0 + 3 * p;
code_push_statement(&stmt, instr->context.line);
code_push_statement(code, &stmt, instr->context.line);
}
/* Now handle extparams */
first = vec_size(instr->params);
@ -2858,7 +2858,7 @@ static bool gen_blocks_recursive(ir_function *func, ir_block *block)
continue;
if (p-8 >= vec_size(ir->extparams))
ir_gen_extparam(ir);
ir_gen_extparam(code, ir);
targetparam = ir->extparams[p-8];
@ -2873,7 +2873,7 @@ static bool gen_blocks_recursive(ir_function *func, ir_block *block)
stmt.opcode = type_store_instr[param->vtype];
stmt.o1.u1 = ir_value_code_addr(param);
stmt.o2.u1 = ir_value_code_addr(targetparam);
code_push_statement(&stmt, instr->context.line);
code_push_statement(code, &stmt, instr->context.line);
}
stmt.opcode = INSTR_CALL0 + vec_size(instr->params);
@ -2882,7 +2882,7 @@ static bool gen_blocks_recursive(ir_function *func, ir_block *block)
stmt.o1.u1 = ir_value_code_addr(instr->_ops[1]);
stmt.o2.u1 = 0;
stmt.o3.u1 = 0;
code_push_statement(&stmt, instr->context.line);
code_push_statement(code, &stmt, instr->context.line);
retvalue = instr->_ops[0];
if (retvalue && retvalue->store != store_return &&
@ -2896,7 +2896,7 @@ static bool gen_blocks_recursive(ir_function *func, ir_block *block)
stmt.o1.u1 = OFS_RETURN;
stmt.o2.u1 = ir_value_code_addr(retvalue);
stmt.o3.u1 = 0;
code_push_statement(&stmt, instr->context.line);
code_push_statement(code, &stmt, instr->context.line);
}
continue;
}
@ -2946,12 +2946,12 @@ static bool gen_blocks_recursive(ir_function *func, ir_block *block)
}
}
code_push_statement(&stmt, instr->context.line);
code_push_statement(code, &stmt, instr->context.line);
}
return true;
}
static bool gen_function_code(ir_function *self)
static bool gen_function_code(code_t *code, ir_function *self)
{
ir_block *block;
prog_section_statement stmt, *retst;
@ -2968,13 +2968,13 @@ static bool gen_function_code(ir_function *self)
if (block->generated)
return true;
if (!gen_blocks_recursive(self, block)) {
if (!gen_blocks_recursive(code, self, block)) {
irerror(self->context, "failed to generate blocks for '%s'", self->name);
return false;
}
/* code_write and qcvm -disasm need to know that the function ends here */
retst = &vec_last(code_statements);
retst = &vec_last(code->statements);
if (OPTS_OPTIMIZATION(OPTIM_VOID_RETURN) &&
self->outtype == TYPE_VOID &&
retst->opcode == INSTR_RETURN &&
@ -2987,12 +2987,12 @@ static bool gen_function_code(ir_function *self)
stmt.o1.u1 = 0;
stmt.o2.u1 = 0;
stmt.o3.u1 = 0;
code_push_statement(&stmt, vec_last(code_linenums));
code_push_statement(code, &stmt, vec_last(code->linenums));
}
return true;
}
static qcint ir_builder_filestring(ir_builder *ir, const char *filename)
static qcint ir_builder_filestring(code_t *code, ir_builder *ir, const char *filename)
{
/* NOTE: filename pointers are copied, we never strdup them,
* thus we can use pointer-comparison to find the string.
@ -3005,13 +3005,13 @@ static qcint ir_builder_filestring(ir_builder *ir, const char *filename)
return ir->filestrings[i];
}
str = code_genstring(filename);
str = code_genstring(code, filename);
vec_push(ir->filenames, filename);
vec_push(ir->filestrings, str);
return str;
}
static bool gen_global_function(ir_builder *ir, ir_value *global)
static bool gen_global_function(code_t *code, ir_builder *ir, ir_value *global)
{
prog_section_function fun;
ir_function *irfun;
@ -3027,7 +3027,7 @@ static bool gen_global_function(ir_builder *ir, ir_value *global)
irfun = global->constval.vfunc;
fun.name = global->code.name;
fun.file = ir_builder_filestring(ir, global->context.file);
fun.file = ir_builder_filestring(code, ir, global->context.file);
fun.profile = 0; /* always 0 */
fun.nargs = vec_size(irfun->params);
if (fun.nargs > 8)
@ -3046,11 +3046,11 @@ static bool gen_global_function(ir_builder *ir, ir_value *global)
if (irfun->builtin)
fun.entry = irfun->builtin+1;
else {
irfun->code_function_def = vec_size(code_functions);
fun.entry = vec_size(code_statements);
irfun->code_function_def = vec_size(code->functions);
fun.entry = vec_size(code->statements);
}
vec_push(code_functions, fun);
vec_push(code->functions, fun);
return true;
}
@ -3066,7 +3066,7 @@ static ir_value* ir_gen_extparam_proto(ir_builder *ir)
return global;
}
static void ir_gen_extparam(ir_builder *ir)
static void ir_gen_extparam(code_t *code, ir_builder *ir)
{
prog_section_def def;
ir_value *global;
@ -3076,20 +3076,22 @@ static void ir_gen_extparam(ir_builder *ir)
else
global = ir->extparam_protos[vec_size(ir->extparams)];
def.name = code_genstring(global->name);
def.type = TYPE_VECTOR;
def.offset = vec_size(code_globals);
def.name = code_genstring(code, global->name);
def.type = TYPE_VECTOR;
def.offset = vec_size(code->globals);
vec_push(code->defs, def);
vec_push(code_defs, def);
ir_value_code_setaddr(global, def.offset);
vec_push(code_globals, 0);
vec_push(code_globals, 0);
vec_push(code_globals, 0);
vec_push(code->globals, 0);
vec_push(code->globals, 0);
vec_push(code->globals, 0);
vec_push(ir->extparams, global);
}
static bool gen_function_extparam_copy(ir_function *self)
static bool gen_function_extparam_copy(code_t *code, ir_function *self)
{
size_t i, ext, numparams;
@ -3106,7 +3108,7 @@ static bool gen_function_extparam_copy(ir_function *self)
for (i = 8; i < numparams; ++i) {
ext = i - 8;
if (ext >= vec_size(ir->extparams))
ir_gen_extparam(ir);
ir_gen_extparam(code, ir);
ep = ir->extparams[ext];
@ -3118,13 +3120,13 @@ static bool gen_function_extparam_copy(ir_function *self)
}
stmt.o1.u1 = ir_value_code_addr(ep);
stmt.o2.u1 = ir_value_code_addr(self->locals[i]);
code_push_statement(&stmt, self->context.line);
code_push_statement(code, &stmt, self->context.line);
}
return true;
}
static bool gen_function_varargs_copy(ir_function *self)
static bool gen_function_varargs_copy(code_t *code, ir_function *self)
{
size_t i, ext, numparams, maxparams;
@ -3143,24 +3145,24 @@ static bool gen_function_varargs_copy(ir_function *self)
if (i < 8) {
stmt.o1.u1 = OFS_PARM0 + 3*i;
stmt.o2.u1 = ir_value_code_addr(self->locals[i]);
code_push_statement(&stmt, self->context.line);
code_push_statement(code, &stmt, self->context.line);
continue;
}
ext = i - 8;
while (ext >= vec_size(ir->extparams))
ir_gen_extparam(ir);
ir_gen_extparam(code, ir);
ep = ir->extparams[ext];
stmt.o1.u1 = ir_value_code_addr(ep);
stmt.o2.u1 = ir_value_code_addr(self->locals[i]);
code_push_statement(&stmt, self->context.line);
code_push_statement(code, &stmt, self->context.line);
}
return true;
}
static bool gen_function_locals(ir_builder *ir, ir_value *global)
static bool gen_function_locals(code_t *code, ir_builder *ir, ir_value *global)
{
prog_section_function *def;
ir_function *irfun;
@ -3168,13 +3170,13 @@ static bool gen_function_locals(ir_builder *ir, ir_value *global)
uint32_t firstlocal, firstglobal;
irfun = global->constval.vfunc;
def = code_functions + irfun->code_function_def;
def = code->functions + irfun->code_function_def;
if (OPTS_OPTION_BOOL(OPTION_G) ||
!OPTS_OPTIMIZATION(OPTIM_OVERLAP_LOCALS) ||
(irfun->flags & IR_FLAG_MASK_NO_OVERLAP))
{
firstlocal = def->firstlocal = vec_size(code_globals);
firstlocal = def->firstlocal = vec_size(code->globals);
} else {
firstlocal = def->firstlocal = ir->first_common_local;
++opts_optimizationcount[OPTIM_OVERLAP_LOCALS];
@ -3182,13 +3184,13 @@ static bool gen_function_locals(ir_builder *ir, ir_value *global)
firstglobal = (OPTS_OPTIMIZATION(OPTIM_GLOBAL_TEMPS) ? ir->first_common_globaltemp : firstlocal);
for (i = vec_size(code_globals); i < firstlocal + irfun->allocated_locals; ++i)
vec_push(code_globals, 0);
for (i = vec_size(code->globals); i < firstlocal + irfun->allocated_locals; ++i)
vec_push(code->globals, 0);
for (i = 0; i < vec_size(irfun->locals); ++i) {
ir_value *v = irfun->locals[i];
if (v->locked || !OPTS_OPTIMIZATION(OPTIM_GLOBAL_TEMPS)) {
ir_value_code_setaddr(v, firstlocal + v->code.local);
if (!ir_builder_gen_global(ir, irfun->locals[i], true)) {
if (!ir_builder_gen_global(code, ir, irfun->locals[i], true)) {
irerror(irfun->locals[i]->context, "failed to generate local %s", irfun->locals[i]->name);
return false;
}
@ -3209,7 +3211,7 @@ static bool gen_function_locals(ir_builder *ir, ir_value *global)
return true;
}
static bool gen_global_function_code(ir_builder *ir, ir_value *global)
static bool gen_global_function_code(code_t *code, ir_builder *ir, ir_value *global)
{
prog_section_function *fundef;
ir_function *irfun;
@ -3233,29 +3235,29 @@ static bool gen_global_function_code(ir_builder *ir, ir_value *global)
irerror(irfun->context, "`%s`: IR global wasn't generated, failed to access function-def", irfun->name);
return false;
}
fundef = &code_functions[irfun->code_function_def];
fundef = &code->functions[irfun->code_function_def];
fundef->entry = vec_size(code_statements);
if (!gen_function_locals(ir, global)) {
fundef->entry = vec_size(code->statements);
if (!gen_function_locals(code, ir, global)) {
irerror(irfun->context, "Failed to generate locals for function %s", irfun->name);
return false;
}
if (!gen_function_extparam_copy(irfun)) {
if (!gen_function_extparam_copy(code, irfun)) {
irerror(irfun->context, "Failed to generate extparam-copy code for function %s", irfun->name);
return false;
}
if (irfun->max_varargs && !gen_function_varargs_copy(irfun)) {
if (irfun->max_varargs && !gen_function_varargs_copy(code, irfun)) {
irerror(irfun->context, "Failed to generate vararg-copy code for function %s", irfun->name);
return false;
}
if (!gen_function_code(irfun)) {
if (!gen_function_code(code, irfun)) {
irerror(irfun->context, "Failed to generate code for function %s", irfun->name);
return false;
}
return true;
}
static void gen_vector_defs(prog_section_def def, const char *name)
static void gen_vector_defs(code_t *code, prog_section_def def, const char *name)
{
char *component;
size_t len, i;
@ -3276,8 +3278,8 @@ static void gen_vector_defs(prog_section_def def, const char *name)
component[len-1] = 'x';
for (i = 0; i < 3; ++i) {
def.name = code_genstring(component);
vec_push(code_defs, def);
def.name = code_genstring(code, component);
vec_push(code->defs, def);
def.offset++;
component[len-1]++;
}
@ -3285,7 +3287,7 @@ static void gen_vector_defs(prog_section_def def, const char *name)
mem_d(component);
}
static void gen_vector_fields(prog_section_field fld, const char *name)
static void gen_vector_fields(code_t *code, prog_section_field fld, const char *name)
{
char *component;
size_t len, i;
@ -3306,8 +3308,8 @@ static void gen_vector_fields(prog_section_field fld, const char *name)
component[len-1] = 'x';
for (i = 0; i < 3; ++i) {
fld.name = code_genstring(component);
vec_push(code_fields, fld);
fld.name = code_genstring(code, component);
vec_push(code->fields, fld);
fld.offset++;
component[len-1]++;
}
@ -3315,7 +3317,7 @@ static void gen_vector_fields(prog_section_field fld, const char *name)
mem_d(component);
}
static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool islocal)
static bool ir_builder_gen_global(code_t *code, ir_builder *self, ir_value *global, bool islocal)
{
size_t i;
int32_t *iptr;
@ -3323,7 +3325,7 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool isloc
bool pushdef = opts.optimizeoff;
def.type = global->vtype;
def.offset = vec_size(code_globals);
def.offset = vec_size(code->globals);
def.name = 0;
if (OPTS_OPTION_BOOL(OPTION_G) || !islocal)
{
@ -3339,21 +3341,21 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool isloc
if (pushdef && global->name) {
if (global->name[0] == '#') {
if (!self->str_immediate)
self->str_immediate = code_genstring("IMMEDIATE");
self->str_immediate = code_genstring(code, "IMMEDIATE");
def.name = global->code.name = self->str_immediate;
}
else
def.name = global->code.name = code_genstring(global->name);
def.name = global->code.name = code_genstring(code, global->name);
}
else
def.name = 0;
if (islocal) {
def.offset = ir_value_code_addr(global);
vec_push(code_defs, def);
vec_push(code->defs, def);
if (global->vtype == TYPE_VECTOR)
gen_vector_defs(def, global->name);
gen_vector_defs(code, def, global->name);
else if (global->vtype == TYPE_FIELD && global->fieldtype == TYPE_VECTOR)
gen_vector_defs(def, global->name);
gen_vector_defs(code, def, global->name);
return true;
}
}
@ -3380,102 +3382,102 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool isloc
* Maybe this could be an -foption
* fteqcc creates data for end_sys_* - of size 1, so let's do the same
*/
ir_value_code_setaddr(global, vec_size(code_globals));
vec_push(code_globals, 0);
ir_value_code_setaddr(global, vec_size(code->globals));
vec_push(code->globals, 0);
/* Add the def */
if (pushdef) vec_push(code_defs, def);
if (pushdef) vec_push(code->defs, def);
return true;
case TYPE_POINTER:
if (pushdef) vec_push(code_defs, def);
return gen_global_pointer(global);
if (pushdef) vec_push(code->defs, def);
return gen_global_pointer(code, global);
case TYPE_FIELD:
if (pushdef) {
vec_push(code_defs, def);
vec_push(code->defs, def);
if (global->fieldtype == TYPE_VECTOR)
gen_vector_defs(def, global->name);
gen_vector_defs(code, def, global->name);
}
return gen_global_field(global);
return gen_global_field(code, global);
case TYPE_ENTITY:
/* fall through */
case TYPE_FLOAT:
{
ir_value_code_setaddr(global, vec_size(code_globals));
ir_value_code_setaddr(global, vec_size(code->globals));
if (global->hasvalue) {
iptr = (int32_t*)&global->constval.ivec[0];
vec_push(code_globals, *iptr);
vec_push(code->globals, *iptr);
} else {
vec_push(code_globals, 0);
vec_push(code->globals, 0);
}
if (!islocal && global->cvq != CV_CONST)
def.type |= DEF_SAVEGLOBAL;
if (pushdef) vec_push(code_defs, def);
if (pushdef) vec_push(code->defs, def);
return global->code.globaladdr >= 0;
}
case TYPE_STRING:
{
ir_value_code_setaddr(global, vec_size(code_globals));
ir_value_code_setaddr(global, vec_size(code->globals));
if (global->hasvalue) {
vec_push(code_globals, code_genstring(global->constval.vstring));
vec_push(code->globals, code_genstring(code, global->constval.vstring));
} else {
vec_push(code_globals, 0);
vec_push(code->globals, 0);
}
if (!islocal && global->cvq != CV_CONST)
def.type |= DEF_SAVEGLOBAL;
if (pushdef) vec_push(code_defs, def);
if (pushdef) vec_push(code->defs, def);
return global->code.globaladdr >= 0;
}
case TYPE_VECTOR:
{
size_t d;
ir_value_code_setaddr(global, vec_size(code_globals));
ir_value_code_setaddr(global, vec_size(code->globals));
if (global->hasvalue) {
iptr = (int32_t*)&global->constval.ivec[0];
vec_push(code_globals, iptr[0]);
vec_push(code->globals, iptr[0]);
if (global->code.globaladdr < 0)
return false;
for (d = 1; d < type_sizeof_[global->vtype]; ++d) {
vec_push(code_globals, iptr[d]);
vec_push(code->globals, iptr[d]);
}
} else {
vec_push(code_globals, 0);
vec_push(code->globals, 0);
if (global->code.globaladdr < 0)
return false;
for (d = 1; d < type_sizeof_[global->vtype]; ++d) {
vec_push(code_globals, 0);
vec_push(code->globals, 0);
}
}
if (!islocal && global->cvq != CV_CONST)
def.type |= DEF_SAVEGLOBAL;
if (pushdef) {
vec_push(code_defs, def);
vec_push(code->defs, def);
def.type &= ~DEF_SAVEGLOBAL;
gen_vector_defs(def, global->name);
gen_vector_defs(code, def, global->name);
}
return global->code.globaladdr >= 0;
}
case TYPE_FUNCTION:
ir_value_code_setaddr(global, vec_size(code_globals));
ir_value_code_setaddr(global, vec_size(code->globals));
if (!global->hasvalue) {
vec_push(code_globals, 0);
vec_push(code->globals, 0);
if (global->code.globaladdr < 0)
return false;
} else {
vec_push(code_globals, vec_size(code_functions));
if (!gen_global_function(self, global))
vec_push(code->globals, vec_size(code->functions));
if (!gen_global_function(code, self, global))
return false;
}
if (!islocal && global->cvq != CV_CONST)
def.type |= DEF_SAVEGLOBAL;
if (pushdef) vec_push(code_defs, def);
if (pushdef) vec_push(code->defs, def);
return true;
case TYPE_VARIANT:
/* assume biggest type */
ir_value_code_setaddr(global, vec_size(code_globals));
vec_push(code_globals, 0);
ir_value_code_setaddr(global, vec_size(code->globals));
vec_push(code->globals, 0);
for (i = 1; i < type_sizeof_[TYPE_VARIANT]; ++i)
vec_push(code_globals, 0);
vec_push(code->globals, 0);
return true;
default:
/* refuse to create 'void' type or any other fancy business. */
@ -3485,12 +3487,12 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool isloc
}
}
static void ir_builder_prepare_field(ir_value *field)
static GMQCC_INLINE void ir_builder_prepare_field(code_t *code, ir_value *field)
{
field->code.fieldaddr = code_alloc_field(type_sizeof_[field->fieldtype]);
field->code.fieldaddr = code_alloc_field(code, type_sizeof_[field->fieldtype]);
}
static bool ir_builder_gen_field(ir_builder *self, ir_value *field)
static bool ir_builder_gen_field(code_t *code, ir_builder *self, ir_value *field)
{
prog_section_def def;
prog_section_field fld;
@ -3498,7 +3500,7 @@ static bool ir_builder_gen_field(ir_builder *self, ir_value *field)
(void)self;
def.type = (uint16_t)field->vtype;
def.offset = (uint16_t)vec_size(code_globals);
def.offset = (uint16_t)vec_size(code->globals);
/* create a global named the same as the field */
if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_GMQCC) {
@ -3518,7 +3520,7 @@ static bool ir_builder_gen_field(ir_builder *self, ir_value *field)
memcpy(name+1, field->name, len); /* no strncpy - we used strlen above */
name[len+1] = 0;
def.name = code_genstring(name);
def.name = code_genstring(code, name);
fld.name = def.name + 1; /* we reuse that string table entry */
} else {
/* in plain QC, there cannot be a global with the same name,
@ -3526,13 +3528,13 @@ static bool ir_builder_gen_field(ir_builder *self, ir_value *field)
* FIXME: fteqcc should create a global as well
* check if it actually uses the same name. Probably does
*/
def.name = code_genstring(field->name);
def.name = code_genstring(code, field->name);
fld.name = def.name;
}
field->code.name = def.name;
vec_push(code_defs, def);
vec_push(code->defs, def);
fld.type = field->fieldtype;
@ -3543,24 +3545,24 @@ static bool ir_builder_gen_field(ir_builder *self, ir_value *field)
fld.offset = field->code.fieldaddr;
vec_push(code_fields, fld);
vec_push(code->fields, fld);
ir_value_code_setaddr(field, vec_size(code_globals));
vec_push(code_globals, fld.offset);
ir_value_code_setaddr(field, vec_size(code->globals));
vec_push(code->globals, fld.offset);
if (fld.type == TYPE_VECTOR) {
vec_push(code_globals, fld.offset+1);
vec_push(code_globals, fld.offset+2);
vec_push(code->globals, fld.offset+1);
vec_push(code->globals, fld.offset+2);
}
if (field->fieldtype == TYPE_VECTOR) {
gen_vector_defs(def, field->name);
gen_vector_fields(fld, field->name);
gen_vector_defs (code, def, field->name);
gen_vector_fields(code, fld, field->name);
}
return field->code.globaladdr >= 0;
}
bool ir_builder_generate(ir_builder *self, const char *filename)
bool ir_builder_generate(code_t *code, ir_builder *self, const char *filename)
{
prog_section_statement stmt;
size_t i;
@ -3570,12 +3572,12 @@ bool ir_builder_generate(ir_builder *self, const char *filename)
for (i = 0; i < vec_size(self->fields); ++i)
{
ir_builder_prepare_field(self->fields[i]);
ir_builder_prepare_field(code, self->fields[i]);
}
for (i = 0; i < vec_size(self->globals); ++i)
{
if (!ir_builder_gen_global(self, self->globals[i], false)) {
if (!ir_builder_gen_global(code, self, self->globals[i], false)) {
return false;
}
if (self->globals[i]->vtype == TYPE_FUNCTION) {
@ -3592,62 +3594,62 @@ bool ir_builder_generate(ir_builder *self, const char *filename)
for (i = 0; i < vec_size(self->fields); ++i)
{
if (!ir_builder_gen_field(self, self->fields[i])) {
if (!ir_builder_gen_field(code, self, self->fields[i])) {
return false;
}
}
/* generate nil */
ir_value_code_setaddr(self->nil, vec_size(code_globals));
vec_push(code_globals, 0);
vec_push(code_globals, 0);
vec_push(code_globals, 0);
ir_value_code_setaddr(self->nil, vec_size(code->globals));
vec_push(code->globals, 0);
vec_push(code->globals, 0);
vec_push(code->globals, 0);
/* generate global temps */
self->first_common_globaltemp = vec_size(code_globals);
self->first_common_globaltemp = vec_size(code->globals);
for (i = 0; i < self->max_globaltemps; ++i) {
vec_push(code_globals, 0);
vec_push(code->globals, 0);
}
/* generate common locals */
self->first_common_local = vec_size(code_globals);
self->first_common_local = vec_size(code->globals);
for (i = 0; i < self->max_locals; ++i) {
vec_push(code_globals, 0);
vec_push(code->globals, 0);
}
/* generate function code */
for (i = 0; i < vec_size(self->globals); ++i)
{
if (self->globals[i]->vtype == TYPE_FUNCTION) {
if (!gen_global_function_code(self, self->globals[i])) {
if (!gen_global_function_code(code, self, self->globals[i])) {
return false;
}
}
}
if (vec_size(code_globals) >= 65536) {
if (vec_size(code->globals) >= 65536) {
irerror(vec_last(self->globals)->context, "This progs file would require more globals than the metadata can handle. Bailing out.");
return false;
}
/* DP errors if the last instruction is not an INSTR_DONE. */
if (vec_last(code_statements).opcode != INSTR_DONE)
if (vec_last(code->statements).opcode != INSTR_DONE)
{
stmt.opcode = INSTR_DONE;
stmt.o1.u1 = 0;
stmt.o2.u1 = 0;
stmt.o3.u1 = 0;
code_push_statement(&stmt, vec_last(code_linenums));
code_push_statement(code, &stmt, vec_last(code->linenums));
}
if (OPTS_OPTION_BOOL(OPTION_PP_ONLY))
return true;
if (vec_size(code_statements) != vec_size(code_linenums)) {
if (vec_size(code->statements) != vec_size(code->linenums)) {
con_err("Linecounter wrong: %lu != %lu\n",
(unsigned long)vec_size(code_statements),
(unsigned long)vec_size(code_linenums));
(unsigned long)vec_size(code->statements),
(unsigned long)vec_size(code->linenums));
} else if (OPTS_FLAG(LNO)) {
char *dot;
char *dot;
size_t filelen = strlen(filename);
memcpy(vec_add(lnofile, filelen+1), filename, filelen+1);
@ -3666,7 +3668,7 @@ bool ir_builder_generate(ir_builder *self, const char *filename)
else
con_out("writing '%s'\n", filename);
}
if (!code_write(filename, lnofile)) {
if (!code_write(code, filename, lnofile)) {
vec_free(lnofile);
return false;
}

2
ir.h
View file

@ -349,7 +349,7 @@ ir_value* ir_builder_create_field(ir_builder*, const char *name, int vtype);
ir_value* ir_builder_get_va_count(ir_builder*);
bool ir_builder_generate(ir_builder *self, const char *filename);
bool ir_builder_generate(code_t *, ir_builder *self, const char *filename);
void ir_builder_dump(ir_builder*, int (*oprintf)(const char*, ...));

13
parser.c
View file

@ -103,6 +103,9 @@ typedef struct parser_s {
/* collected information */
size_t max_param_count;
/* code generator */
code_t *code;
} parser_t;
static ast_expression * const intrinsic_debug_typestring = (ast_expression*)0x1;
@ -5943,7 +5946,7 @@ static void generate_checksum(parser_t *parser)
}
crc = progdefs_crc_both(crc, "} entvars_t;\n\n");
code_crc = crc;
parser->code->crc = crc;
}
parser_t *parser_create()
@ -5958,6 +5961,12 @@ parser_t *parser_create()
memset(parser, 0, sizeof(*parser));
if (!(parser->code = code_init())) {
mem_d(parser);
return NULL;
}
for (i = 0; i < operator_count; ++i) {
if (operators[i].id == opid1('=')) {
parser->assign_op = operators+i;
@ -6313,7 +6322,7 @@ bool parser_finish(parser_t *parser, const char *output)
generate_checksum(parser);
if (!ir_builder_generate(ir, output)) {
if (!ir_builder_generate(parser->code, ir, output)) {
con_out("*** failed to generate output file\n");
ir_builder_delete(ir);
return false;