X-Git-Url: https://git.xonotic.org/?p=xonotic%2Fgmqcc.git;a=blobdiff_plain;f=ir.c;h=73cbc9af06abec83170abbf9e3b98c9bb867f28a;hp=5dae734462fe6b7513f60588ebce6439383fd778;hb=6024e377ba11dcbcf24577100d95355536e0c9db;hpb=f892b323351eb110dc97b8cf4e15d03dddc6fb78 diff --git a/ir.c b/ir.c index 5dae734..73cbc9a 100644 --- a/ir.c +++ b/ir.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2012, 2013 + * Copyright (C) 2012, 2013, 2014, 2015 * Wolfgang Bumiller * Dale Weiler * @@ -23,6 +23,7 @@ */ #include #include + #include "gmqcc.h" #include "ir.h" @@ -217,7 +218,7 @@ static bool ir_value_set_name(ir_value*, const char *name); static void ir_value_dump(ir_value*, int (*oprintf)(const char*,...)); static ir_value* ir_gen_extparam_proto(ir_builder *ir); -static void ir_gen_extparam (code_t *, ir_builder *ir); +static void ir_gen_extparam (ir_builder *ir); static bool ir_builder_set_name(ir_builder *self, const char *name); @@ -226,11 +227,11 @@ static bool ir_function_set_name(ir_function*, const char *name); static void ir_function_delete(ir_function*); static void ir_function_dump(ir_function*, char *ind, int (*oprintf)(const char*,...)); -static ir_value* ir_block_create_general_instr(ir_block *self, lex_ctx, const char *label, +static ir_value* ir_block_create_general_instr(ir_block *self, lex_ctx_t, const char *label, int op, ir_value *a, ir_value *b, int outype); static void ir_block_delete(ir_block*); static ir_block* ir_block_new(struct ir_function_s *owner, const char *label); -static bool GMQCC_WARN ir_block_create_store(ir_block*, lex_ctx, ir_value *target, ir_value *what); +static bool GMQCC_WARN ir_block_create_store(ir_block*, lex_ctx_t, ir_value *target, ir_value *what); static bool ir_block_set_label(ir_block*, const char *label); static void ir_block_dump(ir_block*, char *ind, int (*oprintf)(const char*,...)); @@ -239,15 +240,15 @@ static void ir_instr_delete(ir_instr*); static void ir_instr_dump(ir_instr* in, char *ind, int (*oprintf)(const char*,...)); /* error functions */ -static void irerror(lex_ctx ctx, const char *msg, ...) +static void irerror(lex_ctx_t ctx, const char *msg, ...) { va_list ap; va_start(ap, msg); - con_cvprintmsg((void*)&ctx, LVL_ERROR, "internal error", msg, ap); + con_cvprintmsg(ctx, LVL_ERROR, "internal error", msg, ap); va_end(ap); } -static bool irwarning(lex_ctx ctx, int warntype, const char *fmt, ...) +static bool GMQCC_WARN irwarning(lex_ctx_t ctx, int warntype, const char *fmt, ...) { bool r; va_list ap; @@ -311,6 +312,7 @@ static void ir_function_delete_quick(ir_function *self); ir_builder* ir_builder_new(const char *modulename) { ir_builder* self; + size_t i; self = (ir_builder*)mem_a(sizeof(*self)); if (!self) @@ -343,7 +345,19 @@ ir_builder* ir_builder_new(const char *modulename) self->nil = ir_value_var("nil", store_value, TYPE_NIL); self->nil->cvq = CV_CONST; + for (i = 0; i != IR_MAX_VINSTR_TEMPS; ++i) { + /* we write to them, but they're not supposed to be used outside the IR, so + * let's not allow the generation of ir_instrs which use these. + * So it's a constant noexpr. + */ + self->vinstr_temp[i] = ir_value_var("vinstr_temp", store_value, TYPE_NOEXPR); + self->vinstr_temp[i]->cvq = CV_CONST; + } + self->reserved_va_count = NULL; + self->coverage_func = NULL; + + self->code = code_init(); return self; } @@ -372,9 +386,14 @@ void ir_builder_delete(ir_builder* self) ir_value_delete(self->fields[i]); } ir_value_delete(self->nil); + for (i = 0; i != IR_MAX_VINSTR_TEMPS; ++i) { + ir_value_delete(self->vinstr_temp[i]); + } vec_free(self->fields); vec_free(self->filenames); vec_free(self->filestrings); + + code_cleanup(self->code); mem_d(self); } @@ -430,7 +449,7 @@ ir_value* ir_builder_create_global(ir_builder *self, const char *name, int vtype { ir_value *ve; - if (name && name[0] != '#') + if (name[0] != '#') { ve = ir_builder_get_global(self, name); if (ve) { @@ -580,11 +599,15 @@ static void ir_function_collect_value(ir_function *self, ir_value *v) vec_push(self->values, v); } -ir_block* ir_function_create_block(lex_ctx ctx, ir_function *self, const char *label) +ir_block* ir_function_create_block(lex_ctx_t ctx, ir_function *self, const char *label) { ir_block* bn = ir_block_new(self, label); bn->context = ctx; vec_push(self->blocks, bn); + + if ((self->flags & IR_FLAG_BLOCK_COVERAGE) && self->owner->coverage_func) + (void)ir_block_create_call(bn, ctx, NULL, self->owner->coverage_func, false); + return bn; } @@ -595,7 +618,8 @@ static bool instr_is_operation(uint16_t op) (op == INSTR_ADDRESS) || (op >= INSTR_NOT_F && op <= INSTR_NOT_FNC) || (op >= INSTR_AND && op <= INSTR_BITOR) || - (op >= INSTR_CALL0 && op <= INSTR_CALL8) ); + (op >= INSTR_CALL0 && op <= INSTR_CALL8) || + (op >= VINSTR_BITAND_V && op <= VINSTR_NEG_V) ); } static bool ir_function_pass_peephole(ir_function *self) @@ -624,6 +648,7 @@ static bool ir_function_pass_peephole(ir_function *self) if (!instr_is_operation(oper->opcode)) continue; + /* Don't change semantics of MUL_VF in engines where these may not alias. */ if (OPTS_FLAG(LEGACY_VECTOR_MATHS)) { if (oper->opcode == INSTR_MUL_VF && oper->_ops[2]->memberof == oper->_ops[1]) continue; @@ -950,7 +975,7 @@ bool ir_block_set_label(ir_block *self, const char *name) *IR Instructions */ -static ir_instr* ir_instr_new(lex_ctx ctx, ir_block* owner, int op) +static ir_instr* ir_instr_new(lex_ctx_t ctx, ir_block* owner, int op) { ir_instr *self; self = (ir_instr*)mem_a(sizeof(*self)); @@ -1015,6 +1040,11 @@ static void ir_instr_delete(ir_instr *self) static bool ir_instr_op(ir_instr *self, int op, ir_value *v, bool writing) { + if (v && v->vtype == TYPE_NOEXPR) { + irerror(self->context, "tried to use a NOEXPR value"); + return false; + } + if (self->_ops[op]) { size_t idx; if (writing && vec_ir_instr_find(self->_ops[op]->writes, self, &idx)) @@ -1091,6 +1121,20 @@ ir_value* ir_value_var(const char *name, int storetype, int vtype) return self; } +/* helper function */ +static ir_value* ir_builder_imm_float(ir_builder *self, float value, bool add_to_list) { + ir_value *v = ir_value_var("#IMMEDIATE", store_global, TYPE_FLOAT); + v->flags |= IR_FLAG_ERASABLE; + v->hasvalue = true; + v->cvq = CV_CONST; + v->constval.vfloat = value; + + vec_push(self->globals, v); + if (add_to_list) + vec_push(self->const_floats, v); + return v; +} + ir_value* ir_value_vector_member(ir_value *self, unsigned int member) { char *name; @@ -1176,9 +1220,11 @@ void ir_value_delete(ir_value* self) if (self->vtype == TYPE_STRING) mem_d((void*)self->constval.vstring); } - for (i = 0; i < 3; ++i) { - if (self->members[i]) - ir_value_delete(self->members[i]); + if (!(self->flags & IR_FLAG_SPLIT_VECTOR)) { + for (i = 0; i < 3; ++i) { + if (self->members[i]) + ir_value_delete(self->members[i]); + } } vec_free(self->reads); vec_free(self->writes); @@ -1212,7 +1258,7 @@ bool ir_value_set_func(ir_value *self, int f) return true; } -bool ir_value_set_vector(ir_value *self, vector v) +bool ir_value_set_vector(ir_value *self, vec3_t v) { if (self->vtype != TYPE_VECTOR) return false; @@ -1478,7 +1524,7 @@ static bool ir_check_unreachable(ir_block *self) return false; } -bool ir_block_create_store_op(ir_block *self, lex_ctx ctx, int op, ir_value *target, ir_value *what) +bool ir_block_create_store_op(ir_block *self, lex_ctx_t ctx, int op, ir_value *target, ir_value *what) { ir_instr *in; if (!ir_check_unreachable(self)) @@ -1489,7 +1535,7 @@ bool ir_block_create_store_op(ir_block *self, lex_ctx ctx, int op, ir_value *tar { irerror(self->context, "cannot store to an SSA value"); irerror(self->context, "trying to store: %s <- %s", target->name, what->name); - irerror(self->context, "instruction: %s", asm_instr[op].m); + irerror(self->context, "instruction: %s", util_instr_str[op]); return false; } @@ -1507,7 +1553,27 @@ bool ir_block_create_store_op(ir_block *self, lex_ctx ctx, int op, ir_value *tar return true; } -static bool ir_block_create_store(ir_block *self, lex_ctx ctx, ir_value *target, ir_value *what) +bool ir_block_create_state_op(ir_block *self, lex_ctx_t ctx, ir_value *frame, ir_value *think) +{ + ir_instr *in; + if (!ir_check_unreachable(self)) + return false; + + in = ir_instr_new(ctx, self, INSTR_STATE); + if (!in) + return false; + + if (!ir_instr_op(in, 0, frame, false) || + !ir_instr_op(in, 1, think, false)) + { + ir_instr_delete(in); + return false; + } + vec_push(self->instr, in); + return true; +} + +static bool ir_block_create_store(ir_block *self, lex_ctx_t ctx, ir_value *target, ir_value *what) { int op = 0; int vtype; @@ -1532,7 +1598,7 @@ static bool ir_block_create_store(ir_block *self, lex_ctx ctx, ir_value *target, return ir_block_create_store_op(self, ctx, op, target, what); } -bool ir_block_create_storep(ir_block *self, lex_ctx ctx, ir_value *target, ir_value *what) +bool ir_block_create_storep(ir_block *self, lex_ctx_t ctx, ir_value *target, ir_value *what) { int op = 0; int vtype; @@ -1554,12 +1620,14 @@ bool ir_block_create_storep(ir_block *self, lex_ctx ctx, ir_value *target, ir_va return ir_block_create_store_op(self, ctx, op, target, what); } -bool ir_block_create_return(ir_block *self, lex_ctx ctx, ir_value *v) +bool ir_block_create_return(ir_block *self, lex_ctx_t ctx, ir_value *v) { ir_instr *in; if (!ir_check_unreachable(self)) return false; + self->final = true; + self->is_return = true; in = ir_instr_new(ctx, self, INSTR_RETURN); if (!in) @@ -1574,7 +1642,7 @@ bool ir_block_create_return(ir_block *self, lex_ctx ctx, ir_value *v) return true; } -bool ir_block_create_if(ir_block *self, lex_ctx ctx, ir_value *v, +bool ir_block_create_if(ir_block *self, lex_ctx_t ctx, ir_value *v, ir_block *ontrue, ir_block *onfalse) { ir_instr *in; @@ -1603,7 +1671,7 @@ bool ir_block_create_if(ir_block *self, lex_ctx ctx, ir_value *v, return true; } -bool ir_block_create_jump(ir_block *self, lex_ctx ctx, ir_block *to) +bool ir_block_create_jump(ir_block *self, lex_ctx_t ctx, ir_block *to) { ir_instr *in; if (!ir_check_unreachable(self)) @@ -1621,13 +1689,13 @@ bool ir_block_create_jump(ir_block *self, lex_ctx ctx, ir_block *to) return true; } -bool ir_block_create_goto(ir_block *self, lex_ctx ctx, ir_block *to) +bool ir_block_create_goto(ir_block *self, lex_ctx_t ctx, ir_block *to) { self->owner->flags |= IR_FLAG_HAS_GOTO; return ir_block_create_jump(self, ctx, to); } -ir_instr* ir_block_create_phi(ir_block *self, lex_ctx ctx, const char *label, int ot) +ir_instr* ir_block_create_phi(ir_block *self, lex_ctx_t ctx, const char *label, int ot) { ir_value *out; ir_instr *in; @@ -1674,7 +1742,7 @@ void ir_phi_add(ir_instr* self, ir_block *b, ir_value *v) } /* call related code */ -ir_instr* ir_block_create_call(ir_block *self, lex_ctx ctx, const char *label, ir_value *func, bool noreturn) +ir_instr* ir_block_create_call(ir_block *self, lex_ctx_t ctx, const char *label, ir_value *func, bool noreturn) { ir_value *out; ir_instr *in; @@ -1725,7 +1793,7 @@ void ir_call_param(ir_instr* self, ir_value *v) /* binary op related code */ -ir_value* ir_block_create_binop(ir_block *self, lex_ctx ctx, +ir_value* ir_block_create_binop(ir_block *self, lex_ctx_t ctx, const char *label, int opcode, ir_value *left, ir_value *right) { @@ -1748,6 +1816,7 @@ ir_value* ir_block_create_binop(ir_block *self, lex_ctx ctx, #endif case INSTR_BITAND: case INSTR_BITOR: + case VINSTR_BITXOR: #if 0 case INSTR_SUB_S: /* -- offset of string as float */ case INSTR_MUL_IF: @@ -1784,6 +1853,13 @@ ir_value* ir_block_create_binop(ir_block *self, lex_ctx ctx, case INSTR_SUB_V: case INSTR_MUL_VF: case INSTR_MUL_FV: + case VINSTR_BITAND_V: + case VINSTR_BITOR_V: + case VINSTR_BITXOR_V: + case VINSTR_BITAND_VF: + case VINSTR_BITOR_VF: + case VINSTR_BITXOR_VF: + case VINSTR_CROSS: #if 0 case INSTR_DIV_VF: case INSTR_MUL_IV: @@ -1796,14 +1872,33 @@ ir_value* ir_block_create_binop(ir_block *self, lex_ctx ctx, ot = TYPE_POINTER; break; #endif + /* + * after the following default case, the value of opcode can never + * be 1, 2, 3, 4, 5, 6, 7, 8, 9, 62, 63, 64, 65 + */ default: /* ranges: */ /* boolean operations result in floats */ + + /* + * opcode >= 10 takes true branch opcode is at least 10 + * opcode <= 23 takes false branch opcode is at least 24 + */ if (opcode >= INSTR_EQ_F && opcode <= INSTR_GT) ot = TYPE_FLOAT; + + /* + * At condition "opcode <= 23", the value of "opcode" must be + * at least 24. + * At condition "opcode <= 23", the value of "opcode" cannot be + * equal to any of {1, 2, 3, 4, 5, 6, 7, 8, 9, 62, 63, 64, 65}. + * The condition "opcode <= 23" cannot be true. + * + * Thus ot=2 (TYPE_FLOAT) can never be true + */ +#if 0 else if (opcode >= INSTR_LE && opcode <= INSTR_GT) ot = TYPE_FLOAT; -#if 0 else if (opcode >= INSTR_LE_I && opcode <= INSTR_EQ_FI) ot = TYPE_FLOAT; #endif @@ -1817,26 +1912,29 @@ ir_value* ir_block_create_binop(ir_block *self, lex_ctx ctx, return ir_block_create_general_instr(self, ctx, label, opcode, left, right, ot); } -ir_value* ir_block_create_unary(ir_block *self, lex_ctx ctx, +ir_value* ir_block_create_unary(ir_block *self, lex_ctx_t ctx, const char *label, int opcode, ir_value *operand) { int ot = TYPE_FLOAT; + ir_value *minus_1 = NULL; + if (opcode == VINSTR_NEG_F || opcode == VINSTR_NEG_V) + minus_1 = ir_builder_imm_float(self->owner->owner, -1.0f, false); switch (opcode) { case INSTR_NOT_F: case INSTR_NOT_V: case INSTR_NOT_S: case INSTR_NOT_ENT: - case INSTR_NOT_FNC: -#if 0 - case INSTR_NOT_I: -#endif + case INSTR_NOT_FNC: /* + case INSTR_NOT_I: */ ot = TYPE_FLOAT; break; - /* QC doesn't have other unary operations. We expect extensions to fill - * the above list, otherwise we assume out-type = in-type, eg for an - * unary minus - */ + /* Negation is implemented as -1 * */ + case VINSTR_NEG_F: + return ir_block_create_general_instr(self, ctx, label, INSTR_MUL_F, minus_1, operand, TYPE_FLOAT); + case VINSTR_NEG_V: + return ir_block_create_general_instr(self, ctx, label, INSTR_MUL_FV, minus_1, operand, TYPE_VECTOR); + default: ot = operand->vtype; break; @@ -1850,7 +1948,7 @@ ir_value* ir_block_create_unary(ir_block *self, lex_ctx ctx, return ir_block_create_general_instr(self, ctx, label, opcode, operand, NULL, ot); } -static ir_value* ir_block_create_general_instr(ir_block *self, lex_ctx ctx, const char *label, +static ir_value* ir_block_create_general_instr(ir_block *self, lex_ctx_t ctx, const char *label, int op, ir_value *a, ir_value *b, int outype) { ir_instr *instr; @@ -1882,7 +1980,7 @@ on_error: return NULL; } -ir_value* ir_block_create_fieldaddress(ir_block *self, lex_ctx ctx, const char *label, ir_value *ent, ir_value *field) +ir_value* ir_block_create_fieldaddress(ir_block *self, lex_ctx_t ctx, const char *label, ir_value *ent, ir_value *field) { ir_value *v; @@ -1898,7 +1996,7 @@ ir_value* ir_block_create_fieldaddress(ir_block *self, lex_ctx ctx, const char * return v; } -ir_value* ir_block_create_load_from_ent(ir_block *self, lex_ctx ctx, const char *label, ir_value *ent, ir_value *field, int outype) +ir_value* ir_block_create_load_from_ent(ir_block *self, lex_ctx_t ctx, const char *label, ir_value *ent, ir_value *field, int outype) { int op; if (ent->vtype != TYPE_ENTITY) @@ -2460,7 +2558,16 @@ static bool ir_block_life_propagate(ir_block *self, bool *changed) } } - if (instr->opcode == INSTR_MUL_VF) + /* These operations need a special case as they can break when using + * same source and destination operand otherwise, as the engine may + * read the source multiple times. */ + if (instr->opcode == INSTR_MUL_VF || + instr->opcode == VINSTR_BITAND_VF || + instr->opcode == VINSTR_BITOR_VF || + instr->opcode == VINSTR_BITXOR || + instr->opcode == VINSTR_BITXOR_VF || + instr->opcode == VINSTR_BITXOR_V || + instr->opcode == VINSTR_CROSS) { value = instr->_ops[2]; /* the float source will get an additional lifetime */ @@ -2469,7 +2576,13 @@ static bool ir_block_life_propagate(ir_block *self, bool *changed) if (value->memberof && ir_value_life_merge(value->memberof, instr->eid+1)) *changed = true; } - else if (instr->opcode == INSTR_MUL_FV || instr->opcode == INSTR_LOAD_V) + + if (instr->opcode == INSTR_MUL_FV || + instr->opcode == INSTR_LOAD_V || + instr->opcode == VINSTR_BITXOR || + instr->opcode == VINSTR_BITXOR_VF || + instr->opcode == VINSTR_BITXOR_V || + instr->opcode == VINSTR_CROSS) { value = instr->_ops[1]; /* the float source will get an additional lifetime */ @@ -2561,7 +2674,8 @@ bool ir_function_calculate_liferanges(ir_function *self) /* parameters live at 0 */ for (i = 0; i < vec_size(self->params); ++i) - ir_value_life_merge(self->locals[i], 0); + if (!ir_value_life_merge(self->locals[i], 0)) + compile_error(self->context, "internal error: failed value-life merging"); do { self->run_id++; @@ -2642,7 +2756,7 @@ bool ir_function_calculate_liferanges(ir_function *self) * * Breaking conventions is annoying... */ -static bool ir_builder_gen_global(code_t *, ir_builder *self, ir_value *global, bool islocal); +static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool islocal); static bool gen_global_field(code_t *code, ir_value *global) { @@ -2717,13 +2831,14 @@ static bool gen_global_pointer(code_t *code, ir_value *global) static bool gen_blocks_recursive(code_t *code, ir_function *func, ir_block *block) { - prog_section_statement stmt; + prog_section_statement_t stmt; ir_instr *instr; ir_block *target; ir_block *ontrue; ir_block *onfalse; size_t stidx; size_t i; + int j; block->generated = true; block->code_start = vec_size(code->statements); @@ -2750,12 +2865,173 @@ static bool gen_blocks_recursive(code_t *code, ir_function *func, ir_block *bloc stmt.o2.s1 = 0; stmt.o3.s1 = 0; if (stmt.o1.s1 != 1) - code_push_statement(code, &stmt, instr->context.line); + code_push_statement(code, &stmt, instr->context); /* no further instructions can be in this block */ return true; } + if (instr->opcode == VINSTR_BITXOR) { + stmt.opcode = INSTR_BITOR; + stmt.o1.s1 = ir_value_code_addr(instr->_ops[1]); + stmt.o2.s1 = ir_value_code_addr(instr->_ops[2]); + stmt.o3.s1 = ir_value_code_addr(instr->_ops[0]); + code_push_statement(code, &stmt, instr->context); + stmt.opcode = INSTR_BITAND; + stmt.o1.s1 = ir_value_code_addr(instr->_ops[1]); + stmt.o2.s1 = ir_value_code_addr(instr->_ops[2]); + stmt.o3.s1 = ir_value_code_addr(func->owner->vinstr_temp[0]); + code_push_statement(code, &stmt, instr->context); + stmt.opcode = INSTR_SUB_F; + stmt.o1.s1 = ir_value_code_addr(instr->_ops[0]); + stmt.o2.s1 = ir_value_code_addr(func->owner->vinstr_temp[0]); + stmt.o3.s1 = ir_value_code_addr(instr->_ops[0]); + code_push_statement(code, &stmt, instr->context); + + /* instruction generated */ + continue; + } + + if (instr->opcode == VINSTR_BITAND_V) { + stmt.opcode = INSTR_BITAND; + stmt.o1.s1 = ir_value_code_addr(instr->_ops[1]); + stmt.o2.s1 = ir_value_code_addr(instr->_ops[2]); + stmt.o3.s1 = ir_value_code_addr(instr->_ops[0]); + code_push_statement(code, &stmt, instr->context); + ++stmt.o1.s1; + ++stmt.o2.s1; + ++stmt.o3.s1; + code_push_statement(code, &stmt, instr->context); + ++stmt.o1.s1; + ++stmt.o2.s1; + ++stmt.o3.s1; + code_push_statement(code, &stmt, instr->context); + + /* instruction generated */ + continue; + } + + if (instr->opcode == VINSTR_BITOR_V) { + stmt.opcode = INSTR_BITOR; + stmt.o1.s1 = ir_value_code_addr(instr->_ops[1]); + stmt.o2.s1 = ir_value_code_addr(instr->_ops[2]); + stmt.o3.s1 = ir_value_code_addr(instr->_ops[0]); + code_push_statement(code, &stmt, instr->context); + ++stmt.o1.s1; + ++stmt.o2.s1; + ++stmt.o3.s1; + code_push_statement(code, &stmt, instr->context); + ++stmt.o1.s1; + ++stmt.o2.s1; + ++stmt.o3.s1; + code_push_statement(code, &stmt, instr->context); + + /* instruction generated */ + continue; + } + + if (instr->opcode == VINSTR_BITXOR_V) { + for (j = 0; j < 3; ++j) { + stmt.opcode = INSTR_BITOR; + stmt.o1.s1 = ir_value_code_addr(instr->_ops[1]) + j; + stmt.o2.s1 = ir_value_code_addr(instr->_ops[2]) + j; + stmt.o3.s1 = ir_value_code_addr(instr->_ops[0]) + j; + code_push_statement(code, &stmt, instr->context); + stmt.opcode = INSTR_BITAND; + stmt.o1.s1 = ir_value_code_addr(instr->_ops[1]) + j; + stmt.o2.s1 = ir_value_code_addr(instr->_ops[2]) + j; + stmt.o3.s1 = ir_value_code_addr(func->owner->vinstr_temp[0]) + j; + code_push_statement(code, &stmt, instr->context); + } + stmt.opcode = INSTR_SUB_V; + stmt.o1.s1 = ir_value_code_addr(instr->_ops[0]); + stmt.o2.s1 = ir_value_code_addr(func->owner->vinstr_temp[0]); + stmt.o3.s1 = ir_value_code_addr(instr->_ops[0]); + code_push_statement(code, &stmt, instr->context); + + /* instruction generated */ + continue; + } + + if (instr->opcode == VINSTR_BITAND_VF) { + stmt.opcode = INSTR_BITAND; + stmt.o1.s1 = ir_value_code_addr(instr->_ops[1]); + stmt.o2.s1 = ir_value_code_addr(instr->_ops[2]); + stmt.o3.s1 = ir_value_code_addr(instr->_ops[0]); + code_push_statement(code, &stmt, instr->context); + ++stmt.o1.s1; + ++stmt.o3.s1; + code_push_statement(code, &stmt, instr->context); + ++stmt.o1.s1; + ++stmt.o3.s1; + code_push_statement(code, &stmt, instr->context); + + /* instruction generated */ + continue; + } + + if (instr->opcode == VINSTR_BITOR_VF) { + stmt.opcode = INSTR_BITOR; + stmt.o1.s1 = ir_value_code_addr(instr->_ops[1]); + stmt.o2.s1 = ir_value_code_addr(instr->_ops[2]); + stmt.o3.s1 = ir_value_code_addr(instr->_ops[0]); + code_push_statement(code, &stmt, instr->context); + ++stmt.o1.s1; + ++stmt.o3.s1; + code_push_statement(code, &stmt, instr->context); + ++stmt.o1.s1; + ++stmt.o3.s1; + code_push_statement(code, &stmt, instr->context); + + /* instruction generated */ + continue; + } + + if (instr->opcode == VINSTR_BITXOR_VF) { + for (j = 0; j < 3; ++j) { + stmt.opcode = INSTR_BITOR; + stmt.o1.s1 = ir_value_code_addr(instr->_ops[1]) + j; + stmt.o2.s1 = ir_value_code_addr(instr->_ops[2]); + stmt.o3.s1 = ir_value_code_addr(instr->_ops[0]) + j; + code_push_statement(code, &stmt, instr->context); + stmt.opcode = INSTR_BITAND; + stmt.o1.s1 = ir_value_code_addr(instr->_ops[1]) + j; + stmt.o2.s1 = ir_value_code_addr(instr->_ops[2]); + stmt.o3.s1 = ir_value_code_addr(func->owner->vinstr_temp[0]) + j; + code_push_statement(code, &stmt, instr->context); + } + stmt.opcode = INSTR_SUB_V; + stmt.o1.s1 = ir_value_code_addr(instr->_ops[0]); + stmt.o2.s1 = ir_value_code_addr(func->owner->vinstr_temp[0]); + stmt.o3.s1 = ir_value_code_addr(instr->_ops[0]); + code_push_statement(code, &stmt, instr->context); + + /* instruction generated */ + continue; + } + + if (instr->opcode == VINSTR_CROSS) { + stmt.opcode = INSTR_MUL_F; + for (j = 0; j < 3; ++j) { + stmt.o1.s1 = ir_value_code_addr(instr->_ops[1]) + (j + 1) % 3; + stmt.o2.s1 = ir_value_code_addr(instr->_ops[2]) + (j + 2) % 3; + stmt.o3.s1 = ir_value_code_addr(instr->_ops[0]) + j; + code_push_statement(code, &stmt, instr->context); + stmt.o1.s1 = ir_value_code_addr(instr->_ops[1]) + (j + 2) % 3; + stmt.o2.s1 = ir_value_code_addr(instr->_ops[2]) + (j + 1) % 3; + stmt.o3.s1 = ir_value_code_addr(func->owner->vinstr_temp[0]) + j; + code_push_statement(code, &stmt, instr->context); + } + stmt.opcode = INSTR_SUB_V; + stmt.o1.s1 = ir_value_code_addr(instr->_ops[0]); + stmt.o2.s1 = ir_value_code_addr(func->owner->vinstr_temp[0]); + stmt.o3.s1 = ir_value_code_addr(instr->_ops[0]); + code_push_statement(code, &stmt, instr->context); + + /* instruction generated */ + continue; + } + if (instr->opcode == VINSTR_COND) { ontrue = instr->bops[0]; onfalse = instr->bops[1]; @@ -2771,13 +3047,13 @@ static bool gen_blocks_recursive(code_t *code, ir_function *func, ir_block *bloc stmt.opcode = INSTR_IF; stmt.o2.s1 = (ontrue->code_start) - vec_size(code->statements); if (stmt.o2.s1 != 1) - code_push_statement(code, &stmt, instr->context.line); + code_push_statement(code, &stmt, instr->context); } if (onfalse->generated) { stmt.opcode = INSTR_IFNOT; stmt.o2.s1 = (onfalse->code_start) - vec_size(code->statements); if (stmt.o2.s1 != 1) - code_push_statement(code, &stmt, instr->context.line); + code_push_statement(code, &stmt, instr->context); } if (!ontrue->generated) { if (onfalse->generated) @@ -2797,7 +3073,7 @@ static bool gen_blocks_recursive(code_t *code, ir_function *func, ir_block *bloc ontrue = tmp; } stidx = vec_size(code->statements); - code_push_statement(code, &stmt, instr->context.line); + code_push_statement(code, &stmt, instr->context); /* on false we jump, so add ontrue-path */ if (!gen_blocks_recursive(code, func, ontrue)) return false; @@ -2829,7 +3105,7 @@ static bool gen_blocks_recursive(code_t *code, ir_function *func, ir_block *bloc stmt.o2.s1 = 0; stmt.o3.s1 = 0; if (stmt.o1.s1 != 1) - code_push_statement(code, &stmt, instr->context.line); + code_push_statement(code, &stmt, instr->context); return true; } else if (stidx+2 == vec_size(code->statements) && code->statements[stidx].o2.s1 == 1) { @@ -2868,7 +3144,21 @@ static bool gen_blocks_recursive(code_t *code, ir_function *func, ir_block *bloc 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(code, &stmt, instr->context.line); + + if (param->vtype == TYPE_VECTOR && (param->flags & IR_FLAG_SPLIT_VECTOR)) { + /* fetch 3 separate floats */ + stmt.opcode = INSTR_STORE_F; + stmt.o1.u1 = ir_value_code_addr(param->members[0]); + code_push_statement(code, &stmt, instr->context); + stmt.o2.u1++; + stmt.o1.u1 = ir_value_code_addr(param->members[1]); + code_push_statement(code, &stmt, instr->context); + stmt.o2.u1++; + stmt.o1.u1 = ir_value_code_addr(param->members[2]); + code_push_statement(code, &stmt, instr->context); + } + else + code_push_statement(code, &stmt, instr->context); } /* Now handle extparams */ first = vec_size(instr->params); @@ -2882,7 +3172,7 @@ static bool gen_blocks_recursive(code_t *code, ir_function *func, ir_block *bloc continue; if (p-8 >= vec_size(ir->extparams)) - ir_gen_extparam(code, ir); + ir_gen_extparam(ir); targetparam = ir->extparams[p-8]; @@ -2897,7 +3187,20 @@ static bool gen_blocks_recursive(code_t *code, ir_function *func, ir_block *bloc 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(code, &stmt, instr->context.line); + if (param->vtype == TYPE_VECTOR && (param->flags & IR_FLAG_SPLIT_VECTOR)) { + /* fetch 3 separate floats */ + stmt.opcode = INSTR_STORE_F; + stmt.o1.u1 = ir_value_code_addr(param->members[0]); + code_push_statement(code, &stmt, instr->context); + stmt.o2.u1++; + stmt.o1.u1 = ir_value_code_addr(param->members[1]); + code_push_statement(code, &stmt, instr->context); + stmt.o2.u1++; + stmt.o1.u1 = ir_value_code_addr(param->members[2]); + code_push_statement(code, &stmt, instr->context); + } + else + code_push_statement(code, &stmt, instr->context); } stmt.opcode = INSTR_CALL0 + vec_size(instr->params); @@ -2906,7 +3209,7 @@ static bool gen_blocks_recursive(code_t *code, ir_function *func, ir_block *bloc stmt.o1.u1 = ir_value_code_addr(instr->_ops[1]); stmt.o2.u1 = 0; stmt.o3.u1 = 0; - code_push_statement(code, &stmt, instr->context.line); + code_push_statement(code, &stmt, instr->context); retvalue = instr->_ops[0]; if (retvalue && retvalue->store != store_return && @@ -2920,14 +3223,20 @@ static bool gen_blocks_recursive(code_t *code, ir_function *func, ir_block *bloc stmt.o1.u1 = OFS_RETURN; stmt.o2.u1 = ir_value_code_addr(retvalue); stmt.o3.u1 = 0; - code_push_statement(code, &stmt, instr->context.line); + code_push_statement(code, &stmt, instr->context); } continue; } if (instr->opcode == INSTR_STATE) { - irerror(block->context, "TODO: state instruction"); - return false; + stmt.opcode = instr->opcode; + if (instr->_ops[0]) + stmt.o1.u1 = ir_value_code_addr(instr->_ops[0]); + if (instr->_ops[1]) + stmt.o2.u1 = ir_value_code_addr(instr->_ops[1]); + stmt.o3.u1 = 0; + code_push_statement(code, &stmt, instr->context); + continue; } stmt.opcode = instr->opcode; @@ -2969,8 +3278,7 @@ static bool gen_blocks_recursive(code_t *code, ir_function *func, ir_block *bloc continue; } } - - code_push_statement(code, &stmt, instr->context.line); + code_push_statement(code, &stmt, instr->context); } return true; } @@ -2978,7 +3286,7 @@ static bool gen_blocks_recursive(code_t *code, ir_function *func, ir_block *bloc static bool gen_function_code(code_t *code, ir_function *self) { ir_block *block; - prog_section_statement stmt, *retst; + prog_section_statement_t stmt, *retst; /* Starting from entry point, we generate blocks "as they come" * for now. Dead blocks will not be translated obviously. @@ -3007,38 +3315,43 @@ static bool gen_function_code(code_t *code, ir_function *self) retst->opcode = INSTR_DONE; ++opts_optimizationcount[OPTIM_VOID_RETURN]; } else { + lex_ctx_t last; + stmt.opcode = INSTR_DONE; - stmt.o1.u1 = 0; - stmt.o2.u1 = 0; - stmt.o3.u1 = 0; - code_push_statement(code, &stmt, vec_last(code->linenums)); + stmt.o1.u1 = 0; + stmt.o2.u1 = 0; + stmt.o3.u1 = 0; + last.line = vec_last(code->linenums); + last.column = vec_last(code->columnnums); + + code_push_statement(code, &stmt, last); } return true; } -static qcint ir_builder_filestring(code_t *code, ir_builder *ir, const char *filename) +static qcint_t ir_builder_filestring(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. */ size_t i; - qcint str; + qcint_t str; for (i = 0; i < vec_size(ir->filenames); ++i) { if (ir->filenames[i] == filename) return ir->filestrings[i]; } - str = code_genstring(code, filename); + str = code_genstring(ir->code, filename); vec_push(ir->filenames, filename); vec_push(ir->filestrings, str); return str; } -static bool gen_global_function(code_t *code, ir_builder *ir, ir_value *global) +static bool gen_global_function(ir_builder *ir, ir_value *global) { - prog_section_function fun; - ir_function *irfun; + prog_section_function_t fun; + ir_function *irfun; size_t i; @@ -3051,7 +3364,7 @@ static bool gen_global_function(code_t *code, ir_builder *ir, ir_value *global) irfun = global->constval.vfunc; fun.name = global->code.name; - fun.file = ir_builder_filestring(code, ir, global->context.file); + fun.file = ir_builder_filestring(ir, global->context.file); fun.profile = 0; /* always 0 */ fun.nargs = vec_size(irfun->params); if (fun.nargs > 8) @@ -3070,11 +3383,11 @@ static bool gen_global_function(code_t *code, 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(ir->code->functions); + fun.entry = vec_size(ir->code->statements); } - vec_push(code->functions, fun); + vec_push(ir->code->functions, fun); return true; } @@ -3090,27 +3403,27 @@ static ir_value* ir_gen_extparam_proto(ir_builder *ir) return global; } -static void ir_gen_extparam(code_t *code, ir_builder *ir) +static void ir_gen_extparam(ir_builder *ir) { - prog_section_def def; - ir_value *global; + prog_section_def_t def; + ir_value *global; if (vec_size(ir->extparam_protos) < vec_size(ir->extparams)+1) global = ir_gen_extparam_proto(ir); else global = ir->extparam_protos[vec_size(ir->extparams)]; - def.name = code_genstring(code, global->name); + def.name = code_genstring(ir->code, global->name); def.type = TYPE_VECTOR; - def.offset = vec_size(code->globals); + def.offset = vec_size(ir->code->globals); - vec_push(code->defs, def); + vec_push(ir->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(ir->code->globals, 0); + vec_push(ir->code->globals, 0); + vec_push(ir->code->globals, 0); vec_push(ir->extparams, global); } @@ -3121,7 +3434,7 @@ static bool gen_function_extparam_copy(code_t *code, ir_function *self) ir_builder *ir = self->owner; ir_value *ep; - prog_section_statement stmt; + prog_section_statement_t stmt; numparams = vec_size(self->params); if (!numparams) @@ -3132,7 +3445,7 @@ static bool gen_function_extparam_copy(code_t *code, ir_function *self) for (i = 8; i < numparams; ++i) { ext = i - 8; if (ext >= vec_size(ir->extparams)) - ir_gen_extparam(code, ir); + ir_gen_extparam(ir); ep = ir->extparams[ext]; @@ -3144,7 +3457,7 @@ static bool gen_function_extparam_copy(code_t *code, ir_function *self) } stmt.o1.u1 = ir_value_code_addr(ep); stmt.o2.u1 = ir_value_code_addr(self->locals[i]); - code_push_statement(code, &stmt, self->context.line); + code_push_statement(code, &stmt, self->context); } return true; @@ -3156,7 +3469,7 @@ static bool gen_function_varargs_copy(code_t *code, ir_function *self) ir_builder *ir = self->owner; ir_value *ep; - prog_section_statement stmt; + prog_section_statement_t stmt; numparams = vec_size(self->params); if (!numparams) @@ -3169,38 +3482,38 @@ static bool gen_function_varargs_copy(code_t *code, 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(code, &stmt, self->context.line); + code_push_statement(code, &stmt, self->context); continue; } ext = i - 8; while (ext >= vec_size(ir->extparams)) - ir_gen_extparam(code, ir); + ir_gen_extparam(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(code, &stmt, self->context.line); + code_push_statement(code, &stmt, self->context); } return true; } -static bool gen_function_locals(code_t *code, ir_builder *ir, ir_value *global) +static bool gen_function_locals(ir_builder *ir, ir_value *global) { - prog_section_function *def; - ir_function *irfun; - size_t i; - uint32_t firstlocal, firstglobal; + prog_section_function_t *def; + ir_function *irfun; + size_t i; + uint32_t firstlocal, firstglobal; irfun = global->constval.vfunc; - def = code->functions + irfun->code_function_def; + def = ir->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(ir->code->globals); } else { firstlocal = def->firstlocal = ir->first_common_local; ++opts_optimizationcount[OPTIM_OVERLAP_LOCALS]; @@ -3208,13 +3521,13 @@ static bool gen_function_locals(code_t *code, 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(ir->code->globals); i < firstlocal + irfun->allocated_locals; ++i) + vec_push(ir->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(code, ir, irfun->locals[i], true)) { + if (!ir_builder_gen_global(ir, irfun->locals[i], true)) { irerror(irfun->locals[i]->context, "failed to generate local %s", irfun->locals[i]->name); return false; } @@ -3235,18 +3548,26 @@ static bool gen_function_locals(code_t *code, ir_builder *ir, ir_value *global) return true; } -static bool gen_global_function_code(code_t *code, ir_builder *ir, ir_value *global) +static bool gen_global_function_code(ir_builder *ir, ir_value *global) { - prog_section_function *fundef; - ir_function *irfun; + prog_section_function_t *fundef; + ir_function *irfun; (void)ir; irfun = global->constval.vfunc; if (!irfun) { if (global->cvq == CV_NONE) { - irwarning(global->context, WARN_IMPLICIT_FUNCTION_POINTER, - "function `%s` has no body and in QC implicitly becomes a function-pointer", global->name); + if (irwarning(global->context, WARN_IMPLICIT_FUNCTION_POINTER, + "function `%s` has no body and in QC implicitly becomes a function-pointer", + global->name)) + { + /* Not bailing out just now. If this happens a lot you don't want to have + * to rerun gmqcc for each such function. + */ + + /* return false; */ + } } /* this was a function pointer, don't generate code for those */ return true; @@ -3255,33 +3576,41 @@ static bool gen_global_function_code(code_t *code, ir_builder *ir, ir_value *glo if (irfun->builtin) return true; + /* + * If there is no definition and the thing is eraseable, we can ignore + * outputting the function to begin with. + */ + if (global->flags & IR_FLAG_ERASABLE && irfun->code_function_def < 0) { + return true; + } + if (irfun->code_function_def < 0) { 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 = &ir->code->functions[irfun->code_function_def]; - fundef->entry = vec_size(code->statements); - if (!gen_function_locals(code, ir, global)) { + fundef->entry = vec_size(ir->code->statements); + if (!gen_function_locals(ir, global)) { irerror(irfun->context, "Failed to generate locals for function %s", irfun->name); return false; } - if (!gen_function_extparam_copy(code, irfun)) { + if (!gen_function_extparam_copy(ir->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(code, irfun)) { + if (irfun->max_varargs && !gen_function_varargs_copy(ir->code, irfun)) { irerror(irfun->context, "Failed to generate vararg-copy code for function %s", irfun->name); return false; } - if (!gen_function_code(code, irfun)) { + if (!gen_function_code(ir->code, irfun)) { irerror(irfun->context, "Failed to generate code for function %s", irfun->name); return false; } return true; } -static void gen_vector_defs(code_t *code, prog_section_def def, const char *name) +static void gen_vector_defs(code_t *code, prog_section_def_t def, const char *name) { char *component; size_t len, i; @@ -3311,7 +3640,7 @@ static void gen_vector_defs(code_t *code, prog_section_def def, const char *name mem_d(component); } -static void gen_vector_fields(code_t *code, prog_section_field fld, const char *name) +static void gen_vector_fields(code_t *code, prog_section_field_t fld, const char *name) { char *component; size_t len, i; @@ -3341,20 +3670,32 @@ static void gen_vector_fields(code_t *code, prog_section_field fld, const char * mem_d(component); } -static bool ir_builder_gen_global(code_t *code, ir_builder *self, ir_value *global, bool islocal) +static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool islocal) { - size_t i; - int32_t *iptr; - prog_section_def def; - bool pushdef = opts.optimizeoff; + size_t i; + int32_t *iptr; + prog_section_def_t def; + bool pushdef = opts.optimizeoff; + + /* we don't generate split-vectors */ + if (global->vtype == TYPE_VECTOR && (global->flags & IR_FLAG_SPLIT_VECTOR)) + return true; def.type = global->vtype; - def.offset = vec_size(code->globals); + def.offset = vec_size(self->code->globals); def.name = 0; if (OPTS_OPTION_BOOL(OPTION_G) || !islocal) { pushdef = true; + /* + * if we're eraseable and the function isn't referenced ignore outputting + * the function. + */ + if (global->flags & IR_FLAG_ERASABLE && vec_size(global->reads) == 0) { + return true; + } + if (OPTS_OPTIMIZATION(OPTIM_STRIP_CONSTANT_NAMES) && !(global->flags & IR_FLAG_INCLUDE_DEF) && (global->name[0] == '#' || global->cvq == CV_CONST)) @@ -3362,24 +3703,24 @@ static bool ir_builder_gen_global(code_t *code, ir_builder *self, ir_value *glob pushdef = false; } - if (pushdef && global->name) { + if (pushdef) { if (global->name[0] == '#') { if (!self->str_immediate) - self->str_immediate = code_genstring(code, "IMMEDIATE"); + self->str_immediate = code_genstring(self->code, "IMMEDIATE"); def.name = global->code.name = self->str_immediate; } else - def.name = global->code.name = code_genstring(code, global->name); + def.name = global->code.name = code_genstring(self->code, global->name); } else def.name = 0; if (islocal) { def.offset = ir_value_code_addr(global); - vec_push(code->defs, def); + vec_push(self->code->defs, def); if (global->vtype == TYPE_VECTOR) - gen_vector_defs(code, def, global->name); + gen_vector_defs(self->code, def, global->name); else if (global->vtype == TYPE_FIELD && global->fieldtype == TYPE_VECTOR) - gen_vector_defs(code, def, global->name); + gen_vector_defs(self->code, def, global->name); return true; } } @@ -3398,111 +3739,119 @@ static bool ir_builder_gen_global(code_t *code, ir_builder *self, ir_value *glob /* TODO: same as above but for entity-fields rather than globsl */ } - else - irwarning(global->context, WARN_VOID_VARIABLES, "unrecognized variable of type void `%s`", - global->name); + else if(irwarning(global->context, WARN_VOID_VARIABLES, "unrecognized variable of type void `%s`", + global->name)) + { + /* Not bailing out */ + /* return false; */ + } /* I'd argue setting it to 0 is sufficient, but maybe some depend on knowing how far * the system fields actually go? Though the engine knows this anyway... * 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(self->code->globals)); + vec_push(self->code->globals, 0); /* Add the def */ - if (pushdef) vec_push(code->defs, def); + if (pushdef) vec_push(self->code->defs, def); return true; case TYPE_POINTER: - if (pushdef) vec_push(code->defs, def); - return gen_global_pointer(code, global); + if (pushdef) vec_push(self->code->defs, def); + return gen_global_pointer(self->code, global); case TYPE_FIELD: if (pushdef) { - vec_push(code->defs, def); + vec_push(self->code->defs, def); if (global->fieldtype == TYPE_VECTOR) - gen_vector_defs(code, def, global->name); + gen_vector_defs(self->code, def, global->name); } - return gen_global_field(code, global); + return gen_global_field(self->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(self->code->globals)); if (global->hasvalue) { + if (global->cvq == CV_CONST && !vec_size(global->reads)) + return true; iptr = (int32_t*)&global->constval.ivec[0]; - vec_push(code->globals, *iptr); + vec_push(self->code->globals, *iptr); } else { - vec_push(code->globals, 0); + vec_push(self->code->globals, 0); } if (!islocal && global->cvq != CV_CONST) def.type |= DEF_SAVEGLOBAL; - if (pushdef) vec_push(code->defs, def); + if (pushdef) vec_push(self->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(self->code->globals)); if (global->hasvalue) { - uint32_t load = code_genstring(code, global->constval.vstring); - vec_push(code->globals, load); + uint32_t load; + if (global->cvq == CV_CONST && !vec_size(global->reads)) + return true; + load = code_genstring(self->code, global->constval.vstring); + vec_push(self->code->globals, load); } else { - vec_push(code->globals, 0); + vec_push(self->code->globals, 0); } if (!islocal && global->cvq != CV_CONST) def.type |= DEF_SAVEGLOBAL; - if (pushdef) vec_push(code->defs, def); + if (pushdef) vec_push(self->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(self->code->globals)); if (global->hasvalue) { iptr = (int32_t*)&global->constval.ivec[0]; - vec_push(code->globals, iptr[0]); + vec_push(self->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(self->code->globals, iptr[d]); } } else { - vec_push(code->globals, 0); + vec_push(self->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(self->code->globals, 0); } } if (!islocal && global->cvq != CV_CONST) def.type |= DEF_SAVEGLOBAL; if (pushdef) { - vec_push(code->defs, def); + vec_push(self->code->defs, def); def.type &= ~DEF_SAVEGLOBAL; - gen_vector_defs(code, def, global->name); + gen_vector_defs(self->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(self->code->globals)); if (!global->hasvalue) { - vec_push(code->globals, 0); + vec_push(self->code->globals, 0); if (global->code.globaladdr < 0) return false; } else { - vec_push(code->globals, vec_size(code->functions)); - if (!gen_global_function(code, self, global)) + vec_push(self->code->globals, vec_size(self->code->functions)); + if (!gen_global_function(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(self->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(self->code->globals)); + vec_push(self->code->globals, 0); for (i = 1; i < type_sizeof_[TYPE_VARIANT]; ++i) - vec_push(code->globals, 0); + vec_push(self->code->globals, 0); return true; default: /* refuse to create 'void' type or any other fancy business. */ @@ -3517,15 +3866,15 @@ static GMQCC_INLINE void ir_builder_prepare_field(code_t *code, ir_value *field) field->code.fieldaddr = code_alloc_field(code, type_sizeof_[field->fieldtype]); } -static bool ir_builder_gen_field(code_t *code, ir_builder *self, ir_value *field) +static bool ir_builder_gen_field(ir_builder *self, ir_value *field) { - prog_section_def def; - prog_section_field fld; + prog_section_def_t def; + prog_section_field_t fld; (void)self; def.type = (uint16_t)field->vtype; - def.offset = (uint16_t)vec_size(code->globals); + def.offset = (uint16_t)vec_size(self->code->globals); /* create a global named the same as the field */ if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_GMQCC) { @@ -3545,7 +3894,7 @@ static bool ir_builder_gen_field(code_t *code, 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(code, name); + def.name = code_genstring(self->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, @@ -3553,13 +3902,13 @@ static bool ir_builder_gen_field(code_t *code, 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(code, field->name); + def.name = code_genstring(self->code, field->name); fld.name = def.name; } field->code.name = def.name; - vec_push(code->defs, def); + vec_push(self->code->defs, def); fld.type = field->fieldtype; @@ -3570,37 +3919,138 @@ static bool ir_builder_gen_field(code_t *code, ir_builder *self, ir_value *field fld.offset = field->code.fieldaddr; - vec_push(code->fields, fld); + vec_push(self->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(self->code->globals)); + vec_push(self->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(self->code->globals, fld.offset+1); + vec_push(self->code->globals, fld.offset+2); } if (field->fieldtype == TYPE_VECTOR) { - gen_vector_defs (code, def, field->name); - gen_vector_fields(code, fld, field->name); + gen_vector_defs (self->code, def, field->name); + gen_vector_fields(self->code, fld, field->name); } return field->code.globaladdr >= 0; } -bool ir_builder_generate(code_t *code, ir_builder *self, const char *filename) +static void ir_builder_collect_reusables(ir_builder *builder) { + size_t i; + ir_value **reusables = NULL; + for (i = 0; i < vec_size(builder->globals); ++i) { + ir_value *value = builder->globals[i]; + if (value->vtype != TYPE_FLOAT || !value->hasvalue) + continue; + if (value->cvq == CV_CONST || (value->name && value->name[0] == '#')) { + vec_push(reusables, value); + } + } + builder->const_floats = reusables; +} + +static void ir_builder_split_vector(ir_builder *self, ir_value *vec) { + size_t i, count; + ir_value* found[3] = { NULL, NULL, NULL }; + + /* must not be written to */ + if (vec_size(vec->writes)) + return; + /* must not be trying to access individual members */ + if (vec->members[0] || vec->members[1] || vec->members[2]) + return; + /* should be actually used otherwise it won't be generated anyway */ + count = vec_size(vec->reads); + if (!count) + return; + + /* may only be used directly as function parameters, so if we find some other instruction cancel */ + for (i = 0; i != count; ++i) { + /* we only split vectors if they're used directly as parameter to a call only! */ + ir_instr *user = vec->reads[i]; + if ((user->opcode < INSTR_CALL0 || user->opcode > INSTR_CALL8) && user->opcode != VINSTR_NRCALL) + return; + } + + vec->flags |= IR_FLAG_SPLIT_VECTOR; + + /* find existing floats making up the split */ + count = vec_size(self->const_floats); + for (i = 0; i != count; ++i) { + ir_value *c = self->const_floats[i]; + if (!found[0] && c->constval.vfloat == vec->constval.vvec.x) + found[0] = c; + if (!found[1] && c->constval.vfloat == vec->constval.vvec.y) + found[1] = c; + if (!found[2] && c->constval.vfloat == vec->constval.vvec.z) + found[2] = c; + if (found[0] && found[1] && found[2]) + break; + } + + /* generate floats for not yet found components */ + if (!found[0]) + found[0] = ir_builder_imm_float(self, vec->constval.vvec.x, true); + if (!found[1]) { + if (vec->constval.vvec.y == vec->constval.vvec.x) + found[1] = found[0]; + else + found[1] = ir_builder_imm_float(self, vec->constval.vvec.y, true); + } + if (!found[2]) { + if (vec->constval.vvec.z == vec->constval.vvec.x) + found[2] = found[0]; + else if (vec->constval.vvec.z == vec->constval.vvec.y) + found[2] = found[1]; + else + found[2] = ir_builder_imm_float(self, vec->constval.vvec.z, true); + } + + /* the .members array should be safe to use here. */ + vec->members[0] = found[0]; + vec->members[1] = found[1]; + vec->members[2] = found[2]; + + /* register the readers for these floats */ + count = vec_size(vec->reads); + for (i = 0; i != count; ++i) { + vec_push(found[0]->reads, vec->reads[i]); + vec_push(found[1]->reads, vec->reads[i]); + vec_push(found[2]->reads, vec->reads[i]); + } +} + +static void ir_builder_split_vectors(ir_builder *self) { + size_t i, count = vec_size(self->globals); + for (i = 0; i != count; ++i) { + ir_value *v = self->globals[i]; + if (v->vtype != TYPE_VECTOR || !v->name || v->name[0] != '#') + continue; + ir_builder_split_vector(self, self->globals[i]); + } +} + +bool ir_builder_generate(ir_builder *self, const char *filename) { - prog_section_statement stmt; + prog_section_statement_t stmt; size_t i; char *lnofile = NULL; + if (OPTS_FLAG(SPLIT_VECTOR_PARAMETERS)) { + ir_builder_collect_reusables(self); + if (vec_size(self->const_floats) > 0) + ir_builder_split_vectors(self); + } + for (i = 0; i < vec_size(self->fields); ++i) { - ir_builder_prepare_field(code, self->fields[i]); + ir_builder_prepare_field(self->code, self->fields[i]); } for (i = 0; i < vec_size(self->globals); ++i) { - if (!ir_builder_gen_global(code, self, self->globals[i], false)) { + if (!ir_builder_gen_global(self, self->globals[i], false)) { return false; } if (self->globals[i]->vtype == TYPE_FUNCTION) { @@ -3617,60 +4067,73 @@ bool ir_builder_generate(code_t *code, ir_builder *self, const char *filename) for (i = 0; i < vec_size(self->fields); ++i) { - if (!ir_builder_gen_field(code, self, self->fields[i])) { + if (!ir_builder_gen_field(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(self->code->globals)); + vec_push(self->code->globals, 0); + vec_push(self->code->globals, 0); + vec_push(self->code->globals, 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); + } /* generate global temps */ - self->first_common_globaltemp = vec_size(code->globals); + self->first_common_globaltemp = vec_size(self->code->globals); for (i = 0; i < self->max_globaltemps; ++i) { - vec_push(code->globals, 0); + vec_push(self->code->globals, 0); } /* generate common locals */ - self->first_common_local = vec_size(code->globals); + self->first_common_local = vec_size(self->code->globals); for (i = 0; i < self->max_locals; ++i) { - vec_push(code->globals, 0); + vec_push(self->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(code, self, self->globals[i])) { + if (!gen_global_function_code(self, self->globals[i])) { return false; } } } - 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."); + 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)); return false; } /* DP errors if the last instruction is not an INSTR_DONE. */ - if (vec_last(code->statements).opcode != INSTR_DONE) + if (vec_last(self->code->statements).opcode != INSTR_DONE) { + lex_ctx_t last; + stmt.opcode = INSTR_DONE; - stmt.o1.u1 = 0; - stmt.o2.u1 = 0; - stmt.o3.u1 = 0; - code_push_statement(code, &stmt, vec_last(code->linenums)); + 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); + + code_push_statement(self->code, &stmt, last); } if (OPTS_OPTION_BOOL(OPTION_PP_ONLY)) return true; - if (vec_size(code->statements) != vec_size(code->linenums)) { + if (vec_size(self->code->statements) != vec_size(self->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(self->code->statements), + (unsigned long)vec_size(self->code->linenums)); } else if (OPTS_FLAG(LNO)) { char *dot; size_t filelen = strlen(filename); @@ -3685,16 +4148,11 @@ bool ir_builder_generate(code_t *code, ir_builder *self, const char *filename) memcpy(vec_add(lnofile, 5), ".lno", 5); } - if (!OPTS_OPTION_BOOL(OPTION_QUIET)) { - if (lnofile) - con_out("writing '%s' and '%s'...\n", filename, lnofile); - else - con_out("writing '%s'\n", filename); - } - if (!code_write(code, filename, lnofile)) { + if (!code_write(self->code, filename, lnofile)) { vec_free(lnofile); return false; } + vec_free(lnofile); return true; } @@ -3705,20 +4163,27 @@ bool ir_builder_generate(code_t *code, ir_builder *self, const char *filename) #define IND_BUFSZ 1024 -#ifdef _MSC_VER -# define strncat(dst, src, sz) strncat_s(dst, sz, src, _TRUNCATE) -#endif - static const char *qc_opname(int op) { if (op < 0) return ""; - if (op < (int)( sizeof(asm_instr) / sizeof(asm_instr[0]) )) - return asm_instr[op].m; + if (op < VINSTR_END) + return util_instr_str[op]; switch (op) { - case VINSTR_PHI: return "PHI"; - case VINSTR_JUMP: return "JUMP"; - case VINSTR_COND: return "COND"; - default: return ""; + case VINSTR_END: return "END"; + case VINSTR_PHI: return "PHI"; + case VINSTR_JUMP: return "JUMP"; + case VINSTR_COND: return "COND"; + case VINSTR_BITXOR: return "BITXOR"; + case VINSTR_BITAND_V: return "BITAND_V"; + case VINSTR_BITOR_V: return "BITOR_V"; + case VINSTR_BITXOR_V: return "BITXOR_V"; + case VINSTR_BITAND_VF: return "BITAND_VF"; + case VINSTR_BITOR_VF: return "BITOR_VF"; + case VINSTR_BITXOR_VF: return "BITXOR_VF"; + case VINSTR_CROSS: return "CROSS"; + case VINSTR_NEG_F: return "NEG_F"; + case VINSTR_NEG_V: return "NEG_V"; + default: return ""; } } @@ -3756,7 +4221,7 @@ void ir_function_dump(ir_function *f, char *ind, return; } oprintf("%sfunction %s\n", ind, f->name); - strncat(ind, "\t", IND_BUFSZ); + util_strncat(ind, "\t", IND_BUFSZ-1); if (vec_size(f->locals)) { oprintf("%s%i locals:\n", ind, (int)vec_size(f->locals)); @@ -3852,7 +4317,7 @@ void ir_block_dump(ir_block* b, char *ind, { size_t i; oprintf("%s:%s\n", ind, b->label); - strncat(ind, "\t", IND_BUFSZ); + util_strncat(ind, "\t", IND_BUFSZ-1); if (b->instr && b->instr[0]) oprintf("%s (%i) [entry]\n", ind, (int)(b->instr[0]->eid-1)); @@ -3886,7 +4351,7 @@ void ir_instr_dump(ir_instr *in, char *ind, return; } - strncat(ind, "\t", IND_BUFSZ); + util_strncat(ind, "\t", IND_BUFSZ-1); if (in->_ops[0] && (in->_ops[1] || in->_ops[2])) { ir_value_dump(in->_ops[0], oprintf);