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

More std::vector migration

Browse source
This commit is contained in:
Dale Weiler 2015-01-15 01:22:21 -05:00
parent 2e3b3569bf
commit 35a8c3c9af
5 changed files with 335 additions and 370 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

127
code.cpp
View file

@ -94,16 +94,16 @@ void code_push_statement(code_t *code, prog_section_statement_t *stmt_in, lex_ct
}
}
vec_push(code->statements, stmt);
vec_push(code->linenums, (int)ctx.line);
vec_push(code->columnnums, (int)ctx.column);
code->statements.push_back(stmt);
code->linenums.push_back(ctx.line);
code->columnnums.push_back(ctx.column);
}
void code_pop_statement(code_t *code)
{
vec_pop(code->statements);
vec_pop(code->linenums);
vec_pop(code->columnnums);
code->statements.pop_back();
code->linenums.pop_back();
code->columnnums.pop_back();
}
code_t *code_init() {
@ -124,15 +124,15 @@ code_t *code_init() {
* some null (empty) statements, functions, and 28 globals
*/
for(; i < 28; i++)
vec_push(code->globals, 0);
code->globals.push_back(0);
vec_push(code->chars, '\0');
vec_push(code->functions, empty_function);
code->chars.push_back('\0');
code->functions.push_back(empty_function);
code_push_statement(code, &empty_statement, empty_ctx);
vec_push(code->defs, empty_def);
vec_push(code->fields, empty_def);
code->defs.push_back(empty_def);
code->fields.push_back(empty_def);
return code;
}
@ -148,8 +148,8 @@ uint32_t code_genstring(code_t *code, const char *str) {
if (!*str) {
if (!code->string_cached_empty) {
code->string_cached_empty = vec_size(code->chars);
vec_push(code->chars, 0);
code->string_cached_empty = code->chars.size();
code->chars.push_back(0);
}
return code->string_cached_empty;
}
@ -165,8 +165,9 @@ uint32_t code_genstring(code_t *code, const char *str) {
if (CODE_HASH_ENTER(existing))
return CODE_HASH_LEAVE(existing);
CODE_HASH_LEAVE(existing) = vec_size(code->chars);
vec_append(code->chars, strlen(str)+1, str);
CODE_HASH_LEAVE(existing) = code->chars.size();
code->chars.insert(code->chars.end(), str, str + strlen(str) + 1);
//vec_append(code->chars, strlen(str)+1, str);
util_htseth(code->string_cache, str, hash, CODE_HASH_ENTER(existing));
return CODE_HASH_LEAVE(existing);
@ -188,16 +189,16 @@ static size_t code_size_generic(code_t *code, prog_header_t *code_header, bool l
size += sizeof(code_header->globals.length);
size += sizeof(code_header->fields.length);
size += sizeof(code_header->statements.length);
size += sizeof(code->linenums[0]) * vec_size(code->linenums);
size += sizeof(code->columnnums[0]) * vec_size(code->columnnums);
size += sizeof(code->linenums[0]) * code->linenums.size();
size += sizeof(code->columnnums[0]) * code->columnnums.size();
} else {
size += sizeof(prog_header_t);
size += sizeof(prog_section_statement_t) * vec_size(code->statements);
size += sizeof(prog_section_def_t) * vec_size(code->defs);
size += sizeof(prog_section_field_t) * vec_size(code->fields);
size += sizeof(prog_section_function_t) * vec_size(code->functions);
size += sizeof(int32_t) * vec_size(code->globals);
size += 1 * vec_size(code->chars);
size += sizeof(prog_section_statement_t) * code->statements.size();
size += sizeof(prog_section_def_t) * code->defs.size();
size += sizeof(prog_section_field_t) * code->fields.size();
size += sizeof(prog_section_function_t) * code->functions.size();
size += sizeof(int32_t) * code->globals.size();
size += 1 * code->chars.size();
}
return size;
}
@ -209,17 +210,17 @@ static void code_create_header(code_t *code, prog_header_t *code_header, const c
size_t i;
code_header->statements.offset = sizeof(prog_header_t);
code_header->statements.length = vec_size(code->statements);
code_header->defs.offset = code_header->statements.offset + (sizeof(prog_section_statement_t) * vec_size(code->statements));
code_header->defs.length = vec_size(code->defs);
code_header->fields.offset = code_header->defs.offset + (sizeof(prog_section_def_t) * vec_size(code->defs));
code_header->fields.length = vec_size(code->fields);
code_header->functions.offset = code_header->fields.offset + (sizeof(prog_section_field_t) * vec_size(code->fields));
code_header->functions.length = vec_size(code->functions);
code_header->globals.offset = code_header->functions.offset + (sizeof(prog_section_function_t) * 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 = code->statements.size();
code_header->defs.offset = code_header->statements.offset + (sizeof(prog_section_statement_t) * code->statements.size());
code_header->defs.length = code->defs.size();
code_header->fields.offset = code_header->defs.offset + (sizeof(prog_section_def_t) * code->defs.size());
code_header->fields.length = code->fields.size();
code_header->functions.offset = code_header->fields.offset + (sizeof(prog_section_field_t) * code->fields.size());
code_header->functions.length = code->functions.size();
code_header->globals.offset = code_header->functions.offset + (sizeof(prog_section_function_t) * code->functions.size());
code_header->globals.length = code->globals.size();
code_header->strings.offset = code_header->globals.offset + (sizeof(int32_t) * code->globals.size());
code_header->strings.length = code->chars.size();
code_header->version = 6;
code_header->skip = 0;
@ -231,24 +232,18 @@ static void code_create_header(code_t *code, prog_header_t *code_header, const c
if (OPTS_FLAG(DARKPLACES_STRING_TABLE_BUG)) {
/* >= + P */
vec_push(code->chars, '\0'); /* > */
vec_push(code->chars, '\0'); /* = */
vec_push(code->chars, '\0'); /* P */
code->chars.push_back('\0'); /* > */
code->chars.push_back('\0'); /* = */
code->chars.push_back('\0'); /* P */
}
/* ensure all data is in LE format */
util_swap_header(code_header);
/*
* These are not part of the header but we ensure LE format here to save on duplicated
* code.
*/
util_swap_statements (code->statements);
util_swap_header(*code_header);
util_swap_statements(code->statements);
util_swap_defs_fields(code->defs);
util_swap_defs_fields(code->fields);
util_swap_functions (code->functions);
util_swap_globals (code->globals);
util_swap_functions(code->functions);
util_swap_globals(code->globals);
if (!OPTS_OPTION_BOOL(OPTION_QUIET)) {
if (lnofile)
@ -296,8 +291,8 @@ static void code_stats(const char *filename, const char *lnofile, code_t *code,
}
bool code_write(code_t *code, const char *filename, const char *lnofile) {
prog_header_t code_header;
FILE *fp = NULL;
prog_header_t code_header;
FILE *fp = NULL;
code_create_header(code, &code_header, filename, lnofile);
@ -308,9 +303,9 @@ bool code_write(code_t *code, 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(code->columnnums, vec_size(code->columnnums), sizeof(code->columnnums[0]));
util_endianswap(&version, 1, sizeof(version));
util_endianswap(&code->linenums[0], code->linenums.size(), sizeof(code->linenums[0]));
util_endianswap(&code->columnnums[0], code->columnnums.size(), sizeof(code->columnnums[0]));
if (fwrite("LNOF", 4, 1, fp) != 1 ||
fwrite(&version, sizeof(version), 1, fp) != 1 ||
@ -318,8 +313,8 @@ bool code_write(code_t *code, const char *filename, const char *lnofile) {
fwrite(&code_header.globals.length, sizeof(code_header.globals.length), 1, fp) != 1 ||
fwrite(&code_header.fields.length, sizeof(code_header.fields.length), 1, fp) != 1 ||
fwrite(&code_header.statements.length, sizeof(code_header.statements.length), 1, fp) != 1 ||
fwrite(code->linenums, sizeof(code->linenums[0]), vec_size(code->linenums), fp) != vec_size(code->linenums) ||
fwrite(code->columnnums, sizeof(code->columnnums[0]), vec_size(code->columnnums), fp) != vec_size(code->columnnums))
fwrite(&code->linenums[0], sizeof(code->linenums[0]), code->linenums.size(), fp) != code->linenums.size() ||
fwrite(&code->columnnums[0], sizeof(code->columnnums[0]), code->columnnums.size(), fp) != code->columnnums.size())
{
con_err("failed to write lno file\n");
}
@ -332,13 +327,13 @@ bool code_write(code_t *code, const char *filename, const char *lnofile) {
if (!fp)
return false;
if (1 != fwrite(&code_header, sizeof(prog_header_t) , 1 , fp) ||
vec_size(code->statements) != fwrite(code->statements, sizeof(prog_section_statement_t), vec_size(code->statements), fp) ||
vec_size(code->defs) != fwrite(code->defs, sizeof(prog_section_def_t) , vec_size(code->defs) , fp) ||
vec_size(code->fields) != fwrite(code->fields, sizeof(prog_section_field_t) , vec_size(code->fields) , fp) ||
vec_size(code->functions) != fwrite(code->functions, sizeof(prog_section_function_t) , vec_size(code->functions) , fp) ||
vec_size(code->globals) != fwrite(code->globals, sizeof(int32_t) , vec_size(code->globals) , fp) ||
vec_size(code->chars) != fwrite(code->chars, 1 , vec_size(code->chars) , fp))
if (1 != fwrite(&code_header, sizeof(prog_header_t) , 1 , fp) ||
code->statements.size() != fwrite(&code->statements[0], sizeof(prog_section_statement_t), code->statements.size(), fp) ||
code->defs.size() != fwrite(&code->defs[0], sizeof(prog_section_def_t) , code->defs.size() , fp) ||
code->fields.size() != fwrite(&code->fields[0], sizeof(prog_section_field_t) , code->fields.size() , fp) ||
code->functions.size() != fwrite(&code->functions[0], sizeof(prog_section_function_t) , code->functions.size() , fp) ||
code->globals.size() != fwrite(&code->globals[0], sizeof(int32_t) , code->globals.size() , fp) ||
code->chars.size() != fwrite(&code->chars[0], 1 , code->chars.size() , fp))
{
fclose(fp);
return false;
@ -350,16 +345,6 @@ bool code_write(code_t *code, const char *filename, const char *lnofile) {
}
void code_cleanup(code_t *code) {
vec_free(code->statements);
vec_free(code->linenums);
vec_free(code->columnnums);
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);
mem_d(code);
}

217
exec.cpp
View file

@ -30,10 +30,9 @@ static void qcvmerror(qc_program_t *prog, const char *fmt, ...)
qc_program_t* prog_load(const char *filename, bool skipversion)
{
prog_header_t header;
qc_program_t *prog;
size_t i;
FILE *file = fopen(filename, "rb");
prog_header_t header;
qc_program_t *prog;
FILE *file = fopen(filename, "rb");
/* we need all those in order to support INSTR_STATE: */
bool has_self = false,
@ -51,7 +50,7 @@ qc_program_t* prog_load(const char *filename, bool skipversion)
return NULL;
}
util_swap_header(&header);
util_swap_header(header);
if (!skipversion && header.version != 6) {
loaderror("header says this is a version %i progs, we need version 6\n", header.version);
@ -81,9 +80,10 @@ qc_program_t* prog_load(const char *filename, bool skipversion)
loaderror("seek failed"); \
goto error; \
} \
prog->progvar.resize(header.hdrvar.length + reserved); \
if (fread( \
vec_add(prog->progvar, header.hdrvar.length + reserved), \
sizeof(*prog->progvar), \
&prog->progvar[0], \
sizeof(prog->progvar[0]), \
header.hdrvar.length, \
file \
)!= header.hdrvar.length \
@ -101,21 +101,22 @@ qc_program_t* prog_load(const char *filename, bool skipversion)
read_data1(strings);
read_data2(globals, 2); /* reserve more in case a RETURN using with the global at "the end" exists */
util_swap_statements (prog->code);
util_swap_statements(prog->code);
util_swap_defs_fields(prog->defs);
util_swap_defs_fields(prog->fields);
util_swap_functions (prog->functions);
util_swap_globals (prog->globals);
util_swap_functions(prog->functions);
util_swap_globals(prog->globals);
fclose(file);
/* profile counters */
memset(vec_add(prog->profile, vec_size(prog->code)), 0, sizeof(prog->profile[0]) * vec_size(prog->code));
memset(vec_add(prog->profile, prog->code.size()), 0, sizeof(prog->profile[0]) * prog->code.size());
/* Add tempstring area */
prog->tempstring_start = vec_size(prog->strings);
prog->tempstring_at = vec_size(prog->strings);
memset(vec_add(prog->strings, 16*1024), 0, 16*1024);
prog->tempstring_start = prog->strings.size();
prog->tempstring_at = prog->strings.size();
prog->strings.resize(prog->strings.size() + 16*1024, '\0');
/* spawn the world entity */
vec_push(prog->entitypool, true);
@ -123,29 +124,29 @@ qc_program_t* prog_load(const char *filename, bool skipversion)
prog->entities = 1;
/* cache some globals and fields from names */
for (i = 0; i < vec_size(prog->defs); ++i) {
const char *name = prog_getstring(prog, prog->defs[i].name);
if (!strcmp(name, "self")) {
prog->cached_globals.self = prog->defs[i].offset;
for (auto &it : prog->defs) {
const char *name = prog_getstring(prog, it.name);
if (!strcmp(name, "self")) {
prog->cached_globals.self = it.offset;
has_self = true;
}
else if (!strcmp(name, "time")) {
prog->cached_globals.time = prog->defs[i].offset;
prog->cached_globals.time = it.offset;
has_time = true;
}
}
for (i = 0; i < vec_size(prog->fields); ++i) {
const char *name = prog_getstring(prog, prog->fields[i].name);
if (!strcmp(name, "think")) {
prog->cached_fields.think = prog->fields[i].offset;
for (auto &it : prog->fields) {
const char *name = prog_getstring(prog, it.name);
if (!strcmp(name, "think")) {
prog->cached_fields.think = it.offset;
has_think = true;
}
else if (!strcmp(name, "nextthink")) {
prog->cached_fields.nextthink = prog->fields[i].offset;
prog->cached_fields.nextthink = it.offset;
has_nextthink = true;
}
else if (!strcmp(name, "frame")) {
prog->cached_fields.frame = prog->fields[i].offset;
prog->cached_fields.frame = it.offset;
has_frame = true;
}
}
@ -157,12 +158,6 @@ qc_program_t* prog_load(const char *filename, bool skipversion)
error:
if (prog->filename)
mem_d(prog->filename);
vec_free(prog->code);
vec_free(prog->defs);
vec_free(prog->fields);
vec_free(prog->functions);
vec_free(prog->strings);
vec_free(prog->globals);
vec_free(prog->entitydata);
vec_free(prog->entitypool);
mem_d(prog);
@ -174,12 +169,6 @@ error:
void prog_delete(qc_program_t *prog)
{
if (prog->filename) mem_d(prog->filename);
vec_free(prog->code);
vec_free(prog->defs);
vec_free(prog->fields);
vec_free(prog->functions);
vec_free(prog->strings);
vec_free(prog->globals);
vec_free(prog->entitydata);
vec_free(prog->entitypool);
vec_free(prog->localstack);
@ -194,29 +183,25 @@ void prog_delete(qc_program_t *prog)
const char* prog_getstring(qc_program_t *prog, qcint_t str) {
/* cast for return required for C++ */
if (str < 0 || str >= (qcint_t)vec_size(prog->strings))
if (str < 0 || str >= (qcint_t)prog->strings.size())
return "<<<invalid string>>>";
return prog->strings + str;
return &prog->strings[0] + str;
}
prog_section_def_t* prog_entfield(qc_program_t *prog, qcint_t off) {
size_t i;
for (i = 0; i < vec_size(prog->fields); ++i) {
if (prog->fields[i].offset == off)
return (prog->fields + i);
}
return NULL;
for (auto &it : prog->fields)
if (it.offset == off)
return &it;
return nullptr;
}
prog_section_def_t* prog_getdef(qc_program_t *prog, qcint_t off)
{
size_t i;
for (i = 0; i < vec_size(prog->defs); ++i) {
if (prog->defs[i].offset == off)
return (prog->defs + i);
}
return NULL;
for (auto &it : prog->defs)
if (it.offset == off)
return &it;
return nullptr;
}
qcany_t* prog_getedict(qc_program_t *prog, qcint_t e) {
@ -269,19 +254,19 @@ qcint_t prog_tempstring(qc_program_t *prog, const char *str) {
size_t at = prog->tempstring_at;
/* when we reach the end we start over */
if (at + len >= vec_size(prog->strings))
if (at + len >= prog->strings.size())
at = prog->tempstring_start;
/* when it doesn't fit, reallocate */
if (at + len >= vec_size(prog->strings))
if (at + len >= prog->strings.size())
{
(void)vec_add(prog->strings, len+1);
memcpy(prog->strings + at, str, len+1);
prog->strings.resize(prog->strings.size() + len+1);
memcpy(&prog->strings[0] + at, str, len+1);
return at;
}
/* when it fits, just copy */
memcpy(prog->strings + at, str, len+1);
memcpy(&prog->strings[0] + at, str, len+1);
prog->tempstring_at += len+1;
return at;
}
@ -498,13 +483,13 @@ static qcint_t prog_enterfunction(qc_program_t *prog, prog_section_function_t *f
cur = prog->stack[vec_size(prog->stack)-1].function;
if (cur)
{
qcint_t *globals = prog->globals + cur->firstlocal;
qcint_t *globals = &prog->globals[0] + cur->firstlocal;
vec_append(prog->localstack, cur->locals, globals);
}
}
#else
{
qcint_t *globals = prog->globals + func->firstlocal;
qcint_t *globals = &prog->globals[0] + func->firstlocal;
vec_append(prog->localstack, func->locals, globals);
}
#endif
@ -546,7 +531,7 @@ static qcint_t prog_leavefunction(qc_program_t *prog) {
oldsp = prog->stack[vec_size(prog->stack)-1].localsp;
#endif
if (prev) {
qcint_t *globals = prog->globals + prev->firstlocal;
qcint_t *globals = &prog->globals[0] + prev->firstlocal;
memcpy(globals, prog->localstack + oldsp, prev->locals * sizeof(prog->localstack[0]));
/* vec_remove(prog->localstack, oldsp, vec_size(prog->localstack)-oldsp); */
vec_shrinkto(prog->localstack, oldsp);
@ -565,7 +550,7 @@ bool prog_exec(qc_program_t *prog, prog_section_function_t *func, size_t flags,
prog->vmerror = 0;
prog->xflags = flags;
st = prog->code + prog_enterfunction(prog, func);
st = &prog->code[0] + prog_enterfunction(prog, func);
--st;
switch (flags)
{
@ -649,7 +634,7 @@ static qcvm_parameter *main_params = NULL;
} \
} while (0)
#define GetGlobal(idx) ((qcany_t*)(prog->globals + (idx)))
#define GetGlobal(idx) ((qcany_t*)(&prog->globals[0] + (idx)))
#define GetArg(num) GetGlobal(OFS_PARM0 + 3*(num))
#define Return(any) *(GetGlobal(OFS_RETURN)) = (any)
@ -657,7 +642,7 @@ static int qc_print(qc_program_t *prog) {
size_t i;
const char *laststr = NULL;
for (i = 0; i < (size_t)prog->argc; ++i) {
qcany_t *str = (qcany_t*)(prog->globals + OFS_PARM0 + 3*i);
qcany_t *str = (qcany_t*)(&prog->globals[0] + OFS_PARM0 + 3*i);
laststr = prog_getstring(prog, str->string);
printf("%s", laststr);
}
@ -1108,18 +1093,18 @@ int main(int argc, char **argv) {
if (opts_info) {
printf("Program's system-checksum = 0x%04x\n", (unsigned int)prog->crc16);
printf("Entity field space: %u\n", (unsigned int)prog->entityfields);
printf("Globals: %u\n", (unsigned int)vec_size(prog->globals));
printf("Globals: %zu\n", prog->globals.size());
printf("Counts:\n"
" code: %lu\n"
" defs: %lu\n"
" fields: %lu\n"
" functions: %lu\n"
" strings: %lu\n",
(unsigned long)vec_size(prog->code),
(unsigned long)vec_size(prog->defs),
(unsigned long)vec_size(prog->fields),
(unsigned long)vec_size(prog->functions),
(unsigned long)vec_size(prog->strings));
" code: %zu\n"
" defs: %zu\n"
" fields: %zu\n"
" functions: %zu\n"
" strings: %zu\n",
prog->code.size(),
prog->defs.size(),
prog->fields.size(),
prog->functions.size(),
prog->strings.size());
}
if (opts_info) {
@ -1129,7 +1114,7 @@ int main(int argc, char **argv) {
for (i = 0; i < vec_size(dis_list); ++i) {
size_t k;
printf("Looking for `%s`\n", dis_list[i]);
for (k = 1; k < vec_size(prog->functions); ++k) {
for (k = 1; k < prog->functions.size(); ++k) {
const char *name = prog_getstring(prog, prog->functions[k].name);
if (!strcmp(name, dis_list[i])) {
prog_disasm_function(prog, k);
@ -1138,34 +1123,34 @@ int main(int argc, char **argv) {
}
}
if (opts_disasm) {
for (i = 1; i < vec_size(prog->functions); ++i)
for (i = 1; i < prog->functions.size(); ++i)
prog_disasm_function(prog, i);
return 0;
}
if (opts_printdefs) {
const char *getstring = NULL;
for (i = 0; i < vec_size(prog->defs); ++i) {
for (auto &it : prog->defs) {
printf("Global: %8s %-16s at %u%s",
type_name[prog->defs[i].type & DEF_TYPEMASK],
prog_getstring(prog, prog->defs[i].name),
(unsigned int)prog->defs[i].offset,
((prog->defs[i].type & DEF_SAVEGLOBAL) ? " [SAVE]" : ""));
type_name[it.type & DEF_TYPEMASK],
prog_getstring(prog, it.name),
(unsigned int)it.offset,
((it.type & DEF_SAVEGLOBAL) ? " [SAVE]" : ""));
if (opts_v) {
switch (prog->defs[i].type & DEF_TYPEMASK) {
switch (it.type & DEF_TYPEMASK) {
case TYPE_FLOAT:
printf(" [init: %g]", ((qcany_t*)(prog->globals + prog->defs[i].offset))->_float);
printf(" [init: %g]", ((qcany_t*)(&prog->globals[0] + it.offset))->_float);
break;
case TYPE_INTEGER:
printf(" [init: %i]", (int)( ((qcany_t*)(prog->globals + prog->defs[i].offset))->_int ));
printf(" [init: %i]", (int)( ((qcany_t*)(&prog->globals[0] + it.offset))->_int ));
break;
case TYPE_ENTITY:
case TYPE_FUNCTION:
case TYPE_FIELD:
case TYPE_POINTER:
printf(" [init: %u]", (unsigned)( ((qcany_t*)(prog->globals + prog->defs[i].offset))->_int ));
printf(" [init: %u]", (unsigned)( ((qcany_t*)(&prog->globals[0] + it.offset))->_int ));
break;
case TYPE_STRING:
getstring = prog_getstring(prog, ((qcany_t*)(prog->globals + prog->defs[i].offset))->string);
getstring = prog_getstring(prog, ((qcany_t*)(&prog->globals[0] + it.offset))->string);
printf(" [init: `");
print_escaped_string(getstring, strlen(getstring));
printf("`]\n");
@ -1178,37 +1163,37 @@ int main(int argc, char **argv) {
}
}
if (opts_printfields) {
for (i = 0; i < vec_size(prog->fields); ++i) {
printf("Field: %8s %-16s at %u%s\n",
type_name[prog->fields[i].type],
prog_getstring(prog, prog->fields[i].name),
(unsigned int)prog->fields[i].offset,
((prog->fields[i].type & DEF_SAVEGLOBAL) ? " [SAVE]" : ""));
for (auto &it : prog->fields) {
printf("Field: %8s %-16s at %d%s\n",
type_name[it.type],
prog_getstring(prog, it.name),
it.offset,
((it.type & DEF_SAVEGLOBAL) ? " [SAVE]" : ""));
}
}
if (opts_printfuns) {
for (i = 0; i < vec_size(prog->functions); ++i) {
for (auto &it : prog->functions) {
int32_t a;
printf("Function: %-16s taking %u parameters:(",
prog_getstring(prog, prog->functions[i].name),
(unsigned int)prog->functions[i].nargs);
for (a = 0; a < prog->functions[i].nargs; ++a) {
printf(" %i", prog->functions[i].argsize[a]);
prog_getstring(prog, it.name),
(unsigned int)it.nargs);
for (a = 0; a < it.nargs; ++a) {
printf(" %i", it.argsize[a]);
}
if (opts_v > 1) {
int32_t start = prog->functions[i].entry;
int32_t start = it.entry;
if (start < 0)
printf(") builtin %i\n", (int)-start);
else {
size_t funsize = 0;
prog_section_statement_t *st = prog->code + start;
prog_section_statement_t *st = &prog->code[0] + start;
for (;st->opcode != INSTR_DONE; ++st)
++funsize;
printf(") - %lu instructions", (unsigned long)funsize);
printf(") - %zu instructions", funsize);
if (opts_v > 2) {
printf(" - locals: %i + %i\n",
prog->functions[i].firstlocal,
prog->functions[i].locals);
it.firstlocal,
it.locals);
}
else
printf("\n");
@ -1216,15 +1201,15 @@ int main(int argc, char **argv) {
}
else if (opts_v) {
printf(") locals: %i + %i\n",
prog->functions[i].firstlocal,
prog->functions[i].locals);
it.firstlocal,
it.locals);
}
else
printf(")\n");
}
}
if (!noexec) {
for (i = 1; i < vec_size(prog->functions); ++i) {
for (i = 1; i < prog->functions.size(); ++i) {
const char *name = prog_getstring(prog, prog->functions[i].name);
if (!strcmp(name, "main"))
fnmain = (qcint_t)i;
@ -1243,7 +1228,7 @@ int main(int argc, char **argv) {
}
static void prog_disasm_function(qc_program_t *prog, size_t id) {
prog_section_function_t *fdef = prog->functions + id;
prog_section_function_t *fdef = &prog->functions[0] + id;
prog_section_statement_t *st;
if (fdef->entry < 0) {
@ -1253,7 +1238,7 @@ static void prog_disasm_function(qc_program_t *prog, size_t id) {
else
printf("FUNCTION \"%s\"\n", prog_getstring(prog, fdef->name));
st = prog->code + fdef->entry;
st = &prog->code[0] + fdef->entry;
while (st->opcode != INSTR_DONE) {
prog_print_statement(prog, st);
++st;
@ -1268,11 +1253,11 @@ static void prog_disasm_function(qc_program_t *prog, size_t id) {
* sort of isn't, which makes it nicer looking.
*/
#define OPA ( (qcany_t*) (prog->globals + st->o1.u1) )
#define OPB ( (qcany_t*) (prog->globals + st->o2.u1) )
#define OPC ( (qcany_t*) (prog->globals + st->o3.u1) )
#define OPA ( (qcany_t*) (&prog->globals[0] + st->o1.u1) )
#define OPB ( (qcany_t*) (&prog->globals[0] + st->o2.u1) )
#define OPC ( (qcany_t*) (&prog->globals[0] + st->o3.u1) )
#define GLOBAL(x) ( (qcany_t*) (prog->globals + (x)) )
#define GLOBAL(x) ( (qcany_t*) (&prog->globals[0] + (x)) )
/* to be consistent with current darkplaces behaviour */
#if !defined(FLOAT_IS_TRUE_FOR_INT)
@ -1287,7 +1272,7 @@ while (prog->vmerror == 0) {
++st;
#if QCVM_PROFILE
prog->profile[st - prog->code]++;
prog->profile[st - &prog->code[0]]++;
#endif
#if QCVM_TRACE
@ -1307,7 +1292,7 @@ while (prog->vmerror == 0) {
GLOBAL(OFS_RETURN)->ivector[1] = OPA->ivector[1];
GLOBAL(OFS_RETURN)->ivector[2] = OPA->ivector[2];
st = prog->code + prog_leavefunction(prog);
st = &prog->code[0] + prog_leavefunction(prog);
if (!vec_size(prog->stack))
goto cleanup;
@ -1561,7 +1546,7 @@ while (prog->vmerror == 0) {
if (!OPA->function)
qcvmerror(prog, "NULL function in `%s`", prog->filename);
if(!OPA->function || OPA->function >= (qcint_t)vec_size(prog->functions))
if(!OPA->function || OPA->function >= (qcint_t)prog->functions.size())
{
qcvmerror(prog, "CALL outside the program in `%s`", prog->filename);
goto cleanup;
@ -1570,7 +1555,7 @@ while (prog->vmerror == 0) {
newf = &prog->functions[OPA->function];
newf->profile++;
prog->statement = (st - prog->code) + 1;
prog->statement = (st - &prog->code[0]) + 1;
if (newf->entry < 0)
{
@ -1583,7 +1568,7 @@ while (prog->vmerror == 0) {
builtinnumber, prog->filename);
}
else
st = prog->code + prog_enterfunction(prog, newf) - 1; /* offset st++ */
st = &prog->code[0] + prog_enterfunction(prog, newf) - 1; /* offset st++ */
if (prog->vmerror)
goto cleanup;
break;
@ -1603,7 +1588,7 @@ while (prog->vmerror == 0) {
frame = (qcfloat_t*)&((qcint_t*)ed)[prog->cached_fields.frame];
*frame = OPA->_float;
nextthink = (qcfloat_t*)&((qcint_t*)ed)[prog->cached_fields.nextthink];
time = (qcfloat_t*)(prog->globals + prog->cached_globals.time);
time = (qcfloat_t*)(&prog->globals[0] + prog->cached_globals.time);
*nextthink = *time + 0.1;
break;
}

63
gmqcc.h
View file

@ -1,5 +1,6 @@
#ifndef GMQCC_HDR
#define GMQCC_HDR
#include <vector>
#include <stdarg.h>
#include <stddef.h>
#include <stdlib.h>
@ -486,29 +487,29 @@ enum {
/* TODO: elide */
extern const char *util_instr_str[VINSTR_END];
void util_swap_header (prog_header_t *code_header);
void util_swap_statements (prog_section_statement_t *statements);
void util_swap_defs_fields(prog_section_both_t *section);
void util_swap_functions (prog_section_function_t *functions);
void util_swap_globals (int32_t *globals);
void util_swap_header(prog_header_t &code_header);
void util_swap_statements(std::vector<prog_section_statement_t> &statements);
void util_swap_defs_fields(std::vector<prog_section_both_t> &section);
void util_swap_functions(std::vector<prog_section_function_t> &functions);
void util_swap_globals(std::vector<int32_t> &globals);
typedef float qcfloat_t;
typedef int32_t qcint_t;
typedef float qcfloat_t;
typedef int32_t qcint_t;
typedef uint32_t qcuint_t;
struct code_t {
prog_section_statement_t *statements;
int *linenums;
int *columnnums;
prog_section_def_t *defs;
prog_section_field_t *fields;
prog_section_function_t *functions;
int *globals;
char *chars;
uint16_t crc;
uint32_t entfields;
ht string_cache;
qcint_t string_cached_empty;
std::vector<prog_section_statement_t> statements;
std::vector<int> linenums;
std::vector<int> columnnums;
std::vector<prog_section_def_t> defs;
std::vector<prog_section_field_t> fields;
std::vector<prog_section_function_t> functions;
std::vector<int> globals;
std::vector<char> chars;
uint16_t crc;
uint32_t entfields;
ht string_cache;
qcint_t string_cached_empty;
};
/*
@ -517,8 +518,8 @@ struct code_t {
*/
struct lex_ctx_t {
const char *file;
size_t line;
size_t column;
size_t line;
size_t column;
};
/*
@ -645,17 +646,17 @@ struct qc_exec_stack_t {
};
struct qc_program_t {
char *filename;
prog_section_statement_t *code;
prog_section_def_t *defs;
prog_section_def_t *fields;
prog_section_function_t *functions;
char *strings;
qcint_t *globals;
qcint_t *entitydata;
bool *entitypool;
char *filename;
std::vector<prog_section_statement_t> code;
std::vector<prog_section_def_t> defs;
std::vector<prog_section_def_t> fields;
std::vector<prog_section_function_t> functions;
std::vector<char> strings;
std::vector<qcint_t> globals;
qcint_t *entitydata;
bool *entitypool;
const char* *function_stack;
const char* *function_stack;
uint16_t crc16;

216
ir.cpp
View file

@ -2747,20 +2747,20 @@ static bool gen_global_field(code_t *code, 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, code->globals.size());
code->globals.push_back(fld->code.fieldaddr);
if (global->fieldtype == TYPE_VECTOR) {
vec_push(code->globals, fld->code.fieldaddr+1);
vec_push(code->globals, fld->code.fieldaddr+2);
code->globals.push_back(fld->code.fieldaddr+1);
code->globals.push_back(fld->code.fieldaddr+2);
}
}
else
{
ir_value_code_setaddr(global, vec_size(code->globals));
vec_push(code->globals, 0);
ir_value_code_setaddr(global, code->globals.size());
code->globals.push_back(0);
if (global->fieldtype == TYPE_VECTOR) {
vec_push(code->globals, 0);
vec_push(code->globals, 0);
code->globals.push_back(0);
code->globals.push_back(0);
}
}
if (global->code.globaladdr < 0)
@ -2794,13 +2794,13 @@ static bool gen_global_pointer(code_t *code, 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, code->globals.size());
code->globals.push_back(target->code.globaladdr);
}
else
{
ir_value_code_setaddr(global, vec_size(code->globals));
vec_push(code->globals, 0);
ir_value_code_setaddr(global, code->globals.size());
code->globals.push_back(0);
}
if (global->code.globaladdr < 0)
return false;
@ -2819,7 +2819,7 @@ static bool gen_blocks_recursive(code_t *code, ir_function *func, ir_block *bloc
int j;
block->generated = true;
block->code_start = vec_size(code->statements);
block->code_start = code->statements.size();
for (i = 0; i < vec_size(block->instr); ++i)
{
instr = block->instr[i];
@ -2839,7 +2839,7 @@ static bool gen_blocks_recursive(code_t *code, ir_function *func, ir_block *bloc
/* 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 - code->statements.size();
stmt.o2.s1 = 0;
stmt.o3.s1 = 0;
if (stmt.o1.s1 != 1)
@ -3023,13 +3023,13 @@ static bool gen_blocks_recursive(code_t *code, ir_function *func, ir_block *bloc
if (ontrue->generated) {
stmt.opcode = INSTR_IF;
stmt.o2.s1 = (ontrue->code_start) - vec_size(code->statements);
stmt.o2.s1 = ontrue->code_start - code->statements.size();
if (stmt.o2.s1 != 1)
code_push_statement(code, &stmt, instr->context);
}
if (onfalse->generated) {
stmt.opcode = INSTR_IFNOT;
stmt.o2.s1 = (onfalse->code_start) - vec_size(code->statements);
stmt.o2.s1 = onfalse->code_start - code->statements.size();
if (stmt.o2.s1 != 1)
code_push_statement(code, &stmt, instr->context);
}
@ -3050,24 +3050,24 @@ static bool gen_blocks_recursive(code_t *code, ir_function *func, ir_block *bloc
onfalse = ontrue;
ontrue = tmp;
}
stidx = vec_size(code->statements);
stidx = code->statements.size();
code_push_statement(code, &stmt, instr->context);
/* on false we jump, so add ontrue-path */
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 = code->statements.size() - 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].o2.s1 = onfalse->code_start - stidx;
if (stidx+2 == code->statements.size() && 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 = code->statements.back().opcode;
if (stmt.opcode == INSTR_GOTO ||
stmt.opcode == INSTR_IF ||
stmt.opcode == INSTR_IFNOT ||
@ -3079,14 +3079,14 @@ static bool gen_blocks_recursive(code_t *code, ir_function *func, ir_block *bloc
}
/* 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 - code->statements.size();
stmt.o2.s1 = 0;
stmt.o3.s1 = 0;
if (stmt.o1.s1 != 1)
code_push_statement(code, &stmt, instr->context);
return true;
}
else if (stidx+2 == vec_size(code->statements) && code->statements[stidx].o2.s1 == 1) {
else if (stidx+2 == code->statements.size() && 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++;
@ -3284,7 +3284,7 @@ static bool gen_function_code(code_t *code, ir_function *self)
}
/* code_write and qcvm -disasm need to know that the function ends here */
retst = &vec_last(code->statements);
retst = &code->statements.back();
if (OPTS_OPTIMIZATION(OPTIM_VOID_RETURN) &&
self->outtype == TYPE_VOID &&
retst->opcode == INSTR_RETURN &&
@ -3299,8 +3299,8 @@ static bool gen_function_code(code_t *code, ir_function *self)
stmt.o1.u1 = 0;
stmt.o2.u1 = 0;
stmt.o3.u1 = 0;
last.line = vec_last(code->linenums);
last.column = vec_last(code->columnnums);
last.line = code->linenums.back();
last.column = code->columnnums.back();
code_push_statement(code, &stmt, last);
}
@ -3333,22 +3333,20 @@ static bool gen_global_function(ir_builder *ir, ir_value *global)
size_t i;
if (!global->hasvalue || (!global->constval.vfunc))
{
if (!global->hasvalue || (!global->constval.vfunc)) {
irerror(global->context, "Invalid state of function-global: not constant: %s", global->name);
return false;
}
irfun = global->constval.vfunc;
fun.name = global->code.name;
fun.file = ir_builder_filestring(ir, global->context.file);
fun.name = global->code.name;
fun.file = ir_builder_filestring(ir, global->context.file);
fun.profile = 0; /* always 0 */
fun.nargs = vec_size(irfun->params);
fun.nargs = vec_size(irfun->params);
if (fun.nargs > 8)
fun.nargs = 8;
for (i = 0;i < 8; ++i) {
for (i = 0; i < 8; ++i) {
if ((int32_t)i >= fun.nargs)
fun.argsize[i] = 0;
else
@ -3356,16 +3354,16 @@ static bool gen_global_function(ir_builder *ir, ir_value *global)
}
fun.firstlocal = 0;
fun.locals = irfun->allocated_locals;
fun.locals = irfun->allocated_locals;
if (irfun->builtin)
fun.entry = irfun->builtin+1;
else {
irfun->code_function_def = vec_size(ir->code->functions);
fun.entry = vec_size(ir->code->statements);
irfun->code_function_def = ir->code->functions.size();
fun.entry = ir->code->statements.size();
}
vec_push(ir->code->functions, fun);
ir->code->functions.push_back(fun);
return true;
}
@ -3391,17 +3389,17 @@ static void ir_gen_extparam(ir_builder *ir)
else
global = ir->extparam_protos[vec_size(ir->extparams)];
def.name = code_genstring(ir->code, global->name);
def.type = TYPE_VECTOR;
def.offset = vec_size(ir->code->globals);
def.name = code_genstring(ir->code, global->name);
def.type = TYPE_VECTOR;
def.offset = ir->code->globals.size();
vec_push(ir->code->defs, def);
ir->code->defs.push_back(def);
ir_value_code_setaddr(global, def.offset);
vec_push(ir->code->globals, 0);
vec_push(ir->code->globals, 0);
vec_push(ir->code->globals, 0);
ir->code->globals.push_back(0);
ir->code->globals.push_back(0);
ir->code->globals.push_back(0);
vec_push(ir->extparams, global);
}
@ -3485,13 +3483,13 @@ static bool gen_function_locals(ir_builder *ir, ir_value *global)
uint32_t firstlocal, firstglobal;
irfun = global->constval.vfunc;
def = ir->code->functions + irfun->code_function_def;
def = &ir->code->functions[0] + 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(ir->code->globals);
firstlocal = def->firstlocal = ir->code->globals.size();
} else {
firstlocal = def->firstlocal = ir->first_common_local;
++opts_optimizationcount[OPTIM_OVERLAP_LOCALS];
@ -3499,8 +3497,8 @@ 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(ir->code->globals); i < firstlocal + irfun->allocated_locals; ++i)
vec_push(ir->code->globals, 0);
for (i = ir->code->globals.size(); i < firstlocal + irfun->allocated_locals; ++i)
ir->code->globals.push_back(0);
for (i = 0; i < vec_size(irfun->locals); ++i) {
ir_value *v = irfun->locals[i];
if (v->locked || !OPTS_OPTIMIZATION(OPTIM_GLOBAL_TEMPS)) {
@ -3568,7 +3566,7 @@ static bool gen_global_function_code(ir_builder *ir, ir_value *global)
}
fundef = &ir->code->functions[irfun->code_function_def];
fundef->entry = vec_size(ir->code->statements);
fundef->entry = ir->code->statements.size();
if (!gen_function_locals(ir, global)) {
irerror(irfun->context, "Failed to generate locals for function %s", irfun->name);
return false;
@ -3610,7 +3608,7 @@ static void gen_vector_defs(code_t *code, prog_section_def_t def, const char *na
for (i = 0; i < 3; ++i) {
def.name = code_genstring(code, component);
vec_push(code->defs, def);
code->defs.push_back(def);
def.offset++;
component[len-1]++;
}
@ -3640,7 +3638,7 @@ static void gen_vector_fields(code_t *code, prog_section_field_t fld, const char
for (i = 0; i < 3; ++i) {
fld.name = code_genstring(code, component);
vec_push(code->fields, fld);
code->fields.push_back(fld);
fld.offset++;
component[len-1]++;
}
@ -3659,9 +3657,9 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool isloc
if (global->vtype == TYPE_VECTOR && (global->flags & IR_FLAG_SPLIT_VECTOR))
return true;
def.type = global->vtype;
def.offset = vec_size(self->code->globals);
def.name = 0;
def.type = global->vtype;
def.offset = self->code->globals.size();
def.name = 0;
if (OPTS_OPTION_BOOL(OPTION_G) || !islocal)
{
pushdef = true;
@ -3694,7 +3692,7 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool isloc
def.name = 0;
if (islocal) {
def.offset = ir_value_code_addr(global);
vec_push(self->code->defs, def);
self->code->defs.push_back(def);
if (global->vtype == TYPE_VECTOR)
gen_vector_defs(self->code, def, global->name);
else if (global->vtype == TYPE_FIELD && global->fieldtype == TYPE_VECTOR)
@ -3728,17 +3726,17 @@ 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(self->code->globals));
vec_push(self->code->globals, 0);
ir_value_code_setaddr(global, self->code->globals.size());
self->code->globals.push_back(0);
/* Add the def */
if (pushdef) vec_push(self->code->defs, def);
if (pushdef) self->code->defs.push_back(def);
return true;
case TYPE_POINTER:
if (pushdef) vec_push(self->code->defs, def);
if (pushdef) self->code->defs.push_back(def);
return gen_global_pointer(self->code, global);
case TYPE_FIELD:
if (pushdef) {
vec_push(self->code->defs, def);
self->code->defs.push_back(def);
if (global->fieldtype == TYPE_VECTOR)
gen_vector_defs(self->code, def, global->name);
}
@ -3747,84 +3745,84 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool isloc
/* fall through */
case TYPE_FLOAT:
{
ir_value_code_setaddr(global, vec_size(self->code->globals));
ir_value_code_setaddr(global, self->code->globals.size());
if (global->hasvalue) {
iptr = (int32_t*)&global->constval.ivec[0];
vec_push(self->code->globals, *iptr);
self->code->globals.push_back(*iptr);
} else {
vec_push(self->code->globals, 0);
self->code->globals.push_back(0);
}
if (!islocal && global->cvq != CV_CONST)
def.type |= DEF_SAVEGLOBAL;
if (pushdef) vec_push(self->code->defs, def);
if (pushdef) self->code->defs.push_back(def);
return global->code.globaladdr >= 0;
}
case TYPE_STRING:
{
ir_value_code_setaddr(global, vec_size(self->code->globals));
ir_value_code_setaddr(global, self->code->globals.size());
if (global->hasvalue) {
uint32_t load = code_genstring(self->code, global->constval.vstring);
vec_push(self->code->globals, load);
self->code->globals.push_back(load);
} else {
vec_push(self->code->globals, 0);
self->code->globals.push_back(0);
}
if (!islocal && global->cvq != CV_CONST)
def.type |= DEF_SAVEGLOBAL;
if (pushdef) vec_push(self->code->defs, def);
if (pushdef) self->code->defs.push_back(def);
return global->code.globaladdr >= 0;
}
case TYPE_VECTOR:
{
size_t d;
ir_value_code_setaddr(global, vec_size(self->code->globals));
ir_value_code_setaddr(global, self->code->globals.size());
if (global->hasvalue) {
iptr = (int32_t*)&global->constval.ivec[0];
vec_push(self->code->globals, iptr[0]);
self->code->globals.push_back(iptr[0]);
if (global->code.globaladdr < 0)
return false;
for (d = 1; d < type_sizeof_[global->vtype]; ++d) {
vec_push(self->code->globals, iptr[d]);
self->code->globals.push_back(iptr[d]);
}
} else {
vec_push(self->code->globals, 0);
self->code->globals.push_back(0);
if (global->code.globaladdr < 0)
return false;
for (d = 1; d < type_sizeof_[global->vtype]; ++d) {
vec_push(self->code->globals, 0);
self->code->globals.push_back(0);
}
}
if (!islocal && global->cvq != CV_CONST)
def.type |= DEF_SAVEGLOBAL;
if (pushdef) {
vec_push(self->code->defs, def);
self->code->defs.push_back(def);
def.type &= ~DEF_SAVEGLOBAL;
gen_vector_defs(self->code, def, global->name);
}
return global->code.globaladdr >= 0;
}
case TYPE_FUNCTION:
ir_value_code_setaddr(global, vec_size(self->code->globals));
ir_value_code_setaddr(global, self->code->globals.size());
if (!global->hasvalue) {
vec_push(self->code->globals, 0);
self->code->globals.push_back(0);
if (global->code.globaladdr < 0)
return false;
} else {
vec_push(self->code->globals, vec_size(self->code->functions));
self->code->globals.push_back(self->code->functions.size());
if (!gen_global_function(self, global))
return false;
}
if (!islocal && global->cvq != CV_CONST)
def.type |= DEF_SAVEGLOBAL;
if (pushdef) vec_push(self->code->defs, def);
if (pushdef) self->code->defs.push_back(def);
return true;
case TYPE_VARIANT:
/* assume biggest type */
ir_value_code_setaddr(global, vec_size(self->code->globals));
vec_push(self->code->globals, 0);
ir_value_code_setaddr(global, self->code->globals.size());
self->code->globals.push_back(0);
for (i = 1; i < type_sizeof_[TYPE_VARIANT]; ++i)
vec_push(self->code->globals, 0);
self->code->globals.push_back(0);
return true;
default:
/* refuse to create 'void' type or any other fancy business. */
@ -3847,7 +3845,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(self->code->globals);
def.offset = (uint16_t)self->code->globals.size();
/* create a global named the same as the field */
if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_GMQCC) {
@ -3881,7 +3879,7 @@ static bool ir_builder_gen_field(ir_builder *self, ir_value *field)
field->code.name = def.name;
vec_push(self->code->defs, def);
self->code->defs.push_back(def);
fld.type = field->fieldtype;
@ -3892,13 +3890,13 @@ static bool ir_builder_gen_field(ir_builder *self, ir_value *field)
fld.offset = field->code.fieldaddr;
vec_push(self->code->fields, fld);
self->code->fields.push_back(fld);
ir_value_code_setaddr(field, vec_size(self->code->globals));
vec_push(self->code->globals, fld.offset);
ir_value_code_setaddr(field, self->code->globals.size());
self->code->globals.push_back(fld.offset);
if (fld.type == TYPE_VECTOR) {
vec_push(self->code->globals, fld.offset+1);
vec_push(self->code->globals, fld.offset+2);
self->code->globals.push_back(fld.offset+1);
self->code->globals.push_back(fld.offset+2);
}
if (field->fieldtype == TYPE_VECTOR) {
@ -4046,28 +4044,28 @@ bool ir_builder_generate(ir_builder *self, const char *filename)
}
/* generate nil */
ir_value_code_setaddr(self->nil, vec_size(self->code->globals));
vec_push(self->code->globals, 0);
vec_push(self->code->globals, 0);
vec_push(self->code->globals, 0);
ir_value_code_setaddr(self->nil, self->code->globals.size());
self->code->globals.push_back(0);
self->code->globals.push_back(0);
self->code->globals.push_back(0);
/* generate virtual-instruction temps */
for (i = 0; i < IR_MAX_VINSTR_TEMPS; ++i) {
ir_value_code_setaddr(self->vinstr_temp[i], vec_size(self->code->globals));
vec_push(self->code->globals, 0);
vec_push(self->code->globals, 0);
vec_push(self->code->globals, 0);
ir_value_code_setaddr(self->vinstr_temp[i], self->code->globals.size());
self->code->globals.push_back(0);
self->code->globals.push_back(0);
self->code->globals.push_back(0);
}
/* generate global temps */
self->first_common_globaltemp = vec_size(self->code->globals);
self->first_common_globaltemp = self->code->globals.size();
for (i = 0; i < self->max_globaltemps; ++i) {
vec_push(self->code->globals, 0);
self->code->globals.push_back(0);
}
/* generate common locals */
self->first_common_local = vec_size(self->code->globals);
self->first_common_local = self->code->globals.size();
for (i = 0; i < self->max_locals; ++i) {
vec_push(self->code->globals, 0);
self->code->globals.push_back(0);
}
/* generate function code */
@ -4080,13 +4078,15 @@ bool ir_builder_generate(ir_builder *self, const char *filename)
}
}
if (vec_size(self->code->globals) >= 65536) {
irerror(vec_last(self->globals)->context, "This progs file would require more globals than the metadata can handle (%u). Bailing out.", (unsigned int)vec_size(self->code->globals));
if (self->code->globals.size() >= 65536) {
irerror(vec_last(self->globals)->context,
"This progs file would require more globals than the metadata can handle (%zu). Bailing out.",
self->code->globals.size());
return false;
}
/* DP errors if the last instruction is not an INSTR_DONE. */
if (vec_last(self->code->statements).opcode != INSTR_DONE)
if (self->code->statements.back().opcode != INSTR_DONE)
{
lex_ctx_t last;
@ -4094,8 +4094,8 @@ bool ir_builder_generate(ir_builder *self, const char *filename)
stmt.o1.u1 = 0;
stmt.o2.u1 = 0;
stmt.o3.u1 = 0;
last.line = vec_last(self->code->linenums);
last.column = vec_last(self->code->columnnums);
last.line = self->code->linenums.back();
last.column = self->code->columnnums.back();
code_push_statement(self->code, &stmt, last);
}
@ -4103,10 +4103,10 @@ bool ir_builder_generate(ir_builder *self, const char *filename)
if (OPTS_OPTION_BOOL(OPTION_PP_ONLY))
return true;
if (vec_size(self->code->statements) != vec_size(self->code->linenums)) {
if (self->code->statements.size() != self->code->linenums.size()) {
con_err("Linecounter wrong: %lu != %lu\n",
(unsigned long)vec_size(self->code->statements),
(unsigned long)vec_size(self->code->linenums));
self->code->statements.size(),
self->code->linenums.size());
} else if (OPTS_FLAG(LNO)) {
char *dot;
size_t filelen = strlen(filename);

82
util.cpp
View file

@ -87,62 +87,56 @@ void util_endianswap(void *_data, size_t count, unsigned int typesize) {
#endif
}
void util_swap_header(prog_header_t *code_header) {
util_endianswap(&code_header->version, 1, sizeof(code_header->version));
util_endianswap(&code_header->crc16, 1, sizeof(code_header->crc16));
util_endianswap(&code_header->statements.offset, 1, sizeof(code_header->statements.offset));
util_endianswap(&code_header->statements.length, 1, sizeof(code_header->statements.length));
util_endianswap(&code_header->defs.offset, 1, sizeof(code_header->defs.offset));
util_endianswap(&code_header->defs.length, 1, sizeof(code_header->defs.length));
util_endianswap(&code_header->fields.offset, 1, sizeof(code_header->fields.offset));
util_endianswap(&code_header->fields.length, 1, sizeof(code_header->fields.length));
util_endianswap(&code_header->functions.offset, 1, sizeof(code_header->functions.offset));
util_endianswap(&code_header->functions.length, 1, sizeof(code_header->functions.length));
util_endianswap(&code_header->strings.offset, 1, sizeof(code_header->strings.offset));
util_endianswap(&code_header->strings.length, 1, sizeof(code_header->strings.length));
util_endianswap(&code_header->globals.offset, 1, sizeof(code_header->globals.offset));
util_endianswap(&code_header->globals.length, 1, sizeof(code_header->globals.length));
util_endianswap(&code_header->entfield, 1, sizeof(code_header->entfield));
void util_swap_header(prog_header_t &code_header) {
util_endianswap(&code_header.version, 1, sizeof(code_header.version));
util_endianswap(&code_header.crc16, 1, sizeof(code_header.crc16));
util_endianswap(&code_header.statements.offset, 1, sizeof(code_header.statements.offset));
util_endianswap(&code_header.statements.length, 1, sizeof(code_header.statements.length));
util_endianswap(&code_header.defs.offset, 1, sizeof(code_header.defs.offset));
util_endianswap(&code_header.defs.length, 1, sizeof(code_header.defs.length));
util_endianswap(&code_header.fields.offset, 1, sizeof(code_header.fields.offset));
util_endianswap(&code_header.fields.length, 1, sizeof(code_header.fields.length));
util_endianswap(&code_header.functions.offset, 1, sizeof(code_header.functions.offset));
util_endianswap(&code_header.functions.length, 1, sizeof(code_header.functions.length));
util_endianswap(&code_header.strings.offset, 1, sizeof(code_header.strings.offset));
util_endianswap(&code_header.strings.length, 1, sizeof(code_header.strings.length));
util_endianswap(&code_header.globals.offset, 1, sizeof(code_header.globals.offset));
util_endianswap(&code_header.globals.length, 1, sizeof(code_header.globals.length));
util_endianswap(&code_header.entfield, 1, sizeof(code_header.entfield));
}
void util_swap_statements(prog_section_statement_t *statements) {
size_t i;
for (i = 0; i < vec_size(statements); ++i) {
util_endianswap(&statements[i].opcode, 1, sizeof(statements[i].opcode));
util_endianswap(&statements[i].o1, 1, sizeof(statements[i].o1));
util_endianswap(&statements[i].o2, 1, sizeof(statements[i].o2));
util_endianswap(&statements[i].o3, 1, sizeof(statements[i].o3));
void util_swap_statements(std::vector<prog_section_statement_t> &statements) {
for (auto &it : statements) {
util_endianswap(&it.opcode, 1, sizeof(it.opcode));
util_endianswap(&it.o1, 1, sizeof(it.o1));
util_endianswap(&it.o2, 1, sizeof(it.o2));
util_endianswap(&it.o3, 1, sizeof(it.o3));
}
}
void util_swap_defs_fields(prog_section_both_t *section) {
size_t i;
for (i = 0; i < vec_size(section); ++i) {
util_endianswap(&section[i].type, 1, sizeof(section[i].type));
util_endianswap(&section[i].offset, 1, sizeof(section[i].offset));
util_endianswap(&section[i].name, 1, sizeof(section[i].name));
void util_swap_defs_fields(std::vector<prog_section_both_t> &section) {
for (auto &it : section) {
util_endianswap(&it.type, 1, sizeof(it.type));
util_endianswap(&it.offset, 1, sizeof(it.offset));
util_endianswap(&it.name, 1, sizeof(it.name));
}
}
void util_swap_functions(prog_section_function_t *functions) {
size_t i;
for (i = 0; i < vec_size(functions); ++i) {
util_endianswap(&functions[i].entry, 1, sizeof(functions[i].entry));
util_endianswap(&functions[i].firstlocal, 1, sizeof(functions[i].firstlocal));
util_endianswap(&functions[i].locals, 1, sizeof(functions[i].locals));
util_endianswap(&functions[i].profile, 1, sizeof(functions[i].profile));
util_endianswap(&functions[i].name, 1, sizeof(functions[i].name));
util_endianswap(&functions[i].file, 1, sizeof(functions[i].file));
util_endianswap(&functions[i].nargs, 1, sizeof(functions[i].nargs));
void util_swap_functions(std::vector<prog_section_function_t> &functions) {
for (auto &it : functions) {
util_endianswap(&it.entry, 1, sizeof(it.entry));
util_endianswap(&it.firstlocal, 1, sizeof(it.firstlocal));
util_endianswap(&it.locals, 1, sizeof(it.locals));
util_endianswap(&it.profile, 1, sizeof(it.profile));
util_endianswap(&it.name, 1, sizeof(it.name));
util_endianswap(&it.file, 1, sizeof(it.file));
util_endianswap(&it.nargs, 1, sizeof(it.nargs));
/* Don't swap argsize[] - it's just a byte array, which Quake uses only as such. */
}
}
void util_swap_globals(int32_t *globals) {
util_endianswap(globals, vec_size(globals), sizeof(int32_t));
void util_swap_globals(std::vector<int32_t> &globals) {
util_endianswap(&globals[0], globals.size(), sizeof(int32_t));
}
/*