stage1: rename IrExecutableSrc to Stage1Zir

and make IrBuilderSrc private to astgen.cpp

src/stage1/all_types.hpp

@@ -110,7 +110,7 @@ enum X64CABIClass {
     X64CABIClass_SSE,
 };
 
-struct IrExecutableSrc {
+struct Stage1Zir {
     ZigList<IrBasicBlockSrc *> basic_block_list;
     Buf *name;
     ZigFn *name_fn;
@@ -148,7 +148,7 @@ struct IrExecutableGen {
     Buf *c_import_buf;
     AstNode *source_node;
     IrExecutableGen *parent_exec;
-    IrExecutableSrc *source_exec;
+    Stage1Zir *source_exec;
     Scope *begin_scope;
     ErrorMsg *first_err_trace_msg;
     ZigList<Tld *> tld_list;
@@ -1651,7 +1651,7 @@ struct ZigFn {
     // in the case of async functions this is the implicit return type according to the
     // zig source code, not according to zig ir
     ZigType *src_implicit_return_type;
-    IrExecutableSrc *ir_executable;
+    Stage1Zir *ir_executable;
     IrExecutableGen analyzed_executable;
     size_t prealloc_bbc;
     size_t prealloc_backward_branch_quota;

src/stage1/analyze.cpp

@@ -3653,7 +3653,7 @@ static void get_fully_qualified_decl_name(CodeGen *g, Buf *buf, Tld *tld, bool i
 
 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<IrExecutableSrc>();
+    fn_entry->ir_executable = heap::c_allocator.create<Stage1Zir>();
 
     fn_entry->prealloc_backward_branch_quota = default_backward_branch_quota;
 
@@ -9862,7 +9862,7 @@ void AstNode::src() {
             line, column);
 }
 
-void IrExecutableSrc::src() {
+void Stage1Zir::src() {
     if (this->source_node != nullptr) {
         this->source_node->src();
     }

src/stage1/astgen.cpp

@@ -11,6 +11,13 @@
 #include "os.hpp"
 #include "parser.hpp"
 
+struct IrBuilderSrc {
+    CodeGen *codegen;
+    Stage1Zir *exec;
+    IrBasicBlockSrc *current_basic_block;
+    AstNode *main_block_node;
+};
+
 static IrInstSrc *ir_gen_node(IrBuilderSrc *irb, AstNode *node, Scope *scope);
 static IrInstSrc *ir_gen_node_extra(IrBuilderSrc *irb, AstNode *node, Scope *scope, LVal lval,
         ResultLoc *result_loc);
@@ -34,14 +41,14 @@ 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, IrExecutableSrc *exec, ErrorMsg *err_msg, int limit) {
+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, IrExecutableSrc *exec, AstNode *source_node, Buf *msg) {
+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) {
@@ -342,7 +349,7 @@ void destroy_instruction_src(IrInstSrc *inst) {
 }
 
 
-bool ir_should_inline(IrExecutableSrc *exec, Scope *scope) {
+bool ir_should_inline(Stage1Zir *exec, Scope *scope) {
     if (exec->is_inline)
         return true;
 
@@ -364,17 +371,17 @@ static void ir_instruction_append(IrBasicBlockSrc *basic_block, IrInstSrc *instr
     basic_block->instruction_list.append(instruction);
 }
 
-static size_t exec_next_debug_id(IrExecutableSrc *exec) {
+static size_t exec_next_debug_id(Stage1Zir *exec) {
     size_t result = exec->next_debug_id;
     exec->next_debug_id += 1;
     return result;
 }
 
-static ZigFn *exec_fn_entry(IrExecutableSrc *exec) {
+static ZigFn *exec_fn_entry(Stage1Zir *exec) {
     return exec->fn_entry;
 }
 
-static Buf *exec_c_import_buf(IrExecutableSrc *exec) {
+static Buf *exec_c_import_buf(Stage1Zir *exec) {
     return exec->c_import_buf;
 }
 
@@ -5891,7 +5898,7 @@ static IrInstSrc *ir_gen_var_decl(IrBuilderSrc *irb, Scope *scope, AstNode *node
     Scope *init_scope = is_comptime_scalar ?
         create_comptime_scope(irb->codegen, variable_declaration->expr, scope) : scope;
 
-    // Temporarily set the name of the IrExecutableSrc to the VariableDeclaration
+    // Temporarily set the name of the Stage1Zir to the VariableDeclaration
     // so that the struct or enum from the init expression inherits the name.
     Buf *old_exec_name = irb->exec->name;
     irb->exec->name = variable_declaration->symbol;
@@ -7511,7 +7518,7 @@ static bool render_instance_name_recursive(CodeGen *codegen, Buf *name, Scope *o
     return true;
 }
 
-Buf *get_anon_type_name(CodeGen *codegen, IrExecutableSrc *exec, const char *kind_name,
+Buf *get_anon_type_name(CodeGen *codegen, Stage1Zir *exec, const char *kind_name,
         Scope *scope, AstNode *source_node, Buf *out_bare_name)
 {
     if (exec != nullptr && exec->name) {
@@ -8040,7 +8047,7 @@ static IrInstSrc *ir_gen_node(IrBuilderSrc *irb, AstNode *node, Scope *scope) {
     return ir_gen_node_extra(irb, node, scope, LValNone, nullptr);
 }
 
-bool ir_gen(CodeGen *codegen, AstNode *node, Scope *scope, IrExecutableSrc *ir_executable) {
+bool ir_gen(CodeGen *codegen, AstNode *node, Scope *scope, Stage1Zir *ir_executable) {
     assert(node->owner);
 
     IrBuilderSrc ir_builder = {0};
@@ -8081,7 +8088,7 @@ bool ir_gen(CodeGen *codegen, AstNode *node, Scope *scope, IrExecutableSrc *ir_e
 bool ir_gen_fn(CodeGen *codegen, ZigFn *fn_entry) {
     assert(fn_entry);
 
-    IrExecutableSrc *ir_executable = fn_entry->ir_executable;
+    Stage1Zir *ir_executable = fn_entry->ir_executable;
     AstNode *body_node = fn_entry->body_node;
 
     assert(fn_entry->child_scope);
@@ -8089,7 +8096,7 @@ bool ir_gen_fn(CodeGen *codegen, ZigFn *fn_entry) {
     return ir_gen(codegen, body_node, fn_entry->child_scope, ir_executable);
 }
 
-void invalidate_exec(IrExecutableSrc *exec, ErrorMsg *msg) {
+void invalidate_exec(Stage1Zir *exec, ErrorMsg *msg) {
     if (exec->first_err_trace_msg != nullptr)
         return;
 

src/stage1/astgen.hpp

@@ -10,7 +10,7 @@
 
 #include "all_types.hpp"
 
-bool ir_gen(CodeGen *g, AstNode *node, Scope *scope, IrExecutableSrc *ir_executable);
+bool ir_gen(CodeGen *g, AstNode *node, Scope *scope, Stage1Zir *ir_executable);
 bool ir_gen_fn(CodeGen *g, ZigFn *fn_entry);
 
 bool ir_inst_src_has_side_effects(IrInstSrc *inst);
@@ -21,7 +21,7 @@ ZigVar *create_local_var(CodeGen *codegen, AstNode *node, Scope *parent_scope,
 
 ResultLoc *no_result_loc(void);
 
-void invalidate_exec(IrExecutableSrc *exec, ErrorMsg *msg);
+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,
@@ -29,15 +29,8 @@ void ir_add_call_stack_errors_gen(CodeGen *codegen, IrExecutableGen *exec, Error
 
 void destroy_instruction_src(IrInstSrc *inst);
 
-struct IrBuilderSrc {
-    CodeGen *codegen;
-    IrExecutableSrc *exec;
-    IrBasicBlockSrc *current_basic_block;
-    AstNode *main_block_node;
-};
-
-bool ir_should_inline(IrExecutableSrc *exec, Scope *scope);
-Buf *get_anon_type_name(CodeGen *codegen, IrExecutableSrc *exec, const char *kind_name,
+bool ir_should_inline(Stage1Zir *exec, Scope *scope);
+Buf *get_anon_type_name(CodeGen *codegen, Stage1Zir *exec, const char *kind_name,
         Scope *scope, AstNode *source_node, Buf *out_bare_name);
 
 #endif

src/stage1/ir.cpp

@@ -33,7 +33,8 @@ struct IrBuilderGen {
 
 struct IrAnalyze {
     CodeGen *codegen;
-    IrBuilderSrc old_irb;
+    Stage1Zir *zir;
+    IrBasicBlockSrc *zir_current_basic_block;
     IrBuilderGen new_irb;
     size_t old_bb_index;
     size_t instruction_index;
@@ -476,17 +477,17 @@ static void ira_deref(IrAnalyze *ira) {
     }
     assert(ira->ref_count != 0);
 
-    for (size_t bb_i = 0; bb_i < ira->old_irb.exec->basic_block_list.length; bb_i += 1) {
-        IrBasicBlockSrc *pass1_bb = ira->old_irb.exec->basic_block_list.items[bb_i];
+    for (size_t bb_i = 0; bb_i < ira->zir->basic_block_list.length; bb_i += 1) {
+        IrBasicBlockSrc *pass1_bb = ira->zir->basic_block_list.items[bb_i];
         for (size_t inst_i = 0; inst_i < pass1_bb->instruction_list.length; inst_i += 1) {
             IrInstSrc *pass1_inst = pass1_bb->instruction_list.items[inst_i];
             destroy_instruction_src(pass1_inst);
         }
         heap::c_allocator.destroy(pass1_bb);
     }
-    ira->old_irb.exec->basic_block_list.deinit();
-    ira->old_irb.exec->tld_list.deinit();
-    heap::c_allocator.destroy(ira->old_irb.exec);
+    ira->zir->basic_block_list.deinit();
+    ira->zir->tld_list.deinit();
+    heap::c_allocator.destroy(ira->zir);
     ira->src_implicit_return_type_list.deinit();
     ira->resume_stack.deinit();
 
@@ -2630,7 +2631,7 @@ static Error ir_exec_scan_for_side_effects(CodeGen *codegen, IrExecutableGen *ex
 }
 
 static bool ir_emit_global_runtime_side_effect(IrAnalyze *ira, IrInst* source_instruction) {
-    if (ir_should_inline(ira->old_irb.exec, source_instruction->scope)) {
+    if (ir_should_inline(ira->zir, source_instruction->scope)) {
         ir_add_error(ira, source_instruction, buf_sprintf("unable to evaluate constant expression"));
         return false;
     }
@@ -5287,7 +5288,7 @@ static IrBasicBlockGen *ir_get_new_bb_runtime(IrAnalyze *ira, IrBasicBlockSrc *o
 static void ir_start_bb(IrAnalyze *ira, IrBasicBlockSrc *old_bb, IrBasicBlockSrc *const_predecessor_bb) {
     ir_assert(!old_bb->suspended, (old_bb->instruction_list.length != 0) ? &old_bb->instruction_list.at(0)->base : nullptr);
     ira->instruction_index = 0;
-    ira->old_irb.current_basic_block = old_bb;
+    ira->zir_current_basic_block = old_bb;
     ira->const_predecessor_bb = const_predecessor_bb;
     ira->old_bb_index = old_bb->index;
 }
@@ -5297,23 +5298,23 @@ static IrInstGen *ira_suspend(IrAnalyze *ira, IrInst *old_instruction, IrBasicBl
 {
     if (ira->codegen->verbose_ir) {
         fprintf(stderr, "suspend %s_%" PRIu32 " %s_%" PRIu32 " #%" PRIu32 " (%zu,%zu)\n",
-                ira->old_irb.current_basic_block->name_hint,
-                ira->old_irb.current_basic_block->debug_id,
-                ira->old_irb.exec->basic_block_list.at(ira->old_bb_index)->name_hint,
-                ira->old_irb.exec->basic_block_list.at(ira->old_bb_index)->debug_id,
-                ira->old_irb.current_basic_block->instruction_list.at(ira->instruction_index)->base.debug_id,
+                ira->zir_current_basic_block->name_hint,
+                ira->zir_current_basic_block->debug_id,
+                ira->zir->basic_block_list.at(ira->old_bb_index)->name_hint,
+                ira->zir->basic_block_list.at(ira->old_bb_index)->debug_id,
+                ira->zir_current_basic_block->instruction_list.at(ira->instruction_index)->base.debug_id,
                 ira->old_bb_index, ira->instruction_index);
     }
     suspend_pos->basic_block_index = ira->old_bb_index;
     suspend_pos->instruction_index = ira->instruction_index;
 
-    ira->old_irb.current_basic_block->suspended = true;
+    ira->zir_current_basic_block->suspended = true;
 
     // null next_bb means that the caller plans to call ira_resume before returning
     if (next_bb != nullptr) {
         ira->old_bb_index = next_bb->index;
-        ira->old_irb.current_basic_block = ira->old_irb.exec->basic_block_list.at(ira->old_bb_index);
-        assert(ira->old_irb.current_basic_block == next_bb);
+        ira->zir_current_basic_block = ira->zir->basic_block_list.at(ira->old_bb_index);
+        assert(ira->zir_current_basic_block == next_bb);
         ira->instruction_index = 0;
         ira->const_predecessor_bb = nullptr;
         next_bb->child = ir_get_new_bb_runtime(ira, next_bb, old_instruction);
@@ -5328,19 +5329,19 @@ static IrInstGen *ira_resume(IrAnalyze *ira) {
         fprintf(stderr, "resume (%zu,%zu) ", pos.basic_block_index, pos.instruction_index);
     }
     ira->old_bb_index = pos.basic_block_index;
-    ira->old_irb.current_basic_block = ira->old_irb.exec->basic_block_list.at(ira->old_bb_index);
-    assert(ira->old_irb.current_basic_block->in_resume_stack);
-    ira->old_irb.current_basic_block->in_resume_stack = false;
-    ira->old_irb.current_basic_block->suspended = false;
+    ira->zir_current_basic_block = ira->zir->basic_block_list.at(ira->old_bb_index);
+    assert(ira->zir_current_basic_block->in_resume_stack);
+    ira->zir_current_basic_block->in_resume_stack = false;
+    ira->zir_current_basic_block->suspended = false;
     ira->instruction_index = pos.instruction_index;
-    assert(pos.instruction_index < ira->old_irb.current_basic_block->instruction_list.length);
+    assert(pos.instruction_index < ira->zir_current_basic_block->instruction_list.length);
     if (ira->codegen->verbose_ir) {
-        fprintf(stderr, "%s_%" PRIu32 " #%" PRIu32 "\n", ira->old_irb.current_basic_block->name_hint,
-                ira->old_irb.current_basic_block->debug_id,
-                ira->old_irb.current_basic_block->instruction_list.at(pos.instruction_index)->base.debug_id);
+        fprintf(stderr, "%s_%" PRIu32 " #%" PRIu32 "\n", ira->zir_current_basic_block->name_hint,
+                ira->zir_current_basic_block->debug_id,
+                ira->zir_current_basic_block->instruction_list.at(pos.instruction_index)->base.debug_id);
     }
     ira->const_predecessor_bb = nullptr;
-    ira->new_irb.current_basic_block = ira->old_irb.current_basic_block->child;
+    ira->new_irb.current_basic_block = ira->zir_current_basic_block->child;
     assert(ira->new_irb.current_basic_block != nullptr);
     return ira->codegen->unreach_instruction;
 }
@@ -5350,8 +5351,8 @@ static void ir_start_next_bb(IrAnalyze *ira) {
 
     bool need_repeat = true;
     for (;;) {
-        while (ira->old_bb_index < ira->old_irb.exec->basic_block_list.length) {
-            IrBasicBlockSrc *old_bb = ira->old_irb.exec->basic_block_list.at(ira->old_bb_index);
+        while (ira->old_bb_index < ira->zir->basic_block_list.length) {
+            IrBasicBlockSrc *old_bb = ira->zir->basic_block_list.at(ira->old_bb_index);
             if (old_bb->child == nullptr && old_bb->suspend_instruction_ref == nullptr) {
                 ira->old_bb_index += 1;
                 continue;
@@ -5403,8 +5404,8 @@ static void ir_finish_bb(IrAnalyze *ira) {
         }
     }
     ira->instruction_index += 1;
-    while (ira->instruction_index < ira->old_irb.current_basic_block->instruction_list.length) {
-        IrInstSrc *next_instruction = ira->old_irb.current_basic_block->instruction_list.at(ira->instruction_index);
+    while (ira->instruction_index < ira->zir_current_basic_block->instruction_list.length) {
+        IrInstSrc *next_instruction = ira->zir_current_basic_block->instruction_list.at(ira->instruction_index);
         if (!next_instruction->is_gen) {
             ir_add_error(ira, &next_instruction->base, buf_sprintf("unreachable code"));
             break;
@@ -5443,13 +5444,13 @@ static bool ir_emit_backward_branch(IrAnalyze *ira, IrInst* source_instruction)
 }
 
 static IrInstGen *ir_inline_bb(IrAnalyze *ira, IrInst* source_instruction, IrBasicBlockSrc *old_bb) {
-    if (old_bb->debug_id <= ira->old_irb.current_basic_block->debug_id) {
+    if (old_bb->debug_id <= ira->zir_current_basic_block->debug_id) {
         if (!ir_emit_backward_branch(ira, source_instruction))
             return ir_unreach_error(ira);
     }
 
-    old_bb->child = ira->old_irb.current_basic_block->child;
-    ir_start_bb(ira, old_bb, ira->old_irb.current_basic_block);
+    old_bb->child = ira->zir_current_basic_block->child;
+    ir_start_bb(ira, old_bb, ira->zir_current_basic_block);
     return ira->codegen->unreach_instruction;
 }
 
@@ -5587,7 +5588,7 @@ Error ir_eval_const_value(CodeGen *codegen, Scope *scope, AstNode *node,
     if (type_is_invalid(return_ptr->type))
         return ErrorSemanticAnalyzeFail;
 
-    IrExecutableSrc *ir_executable = heap::c_allocator.create<IrExecutableSrc>();
+    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;
@@ -6914,7 +6915,7 @@ static IrInstGen *ir_analyze_struct_literal_to_array(IrAnalyze *ira, IrInst* sou
     size_t instr_field_count = actual_type->data.structure.src_field_count;
     assert(array_len == instr_field_count);
 
-    bool need_comptime = ir_should_inline(ira->old_irb.exec, source_instr->scope)
+    bool need_comptime = ir_should_inline(ira->zir, source_instr->scope)
         || type_requires_comptime(ira->codegen, wanted_type) == ReqCompTimeYes;
     bool is_comptime = true;
 
@@ -7004,7 +7005,7 @@ static IrInstGen *ir_analyze_struct_literal_to_struct(IrAnalyze *ira, IrInst* so
     size_t actual_field_count = wanted_type->data.structure.src_field_count;
     size_t instr_field_count = actual_type->data.structure.src_field_count;
 
-    bool need_comptime = ir_should_inline(ira->old_irb.exec, source_instr->scope)
+    bool need_comptime = ir_should_inline(ira->zir, source_instr->scope)
         || type_requires_comptime(ira->codegen, wanted_type) == ReqCompTimeYes;
     bool is_comptime = true;
 
@@ -11419,7 +11420,7 @@ static IrInstGen *ir_analyze_instruction_extern(IrAnalyze *ira, IrInstSrcExtern
             is_thread_local, expr_type);
 }
 
-static bool exec_has_err_ret_trace(CodeGen *g, IrExecutableSrc *exec) {
+static bool exec_has_err_ret_trace(CodeGen *g, Stage1Zir *exec) {
     ZigFn *fn_entry = exec->fn_entry;
     return fn_entry != nullptr && fn_entry->calls_or_awaits_errorable_fn && g->have_err_ret_tracing;
 }
@@ -11430,7 +11431,7 @@ static IrInstGen *ir_analyze_instruction_error_return_trace(IrAnalyze *ira,
     ZigType *ptr_to_stack_trace_type = get_pointer_to_type(ira->codegen, get_stack_trace_type(ira->codegen), false);
     if (instruction->optional == IrInstErrorReturnTraceNull) {
         ZigType *optional_type = get_optional_type(ira->codegen, ptr_to_stack_trace_type);
-        if (!exec_has_err_ret_trace(ira->codegen, ira->old_irb.exec)) {
+        if (!exec_has_err_ret_trace(ira->codegen, ira->zir)) {
             IrInstGen *result = ir_const(ira, &instruction->base.base, optional_type);
             ZigValue *out_val = result->value;
             assert(get_src_ptr_type(optional_type) != nullptr);
@@ -13213,7 +13214,7 @@ static IrInstGen *ir_analyze_call_extra(IrAnalyze *ira, IrInst* source_instr,
         return ira->codegen->invalid_inst_gen;
     CallModifier modifier = (CallModifier)bigint_as_u32(&modifier_val->data.x_enum_tag);
 
-    if (ir_should_inline(ira->old_irb.exec, source_instr->scope)) {
+    if (ir_should_inline(ira->zir, source_instr->scope)) {
         switch (modifier) {
             case CallModifierBuiltin:
                 zig_unreachable();
@@ -13302,7 +13303,7 @@ static IrInstGen *ir_analyze_async_call_extra(IrAnalyze *ira, IrInst* source_ins
     if (type_is_invalid(fn_ref->value->type))
         return ira->codegen->invalid_inst_gen;
 
-    if (ir_should_inline(ira->old_irb.exec, source_instr->scope)) {
+    if (ir_should_inline(ira->zir, source_instr->scope)) {
         ir_add_error(ira, source_instr, buf_sprintf("TODO: comptime @asyncCall"));
             return ira->codegen->invalid_inst_gen;
     }
@@ -13415,7 +13416,7 @@ static IrInstGen *ir_analyze_instruction_call(IrAnalyze *ira, IrInstSrcCall *cal
         return ira->codegen->invalid_inst_gen;
 
     bool is_comptime = (call_instruction->modifier == CallModifierCompileTime) ||
-        ir_should_inline(ira->old_irb.exec, call_instruction->base.base.scope);
+        ir_should_inline(ira->zir, call_instruction->base.base.scope);
     CallModifier modifier = is_comptime ? CallModifierCompileTime : call_instruction->modifier;
 
     if (is_comptime || instr_is_comptime(fn_ref)) {
@@ -13777,7 +13778,7 @@ static IrInstGen *ir_analyze_instruction_un_op(IrAnalyze *ira, IrInstSrcUnOp *in
 }
 
 static void ir_push_resume(IrAnalyze *ira, IrSuspendPosition pos) {
-    IrBasicBlockSrc *old_bb = ira->old_irb.exec->basic_block_list.at(pos.basic_block_index);
+    IrBasicBlockSrc *old_bb = ira->zir->basic_block_list.at(pos.basic_block_index);
     if (old_bb->in_resume_stack) return;
     ira->resume_stack.append(pos);
     old_bb->in_resume_stack = true;
@@ -13864,7 +13865,7 @@ static IrInstGen *ir_analyze_instruction_cond_br(IrAnalyze *ira, IrInstSrcCondBr
 static IrInstGen *ir_analyze_instruction_unreachable(IrAnalyze *ira,
         IrInstSrcUnreachable *unreachable_instruction)
 {
-    if (ir_should_inline(ira->old_irb.exec, unreachable_instruction->base.base.scope)) {
+    if (ir_should_inline(ira->zir, unreachable_instruction->base.base.scope)) {
         ir_add_error(ira, &unreachable_instruction->base.base, buf_sprintf("reached unreachable code"));
         return ir_unreach_error(ira);
     }
@@ -16479,7 +16480,7 @@ static IrInstGen *ir_analyze_union_init(IrAnalyze *ira, IrInst* source_instructi
         }
     }
 
-    bool is_comptime = ir_should_inline(ira->old_irb.exec, source_instruction->scope)
+    bool is_comptime = ir_should_inline(ira->zir, source_instruction->scope)
         || type_requires_comptime(ira->codegen, union_type) == ReqCompTimeYes;
 
     IrInstGen *result = ir_get_deref(ira, source_instruction, result_loc, nullptr);
@@ -16532,7 +16533,7 @@ static IrInstGen *ir_analyze_container_init_fields(IrAnalyze *ira, IrInst *sourc
     AstNode **field_assign_nodes = heap::c_allocator.allocate<AstNode *>(actual_field_count);
     ZigList<IrInstGen *> const_ptrs = {};
 
-    bool is_comptime = ir_should_inline(ira->old_irb.exec, source_instr->scope)
+    bool is_comptime = ir_should_inline(ira->zir, source_instr->scope)
         || type_requires_comptime(ira->codegen, container_type) == ReqCompTimeYes;
 
 
@@ -16719,7 +16720,7 @@ static IrInstGen *ir_analyze_instruction_container_init_list(IrAnalyze *ira,
         case ReqCompTimeInvalid:
             return ira->codegen->invalid_inst_gen;
         case ReqCompTimeNo:
-            is_comptime = ir_should_inline(ira->old_irb.exec, instruction->base.base.scope);
+            is_comptime = ir_should_inline(ira->zir, instruction->base.base.scope);
             break;
         case ReqCompTimeYes:
             is_comptime = true;
@@ -18491,7 +18492,7 @@ static ZigType *type_info_to_type(IrAnalyze *ira, IrInst *source_instr, ZigTypeI
 
             Buf *bare_name = buf_alloc();
             Buf *full_name = get_anon_type_name(ira->codegen,
-                ira->old_irb.exec, "opaque", source_instr->scope, source_instr->source_node, bare_name);
+                ira->zir, "opaque", source_instr->scope, source_instr->source_node, bare_name);
             return get_opaque_type(ira->codegen,
                 source_instr->scope, source_instr->source_node, buf_ptr(full_name), bare_name);
         }
@@ -18538,7 +18539,7 @@ static ZigType *type_info_to_type(IrAnalyze *ira, IrInst *source_instr, ZigTypeI
             assert(is_slice(slice->type));
             ZigType *err_set_type = new_type_table_entry(ZigTypeIdErrorSet);
             Buf bare_name = BUF_INIT;
-            buf_init_from_buf(&err_set_type->name, get_anon_type_name(ira->codegen, ira->old_irb.exec, "error", source_instr->scope, source_instr->source_node, &bare_name));
+            buf_init_from_buf(&err_set_type->name, get_anon_type_name(ira->codegen, ira->zir, "error", source_instr->scope, source_instr->source_node, &bare_name));
             err_set_type->size_in_bits = ira->codegen->builtin_types.entry_global_error_set->size_in_bits;
             err_set_type->abi_align = ira->codegen->builtin_types.entry_global_error_set->abi_align;
             err_set_type->abi_size = ira->codegen->builtin_types.entry_global_error_set->abi_size;
@@ -18617,7 +18618,7 @@ static ZigType *type_info_to_type(IrAnalyze *ira, IrInst *source_instr, ZigTypeI
 
             ZigType *entry = new_type_table_entry(ZigTypeIdStruct);
             buf_init_from_buf(&entry->name,
-                get_anon_type_name(ira->codegen, ira->old_irb.exec, "struct", source_instr->scope, source_instr->source_node, &entry->name));
+                get_anon_type_name(ira->codegen, ira->zir, "struct", source_instr->scope, source_instr->source_node, &entry->name));
             entry->data.structure.decl_node = source_instr->source_node;
             entry->data.structure.fields = alloc_type_struct_fields(fields_len);
             entry->data.structure.fields_by_name.init(fields_len);
@@ -18727,7 +18728,7 @@ static ZigType *type_info_to_type(IrAnalyze *ira, IrInst *source_instr, ZigTypeI
 
             ZigType *entry = new_type_table_entry(ZigTypeIdEnum);
             buf_init_from_buf(&entry->name,
-                get_anon_type_name(ira->codegen, ira->old_irb.exec, "enum", source_instr->scope, source_instr->source_node, &entry->name));
+                get_anon_type_name(ira->codegen, ira->zir, "enum", source_instr->scope, source_instr->source_node, &entry->name));
             entry->data.enumeration.decl_node = source_instr->source_node;
             entry->data.enumeration.tag_int_type = tag_type;
             entry->data.enumeration.decls_scope = create_decls_scope(
@@ -18809,7 +18810,7 @@ static ZigType *type_info_to_type(IrAnalyze *ira, IrInst *source_instr, ZigTypeI
 
             ZigType *entry = new_type_table_entry(ZigTypeIdUnion);
             buf_init_from_buf(&entry->name,
-                get_anon_type_name(ira->codegen, ira->old_irb.exec, "union", source_instr->scope, source_instr->source_node, &entry->name));
+                get_anon_type_name(ira->codegen, ira->zir, "union", source_instr->scope, source_instr->source_node, &entry->name));
             entry->data.unionation.decl_node = source_instr->source_node;
             entry->data.unionation.fields = heap::c_allocator.allocate<TypeUnionField>(fields_len);
             entry->data.unionation.fields_by_name.init(fields_len);
@@ -22004,7 +22005,7 @@ static IrInstGen *ir_analyze_instruction_panic(IrAnalyze *ira, IrInstSrcPanic *i
     if (type_is_invalid(msg->value->type))
         return ir_unreach_error(ira);
 
-    if (ir_should_inline(ira->old_irb.exec, instruction->base.base.scope)) {
+    if (ir_should_inline(ira->zir, instruction->base.base.scope)) {
         ir_add_error(ira, &instruction->base.base, buf_sprintf("encountered @panic at compile-time"));
         return ir_unreach_error(ira);
     }
@@ -24077,7 +24078,7 @@ static IrInstGen *ir_analyze_instruction_resume(IrAnalyze *ira, IrInstSrcResume
 }
 
 static IrInstGen *ir_analyze_instruction_spill_begin(IrAnalyze *ira, IrInstSrcSpillBegin *instruction) {
-    if (ir_should_inline(ira->old_irb.exec, instruction->base.base.scope))
+    if (ir_should_inline(ira->zir, instruction->base.base.scope))
         return ir_const_void(ira, &instruction->base.base);
 
     IrInstGen *operand = instruction->operand->child;
@@ -24103,7 +24104,7 @@ static IrInstGen *ir_analyze_instruction_spill_end(IrAnalyze *ira, IrInstSrcSpil
     if (type_is_invalid(operand->value->type))
         return ira->codegen->invalid_inst_gen;
 
-    if (ir_should_inline(ira->old_irb.exec, instruction->base.base.scope) ||
+    if (ir_should_inline(ira->zir, instruction->base.base.scope) ||
         !type_has_bits(ira->codegen, operand->value->type) ||
         instr_is_comptime(operand))
     {
@@ -24467,7 +24468,7 @@ 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, IrExecutableSrc *old_exec, IrExecutableGen *new_exec,
+ZigType *ir_analyze(CodeGen *codegen, Stage1Zir *old_exec, IrExecutableGen *new_exec,
         ZigType *expected_type, AstNode *expected_type_source_node, ZigValue *result_ptr)
 {
     assert(old_exec->first_err_trace_msg == nullptr);
@@ -24481,13 +24482,12 @@ ZigType *ir_analyze(CodeGen *codegen, IrExecutableSrc *old_exec, IrExecutableGen
     ira->explicit_return_type = expected_type;
     ira->explicit_return_type_source_node = expected_type_source_node;
 
-    ira->old_irb.codegen = codegen;
-    ira->old_irb.exec = old_exec;
+    ira->zir = old_exec;
 
     ira->new_irb.codegen = codegen;
     ira->new_irb.exec = new_exec;
 
-    IrBasicBlockSrc *old_entry_bb = ira->old_irb.exec->basic_block_list.at(0);
+    IrBasicBlockSrc *old_entry_bb = ira->zir->basic_block_list.at(0);
     IrBasicBlockGen *new_entry_bb = ir_get_new_bb(ira, old_entry_bb, nullptr);
     ira->new_irb.current_basic_block = new_entry_bb;
     ira->old_bb_index = 0;
@@ -24507,8 +24507,8 @@ ZigType *ir_analyze(CodeGen *codegen, IrExecutableSrc *old_exec, IrExecutableGen
                 get_pointer_to_type(codegen, expected_type, false));
     }
 
-    while (ira->old_bb_index < ira->old_irb.exec->basic_block_list.length) {
-        IrInstSrc *old_instruction = ira->old_irb.current_basic_block->instruction_list.at(ira->instruction_index);
+    while (ira->old_bb_index < ira->zir->basic_block_list.length) {
+        IrInstSrc *old_instruction = ira->zir_current_basic_block->instruction_list.at(ira->instruction_index);
 
         if (old_instruction->base.ref_count == 0 && !ir_inst_src_has_side_effects(old_instruction)) {
             ira->instruction_index += 1;

src/stage1/ir.hpp

@@ -20,7 +20,7 @@ Error ir_eval_const_value(CodeGen *codegen, Scope *scope, AstNode *node,
 
 Error ir_resolve_lazy(CodeGen *codegen, AstNode *source_node, ZigValue *val);
 
-ZigType *ir_analyze(CodeGen *g, IrExecutableSrc *old_executable, IrExecutableGen *new_executable,
+ZigType *ir_analyze(CodeGen *g, Stage1Zir *old_executable, IrExecutableGen *new_executable,
         ZigType *expected_type, AstNode *expected_type_source_node, ZigValue *return_ptr);
 
 bool ir_inst_gen_has_side_effects(IrInstGen *inst);

src/stage1/ir_print.cpp

@@ -3395,7 +3395,7 @@ void ir_print_basic_block_gen(CodeGen *codegen, FILE *f, IrBasicBlockGen *bb, in
     ir_print.printed.deinit();
 }
 
-void ir_print_src(CodeGen *codegen, FILE *f, IrExecutableSrc *executable, int indent_size) {
+void ir_print_src(CodeGen *codegen, FILE *f, Stage1Zir *executable, int indent_size) {
     IrPrintSrc ir_print = {};
     IrPrintSrc *irp = &ir_print;
     irp->codegen = codegen;

src/stage1/ir_print.hpp

@@ -12,7 +12,7 @@
 
 #include <stdio.h>
 
-void ir_print_src(CodeGen *codegen, FILE *f, IrExecutableSrc *executable, int indent_size);
+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_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);