X-Git-Url: https://git.xonotic.org/?p=xonotic%2Fgmqcc.git;a=blobdiff_plain;f=ir.h;h=1820317a52ba408f5ffb5ab93be0e470908eda41;hp=7f4106ee902eff29a63a17b71b93d254778f3d23;hb=e7d1e701c4498040ff77024d76a81cbc178c78f7;hpb=aabefd1bfe0c5b08bea9341c1394cfa8b96d754d diff --git a/ir.h b/ir.h index 7f4106e..1820317 100644 --- a/ir.h +++ b/ir.h @@ -14,11 +14,11 @@ struct ir_block; struct ir_function; struct ir_builder; -typedef struct { +struct ir_life_entry_t { /* both inclusive */ size_t start; size_t end; -} ir_life_entry_t; +}; enum { IR_FLAG_HAS_ARRAYS = 1 << 0, @@ -36,27 +36,32 @@ enum { }; struct ir_value { - char *name; - int vtype; - int store; - lex_ctx_t context; + ir_value(std::string&& name, store_type storetype, qc_type vtype); + ~ir_value(); + void* operator new(std::size_t); // to use mem_a + void operator delete(void*); // to use mem_d - int fieldtype; /* even the IR knows the subtype of a field */ - int outtype; /* and the output type of a function */ - int cvq; /* 'const' vs 'var' qualifier */ + std::string name; + + qc_type vtype; + store_type store; + lex_ctx_t context; + qc_type fieldtype; // even the IR knows the subtype of a field + qc_type outtype; // and the output type of a function + int cvq; // 'const' vs 'var' qualifier ir_flag_t flags; - ir_instr **reads; - ir_instr **writes; + std::vector reads; + std::vector writes; - /* constantvalues */ + // constant values bool hasvalue; union { - qcfloat_t vfloat; - int vint; - vec3_t vvec; - int32_t ivec[3]; + qcfloat_t vfloat; + int vint; + vec3_t vvec; + int32_t ivec[3]; char *vstring; ir_value *vpointer; ir_function *vfunc; @@ -65,21 +70,20 @@ struct ir_value { struct { int32_t globaladdr; int32_t name; - int32_t local; /* filled by the local-allocator */ - int32_t addroffset; /* added for members */ - int32_t fieldaddr; /* to generate field-addresses early */ + int32_t local; // filled by the local-allocator + int32_t addroffset; // added for members + int32_t fieldaddr; // to generate field-addresses early } code; - /* for acessing vectors */ + // for accessing vectors ir_value *members[3]; ir_value *memberof; - - bool unique_life; /* arrays will never overlap with temps */ - bool locked; /* temps living during a CALL must be locked */ + bool unique_life; // arrays will never overlap with temps + bool locked; // temps living during a CALL must be locked bool callparam; - ir_life_entry_t *life; /* For the temp allocator */ + std::vector life; // For the temp allocator }; /* @@ -87,7 +91,6 @@ struct ir_value { * if a result of an operation: the function should store * it to remember to delete it / garbage collect it */ -void ir_value_delete(ir_value*); ir_value* ir_value_vector_member(ir_value*, unsigned int member); bool GMQCC_WARN ir_value_set_float(ir_value*, float f); bool GMQCC_WARN ir_value_set_func(ir_value*, int f); @@ -105,57 +108,69 @@ struct ir_phi_entry_t { /* instruction */ struct ir_instr { + void* operator new(std::size_t); + void operator delete(void*); + + ir_instr(lex_ctx_t, ir_block *owner, int opcode); + ~ir_instr(); + int opcode; lex_ctx_t context; - ir_value *(_ops[3]); - ir_block *(bops[2]); + ir_value *(_ops[3]) = { nullptr, nullptr, nullptr }; + ir_block *(bops[2]) = { nullptr, nullptr }; - ir_phi_entry_t *phi; - ir_value **params; + std::vector phi; + std::vector params; - /* For the temp-allocation */ - size_t eid; + // For the temp-allocation + size_t eid = 0; - /* For IFs */ - bool likely; + // For IFs + bool likely = true; ir_block *owner; }; /* block */ struct ir_block { - char *label; - lex_ctx_t context; - bool final; /* once a jump is added we're done */ + void* operator new(std::size_t); + void operator delete(void*); - ir_instr **instr; - ir_block **entries; - ir_block **exits; - ir_value **living; - - /* For the temp-allocation */ - size_t entry_id; - size_t eid; - bool is_return; + ir_block(ir_function *owner, const std::string& name); + ~ir_block(); ir_function *owner; + std::string label; + + lex_ctx_t context; + bool final = false; /* once a jump is added we're done */ + + ir_instr **instr = nullptr; + ir_block **entries = nullptr; + ir_block **exits = nullptr; + std::vector living; - bool generated; - size_t code_start; + /* For the temp-allocation */ + size_t entry_id = 0; + size_t eid = 0; + bool is_return = false; + + bool generated = false; + size_t code_start = 0; }; ir_value* ir_block_create_binop(ir_block*, lex_ctx_t, const char *label, int op, ir_value *left, ir_value *right); ir_value* ir_block_create_unary(ir_block*, lex_ctx_t, const char *label, int op, ir_value *operand); bool GMQCC_WARN ir_block_create_store_op(ir_block*, lex_ctx_t, int op, ir_value *target, ir_value *what); bool GMQCC_WARN ir_block_create_storep(ir_block*, lex_ctx_t, ir_value *target, ir_value *what); -ir_value* ir_block_create_load_from_ent(ir_block*, lex_ctx_t, const char *label, ir_value *ent, ir_value *field, int outype); +ir_value* ir_block_create_load_from_ent(ir_block*, lex_ctx_t, const char *label, ir_value *ent, ir_value *field, qc_type outype); ir_value* ir_block_create_fieldaddress(ir_block*, lex_ctx_t, const char *label, ir_value *entity, ir_value *field); bool GMQCC_WARN ir_block_create_state_op(ir_block*, lex_ctx_t, ir_value *frame, ir_value *think); /* This is to create an instruction of the form * %label := opcode a, b */ -ir_instr* ir_block_create_phi(ir_block*, lex_ctx_t, const char *label, int vtype); +ir_instr* ir_block_create_phi(ir_block*, lex_ctx_t, const char *label, qc_type vtype); ir_value* ir_phi_value(ir_instr*); void ir_phi_add(ir_instr*, ir_block *b, ir_value *v); ir_instr* ir_block_create_call(ir_block*, lex_ctx_t, const char *label, ir_value *func, bool noreturn); @@ -178,27 +193,36 @@ bool GMQCC_WARN ir_block_create_goto(ir_block*, lex_ctx_t, ir_block *to); /* function */ struct ir_function { - char *name; - int outtype; - int *params; - ir_block **blocks; - ir_flag_t flags; - int builtin; + void* operator new(std::size_t); + void operator delete(void*); + + ir_function(ir_builder *owner, qc_type returntype); + ~ir_function(); + + ir_builder *owner; + + std::string name; + qc_type outtype; + int *params = nullptr; + ir_flag_t flags = 0; + int builtin = 0; + + std::vector> blocks; /* * values generated from operations * which might get optimized away, so anything * in there needs to be deleted in the dtor. */ - ir_value **values; - ir_value **locals; /* locally defined variables */ - ir_value *value; + std::vector> values; + std::vector> locals; /* locally defined variables */ + ir_value *value = nullptr; - size_t allocated_locals; - size_t globaltemps; + size_t allocated_locals = 0; + size_t globaltemps = 0; - ir_block* first; - ir_block* last; + ir_block* first = nullptr; + ir_block* last = nullptr; lex_ctx_t context; @@ -209,19 +233,17 @@ struct ir_function { * * remember the ID: */ - qcint_t code_function_def; + qcint_t code_function_def = -1; /* for temp allocation */ - size_t run_id; - - ir_builder *owner; + size_t run_id = 0; /* vararg support: */ - size_t max_varargs; + size_t max_varargs = 0; }; -ir_value* ir_function_create_local(ir_function *self, const char *name, int vtype, bool param); +ir_value* ir_function_create_local(ir_function *self, const std::string& name, qc_type vtype, bool param); bool GMQCC_WARN ir_function_finalize(ir_function*); ir_block* ir_function_create_block(lex_ctx_t ctx, ir_function*, const char *label); @@ -230,47 +252,55 @@ ir_block* ir_function_create_block(lex_ctx_t ctx, ir_function*, const char #define IR_MAX_VINSTR_TEMPS 1 struct ir_builder { - char *name; - ir_function **functions; - ir_value **globals; - ir_value **fields; - ir_value **const_floats; /* for reusing them in vector-splits, TODO: sort this or use a radix-tree */ + void* operator new(std::size_t); + void operator delete(void*); + ir_builder(const std::string& modulename); + ~ir_builder(); + + std::string name; + std::vector> functions; + std::vector> globals; + std::vector> fields; + // for reusing them in vector-splits, TODO: sort this or use a radix-tree + std::vector const_floats; ht htfunctions; ht htglobals; ht htfields; - ir_value **extparams; - ir_value **extparam_protos; + // extparams' ir_values reference the ones from extparam_protos + std::vector> extparam_protos; + std::vector extparams; - /* the highest func->allocated_locals */ - size_t max_locals; - size_t max_globaltemps; - uint32_t first_common_local; - uint32_t first_common_globaltemp; + // the highest func->allocated_locals + size_t max_locals = 0; + size_t max_globaltemps = 0; + uint32_t first_common_local = 0; + uint32_t first_common_globaltemp = 0; - const char **filenames; - qcint_t *filestrings; - /* we cache the #IMMEDIATE string here */ - qcint_t str_immediate; - /* there should just be this one nil */ + std::vector filenames; + std::vector filestrings; + + // we cache the #IMMEDIATE string here + qcint_t str_immediate = 0; + + // there should just be this one nil ir_value *nil; - ir_value *reserved_va_count; - ir_value *coverage_func; + ir_value *reserved_va_count = nullptr; + ir_value *coverage_func = nullptr; + /* some virtual instructions require temps, and their code is isolated * so that we don't need to keep track of their liveness. */ ir_value *vinstr_temp[IR_MAX_VINSTR_TEMPS]; /* code generator */ - code_t *code; + std::unique_ptr code; }; -ir_builder* ir_builder_new(const char *modulename); -void ir_builder_delete(ir_builder*); -ir_function* ir_builder_create_function(ir_builder*, const char *name, int outtype); -ir_value* ir_builder_create_global(ir_builder*, const char *name, int vtype); -ir_value* ir_builder_create_field(ir_builder*, const char *name, int vtype); +ir_function* ir_builder_create_function(ir_builder*, const std::string& name, qc_type outtype); +ir_value* ir_builder_create_global(ir_builder*, const std::string& name, qc_type vtype); +ir_value* ir_builder_create_field(ir_builder*, const std::string& name, qc_type vtype); ir_value* ir_builder_get_va_count(ir_builder*); bool ir_builder_generate(ir_builder *self, const char *filename); void ir_builder_dump(ir_builder*, int (*oprintf)(const char*, ...));