6 * Type large enough to hold all the possible IR flags. This should be
7 * changed if the static assertion at the end of this file fails.
9 typedef uint8_t ir_flag_t;
17 struct ir_life_entry_t {
24 IR_FLAG_HAS_ARRAYS = 1 << 0,
25 IR_FLAG_HAS_UNINITIALIZED = 1 << 1,
26 IR_FLAG_HAS_GOTO = 1 << 2,
27 IR_FLAG_INCLUDE_DEF = 1 << 3,
28 IR_FLAG_ERASABLE = 1 << 4,
29 IR_FLAG_BLOCK_COVERAGE = 1 << 5,
31 IR_FLAG_SPLIT_VECTOR = 1 << 6,
34 IR_FLAG_MASK_NO_OVERLAP = (IR_FLAG_HAS_ARRAYS | IR_FLAG_HAS_UNINITIALIZED),
35 IR_FLAG_MASK_NO_LOCAL_TEMPS = (IR_FLAG_HAS_ARRAYS | IR_FLAG_HAS_UNINITIALIZED)
39 ir_value(std::string&& name, store_type storetype, qc_type vtype);
47 qc_type m_fieldtype; // even the IR knows the subtype of a field
48 qc_type m_outtype; // and the output type of a function
49 int m_cvq; // 'const' vs 'var' qualifier
52 std::vector<ir_instr *> m_reads;
53 std::vector<ir_instr *> m_writes;
70 int32_t local; // filled by the local-allocator
71 int32_t addroffset; // added for members
72 int32_t fieldaddr; // to generate field-addresses early
75 // for accessing vectors
76 ir_value *m_members[3];
79 bool m_unique_life; // arrays will never overlap with temps
80 bool m_locked; // temps living during a CALL must be locked
83 std::vector<ir_life_entry_t> m_life; // For the temp allocator
87 * ir_value can be a variable, or created by an operation
88 * if a result of an operation: the function should store
89 * it to remember to delete it / garbage collect it
91 ir_value* ir_value_vector_member(ir_value*, unsigned int member);
92 bool GMQCC_WARN ir_value_set_float(ir_value*, float f);
93 bool GMQCC_WARN ir_value_set_func(ir_value*, int f);
94 bool GMQCC_WARN ir_value_set_string(ir_value*, const char *s);
95 bool GMQCC_WARN ir_value_set_vector(ir_value*, vec3_t v);
96 bool GMQCC_WARN ir_value_set_field(ir_value*, ir_value *fld);
97 bool ir_value_lives(ir_value*, size_t);
98 void ir_value_dump_life(const ir_value *self, int (*oprintf)(const char*,...));
101 struct ir_phi_entry_t {
108 ir_instr(lex_ctx_t, ir_block *owner, int opcode);
113 ir_value *(_m_ops[3]) = { nullptr, nullptr, nullptr };
114 ir_block *(m_bops[2]) = { nullptr, nullptr };
116 std::vector<ir_phi_entry_t> m_phi;
117 std::vector<ir_value *> m_params;
119 // For the temp-allocation
123 bool m_likely = true;
130 ir_block(ir_function *owner, const std::string& name);
133 ir_function *m_owner;
137 bool m_final = false; /* once a jump is added we're done */
139 ir_instr **m_instr = nullptr;
140 ir_block **m_entries = nullptr;
141 ir_block **m_exits = nullptr;
142 std::vector<ir_value *> m_living;
144 /* For the temp-allocation */
145 size_t m_entry_id = 0;
147 bool m_is_return = false;
149 bool m_generated = false;
150 size_t m_code_start = 0;
153 ir_value* ir_block_create_binop(ir_block*, lex_ctx_t, const char *label, int op, ir_value *left, ir_value *right);
154 ir_value* ir_block_create_unary(ir_block*, lex_ctx_t, const char *label, int op, ir_value *operand);
155 bool GMQCC_WARN ir_block_create_store_op(ir_block*, lex_ctx_t, int op, ir_value *target, ir_value *what);
156 bool GMQCC_WARN ir_block_create_storep(ir_block*, lex_ctx_t, ir_value *target, ir_value *what);
157 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);
158 ir_value* ir_block_create_fieldaddress(ir_block*, lex_ctx_t, const char *label, ir_value *entity, ir_value *field);
159 bool GMQCC_WARN ir_block_create_state_op(ir_block*, lex_ctx_t, ir_value *frame, ir_value *think);
161 /* This is to create an instruction of the form
162 * <outtype>%label := opcode a, b
164 ir_instr* ir_block_create_phi(ir_block*, lex_ctx_t, const char *label, qc_type vtype);
165 ir_value* ir_phi_value(ir_instr*);
166 void ir_phi_add(ir_instr*, ir_block *b, ir_value *v);
167 ir_instr* ir_block_create_call(ir_block*, lex_ctx_t, const char *label, ir_value *func, bool noreturn);
168 ir_value* ir_call_value(ir_instr*);
169 void ir_call_param(ir_instr*, ir_value*);
171 bool GMQCC_WARN ir_block_create_return(ir_block*, lex_ctx_t, ir_value *opt_value);
173 bool GMQCC_WARN ir_block_create_if(ir_block*, lex_ctx_t, ir_value *cond,
174 ir_block *ontrue, ir_block *onfalse);
176 * A 'goto' is an actual 'goto' coded in QC, whereas
177 * a 'jump' is a virtual construct which simply names the
178 * next block to go to.
179 * A goto usually becomes an OP_GOTO in the resulting code,
180 * whereas a 'jump' usually doesn't add any actual instruction.
182 bool GMQCC_WARN ir_block_create_jump(ir_block*, lex_ctx_t, ir_block *to);
183 bool GMQCC_WARN ir_block_create_goto(ir_block*, lex_ctx_t, ir_block *to);
187 ir_function(ir_builder *owner, qc_type returntype);
194 int *m_params = nullptr;
195 ir_flag_t m_flags = 0;
198 std::vector<std::unique_ptr<ir_block>> m_blocks;
201 * values generated from operations
202 * which might get optimized away, so anything
203 * in there needs to be deleted in the dtor.
205 std::vector<std::unique_ptr<ir_value>> m_values;
206 std::vector<std::unique_ptr<ir_value>> m_locals; /* locally defined variables */
207 ir_value *m_value = nullptr;
209 size_t m_allocated_locals = 0;
210 size_t m_globaltemps = 0;
212 ir_block* m_first = nullptr;
213 ir_block* m_last = nullptr;
218 * for prototypes - first we generate all the
219 * globals, and we remember teh function-defs
220 * so we can later fill in the entry pos
224 qcint_t m_code_function_def = -1;
226 /* for temp allocation */
229 /* vararg support: */
230 size_t m_max_varargs = 0;
234 ir_value* ir_function_create_local(ir_function *self, const std::string& name, qc_type vtype, bool param);
235 bool GMQCC_WARN ir_function_finalize(ir_function*);
236 ir_block* ir_function_create_block(lex_ctx_t ctx, ir_function*, const char *label);
239 #define IR_HT_SIZE 1024
240 #define IR_MAX_VINSTR_TEMPS 1
243 ir_builder(const std::string& modulename);
247 std::vector<std::unique_ptr<ir_function>> m_functions;
248 std::vector<std::unique_ptr<ir_value>> m_globals;
249 std::vector<std::unique_ptr<ir_value>> m_fields;
250 // for reusing them in vector-splits, TODO: sort this or use a radix-tree
251 std::vector<ir_value*> m_const_floats;
257 // extparams' ir_values reference the ones from extparam_protos
258 std::vector<std::unique_ptr<ir_value>> m_extparam_protos;
259 std::vector<ir_value*> m_extparams;
261 // the highest func->allocated_locals
262 size_t m_max_locals = 0;
263 size_t m_max_globaltemps = 0;
264 uint32_t m_first_common_local = 0;
265 uint32_t m_first_common_globaltemp = 0;
267 std::vector<const char*> m_filenames;
268 std::vector<qcint_t> m_filestrings;
270 // we cache the #IMMEDIATE string here
271 qcint_t m_str_immediate = 0;
273 // there should just be this one nil
275 ir_value *m_reserved_va_count = nullptr;
276 ir_value *m_coverage_func = nullptr;
278 /* some virtual instructions require temps, and their code is isolated
279 * so that we don't need to keep track of their liveness.
281 ir_value *m_vinstr_temp[IR_MAX_VINSTR_TEMPS];
284 std::unique_ptr<code_t> m_code;
287 ir_function* ir_builder_create_function(ir_builder*, const std::string& name, qc_type outtype);
288 ir_value* ir_builder_create_global(ir_builder*, const std::string& name, qc_type vtype);
289 ir_value* ir_builder_create_field(ir_builder*, const std::string& name, qc_type vtype);
290 ir_value* ir_builder_get_va_count(ir_builder*);
291 bool ir_builder_generate(ir_builder *self, const char *filename);
292 void ir_builder_dump(ir_builder*, int (*oprintf)(const char*, ...));
295 * This code assumes 32 bit floats while generating binary
296 * Blub: don't use extern here, it's annoying and shows up in nm
299 typedef int static_assert_is_32bit_float [(sizeof(int32_t) == 4) ? 1 : -1];
300 typedef int static_assert_is_32bit_integer[(sizeof(qcfloat_t) == 4) ? 1 : -1];
303 * If the condition creates a situation where this becomes -1 size it means there are
304 * more IR_FLAGs than the type ir_flag_t is capable of holding. So either eliminate
305 * the IR flag count or change the ir_flag_t typedef to a type large enough to accomodate
308 typedef int static_assert_is_ir_flag_safe [((IR_FLAG_LAST) <= (ir_flag_t)(-1)) ? 1 : -1];