Commit b11ac9c5bf
Changed files (9)
src/stage1/all_types.hpp
@@ -51,7 +51,7 @@ struct ResultLocPeerParent;
struct ResultLocBitCast;
struct ResultLocCast;
struct ResultLocReturn;
-struct IrExecutableGen;
+struct Stage1Air;
enum FileExt {
FileExtUnknown,
@@ -116,19 +116,14 @@ struct Stage1Zir {
ZigFn *name_fn;
size_t mem_slot_count;
size_t next_debug_id;
- size_t *backward_branch_count;
- size_t *backward_branch_quota;
ZigFn *fn_entry;
Buf *c_import_buf;
AstNode *source_node;
- IrExecutableGen *parent_exec;
- IrAnalyze *analysis;
Scope *begin_scope;
ErrorMsg *first_err_trace_msg;
ZigList<Tld *> tld_list;
bool is_inline;
- bool is_generic_instantiation;
bool need_err_code_spill;
// This is a function for use in the debugger to print
@@ -136,25 +131,22 @@ struct Stage1Zir {
void src();
};
-struct IrExecutableGen {
+struct Stage1Air {
ZigList<IrBasicBlockGen *> basic_block_list;
Buf *name;
ZigFn *name_fn;
size_t mem_slot_count;
size_t next_debug_id;
- size_t *backward_branch_count;
- size_t *backward_branch_quota;
ZigFn *fn_entry;
Buf *c_import_buf;
AstNode *source_node;
- IrExecutableGen *parent_exec;
+ Stage1Air *parent_exec;
Stage1Zir *source_exec;
Scope *begin_scope;
ErrorMsg *first_err_trace_msg;
ZigList<Tld *> tld_list;
bool is_inline;
- bool is_generic_instantiation;
bool need_err_code_spill;
// This is a function for use in the debugger to print
@@ -1652,9 +1644,8 @@ struct ZigFn {
// zig source code, not according to zig ir
ZigType *src_implicit_return_type;
Stage1Zir *ir_executable;
- IrExecutableGen analyzed_executable;
- size_t prealloc_bbc;
- size_t prealloc_backward_branch_quota;
+ Stage1Air analyzed_executable;
+ size_t branch_quota;
AstNode **param_source_nodes;
Buf **param_names;
IrInstGen *err_code_spill;
src/stage1/analyze.cpp
@@ -3655,10 +3655,6 @@ static ZigFn *create_fn_raw(CodeGen *g, bool is_noinline) {
ZigFn *fn_entry = heap::c_allocator.create<ZigFn>();
fn_entry->ir_executable = heap::c_allocator.create<Stage1Zir>();
- fn_entry->prealloc_backward_branch_quota = default_backward_branch_quota;
-
- fn_entry->analyzed_executable.backward_branch_count = &fn_entry->prealloc_bbc;
- fn_entry->analyzed_executable.backward_branch_quota = &fn_entry->prealloc_backward_branch_quota;
fn_entry->analyzed_executable.fn_entry = fn_entry;
fn_entry->ir_executable->fn_entry = fn_entry;
fn_entry->is_noinline = is_noinline;
@@ -5134,8 +5130,11 @@ static void analyze_fn_ir(CodeGen *g, ZigFn *fn, AstNode *return_type_node) {
if (fn->analyzed_executable.source_node == nullptr) {
fn->analyzed_executable.source_node = fn->body_node;
}
- ZigType *block_return_type = ir_analyze(g, fn->ir_executable,
- &fn->analyzed_executable, fn_type_id->return_type, return_type_node, nullptr);
+ size_t backward_branch_count = 0;
+ size_t backward_branch_quota = max(fn->branch_quota, default_backward_branch_quota);
+ ZigType *block_return_type = ir_analyze(g, fn->ir_executable, &fn->analyzed_executable,
+ &backward_branch_count, &backward_branch_quota,
+ fn_type_id->return_type, return_type_node, nullptr);
fn->src_implicit_return_type = block_return_type;
if (type_is_invalid(block_return_type) || fn->analyzed_executable.first_err_trace_msg != nullptr) {
@@ -9866,13 +9865,10 @@ void Stage1Zir::src() {
if (this->source_node != nullptr) {
this->source_node->src();
}
- if (this->parent_exec != nullptr) {
- this->parent_exec->src();
- }
}
-void IrExecutableGen::src() {
- IrExecutableGen *it;
+void Stage1Air::src() {
+ Stage1Air *it;
for (it = this; it != nullptr && it->source_node != nullptr; it = it->parent_exec) {
it->source_node->src();
}
src/stage1/astgen.cpp
@@ -41,19 +41,9 @@ static void ir_assert_impl(bool ok, IrInst *source_instruction, char const *file
src_assert_impl(ok, source_instruction->source_node, file, line);
}
-static void ir_add_call_stack_errors(CodeGen *codegen, Stage1Zir *exec, ErrorMsg *err_msg, int limit) {
- if (!exec || !exec->source_node || limit < 0) return;
- add_error_note(codegen, err_msg, exec->source_node, buf_sprintf("called from here"));
-
- ir_add_call_stack_errors_gen(codegen, exec->parent_exec, err_msg, limit - 1);
-}
-
static ErrorMsg *exec_add_error_node(CodeGen *codegen, Stage1Zir *exec, AstNode *source_node, Buf *msg) {
ErrorMsg *err_msg = add_node_error(codegen, source_node, msg);
invalidate_exec(exec, err_msg);
- if (exec->parent_exec) {
- ir_add_call_stack_errors(codegen, exec, err_msg, 10);
- }
return err_msg;
}
@@ -8118,7 +8108,7 @@ AstNode *ast_field_to_symbol_node(AstNode *err_set_field_node) {
}
}
-void ir_add_call_stack_errors_gen(CodeGen *codegen, IrExecutableGen *exec, ErrorMsg *err_msg, int limit) {
+void ir_add_call_stack_errors_gen(CodeGen *codegen, Stage1Air *exec, ErrorMsg *err_msg, int limit) {
if (!exec || !exec->source_node || limit < 0) return;
add_error_note(codegen, err_msg, exec->source_node, buf_sprintf("called from here"));
src/stage1/astgen.hpp
@@ -24,7 +24,7 @@ ResultLoc *no_result_loc(void);
void invalidate_exec(Stage1Zir *exec, ErrorMsg *msg);
AstNode *ast_field_to_symbol_node(AstNode *err_set_field_node);
-void ir_add_call_stack_errors_gen(CodeGen *codegen, IrExecutableGen *exec, ErrorMsg *err_msg,
+void ir_add_call_stack_errors_gen(CodeGen *codegen, Stage1Air *exec, ErrorMsg *err_msg,
int limit);
void destroy_instruction_src(IrInstSrc *inst);
src/stage1/codegen.cpp
@@ -2443,7 +2443,7 @@ static LLVMValueRef get_merge_err_ret_traces_fn_val(CodeGen *g) {
return fn_val;
}
-static LLVMValueRef ir_render_save_err_ret_addr(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_save_err_ret_addr(CodeGen *g, Stage1Air *executable,
IrInstGenSaveErrRetAddr *save_err_ret_addr_instruction)
{
assert(g->have_err_ret_tracing);
@@ -2636,7 +2636,7 @@ static void gen_async_return(CodeGen *g, IrInstGenReturn *instruction) {
LLVMBuildRetVoid(g->builder);
}
-static LLVMValueRef ir_render_return(CodeGen *g, IrExecutableGen *executable, IrInstGenReturn *instruction) {
+static LLVMValueRef ir_render_return(CodeGen *g, Stage1Air *executable, IrInstGenReturn *instruction) {
if (fn_is_async(g->cur_fn)) {
gen_async_return(g, instruction);
return nullptr;
@@ -3061,7 +3061,7 @@ static void gen_shift_rhs_check(CodeGen *g, ZigType *lhs_type, ZigType *rhs_type
}
}
-static LLVMValueRef ir_render_bin_op(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_bin_op(CodeGen *g, Stage1Air *executable,
IrInstGenBinOp *bin_op_instruction)
{
IrBinOp op_id = bin_op_instruction->op_id;
@@ -3283,7 +3283,7 @@ static void add_error_range_check(CodeGen *g, ZigType *err_set_type, ZigType *in
}
}
-static LLVMValueRef ir_render_cast(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_cast(CodeGen *g, Stage1Air *executable,
IrInstGenCast *cast_instruction)
{
Error err;
@@ -3367,7 +3367,7 @@ static LLVMValueRef ir_render_cast(CodeGen *g, IrExecutableGen *executable,
zig_unreachable();
}
-static LLVMValueRef ir_render_ptr_of_array_to_slice(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_ptr_of_array_to_slice(CodeGen *g, Stage1Air *executable,
IrInstGenPtrOfArrayToSlice *instruction)
{
ZigType *actual_type = instruction->operand->value->type;
@@ -3404,7 +3404,7 @@ static LLVMValueRef ir_render_ptr_of_array_to_slice(CodeGen *g, IrExecutableGen
return result_loc;
}
-static LLVMValueRef ir_render_ptr_cast(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_ptr_cast(CodeGen *g, Stage1Air *executable,
IrInstGenPtrCast *instruction)
{
ZigType *wanted_type = instruction->base.value->type;
@@ -3430,7 +3430,7 @@ static LLVMValueRef ir_render_ptr_cast(CodeGen *g, IrExecutableGen *executable,
return result_ptr;
}
-static LLVMValueRef ir_render_bit_cast(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_bit_cast(CodeGen *g, Stage1Air *executable,
IrInstGenBitCast *instruction)
{
ZigType *wanted_type = instruction->base.value->type;
@@ -3458,7 +3458,7 @@ static LLVMValueRef ir_render_bit_cast(CodeGen *g, IrExecutableGen *executable,
}
}
-static LLVMValueRef ir_render_widen_or_shorten(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_widen_or_shorten(CodeGen *g, Stage1Air *executable,
IrInstGenWidenOrShorten *instruction)
{
ZigType *actual_type = instruction->target->value->type;
@@ -3475,7 +3475,7 @@ static LLVMValueRef ir_render_widen_or_shorten(CodeGen *g, IrExecutableGen *exec
instruction->base.value->type, target_val);
}
-static LLVMValueRef ir_render_int_to_ptr(CodeGen *g, IrExecutableGen *executable, IrInstGenIntToPtr *instruction) {
+static LLVMValueRef ir_render_int_to_ptr(CodeGen *g, Stage1Air *executable, IrInstGenIntToPtr *instruction) {
ZigType *wanted_type = instruction->base.value->type;
LLVMValueRef target_val = ir_llvm_value(g, instruction->target);
const uint32_t align_bytes = get_ptr_align(g, wanted_type);
@@ -3513,13 +3513,13 @@ static LLVMValueRef ir_render_int_to_ptr(CodeGen *g, IrExecutableGen *executable
return LLVMBuildIntToPtr(g->builder, target_val, get_llvm_type(g, wanted_type), "");
}
-static LLVMValueRef ir_render_ptr_to_int(CodeGen *g, IrExecutableGen *executable, IrInstGenPtrToInt *instruction) {
+static LLVMValueRef ir_render_ptr_to_int(CodeGen *g, Stage1Air *executable, IrInstGenPtrToInt *instruction) {
ZigType *wanted_type = instruction->base.value->type;
LLVMValueRef target_val = ir_llvm_value(g, instruction->target);
return LLVMBuildPtrToInt(g->builder, target_val, get_llvm_type(g, wanted_type), "");
}
-static LLVMValueRef ir_render_int_to_enum(CodeGen *g, IrExecutableGen *executable, IrInstGenIntToEnum *instruction) {
+static LLVMValueRef ir_render_int_to_enum(CodeGen *g, Stage1Air *executable, IrInstGenIntToEnum *instruction) {
ZigType *wanted_type = instruction->base.value->type;
assert(wanted_type->id == ZigTypeIdEnum);
ZigType *tag_int_type = wanted_type->data.enumeration.tag_int_type;
@@ -3559,7 +3559,7 @@ static LLVMValueRef ir_render_int_to_enum(CodeGen *g, IrExecutableGen *executabl
return tag_int_value;
}
-static LLVMValueRef ir_render_int_to_err(CodeGen *g, IrExecutableGen *executable, IrInstGenIntToErr *instruction) {
+static LLVMValueRef ir_render_int_to_err(CodeGen *g, Stage1Air *executable, IrInstGenIntToErr *instruction) {
ZigType *wanted_type = instruction->base.value->type;
assert(wanted_type->id == ZigTypeIdErrorSet);
@@ -3576,7 +3576,7 @@ static LLVMValueRef ir_render_int_to_err(CodeGen *g, IrExecutableGen *executable
return gen_widen_or_shorten(g, false, actual_type, g->err_tag_type, target_val);
}
-static LLVMValueRef ir_render_err_to_int(CodeGen *g, IrExecutableGen *executable, IrInstGenErrToInt *instruction) {
+static LLVMValueRef ir_render_err_to_int(CodeGen *g, Stage1Air *executable, IrInstGenErrToInt *instruction) {
ZigType *wanted_type = instruction->base.value->type;
assert(wanted_type->id == ZigTypeIdInt);
assert(!wanted_type->data.integral.is_signed);
@@ -3602,7 +3602,7 @@ static LLVMValueRef ir_render_err_to_int(CodeGen *g, IrExecutableGen *executable
}
}
-static LLVMValueRef ir_render_unreachable(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_unreachable(CodeGen *g, Stage1Air *executable,
IrInstGenUnreachable *unreachable_instruction)
{
if (ir_want_runtime_safety(g, &unreachable_instruction->base)) {
@@ -3613,7 +3613,7 @@ static LLVMValueRef ir_render_unreachable(CodeGen *g, IrExecutableGen *executabl
return nullptr;
}
-static LLVMValueRef ir_render_cond_br(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_cond_br(CodeGen *g, Stage1Air *executable,
IrInstGenCondBr *cond_br_instruction)
{
LLVMBuildCondBr(g->builder,
@@ -3623,12 +3623,12 @@ static LLVMValueRef ir_render_cond_br(CodeGen *g, IrExecutableGen *executable,
return nullptr;
}
-static LLVMValueRef ir_render_br(CodeGen *g, IrExecutableGen *executable, IrInstGenBr *br_instruction) {
+static LLVMValueRef ir_render_br(CodeGen *g, Stage1Air *executable, IrInstGenBr *br_instruction) {
LLVMBuildBr(g->builder, br_instruction->dest_block->llvm_block);
return nullptr;
}
-static LLVMValueRef ir_render_binary_not(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_binary_not(CodeGen *g, Stage1Air *executable,
IrInstGenBinaryNot *inst)
{
LLVMValueRef operand = ir_llvm_value(g, inst->operand);
@@ -3660,13 +3660,13 @@ static LLVMValueRef ir_gen_negation(CodeGen *g, IrInstGen *inst, IrInstGen *oper
}
}
-static LLVMValueRef ir_render_negation(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_negation(CodeGen *g, Stage1Air *executable,
IrInstGenNegation *inst)
{
return ir_gen_negation(g, &inst->base, inst->operand, inst->wrapping);
}
-static LLVMValueRef ir_render_bool_not(CodeGen *g, IrExecutableGen *executable, IrInstGenBoolNot *instruction) {
+static LLVMValueRef ir_render_bool_not(CodeGen *g, Stage1Air *executable, IrInstGenBoolNot *instruction) {
LLVMValueRef value = ir_llvm_value(g, instruction->value);
LLVMValueRef zero = LLVMConstNull(LLVMTypeOf(value));
return LLVMBuildICmp(g->builder, LLVMIntEQ, value, zero, "");
@@ -3680,14 +3680,14 @@ static void render_decl_var(CodeGen *g, ZigVar *var) {
gen_var_debug_decl(g, var);
}
-static LLVMValueRef ir_render_decl_var(CodeGen *g, IrExecutableGen *executable, IrInstGenDeclVar *instruction) {
+static LLVMValueRef ir_render_decl_var(CodeGen *g, Stage1Air *executable, IrInstGenDeclVar *instruction) {
instruction->var->ptr_instruction = instruction->var_ptr;
instruction->var->did_the_decl_codegen = true;
render_decl_var(g, instruction->var);
return nullptr;
}
-static LLVMValueRef ir_render_load_ptr(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_load_ptr(CodeGen *g, Stage1Air *executable,
IrInstGenLoadPtr *instruction)
{
ZigType *child_type = instruction->base.value->type;
@@ -3889,7 +3889,7 @@ static void gen_undef_init(CodeGen *g, ZigType *ptr_type, ZigType *value_type, L
gen_assign_raw(g, ptr, ptr_type, zero);
}
-static LLVMValueRef ir_render_store_ptr(CodeGen *g, IrExecutableGen *executable, IrInstGenStorePtr *instruction) {
+static LLVMValueRef ir_render_store_ptr(CodeGen *g, Stage1Air *executable, IrInstGenStorePtr *instruction) {
Error err;
ZigType *ptr_type = instruction->ptr->value->type;
@@ -3921,7 +3921,7 @@ static LLVMValueRef ir_render_store_ptr(CodeGen *g, IrExecutableGen *executable,
return nullptr;
}
-static LLVMValueRef ir_render_vector_store_elem(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_vector_store_elem(CodeGen *g, Stage1Air *executable,
IrInstGenVectorStoreElem *instruction)
{
LLVMValueRef vector_ptr = ir_llvm_value(g, instruction->vector_ptr);
@@ -3934,7 +3934,7 @@ static LLVMValueRef ir_render_vector_store_elem(CodeGen *g, IrExecutableGen *exe
return nullptr;
}
-static LLVMValueRef ir_render_var_ptr(CodeGen *g, IrExecutableGen *executable, IrInstGenVarPtr *instruction) {
+static LLVMValueRef ir_render_var_ptr(CodeGen *g, Stage1Air *executable, IrInstGenVarPtr *instruction) {
Error err;
ZigType *ptr_type = instruction->base.value->type;
@@ -3961,7 +3961,7 @@ static LLVMValueRef ir_render_var_ptr(CodeGen *g, IrExecutableGen *executable, I
get_llvm_type(g, ptr_type), "");
}
-static LLVMValueRef ir_render_return_ptr(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_return_ptr(CodeGen *g, Stage1Air *executable,
IrInstGenReturnPtr *instruction)
{
if (!type_has_bits(g, instruction->base.value->type))
@@ -3970,7 +3970,7 @@ static LLVMValueRef ir_render_return_ptr(CodeGen *g, IrExecutableGen *executable
return g->cur_ret_ptr;
}
-static LLVMValueRef ir_render_elem_ptr(CodeGen *g, IrExecutableGen *executable, IrInstGenElemPtr *instruction) {
+static LLVMValueRef ir_render_elem_ptr(CodeGen *g, Stage1Air *executable, IrInstGenElemPtr *instruction) {
LLVMValueRef array_ptr_ptr = ir_llvm_value(g, instruction->array_ptr);
ZigType *array_ptr_type = instruction->array_ptr->value->type;
assert(array_ptr_type->id == ZigTypeIdPointer);
@@ -4222,7 +4222,7 @@ static void gen_init_stack_trace(CodeGen *g, LLVMValueRef trace_field_ptr, LLVMV
LLVMBuildStore(g->builder, LLVMConstInt(usize_type_ref, stack_trace_ptr_count, false), addrs_len_ptr);
}
-static LLVMValueRef ir_render_call(CodeGen *g, IrExecutableGen *executable, IrInstGenCall *instruction) {
+static LLVMValueRef ir_render_call(CodeGen *g, Stage1Air *executable, IrInstGenCall *instruction) {
Error err;
LLVMTypeRef usize_type_ref = g->builtin_types.entry_usize->llvm_type;
@@ -4642,7 +4642,7 @@ static LLVMValueRef ir_render_call(CodeGen *g, IrExecutableGen *executable, IrIn
}
}
-static LLVMValueRef ir_render_struct_field_ptr(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_struct_field_ptr(CodeGen *g, Stage1Air *executable,
IrInstGenStructFieldPtr *instruction)
{
Error err;
@@ -4693,7 +4693,7 @@ static LLVMValueRef ir_render_struct_field_ptr(CodeGen *g, IrExecutableGen *exec
return field_ptr_val;
}
-static LLVMValueRef ir_render_union_field_ptr(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_union_field_ptr(CodeGen *g, Stage1Air *executable,
IrInstGenUnionFieldPtr *instruction)
{
if (instruction->base.value->special != ConstValSpecialRuntime)
@@ -4793,7 +4793,7 @@ static size_t find_asm_index(CodeGen *g, AstNode *node, AsmToken *tok, Buf *src_
return SIZE_MAX;
}
-static LLVMValueRef ir_render_asm_gen(CodeGen *g, IrExecutableGen *executable, IrInstGenAsm *instruction) {
+static LLVMValueRef ir_render_asm_gen(CodeGen *g, Stage1Air *executable, IrInstGenAsm *instruction) {
AstNode *asm_node = instruction->base.base.source_node;
assert(asm_node->type == NodeTypeAsmExpr);
AstNodeAsmExpr *asm_expr = &asm_node->data.asm_expr;
@@ -4970,13 +4970,13 @@ static LLVMValueRef gen_non_null_bit(CodeGen *g, ZigType *maybe_type, LLVMValueR
return gen_load_untyped(g, maybe_field_ptr, 0, false, "");
}
-static LLVMValueRef ir_render_test_non_null(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_test_non_null(CodeGen *g, Stage1Air *executable,
IrInstGenTestNonNull *instruction)
{
return gen_non_null_bit(g, instruction->value->value->type, ir_llvm_value(g, instruction->value));
}
-static LLVMValueRef ir_render_optional_unwrap_ptr(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_optional_unwrap_ptr(CodeGen *g, Stage1Air *executable,
IrInstGenOptionalUnwrapPtr *instruction)
{
if (instruction->base.value->special != ConstValSpecialRuntime)
@@ -5083,7 +5083,7 @@ static LLVMValueRef get_int_builtin_fn(CodeGen *g, ZigType *expr_type, BuiltinFn
return fn_val;
}
-static LLVMValueRef ir_render_clz(CodeGen *g, IrExecutableGen *executable, IrInstGenClz *instruction) {
+static LLVMValueRef ir_render_clz(CodeGen *g, Stage1Air *executable, IrInstGenClz *instruction) {
ZigType *int_type = instruction->op->value->type;
LLVMValueRef fn_val = get_int_builtin_fn(g, int_type, BuiltinFnIdClz);
LLVMValueRef operand = ir_llvm_value(g, instruction->op);
@@ -5095,7 +5095,7 @@ static LLVMValueRef ir_render_clz(CodeGen *g, IrExecutableGen *executable, IrIns
return gen_widen_or_shorten(g, false, int_type, instruction->base.value->type, wrong_size_int);
}
-static LLVMValueRef ir_render_ctz(CodeGen *g, IrExecutableGen *executable, IrInstGenCtz *instruction) {
+static LLVMValueRef ir_render_ctz(CodeGen *g, Stage1Air *executable, IrInstGenCtz *instruction) {
ZigType *int_type = instruction->op->value->type;
LLVMValueRef fn_val = get_int_builtin_fn(g, int_type, BuiltinFnIdCtz);
LLVMValueRef operand = ir_llvm_value(g, instruction->op);
@@ -5107,7 +5107,7 @@ static LLVMValueRef ir_render_ctz(CodeGen *g, IrExecutableGen *executable, IrIns
return gen_widen_or_shorten(g, false, int_type, instruction->base.value->type, wrong_size_int);
}
-static LLVMValueRef ir_render_shuffle_vector(CodeGen *g, IrExecutableGen *executable, IrInstGenShuffleVector *instruction) {
+static LLVMValueRef ir_render_shuffle_vector(CodeGen *g, Stage1Air *executable, IrInstGenShuffleVector *instruction) {
uint64_t len_a = instruction->a->value->type->data.vector.len;
uint64_t len_mask = instruction->mask->value->type->data.vector.len;
@@ -5137,7 +5137,7 @@ static LLVMValueRef ir_render_shuffle_vector(CodeGen *g, IrExecutableGen *execut
llvm_mask_value, "");
}
-static LLVMValueRef ir_render_splat(CodeGen *g, IrExecutableGen *executable, IrInstGenSplat *instruction) {
+static LLVMValueRef ir_render_splat(CodeGen *g, Stage1Air *executable, IrInstGenSplat *instruction) {
ZigType *result_type = instruction->base.value->type;
ir_assert(result_type->id == ZigTypeIdVector, &instruction->base);
uint32_t len = result_type->data.vector.len;
@@ -5149,7 +5149,7 @@ static LLVMValueRef ir_render_splat(CodeGen *g, IrExecutableGen *executable, IrI
return LLVMBuildShuffleVector(g->builder, op_vector, undef_vector, LLVMConstNull(mask_llvm_type), "");
}
-static LLVMValueRef ir_render_pop_count(CodeGen *g, IrExecutableGen *executable, IrInstGenPopCount *instruction) {
+static LLVMValueRef ir_render_pop_count(CodeGen *g, Stage1Air *executable, IrInstGenPopCount *instruction) {
ZigType *int_type = instruction->op->value->type;
LLVMValueRef fn_val = get_int_builtin_fn(g, int_type, BuiltinFnIdPopCount);
LLVMValueRef operand = ir_llvm_value(g, instruction->op);
@@ -5157,7 +5157,7 @@ static LLVMValueRef ir_render_pop_count(CodeGen *g, IrExecutableGen *executable,
return gen_widen_or_shorten(g, false, int_type, instruction->base.value->type, wrong_size_int);
}
-static LLVMValueRef ir_render_switch_br(CodeGen *g, IrExecutableGen *executable, IrInstGenSwitchBr *instruction) {
+static LLVMValueRef ir_render_switch_br(CodeGen *g, Stage1Air *executable, IrInstGenSwitchBr *instruction) {
ZigType *target_type = instruction->target_value->value->type;
LLVMBasicBlockRef else_block = instruction->else_block->llvm_block;
@@ -5185,7 +5185,7 @@ static LLVMValueRef ir_render_switch_br(CodeGen *g, IrExecutableGen *executable,
return nullptr;
}
-static LLVMValueRef ir_render_phi(CodeGen *g, IrExecutableGen *executable, IrInstGenPhi *instruction) {
+static LLVMValueRef ir_render_phi(CodeGen *g, Stage1Air *executable, IrInstGenPhi *instruction) {
if (!type_has_bits(g, instruction->base.value->type))
return nullptr;
@@ -5209,7 +5209,7 @@ static LLVMValueRef ir_render_phi(CodeGen *g, IrExecutableGen *executable, IrIns
return phi;
}
-static LLVMValueRef ir_render_ref(CodeGen *g, IrExecutableGen *executable, IrInstGenRef *instruction) {
+static LLVMValueRef ir_render_ref(CodeGen *g, Stage1Air *executable, IrInstGenRef *instruction) {
if (!type_has_bits(g, instruction->base.value->type)) {
return nullptr;
}
@@ -5229,7 +5229,7 @@ static LLVMValueRef ir_render_ref(CodeGen *g, IrExecutableGen *executable, IrIns
}
}
-static LLVMValueRef ir_render_err_name(CodeGen *g, IrExecutableGen *executable, IrInstGenErrName *instruction) {
+static LLVMValueRef ir_render_err_name(CodeGen *g, Stage1Air *executable, IrInstGenErrName *instruction) {
assert(g->generate_error_name_table);
assert(g->errors_by_index.length > 0);
@@ -5356,7 +5356,7 @@ static LLVMValueRef get_enum_tag_name_function(CodeGen *g, ZigType *enum_type) {
return fn_val;
}
-static LLVMValueRef ir_render_enum_tag_name(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_enum_tag_name(CodeGen *g, Stage1Air *executable,
IrInstGenTagName *instruction)
{
ZigType *enum_type = instruction->target->value->type;
@@ -5369,7 +5369,7 @@ static LLVMValueRef ir_render_enum_tag_name(CodeGen *g, IrExecutableGen *executa
get_llvm_cc(g, CallingConventionUnspecified), ZigLLVM_CallAttrAuto, "");
}
-static LLVMValueRef ir_render_field_parent_ptr(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_field_parent_ptr(CodeGen *g, Stage1Air *executable,
IrInstGenFieldParentPtr *instruction)
{
ZigType *container_ptr_type = instruction->base.value->type;
@@ -5396,7 +5396,7 @@ static LLVMValueRef ir_render_field_parent_ptr(CodeGen *g, IrExecutableGen *exec
}
}
-static LLVMValueRef ir_render_align_cast(CodeGen *g, IrExecutableGen *executable, IrInstGenAlignCast *instruction) {
+static LLVMValueRef ir_render_align_cast(CodeGen *g, Stage1Air *executable, IrInstGenAlignCast *instruction) {
LLVMValueRef target_val = ir_llvm_value(g, instruction->target);
assert(target_val);
@@ -5459,7 +5459,7 @@ static LLVMValueRef ir_render_align_cast(CodeGen *g, IrExecutableGen *executable
return target_val;
}
-static LLVMValueRef ir_render_error_return_trace(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_error_return_trace(CodeGen *g, Stage1Air *executable,
IrInstGenErrorReturnTrace *instruction)
{
bool is_llvm_alloca;
@@ -5530,7 +5530,7 @@ static LLVMTypeRef get_atomic_abi_type(CodeGen *g, IrInstGen *instruction) {
}
}
-static LLVMValueRef ir_render_cmpxchg(CodeGen *g, IrExecutableGen *executable, IrInstGenCmpxchg *instruction) {
+static LLVMValueRef ir_render_cmpxchg(CodeGen *g, Stage1Air *executable, IrInstGenCmpxchg *instruction) {
LLVMValueRef ptr_val = ir_llvm_value(g, instruction->ptr);
LLVMValueRef cmp_val = ir_llvm_value(g, instruction->cmp_value);
LLVMValueRef new_val = ir_llvm_value(g, instruction->new_value);
@@ -5592,7 +5592,7 @@ static LLVMValueRef ir_render_cmpxchg(CodeGen *g, IrExecutableGen *executable, I
return result_loc;
}
-static LLVMValueRef ir_render_reduce(CodeGen *g, IrExecutableGen *executable, IrInstGenReduce *instruction) {
+static LLVMValueRef ir_render_reduce(CodeGen *g, Stage1Air *executable, IrInstGenReduce *instruction) {
LLVMValueRef value = ir_llvm_value(g, instruction->value);
ZigType *value_type = instruction->value->value->type;
@@ -5656,13 +5656,13 @@ static LLVMValueRef ir_render_reduce(CodeGen *g, IrExecutableGen *executable, Ir
return result_val;
}
-static LLVMValueRef ir_render_fence(CodeGen *g, IrExecutableGen *executable, IrInstGenFence *instruction) {
+static LLVMValueRef ir_render_fence(CodeGen *g, Stage1Air *executable, IrInstGenFence *instruction) {
LLVMAtomicOrdering atomic_order = to_LLVMAtomicOrdering(instruction->order);
LLVMBuildFence(g->builder, atomic_order, false, "");
return nullptr;
}
-static LLVMValueRef ir_render_truncate(CodeGen *g, IrExecutableGen *executable, IrInstGenTruncate *instruction) {
+static LLVMValueRef ir_render_truncate(CodeGen *g, Stage1Air *executable, IrInstGenTruncate *instruction) {
LLVMValueRef target_val = ir_llvm_value(g, instruction->target);
ZigType *dest_type = instruction->base.value->type;
ZigType *src_type = instruction->target->value->type;
@@ -5677,7 +5677,7 @@ static LLVMValueRef ir_render_truncate(CodeGen *g, IrExecutableGen *executable,
}
}
-static LLVMValueRef ir_render_memset(CodeGen *g, IrExecutableGen *executable, IrInstGenMemset *instruction) {
+static LLVMValueRef ir_render_memset(CodeGen *g, Stage1Air *executable, IrInstGenMemset *instruction) {
LLVMValueRef dest_ptr = ir_llvm_value(g, instruction->dest_ptr);
LLVMValueRef len_val = ir_llvm_value(g, instruction->count);
@@ -5707,7 +5707,7 @@ static LLVMValueRef ir_render_memset(CodeGen *g, IrExecutableGen *executable, Ir
return nullptr;
}
-static LLVMValueRef ir_render_memcpy(CodeGen *g, IrExecutableGen *executable, IrInstGenMemcpy *instruction) {
+static LLVMValueRef ir_render_memcpy(CodeGen *g, Stage1Air *executable, IrInstGenMemcpy *instruction) {
LLVMValueRef dest_ptr = ir_llvm_value(g, instruction->dest_ptr);
LLVMValueRef src_ptr = ir_llvm_value(g, instruction->src_ptr);
LLVMValueRef len_val = ir_llvm_value(g, instruction->count);
@@ -5729,14 +5729,14 @@ static LLVMValueRef ir_render_memcpy(CodeGen *g, IrExecutableGen *executable, Ir
return nullptr;
}
-static LLVMValueRef ir_render_wasm_memory_size(CodeGen *g, IrExecutableGen *executable, IrInstGenWasmMemorySize *instruction) {
+static LLVMValueRef ir_render_wasm_memory_size(CodeGen *g, Stage1Air *executable, IrInstGenWasmMemorySize *instruction) {
// TODO adjust for wasm64
LLVMValueRef param = ir_llvm_value(g, instruction->index);
LLVMValueRef val = LLVMBuildCall(g->builder, gen_wasm_memory_size(g), ¶m, 1, "");
return val;
}
-static LLVMValueRef ir_render_wasm_memory_grow(CodeGen *g, IrExecutableGen *executable, IrInstGenWasmMemoryGrow *instruction) {
+static LLVMValueRef ir_render_wasm_memory_grow(CodeGen *g, Stage1Air *executable, IrInstGenWasmMemoryGrow *instruction) {
// TODO adjust for wasm64
LLVMValueRef params[] = {
ir_llvm_value(g, instruction->index),
@@ -5746,7 +5746,7 @@ static LLVMValueRef ir_render_wasm_memory_grow(CodeGen *g, IrExecutableGen *exec
return val;
}
-static LLVMValueRef ir_render_slice(CodeGen *g, IrExecutableGen *executable, IrInstGenSlice *instruction) {
+static LLVMValueRef ir_render_slice(CodeGen *g, Stage1Air *executable, IrInstGenSlice *instruction) {
Error err;
LLVMValueRef array_ptr_ptr = ir_llvm_value(g, instruction->ptr);
@@ -5983,12 +5983,12 @@ static LLVMValueRef get_trap_fn_val(CodeGen *g) {
}
-static LLVMValueRef ir_render_breakpoint(CodeGen *g, IrExecutableGen *executable, IrInstGenBreakpoint *instruction) {
+static LLVMValueRef ir_render_breakpoint(CodeGen *g, Stage1Air *executable, IrInstGenBreakpoint *instruction) {
LLVMBuildCall(g->builder, get_trap_fn_val(g), nullptr, 0, "");
return nullptr;
}
-static LLVMValueRef ir_render_return_address(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_return_address(CodeGen *g, Stage1Air *executable,
IrInstGenReturnAddress *instruction)
{
if (target_is_wasm(g->zig_target) && g->zig_target->os != OsEmscripten) {
@@ -6016,7 +6016,7 @@ static LLVMValueRef get_frame_address_fn_val(CodeGen *g) {
return g->frame_address_fn_val;
}
-static LLVMValueRef ir_render_frame_address(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_frame_address(CodeGen *g, Stage1Air *executable,
IrInstGenFrameAddress *instruction)
{
LLVMValueRef zero = LLVMConstNull(g->builtin_types.entry_i32->llvm_type);
@@ -6024,7 +6024,7 @@ static LLVMValueRef ir_render_frame_address(CodeGen *g, IrExecutableGen *executa
return LLVMBuildPtrToInt(g->builder, ptr_val, g->builtin_types.entry_usize->llvm_type, "");
}
-static LLVMValueRef ir_render_handle(CodeGen *g, IrExecutableGen *executable, IrInstGenFrameHandle *instruction) {
+static LLVMValueRef ir_render_handle(CodeGen *g, Stage1Air *executable, IrInstGenFrameHandle *instruction) {
return g->cur_frame_ptr;
}
@@ -6053,7 +6053,7 @@ static LLVMValueRef render_shl_with_overflow(CodeGen *g, IrInstGenOverflowOp *in
return overflow_bit;
}
-static LLVMValueRef ir_render_overflow_op(CodeGen *g, IrExecutableGen *executable, IrInstGenOverflowOp *instruction) {
+static LLVMValueRef ir_render_overflow_op(CodeGen *g, Stage1Air *executable, IrInstGenOverflowOp *instruction) {
AddSubMul add_sub_mul;
switch (instruction->op) {
case IrOverflowOpAdd:
@@ -6091,7 +6091,7 @@ static LLVMValueRef ir_render_overflow_op(CodeGen *g, IrExecutableGen *executabl
return overflow_bit;
}
-static LLVMValueRef ir_render_test_err(CodeGen *g, IrExecutableGen *executable, IrInstGenTestErr *instruction) {
+static LLVMValueRef ir_render_test_err(CodeGen *g, Stage1Air *executable, IrInstGenTestErr *instruction) {
ZigType *err_union_type = instruction->err_union->value->type;
ZigType *payload_type = err_union_type->data.error_union.payload_type;
LLVMValueRef err_union_handle = ir_llvm_value(g, instruction->err_union);
@@ -6108,7 +6108,7 @@ static LLVMValueRef ir_render_test_err(CodeGen *g, IrExecutableGen *executable,
return LLVMBuildICmp(g->builder, LLVMIntNE, err_val, zero, "");
}
-static LLVMValueRef ir_render_unwrap_err_code(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_unwrap_err_code(CodeGen *g, Stage1Air *executable,
IrInstGenUnwrapErrCode *instruction)
{
if (instruction->base.value->special != ConstValSpecialRuntime)
@@ -6128,7 +6128,7 @@ static LLVMValueRef ir_render_unwrap_err_code(CodeGen *g, IrExecutableGen *execu
}
}
-static LLVMValueRef ir_render_unwrap_err_payload(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_unwrap_err_payload(CodeGen *g, Stage1Air *executable,
IrInstGenUnwrapErrPayload *instruction)
{
Error err;
@@ -6197,7 +6197,7 @@ static LLVMValueRef ir_render_unwrap_err_payload(CodeGen *g, IrExecutableGen *ex
}
}
-static LLVMValueRef ir_render_optional_wrap(CodeGen *g, IrExecutableGen *executable, IrInstGenOptionalWrap *instruction) {
+static LLVMValueRef ir_render_optional_wrap(CodeGen *g, Stage1Air *executable, IrInstGenOptionalWrap *instruction) {
ZigType *wanted_type = instruction->base.value->type;
assert(wanted_type->id == ZigTypeIdOptional);
@@ -6233,7 +6233,7 @@ static LLVMValueRef ir_render_optional_wrap(CodeGen *g, IrExecutableGen *executa
return result_loc;
}
-static LLVMValueRef ir_render_err_wrap_code(CodeGen *g, IrExecutableGen *executable, IrInstGenErrWrapCode *instruction) {
+static LLVMValueRef ir_render_err_wrap_code(CodeGen *g, Stage1Air *executable, IrInstGenErrWrapCode *instruction) {
ZigType *wanted_type = instruction->base.value->type;
assert(wanted_type->id == ZigTypeIdErrorUnion);
@@ -6253,7 +6253,7 @@ static LLVMValueRef ir_render_err_wrap_code(CodeGen *g, IrExecutableGen *executa
return result_loc;
}
-static LLVMValueRef ir_render_err_wrap_payload(CodeGen *g, IrExecutableGen *executable, IrInstGenErrWrapPayload *instruction) {
+static LLVMValueRef ir_render_err_wrap_payload(CodeGen *g, Stage1Air *executable, IrInstGenErrWrapPayload *instruction) {
ZigType *wanted_type = instruction->base.value->type;
assert(wanted_type->id == ZigTypeIdErrorUnion);
@@ -6284,7 +6284,7 @@ static LLVMValueRef ir_render_err_wrap_payload(CodeGen *g, IrExecutableGen *exec
return result_loc;
}
-static LLVMValueRef ir_render_union_tag(CodeGen *g, IrExecutableGen *executable, IrInstGenUnionTag *instruction) {
+static LLVMValueRef ir_render_union_tag(CodeGen *g, Stage1Air *executable, IrInstGenUnionTag *instruction) {
ZigType *union_type = instruction->value->value->type;
ZigType *tag_type = union_type->data.unionation.tag_type;
@@ -6302,14 +6302,14 @@ static LLVMValueRef ir_render_union_tag(CodeGen *g, IrExecutableGen *executable,
return get_handle_value(g, tag_field_ptr, tag_type, ptr_type);
}
-static LLVMValueRef ir_render_panic(CodeGen *g, IrExecutableGen *executable, IrInstGenPanic *instruction) {
+static LLVMValueRef ir_render_panic(CodeGen *g, Stage1Air *executable, IrInstGenPanic *instruction) {
bool is_llvm_alloca;
LLVMValueRef err_ret_trace_val = get_cur_err_ret_trace_val(g, instruction->base.base.scope, &is_llvm_alloca);
gen_panic(g, ir_llvm_value(g, instruction->msg), err_ret_trace_val, is_llvm_alloca);
return nullptr;
}
-static LLVMValueRef ir_render_atomic_rmw(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_atomic_rmw(CodeGen *g, Stage1Air *executable,
IrInstGenAtomicRmw *instruction)
{
bool is_signed;
@@ -6354,7 +6354,7 @@ static LLVMValueRef ir_render_atomic_rmw(CodeGen *g, IrExecutableGen *executable
return LLVMBuildIntToPtr(g->builder, uncasted_result, get_llvm_type(g, operand_type), "");
}
-static LLVMValueRef ir_render_atomic_load(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_atomic_load(CodeGen *g, Stage1Air *executable,
IrInstGenAtomicLoad *instruction)
{
LLVMAtomicOrdering ordering = to_LLVMAtomicOrdering(instruction->ordering);
@@ -6375,7 +6375,7 @@ static LLVMValueRef ir_render_atomic_load(CodeGen *g, IrExecutableGen *executabl
return load_inst;
}
-static LLVMValueRef ir_render_atomic_store(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_atomic_store(CodeGen *g, Stage1Air *executable,
IrInstGenAtomicStore *instruction)
{
LLVMAtomicOrdering ordering = to_LLVMAtomicOrdering(instruction->ordering);
@@ -6398,13 +6398,13 @@ static LLVMValueRef ir_render_atomic_store(CodeGen *g, IrExecutableGen *executab
return nullptr;
}
-static LLVMValueRef ir_render_float_op(CodeGen *g, IrExecutableGen *executable, IrInstGenFloatOp *instruction) {
+static LLVMValueRef ir_render_float_op(CodeGen *g, Stage1Air *executable, IrInstGenFloatOp *instruction) {
LLVMValueRef operand = ir_llvm_value(g, instruction->operand);
LLVMValueRef fn_val = get_float_fn(g, instruction->base.value->type, ZigLLVMFnIdFloatOp, instruction->fn_id);
return LLVMBuildCall(g->builder, fn_val, &operand, 1, "");
}
-static LLVMValueRef ir_render_mul_add(CodeGen *g, IrExecutableGen *executable, IrInstGenMulAdd *instruction) {
+static LLVMValueRef ir_render_mul_add(CodeGen *g, Stage1Air *executable, IrInstGenMulAdd *instruction) {
LLVMValueRef op1 = ir_llvm_value(g, instruction->op1);
LLVMValueRef op2 = ir_llvm_value(g, instruction->op2);
LLVMValueRef op3 = ir_llvm_value(g, instruction->op3);
@@ -6419,7 +6419,7 @@ static LLVMValueRef ir_render_mul_add(CodeGen *g, IrExecutableGen *executable, I
return LLVMBuildCall(g->builder, fn_val, args, 3, "");
}
-static LLVMValueRef ir_render_bswap(CodeGen *g, IrExecutableGen *executable, IrInstGenBswap *instruction) {
+static LLVMValueRef ir_render_bswap(CodeGen *g, Stage1Air *executable, IrInstGenBswap *instruction) {
LLVMValueRef op = ir_llvm_value(g, instruction->op);
ZigType *expr_type = instruction->base.value->type;
bool is_vector = expr_type->id == ZigTypeIdVector;
@@ -6453,7 +6453,7 @@ static LLVMValueRef ir_render_bswap(CodeGen *g, IrExecutableGen *executable, IrI
return LLVMBuildTrunc(g->builder, shifted, get_llvm_type(g, expr_type), "");
}
-static LLVMValueRef ir_render_extern(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_extern(CodeGen *g, Stage1Air *executable,
IrInstGenExtern *instruction)
{
ZigType *expr_type = instruction->base.value->type;
@@ -6477,7 +6477,7 @@ static LLVMValueRef ir_render_extern(CodeGen *g, IrExecutableGen *executable,
return LLVMBuildBitCast(g->builder, global_value, get_llvm_type(g, expr_type), "");
}
-static LLVMValueRef ir_render_bit_reverse(CodeGen *g, IrExecutableGen *executable, IrInstGenBitReverse *instruction) {
+static LLVMValueRef ir_render_bit_reverse(CodeGen *g, Stage1Air *executable, IrInstGenBitReverse *instruction) {
LLVMValueRef op = ir_llvm_value(g, instruction->op);
ZigType *int_type = instruction->base.value->type;
assert(int_type->id == ZigTypeIdInt);
@@ -6485,7 +6485,7 @@ static LLVMValueRef ir_render_bit_reverse(CodeGen *g, IrExecutableGen *executabl
return LLVMBuildCall(g->builder, fn_val, &op, 1, "");
}
-static LLVMValueRef ir_render_vector_to_array(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_vector_to_array(CodeGen *g, Stage1Air *executable,
IrInstGenVectorToArray *instruction)
{
ZigType *array_type = instruction->base.value->type;
@@ -6519,7 +6519,7 @@ static LLVMValueRef ir_render_vector_to_array(CodeGen *g, IrExecutableGen *execu
return result_loc;
}
-static LLVMValueRef ir_render_array_to_vector(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_array_to_vector(CodeGen *g, Stage1Air *executable,
IrInstGenArrayToVector *instruction)
{
ZigType *vector_type = instruction->base.value->type;
@@ -6556,7 +6556,7 @@ static LLVMValueRef ir_render_array_to_vector(CodeGen *g, IrExecutableGen *execu
}
}
-static LLVMValueRef ir_render_assert_zero(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_assert_zero(CodeGen *g, Stage1Air *executable,
IrInstGenAssertZero *instruction)
{
LLVMValueRef target = ir_llvm_value(g, instruction->target);
@@ -6567,7 +6567,7 @@ static LLVMValueRef ir_render_assert_zero(CodeGen *g, IrExecutableGen *executabl
return nullptr;
}
-static LLVMValueRef ir_render_assert_non_null(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_assert_non_null(CodeGen *g, Stage1Air *executable,
IrInstGenAssertNonNull *instruction)
{
LLVMValueRef target = ir_llvm_value(g, instruction->target);
@@ -6592,7 +6592,7 @@ static LLVMValueRef ir_render_assert_non_null(CodeGen *g, IrExecutableGen *execu
return nullptr;
}
-static LLVMValueRef ir_render_suspend_begin(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_suspend_begin(CodeGen *g, Stage1Air *executable,
IrInstGenSuspendBegin *instruction)
{
if (fn_is_async(g->cur_fn)) {
@@ -6601,7 +6601,7 @@ static LLVMValueRef ir_render_suspend_begin(CodeGen *g, IrExecutableGen *executa
return nullptr;
}
-static LLVMValueRef ir_render_suspend_finish(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_suspend_finish(CodeGen *g, Stage1Air *executable,
IrInstGenSuspendFinish *instruction)
{
LLVMBuildRetVoid(g->builder);
@@ -6653,7 +6653,7 @@ static LLVMValueRef gen_await_early_return(CodeGen *g, IrInstGen *source_instr,
}
}
-static LLVMValueRef ir_render_await(CodeGen *g, IrExecutableGen *executable, IrInstGenAwait *instruction) {
+static LLVMValueRef ir_render_await(CodeGen *g, Stage1Air *executable, IrInstGenAwait *instruction) {
LLVMTypeRef usize_type_ref = g->builtin_types.entry_usize->llvm_type;
LLVMValueRef zero = LLVMConstNull(usize_type_ref);
LLVMValueRef target_frame_ptr = ir_llvm_value(g, instruction->frame);
@@ -6740,7 +6740,7 @@ static LLVMValueRef ir_render_await(CodeGen *g, IrExecutableGen *executable, IrI
return nullptr;
}
-static LLVMValueRef ir_render_resume(CodeGen *g, IrExecutableGen *executable, IrInstGenResume *instruction) {
+static LLVMValueRef ir_render_resume(CodeGen *g, Stage1Air *executable, IrInstGenResume *instruction) {
LLVMValueRef frame = ir_llvm_value(g, instruction->frame);
ZigType *frame_type = instruction->frame->value->type;
assert(frame_type->id == ZigTypeIdAnyFrame);
@@ -6749,14 +6749,14 @@ static LLVMValueRef ir_render_resume(CodeGen *g, IrExecutableGen *executable, Ir
return nullptr;
}
-static LLVMValueRef ir_render_frame_size(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_frame_size(CodeGen *g, Stage1Air *executable,
IrInstGenFrameSize *instruction)
{
LLVMValueRef fn_val = ir_llvm_value(g, instruction->fn);
return gen_frame_size(g, fn_val);
}
-static LLVMValueRef ir_render_spill_begin(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_spill_begin(CodeGen *g, Stage1Air *executable,
IrInstGenSpillBegin *instruction)
{
if (!fn_is_async(g->cur_fn))
@@ -6776,7 +6776,7 @@ static LLVMValueRef ir_render_spill_begin(CodeGen *g, IrExecutableGen *executabl
zig_unreachable();
}
-static LLVMValueRef ir_render_spill_end(CodeGen *g, IrExecutableGen *executable, IrInstGenSpillEnd *instruction) {
+static LLVMValueRef ir_render_spill_end(CodeGen *g, Stage1Air *executable, IrInstGenSpillEnd *instruction) {
if (!fn_is_async(g->cur_fn))
return ir_llvm_value(g, instruction->begin->operand);
@@ -6792,7 +6792,7 @@ static LLVMValueRef ir_render_spill_end(CodeGen *g, IrExecutableGen *executable,
zig_unreachable();
}
-static LLVMValueRef ir_render_vector_extract_elem(CodeGen *g, IrExecutableGen *executable,
+static LLVMValueRef ir_render_vector_extract_elem(CodeGen *g, Stage1Air *executable,
IrInstGenVectorExtractElem *instruction)
{
LLVMValueRef vector = ir_llvm_value(g, instruction->vector);
@@ -6811,7 +6811,7 @@ static void set_debug_location(CodeGen *g, IrInstGen *instruction) {
node_column_onebased(source_node), get_di_scope(g, scope));
}
-static LLVMValueRef ir_render_instruction(CodeGen *g, IrExecutableGen *executable, IrInstGen *instruction) {
+static LLVMValueRef ir_render_instruction(CodeGen *g, Stage1Air *executable, IrInstGen *instruction) {
switch (instruction->id) {
case IrInstGenIdInvalid:
case IrInstGenIdConst:
@@ -6999,7 +6999,7 @@ static LLVMValueRef ir_render_instruction(CodeGen *g, IrExecutableGen *executabl
static void ir_render(CodeGen *g, ZigFn *fn_entry) {
assert(fn_entry);
- IrExecutableGen *executable = &fn_entry->analyzed_executable;
+ Stage1Air *executable = &fn_entry->analyzed_executable;
assert(executable->basic_block_list.length > 0);
for (size_t block_i = 0; block_i < executable->basic_block_list.length; block_i += 1) {
@@ -7997,7 +7997,7 @@ static void generate_error_name_table(CodeGen *g) {
}
static void build_all_basic_blocks(CodeGen *g, ZigFn *fn) {
- IrExecutableGen *executable = &fn->analyzed_executable;
+ Stage1Air *executable = &fn->analyzed_executable;
assert(executable->basic_block_list.length > 0);
LLVMValueRef fn_val = fn_llvm_value(g, fn);
LLVMBasicBlockRef first_bb = nullptr;
@@ -8380,7 +8380,7 @@ static void do_code_gen(CodeGen *g) {
node_line_onebased(source_node), node_column_onebased(source_node),
get_di_scope(g, fn_table_entry->child_scope));
}
- IrExecutableGen *executable = &fn_table_entry->analyzed_executable;
+ Stage1Air *executable = &fn_table_entry->analyzed_executable;
LLVMBasicBlockRef bad_resume_block = LLVMAppendBasicBlock(g->cur_fn_val, "BadResume");
LLVMPositionBuilderAtEnd(g->builder, bad_resume_block);
gen_assertion_scope(g, PanicMsgIdBadResume, fn_table_entry->child_scope);
src/stage1/ir.cpp
@@ -24,7 +24,7 @@
struct IrBuilderGen {
CodeGen *codegen;
- IrExecutableGen *exec;
+ Stage1Air *exec;
IrBasicBlockGen *current_basic_block;
// track for immediate post-analysis destruction
@@ -46,6 +46,9 @@ struct IrAnalyze {
size_t ref_count;
size_t break_debug_id; // for debugging purposes
IrInstGen *return_ptr;
+ Stage1Air *parent_exec;
+ size_t *backward_branch_count;
+ size_t *backward_branch_quota;
// For the purpose of using in a debugger
void dump();
@@ -672,7 +675,7 @@ static void ir_inst_gen_append(IrBasicBlockGen *basic_block, IrInstGen *instruct
basic_block->instruction_list.append(instruction);
}
-static size_t exec_next_debug_id_gen(IrExecutableGen *exec) {
+static size_t exec_next_debug_id_gen(Stage1Air *exec) {
size_t result = exec->next_debug_id;
exec->next_debug_id += 1;
return result;
@@ -716,7 +719,7 @@ ZigType *ir_analyze_type_expr(IrAnalyze *ira, Scope *scope, AstNode *node) {
create_result_ptr(ira->codegen, ira->codegen->builtin_types.entry_type, &result, &result_ptr);
if ((err = ir_eval_const_value(ira->codegen, scope, node, result_ptr,
- ira->new_irb.exec->backward_branch_count, ira->new_irb.exec->backward_branch_quota,
+ ira->backward_branch_count, ira->backward_branch_quota,
nullptr, nullptr, node, nullptr, ira->new_irb.exec, nullptr, UndefBad)))
{
return ira->codegen->builtin_types.entry_invalid;
@@ -2512,7 +2515,7 @@ static ZigType *make_err_set_with_one_item(CodeGen *g, Scope *parent_scope, AstN
return err_set_type;
}
-static void invalidate_exec_gen(IrExecutableGen *exec, ErrorMsg *msg) {
+static void invalidate_exec_gen(Stage1Air *exec, ErrorMsg *msg) {
if (exec->first_err_trace_msg != nullptr)
return;
@@ -2527,7 +2530,7 @@ static void invalidate_exec_gen(IrExecutableGen *exec, ErrorMsg *msg) {
}
-static ErrorMsg *exec_add_error_node_gen(CodeGen *codegen, IrExecutableGen *exec, AstNode *source_node, Buf *msg) {
+static ErrorMsg *exec_add_error_node_gen(CodeGen *codegen, Stage1Air *exec, AstNode *source_node, Buf *msg) {
ErrorMsg *err_msg = add_node_error(codegen, source_node, msg);
invalidate_exec_gen(exec, err_msg);
if (exec->parent_exec) {
@@ -2601,7 +2604,7 @@ ZigValue *const_ptr_pointee(IrAnalyze *ira, CodeGen *codegen, ZigValue *const_va
return val;
}
-static Error ir_exec_scan_for_side_effects(CodeGen *codegen, IrExecutableGen *exec) {
+static Error ir_exec_scan_for_side_effects(CodeGen *codegen, Stage1Air *exec) {
IrBasicBlockGen *bb = exec->basic_block_list.at(0);
for (size_t i = 0; i < bb->instruction_list.length; i += 1) {
IrInstGen *instruction = bb->instruction_list.at(i);
@@ -5425,8 +5428,8 @@ static IrInstGen *ir_unreach_error(IrAnalyze *ira) {
}
static bool ir_emit_backward_branch(IrAnalyze *ira, IrInst* source_instruction) {
- size_t *bbc = ira->new_irb.exec->backward_branch_count;
- size_t *quota = ira->new_irb.exec->backward_branch_quota;
+ size_t *bbc = ira->backward_branch_count;
+ size_t *quota = ira->backward_branch_quota;
// If we're already over quota, we've already given an error message for this.
if (*bbc > *quota) {
@@ -5532,7 +5535,7 @@ static IrInstGen *ir_get_const_ptr(IrAnalyze *ira, IrInst *instruction,
return const_instr;
}
-static Error ir_resolve_const_val(CodeGen *codegen, IrExecutableGen *exec, AstNode *source_node,
+static Error ir_resolve_const_val(CodeGen *codegen, Stage1Air *exec, AstNode *source_node,
ZigValue *val, UndefAllowed undef_allowed)
{
Error err;
@@ -5579,7 +5582,7 @@ static ZigValue *ir_resolve_const(IrAnalyze *ira, IrInstGen *value, UndefAllowed
Error ir_eval_const_value(CodeGen *codegen, Scope *scope, AstNode *node,
ZigValue *return_ptr, size_t *backward_branch_count, size_t *backward_branch_quota,
ZigFn *fn_entry, Buf *c_import_buf, AstNode *source_node, Buf *exec_name,
- IrExecutableGen *parent_exec, AstNode *expected_type_source_node, UndefAllowed undef_allowed)
+ Stage1Air *parent_exec, AstNode *expected_type_source_node, UndefAllowed undef_allowed)
{
Error err;
@@ -5590,7 +5593,6 @@ Error ir_eval_const_value(CodeGen *codegen, Scope *scope, AstNode *node,
Stage1Zir *ir_executable = heap::c_allocator.create<Stage1Zir>();
ir_executable->source_node = source_node;
- ir_executable->parent_exec = parent_exec;
ir_executable->name = exec_name;
ir_executable->is_inline = true;
ir_executable->fn_entry = fn_entry;
@@ -5610,7 +5612,7 @@ Error ir_eval_const_value(CodeGen *codegen, Scope *scope, AstNode *node,
ir_print_src(codegen, stderr, ir_executable, 2);
fprintf(stderr, "}\n");
}
- IrExecutableGen *analyzed_executable = heap::c_allocator.create<IrExecutableGen>();
+ Stage1Air *analyzed_executable = heap::c_allocator.create<Stage1Air>();
analyzed_executable->source_node = source_node;
analyzed_executable->parent_exec = parent_exec;
analyzed_executable->source_exec = ir_executable;
@@ -5618,10 +5620,9 @@ Error ir_eval_const_value(CodeGen *codegen, Scope *scope, AstNode *node,
analyzed_executable->is_inline = true;
analyzed_executable->fn_entry = fn_entry;
analyzed_executable->c_import_buf = c_import_buf;
- analyzed_executable->backward_branch_count = backward_branch_count;
- analyzed_executable->backward_branch_quota = backward_branch_quota;
analyzed_executable->begin_scope = scope;
ZigType *result_type = ir_analyze(codegen, ir_executable, analyzed_executable,
+ backward_branch_count, backward_branch_quota,
return_ptr->type->data.pointer.child_type, expected_type_source_node, return_ptr);
if (type_is_invalid(result_type)) {
return ErrorSemanticAnalyzeFail;
@@ -5663,7 +5664,7 @@ static ErrorTableEntry *ir_resolve_error(IrAnalyze *ira, IrInstGen *err_value) {
return const_val->data.x_err_set;
}
-static ZigType *ir_resolve_const_type(CodeGen *codegen, IrExecutableGen *exec, AstNode *source_node,
+static ZigType *ir_resolve_const_type(CodeGen *codegen, Stage1Air *exec, AstNode *source_node,
ZigValue *val)
{
Error err;
@@ -8071,7 +8072,7 @@ static IrInstGen *ir_get_deref(IrAnalyze *ira, IrInst* source_instruction, IrIns
return ir_build_load_ptr_gen(ira, source_instruction, ptr, child_type, result_loc_inst);
}
-static bool ir_resolve_const_align(CodeGen *codegen, IrExecutableGen *exec, AstNode *source_node,
+static bool ir_resolve_const_align(CodeGen *codegen, Stage1Air *exec, AstNode *source_node,
ZigValue *const_val, uint32_t *out)
{
Error err;
@@ -12752,7 +12753,7 @@ static IrInstGen *ir_analyze_fn_call(IrAnalyze *ira, IrInst* source_instr,
create_result_ptr(ira->codegen, return_type, &result, &result_ptr);
if ((err = ir_eval_const_value(ira->codegen, exec_scope, body_node, result_ptr,
- ira->new_irb.exec->backward_branch_count, ira->new_irb.exec->backward_branch_quota,
+ ira->backward_branch_count, ira->backward_branch_quota,
fn_entry, nullptr, source_instr->source_node, nullptr, ira->new_irb.exec, return_type_node,
UndefOk)))
{
@@ -12869,7 +12870,7 @@ static IrInstGen *ir_analyze_fn_call(IrAnalyze *ira, IrInst* source_instr,
create_result_ptr(ira->codegen, get_align_amt_type(ira->codegen), &align_result, &result_ptr);
if ((err = ir_eval_const_value(ira->codegen, impl_fn->child_scope,
fn_proto_node->data.fn_proto.align_expr, result_ptr,
- ira->new_irb.exec->backward_branch_count, ira->new_irb.exec->backward_branch_quota,
+ ira->backward_branch_count, ira->backward_branch_quota,
nullptr, nullptr, fn_proto_node->data.fn_proto.align_expr, nullptr, ira->new_irb.exec,
nullptr, UndefBad)))
{
@@ -12934,11 +12935,9 @@ static IrInstGen *ir_analyze_fn_call(IrAnalyze *ira, IrInst* source_instr,
return ira->codegen->invalid_inst_gen;
impl_fn->ir_executable->source_node = source_instr->source_node;
- impl_fn->ir_executable->parent_exec = ira->new_irb.exec;
impl_fn->analyzed_executable.source_node = source_instr->source_node;
impl_fn->analyzed_executable.parent_exec = ira->new_irb.exec;
- impl_fn->analyzed_executable.backward_branch_quota = ira->new_irb.exec->backward_branch_quota;
- impl_fn->analyzed_executable.is_generic_instantiation = true;
+ impl_fn->branch_quota = *ira->backward_branch_quota;
ira->codegen->fn_defs.append(impl_fn);
}
@@ -18980,8 +18979,8 @@ static IrInstGen *ir_analyze_instruction_set_eval_branch_quota(IrAnalyze *ira,
if (!ir_resolve_unsigned(ira, instruction->new_quota->child, ira->codegen->builtin_types.entry_u32, &new_quota))
return ira->codegen->invalid_inst_gen;
- if (new_quota > *ira->new_irb.exec->backward_branch_quota) {
- *ira->new_irb.exec->backward_branch_quota = new_quota;
+ if (new_quota > *ira->backward_branch_quota) {
+ *ira->backward_branch_quota = new_quota;
}
return ir_const_void(ira, &instruction->base.base);
@@ -19015,7 +19014,7 @@ static IrInstGen *ir_analyze_instruction_c_import(IrAnalyze *ira, IrInstSrcCImpo
ZigValue *result_ptr;
create_result_ptr(ira->codegen, void_type, &cimport_result, &result_ptr);
if ((err = ir_eval_const_value(ira->codegen, &cimport_scope->base, block_node, result_ptr,
- ira->new_irb.exec->backward_branch_count, ira->new_irb.exec->backward_branch_quota, nullptr,
+ ira->backward_branch_count, ira->backward_branch_quota, nullptr,
&cimport_scope->buf, block_node, nullptr, nullptr, nullptr, UndefBad)))
{
return ira->codegen->invalid_inst_gen;
@@ -24467,25 +24466,27 @@ static IrInstGen *ir_analyze_instruction_base(IrAnalyze *ira, IrInstSrc *instruc
}
// This function attempts to evaluate IR code while doing type checking and other analysis.
-// It emits to a new IrExecutableGen which is partially evaluated IR code.
-ZigType *ir_analyze(CodeGen *codegen, Stage1Zir *old_exec, IrExecutableGen *new_exec,
+// It emits to a new Stage1Air which is partially evaluated IR code.
+ZigType *ir_analyze(CodeGen *codegen, Stage1Zir *stage1_zir, Stage1Air *stage1_air,
+ size_t *backward_branch_count, size_t *backward_branch_quota,
ZigType *expected_type, AstNode *expected_type_source_node, ZigValue *result_ptr)
{
- assert(old_exec->first_err_trace_msg == nullptr);
+ assert(stage1_zir->first_err_trace_msg == nullptr);
assert(expected_type == nullptr || !type_is_invalid(expected_type));
IrAnalyze *ira = heap::c_allocator.create<IrAnalyze>();
+ ira->backward_branch_count = backward_branch_count;
+ ira->backward_branch_quota = backward_branch_quota;
ira->ref_count = 1;
- old_exec->analysis = ira;
ira->codegen = codegen;
ira->explicit_return_type = expected_type;
ira->explicit_return_type_source_node = expected_type_source_node;
- ira->zir = old_exec;
+ ira->zir = stage1_zir;
ira->new_irb.codegen = codegen;
- ira->new_irb.exec = new_exec;
+ ira->new_irb.exec = stage1_air;
IrBasicBlockSrc *old_entry_bb = ira->zir->basic_block_list.at(0);
IrBasicBlockGen *new_entry_bb = ir_get_new_bb(ira, old_entry_bb, nullptr);
@@ -24497,13 +24498,13 @@ ZigType *ir_analyze(CodeGen *codegen, Stage1Zir *old_exec, IrExecutableGen *new_
if (result_ptr != nullptr) {
assert(result_ptr->type->id == ZigTypeIdPointer);
IrInstGenConst *const_inst = ir_create_inst_noval<IrInstGenConst>(
- &ira->new_irb, new_exec->begin_scope, new_exec->source_node);
+ &ira->new_irb, stage1_air->begin_scope, stage1_air->source_node);
const_inst->base.value = result_ptr;
ira->return_ptr = &const_inst->base;
} else {
- assert(new_exec->begin_scope != nullptr);
- assert(new_exec->source_node != nullptr);
- ira->return_ptr = ir_build_return_ptr(ira, new_exec->begin_scope, new_exec->source_node,
+ assert(stage1_air->begin_scope != nullptr);
+ assert(stage1_air->source_node != nullptr);
+ ira->return_ptr = ir_build_return_ptr(ira, stage1_air->begin_scope, stage1_air->source_node,
get_pointer_to_type(codegen, expected_type, false));
}
@@ -24531,16 +24532,16 @@ ZigType *ir_analyze(CodeGen *codegen, Stage1Zir *old_exec, IrExecutableGen *new_
fprintf(stderr, "-> (invalid)");
}
- if (new_exec->first_err_trace_msg != nullptr) {
- ira->codegen->trace_err = new_exec->first_err_trace_msg;
+ if (stage1_air->first_err_trace_msg != nullptr) {
+ ira->codegen->trace_err = stage1_air->first_err_trace_msg;
} else {
- new_exec->first_err_trace_msg = ira->codegen->trace_err;
+ stage1_air->first_err_trace_msg = ira->codegen->trace_err;
}
- if (new_exec->first_err_trace_msg != nullptr &&
+ if (stage1_air->first_err_trace_msg != nullptr &&
!old_instruction->base.source_node->already_traced_this_node)
{
old_instruction->base.source_node->already_traced_this_node = true;
- new_exec->first_err_trace_msg = add_error_note(ira->codegen, new_exec->first_err_trace_msg,
+ stage1_air->first_err_trace_msg = add_error_note(ira->codegen, stage1_air->first_err_trace_msg,
old_instruction->base.source_node, buf_create_from_str("referenced here"));
}
return ira->codegen->builtin_types.entry_invalid;
@@ -24566,14 +24567,14 @@ ZigType *ir_analyze(CodeGen *codegen, Stage1Zir *old_exec, IrExecutableGen *new_
}
ZigType *res_type;
- if (new_exec->first_err_trace_msg != nullptr) {
- codegen->trace_err = new_exec->first_err_trace_msg;
- if (codegen->trace_err != nullptr && new_exec->source_node != nullptr &&
- !new_exec->source_node->already_traced_this_node)
+ if (stage1_air->first_err_trace_msg != nullptr) {
+ codegen->trace_err = stage1_air->first_err_trace_msg;
+ if (codegen->trace_err != nullptr && stage1_air->source_node != nullptr &&
+ !stage1_air->source_node->already_traced_this_node)
{
- new_exec->source_node->already_traced_this_node = true;
+ stage1_air->source_node->already_traced_this_node = true;
codegen->trace_err = add_error_note(codegen, codegen->trace_err,
- new_exec->source_node, buf_create_from_str("referenced here"));
+ stage1_air->source_node, buf_create_from_str("referenced here"));
}
res_type = ira->codegen->builtin_types.entry_invalid;
} else if (ira->src_implicit_return_type_list.length == 0) {
src/stage1/ir.hpp
@@ -16,12 +16,13 @@ IrInstGen *ir_create_alloca(CodeGen *g, Scope *scope, AstNode *source_node, ZigF
Error ir_eval_const_value(CodeGen *codegen, Scope *scope, AstNode *node,
ZigValue *return_ptr, size_t *backward_branch_count, size_t *backward_branch_quota,
ZigFn *fn_entry, Buf *c_import_buf, AstNode *source_node, Buf *exec_name,
- IrExecutableGen *parent_exec, AstNode *expected_type_source_node, UndefAllowed undef);
+ Stage1Air *parent_exec, AstNode *expected_type_source_node, UndefAllowed undef);
Error ir_resolve_lazy(CodeGen *codegen, AstNode *source_node, ZigValue *val);
-ZigType *ir_analyze(CodeGen *g, Stage1Zir *old_executable, IrExecutableGen *new_executable,
- ZigType *expected_type, AstNode *expected_type_source_node, ZigValue *return_ptr);
+ZigType *ir_analyze(CodeGen *codegen, Stage1Zir *stage1_zir, Stage1Air *stage1_air,
+ size_t *backward_branch_count, size_t *backward_branch_quota,
+ ZigType *expected_type, AstNode *expected_type_source_node, ZigValue *result_ptr);
bool ir_inst_gen_has_side_effects(IrInstGen *inst);
bool ir_inst_src_has_side_effects(IrInstSrc *inst);
src/stage1/ir_print.cpp
@@ -3408,7 +3408,7 @@ void ir_print_src(CodeGen *codegen, FILE *f, Stage1Zir *executable, int indent_s
}
}
-void ir_print_gen(CodeGen *codegen, FILE *f, IrExecutableGen *executable, int indent_size) {
+void ir_print_gen(CodeGen *codegen, FILE *f, Stage1Air *executable, int indent_size) {
IrPrintGen ir_print = {};
IrPrintGen *irp = &ir_print;
irp->codegen = codegen;
src/stage1/ir_print.hpp
@@ -13,7 +13,7 @@
#include <stdio.h>
void ir_print_src(CodeGen *codegen, FILE *f, Stage1Zir *executable, int indent_size);
-void ir_print_gen(CodeGen *codegen, FILE *f, IrExecutableGen *executable, int indent_size);
+void ir_print_gen(CodeGen *codegen, FILE *f, Stage1Air *executable, int indent_size);
void ir_print_inst_src(CodeGen *codegen, FILE *f, IrInstSrc *inst, int indent_size);
void ir_print_inst_gen(CodeGen *codegen, FILE *f, IrInstGen *inst, int indent_size);
void ir_print_basic_block_src(CodeGen *codegen, FILE *f, IrBasicBlockSrc *bb, int indent_size);