Merge remote-tracking branch 'origin/master' into llvm8

1 files changed, 2033 insertions, 2569 deletions

diff --git a/src/ir.cpp b/src/ir.cpp
index 7b2ae30a79..9bb884c61c 100644
--- a/src/ir.cpp
+++ b/src/ir.cpp
@@ -140,7 +140,7 @@ struct ConstCastErrSetMismatch {
 
 static IrInstruction *ir_gen_node(IrBuilder *irb, AstNode *node, Scope *scope);
 static IrInstruction *ir_gen_node_extra(IrBuilder *irb, AstNode *node, Scope *scope, LVal lval);
-static ZigType *ir_analyze_instruction(IrAnalyze *ira, IrInstruction *instruction);
+static IrInstruction *ir_analyze_instruction(IrAnalyze *ira, IrInstruction *instruction);
 static IrInstruction *ir_implicit_cast(IrAnalyze *ira, IrInstruction *value, ZigType *expected_type);
 static IrInstruction *ir_get_deref(IrAnalyze *ira, IrInstruction *source_instruction, IrInstruction *ptr);
 static ErrorMsg *exec_add_error_node(CodeGen *codegen, IrExecutable *exec, AstNode *source_node, Buf *msg);
@@ -153,6 +153,10 @@ static ZigType *adjust_ptr_align(CodeGen *g, ZigType *ptr_type, uint32_t new_ali
 static ZigType *adjust_slice_align(CodeGen *g, ZigType *slice_type, uint32_t new_align);
 static void buf_read_value_bytes(CodeGen *codegen, uint8_t *buf, ConstExprValue *val);
 static void buf_write_value_bytes(CodeGen *codegen, uint8_t *buf, ConstExprValue *val);
+static Error ir_read_const_ptr(IrAnalyze *ira, AstNode *source_node,
+        ConstExprValue *out_val, ConstExprValue *ptr_val);
+static IrInstruction *ir_analyze_ptr_cast(IrAnalyze *ira, IrInstruction *source_instr, IrInstruction *ptr,
+        ZigType *dest_type, IrInstruction *dest_type_src);
 
 static ConstExprValue *const_ptr_pointee_unchecked(CodeGen *g, ConstExprValue *const_val) {
     assert(get_src_ptr_type(const_val->type) != nullptr);
@@ -166,7 +170,7 @@ static ConstExprValue *const_ptr_pointee_unchecked(CodeGen *g, ConstExprValue *c
             break;
         case ConstPtrSpecialBaseArray:
             expand_undef_array(g, const_val->data.x_ptr.data.base_array.array_val);
-            result = &const_val->data.x_ptr.data.base_array.array_val->data.x_array.s_none.elements[
+            result = &const_val->data.x_ptr.data.base_array.array_val->data.x_array.data.s_none.elements[
                 const_val->data.x_ptr.data.base_array.elem_index];
             break;
         case ConstPtrSpecialBaseStruct:
@@ -257,11 +261,6 @@ static bool instr_is_unreachable(IrInstruction *instruction) {
     return instruction->value.type && instruction->value.type->id == ZigTypeIdUnreachable;
 }
 
-static void ir_link_new_instruction(IrInstruction *new_instruction, IrInstruction *old_instruction) {
-    new_instruction->other = old_instruction;
-    old_instruction->other = new_instruction;
-}
-
 static void ir_link_new_bb(IrBasicBlock *new_bb, IrBasicBlock *old_bb) {
     new_bb->other = old_bb;
     old_bb->other = new_bb;
@@ -496,14 +495,6 @@ static constexpr IrInstructionId ir_instruction_id(IrInstructionUnionInit *) {
     return IrInstructionIdUnionInit;
 }
 
-static constexpr IrInstructionId ir_instruction_id(IrInstructionMinValue *) {
-    return IrInstructionIdMinValue;
-}
-
-static constexpr IrInstructionId ir_instruction_id(IrInstructionMaxValue *) {
-    return IrInstructionIdMaxValue;
-}
-
 static constexpr IrInstructionId ir_instruction_id(IrInstructionCompileErr *) {
     return IrInstructionIdCompileErr;
 }
@@ -720,8 +711,12 @@ static constexpr IrInstructionId ir_instruction_id(IrInstructionFieldParentPtr *
     return IrInstructionIdFieldParentPtr;
 }
 
-static constexpr IrInstructionId ir_instruction_id(IrInstructionOffsetOf *) {
-    return IrInstructionIdOffsetOf;
+static constexpr IrInstructionId ir_instruction_id(IrInstructionByteOffsetOf *) {
+    return IrInstructionIdByteOffsetOf;
+}
+
+static constexpr IrInstructionId ir_instruction_id(IrInstructionBitOffsetOf *) {
+    return IrInstructionIdBitOffsetOf;
 }
 
 static constexpr IrInstructionId ir_instruction_id(IrInstructionTypeInfo *) {
@@ -911,15 +906,6 @@ static IrInstruction *ir_build_cond_br(IrBuilder *irb, Scope *scope, AstNode *so
     return &cond_br_instruction->base;
 }
 
-static IrInstruction *ir_build_cond_br_from(IrBuilder *irb, IrInstruction *old_instruction,
-        IrInstruction *condition, IrBasicBlock *then_block, IrBasicBlock *else_block, IrInstruction *is_comptime)
-{
-    IrInstruction *new_instruction = ir_build_cond_br(irb, old_instruction->scope, old_instruction->source_node,
-            condition, then_block, else_block, is_comptime);
-    ir_link_new_instruction(new_instruction, old_instruction);
-    return new_instruction;
-}
-
 static IrInstruction *ir_build_return(IrBuilder *irb, Scope *scope, AstNode *source_node, IrInstruction *return_value) {
     IrInstructionReturn *return_instruction = ir_build_instruction<IrInstructionReturn>(irb, scope, source_node);
     return_instruction->base.value.type = irb->codegen->builtin_types.entry_unreachable;
@@ -1090,15 +1076,6 @@ static IrInstruction *ir_build_bin_op(IrBuilder *irb, Scope *scope, AstNode *sou
     return &bin_op_instruction->base;
 }
 
-static IrInstruction *ir_build_bin_op_from(IrBuilder *irb, IrInstruction *old_instruction, IrBinOp op_id,
-        IrInstruction *op1, IrInstruction *op2, bool safety_check_on)
-{
-    IrInstruction *new_instruction = ir_build_bin_op(irb, old_instruction->scope,
-            old_instruction->source_node, op_id, op1, op2, safety_check_on);
-    ir_link_new_instruction(new_instruction, old_instruction);
-    return new_instruction;
-}
-
 static IrInstruction *ir_build_var_ptr_x(IrBuilder *irb, Scope *scope, AstNode *source_node, ZigVar *var,
         ScopeFnDef *crossed_fndef_scope)
 {
@@ -1181,15 +1158,6 @@ static IrInstruction *ir_build_union_field_ptr(IrBuilder *irb, Scope *scope, Ast
     return &instruction->base;
 }
 
-static IrInstruction *ir_build_union_field_ptr_from(IrBuilder *irb, IrInstruction *old_instruction,
-    IrInstruction *union_ptr, TypeUnionField *type_union_field)
-{
-    IrInstruction *new_instruction = ir_build_union_field_ptr(irb, old_instruction->scope,
-            old_instruction->source_node, union_ptr, type_union_field);
-    ir_link_new_instruction(new_instruction, old_instruction);
-    return new_instruction;
-}
-
 static IrInstruction *ir_build_call(IrBuilder *irb, Scope *scope, AstNode *source_node,
         ZigFn *fn_entry, IrInstruction *fn_ref, size_t arg_count, IrInstruction **args,
         bool is_comptime, FnInline fn_inline, bool is_async, IrInstruction *async_allocator,
@@ -1218,17 +1186,6 @@ static IrInstruction *ir_build_call(IrBuilder *irb, Scope *scope, AstNode *sourc
     return &call_instruction->base;
 }
 
-static IrInstruction *ir_build_call_from(IrBuilder *irb, IrInstruction *old_instruction,
-        ZigFn *fn_entry, IrInstruction *fn_ref, size_t arg_count, IrInstruction **args,
-        bool is_comptime, FnInline fn_inline, bool is_async, IrInstruction *async_allocator,
-        IrInstruction *new_stack)
-{
-    IrInstruction *new_instruction = ir_build_call(irb, old_instruction->scope,
-            old_instruction->source_node, fn_entry, fn_ref, arg_count, args, is_comptime, fn_inline, is_async, async_allocator, new_stack);
-    ir_link_new_instruction(new_instruction, old_instruction);
-    return new_instruction;
-}
-
 static IrInstruction *ir_build_phi(IrBuilder *irb, Scope *scope, AstNode *source_node,
         size_t incoming_count, IrBasicBlock **incoming_blocks, IrInstruction **incoming_values)
 {
@@ -1248,15 +1205,6 @@ static IrInstruction *ir_build_phi(IrBuilder *irb, Scope *scope, AstNode *source
     return &phi_instruction->base;
 }
 
-static IrInstruction *ir_build_phi_from(IrBuilder *irb, IrInstruction *old_instruction,
-        size_t incoming_count, IrBasicBlock **incoming_blocks, IrInstruction **incoming_values)
-{
-    IrInstruction *new_instruction = ir_build_phi(irb, old_instruction->scope, old_instruction->source_node,
-            incoming_count, incoming_blocks, incoming_values);
-    ir_link_new_instruction(new_instruction, old_instruction);
-    return new_instruction;
-}
-
 static IrInstruction *ir_create_br(IrBuilder *irb, Scope *scope, AstNode *source_node,
         IrBasicBlock *dest_block, IrInstruction *is_comptime)
 {
@@ -1280,15 +1228,9 @@ static IrInstruction *ir_build_br(IrBuilder *irb, Scope *scope, AstNode *source_
     return instruction;
 }
 
-static IrInstruction *ir_build_br_from(IrBuilder *irb, IrInstruction *old_instruction, IrBasicBlock *dest_block) {
-    IrInstruction *new_instruction = ir_build_br(irb, old_instruction->scope, old_instruction->source_node, dest_block, nullptr);
-    ir_link_new_instruction(new_instruction, old_instruction);
-    return new_instruction;
-}
-
 static IrInstruction *ir_build_ptr_type(IrBuilder *irb, Scope *scope, AstNode *source_node,
         IrInstruction *child_type, bool is_const, bool is_volatile, PtrLen ptr_len,
-        IrInstruction *align_value, uint32_t bit_offset_start, uint32_t bit_offset_end)
+        IrInstruction *align_value, uint32_t bit_offset_start, uint32_t host_int_bytes)
 {
     IrInstructionPtrType *ptr_type_of_instruction = ir_build_instruction<IrInstructionPtrType>(irb, scope, source_node);
     ptr_type_of_instruction->align_value = align_value;
@@ -1297,7 +1239,7 @@ static IrInstruction *ir_build_ptr_type(IrBuilder *irb, Scope *scope, AstNode *s
     ptr_type_of_instruction->is_volatile = is_volatile;
     ptr_type_of_instruction->ptr_len = ptr_len;
     ptr_type_of_instruction->bit_offset_start = bit_offset_start;
-    ptr_type_of_instruction->bit_offset_end = bit_offset_end;
+    ptr_type_of_instruction->host_int_bytes = host_int_bytes;
 
     if (align_value) ir_ref_instruction(align_value, irb->current_basic_block);
     ir_ref_instruction(child_type, irb->current_basic_block);
@@ -1315,15 +1257,6 @@ static IrInstruction *ir_build_un_op(IrBuilder *irb, Scope *scope, AstNode *sour
     return &br_instruction->base;
 }
 
-static IrInstruction *ir_build_un_op_from(IrBuilder *irb, IrInstruction *old_instruction,
-        IrUnOp op_id, IrInstruction *value)
-{
-    IrInstruction *new_instruction = ir_build_un_op(irb, old_instruction->scope,
-            old_instruction->source_node, op_id, value);
-    ir_link_new_instruction(new_instruction, old_instruction);
-    return new_instruction;
-}
-
 static IrInstruction *ir_build_container_init_list(IrBuilder *irb, Scope *scope, AstNode *source_node,
         IrInstruction *container_type, size_t item_count, IrInstruction **items)
 {
@@ -1341,15 +1274,6 @@ static IrInstruction *ir_build_container_init_list(IrBuilder *irb, Scope *scope,
     return &container_init_list_instruction->base;
 }
 
-static IrInstruction *ir_build_container_init_list_from(IrBuilder *irb, IrInstruction *old_instruction,
-        IrInstruction *container_type, size_t item_count, IrInstruction **items)
-{
-    IrInstruction *new_instruction = ir_build_container_init_list(irb, old_instruction->scope,
-            old_instruction->source_node, container_type, item_count, items);
-    ir_link_new_instruction(new_instruction, old_instruction);
-    return new_instruction;
-}
-
 static IrInstruction *ir_build_container_init_fields(IrBuilder *irb, Scope *scope, AstNode *source_node,
         IrInstruction *container_type, size_t field_count, IrInstructionContainerInitFieldsField *fields)
 {
@@ -1381,15 +1305,6 @@ static IrInstruction *ir_build_struct_init(IrBuilder *irb, Scope *scope, AstNode
     return &struct_init_instruction->base;
 }
 
-static IrInstruction *ir_build_struct_init_from(IrBuilder *irb, IrInstruction *old_instruction,
-        ZigType *struct_type, size_t field_count, IrInstructionStructInitField *fields)
-{
-    IrInstruction *new_instruction = ir_build_struct_init(irb, old_instruction->scope,
-            old_instruction->source_node, struct_type, field_count, fields);
-    ir_link_new_instruction(new_instruction, old_instruction);
-    return new_instruction;
-}
-
 static IrInstruction *ir_build_union_init(IrBuilder *irb, Scope *scope, AstNode *source_node,
         ZigType *union_type, TypeUnionField *field, IrInstruction *init_value)
 {
@@ -1403,15 +1318,6 @@ static IrInstruction *ir_build_union_init(IrBuilder *irb, Scope *scope, AstNode
     return &union_init_instruction->base;
 }
 
-static IrInstruction *ir_build_union_init_from(IrBuilder *irb, IrInstruction *old_instruction,
-        ZigType *union_type, TypeUnionField *field, IrInstruction *init_value)
-{
-    IrInstruction *new_instruction = ir_build_union_init(irb, old_instruction->scope,
-            old_instruction->source_node, union_type, field, init_value);
-    ir_link_new_instruction(new_instruction, old_instruction);
-    return new_instruction;
-}
-
 static IrInstruction *ir_build_unreachable(IrBuilder *irb, Scope *scope, AstNode *source_node) {
     IrInstructionUnreachable *unreachable_instruction =
         ir_build_instruction<IrInstructionUnreachable>(irb, scope, source_node);
@@ -1420,12 +1326,6 @@ static IrInstruction *ir_build_unreachable(IrBuilder *irb, Scope *scope, AstNode
     return &unreachable_instruction->base;
 }
 
-static IrInstruction *ir_build_unreachable_from(IrBuilder *irb, IrInstruction *old_instruction) {
-    IrInstruction *new_instruction = ir_build_unreachable(irb, old_instruction->scope, old_instruction->source_node);
-    ir_link_new_instruction(new_instruction, old_instruction);
-    return new_instruction;
-}
-
 static IrInstruction *ir_build_store_ptr(IrBuilder *irb, Scope *scope, AstNode *source_node,
         IrInstruction *ptr, IrInstruction *value)
 {
@@ -1441,15 +1341,6 @@ static IrInstruction *ir_build_store_ptr(IrBuilder *irb, Scope *scope, AstNode *
     return &instruction->base;
 }
 
-static IrInstruction *ir_build_store_ptr_from(IrBuilder *irb, IrInstruction *old_instruction,
-        IrInstruction *ptr, IrInstruction *value)
-{
-    IrInstruction *new_instruction = ir_build_store_ptr(irb, old_instruction->scope,
-            old_instruction->source_node, ptr, value);
-    ir_link_new_instruction(new_instruction, old_instruction);
-    return new_instruction;
-}
-
 static IrInstruction *ir_build_var_decl(IrBuilder *irb, Scope *scope, AstNode *source_node,
         ZigVar *var, IrInstruction *var_type, IrInstruction *align_value, IrInstruction *init_value)
 {
@@ -1468,15 +1359,6 @@ static IrInstruction *ir_build_var_decl(IrBuilder *irb, Scope *scope, AstNode *s
     return &decl_var_instruction->base;
 }
 
-static IrInstruction *ir_build_var_decl_from(IrBuilder *irb, IrInstruction *old_instruction,
-        ZigVar *var, IrInstruction *var_type, IrInstruction *align_value, IrInstruction *init_value)
-{
-    IrInstruction *new_instruction = ir_build_var_decl(irb, old_instruction->scope,
-            old_instruction->source_node, var, var_type, align_value, init_value);
-    ir_link_new_instruction(new_instruction, old_instruction);
-    return new_instruction;
-}
-
 static IrInstruction *ir_build_export(IrBuilder *irb, Scope *scope, AstNode *source_node,
         IrInstruction *name, IrInstruction *target, IrInstruction *linkage)
 {
@@ -1504,13 +1386,6 @@ static IrInstruction *ir_build_load_ptr(IrBuilder *irb, Scope *scope, AstNode *s
     return &instruction->base;
 }
 
-static IrInstruction *ir_build_load_ptr_from(IrBuilder *irb, IrInstruction *old_instruction, IrInstruction *ptr) {
-    IrInstruction *new_instruction = ir_build_load_ptr(irb, old_instruction->scope,
-            old_instruction->source_node, ptr);
-    ir_link_new_instruction(new_instruction, old_instruction);
-    return new_instruction;
-}
-
 static IrInstruction *ir_build_typeof(IrBuilder *irb, Scope *scope, AstNode *source_node, IrInstruction *value) {
     IrInstructionTypeOf *instruction = ir_build_instruction<IrInstructionTypeOf>(irb, scope, source_node);
     instruction->value = value;
@@ -1635,15 +1510,6 @@ static IrInstruction *ir_build_asm(IrBuilder *irb, Scope *scope, AstNode *source
     return &instruction->base;
 }
 
-static IrInstruction *ir_build_asm_from(IrBuilder *irb, IrInstruction *old_instruction, IrInstruction **input_list,
-        IrInstruction **output_types, ZigVar **output_vars, size_t return_count, bool has_side_effects)
-{
-    IrInstruction *new_instruction = ir_build_asm(irb, old_instruction->scope,
-            old_instruction->source_node, input_list, output_types, output_vars, return_count, has_side_effects);
-    ir_link_new_instruction(new_instruction, old_instruction);
-    return new_instruction;
-}
-
 static IrInstruction *ir_build_size_of(IrBuilder *irb, Scope *scope, AstNode *source_node, IrInstruction *type_value) {
     IrInstructionSizeOf *instruction = ir_build_instruction<IrInstructionSizeOf>(irb, scope, source_node);
     instruction->type_value = type_value;
@@ -1662,15 +1528,6 @@ static IrInstruction *ir_build_test_nonnull(IrBuilder *irb, Scope *scope, AstNod
     return &instruction->base;
 }
 
-static IrInstruction *ir_build_test_nonnull_from(IrBuilder *irb, IrInstruction *old_instruction,
-        IrInstruction *value)
-{
-    IrInstruction *new_instruction = ir_build_test_nonnull(irb, old_instruction->scope,
-            old_instruction->source_node, value);
-    ir_link_new_instruction(new_instruction, old_instruction);
-    return new_instruction;
-}
-
 static IrInstruction *ir_build_unwrap_maybe(IrBuilder *irb, Scope *scope, AstNode *source_node, IrInstruction *value,
         bool safety_check_on)
 {
@@ -1683,15 +1540,6 @@ static IrInstruction *ir_build_unwrap_maybe(IrBuilder *irb, Scope *scope, AstNod
     return &instruction->base;
 }
 
-static IrInstruction *ir_build_unwrap_maybe_from(IrBuilder *irb, IrInstruction *old_instruction,
-        IrInstruction *value, bool safety_check_on)
-{
-    IrInstruction *new_instruction = ir_build_unwrap_maybe(irb, old_instruction->scope, old_instruction->source_node,
-            value, safety_check_on);
-    ir_link_new_instruction(new_instruction, old_instruction);
-    return new_instruction;
-}
-
 static IrInstruction *ir_build_maybe_wrap(IrBuilder *irb, Scope *scope, AstNode *source_node, IrInstruction *value) {
     IrInstructionOptionalWrap *instruction = ir_build_instruction<IrInstructionOptionalWrap>(irb, scope, source_node);
     instruction->value = value;
@@ -1728,12 +1576,6 @@ static IrInstruction *ir_build_clz(IrBuilder *irb, Scope *scope, AstNode *source
     return &instruction->base;
 }
 
-static IrInstruction *ir_build_clz_from(IrBuilder *irb, IrInstruction *old_instruction, IrInstruction *value) {
-    IrInstruction *new_instruction = ir_build_clz(irb, old_instruction->scope, old_instruction->source_node, value);
-    ir_link_new_instruction(new_instruction, old_instruction);
-    return new_instruction;
-}
-
 static IrInstruction *ir_build_ctz(IrBuilder *irb, Scope *scope, AstNode *source_node, IrInstruction *value) {
     IrInstructionCtz *instruction = ir_build_instruction<IrInstructionCtz>(irb, scope, source_node);
     instruction->value = value;
@@ -1743,12 +1585,6 @@ static IrInstruction *ir_build_ctz(IrBuilder *irb, Scope *scope, AstNode *source
     return &instruction->base;
 }
 
-static IrInstruction *ir_build_ctz_from(IrBuilder *irb, IrInstruction *old_instruction, IrInstruction *value) {
-    IrInstruction *new_instruction = ir_build_ctz(irb, old_instruction->scope, old_instruction->source_node, value);
-    ir_link_new_instruction(new_instruction, old_instruction);
-    return new_instruction;
-}
-
 static IrInstruction *ir_build_pop_count(IrBuilder *irb, Scope *scope, AstNode *source_node, IrInstruction *value) {
     IrInstructionPopCount *instruction = ir_build_instruction<IrInstructionPopCount>(irb, scope, source_node);
     instruction->value = value;
@@ -1785,16 +1621,6 @@ static IrInstruction *ir_build_switch_br(IrBuilder *irb, Scope *scope, AstNode *
     return &instruction->base;
 }
 
-static IrInstruction *ir_build_switch_br_from(IrBuilder *irb, IrInstruction *old_instruction,
-        IrInstruction *target_value, IrBasicBlock *else_block, size_t case_count,
-        IrInstructionSwitchBrCase *cases, IrInstruction *is_comptime, IrInstruction *switch_prongs_void)
-{
-    IrInstruction *new_instruction = ir_build_switch_br(irb, old_instruction->scope, old_instruction->source_node,
-            target_value, else_block, case_count, cases, is_comptime, switch_prongs_void);
-    ir_link_new_instruction(new_instruction, old_instruction);
-    return new_instruction;
-}
-
 static IrInstruction *ir_build_switch_target(IrBuilder *irb, Scope *scope, AstNode *source_node,
         IrInstruction *target_value_ptr)
 {
@@ -1859,24 +1685,6 @@ static IrInstruction *ir_build_ref(IrBuilder *irb, Scope *scope, AstNode *source
     return &instruction->base;
 }
 
-static IrInstruction *ir_build_min_value(IrBuilder *irb, Scope *scope, AstNode *source_node, IrInstruction *value) {
-    IrInstructionMinValue *instruction = ir_build_instruction<IrInstructionMinValue>(irb, scope, source_node);
-    instruction->value = value;
-
-    ir_ref_instruction(value, irb->current_basic_block);
-
-    return &instruction->base;
-}
-
-static IrInstruction *ir_build_max_value(IrBuilder *irb, Scope *scope, AstNode *source_node, IrInstruction *value) {
-    IrInstructionMaxValue *instruction = ir_build_instruction<IrInstructionMaxValue>(irb, scope, source_node);
-    instruction->value = value;
-
-    ir_ref_instruction(value, irb->current_basic_block);
-
-    return &instruction->base;
-}
-
 static IrInstruction *ir_build_compile_err(IrBuilder *irb, Scope *scope, AstNode *source_node, IrInstruction *msg) {
     IrInstructionCompileErr *instruction = ir_build_instruction<IrInstructionCompileErr>(irb, scope, source_node);
     instruction->msg = msg;
@@ -1909,13 +1717,6 @@ static IrInstruction *ir_build_err_name(IrBuilder *irb, Scope *scope, AstNode *s
     return &instruction->base;
 }
 
-static IrInstruction *ir_build_err_name_from(IrBuilder *irb, IrInstruction *old_instruction, IrInstruction *value) {
-    IrInstruction *new_instruction = ir_build_err_name(irb, old_instruction->scope,
-            old_instruction->source_node, value);
-    ir_link_new_instruction(new_instruction, old_instruction);
-    return new_instruction;
-}
-
 static IrInstruction *ir_build_c_import(IrBuilder *irb, Scope *scope, AstNode *source_node) {
     IrInstructionCImport *instruction = ir_build_instruction<IrInstructionCImport>(irb, scope, source_node);
     return &instruction->base;
@@ -1997,12 +1798,6 @@ static IrInstruction *ir_build_fence(IrBuilder *irb, Scope *scope, AstNode *sour
     return &instruction->base;
 }
 
-static IrInstruction *ir_build_fence_from(IrBuilder *irb, IrInstruction *old_instruction, IrInstruction *order_value, AtomicOrder order) {
-    IrInstruction *new_instruction = ir_build_fence(irb, old_instruction->scope, old_instruction->source_node, order_value, order);
-    ir_link_new_instruction(new_instruction, old_instruction);
-    return new_instruction;
-}
-
 static IrInstruction *ir_build_truncate(IrBuilder *irb, Scope *scope, AstNode *source_node, IrInstruction *dest_type, IrInstruction *target) {
     IrInstructionTruncate *instruction = ir_build_instruction<IrInstructionTruncate>(irb, scope, source_node);
     instruction->dest_type = dest_type;
@@ -2118,12 +1913,6 @@ static IrInstruction *ir_build_bool_not(IrBuilder *irb, Scope *scope, AstNode *s
     return &instruction->base;
 }
 
-static IrInstruction *ir_build_bool_not_from(IrBuilder *irb, IrInstruction *old_instruction, IrInstruction *value) {
-    IrInstruction *new_instruction = ir_build_bool_not(irb, old_instruction->scope, old_instruction->source_node, value);
-    ir_link_new_instruction(new_instruction, old_instruction);
-    return new_instruction;
-}
-
 static IrInstruction *ir_build_memset(IrBuilder *irb, Scope *scope, AstNode *source_node,
     IrInstruction *dest_ptr, IrInstruction *byte, IrInstruction *count)
 {
@@ -2139,14 +1928,6 @@ static IrInstruction *ir_build_memset(IrBuilder *irb, Scope *scope, AstNode *sou
     return &instruction->base;
 }
 
-static IrInstruction *ir_build_memset_from(IrBuilder *irb, IrInstruction *old_instruction,
-    IrInstruction *dest_ptr, IrInstruction *byte, IrInstruction *count)
-{
-    IrInstruction *new_instruction = ir_build_memset(irb, old_instruction->scope, old_instruction->source_node, dest_ptr, byte, count);
-    ir_link_new_instruction(new_instruction, old_instruction);
-    return new_instruction;
-}
-
 static IrInstruction *ir_build_memcpy(IrBuilder *irb, Scope *scope, AstNode *source_node,
     IrInstruction *dest_ptr, IrInstruction *src_ptr, IrInstruction *count)
 {
@@ -2162,14 +1943,6 @@ static IrInstruction *ir_build_memcpy(IrBuilder *irb, Scope *scope, AstNode *sou
     return &instruction->base;
 }
 
-static IrInstruction *ir_build_memcpy_from(IrBuilder *irb, IrInstruction *old_instruction,
-    IrInstruction *dest_ptr, IrInstruction *src_ptr, IrInstruction *count)
-{
-    IrInstruction *new_instruction = ir_build_memcpy(irb, old_instruction->scope, old_instruction->source_node, dest_ptr, src_ptr, count);
-    ir_link_new_instruction(new_instruction, old_instruction);
-    return new_instruction;
-}
-
 static IrInstruction *ir_build_slice(IrBuilder *irb, Scope *scope, AstNode *source_node,
     IrInstruction *ptr, IrInstruction *start, IrInstruction *end, bool safety_check_on)
 {
@@ -2186,15 +1959,6 @@ static IrInstruction *ir_build_slice(IrBuilder *irb, Scope *scope, AstNode *sour
     return &instruction->base;
 }
 
-static IrInstruction *ir_build_slice_from(IrBuilder *irb, IrInstruction *old_instruction,
-    IrInstruction *ptr, IrInstruction *start, IrInstruction *end, bool safety_check_on)
-{
-    IrInstruction *new_instruction = ir_build_slice(irb, old_instruction->scope,
-            old_instruction->source_node, ptr, start, end, safety_check_on);
-    ir_link_new_instruction(new_instruction, old_instruction);
-    return new_instruction;
-}
-
 static IrInstruction *ir_build_member_count(IrBuilder *irb, Scope *scope, AstNode *source_node, IrInstruction *container) {
     IrInstructionMemberCount *instruction = ir_build_instruction<IrInstructionMemberCount>(irb, scope, source_node);
     instruction->container = container;
@@ -2235,45 +1999,21 @@ static IrInstruction *ir_build_breakpoint(IrBuilder *irb, Scope *scope, AstNode
     return &instruction->base;
 }
 
-static IrInstruction *ir_build_breakpoint_from(IrBuilder *irb, IrInstruction *old_instruction) {
-    IrInstruction *new_instruction = ir_build_breakpoint(irb, old_instruction->scope, old_instruction->source_node);
-    ir_link_new_instruction(new_instruction, old_instruction);
-    return new_instruction;
-}
-
 static IrInstruction *ir_build_return_address(IrBuilder *irb, Scope *scope, AstNode *source_node) {
     IrInstructionReturnAddress *instruction = ir_build_instruction<IrInstructionReturnAddress>(irb, scope, source_node);
     return &instruction->base;
 }
 
-static IrInstruction *ir_build_return_address_from(IrBuilder *irb, IrInstruction *old_instruction) {
-    IrInstruction *new_instruction = ir_build_return_address(irb, old_instruction->scope, old_instruction->source_node);
-    ir_link_new_instruction(new_instruction, old_instruction);
-    return new_instruction;
-}
-
 static IrInstruction *ir_build_frame_address(IrBuilder *irb, Scope *scope, AstNode *source_node) {
     IrInstructionFrameAddress *instruction = ir_build_instruction<IrInstructionFrameAddress>(irb, scope, source_node);
     return &instruction->base;
 }
 
-static IrInstruction *ir_build_frame_address_from(IrBuilder *irb, IrInstruction *old_instruction) {
-    IrInstruction *new_instruction = ir_build_frame_address(irb, old_instruction->scope, old_instruction->source_node);
-    ir_link_new_instruction(new_instruction, old_instruction);
-    return new_instruction;
-}
-
 static IrInstruction *ir_build_handle(IrBuilder *irb, Scope *scope, AstNode *source_node) {
     IrInstructionHandle *instruction = ir_build_instruction<IrInstructionHandle>(irb, scope, source_node);
     return &instruction->base;
 }
 
-static IrInstruction *ir_build_handle_from(IrBuilder *irb, IrInstruction *old_instruction) {
-    IrInstruction *new_instruction = ir_build_handle(irb, old_instruction->scope, old_instruction->source_node);
-    ir_link_new_instruction(new_instruction, old_instruction);
-    return new_instruction;
-}
-
 static IrInstruction *ir_build_overflow_op(IrBuilder *irb, Scope *scope, AstNode *source_node,
         IrOverflowOp op, IrInstruction *type_value, IrInstruction *op1, IrInstruction *op2,
         IrInstruction *result_ptr, ZigType *result_ptr_type)
@@ -2294,16 +2034,6 @@ static IrInstruction *ir_build_overflow_op(IrBuilder *irb, Scope *scope, AstNode
     return &instruction->base;
 }
 
-static IrInstruction *ir_build_overflow_op_from(IrBuilder *irb, IrInstruction *old_instruction,
-        IrOverflowOp op, IrInstruction *type_value, IrInstruction *op1, IrInstruction *op2,
-        IrInstruction *result_ptr, ZigType *result_ptr_type)
-{
-    IrInstruction *new_instruction = ir_build_overflow_op(irb, old_instruction->scope, old_instruction->source_node,
-            op, type_value, op1, op2, result_ptr, result_ptr_type);
-    ir_link_new_instruction(new_instruction, old_instruction);
-    return new_instruction;
-}
-
 static IrInstruction *ir_build_align_of(IrBuilder *irb, Scope *scope, AstNode *source_node, IrInstruction *type_value) {
     IrInstructionAlignOf *instruction = ir_build_instruction<IrInstructionAlignOf>(irb, scope, source_node);
     instruction->type_value = type_value;
@@ -2324,13 +2054,6 @@ static IrInstruction *ir_build_test_err(IrBuilder *irb, Scope *scope, AstNode *s
     return &instruction->base;
 }
 
-static IrInstruction *ir_build_test_err_from(IrBuilder *irb, IrInstruction *old_instruction, IrInstruction *value) {
-    IrInstruction *new_instruction = ir_build_test_err(irb, old_instruction->scope, old_instruction->source_node,
-            value);
-    ir_link_new_instruction(new_instruction, old_instruction);
-    return new_instruction;
-}
-
 static IrInstruction *ir_build_unwrap_err_code(IrBuilder *irb, Scope *scope, AstNode *source_node,
     IrInstruction *value)
 {
@@ -2342,15 +2065,6 @@ static IrInstruction *ir_build_unwrap_err_code(IrBuilder *irb, Scope *scope, Ast
     return &instruction->base;
 }
 
-static IrInstruction *ir_build_unwrap_err_code_from(IrBuilder *irb, IrInstruction *old_instruction,
-    IrInstruction *value)
-{
-    IrInstruction *new_instruction = ir_build_unwrap_err_code(irb, old_instruction->scope,
-        old_instruction->source_node, value);
-    ir_link_new_instruction(new_instruction, old_instruction);
-    return new_instruction;
-}
-
 static IrInstruction *ir_build_unwrap_err_payload(IrBuilder *irb, Scope *scope, AstNode *source_node,
     IrInstruction *value, bool safety_check_on)
 {
@@ -2363,15 +2077,6 @@ static IrInstruction *ir_build_unwrap_err_payload(IrBuilder *irb, Scope *scope,
     return &instruction->base;
 }
 
-static IrInstruction *ir_build_unwrap_err_payload_from(IrBuilder *irb, IrInstruction *old_instruction,
-    IrInstruction *value, bool safety_check_on)
-{
-    IrInstruction *new_instruction = ir_build_unwrap_err_payload(irb, old_instruction->scope,
-        old_instruction->source_node, value, safety_check_on);
-    ir_link_new_instruction(new_instruction, old_instruction);
-    return new_instruction;
-}
-
 static IrInstruction *ir_build_fn_proto(IrBuilder *irb, Scope *scope, AstNode *source_node,
     IrInstruction **param_types, IrInstruction *align_value, IrInstruction *return_type,
     IrInstruction *async_allocator_type_value, bool is_var_args)
@@ -2628,10 +2333,23 @@ static IrInstruction *ir_build_field_parent_ptr(IrBuilder *irb, Scope *scope, As
     return &instruction->base;
 }
 
-static IrInstruction *ir_build_offset_of(IrBuilder *irb, Scope *scope, AstNode *source_node,
+static IrInstruction *ir_build_byte_offset_of(IrBuilder *irb, Scope *scope, AstNode *source_node,
         IrInstruction *type_value, IrInstruction *field_name)
 {
-    IrInstructionOffsetOf *instruction = ir_build_instruction<IrInstructionOffsetOf>(irb, scope, source_node);
+    IrInstructionByteOffsetOf *instruction = ir_build_instruction<IrInstructionByteOffsetOf>(irb, scope, source_node);
+    instruction->type_value = type_value;
+    instruction->field_name = field_name;
+
+    ir_ref_instruction(type_value, irb->current_basic_block);
+    ir_ref_instruction(field_name, irb->current_basic_block);
+
+    return &instruction->base;
+}
+
+static IrInstruction *ir_build_bit_offset_of(IrBuilder *irb, Scope *scope, AstNode *source_node,
+        IrInstruction *type_value, IrInstruction *field_name)
+{
+    IrInstructionBitOffsetOf *instruction = ir_build_instruction<IrInstructionBitOffsetOf>(irb, scope, source_node);
     instruction->type_value = type_value;
     instruction->field_name = field_name;
 
@@ -3322,6 +3040,10 @@ static ZigVar *create_local_var(CodeGen *codegen, AstNode *node, Scope *parent_s
     variable_entry->src_arg_index = SIZE_MAX;
     variable_entry->value = create_const_vals(1);
 
+    if (is_comptime != nullptr) {
+        is_comptime->ref_count += 1;
+    }
+
     if (name) {
         buf_init_from_buf(&variable_entry->name, name);
 
@@ -3360,7 +3082,7 @@ static ZigVar *create_local_var(CodeGen *codegen, AstNode *node, Scope *parent_s
     variable_entry->src_is_const = src_is_const;
     variable_entry->gen_is_const = gen_is_const;
     variable_entry->decl_node = node;
-    variable_entry->child_scope = create_var_scope(node, parent_scope, variable_entry);
+    variable_entry->child_scope = create_var_scope(codegen, node, parent_scope, variable_entry);
 
     return variable_entry;
 }
@@ -3388,7 +3110,7 @@ static IrInstruction *ir_gen_block(IrBuilder *irb, Scope *parent_scope, AstNode
     ZigList<IrInstruction *> incoming_values = {0};
     ZigList<IrBasicBlock *> incoming_blocks = {0};
 
-    ScopeBlock *scope_block = create_block_scope(block_node, parent_scope);
+    ScopeBlock *scope_block = create_block_scope(irb->codegen, block_node, parent_scope);
 
     Scope *outer_block_scope = &scope_block->base;
     Scope *child_scope = outer_block_scope;
@@ -4065,26 +3787,6 @@ static IrInstruction *ir_gen_builtin_fn_call(IrBuilder *irb, Scope *scope, AstNo
                 IrInstruction *c_undef = ir_build_c_undef(irb, scope, node, arg0_value);
                 return ir_lval_wrap(irb, scope, c_undef, lval);
             }
-        case BuiltinFnIdMaxValue:
-            {
-                AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
-                IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
-                if (arg0_value == irb->codegen->invalid_instruction)
-                    return arg0_value;
-
-                IrInstruction *max_value = ir_build_max_value(irb, scope, node, arg0_value);
-                return ir_lval_wrap(irb, scope, max_value, lval);
-            }
-        case BuiltinFnIdMinValue:
-            {
-                AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
-                IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
-                if (arg0_value == irb->codegen->invalid_instruction)
-                    return arg0_value;
-
-                IrInstruction *min_value = ir_build_min_value(irb, scope, node, arg0_value);
-                return ir_lval_wrap(irb, scope, min_value, lval);
-            }
         case BuiltinFnIdCompileErr:
             {
                 AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
@@ -4688,7 +4390,7 @@ static IrInstruction *ir_gen_builtin_fn_call(IrBuilder *irb, Scope *scope, AstNo
                 IrInstruction *field_parent_ptr = ir_build_field_parent_ptr(irb, scope, node, arg0_value, arg1_value, arg2_value, nullptr);
                 return ir_lval_wrap(irb, scope, field_parent_ptr, lval);
             }
-        case BuiltinFnIdOffsetOf:
+        case BuiltinFnIdByteOffsetOf:
             {
                 AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
                 IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
@@ -4700,7 +4402,22 @@ static IrInstruction *ir_gen_builtin_fn_call(IrBuilder *irb, Scope *scope, AstNo
                 if (arg1_value == irb->codegen->invalid_instruction)
                     return arg1_value;
 
-                IrInstruction *offset_of = ir_build_offset_of(irb, scope, node, arg0_value, arg1_value);
+                IrInstruction *offset_of = ir_build_byte_offset_of(irb, scope, node, arg0_value, arg1_value);
+                return ir_lval_wrap(irb, scope, offset_of, lval);
+            }
+        case BuiltinFnIdBitOffsetOf:
+            {
+                AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
+                IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
+                if (arg0_value == irb->codegen->invalid_instruction)
+                    return arg0_value;
+
+                AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
+                IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
+                if (arg1_value == irb->codegen->invalid_instruction)
+                    return arg1_value;
+
+                IrInstruction *offset_of = ir_build_bit_offset_of(irb, scope, node, arg0_value, arg1_value);
                 return ir_lval_wrap(irb, scope, offset_of, lval);
             }
         case BuiltinFnIdInlineCall:
@@ -5026,7 +4743,7 @@ static IrInstruction *ir_gen_if_bool_expr(IrBuilder *irb, Scope *scope, AstNode
 
     ir_set_cursor_at_end_and_append_block(irb, then_block);
 
-    Scope *subexpr_scope = create_runtime_scope(node, scope, is_comptime);
+    Scope *subexpr_scope = create_runtime_scope(irb->codegen, node, scope, is_comptime);
     IrInstruction *then_expr_result = ir_gen_node(irb, then_node, subexpr_scope);
     if (then_expr_result == irb->codegen->invalid_instruction)
         return then_expr_result;
@@ -5118,26 +4835,26 @@ static IrInstruction *ir_gen_pointer_type(IrBuilder *irb, Scope *scope, AstNode
         bit_offset_start = bigint_as_unsigned(node->data.pointer_type.bit_offset_start);
     }
 
-    uint32_t bit_offset_end = 0;
-    if (node->data.pointer_type.bit_offset_end != nullptr) {
-        if (!bigint_fits_in_bits(node->data.pointer_type.bit_offset_end, 32, false)) {
+    uint32_t host_int_bytes = 0;
+    if (node->data.pointer_type.host_int_bytes != nullptr) {
+        if (!bigint_fits_in_bits(node->data.pointer_type.host_int_bytes, 32, false)) {
             Buf *val_buf = buf_alloc();
-            bigint_append_buf(val_buf, node->data.pointer_type.bit_offset_end, 10);
+            bigint_append_buf(val_buf, node->data.pointer_type.host_int_bytes, 10);
             exec_add_error_node(irb->codegen, irb->exec, node,
-                    buf_sprintf("value %s too large for u32 bit offset", buf_ptr(val_buf)));
+                    buf_sprintf("value %s too large for u32 byte count", buf_ptr(val_buf)));
             return irb->codegen->invalid_instruction;
         }
-        bit_offset_end = bigint_as_unsigned(node->data.pointer_type.bit_offset_end);
+        host_int_bytes = bigint_as_unsigned(node->data.pointer_type.host_int_bytes);
     }
 
-    if ((bit_offset_start != 0 || bit_offset_end != 0) && bit_offset_start >= bit_offset_end) {
+    if (host_int_bytes != 0 && bit_offset_start >= host_int_bytes * 8) {
         exec_add_error_node(irb->codegen, irb->exec, node,
-                buf_sprintf("bit offset start must be less than bit offset end"));
+                buf_sprintf("bit offset starts after end of host integer"));
         return irb->codegen->invalid_instruction;
     }
 
     return ir_build_ptr_type(irb, scope, node, child_type, is_const, is_volatile,
-            ptr_len, align_value, bit_offset_start, bit_offset_end);
+            ptr_len, align_value, bit_offset_start, host_int_bytes);
 }
 
 static IrInstruction *ir_gen_err_assert_ok(IrBuilder *irb, Scope *scope, AstNode *source_node, AstNode *expr_node,
@@ -5318,7 +5035,7 @@ static IrInstruction *ir_gen_while_expr(IrBuilder *irb, Scope *scope, AstNode *n
         ir_should_inline(irb->exec, scope) || node->data.while_expr.is_inline);
     ir_build_br(irb, scope, node, cond_block, is_comptime);
 
-    Scope *subexpr_scope = create_runtime_scope(node, scope, is_comptime);
+    Scope *subexpr_scope = create_runtime_scope(irb->codegen, node, scope, is_comptime);
     Buf *var_symbol = node->data.while_expr.var_symbol;
     Buf *err_symbol = node->data.while_expr.err_symbol;
     if (err_symbol != nullptr) {
@@ -5359,7 +5076,7 @@ static IrInstruction *ir_gen_while_expr(IrBuilder *irb, Scope *scope, AstNode *n
         ZigList<IrInstruction *> incoming_values = {0};
         ZigList<IrBasicBlock *> incoming_blocks = {0};
 
-        ScopeLoop *loop_scope = create_loop_scope(node, payload_scope);
+        ScopeLoop *loop_scope = create_loop_scope(irb->codegen, node, payload_scope);
         loop_scope->break_block = end_block;
         loop_scope->continue_block = continue_block;
         loop_scope->is_comptime = is_comptime;
@@ -5384,24 +5101,22 @@ static IrInstruction *ir_gen_while_expr(IrBuilder *irb, Scope *scope, AstNode *n
                 ir_mark_gen(ir_build_br(irb, payload_scope, node, cond_block, is_comptime));
         }
 
-        IrInstruction *else_result = nullptr;
-        if (else_node) {
-            ir_set_cursor_at_end_and_append_block(irb, else_block);
+        ir_set_cursor_at_end_and_append_block(irb, else_block);
+        assert(else_node != nullptr);
 
-            // TODO make it an error to write to error variable
-            AstNode *err_symbol_node = else_node; // TODO make more accurate
-            ZigVar *err_var = ir_create_var(irb, err_symbol_node, scope, err_symbol,
-                    true, false, false, is_comptime);
-            Scope *err_scope = err_var->child_scope;
-            IrInstruction *err_var_value = ir_build_unwrap_err_code(irb, err_scope, err_symbol_node, err_val_ptr);
-            ir_build_var_decl(irb, err_scope, symbol_node, err_var, nullptr, nullptr, err_var_value);
+        // TODO make it an error to write to error variable
+        AstNode *err_symbol_node = else_node; // TODO make more accurate
+        ZigVar *err_var = ir_create_var(irb, err_symbol_node, scope, err_symbol,
+                true, false, false, is_comptime);
+        Scope *err_scope = err_var->child_scope;
+        IrInstruction *err_var_value = ir_build_unwrap_err_code(irb, err_scope, err_symbol_node, err_val_ptr);
+        ir_build_var_decl(irb, err_scope, symbol_node, err_var, nullptr, nullptr, err_var_value);
 
-            else_result = ir_gen_node(irb, else_node, err_scope);
-            if (else_result == irb->codegen->invalid_instruction)
-                return else_result;
-            if (!instr_is_unreachable(else_result))
-                ir_mark_gen(ir_build_br(irb, scope, node, end_block, is_comptime));
-        }
+        IrInstruction *else_result = ir_gen_node(irb, else_node, err_scope);
+        if (else_result == irb->codegen->invalid_instruction)
+            return else_result;
+        if (!instr_is_unreachable(else_result))
+            ir_mark_gen(ir_build_br(irb, scope, node, end_block, is_comptime));
         IrBasicBlock *after_else_block = irb->current_basic_block;
         ir_set_cursor_at_end_and_append_block(irb, end_block);
         if (else_result) {
@@ -5415,7 +5130,7 @@ static IrInstruction *ir_gen_while_expr(IrBuilder *irb, Scope *scope, AstNode *n
         return ir_build_phi(irb, scope, node, incoming_blocks.length, incoming_blocks.items, incoming_values.items);
     } else if (var_symbol != nullptr) {
         ir_set_cursor_at_end_and_append_block(irb, cond_block);
-        Scope *subexpr_scope = create_runtime_scope(node, scope, is_comptime);
+        Scope *subexpr_scope = create_runtime_scope(irb->codegen, node, scope, is_comptime);
         // TODO make it an error to write to payload variable
         AstNode *symbol_node = node; // TODO make more accurate
 
@@ -5443,7 +5158,7 @@ static IrInstruction *ir_gen_while_expr(IrBuilder *irb, Scope *scope, AstNode *n
         ZigList<IrInstruction *> incoming_values = {0};
         ZigList<IrBasicBlock *> incoming_blocks = {0};
 
-        ScopeLoop *loop_scope = create_loop_scope(node, child_scope);
+        ScopeLoop *loop_scope = create_loop_scope(irb->codegen, node, child_scope);
         loop_scope->break_block = end_block;
         loop_scope->continue_block = continue_block;
         loop_scope->is_comptime = is_comptime;
@@ -5506,9 +5221,9 @@ static IrInstruction *ir_gen_while_expr(IrBuilder *irb, Scope *scope, AstNode *n
         ZigList<IrInstruction *> incoming_values = {0};
         ZigList<IrBasicBlock *> incoming_blocks = {0};
 
-        Scope *subexpr_scope = create_runtime_scope(node, scope, is_comptime);
+        Scope *subexpr_scope = create_runtime_scope(irb->codegen, node, scope, is_comptime);
 
-        ScopeLoop *loop_scope = create_loop_scope(node, subexpr_scope);
+        ScopeLoop *loop_scope = create_loop_scope(irb->codegen, node, subexpr_scope);
         loop_scope->break_block = end_block;
         loop_scope->continue_block = continue_block;
         loop_scope->is_comptime = is_comptime;
@@ -5645,7 +5360,7 @@ static IrInstruction *ir_gen_for_expr(IrBuilder *irb, Scope *parent_scope, AstNo
 
     ZigList<IrInstruction *> incoming_values = {0};
     ZigList<IrBasicBlock *> incoming_blocks = {0};
-    ScopeLoop *loop_scope = create_loop_scope(node, child_scope);
+    ScopeLoop *loop_scope = create_loop_scope(irb->codegen, node, child_scope);
     loop_scope->break_block = end_block;
     loop_scope->continue_block = continue_block;
     loop_scope->is_comptime = is_comptime;
@@ -5855,7 +5570,7 @@ static IrInstruction *ir_gen_test_expr(IrBuilder *irb, Scope *scope, AstNode *no
 
     ir_set_cursor_at_end_and_append_block(irb, then_block);
 
-    Scope *subexpr_scope = create_runtime_scope(node, scope, is_comptime);
+    Scope *subexpr_scope = create_runtime_scope(irb->codegen, node, scope, is_comptime);
     Scope *var_scope;
     if (var_symbol) {
         IrInstruction *var_type = nullptr;
@@ -5930,7 +5645,7 @@ static IrInstruction *ir_gen_if_err_expr(IrBuilder *irb, Scope *scope, AstNode *
 
     ir_set_cursor_at_end_and_append_block(irb, ok_block);
 
-    Scope *subexpr_scope = create_runtime_scope(node, scope, is_comptime);
+    Scope *subexpr_scope = create_runtime_scope(irb->codegen, node, scope, is_comptime);
     Scope *var_scope;
     if (var_symbol) {
         IrInstruction *var_type = nullptr;
@@ -6066,8 +5781,8 @@ static IrInstruction *ir_gen_switch_expr(IrBuilder *irb, Scope *scope, AstNode *
     ZigList<IrInstructionCheckSwitchProngsRange> check_ranges = {0};
 
     // First do the else and the ranges
-    Scope *subexpr_scope = create_runtime_scope(node, scope, is_comptime);
-    Scope *comptime_scope = create_comptime_scope(node, scope);
+    Scope *subexpr_scope = create_runtime_scope(irb->codegen, node, scope, is_comptime);
+    Scope *comptime_scope = create_comptime_scope(irb->codegen, node, scope);
     AstNode *else_prong = nullptr;
     for (size_t prong_i = 0; prong_i < prong_count; prong_i += 1) {
         AstNode *prong_node = node->data.switch_expr.prongs.at(prong_i);
@@ -6231,7 +5946,7 @@ static IrInstruction *ir_gen_switch_expr(IrBuilder *irb, Scope *scope, AstNode *
 static IrInstruction *ir_gen_comptime(IrBuilder *irb, Scope *parent_scope, AstNode *node, LVal lval) {
     assert(node->type == NodeTypeCompTime);
 
-    Scope *child_scope = create_comptime_scope(node, parent_scope);
+    Scope *child_scope = create_comptime_scope(irb->codegen, node, parent_scope);
     return ir_gen_node_extra(irb, node->data.comptime_expr.expr, child_scope, lval);
 }
 
@@ -6394,10 +6109,10 @@ static IrInstruction *ir_gen_error_type(IrBuilder *irb, Scope *scope, AstNode *n
 static IrInstruction *ir_gen_defer(IrBuilder *irb, Scope *parent_scope, AstNode *node) {
     assert(node->type == NodeTypeDefer);
 
-    ScopeDefer *defer_child_scope = create_defer_scope(node, parent_scope);
+    ScopeDefer *defer_child_scope = create_defer_scope(irb->codegen, node, parent_scope);
     node->data.defer.child_scope = &defer_child_scope->base;
 
-    ScopeDeferExpr *defer_expr_scope = create_defer_expr_scope(node, parent_scope);
+    ScopeDeferExpr *defer_expr_scope = create_defer_expr_scope(irb->codegen, node, parent_scope);
     node->data.defer.expr_scope = &defer_expr_scope->base;
 
     return ir_build_const_void(irb, parent_scope, node);
@@ -6573,7 +6288,7 @@ static ZigType *get_error_set_union(CodeGen *g, ErrorTableEntry **errors, ZigTyp
 
     ZigType *err_set_type = new_type_table_entry(ZigTypeIdErrorSet);
     buf_resize(&err_set_type->name, 0);
-    buf_appendf(&err_set_type->name, "error{");
+    buf_appendf(&err_set_type->name, "error.{");
 
     for (uint32_t i = 0, count = set1->data.error_set.err_count; i < count; i += 1) {
         assert(errors[set1->data.error_set.errors[i]->value] == set1->data.error_set.errors[i]);
@@ -6625,7 +6340,7 @@ static ZigType *make_err_set_with_one_item(CodeGen *g, Scope *parent_scope, AstN
 {
     ZigType *err_set_type = new_type_table_entry(ZigTypeIdErrorSet);
     buf_resize(&err_set_type->name, 0);
-    buf_appendf(&err_set_type->name, "error{%s}", buf_ptr(&err_entry->name));
+    buf_appendf(&err_set_type->name, "error.{%s}", buf_ptr(&err_entry->name));
     err_set_type->is_copyable = true;
     err_set_type->type_ref = g->builtin_types.entry_global_error_set->type_ref;
     err_set_type->di_type = g->builtin_types.entry_global_error_set->di_type;
@@ -7154,7 +6869,7 @@ static IrInstruction *ir_gen_suspend(IrBuilder *irb, Scope *parent_scope, AstNod
         suspend_code = ir_build_coro_suspend(irb, parent_scope, node, nullptr, const_bool_false);
     } else {
         Scope *child_scope;
-        ScopeSuspend *suspend_scope = create_suspend_scope(node, parent_scope);
+        ScopeSuspend *suspend_scope = create_suspend_scope(irb->codegen, node, parent_scope);
         suspend_scope->resume_block = resume_block;
         child_scope = &suspend_scope->base;
         IrInstruction *save_token = ir_build_coro_save(irb, child_scope, node, irb->exec->coro_handle);
@@ -7370,7 +7085,7 @@ bool ir_gen(CodeGen *codegen, AstNode *node, Scope *scope, IrExecutable *ir_exec
     ZigVar *coro_size_var;
     if (is_async) {
         // create the coro promise
-        Scope *coro_scope = create_coro_prelude_scope(node, scope);
+        Scope *coro_scope = create_coro_prelude_scope(irb->codegen, node, scope);
         const_bool_false = ir_build_const_bool(irb, coro_scope, node, false);
         ZigVar *promise_var = ir_create_var(irb, node, coro_scope, nullptr, false, false, true, const_bool_false);
 
@@ -8481,7 +8196,7 @@ static ZigType *get_error_set_intersection(IrAnalyze *ira, ZigType *set1, ZigTyp
 
     ZigType *err_set_type = new_type_table_entry(ZigTypeIdErrorSet);
     buf_resize(&err_set_type->name, 0);
-    buf_appendf(&err_set_type->name, "error{");
+    buf_appendf(&err_set_type->name, "error.{");
 
     for (uint32_t i = 0; i < set2->data.error_set.err_count; i += 1) {
         ErrorTableEntry *error_entry = set2->data.error_set.errors[i];
@@ -8539,17 +8254,6 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, ZigType *wanted
         return result;
     }
 
-    // *T and [*]T can always cast to *c_void
-    if (wanted_type->id == ZigTypeIdPointer &&
-        wanted_type->data.pointer.ptr_len == PtrLenSingle &&
-        wanted_type->data.pointer.child_type == g->builtin_types.entry_c_void &&
-        actual_type->id == ZigTypeIdPointer &&
-        (!actual_type->data.pointer.is_const || wanted_type->data.pointer.is_const) &&
-        (!actual_type->data.pointer.is_volatile || wanted_type->data.pointer.is_volatile))
-    {
-        return result;
-    }
-
     // pointer const
     if (wanted_type->id == ZigTypeIdPointer && actual_type->id == ZigTypeIdPointer) {
         ConstCastOnly child = types_match_const_cast_only(ira, wanted_type->data.pointer.child_type,
@@ -8575,8 +8279,8 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, ZigType *wanted
         if ((actual_type->data.pointer.ptr_len == wanted_type->data.pointer.ptr_len) &&
             (!actual_type->data.pointer.is_const || wanted_type->data.pointer.is_const) &&
             (!actual_type->data.pointer.is_volatile || wanted_type->data.pointer.is_volatile) &&
-            actual_type->data.pointer.bit_offset == wanted_type->data.pointer.bit_offset &&
-            actual_type->data.pointer.unaligned_bit_count == wanted_type->data.pointer.unaligned_bit_count &&
+            actual_type->data.pointer.bit_offset_in_host == wanted_type->data.pointer.bit_offset_in_host &&
+            actual_type->data.pointer.host_int_bytes == wanted_type->data.pointer.host_int_bytes &&
             get_ptr_align(ira->codegen, actual_type) >= get_ptr_align(ira->codegen, wanted_type))
         {
             return result;
@@ -8597,8 +8301,8 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, ZigType *wanted
         }
         if ((!actual_ptr_type->data.pointer.is_const || wanted_ptr_type->data.pointer.is_const) &&
             (!actual_ptr_type->data.pointer.is_volatile || wanted_ptr_type->data.pointer.is_volatile) &&
-            actual_ptr_type->data.pointer.bit_offset == wanted_ptr_type->data.pointer.bit_offset &&
-            actual_ptr_type->data.pointer.unaligned_bit_count == wanted_ptr_type->data.pointer.unaligned_bit_count &&
+            actual_ptr_type->data.pointer.bit_offset_in_host == wanted_ptr_type->data.pointer.bit_offset_in_host &&
+            actual_ptr_type->data.pointer.host_int_bytes == wanted_ptr_type->data.pointer.host_int_bytes &&
             get_ptr_align(g, actual_ptr_type) >= get_ptr_align(g, wanted_ptr_type))
         {
             ConstCastOnly child = types_match_const_cast_only(ira, wanted_ptr_type->data.pointer.child_type,
@@ -9319,9 +9023,15 @@ static ZigType *ir_resolve_peer_types(IrAnalyze *ira, AstNode *source_node, ZigT
         if (prev_inst->value.type->id == ZigTypeIdErrorSet) {
             return err_set_type;
         } else if (prev_inst->value.type->id == ZigTypeIdErrorUnion) {
-            return get_error_union_type(ira->codegen, err_set_type, prev_inst->value.type->data.error_union.payload_type);
+            ZigType *payload_type = prev_inst->value.type->data.error_union.payload_type;
+            if ((err = type_resolve(ira->codegen, payload_type, ResolveStatusSizeKnown)))
+                return ira->codegen->builtin_types.entry_invalid;
+            return get_error_union_type(ira->codegen, err_set_type, payload_type);
         } else if (expected_type != nullptr && expected_type->id == ZigTypeIdErrorUnion) {
-            return get_error_union_type(ira->codegen, err_set_type, expected_type->data.error_union.payload_type);
+            ZigType *payload_type = expected_type->data.error_union.payload_type;
+            if ((err = type_resolve(ira->codegen, payload_type, ResolveStatusSizeKnown)))
+                return ira->codegen->builtin_types.entry_invalid;
+            return get_error_union_type(ira->codegen, err_set_type, payload_type);
         } else {
             if (prev_inst->value.type->id == ZigTypeIdComptimeInt ||
                 prev_inst->value.type->id == ZigTypeIdComptimeFloat)
@@ -9334,6 +9044,8 @@ static ZigType *ir_resolve_peer_types(IrAnalyze *ira, AstNode *source_node, ZigT
                     buf_sprintf("unable to make error union out of null literal"));
                 return ira->codegen->builtin_types.entry_invalid;
             } else {
+                if ((err = type_resolve(ira->codegen, prev_inst->value.type, ResolveStatusSizeKnown)))
+                    return ira->codegen->builtin_types.entry_invalid;
                 return get_error_union_type(ira->codegen, err_set_type, prev_inst->value.type);
             }
         }
@@ -9658,10 +9370,10 @@ static void ir_finish_bb(IrAnalyze *ira) {
     }
 }
 
-static ZigType *ir_unreach_error(IrAnalyze *ira) {
+static IrInstruction *ir_unreach_error(IrAnalyze *ira) {
     ira->old_bb_index = SIZE_MAX;
     ira->new_irb.exec->invalid = true;
-    return ira->codegen->builtin_types.entry_unreachable;
+    return ira->codegen->unreach_instruction;
 }
 
 static bool ir_emit_backward_branch(IrAnalyze *ira, IrInstruction *source_instruction) {
@@ -9681,7 +9393,7 @@ static bool ir_emit_backward_branch(IrAnalyze *ira, IrInstruction *source_instru
     return true;
 }
 
-static ZigType *ir_inline_bb(IrAnalyze *ira, IrInstruction *source_instruction, IrBasicBlock *old_bb) {
+static IrInstruction *ir_inline_bb(IrAnalyze *ira, IrInstruction *source_instruction, IrBasicBlock *old_bb) {
     if (old_bb->debug_id <= ira->old_irb.current_basic_block->debug_id) {
         if (!ir_emit_backward_branch(ira, source_instruction))
             return ir_unreach_error(ira);
@@ -9689,32 +9401,50 @@ static ZigType *ir_inline_bb(IrAnalyze *ira, IrInstruction *source_instruction,
 
     old_bb->other = ira->old_irb.current_basic_block->other;
     ir_start_bb(ira, old_bb, ira->old_irb.current_basic_block);
-    return ira->codegen->builtin_types.entry_unreachable;
+    return ira->codegen->unreach_instruction;
 }
 
-static ZigType *ir_finish_anal(IrAnalyze *ira, ZigType *result_type) {
-    if (result_type->id == ZigTypeIdUnreachable)
+static IrInstruction *ir_finish_anal(IrAnalyze *ira, IrInstruction *instruction) {
+    if (instruction->value.type->id == ZigTypeIdUnreachable)
         ir_finish_bb(ira);
-    return result_type;
+    return instruction;
 }
 
-static IrInstruction *ir_get_const(IrAnalyze *ira, IrInstruction *old_instruction) {
+static IrInstruction *ir_const(IrAnalyze *ira, IrInstruction *old_instruction, ZigType *ty) {
     IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(&ira->new_irb,
             old_instruction->scope, old_instruction->source_node);
     IrInstruction *new_instruction = &const_instruction->base;
+    new_instruction->value.type = ty;
     new_instruction->value.special = ConstValSpecialStatic;
     return new_instruction;
 }
 
-static ConstExprValue *ir_build_const_from(IrAnalyze *ira, IrInstruction *old_instruction) {
-    IrInstruction *new_instruction = ir_get_const(ira, old_instruction);
-    ir_link_new_instruction(new_instruction, old_instruction);
-    return &new_instruction->value;
+static IrInstruction *ir_const_type(IrAnalyze *ira, IrInstruction *source_instruction, ZigType *ty) {
+    IrInstruction *result = ir_const(ira, source_instruction, ira->codegen->builtin_types.entry_type);
+    result->value.data.x_type = ty;
+    return result;
 }
 
-static ZigType *ir_analyze_void(IrAnalyze *ira, IrInstruction *instruction) {
-    ir_build_const_from(ira, instruction);
-    return ira->codegen->builtin_types.entry_void;
+static IrInstruction *ir_const_bool(IrAnalyze *ira, IrInstruction *source_instruction, bool value) {
+    IrInstruction *result = ir_const(ira, source_instruction, ira->codegen->builtin_types.entry_bool);
+    result->value.data.x_bool = value;
+    return result;
+}
+
+static IrInstruction *ir_const_void(IrAnalyze *ira, IrInstruction *source_instruction) {
+    return ir_const(ira, source_instruction, ira->codegen->builtin_types.entry_void);
+}
+
+static IrInstruction *ir_const_unsigned(IrAnalyze *ira, IrInstruction *source_instruction, uint64_t value) {
+    IrInstruction *result = ir_const(ira, source_instruction, ira->codegen->builtin_types.entry_num_lit_int);
+    bigint_init_unsigned(&result->value.data.x_bigint, value);
+    return result;
+}
+
+static IrInstruction *ir_const_usize(IrAnalyze *ira, IrInstruction *source_instruction, uint64_t value) {
+    IrInstruction *result = ir_const(ira, source_instruction, ira->codegen->builtin_types.entry_usize);
+    bigint_init_unsigned(&result->value.data.x_bigint, value);
+    return result;
 }
 
 static IrInstruction *ir_get_const_ptr(IrAnalyze *ira, IrInstruction *instruction,
@@ -9723,31 +9453,14 @@ static IrInstruction *ir_get_const_ptr(IrAnalyze *ira, IrInstruction *instructio
 {
     ZigType *ptr_type = get_pointer_to_type_extra(ira->codegen, pointee_type,
             ptr_is_const, ptr_is_volatile, PtrLenSingle, ptr_align, 0, 0);
-    IrInstruction *const_instr = ir_get_const(ira, instruction);
+    IrInstruction *const_instr = ir_const(ira, instruction, ptr_type);
     ConstExprValue *const_val = &const_instr->value;
-    const_val->type = ptr_type;
     const_val->data.x_ptr.special = ConstPtrSpecialRef;
     const_val->data.x_ptr.mut = ptr_mut;
     const_val->data.x_ptr.data.ref.pointee = pointee;
     return const_instr;
 }
 
-static ZigType *ir_analyze_const_ptr(IrAnalyze *ira, IrInstruction *instruction,
-        ConstExprValue *pointee, ZigType *pointee_type,
-        ConstPtrMut ptr_mut, bool ptr_is_const, bool ptr_is_volatile)
-{
-    IrInstruction *const_instr = ir_get_const_ptr(ira, instruction, pointee,
-            pointee_type, ptr_mut, ptr_is_const, ptr_is_volatile, 0);
-    ir_link_new_instruction(const_instr, instruction);
-    return const_instr->value.type;
-}
-
-static ZigType *ir_analyze_const_usize(IrAnalyze *ira, IrInstruction *instruction, uint64_t value) {
-    ConstExprValue *const_val = ir_build_const_from(ira, instruction);
-    bigint_init_unsigned(&const_val->data.x_bigint, value);
-    return ira->codegen->builtin_types.entry_usize;
-}
-
 enum UndefAllowed {
     UndefOk,
     UndefBad,
@@ -9840,6 +9553,7 @@ static ZigType *ir_resolve_type(IrAnalyze *ira, IrInstruction *type_value) {
     if (!const_val)
         return ira->codegen->builtin_types.entry_invalid;
 
+    assert(const_val->data.x_type != nullptr);
     return const_val->data.x_type;
 }
 
@@ -9996,46 +9710,6 @@ static IrInstruction *ir_analyze_err_wrap_code(IrAnalyze *ira, IrInstruction *so
     return result;
 }
 
-static IrInstruction *ir_analyze_cast_ref(IrAnalyze *ira, IrInstruction *source_instr,
-        IrInstruction *value, ZigType *wanted_type)
-{
-    if (instr_is_comptime(value)) {
-        ConstExprValue *val = ir_resolve_const(ira, value, UndefBad);
-        if (!val)
-            return ira->codegen->invalid_instruction;
-
-        IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(&ira->new_irb,
-                source_instr->scope, source_instr->source_node);
-        const_instruction->base.value.type = wanted_type;
-        const_instruction->base.value.special = ConstValSpecialStatic;
-        const_instruction->base.value.data.x_ptr.special = ConstPtrSpecialRef;
-        const_instruction->base.value.data.x_ptr.data.ref.pointee = val;
-        return &const_instruction->base;
-    }
-
-    if (value->id == IrInstructionIdLoadPtr) {
-        IrInstructionLoadPtr *load_ptr_inst = (IrInstructionLoadPtr *)value;
-        ConstCastOnly const_cast_result = types_match_const_cast_only(ira, wanted_type,
-                load_ptr_inst->ptr->value.type, source_instr->source_node, false);
-        if (const_cast_result.id == ConstCastResultIdInvalid)
-            return ira->codegen->invalid_instruction;
-        if (const_cast_result.id == ConstCastResultIdOk)
-            return load_ptr_inst->ptr;
-    }
-    IrInstruction *new_instruction = ir_build_ref(&ira->new_irb, source_instr->scope,
-            source_instr->source_node, value, true, false);
-    new_instruction->value.type = wanted_type;
-
-    ZigType *child_type = wanted_type->data.pointer.child_type;
-    if (type_has_bits(child_type)) {
-        ZigFn *fn_entry = exec_fn_entry(ira->new_irb.exec);
-        assert(fn_entry);
-        fn_entry->alloca_list.append(new_instruction);
-    }
-    ir_add_alloca(ira, new_instruction, child_type);
-    return new_instruction;
-}
-
 static IrInstruction *ir_analyze_null_to_maybe(IrAnalyze *ira, IrInstruction *source_instr, IrInstruction *value, ZigType *wanted_type) {
     assert(wanted_type->id == ZigTypeIdOptional);
     assert(instr_is_comptime(value));
@@ -10569,9 +10243,9 @@ static IrInstruction *ir_analyze_ptr_to_array(IrAnalyze *ira, IrInstruction *sou
             array_val->special = ConstValSpecialStatic;
             array_val->type = array_type;
             array_val->data.x_array.special = ConstArraySpecialNone;
-            array_val->data.x_array.s_none.elements = pointee;
-            array_val->data.x_array.s_none.parent.id = ConstParentIdScalar;
-            array_val->data.x_array.s_none.parent.data.p_scalar.scalar_val = pointee;
+            array_val->data.x_array.data.s_none.elements = pointee;
+            array_val->data.x_array.data.s_none.parent.id = ConstParentIdScalar;
+            array_val->data.x_array.data.s_none.parent.data.p_scalar.scalar_val = pointee;
 
             IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(&ira->new_irb,
                     source_instr->scope, source_instr->source_node);
@@ -10761,31 +10435,6 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
         }
     }
 
-    // cast from [N]T to *const []const T
-    if (wanted_type->id == ZigTypeIdPointer &&
-        wanted_type->data.pointer.is_const &&
-        is_slice(wanted_type->data.pointer.child_type) &&
-        actual_type->id == ZigTypeIdArray)
-    {
-        ZigType *ptr_type =
-            wanted_type->data.pointer.child_type->data.structure.fields[slice_ptr_index].type_entry;
-        assert(ptr_type->id == ZigTypeIdPointer);
-        if ((ptr_type->data.pointer.is_const || actual_type->data.array.len == 0) &&
-            types_match_const_cast_only(ira, ptr_type->data.pointer.child_type, actual_type->data.array.child_type,
-                source_node, false).id == ConstCastResultIdOk)
-        {
-            IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, wanted_type->data.pointer.child_type, value);
-            if (type_is_invalid(cast1->value.type))
-                return ira->codegen->invalid_instruction;
-
-            IrInstruction *cast2 = ir_analyze_cast(ira, source_instr, wanted_type, cast1);
-            if (type_is_invalid(cast2->value.type))
-                return ira->codegen->invalid_instruction;
-
-            return cast2;
-        }
-    }
-
     // cast from [N]T to ?[]const T
     if (wanted_type->id == ZigTypeIdOptional &&
         is_slice(wanted_type->data.maybe.child_type) &&
@@ -10838,8 +10487,11 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
     {
         ZigType *slice_ptr_type = wanted_type->data.structure.fields[slice_ptr_index].type_entry;
         assert(slice_ptr_type->id == ZigTypeIdPointer);
-        if (types_match_const_cast_only(ira, slice_ptr_type->data.pointer.child_type,
-            actual_type->data.pointer.child_type->data.array.child_type, source_node,
+        ZigType *array_type = actual_type->data.pointer.child_type;
+        bool const_ok = (slice_ptr_type->data.pointer.is_const || array_type->data.array.len == 0
+                || !actual_type->data.pointer.is_const);
+        if (const_ok && types_match_const_cast_only(ira, slice_ptr_type->data.pointer.child_type,
+            array_type->data.array.child_type, source_node,
             !slice_ptr_type->data.pointer.is_const).id == ConstCastResultIdOk)
         {
             return ir_resolve_ptr_of_array_to_slice(ira, source_instr, value, wanted_type);
@@ -10863,19 +10515,6 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
             } else {
                 return ira->codegen->invalid_instruction;
             }
-        } else if (wanted_child_type->id == ZigTypeIdPointer &&
-                   wanted_child_type->data.pointer.is_const &&
-                   (actual_type->id == ZigTypeIdPointer || is_container(actual_type)))
-        {
-            IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, wanted_child_type, value);
-            if (type_is_invalid(cast1->value.type))
-                return ira->codegen->invalid_instruction;
-
-            IrInstruction *cast2 = ir_analyze_cast(ira, source_instr, wanted_type, cast1);
-            if (type_is_invalid(cast2->value.type))
-                return ira->codegen->invalid_instruction;
-
-            return cast2;
         } else if (
             wanted_child_type->id == ZigTypeIdPointer &&
             wanted_child_type->data.pointer.ptr_len == PtrLenUnknown &&
@@ -10980,35 +10619,10 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
     }
 
     // cast from number literal to another type
-    // cast from number literal to *const integer
     if (actual_type->id == ZigTypeIdComptimeFloat ||
         actual_type->id == ZigTypeIdComptimeInt)
     {
-        if ((err = ensure_complete_type(ira->codegen, wanted_type)))
-            return ira->codegen->invalid_instruction;
-        if (wanted_type->id == ZigTypeIdEnum) {
-            IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, wanted_type->data.enumeration.tag_int_type, value);
-            if (type_is_invalid(cast1->value.type))
-                return ira->codegen->invalid_instruction;
-
-            IrInstruction *cast2 = ir_analyze_cast(ira, source_instr, wanted_type, cast1);
-            if (type_is_invalid(cast2->value.type))
-                return ira->codegen->invalid_instruction;
-
-            return cast2;
-        } else if (wanted_type->id == ZigTypeIdPointer &&
-            wanted_type->data.pointer.is_const)
-        {
-            IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, wanted_type->data.pointer.child_type, value);
-            if (type_is_invalid(cast1->value.type))
-                return ira->codegen->invalid_instruction;
-
-            IrInstruction *cast2 = ir_analyze_cast(ira, source_instr, wanted_type, cast1);
-            if (type_is_invalid(cast2->value.type))
-                return ira->codegen->invalid_instruction;
-
-            return cast2;
-        } else if (ir_num_lit_fits_in_other_type(ira, value, wanted_type, true)) {
+        if (ir_num_lit_fits_in_other_type(ira, value, wanted_type, true)) {
             CastOp op;
             if ((actual_type->id == ZigTypeIdComptimeFloat &&
                  wanted_type->id == ZigTypeIdFloat) ||
@@ -11061,29 +10675,6 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
         }
     }
 
-    // enum to *const union which has the enum as the tag type
-    if (actual_type->id == ZigTypeIdEnum && wanted_type->id == ZigTypeIdPointer) {
-        ZigType *union_type = wanted_type->data.pointer.child_type;
-        if (union_type->data.unionation.decl_node->data.container_decl.auto_enum ||
-            union_type->data.unionation.decl_node->data.container_decl.init_arg_expr != nullptr)
-        {
-            if ((err = type_resolve(ira->codegen, union_type, ResolveStatusZeroBitsKnown)))
-                return ira->codegen->invalid_instruction;
-
-            if (union_type->data.unionation.tag_type == actual_type) {
-                IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, union_type, value);
-                if (type_is_invalid(cast1->value.type))
-                    return ira->codegen->invalid_instruction;
-
-                IrInstruction *cast2 = ir_analyze_cast(ira, source_instr, wanted_type, cast1);
-                if (type_is_invalid(cast2->value.type))
-                    return ira->codegen->invalid_instruction;
-
-                return cast2;
-            }
-        }
-    }
-
     // cast from *T to *[1]T
     if (wanted_type->id == ZigTypeIdPointer && wanted_type->data.pointer.ptr_len == PtrLenSingle &&
         actual_type->id == ZigTypeIdPointer && actual_type->data.pointer.ptr_len == PtrLenSingle)
@@ -11118,6 +10709,33 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
         }
     }
 
+    // cast from *T and [*]T to *c_void and ?*c_void
+    // but don't do it if the actual type is a double pointer
+    if (actual_type->id == ZigTypeIdPointer && actual_type->data.pointer.child_type->id != ZigTypeIdPointer) {
+        ZigType *dest_ptr_type = nullptr;
+        if (wanted_type->id == ZigTypeIdPointer &&
+            wanted_type->data.pointer.ptr_len == PtrLenSingle &&
+            wanted_type->data.pointer.child_type == ira->codegen->builtin_types.entry_c_void)
+        {
+            dest_ptr_type = wanted_type;
+        } else if (wanted_type->id == ZigTypeIdOptional &&
+            wanted_type->data.maybe.child_type->id == ZigTypeIdPointer &&
+            wanted_type->data.maybe.child_type->data.pointer.ptr_len == PtrLenSingle &&
+            wanted_type->data.maybe.child_type->data.pointer.child_type == ira->codegen->builtin_types.entry_c_void)
+        {
+            dest_ptr_type = wanted_type->data.maybe.child_type;
+        }
+        if (dest_ptr_type != nullptr &&
+            (!actual_type->data.pointer.is_const || dest_ptr_type->data.pointer.is_const) &&
+            (!actual_type->data.pointer.is_volatile || dest_ptr_type->data.pointer.is_volatile) &&
+            actual_type->data.pointer.bit_offset_in_host == dest_ptr_type->data.pointer.bit_offset_in_host &&
+            actual_type->data.pointer.host_int_bytes == dest_ptr_type->data.pointer.host_int_bytes &&
+            get_ptr_align(ira->codegen, actual_type) >= get_ptr_align(ira->codegen, dest_ptr_type))
+        {
+            return ir_analyze_ptr_cast(ira, source_instr, value, wanted_type, source_instr);
+        }
+    }
+
     // cast from T to *T where T is zero bits
     if (wanted_type->id == ZigTypeIdPointer && wanted_type->data.pointer.ptr_len == PtrLenSingle &&
         types_match_const_cast_only(ira, wanted_type->data.pointer.child_type,
@@ -11137,14 +10755,6 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
         return ir_analyze_undefined_to_anything(ira, source_instr, value, wanted_type);
     }
 
-    // cast from something to const pointer of it
-    if (!type_requires_comptime(actual_type)) {
-        ZigType *const_ptr_actual = get_pointer_to_type(ira->codegen, actual_type, true);
-        if (types_match_const_cast_only(ira, wanted_type, const_ptr_actual, source_node, false).id == ConstCastResultIdOk) {
-            return ir_analyze_cast_ref(ira, source_instr, value, wanted_type);
-        }
-    }
-
     ErrorMsg *parent_msg = ir_add_error_node(ira, source_instr->source_node,
         buf_sprintf("expected type '%s', found '%s'",
             buf_ptr(&wanted_type->name),
@@ -11170,34 +10780,42 @@ static IrInstruction *ir_implicit_cast(IrAnalyze *ira, IrInstruction *value, Zig
 }
 
 static IrInstruction *ir_get_deref(IrAnalyze *ira, IrInstruction *source_instruction, IrInstruction *ptr) {
+    Error err;
     ZigType *type_entry = ptr->value.type;
     if (type_is_invalid(type_entry)) {
         return ira->codegen->invalid_instruction;
     } else if (type_entry->id == ZigTypeIdPointer) {
         ZigType *child_type = type_entry->data.pointer.child_type;
+        // dereferencing a *u0 is comptime known to be 0
+        if (child_type->id == ZigTypeIdInt && child_type->data.integral.bit_count == 0) {
+            IrInstruction *result = ir_create_const(&ira->new_irb, source_instruction->scope,
+                source_instruction->source_node, child_type);
+            init_const_unsigned_negative(&result->value, child_type, 0, false);
+            return result;
+        }
         if (instr_is_comptime(ptr)) {
+            if (ptr->value.special == ConstValSpecialUndef) {
+                ir_add_error(ira, ptr, buf_sprintf("attempt to dereference undefined value"));
+                return ira->codegen->invalid_instruction;
+            }
             if (ptr->value.data.x_ptr.mut == ConstPtrMutComptimeConst ||
                 ptr->value.data.x_ptr.mut == ConstPtrMutComptimeVar)
             {
-                ConstExprValue *pointee = ir_const_ptr_pointee(ira, &ptr->value, source_instruction->source_node);
-                if (pointee == nullptr)
-                    return ira->codegen->invalid_instruction;
+                ConstExprValue *pointee = const_ptr_pointee_unchecked(ira->codegen, &ptr->value);
                 if (pointee->special != ConstValSpecialRuntime) {
                     IrInstruction *result = ir_create_const(&ira->new_irb, source_instruction->scope,
                         source_instruction->source_node, child_type);
-                    copy_const_val(&result->value, pointee, ptr->value.data.x_ptr.mut == ConstPtrMutComptimeConst);
+
+                    if ((err = ir_read_const_ptr(ira, source_instruction->source_node, &result->value,
+                                    &ptr->value)))
+                    {
+                        return ira->codegen->invalid_instruction;
+                    }
                     result->value.type = child_type;
                     return result;
                 }
             }
         }
-        // dereferencing a *u0 is comptime known to be 0
-        if (child_type->id == ZigTypeIdInt && child_type->data.integral.bit_count == 0) {
-            IrInstruction *result = ir_create_const(&ira->new_irb, source_instruction->scope,
-                source_instruction->source_node, child_type);
-            init_const_unsigned_negative(&result->value, child_type, 0, false);
-            return result;
-        }
         // TODO if the instruction is a const ref instruction we can skip it
         IrInstruction *load_ptr_instruction = ir_build_load_ptr(&ira->new_irb, source_instruction->scope,
                 source_instruction->source_node, ptr);
@@ -11211,14 +10829,6 @@ static IrInstruction *ir_get_deref(IrAnalyze *ira, IrInstruction *source_instruc
     }
 }
 
-static ZigType *ir_analyze_ref(IrAnalyze *ira, IrInstruction *source_instruction, IrInstruction *value,
-        bool is_const, bool is_volatile)
-{
-    IrInstruction *result = ir_get_ref(ira, source_instruction, value, is_const, is_volatile);
-    ir_link_new_instruction(result, source_instruction);
-    return result->value.type;
-}
-
 static bool ir_resolve_align(IrAnalyze *ira, IrInstruction *value, uint32_t *out) {
     if (type_is_invalid(value->value.type))
         return false;
@@ -11391,13 +11001,16 @@ static Buf *ir_resolve_str(IrAnalyze *ira, IrInstruction *value) {
 
     assert(ptr_field->data.x_ptr.special == ConstPtrSpecialBaseArray);
     ConstExprValue *array_val = ptr_field->data.x_ptr.data.base_array.array_val;
+    if (array_val->data.x_array.special == ConstArraySpecialBuf) {
+        return array_val->data.x_array.data.s_buf;
+    }
     expand_undef_array(ira->codegen, array_val);
     size_t len = bigint_as_unsigned(&len_field->data.x_bigint);
     Buf *result = buf_alloc();
     buf_resize(result, len);
     for (size_t i = 0; i < len; i += 1) {
         size_t new_index = ptr_field->data.x_ptr.data.base_array.elem_index + i;
-        ConstExprValue *char_val = &array_val->data.x_array.s_none.elements[new_index];
+        ConstExprValue *char_val = &array_val->data.x_array.data.s_none.elements[new_index];
         if (char_val->special == ConstValSpecialUndef) {
             ir_add_error(ira, casted_value, buf_sprintf("use of undefined value"));
             return nullptr;
@@ -11410,29 +11023,25 @@ static Buf *ir_resolve_str(IrAnalyze *ira, IrInstruction *value) {
     return result;
 }
 
-static ZigType *ir_analyze_instruction_add_implicit_return_type(IrAnalyze *ira,
+static IrInstruction *ir_analyze_instruction_add_implicit_return_type(IrAnalyze *ira,
         IrInstructionAddImplicitReturnType *instruction)
 {
-    IrInstruction *value = instruction->value->other;
+    IrInstruction *value = instruction->value->child;
     if (type_is_invalid(value->value.type))
         return ir_unreach_error(ira);
 
     ira->src_implicit_return_type_list.append(value);
 
-    ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-    out_val->type = ira->codegen->builtin_types.entry_void;
-    return out_val->type;
+    return ir_const_void(ira, &instruction->base);
 }
 
-static ZigType *ir_analyze_instruction_return(IrAnalyze *ira,
-    IrInstructionReturn *return_instruction)
-{
-    IrInstruction *value = return_instruction->value->other;
+static IrInstruction *ir_analyze_instruction_return(IrAnalyze *ira, IrInstructionReturn *instruction) {
+    IrInstruction *value = instruction->value->child;
     if (type_is_invalid(value->value.type))
         return ir_unreach_error(ira);
 
     IrInstruction *casted_value = ir_implicit_cast(ira, value, ira->explicit_return_type);
-    if (casted_value == ira->codegen->invalid_instruction)
+    if (type_is_invalid(casted_value->value.type))
         return ir_unreach_error(ira);
 
     if (casted_value->value.special == ConstValSpecialRuntime &&
@@ -11442,63 +11051,65 @@ static ZigType *ir_analyze_instruction_return(IrAnalyze *ira,
         ir_add_error(ira, casted_value, buf_sprintf("function returns address of local variable"));
         return ir_unreach_error(ira);
     }
-    IrInstruction *result = ir_build_return(&ira->new_irb, return_instruction->base.scope,
-            return_instruction->base.source_node, casted_value);
+    IrInstruction *result = ir_build_return(&ira->new_irb, instruction->base.scope,
+            instruction->base.source_node, casted_value);
     result->value.type = ira->codegen->builtin_types.entry_unreachable;
-    ir_link_new_instruction(result, &return_instruction->base);
-    return ir_finish_anal(ira, result->value.type);
+    return ir_finish_anal(ira, result);
 }
 
-static ZigType *ir_analyze_instruction_const(IrAnalyze *ira, IrInstructionConst *const_instruction) {
-    ConstExprValue *out_val = ir_build_const_from(ira, &const_instruction->base);
-    *out_val = const_instruction->base.value;
-    return const_instruction->base.value.type;
+static IrInstruction *ir_analyze_instruction_const(IrAnalyze *ira, IrInstructionConst *instruction) {
+    IrInstruction *result = ir_const(ira, &instruction->base, nullptr);
+    // TODO determine if we need to use copy_const_val here
+    result->value = instruction->base.value;
+    return result;
 }
 
-static ZigType *ir_analyze_bin_op_bool(IrAnalyze *ira, IrInstructionBinOp *bin_op_instruction) {
-    IrInstruction *op1 = bin_op_instruction->op1->other;
+static IrInstruction *ir_analyze_bin_op_bool(IrAnalyze *ira, IrInstructionBinOp *bin_op_instruction) {
+    IrInstruction *op1 = bin_op_instruction->op1->child;
     if (type_is_invalid(op1->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *op2 = bin_op_instruction->op2->other;
+    IrInstruction *op2 = bin_op_instruction->op2->child;
     if (type_is_invalid(op2->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     ZigType *bool_type = ira->codegen->builtin_types.entry_bool;
 
     IrInstruction *casted_op1 = ir_implicit_cast(ira, op1, bool_type);
     if (casted_op1 == ira->codegen->invalid_instruction)
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     IrInstruction *casted_op2 = ir_implicit_cast(ira, op2, bool_type);
     if (casted_op2 == ira->codegen->invalid_instruction)
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (instr_is_comptime(casted_op1) && instr_is_comptime(casted_op2)) {
-        ConstExprValue *out_val = ir_build_const_from(ira, &bin_op_instruction->base);
         ConstExprValue *op1_val = ir_resolve_const(ira, casted_op1, UndefBad);
         if (op1_val == nullptr)
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
 
         ConstExprValue *op2_val = ir_resolve_const(ira, casted_op2, UndefBad);
         if (op2_val == nullptr)
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
 
         assert(casted_op1->value.type->id == ZigTypeIdBool);
         assert(casted_op2->value.type->id == ZigTypeIdBool);
+        bool result_bool;
         if (bin_op_instruction->op_id == IrBinOpBoolOr) {
-            out_val->data.x_bool = op1_val->data.x_bool || op2_val->data.x_bool;
+            result_bool = op1_val->data.x_bool || op2_val->data.x_bool;
         } else if (bin_op_instruction->op_id == IrBinOpBoolAnd) {
-            out_val->data.x_bool = op1_val->data.x_bool && op2_val->data.x_bool;
+            result_bool = op1_val->data.x_bool && op2_val->data.x_bool;
         } else {
             zig_unreachable();
         }
-        return bool_type;
+        return ir_const_bool(ira, &bin_op_instruction->base, result_bool);
     }
 
-    ir_build_bin_op_from(&ira->new_irb, &bin_op_instruction->base, bin_op_instruction->op_id,
-            casted_op1, casted_op2, bin_op_instruction->safety_check_on);
-    return bool_type;
+    IrInstruction *result = ir_build_bin_op(&ira->new_irb,
+            bin_op_instruction->base.scope, bin_op_instruction->base.source_node,
+            bin_op_instruction->op_id, casted_op1, casted_op2, bin_op_instruction->safety_check_on);
+    result->value.type = bool_type;
+    return result;
 }
 
 static bool resolve_cmp_op_id(IrBinOp op_id, Cmp cmp) {
@@ -11529,15 +11140,15 @@ static bool optional_value_is_null(ConstExprValue *val) {
     }
 }
 
-static ZigType *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstructionBinOp *bin_op_instruction) {
+static IrInstruction *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstructionBinOp *bin_op_instruction) {
     Error err;
-    IrInstruction *op1 = bin_op_instruction->op1->other;
+    IrInstruction *op1 = bin_op_instruction->op1->child;
     if (type_is_invalid(op1->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *op2 = bin_op_instruction->op2->other;
+    IrInstruction *op2 = bin_op_instruction->op2->child;
     if (type_is_invalid(op2->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     AstNode *source_node = bin_op_instruction->base.source_node;
 
@@ -11549,9 +11160,7 @@ static ZigType *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstructionBinOp *bin_op
         (op1->value.type->id == ZigTypeIdNull && op2->value.type->id == ZigTypeIdNull)))
     {
         if (op1->value.type->id == ZigTypeIdNull && op2->value.type->id == ZigTypeIdNull) {
-            ConstExprValue *out_val = ir_build_const_from(ira, &bin_op_instruction->base);
-            out_val->data.x_bool = (op_id == IrBinOpCmpEq);
-            return ira->codegen->builtin_types.entry_bool;
+            return ir_const_bool(ira, &bin_op_instruction->base, (op_id == IrBinOpCmpEq));
         }
         IrInstruction *maybe_op;
         if (op1->value.type->id == ZigTypeIdNull) {
@@ -11564,11 +11173,10 @@ static ZigType *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstructionBinOp *bin_op
         if (instr_is_comptime(maybe_op)) {
             ConstExprValue *maybe_val = ir_resolve_const(ira, maybe_op, UndefBad);
             if (!maybe_val)
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             bool is_null = optional_value_is_null(maybe_val);
-            ConstExprValue *out_val = ir_build_const_from(ira, &bin_op_instruction->base);
-            out_val->data.x_bool = (op_id == IrBinOpCmpEq) ? is_null : !is_null;
-            return ira->codegen->builtin_types.entry_bool;
+            bool bool_result = (op_id == IrBinOpCmpEq) ? is_null : !is_null;
+            return ir_const_bool(ira, &bin_op_instruction->base, bool_result);
         }
 
         IrInstruction *is_non_null = ir_build_test_nonnull(&ira->new_irb, bin_op_instruction->base.scope,
@@ -11576,28 +11184,30 @@ static ZigType *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstructionBinOp *bin_op
         is_non_null->value.type = ira->codegen->builtin_types.entry_bool;
 
         if (op_id == IrBinOpCmpEq) {
-            ir_build_bool_not_from(&ira->new_irb, &bin_op_instruction->base, is_non_null);
+            IrInstruction *result = ir_build_bool_not(&ira->new_irb, bin_op_instruction->base.scope,
+                bin_op_instruction->base.source_node, is_non_null);
+            result->value.type = ira->codegen->builtin_types.entry_bool;
+            return result;
         } else {
-            ir_link_new_instruction(is_non_null, &bin_op_instruction->base);
+            return is_non_null;
         }
-        return ira->codegen->builtin_types.entry_bool;
     } else if (op1->value.type->id == ZigTypeIdNull || op2->value.type->id == ZigTypeIdNull) {
         ir_add_error_node(ira, source_node, buf_sprintf("comparison against null can only be done with optionals"));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     if (op1->value.type->id == ZigTypeIdErrorSet && op2->value.type->id == ZigTypeIdErrorSet) {
         if (!is_equality_cmp) {
             ir_add_error_node(ira, source_node, buf_sprintf("operator not allowed for errors"));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
         ZigType *intersect_type = get_error_set_intersection(ira, op1->value.type, op2->value.type, source_node);
         if (type_is_invalid(intersect_type)) {
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
 
         if (!resolve_inferred_error_set(ira->codegen, intersect_type, source_node)) {
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
 
         // exception if one of the operators has the type of the empty error set, we allow the comparison
@@ -11614,9 +11224,7 @@ static ZigType *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstructionBinOp *bin_op
             } else {
                 zig_unreachable();
             }
-            ConstExprValue *out_val = ir_build_const_from(ira, &bin_op_instruction->base);
-            out_val->data.x_bool = answer;
-            return ira->codegen->builtin_types.entry_bool;
+            return ir_const_bool(ira, &bin_op_instruction->base, answer);
         }
 
         if (!type_is_global_error_set(intersect_type)) {
@@ -11624,7 +11232,7 @@ static ZigType *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstructionBinOp *bin_op
                 ir_add_error_node(ira, source_node,
                     buf_sprintf("error sets '%s' and '%s' have no common errors",
                         buf_ptr(&op1->value.type->name), buf_ptr(&op2->value.type->name)));
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             }
             if (op1->value.type->data.error_set.err_count == 1 && op2->value.type->data.error_set.err_count == 1) {
                 bool are_equal = true;
@@ -11636,19 +11244,17 @@ static ZigType *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstructionBinOp *bin_op
                 } else {
                     zig_unreachable();
                 }
-                ConstExprValue *out_val = ir_build_const_from(ira, &bin_op_instruction->base);
-                out_val->data.x_bool = answer;
-                return ira->codegen->builtin_types.entry_bool;
+                return ir_const_bool(ira, &bin_op_instruction->base, answer);
             }
         }
 
         if (instr_is_comptime(op1) && instr_is_comptime(op2)) {
             ConstExprValue *op1_val = ir_resolve_const(ira, op1, UndefBad);
             if (op1_val == nullptr)
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             ConstExprValue *op2_val = ir_resolve_const(ira, op2, UndefBad);
             if (op2_val == nullptr)
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
 
             bool answer;
             bool are_equal = op1_val->data.x_err_set->value == op2_val->data.x_err_set->value;
@@ -11660,21 +11266,20 @@ static ZigType *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstructionBinOp *bin_op
                 zig_unreachable();
             }
 
-            ConstExprValue *out_val = ir_build_const_from(ira, &bin_op_instruction->base);
-            out_val->data.x_bool = answer;
-            return ira->codegen->builtin_types.entry_bool;
+            return ir_const_bool(ira, &bin_op_instruction->base, answer);
         }
 
-        ir_build_bin_op_from(&ira->new_irb, &bin_op_instruction->base, op_id,
-                op1, op2, bin_op_instruction->safety_check_on);
-
-        return ira->codegen->builtin_types.entry_bool;
+        IrInstruction *result = ir_build_bin_op(&ira->new_irb,
+                bin_op_instruction->base.scope, bin_op_instruction->base.source_node,
+                op_id, op1, op2, bin_op_instruction->safety_check_on);
+        result->value.type = ira->codegen->builtin_types.entry_bool;
+        return result;
     }
 
     IrInstruction *instructions[] = {op1, op2};
     ZigType *resolved_type = ir_resolve_peer_types(ira, source_node, nullptr, instructions, 2);
     if (type_is_invalid(resolved_type))
-        return resolved_type;
+        return ira->codegen->invalid_instruction;
 
     bool operator_allowed;
     switch (resolved_type->id) {
@@ -11719,28 +11324,28 @@ static ZigType *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstructionBinOp *bin_op
     if (!operator_allowed) {
         ir_add_error_node(ira, source_node,
             buf_sprintf("operator not allowed for type '%s'", buf_ptr(&resolved_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     IrInstruction *casted_op1 = ir_implicit_cast(ira, op1, resolved_type);
     if (casted_op1 == ira->codegen->invalid_instruction)
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     IrInstruction *casted_op2 = ir_implicit_cast(ira, op2, resolved_type);
     if (casted_op2 == ira->codegen->invalid_instruction)
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if ((err = type_resolve(ira->codegen, resolved_type, ResolveStatusZeroBitsKnown)))
-        return resolved_type;
+        return ira->codegen->invalid_instruction;
 
     bool one_possible_value = !type_requires_comptime(resolved_type) && !type_has_bits(resolved_type);
     if (one_possible_value || (instr_is_comptime(casted_op1) && instr_is_comptime(casted_op2))) {
         ConstExprValue *op1_val = one_possible_value ? &casted_op1->value : ir_resolve_const(ira, casted_op1, UndefBad);
         if (op1_val == nullptr)
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         ConstExprValue *op2_val = one_possible_value ? &casted_op2->value : ir_resolve_const(ira, casted_op2, UndefBad);
         if (op2_val == nullptr)
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
 
         bool answer;
         if (resolved_type->id == ZigTypeIdComptimeFloat || resolved_type->id == ZigTypeIdFloat) {
@@ -11750,7 +11355,7 @@ static ZigType *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstructionBinOp *bin_op
             Cmp cmp_result = bigint_cmp(&op1_val->data.x_bigint, &op2_val->data.x_bigint);
             answer = resolve_cmp_op_id(op_id, cmp_result);
         } else {
-            bool are_equal = one_possible_value || const_values_equal(op1_val, op2_val);
+            bool are_equal = one_possible_value || const_values_equal(ira->codegen, op1_val, op2_val);
             if (op_id == IrBinOpCmpEq) {
                 answer = are_equal;
             } else if (op_id == IrBinOpCmpNotEq) {
@@ -11760,9 +11365,7 @@ static ZigType *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstructionBinOp *bin_op
             }
         }
 
-        ConstExprValue *out_val = ir_build_const_from(ira, &bin_op_instruction->base);
-        out_val->data.x_bool = answer;
-        return ira->codegen->builtin_types.entry_bool;
+        return ir_const_bool(ira, &bin_op_instruction->base, answer);
     }
 
     // some comparisons with unsigned numbers can be evaluated
@@ -11772,13 +11375,13 @@ static ZigType *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstructionBinOp *bin_op
         if (instr_is_comptime(casted_op1)) {
             known_left_val = ir_resolve_const(ira, casted_op1, UndefBad);
             if (known_left_val == nullptr)
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
 
             flipped_op_id = op_id;
         } else if (instr_is_comptime(casted_op2)) {
             known_left_val = ir_resolve_const(ira, casted_op2, UndefBad);
             if (known_left_val == nullptr)
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
 
             if (op_id == IrBinOpCmpLessThan) {
                 flipped_op_id = IrBinOpCmpGreaterThan;
@@ -11798,16 +11401,15 @@ static ZigType *ir_analyze_bin_op_cmp(IrAnalyze *ira, IrInstructionBinOp *bin_op
             (flipped_op_id == IrBinOpCmpLessOrEq || flipped_op_id == IrBinOpCmpGreaterThan))
         {
             bool answer = (flipped_op_id == IrBinOpCmpLessOrEq);
-            ConstExprValue *out_val = ir_build_const_from(ira, &bin_op_instruction->base);
-            out_val->data.x_bool = answer;
-            return ira->codegen->builtin_types.entry_bool;
+            return ir_const_bool(ira, &bin_op_instruction->base, answer);
         }
     }
 
-    ir_build_bin_op_from(&ira->new_irb, &bin_op_instruction->base, op_id,
-            casted_op1, casted_op2, bin_op_instruction->safety_check_on);
-
-    return ira->codegen->builtin_types.entry_bool;
+    IrInstruction *result = ir_build_bin_op(&ira->new_irb,
+            bin_op_instruction->base.scope, bin_op_instruction->base.source_node,
+            op_id, casted_op1, casted_op2, bin_op_instruction->safety_check_on);
+    result->value.type = ira->codegen->builtin_types.entry_bool;
+    return result;
 }
 
 static int ir_eval_math_op(ZigType *type_entry, ConstExprValue *op1_val,
@@ -11990,21 +11592,21 @@ static int ir_eval_math_op(ZigType *type_entry, ConstExprValue *op1_val,
     return 0;
 }
 
-static ZigType *ir_analyze_bit_shift(IrAnalyze *ira, IrInstructionBinOp *bin_op_instruction) {
-    IrInstruction *op1 = bin_op_instruction->op1->other;
+static IrInstruction *ir_analyze_bit_shift(IrAnalyze *ira, IrInstructionBinOp *bin_op_instruction) {
+    IrInstruction *op1 = bin_op_instruction->op1->child;
     if (type_is_invalid(op1->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (op1->value.type->id != ZigTypeIdInt && op1->value.type->id != ZigTypeIdComptimeInt) {
         ir_add_error(ira, &bin_op_instruction->base,
             buf_sprintf("bit shifting operation expected integer type, found '%s'",
                 buf_ptr(&op1->value.type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
-    IrInstruction *op2 = bin_op_instruction->op2->other;
+    IrInstruction *op2 = bin_op_instruction->op2->child;
     if (type_is_invalid(op2->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     IrInstruction *casted_op2;
     IrBinOp op_id = bin_op_instruction->op_id;
@@ -12019,7 +11621,7 @@ static ZigType *ir_analyze_bit_shift(IrAnalyze *ira, IrInstructionBinOp *bin_op_
             Buf *val_buf = buf_alloc();
             bigint_append_buf(val_buf, &casted_op2->value.data.x_bigint, 10);
             ir_add_error(ira, casted_op2, buf_sprintf("shift by negative value %s", buf_ptr(val_buf)));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
     } else {
         ZigType *shift_amt_type = get_smallest_unsigned_int_type(ira->codegen,
@@ -12041,71 +11643,70 @@ static ZigType *ir_analyze_bit_shift(IrAnalyze *ira, IrInstructionBinOp *bin_op_
                     buf_sprintf("value %s cannot fit into type %s",
                         buf_ptr(val_buf),
                         buf_ptr(&shift_amt_type->name)));
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             }
         }
 
         casted_op2 = ir_implicit_cast(ira, op2, shift_amt_type);
         if (casted_op2 == ira->codegen->invalid_instruction)
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
     }
 
     if (instr_is_comptime(op1) && instr_is_comptime(casted_op2)) {
         ConstExprValue *op1_val = ir_resolve_const(ira, op1, UndefBad);
         if (op1_val == nullptr)
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
 
         ConstExprValue *op2_val = ir_resolve_const(ira, casted_op2, UndefBad);
         if (op2_val == nullptr)
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
 
-        IrInstruction *result_instruction = ir_get_const(ira, &bin_op_instruction->base);
-        ir_link_new_instruction(result_instruction, &bin_op_instruction->base);
-        ConstExprValue *out_val = &result_instruction->value;
+        IrInstruction *result_instruction = ir_const(ira, &bin_op_instruction->base, op1->value.type);
 
         int err;
-        if ((err = ir_eval_math_op(op1->value.type, op1_val, op_id, op2_val, out_val))) {
+        if ((err = ir_eval_math_op(op1->value.type, op1_val, op_id, op2_val, &result_instruction->value))) {
             if (err == ErrorOverflow) {
                 ir_add_error(ira, &bin_op_instruction->base, buf_sprintf("operation caused overflow"));
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             } else if (err == ErrorShiftedOutOneBits) {
                 ir_add_error(ira, &bin_op_instruction->base, buf_sprintf("exact shift shifted out 1 bits"));
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             } else {
                 zig_unreachable();
             }
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
 
         ir_num_lit_fits_in_other_type(ira, result_instruction, op1->value.type, false);
-        return op1->value.type;
+        return result_instruction;
     } else if (op1->value.type->id == ZigTypeIdComptimeInt) {
         ir_add_error(ira, &bin_op_instruction->base,
                 buf_sprintf("LHS of shift must be an integer type, or RHS must be compile-time known"));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     } else if (instr_is_comptime(casted_op2) && bigint_cmp_zero(&casted_op2->value.data.x_bigint) == CmpEQ) {
         IrInstruction *result = ir_build_cast(&ira->new_irb, bin_op_instruction->base.scope,
                 bin_op_instruction->base.source_node, op1->value.type, op1, CastOpNoop);
         result->value.type = op1->value.type;
-        ir_link_new_instruction(result, &bin_op_instruction->base);
-        return result->value.type;
+        return result;
     }
 
-    ir_build_bin_op_from(&ira->new_irb, &bin_op_instruction->base, op_id,
+    IrInstruction *result = ir_build_bin_op(&ira->new_irb, bin_op_instruction->base.scope,
+            bin_op_instruction->base.source_node, op_id,
             op1, casted_op2, bin_op_instruction->safety_check_on);
-    return op1->value.type;
+    result->value.type = op1->value.type;
+    return result;
 }
 
-static ZigType *ir_analyze_bin_op_math(IrAnalyze *ira, IrInstructionBinOp *bin_op_instruction) {
-    IrInstruction *op1 = bin_op_instruction->op1->other;
+static IrInstruction *ir_analyze_bin_op_math(IrAnalyze *ira, IrInstructionBinOp *instruction) {
+    IrInstruction *op1 = instruction->op1->child;
     if (type_is_invalid(op1->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *op2 = bin_op_instruction->op2->other;
+    IrInstruction *op2 = instruction->op2->child;
     if (type_is_invalid(op2->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrBinOp op_id = bin_op_instruction->op_id;
+    IrBinOp op_id = instruction->op_id;
 
     // look for pointer math
     if (op1->value.type->id == ZigTypeIdPointer && op1->value.type->data.pointer.ptr_len == PtrLenUnknown &&
@@ -12113,19 +11714,18 @@ static ZigType *ir_analyze_bin_op_math(IrAnalyze *ira, IrInstructionBinOp *bin_o
     {
         IrInstruction *casted_op2 = ir_implicit_cast(ira, op2, ira->codegen->builtin_types.entry_usize);
         if (casted_op2 == ira->codegen->invalid_instruction)
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
 
-        IrInstruction *result = ir_build_bin_op(&ira->new_irb, bin_op_instruction->base.scope,
-                bin_op_instruction->base.source_node, op_id, op1, casted_op2, true);
+        IrInstruction *result = ir_build_bin_op(&ira->new_irb, instruction->base.scope,
+                instruction->base.source_node, op_id, op1, casted_op2, true);
         result->value.type = op1->value.type;
-        ir_link_new_instruction(result, &bin_op_instruction->base);
-        return result->value.type;
+        return result;
     }
 
     IrInstruction *instructions[] = {op1, op2};
-    ZigType *resolved_type = ir_resolve_peer_types(ira, bin_op_instruction->base.source_node, nullptr, instructions, 2);
+    ZigType *resolved_type = ir_resolve_peer_types(ira, instruction->base.source_node, nullptr, instructions, 2);
     if (type_is_invalid(resolved_type))
-        return resolved_type;
+        return ira->codegen->invalid_instruction;
 
     bool is_int = resolved_type->id == ZigTypeIdInt || resolved_type->id == ZigTypeIdComptimeInt;
     bool is_float = resolved_type->id == ZigTypeIdFloat || resolved_type->id == ZigTypeIdComptimeFloat;
@@ -12145,11 +11745,11 @@ static ZigType *ir_analyze_bin_op_math(IrAnalyze *ira, IrInstructionBinOp *bin_o
             if (instr_is_comptime(op1) && instr_is_comptime(op2)) {
                 ConstExprValue *op1_val = ir_resolve_const(ira, op1, UndefBad);
                 if (op1_val == nullptr)
-                    return ira->codegen->builtin_types.entry_invalid;
+                    return ira->codegen->invalid_instruction;
 
                 ConstExprValue *op2_val = ir_resolve_const(ira, op2, UndefBad);
                 if (op2_val == nullptr)
-                    return ira->codegen->builtin_types.entry_invalid;
+                    return ira->codegen->invalid_instruction;
 
                 if (bigint_cmp_zero(&op2_val->data.x_bigint) == CmpEQ) {
                     // the division by zero error will be caught later, but we don't have a
@@ -12168,11 +11768,11 @@ static ZigType *ir_analyze_bin_op_math(IrAnalyze *ira, IrInstructionBinOp *bin_o
                 }
             }
             if (!ok) {
-                ir_add_error(ira, &bin_op_instruction->base,
+                ir_add_error(ira, &instruction->base,
                     buf_sprintf("division with '%s' and '%s': signed integers must use @divTrunc, @divFloor, or @divExact",
                         buf_ptr(&op1->value.type->name),
                         buf_ptr(&op2->value.type->name)));
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             }
         } else {
             op_id = IrBinOpDivTrunc;
@@ -12183,12 +11783,12 @@ static ZigType *ir_analyze_bin_op_math(IrAnalyze *ira, IrInstructionBinOp *bin_o
             if (instr_is_comptime(op1) && instr_is_comptime(op2)) {
                 ConstExprValue *op1_val = ir_resolve_const(ira, op1, UndefBad);
                 if (op1_val == nullptr)
-                    return ira->codegen->builtin_types.entry_invalid;
+                    return ira->codegen->invalid_instruction;
 
                 if (is_int) {
                     ConstExprValue *op2_val = ir_resolve_const(ira, op2, UndefBad);
                     if (op2_val == nullptr)
-                        return ira->codegen->builtin_types.entry_invalid;
+                        return ira->codegen->invalid_instruction;
 
                     if (bigint_cmp_zero(&op2->value.data.x_bigint) == CmpEQ) {
                         // the division by zero error will be caught later, but we don't
@@ -12204,11 +11804,11 @@ static ZigType *ir_analyze_bin_op_math(IrAnalyze *ira, IrInstructionBinOp *bin_o
                 } else {
                     IrInstruction *casted_op2 = ir_implicit_cast(ira, op2, resolved_type);
                     if (casted_op2 == ira->codegen->invalid_instruction)
-                        return ira->codegen->builtin_types.entry_invalid;
+                        return ira->codegen->invalid_instruction;
 
                     ConstExprValue *op2_val = ir_resolve_const(ira, casted_op2, UndefBad);
                     if (op2_val == nullptr)
-                        return ira->codegen->builtin_types.entry_invalid;
+                        return ira->codegen->invalid_instruction;
 
                     if (float_cmp_zero(&casted_op2->value) == CmpEQ) {
                         // the division by zero error will be caught later, but we don't
@@ -12224,11 +11824,11 @@ static ZigType *ir_analyze_bin_op_math(IrAnalyze *ira, IrInstructionBinOp *bin_o
                 }
             }
             if (!ok) {
-                ir_add_error(ira, &bin_op_instruction->base,
+                ir_add_error(ira, &instruction->base,
                     buf_sprintf("remainder division with '%s' and '%s': signed integers and floats must use @rem or @mod",
                         buf_ptr(&op1->value.type->name),
                         buf_ptr(&op2->value.type->name)));
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             }
         }
         op_id = IrBinOpRemRem;
@@ -12249,12 +11849,12 @@ static ZigType *ir_analyze_bin_op_math(IrAnalyze *ira, IrInstructionBinOp *bin_o
     {
         // float
     } else {
-        AstNode *source_node = bin_op_instruction->base.source_node;
+        AstNode *source_node = instruction->base.source_node;
         ir_add_error_node(ira, source_node,
             buf_sprintf("invalid operands to binary expression: '%s' and '%s'",
                 buf_ptr(&op1->value.type->name),
                 buf_ptr(&op2->value.type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     if (resolved_type->id == ZigTypeIdComptimeInt) {
@@ -12269,72 +11869,70 @@ static ZigType *ir_analyze_bin_op_math(IrAnalyze *ira, IrInstructionBinOp *bin_o
 
     IrInstruction *casted_op1 = ir_implicit_cast(ira, op1, resolved_type);
     if (casted_op1 == ira->codegen->invalid_instruction)
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     IrInstruction *casted_op2 = ir_implicit_cast(ira, op2, resolved_type);
     if (casted_op2 == ira->codegen->invalid_instruction)
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (instr_is_comptime(casted_op1) && instr_is_comptime(casted_op2)) {
         ConstExprValue *op1_val = ir_resolve_const(ira, casted_op1, UndefBad);
         if (op1_val == nullptr)
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         ConstExprValue *op2_val = ir_resolve_const(ira, casted_op2, UndefBad);
         if (op2_val == nullptr)
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
 
-        IrInstruction *result_instruction = ir_get_const(ira, &bin_op_instruction->base);
-        ir_link_new_instruction(result_instruction, &bin_op_instruction->base);
-        ConstExprValue *out_val = &result_instruction->value;
+        IrInstruction *result_instruction = ir_const(ira, &instruction->base, resolved_type);
 
         int err;
-        if ((err = ir_eval_math_op(resolved_type, op1_val, op_id, op2_val, out_val))) {
+        if ((err = ir_eval_math_op(resolved_type, op1_val, op_id, op2_val, &result_instruction->value))) {
             if (err == ErrorDivByZero) {
-                ir_add_error(ira, &bin_op_instruction->base, buf_sprintf("division by zero"));
-                return ira->codegen->builtin_types.entry_invalid;
+                ir_add_error(ira, &instruction->base, buf_sprintf("division by zero"));
+                return ira->codegen->invalid_instruction;
             } else if (err == ErrorOverflow) {
-                ir_add_error(ira, &bin_op_instruction->base, buf_sprintf("operation caused overflow"));
-                return ira->codegen->builtin_types.entry_invalid;
+                ir_add_error(ira, &instruction->base, buf_sprintf("operation caused overflow"));
+                return ira->codegen->invalid_instruction;
             } else if (err == ErrorExactDivRemainder) {
-                ir_add_error(ira, &bin_op_instruction->base, buf_sprintf("exact division had a remainder"));
-                return ira->codegen->builtin_types.entry_invalid;
+                ir_add_error(ira, &instruction->base, buf_sprintf("exact division had a remainder"));
+                return ira->codegen->invalid_instruction;
             } else if (err == ErrorNegativeDenominator) {
-                ir_add_error(ira, &bin_op_instruction->base, buf_sprintf("negative denominator"));
-                return ira->codegen->builtin_types.entry_invalid;
+                ir_add_error(ira, &instruction->base, buf_sprintf("negative denominator"));
+                return ira->codegen->invalid_instruction;
             } else {
                 zig_unreachable();
             }
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
 
         ir_num_lit_fits_in_other_type(ira, result_instruction, resolved_type, false);
-        return resolved_type;
+        return result_instruction;
     }
 
-    ir_build_bin_op_from(&ira->new_irb, &bin_op_instruction->base, op_id,
-            casted_op1, casted_op2, bin_op_instruction->safety_check_on);
-    return resolved_type;
+    IrInstruction *result = ir_build_bin_op(&ira->new_irb, instruction->base.scope,
+            instruction->base.source_node, op_id, casted_op1, casted_op2, instruction->safety_check_on);
+    result->value.type = resolved_type;
+    return result;
 }
 
-
-static ZigType *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *instruction) {
-    IrInstruction *op1 = instruction->op1->other;
+static IrInstruction *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *instruction) {
+    IrInstruction *op1 = instruction->op1->child;
     ZigType *op1_type = op1->value.type;
     if (type_is_invalid(op1_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *op2 = instruction->op2->other;
+    IrInstruction *op2 = instruction->op2->child;
     ZigType *op2_type = op2->value.type;
     if (type_is_invalid(op2_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     ConstExprValue *op1_val = ir_resolve_const(ira, op1, UndefBad);
     if (!op1_val)
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     ConstExprValue *op2_val = ir_resolve_const(ira, op2, UndefBad);
     if (!op2_val)
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     ConstExprValue *op1_array_val;
     size_t op1_array_index;
@@ -12361,11 +11959,12 @@ static ZigType *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *instruc
         assert(ptr_val->data.x_ptr.special == ConstPtrSpecialBaseArray);
         op1_array_val = ptr_val->data.x_ptr.data.base_array.array_val;
         op1_array_index = ptr_val->data.x_ptr.data.base_array.elem_index;
-        op1_array_end = op1_array_val->type->data.array.len;
+        ConstExprValue *len_val = &op1_val->data.x_struct.fields[slice_len_index];
+        op1_array_end = bigint_as_unsigned(&len_val->data.x_bigint);
     } else {
         ir_add_error(ira, op1,
             buf_sprintf("expected array or C string literal, found '%s'", buf_ptr(&op1->value.type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     ConstExprValue *op2_array_val;
@@ -12376,7 +11975,7 @@ static ZigType *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *instruc
             ir_add_error(ira, op2, buf_sprintf("expected array of type '%s', found '%s'",
                         buf_ptr(&child_type->name),
                         buf_ptr(&op2->value.type->name)));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
         op2_array_val = op2_val;
         op2_array_index = 0;
@@ -12390,7 +11989,7 @@ static ZigType *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *instruc
             ir_add_error(ira, op2, buf_sprintf("expected array of type '%s', found '%s'",
                         buf_ptr(&child_type->name),
                         buf_ptr(&op2->value.type->name)));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
         op2_array_val = op2_val->data.x_ptr.data.base_array.array_val;
         op2_array_index = op2_val->data.x_ptr.data.base_array.elem_index;
@@ -12401,32 +12000,35 @@ static ZigType *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *instruc
             ir_add_error(ira, op2, buf_sprintf("expected array of type '%s', found '%s'",
                         buf_ptr(&child_type->name),
                         buf_ptr(&op2->value.type->name)));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
         ConstExprValue *ptr_val = &op2_val->data.x_struct.fields[slice_ptr_index];
         assert(ptr_val->data.x_ptr.special == ConstPtrSpecialBaseArray);
         op2_array_val = ptr_val->data.x_ptr.data.base_array.array_val;
         op2_array_index = ptr_val->data.x_ptr.data.base_array.elem_index;
         op2_array_end = op2_array_val->type->data.array.len;
+        ConstExprValue *len_val = &op2_val->data.x_struct.fields[slice_len_index];
+        op2_array_end = bigint_as_unsigned(&len_val->data.x_bigint);
     } else {
         ir_add_error(ira, op2,
             buf_sprintf("expected array or C string literal, found '%s'", buf_ptr(&op2->value.type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
-    ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
+    // The type of result is populated in the following if blocks
+    IrInstruction *result = ir_const(ira, &instruction->base, nullptr);
+    ConstExprValue *out_val = &result->value;
 
-    ZigType *result_type;
     ConstExprValue *out_array_val;
     size_t new_len = (op1_array_end - op1_array_index) + (op2_array_end - op2_array_index);
     if (op1_type->id == ZigTypeIdArray || op2_type->id == ZigTypeIdArray) {
-        result_type = get_array_type(ira->codegen, child_type, new_len);
+        result->value.type = get_array_type(ira->codegen, child_type, new_len);
 
         out_array_val = out_val;
     } else if (is_slice(op1_type) || is_slice(op2_type)) {
         ZigType *ptr_type = get_pointer_to_type_extra(ira->codegen, child_type,
                 true, false, PtrLenUnknown, 0, 0, 0);
-        result_type = get_slice_type(ira->codegen, ptr_type);
+        result->value.type = get_slice_type(ira->codegen, ptr_type);
         out_array_val = create_const_vals(1);
         out_array_val->special = ConstValSpecialStatic;
         out_array_val->type = get_array_type(ira->codegen, child_type, new_len);
@@ -12446,7 +12048,7 @@ static ZigType *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *instruc
         new_len += 1; // null byte
 
         // TODO make this `[*]null T` instead of `[*]T`
-        result_type = get_pointer_to_type_extra(ira->codegen, child_type, true, false, PtrLenUnknown, 0, 0, 0);
+        result->value.type = get_pointer_to_type_extra(ira->codegen, child_type, true, false, PtrLenUnknown, 0, 0, 0);
 
         out_array_val = create_const_vals(1);
         out_array_val->special = ConstValSpecialStatic;
@@ -12460,51 +12062,52 @@ static ZigType *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *instruc
     if (op1_array_val->data.x_array.special == ConstArraySpecialUndef &&
         op2_array_val->data.x_array.special == ConstArraySpecialUndef) {
         out_array_val->data.x_array.special = ConstArraySpecialUndef;
-        return result_type;
+        return result;
     }
 
-    out_array_val->data.x_array.s_none.elements = create_const_vals(new_len);
+    out_array_val->data.x_array.data.s_none.elements = create_const_vals(new_len);
+    // TODO handle the buf case here for an optimization
     expand_undef_array(ira->codegen, op1_array_val);
     expand_undef_array(ira->codegen, op2_array_val);
 
     size_t next_index = 0;
     for (size_t i = op1_array_index; i < op1_array_end; i += 1, next_index += 1) {
-        out_array_val->data.x_array.s_none.elements[next_index] = op1_array_val->data.x_array.s_none.elements[i];
+        out_array_val->data.x_array.data.s_none.elements[next_index] = op1_array_val->data.x_array.data.s_none.elements[i];
     }
     for (size_t i = op2_array_index; i < op2_array_end; i += 1, next_index += 1) {
-        out_array_val->data.x_array.s_none.elements[next_index] = op2_array_val->data.x_array.s_none.elements[i];
+        out_array_val->data.x_array.data.s_none.elements[next_index] = op2_array_val->data.x_array.data.s_none.elements[i];
     }
     if (next_index < new_len) {
-        ConstExprValue *null_byte = &out_array_val->data.x_array.s_none.elements[next_index];
+        ConstExprValue *null_byte = &out_array_val->data.x_array.data.s_none.elements[next_index];
         init_const_unsigned_negative(null_byte, child_type, 0, false);
         next_index += 1;
     }
     assert(next_index == new_len);
 
-    return result_type;
+    return result;
 }
 
-static ZigType *ir_analyze_array_mult(IrAnalyze *ira, IrInstructionBinOp *instruction) {
-    IrInstruction *op1 = instruction->op1->other;
+static IrInstruction *ir_analyze_array_mult(IrAnalyze *ira, IrInstructionBinOp *instruction) {
+    IrInstruction *op1 = instruction->op1->child;
     if (type_is_invalid(op1->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *op2 = instruction->op2->other;
+    IrInstruction *op2 = instruction->op2->child;
     if (type_is_invalid(op2->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     ConstExprValue *array_val = ir_resolve_const(ira, op1, UndefBad);
     if (!array_val)
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     uint64_t mult_amt;
     if (!ir_resolve_usize(ira, op2, &mult_amt))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     ZigType *array_type = op1->value.type;
     if (array_type->id != ZigTypeIdArray) {
         ir_add_error(ira, op1, buf_sprintf("expected array type, found '%s'", buf_ptr(&op1->value.type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     uint64_t old_array_len = array_type->data.array.len;
@@ -12513,67 +12116,68 @@ static ZigType *ir_analyze_array_mult(IrAnalyze *ira, IrInstructionBinOp *instru
     if (mul_u64_overflow(old_array_len, mult_amt, &new_array_len))
     {
         ir_add_error(ira, &instruction->base, buf_sprintf("operation results in overflow"));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
-    ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
+    ZigType *child_type = array_type->data.array.child_type;
+
+    IrInstruction *result = ir_const(ira, &instruction->base,
+        get_array_type(ira->codegen, child_type, new_array_len));
+    ConstExprValue *out_val = &result->value;
     if (array_val->data.x_array.special == ConstArraySpecialUndef) {
         out_val->data.x_array.special = ConstArraySpecialUndef;
-
-        ZigType *child_type = array_type->data.array.child_type;
-        return get_array_type(ira->codegen, child_type, new_array_len);
+        return result;
     }
 
-    out_val->data.x_array.s_none.elements = create_const_vals(new_array_len);
+    // TODO optimize the buf case
+    expand_undef_array(ira->codegen, array_val);
+    out_val->data.x_array.data.s_none.elements = create_const_vals(new_array_len);
 
     uint64_t i = 0;
     for (uint64_t x = 0; x < mult_amt; x += 1) {
         for (uint64_t y = 0; y < old_array_len; y += 1) {
-            out_val->data.x_array.s_none.elements[i] = array_val->data.x_array.s_none.elements[y];
+            out_val->data.x_array.data.s_none.elements[i] = array_val->data.x_array.data.s_none.elements[y];
             i += 1;
         }
     }
     assert(i == new_array_len);
 
-    ZigType *child_type = array_type->data.array.child_type;
-    return get_array_type(ira->codegen, child_type, new_array_len);
+    return result;
 }
 
-static ZigType *ir_analyze_merge_error_sets(IrAnalyze *ira, IrInstructionBinOp *instruction) {
-    ZigType *op1_type = ir_resolve_type(ira, instruction->op1->other);
+static IrInstruction *ir_analyze_merge_error_sets(IrAnalyze *ira, IrInstructionBinOp *instruction) {
+    ZigType *op1_type = ir_resolve_type(ira, instruction->op1->child);
     if (type_is_invalid(op1_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (op1_type->id != ZigTypeIdErrorSet) {
         ir_add_error(ira, instruction->op1,
                 buf_sprintf("expected error set type, found '%s'", buf_ptr(&op1_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
-    ZigType *op2_type = ir_resolve_type(ira, instruction->op2->other);
+    ZigType *op2_type = ir_resolve_type(ira, instruction->op2->child);
     if (type_is_invalid(op2_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (op2_type->id != ZigTypeIdErrorSet) {
         ir_add_error(ira, instruction->op2,
                 buf_sprintf("expected error set type, found '%s'", buf_ptr(&op2_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     if (type_is_global_error_set(op1_type) ||
         type_is_global_error_set(op2_type))
     {
-        ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-        out_val->data.x_type = ira->codegen->builtin_types.entry_global_error_set;
-        return ira->codegen->builtin_types.entry_type;
+        return ir_const_type(ira, &instruction->base, ira->codegen->builtin_types.entry_global_error_set);
     }
 
-    if (!resolve_inferred_error_set(ira->codegen, op1_type, instruction->op1->other->source_node)) {
-        return ira->codegen->builtin_types.entry_invalid;
+    if (!resolve_inferred_error_set(ira->codegen, op1_type, instruction->op1->child->source_node)) {
+        return ira->codegen->invalid_instruction;
     }
 
-    if (!resolve_inferred_error_set(ira->codegen, op2_type, instruction->op2->other->source_node)) {
-        return ira->codegen->builtin_types.entry_invalid;
+    if (!resolve_inferred_error_set(ira->codegen, op2_type, instruction->op2->child->source_node)) {
+        return ira->codegen->invalid_instruction;
     }
 
     ErrorTableEntry **errors = allocate<ErrorTableEntry *>(ira->codegen->errors_by_index.length);
@@ -12585,13 +12189,10 @@ static ZigType *ir_analyze_merge_error_sets(IrAnalyze *ira, IrInstructionBinOp *
     ZigType *result_type = get_error_set_union(ira->codegen, errors, op1_type, op2_type);
     free(errors);
 
-
-    ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-    out_val->data.x_type = result_type;
-    return ira->codegen->builtin_types.entry_type;
+    return ir_const_type(ira, &instruction->base, result_type);
 }
 
-static ZigType *ir_analyze_instruction_bin_op(IrAnalyze *ira, IrInstructionBinOp *bin_op_instruction) {
+static IrInstruction *ir_analyze_instruction_bin_op(IrAnalyze *ira, IrInstructionBinOp *bin_op_instruction) {
     IrBinOp op_id = bin_op_instruction->op_id;
     switch (op_id) {
         case IrBinOpInvalid:
@@ -12638,25 +12239,25 @@ static ZigType *ir_analyze_instruction_bin_op(IrAnalyze *ira, IrInstructionBinOp
     zig_unreachable();
 }
 
-static ZigType *ir_analyze_instruction_decl_var(IrAnalyze *ira, IrInstructionDeclVar *decl_var_instruction) {
+static IrInstruction *ir_analyze_instruction_decl_var(IrAnalyze *ira, IrInstructionDeclVar *decl_var_instruction) {
     Error err;
     ZigVar *var = decl_var_instruction->var;
 
-    IrInstruction *init_value = decl_var_instruction->init_value->other;
+    IrInstruction *init_value = decl_var_instruction->init_value->child;
     if (type_is_invalid(init_value->value.type)) {
         var->value->type = ira->codegen->builtin_types.entry_invalid;
-        return var->value->type;
+        return ira->codegen->invalid_instruction;
     }
 
     ZigType *explicit_type = nullptr;
     IrInstruction *var_type = nullptr;
     if (decl_var_instruction->var_type != nullptr) {
-        var_type = decl_var_instruction->var_type->other;
+        var_type = decl_var_instruction->var_type->child;
         ZigType *proposed_type = ir_resolve_type(ira, var_type);
         explicit_type = validate_var_type(ira->codegen, var_type->source_node, proposed_type);
         if (type_is_invalid(explicit_type)) {
             var->value->type = ira->codegen->builtin_types.entry_invalid;
-            return var->value->type;
+            return ira->codegen->invalid_instruction;
         }
     }
 
@@ -12734,19 +12335,17 @@ static ZigType *ir_analyze_instruction_decl_var(IrAnalyze *ira, IrInstructionDec
     assert(var->value->type);
 
     if (type_is_invalid(result_type)) {
-        decl_var_instruction->base.other = &decl_var_instruction->base;
-        return ira->codegen->builtin_types.entry_void;
+        return ir_const_void(ira, &decl_var_instruction->base);
     }
 
     if (decl_var_instruction->align_value == nullptr) {
         if ((err = type_resolve(ira->codegen, result_type, ResolveStatusAlignmentKnown))) {
             var->value->type = ira->codegen->builtin_types.entry_invalid;
-            decl_var_instruction->base.other = &decl_var_instruction->base;
-            return ira->codegen->builtin_types.entry_void;
+            return ir_const_void(ira, &decl_var_instruction->base);
         }
         var->align_bytes = get_abi_alignment(ira->codegen, result_type);
     } else {
-        if (!ir_resolve_align(ira, decl_var_instruction->align_value->other, &var->align_bytes)) {
+        if (!ir_resolve_align(ira, decl_var_instruction->align_value->child, &var->align_bytes)) {
             var->value->type = ira->codegen->builtin_types.entry_invalid;
         }
     }
@@ -12758,43 +12357,44 @@ static ZigType *ir_analyze_instruction_decl_var(IrAnalyze *ira, IrInstructionDec
             copy_const_val(mem_slot, &casted_init_value->value, !is_comptime_var || var->gen_is_const);
 
             if (is_comptime_var || (var_class_requires_const && var->gen_is_const)) {
-                ir_build_const_from(ira, &decl_var_instruction->base);
-                return ira->codegen->builtin_types.entry_void;
+                return ir_const_void(ira, &decl_var_instruction->base);
             }
         }
     } else if (is_comptime_var) {
         ir_add_error(ira, &decl_var_instruction->base,
                 buf_sprintf("cannot store runtime value in compile time variable"));
         var->value->type = ira->codegen->builtin_types.entry_invalid;
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
-    ir_build_var_decl_from(&ira->new_irb, &decl_var_instruction->base, var, var_type, nullptr, casted_init_value);
-
     ZigFn *fn_entry = exec_fn_entry(ira->new_irb.exec);
     if (fn_entry)
         fn_entry->variable_list.append(var);
 
-    return ira->codegen->builtin_types.entry_void;
+    IrInstruction *result = ir_build_var_decl(&ira->new_irb,
+        decl_var_instruction->base.scope, decl_var_instruction->base.source_node,
+        var, var_type, nullptr, casted_init_value);
+    result->value.type = ira->codegen->builtin_types.entry_void;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_export(IrAnalyze *ira, IrInstructionExport *instruction) {
-    IrInstruction *name = instruction->name->other;
+static IrInstruction *ir_analyze_instruction_export(IrAnalyze *ira, IrInstructionExport *instruction) {
+    IrInstruction *name = instruction->name->child;
     Buf *symbol_name = ir_resolve_str(ira, name);
     if (symbol_name == nullptr) {
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
-    IrInstruction *target = instruction->target->other;
+    IrInstruction *target = instruction->target->child;
     if (type_is_invalid(target->value.type)) {
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     GlobalLinkageId global_linkage_id = GlobalLinkageIdStrong;
     if (instruction->linkage != nullptr) {
-        IrInstruction *linkage_value = instruction->linkage->other;
+        IrInstruction *linkage_value = instruction->linkage->child;
         if (!ir_resolve_global_linkage(ira, linkage_value, &global_linkage_id)) {
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
     }
 
@@ -12942,8 +12542,7 @@ static ZigType *ir_analyze_instruction_export(IrAnalyze *ira, IrInstructionExpor
             break;
     }
 
-    ir_build_const_from(ira, &instruction->base);
-    return ira->codegen->builtin_types.entry_void;
+    return ir_const_void(ira, &instruction->base);
 }
 
 static bool exec_has_err_ret_trace(CodeGen *g, IrExecutable *exec) {
@@ -12951,55 +12550,58 @@ static bool exec_has_err_ret_trace(CodeGen *g, IrExecutable *exec) {
     return fn_entry != nullptr && fn_entry->calls_or_awaits_errorable_fn && g->have_err_ret_tracing;
 }
 
-static ZigType *ir_analyze_instruction_error_return_trace(IrAnalyze *ira,
+static IrInstruction *ir_analyze_instruction_error_return_trace(IrAnalyze *ira,
         IrInstructionErrorReturnTrace *instruction)
 {
     if (instruction->optional == IrInstructionErrorReturnTrace::Null) {
         ZigType *ptr_to_stack_trace_type = get_ptr_to_stack_trace_type(ira->codegen);
         ZigType *optional_type = get_optional_type(ira->codegen, ptr_to_stack_trace_type);
         if (!exec_has_err_ret_trace(ira->codegen, ira->new_irb.exec)) {
-            ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
+            IrInstruction *result = ir_const(ira, &instruction->base, optional_type);
+            ConstExprValue *out_val = &result->value;
             assert(get_codegen_ptr_type(optional_type) != nullptr);
             out_val->data.x_ptr.special = ConstPtrSpecialHardCodedAddr;
             out_val->data.x_ptr.data.hard_coded_addr.addr = 0;
-            return optional_type;
+            return result;
         }
         IrInstruction *new_instruction = ir_build_error_return_trace(&ira->new_irb, instruction->base.scope,
                 instruction->base.source_node, instruction->optional);
-        ir_link_new_instruction(new_instruction, &instruction->base);
-        return optional_type;
+        new_instruction->value.type = optional_type;
+        return new_instruction;
     } else {
         assert(ira->codegen->have_err_ret_tracing);
         IrInstruction *new_instruction = ir_build_error_return_trace(&ira->new_irb, instruction->base.scope,
                 instruction->base.source_node, instruction->optional);
-        ir_link_new_instruction(new_instruction, &instruction->base);
-        return get_ptr_to_stack_trace_type(ira->codegen);
+        new_instruction->value.type = get_ptr_to_stack_trace_type(ira->codegen);
+        return new_instruction;
     }
 }
 
-static ZigType *ir_analyze_instruction_error_union(IrAnalyze *ira,
+static IrInstruction *ir_analyze_instruction_error_union(IrAnalyze *ira,
         IrInstructionErrorUnion *instruction)
 {
-    ZigType *err_set_type = ir_resolve_type(ira, instruction->err_set->other);
+    Error err;
+
+    ZigType *err_set_type = ir_resolve_type(ira, instruction->err_set->child);
     if (type_is_invalid(err_set_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    ZigType *payload_type = ir_resolve_type(ira, instruction->payload->other);
+    ZigType *payload_type = ir_resolve_type(ira, instruction->payload->child);
     if (type_is_invalid(payload_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (err_set_type->id != ZigTypeIdErrorSet) {
-        ir_add_error(ira, instruction->err_set->other,
+        ir_add_error(ira, instruction->err_set->child,
             buf_sprintf("expected error set type, found type '%s'",
                 buf_ptr(&err_set_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
+    if ((err = type_resolve(ira->codegen, payload_type, ResolveStatusSizeKnown)))
+        return ira->codegen->invalid_instruction;
     ZigType *result_type = get_error_union_type(ira->codegen, err_set_type, payload_type);
 
-    ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-    out_val->data.x_type = result_type;
-    return ira->codegen->builtin_types.entry_type;
+    return ir_const_type(ira, &instruction->base, result_type);
 }
 
 IrInstruction *ir_get_implicit_allocator(IrAnalyze *ira, IrInstruction *source_instr, ImplicitAllocatorId id) {
@@ -13277,7 +12879,7 @@ no_mem_slot:
     return var_ptr_instruction;
 }
 
-static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instruction,
+static IrInstruction *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instruction,
     ZigFn *fn_entry, ZigType *fn_type, IrInstruction *fn_ref,
     IrInstruction *first_arg_ptr, bool comptime_fn_call, FnInline fn_inline)
 {
@@ -13297,7 +12899,7 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
 
     size_t call_param_count = call_instruction->arg_count + first_arg_1_or_0;
     for (size_t i = 0; i < call_instruction->arg_count; i += 1) {
-        ConstExprValue *arg_tuple_value = &call_instruction->args[i]->other->value;
+        ConstExprValue *arg_tuple_value = &call_instruction->args[i]->child->value;
         if (arg_tuple_value->type->id == ZigTypeIdArgTuple) {
             call_param_count -= 1;
             call_param_count += arg_tuple_value->data.x_arg_tuple.end_index -
@@ -13313,21 +12915,21 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
         if (fn_proto_node) {
             add_error_note(ira->codegen, msg, fn_proto_node, buf_sprintf("declared here"));
         }
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
     if (fn_type_id->cc == CallingConventionAsync && !call_instruction->is_async) {
         ErrorMsg *msg = ir_add_error(ira, fn_ref, buf_sprintf("must use async keyword to call async function"));
         if (fn_proto_node) {
             add_error_note(ira->codegen, msg, fn_proto_node, buf_sprintf("declared here"));
         }
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
     if (fn_type_id->cc != CallingConventionAsync && call_instruction->is_async) {
         ErrorMsg *msg = ir_add_error(ira, fn_ref, buf_sprintf("cannot use async keyword to call non-async function"));
         if (fn_proto_node) {
             add_error_note(ira->codegen, msg, fn_proto_node, buf_sprintf("declared here"));
         }
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
 
@@ -13339,7 +12941,7 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
                 add_error_note(ira->codegen, msg, fn_proto_node,
                     buf_sprintf("declared here"));
             }
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
     } else if (src_param_count != call_param_count) {
         ErrorMsg *msg = ir_add_error_node(ira, source_node,
@@ -13348,18 +12950,18 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
             add_error_note(ira->codegen, msg, fn_proto_node,
                 buf_sprintf("declared here"));
         }
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     if (comptime_fn_call) {
         // No special handling is needed for compile time evaluation of generic functions.
         if (!fn_entry || fn_entry->body_node == nullptr) {
             ir_add_error(ira, fn_ref, buf_sprintf("unable to evaluate constant expression"));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
 
         if (!ir_emit_backward_branch(ira, &call_instruction->base))
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
 
         // Fork a scope of the function with known values for the parameters.
         Scope *exec_scope = &fn_entry->fndef_scope->base;
@@ -13372,7 +12974,7 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
             if (fn_type_id->next_param_index >= 1) {
                 ZigType *param_type = fn_type_id->param_info[next_proto_i].type;
                 if (type_is_invalid(param_type))
-                    return ira->codegen->builtin_types.entry_invalid;
+                    return ira->codegen->invalid_instruction;
                 first_arg_known_bare = param_type->id != ZigTypeIdPointer;
             }
 
@@ -13382,37 +12984,39 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
             } else {
                 first_arg = ir_get_deref(ira, first_arg_ptr, first_arg_ptr);
                 if (type_is_invalid(first_arg->value.type))
-                    return ira->codegen->builtin_types.entry_invalid;
+                    return ira->codegen->invalid_instruction;
             }
 
             if (!ir_analyze_fn_call_inline_arg(ira, fn_proto_node, first_arg, &exec_scope, &next_proto_i))
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
         }
 
         if (fn_proto_node->data.fn_proto.is_var_args) {
             ir_add_error(ira, &call_instruction->base,
                     buf_sprintf("compiler bug: unable to call var args function at compile time. https://github.com/ziglang/zig/issues/313"));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
 
 
         for (size_t call_i = 0; call_i < call_instruction->arg_count; call_i += 1) {
-            IrInstruction *old_arg = call_instruction->args[call_i]->other;
+            IrInstruction *old_arg = call_instruction->args[call_i]->child;
             if (type_is_invalid(old_arg->value.type))
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
 
             if (!ir_analyze_fn_call_inline_arg(ira, fn_proto_node, old_arg, &exec_scope, &next_proto_i))
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
         }
 
         AstNode *return_type_node = fn_proto_node->data.fn_proto.return_type;
         ZigType *specified_return_type = analyze_type_expr(ira->codegen, exec_scope, return_type_node);
         if (type_is_invalid(specified_return_type))
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         ZigType *return_type;
         ZigType *inferred_err_set_type = nullptr;
         if (fn_proto_node->data.fn_proto.auto_err_set) {
             inferred_err_set_type = get_auto_err_set_type(ira->codegen, fn_entry);
+            if ((err = type_resolve(ira->codegen, specified_return_type, ResolveStatusSizeKnown)))
+                return ira->codegen->invalid_instruction;
             return_type = get_error_union_type(ira->codegen, inferred_err_set_type, specified_return_type);
         } else {
             return_type = specified_return_type;
@@ -13455,12 +13059,14 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
             }
 
             if (type_is_invalid(result->value.type))
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
         }
 
-        ConstExprValue *out_val = ir_build_const_from(ira, &call_instruction->base);
-        *out_val = result->value;
-        return ir_finish_anal(ira, return_type);
+        IrInstruction *new_instruction = ir_const(ira, &call_instruction->base, result->value.type);
+        // TODO should we use copy_const_val?
+        new_instruction->value = result->value;
+        new_instruction->value.type = return_type;
+        return ir_finish_anal(ira, new_instruction);
     }
 
     IrInstruction *casted_new_stack = nullptr;
@@ -13468,28 +13074,28 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
         ZigType *u8_ptr = get_pointer_to_type_extra(ira->codegen, ira->codegen->builtin_types.entry_u8,
                 false, false, PtrLenUnknown, 0, 0, 0);
         ZigType *u8_slice = get_slice_type(ira->codegen, u8_ptr);
-        IrInstruction *new_stack = call_instruction->new_stack->other;
+        IrInstruction *new_stack = call_instruction->new_stack->child;
         if (type_is_invalid(new_stack->value.type))
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
 
         casted_new_stack = ir_implicit_cast(ira, new_stack, u8_slice);
         if (type_is_invalid(casted_new_stack->value.type))
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
     }
 
     if (fn_type->data.fn.is_generic) {
         if (!fn_entry) {
             ir_add_error(ira, call_instruction->fn_ref,
                 buf_sprintf("calling a generic function requires compile-time known function value"));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
 
         // Count the arguments of the function type id we are creating
         size_t new_fn_arg_count = first_arg_1_or_0;
         for (size_t call_i = 0; call_i < call_instruction->arg_count; call_i += 1) {
-            IrInstruction *arg = call_instruction->args[call_i]->other;
+            IrInstruction *arg = call_instruction->args[call_i]->child;
             if (type_is_invalid(arg->value.type))
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
 
             if (arg->value.type->id == ZigTypeIdArgTuple) {
                 new_fn_arg_count += arg->value.data.x_arg_tuple.end_index - arg->value.data.x_arg_tuple.start_index;
@@ -13502,10 +13108,10 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
 
         // Fork a scope of the function with known values for the parameters.
         Scope *parent_scope = fn_entry->fndef_scope->base.parent;
-        ZigFn *impl_fn = create_fn(fn_proto_node);
+        ZigFn *impl_fn = create_fn(ira->codegen, fn_proto_node);
         impl_fn->param_source_nodes = allocate<AstNode *>(new_fn_arg_count);
         buf_init_from_buf(&impl_fn->symbol_name, &fn_entry->symbol_name);
-        impl_fn->fndef_scope = create_fndef_scope(impl_fn->body_node, parent_scope, impl_fn);
+        impl_fn->fndef_scope = create_fndef_scope(ira->codegen, impl_fn->body_node, parent_scope, impl_fn);
         impl_fn->child_scope = &impl_fn->fndef_scope->base;
         FnTypeId inst_fn_type_id = {0};
         init_fn_type_id(&inst_fn_type_id, fn_proto_node, new_fn_arg_count);
@@ -13527,7 +13133,7 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
             if (fn_type_id->next_param_index >= 1) {
                 ZigType *param_type = fn_type_id->param_info[next_proto_i].type;
                 if (type_is_invalid(param_type))
-                    return ira->codegen->builtin_types.entry_invalid;
+                    return ira->codegen->invalid_instruction;
                 first_arg_known_bare = param_type->id != ZigTypeIdPointer;
             }
 
@@ -13537,13 +13143,13 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
             } else {
                 first_arg = ir_get_deref(ira, first_arg_ptr, first_arg_ptr);
                 if (type_is_invalid(first_arg->value.type))
-                    return ira->codegen->builtin_types.entry_invalid;
+                    return ira->codegen->invalid_instruction;
             }
 
             if (!ir_analyze_fn_call_generic_arg(ira, fn_proto_node, first_arg, &impl_fn->child_scope,
                 &next_proto_i, generic_id, &inst_fn_type_id, casted_args, impl_fn))
             {
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             }
         }
 
@@ -13553,9 +13159,9 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
         ZigFn *parent_fn_entry = exec_fn_entry(ira->new_irb.exec);
         assert(parent_fn_entry);
         for (size_t call_i = 0; call_i < call_instruction->arg_count; call_i += 1) {
-            IrInstruction *arg = call_instruction->args[call_i]->other;
+            IrInstruction *arg = call_instruction->args[call_i]->child;
             if (type_is_invalid(arg->value.type))
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
 
             if (arg->value.type->id == ZigTypeIdArgTuple) {
                 for (size_t arg_tuple_i = arg->value.data.x_arg_tuple.start_index;
@@ -13573,20 +13179,20 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
                     if (arg_var == nullptr) {
                         ir_add_error(ira, arg,
                             buf_sprintf("compiler bug: var args can't handle void. https://github.com/ziglang/zig/issues/557"));
-                        return ira->codegen->builtin_types.entry_invalid;
+                        return ira->codegen->invalid_instruction;
                     }
                     IrInstruction *arg_var_ptr_inst = ir_get_var_ptr(ira, arg, arg_var);
                     if (type_is_invalid(arg_var_ptr_inst->value.type))
-                        return ira->codegen->builtin_types.entry_invalid;
+                        return ira->codegen->invalid_instruction;
 
                     IrInstruction *arg_tuple_arg = ir_get_deref(ira, arg, arg_var_ptr_inst);
                     if (type_is_invalid(arg_tuple_arg->value.type))
-                        return ira->codegen->builtin_types.entry_invalid;
+                        return ira->codegen->invalid_instruction;
 
                     if (!ir_analyze_fn_call_generic_arg(ira, fn_proto_node, arg_tuple_arg, &impl_fn->child_scope,
                         &next_proto_i, generic_id, &inst_fn_type_id, casted_args, impl_fn))
                     {
-                        return ira->codegen->builtin_types.entry_invalid;
+                        return ira->codegen->invalid_instruction;
                     }
                 }
             } else {
@@ -13601,7 +13207,7 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
                 if (!ir_analyze_fn_call_generic_arg(ira, fn_proto_node, arg, &impl_fn->child_scope,
                     &next_proto_i, generic_id, &inst_fn_type_id, casted_args, impl_fn))
                 {
-                    return ira->codegen->builtin_types.entry_invalid;
+                    return ira->codegen->invalid_instruction;
                 }
             }
         }
@@ -13637,16 +13243,18 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
             AstNode *return_type_node = fn_proto_node->data.fn_proto.return_type;
             ZigType *specified_return_type = analyze_type_expr(ira->codegen, impl_fn->child_scope, return_type_node);
             if (type_is_invalid(specified_return_type))
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             if (fn_proto_node->data.fn_proto.auto_err_set) {
                 ZigType *inferred_err_set_type = get_auto_err_set_type(ira->codegen, impl_fn);
+                if ((err = type_resolve(ira->codegen, specified_return_type, ResolveStatusSizeKnown)))
+                    return ira->codegen->invalid_instruction;
                 inst_fn_type_id.return_type = get_error_union_type(ira->codegen, inferred_err_set_type, specified_return_type);
             } else {
                 inst_fn_type_id.return_type = specified_return_type;
             }
 
             if ((err = type_resolve(ira->codegen, specified_return_type, ResolveStatusZeroBitsKnown)))
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
 
             if (type_requires_comptime(specified_return_type)) {
                 // Throw out our work and call the function as if it were comptime.
@@ -13659,7 +13267,7 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
             if (async_allocator_type_node != nullptr) {
                 ZigType *async_allocator_type = analyze_type_expr(ira->codegen, impl_fn->child_scope, async_allocator_type_node);
                 if (type_is_invalid(async_allocator_type))
-                    return ira->codegen->builtin_types.entry_invalid;
+                    return ira->codegen->invalid_instruction;
                 inst_fn_type_id.async_allocator_type = async_allocator_type;
             }
             IrInstruction *uncasted_async_allocator_inst;
@@ -13667,18 +13275,18 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
                 uncasted_async_allocator_inst = ir_get_implicit_allocator(ira, &call_instruction->base,
                         ImplicitAllocatorIdLocalVar);
                 if (type_is_invalid(uncasted_async_allocator_inst->value.type))
-                    return ira->codegen->builtin_types.entry_invalid;
+                    return ira->codegen->invalid_instruction;
             } else {
-                uncasted_async_allocator_inst = call_instruction->async_allocator->other;
+                uncasted_async_allocator_inst = call_instruction->async_allocator->child;
                 if (type_is_invalid(uncasted_async_allocator_inst->value.type))
-                    return ira->codegen->builtin_types.entry_invalid;
+                    return ira->codegen->invalid_instruction;
             }
             if (inst_fn_type_id.async_allocator_type == nullptr) {
                 inst_fn_type_id.async_allocator_type = uncasted_async_allocator_inst->value.type;
             }
             async_allocator_inst = ir_implicit_cast(ira, uncasted_async_allocator_inst, inst_fn_type_id.async_allocator_type);
             if (type_is_invalid(async_allocator_inst->value.type))
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
         }
 
         auto existing_entry = ira->codegen->generic_table.put_unique(generic_id, impl_fn);
@@ -13689,7 +13297,7 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
             // finish instantiating the function
             impl_fn->type_entry = get_fn_type(ira->codegen, &inst_fn_type_id);
             if (type_is_invalid(impl_fn->type_entry))
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
 
             impl_fn->ir_executable.source_node = call_instruction->base.source_node;
             impl_fn->ir_executable.parent_exec = ira->new_irb.exec;
@@ -13708,21 +13316,22 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
 
         size_t impl_param_count = impl_fn->type_entry->data.fn.fn_type_id.param_count;
         if (call_instruction->is_async) {
-            IrInstruction *result = ir_analyze_async_call(ira, call_instruction, impl_fn, impl_fn->type_entry, fn_ref, casted_args, impl_param_count,
-                    async_allocator_inst);
-            ir_link_new_instruction(result, &call_instruction->base);
+            IrInstruction *result = ir_analyze_async_call(ira, call_instruction, impl_fn, impl_fn->type_entry,
+                    fn_ref, casted_args, impl_param_count, async_allocator_inst);
             ir_add_alloca(ira, result, result->value.type);
-            return ir_finish_anal(ira, result->value.type);
+            return ir_finish_anal(ira, result);
         }
 
         assert(async_allocator_inst == nullptr);
-        IrInstruction *new_call_instruction = ir_build_call_from(&ira->new_irb, &call_instruction->base,
+        IrInstruction *new_call_instruction = ir_build_call(&ira->new_irb,
+                call_instruction->base.scope, call_instruction->base.source_node,
                 impl_fn, nullptr, impl_param_count, casted_args, false, fn_inline,
                 call_instruction->is_async, nullptr, casted_new_stack);
+        new_call_instruction->value.type = return_type;
 
         ir_add_alloca(ira, new_call_instruction, return_type);
 
-        return ir_finish_anal(ira, return_type);
+        return ir_finish_anal(ira, new_call_instruction);
     }
 
     ZigFn *parent_fn_entry = exec_fn_entry(ira->new_irb.exec);
@@ -13740,7 +13349,7 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
 
         ZigType *param_type = fn_type_id->param_info[next_arg_index].type;
         if (type_is_invalid(param_type))
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
 
         IrInstruction *first_arg;
         if (param_type->id == ZigTypeIdPointer &&
@@ -13750,28 +13359,28 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
         } else {
             first_arg = ir_get_deref(ira, first_arg_ptr, first_arg_ptr);
             if (type_is_invalid(first_arg->value.type))
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
         }
 
         IrInstruction *casted_arg = ir_implicit_cast(ira, first_arg, param_type);
         if (type_is_invalid(casted_arg->value.type))
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
 
         casted_args[next_arg_index] = casted_arg;
         next_arg_index += 1;
     }
     for (size_t call_i = 0; call_i < call_instruction->arg_count; call_i += 1) {
-        IrInstruction *old_arg = call_instruction->args[call_i]->other;
+        IrInstruction *old_arg = call_instruction->args[call_i]->child;
         if (type_is_invalid(old_arg->value.type))
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         IrInstruction *casted_arg;
         if (next_arg_index < src_param_count) {
             ZigType *param_type = fn_type_id->param_info[next_arg_index].type;
             if (type_is_invalid(param_type))
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             casted_arg = ir_implicit_cast(ira, old_arg, param_type);
             if (type_is_invalid(casted_arg->value.type))
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
         } else {
             casted_arg = old_arg;
         }
@@ -13784,7 +13393,7 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
 
     ZigType *return_type = fn_type_id->return_type;
     if (type_is_invalid(return_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (call_instruction->is_async) {
         IrInstruction *uncasted_async_allocator_inst;
@@ -13792,41 +13401,41 @@ static ZigType *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *call_instr
             uncasted_async_allocator_inst = ir_get_implicit_allocator(ira, &call_instruction->base,
                     ImplicitAllocatorIdLocalVar);
             if (type_is_invalid(uncasted_async_allocator_inst->value.type))
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
         } else {
-            uncasted_async_allocator_inst = call_instruction->async_allocator->other;
+            uncasted_async_allocator_inst = call_instruction->async_allocator->child;
             if (type_is_invalid(uncasted_async_allocator_inst->value.type))
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
 
         }
         IrInstruction *async_allocator_inst = ir_implicit_cast(ira, uncasted_async_allocator_inst, fn_type_id->async_allocator_type);
         if (type_is_invalid(async_allocator_inst->value.type))
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
 
-        IrInstruction *result = ir_analyze_async_call(ira, call_instruction, fn_entry, fn_type, fn_ref, casted_args, call_param_count,
-                async_allocator_inst);
-        ir_link_new_instruction(result, &call_instruction->base);
+        IrInstruction *result = ir_analyze_async_call(ira, call_instruction, fn_entry, fn_type, fn_ref,
+                casted_args, call_param_count, async_allocator_inst);
         ir_add_alloca(ira, result, result->value.type);
-        return ir_finish_anal(ira, result->value.type);
+        return ir_finish_anal(ira, result);
     }
 
     if (fn_entry != nullptr && fn_entry->fn_inline == FnInlineAlways && fn_inline == FnInlineNever) {
         ir_add_error(ira, &call_instruction->base,
             buf_sprintf("no-inline call of inline function"));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
-    IrInstruction *new_call_instruction = ir_build_call_from(&ira->new_irb, &call_instruction->base,
+    IrInstruction *new_call_instruction = ir_build_call(&ira->new_irb,
+            call_instruction->base.scope, call_instruction->base.source_node,
             fn_entry, fn_ref, call_param_count, casted_args, false, fn_inline, false, nullptr, casted_new_stack);
-
+    new_call_instruction->value.type = return_type;
     ir_add_alloca(ira, new_call_instruction, return_type);
-    return ir_finish_anal(ira, return_type);
+    return ir_finish_anal(ira, new_call_instruction);
 }
 
-static ZigType *ir_analyze_instruction_call(IrAnalyze *ira, IrInstructionCall *call_instruction) {
-    IrInstruction *fn_ref = call_instruction->fn_ref->other;
+static IrInstruction *ir_analyze_instruction_call(IrAnalyze *ira, IrInstructionCall *call_instruction) {
+    IrInstruction *fn_ref = call_instruction->fn_ref->child;
     if (type_is_invalid(fn_ref->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     bool is_comptime = call_instruction->is_comptime ||
         ir_should_inline(ira->new_irb.exec, call_instruction->base.scope);
@@ -13835,28 +13444,26 @@ static ZigType *ir_analyze_instruction_call(IrAnalyze *ira, IrInstructionCall *c
         if (fn_ref->value.type->id == ZigTypeIdMetaType) {
             ZigType *dest_type = ir_resolve_type(ira, fn_ref);
             if (type_is_invalid(dest_type))
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
 
             size_t actual_param_count = call_instruction->arg_count;
 
             if (actual_param_count != 1) {
                 ir_add_error_node(ira, call_instruction->base.source_node,
                         buf_sprintf("cast expression expects exactly one parameter"));
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             }
 
-            IrInstruction *arg = call_instruction->args[0]->other;
+            IrInstruction *arg = call_instruction->args[0]->child;
 
             IrInstruction *cast_instruction = ir_analyze_cast(ira, &call_instruction->base, dest_type, arg);
             if (type_is_invalid(cast_instruction->value.type))
-                return ira->codegen->builtin_types.entry_invalid;
-
-            ir_link_new_instruction(cast_instruction, &call_instruction->base);
-            return ir_finish_anal(ira, cast_instruction->value.type);
+                return ira->codegen->invalid_instruction;
+            return ir_finish_anal(ira, cast_instruction);
         } else if (fn_ref->value.type->id == ZigTypeIdFn) {
             ZigFn *fn_table_entry = ir_resolve_fn(ira, fn_ref);
             if (fn_table_entry == nullptr)
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             return ir_analyze_fn_call(ira, call_instruction, fn_table_entry, fn_table_entry->type_entry,
                 fn_ref, nullptr, is_comptime, call_instruction->fn_inline);
         } else if (fn_ref->value.type->id == ZigTypeIdBoundFn) {
@@ -13868,7 +13475,7 @@ static ZigType *ir_analyze_instruction_call(IrAnalyze *ira, IrInstructionCall *c
         } else {
             ir_add_error_node(ira, fn_ref->source_node,
                 buf_sprintf("type '%s' not a function", buf_ptr(&fn_ref->value.type->name)));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
     }
 
@@ -13878,7 +13485,7 @@ static ZigType *ir_analyze_instruction_call(IrAnalyze *ira, IrInstructionCall *c
     } else {
         ir_add_error_node(ira, fn_ref->source_node,
             buf_sprintf("type '%s' not a function", buf_ptr(&fn_ref->value.type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 }
 
@@ -13887,10 +13494,16 @@ static ZigType *ir_analyze_instruction_call(IrAnalyze *ira, IrInstructionCall *c
 static Error ir_read_const_ptr(IrAnalyze *ira, AstNode *source_node,
         ConstExprValue *out_val, ConstExprValue *ptr_val)
 {
+    Error err;
     assert(out_val->type != nullptr);
 
     ConstExprValue *pointee = const_ptr_pointee_unchecked(ira->codegen, ptr_val);
 
+    if ((err = type_resolve(ira->codegen, pointee->type, ResolveStatusSizeKnown)))
+        return ErrorSemanticAnalyzeFail;
+    if ((err = type_resolve(ira->codegen, out_val->type, ResolveStatusSizeKnown)))
+        return ErrorSemanticAnalyzeFail;
+
     size_t src_size = type_size(ira->codegen, pointee->type);
     size_t dst_size = type_size(ira->codegen, out_val->type);
 
@@ -13913,56 +13526,14 @@ static Error ir_read_const_ptr(IrAnalyze *ira, AstNode *source_node,
     return ErrorNone;
 }
 
-static ZigType *ir_analyze_dereference(IrAnalyze *ira, IrInstructionUnOp *un_op_instruction) {
+static IrInstruction *ir_analyze_maybe(IrAnalyze *ira, IrInstructionUnOp *un_op_instruction) {
     Error err;
-    IrInstruction *value = un_op_instruction->value->other;
-
-    ZigType *ptr_type = value->value.type;
-    ZigType *child_type;
-    if (type_is_invalid(ptr_type)) {
-        return ira->codegen->builtin_types.entry_invalid;
-    } else if (ptr_type->id == ZigTypeIdPointer) {
-        if (ptr_type->data.pointer.ptr_len == PtrLenUnknown) {
-            ir_add_error_node(ira, un_op_instruction->base.source_node,
-                buf_sprintf("index syntax required for unknown-length pointer type '%s'",
-                    buf_ptr(&ptr_type->name)));
-            return ira->codegen->builtin_types.entry_invalid;
-        }
-        child_type = ptr_type->data.pointer.child_type;
-    } else {
-        ir_add_error_node(ira, un_op_instruction->base.source_node,
-            buf_sprintf("attempt to dereference non-pointer type '%s'",
-                buf_ptr(&ptr_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
-    }
-
-    // this dereference is always an rvalue because in the IR gen we identify lvalue and emit
-    // one of the ptr instructions
-
-    if (instr_is_comptime(value)) {
-        ConstExprValue *comptime_value = ir_resolve_const(ira, value, UndefBad);
-        if (comptime_value == nullptr)
-            return ira->codegen->builtin_types.entry_invalid;
-
-        ConstExprValue *out_val = ir_build_const_from(ira, &un_op_instruction->base);
-        out_val->type = child_type;
-        if ((err = ir_read_const_ptr(ira, un_op_instruction->base.source_node, out_val, comptime_value)))
-            return ira->codegen->builtin_types.entry_invalid;
-        return child_type;
-    }
-
-    ir_build_load_ptr_from(&ira->new_irb, &un_op_instruction->base, value);
-    return child_type;
-}
-
-static ZigType *ir_analyze_maybe(IrAnalyze *ira, IrInstructionUnOp *un_op_instruction) {
-    Error err;
-    IrInstruction *value = un_op_instruction->value->other;
+    IrInstruction *value = un_op_instruction->value->child;
     ZigType *type_entry = ir_resolve_type(ira, value);
     if (type_is_invalid(type_entry))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     if ((err = ensure_complete_type(ira->codegen, type_entry)))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     switch (type_entry->id) {
         case ZigTypeIdInvalid:
@@ -13989,27 +13560,23 @@ static ZigType *ir_analyze_maybe(IrAnalyze *ira, IrInstructionUnOp *un_op_instru
         case ZigTypeIdBoundFn:
         case ZigTypeIdArgTuple:
         case ZigTypeIdPromise:
-            {
-                ConstExprValue *out_val = ir_build_const_from(ira, &un_op_instruction->base);
-                out_val->data.x_type = get_optional_type(ira->codegen, type_entry);
-                return ira->codegen->builtin_types.entry_type;
-            }
+            return ir_const_type(ira, &un_op_instruction->base, get_optional_type(ira->codegen, type_entry));
         case ZigTypeIdUnreachable:
         case ZigTypeIdOpaque:
             ir_add_error_node(ira, un_op_instruction->base.source_node,
                     buf_sprintf("type '%s' not optional", buf_ptr(&type_entry->name)));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
     }
     zig_unreachable();
 }
 
-static ZigType *ir_analyze_negation(IrAnalyze *ira, IrInstructionUnOp *un_op_instruction) {
-    IrInstruction *value = un_op_instruction->value->other;
+static IrInstruction *ir_analyze_negation(IrAnalyze *ira, IrInstructionUnOp *instruction) {
+    IrInstruction *value = instruction->value->child;
     ZigType *expr_type = value->value.type;
     if (type_is_invalid(expr_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    bool is_wrap_op = (un_op_instruction->op_id == IrUnOpNegationWrap);
+    bool is_wrap_op = (instruction->op_id == IrUnOpNegationWrap);
 
     bool is_float = (expr_type->id == ZigTypeIdFloat || expr_type->id == ZigTypeIdComptimeFloat);
 
@@ -14019,9 +13586,10 @@ static ZigType *ir_analyze_negation(IrAnalyze *ira, IrInstructionUnOp *un_op_ins
         if (instr_is_comptime(value)) {
             ConstExprValue *target_const_val = ir_resolve_const(ira, value, UndefBad);
             if (!target_const_val)
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
 
-            ConstExprValue *out_val = ir_build_const_from(ira, &un_op_instruction->base);
+            IrInstruction *result = ir_const(ira, &instruction->base, expr_type);
+            ConstExprValue *out_val = &result->value;
             if (is_float) {
                 float_negate(out_val, target_const_val);
             } else if (is_wrap_op) {
@@ -14031,75 +13599,96 @@ static ZigType *ir_analyze_negation(IrAnalyze *ira, IrInstructionUnOp *un_op_ins
                 bigint_negate(&out_val->data.x_bigint, &target_const_val->data.x_bigint);
             }
             if (is_wrap_op || is_float || expr_type->id == ZigTypeIdComptimeInt) {
-                return expr_type;
+                return result;
             }
 
             if (!bigint_fits_in_bits(&out_val->data.x_bigint, expr_type->data.integral.bit_count, true)) {
-                ir_add_error(ira, &un_op_instruction->base, buf_sprintf("negation caused overflow"));
-                return ira->codegen->builtin_types.entry_invalid;
+                ir_add_error(ira, &instruction->base, buf_sprintf("negation caused overflow"));
+                return ira->codegen->invalid_instruction;
             }
-            return expr_type;
+            return result;
         }
 
-        ir_build_un_op_from(&ira->new_irb, &un_op_instruction->base, un_op_instruction->op_id, value);
-        return expr_type;
+        IrInstruction *result = ir_build_un_op(&ira->new_irb,
+                instruction->base.scope, instruction->base.source_node,
+                instruction->op_id, value);
+        result->value.type = expr_type;
+        return result;
     }
 
     const char *fmt = is_wrap_op ? "invalid wrapping negation type: '%s'" : "invalid negation type: '%s'";
-    ir_add_error(ira, &un_op_instruction->base, buf_sprintf(fmt, buf_ptr(&expr_type->name)));
-    return ira->codegen->builtin_types.entry_invalid;
+    ir_add_error(ira, &instruction->base, buf_sprintf(fmt, buf_ptr(&expr_type->name)));
+    return ira->codegen->invalid_instruction;
 }
 
-static ZigType *ir_analyze_bin_not(IrAnalyze *ira, IrInstructionUnOp *instruction) {
-    IrInstruction *value = instruction->value->other;
+static IrInstruction *ir_analyze_bin_not(IrAnalyze *ira, IrInstructionUnOp *instruction) {
+    IrInstruction *value = instruction->value->child;
     ZigType *expr_type = value->value.type;
     if (type_is_invalid(expr_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (expr_type->id == ZigTypeIdInt) {
         if (instr_is_comptime(value)) {
             ConstExprValue *target_const_val = ir_resolve_const(ira, value, UndefBad);
             if (target_const_val == nullptr)
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
 
-            ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-            bigint_not(&out_val->data.x_bigint, &target_const_val->data.x_bigint,
+            IrInstruction *result = ir_const(ira, &instruction->base, expr_type);
+            bigint_not(&result->value.data.x_bigint, &target_const_val->data.x_bigint,
                     expr_type->data.integral.bit_count, expr_type->data.integral.is_signed);
-            return expr_type;
+            return result;
         }
 
-        ir_build_un_op_from(&ira->new_irb, &instruction->base, IrUnOpBinNot, value);
-        return expr_type;
+        IrInstruction *result = ir_build_un_op(&ira->new_irb, instruction->base.scope,
+                instruction->base.source_node, IrUnOpBinNot, value);
+        result->value.type = expr_type;
+        return result;
     }
 
     ir_add_error(ira, &instruction->base,
             buf_sprintf("unable to perform binary not operation on type '%s'", buf_ptr(&expr_type->name)));
-    return ira->codegen->builtin_types.entry_invalid;
+    return ira->codegen->invalid_instruction;
 }
 
-static ZigType *ir_analyze_instruction_un_op(IrAnalyze *ira, IrInstructionUnOp *un_op_instruction) {
-    IrUnOp op_id = un_op_instruction->op_id;
+static IrInstruction *ir_analyze_instruction_un_op(IrAnalyze *ira, IrInstructionUnOp *instruction) {
+    IrUnOp op_id = instruction->op_id;
     switch (op_id) {
         case IrUnOpInvalid:
             zig_unreachable();
         case IrUnOpBinNot:
-            return ir_analyze_bin_not(ira, un_op_instruction);
+            return ir_analyze_bin_not(ira, instruction);
         case IrUnOpNegation:
         case IrUnOpNegationWrap:
-            return ir_analyze_negation(ira, un_op_instruction);
-        case IrUnOpDereference:
-            return ir_analyze_dereference(ira, un_op_instruction);
+            return ir_analyze_negation(ira, instruction);
+        case IrUnOpDereference: {
+            IrInstruction *ptr = instruction->value->child;
+            if (type_is_invalid(ptr->value.type))
+                return ira->codegen->invalid_instruction;
+            ZigType *ptr_type = ptr->value.type;
+            if (ptr_type->id == ZigTypeIdPointer && ptr_type->data.pointer.ptr_len == PtrLenUnknown) {
+                ir_add_error_node(ira, instruction->base.source_node,
+                    buf_sprintf("index syntax required for unknown-length pointer type '%s'",
+                        buf_ptr(&ptr_type->name)));
+                return ira->codegen->invalid_instruction;
+            }
+            // this dereference is always an rvalue because in the IR gen we identify lvalue and emit
+            // one of the ptr instructions
+            IrInstruction *result = ir_get_deref(ira, &instruction->base, ptr);
+            if (result == ira->codegen->invalid_instruction)
+                return ira->codegen->invalid_instruction;
+            return result;
+        }
         case IrUnOpOptional:
-            return ir_analyze_maybe(ira, un_op_instruction);
+            return ir_analyze_maybe(ira, instruction);
     }
     zig_unreachable();
 }
 
-static ZigType *ir_analyze_instruction_br(IrAnalyze *ira, IrInstructionBr *br_instruction) {
+static IrInstruction *ir_analyze_instruction_br(IrAnalyze *ira, IrInstructionBr *br_instruction) {
     IrBasicBlock *old_dest_block = br_instruction->dest_block;
 
     bool is_comptime;
-    if (!ir_resolve_comptime(ira, br_instruction->is_comptime->other, &is_comptime))
+    if (!ir_resolve_comptime(ira, br_instruction->is_comptime->child, &is_comptime))
         return ir_unreach_error(ira);
 
     if (is_comptime || old_dest_block->ref_count == 1)
@@ -14109,17 +13698,19 @@ static ZigType *ir_analyze_instruction_br(IrAnalyze *ira, IrInstructionBr *br_in
     if (new_bb == nullptr)
         return ir_unreach_error(ira);
 
-    ir_build_br_from(&ira->new_irb, &br_instruction->base, new_bb);
-    return ir_finish_anal(ira, ira->codegen->builtin_types.entry_unreachable);
+    IrInstruction *result = ir_build_br(&ira->new_irb,
+            br_instruction->base.scope, br_instruction->base.source_node, new_bb, nullptr);
+    result->value.type = ira->codegen->builtin_types.entry_unreachable;
+    return ir_finish_anal(ira, result);
 }
 
-static ZigType *ir_analyze_instruction_cond_br(IrAnalyze *ira, IrInstructionCondBr *cond_br_instruction) {
-    IrInstruction *condition = cond_br_instruction->condition->other;
+static IrInstruction *ir_analyze_instruction_cond_br(IrAnalyze *ira, IrInstructionCondBr *cond_br_instruction) {
+    IrInstruction *condition = cond_br_instruction->condition->child;
     if (type_is_invalid(condition->value.type))
         return ir_unreach_error(ira);
 
     bool is_comptime;
-    if (!ir_resolve_comptime(ira, cond_br_instruction->is_comptime->other, &is_comptime))
+    if (!ir_resolve_comptime(ira, cond_br_instruction->is_comptime->child, &is_comptime))
         return ir_unreach_error(ira);
 
     if (is_comptime || instr_is_comptime(condition)) {
@@ -14137,8 +13728,10 @@ static ZigType *ir_analyze_instruction_cond_br(IrAnalyze *ira, IrInstructionCond
         if (new_dest_block == nullptr)
             return ir_unreach_error(ira);
 
-        ir_build_br_from(&ira->new_irb, &cond_br_instruction->base, new_dest_block);
-        return ir_finish_anal(ira, ira->codegen->builtin_types.entry_unreachable);
+        IrInstruction *result = ir_build_br(&ira->new_irb,
+            cond_br_instruction->base.scope, cond_br_instruction->base.source_node, new_dest_block, nullptr);
+        result->value.type = ira->codegen->builtin_types.entry_unreachable;
+        return ir_finish_anal(ira, result);
     }
 
     ZigType *bool_type = ira->codegen->builtin_types.entry_bool;
@@ -14155,36 +13748,41 @@ static ZigType *ir_analyze_instruction_cond_br(IrAnalyze *ira, IrInstructionCond
     if (new_else_block == nullptr)
         return ir_unreach_error(ira);
 
-    ir_build_cond_br_from(&ira->new_irb, &cond_br_instruction->base,
+    IrInstruction *result = ir_build_cond_br(&ira->new_irb,
+            cond_br_instruction->base.scope, cond_br_instruction->base.source_node,
             casted_condition, new_then_block, new_else_block, nullptr);
-    return ir_finish_anal(ira, ira->codegen->builtin_types.entry_unreachable);
+    result->value.type = ira->codegen->builtin_types.entry_unreachable;
+    return ir_finish_anal(ira, result);
 }
 
-static ZigType *ir_analyze_instruction_unreachable(IrAnalyze *ira,
+static IrInstruction *ir_analyze_instruction_unreachable(IrAnalyze *ira,
         IrInstructionUnreachable *unreachable_instruction)
 {
-    ir_build_unreachable_from(&ira->new_irb, &unreachable_instruction->base);
-    return ir_finish_anal(ira, ira->codegen->builtin_types.entry_unreachable);
+    IrInstruction *result = ir_build_unreachable(&ira->new_irb,
+            unreachable_instruction->base.scope, unreachable_instruction->base.source_node);
+    result->value.type = ira->codegen->builtin_types.entry_unreachable;
+    return ir_finish_anal(ira, result);
 }
 
-static ZigType *ir_analyze_instruction_phi(IrAnalyze *ira, IrInstructionPhi *phi_instruction) {
+static IrInstruction *ir_analyze_instruction_phi(IrAnalyze *ira, IrInstructionPhi *phi_instruction) {
     if (ira->const_predecessor_bb) {
         for (size_t i = 0; i < phi_instruction->incoming_count; i += 1) {
             IrBasicBlock *predecessor = phi_instruction->incoming_blocks[i];
             if (predecessor != ira->const_predecessor_bb)
                 continue;
-            IrInstruction *value = phi_instruction->incoming_values[i]->other;
+            IrInstruction *value = phi_instruction->incoming_values[i]->child;
             assert(value->value.type);
             if (type_is_invalid(value->value.type))
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
 
             if (value->value.special != ConstValSpecialRuntime) {
-                ConstExprValue *out_val = ir_build_const_from(ira, &phi_instruction->base);
-                *out_val = value->value;
+                IrInstruction *result = ir_const(ira, &phi_instruction->base, nullptr);
+                // TODO use copy_const_val?
+                result->value = value->value;
+                return result;
             } else {
-                phi_instruction->base.other = value;
+                return value;
             }
-            return value->value.type;
         }
         zig_unreachable();
     }
@@ -14200,12 +13798,12 @@ static ZigType *ir_analyze_instruction_phi(IrAnalyze *ira, IrInstructionPhi *phi
 
         IrInstruction *old_value = phi_instruction->incoming_values[i];
         assert(old_value);
-        IrInstruction *new_value = old_value->other;
+        IrInstruction *new_value = old_value->child;
         if (!new_value || new_value->value.type->id == ZigTypeIdUnreachable || predecessor->other == nullptr)
             continue;
 
         if (type_is_invalid(new_value->value.type))
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
 
 
         assert(predecessor->other);
@@ -14214,20 +13812,20 @@ static ZigType *ir_analyze_instruction_phi(IrAnalyze *ira, IrInstructionPhi *phi
     }
 
     if (new_incoming_blocks.length == 0) {
-        ir_build_unreachable_from(&ira->new_irb, &phi_instruction->base);
-        return ir_finish_anal(ira, ira->codegen->builtin_types.entry_unreachable);
+        IrInstruction *result = ir_build_unreachable(&ira->new_irb,
+            phi_instruction->base.scope, phi_instruction->base.source_node);
+        result->value.type = ira->codegen->builtin_types.entry_unreachable;
+        return ir_finish_anal(ira, result);
     }
 
     if (new_incoming_blocks.length == 1) {
-        IrInstruction *first_value = new_incoming_values.at(0);
-        phi_instruction->base.other = first_value;
-        return first_value->value.type;
+        return new_incoming_values.at(0);
     }
 
     ZigType *resolved_type = ir_resolve_peer_types(ira, phi_instruction->base.source_node, nullptr,
             new_incoming_values.items, new_incoming_values.length);
     if (type_is_invalid(resolved_type))
-        return resolved_type;
+        return ira->codegen->invalid_instruction;
 
     if (resolved_type->id == ZigTypeIdComptimeFloat ||
         resolved_type->id == ZigTypeIdComptimeInt ||
@@ -14236,7 +13834,7 @@ static ZigType *ir_analyze_instruction_phi(IrAnalyze *ira, IrInstructionPhi *phi
     {
         ir_add_error_node(ira, phi_instruction->base.source_node,
                 buf_sprintf("unable to infer expression type"));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     bool all_stack_ptrs = (resolved_type->id == ZigTypeIdPointer);
@@ -14252,7 +13850,7 @@ static ZigType *ir_analyze_instruction_phi(IrAnalyze *ira, IrInstructionPhi *phi
         ir_set_cursor_at_end(&ira->new_irb, predecessor);
         IrInstruction *casted_value = ir_implicit_cast(ira, new_value, resolved_type);
         if (casted_value == ira->codegen->invalid_instruction) {
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
         new_incoming_values.items[i] = casted_value;
         predecessor->instruction_list.append(branch_instruction);
@@ -14265,24 +13863,20 @@ static ZigType *ir_analyze_instruction_phi(IrAnalyze *ira, IrInstructionPhi *phi
     }
     ir_set_cursor_at_end(&ira->new_irb, cur_bb);
 
-    IrInstruction *result = ir_build_phi_from(&ira->new_irb, &phi_instruction->base, new_incoming_blocks.length,
-            new_incoming_blocks.items, new_incoming_values.items);
+    IrInstruction *result = ir_build_phi(&ira->new_irb,
+        phi_instruction->base.scope, phi_instruction->base.source_node,
+        new_incoming_blocks.length, new_incoming_blocks.items, new_incoming_values.items);
+    result->value.type = resolved_type;
 
     if (all_stack_ptrs) {
         assert(result->value.special == ConstValSpecialRuntime);
         result->value.data.rh_ptr = RuntimeHintPtrStack;
     }
 
-    return resolved_type;
-}
-
-static ZigType *ir_analyze_var_ptr(IrAnalyze *ira, IrInstruction *instruction, ZigVar *var) {
-    IrInstruction *result = ir_get_var_ptr(ira, instruction, var);
-    ir_link_new_instruction(result, instruction);
-    return result->value.type;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_var_ptr(IrAnalyze *ira, IrInstructionVarPtr *instruction) {
+static IrInstruction *ir_analyze_instruction_var_ptr(IrAnalyze *ira, IrInstructionVarPtr *instruction) {
     ZigVar *var = instruction->var;
     IrInstruction *result = ir_get_var_ptr(ira, &instruction->base, var);
     if (instruction->crossed_fndef_scope != nullptr && !instr_is_comptime(result)) {
@@ -14292,10 +13886,9 @@ static ZigType *ir_analyze_instruction_var_ptr(IrAnalyze *ira, IrInstructionVarP
                 buf_sprintf("crossed function definition here"));
         add_error_note(ira->codegen, msg, var->decl_node,
                 buf_sprintf("declared here"));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
-    ir_link_new_instruction(result, &instruction->base);
-    return result->value.type;
+    return result;
 }
 
 static ZigType *adjust_ptr_align(CodeGen *g, ZigType *ptr_type, uint32_t new_align) {
@@ -14305,7 +13898,7 @@ static ZigType *adjust_ptr_align(CodeGen *g, ZigType *ptr_type, uint32_t new_ali
             ptr_type->data.pointer.is_const, ptr_type->data.pointer.is_volatile,
             ptr_type->data.pointer.ptr_len,
             new_align,
-            ptr_type->data.pointer.bit_offset, ptr_type->data.pointer.unaligned_bit_count);
+            ptr_type->data.pointer.bit_offset_in_host, ptr_type->data.pointer.host_int_bytes);
 }
 
 static ZigType *adjust_slice_align(CodeGen *g, ZigType *slice_type, uint32_t new_align) {
@@ -14322,20 +13915,20 @@ static ZigType *adjust_ptr_len(CodeGen *g, ZigType *ptr_type, PtrLen ptr_len) {
             ptr_type->data.pointer.is_const, ptr_type->data.pointer.is_volatile,
             ptr_len,
             ptr_type->data.pointer.explicit_alignment,
-            ptr_type->data.pointer.bit_offset, ptr_type->data.pointer.unaligned_bit_count);
+            ptr_type->data.pointer.bit_offset_in_host, ptr_type->data.pointer.host_int_bytes);
 }
 
-static ZigType *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstructionElemPtr *elem_ptr_instruction) {
+static IrInstruction *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstructionElemPtr *elem_ptr_instruction) {
     Error err;
-    IrInstruction *array_ptr = elem_ptr_instruction->array_ptr->other;
+    IrInstruction *array_ptr = elem_ptr_instruction->array_ptr->child;
     if (type_is_invalid(array_ptr->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     ConstExprValue *orig_array_ptr_val = &array_ptr->value;
 
-    IrInstruction *elem_index = elem_ptr_instruction->elem_index->other;
+    IrInstruction *elem_index = elem_ptr_instruction->elem_index->child;
     if (type_is_invalid(elem_index->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     ZigType *ptr_type = orig_array_ptr_val->type;
     assert(ptr_type->id == ZigTypeIdPointer);
@@ -14347,7 +13940,7 @@ static ZigType *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstructionEle
     ZigType *return_type;
 
     if (type_is_invalid(array_type)) {
-        return array_type;
+        return ira->codegen->invalid_instruction;
     } else if (array_type->id == ZigTypeIdArray ||
         (array_type->id == ZigTypeIdPointer &&
          array_type->data.pointer.ptr_len == PtrLenSingle &&
@@ -14360,16 +13953,16 @@ static ZigType *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstructionEle
                 orig_array_ptr_val = ir_const_ptr_pointee(ira, orig_array_ptr_val,
                         elem_ptr_instruction->base.source_node);
                 if (orig_array_ptr_val == nullptr)
-                    return ira->codegen->builtin_types.entry_invalid;
+                    return ira->codegen->invalid_instruction;
             }
         }
         if (array_type->data.array.len == 0) {
             ir_add_error_node(ira, elem_ptr_instruction->base.source_node,
                     buf_sprintf("index 0 outside array of size 0"));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
         ZigType *child_type = array_type->data.array.child_type;
-        if (ptr_type->data.pointer.unaligned_bit_count == 0) {
+        if (ptr_type->data.pointer.host_int_bytes == 0) {
             return_type = get_pointer_to_type_extra(ira->codegen, child_type,
                     ptr_type->data.pointer.is_const, ptr_type->data.pointer.is_volatile,
                     elem_ptr_instruction->ptr_len,
@@ -14377,7 +13970,7 @@ static ZigType *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstructionEle
         } else {
             uint64_t elem_val_scalar;
             if (!ir_resolve_usize(ira, elem_index, &elem_val_scalar))
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
 
             size_t bit_width = type_size_bits(ira->codegen, child_type);
             size_t bit_offset = bit_width * elem_val_scalar;
@@ -14385,13 +13978,13 @@ static ZigType *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstructionEle
             return_type = get_pointer_to_type_extra(ira->codegen, child_type,
                     ptr_type->data.pointer.is_const, ptr_type->data.pointer.is_volatile,
                     elem_ptr_instruction->ptr_len,
-                    1, (uint32_t)bit_offset, (uint32_t)bit_width);
+                    1, (uint32_t)bit_offset, ptr_type->data.pointer.host_int_bytes);
         }
     } else if (array_type->id == ZigTypeIdPointer) {
         if (array_type->data.pointer.ptr_len == PtrLenSingle) {
             ir_add_error_node(ira, elem_ptr_instruction->base.source_node,
                     buf_sprintf("index of single-item pointer"));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
         return_type = adjust_ptr_len(ira->codegen, array_type, elem_ptr_instruction->ptr_len);
     } else if (is_slice(array_type)) {
@@ -14400,21 +13993,21 @@ static ZigType *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstructionEle
     } else if (array_type->id == ZigTypeIdArgTuple) {
         ConstExprValue *ptr_val = ir_resolve_const(ira, array_ptr, UndefBad);
         if (!ptr_val)
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         ConstExprValue *args_val = ir_const_ptr_pointee(ira, ptr_val, elem_ptr_instruction->base.source_node);
         if (args_val == nullptr)
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         size_t start = args_val->data.x_arg_tuple.start_index;
         size_t end = args_val->data.x_arg_tuple.end_index;
         uint64_t elem_index_val;
         if (!ir_resolve_usize(ira, elem_index, &elem_index_val))
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         size_t index = elem_index_val;
         size_t len = end - start;
         if (index >= len) {
             ir_add_error(ira, &elem_ptr_instruction->base,
                 buf_sprintf("index %" ZIG_PRI_usize " outside argument list of size %" ZIG_PRI_usize "", index, len));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
         size_t abs_index = start + index;
         ZigFn *fn_entry = exec_fn_entry(ira->new_irb.exec);
@@ -14423,25 +14016,25 @@ static ZigType *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstructionEle
         bool is_const = true;
         bool is_volatile = false;
         if (var) {
-            return ir_analyze_var_ptr(ira, &elem_ptr_instruction->base, var);
+            return ir_get_var_ptr(ira, &elem_ptr_instruction->base, var);
         } else {
-            return ir_analyze_const_ptr(ira, &elem_ptr_instruction->base, &ira->codegen->const_void_val,
-                    ira->codegen->builtin_types.entry_void, ConstPtrMutComptimeConst, is_const, is_volatile);
+            return ir_get_const_ptr(ira, &elem_ptr_instruction->base, &ira->codegen->const_void_val,
+                    ira->codegen->builtin_types.entry_void, ConstPtrMutComptimeConst, is_const, is_volatile, 0);
         }
     } else {
         ir_add_error_node(ira, elem_ptr_instruction->base.source_node,
                 buf_sprintf("array access of non-array type '%s'", buf_ptr(&array_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     ZigType *usize = ira->codegen->builtin_types.entry_usize;
     IrInstruction *casted_elem_index = ir_implicit_cast(ira, elem_index, usize);
     if (casted_elem_index == ira->codegen->invalid_instruction)
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     bool safety_check_on = elem_ptr_instruction->safety_check_on;
     if ((err = ensure_complete_type(ira->codegen, return_type->data.pointer.child_type)))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     uint64_t elem_size = type_size(ira->codegen, return_type->data.pointer.child_type);
     uint64_t abi_align = get_abi_alignment(ira->codegen, return_type->data.pointer.child_type);
@@ -14454,7 +14047,7 @@ static ZigType *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstructionEle
                 ir_add_error_node(ira, elem_ptr_instruction->base.source_node,
                     buf_sprintf("index %" ZIG_PRI_u64 " outside array of size %" ZIG_PRI_u64,
                             index, array_len));
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             }
             safety_check_on = false;
         }
@@ -14486,14 +14079,15 @@ static ZigType *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstructionEle
             ConstExprValue *array_ptr_val = ir_const_ptr_pointee(ira, orig_array_ptr_val,
                                         elem_ptr_instruction->base.source_node);
             if (array_ptr_val == nullptr)
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
 
             if (array_ptr_val->special != ConstValSpecialRuntime &&
                 (array_type->id != ZigTypeIdPointer ||
                     array_ptr_val->data.x_ptr.special != ConstPtrSpecialHardCodedAddr))
             {
                 if (array_type->id == ZigTypeIdPointer) {
-                    ConstExprValue *out_val = ir_build_const_from(ira, &elem_ptr_instruction->base);
+                    IrInstruction *result = ir_const(ira, &elem_ptr_instruction->base, return_type);
+                    ConstExprValue *out_val = &result->value;
                     out_val->data.x_ptr.mut = array_ptr_val->data.x_ptr.mut;
                     size_t new_index;
                     size_t mem_size;
@@ -14538,26 +14132,26 @@ static ZigType *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstructionEle
                     if (new_index >= mem_size) {
                         ir_add_error_node(ira, elem_ptr_instruction->base.source_node,
                             buf_sprintf("index %" ZIG_PRI_u64 " outside pointer of size %" ZIG_PRI_usize "", index, old_size));
-                        return ira->codegen->builtin_types.entry_invalid;
+                        return ira->codegen->invalid_instruction;
                     }
-                    return return_type;
+                    return result;
                 } else if (is_slice(array_type)) {
                     ConstExprValue *ptr_field = &array_ptr_val->data.x_struct.fields[slice_ptr_index];
                     if (ptr_field->data.x_ptr.special == ConstPtrSpecialHardCodedAddr) {
                         IrInstruction *result = ir_build_elem_ptr(&ira->new_irb, elem_ptr_instruction->base.scope, elem_ptr_instruction->base.source_node,
                                 array_ptr, casted_elem_index, false, elem_ptr_instruction->ptr_len);
                         result->value.type = return_type;
-                        ir_link_new_instruction(result, &elem_ptr_instruction->base);
-                        return return_type;
+                        return result;
                     }
                     ConstExprValue *len_field = &array_ptr_val->data.x_struct.fields[slice_len_index];
-                    ConstExprValue *out_val = ir_build_const_from(ira, &elem_ptr_instruction->base);
+                    IrInstruction *result = ir_const(ira, &elem_ptr_instruction->base, return_type);
+                    ConstExprValue *out_val = &result->value;
                     uint64_t slice_len = bigint_as_unsigned(&len_field->data.x_bigint);
                     if (index >= slice_len) {
                         ir_add_error_node(ira, elem_ptr_instruction->base.source_node,
                             buf_sprintf("index %" ZIG_PRI_u64 " outside slice of size %" ZIG_PRI_u64,
                                 index, slice_len));
-                        return ira->codegen->builtin_types.entry_invalid;
+                        return ira->codegen->invalid_instruction;
                     }
                     out_val->data.x_ptr.mut = ptr_field->data.x_ptr.mut;
                     switch (ptr_field->data.x_ptr.special) {
@@ -14588,14 +14182,15 @@ static ZigType *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstructionEle
                         case ConstPtrSpecialFunction:
                             zig_panic("TODO elem ptr on a slice that was ptrcast from a function");
                     }
-                    return return_type;
+                    return result;
                 } else if (array_type->id == ZigTypeIdArray) {
-                    ConstExprValue *out_val = ir_build_const_from(ira, &elem_ptr_instruction->base);
+                    IrInstruction *result = ir_const(ira, &elem_ptr_instruction->base, return_type);
+                    ConstExprValue *out_val = &result->value;
                     out_val->data.x_ptr.special = ConstPtrSpecialBaseArray;
                     out_val->data.x_ptr.mut = orig_array_ptr_val->data.x_ptr.mut;
                     out_val->data.x_ptr.data.base_array.array_val = array_ptr_val;
                     out_val->data.x_ptr.data.base_array.elem_index = index;
-                    return return_type;
+                    return result;
                 } else {
                     zig_unreachable();
                 }
@@ -14604,6 +14199,12 @@ static ZigType *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstructionEle
 
     } else {
         // runtime known element index
+        if (type_requires_comptime(return_type)) {
+            ir_add_error(ira, elem_index,
+                buf_sprintf("values of type '%s' must be comptime known, but index value is runtime known",
+                    buf_ptr(&return_type->data.pointer.child_type->name)));
+            return ira->codegen->invalid_instruction;
+        }
         if (ptr_align < abi_align) {
             if (elem_size >= ptr_align && elem_size % ptr_align == 0) {
                 return_type = adjust_ptr_align(ira->codegen, return_type, ptr_align);
@@ -14619,8 +14220,7 @@ static ZigType *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstructionEle
     IrInstruction *result = ir_build_elem_ptr(&ira->new_irb, elem_ptr_instruction->base.scope, elem_ptr_instruction->base.source_node,
             array_ptr, casted_elem_index, safety_check_on, elem_ptr_instruction->ptr_len);
     result->value.type = return_type;
-    ir_link_new_instruction(result, &elem_ptr_instruction->base);
-    return return_type;
+    return result;
 }
 
 static IrInstruction *ir_analyze_container_member_access_inner(IrAnalyze *ira,
@@ -14680,10 +14280,10 @@ static IrInstruction *ir_analyze_container_field_ptr(IrAnalyze *ira, Buf *field_
         if (field) {
             bool is_packed = (bare_type->data.structure.layout == ContainerLayoutPacked);
             uint32_t align_bytes = is_packed ? 1 : get_abi_alignment(ira->codegen, field->type_entry);
-            size_t ptr_bit_offset = container_ptr->value.type->data.pointer.bit_offset;
-            size_t ptr_unaligned_bit_count = container_ptr->value.type->data.pointer.unaligned_bit_count;
-            size_t unaligned_bit_count_for_result_type = (ptr_unaligned_bit_count == 0) ?
-                field->unaligned_bit_count : type_size_bits(ira->codegen, field->type_entry);
+            uint32_t ptr_bit_offset = container_ptr->value.type->data.pointer.bit_offset_in_host;
+            uint32_t ptr_host_int_bytes = container_ptr->value.type->data.pointer.host_int_bytes;
+            uint32_t host_int_bytes_for_result_type = (ptr_host_int_bytes == 0) ?
+                get_host_int_bytes(ira->codegen, bare_type, field) : ptr_host_int_bytes;
             if (instr_is_comptime(container_ptr)) {
                 ConstExprValue *ptr_val = ir_resolve_const(ira, container_ptr, UndefBad);
                 if (!ptr_val)
@@ -14698,15 +14298,14 @@ static IrInstruction *ir_analyze_container_field_ptr(IrAnalyze *ira, Buf *field_
                     ConstExprValue *field_val = &struct_val->data.x_struct.fields[field->src_index];
                     ZigType *ptr_type = get_pointer_to_type_extra(ira->codegen, field_val->type,
                             is_const, is_volatile, PtrLenSingle, align_bytes,
-                            (uint32_t)(ptr_bit_offset + field->packed_bits_offset),
-                            (uint32_t)unaligned_bit_count_for_result_type);
-                    IrInstruction *result = ir_get_const(ira, source_instr);
+                            (uint32_t)(ptr_bit_offset + field->bit_offset_in_host),
+                            (uint32_t)host_int_bytes_for_result_type);
+                    IrInstruction *result = ir_const(ira, source_instr, ptr_type);
                     ConstExprValue *const_val = &result->value;
                     const_val->data.x_ptr.special = ConstPtrSpecialBaseStruct;
                     const_val->data.x_ptr.mut = container_ptr->value.data.x_ptr.mut;
                     const_val->data.x_ptr.data.base_struct.struct_val = struct_val;
                     const_val->data.x_ptr.data.base_struct.field_index = field->src_index;
-                    const_val->type = ptr_type;
                     return result;
                 }
             }
@@ -14715,8 +14314,8 @@ static IrInstruction *ir_analyze_container_field_ptr(IrAnalyze *ira, Buf *field_
             result->value.type = get_pointer_to_type_extra(ira->codegen, field->type_entry, is_const, is_volatile,
                     PtrLenSingle,
                     align_bytes,
-                    (uint32_t)(ptr_bit_offset + field->packed_bits_offset),
-                    (uint32_t)unaligned_bit_count_for_result_type);
+                    (uint32_t)(ptr_bit_offset + field->bit_offset_in_host),
+                    host_int_bytes_for_result_type);
             return result;
         } else {
             return ir_analyze_container_member_access_inner(ira, bare_type, field_name,
@@ -14764,12 +14363,11 @@ static IrInstruction *ir_analyze_container_field_ptr(IrAnalyze *ira, Buf *field_
                     ZigType *ptr_type = get_pointer_to_type_extra(ira->codegen, field_type,
                             is_const, is_volatile, PtrLenSingle, 0, 0, 0);
 
-                    IrInstruction *result = ir_get_const(ira, source_instr);
+                    IrInstruction *result = ir_const(ira, source_instr, ptr_type);
                     ConstExprValue *const_val = &result->value;
                     const_val->data.x_ptr.special = ConstPtrSpecialRef;
                     const_val->data.x_ptr.mut = container_ptr->value.data.x_ptr.mut;
                     const_val->data.x_ptr.data.ref.pointee = payload_val;
-                    const_val->type = ptr_type;
                     return result;
                 }
             }
@@ -14806,11 +14404,11 @@ static void add_link_lib_symbol(IrAnalyze *ira, Buf *lib_name, Buf *symbol_name,
 }
 
 
-static ZigType *ir_analyze_decl_ref(IrAnalyze *ira, IrInstruction *source_instruction, Tld *tld) {
+static IrInstruction *ir_analyze_decl_ref(IrAnalyze *ira, IrInstruction *source_instruction, Tld *tld) {
     bool pointer_only = false;
     resolve_top_level_decl(ira->codegen, tld, pointer_only, source_instruction->source_node);
     if (tld->resolution == TldResolutionInvalid)
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     switch (tld->id) {
         case TldIdContainer:
@@ -14824,7 +14422,7 @@ static ZigType *ir_analyze_decl_ref(IrAnalyze *ira, IrInstruction *source_instru
                 add_link_lib_symbol(ira, tld_var->extern_lib_name, &var->name, source_instruction->source_node);
             }
 
-            return ir_analyze_var_ptr(ira, source_instruction, var);
+            return ir_get_var_ptr(ira, source_instruction, var);
         }
         case TldIdFn:
         {
@@ -14833,7 +14431,7 @@ static ZigType *ir_analyze_decl_ref(IrAnalyze *ira, IrInstruction *source_instru
             assert(fn_entry->type_entry);
 
             if (type_is_invalid(fn_entry->type_entry))
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
 
             // TODO instead of allocating this every time, put it in the tld value and we can reference
             // the same one every time
@@ -14850,8 +14448,8 @@ static ZigType *ir_analyze_decl_ref(IrAnalyze *ira, IrInstruction *source_instru
 
             bool ptr_is_const = true;
             bool ptr_is_volatile = false;
-            return ir_analyze_const_ptr(ira, source_instruction, const_val, fn_entry->type_entry,
-                    ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
+            return ir_get_const_ptr(ira, source_instruction, const_val, fn_entry->type_entry,
+                    ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
         }
     }
     zig_unreachable();
@@ -14868,45 +14466,43 @@ static ErrorTableEntry *find_err_table_entry(ZigType *err_set_type, Buf *field_n
     return nullptr;
 }
 
-static ZigType *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstructionFieldPtr *field_ptr_instruction) {
+static IrInstruction *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstructionFieldPtr *field_ptr_instruction) {
     Error err;
-    IrInstruction *container_ptr = field_ptr_instruction->container_ptr->other;
+    IrInstruction *container_ptr = field_ptr_instruction->container_ptr->child;
     if (type_is_invalid(container_ptr->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (container_ptr->value.type->id != ZigTypeIdPointer) {
         ir_add_error_node(ira, field_ptr_instruction->base.source_node,
             buf_sprintf("attempt to dereference non-pointer type '%s'",
                 buf_ptr(&container_ptr->value.type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
     ZigType *container_type = container_ptr->value.type->data.pointer.child_type;
 
     Buf *field_name = field_ptr_instruction->field_name_buffer;
     if (!field_name) {
-        IrInstruction *field_name_expr = field_ptr_instruction->field_name_expr->other;
+        IrInstruction *field_name_expr = field_ptr_instruction->field_name_expr->child;
         field_name = ir_resolve_str(ira, field_name_expr);
         if (!field_name)
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
     }
 
 
     AstNode *source_node = field_ptr_instruction->base.source_node;
 
     if (type_is_invalid(container_type)) {
-        return container_type;
+        return ira->codegen->invalid_instruction;
     } else if (is_container_ref(container_type)) {
         assert(container_ptr->value.type->id == ZigTypeIdPointer);
         if (container_type->id == ZigTypeIdPointer) {
             ZigType *bare_type = container_ref_type(container_type);
             IrInstruction *container_child = ir_get_deref(ira, &field_ptr_instruction->base, container_ptr);
             IrInstruction *result = ir_analyze_container_field_ptr(ira, field_name, &field_ptr_instruction->base, container_child, bare_type);
-            ir_link_new_instruction(result, &field_ptr_instruction->base);
-            return result->value.type;
+            return result;
         } else {
             IrInstruction *result = ir_analyze_container_field_ptr(ira, field_name, &field_ptr_instruction->base, container_ptr, container_type);
-            ir_link_new_instruction(result, &field_ptr_instruction->base);
-            return result->value.type;
+            return result;
         }
     } else if (is_array_ref(container_type)) {
         if (buf_eql_str(field_name, "len")) {
@@ -14920,23 +14516,23 @@ static ZigType *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstructionFi
             ZigType *usize = ira->codegen->builtin_types.entry_usize;
             bool ptr_is_const = true;
             bool ptr_is_volatile = false;
-            return ir_analyze_const_ptr(ira, &field_ptr_instruction->base, len_val,
-                    usize, ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
+            return ir_get_const_ptr(ira, &field_ptr_instruction->base, len_val,
+                    usize, ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
         } else {
             ir_add_error_node(ira, source_node,
                 buf_sprintf("no member named '%s' in '%s'", buf_ptr(field_name),
                     buf_ptr(&container_type->name)));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
     } else if (container_type->id == ZigTypeIdArgTuple) {
         ConstExprValue *container_ptr_val = ir_resolve_const(ira, container_ptr, UndefBad);
         if (!container_ptr_val)
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
 
         assert(container_ptr->value.type->id == ZigTypeIdPointer);
         ConstExprValue *child_val = ir_const_ptr_pointee(ira, container_ptr_val, source_node);
         if (child_val == nullptr)
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
 
         if (buf_eql_str(field_name, "len")) {
             ConstExprValue *len_val = create_const_vals(1);
@@ -14946,27 +14542,27 @@ static ZigType *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstructionFi
             ZigType *usize = ira->codegen->builtin_types.entry_usize;
             bool ptr_is_const = true;
             bool ptr_is_volatile = false;
-            return ir_analyze_const_ptr(ira, &field_ptr_instruction->base, len_val,
-                    usize, ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
+            return ir_get_const_ptr(ira, &field_ptr_instruction->base, len_val,
+                    usize, ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
         } else {
             ir_add_error_node(ira, source_node,
                 buf_sprintf("no member named '%s' in '%s'", buf_ptr(field_name),
                     buf_ptr(&container_type->name)));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
     } else if (container_type->id == ZigTypeIdMetaType) {
         ConstExprValue *container_ptr_val = ir_resolve_const(ira, container_ptr, UndefBad);
         if (!container_ptr_val)
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
 
         assert(container_ptr->value.type->id == ZigTypeIdPointer);
         ConstExprValue *child_val = ir_const_ptr_pointee(ira, container_ptr_val, source_node);
         if (child_val == nullptr)
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         ZigType *child_type = child_val->data.x_type;
 
         if (type_is_invalid(child_type)) {
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         } else if (is_container(child_type)) {
             if (is_slice(child_type) && buf_eql_str(field_name, "Child")) {
                 bool ptr_is_const = true;
@@ -14974,22 +14570,22 @@ static ZigType *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstructionFi
                 TypeStructField *ptr_field = &child_type->data.structure.fields[slice_ptr_index];
                 assert(ptr_field->type_entry->id == ZigTypeIdPointer);
                 ZigType *child_type = ptr_field->type_entry->data.pointer.child_type;
-                return ir_analyze_const_ptr(ira, &field_ptr_instruction->base,
+                return ir_get_const_ptr(ira, &field_ptr_instruction->base,
                     create_const_type(ira->codegen, child_type),
                     ira->codegen->builtin_types.entry_type,
-                    ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
+                    ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
             }
             if (child_type->id == ZigTypeIdEnum) {
                 if ((err = ensure_complete_type(ira->codegen, child_type)))
-                    return ira->codegen->builtin_types.entry_invalid;
+                    return ira->codegen->invalid_instruction;
 
                 TypeEnumField *field = find_enum_type_field(child_type, field_name);
                 if (field) {
                     bool ptr_is_const = true;
                     bool ptr_is_volatile = false;
-                    return ir_analyze_const_ptr(ira, &field_ptr_instruction->base,
+                    return ir_get_const_ptr(ira, &field_ptr_instruction->base,
                             create_const_enum(child_type, &field->value), child_type,
-                            ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
+                            ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
                 }
             }
             ScopeDecls *container_scope = get_container_scope(child_type);
@@ -15005,21 +14601,21 @@ static ZigType *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstructionFi
                     child_type->data.unionation.decl_node->data.container_decl.auto_enum))
             {
                 if ((err = ensure_complete_type(ira->codegen, child_type)))
-                    return ira->codegen->builtin_types.entry_invalid;
+                    return ira->codegen->invalid_instruction;
                 TypeUnionField *field = find_union_type_field(child_type, field_name);
                 if (field) {
                     ZigType *enum_type = child_type->data.unionation.tag_type;
                     bool ptr_is_const = true;
                     bool ptr_is_volatile = false;
-                    return ir_analyze_const_ptr(ira, &field_ptr_instruction->base,
+                    return ir_get_const_ptr(ira, &field_ptr_instruction->base,
                             create_const_enum(enum_type, &field->enum_field->value), enum_type,
-                            ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
+                            ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
                 }
             }
             ir_add_error(ira, &field_ptr_instruction->base,
                 buf_sprintf("container '%s' has no member called '%s'",
                     buf_ptr(&child_type->name), buf_ptr(field_name)));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         } else if (child_type->id == ZigTypeIdErrorSet) {
             ErrorTableEntry *err_entry;
             ZigType *err_set_type;
@@ -15047,13 +14643,13 @@ static ZigType *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstructionFi
                 err_set_type = err_entry->set_with_only_this_in_it;
             } else {
                 if (!resolve_inferred_error_set(ira->codegen, child_type, field_ptr_instruction->base.source_node)) {
-                    return ira->codegen->builtin_types.entry_invalid;
+                    return ira->codegen->invalid_instruction;
                 }
                 err_entry = find_err_table_entry(child_type, field_name);
                 if (err_entry == nullptr) {
                     ir_add_error(ira, &field_ptr_instruction->base,
                         buf_sprintf("no error named '%s' in '%s'", buf_ptr(field_name), buf_ptr(&child_type->name)));
-                    return ira->codegen->builtin_types.entry_invalid;
+                    return ira->codegen->invalid_instruction;
                 }
                 err_set_type = child_type;
             }
@@ -15064,128 +14660,128 @@ static ZigType *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstructionFi
 
             bool ptr_is_const = true;
             bool ptr_is_volatile = false;
-            return ir_analyze_const_ptr(ira, &field_ptr_instruction->base, const_val,
-                    err_set_type, ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
+            return ir_get_const_ptr(ira, &field_ptr_instruction->base, const_val,
+                    err_set_type, ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
         } else if (child_type->id == ZigTypeIdInt) {
             if (buf_eql_str(field_name, "bit_count")) {
                 bool ptr_is_const = true;
                 bool ptr_is_volatile = false;
-                return ir_analyze_const_ptr(ira, &field_ptr_instruction->base,
+                return ir_get_const_ptr(ira, &field_ptr_instruction->base,
                     create_const_unsigned_negative(ira->codegen->builtin_types.entry_num_lit_int,
                         child_type->data.integral.bit_count, false),
                     ira->codegen->builtin_types.entry_num_lit_int,
-                    ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
+                    ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
             } else if (buf_eql_str(field_name, "is_signed")) {
                 bool ptr_is_const = true;
                 bool ptr_is_volatile = false;
-                return ir_analyze_const_ptr(ira, &field_ptr_instruction->base,
+                return ir_get_const_ptr(ira, &field_ptr_instruction->base,
                     create_const_bool(ira->codegen, child_type->data.integral.is_signed),
                     ira->codegen->builtin_types.entry_bool,
-                    ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
+                    ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
             } else {
                 ir_add_error(ira, &field_ptr_instruction->base,
                     buf_sprintf("type '%s' has no member called '%s'",
                         buf_ptr(&child_type->name), buf_ptr(field_name)));
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             }
         } else if (child_type->id == ZigTypeIdFloat) {
             if (buf_eql_str(field_name, "bit_count")) {
                 bool ptr_is_const = true;
                 bool ptr_is_volatile = false;
-                return ir_analyze_const_ptr(ira, &field_ptr_instruction->base,
+                return ir_get_const_ptr(ira, &field_ptr_instruction->base,
                     create_const_unsigned_negative(ira->codegen->builtin_types.entry_num_lit_int,
                         child_type->data.floating.bit_count, false),
                     ira->codegen->builtin_types.entry_num_lit_int,
-                    ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
+                    ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
             } else {
                 ir_add_error(ira, &field_ptr_instruction->base,
                     buf_sprintf("type '%s' has no member called '%s'",
                         buf_ptr(&child_type->name), buf_ptr(field_name)));
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             }
         } else if (child_type->id == ZigTypeIdPointer) {
             if (buf_eql_str(field_name, "Child")) {
                 bool ptr_is_const = true;
                 bool ptr_is_volatile = false;
-                return ir_analyze_const_ptr(ira, &field_ptr_instruction->base,
+                return ir_get_const_ptr(ira, &field_ptr_instruction->base,
                     create_const_type(ira->codegen, child_type->data.pointer.child_type),
                     ira->codegen->builtin_types.entry_type,
-                    ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
+                    ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
             } else if (buf_eql_str(field_name, "alignment")) {
                 bool ptr_is_const = true;
                 bool ptr_is_volatile = false;
                 if ((err = type_resolve(ira->codegen, child_type->data.pointer.child_type,
                                 ResolveStatusAlignmentKnown)))
                 {
-                    return ira->codegen->builtin_types.entry_invalid;
+                    return ira->codegen->invalid_instruction;
                 }
-                return ir_analyze_const_ptr(ira, &field_ptr_instruction->base,
+                return ir_get_const_ptr(ira, &field_ptr_instruction->base,
                     create_const_unsigned_negative(ira->codegen->builtin_types.entry_num_lit_int,
                         get_ptr_align(ira->codegen, child_type), false),
                     ira->codegen->builtin_types.entry_num_lit_int,
-                    ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
+                    ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
             } else {
                 ir_add_error(ira, &field_ptr_instruction->base,
                     buf_sprintf("type '%s' has no member called '%s'",
                         buf_ptr(&child_type->name), buf_ptr(field_name)));
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             }
         } else if (child_type->id == ZigTypeIdArray) {
             if (buf_eql_str(field_name, "Child")) {
                 bool ptr_is_const = true;
                 bool ptr_is_volatile = false;
-                return ir_analyze_const_ptr(ira, &field_ptr_instruction->base,
+                return ir_get_const_ptr(ira, &field_ptr_instruction->base,
                     create_const_type(ira->codegen, child_type->data.array.child_type),
                     ira->codegen->builtin_types.entry_type,
-                    ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
+                    ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
             } else if (buf_eql_str(field_name, "len")) {
                 bool ptr_is_const = true;
                 bool ptr_is_volatile = false;
-                return ir_analyze_const_ptr(ira, &field_ptr_instruction->base,
+                return ir_get_const_ptr(ira, &field_ptr_instruction->base,
                     create_const_unsigned_negative(ira->codegen->builtin_types.entry_num_lit_int,
                         child_type->data.array.len, false),
                     ira->codegen->builtin_types.entry_num_lit_int,
-                    ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
+                    ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
             } else {
                 ir_add_error(ira, &field_ptr_instruction->base,
                     buf_sprintf("type '%s' has no member called '%s'",
                         buf_ptr(&child_type->name), buf_ptr(field_name)));
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             }
         } else if (child_type->id == ZigTypeIdErrorUnion) {
             if (buf_eql_str(field_name, "Payload")) {
                 bool ptr_is_const = true;
                 bool ptr_is_volatile = false;
-                return ir_analyze_const_ptr(ira, &field_ptr_instruction->base,
+                return ir_get_const_ptr(ira, &field_ptr_instruction->base,
                     create_const_type(ira->codegen, child_type->data.error_union.payload_type),
                     ira->codegen->builtin_types.entry_type,
-                    ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
+                    ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
             } else if (buf_eql_str(field_name, "ErrorSet")) {
                 bool ptr_is_const = true;
                 bool ptr_is_volatile = false;
-                return ir_analyze_const_ptr(ira, &field_ptr_instruction->base,
+                return ir_get_const_ptr(ira, &field_ptr_instruction->base,
                     create_const_type(ira->codegen, child_type->data.error_union.err_set_type),
                     ira->codegen->builtin_types.entry_type,
-                    ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
+                    ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
             } else {
                 ir_add_error(ira, &field_ptr_instruction->base,
                     buf_sprintf("type '%s' has no member called '%s'",
                         buf_ptr(&child_type->name), buf_ptr(field_name)));
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             }
         } else if (child_type->id == ZigTypeIdOptional) {
             if (buf_eql_str(field_name, "Child")) {
                 bool ptr_is_const = true;
                 bool ptr_is_volatile = false;
-                return ir_analyze_const_ptr(ira, &field_ptr_instruction->base,
+                return ir_get_const_ptr(ira, &field_ptr_instruction->base,
                     create_const_type(ira->codegen, child_type->data.maybe.child_type),
                     ira->codegen->builtin_types.entry_type,
-                    ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
+                    ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
             } else {
                 ir_add_error(ira, &field_ptr_instruction->base,
                     buf_sprintf("type '%s' has no member called '%s'",
                         buf_ptr(&child_type->name), buf_ptr(field_name)));
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             }
         } else if (child_type->id == ZigTypeIdFn) {
             if (buf_eql_str(field_name, "ReturnType")) {
@@ -15195,50 +14791,50 @@ static ZigType *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstructionFi
 
                     ir_add_error(ira, &field_ptr_instruction->base,
                         buf_sprintf("ReturnType has not been resolved because '%s' is generic", buf_ptr(&child_type->name)));
-                    return ira->codegen->builtin_types.entry_invalid;
+                    return ira->codegen->invalid_instruction;
                 }
 
                 bool ptr_is_const = true;
                 bool ptr_is_volatile = false;
-                return ir_analyze_const_ptr(ira, &field_ptr_instruction->base,
+                return ir_get_const_ptr(ira, &field_ptr_instruction->base,
                     create_const_type(ira->codegen, child_type->data.fn.fn_type_id.return_type),
                     ira->codegen->builtin_types.entry_type,
-                    ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
+                    ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
             } else if (buf_eql_str(field_name, "is_var_args")) {
                 bool ptr_is_const = true;
                 bool ptr_is_volatile = false;
-                return ir_analyze_const_ptr(ira, &field_ptr_instruction->base,
+                return ir_get_const_ptr(ira, &field_ptr_instruction->base,
                     create_const_bool(ira->codegen, child_type->data.fn.fn_type_id.is_var_args),
                     ira->codegen->builtin_types.entry_bool,
-                    ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
+                    ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
             } else if (buf_eql_str(field_name, "arg_count")) {
                 bool ptr_is_const = true;
                 bool ptr_is_volatile = false;
-                return ir_analyze_const_ptr(ira, &field_ptr_instruction->base,
+                return ir_get_const_ptr(ira, &field_ptr_instruction->base,
                     create_const_usize(ira->codegen, child_type->data.fn.fn_type_id.param_count),
                     ira->codegen->builtin_types.entry_usize,
-                    ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
+                    ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
             } else {
                 ir_add_error(ira, &field_ptr_instruction->base,
                     buf_sprintf("type '%s' has no member called '%s'",
                         buf_ptr(&child_type->name), buf_ptr(field_name)));
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             }
         } else {
             ir_add_error(ira, &field_ptr_instruction->base,
                 buf_sprintf("type '%s' does not support field access", buf_ptr(&child_type->name)));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
     } else if (container_type->id == ZigTypeIdNamespace) {
         assert(container_ptr->value.type->id == ZigTypeIdPointer);
         ConstExprValue *container_ptr_val = ir_resolve_const(ira, container_ptr, UndefBad);
         if (!container_ptr_val)
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
 
         ConstExprValue *namespace_val = ir_const_ptr_pointee(ira, container_ptr_val,
                 field_ptr_instruction->base.source_node);
         if (namespace_val == nullptr)
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         assert(namespace_val->special == ConstValSpecialStatic);
 
         ImportTableEntry *namespace_import = namespace_val->data.x_import;
@@ -15251,78 +14847,74 @@ static ZigType *ir_analyze_instruction_field_ptr(IrAnalyze *ira, IrInstructionFi
                 ErrorMsg *msg = ir_add_error_node(ira, source_node,
                     buf_sprintf("'%s' is private", buf_ptr(field_name)));
                 add_error_note(ira->codegen, msg, tld->source_node, buf_sprintf("declared here"));
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             }
             return ir_analyze_decl_ref(ira, &field_ptr_instruction->base, tld);
         } else {
             const char *import_name = namespace_import->path ? buf_ptr(namespace_import->path) : "(C import)";
             ir_add_error_node(ira, source_node,
                 buf_sprintf("no member named '%s' in '%s'", buf_ptr(field_name), import_name));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
     } else {
         ir_add_error_node(ira, field_ptr_instruction->base.source_node,
             buf_sprintf("type '%s' does not support field access", buf_ptr(&container_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 }
 
-static ZigType *ir_analyze_instruction_load_ptr(IrAnalyze *ira, IrInstructionLoadPtr *load_ptr_instruction) {
-    IrInstruction *ptr = load_ptr_instruction->ptr->other;
+static IrInstruction *ir_analyze_instruction_load_ptr(IrAnalyze *ira, IrInstructionLoadPtr *load_ptr_instruction) {
+    IrInstruction *ptr = load_ptr_instruction->ptr->child;
     if (type_is_invalid(ptr->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
-
-    IrInstruction *result = ir_get_deref(ira, &load_ptr_instruction->base, ptr);
-    ir_link_new_instruction(result, &load_ptr_instruction->base);
-    assert(result->value.type);
-    return result->value.type;
+        return ira->codegen->invalid_instruction;
+    return ir_get_deref(ira, &load_ptr_instruction->base, ptr);
 }
 
-static ZigType *ir_analyze_instruction_store_ptr(IrAnalyze *ira, IrInstructionStorePtr *store_ptr_instruction) {
-    IrInstruction *ptr = store_ptr_instruction->ptr->other;
+static IrInstruction *ir_analyze_instruction_store_ptr(IrAnalyze *ira, IrInstructionStorePtr *store_ptr_instruction) {
+    IrInstruction *ptr = store_ptr_instruction->ptr->child;
     if (type_is_invalid(ptr->value.type))
-        return ptr->value.type;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *value = store_ptr_instruction->value->other;
+    IrInstruction *value = store_ptr_instruction->value->child;
     if (type_is_invalid(value->value.type))
-        return value->value.type;
+        return ira->codegen->invalid_instruction;
 
     if (ptr->value.type->id != ZigTypeIdPointer) {
         ir_add_error(ira, ptr,
             buf_sprintf("attempt to dereference non pointer type '%s'", buf_ptr(&ptr->value.type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     if (ptr->value.data.x_ptr.special == ConstPtrSpecialDiscard) {
-        return ir_analyze_void(ira, &store_ptr_instruction->base);
+        return ir_const_void(ira, &store_ptr_instruction->base);
     }
 
     if (ptr->value.type->data.pointer.is_const && !store_ptr_instruction->base.is_gen) {
         ir_add_error(ira, &store_ptr_instruction->base, buf_sprintf("cannot assign to constant"));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     ZigType *child_type = ptr->value.type->data.pointer.child_type;
     IrInstruction *casted_value = ir_implicit_cast(ira, value, child_type);
     if (casted_value == ira->codegen->invalid_instruction)
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (instr_is_comptime(ptr) && ptr->value.data.x_ptr.special != ConstPtrSpecialHardCodedAddr) {
         if (ptr->value.data.x_ptr.mut == ConstPtrMutComptimeConst) {
             ir_add_error(ira, &store_ptr_instruction->base, buf_sprintf("cannot assign to constant"));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
         if (ptr->value.data.x_ptr.mut == ConstPtrMutComptimeVar) {
             if (instr_is_comptime(casted_value)) {
                 ConstExprValue *dest_val = ir_const_ptr_pointee(ira, &ptr->value, store_ptr_instruction->base.source_node);
                 if (dest_val == nullptr)
-                    return ira->codegen->builtin_types.entry_invalid;
+                    return ira->codegen->invalid_instruction;
                 if (dest_val->special != ConstValSpecialRuntime) {
                     *dest_val = casted_value->value;
                     if (!ira->new_irb.current_basic_block->must_be_comptime_source_instr) {
                         ira->new_irb.current_basic_block->must_be_comptime_source_instr = &store_ptr_instruction->base;
                     }
-                    return ir_analyze_void(ira, &store_ptr_instruction->base);
+                    return ir_const_void(ira, &store_ptr_instruction->base);
                 }
             }
             ir_add_error(ira, &store_ptr_instruction->base,
@@ -15330,19 +14922,22 @@ static ZigType *ir_analyze_instruction_store_ptr(IrAnalyze *ira, IrInstructionSt
             ConstExprValue *dest_val = const_ptr_pointee_unchecked(ira->codegen, &ptr->value);
             dest_val->type = ira->codegen->builtin_types.entry_invalid;
 
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
     }
 
-    ir_build_store_ptr_from(&ira->new_irb, &store_ptr_instruction->base, ptr, casted_value);
-    return ira->codegen->builtin_types.entry_void;
+    IrInstruction *result = ir_build_store_ptr(&ira->new_irb,
+        store_ptr_instruction->base.scope, store_ptr_instruction->base.source_node,
+        ptr, casted_value);
+    result->value.type = ira->codegen->builtin_types.entry_void;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_typeof(IrAnalyze *ira, IrInstructionTypeOf *typeof_instruction) {
-    IrInstruction *expr_value = typeof_instruction->value->other;
+static IrInstruction *ir_analyze_instruction_typeof(IrAnalyze *ira, IrInstructionTypeOf *typeof_instruction) {
+    IrInstruction *expr_value = typeof_instruction->value->child;
     ZigType *type_entry = expr_value->value.type;
     if (type_is_invalid(type_entry))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     switch (type_entry->id) {
         case ZigTypeIdInvalid:
             zig_unreachable(); // handled above
@@ -15370,24 +14965,19 @@ static ZigType *ir_analyze_instruction_typeof(IrAnalyze *ira, IrInstructionTypeO
         case ZigTypeIdArgTuple:
         case ZigTypeIdOpaque:
         case ZigTypeIdPromise:
-            {
-                ConstExprValue *out_val = ir_build_const_from(ira, &typeof_instruction->base);
-                out_val->data.x_type = type_entry;
-
-                return ira->codegen->builtin_types.entry_type;
-            }
+            return ir_const_type(ira, &typeof_instruction->base, type_entry);
     }
 
     zig_unreachable();
 }
 
-static ZigType *ir_analyze_instruction_to_ptr_type(IrAnalyze *ira,
+static IrInstruction *ir_analyze_instruction_to_ptr_type(IrAnalyze *ira,
         IrInstructionToPtrType *to_ptr_type_instruction)
 {
-    IrInstruction *value = to_ptr_type_instruction->value->other;
+    IrInstruction *value = to_ptr_type_instruction->value->child;
     ZigType *type_entry = value->value.type;
     if (type_is_invalid(type_entry))
-        return type_entry;
+        return ira->codegen->invalid_instruction;
 
     ZigType *ptr_type;
     if (type_entry->id == ZigTypeIdArray) {
@@ -15397,76 +14987,69 @@ static ZigType *ir_analyze_instruction_to_ptr_type(IrAnalyze *ira,
     } else if (type_entry->id == ZigTypeIdArgTuple) {
         ConstExprValue *arg_tuple_val = ir_resolve_const(ira, value, UndefBad);
         if (!arg_tuple_val)
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         zig_panic("TODO for loop on var args");
     } else {
         ir_add_error_node(ira, to_ptr_type_instruction->base.source_node,
                 buf_sprintf("expected array type, found '%s'", buf_ptr(&type_entry->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
-    ConstExprValue *out_val = ir_build_const_from(ira, &to_ptr_type_instruction->base);
-    out_val->data.x_type = ptr_type;
-    return ira->codegen->builtin_types.entry_type;
+    return ir_const_type(ira, &to_ptr_type_instruction->base, ptr_type);
 }
 
-static ZigType *ir_analyze_instruction_ptr_type_child(IrAnalyze *ira,
+static IrInstruction *ir_analyze_instruction_ptr_type_child(IrAnalyze *ira,
         IrInstructionPtrTypeChild *ptr_type_child_instruction)
 {
-    IrInstruction *type_value = ptr_type_child_instruction->value->other;
+    IrInstruction *type_value = ptr_type_child_instruction->value->child;
     ZigType *type_entry = ir_resolve_type(ira, type_value);
     if (type_is_invalid(type_entry))
-        return type_entry;
+        return ira->codegen->invalid_instruction;
 
     if (type_entry->id != ZigTypeIdPointer) {
         ir_add_error_node(ira, ptr_type_child_instruction->base.source_node,
                 buf_sprintf("expected pointer type, found '%s'", buf_ptr(&type_entry->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
-    ConstExprValue *out_val = ir_build_const_from(ira, &ptr_type_child_instruction->base);
-    out_val->data.x_type = type_entry->data.pointer.child_type;
-    return ira->codegen->builtin_types.entry_type;
+    return ir_const_type(ira, &ptr_type_child_instruction->base, type_entry->data.pointer.child_type);
 }
 
-static ZigType *ir_analyze_instruction_set_cold(IrAnalyze *ira, IrInstructionSetCold *instruction) {
+static IrInstruction *ir_analyze_instruction_set_cold(IrAnalyze *ira, IrInstructionSetCold *instruction) {
     if (ira->new_irb.exec->is_inline) {
         // ignore setCold when running functions at compile time
-        ir_build_const_from(ira, &instruction->base);
-        return ira->codegen->builtin_types.entry_void;
+        return ir_const_void(ira, &instruction->base);
     }
 
-    IrInstruction *is_cold_value = instruction->is_cold->other;
+    IrInstruction *is_cold_value = instruction->is_cold->child;
     bool want_cold;
     if (!ir_resolve_bool(ira, is_cold_value, &want_cold))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     ZigFn *fn_entry = scope_fn_entry(instruction->base.scope);
     if (fn_entry == nullptr) {
         ir_add_error(ira, &instruction->base, buf_sprintf("@setCold outside function"));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     if (fn_entry->set_cold_node != nullptr) {
         ErrorMsg *msg = ir_add_error(ira, &instruction->base, buf_sprintf("cold set twice in same function"));
         add_error_note(ira->codegen, msg, fn_entry->set_cold_node, buf_sprintf("first set here"));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     fn_entry->set_cold_node = instruction->base.source_node;
     fn_entry->is_cold = want_cold;
 
-    ir_build_const_from(ira, &instruction->base);
-    return ira->codegen->builtin_types.entry_void;
+    return ir_const_void(ira, &instruction->base);
 }
 
-static ZigType *ir_analyze_instruction_set_runtime_safety(IrAnalyze *ira,
+static IrInstruction *ir_analyze_instruction_set_runtime_safety(IrAnalyze *ira,
         IrInstructionSetRuntimeSafety *set_runtime_safety_instruction)
 {
     if (ira->new_irb.exec->is_inline) {
         // ignore setRuntimeSafety when running functions at compile time
-        ir_build_const_from(ira, &set_runtime_safety_instruction->base);
-        return ira->codegen->builtin_types.entry_void;
+        return ir_const_void(ira, &set_runtime_safety_instruction->base);
     }
 
     bool *safety_off_ptr;
@@ -15498,32 +15081,30 @@ static ZigType *ir_analyze_instruction_set_runtime_safety(IrAnalyze *ira,
     }
     assert(scope != nullptr);
 
-    IrInstruction *safety_on_value = set_runtime_safety_instruction->safety_on->other;
+    IrInstruction *safety_on_value = set_runtime_safety_instruction->safety_on->child;
     bool want_runtime_safety;
     if (!ir_resolve_bool(ira, safety_on_value, &want_runtime_safety))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     AstNode *source_node = set_runtime_safety_instruction->base.source_node;
     if (*safety_set_node_ptr) {
         ErrorMsg *msg = ir_add_error_node(ira, source_node,
                 buf_sprintf("runtime safety set twice for same scope"));
         add_error_note(ira->codegen, msg, *safety_set_node_ptr, buf_sprintf("first set here"));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
     *safety_set_node_ptr = source_node;
     *safety_off_ptr = !want_runtime_safety;
 
-    ir_build_const_from(ira, &set_runtime_safety_instruction->base);
-    return ira->codegen->builtin_types.entry_void;
+    return ir_const_void(ira, &set_runtime_safety_instruction->base);
 }
 
-static ZigType *ir_analyze_instruction_set_float_mode(IrAnalyze *ira,
+static IrInstruction *ir_analyze_instruction_set_float_mode(IrAnalyze *ira,
         IrInstructionSetFloatMode *instruction)
 {
     if (ira->new_irb.exec->is_inline) {
         // ignore setFloatMode when running functions at compile time
-        ir_build_const_from(ira, &instruction->base);
-        return ira->codegen->builtin_types.entry_void;
+        return ir_const_void(ira, &instruction->base);
     }
 
     bool *fast_math_on_ptr;
@@ -15555,38 +15136,37 @@ static ZigType *ir_analyze_instruction_set_float_mode(IrAnalyze *ira,
     }
     assert(scope != nullptr);
 
-    IrInstruction *float_mode_value = instruction->mode_value->other;
+    IrInstruction *float_mode_value = instruction->mode_value->child;
     FloatMode float_mode_scalar;
     if (!ir_resolve_float_mode(ira, float_mode_value, &float_mode_scalar))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     AstNode *source_node = instruction->base.source_node;
     if (*fast_math_set_node_ptr) {
         ErrorMsg *msg = ir_add_error_node(ira, source_node,
                 buf_sprintf("float mode set twice for same scope"));
         add_error_note(ira->codegen, msg, *fast_math_set_node_ptr, buf_sprintf("first set here"));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
     *fast_math_set_node_ptr = source_node;
     *fast_math_on_ptr = (float_mode_scalar == FloatModeOptimized);
 
-    ir_build_const_from(ira, &instruction->base);
-    return ira->codegen->builtin_types.entry_void;
+    return ir_const_void(ira, &instruction->base);
 }
 
-static ZigType *ir_analyze_instruction_slice_type(IrAnalyze *ira,
+static IrInstruction *ir_analyze_instruction_slice_type(IrAnalyze *ira,
         IrInstructionSliceType *slice_type_instruction)
 {
     Error err;
     uint32_t align_bytes = 0;
     if (slice_type_instruction->align_value != nullptr) {
-        if (!ir_resolve_align(ira, slice_type_instruction->align_value->other, &align_bytes))
-            return ira->codegen->builtin_types.entry_invalid;
+        if (!ir_resolve_align(ira, slice_type_instruction->align_value->child, &align_bytes))
+            return ira->codegen->invalid_instruction;
     }
 
-    ZigType *child_type = ir_resolve_type(ira, slice_type_instruction->child_type->other);
+    ZigType *child_type = ir_resolve_type(ira, slice_type_instruction->child_type->child);
     if (type_is_invalid(child_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     bool is_const = slice_type_instruction->is_const;
     bool is_volatile = slice_type_instruction->is_volatile;
@@ -15601,7 +15181,7 @@ static ZigType *ir_analyze_instruction_slice_type(IrAnalyze *ira,
         case ZigTypeIdOpaque:
             ir_add_error_node(ira, slice_type_instruction->base.source_node,
                     buf_sprintf("slice of type '%s' not allowed", buf_ptr(&child_type->name)));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         case ZigTypeIdMetaType:
         case ZigTypeIdVoid:
         case ZigTypeIdBool:
@@ -15623,19 +15203,17 @@ static ZigType *ir_analyze_instruction_slice_type(IrAnalyze *ira,
         case ZigTypeIdPromise:
             {
                 if ((err = type_resolve(ira->codegen, child_type, ResolveStatusZeroBitsKnown)))
-                    return ira->codegen->builtin_types.entry_invalid;
+                    return ira->codegen->invalid_instruction;
                 ZigType *slice_ptr_type = get_pointer_to_type_extra(ira->codegen, child_type,
                         is_const, is_volatile, PtrLenUnknown, align_bytes, 0, 0);
                 ZigType *result_type = get_slice_type(ira->codegen, slice_ptr_type);
-                ConstExprValue *out_val = ir_build_const_from(ira, &slice_type_instruction->base);
-                out_val->data.x_type = result_type;
-                return ira->codegen->builtin_types.entry_type;
+                return ir_const_type(ira, &slice_type_instruction->base, result_type);
             }
     }
     zig_unreachable();
 }
 
-static ZigType *ir_analyze_instruction_asm(IrAnalyze *ira, IrInstructionAsm *asm_instruction) {
+static IrInstruction *ir_analyze_instruction_asm(IrAnalyze *ira, IrInstructionAsm *asm_instruction) {
     assert(asm_instruction->base.source_node->type == NodeTypeAsmExpr);
 
     AstNodeAsmExpr *asm_expr = &asm_instruction->base.source_node->data.asm_expr;
@@ -15647,18 +15225,17 @@ static ZigType *ir_analyze_instruction_asm(IrAnalyze *ira, IrInstructionAsm *asm
         {
             ir_add_error(ira, &asm_instruction->base,
                 buf_sprintf("global assembly cannot have inputs, outputs, or clobbers"));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
 
         buf_append_char(&ira->codegen->global_asm, '\n');
         buf_append_buf(&ira->codegen->global_asm, asm_expr->asm_template);
 
-        ir_build_const_from(ira, &asm_instruction->base);
-        return ira->codegen->builtin_types.entry_void;
+        return ir_const_void(ira, &asm_instruction->base);
     }
 
     if (!ir_emit_global_runtime_side_effect(ira, &asm_instruction->base))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     // TODO validate the output types and variable types
 
@@ -15669,38 +15246,41 @@ static ZigType *ir_analyze_instruction_asm(IrAnalyze *ira, IrInstructionAsm *asm
     for (size_t i = 0; i < asm_expr->output_list.length; i += 1) {
         AsmOutput *asm_output = asm_expr->output_list.at(i);
         if (asm_output->return_type) {
-            output_types[i] = asm_instruction->output_types[i]->other;
+            output_types[i] = asm_instruction->output_types[i]->child;
             return_type = ir_resolve_type(ira, output_types[i]);
             if (type_is_invalid(return_type))
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
         }
     }
 
     for (size_t i = 0; i < asm_expr->input_list.length; i += 1) {
-        input_list[i] = asm_instruction->input_list[i]->other;
+        input_list[i] = asm_instruction->input_list[i]->child;
         if (type_is_invalid(input_list[i]->value.type))
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
     }
 
-    ir_build_asm_from(&ira->new_irb, &asm_instruction->base, input_list, output_types,
-        asm_instruction->output_vars, asm_instruction->return_count, asm_instruction->has_side_effects);
-    return return_type;
+    IrInstruction *result = ir_build_asm(&ira->new_irb,
+        asm_instruction->base.scope, asm_instruction->base.source_node,
+        input_list, output_types, asm_instruction->output_vars, asm_instruction->return_count,
+        asm_instruction->has_side_effects);
+    result->value.type = return_type;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_array_type(IrAnalyze *ira,
+static IrInstruction *ir_analyze_instruction_array_type(IrAnalyze *ira,
         IrInstructionArrayType *array_type_instruction)
 {
     Error err;
 
-    IrInstruction *size_value = array_type_instruction->size->other;
+    IrInstruction *size_value = array_type_instruction->size->child;
     uint64_t size;
     if (!ir_resolve_usize(ira, size_value, &size))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *child_type_value = array_type_instruction->child_type->other;
+    IrInstruction *child_type_value = array_type_instruction->child_type->child;
     ZigType *child_type = ir_resolve_type(ira, child_type_value);
     if (type_is_invalid(child_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     switch (child_type->id) {
         case ZigTypeIdInvalid: // handled above
             zig_unreachable();
@@ -15711,7 +15291,7 @@ static ZigType *ir_analyze_instruction_array_type(IrAnalyze *ira,
         case ZigTypeIdOpaque:
             ir_add_error_node(ira, array_type_instruction->base.source_node,
                     buf_sprintf("array of type '%s' not allowed", buf_ptr(&child_type->name)));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         case ZigTypeIdMetaType:
         case ZigTypeIdVoid:
         case ZigTypeIdBool:
@@ -15733,43 +15313,39 @@ static ZigType *ir_analyze_instruction_array_type(IrAnalyze *ira,
         case ZigTypeIdPromise:
             {
                 if ((err = ensure_complete_type(ira->codegen, child_type)))
-                    return ira->codegen->builtin_types.entry_invalid;
+                    return ira->codegen->invalid_instruction;
                 ZigType *result_type = get_array_type(ira->codegen, child_type, size);
-                ConstExprValue *out_val = ir_build_const_from(ira, &array_type_instruction->base);
-                out_val->data.x_type = result_type;
-                return ira->codegen->builtin_types.entry_type;
+                return ir_const_type(ira, &array_type_instruction->base, result_type);
             }
     }
     zig_unreachable();
 }
 
-static ZigType *ir_analyze_instruction_promise_type(IrAnalyze *ira, IrInstructionPromiseType *instruction) {
+static IrInstruction *ir_analyze_instruction_promise_type(IrAnalyze *ira, IrInstructionPromiseType *instruction) {
     ZigType *promise_type;
 
     if (instruction->payload_type == nullptr) {
         promise_type = ira->codegen->builtin_types.entry_promise;
     } else {
-        ZigType *payload_type = ir_resolve_type(ira, instruction->payload_type->other);
+        ZigType *payload_type = ir_resolve_type(ira, instruction->payload_type->child);
         if (type_is_invalid(payload_type))
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
 
         promise_type = get_promise_type(ira->codegen, payload_type);
     }
 
-    ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-    out_val->data.x_type = promise_type;
-    return ira->codegen->builtin_types.entry_type;
+    return ir_const_type(ira, &instruction->base, promise_type);
 }
 
-static ZigType *ir_analyze_instruction_size_of(IrAnalyze *ira,
+static IrInstruction *ir_analyze_instruction_size_of(IrAnalyze *ira,
         IrInstructionSizeOf *size_of_instruction)
 {
     Error err;
-    IrInstruction *type_value = size_of_instruction->type_value->other;
+    IrInstruction *type_value = size_of_instruction->type_value->child;
     ZigType *type_entry = ir_resolve_type(ira, type_value);
 
     if ((err = ensure_complete_type(ira->codegen, type_entry)))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     switch (type_entry->id) {
         case ZigTypeIdInvalid: // handled above
@@ -15786,7 +15362,7 @@ static ZigType *ir_analyze_instruction_size_of(IrAnalyze *ira,
         case ZigTypeIdOpaque:
             ir_add_error_node(ira, size_of_instruction->base.source_node,
                     buf_sprintf("no size available for type '%s'", buf_ptr(&type_entry->name)));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         case ZigTypeIdVoid:
         case ZigTypeIdBool:
         case ZigTypeIdInt:
@@ -15803,18 +15379,16 @@ static ZigType *ir_analyze_instruction_size_of(IrAnalyze *ira,
         case ZigTypeIdPromise:
             {
                 uint64_t size_in_bytes = type_size(ira->codegen, type_entry);
-                ConstExprValue *out_val = ir_build_const_from(ira, &size_of_instruction->base);
-                bigint_init_unsigned(&out_val->data.x_bigint, size_in_bytes);
-                return ira->codegen->builtin_types.entry_num_lit_int;
+                return ir_const_unsigned(ira, &size_of_instruction->base, size_in_bytes);
             }
     }
     zig_unreachable();
 }
 
-static ZigType *ir_analyze_instruction_test_non_null(IrAnalyze *ira, IrInstructionTestNonNull *instruction) {
-    IrInstruction *value = instruction->value->other;
+static IrInstruction *ir_analyze_instruction_test_non_null(IrAnalyze *ira, IrInstructionTestNonNull *instruction) {
+    IrInstruction *value = instruction->value->child;
     if (type_is_invalid(value->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     ZigType *type_entry = value->value.type;
 
@@ -15822,43 +15396,39 @@ static ZigType *ir_analyze_instruction_test_non_null(IrAnalyze *ira, IrInstructi
         if (instr_is_comptime(value)) {
             ConstExprValue *maybe_val = ir_resolve_const(ira, value, UndefBad);
             if (!maybe_val)
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
 
-            ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-            out_val->data.x_bool = !optional_value_is_null(maybe_val);
-            return ira->codegen->builtin_types.entry_bool;
+            return ir_const_bool(ira, &instruction->base, !optional_value_is_null(maybe_val));
         }
 
-        ir_build_test_nonnull_from(&ira->new_irb, &instruction->base, value);
-        return ira->codegen->builtin_types.entry_bool;
+        IrInstruction *result = ir_build_test_nonnull(&ira->new_irb,
+            instruction->base.scope, instruction->base.source_node, value);
+        result->value.type = ira->codegen->builtin_types.entry_bool;
+        return result;
     } else if (type_entry->id == ZigTypeIdNull) {
-        ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-        out_val->data.x_bool = false;
-        return ira->codegen->builtin_types.entry_bool;
+        return ir_const_bool(ira, &instruction->base, false);
     } else {
-        ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-        out_val->data.x_bool = true;
-        return ira->codegen->builtin_types.entry_bool;
+        return ir_const_bool(ira, &instruction->base, true);
     }
 }
 
-static ZigType *ir_analyze_instruction_unwrap_maybe(IrAnalyze *ira,
+static IrInstruction *ir_analyze_instruction_unwrap_maybe(IrAnalyze *ira,
         IrInstructionUnwrapOptional *unwrap_maybe_instruction)
 {
-    IrInstruction *value = unwrap_maybe_instruction->value->other;
+    IrInstruction *value = unwrap_maybe_instruction->value->child;
     if (type_is_invalid(value->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     ZigType *ptr_type = value->value.type;
     assert(ptr_type->id == ZigTypeIdPointer);
 
     ZigType *type_entry = ptr_type->data.pointer.child_type;
     if (type_is_invalid(type_entry)) {
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     } else if (type_entry->id != ZigTypeIdOptional) {
         ir_add_error_node(ira, unwrap_maybe_instruction->value->source_node,
                 buf_sprintf("expected optional type, found '%s'", buf_ptr(&type_entry->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
     ZigType *child_type = type_entry->data.maybe.child_type;
     ZigType *result_type = get_pointer_to_type_extra(ira->codegen, child_type,
@@ -15867,17 +15437,18 @@ static ZigType *ir_analyze_instruction_unwrap_maybe(IrAnalyze *ira,
     if (instr_is_comptime(value)) {
         ConstExprValue *val = ir_resolve_const(ira, value, UndefBad);
         if (!val)
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         ConstExprValue *maybe_val = ir_const_ptr_pointee(ira, val, unwrap_maybe_instruction->base.source_node);
         if (maybe_val == nullptr)
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
 
         if (val->data.x_ptr.mut != ConstPtrMutRuntimeVar) {
             if (optional_value_is_null(maybe_val)) {
                 ir_add_error(ira, &unwrap_maybe_instruction->base, buf_sprintf("unable to unwrap null"));
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             }
-            ConstExprValue *out_val = ir_build_const_from(ira, &unwrap_maybe_instruction->base);
+            IrInstruction *result = ir_const(ira, &unwrap_maybe_instruction->base, result_type);
+            ConstExprValue *out_val = &result->value;
             out_val->data.x_ptr.special = ConstPtrSpecialRef;
             out_val->data.x_ptr.mut = val->data.x_ptr.mut;
             if (type_is_codegen_pointer(child_type)) {
@@ -15885,83 +15456,87 @@ static ZigType *ir_analyze_instruction_unwrap_maybe(IrAnalyze *ira,
             } else {
                 out_val->data.x_ptr.data.ref.pointee = maybe_val->data.x_optional;
             }
-            return result_type;
+            return result;
         }
     }
 
-    ir_build_unwrap_maybe_from(&ira->new_irb, &unwrap_maybe_instruction->base, value,
-            unwrap_maybe_instruction->safety_check_on);
-    return result_type;
+    IrInstruction *result = ir_build_unwrap_maybe(&ira->new_irb,
+            unwrap_maybe_instruction->base.scope, unwrap_maybe_instruction->base.source_node,
+            value, unwrap_maybe_instruction->safety_check_on);
+    result->value.type = result_type;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_ctz(IrAnalyze *ira, IrInstructionCtz *ctz_instruction) {
-    IrInstruction *value = ctz_instruction->value->other;
+static IrInstruction *ir_analyze_instruction_ctz(IrAnalyze *ira, IrInstructionCtz *ctz_instruction) {
+    IrInstruction *value = ctz_instruction->value->child;
     if (type_is_invalid(value->value.type)) {
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     } else if (value->value.type->id == ZigTypeIdInt) {
         ZigType *return_type = get_smallest_unsigned_int_type(ira->codegen,
                 value->value.type->data.integral.bit_count);
         if (value->value.special != ConstValSpecialRuntime) {
-            size_t result = bigint_ctz(&value->value.data.x_bigint,
+            size_t result_usize = bigint_ctz(&value->value.data.x_bigint,
                     value->value.type->data.integral.bit_count);
-            ConstExprValue *out_val = ir_build_const_from(ira, &ctz_instruction->base);
-            bigint_init_unsigned(&out_val->data.x_bigint, result);
-            return return_type;
+            IrInstruction *result = ir_const(ira, &ctz_instruction->base, return_type);
+            bigint_init_unsigned(&result->value.data.x_bigint, result_usize);
+            return result;
         }
 
-        ir_build_ctz_from(&ira->new_irb, &ctz_instruction->base, value);
-        return return_type;
+        IrInstruction *result = ir_build_ctz(&ira->new_irb,
+            ctz_instruction->base.scope, ctz_instruction->base.source_node, value);
+        result->value.type = return_type;
+        return result;
     } else {
         ir_add_error_node(ira, ctz_instruction->base.source_node,
             buf_sprintf("expected integer type, found '%s'", buf_ptr(&value->value.type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 }
 
-static ZigType *ir_analyze_instruction_clz(IrAnalyze *ira, IrInstructionClz *clz_instruction) {
-    IrInstruction *value = clz_instruction->value->other;
+static IrInstruction *ir_analyze_instruction_clz(IrAnalyze *ira, IrInstructionClz *clz_instruction) {
+    IrInstruction *value = clz_instruction->value->child;
     if (type_is_invalid(value->value.type)) {
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     } else if (value->value.type->id == ZigTypeIdInt) {
         ZigType *return_type = get_smallest_unsigned_int_type(ira->codegen,
                 value->value.type->data.integral.bit_count);
         if (value->value.special != ConstValSpecialRuntime) {
-            size_t result = bigint_clz(&value->value.data.x_bigint,
+            size_t result_usize = bigint_clz(&value->value.data.x_bigint,
                     value->value.type->data.integral.bit_count);
-            ConstExprValue *out_val = ir_build_const_from(ira, &clz_instruction->base);
-            bigint_init_unsigned(&out_val->data.x_bigint, result);
-            return return_type;
+            IrInstruction *result = ir_const(ira, &clz_instruction->base, return_type);
+            bigint_init_unsigned(&result->value.data.x_bigint, result_usize);
+            return result;
         }
 
-        ir_build_clz_from(&ira->new_irb, &clz_instruction->base, value);
-        return return_type;
+        IrInstruction *result = ir_build_clz(&ira->new_irb,
+            clz_instruction->base.scope, clz_instruction->base.source_node, value);
+        result->value.type = return_type;
+        return result;
     } else {
         ir_add_error_node(ira, clz_instruction->base.source_node,
             buf_sprintf("expected integer type, found '%s'", buf_ptr(&value->value.type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 }
 
-static ZigType *ir_analyze_instruction_pop_count(IrAnalyze *ira, IrInstructionPopCount *instruction) {
-    IrInstruction *value = instruction->value->other;
+static IrInstruction *ir_analyze_instruction_pop_count(IrAnalyze *ira, IrInstructionPopCount *instruction) {
+    IrInstruction *value = instruction->value->child;
     if (type_is_invalid(value->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (value->value.type->id != ZigTypeIdInt && value->value.type->id != ZigTypeIdComptimeInt) {
         ir_add_error(ira, value,
             buf_sprintf("expected integer type, found '%s'", buf_ptr(&value->value.type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     if (instr_is_comptime(value)) {
         ConstExprValue *val = ir_resolve_const(ira, value, UndefBad);
         if (!val)
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         if (bigint_cmp_zero(&val->data.x_bigint) != CmpLT) {
             size_t result = bigint_popcount_unsigned(&val->data.x_bigint);
-            ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-            bigint_init_unsigned(&out_val->data.x_bigint, result);
-            return ira->codegen->builtin_types.entry_num_lit_int;
+            return ir_const_unsigned(ira, &instruction->base, result);
         }
         if (value->value.type->id == ZigTypeIdComptimeInt) {
             Buf *val_buf = buf_alloc();
@@ -15969,19 +15544,16 @@ static ZigType *ir_analyze_instruction_pop_count(IrAnalyze *ira, IrInstructionPo
             ir_add_error(ira, &instruction->base,
                 buf_sprintf("@popCount on negative %s value %s",
                     buf_ptr(&value->value.type->name), buf_ptr(val_buf)));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
         size_t result = bigint_popcount_signed(&val->data.x_bigint, value->value.type->data.integral.bit_count);
-        ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-        bigint_init_unsigned(&out_val->data.x_bigint, result);
-        return ira->codegen->builtin_types.entry_num_lit_int;
+        return ir_const_unsigned(ira, &instruction->base, result);
     }
 
     IrInstruction *result = ir_build_pop_count(&ira->new_irb, instruction->base.scope,
             instruction->base.source_node, value);
     result->value.type = get_smallest_unsigned_int_type(ira->codegen, value->value.type->data.integral.bit_count);
-    ir_link_new_instruction(result, &instruction->base);
-    return result->value.type;
+    return result;
 }
 
 static IrInstruction *ir_analyze_union_tag(IrAnalyze *ira, IrInstruction *source_instr, IrInstruction *value) {
@@ -16027,15 +15599,15 @@ static IrInstruction *ir_analyze_union_tag(IrAnalyze *ira, IrInstruction *source
     return result;
 }
 
-static ZigType *ir_analyze_instruction_switch_br(IrAnalyze *ira,
+static IrInstruction *ir_analyze_instruction_switch_br(IrAnalyze *ira,
         IrInstructionSwitchBr *switch_br_instruction)
 {
-    IrInstruction *target_value = switch_br_instruction->target_value->other;
+    IrInstruction *target_value = switch_br_instruction->target_value->child;
     if (type_is_invalid(target_value->value.type))
         return ir_unreach_error(ira);
 
     if (switch_br_instruction->switch_prongs_void != nullptr) {
-        if (type_is_invalid(switch_br_instruction->switch_prongs_void->other->value.type)) {
+        if (type_is_invalid(switch_br_instruction->switch_prongs_void->child->value.type)) {
             return ir_unreach_error(ira);
         }
     }
@@ -16044,8 +15616,8 @@ static ZigType *ir_analyze_instruction_switch_br(IrAnalyze *ira,
     size_t case_count = switch_br_instruction->case_count;
 
     bool is_comptime;
-    if (!ir_resolve_comptime(ira, switch_br_instruction->is_comptime->other, &is_comptime))
-        return ira->codegen->builtin_types.entry_invalid;
+    if (!ir_resolve_comptime(ira, switch_br_instruction->is_comptime->child, &is_comptime))
+        return ira->codegen->invalid_instruction;
 
     if (is_comptime || instr_is_comptime(target_value)) {
         ConstExprValue *target_val = ir_resolve_const(ira, target_value, UndefBad);
@@ -16055,7 +15627,7 @@ static ZigType *ir_analyze_instruction_switch_br(IrAnalyze *ira,
         IrBasicBlock *old_dest_block = switch_br_instruction->else_block;
         for (size_t i = 0; i < case_count; i += 1) {
             IrInstructionSwitchBrCase *old_case = &switch_br_instruction->cases[i];
-            IrInstruction *case_value = old_case->value->other;
+            IrInstruction *case_value = old_case->value->child;
             if (type_is_invalid(case_value->value.type))
                 return ir_unreach_error(ira);
 
@@ -16073,7 +15645,7 @@ static ZigType *ir_analyze_instruction_switch_br(IrAnalyze *ira,
             if (!case_val)
                 return ir_unreach_error(ira);
 
-            if (const_values_equal(target_val, case_val)) {
+            if (const_values_equal(ira->codegen, target_val, case_val)) {
                 old_dest_block = old_case->block;
                 break;
             }
@@ -16083,8 +15655,11 @@ static ZigType *ir_analyze_instruction_switch_br(IrAnalyze *ira,
             return ir_inline_bb(ira, &switch_br_instruction->base, old_dest_block);
         } else {
             IrBasicBlock *new_dest_block = ir_get_new_bb(ira, old_dest_block, &switch_br_instruction->base);
-            ir_build_br_from(&ira->new_irb, &switch_br_instruction->base, new_dest_block);
-            return ir_finish_anal(ira, ira->codegen->builtin_types.entry_unreachable);
+            IrInstruction *result = ir_build_br(&ira->new_irb,
+                switch_br_instruction->base.scope, switch_br_instruction->base.source_node,
+                new_dest_block, nullptr);
+            result->value.type = ira->codegen->builtin_types.entry_unreachable;
+            return ir_finish_anal(ira, result);
         }
     }
 
@@ -16102,7 +15677,7 @@ static ZigType *ir_analyze_instruction_switch_br(IrAnalyze *ira,
         new_case->block->ref_instruction = nullptr;
 
         IrInstruction *old_value = old_case->value;
-        IrInstruction *new_value = old_value->other;
+        IrInstruction *new_value = old_value->child;
         if (type_is_invalid(new_value->value.type))
             continue;
 
@@ -16130,32 +15705,31 @@ static ZigType *ir_analyze_instruction_switch_br(IrAnalyze *ira,
     }
 
     IrBasicBlock *new_else_block = ir_get_new_bb(ira, switch_br_instruction->else_block, &switch_br_instruction->base);
-    ir_build_switch_br_from(&ira->new_irb, &switch_br_instruction->base,
-            target_value, new_else_block, case_count, cases, nullptr, nullptr);
-    return ir_finish_anal(ira, ira->codegen->builtin_types.entry_unreachable);
+    IrInstruction *result = ir_build_switch_br(&ira->new_irb,
+        switch_br_instruction->base.scope, switch_br_instruction->base.source_node,
+        target_value, new_else_block, case_count, cases, nullptr, nullptr);
+    result->value.type = ira->codegen->builtin_types.entry_unreachable;
+    return ir_finish_anal(ira, result);
 }
 
-static ZigType *ir_analyze_instruction_switch_target(IrAnalyze *ira,
+static IrInstruction *ir_analyze_instruction_switch_target(IrAnalyze *ira,
         IrInstructionSwitchTarget *switch_target_instruction)
 {
     Error err;
-    IrInstruction *target_value_ptr = switch_target_instruction->target_value_ptr->other;
+    IrInstruction *target_value_ptr = switch_target_instruction->target_value_ptr->child;
     if (type_is_invalid(target_value_ptr->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (target_value_ptr->value.type->id == ZigTypeIdMetaType) {
         assert(instr_is_comptime(target_value_ptr));
         ZigType *ptr_type = target_value_ptr->value.data.x_type;
         assert(ptr_type->id == ZigTypeIdPointer);
-        ConstExprValue *out_val = ir_build_const_from(ira, &switch_target_instruction->base);
-        out_val->type = ira->codegen->builtin_types.entry_type;
-        out_val->data.x_type = ptr_type->data.pointer.child_type;
-        return out_val->type;
+        return ir_const_type(ira, &switch_target_instruction->base, ptr_type->data.pointer.child_type);
     }
 
     if (target_value_ptr->value.type->id != ZigTypeIdPointer) {
         ir_add_error(ira, target_value_ptr, buf_sprintf("invalid deref on switch target"));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     ZigType *target_type = target_value_ptr->value.type->data.pointer.child_type;
@@ -16163,13 +15737,13 @@ static ZigType *ir_analyze_instruction_switch_target(IrAnalyze *ira,
     if (instr_is_comptime(target_value_ptr)) {
         pointee_val = ir_const_ptr_pointee(ira, &target_value_ptr->value, target_value_ptr->source_node);
         if (pointee_val == nullptr)
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
             
         if (pointee_val->special == ConstValSpecialRuntime)
             pointee_val = nullptr;
     }
     if ((err = ensure_complete_type(ira->codegen, target_type)))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     switch (target_type->id) {
         case ZigTypeIdInvalid:
@@ -16185,16 +15759,20 @@ static ZigType *ir_analyze_instruction_switch_target(IrAnalyze *ira,
         case ZigTypeIdPromise:
         case ZigTypeIdFn:
         case ZigTypeIdNamespace:
-        case ZigTypeIdErrorSet:
+        case ZigTypeIdErrorSet: {
             if (pointee_val) {
-                ConstExprValue *out_val = ir_build_const_from(ira, &switch_target_instruction->base);
-                copy_const_val(out_val, pointee_val, true);
-                out_val->type = target_type;
-                return target_type;
+                IrInstruction *result = ir_const(ira, &switch_target_instruction->base, nullptr);
+                copy_const_val(&result->value, pointee_val, true);
+                result->value.type = target_type;
+                return result;
             }
 
-            ir_build_load_ptr_from(&ira->new_irb, &switch_target_instruction->base, target_value_ptr);
-            return target_type;
+            IrInstruction *result = ir_build_load_ptr(&ira->new_irb,
+                switch_target_instruction->base.scope, switch_target_instruction->base.source_node,
+                target_value_ptr);
+            result->value.type = target_type;
+            return result;
+        }
         case ZigTypeIdUnion: {
             AstNode *decl_node = target_type->data.unionation.decl_node;
             if (!decl_node->data.container_decl.auto_enum &&
@@ -16204,21 +15782,21 @@ static ZigType *ir_analyze_instruction_switch_target(IrAnalyze *ira,
                     buf_sprintf("switch on union which has no attached enum"));
                 add_error_note(ira->codegen, msg, decl_node,
                         buf_sprintf("consider 'union(enum)' here"));
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             }
             ZigType *tag_type = target_type->data.unionation.tag_type;
             assert(tag_type != nullptr);
             assert(tag_type->id == ZigTypeIdEnum);
             if (pointee_val) {
-                ConstExprValue *out_val = ir_build_const_from(ira, &switch_target_instruction->base);
-                bigint_init_bigint(&out_val->data.x_enum_tag, &pointee_val->data.x_union.tag);
-                return tag_type;
+                IrInstruction *result = ir_const(ira, &switch_target_instruction->base, tag_type);
+                bigint_init_bigint(&result->value.data.x_enum_tag, &pointee_val->data.x_union.tag);
+                return result;
             }
             if (tag_type->data.enumeration.src_field_count == 1) {
-                ConstExprValue *out_val = ir_build_const_from(ira, &switch_target_instruction->base);
+                IrInstruction *result = ir_const(ira, &switch_target_instruction->base, tag_type);
                 TypeEnumField *only_field = &tag_type->data.enumeration.fields[0];
-                bigint_init_bigint(&out_val->data.x_enum_tag, &only_field->value);
-                return tag_type;
+                bigint_init_bigint(&result->value.data.x_enum_tag, &only_field->value);
+                return result;
             }
 
             IrInstruction *union_value = ir_build_load_ptr(&ira->new_irb, switch_target_instruction->base.scope,
@@ -16228,30 +15806,28 @@ static ZigType *ir_analyze_instruction_switch_target(IrAnalyze *ira,
             IrInstruction *union_tag_inst = ir_build_union_tag(&ira->new_irb, switch_target_instruction->base.scope,
                     switch_target_instruction->base.source_node, union_value);
             union_tag_inst->value.type = tag_type;
-            ir_link_new_instruction(union_tag_inst, &switch_target_instruction->base);
-            return tag_type;
+            return union_tag_inst;
         }
         case ZigTypeIdEnum: {
             if ((err = type_resolve(ira->codegen, target_type, ResolveStatusZeroBitsKnown)))
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             if (target_type->data.enumeration.src_field_count < 2) {
                 TypeEnumField *only_field = &target_type->data.enumeration.fields[0];
-                ConstExprValue *out_val = ir_build_const_from(ira, &switch_target_instruction->base);
-                bigint_init_bigint(&out_val->data.x_enum_tag, &only_field->value);
-                return target_type;
+                IrInstruction *result = ir_const(ira, &switch_target_instruction->base, target_type);
+                bigint_init_bigint(&result->value.data.x_enum_tag, &only_field->value);
+                return result;
             }
 
             if (pointee_val) {
-                ConstExprValue *out_val = ir_build_const_from(ira, &switch_target_instruction->base);
-                bigint_init_bigint(&out_val->data.x_enum_tag, &pointee_val->data.x_enum_tag);
-                return target_type;
+                IrInstruction *result = ir_const(ira, &switch_target_instruction->base, target_type);
+                bigint_init_bigint(&result->value.data.x_enum_tag, &pointee_val->data.x_enum_tag);
+                return result;
             }
 
             IrInstruction *enum_value = ir_build_load_ptr(&ira->new_irb, switch_target_instruction->base.scope,
                 switch_target_instruction->base.source_node, target_value_ptr);
             enum_value->value.type = target_type;
-            ir_link_new_instruction(enum_value, &switch_target_instruction->base);
-            return target_type;
+            return enum_value;
         }
         case ZigTypeIdErrorUnion:
         case ZigTypeIdUnreachable:
@@ -16265,26 +15841,26 @@ static ZigType *ir_analyze_instruction_switch_target(IrAnalyze *ira,
         case ZigTypeIdOpaque:
             ir_add_error(ira, &switch_target_instruction->base,
                 buf_sprintf("invalid switch target type '%s'", buf_ptr(&target_type->name)));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
     }
     zig_unreachable();
 }
 
-static ZigType *ir_analyze_instruction_switch_var(IrAnalyze *ira, IrInstructionSwitchVar *instruction) {
-    IrInstruction *target_value_ptr = instruction->target_value_ptr->other;
+static IrInstruction *ir_analyze_instruction_switch_var(IrAnalyze *ira, IrInstructionSwitchVar *instruction) {
+    IrInstruction *target_value_ptr = instruction->target_value_ptr->child;
     if (type_is_invalid(target_value_ptr->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *prong_value = instruction->prong_value->other;
+    IrInstruction *prong_value = instruction->prong_value->child;
     if (type_is_invalid(prong_value->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     assert(target_value_ptr->value.type->id == ZigTypeIdPointer);
     ZigType *target_type = target_value_ptr->value.type->data.pointer.child_type;
     if (target_type->id == ZigTypeIdUnion) {
         ConstExprValue *prong_val = ir_resolve_const(ira, prong_value, UndefBad);
         if (!prong_val)
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
 
         assert(prong_value->value.type->id == ZigTypeIdEnum);
         TypeUnionField *field = find_union_field_by_tag(target_type, &prong_val->data.x_enum_tag);
@@ -16292,43 +15868,46 @@ static ZigType *ir_analyze_instruction_switch_var(IrAnalyze *ira, IrInstructionS
         if (instr_is_comptime(target_value_ptr)) {
             ConstExprValue *target_val_ptr = ir_resolve_const(ira, target_value_ptr, UndefBad);
             if (!target_value_ptr)
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
 
             ConstExprValue *pointee_val = ir_const_ptr_pointee(ira, target_val_ptr, instruction->base.source_node);
             if (pointee_val == nullptr)
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
 
-            ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
+            IrInstruction *result = ir_const(ira, &instruction->base,
+                    get_pointer_to_type(ira->codegen, field->type_entry,
+                    target_val_ptr->type->data.pointer.is_const));
+            ConstExprValue *out_val = &result->value;
             out_val->data.x_ptr.special = ConstPtrSpecialRef;
             out_val->data.x_ptr.mut = target_val_ptr->data.x_ptr.mut;
             out_val->data.x_ptr.data.ref.pointee = pointee_val->data.x_union.payload;
-            return get_pointer_to_type(ira->codegen, field->type_entry, target_val_ptr->type->data.pointer.is_const);
+            return result;
         }
 
-        ir_build_union_field_ptr_from(&ira->new_irb, &instruction->base, target_value_ptr, field);
-        return get_pointer_to_type(ira->codegen, field->type_entry,
+        IrInstruction *result = ir_build_union_field_ptr(&ira->new_irb,
+            instruction->base.scope, instruction->base.source_node, target_value_ptr, field);
+        result->value.type = get_pointer_to_type(ira->codegen, field->type_entry,
                 target_value_ptr->value.type->data.pointer.is_const);
+        return result;
     } else {
         ir_add_error(ira, &instruction->base,
             buf_sprintf("switch on type '%s' provides no expression parameter", buf_ptr(&target_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 }
 
-static ZigType *ir_analyze_instruction_union_tag(IrAnalyze *ira, IrInstructionUnionTag *instruction) {
-    IrInstruction *value = instruction->value->other;
-    IrInstruction *new_instruction = ir_analyze_union_tag(ira, &instruction->base, value);
-    ir_link_new_instruction(new_instruction, &instruction->base);
-    return new_instruction->value.type;
+static IrInstruction *ir_analyze_instruction_union_tag(IrAnalyze *ira, IrInstructionUnionTag *instruction) {
+    IrInstruction *value = instruction->value->child;
+    return ir_analyze_union_tag(ira, &instruction->base, value);
 }
 
-static ZigType *ir_analyze_instruction_import(IrAnalyze *ira, IrInstructionImport *import_instruction) {
+static IrInstruction *ir_analyze_instruction_import(IrAnalyze *ira, IrInstructionImport *import_instruction) {
     Error err;
 
-    IrInstruction *name_value = import_instruction->name->other;
+    IrInstruction *name_value = import_instruction->name->child;
     Buf *import_target_str = ir_resolve_str(ira, name_value);
     if (!import_target_str)
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     AstNode *source_node = import_instruction->base.source_node;
     ImportTableEntry *import = source_node->owner;
@@ -16363,20 +15942,21 @@ static ZigType *ir_analyze_instruction_import(IrAnalyze *ira, IrInstructionImpor
 
     auto import_entry = ira->codegen->import_table.maybe_get(resolved_path);
     if (import_entry) {
-        ConstExprValue *out_val = ir_build_const_from(ira, &import_instruction->base);
-        out_val->data.x_import = import_entry->value;
-        return ira->codegen->builtin_types.entry_namespace;
+        IrInstruction *result = ir_const(ira, &import_instruction->base,
+                ira->codegen->builtin_types.entry_namespace);
+        result->value.data.x_import = import_entry->value;
+        return result;
     }
 
     if ((err = file_fetch(ira->codegen, resolved_path, import_code))) {
         if (err == ErrorFileNotFound) {
             ir_add_error_node(ira, source_node,
                     buf_sprintf("unable to find '%s'", buf_ptr(import_target_path)));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         } else {
             ir_add_error_node(ira, source_node,
                     buf_sprintf("unable to open '%s': %s", buf_ptr(&full_path), err_str(err)));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
     }
 
@@ -16384,27 +15964,26 @@ static ZigType *ir_analyze_instruction_import(IrAnalyze *ira, IrInstructionImpor
 
     scan_import(ira->codegen, target_import);
 
-    ConstExprValue *out_val = ir_build_const_from(ira, &import_instruction->base);
-    out_val->data.x_import = target_import;
-    return ira->codegen->builtin_types.entry_namespace;
-
+    IrInstruction *result = ir_const(ira, &import_instruction->base, ira->codegen->builtin_types.entry_namespace);
+    result->value.data.x_import = target_import;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_array_len(IrAnalyze *ira,
+static IrInstruction *ir_analyze_instruction_array_len(IrAnalyze *ira,
         IrInstructionArrayLen *array_len_instruction)
 {
-    IrInstruction *array_value = array_len_instruction->array_value->other;
+    IrInstruction *array_value = array_len_instruction->array_value->child;
     ZigType *type_entry = array_value->value.type;
     if (type_is_invalid(type_entry)) {
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     } else if (type_entry->id == ZigTypeIdArray) {
-        return ir_analyze_const_usize(ira, &array_len_instruction->base,
+        return ir_const_usize(ira, &array_len_instruction->base,
                 type_entry->data.array.len);
     } else if (is_slice(type_entry)) {
         if (array_value->value.special != ConstValSpecialRuntime) {
             ConstExprValue *len_val = &array_value->value.data.x_struct.fields[slice_len_index];
             if (len_val->special != ConstValSpecialRuntime) {
-                return ir_analyze_const_usize(ira, &array_len_instruction->base,
+                return ir_const_usize(ira, &array_len_instruction->base,
                         bigint_as_unsigned(&len_val->data.x_bigint));
             }
         }
@@ -16412,57 +15991,61 @@ static ZigType *ir_analyze_instruction_array_len(IrAnalyze *ira,
         IrInstruction *len_ptr = ir_build_struct_field_ptr(&ira->new_irb, array_len_instruction->base.scope,
                 array_len_instruction->base.source_node, array_value, field);
         len_ptr->value.type = get_pointer_to_type(ira->codegen, ira->codegen->builtin_types.entry_usize, true);
-        ir_build_load_ptr_from(&ira->new_irb, &array_len_instruction->base, len_ptr);
-        return ira->codegen->builtin_types.entry_usize;
+        IrInstruction *result = ir_build_load_ptr(&ira->new_irb,
+            array_len_instruction->base.scope, array_len_instruction->base.source_node, len_ptr);
+        result->value.type = ira->codegen->builtin_types.entry_usize;
+        return result;
     } else {
         ir_add_error_node(ira, array_len_instruction->base.source_node,
             buf_sprintf("type '%s' has no field 'len'", buf_ptr(&array_value->value.type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 }
 
-static ZigType *ir_analyze_instruction_ref(IrAnalyze *ira, IrInstructionRef *ref_instruction) {
-    IrInstruction *value = ref_instruction->value->other;
-    return ir_analyze_ref(ira, &ref_instruction->base, value, ref_instruction->is_const, ref_instruction->is_volatile);
+static IrInstruction *ir_analyze_instruction_ref(IrAnalyze *ira, IrInstructionRef *ref_instruction) {
+    IrInstruction *value = ref_instruction->value->child;
+    if (type_is_invalid(value->value.type))
+        return ira->codegen->invalid_instruction;
+    return ir_get_ref(ira, &ref_instruction->base, value, ref_instruction->is_const, ref_instruction->is_volatile);
 }
 
-static ZigType *ir_analyze_container_init_fields_union(IrAnalyze *ira, IrInstruction *instruction,
+static IrInstruction *ir_analyze_container_init_fields_union(IrAnalyze *ira, IrInstruction *instruction,
     ZigType *container_type, size_t instr_field_count, IrInstructionContainerInitFieldsField *fields)
 {
     Error err;
     assert(container_type->id == ZigTypeIdUnion);
 
     if ((err = ensure_complete_type(ira->codegen, container_type)))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (instr_field_count != 1) {
         ir_add_error(ira, instruction,
             buf_sprintf("union initialization expects exactly one field"));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     IrInstructionContainerInitFieldsField *field = &fields[0];
-    IrInstruction *field_value = field->value->other;
+    IrInstruction *field_value = field->value->child;
     if (type_is_invalid(field_value->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     TypeUnionField *type_field = find_union_type_field(container_type, field->name);
     if (!type_field) {
         ir_add_error_node(ira, field->source_node,
             buf_sprintf("no member named '%s' in union '%s'",
                 buf_ptr(field->name), buf_ptr(&container_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     if (type_is_invalid(type_field->type_entry))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     IrInstruction *casted_field_value = ir_implicit_cast(ira, field_value, type_field->type_entry);
     if (casted_field_value == ira->codegen->invalid_instruction)
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if ((err = type_resolve(ira->codegen, casted_field_value->value.type, ResolveStatusZeroBitsKnown)))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     bool is_comptime = ir_should_inline(ira->new_irb.exec, instruction->scope);
     if (is_comptime || casted_field_value->value.special != ConstValSpecialRuntime ||
@@ -16470,9 +16053,10 @@ static ZigType *ir_analyze_container_init_fields_union(IrAnalyze *ira, IrInstruc
     {
         ConstExprValue *field_val = ir_resolve_const(ira, casted_field_value, UndefOk);
         if (!field_val)
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
 
-        ConstExprValue *out_val = ir_build_const_from(ira, instruction);
+        IrInstruction *result = ir_const(ira, instruction, container_type);
+        ConstExprValue *out_val = &result->value;
         out_val->data.x_union.payload = field_val;
         out_val->data.x_union.tag = type_field->enum_field->value;
 
@@ -16482,17 +16066,18 @@ static ZigType *ir_analyze_container_init_fields_union(IrAnalyze *ira, IrInstruc
             parent->data.p_union.union_val = out_val;
         }
 
-        return container_type;
+        return result;
     }
 
-    IrInstruction *new_instruction = ir_build_union_init_from(&ira->new_irb, instruction,
+    IrInstruction *new_instruction = ir_build_union_init(&ira->new_irb,
+        instruction->scope, instruction->source_node,
         container_type, type_field, casted_field_value);
-
+    new_instruction->value.type = container_type;
     ir_add_alloca(ira, new_instruction, container_type);
-    return container_type;
+    return new_instruction;
 }
 
-static ZigType *ir_analyze_container_init_fields(IrAnalyze *ira, IrInstruction *instruction,
+static IrInstruction *ir_analyze_container_init_fields(IrAnalyze *ira, IrInstruction *instruction,
     ZigType *container_type, size_t instr_field_count, IrInstructionContainerInitFieldsField *fields)
 {
     Error err;
@@ -16503,11 +16088,11 @@ static ZigType *ir_analyze_container_init_fields(IrAnalyze *ira, IrInstruction *
         ir_add_error(ira, instruction,
             buf_sprintf("type '%s' does not support struct initialization syntax",
                 buf_ptr(&container_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     if ((err = ensure_complete_type(ira->codegen, container_type)))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     size_t actual_field_count = container_type->data.structure.src_field_count;
 
@@ -16526,31 +16111,31 @@ static ZigType *ir_analyze_container_init_fields(IrAnalyze *ira, IrInstruction *
     for (size_t i = 0; i < instr_field_count; i += 1) {
         IrInstructionContainerInitFieldsField *field = &fields[i];
 
-        IrInstruction *field_value = field->value->other;
+        IrInstruction *field_value = field->value->child;
         if (type_is_invalid(field_value->value.type))
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
 
         TypeStructField *type_field = find_struct_type_field(container_type, field->name);
         if (!type_field) {
             ir_add_error_node(ira, field->source_node,
                 buf_sprintf("no member named '%s' in struct '%s'",
                     buf_ptr(field->name), buf_ptr(&container_type->name)));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
 
         if (type_is_invalid(type_field->type_entry))
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
 
         IrInstruction *casted_field_value = ir_implicit_cast(ira, field_value, type_field->type_entry);
         if (casted_field_value == ira->codegen->invalid_instruction)
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
 
         size_t field_index = type_field->src_index;
         AstNode *existing_assign_node = field_assign_nodes[field_index];
         if (existing_assign_node) {
             ErrorMsg *msg = ir_add_error_node(ira, field->source_node, buf_sprintf("duplicate field"));
             add_error_note(ira->codegen, msg, existing_assign_node, buf_sprintf("other field here"));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
         field_assign_nodes[field_index] = field->source_node;
 
@@ -16561,7 +16146,7 @@ static ZigType *ir_analyze_container_init_fields(IrAnalyze *ira, IrInstruction *
             if (is_comptime || casted_field_value->value.special != ConstValSpecialRuntime) {
                 ConstExprValue *field_val = ir_resolve_const(ira, casted_field_value, UndefOk);
                 if (!field_val)
-                    return ira->codegen->builtin_types.entry_invalid;
+                    return ira->codegen->invalid_instruction;
 
                 copy_const_val(&const_val.data.x_struct.fields[field_index], field_val, true);
             } else {
@@ -16580,11 +16165,14 @@ static ZigType *ir_analyze_container_init_fields(IrAnalyze *ira, IrInstruction *
         }
     }
     if (any_missing)
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (const_val.special == ConstValSpecialStatic) {
-        ConstExprValue *out_val = ir_build_const_from(ira, instruction);
+        IrInstruction *result = ir_const(ira, instruction, nullptr);
+        ConstExprValue *out_val = &result->value;
+        // TODO copy_const_val?
         *out_val = const_val;
+        result->value.type = container_type;
 
         for (size_t i = 0; i < instr_field_count; i += 1) {
             ConstExprValue *field_val = &out_val->data.x_struct.fields[i];
@@ -16596,34 +16184,35 @@ static ZigType *ir_analyze_container_init_fields(IrAnalyze *ira, IrInstruction *
             }
         }
 
-        return container_type;
+        return result;
     }
 
     if (is_comptime) {
         ir_add_error_node(ira, first_non_const_instruction->source_node,
             buf_sprintf("unable to evaluate constant expression"));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
-    IrInstruction *new_instruction = ir_build_struct_init_from(&ira->new_irb, instruction,
+    IrInstruction *new_instruction = ir_build_struct_init(&ira->new_irb,
+        instruction->scope, instruction->source_node,
         container_type, actual_field_count, new_fields);
-
+    new_instruction->value.type = container_type;
     ir_add_alloca(ira, new_instruction, container_type);
-    return container_type;
+    return new_instruction;
 }
 
-static ZigType *ir_analyze_instruction_container_init_list(IrAnalyze *ira,
+static IrInstruction *ir_analyze_instruction_container_init_list(IrAnalyze *ira,
         IrInstructionContainerInitList *instruction)
 {
-    IrInstruction *container_type_value = instruction->container_type->other;
+    IrInstruction *container_type_value = instruction->container_type->child;
     if (type_is_invalid(container_type_value->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     size_t elem_count = instruction->item_count;
     if (container_type_value->value.type->id == ZigTypeIdMetaType) {
         ZigType *container_type = ir_resolve_type(ira, container_type_value);
         if (type_is_invalid(container_type))
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
 
         if (container_type->id == ZigTypeIdStruct && !is_slice(container_type) && elem_count == 0) {
             return ir_analyze_container_init_fields(ira, &instruction->base, container_type,
@@ -16639,7 +16228,7 @@ static ZigType *ir_analyze_instruction_container_init_list(IrAnalyze *ira,
                     ir_add_error(ira, &instruction->base,
                         buf_sprintf("expected %s literal, found %s literal",
                             buf_ptr(&container_type->name), buf_ptr(&literal_type->name)));
-                    return ira->codegen->builtin_types.entry_invalid;
+                    return ira->codegen->invalid_instruction;
                 }
             } else {
                 ZigType *pointer_type = container_type->data.structure.fields[slice_ptr_index].type_entry;
@@ -16652,7 +16241,7 @@ static ZigType *ir_analyze_instruction_container_init_list(IrAnalyze *ira,
             ConstExprValue const_val = {};
             const_val.special = ConstValSpecialStatic;
             const_val.type = fixed_size_array_type;
-            const_val.data.x_array.s_none.elements = create_const_vals(elem_count);
+            const_val.data.x_array.data.s_none.elements = create_const_vals(elem_count);
 
             bool is_comptime = ir_should_inline(ira->new_irb.exec, instruction->base.scope);
 
@@ -16661,13 +16250,13 @@ static ZigType *ir_analyze_instruction_container_init_list(IrAnalyze *ira,
             IrInstruction *first_non_const_instruction = nullptr;
 
             for (size_t i = 0; i < elem_count; i += 1) {
-                IrInstruction *arg_value = instruction->items[i]->other;
+                IrInstruction *arg_value = instruction->items[i]->child;
                 if (type_is_invalid(arg_value->value.type))
-                    return ira->codegen->builtin_types.entry_invalid;
+                    return ira->codegen->invalid_instruction;
 
                 IrInstruction *casted_arg = ir_implicit_cast(ira, arg_value, child_type);
                 if (casted_arg == ira->codegen->invalid_instruction)
-                    return ira->codegen->builtin_types.entry_invalid;
+                    return ira->codegen->invalid_instruction;
 
                 new_items[i] = casted_arg;
 
@@ -16675,9 +16264,9 @@ static ZigType *ir_analyze_instruction_container_init_list(IrAnalyze *ira,
                     if (is_comptime || casted_arg->value.special != ConstValSpecialRuntime) {
                         ConstExprValue *elem_val = ir_resolve_const(ira, casted_arg, UndefBad);
                         if (!elem_val)
-                            return ira->codegen->builtin_types.entry_invalid;
+                            return ira->codegen->invalid_instruction;
 
-                        copy_const_val(&const_val.data.x_array.s_none.elements[i], elem_val, true);
+                        copy_const_val(&const_val.data.x_array.data.s_none.elements[i], elem_val, true);
                     } else {
                         first_non_const_instruction = casted_arg;
                         const_val.special = ConstValSpecialRuntime;
@@ -16686,10 +16275,13 @@ static ZigType *ir_analyze_instruction_container_init_list(IrAnalyze *ira,
             }
 
             if (const_val.special == ConstValSpecialStatic) {
-                ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
+                IrInstruction *result = ir_const(ira, &instruction->base, nullptr);
+                ConstExprValue *out_val = &result->value;
+                // TODO copy_const_val?
                 *out_val = const_val;
+                result->value.type = fixed_size_array_type;
                 for (size_t i = 0; i < elem_count; i += 1) {
-                    ConstExprValue *elem_val = &out_val->data.x_array.s_none.elements[i];
+                    ConstExprValue *elem_val = &out_val->data.x_array.data.s_none.elements[i];
                     ConstParent *parent = get_const_val_parent(ira->codegen, elem_val);
                     if (parent != nullptr) {
                         parent->id = ConstParentIdArray;
@@ -16697,123 +16289,58 @@ static ZigType *ir_analyze_instruction_container_init_list(IrAnalyze *ira,
                         parent->data.p_array.elem_index = i;
                     }
                 }
-                return fixed_size_array_type;
+                return result;
             }
 
             if (is_comptime) {
                 ir_add_error_node(ira, first_non_const_instruction->source_node,
                     buf_sprintf("unable to evaluate constant expression"));
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             }
 
-            IrInstruction *new_instruction = ir_build_container_init_list_from(&ira->new_irb, &instruction->base,
+            IrInstruction *new_instruction = ir_build_container_init_list(&ira->new_irb,
+                instruction->base.scope, instruction->base.source_node,
                 container_type_value, elem_count, new_items);
+            new_instruction->value.type = fixed_size_array_type;
             ir_add_alloca(ira, new_instruction, fixed_size_array_type);
-            return fixed_size_array_type;
+            return new_instruction;
         } else if (container_type->id == ZigTypeIdVoid) {
             if (elem_count != 0) {
                 ir_add_error_node(ira, instruction->base.source_node,
                     buf_sprintf("void expression expects no arguments"));
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             }
-            return ir_analyze_void(ira, &instruction->base);
+            return ir_const_void(ira, &instruction->base);
         } else {
             ir_add_error_node(ira, instruction->base.source_node,
                 buf_sprintf("type '%s' does not support array initialization",
                     buf_ptr(&container_type->name)));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
     } else {
         ir_add_error(ira, container_type_value,
             buf_sprintf("expected type, found '%s' value", buf_ptr(&container_type_value->value.type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 }
 
-static ZigType *ir_analyze_instruction_container_init_fields(IrAnalyze *ira, IrInstructionContainerInitFields *instruction) {
-    IrInstruction *container_type_value = instruction->container_type->other;
+static IrInstruction *ir_analyze_instruction_container_init_fields(IrAnalyze *ira, IrInstructionContainerInitFields *instruction) {
+    IrInstruction *container_type_value = instruction->container_type->child;
     ZigType *container_type = ir_resolve_type(ira, container_type_value);
     if (type_is_invalid(container_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     return ir_analyze_container_init_fields(ira, &instruction->base, container_type,
         instruction->field_count, instruction->fields);
 }
 
-static ZigType *ir_analyze_min_max(IrAnalyze *ira, IrInstruction *source_instruction,
-        IrInstruction *target_type_value, bool is_max)
-{
-    ZigType *target_type = ir_resolve_type(ira, target_type_value);
-    if (type_is_invalid(target_type))
-        return ira->codegen->builtin_types.entry_invalid;
-    switch (target_type->id) {
-        case ZigTypeIdInvalid:
-            zig_unreachable();
-        case ZigTypeIdInt:
-            {
-                ConstExprValue *out_val = ir_build_const_from(ira, source_instruction);
-                eval_min_max_value(ira->codegen, target_type, out_val, is_max);
-                return ira->codegen->builtin_types.entry_num_lit_int;
-            }
-        case ZigTypeIdBool:
-        case ZigTypeIdVoid:
-            {
-                ConstExprValue *out_val = ir_build_const_from(ira, source_instruction);
-                eval_min_max_value(ira->codegen, target_type, out_val, is_max);
-                return target_type;
-            }
-        case ZigTypeIdEnum:
-        case ZigTypeIdFloat:
-        case ZigTypeIdMetaType:
-        case ZigTypeIdUnreachable:
-        case ZigTypeIdPointer:
-        case ZigTypeIdPromise:
-        case ZigTypeIdArray:
-        case ZigTypeIdStruct:
-        case ZigTypeIdComptimeFloat:
-        case ZigTypeIdComptimeInt:
-        case ZigTypeIdUndefined:
-        case ZigTypeIdNull:
-        case ZigTypeIdOptional:
-        case ZigTypeIdErrorUnion:
-        case ZigTypeIdErrorSet:
-        case ZigTypeIdUnion:
-        case ZigTypeIdFn:
-        case ZigTypeIdNamespace:
-        case ZigTypeIdBoundFn:
-        case ZigTypeIdArgTuple:
-        case ZigTypeIdOpaque:
-            {
-                const char *err_format = is_max ?
-                    "no max value available for type '%s'" :
-                    "no min value available for type '%s'";
-                ir_add_error(ira, source_instruction,
-                        buf_sprintf(err_format, buf_ptr(&target_type->name)));
-                return ira->codegen->builtin_types.entry_invalid;
-            }
-    }
-    zig_unreachable();
-}
-
-static ZigType *ir_analyze_instruction_min_value(IrAnalyze *ira,
-        IrInstructionMinValue *instruction)
-{
-    return ir_analyze_min_max(ira, &instruction->base, instruction->value->other, false);
-}
-
-static ZigType *ir_analyze_instruction_max_value(IrAnalyze *ira,
-        IrInstructionMaxValue *instruction)
-{
-    return ir_analyze_min_max(ira, &instruction->base, instruction->value->other, true);
-}
-
-static ZigType *ir_analyze_instruction_compile_err(IrAnalyze *ira,
+static IrInstruction *ir_analyze_instruction_compile_err(IrAnalyze *ira,
         IrInstructionCompileErr *instruction)
 {
-    IrInstruction *msg_value = instruction->msg->other;
+    IrInstruction *msg_value = instruction->msg->child;
     Buf *msg_buf = ir_resolve_str(ira, msg_value);
     if (!msg_buf)
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     ErrorMsg *msg = ir_add_error(ira, &instruction->base, msg_buf);
     size_t i = ira->codegen->tld_ref_source_node_stack.length;
@@ -16828,16 +16355,16 @@ static ZigType *ir_analyze_instruction_compile_err(IrAnalyze *ira,
         }
     }
 
-    return ira->codegen->builtin_types.entry_invalid;
+    return ira->codegen->invalid_instruction;
 }
 
-static ZigType *ir_analyze_instruction_compile_log(IrAnalyze *ira, IrInstructionCompileLog *instruction) {
+static IrInstruction *ir_analyze_instruction_compile_log(IrAnalyze *ira, IrInstructionCompileLog *instruction) {
     Buf buf = BUF_INIT;
     fprintf(stderr, "| ");
     for (size_t i = 0; i < instruction->msg_count; i += 1) {
-        IrInstruction *msg = instruction->msg_list[i]->other;
+        IrInstruction *msg = instruction->msg_list[i]->child;
         if (type_is_invalid(msg->value.type))
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         buf_resize(&buf, 0);
         render_const_value(ira->codegen, &buf, &msg->value);
         const char *comma_str = (i != 0) ? ", " : "";
@@ -16845,20 +16372,21 @@ static ZigType *ir_analyze_instruction_compile_log(IrAnalyze *ira, IrInstruction
     }
     fprintf(stderr, "\n");
 
-    ir_add_error(ira, &instruction->base, buf_sprintf("found compile log statement"));
+    // Here we bypass higher level functions such as ir_add_error because we do not want
+    // invalidate_exec to be called.
+    add_node_error(ira->codegen, instruction->base.source_node, buf_sprintf("found compile log statement"));
 
-    ir_build_const_from(ira, &instruction->base);
-    return ira->codegen->builtin_types.entry_void;
+    return ir_const_void(ira, &instruction->base);
 }
 
-static ZigType *ir_analyze_instruction_err_name(IrAnalyze *ira, IrInstructionErrName *instruction) {
-    IrInstruction *value = instruction->value->other;
+static IrInstruction *ir_analyze_instruction_err_name(IrAnalyze *ira, IrInstructionErrName *instruction) {
+    IrInstruction *value = instruction->value->child;
     if (type_is_invalid(value->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     IrInstruction *casted_value = ir_implicit_cast(ira, value, value->value.type);
     if (type_is_invalid(casted_value->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     ZigType *u8_ptr_type = get_pointer_to_type_extra(ira->codegen, ira->codegen->builtin_types.entry_u8,
             true, false, PtrLenUnknown, 0, 0, 0);
@@ -16869,84 +16397,87 @@ static ZigType *ir_analyze_instruction_err_name(IrAnalyze *ira, IrInstructionErr
             ConstExprValue *array_val = create_const_str_lit(ira->codegen, &err->name);
             err->cached_error_name_val = create_const_slice(ira->codegen, array_val, 0, buf_len(&err->name), true);
         }
-        ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-        copy_const_val(out_val, err->cached_error_name_val, true);
-        return str_type;
+        IrInstruction *result = ir_const(ira, &instruction->base, nullptr);
+        copy_const_val(&result->value, err->cached_error_name_val, true);
+        result->value.type = str_type;
+        return result;
     }
 
     ira->codegen->generate_error_name_table = true;
-    ir_build_err_name_from(&ira->new_irb, &instruction->base, value);
-    return str_type;
+
+    IrInstruction *result = ir_build_err_name(&ira->new_irb,
+        instruction->base.scope, instruction->base.source_node, value);
+    result->value.type = str_type;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_enum_tag_name(IrAnalyze *ira, IrInstructionTagName *instruction) {
+static IrInstruction *ir_analyze_instruction_enum_tag_name(IrAnalyze *ira, IrInstructionTagName *instruction) {
     Error err;
-    IrInstruction *target = instruction->target->other;
+    IrInstruction *target = instruction->target->child;
     if (type_is_invalid(target->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     assert(target->value.type->id == ZigTypeIdEnum);
 
     if (instr_is_comptime(target)) {
         if ((err = type_resolve(ira->codegen, target->value.type, ResolveStatusZeroBitsKnown)))
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         TypeEnumField *field = find_enum_field_by_tag(target->value.type, &target->value.data.x_bigint);
         ConstExprValue *array_val = create_const_str_lit(ira->codegen, field->name);
-        ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-        init_const_slice(ira->codegen, out_val, array_val, 0, buf_len(field->name), true);
-        return out_val->type;
+        IrInstruction *result = ir_const(ira, &instruction->base, nullptr);
+        init_const_slice(ira->codegen, &result->value, array_val, 0, buf_len(field->name), true);
+        return result;
     }
 
     IrInstruction *result = ir_build_tag_name(&ira->new_irb, instruction->base.scope,
             instruction->base.source_node, target);
-    ir_link_new_instruction(result, &instruction->base);
     ZigType *u8_ptr_type = get_pointer_to_type_extra(
             ira->codegen, ira->codegen->builtin_types.entry_u8,
             true, false, PtrLenUnknown,
             0, 0, 0);
     result->value.type = get_slice_type(ira->codegen, u8_ptr_type);
-    return result->value.type;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_field_parent_ptr(IrAnalyze *ira,
+static IrInstruction *ir_analyze_instruction_field_parent_ptr(IrAnalyze *ira,
         IrInstructionFieldParentPtr *instruction)
 {
     Error err;
-    IrInstruction *type_value = instruction->type_value->other;
+    IrInstruction *type_value = instruction->type_value->child;
     ZigType *container_type = ir_resolve_type(ira, type_value);
     if (type_is_invalid(container_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *field_name_value = instruction->field_name->other;
+    IrInstruction *field_name_value = instruction->field_name->child;
     Buf *field_name = ir_resolve_str(ira, field_name_value);
     if (!field_name)
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *field_ptr = instruction->field_ptr->other;
+    IrInstruction *field_ptr = instruction->field_ptr->child;
     if (type_is_invalid(field_ptr->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (container_type->id != ZigTypeIdStruct) {
         ir_add_error(ira, type_value,
                 buf_sprintf("expected struct type, found '%s'", buf_ptr(&container_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     if ((err = ensure_complete_type(ira->codegen, container_type)))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     TypeStructField *field = find_struct_type_field(container_type, field_name);
     if (field == nullptr) {
         ir_add_error(ira, field_name_value,
                 buf_sprintf("struct '%s' has no field '%s'",
                     buf_ptr(&container_type->name), buf_ptr(field_name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     if (field_ptr->value.type->id != ZigTypeIdPointer) {
         ir_add_error(ira, field_ptr,
                 buf_sprintf("expected pointer, found '%s'", buf_ptr(&field_ptr->value.type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     bool is_packed = (container_type->data.structure.layout == ContainerLayoutPacked);
@@ -16960,7 +16491,7 @@ static ZigType *ir_analyze_instruction_field_parent_ptr(IrAnalyze *ira,
             field_ptr_align, 0, 0);
     IrInstruction *casted_field_ptr = ir_implicit_cast(ira, field_ptr, field_ptr_type);
     if (type_is_invalid(casted_field_ptr->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     ZigType *result_type = get_pointer_to_type_extra(ira->codegen, container_type,
             casted_field_ptr->value.type->data.pointer.is_const,
@@ -16971,11 +16502,11 @@ static ZigType *ir_analyze_instruction_field_parent_ptr(IrAnalyze *ira,
     if (instr_is_comptime(casted_field_ptr)) {
         ConstExprValue *field_ptr_val = ir_resolve_const(ira, casted_field_ptr, UndefBad);
         if (!field_ptr_val)
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
 
         if (field_ptr_val->data.x_ptr.special != ConstPtrSpecialBaseStruct) {
             ir_add_error(ira, field_ptr, buf_sprintf("pointer value not based on parent struct"));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
 
         size_t ptr_field_index = field_ptr_val->data.x_ptr.data.base_struct.field_index;
@@ -16984,68 +16515,98 @@ static ZigType *ir_analyze_instruction_field_parent_ptr(IrAnalyze *ira,
                     buf_sprintf("field '%s' has index %" ZIG_PRI_usize " but pointer value is index %" ZIG_PRI_usize " of struct '%s'",
                         buf_ptr(field->name), field->src_index,
                         ptr_field_index, buf_ptr(&container_type->name)));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
 
-        ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
+        IrInstruction *result = ir_const(ira, &instruction->base, result_type);
+        ConstExprValue *out_val = &result->value;
         out_val->data.x_ptr.special = ConstPtrSpecialRef;
         out_val->data.x_ptr.data.ref.pointee = field_ptr_val->data.x_ptr.data.base_struct.struct_val;
         out_val->data.x_ptr.mut = field_ptr_val->data.x_ptr.mut;
-
-        return result_type;
+        return result;
     }
 
     IrInstruction *result = ir_build_field_parent_ptr(&ira->new_irb, instruction->base.scope,
             instruction->base.source_node, type_value, field_name_value, casted_field_ptr, field);
-    ir_link_new_instruction(result, &instruction->base);
-    return result_type;
+    result->value.type = result_type;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_offset_of(IrAnalyze *ira,
-        IrInstructionOffsetOf *instruction)
+static TypeStructField *validate_byte_offset(IrAnalyze *ira,
+        IrInstruction *type_value,
+        IrInstruction *field_name_value,
+        size_t *byte_offset) 
 {
-    Error err;
-    IrInstruction *type_value = instruction->type_value->other;
     ZigType *container_type = ir_resolve_type(ira, type_value);
     if (type_is_invalid(container_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return nullptr;
 
+    Error err;
     if ((err = ensure_complete_type(ira->codegen, container_type)))
-        return ira->codegen->builtin_types.entry_invalid;
+        return nullptr;
 
-    IrInstruction *field_name_value = instruction->field_name->other;
     Buf *field_name = ir_resolve_str(ira, field_name_value);
     if (!field_name)
-        return ira->codegen->builtin_types.entry_invalid;
+        return nullptr;
 
     if (container_type->id != ZigTypeIdStruct) {
         ir_add_error(ira, type_value,
                 buf_sprintf("expected struct type, found '%s'", buf_ptr(&container_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return nullptr;
     }
 
     TypeStructField *field = find_struct_type_field(container_type, field_name);
     if (field == nullptr) {
         ir_add_error(ira, field_name_value,
                 buf_sprintf("struct '%s' has no field '%s'",
-                    buf_ptr(&container_type->name), buf_ptr(field_name)));
-        return ira->codegen->builtin_types.entry_invalid;
+                        buf_ptr(&container_type->name), buf_ptr(field_name)));
+        return nullptr;
     }
 
     if (!type_has_bits(field->type_entry)) {
         ir_add_error(ira, field_name_value,
-                     buf_sprintf("zero-bit field '%s' in struct '%s' has no offset",
-                                 buf_ptr(field_name), buf_ptr(&container_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+                buf_sprintf("zero-bit field '%s' in struct '%s' has no offset",
+                        buf_ptr(field_name), buf_ptr(&container_type->name)));
+        return nullptr;
     }
-    size_t byte_offset = LLVMOffsetOfElement(ira->codegen->target_data_ref, container_type->type_ref, field->gen_index);
-    ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-    bigint_init_unsigned(&out_val->data.x_bigint, byte_offset);
-    return ira->codegen->builtin_types.entry_num_lit_int;
+
+    *byte_offset = LLVMOffsetOfElement(ira->codegen->target_data_ref, container_type->type_ref, field->gen_index);
+    return field;
+}
+
+static IrInstruction *ir_analyze_instruction_byte_offset_of(IrAnalyze *ira,
+        IrInstructionByteOffsetOf *instruction)
+{
+    IrInstruction *type_value = instruction->type_value->child;
+    if (type_is_invalid(type_value->value.type))
+        return ira->codegen->invalid_instruction;
+
+    IrInstruction *field_name_value = instruction->field_name->child;
+    size_t byte_offset = 0;
+    if (!validate_byte_offset(ira, type_value, field_name_value, &byte_offset))
+        return ira->codegen->invalid_instruction;
+
+
+    return ir_const_unsigned(ira, &instruction->base, byte_offset);
 }
 
-static void ensure_field_index(ZigType *type, const char *field_name, size_t index)
+static IrInstruction *ir_analyze_instruction_bit_offset_of(IrAnalyze *ira,
+        IrInstructionBitOffsetOf *instruction)
 {
+    IrInstruction *type_value = instruction->type_value->child;
+    if (type_is_invalid(type_value->value.type))
+        return ira->codegen->invalid_instruction;
+    IrInstruction *field_name_value = instruction->field_name->child;
+    size_t byte_offset = 0;
+    TypeStructField *field = nullptr;
+    if (!(field = validate_byte_offset(ira, type_value, field_name_value, &byte_offset)))
+        return ira->codegen->invalid_instruction;
+
+    size_t bit_offset = byte_offset * 8 + field->bit_offset_in_host;
+    return ir_const_unsigned(ira, &instruction->base, bit_offset);
+}
+
+static void ensure_field_index(ZigType *type, const char *field_name, size_t index) {
     Buf *field_name_buf;
 
     assert(type != nullptr && !type_is_invalid(type));
@@ -17057,8 +16618,8 @@ static void ensure_field_index(ZigType *type, const char *field_name, size_t ind
 
 static ZigType *ir_type_info_get_type(IrAnalyze *ira, const char *type_name, ZigType *root) {
     Error err;
-    static ConstExprValue *type_info_var = nullptr;
-    static ZigType *type_info_type = nullptr;
+    static ConstExprValue *type_info_var = nullptr; // TODO oops this global variable made it past code review
+    static ZigType *type_info_type = nullptr; // TODO oops this global variable made it past code review
     if (type_info_var == nullptr) {
         type_info_var = get_builtin_value(ira->codegen, "TypeInfo");
         assert(type_info_var->type->id == ZigTypeIdMetaType);
@@ -17146,8 +16707,8 @@ static Error ir_make_type_info_defs(IrAnalyze *ira, ConstExprValue *out_val, Sco
     definition_array->special = ConstValSpecialStatic;
     definition_array->type = get_array_type(ira->codegen, type_info_definition_type, definition_count);
     definition_array->data.x_array.special = ConstArraySpecialNone;
-    definition_array->data.x_array.s_none.parent.id = ConstParentIdNone;
-    definition_array->data.x_array.s_none.elements = create_const_vals(definition_count);
+    definition_array->data.x_array.data.s_none.parent.id = ConstParentIdNone;
+    definition_array->data.x_array.data.s_none.elements = create_const_vals(definition_count);
     init_const_slice(ira->codegen, out_val, definition_array, 0, definition_count, false);
 
     // Loop through the definitions and generate info.
@@ -17164,7 +16725,7 @@ static Error ir_make_type_info_defs(IrAnalyze *ira, ConstExprValue *out_val, Sco
                 continue;
         }
 
-        ConstExprValue *definition_val = &definition_array->data.x_array.s_none.elements[definition_index];
+        ConstExprValue *definition_val = &definition_array->data.x_array.data.s_none.elements[definition_index];
 
         definition_val->special = ConstValSpecialStatic;
         definition_val->type = type_info_definition_type;
@@ -17293,15 +16854,15 @@ static Error ir_make_type_info_defs(IrAnalyze *ira, ConstExprValue *out_val, Sco
                     fn_arg_name_array->type = get_array_type(ira->codegen,
                             get_slice_type(ira->codegen, u8_ptr), fn_arg_count);
                     fn_arg_name_array->data.x_array.special = ConstArraySpecialNone;
-                    fn_arg_name_array->data.x_array.s_none.parent.id = ConstParentIdNone;
-                    fn_arg_name_array->data.x_array.s_none.elements = create_const_vals(fn_arg_count);
+                    fn_arg_name_array->data.x_array.data.s_none.parent.id = ConstParentIdNone;
+                    fn_arg_name_array->data.x_array.data.s_none.elements = create_const_vals(fn_arg_count);
 
                     init_const_slice(ira->codegen, &fn_def_fields[8], fn_arg_name_array, 0, fn_arg_count, false);
 
                     for (size_t fn_arg_index = 0; fn_arg_index < fn_arg_count; fn_arg_index++)
                     {
                         ZigVar *arg_var = fn_entry->variable_list.at(fn_arg_index);
-                        ConstExprValue *fn_arg_name_val = &fn_arg_name_array->data.x_array.s_none.elements[fn_arg_index];
+                        ConstExprValue *fn_arg_name_val = &fn_arg_name_array->data.x_array.data.s_none.elements[fn_arg_index];
                         ConstExprValue *arg_name = create_const_str_lit(ira->codegen, &arg_var->name);
                         init_const_slice(ira->codegen, fn_arg_name_val, arg_name, 0, buf_len(&arg_var->name), true);
                         fn_arg_name_val->data.x_struct.parent.id = ConstParentIdArray;
@@ -17342,6 +16903,7 @@ static Error ir_make_type_info_defs(IrAnalyze *ira, ConstExprValue *out_val, Sco
 }
 
 static ConstExprValue *create_ptr_like_type_info(IrAnalyze *ira, ZigType *ptr_type_entry) {
+    Error err;
     ZigType *attrs_type;
     uint32_t size_enum_index;
     if (is_slice(ptr_type_entry)) {
@@ -17354,6 +16916,9 @@ static ConstExprValue *create_ptr_like_type_info(IrAnalyze *ira, ZigType *ptr_ty
         zig_unreachable();
     }
 
+    if ((err = type_resolve(ira->codegen, attrs_type->data.pointer.child_type, ResolveStatusAlignmentKnown)))
+        return nullptr;
+
     ZigType *type_info_pointer_type = ir_type_info_get_type(ira, "Pointer", nullptr);
     assertNoError(ensure_complete_type(ira->codegen, type_info_pointer_type));
 
@@ -17497,6 +17062,8 @@ static Error ir_make_type_info_value(IrAnalyze *ira, ZigType *type_entry, ConstE
         case ZigTypeIdPointer:
             {
                 result = create_ptr_like_type_info(ira, type_entry);
+                if (result == nullptr)
+                    return ErrorSemanticAnalyzeFail;
                 break;
             }
         case ZigTypeIdArray:
@@ -17593,15 +17160,15 @@ static Error ir_make_type_info_value(IrAnalyze *ira, ZigType *type_entry, ConstE
                 enum_field_array->special = ConstValSpecialStatic;
                 enum_field_array->type = get_array_type(ira->codegen, type_info_enum_field_type, enum_field_count);
                 enum_field_array->data.x_array.special = ConstArraySpecialNone;
-                enum_field_array->data.x_array.s_none.parent.id = ConstParentIdNone;
-                enum_field_array->data.x_array.s_none.elements = create_const_vals(enum_field_count);
+                enum_field_array->data.x_array.data.s_none.parent.id = ConstParentIdNone;
+                enum_field_array->data.x_array.data.s_none.elements = create_const_vals(enum_field_count);
 
                 init_const_slice(ira->codegen, &fields[2], enum_field_array, 0, enum_field_count, false);
 
                 for (uint32_t enum_field_index = 0; enum_field_index < enum_field_count; enum_field_index++)
                 {
                     TypeEnumField *enum_field = &type_entry->data.enumeration.fields[enum_field_index];
-                    ConstExprValue *enum_field_val = &enum_field_array->data.x_array.s_none.elements[enum_field_index];
+                    ConstExprValue *enum_field_val = &enum_field_array->data.x_array.data.s_none.elements[enum_field_index];
                     make_enum_field_val(ira, enum_field_val, enum_field, type_info_enum_field_type);
                     enum_field_val->data.x_struct.parent.id = ConstParentIdArray;
                     enum_field_val->data.x_struct.parent.data.p_array.array_val = enum_field_array;
@@ -17632,13 +17199,13 @@ static Error ir_make_type_info_value(IrAnalyze *ira, ZigType *type_entry, ConstE
                 error_array->special = ConstValSpecialStatic;
                 error_array->type = get_array_type(ira->codegen, type_info_error_type, error_count);
                 error_array->data.x_array.special = ConstArraySpecialNone;
-                error_array->data.x_array.s_none.parent.id = ConstParentIdNone;
-                error_array->data.x_array.s_none.elements = create_const_vals(error_count);
+                error_array->data.x_array.data.s_none.parent.id = ConstParentIdNone;
+                error_array->data.x_array.data.s_none.elements = create_const_vals(error_count);
 
                 init_const_slice(ira->codegen, &fields[0], error_array, 0, error_count, false);
                 for (uint32_t error_index = 0; error_index < error_count; error_index++) {
                     ErrorTableEntry *error = type_entry->data.error_set.errors[error_index];
-                    ConstExprValue *error_val = &error_array->data.x_array.s_none.elements[error_index];
+                    ConstExprValue *error_val = &error_array->data.x_array.data.s_none.elements[error_index];
 
                     error_val->special = ConstValSpecialStatic;
                     error_val->type = type_info_error_type;
@@ -17727,8 +17294,8 @@ static Error ir_make_type_info_value(IrAnalyze *ira, ZigType *type_entry, ConstE
                 union_field_array->special = ConstValSpecialStatic;
                 union_field_array->type = get_array_type(ira->codegen, type_info_union_field_type, union_field_count);
                 union_field_array->data.x_array.special = ConstArraySpecialNone;
-                union_field_array->data.x_array.s_none.parent.id = ConstParentIdNone;
-                union_field_array->data.x_array.s_none.elements = create_const_vals(union_field_count);
+                union_field_array->data.x_array.data.s_none.parent.id = ConstParentIdNone;
+                union_field_array->data.x_array.data.s_none.elements = create_const_vals(union_field_count);
 
                 init_const_slice(ira->codegen, &fields[2], union_field_array, 0, union_field_count, false);
 
@@ -17736,7 +17303,7 @@ static Error ir_make_type_info_value(IrAnalyze *ira, ZigType *type_entry, ConstE
 
                 for (uint32_t union_field_index = 0; union_field_index < union_field_count; union_field_index++) {
                     TypeUnionField *union_field = &type_entry->data.unionation.fields[union_field_index];
-                    ConstExprValue *union_field_val = &union_field_array->data.x_array.s_none.elements[union_field_index];
+                    ConstExprValue *union_field_val = &union_field_array->data.x_array.data.s_none.elements[union_field_index];
 
                     union_field_val->special = ConstValSpecialStatic;
                     union_field_val->type = type_info_union_field_type;
@@ -17775,6 +17342,8 @@ static Error ir_make_type_info_value(IrAnalyze *ira, ZigType *type_entry, ConstE
             {
                 if (type_entry->data.structure.is_slice) {
                     result = create_ptr_like_type_info(ira, type_entry);
+                    if (result == nullptr)
+                        return ErrorSemanticAnalyzeFail;
                     break;
                 }
 
@@ -17800,14 +17369,14 @@ static Error ir_make_type_info_value(IrAnalyze *ira, ZigType *type_entry, ConstE
                 struct_field_array->special = ConstValSpecialStatic;
                 struct_field_array->type = get_array_type(ira->codegen, type_info_struct_field_type, struct_field_count);
                 struct_field_array->data.x_array.special = ConstArraySpecialNone;
-                struct_field_array->data.x_array.s_none.parent.id = ConstParentIdNone;
-                struct_field_array->data.x_array.s_none.elements = create_const_vals(struct_field_count);
+                struct_field_array->data.x_array.data.s_none.parent.id = ConstParentIdNone;
+                struct_field_array->data.x_array.data.s_none.elements = create_const_vals(struct_field_count);
 
                 init_const_slice(ira->codegen, &fields[1], struct_field_array, 0, struct_field_count, false);
 
                 for (uint32_t struct_field_index = 0; struct_field_index < struct_field_count; struct_field_index++) {
                     TypeStructField *struct_field = &type_entry->data.structure.fields[struct_field_index];
-                    ConstExprValue *struct_field_val = &struct_field_array->data.x_array.s_none.elements[struct_field_index];
+                    ConstExprValue *struct_field_val = &struct_field_array->data.x_array.data.s_none.elements[struct_field_index];
 
                     struct_field_val->special = ConstValSpecialStatic;
                     struct_field_val->type = type_info_struct_field_type;
@@ -17906,15 +17475,15 @@ static Error ir_make_type_info_value(IrAnalyze *ira, ZigType *type_entry, ConstE
                 fn_arg_array->special = ConstValSpecialStatic;
                 fn_arg_array->type = get_array_type(ira->codegen, type_info_fn_arg_type, fn_arg_count);
                 fn_arg_array->data.x_array.special = ConstArraySpecialNone;
-                fn_arg_array->data.x_array.s_none.parent.id = ConstParentIdNone;
-                fn_arg_array->data.x_array.s_none.elements = create_const_vals(fn_arg_count);
+                fn_arg_array->data.x_array.data.s_none.parent.id = ConstParentIdNone;
+                fn_arg_array->data.x_array.data.s_none.elements = create_const_vals(fn_arg_count);
 
                 init_const_slice(ira->codegen, &fields[5], fn_arg_array, 0, fn_arg_count, false);
 
                 for (size_t fn_arg_index = 0; fn_arg_index < fn_arg_count; fn_arg_index++)
                 {
                     FnTypeParamInfo *fn_param_info = &type_entry->data.fn.fn_type_id.param_info[fn_arg_index];
-                    ConstExprValue *fn_arg_val = &fn_arg_array->data.x_array.s_none.elements[fn_arg_index];
+                    ConstExprValue *fn_arg_val = &fn_arg_array->data.x_array.data.s_none.elements[fn_arg_index];
 
                     fn_arg_val->special = ConstValSpecialStatic;
                     fn_arg_val->type = type_info_fn_arg_type;
@@ -17967,23 +17536,23 @@ static Error ir_make_type_info_value(IrAnalyze *ira, ZigType *type_entry, ConstE
     return ErrorNone;
 }
 
-static ZigType *ir_analyze_instruction_type_info(IrAnalyze *ira,
+static IrInstruction *ir_analyze_instruction_type_info(IrAnalyze *ira,
         IrInstructionTypeInfo *instruction)
 {
     Error err;
-    IrInstruction *type_value = instruction->type_value->other;
+    IrInstruction *type_value = instruction->type_value->child;
     ZigType *type_entry = ir_resolve_type(ira, type_value);
     if (type_is_invalid(type_entry))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     ZigType *result_type = ir_type_info_get_type(ira, nullptr, nullptr);
 
     ConstExprValue *payload;
     if ((err = ir_make_type_info_value(ira, type_entry, &payload)))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-    out_val->type = result_type;
+    IrInstruction *result = ir_const(ira, &instruction->base, result_type);
+    ConstExprValue *out_val = &result->value;
     bigint_init_unsigned(&out_val->data.x_union.tag, type_id_index(type_entry));
     out_val->data.x_union.payload = payload;
 
@@ -17993,86 +17562,85 @@ static ZigType *ir_analyze_instruction_type_info(IrAnalyze *ira,
         payload->data.x_struct.parent.data.p_union.union_val = out_val;
     }
 
-    return result_type;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_type_id(IrAnalyze *ira,
+static IrInstruction *ir_analyze_instruction_type_id(IrAnalyze *ira,
         IrInstructionTypeId *instruction)
 {
-    IrInstruction *type_value = instruction->type_value->other;
+    IrInstruction *type_value = instruction->type_value->child;
     ZigType *type_entry = ir_resolve_type(ira, type_value);
     if (type_is_invalid(type_entry))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     ConstExprValue *var_value = get_builtin_value(ira->codegen, "TypeId");
     assert(var_value->type->id == ZigTypeIdMetaType);
     ZigType *result_type = var_value->data.x_type;
 
-    ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-    bigint_init_unsigned(&out_val->data.x_enum_tag, type_id_index(type_entry));
-    return result_type;
+    IrInstruction *result = ir_const(ira, &instruction->base, result_type);
+    bigint_init_unsigned(&result->value.data.x_enum_tag, type_id_index(type_entry));
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_set_eval_branch_quota(IrAnalyze *ira,
+static IrInstruction *ir_analyze_instruction_set_eval_branch_quota(IrAnalyze *ira,
         IrInstructionSetEvalBranchQuota *instruction)
 {
     if (ira->new_irb.exec->parent_exec != nullptr && !ira->new_irb.exec->is_generic_instantiation) {
         ir_add_error(ira, &instruction->base,
                 buf_sprintf("@setEvalBranchQuota must be called from the top of the comptime stack"));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     uint64_t new_quota;
-    if (!ir_resolve_usize(ira, instruction->new_quota->other, &new_quota))
-        return ira->codegen->builtin_types.entry_invalid;
+    if (!ir_resolve_usize(ira, instruction->new_quota->child, &new_quota))
+        return ira->codegen->invalid_instruction;
 
     if (new_quota > ira->new_irb.exec->backward_branch_quota) {
         ira->new_irb.exec->backward_branch_quota = new_quota;
     }
 
-    ir_build_const_from(ira, &instruction->base);
-    return ira->codegen->builtin_types.entry_void;
+    return ir_const_void(ira, &instruction->base);
 }
 
-static ZigType *ir_analyze_instruction_type_name(IrAnalyze *ira, IrInstructionTypeName *instruction) {
-    IrInstruction *type_value = instruction->type_value->other;
+static IrInstruction *ir_analyze_instruction_type_name(IrAnalyze *ira, IrInstructionTypeName *instruction) {
+    IrInstruction *type_value = instruction->type_value->child;
     ZigType *type_entry = ir_resolve_type(ira, type_value);
     if (type_is_invalid(type_entry))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (!type_entry->cached_const_name_val) {
         type_entry->cached_const_name_val = create_const_str_lit(ira->codegen, &type_entry->name);
     }
-    ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-    copy_const_val(out_val, type_entry->cached_const_name_val, true);
-    return out_val->type;
+    IrInstruction *result = ir_const(ira, &instruction->base, nullptr);
+    copy_const_val(&result->value, type_entry->cached_const_name_val, true);
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_c_import(IrAnalyze *ira, IrInstructionCImport *instruction) {
+static IrInstruction *ir_analyze_instruction_c_import(IrAnalyze *ira, IrInstructionCImport *instruction) {
     if (ira->codegen->enable_cache) {
         ir_add_error(ira, &instruction->base,
             buf_sprintf("TODO @cImport is incompatible with --cache on. The cache system currently is unable to detect subsequent changes in .h files."));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     AstNode *node = instruction->base.source_node;
     assert(node->type == NodeTypeFnCallExpr);
     AstNode *block_node = node->data.fn_call_expr.params.at(0);
 
-    ScopeCImport *cimport_scope = create_cimport_scope(node, instruction->base.scope);
+    ScopeCImport *cimport_scope = create_cimport_scope(ira->codegen, node, instruction->base.scope);
 
     // Execute the C import block like an inline function
     ZigType *void_type = ira->codegen->builtin_types.entry_void;
-    IrInstruction *result = ir_eval_const_value(ira->codegen, &cimport_scope->base, block_node, void_type,
+    IrInstruction *cimport_result = ir_eval_const_value(ira->codegen, &cimport_scope->base, block_node, void_type,
         ira->new_irb.exec->backward_branch_count, ira->new_irb.exec->backward_branch_quota, nullptr,
         &cimport_scope->buf, block_node, nullptr, nullptr);
-    if (type_is_invalid(result->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+    if (type_is_invalid(cimport_result->value.type))
+        return ira->codegen->invalid_instruction;
 
     find_libc_include_path(ira->codegen);
 
     ImportTableEntry *child_import = allocate<ImportTableEntry>(1);
-    child_import->decls_scope = create_decls_scope(node, nullptr, nullptr, child_import);
+    child_import->decls_scope = create_decls_scope(ira->codegen, node, nullptr, nullptr, child_import);
     child_import->c_import_node = node;
     child_import->package = new_anonymous_package();
     child_import->package->package_table.put(buf_create_from_str("builtin"), ira->codegen->compile_var_package);
@@ -18086,7 +17654,7 @@ static ZigType *ir_analyze_instruction_c_import(IrAnalyze *ira, IrInstructionCIm
     if ((err = parse_h_buf(child_import, &errors, &cimport_scope->buf, ira->codegen, node))) {
         if (err != ErrorCCompileErrors) {
             ir_add_error_node(ira, node, buf_sprintf("C import failed: %s", err_str(err)));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
     }
 
@@ -18097,7 +17665,7 @@ static ZigType *ir_analyze_instruction_c_import(IrAnalyze *ira, IrInstructionCIm
             err_msg_add_note(parent_err_msg, err_msg);
         }
 
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     if (ira->codegen->verbose_cimport) {
@@ -18108,19 +17676,19 @@ static ZigType *ir_analyze_instruction_c_import(IrAnalyze *ira, IrInstructionCIm
 
     scan_decls(ira->codegen, child_import->decls_scope, child_import->root);
 
-    ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-    out_val->data.x_import = child_import;
-    return ira->codegen->builtin_types.entry_namespace;
+    IrInstruction *result = ir_const(ira, &instruction->base, ira->codegen->builtin_types.entry_namespace);
+    result->value.data.x_import = child_import;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_c_include(IrAnalyze *ira, IrInstructionCInclude *instruction) {
-    IrInstruction *name_value = instruction->name->other;
+static IrInstruction *ir_analyze_instruction_c_include(IrAnalyze *ira, IrInstructionCInclude *instruction) {
+    IrInstruction *name_value = instruction->name->child;
     if (type_is_invalid(name_value->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     Buf *include_name = ir_resolve_str(ira, name_value);
     if (!include_name)
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     Buf *c_import_buf = exec_c_import_buf(ira->new_irb.exec);
     // We check for this error in pass1
@@ -18128,26 +17696,25 @@ static ZigType *ir_analyze_instruction_c_include(IrAnalyze *ira, IrInstructionCI
 
     buf_appendf(c_import_buf, "#include <%s>\n", buf_ptr(include_name));
 
-    ir_build_const_from(ira, &instruction->base);
-    return ira->codegen->builtin_types.entry_void;
+    return ir_const_void(ira, &instruction->base);
 }
 
-static ZigType *ir_analyze_instruction_c_define(IrAnalyze *ira, IrInstructionCDefine *instruction) {
-    IrInstruction *name = instruction->name->other;
+static IrInstruction *ir_analyze_instruction_c_define(IrAnalyze *ira, IrInstructionCDefine *instruction) {
+    IrInstruction *name = instruction->name->child;
     if (type_is_invalid(name->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     Buf *define_name = ir_resolve_str(ira, name);
     if (!define_name)
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *value = instruction->value->other;
+    IrInstruction *value = instruction->value->child;
     if (type_is_invalid(value->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     Buf *define_value = ir_resolve_str(ira, value);
     if (!define_value)
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     Buf *c_import_buf = exec_c_import_buf(ira->new_irb.exec);
     // We check for this error in pass1
@@ -18155,18 +17722,17 @@ static ZigType *ir_analyze_instruction_c_define(IrAnalyze *ira, IrInstructionCDe
 
     buf_appendf(c_import_buf, "#define %s %s\n", buf_ptr(define_name), buf_ptr(define_value));
 
-    ir_build_const_from(ira, &instruction->base);
-    return ira->codegen->builtin_types.entry_void;
+    return ir_const_void(ira, &instruction->base);
 }
 
-static ZigType *ir_analyze_instruction_c_undef(IrAnalyze *ira, IrInstructionCUndef *instruction) {
-    IrInstruction *name = instruction->name->other;
+static IrInstruction *ir_analyze_instruction_c_undef(IrAnalyze *ira, IrInstructionCUndef *instruction) {
+    IrInstruction *name = instruction->name->child;
     if (type_is_invalid(name->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     Buf *undef_name = ir_resolve_str(ira, name);
     if (!undef_name)
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     Buf *c_import_buf = exec_c_import_buf(ira->new_irb.exec);
     // We check for this error in pass1
@@ -18174,18 +17740,17 @@ static ZigType *ir_analyze_instruction_c_undef(IrAnalyze *ira, IrInstructionCUnd
 
     buf_appendf(c_import_buf, "#undef %s\n", buf_ptr(undef_name));
 
-    ir_build_const_from(ira, &instruction->base);
-    return ira->codegen->builtin_types.entry_void;
+    return ir_const_void(ira, &instruction->base);
 }
 
-static ZigType *ir_analyze_instruction_embed_file(IrAnalyze *ira, IrInstructionEmbedFile *instruction) {
-    IrInstruction *name = instruction->name->other;
+static IrInstruction *ir_analyze_instruction_embed_file(IrAnalyze *ira, IrInstructionEmbedFile *instruction) {
+    IrInstruction *name = instruction->name->child;
     if (type_is_invalid(name->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     Buf *rel_file_path = ir_resolve_str(ira, name);
     if (!rel_file_path)
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     ImportTableEntry *import = get_scope_import(instruction->base.scope);
     // figure out absolute path to resource
@@ -18205,85 +17770,86 @@ static ZigType *ir_analyze_instruction_embed_file(IrAnalyze *ira, IrInstructionE
     if ((err = file_fetch(ira->codegen, file_path, file_contents))) {
         if (err == ErrorFileNotFound) {
             ir_add_error(ira, instruction->name, buf_sprintf("unable to find '%s'", buf_ptr(file_path)));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         } else {
             ir_add_error(ira, instruction->name, buf_sprintf("unable to open '%s': %s", buf_ptr(file_path), err_str(err)));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
     }
 
-    ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-    init_const_str_lit(ira->codegen, out_val, file_contents);
-
-    return get_array_type(ira->codegen, ira->codegen->builtin_types.entry_u8, buf_len(file_contents));
+    ZigType *result_type = get_array_type(ira->codegen,
+            ira->codegen->builtin_types.entry_u8, buf_len(file_contents));
+    IrInstruction *result = ir_const(ira, &instruction->base, result_type);
+    init_const_str_lit(ira->codegen, &result->value, file_contents);
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_cmpxchg(IrAnalyze *ira, IrInstructionCmpxchg *instruction) {
-    ZigType *operand_type = ir_resolve_atomic_operand_type(ira, instruction->type_value->other);
+static IrInstruction *ir_analyze_instruction_cmpxchg(IrAnalyze *ira, IrInstructionCmpxchg *instruction) {
+    ZigType *operand_type = ir_resolve_atomic_operand_type(ira, instruction->type_value->child);
     if (type_is_invalid(operand_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *ptr = instruction->ptr->other;
+    IrInstruction *ptr = instruction->ptr->child;
     if (type_is_invalid(ptr->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     // TODO let this be volatile
     ZigType *ptr_type = get_pointer_to_type(ira->codegen, operand_type, false);
     IrInstruction *casted_ptr = ir_implicit_cast(ira, ptr, ptr_type);
     if (type_is_invalid(casted_ptr->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *cmp_value = instruction->cmp_value->other;
+    IrInstruction *cmp_value = instruction->cmp_value->child;
     if (type_is_invalid(cmp_value->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *new_value = instruction->new_value->other;
+    IrInstruction *new_value = instruction->new_value->child;
     if (type_is_invalid(new_value->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *success_order_value = instruction->success_order_value->other;
+    IrInstruction *success_order_value = instruction->success_order_value->child;
     if (type_is_invalid(success_order_value->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     AtomicOrder success_order;
     if (!ir_resolve_atomic_order(ira, success_order_value, &success_order))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *failure_order_value = instruction->failure_order_value->other;
+    IrInstruction *failure_order_value = instruction->failure_order_value->child;
     if (type_is_invalid(failure_order_value->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     AtomicOrder failure_order;
     if (!ir_resolve_atomic_order(ira, failure_order_value, &failure_order))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     IrInstruction *casted_cmp_value = ir_implicit_cast(ira, cmp_value, operand_type);
     if (type_is_invalid(casted_cmp_value->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     IrInstruction *casted_new_value = ir_implicit_cast(ira, new_value, operand_type);
     if (type_is_invalid(casted_new_value->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (success_order < AtomicOrderMonotonic) {
         ir_add_error(ira, success_order_value,
                 buf_sprintf("success atomic ordering must be Monotonic or stricter"));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
     if (failure_order < AtomicOrderMonotonic) {
         ir_add_error(ira, failure_order_value,
                 buf_sprintf("failure atomic ordering must be Monotonic or stricter"));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
     if (failure_order > success_order) {
         ir_add_error(ira, failure_order_value,
                 buf_sprintf("failure atomic ordering must be no stricter than success"));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
     if (failure_order == AtomicOrderRelease || failure_order == AtomicOrderAcqRel) {
         ir_add_error(ira, failure_order_value,
                 buf_sprintf("failure atomic ordering must not be Release or AcqRel"));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     if (instr_is_comptime(casted_ptr) && instr_is_comptime(casted_cmp_value) && instr_is_comptime(casted_new_value)) {
@@ -18294,127 +17860,118 @@ static ZigType *ir_analyze_instruction_cmpxchg(IrAnalyze *ira, IrInstructionCmpx
             nullptr, casted_ptr, casted_cmp_value, casted_new_value, nullptr, nullptr, instruction->is_weak,
             operand_type, success_order, failure_order);
     result->value.type = get_optional_type(ira->codegen, operand_type);
-    ir_link_new_instruction(result, &instruction->base);
     ir_add_alloca(ira, result, result->value.type);
-    return result->value.type;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_fence(IrAnalyze *ira, IrInstructionFence *instruction) {
-    IrInstruction *order_value = instruction->order_value->other;
+static IrInstruction *ir_analyze_instruction_fence(IrAnalyze *ira, IrInstructionFence *instruction) {
+    IrInstruction *order_value = instruction->order_value->child;
     if (type_is_invalid(order_value->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     AtomicOrder order;
     if (!ir_resolve_atomic_order(ira, order_value, &order))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    ir_build_fence_from(&ira->new_irb, &instruction->base, order_value, order);
-    return ira->codegen->builtin_types.entry_void;
+    IrInstruction *result = ir_build_fence(&ira->new_irb,
+        instruction->base.scope, instruction->base.source_node, order_value, order);
+    result->value.type = ira->codegen->builtin_types.entry_void;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_truncate(IrAnalyze *ira, IrInstructionTruncate *instruction) {
-    IrInstruction *dest_type_value = instruction->dest_type->other;
+static IrInstruction *ir_analyze_instruction_truncate(IrAnalyze *ira, IrInstructionTruncate *instruction) {
+    IrInstruction *dest_type_value = instruction->dest_type->child;
     ZigType *dest_type = ir_resolve_type(ira, dest_type_value);
     if (type_is_invalid(dest_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (dest_type->id != ZigTypeIdInt &&
         dest_type->id != ZigTypeIdComptimeInt)
     {
         ir_add_error(ira, dest_type_value, buf_sprintf("expected integer type, found '%s'", buf_ptr(&dest_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
-    IrInstruction *target = instruction->target->other;
+    IrInstruction *target = instruction->target->child;
     ZigType *src_type = target->value.type;
     if (type_is_invalid(src_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (src_type->id != ZigTypeIdInt &&
         src_type->id != ZigTypeIdComptimeInt)
     {
         ir_add_error(ira, target, buf_sprintf("expected integer type, found '%s'", buf_ptr(&src_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     if (src_type->data.integral.is_signed != dest_type->data.integral.is_signed) {
         const char *sign_str = dest_type->data.integral.is_signed ? "signed" : "unsigned";
         ir_add_error(ira, target, buf_sprintf("expected %s integer type, found '%s'", sign_str, buf_ptr(&src_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     } else if (src_type->data.integral.bit_count < dest_type->data.integral.bit_count) {
         ir_add_error(ira, target, buf_sprintf("type '%s' has fewer bits than destination type '%s'",
                     buf_ptr(&src_type->name), buf_ptr(&dest_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     if (target->value.special == ConstValSpecialStatic) {
-        ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-        bigint_truncate(&out_val->data.x_bigint, &target->value.data.x_bigint, dest_type->data.integral.bit_count,
-                dest_type->data.integral.is_signed);
-        return dest_type;
+        IrInstruction *result = ir_const(ira, &instruction->base, dest_type);
+        bigint_truncate(&result->value.data.x_bigint, &target->value.data.x_bigint,
+                dest_type->data.integral.bit_count, dest_type->data.integral.is_signed);
+        return result;
     }
 
     IrInstruction *new_instruction = ir_build_truncate(&ira->new_irb, instruction->base.scope,
             instruction->base.source_node, dest_type_value, target);
-    ir_link_new_instruction(new_instruction, &instruction->base);
-    return dest_type;
+    new_instruction->value.type = dest_type;
+    return new_instruction;
 }
 
-static ZigType *ir_analyze_instruction_int_cast(IrAnalyze *ira, IrInstructionIntCast *instruction) {
-    ZigType *dest_type = ir_resolve_type(ira, instruction->dest_type->other);
+static IrInstruction *ir_analyze_instruction_int_cast(IrAnalyze *ira, IrInstructionIntCast *instruction) {
+    ZigType *dest_type = ir_resolve_type(ira, instruction->dest_type->child);
     if (type_is_invalid(dest_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (dest_type->id != ZigTypeIdInt) {
         ir_add_error(ira, instruction->dest_type, buf_sprintf("expected integer type, found '%s'", buf_ptr(&dest_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
-    IrInstruction *target = instruction->target->other;
+    IrInstruction *target = instruction->target->child;
     if (type_is_invalid(target->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (target->value.type->id == ZigTypeIdComptimeInt) {
         if (ir_num_lit_fits_in_other_type(ira, target, dest_type, true)) {
-            IrInstruction *result = ir_resolve_cast(ira, &instruction->base, target, dest_type,
-                    CastOpNumLitToConcrete, false);
-            if (type_is_invalid(result->value.type))
-                return ira->codegen->builtin_types.entry_invalid;
-            ir_link_new_instruction(result, &instruction->base);
-            return dest_type;
+            return ir_resolve_cast(ira, &instruction->base, target, dest_type, CastOpNumLitToConcrete, false);
         } else {
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
     }
 
     if (target->value.type->id != ZigTypeIdInt) {
         ir_add_error(ira, instruction->target, buf_sprintf("expected integer type, found '%s'",
                     buf_ptr(&target->value.type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
-    IrInstruction *result = ir_analyze_widen_or_shorten(ira, &instruction->base, target, dest_type);
-    if (type_is_invalid(result->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
-
-    ir_link_new_instruction(result, &instruction->base);
-    return dest_type;
+    return ir_analyze_widen_or_shorten(ira, &instruction->base, target, dest_type);
 }
 
-static ZigType *ir_analyze_instruction_float_cast(IrAnalyze *ira, IrInstructionFloatCast *instruction) {
-    ZigType *dest_type = ir_resolve_type(ira, instruction->dest_type->other);
+static IrInstruction *ir_analyze_instruction_float_cast(IrAnalyze *ira, IrInstructionFloatCast *instruction) {
+    ZigType *dest_type = ir_resolve_type(ira, instruction->dest_type->child);
     if (type_is_invalid(dest_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (dest_type->id != ZigTypeIdFloat) {
         ir_add_error(ira, instruction->dest_type,
                 buf_sprintf("expected float type, found '%s'", buf_ptr(&dest_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
-    IrInstruction *target = instruction->target->other;
+    IrInstruction *target = instruction->target->child;
     if (type_is_invalid(target->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (target->value.type->id == ZigTypeIdComptimeInt ||
         target->value.type->id == ZigTypeIdComptimeFloat)
@@ -18426,55 +17983,43 @@ static ZigType *ir_analyze_instruction_float_cast(IrAnalyze *ira, IrInstructionF
             } else {
                 op = CastOpNumLitToConcrete;
             }
-            IrInstruction *result = ir_resolve_cast(ira, &instruction->base, target, dest_type, op, false);
-            if (type_is_invalid(result->value.type))
-                return ira->codegen->builtin_types.entry_invalid;
-            ir_link_new_instruction(result, &instruction->base);
-            return dest_type;
+            return ir_resolve_cast(ira, &instruction->base, target, dest_type, op, false);
         } else {
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
     }
 
     if (target->value.type->id != ZigTypeIdFloat) {
         ir_add_error(ira, instruction->target, buf_sprintf("expected float type, found '%s'",
                     buf_ptr(&target->value.type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
-    IrInstruction *result = ir_analyze_widen_or_shorten(ira, &instruction->base, target, dest_type);
-    if (type_is_invalid(result->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
-    ir_link_new_instruction(result, &instruction->base);
-    return dest_type;
+    return ir_analyze_widen_or_shorten(ira, &instruction->base, target, dest_type);
 }
 
-static ZigType *ir_analyze_instruction_err_set_cast(IrAnalyze *ira, IrInstructionErrSetCast *instruction) {
-    ZigType *dest_type = ir_resolve_type(ira, instruction->dest_type->other);
+static IrInstruction *ir_analyze_instruction_err_set_cast(IrAnalyze *ira, IrInstructionErrSetCast *instruction) {
+    ZigType *dest_type = ir_resolve_type(ira, instruction->dest_type->child);
     if (type_is_invalid(dest_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (dest_type->id != ZigTypeIdErrorSet) {
         ir_add_error(ira, instruction->dest_type,
                 buf_sprintf("expected error set type, found '%s'", buf_ptr(&dest_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
-    IrInstruction *target = instruction->target->other;
+    IrInstruction *target = instruction->target->child;
     if (type_is_invalid(target->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (target->value.type->id != ZigTypeIdErrorSet) {
         ir_add_error(ira, instruction->target,
                 buf_sprintf("expected error set type, found '%s'", buf_ptr(&target->value.type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
-    IrInstruction *result = ir_analyze_err_set_cast(ira, &instruction->base, target, dest_type);
-    if (type_is_invalid(result->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
-    ir_link_new_instruction(result, &instruction->base);
-    return dest_type;
+    return ir_analyze_err_set_cast(ira, &instruction->base, target, dest_type);
 }
 
 static Error resolve_ptr_align(IrAnalyze *ira, ZigType *ty, uint32_t *result_align) {
@@ -18489,16 +18034,16 @@ static Error resolve_ptr_align(IrAnalyze *ira, ZigType *ty, uint32_t *result_ali
     return ErrorNone;
 }
 
-static ZigType *ir_analyze_instruction_from_bytes(IrAnalyze *ira, IrInstructionFromBytes *instruction) {
+static IrInstruction *ir_analyze_instruction_from_bytes(IrAnalyze *ira, IrInstructionFromBytes *instruction) {
     Error err;
 
-    ZigType *dest_child_type = ir_resolve_type(ira, instruction->dest_child_type->other);
+    ZigType *dest_child_type = ir_resolve_type(ira, instruction->dest_child_type->child);
     if (type_is_invalid(dest_child_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *target = instruction->target->other;
+    IrInstruction *target = instruction->target->child;
     if (type_is_invalid(target->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     bool src_ptr_const;
     bool src_ptr_volatile;
@@ -18508,26 +18053,26 @@ static ZigType *ir_analyze_instruction_from_bytes(IrAnalyze *ira, IrInstructionF
         src_ptr_volatile = target->value.type->data.pointer.is_volatile;
 
         if ((err = resolve_ptr_align(ira, target->value.type, &src_ptr_align)))
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
     } else if (is_slice(target->value.type)) {
         ZigType *src_ptr_type = target->value.type->data.structure.fields[slice_ptr_index].type_entry;
         src_ptr_const = src_ptr_type->data.pointer.is_const;
         src_ptr_volatile = src_ptr_type->data.pointer.is_volatile;
 
         if ((err = resolve_ptr_align(ira, src_ptr_type, &src_ptr_align)))
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
     } else {
         src_ptr_const = true;
         src_ptr_volatile = false;
 
         if ((err = type_resolve(ira->codegen, target->value.type, ResolveStatusAlignmentKnown)))
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
 
         src_ptr_align = get_abi_alignment(ira->codegen, target->value.type);
     }
 
     if ((err = type_resolve(ira->codegen, dest_child_type, ResolveStatusSizeKnown)))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     ZigType *dest_ptr_type = get_pointer_to_type_extra(ira->codegen, dest_child_type,
             src_ptr_const, src_ptr_volatile, PtrLenUnknown,
@@ -18541,7 +18086,7 @@ static ZigType *ir_analyze_instruction_from_bytes(IrAnalyze *ira, IrInstructionF
 
     IrInstruction *casted_value = ir_implicit_cast(ira, target, u8_slice);
     if (type_is_invalid(casted_value->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     bool have_known_len = false;
     uint64_t known_len;
@@ -18549,7 +18094,7 @@ static ZigType *ir_analyze_instruction_from_bytes(IrAnalyze *ira, IrInstructionF
     if (instr_is_comptime(casted_value)) {
         ConstExprValue *val = ir_resolve_const(ira, casted_value, UndefBad);
         if (!val)
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
 
         ConstExprValue *len_val = &val->data.x_struct.fields[slice_len_index];
         if (value_is_comptime(len_val)) {
@@ -18573,96 +18118,84 @@ static ZigType *ir_analyze_instruction_from_bytes(IrAnalyze *ira, IrInstructionF
             add_error_note(ira->codegen, msg, instruction->dest_child_type->source_node,
                 buf_sprintf("%s has size %" ZIG_PRI_u64 "; remaining bytes: %" ZIG_PRI_u64,
                 buf_ptr(&dest_child_type->name), child_type_size, remainder));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
     }
 
-    IrInstruction *result = ir_resolve_cast(ira, &instruction->base, casted_value, dest_slice_type, CastOpResizeSlice, true);
-    ir_link_new_instruction(result, &instruction->base);
-    return dest_slice_type;
+    return ir_resolve_cast(ira, &instruction->base, casted_value, dest_slice_type, CastOpResizeSlice, true);
 }
 
-static ZigType *ir_analyze_instruction_to_bytes(IrAnalyze *ira, IrInstructionToBytes *instruction) {
+static IrInstruction *ir_analyze_instruction_to_bytes(IrAnalyze *ira, IrInstructionToBytes *instruction) {
     Error err;
 
-    IrInstruction *target = instruction->target->other;
+    IrInstruction *target = instruction->target->child;
     if (type_is_invalid(target->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (!is_slice(target->value.type)) {
         ir_add_error(ira, instruction->target,
                 buf_sprintf("expected slice, found '%s'", buf_ptr(&target->value.type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     ZigType *src_ptr_type = target->value.type->data.structure.fields[slice_ptr_index].type_entry;
 
     uint32_t alignment;
     if ((err = resolve_ptr_align(ira, src_ptr_type, &alignment)))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     ZigType *dest_ptr_type = get_pointer_to_type_extra(ira->codegen, ira->codegen->builtin_types.entry_u8,
             src_ptr_type->data.pointer.is_const, src_ptr_type->data.pointer.is_volatile, PtrLenUnknown,
             alignment, 0, 0);
     ZigType *dest_slice_type = get_slice_type(ira->codegen, dest_ptr_type);
 
-    IrInstruction *result = ir_resolve_cast(ira, &instruction->base, target, dest_slice_type, CastOpResizeSlice, true);
-    ir_link_new_instruction(result, &instruction->base);
-    return dest_slice_type;
+    return ir_resolve_cast(ira, &instruction->base, target, dest_slice_type, CastOpResizeSlice, true);
 }
 
-static ZigType *ir_analyze_instruction_int_to_float(IrAnalyze *ira, IrInstructionIntToFloat *instruction) {
-    ZigType *dest_type = ir_resolve_type(ira, instruction->dest_type->other);
+static IrInstruction *ir_analyze_instruction_int_to_float(IrAnalyze *ira, IrInstructionIntToFloat *instruction) {
+    ZigType *dest_type = ir_resolve_type(ira, instruction->dest_type->child);
     if (type_is_invalid(dest_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *target = instruction->target->other;
+    IrInstruction *target = instruction->target->child;
     if (type_is_invalid(target->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (target->value.type->id != ZigTypeIdInt && target->value.type->id != ZigTypeIdComptimeInt) {
         ir_add_error(ira, instruction->target, buf_sprintf("expected int type, found '%s'",
                     buf_ptr(&target->value.type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
-    IrInstruction *result = ir_resolve_cast(ira, &instruction->base, target, dest_type, CastOpIntToFloat, false);
-    ir_link_new_instruction(result, &instruction->base);
-    return dest_type;
+    return ir_resolve_cast(ira, &instruction->base, target, dest_type, CastOpIntToFloat, false);
 }
 
-static ZigType *ir_analyze_instruction_float_to_int(IrAnalyze *ira, IrInstructionFloatToInt *instruction) {
-    ZigType *dest_type = ir_resolve_type(ira, instruction->dest_type->other);
+static IrInstruction *ir_analyze_instruction_float_to_int(IrAnalyze *ira, IrInstructionFloatToInt *instruction) {
+    ZigType *dest_type = ir_resolve_type(ira, instruction->dest_type->child);
     if (type_is_invalid(dest_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *target = instruction->target->other;
+    IrInstruction *target = instruction->target->child;
     if (type_is_invalid(target->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (target->value.type->id == ZigTypeIdComptimeInt) {
-        IrInstruction *casted_value = ir_implicit_cast(ira, target, dest_type);
-        if (type_is_invalid(casted_value->value.type))
-            return ira->codegen->builtin_types.entry_invalid;
-        ir_link_new_instruction(casted_value, &instruction->base);
-        return casted_value->value.type;
+        return ir_implicit_cast(ira, target, dest_type);
     }
 
     if (target->value.type->id != ZigTypeIdFloat && target->value.type->id != ZigTypeIdComptimeFloat) {
         ir_add_error(ira, instruction->target, buf_sprintf("expected float type, found '%s'",
                     buf_ptr(&target->value.type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
-    IrInstruction *result = ir_resolve_cast(ira, &instruction->base, target, dest_type, CastOpFloatToInt, false);
-    ir_link_new_instruction(result, &instruction->base);
-    return dest_type;
+    return ir_resolve_cast(ira, &instruction->base, target, dest_type, CastOpFloatToInt, false);
 }
 
-static ZigType *ir_analyze_instruction_err_to_int(IrAnalyze *ira, IrInstructionErrToInt *instruction) {
-    IrInstruction *target = instruction->target->other;
+static IrInstruction *ir_analyze_instruction_err_to_int(IrAnalyze *ira, IrInstructionErrToInt *instruction) {
+    IrInstruction *target = instruction->target->child;
     if (type_is_invalid(target->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     IrInstruction *casted_target;
     if (target->value.type->id == ZigTypeIdErrorSet) {
@@ -18670,110 +18203,100 @@ static ZigType *ir_analyze_instruction_err_to_int(IrAnalyze *ira, IrInstructionE
     } else {
         casted_target = ir_implicit_cast(ira, target, ira->codegen->builtin_types.entry_global_error_set);
         if (type_is_invalid(casted_target->value.type))
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
     }
 
-    IrInstruction *result = ir_analyze_err_to_int(ira, &instruction->base, casted_target, ira->codegen->err_tag_type);
-    ir_link_new_instruction(result, &instruction->base);
-    return result->value.type;
+    return ir_analyze_err_to_int(ira, &instruction->base, casted_target, ira->codegen->err_tag_type);
 }
 
-static ZigType *ir_analyze_instruction_int_to_err(IrAnalyze *ira, IrInstructionIntToErr *instruction) {
-    IrInstruction *target = instruction->target->other;
+static IrInstruction *ir_analyze_instruction_int_to_err(IrAnalyze *ira, IrInstructionIntToErr *instruction) {
+    IrInstruction *target = instruction->target->child;
     if (type_is_invalid(target->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     IrInstruction *casted_target = ir_implicit_cast(ira, target, ira->codegen->err_tag_type);
     if (type_is_invalid(casted_target->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *result = ir_analyze_int_to_err(ira, &instruction->base, casted_target, ira->codegen->builtin_types.entry_global_error_set);
-    ir_link_new_instruction(result, &instruction->base);
-    return result->value.type;
+    return ir_analyze_int_to_err(ira, &instruction->base, casted_target, ira->codegen->builtin_types.entry_global_error_set);
 }
 
-static ZigType *ir_analyze_instruction_bool_to_int(IrAnalyze *ira, IrInstructionBoolToInt *instruction) {
-    IrInstruction *target = instruction->target->other;
+static IrInstruction *ir_analyze_instruction_bool_to_int(IrAnalyze *ira, IrInstructionBoolToInt *instruction) {
+    IrInstruction *target = instruction->target->child;
     if (type_is_invalid(target->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (target->value.type->id != ZigTypeIdBool) {
         ir_add_error(ira, instruction->target, buf_sprintf("expected bool, found '%s'",
                     buf_ptr(&target->value.type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     if (instr_is_comptime(target)) {
         bool is_true;
         if (!ir_resolve_bool(ira, target, &is_true))
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
 
-        ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-        bigint_init_unsigned(&out_val->data.x_bigint, is_true ? 1 : 0);
-        return ira->codegen->builtin_types.entry_num_lit_int;
+        return ir_const_unsigned(ira, &instruction->base, is_true ? 1 : 0);
     }
 
     ZigType *u1_type = get_int_type(ira->codegen, false, 1);
-    IrInstruction *result = ir_resolve_cast(ira, &instruction->base, target, u1_type, CastOpBoolToInt, false);
-    ir_link_new_instruction(result, &instruction->base);
-    return u1_type;
+    return ir_resolve_cast(ira, &instruction->base, target, u1_type, CastOpBoolToInt, false);
 }
 
-static ZigType *ir_analyze_instruction_int_type(IrAnalyze *ira, IrInstructionIntType *instruction) {
-    IrInstruction *is_signed_value = instruction->is_signed->other;
+static IrInstruction *ir_analyze_instruction_int_type(IrAnalyze *ira, IrInstructionIntType *instruction) {
+    IrInstruction *is_signed_value = instruction->is_signed->child;
     bool is_signed;
     if (!ir_resolve_bool(ira, is_signed_value, &is_signed))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *bit_count_value = instruction->bit_count->other;
+    IrInstruction *bit_count_value = instruction->bit_count->child;
     uint64_t bit_count;
     if (!ir_resolve_unsigned(ira, bit_count_value, ira->codegen->builtin_types.entry_u32, &bit_count))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-    out_val->data.x_type = get_int_type(ira->codegen, is_signed, (uint32_t)bit_count);
-    return ira->codegen->builtin_types.entry_type;
+    return ir_const_type(ira, &instruction->base, get_int_type(ira->codegen, is_signed, (uint32_t)bit_count));
 }
 
-static ZigType *ir_analyze_instruction_bool_not(IrAnalyze *ira, IrInstructionBoolNot *instruction) {
-    IrInstruction *value = instruction->value->other;
+static IrInstruction *ir_analyze_instruction_bool_not(IrAnalyze *ira, IrInstructionBoolNot *instruction) {
+    IrInstruction *value = instruction->value->child;
     if (type_is_invalid(value->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     ZigType *bool_type = ira->codegen->builtin_types.entry_bool;
 
     IrInstruction *casted_value = ir_implicit_cast(ira, value, bool_type);
     if (type_is_invalid(casted_value->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (instr_is_comptime(casted_value)) {
         ConstExprValue *value = ir_resolve_const(ira, casted_value, UndefBad);
         if (value == nullptr)
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
 
-        ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-        out_val->data.x_bool = !value->data.x_bool;
-        return bool_type;
+        return ir_const_bool(ira, &instruction->base, !value->data.x_bool);
     }
 
-    ir_build_bool_not_from(&ira->new_irb, &instruction->base, casted_value);
-    return bool_type;
+    IrInstruction *result = ir_build_bool_not(&ira->new_irb, instruction->base.scope,
+            instruction->base.source_node, casted_value);
+    result->value.type = bool_type;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_memset(IrAnalyze *ira, IrInstructionMemset *instruction) {
+static IrInstruction *ir_analyze_instruction_memset(IrAnalyze *ira, IrInstructionMemset *instruction) {
     Error err;
 
-    IrInstruction *dest_ptr = instruction->dest_ptr->other;
+    IrInstruction *dest_ptr = instruction->dest_ptr->child;
     if (type_is_invalid(dest_ptr->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *byte_value = instruction->byte->other;
+    IrInstruction *byte_value = instruction->byte->child;
     if (type_is_invalid(byte_value->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *count_value = instruction->count->other;
+    IrInstruction *count_value = instruction->count->child;
     if (type_is_invalid(count_value->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     ZigType *dest_uncasted_type = dest_ptr->value.type;
     bool dest_is_volatile = (dest_uncasted_type->id == ZigTypeIdPointer) &&
@@ -18784,7 +18307,7 @@ static ZigType *ir_analyze_instruction_memset(IrAnalyze *ira, IrInstructionMemse
     uint32_t dest_align;
     if (dest_uncasted_type->id == ZigTypeIdPointer) {
         if ((err = resolve_ptr_align(ira, dest_uncasted_type, &dest_align)))
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
     } else {
         dest_align = get_abi_alignment(ira->codegen, u8);
     }
@@ -18793,15 +18316,15 @@ static ZigType *ir_analyze_instruction_memset(IrAnalyze *ira, IrInstructionMemse
 
     IrInstruction *casted_dest_ptr = ir_implicit_cast(ira, dest_ptr, u8_ptr);
     if (type_is_invalid(casted_dest_ptr->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     IrInstruction *casted_byte = ir_implicit_cast(ira, byte_value, u8);
     if (type_is_invalid(casted_byte->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     IrInstruction *casted_count = ir_implicit_cast(ira, count_value, usize);
     if (type_is_invalid(casted_count->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (casted_dest_ptr->value.special == ConstValSpecialStatic &&
         casted_byte->value.special == ConstValSpecialStatic &&
@@ -18826,7 +18349,7 @@ static ZigType *ir_analyze_instruction_memset(IrAnalyze *ira, IrInstructionMemse
                 {
                     ConstExprValue *array_val = dest_ptr_val->data.x_ptr.data.base_array.array_val;
                     expand_undef_array(ira->codegen, array_val);
-                    dest_elements = array_val->data.x_array.s_none.elements;
+                    dest_elements = array_val->data.x_array.data.s_none.elements;
                     start = dest_ptr_val->data.x_ptr.data.base_array.elem_index;
                     bound_end = array_val->type->data.array.len;
                     break;
@@ -18843,7 +18366,7 @@ static ZigType *ir_analyze_instruction_memset(IrAnalyze *ira, IrInstructionMemse
         size_t end = start + count;
         if (end > bound_end) {
             ir_add_error(ira, count_value, buf_sprintf("out of bounds pointer access"));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
 
         ConstExprValue *byte_val = &casted_byte->value;
@@ -18851,28 +18374,29 @@ static ZigType *ir_analyze_instruction_memset(IrAnalyze *ira, IrInstructionMemse
             dest_elements[i] = *byte_val;
         }
 
-        ir_build_const_from(ira, &instruction->base);
-        return ira->codegen->builtin_types.entry_void;
+        return ir_const_void(ira, &instruction->base);
     }
 
-    ir_build_memset_from(&ira->new_irb, &instruction->base, casted_dest_ptr, casted_byte, casted_count);
-    return ira->codegen->builtin_types.entry_void;
+    IrInstruction *result = ir_build_memset(&ira->new_irb, instruction->base.scope, instruction->base.source_node,
+            casted_dest_ptr, casted_byte, casted_count);
+    result->value.type = ira->codegen->builtin_types.entry_void;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_memcpy(IrAnalyze *ira, IrInstructionMemcpy *instruction) {
+static IrInstruction *ir_analyze_instruction_memcpy(IrAnalyze *ira, IrInstructionMemcpy *instruction) {
     Error err;
 
-    IrInstruction *dest_ptr = instruction->dest_ptr->other;
+    IrInstruction *dest_ptr = instruction->dest_ptr->child;
     if (type_is_invalid(dest_ptr->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *src_ptr = instruction->src_ptr->other;
+    IrInstruction *src_ptr = instruction->src_ptr->child;
     if (type_is_invalid(src_ptr->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *count_value = instruction->count->other;
+    IrInstruction *count_value = instruction->count->child;
     if (type_is_invalid(count_value->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     ZigType *u8 = ira->codegen->builtin_types.entry_u8;
     ZigType *dest_uncasted_type = dest_ptr->value.type;
@@ -18885,7 +18409,7 @@ static ZigType *ir_analyze_instruction_memcpy(IrAnalyze *ira, IrInstructionMemcp
     uint32_t dest_align;
     if (dest_uncasted_type->id == ZigTypeIdPointer) {
         if ((err = resolve_ptr_align(ira, dest_uncasted_type, &dest_align)))
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
     } else {
         dest_align = get_abi_alignment(ira->codegen, u8);
     }
@@ -18893,7 +18417,7 @@ static ZigType *ir_analyze_instruction_memcpy(IrAnalyze *ira, IrInstructionMemcp
     uint32_t src_align;
     if (src_uncasted_type->id == ZigTypeIdPointer) {
         if ((err = resolve_ptr_align(ira, src_uncasted_type, &src_align)))
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
     } else {
         src_align = get_abi_alignment(ira->codegen, u8);
     }
@@ -18906,15 +18430,15 @@ static ZigType *ir_analyze_instruction_memcpy(IrAnalyze *ira, IrInstructionMemcp
 
     IrInstruction *casted_dest_ptr = ir_implicit_cast(ira, dest_ptr, u8_ptr_mut);
     if (type_is_invalid(casted_dest_ptr->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     IrInstruction *casted_src_ptr = ir_implicit_cast(ira, src_ptr, u8_ptr_const);
     if (type_is_invalid(casted_src_ptr->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     IrInstruction *casted_count = ir_implicit_cast(ira, count_value, usize);
     if (type_is_invalid(casted_count->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (casted_dest_ptr->value.special == ConstValSpecialStatic &&
         casted_src_ptr->value.special == ConstValSpecialStatic &&
@@ -18940,7 +18464,7 @@ static ZigType *ir_analyze_instruction_memcpy(IrAnalyze *ira, IrInstructionMemcp
                 {
                     ConstExprValue *array_val = dest_ptr_val->data.x_ptr.data.base_array.array_val;
                     expand_undef_array(ira->codegen, array_val);
-                    dest_elements = array_val->data.x_array.s_none.elements;
+                    dest_elements = array_val->data.x_array.data.s_none.elements;
                     dest_start = dest_ptr_val->data.x_ptr.data.base_array.elem_index;
                     dest_end = array_val->type->data.array.len;
                     break;
@@ -18955,7 +18479,7 @@ static ZigType *ir_analyze_instruction_memcpy(IrAnalyze *ira, IrInstructionMemcp
 
         if (dest_start + count > dest_end) {
             ir_add_error(ira, &instruction->base, buf_sprintf("out of bounds pointer access"));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
 
         ConstExprValue *src_ptr_val = &casted_src_ptr->value;
@@ -18976,7 +18500,7 @@ static ZigType *ir_analyze_instruction_memcpy(IrAnalyze *ira, IrInstructionMemcp
                 {
                     ConstExprValue *array_val = src_ptr_val->data.x_ptr.data.base_array.array_val;
                     expand_undef_array(ira->codegen, array_val);
-                    src_elements = array_val->data.x_array.s_none.elements;
+                    src_elements = array_val->data.x_array.data.s_none.elements;
                     src_start = src_ptr_val->data.x_ptr.data.base_array.elem_index;
                     src_end = array_val->type->data.array.len;
                     break;
@@ -18991,7 +18515,7 @@ static ZigType *ir_analyze_instruction_memcpy(IrAnalyze *ira, IrInstructionMemcp
 
         if (src_start + count > src_end) {
             ir_add_error(ira, &instruction->base, buf_sprintf("out of bounds pointer access"));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
 
         // TODO check for noalias violations - this should be generalized to work for any function
@@ -19000,40 +18524,41 @@ static ZigType *ir_analyze_instruction_memcpy(IrAnalyze *ira, IrInstructionMemcp
             dest_elements[dest_start + i] = src_elements[src_start + i];
         }
 
-        ir_build_const_from(ira, &instruction->base);
-        return ira->codegen->builtin_types.entry_void;
+        return ir_const_void(ira, &instruction->base);
     }
 
-    ir_build_memcpy_from(&ira->new_irb, &instruction->base, casted_dest_ptr, casted_src_ptr, casted_count);
-    return ira->codegen->builtin_types.entry_void;
+    IrInstruction *result = ir_build_memcpy(&ira->new_irb, instruction->base.scope, instruction->base.source_node,
+            casted_dest_ptr, casted_src_ptr, casted_count);
+    result->value.type = ira->codegen->builtin_types.entry_void;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_slice(IrAnalyze *ira, IrInstructionSlice *instruction) {
-    IrInstruction *ptr_ptr = instruction->ptr->other;
+static IrInstruction *ir_analyze_instruction_slice(IrAnalyze *ira, IrInstructionSlice *instruction) {
+    IrInstruction *ptr_ptr = instruction->ptr->child;
     if (type_is_invalid(ptr_ptr->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     ZigType *ptr_type = ptr_ptr->value.type;
     assert(ptr_type->id == ZigTypeIdPointer);
     ZigType *array_type = ptr_type->data.pointer.child_type;
 
-    IrInstruction *start = instruction->start->other;
+    IrInstruction *start = instruction->start->child;
     if (type_is_invalid(start->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     ZigType *usize = ira->codegen->builtin_types.entry_usize;
     IrInstruction *casted_start = ir_implicit_cast(ira, start, usize);
     if (type_is_invalid(casted_start->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     IrInstruction *end;
     if (instruction->end) {
-        end = instruction->end->other;
+        end = instruction->end->child;
         if (type_is_invalid(end->value.type))
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         end = ir_implicit_cast(ira, end, usize);
         if (type_is_invalid(end->value.type))
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
     } else {
         end = nullptr;
     }
@@ -19061,17 +18586,13 @@ static ZigType *ir_analyze_instruction_slice(IrAnalyze *ira, IrInstructionSlice
                 return_type = get_slice_type(ira->codegen, slice_ptr_type);
             } else {
                 ir_add_error(ira, &instruction->base, buf_sprintf("slice of single-item pointer"));
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             }
         } else {
-            ZigType *slice_ptr_type = get_pointer_to_type_extra(ira->codegen, array_type->data.pointer.child_type,
-                    array_type->data.pointer.is_const, array_type->data.pointer.is_volatile,
-                    PtrLenUnknown,
-                    array_type->data.pointer.explicit_alignment, 0, 0);
-            return_type = get_slice_type(ira->codegen, slice_ptr_type);
+            return_type = get_slice_type(ira->codegen, array_type);
             if (!end) {
                 ir_add_error(ira, &instruction->base, buf_sprintf("slice of pointer must include end value"));
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             }
         }
     } else if (is_slice(array_type)) {
@@ -19080,7 +18601,7 @@ static ZigType *ir_analyze_instruction_slice(IrAnalyze *ira, IrInstructionSlice
     } else {
         ir_add_error(ira, &instruction->base,
             buf_sprintf("slice of non-array type '%s'", buf_ptr(&array_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     if (instr_is_comptime(ptr_ptr) &&
@@ -19100,18 +18621,18 @@ static ZigType *ir_analyze_instruction_slice(IrAnalyze *ira, IrInstructionSlice
                 assert(child_array_type->id == ZigTypeIdArray);
                 parent_ptr = ir_const_ptr_pointee(ira, &ptr_ptr->value, instruction->base.source_node);
                 if (parent_ptr == nullptr)
-                    return ira->codegen->builtin_types.entry_invalid;
+                    return ira->codegen->invalid_instruction;
 
                 array_val = ir_const_ptr_pointee(ira, parent_ptr, instruction->base.source_node);
                 if (array_val == nullptr)
-                    return ira->codegen->builtin_types.entry_invalid;
+                    return ira->codegen->invalid_instruction;
 
                 rel_end = child_array_type->data.array.len;
                 abs_offset = 0;
             } else {
                 array_val = ir_const_ptr_pointee(ira, &ptr_ptr->value, instruction->base.source_node);
                 if (array_val == nullptr)
-                    return ira->codegen->builtin_types.entry_invalid;
+                    return ira->codegen->invalid_instruction;
                 rel_end = array_type->data.array.len;
                 parent_ptr = nullptr;
                 abs_offset = 0;
@@ -19120,7 +18641,7 @@ static ZigType *ir_analyze_instruction_slice(IrAnalyze *ira, IrInstructionSlice
             assert(array_type->data.pointer.ptr_len == PtrLenUnknown);
             parent_ptr = ir_const_ptr_pointee(ira, &ptr_ptr->value, instruction->base.source_node);
             if (parent_ptr == nullptr)
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
 
             if (parent_ptr->special == ConstValSpecialUndef) {
                 array_val = nullptr;
@@ -19132,9 +18653,15 @@ static ZigType *ir_analyze_instruction_slice(IrAnalyze *ira, IrInstructionSlice
                 case ConstPtrSpecialDiscard:
                     zig_unreachable();
                 case ConstPtrSpecialRef:
-                    array_val = nullptr;
-                    abs_offset = SIZE_MAX;
-                    rel_end = 1;
+                    if (parent_ptr->data.x_ptr.data.ref.pointee->type->id == ZigTypeIdArray) {
+                        array_val = parent_ptr->data.x_ptr.data.ref.pointee;
+                        abs_offset = 0;
+                        rel_end = array_val->type->data.array.len;
+                    } else {
+                        array_val = nullptr;
+                        abs_offset = SIZE_MAX;
+                        rel_end = 1;
+                    }
                     break;
                 case ConstPtrSpecialBaseArray:
                     array_val = parent_ptr->data.x_ptr.data.base_array.array_val;
@@ -19154,9 +18681,14 @@ static ZigType *ir_analyze_instruction_slice(IrAnalyze *ira, IrInstructionSlice
         } else if (is_slice(array_type)) {
             ConstExprValue *slice_ptr = ir_const_ptr_pointee(ira, &ptr_ptr->value, instruction->base.source_node);
             if (slice_ptr == nullptr)
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
 
             parent_ptr = &slice_ptr->data.x_struct.fields[slice_ptr_index];
+            if (parent_ptr->special == ConstValSpecialUndef) {
+                ir_add_error(ira, &instruction->base, buf_sprintf("slice of undefined"));
+                return ira->codegen->invalid_instruction;
+            }
+
             ConstExprValue *len_val = &slice_ptr->data.x_struct.fields[slice_len_index];
 
             switch (parent_ptr->data.x_ptr.special) {
@@ -19190,7 +18722,7 @@ static ZigType *ir_analyze_instruction_slice(IrAnalyze *ira, IrInstructionSlice
         uint64_t start_scalar = bigint_as_unsigned(&casted_start->value.data.x_bigint);
         if (!ptr_is_undef && start_scalar > rel_end) {
             ir_add_error(ira, &instruction->base, buf_sprintf("out of bounds slice"));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
 
         uint64_t end_scalar;
@@ -19202,19 +18734,20 @@ static ZigType *ir_analyze_instruction_slice(IrAnalyze *ira, IrInstructionSlice
         if (!ptr_is_undef) {
             if (end_scalar > rel_end) {
                 ir_add_error(ira, &instruction->base, buf_sprintf("out of bounds slice"));
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             }
             if (start_scalar > end_scalar) {
                 ir_add_error(ira, &instruction->base, buf_sprintf("slice start is greater than end"));
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             }
         }
         if (ptr_is_undef && start_scalar != end_scalar) {
             ir_add_error(ira, &instruction->base, buf_sprintf("non-zero length slice of undefined pointer"));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
 
-        ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
+        IrInstruction *result = ir_const(ira, &instruction->base, return_type);
+        ConstExprValue *out_val = &result->value;
         out_val->data.x_struct.fields = create_const_vals(2);
 
         ConstExprValue *ptr_val = &out_val->data.x_struct.fields[slice_ptr_index];
@@ -19259,29 +18792,30 @@ static ZigType *ir_analyze_instruction_slice(IrAnalyze *ira, IrInstructionSlice
         ConstExprValue *len_val = &out_val->data.x_struct.fields[slice_len_index];
         init_const_usize(ira->codegen, len_val, end_scalar - start_scalar);
 
-        return return_type;
+        return result;
     }
 
-    IrInstruction *new_instruction = ir_build_slice_from(&ira->new_irb, &instruction->base, ptr_ptr,
-            casted_start, end, instruction->safety_check_on);
+    IrInstruction *new_instruction = ir_build_slice(&ira->new_irb,
+            instruction->base.scope, instruction->base.source_node,
+            ptr_ptr, casted_start, end, instruction->safety_check_on);
+    new_instruction->value.type = return_type;
     ir_add_alloca(ira, new_instruction, return_type);
-
-    return return_type;
+    return new_instruction;
 }
 
-static ZigType *ir_analyze_instruction_member_count(IrAnalyze *ira, IrInstructionMemberCount *instruction) {
+static IrInstruction *ir_analyze_instruction_member_count(IrAnalyze *ira, IrInstructionMemberCount *instruction) {
     Error err;
-    IrInstruction *container = instruction->container->other;
+    IrInstruction *container = instruction->container->child;
     if (type_is_invalid(container->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     ZigType *container_type = ir_resolve_type(ira, container);
 
     if ((err = ensure_complete_type(ira->codegen, container_type)))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     uint64_t result;
     if (type_is_invalid(container_type)) {
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     } else if (container_type->id == ZigTypeIdEnum) {
         result = container_type->data.enumeration.src_field_count;
     } else if (container_type->id == ZigTypeIdStruct) {
@@ -19290,166 +18824,164 @@ static ZigType *ir_analyze_instruction_member_count(IrAnalyze *ira, IrInstructio
         result = container_type->data.unionation.src_field_count;
     } else if (container_type->id == ZigTypeIdErrorSet) {
         if (!resolve_inferred_error_set(ira->codegen, container_type, instruction->base.source_node)) {
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
         if (type_is_global_error_set(container_type)) {
             ir_add_error(ira, &instruction->base, buf_sprintf("global error set member count not available at comptime"));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
         result = container_type->data.error_set.err_count;
     } else {
         ir_add_error(ira, &instruction->base, buf_sprintf("no value count available for type '%s'", buf_ptr(&container_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
-    ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-    bigint_init_unsigned(&out_val->data.x_bigint, result);
-    return ira->codegen->builtin_types.entry_num_lit_int;
+    return ir_const_unsigned(ira, &instruction->base, result);
 }
 
-static ZigType *ir_analyze_instruction_member_type(IrAnalyze *ira, IrInstructionMemberType *instruction) {
+static IrInstruction *ir_analyze_instruction_member_type(IrAnalyze *ira, IrInstructionMemberType *instruction) {
     Error err;
-    IrInstruction *container_type_value = instruction->container_type->other;
+    IrInstruction *container_type_value = instruction->container_type->child;
     ZigType *container_type = ir_resolve_type(ira, container_type_value);
     if (type_is_invalid(container_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if ((err = ensure_complete_type(ira->codegen, container_type)))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
 
     uint64_t member_index;
-    IrInstruction *index_value = instruction->member_index->other;
+    IrInstruction *index_value = instruction->member_index->child;
     if (!ir_resolve_usize(ira, index_value, &member_index))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (container_type->id == ZigTypeIdStruct) {
         if (member_index >= container_type->data.structure.src_field_count) {
             ir_add_error(ira, index_value,
                 buf_sprintf("member index %" ZIG_PRI_u64 " out of bounds; '%s' has %" PRIu32 " members",
                     member_index, buf_ptr(&container_type->name), container_type->data.structure.src_field_count));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
         TypeStructField *field = &container_type->data.structure.fields[member_index];
 
-        ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-        out_val->data.x_type = field->type_entry;
-        return ira->codegen->builtin_types.entry_type;
+        return ir_const_type(ira, &instruction->base, field->type_entry);
     } else if (container_type->id == ZigTypeIdUnion) {
         if (member_index >= container_type->data.unionation.src_field_count) {
             ir_add_error(ira, index_value,
                 buf_sprintf("member index %" ZIG_PRI_u64 " out of bounds; '%s' has %" PRIu32 " members",
                     member_index, buf_ptr(&container_type->name), container_type->data.unionation.src_field_count));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
         TypeUnionField *field = &container_type->data.unionation.fields[member_index];
 
-        ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-        out_val->data.x_type = field->type_entry;
-        return ira->codegen->builtin_types.entry_type;
+        return ir_const_type(ira, &instruction->base, field->type_entry);
     } else {
         ir_add_error(ira, container_type_value,
             buf_sprintf("type '%s' does not support @memberType", buf_ptr(&container_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 }
 
-static ZigType *ir_analyze_instruction_member_name(IrAnalyze *ira, IrInstructionMemberName *instruction) {
+static IrInstruction *ir_analyze_instruction_member_name(IrAnalyze *ira, IrInstructionMemberName *instruction) {
     Error err;
-    IrInstruction *container_type_value = instruction->container_type->other;
+    IrInstruction *container_type_value = instruction->container_type->child;
     ZigType *container_type = ir_resolve_type(ira, container_type_value);
     if (type_is_invalid(container_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if ((err = ensure_complete_type(ira->codegen, container_type)))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     uint64_t member_index;
-    IrInstruction *index_value = instruction->member_index->other;
+    IrInstruction *index_value = instruction->member_index->child;
     if (!ir_resolve_usize(ira, index_value, &member_index))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (container_type->id == ZigTypeIdStruct) {
         if (member_index >= container_type->data.structure.src_field_count) {
             ir_add_error(ira, index_value,
                 buf_sprintf("member index %" ZIG_PRI_u64 " out of bounds; '%s' has %" PRIu32 " members",
                     member_index, buf_ptr(&container_type->name), container_type->data.structure.src_field_count));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
         TypeStructField *field = &container_type->data.structure.fields[member_index];
 
-        ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-        init_const_str_lit(ira->codegen, out_val, field->name);
-        return out_val->type;
+        IrInstruction *result = ir_const(ira, &instruction->base, nullptr);
+        init_const_str_lit(ira->codegen, &result->value, field->name);
+        return result;
     } else if (container_type->id == ZigTypeIdEnum) {
         if (member_index >= container_type->data.enumeration.src_field_count) {
             ir_add_error(ira, index_value,
                 buf_sprintf("member index %" ZIG_PRI_u64 " out of bounds; '%s' has %" PRIu32 " members",
                     member_index, buf_ptr(&container_type->name), container_type->data.enumeration.src_field_count));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
         TypeEnumField *field = &container_type->data.enumeration.fields[member_index];
 
-        ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-        init_const_str_lit(ira->codegen, out_val, field->name);
-        return out_val->type;
+        IrInstruction *result = ir_const(ira, &instruction->base, nullptr);
+        init_const_str_lit(ira->codegen, &result->value, field->name);
+        return result;
     } else if (container_type->id == ZigTypeIdUnion) {
         if (member_index >= container_type->data.unionation.src_field_count) {
             ir_add_error(ira, index_value,
                 buf_sprintf("member index %" ZIG_PRI_u64 " out of bounds; '%s' has %" PRIu32 " members",
                     member_index, buf_ptr(&container_type->name), container_type->data.unionation.src_field_count));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
         TypeUnionField *field = &container_type->data.unionation.fields[member_index];
 
-        ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-        init_const_str_lit(ira->codegen, out_val, field->name);
-        return out_val->type;
+        IrInstruction *result = ir_const(ira, &instruction->base, nullptr);
+        init_const_str_lit(ira->codegen, &result->value, field->name);
+        return result;
     } else {
         ir_add_error(ira, container_type_value,
             buf_sprintf("type '%s' does not support @memberName", buf_ptr(&container_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 }
 
-static ZigType *ir_analyze_instruction_breakpoint(IrAnalyze *ira, IrInstructionBreakpoint *instruction) {
-    ir_build_breakpoint_from(&ira->new_irb, &instruction->base);
-    return ira->codegen->builtin_types.entry_void;
+static IrInstruction *ir_analyze_instruction_breakpoint(IrAnalyze *ira, IrInstructionBreakpoint *instruction) {
+    IrInstruction *result = ir_build_breakpoint(&ira->new_irb,
+        instruction->base.scope, instruction->base.source_node);
+    result->value.type = ira->codegen->builtin_types.entry_void;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_return_address(IrAnalyze *ira, IrInstructionReturnAddress *instruction) {
-    ir_build_return_address_from(&ira->new_irb, &instruction->base);
-
+static IrInstruction *ir_analyze_instruction_return_address(IrAnalyze *ira, IrInstructionReturnAddress *instruction) {
+    IrInstruction *result = ir_build_return_address(&ira->new_irb,
+        instruction->base.scope, instruction->base.source_node);
     ZigType *u8 = ira->codegen->builtin_types.entry_u8;
     ZigType *u8_ptr_const = get_pointer_to_type(ira->codegen, u8, true);
-    return u8_ptr_const;
+    result->value.type = u8_ptr_const;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_frame_address(IrAnalyze *ira, IrInstructionFrameAddress *instruction) {
-    ir_build_frame_address_from(&ira->new_irb, &instruction->base);
-
+static IrInstruction *ir_analyze_instruction_frame_address(IrAnalyze *ira, IrInstructionFrameAddress *instruction) {
+    IrInstruction *result = ir_build_frame_address(&ira->new_irb,
+            instruction->base.scope, instruction->base.source_node);
     ZigType *u8 = ira->codegen->builtin_types.entry_u8;
     ZigType *u8_ptr_const = get_pointer_to_type(ira->codegen, u8, true);
-    return u8_ptr_const;
+    result->value.type = u8_ptr_const;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_handle(IrAnalyze *ira, IrInstructionHandle *instruction) {
-    ir_build_handle_from(&ira->new_irb, &instruction->base);
-
+static IrInstruction *ir_analyze_instruction_handle(IrAnalyze *ira, IrInstructionHandle *instruction) {
+    IrInstruction *result = ir_build_handle(&ira->new_irb, instruction->base.scope, instruction->base.source_node);
     ZigFn *fn_entry = exec_fn_entry(ira->new_irb.exec);
     assert(fn_entry != nullptr);
-    return get_promise_type(ira->codegen, fn_entry->type_entry->data.fn.fn_type_id.return_type);
+    result->value.type = get_promise_type(ira->codegen, fn_entry->type_entry->data.fn.fn_type_id.return_type);
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_align_of(IrAnalyze *ira, IrInstructionAlignOf *instruction) {
+static IrInstruction *ir_analyze_instruction_align_of(IrAnalyze *ira, IrInstructionAlignOf *instruction) {
     Error err;
-    IrInstruction *type_value = instruction->type_value->other;
+    IrInstruction *type_value = instruction->type_value->child;
     if (type_is_invalid(type_value->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     ZigType *type_entry = ir_resolve_type(ira, type_value);
 
     if ((err = type_resolve(ira->codegen, type_entry, ResolveStatusAlignmentKnown)))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     switch (type_entry->id) {
         case ZigTypeIdInvalid:
@@ -19467,7 +18999,7 @@ static ZigType *ir_analyze_instruction_align_of(IrAnalyze *ira, IrInstructionAli
         case ZigTypeIdOpaque:
             ir_add_error(ira, instruction->type_value,
                     buf_sprintf("no align available for type '%s'", buf_ptr(&type_entry->name)));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         case ZigTypeIdBool:
         case ZigTypeIdInt:
         case ZigTypeIdFloat:
@@ -19483,42 +19015,40 @@ static ZigType *ir_analyze_instruction_align_of(IrAnalyze *ira, IrInstructionAli
         case ZigTypeIdFn:
             {
                 uint64_t align_in_bytes = get_abi_alignment(ira->codegen, type_entry);
-                ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-                bigint_init_unsigned(&out_val->data.x_bigint, align_in_bytes);
-                return ira->codegen->builtin_types.entry_num_lit_int;
+                return ir_const_unsigned(ira, &instruction->base, align_in_bytes);
             }
     }
     zig_unreachable();
 }
 
-static ZigType *ir_analyze_instruction_overflow_op(IrAnalyze *ira, IrInstructionOverflowOp *instruction) {
+static IrInstruction *ir_analyze_instruction_overflow_op(IrAnalyze *ira, IrInstructionOverflowOp *instruction) {
     Error err;
 
-    IrInstruction *type_value = instruction->type_value->other;
+    IrInstruction *type_value = instruction->type_value->child;
     if (type_is_invalid(type_value->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     ZigType *dest_type = ir_resolve_type(ira, type_value);
     if (type_is_invalid(dest_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (dest_type->id != ZigTypeIdInt) {
         ir_add_error(ira, type_value,
             buf_sprintf("expected integer type, found '%s'", buf_ptr(&dest_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
-    IrInstruction *op1 = instruction->op1->other;
+    IrInstruction *op1 = instruction->op1->child;
     if (type_is_invalid(op1->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     IrInstruction *casted_op1 = ir_implicit_cast(ira, op1, dest_type);
     if (type_is_invalid(casted_op1->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *op2 = instruction->op2->other;
+    IrInstruction *op2 = instruction->op2->child;
     if (type_is_invalid(op2->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     IrInstruction *casted_op2;
     if (instruction->op == IrOverflowOpShl) {
@@ -19529,17 +19059,17 @@ static ZigType *ir_analyze_instruction_overflow_op(IrAnalyze *ira, IrInstruction
         casted_op2 = ir_implicit_cast(ira, op2, dest_type);
     }
     if (type_is_invalid(casted_op2->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *result_ptr = instruction->result_ptr->other;
+    IrInstruction *result_ptr = instruction->result_ptr->child;
     if (type_is_invalid(result_ptr->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     ZigType *expected_ptr_type;
     if (result_ptr->value.type->id == ZigTypeIdPointer) {
         uint32_t alignment;
         if ((err = resolve_ptr_align(ira, result_ptr->value.type, &alignment)))
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         expected_ptr_type = get_pointer_to_type_extra(ira->codegen, dest_type,
                 false, result_ptr->value.type->data.pointer.is_volatile,
                 PtrLenSingle,
@@ -19550,18 +19080,17 @@ static ZigType *ir_analyze_instruction_overflow_op(IrAnalyze *ira, IrInstruction
 
     IrInstruction *casted_result_ptr = ir_implicit_cast(ira, result_ptr, expected_ptr_type);
     if (type_is_invalid(casted_result_ptr->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (casted_op1->value.special == ConstValSpecialStatic &&
         casted_op2->value.special == ConstValSpecialStatic &&
         casted_result_ptr->value.special == ConstValSpecialStatic)
     {
-        ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
         BigInt *op1_bigint = &casted_op1->value.data.x_bigint;
         BigInt *op2_bigint = &casted_op2->value.data.x_bigint;
         ConstExprValue *pointee_val = ir_const_ptr_pointee(ira, &casted_result_ptr->value, casted_result_ptr->source_node);
         if (pointee_val == nullptr)
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         BigInt *dest_bigint = &pointee_val->data.x_bigint;
         switch (instruction->op) {
             case IrOverflowOpAdd:
@@ -19577,77 +19106,74 @@ static ZigType *ir_analyze_instruction_overflow_op(IrAnalyze *ira, IrInstruction
                 bigint_shl(dest_bigint, op1_bigint, op2_bigint);
                 break;
         }
+        bool result_bool = false;
         if (!bigint_fits_in_bits(dest_bigint, dest_type->data.integral.bit_count,
             dest_type->data.integral.is_signed))
         {
-            out_val->data.x_bool = true;
+            result_bool = true;
             BigInt tmp_bigint;
             bigint_init_bigint(&tmp_bigint, dest_bigint);
             bigint_truncate(dest_bigint, &tmp_bigint, dest_type->data.integral.bit_count,
                     dest_type->data.integral.is_signed);
         }
         pointee_val->special = ConstValSpecialStatic;
-        return ira->codegen->builtin_types.entry_bool;
+        return ir_const_bool(ira, &instruction->base, result_bool);
     }
 
-    ir_build_overflow_op_from(&ira->new_irb, &instruction->base, instruction->op, type_value,
-        casted_op1, casted_op2, casted_result_ptr, dest_type);
-    return ira->codegen->builtin_types.entry_bool;
+    IrInstruction *result = ir_build_overflow_op(&ira->new_irb,
+            instruction->base.scope, instruction->base.source_node,
+            instruction->op, type_value, casted_op1, casted_op2, casted_result_ptr, dest_type);
+    result->value.type = ira->codegen->builtin_types.entry_bool;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_test_err(IrAnalyze *ira, IrInstructionTestErr *instruction) {
-    IrInstruction *value = instruction->value->other;
+static IrInstruction *ir_analyze_instruction_test_err(IrAnalyze *ira, IrInstructionTestErr *instruction) {
+    IrInstruction *value = instruction->value->child;
     if (type_is_invalid(value->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     ZigType *type_entry = value->value.type;
     if (type_is_invalid(type_entry)) {
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     } else if (type_entry->id == ZigTypeIdErrorUnion) {
         if (instr_is_comptime(value)) {
             ConstExprValue *err_union_val = ir_resolve_const(ira, value, UndefBad);
             if (!err_union_val)
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
 
             if (err_union_val->special != ConstValSpecialRuntime) {
-                ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-                out_val->data.x_bool = (err_union_val->data.x_err_union.err != nullptr);
-                return ira->codegen->builtin_types.entry_bool;
+                return ir_const_bool(ira, &instruction->base, (err_union_val->data.x_err_union.err != nullptr));
             }
         }
 
         ZigType *err_set_type = type_entry->data.error_union.err_set_type;
         if (!resolve_inferred_error_set(ira->codegen, err_set_type, instruction->base.source_node)) {
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
         if (!type_is_global_error_set(err_set_type) &&
             err_set_type->data.error_set.err_count == 0)
         {
             assert(err_set_type->data.error_set.infer_fn == nullptr);
-            ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-            out_val->data.x_bool = false;
-            return ira->codegen->builtin_types.entry_bool;
+            return ir_const_bool(ira, &instruction->base, false);
         }
 
-        ir_build_test_err_from(&ira->new_irb, &instruction->base, value);
-        return ira->codegen->builtin_types.entry_bool;
+        IrInstruction *result = ir_build_test_err(&ira->new_irb,
+            instruction->base.scope, instruction->base.source_node, value);
+        result->value.type = ira->codegen->builtin_types.entry_bool;
+        return result;
     } else if (type_entry->id == ZigTypeIdErrorSet) {
-        ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-        out_val->data.x_bool = true;
-        return ira->codegen->builtin_types.entry_bool;
+        return ir_const_bool(ira, &instruction->base, true);
     } else {
-        ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-        out_val->data.x_bool = false;
-        return ira->codegen->builtin_types.entry_bool;
+        return ir_const_bool(ira, &instruction->base, false);
     }
 }
 
-static ZigType *ir_analyze_instruction_unwrap_err_code(IrAnalyze *ira,
+static IrInstruction *ir_analyze_instruction_unwrap_err_code(IrAnalyze *ira,
     IrInstructionUnwrapErrCode *instruction)
 {
-    IrInstruction *value = instruction->value->other;
+    IrInstruction *value = instruction->value->child;
     if (type_is_invalid(value->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     ZigType *ptr_type = value->value.type;
 
     // This will be a pointer type because unwrap err payload IR instruction operates on a pointer to a thing.
@@ -19655,41 +19181,44 @@ static ZigType *ir_analyze_instruction_unwrap_err_code(IrAnalyze *ira,
 
     ZigType *type_entry = ptr_type->data.pointer.child_type;
     if (type_is_invalid(type_entry)) {
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     } else if (type_entry->id == ZigTypeIdErrorUnion) {
         if (instr_is_comptime(value)) {
             ConstExprValue *ptr_val = ir_resolve_const(ira, value, UndefBad);
             if (!ptr_val)
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             ConstExprValue *err_union_val = ir_const_ptr_pointee(ira, ptr_val, instruction->base.source_node);
             if (err_union_val == nullptr)
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             if (err_union_val->special != ConstValSpecialRuntime) {
                 ErrorTableEntry *err = err_union_val->data.x_err_union.err;
                 assert(err);
 
-                ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-                out_val->data.x_err_set = err;
-                return type_entry->data.error_union.err_set_type;
+                IrInstruction *result = ir_const(ira, &instruction->base,
+                        type_entry->data.error_union.err_set_type);
+                result->value.data.x_err_set = err;
+                return result;
             }
         }
 
-        ir_build_unwrap_err_code_from(&ira->new_irb, &instruction->base, value);
-        return type_entry->data.error_union.err_set_type;
+        IrInstruction *result = ir_build_unwrap_err_code(&ira->new_irb,
+            instruction->base.scope, instruction->base.source_node, value);
+        result->value.type = type_entry->data.error_union.err_set_type;
+        return result;
     } else {
         ir_add_error(ira, value,
             buf_sprintf("expected error union type, found '%s'", buf_ptr(&type_entry->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 }
 
-static ZigType *ir_analyze_instruction_unwrap_err_payload(IrAnalyze *ira,
+static IrInstruction *ir_analyze_instruction_unwrap_err_payload(IrAnalyze *ira,
     IrInstructionUnwrapErrPayload *instruction)
 {
-    assert(instruction->value->other);
-    IrInstruction *value = instruction->value->other;
+    assert(instruction->value->child);
+    IrInstruction *value = instruction->value->child;
     if (type_is_invalid(value->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     ZigType *ptr_type = value->value.type;
 
     // This will be a pointer type because unwrap err payload IR instruction operates on a pointer to a thing.
@@ -19697,11 +19226,11 @@ static ZigType *ir_analyze_instruction_unwrap_err_payload(IrAnalyze *ira,
 
     ZigType *type_entry = ptr_type->data.pointer.child_type;
     if (type_is_invalid(type_entry)) {
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     } else if (type_entry->id == ZigTypeIdErrorUnion) {
         ZigType *payload_type = type_entry->data.error_union.payload_type;
         if (type_is_invalid(payload_type)) {
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
         ZigType *result_type = get_pointer_to_type_extra(ira->codegen, payload_type,
                 ptr_type->data.pointer.is_const, ptr_type->data.pointer.is_volatile,
@@ -19709,36 +19238,38 @@ static ZigType *ir_analyze_instruction_unwrap_err_payload(IrAnalyze *ira,
         if (instr_is_comptime(value)) {
             ConstExprValue *ptr_val = ir_resolve_const(ira, value, UndefBad);
             if (!ptr_val)
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             ConstExprValue *err_union_val = ir_const_ptr_pointee(ira, ptr_val, instruction->base.source_node);
             if (err_union_val == nullptr)
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             if (err_union_val->special != ConstValSpecialRuntime) {
                 ErrorTableEntry *err = err_union_val->data.x_err_union.err;
                 if (err != nullptr) {
                     ir_add_error(ira, &instruction->base,
                         buf_sprintf("caught unexpected error '%s'", buf_ptr(&err->name)));
-                    return ira->codegen->builtin_types.entry_invalid;
+                    return ira->codegen->invalid_instruction;
                 }
 
-                ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-                out_val->data.x_ptr.special = ConstPtrSpecialRef;
-                out_val->data.x_ptr.data.ref.pointee = err_union_val->data.x_err_union.payload;
-                return result_type;
+                IrInstruction *result = ir_const(ira, &instruction->base, result_type);
+                result->value.data.x_ptr.special = ConstPtrSpecialRef;
+                result->value.data.x_ptr.data.ref.pointee = err_union_val->data.x_err_union.payload;
+                return result;
             }
         }
 
-        ir_build_unwrap_err_payload_from(&ira->new_irb, &instruction->base, value, instruction->safety_check_on);
-        return result_type;
+        IrInstruction *result = ir_build_unwrap_err_payload(&ira->new_irb,
+            instruction->base.scope, instruction->base.source_node, value, instruction->safety_check_on);
+        result->value.type = result_type;
+        return result;
     } else {
         ir_add_error(ira, value,
             buf_sprintf("expected error union type, found '%s'", buf_ptr(&type_entry->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
 }
 
-static ZigType *ir_analyze_instruction_fn_proto(IrAnalyze *ira, IrInstructionFnProto *instruction) {
+static IrInstruction *ir_analyze_instruction_fn_proto(IrAnalyze *ira, IrInstructionFnProto *instruction) {
     Error err;
     AstNode *proto_node = instruction->base.source_node;
     assert(proto_node->type == NodeTypeFnProto);
@@ -19746,7 +19277,7 @@ static ZigType *ir_analyze_instruction_fn_proto(IrAnalyze *ira, IrInstructionFnP
     if (proto_node->data.fn_proto.auto_err_set) {
         ir_add_error(ira, &instruction->base,
             buf_sprintf("inferring error set of return type valid only for function definitions"));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     FnTypeId fn_type_id = {0};
@@ -19762,9 +19293,7 @@ static ZigType *ir_analyze_instruction_fn_proto(IrAnalyze *ira, IrInstructionFnP
                 fn_type_id.param_count = fn_type_id.next_param_index;
                 continue;
             } else if (fn_type_id.cc == CallingConventionUnspecified) {
-                ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-                out_val->data.x_type = get_generic_fn_type(ira->codegen, &fn_type_id);
-                return ira->codegen->builtin_types.entry_type;
+                return ir_const_type(ira, &instruction->base, get_generic_fn_type(ira->codegen, &fn_type_id));
             } else {
                 zig_unreachable();
             }
@@ -19774,36 +19303,32 @@ static ZigType *ir_analyze_instruction_fn_proto(IrAnalyze *ira, IrInstructionFnP
 
         if (instruction->param_types[fn_type_id.next_param_index] == nullptr) {
             param_info->type = nullptr;
-            ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-            out_val->data.x_type = get_generic_fn_type(ira->codegen, &fn_type_id);
-            return ira->codegen->builtin_types.entry_type;
+            return ir_const_type(ira, &instruction->base, get_generic_fn_type(ira->codegen, &fn_type_id));
         } else {
-            IrInstruction *param_type_value = instruction->param_types[fn_type_id.next_param_index]->other;
+            IrInstruction *param_type_value = instruction->param_types[fn_type_id.next_param_index]->child;
             if (type_is_invalid(param_type_value->value.type))
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             ZigType *param_type = ir_resolve_type(ira, param_type_value);
             if (type_is_invalid(param_type))
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             if ((err = type_resolve(ira->codegen, param_type, ResolveStatusZeroBitsKnown)))
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             if (type_requires_comptime(param_type)) {
                 if (!calling_convention_allows_zig_types(fn_type_id.cc)) {
                     ir_add_error(ira, param_type_value,
                         buf_sprintf("parameter of type '%s' not allowed in function with calling convention '%s'",
                             buf_ptr(&param_type->name), calling_convention_name(fn_type_id.cc)));
-                    return ira->codegen->builtin_types.entry_invalid;
+                    return ira->codegen->invalid_instruction;
                 }
                 param_info->type = param_type;
                 fn_type_id.next_param_index += 1;
-                ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-                out_val->data.x_type = get_generic_fn_type(ira->codegen, &fn_type_id);
-                return ira->codegen->builtin_types.entry_type;
+                return ir_const_type(ira, &instruction->base, get_generic_fn_type(ira->codegen, &fn_type_id));
             }
             if (!type_has_bits(param_type) && !calling_convention_allows_zig_types(fn_type_id.cc)) {
                 ir_add_error(ira, param_type_value,
                     buf_sprintf("parameter of type '%s' has 0 bits; not allowed in function with calling convention '%s'",
                         buf_ptr(&param_type->name), calling_convention_name(fn_type_id.cc)));
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             }
             param_info->type = param_type;
         }
@@ -19811,54 +19336,50 @@ static ZigType *ir_analyze_instruction_fn_proto(IrAnalyze *ira, IrInstructionFnP
     }
 
     if (instruction->align_value != nullptr) {
-        if (!ir_resolve_align(ira, instruction->align_value->other, &fn_type_id.alignment))
-            return ira->codegen->builtin_types.entry_invalid;
+        if (!ir_resolve_align(ira, instruction->align_value->child, &fn_type_id.alignment))
+            return ira->codegen->invalid_instruction;
     }
 
-    IrInstruction *return_type_value = instruction->return_type->other;
+    IrInstruction *return_type_value = instruction->return_type->child;
     fn_type_id.return_type = ir_resolve_type(ira, return_type_value);
     if (type_is_invalid(fn_type_id.return_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     if (fn_type_id.return_type->id == ZigTypeIdOpaque) {
         ir_add_error(ira, instruction->return_type,
             buf_sprintf("return type cannot be opaque"));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     if (fn_type_id.cc == CallingConventionAsync) {
         if (instruction->async_allocator_type_value == nullptr) {
             ir_add_error(ira, &instruction->base,
                 buf_sprintf("async fn proto missing allocator type"));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
-        IrInstruction *async_allocator_type_value = instruction->async_allocator_type_value->other;
+        IrInstruction *async_allocator_type_value = instruction->async_allocator_type_value->child;
         fn_type_id.async_allocator_type = ir_resolve_type(ira, async_allocator_type_value);
         if (type_is_invalid(fn_type_id.async_allocator_type))
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
     }
 
-    ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-    out_val->data.x_type = get_fn_type(ira->codegen, &fn_type_id);
-    return ira->codegen->builtin_types.entry_type;
+    return ir_const_type(ira, &instruction->base, get_fn_type(ira->codegen, &fn_type_id));
 }
 
-static ZigType *ir_analyze_instruction_test_comptime(IrAnalyze *ira, IrInstructionTestComptime *instruction) {
-    IrInstruction *value = instruction->value->other;
+static IrInstruction *ir_analyze_instruction_test_comptime(IrAnalyze *ira, IrInstructionTestComptime *instruction) {
+    IrInstruction *value = instruction->value->child;
     if (type_is_invalid(value->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-    out_val->data.x_bool = instr_is_comptime(value);
-    return ira->codegen->builtin_types.entry_bool;
+    return ir_const_bool(ira, &instruction->base, instr_is_comptime(value));
 }
 
-static ZigType *ir_analyze_instruction_check_switch_prongs(IrAnalyze *ira,
+static IrInstruction *ir_analyze_instruction_check_switch_prongs(IrAnalyze *ira,
         IrInstructionCheckSwitchProngs *instruction)
 {
-    IrInstruction *target_value = instruction->target_value->other;
+    IrInstruction *target_value = instruction->target_value->child;
     ZigType *switch_type = target_value->value.type;
     if (type_is_invalid(switch_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (switch_type->id == ZigTypeIdEnum) {
         HashMap<BigInt, AstNode *, bigint_hash, bigint_eql> field_prev_uses = {};
@@ -19867,17 +19388,17 @@ static ZigType *ir_analyze_instruction_check_switch_prongs(IrAnalyze *ira,
         for (size_t range_i = 0; range_i < instruction->range_count; range_i += 1) {
             IrInstructionCheckSwitchProngsRange *range = &instruction->ranges[range_i];
 
-            IrInstruction *start_value = range->start->other;
+            IrInstruction *start_value = range->start->child;
             if (type_is_invalid(start_value->value.type))
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
 
-            IrInstruction *end_value = range->end->other;
+            IrInstruction *end_value = range->end->child;
             if (type_is_invalid(end_value->value.type))
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
 
             if (start_value->value.type->id != ZigTypeIdEnum) {
                 ir_add_error(ira, range->start, buf_sprintf("not an enum type"));
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             }
 
             BigInt start_index;
@@ -19921,7 +19442,7 @@ static ZigType *ir_analyze_instruction_check_switch_prongs(IrAnalyze *ira,
         }
     } else if (switch_type->id == ZigTypeIdErrorSet) {
         if (!resolve_inferred_error_set(ira->codegen, switch_type, target_value->source_node)) {
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
 
         AstNode **field_prev_uses = allocate<AstNode *>(ira->codegen->errors_by_index.length);
@@ -19929,13 +19450,13 @@ static ZigType *ir_analyze_instruction_check_switch_prongs(IrAnalyze *ira,
         for (size_t range_i = 0; range_i < instruction->range_count; range_i += 1) {
             IrInstructionCheckSwitchProngsRange *range = &instruction->ranges[range_i];
 
-            IrInstruction *start_value = range->start->other;
+            IrInstruction *start_value = range->start->child;
             if (type_is_invalid(start_value->value.type))
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
 
-            IrInstruction *end_value = range->end->other;
+            IrInstruction *end_value = range->end->child;
             if (type_is_invalid(end_value->value.type))
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
 
             assert(start_value->value.type->id == ZigTypeIdErrorSet);
             uint32_t start_index = start_value->value.data.x_err_set->value;
@@ -19945,7 +19466,7 @@ static ZigType *ir_analyze_instruction_check_switch_prongs(IrAnalyze *ira,
 
             if (start_index != end_index) {
                 ir_add_error(ira, end_value, buf_sprintf("ranges not allowed when switching on errors"));
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             }
 
             AstNode *prev_node = field_prev_uses[start_index];
@@ -19961,7 +19482,7 @@ static ZigType *ir_analyze_instruction_check_switch_prongs(IrAnalyze *ira,
             if (type_is_global_error_set(switch_type)) {
                 ir_add_error(ira, &instruction->base,
                     buf_sprintf("else prong required when switching on type 'error'"));
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             } else {
                 for (uint32_t i = 0; i < switch_type->data.error_set.err_count; i += 1) {
                     ErrorTableEntry *err_entry = switch_type->data.error_set.errors[i];
@@ -19981,27 +19502,27 @@ static ZigType *ir_analyze_instruction_check_switch_prongs(IrAnalyze *ira,
         for (size_t range_i = 0; range_i < instruction->range_count; range_i += 1) {
             IrInstructionCheckSwitchProngsRange *range = &instruction->ranges[range_i];
 
-            IrInstruction *start_value = range->start->other;
+            IrInstruction *start_value = range->start->child;
             if (type_is_invalid(start_value->value.type))
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             IrInstruction *casted_start_value = ir_implicit_cast(ira, start_value, switch_type);
             if (type_is_invalid(casted_start_value->value.type))
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
 
-            IrInstruction *end_value = range->end->other;
+            IrInstruction *end_value = range->end->child;
             if (type_is_invalid(end_value->value.type))
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             IrInstruction *casted_end_value = ir_implicit_cast(ira, end_value, switch_type);
             if (type_is_invalid(casted_end_value->value.type))
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
 
             ConstExprValue *start_val = ir_resolve_const(ira, casted_start_value, UndefBad);
             if (!start_val)
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
 
             ConstExprValue *end_val = ir_resolve_const(ira, casted_end_value, UndefBad);
             if (!end_val)
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
 
             assert(start_val->type->id == ZigTypeIdInt || start_val->type->id == ZigTypeIdComptimeInt);
             assert(end_val->type->id == ZigTypeIdInt || end_val->type->id == ZigTypeIdComptimeInt);
@@ -20010,7 +19531,7 @@ static ZigType *ir_analyze_instruction_check_switch_prongs(IrAnalyze *ira,
             if (prev_node != nullptr) {
                 ErrorMsg *msg = ir_add_error(ira, start_value, buf_sprintf("duplicate switch value"));
                 add_error_note(ira->codegen, msg, prev_node, buf_sprintf("previous value is here"));
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             }
         }
         if (!instruction->have_else_prong) {
@@ -20020,36 +19541,34 @@ static ZigType *ir_analyze_instruction_check_switch_prongs(IrAnalyze *ira,
             eval_min_max_value_int(ira->codegen, switch_type, &max_val, true);
             if (!rangeset_spans(&rs, &min_val, &max_val)) {
                 ir_add_error(ira, &instruction->base, buf_sprintf("switch must handle all possibilities"));
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
             }
         }
     } else if (!instruction->have_else_prong) {
         ir_add_error(ira, &instruction->base,
             buf_sprintf("else prong required when switching on type '%s'", buf_ptr(&switch_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
-    ir_build_const_from(ira, &instruction->base);
-    return ira->codegen->builtin_types.entry_void;
+    return ir_const_void(ira, &instruction->base);
 }
 
-static ZigType *ir_analyze_instruction_check_statement_is_void(IrAnalyze *ira,
+static IrInstruction *ir_analyze_instruction_check_statement_is_void(IrAnalyze *ira,
         IrInstructionCheckStatementIsVoid *instruction)
 {
-    IrInstruction *statement_value = instruction->statement_value->other;
+    IrInstruction *statement_value = instruction->statement_value->child;
     ZigType *statement_type = statement_value->value.type;
     if (type_is_invalid(statement_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (statement_type->id != ZigTypeIdVoid) {
         ir_add_error(ira, &instruction->base, buf_sprintf("expression value is ignored"));
     }
 
-    ir_build_const_from(ira, &instruction->base);
-    return ira->codegen->builtin_types.entry_void;
+    return ir_const_void(ira, &instruction->base);
 }
 
-static ZigType *ir_analyze_instruction_panic(IrAnalyze *ira, IrInstructionPanic *instruction) {
-    IrInstruction *msg = instruction->msg->other;
+static IrInstruction *ir_analyze_instruction_panic(IrAnalyze *ira, IrInstructionPanic *instruction) {
+    IrInstruction *msg = instruction->msg->child;
     if (type_is_invalid(msg->value.type))
         return ir_unreach_error(ira);
 
@@ -20067,8 +19586,7 @@ static ZigType *ir_analyze_instruction_panic(IrAnalyze *ira, IrInstructionPanic
 
     IrInstruction *new_instruction = ir_build_panic(&ira->new_irb, instruction->base.scope,
             instruction->base.source_node, casted_msg);
-    ir_link_new_instruction(new_instruction, &instruction->base);
-    return ir_finish_anal(ira, ira->codegen->builtin_types.entry_unreachable);
+    return ir_finish_anal(ira, new_instruction);
 }
 
 static IrInstruction *ir_align_cast(IrAnalyze *ira, IrInstruction *target, uint32_t align_bytes, bool safety_check_on) {
@@ -20148,79 +19666,75 @@ static IrInstruction *ir_align_cast(IrAnalyze *ira, IrInstruction *target, uint3
     return result;
 }
 
-static ZigType *ir_analyze_instruction_ptr_cast(IrAnalyze *ira, IrInstructionPtrCast *instruction) {
+static IrInstruction *ir_analyze_ptr_cast(IrAnalyze *ira, IrInstruction *source_instr, IrInstruction *ptr,
+        ZigType *dest_type, IrInstruction *dest_type_src)
+{
     Error err;
 
-    IrInstruction *dest_type_value = instruction->dest_type->other;
-    ZigType *dest_type = ir_resolve_type(ira, dest_type_value);
-    if (type_is_invalid(dest_type))
-        return ira->codegen->builtin_types.entry_invalid;
-
-    IrInstruction *ptr = instruction->ptr->other;
     ZigType *src_type = ptr->value.type;
-    if (type_is_invalid(src_type))
-        return ira->codegen->builtin_types.entry_invalid;
+    assert(!type_is_invalid(src_type));
 
     // We have a check for zero bits later so we use get_src_ptr_type to
     // validate src_type and dest_type.
 
     if (get_src_ptr_type(src_type) == nullptr) {
         ir_add_error(ira, ptr, buf_sprintf("expected pointer, found '%s'", buf_ptr(&src_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     if (get_src_ptr_type(dest_type) == nullptr) {
-        ir_add_error(ira, dest_type_value,
+        ir_add_error(ira, dest_type_src,
                 buf_sprintf("expected pointer, found '%s'", buf_ptr(&dest_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     if (get_ptr_const(src_type) && !get_ptr_const(dest_type)) {
-        ir_add_error(ira, &instruction->base, buf_sprintf("cast discards const qualifier"));
-        return ira->codegen->builtin_types.entry_invalid;
+        ir_add_error(ira, source_instr, buf_sprintf("cast discards const qualifier"));
+        return ira->codegen->invalid_instruction;
     }
 
     if (instr_is_comptime(ptr)) {
         ConstExprValue *val = ir_resolve_const(ira, ptr, UndefOk);
         if (!val)
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
 
-        ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-        copy_const_val(out_val, val, false);
-        out_val->type = dest_type;
-        return dest_type;
+        IrInstruction *result = ir_create_const(&ira->new_irb, source_instr->scope, source_instr->source_node,
+                dest_type);
+        copy_const_val(&result->value, val, false);
+        result->value.type = dest_type;
+        return result;
     }
 
     uint32_t src_align_bytes;
     if ((err = resolve_ptr_align(ira, src_type, &src_align_bytes)))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     uint32_t dest_align_bytes;
     if ((err = resolve_ptr_align(ira, dest_type, &dest_align_bytes)))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (dest_align_bytes > src_align_bytes) {
-        ErrorMsg *msg = ir_add_error(ira, &instruction->base, buf_sprintf("cast increases pointer alignment"));
+        ErrorMsg *msg = ir_add_error(ira, source_instr, buf_sprintf("cast increases pointer alignment"));
         add_error_note(ira->codegen, msg, ptr->source_node,
                 buf_sprintf("'%s' has alignment %" PRIu32, buf_ptr(&src_type->name), src_align_bytes));
-        add_error_note(ira->codegen, msg, dest_type_value->source_node,
+        add_error_note(ira->codegen, msg, dest_type_src->source_node,
                 buf_sprintf("'%s' has alignment %" PRIu32, buf_ptr(&dest_type->name), dest_align_bytes));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
-    IrInstruction *casted_ptr = ir_build_ptr_cast(&ira->new_irb, instruction->base.scope,
-            instruction->base.source_node, nullptr, ptr);
+    IrInstruction *casted_ptr = ir_build_ptr_cast(&ira->new_irb, source_instr->scope,
+            source_instr->source_node, nullptr, ptr);
     casted_ptr->value.type = dest_type;
 
     if (type_has_bits(dest_type) && !type_has_bits(src_type)) {
-        ErrorMsg *msg = ir_add_error(ira, &instruction->base,
+        ErrorMsg *msg = ir_add_error(ira, source_instr,
             buf_sprintf("'%s' and '%s' do not have the same in-memory representation",
                 buf_ptr(&src_type->name), buf_ptr(&dest_type->name)));
         add_error_note(ira->codegen, msg, ptr->source_node,
                 buf_sprintf("'%s' has no in-memory bits", buf_ptr(&src_type->name)));
-        add_error_note(ira->codegen, msg, dest_type_value->source_node,
+        add_error_note(ira->codegen, msg, dest_type_src->source_node,
                 buf_sprintf("'%s' has in-memory bits", buf_ptr(&dest_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     // Keep the bigger alignment, it can only help-
@@ -20229,12 +19743,25 @@ static ZigType *ir_analyze_instruction_ptr_cast(IrAnalyze *ira, IrInstructionPtr
     if (src_align_bytes > dest_align_bytes && type_has_bits(dest_type)) {
         result = ir_align_cast(ira, casted_ptr, src_align_bytes, false);
         if (type_is_invalid(result->value.type))
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
     } else {
         result = casted_ptr;
     }
-    ir_link_new_instruction(result, &instruction->base);
-    return result->value.type;
+    return result;
+}
+
+static IrInstruction *ir_analyze_instruction_ptr_cast(IrAnalyze *ira, IrInstructionPtrCast *instruction) {
+    IrInstruction *dest_type_value = instruction->dest_type->child;
+    ZigType *dest_type = ir_resolve_type(ira, dest_type_value);
+    if (type_is_invalid(dest_type))
+        return ira->codegen->invalid_instruction;
+
+    IrInstruction *ptr = instruction->ptr->child;
+    ZigType *src_type = ptr->value.type;
+    if (type_is_invalid(src_type))
+        return ira->codegen->invalid_instruction;
+
+    return ir_analyze_ptr_cast(ira, &instruction->base, ptr, dest_type, dest_type_value);
 }
 
 static void buf_write_value_bytes(CodeGen *codegen, uint8_t *buf, ConstExprValue *val) {
@@ -20282,9 +19809,10 @@ static void buf_write_value_bytes(CodeGen *codegen, uint8_t *buf, ConstExprValue
         case ZigTypeIdArray:
             {
                 size_t buf_i = 0;
+                // TODO optimize the buf case
                 expand_undef_array(codegen, val);
                 for (size_t elem_i = 0; elem_i < val->type->data.array.len; elem_i += 1) {
-                    ConstExprValue *elem = &val->data.x_array.s_none.elements[elem_i];
+                    ConstExprValue *elem = &val->data.x_array.data.s_none.elements[elem_i];
                     buf_write_value_bytes(codegen, &buf[buf_i], elem);
                     buf_i += type_size(codegen, elem->type);
                 }
@@ -20363,28 +19891,28 @@ static void buf_read_value_bytes(CodeGen *codegen, uint8_t *buf, ConstExprValue
     zig_unreachable();
 }
 
-static ZigType *ir_analyze_instruction_bit_cast(IrAnalyze *ira, IrInstructionBitCast *instruction) {
+static IrInstruction *ir_analyze_instruction_bit_cast(IrAnalyze *ira, IrInstructionBitCast *instruction) {
     Error err;
-    IrInstruction *dest_type_value = instruction->dest_type->other;
+    IrInstruction *dest_type_value = instruction->dest_type->child;
     ZigType *dest_type = ir_resolve_type(ira, dest_type_value);
     if (type_is_invalid(dest_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *value = instruction->value->other;
+    IrInstruction *value = instruction->value->child;
     ZigType *src_type = value->value.type;
     if (type_is_invalid(src_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if ((err = ensure_complete_type(ira->codegen, dest_type)))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if ((err = ensure_complete_type(ira->codegen, src_type)))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (get_codegen_ptr_type(src_type) != nullptr) {
         ir_add_error(ira, value,
             buf_sprintf("unable to @bitCast from pointer type '%s'", buf_ptr(&src_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     switch (src_type->id) {
@@ -20401,7 +19929,7 @@ static ZigType *ir_analyze_instruction_bit_cast(IrAnalyze *ira, IrInstructionBit
         case ZigTypeIdNull:
             ir_add_error(ira, dest_type_value,
                     buf_sprintf("unable to @bitCast from type '%s'", buf_ptr(&src_type->name)));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         default:
             break;
     }
@@ -20409,7 +19937,7 @@ static ZigType *ir_analyze_instruction_bit_cast(IrAnalyze *ira, IrInstructionBit
     if (get_codegen_ptr_type(dest_type) != nullptr) {
         ir_add_error(ira, dest_type_value,
                 buf_sprintf("unable to @bitCast to pointer type '%s'", buf_ptr(&dest_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     switch (dest_type->id) {
@@ -20426,7 +19954,7 @@ static ZigType *ir_analyze_instruction_bit_cast(IrAnalyze *ira, IrInstructionBit
         case ZigTypeIdNull:
             ir_add_error(ira, dest_type_value,
                     buf_sprintf("unable to @bitCast to type '%s'", buf_ptr(&dest_type->name)));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         default:
             break;
     }
@@ -20438,76 +19966,74 @@ static ZigType *ir_analyze_instruction_bit_cast(IrAnalyze *ira, IrInstructionBit
             buf_sprintf("destination type '%s' has size %" ZIG_PRI_u64 " but source type '%s' has size %" ZIG_PRI_u64,
                 buf_ptr(&dest_type->name), dest_size_bytes,
                 buf_ptr(&src_type->name), src_size_bytes));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     if (instr_is_comptime(value)) {
         ConstExprValue *val = ir_resolve_const(ira, value, UndefBad);
         if (!val)
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
 
-        ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-        out_val->type = dest_type;
+        IrInstruction *result = ir_const(ira, &instruction->base, dest_type);
         uint8_t *buf = allocate_nonzero<uint8_t>(src_size_bytes);
         buf_write_value_bytes(ira->codegen, buf, val);
-        buf_read_value_bytes(ira->codegen, buf, out_val);
-        return dest_type;
+        buf_read_value_bytes(ira->codegen, buf, &result->value);
+        return result;
     }
 
     IrInstruction *result = ir_build_bit_cast(&ira->new_irb, instruction->base.scope,
             instruction->base.source_node, nullptr, value);
-    ir_link_new_instruction(result, &instruction->base);
     result->value.type = dest_type;
-    return dest_type;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_int_to_ptr(IrAnalyze *ira, IrInstructionIntToPtr *instruction) {
+static IrInstruction *ir_analyze_instruction_int_to_ptr(IrAnalyze *ira, IrInstructionIntToPtr *instruction) {
     Error err;
-    IrInstruction *dest_type_value = instruction->dest_type->other;
+    IrInstruction *dest_type_value = instruction->dest_type->child;
     ZigType *dest_type = ir_resolve_type(ira, dest_type_value);
     if (type_is_invalid(dest_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     // We explicitly check for the size, so we can use get_src_ptr_type
     if (get_src_ptr_type(dest_type) == nullptr) {
         ir_add_error(ira, dest_type_value, buf_sprintf("expected pointer, found '%s'", buf_ptr(&dest_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     if ((err = type_resolve(ira->codegen, dest_type, ResolveStatusZeroBitsKnown)))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     if (!type_has_bits(dest_type)) {
         ir_add_error(ira, dest_type_value,
                 buf_sprintf("type '%s' has 0 bits and cannot store information", buf_ptr(&dest_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
-    IrInstruction *target = instruction->target->other;
+    IrInstruction *target = instruction->target->child;
     if (type_is_invalid(target->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     IrInstruction *casted_int = ir_implicit_cast(ira, target, ira->codegen->builtin_types.entry_usize);
     if (type_is_invalid(casted_int->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (instr_is_comptime(casted_int)) {
         ConstExprValue *val = ir_resolve_const(ira, casted_int, UndefBad);
         if (!val)
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
 
-        ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-        out_val->data.x_ptr.special = ConstPtrSpecialHardCodedAddr;
-        out_val->data.x_ptr.data.hard_coded_addr.addr = bigint_as_unsigned(&val->data.x_bigint);
-        return dest_type;
+        IrInstruction *result = ir_const(ira, &instruction->base, dest_type);
+        result->value.data.x_ptr.special = ConstPtrSpecialHardCodedAddr;
+        result->value.data.x_ptr.data.hard_coded_addr.addr = bigint_as_unsigned(&val->data.x_bigint);
+        return result;
     }
 
     IrInstruction *result = ir_build_int_to_ptr(&ira->new_irb, instruction->base.scope,
             instruction->base.source_node, nullptr, casted_int);
-    ir_link_new_instruction(result, &instruction->base);
-    return dest_type;
+    result->value.type = dest_type;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_decl_ref(IrAnalyze *ira,
+static IrInstruction *ir_analyze_instruction_decl_ref(IrAnalyze *ira,
         IrInstructionDeclRef *instruction)
 {
     Tld *tld = instruction->tld;
@@ -20515,7 +20041,7 @@ static ZigType *ir_analyze_instruction_decl_ref(IrAnalyze *ira,
 
     resolve_top_level_decl(ira->codegen, tld, lval == LValPtr, instruction->base.source_node);
     if (tld->resolution == TldResolutionInvalid)
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     switch (tld->id) {
         case TldIdContainer:
@@ -20528,19 +20054,16 @@ static ZigType *ir_analyze_instruction_decl_ref(IrAnalyze *ira,
 
             IrInstruction *var_ptr = ir_get_var_ptr(ira, &instruction->base, var);
             if (type_is_invalid(var_ptr->value.type))
-                return ira->codegen->builtin_types.entry_invalid;
+                return ira->codegen->invalid_instruction;
 
             if (tld_var->extern_lib_name != nullptr) {
                 add_link_lib_symbol(ira, tld_var->extern_lib_name, &var->name, instruction->base.source_node);
             }
 
             if (lval == LValPtr) {
-                ir_link_new_instruction(var_ptr, &instruction->base);
-                return var_ptr->value.type;
+                return var_ptr;
             } else {
-                IrInstruction *loaded_instr = ir_get_deref(ira, &instruction->base, var_ptr);
-                ir_link_new_instruction(loaded_instr, &instruction->base);
-                return loaded_instr->value.type;
+                return ir_get_deref(ira, &instruction->base, var_ptr);
             }
         }
         case TldIdFn:
@@ -20556,22 +20079,19 @@ static ZigType *ir_analyze_instruction_decl_ref(IrAnalyze *ira,
             IrInstruction *ref_instruction = ir_create_const_fn(&ira->new_irb, instruction->base.scope,
                     instruction->base.source_node, fn_entry);
             if (lval == LValPtr) {
-                IrInstruction *ptr_instr = ir_get_ref(ira, &instruction->base, ref_instruction, true, false);
-                ir_link_new_instruction(ptr_instr, &instruction->base);
-                return ptr_instr->value.type;
+                return ir_get_ref(ira, &instruction->base, ref_instruction, true, false);
             } else {
-                ir_link_new_instruction(ref_instruction, &instruction->base);
-                return ref_instruction->value.type;
+                return ref_instruction;
             }
         }
     }
     zig_unreachable();
 }
 
-static ZigType *ir_analyze_instruction_ptr_to_int(IrAnalyze *ira, IrInstructionPtrToInt *instruction) {
-    IrInstruction *target = instruction->target->other;
+static IrInstruction *ir_analyze_instruction_ptr_to_int(IrAnalyze *ira, IrInstructionPtrToInt *instruction) {
+    IrInstruction *target = instruction->target->child;
     if (type_is_invalid(target->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     ZigType *usize = ira->codegen->builtin_types.entry_usize;
 
@@ -20579,151 +20099,144 @@ static ZigType *ir_analyze_instruction_ptr_to_int(IrAnalyze *ira, IrInstructionP
     if (get_src_ptr_type(target->value.type) == nullptr) {
         ir_add_error(ira, target,
                 buf_sprintf("expected pointer, found '%s'", buf_ptr(&target->value.type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     if (!type_has_bits(target->value.type)) {
         ir_add_error(ira, target,
                 buf_sprintf("pointer to size 0 type has no address"));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     if (instr_is_comptime(target)) {
         ConstExprValue *val = ir_resolve_const(ira, target, UndefBad);
         if (!val)
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         if (val->type->id == ZigTypeIdPointer && val->data.x_ptr.special == ConstPtrSpecialHardCodedAddr) {
             IrInstruction *result = ir_create_const(&ira->new_irb, instruction->base.scope,
                     instruction->base.source_node, usize);
             bigint_init_unsigned(&result->value.data.x_bigint, val->data.x_ptr.data.hard_coded_addr.addr);
-            ir_link_new_instruction(result, &instruction->base);
-            return usize;
+            result->value.type = usize;
+            return result;
         }
     }
 
     IrInstruction *result = ir_build_ptr_to_int(&ira->new_irb, instruction->base.scope,
             instruction->base.source_node, target);
     result->value.type = usize;
-    ir_link_new_instruction(result, &instruction->base);
-    return usize;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_ptr_type(IrAnalyze *ira, IrInstructionPtrType *instruction) {
+static IrInstruction *ir_analyze_instruction_ptr_type(IrAnalyze *ira, IrInstructionPtrType *instruction) {
     Error err;
-    ZigType *child_type = ir_resolve_type(ira, instruction->child_type->other);
+    ZigType *child_type = ir_resolve_type(ira, instruction->child_type->child);
     if (type_is_invalid(child_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (child_type->id == ZigTypeIdUnreachable) {
         ir_add_error(ira, &instruction->base, buf_sprintf("pointer to noreturn not allowed"));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     } else if (child_type->id == ZigTypeIdOpaque && instruction->ptr_len == PtrLenUnknown) {
         ir_add_error(ira, &instruction->base, buf_sprintf("unknown-length pointer to opaque"));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     uint32_t align_bytes;
     if (instruction->align_value != nullptr) {
-        if (!ir_resolve_align(ira, instruction->align_value->other, &align_bytes))
-            return ira->codegen->builtin_types.entry_invalid;
+        if (!ir_resolve_align(ira, instruction->align_value->child, &align_bytes))
+            return ira->codegen->invalid_instruction;
         if ((err = type_resolve(ira->codegen, child_type, ResolveStatusAlignmentKnown)))
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
     } else {
         if ((err = type_resolve(ira->codegen, child_type, ResolveStatusZeroBitsKnown)))
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         align_bytes = 0;
     }
 
-
-    ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-    out_val->data.x_type = get_pointer_to_type_extra(ira->codegen, child_type,
+    ZigType *result_type = get_pointer_to_type_extra(ira->codegen, child_type,
             instruction->is_const, instruction->is_volatile,
             instruction->ptr_len, align_bytes,
-            instruction->bit_offset_start, instruction->bit_offset_end - instruction->bit_offset_start);
-
-    return ira->codegen->builtin_types.entry_type;
+            instruction->bit_offset_start, instruction->host_int_bytes);
+    return ir_const_type(ira, &instruction->base, result_type);
 }
 
-static ZigType *ir_analyze_instruction_align_cast(IrAnalyze *ira, IrInstructionAlignCast *instruction) {
+static IrInstruction *ir_analyze_instruction_align_cast(IrAnalyze *ira, IrInstructionAlignCast *instruction) {
     uint32_t align_bytes;
-    IrInstruction *align_bytes_inst = instruction->align_bytes->other;
+    IrInstruction *align_bytes_inst = instruction->align_bytes->child;
     if (!ir_resolve_align(ira, align_bytes_inst, &align_bytes))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *target = instruction->target->other;
+    IrInstruction *target = instruction->target->child;
     if (type_is_invalid(target->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     IrInstruction *result = ir_align_cast(ira, target, align_bytes, true);
     if (type_is_invalid(result->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    ir_link_new_instruction(result, &instruction->base);
-    return result->value.type;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_opaque_type(IrAnalyze *ira, IrInstructionOpaqueType *instruction) {
+static IrInstruction *ir_analyze_instruction_opaque_type(IrAnalyze *ira, IrInstructionOpaqueType *instruction) {
     Buf *name = get_anon_type_name(ira->codegen, ira->new_irb.exec, "opaque", instruction->base.source_node);
-    ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-    out_val->data.x_type = get_opaque_type(ira->codegen, instruction->base.scope, instruction->base.source_node,
+    ZigType *result_type = get_opaque_type(ira->codegen, instruction->base.scope, instruction->base.source_node,
             buf_ptr(name));
-    return ira->codegen->builtin_types.entry_type;
+    return ir_const_type(ira, &instruction->base, result_type);
 }
 
-static ZigType *ir_analyze_instruction_set_align_stack(IrAnalyze *ira, IrInstructionSetAlignStack *instruction) {
+static IrInstruction *ir_analyze_instruction_set_align_stack(IrAnalyze *ira, IrInstructionSetAlignStack *instruction) {
     uint32_t align_bytes;
-    IrInstruction *align_bytes_inst = instruction->align_bytes->other;
+    IrInstruction *align_bytes_inst = instruction->align_bytes->child;
     if (!ir_resolve_align(ira, align_bytes_inst, &align_bytes))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (align_bytes > 256) {
         ir_add_error(ira, &instruction->base, buf_sprintf("attempt to @setAlignStack(%" PRIu32 "); maximum is 256", align_bytes));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     ZigFn *fn_entry = exec_fn_entry(ira->new_irb.exec);
     if (fn_entry == nullptr) {
         ir_add_error(ira, &instruction->base, buf_sprintf("@setAlignStack outside function"));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
     if (fn_entry->type_entry->data.fn.fn_type_id.cc == CallingConventionNaked) {
         ir_add_error(ira, &instruction->base, buf_sprintf("@setAlignStack in naked function"));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     if (fn_entry->fn_inline == FnInlineAlways) {
         ir_add_error(ira, &instruction->base, buf_sprintf("@setAlignStack in inline function"));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     if (fn_entry->set_alignstack_node != nullptr) {
         ErrorMsg *msg = ir_add_error_node(ira, instruction->base.source_node,
             buf_sprintf("alignstack set twice"));
         add_error_note(ira->codegen, msg, fn_entry->set_alignstack_node, buf_sprintf("first set here"));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     fn_entry->set_alignstack_node = instruction->base.source_node;
     fn_entry->alignstack_value = align_bytes;
 
-    ir_build_const_from(ira, &instruction->base);
-    return ira->codegen->builtin_types.entry_void;
+    return ir_const_void(ira, &instruction->base);
 }
 
-static ZigType *ir_analyze_instruction_arg_type(IrAnalyze *ira, IrInstructionArgType *instruction) {
-    IrInstruction *fn_type_inst = instruction->fn_type->other;
+static IrInstruction *ir_analyze_instruction_arg_type(IrAnalyze *ira, IrInstructionArgType *instruction) {
+    IrInstruction *fn_type_inst = instruction->fn_type->child;
     ZigType *fn_type = ir_resolve_type(ira, fn_type_inst);
     if (type_is_invalid(fn_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *arg_index_inst = instruction->arg_index->other;
+    IrInstruction *arg_index_inst = instruction->arg_index->child;
     uint64_t arg_index;
     if (!ir_resolve_usize(ira, arg_index_inst, &arg_index))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (fn_type->id != ZigTypeIdFn) {
         ir_add_error(ira, fn_type_inst, buf_sprintf("expected function, found '%s'", buf_ptr(&fn_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     FnTypeId *fn_type_id = &fn_type->data.fn.fn_type_id;
@@ -20731,226 +20244,207 @@ static ZigType *ir_analyze_instruction_arg_type(IrAnalyze *ira, IrInstructionArg
         ir_add_error(ira, arg_index_inst,
                 buf_sprintf("arg index %" ZIG_PRI_u64 " out of bounds; '%s' has %" ZIG_PRI_usize " arguments",
                     arg_index, buf_ptr(&fn_type->name), fn_type_id->param_count));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
-    ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-    out_val->data.x_type = fn_type_id->param_info[arg_index].type;
-    if (out_val->data.x_type == nullptr) {
+    ZigType *result_type = fn_type_id->param_info[arg_index].type;
+    if (result_type == nullptr) {
         // Args are only unresolved if our function is generic.
         assert(fn_type->data.fn.is_generic);
 
         ir_add_error(ira, arg_index_inst,
             buf_sprintf("@ArgType could not resolve the type of arg %" ZIG_PRI_u64 " because '%s' is generic",
                 arg_index, buf_ptr(&fn_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
-
-    return ira->codegen->builtin_types.entry_type;
+    return ir_const_type(ira, &instruction->base, result_type);
 }
 
-static ZigType *ir_analyze_instruction_tag_type(IrAnalyze *ira, IrInstructionTagType *instruction) {
+static IrInstruction *ir_analyze_instruction_tag_type(IrAnalyze *ira, IrInstructionTagType *instruction) {
     Error err;
-    IrInstruction *target_inst = instruction->target->other;
+    IrInstruction *target_inst = instruction->target->child;
     ZigType *enum_type = ir_resolve_type(ira, target_inst);
     if (type_is_invalid(enum_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (enum_type->id == ZigTypeIdEnum) {
         if ((err = ensure_complete_type(ira->codegen, enum_type)))
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
 
-        ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-        out_val->data.x_type = enum_type->data.enumeration.tag_int_type;
-        return ira->codegen->builtin_types.entry_type;
+        return ir_const_type(ira, &instruction->base, enum_type->data.enumeration.tag_int_type);
     } else if (enum_type->id == ZigTypeIdUnion) {
         if ((err = ensure_complete_type(ira->codegen, enum_type)))
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
 
         AstNode *decl_node = enum_type->data.unionation.decl_node;
         if (decl_node->data.container_decl.auto_enum || decl_node->data.container_decl.init_arg_expr != nullptr) {
             assert(enum_type->data.unionation.tag_type != nullptr);
 
-            ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-            out_val->data.x_type = enum_type->data.unionation.tag_type;
-            return ira->codegen->builtin_types.entry_type;
+            return ir_const_type(ira, &instruction->base, enum_type->data.unionation.tag_type);
         } else {
             ErrorMsg *msg = ir_add_error(ira, target_inst, buf_sprintf("union '%s' has no tag",
                 buf_ptr(&enum_type->name)));
             add_error_note(ira->codegen, msg, decl_node, buf_sprintf("consider 'union(enum)' here"));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
     } else {
         ir_add_error(ira, target_inst, buf_sprintf("expected enum or union, found '%s'",
             buf_ptr(&enum_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 }
 
-static ZigType *ir_analyze_instruction_cancel(IrAnalyze *ira, IrInstructionCancel *instruction) {
-    IrInstruction *target_inst = instruction->target->other;
+static IrInstruction *ir_analyze_instruction_cancel(IrAnalyze *ira, IrInstructionCancel *instruction) {
+    IrInstruction *target_inst = instruction->target->child;
     if (type_is_invalid(target_inst->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     IrInstruction *casted_target = ir_implicit_cast(ira, target_inst, ira->codegen->builtin_types.entry_promise);
     if (type_is_invalid(casted_target->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     IrInstruction *result = ir_build_cancel(&ira->new_irb, instruction->base.scope, instruction->base.source_node, casted_target);
     result->value.type = ira->codegen->builtin_types.entry_void;
     result->value.special = ConstValSpecialStatic;
-    ir_link_new_instruction(result, &instruction->base);
-    return result->value.type;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_coro_id(IrAnalyze *ira, IrInstructionCoroId *instruction) {
-    IrInstruction *promise_ptr = instruction->promise_ptr->other;
+static IrInstruction *ir_analyze_instruction_coro_id(IrAnalyze *ira, IrInstructionCoroId *instruction) {
+    IrInstruction *promise_ptr = instruction->promise_ptr->child;
     if (type_is_invalid(promise_ptr->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     IrInstruction *result = ir_build_coro_id(&ira->new_irb, instruction->base.scope, instruction->base.source_node,
             promise_ptr);
-    ir_link_new_instruction(result, &instruction->base);
     result->value.type = ira->codegen->builtin_types.entry_usize;
-    return result->value.type;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_coro_alloc(IrAnalyze *ira, IrInstructionCoroAlloc *instruction) {
-    IrInstruction *coro_id = instruction->coro_id->other;
+static IrInstruction *ir_analyze_instruction_coro_alloc(IrAnalyze *ira, IrInstructionCoroAlloc *instruction) {
+    IrInstruction *coro_id = instruction->coro_id->child;
     if (type_is_invalid(coro_id->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     IrInstruction *result = ir_build_coro_alloc(&ira->new_irb, instruction->base.scope, instruction->base.source_node,
             coro_id);
-    ir_link_new_instruction(result, &instruction->base);
     result->value.type = ira->codegen->builtin_types.entry_bool;
-    return result->value.type;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_coro_size(IrAnalyze *ira, IrInstructionCoroSize *instruction) {
+static IrInstruction *ir_analyze_instruction_coro_size(IrAnalyze *ira, IrInstructionCoroSize *instruction) {
     IrInstruction *result = ir_build_coro_size(&ira->new_irb, instruction->base.scope, instruction->base.source_node);
-    ir_link_new_instruction(result, &instruction->base);
     result->value.type = ira->codegen->builtin_types.entry_usize;
-    return result->value.type;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_coro_begin(IrAnalyze *ira, IrInstructionCoroBegin *instruction) {
-    IrInstruction *coro_id = instruction->coro_id->other;
+static IrInstruction *ir_analyze_instruction_coro_begin(IrAnalyze *ira, IrInstructionCoroBegin *instruction) {
+    IrInstruction *coro_id = instruction->coro_id->child;
     if (type_is_invalid(coro_id->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *coro_mem_ptr = instruction->coro_mem_ptr->other;
+    IrInstruction *coro_mem_ptr = instruction->coro_mem_ptr->child;
     if (type_is_invalid(coro_mem_ptr->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     ZigFn *fn_entry = exec_fn_entry(ira->new_irb.exec);
     assert(fn_entry != nullptr);
     IrInstruction *result = ir_build_coro_begin(&ira->new_irb, instruction->base.scope, instruction->base.source_node,
             coro_id, coro_mem_ptr);
-    ir_link_new_instruction(result, &instruction->base);
     result->value.type = get_promise_type(ira->codegen, fn_entry->type_entry->data.fn.fn_type_id.return_type);
-    return result->value.type;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_get_implicit_allocator(IrAnalyze *ira, IrInstructionGetImplicitAllocator *instruction) {
-    IrInstruction *result = ir_get_implicit_allocator(ira, &instruction->base, instruction->id);
-    ir_link_new_instruction(result, &instruction->base);
-    return result->value.type;
+static IrInstruction *ir_analyze_instruction_get_implicit_allocator(IrAnalyze *ira, IrInstructionGetImplicitAllocator *instruction) {
+    return ir_get_implicit_allocator(ira, &instruction->base, instruction->id);
 }
 
-static ZigType *ir_analyze_instruction_coro_alloc_fail(IrAnalyze *ira, IrInstructionCoroAllocFail *instruction) {
-    IrInstruction *err_val = instruction->err_val->other;
+static IrInstruction *ir_analyze_instruction_coro_alloc_fail(IrAnalyze *ira, IrInstructionCoroAllocFail *instruction) {
+    IrInstruction *err_val = instruction->err_val->child;
     if (type_is_invalid(err_val->value.type))
         return ir_unreach_error(ira);
 
     IrInstruction *result = ir_build_coro_alloc_fail(&ira->new_irb, instruction->base.scope, instruction->base.source_node, err_val);
-    ir_link_new_instruction(result, &instruction->base);
     result->value.type = ira->codegen->builtin_types.entry_unreachable;
-    return ir_finish_anal(ira, result->value.type);
+    return ir_finish_anal(ira, result);
 }
 
-static ZigType *ir_analyze_instruction_coro_suspend(IrAnalyze *ira, IrInstructionCoroSuspend *instruction) {
+static IrInstruction *ir_analyze_instruction_coro_suspend(IrAnalyze *ira, IrInstructionCoroSuspend *instruction) {
     IrInstruction *save_point = nullptr;
     if (instruction->save_point != nullptr) {
-        save_point = instruction->save_point->other;
+        save_point = instruction->save_point->child;
         if (type_is_invalid(save_point->value.type))
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
     }
 
-    IrInstruction *is_final = instruction->is_final->other;
+    IrInstruction *is_final = instruction->is_final->child;
     if (type_is_invalid(is_final->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     IrInstruction *result = ir_build_coro_suspend(&ira->new_irb, instruction->base.scope,
             instruction->base.source_node, save_point, is_final);
-    ir_link_new_instruction(result, &instruction->base);
     result->value.type = ira->codegen->builtin_types.entry_u8;
-    return result->value.type;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_coro_end(IrAnalyze *ira, IrInstructionCoroEnd *instruction) {
+static IrInstruction *ir_analyze_instruction_coro_end(IrAnalyze *ira, IrInstructionCoroEnd *instruction) {
     IrInstruction *result = ir_build_coro_end(&ira->new_irb, instruction->base.scope,
             instruction->base.source_node);
-    ir_link_new_instruction(result, &instruction->base);
     result->value.type = ira->codegen->builtin_types.entry_void;
-    return result->value.type;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_coro_free(IrAnalyze *ira, IrInstructionCoroFree *instruction) {
-    IrInstruction *coro_id = instruction->coro_id->other;
+static IrInstruction *ir_analyze_instruction_coro_free(IrAnalyze *ira, IrInstructionCoroFree *instruction) {
+    IrInstruction *coro_id = instruction->coro_id->child;
     if (type_is_invalid(coro_id->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *coro_handle = instruction->coro_handle->other;
+    IrInstruction *coro_handle = instruction->coro_handle->child;
     if (type_is_invalid(coro_handle->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     IrInstruction *result = ir_build_coro_free(&ira->new_irb, instruction->base.scope,
             instruction->base.source_node, coro_id, coro_handle);
-    ir_link_new_instruction(result, &instruction->base);
     ZigType *ptr_type = get_pointer_to_type(ira->codegen, ira->codegen->builtin_types.entry_u8, false);
     result->value.type = get_optional_type(ira->codegen, ptr_type);
-    return result->value.type;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_coro_resume(IrAnalyze *ira, IrInstructionCoroResume *instruction) {
-    IrInstruction *awaiter_handle = instruction->awaiter_handle->other;
+static IrInstruction *ir_analyze_instruction_coro_resume(IrAnalyze *ira, IrInstructionCoroResume *instruction) {
+    IrInstruction *awaiter_handle = instruction->awaiter_handle->child;
     if (type_is_invalid(awaiter_handle->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     IrInstruction *casted_target = ir_implicit_cast(ira, awaiter_handle, ira->codegen->builtin_types.entry_promise);
     if (type_is_invalid(casted_target->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     IrInstruction *result = ir_build_coro_resume(&ira->new_irb, instruction->base.scope,
             instruction->base.source_node, casted_target);
-    ir_link_new_instruction(result, &instruction->base);
     result->value.type = ira->codegen->builtin_types.entry_void;
-    return result->value.type;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_coro_save(IrAnalyze *ira, IrInstructionCoroSave *instruction) {
-    IrInstruction *coro_handle = instruction->coro_handle->other;
+static IrInstruction *ir_analyze_instruction_coro_save(IrAnalyze *ira, IrInstructionCoroSave *instruction) {
+    IrInstruction *coro_handle = instruction->coro_handle->child;
     if (type_is_invalid(coro_handle->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     IrInstruction *result = ir_build_coro_save(&ira->new_irb, instruction->base.scope,
             instruction->base.source_node, coro_handle);
-    ir_link_new_instruction(result, &instruction->base);
     result->value.type = ira->codegen->builtin_types.entry_usize;
-    return result->value.type;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_coro_promise(IrAnalyze *ira, IrInstructionCoroPromise *instruction) {
-    IrInstruction *coro_handle = instruction->coro_handle->other;
+static IrInstruction *ir_analyze_instruction_coro_promise(IrAnalyze *ira, IrInstructionCoroPromise *instruction) {
+    IrInstruction *coro_handle = instruction->coro_handle->child;
     if (type_is_invalid(coro_handle->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (coro_handle->value.type->id != ZigTypeIdPromise ||
         coro_handle->value.type->data.promise.result_type == nullptr)
     {
         ir_add_error(ira, &instruction->base, buf_sprintf("expected promise->T, found '%s'",
                     buf_ptr(&coro_handle->value.type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     ZigType *coro_frame_type = get_promise_frame_type(ira->codegen,
@@ -20958,26 +20452,24 @@ static ZigType *ir_analyze_instruction_coro_promise(IrAnalyze *ira, IrInstructio
 
     IrInstruction *result = ir_build_coro_promise(&ira->new_irb, instruction->base.scope,
             instruction->base.source_node, coro_handle);
-    ir_link_new_instruction(result, &instruction->base);
     result->value.type = get_pointer_to_type(ira->codegen, coro_frame_type, false);
-    return result->value.type;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_coro_alloc_helper(IrAnalyze *ira, IrInstructionCoroAllocHelper *instruction) {
-    IrInstruction *alloc_fn = instruction->alloc_fn->other;
+static IrInstruction *ir_analyze_instruction_coro_alloc_helper(IrAnalyze *ira, IrInstructionCoroAllocHelper *instruction) {
+    IrInstruction *alloc_fn = instruction->alloc_fn->child;
     if (type_is_invalid(alloc_fn->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *coro_size = instruction->coro_size->other;
+    IrInstruction *coro_size = instruction->coro_size->child;
     if (type_is_invalid(coro_size->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     IrInstruction *result = ir_build_coro_alloc_helper(&ira->new_irb, instruction->base.scope,
             instruction->base.source_node, alloc_fn, coro_size);
-    ir_link_new_instruction(result, &instruction->base);
     ZigType *u8_ptr_type = get_pointer_to_type(ira->codegen, ira->codegen->builtin_types.entry_u8, false);
     result->value.type = get_optional_type(ira->codegen, u8_ptr_type);
-    return result->value.type;
+    return result;
 }
 
 static ZigType *ir_resolve_atomic_operand_type(IrAnalyze *ira, IrInstruction *op) {
@@ -21012,48 +20504,48 @@ static ZigType *ir_resolve_atomic_operand_type(IrAnalyze *ira, IrInstruction *op
     return operand_type;
 }
 
-static ZigType *ir_analyze_instruction_atomic_rmw(IrAnalyze *ira, IrInstructionAtomicRmw *instruction) {
-    ZigType *operand_type = ir_resolve_atomic_operand_type(ira, instruction->operand_type->other);
+static IrInstruction *ir_analyze_instruction_atomic_rmw(IrAnalyze *ira, IrInstructionAtomicRmw *instruction) {
+    ZigType *operand_type = ir_resolve_atomic_operand_type(ira, instruction->operand_type->child);
     if (type_is_invalid(operand_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *ptr_inst = instruction->ptr->other;
+    IrInstruction *ptr_inst = instruction->ptr->child;
     if (type_is_invalid(ptr_inst->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     // TODO let this be volatile
     ZigType *ptr_type = get_pointer_to_type(ira->codegen, operand_type, false);
     IrInstruction *casted_ptr = ir_implicit_cast(ira, ptr_inst, ptr_type);
     if (type_is_invalid(casted_ptr->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     AtomicRmwOp op;
     if (instruction->op == nullptr) {
         op = instruction->resolved_op;
     } else {
-        if (!ir_resolve_atomic_rmw_op(ira, instruction->op->other, &op)) {
-            return ira->codegen->builtin_types.entry_invalid;
+        if (!ir_resolve_atomic_rmw_op(ira, instruction->op->child, &op)) {
+            return ira->codegen->invalid_instruction;
         }
     }
 
-    IrInstruction *operand = instruction->operand->other;
+    IrInstruction *operand = instruction->operand->child;
     if (type_is_invalid(operand->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     IrInstruction *casted_operand = ir_implicit_cast(ira, operand, operand_type);
     if (type_is_invalid(casted_operand->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     AtomicOrder ordering;
     if (instruction->ordering == nullptr) {
         ordering = instruction->resolved_ordering;
     } else {
-        if (!ir_resolve_atomic_order(ira, instruction->ordering->other, &ordering))
-            return ira->codegen->builtin_types.entry_invalid;
+        if (!ir_resolve_atomic_order(ira, instruction->ordering->child, &ordering))
+            return ira->codegen->invalid_instruction;
         if (ordering == AtomicOrderUnordered) {
             ir_add_error(ira, instruction->ordering,
                 buf_sprintf("@atomicRmw atomic ordering must not be Unordered"));
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
         }
     }
 
@@ -21065,74 +20557,69 @@ static ZigType *ir_analyze_instruction_atomic_rmw(IrAnalyze *ira, IrInstructionA
     IrInstruction *result = ir_build_atomic_rmw(&ira->new_irb, instruction->base.scope,
             instruction->base.source_node, nullptr, casted_ptr, nullptr, casted_operand, nullptr,
             op, ordering);
-    ir_link_new_instruction(result, &instruction->base);
     result->value.type = operand_type;
-    return result->value.type;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_atomic_load(IrAnalyze *ira, IrInstructionAtomicLoad *instruction) {
-    ZigType *operand_type = ir_resolve_atomic_operand_type(ira, instruction->operand_type->other);
+static IrInstruction *ir_analyze_instruction_atomic_load(IrAnalyze *ira, IrInstructionAtomicLoad *instruction) {
+    ZigType *operand_type = ir_resolve_atomic_operand_type(ira, instruction->operand_type->child);
     if (type_is_invalid(operand_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *ptr_inst = instruction->ptr->other;
+    IrInstruction *ptr_inst = instruction->ptr->child;
     if (type_is_invalid(ptr_inst->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     ZigType *ptr_type = get_pointer_to_type(ira->codegen, operand_type, true);
     IrInstruction *casted_ptr = ir_implicit_cast(ira, ptr_inst, ptr_type);
     if (type_is_invalid(casted_ptr->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     AtomicOrder ordering;
     if (instruction->ordering == nullptr) {
         ordering = instruction->resolved_ordering;
     } else {
-        if (!ir_resolve_atomic_order(ira, instruction->ordering->other, &ordering))
-            return ira->codegen->builtin_types.entry_invalid;
+        if (!ir_resolve_atomic_order(ira, instruction->ordering->child, &ordering))
+            return ira->codegen->invalid_instruction;
     }
 
     if (ordering == AtomicOrderRelease || ordering == AtomicOrderAcqRel) {
         assert(instruction->ordering != nullptr);
         ir_add_error(ira, instruction->ordering,
             buf_sprintf("@atomicLoad atomic ordering must not be Release or AcqRel"));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     if (instr_is_comptime(casted_ptr)) {
         IrInstruction *result = ir_get_deref(ira, &instruction->base, casted_ptr);
-        ir_link_new_instruction(result, &instruction->base);
         assert(result->value.type != nullptr);
-        return result->value.type;
+        return result;
     }
 
     IrInstruction *result = ir_build_atomic_load(&ira->new_irb, instruction->base.scope,
             instruction->base.source_node, nullptr, casted_ptr, nullptr, ordering);
-    ir_link_new_instruction(result, &instruction->base);
     result->value.type = operand_type;
-    return result->value.type;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_promise_result_type(IrAnalyze *ira, IrInstructionPromiseResultType *instruction) {
-    ZigType *promise_type = ir_resolve_type(ira, instruction->promise_type->other);
+static IrInstruction *ir_analyze_instruction_promise_result_type(IrAnalyze *ira, IrInstructionPromiseResultType *instruction) {
+    ZigType *promise_type = ir_resolve_type(ira, instruction->promise_type->child);
     if (type_is_invalid(promise_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (promise_type->id != ZigTypeIdPromise || promise_type->data.promise.result_type == nullptr) {
         ir_add_error(ira, &instruction->base, buf_sprintf("expected promise->T, found '%s'",
                     buf_ptr(&promise_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
-    ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-    out_val->data.x_type = promise_type->data.promise.result_type;
-    return ira->codegen->builtin_types.entry_type;
+    return ir_const_type(ira, &instruction->base, promise_type->data.promise.result_type);
 }
 
-static ZigType *ir_analyze_instruction_await_bookkeeping(IrAnalyze *ira, IrInstructionAwaitBookkeeping *instruction) {
-    ZigType *promise_result_type = ir_resolve_type(ira, instruction->promise_result_type->other);
+static IrInstruction *ir_analyze_instruction_await_bookkeeping(IrAnalyze *ira, IrInstructionAwaitBookkeeping *instruction) {
+    ZigType *promise_result_type = ir_resolve_type(ira, instruction->promise_result_type->child);
     if (type_is_invalid(promise_result_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     ZigFn *fn_entry = exec_fn_entry(ira->new_irb.exec);
     assert(fn_entry != nullptr);
@@ -21141,17 +20628,15 @@ static ZigType *ir_analyze_instruction_await_bookkeeping(IrAnalyze *ira, IrInstr
         fn_entry->calls_or_awaits_errorable_fn = true;
     }
 
-    ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-    out_val->type = ira->codegen->builtin_types.entry_void;
-    return out_val->type;
+    return ir_const_void(ira, &instruction->base);
 }
 
-static ZigType *ir_analyze_instruction_merge_err_ret_traces(IrAnalyze *ira,
+static IrInstruction *ir_analyze_instruction_merge_err_ret_traces(IrAnalyze *ira,
         IrInstructionMergeErrRetTraces *instruction)
 {
-    IrInstruction *coro_promise_ptr = instruction->coro_promise_ptr->other;
+    IrInstruction *coro_promise_ptr = instruction->coro_promise_ptr->child;
     if (type_is_invalid(coro_promise_ptr->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     assert(coro_promise_ptr->value.type->id == ZigTypeIdPointer);
     ZigType *promise_frame_type = coro_promise_ptr->value.type->data.pointer.child_type;
@@ -21159,71 +20644,67 @@ static ZigType *ir_analyze_instruction_merge_err_ret_traces(IrAnalyze *ira,
     ZigType *promise_result_type = promise_frame_type->data.structure.fields[1].type_entry;
 
     if (!type_can_fail(promise_result_type)) {
-        ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
-        out_val->type = ira->codegen->builtin_types.entry_void;
-        return out_val->type;
+        return ir_const_void(ira, &instruction->base);
     }
 
-    IrInstruction *src_err_ret_trace_ptr = instruction->src_err_ret_trace_ptr->other;
+    IrInstruction *src_err_ret_trace_ptr = instruction->src_err_ret_trace_ptr->child;
     if (type_is_invalid(src_err_ret_trace_ptr->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *dest_err_ret_trace_ptr = instruction->dest_err_ret_trace_ptr->other;
+    IrInstruction *dest_err_ret_trace_ptr = instruction->dest_err_ret_trace_ptr->child;
     if (type_is_invalid(dest_err_ret_trace_ptr->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     IrInstruction *result = ir_build_merge_err_ret_traces(&ira->new_irb, instruction->base.scope,
             instruction->base.source_node, coro_promise_ptr, src_err_ret_trace_ptr, dest_err_ret_trace_ptr);
-    ir_link_new_instruction(result, &instruction->base);
     result->value.type = ira->codegen->builtin_types.entry_void;
-    return result->value.type;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_save_err_ret_addr(IrAnalyze *ira, IrInstructionSaveErrRetAddr *instruction) {
+static IrInstruction *ir_analyze_instruction_save_err_ret_addr(IrAnalyze *ira, IrInstructionSaveErrRetAddr *instruction) {
     IrInstruction *result = ir_build_save_err_ret_addr(&ira->new_irb, instruction->base.scope,
             instruction->base.source_node);
-    ir_link_new_instruction(result, &instruction->base);
     result->value.type = ira->codegen->builtin_types.entry_void;
-    return result->value.type;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_mark_err_ret_trace_ptr(IrAnalyze *ira, IrInstructionMarkErrRetTracePtr *instruction) {
-    IrInstruction *err_ret_trace_ptr = instruction->err_ret_trace_ptr->other;
+static IrInstruction *ir_analyze_instruction_mark_err_ret_trace_ptr(IrAnalyze *ira, IrInstructionMarkErrRetTracePtr *instruction) {
+    IrInstruction *err_ret_trace_ptr = instruction->err_ret_trace_ptr->child;
     if (type_is_invalid(err_ret_trace_ptr->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     IrInstruction *result = ir_build_mark_err_ret_trace_ptr(&ira->new_irb, instruction->base.scope,
             instruction->base.source_node, err_ret_trace_ptr);
-    ir_link_new_instruction(result, &instruction->base);
     result->value.type = ira->codegen->builtin_types.entry_void;
-    return result->value.type;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_sqrt(IrAnalyze *ira, IrInstructionSqrt *instruction) {
-    ZigType *float_type = ir_resolve_type(ira, instruction->type->other);
+static IrInstruction *ir_analyze_instruction_sqrt(IrAnalyze *ira, IrInstructionSqrt *instruction) {
+    ZigType *float_type = ir_resolve_type(ira, instruction->type->child);
     if (type_is_invalid(float_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *op = instruction->op->other;
+    IrInstruction *op = instruction->op->child;
     if (type_is_invalid(op->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     bool ok_type = float_type->id == ZigTypeIdComptimeFloat || float_type->id == ZigTypeIdFloat;
     if (!ok_type) {
         ir_add_error(ira, instruction->type, buf_sprintf("@sqrt does not support type '%s'", buf_ptr(&float_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     IrInstruction *casted_op = ir_implicit_cast(ira, op, float_type);
     if (type_is_invalid(casted_op->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (instr_is_comptime(casted_op)) {
         ConstExprValue *val = ir_resolve_const(ira, casted_op, UndefBad);
         if (!val)
-            return ira->codegen->builtin_types.entry_invalid;
+            return ira->codegen->invalid_instruction;
 
-        ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
+        IrInstruction *result = ir_const(ira, &instruction->base, float_type);
+        ConstExprValue *out_val = &result->value;
 
         if (float_type->id == ZigTypeIdComptimeFloat) {
             bigfloat_sqrt(&out_val->data.x_bigfloat, &val->data.x_bigfloat);
@@ -21248,7 +20729,7 @@ static ZigType *ir_analyze_instruction_sqrt(IrAnalyze *ira, IrInstructionSqrt *i
             zig_unreachable();
         }
 
-        return float_type;
+        return result;
     }
 
     assert(float_type->id == ZigTypeIdFloat);
@@ -21256,93 +20737,87 @@ static ZigType *ir_analyze_instruction_sqrt(IrAnalyze *ira, IrInstructionSqrt *i
         float_type->data.floating.bit_count != 32 &&
         float_type->data.floating.bit_count != 64) {
         ir_add_error(ira, instruction->type, buf_sprintf("compiler TODO: add implementation of sqrt for '%s'", buf_ptr(&float_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     IrInstruction *result = ir_build_sqrt(&ira->new_irb, instruction->base.scope,
             instruction->base.source_node, nullptr, casted_op);
-    ir_link_new_instruction(result, &instruction->base);
     result->value.type = float_type;
-    return result->value.type;
+    return result;
 }
 
-static ZigType *ir_analyze_instruction_enum_to_int(IrAnalyze *ira, IrInstructionEnumToInt *instruction) {
+static IrInstruction *ir_analyze_instruction_enum_to_int(IrAnalyze *ira, IrInstructionEnumToInt *instruction) {
     Error err;
-    IrInstruction *target = instruction->target->other;
+    IrInstruction *target = instruction->target->child;
     if (type_is_invalid(target->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (target->value.type->id != ZigTypeIdEnum) {
         ir_add_error(ira, instruction->target,
             buf_sprintf("expected enum, found type '%s'", buf_ptr(&target->value.type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     if ((err = type_resolve(ira->codegen, target->value.type, ResolveStatusZeroBitsKnown)))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     ZigType *tag_type = target->value.type->data.enumeration.tag_int_type;
 
-    IrInstruction *result = ir_analyze_enum_to_int(ira, &instruction->base, target, tag_type);
-    ir_link_new_instruction(result, &instruction->base);
-    return result->value.type;
+    return ir_analyze_enum_to_int(ira, &instruction->base, target, tag_type);
 }
 
-static ZigType *ir_analyze_instruction_int_to_enum(IrAnalyze *ira, IrInstructionIntToEnum *instruction) {
+static IrInstruction *ir_analyze_instruction_int_to_enum(IrAnalyze *ira, IrInstructionIntToEnum *instruction) {
     Error err;
-    IrInstruction *dest_type_value = instruction->dest_type->other;
+    IrInstruction *dest_type_value = instruction->dest_type->child;
     ZigType *dest_type = ir_resolve_type(ira, dest_type_value);
     if (type_is_invalid(dest_type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (dest_type->id != ZigTypeIdEnum) {
         ir_add_error(ira, instruction->dest_type,
             buf_sprintf("expected enum, found type '%s'", buf_ptr(&dest_type->name)));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
     if ((err = type_resolve(ira->codegen, dest_type, ResolveStatusZeroBitsKnown)))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     ZigType *tag_type = dest_type->data.enumeration.tag_int_type;
 
-    IrInstruction *target = instruction->target->other;
+    IrInstruction *target = instruction->target->child;
     if (type_is_invalid(target->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     IrInstruction *casted_target = ir_implicit_cast(ira, target, tag_type);
     if (type_is_invalid(casted_target->value.type))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *result = ir_analyze_int_to_enum(ira, &instruction->base, casted_target, dest_type);
-    ir_link_new_instruction(result, &instruction->base);
-    return result->value.type;
+    return ir_analyze_int_to_enum(ira, &instruction->base, casted_target, dest_type);
 }
 
-static ZigType *ir_analyze_instruction_check_runtime_scope(IrAnalyze *ira, IrInstructionCheckRuntimeScope *instruction) {
-    IrInstruction *block_comptime_inst = instruction->scope_is_comptime->other;
+static IrInstruction *ir_analyze_instruction_check_runtime_scope(IrAnalyze *ira, IrInstructionCheckRuntimeScope *instruction) {
+    IrInstruction *block_comptime_inst = instruction->scope_is_comptime->child;
     bool scope_is_comptime;
     if (!ir_resolve_bool(ira, block_comptime_inst, &scope_is_comptime))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
-    IrInstruction *is_comptime_inst = instruction->is_comptime->other;
+    IrInstruction *is_comptime_inst = instruction->is_comptime->child;
     bool is_comptime;
     if (!ir_resolve_bool(ira, is_comptime_inst, &is_comptime))
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
 
     if (!scope_is_comptime && is_comptime) {
         ErrorMsg *msg = ir_add_error(ira, &instruction->base,
             buf_sprintf("comptime control flow inside runtime block"));
         add_error_note(ira->codegen, msg, block_comptime_inst->source_node,
                 buf_sprintf("runtime block created here"));
-        return ira->codegen->builtin_types.entry_invalid;
+        return ira->codegen->invalid_instruction;
     }
 
-    ir_build_const_from(ira, &instruction->base);
-    return ira->codegen->builtin_types.entry_void;
+    return ir_const_void(ira, &instruction->base);
 }
 
-static ZigType *ir_analyze_instruction_nocast(IrAnalyze *ira, IrInstruction *instruction) {
+static IrInstruction *ir_analyze_instruction_nocast(IrAnalyze *ira, IrInstruction *instruction) {
     switch (instruction->id) {
         case IrInstructionIdInvalid:
         case IrInstructionIdWidenOrShorten:
@@ -21436,10 +20911,6 @@ static ZigType *ir_analyze_instruction_nocast(IrAnalyze *ira, IrInstruction *ins
             return ir_analyze_instruction_container_init_list(ira, (IrInstructionContainerInitList *)instruction);
         case IrInstructionIdContainerInitFields:
             return ir_analyze_instruction_container_init_fields(ira, (IrInstructionContainerInitFields *)instruction);
-        case IrInstructionIdMinValue:
-            return ir_analyze_instruction_min_value(ira, (IrInstructionMinValue *)instruction);
-        case IrInstructionIdMaxValue:
-            return ir_analyze_instruction_max_value(ira, (IrInstructionMaxValue *)instruction);
         case IrInstructionIdCompileErr:
             return ir_analyze_instruction_compile_err(ira, (IrInstructionCompileErr *)instruction);
         case IrInstructionIdCompileLog:
@@ -21538,8 +21009,10 @@ static ZigType *ir_analyze_instruction_nocast(IrAnalyze *ira, IrInstruction *ins
             return ir_analyze_instruction_enum_tag_name(ira, (IrInstructionTagName *)instruction);
         case IrInstructionIdFieldParentPtr:
             return ir_analyze_instruction_field_parent_ptr(ira, (IrInstructionFieldParentPtr *)instruction);
-        case IrInstructionIdOffsetOf:
-            return ir_analyze_instruction_offset_of(ira, (IrInstructionOffsetOf *)instruction);
+        case IrInstructionIdByteOffsetOf:
+            return ir_analyze_instruction_byte_offset_of(ira, (IrInstructionByteOffsetOf *)instruction);
+        case IrInstructionIdBitOffsetOf:
+            return ir_analyze_instruction_bit_offset_of(ira, (IrInstructionBitOffsetOf *)instruction);
         case IrInstructionIdTypeInfo:
             return ir_analyze_instruction_type_info(ira, (IrInstructionTypeInfo *) instruction);
         case IrInstructionIdTypeId:
@@ -21624,19 +21097,11 @@ static ZigType *ir_analyze_instruction_nocast(IrAnalyze *ira, IrInstruction *ins
     zig_unreachable();
 }
 
-static ZigType *ir_analyze_instruction(IrAnalyze *ira, IrInstruction *instruction) {
-    ZigType *instruction_type = ir_analyze_instruction_nocast(ira, instruction);
-    instruction->value.type = instruction_type;
-
-    if (instruction->other) {
-        instruction->other->value.type = instruction_type;
-    } else {
-        assert(instruction_type->id == ZigTypeIdInvalid ||
-               instruction_type->id == ZigTypeIdUnreachable);
-        instruction->other = instruction;
-    }
-
-    return instruction_type;
+static IrInstruction *ir_analyze_instruction(IrAnalyze *ira, IrInstruction *old_instruction) {
+    IrInstruction *new_instruction = ir_analyze_instruction_nocast(ira, old_instruction);
+    assert(new_instruction->value.type != nullptr);
+    old_instruction->child = new_instruction;
+    return new_instruction;
 }
 
 // This function attempts to evaluate IR code while doing type checking and other analysis.
@@ -21683,13 +21148,13 @@ ZigType *ir_analyze(CodeGen *codegen, IrExecutable *old_exec, IrExecutable *new_
             continue;
         }
 
-        ZigType *return_type = ir_analyze_instruction(ira, old_instruction);
-        if (type_is_invalid(return_type) && ir_should_inline(new_exec, old_instruction->scope)) {
+        IrInstruction *new_instruction = ir_analyze_instruction(ira, old_instruction);
+        if (type_is_invalid(new_instruction->value.type) && ir_should_inline(new_exec, old_instruction->scope)) {
             return ira->codegen->builtin_types.entry_invalid;
         }
 
         // unreachable instructions do their own control flow.
-        if (return_type->id == ZigTypeIdUnreachable)
+        if (new_instruction->value.type->id == ZigTypeIdUnreachable)
             continue;
 
         ira->instruction_index += 1;
@@ -21789,8 +21254,6 @@ bool ir_has_side_effects(IrInstruction *instruction) {
         case IrInstructionIdSwitchTarget:
         case IrInstructionIdUnionTag:
         case IrInstructionIdRef:
-        case IrInstructionIdMinValue:
-        case IrInstructionIdMaxValue:
         case IrInstructionIdEmbedFile:
         case IrInstructionIdTruncate:
         case IrInstructionIdIntType:
@@ -21823,7 +21286,8 @@ bool ir_has_side_effects(IrInstruction *instruction) {
         case IrInstructionIdTypeName:
         case IrInstructionIdTagName:
         case IrInstructionIdFieldParentPtr:
-        case IrInstructionIdOffsetOf:
+        case IrInstructionIdByteOffsetOf:
+        case IrInstructionIdBitOffsetOf:
         case IrInstructionIdTypeInfo:
         case IrInstructionIdTypeId:
         case IrInstructionIdAlignCast: