Commit 6aac423964

@@ -33,12 +33,15 @@ struct BuiltinFnEntry;
 struct TypeStructField;
 struct CodeGen;
 struct ZigValue;
-struct IrInstruction;
-struct IrInstructionCast;
-struct IrInstructionAllocaGen;
-struct IrInstructionCallGen;
-struct IrInstructionAwaitGen;
-struct IrBasicBlock;
+struct IrInst;
+struct IrInstSrc;
+struct IrInstGen;
+struct IrInstGenCast;
+struct IrInstGenAlloca;
+struct IrInstGenCall;
+struct IrInstGenAwait;
+struct IrBasicBlockSrc;
+struct IrBasicBlockGen;
 struct ScopeDecls;
 struct ZigWindowsSDK;
 struct Tld;
@@ -50,6 +53,7 @@ struct ResultLocPeerParent;
 struct ResultLocBitCast;
 struct ResultLocCast;
 struct ResultLocReturn;
+struct IrExecutableGen;
 
 enum PtrLen {
     PtrLenUnknown,
@@ -97,8 +101,8 @@ enum X64CABIClass {
     X64CABIClass_SSE,
 };
 
-struct IrExecutable {
-    ZigList<IrBasicBlock *> basic_block_list;
+struct IrExecutableSrc {
+    ZigList<IrBasicBlockSrc *> basic_block_list;
     Buf *name;
     ZigFn *name_fn;
     size_t mem_slot_count;
@@ -108,8 +112,7 @@ struct IrExecutable {
     ZigFn *fn_entry;
     Buf *c_import_buf;
     AstNode *source_node;
-    IrExecutable *parent_exec;
-    IrExecutable *source_exec;
+    IrExecutableGen *parent_exec;
     IrAnalyze *analysis;
     Scope *begin_scope;
     ErrorMsg *first_err_trace_msg;
@@ -124,6 +127,32 @@ struct IrExecutable {
     void src();
 };
 
+struct IrExecutableGen {
+    ZigList<IrBasicBlockGen *> basic_block_list;
+    Buf *name;
+    ZigFn *name_fn;
+    size_t mem_slot_count;
+    size_t next_debug_id;
+    size_t *backward_branch_count;
+    size_t *backward_branch_quota;
+    ZigFn *fn_entry;
+    Buf *c_import_buf;
+    AstNode *source_node;
+    IrExecutableGen *parent_exec;
+    IrExecutableSrc *source_exec;
+    Scope *begin_scope;
+    ErrorMsg *first_err_trace_msg;
+    ZigList<Tld *> tld_list;
+
+    bool is_inline;
+    bool is_generic_instantiation;
+    bool need_err_code_spill;
+
+    // This is a function for use in the debugger to print
+    // the source location.
+    void src();
+};
+
 enum OutType {
     OutTypeUnknown,
     OutTypeExe,
@@ -287,7 +316,7 @@ struct ConstErrValue {
 
 struct ConstBoundFnValue {
     ZigFn *fn;
-    IrInstruction *first_arg;
+    IrInstGen *first_arg;
 };
 
 struct ConstArgTuple {
@@ -350,14 +379,14 @@ struct LazyValueAlignOf {
     LazyValue base;
 
     IrAnalyze *ira;
-    IrInstruction *target_type;
+    IrInstGen *target_type;
 };
 
 struct LazyValueSizeOf {
     LazyValue base;
 
     IrAnalyze *ira;
-    IrInstruction *target_type;
+    IrInstGen *target_type;
 
     bool bit_size;
 };
@@ -366,9 +395,9 @@ struct LazyValueSliceType {
     LazyValue base;
 
     IrAnalyze *ira;
-    IrInstruction *sentinel; // can be null
-    IrInstruction *elem_type;
-    IrInstruction *align_inst; // can be null
+    IrInstGen *sentinel; // can be null
+    IrInstGen *elem_type;
+    IrInstGen *align_inst; // can be null
 
     bool is_const;
     bool is_volatile;
@@ -379,8 +408,8 @@ struct LazyValueArrayType {
     LazyValue base;
 
     IrAnalyze *ira;
-    IrInstruction *sentinel; // can be null
-    IrInstruction *elem_type;
+    IrInstGen *sentinel; // can be null
+    IrInstGen *elem_type;
     uint64_t length;
 };
 
@@ -388,9 +417,9 @@ struct LazyValuePtrType {
     LazyValue base;
 
     IrAnalyze *ira;
-    IrInstruction *sentinel; // can be null
-    IrInstruction *elem_type;
-    IrInstruction *align_inst; // can be null
+    IrInstGen *sentinel; // can be null
+    IrInstGen *elem_type;
+    IrInstGen *align_inst; // can be null
 
     PtrLen ptr_len;
     uint32_t bit_offset_in_host;
@@ -405,7 +434,7 @@ struct LazyValueOptType {
     LazyValue base;
 
     IrAnalyze *ira;
-    IrInstruction *payload_type;
+    IrInstGen *payload_type;
 };
 
 struct LazyValueFnType {
@@ -413,9 +442,9 @@ struct LazyValueFnType {
 
     IrAnalyze *ira;
     AstNode *proto_node;
-    IrInstruction **param_types;
-    IrInstruction *align_inst; // can be null
-    IrInstruction *return_type;
+    IrInstGen **param_types;
+    IrInstGen *align_inst; // can be null
+    IrInstGen *return_type;
 
     CallingConvention cc;
     bool is_generic;
@@ -425,8 +454,8 @@ struct LazyValueErrUnionType {
     LazyValue base;
 
     IrAnalyze *ira;
-    IrInstruction *err_set_type;
-    IrInstruction *payload_type;
+    IrInstGen *err_set_type;
+    IrInstGen *payload_type;
     Buf *type_name;
 };
 
@@ -1602,19 +1631,19 @@ struct ZigFn {
     // in the case of async functions this is the implicit return type according to the
     // zig source code, not according to zig ir
     ZigType *src_implicit_return_type;
-    IrExecutable *ir_executable;
-    IrExecutable analyzed_executable;
+    IrExecutableSrc *ir_executable;
+    IrExecutableGen analyzed_executable;
     size_t prealloc_bbc;
     size_t prealloc_backward_branch_quota;
     AstNode **param_source_nodes;
     Buf **param_names;
-    IrInstruction *err_code_spill;
+    IrInstGen *err_code_spill;
     AstNode *assumed_non_async;
 
     AstNode *fn_no_inline_set_node;
     AstNode *fn_static_eval_set_node;
 
-    ZigList<IrInstructionAllocaGen *> alloca_gen_list;
+    ZigList<IrInstGenAlloca *> alloca_gen_list;
     ZigList<ZigVar *> variable_list;
 
     Buf *section_name;
@@ -1626,8 +1655,8 @@ struct ZigFn {
     AstNode *non_async_node;
 
     ZigList<GlobalExport> export_list;
-    ZigList<IrInstructionCallGen *> call_list;
-    ZigList<IrInstructionAwaitGen *> await_list;
+    ZigList<IrInstGenCall *> call_list;
+    ZigList<IrInstGenAwait *> await_list;
 
     LLVMValueRef valgrind_client_request_array;
 
@@ -2098,8 +2127,9 @@ struct CodeGen {
     Buf *zig_c_headers_dir; // Cannot be overridden; derived from zig_lib_dir.
     Buf *zig_std_special_dir; // Cannot be overridden; derived from zig_lib_dir.
 
-    IrInstruction *invalid_instruction;
-    IrInstruction *unreach_instruction;
+    IrInstSrc *invalid_inst_src;
+    IrInstGen *invalid_inst_gen;
+    IrInstGen *unreach_instruction;
 
     ZigValue panic_msg_vals[PanicMsgIdCount];
 
@@ -2222,8 +2252,8 @@ struct ZigVar {
     ZigValue *const_value;
     ZigType *var_type;
     LLVMValueRef value_ref;
-    IrInstruction *is_comptime;
-    IrInstruction *ptr_instruction;
+    IrInstSrc *is_comptime;
+    IrInstGen *ptr_instruction;
     // which node is the declaration of the variable
     AstNode *decl_node;
     ZigLLVMDILocalVariable *di_loc_var;
@@ -2232,7 +2262,7 @@ struct ZigVar {
     Scope *child_scope;
     LLVMValueRef param_value_ref;
     size_t mem_slot_index;
-    IrExecutable *owner_exec;
+    IrExecutableSrc *owner_exec;
 
     Buf *section_name;
 
@@ -2323,11 +2353,11 @@ struct ScopeBlock {
     Scope base;
 
     Buf *name;
-    IrBasicBlock *end_block;
-    IrInstruction *is_comptime;
+    IrBasicBlockSrc *end_block;
+    IrInstSrc *is_comptime;
     ResultLocPeerParent *peer_parent;
-    ZigList<IrInstruction *> *incoming_values;
-    ZigList<IrBasicBlock *> *incoming_blocks;
+    ZigList<IrInstSrc *> *incoming_values;
+    ZigList<IrBasicBlockSrc *> *incoming_blocks;
 
     AstNode *safety_set_node;
     AstNode *fast_math_set_node;
@@ -2378,11 +2408,11 @@ struct ScopeLoop {
 
     LVal lval;
     Buf *name;
-    IrBasicBlock *break_block;
-    IrBasicBlock *continue_block;
-    IrInstruction *is_comptime;
-    ZigList<IrInstruction *> *incoming_values;
-    ZigList<IrBasicBlock *> *incoming_blocks;
+    IrBasicBlockSrc *break_block;
+    IrBasicBlockSrc *continue_block;
+    IrInstSrc *is_comptime;
+    ZigList<IrInstSrc *> *incoming_values;
+    ZigList<IrBasicBlockSrc *> *incoming_blocks;
     ResultLocPeerParent *peer_parent;
     ScopeExpr *spill_scope;
 };
@@ -2393,7 +2423,7 @@ struct ScopeLoop {
 struct ScopeRuntime {
     Scope base;
 
-    IrInstruction *is_comptime;
+    IrInstSrc *is_comptime;
 };
 
 // This scope is created for a suspend block in order to have labeled
@@ -2472,319 +2502,450 @@ enum AtomicRmwOp {
 // to another basic block.
 // Phi instructions must be first in a basic block.
 // The last instruction in a basic block must be of type unreachable.
-struct IrBasicBlock {
-    ZigList<IrInstruction *> instruction_list;
-    IrBasicBlock *other;
+struct IrBasicBlockSrc {
+    ZigList<IrInstSrc *> instruction_list;
+    IrBasicBlockGen *child;
+    Scope *scope;
+    const char *name_hint;
+    IrInst *suspend_instruction_ref;
+
+    uint32_t ref_count;
+    uint32_t index; // index into the basic block list
+
+    uint32_t debug_id;
+    bool suspended;
+    bool in_resume_stack;
+};
+
+struct IrBasicBlockGen {
+    ZigList<IrInstGen *> instruction_list;
+    IrBasicBlockSrc *parent;
     Scope *scope;
     const char *name_hint;
-    size_t debug_id;
-    size_t ref_count;
-    // index into the basic block list
-    size_t index;
+    uint32_t index; // index into the basic block list
+    uint32_t ref_count;
     LLVMBasicBlockRef llvm_block;
     LLVMBasicBlockRef llvm_exit_block;
     // The instruction that referenced this basic block and caused us to
     // analyze the basic block. If the same instruction wants us to emit
     // the same basic block, then we re-generate it instead of saving it.
-    IrInstruction *ref_instruction;
+    IrInst *ref_instruction;
     // When this is non-null, a branch to this basic block is only allowed
     // if the branch is comptime. The instruction points to the reason
     // the basic block must be comptime.
-    IrInstruction *must_be_comptime_source_instr;
-    IrInstruction *suspend_instruction_ref;
+    IrInst *must_be_comptime_source_instr;
+
+    uint32_t debug_id;
     bool already_appended;
-    bool suspended;
-    bool in_resume_stack;
 };
 
-// These instructions are in transition to having "pass 1" instructions
-// and "pass 2" instructions. The pass 1 instructions are suffixed with Src
-// and pass 2 are suffixed with Gen.
-// Once all instructions are separated in this way, they'll have different
-// base types for better type safety.
 // Src instructions are generated by ir_gen_* functions in ir.cpp from AST.
 // ir_analyze_* functions consume Src instructions and produce Gen instructions.
+// Src instructions do not have type information; Gen instructions do.
+enum IrInstSrcId {
+    IrInstSrcIdInvalid,
+    IrInstSrcIdDeclVar,
+    IrInstSrcIdBr,
+    IrInstSrcIdCondBr,
+    IrInstSrcIdSwitchBr,
+    IrInstSrcIdSwitchVar,
+    IrInstSrcIdSwitchElseVar,
+    IrInstSrcIdSwitchTarget,
+    IrInstSrcIdPhi,
+    IrInstSrcIdUnOp,
+    IrInstSrcIdBinOp,
+    IrInstSrcIdMergeErrSets,
+    IrInstSrcIdLoadPtr,
+    IrInstSrcIdStorePtr,
+    IrInstSrcIdFieldPtr,
+    IrInstSrcIdElemPtr,
+    IrInstSrcIdVarPtr,
+    IrInstSrcIdCall,
+    IrInstSrcIdCallArgs,
+    IrInstSrcIdCallExtra,
+    IrInstSrcIdConst,
+    IrInstSrcIdReturn,
+    IrInstSrcIdContainerInitList,
+    IrInstSrcIdContainerInitFields,
+    IrInstSrcIdUnreachable,
+    IrInstSrcIdTypeOf,
+    IrInstSrcIdSetCold,
+    IrInstSrcIdSetRuntimeSafety,
+    IrInstSrcIdSetFloatMode,
+    IrInstSrcIdArrayType,
+    IrInstSrcIdAnyFrameType,
+    IrInstSrcIdSliceType,
+    IrInstSrcIdAsm,
+    IrInstSrcIdSizeOf,
+    IrInstSrcIdTestNonNull,
+    IrInstSrcIdOptionalUnwrapPtr,
+    IrInstSrcIdClz,
+    IrInstSrcIdCtz,
+    IrInstSrcIdPopCount,
+    IrInstSrcIdBswap,
+    IrInstSrcIdBitReverse,
+    IrInstSrcIdImport,
+    IrInstSrcIdCImport,
+    IrInstSrcIdCInclude,
+    IrInstSrcIdCDefine,
+    IrInstSrcIdCUndef,
+    IrInstSrcIdRef,
+    IrInstSrcIdCompileErr,
+    IrInstSrcIdCompileLog,
+    IrInstSrcIdErrName,
+    IrInstSrcIdEmbedFile,
+    IrInstSrcIdCmpxchg,
+    IrInstSrcIdFence,
+    IrInstSrcIdTruncate,
+    IrInstSrcIdIntCast,
+    IrInstSrcIdFloatCast,
+    IrInstSrcIdIntToFloat,
+    IrInstSrcIdFloatToInt,
+    IrInstSrcIdBoolToInt,
+    IrInstSrcIdIntType,
+    IrInstSrcIdVectorType,
+    IrInstSrcIdShuffleVector,
+    IrInstSrcIdSplat,
+    IrInstSrcIdBoolNot,
+    IrInstSrcIdMemset,
+    IrInstSrcIdMemcpy,
+    IrInstSrcIdSlice,
+    IrInstSrcIdMemberCount,
+    IrInstSrcIdMemberType,
+    IrInstSrcIdMemberName,
+    IrInstSrcIdBreakpoint,
+    IrInstSrcIdReturnAddress,
+    IrInstSrcIdFrameAddress,
+    IrInstSrcIdFrameHandle,
+    IrInstSrcIdFrameType,
+    IrInstSrcIdFrameSize,
+    IrInstSrcIdAlignOf,
+    IrInstSrcIdOverflowOp,
+    IrInstSrcIdTestErr,
+    IrInstSrcIdMulAdd,
+    IrInstSrcIdFloatOp,
+    IrInstSrcIdUnwrapErrCode,
+    IrInstSrcIdUnwrapErrPayload,
+    IrInstSrcIdFnProto,
+    IrInstSrcIdTestComptime,
+    IrInstSrcIdPtrCast,
+    IrInstSrcIdBitCast,
+    IrInstSrcIdIntToPtr,
+    IrInstSrcIdPtrToInt,
+    IrInstSrcIdIntToEnum,
+    IrInstSrcIdEnumToInt,
+    IrInstSrcIdIntToErr,
+    IrInstSrcIdErrToInt,
+    IrInstSrcIdCheckSwitchProngs,
+    IrInstSrcIdCheckStatementIsVoid,
+    IrInstSrcIdTypeName,
+    IrInstSrcIdDeclRef,
+    IrInstSrcIdPanic,
+    IrInstSrcIdTagName,
+    IrInstSrcIdTagType,
+    IrInstSrcIdFieldParentPtr,
+    IrInstSrcIdByteOffsetOf,
+    IrInstSrcIdBitOffsetOf,
+    IrInstSrcIdTypeInfo,
+    IrInstSrcIdType,
+    IrInstSrcIdHasField,
+    IrInstSrcIdTypeId,
+    IrInstSrcIdSetEvalBranchQuota,
+    IrInstSrcIdPtrType,
+    IrInstSrcIdAlignCast,
+    IrInstSrcIdImplicitCast,
+    IrInstSrcIdResolveResult,
+    IrInstSrcIdResetResult,
+    IrInstSrcIdOpaqueType,
+    IrInstSrcIdSetAlignStack,
+    IrInstSrcIdArgType,
+    IrInstSrcIdExport,
+    IrInstSrcIdErrorReturnTrace,
+    IrInstSrcIdErrorUnion,
+    IrInstSrcIdAtomicRmw,
+    IrInstSrcIdAtomicLoad,
+    IrInstSrcIdAtomicStore,
+    IrInstSrcIdSaveErrRetAddr,
+    IrInstSrcIdAddImplicitReturnType,
+    IrInstSrcIdErrSetCast,
+    IrInstSrcIdToBytes,
+    IrInstSrcIdFromBytes,
+    IrInstSrcIdCheckRuntimeScope,
+    IrInstSrcIdHasDecl,
+    IrInstSrcIdUndeclaredIdent,
+    IrInstSrcIdAlloca,
+    IrInstSrcIdEndExpr,
+    IrInstSrcIdUnionInitNamedField,
+    IrInstSrcIdSuspendBegin,
+    IrInstSrcIdSuspendFinish,
+    IrInstSrcIdAwait,
+    IrInstSrcIdResume,
+    IrInstSrcIdSpillBegin,
+    IrInstSrcIdSpillEnd,
+};
+
 // ir_render_* functions in codegen.cpp consume Gen instructions and produce LLVM IR.
 // Src instructions do not have type information; Gen instructions do.
-enum IrInstructionId {
-    IrInstructionIdInvalid,
-    IrInstructionIdDeclVarSrc,
-    IrInstructionIdDeclVarGen,
-    IrInstructionIdBr,
-    IrInstructionIdCondBr,
-    IrInstructionIdSwitchBr,
-    IrInstructionIdSwitchVar,
-    IrInstructionIdSwitchElseVar,
-    IrInstructionIdSwitchTarget,
-    IrInstructionIdPhi,
-    IrInstructionIdUnOp,
-    IrInstructionIdBinOp,
-    IrInstructionIdMergeErrSets,
-    IrInstructionIdLoadPtr,
-    IrInstructionIdLoadPtrGen,
-    IrInstructionIdStorePtr,
-    IrInstructionIdVectorStoreElem,
-    IrInstructionIdFieldPtr,
-    IrInstructionIdStructFieldPtr,
-    IrInstructionIdUnionFieldPtr,
-    IrInstructionIdElemPtr,
-    IrInstructionIdVarPtr,
-    IrInstructionIdReturnPtr,
-    IrInstructionIdCallSrc,
-    IrInstructionIdCallSrcArgs,
-    IrInstructionIdCallExtra,
-    IrInstructionIdCallGen,
-    IrInstructionIdConst,
-    IrInstructionIdReturn,
-    IrInstructionIdCast,
-    IrInstructionIdResizeSlice,
-    IrInstructionIdContainerInitList,
-    IrInstructionIdContainerInitFields,
-    IrInstructionIdUnreachable,
-    IrInstructionIdTypeOf,
-    IrInstructionIdSetCold,
-    IrInstructionIdSetRuntimeSafety,
-    IrInstructionIdSetFloatMode,
-    IrInstructionIdArrayType,
-    IrInstructionIdAnyFrameType,
-    IrInstructionIdSliceType,
-    IrInstructionIdAsmSrc,
-    IrInstructionIdAsmGen,
-    IrInstructionIdSizeOf,
-    IrInstructionIdTestNonNull,
-    IrInstructionIdOptionalUnwrapPtr,
-    IrInstructionIdOptionalWrap,
-    IrInstructionIdUnionTag,
-    IrInstructionIdClz,
-    IrInstructionIdCtz,
-    IrInstructionIdPopCount,
-    IrInstructionIdBswap,
-    IrInstructionIdBitReverse,
-    IrInstructionIdImport,
-    IrInstructionIdCImport,
-    IrInstructionIdCInclude,
-    IrInstructionIdCDefine,
-    IrInstructionIdCUndef,
-    IrInstructionIdRef,
-    IrInstructionIdRefGen,
-    IrInstructionIdCompileErr,
-    IrInstructionIdCompileLog,
-    IrInstructionIdErrName,
-    IrInstructionIdEmbedFile,
-    IrInstructionIdCmpxchgSrc,
-    IrInstructionIdCmpxchgGen,
-    IrInstructionIdFence,
-    IrInstructionIdTruncate,
-    IrInstructionIdIntCast,
-    IrInstructionIdFloatCast,
-    IrInstructionIdIntToFloat,
-    IrInstructionIdFloatToInt,
-    IrInstructionIdBoolToInt,
-    IrInstructionIdIntType,
-    IrInstructionIdVectorType,
-    IrInstructionIdShuffleVector,
-    IrInstructionIdSplatSrc,
-    IrInstructionIdSplatGen,
-    IrInstructionIdBoolNot,
-    IrInstructionIdMemset,
-    IrInstructionIdMemcpy,
-    IrInstructionIdSliceSrc,
-    IrInstructionIdSliceGen,
-    IrInstructionIdMemberCount,
-    IrInstructionIdMemberType,
-    IrInstructionIdMemberName,
-    IrInstructionIdBreakpoint,
-    IrInstructionIdReturnAddress,
-    IrInstructionIdFrameAddress,
-    IrInstructionIdFrameHandle,
-    IrInstructionIdFrameType,
-    IrInstructionIdFrameSizeSrc,
-    IrInstructionIdFrameSizeGen,
-    IrInstructionIdAlignOf,
-    IrInstructionIdOverflowOp,
-    IrInstructionIdTestErrSrc,
-    IrInstructionIdTestErrGen,
-    IrInstructionIdMulAdd,
-    IrInstructionIdFloatOp,
-    IrInstructionIdUnwrapErrCode,
-    IrInstructionIdUnwrapErrPayload,
-    IrInstructionIdErrWrapCode,
-    IrInstructionIdErrWrapPayload,
-    IrInstructionIdFnProto,
-    IrInstructionIdTestComptime,
-    IrInstructionIdPtrCastSrc,
-    IrInstructionIdPtrCastGen,
-    IrInstructionIdBitCastSrc,
-    IrInstructionIdBitCastGen,
-    IrInstructionIdWidenOrShorten,
-    IrInstructionIdIntToPtr,
-    IrInstructionIdPtrToInt,
-    IrInstructionIdIntToEnum,
-    IrInstructionIdEnumToInt,
-    IrInstructionIdIntToErr,
-    IrInstructionIdErrToInt,
-    IrInstructionIdCheckSwitchProngs,
-    IrInstructionIdCheckStatementIsVoid,
-    IrInstructionIdTypeName,
-    IrInstructionIdDeclRef,
-    IrInstructionIdPanic,
-    IrInstructionIdTagName,
-    IrInstructionIdTagType,
-    IrInstructionIdFieldParentPtr,
-    IrInstructionIdByteOffsetOf,
-    IrInstructionIdBitOffsetOf,
-    IrInstructionIdTypeInfo,
-    IrInstructionIdType,
-    IrInstructionIdHasField,
-    IrInstructionIdTypeId,
-    IrInstructionIdSetEvalBranchQuota,
-    IrInstructionIdPtrType,
-    IrInstructionIdAlignCast,
-    IrInstructionIdImplicitCast,
-    IrInstructionIdResolveResult,
-    IrInstructionIdResetResult,
-    IrInstructionIdOpaqueType,
-    IrInstructionIdSetAlignStack,
-    IrInstructionIdArgType,
-    IrInstructionIdExport,
-    IrInstructionIdErrorReturnTrace,
-    IrInstructionIdErrorUnion,
-    IrInstructionIdAtomicRmw,
-    IrInstructionIdAtomicLoad,
-    IrInstructionIdAtomicStore,
-    IrInstructionIdSaveErrRetAddr,
-    IrInstructionIdAddImplicitReturnType,
-    IrInstructionIdErrSetCast,
-    IrInstructionIdToBytes,
-    IrInstructionIdFromBytes,
-    IrInstructionIdCheckRuntimeScope,
-    IrInstructionIdVectorToArray,
-    IrInstructionIdArrayToVector,
-    IrInstructionIdAssertZero,
-    IrInstructionIdAssertNonNull,
-    IrInstructionIdHasDecl,
-    IrInstructionIdUndeclaredIdent,
-    IrInstructionIdAllocaSrc,
-    IrInstructionIdAllocaGen,
-    IrInstructionIdEndExpr,
-    IrInstructionIdPtrOfArrayToSlice,
-    IrInstructionIdUnionInitNamedField,
-    IrInstructionIdSuspendBegin,
-    IrInstructionIdSuspendFinish,
-    IrInstructionIdAwaitSrc,
-    IrInstructionIdAwaitGen,
-    IrInstructionIdResume,
-    IrInstructionIdSpillBegin,
-    IrInstructionIdSpillEnd,
-    IrInstructionIdVectorExtractElem,
-};
-
-struct IrInstruction {
-    Scope *scope;
-    AstNode *source_node;
-    LLVMValueRef llvm_value;
-    ZigValue *value;
-    uint32_t debug_id;
+enum IrInstGenId {
+    IrInstGenIdInvalid,
+    IrInstGenIdDeclVar,
+    IrInstGenIdBr,
+    IrInstGenIdCondBr,
+    IrInstGenIdSwitchBr,
+    IrInstGenIdPhi,
+    IrInstGenIdBinaryNot,
+    IrInstGenIdNegation,
+    IrInstGenIdNegationWrapping,
+    IrInstGenIdBinOp,
+    IrInstGenIdLoadPtr,
+    IrInstGenIdStorePtr,
+    IrInstGenIdVectorStoreElem,
+    IrInstGenIdStructFieldPtr,
+    IrInstGenIdUnionFieldPtr,
+    IrInstGenIdElemPtr,
+    IrInstGenIdVarPtr,
+    IrInstGenIdReturnPtr,
+    IrInstGenIdCall,
+    IrInstGenIdReturn,
+    IrInstGenIdCast,
+    IrInstGenIdResizeSlice,
+    IrInstGenIdUnreachable,
+    IrInstGenIdAsm,
+    IrInstGenIdTestNonNull,
+    IrInstGenIdOptionalUnwrapPtr,
+    IrInstGenIdOptionalWrap,
+    IrInstGenIdUnionTag,
+    IrInstGenIdClz,
+    IrInstGenIdCtz,
+    IrInstGenIdPopCount,
+    IrInstGenIdBswap,
+    IrInstGenIdBitReverse,
+    IrInstGenIdRef,
+    IrInstGenIdErrName,
+    IrInstGenIdCmpxchg,
+    IrInstGenIdFence,
+    IrInstGenIdTruncate,
+    IrInstGenIdShuffleVector,
+    IrInstGenIdSplat,
+    IrInstGenIdBoolNot,
+    IrInstGenIdMemset,
+    IrInstGenIdMemcpy,
+    IrInstGenIdSlice,
+    IrInstGenIdBreakpoint,
+    IrInstGenIdReturnAddress,
+    IrInstGenIdFrameAddress,
+    IrInstGenIdFrameHandle,
+    IrInstGenIdFrameSize,
+    IrInstGenIdOverflowOp,
+    IrInstGenIdTestErr,
+    IrInstGenIdMulAdd,
+    IrInstGenIdFloatOp,
+    IrInstGenIdUnwrapErrCode,
+    IrInstGenIdUnwrapErrPayload,
+    IrInstGenIdErrWrapCode,
+    IrInstGenIdErrWrapPayload,
+    IrInstGenIdPtrCast,
+    IrInstGenIdBitCast,
+    IrInstGenIdWidenOrShorten,
+    IrInstGenIdIntToPtr,
+    IrInstGenIdPtrToInt,
+    IrInstGenIdIntToEnum,
+    IrInstGenIdIntToErr,
+    IrInstGenIdErrToInt,
+    IrInstGenIdPanic,
+    IrInstGenIdTagName,
+    IrInstGenIdFieldParentPtr,
+    IrInstGenIdAlignCast,
+    IrInstGenIdErrorReturnTrace,
+    IrInstGenIdAtomicRmw,
+    IrInstGenIdAtomicLoad,
+    IrInstGenIdAtomicStore,
+    IrInstGenIdSaveErrRetAddr,
+    IrInstGenIdVectorToArray,
+    IrInstGenIdArrayToVector,
+    IrInstGenIdAssertZero,
+    IrInstGenIdAssertNonNull,
+    IrInstGenIdPtrOfArrayToSlice,
+    IrInstGenIdSuspendBegin,
+    IrInstGenIdSuspendFinish,
+    IrInstGenIdAwait,
+    IrInstGenIdResume,
+    IrInstGenIdSpillBegin,
+    IrInstGenIdSpillEnd,
+    IrInstGenIdVectorExtractElem,
+    IrInstGenIdAlloca,
+    IrInstGenIdConst,
+};
+
+// Common fields between IrInstSrc and IrInstGen. This allows future passes
+// after pass2 to be added to zig.
+struct IrInst {
     // if ref_count is zero and the instruction has no side effects,
     // the instruction can be omitted in codegen
     uint32_t ref_count;
+    uint32_t debug_id;
+
+    Scope *scope;
+    AstNode *source_node;
+
+    // for debugging purposes, these are useful to call to inspect the instruction
+    void dump();
+    void src();
+};
+
+struct IrInstSrc {
+    IrInst base;
+
+    IrInstSrcId id;
+    // true if this instruction was generated by zig and not from user code
+    // this matters for the "unreachable code" compile error
+    bool is_gen;
+    bool is_noreturn;
+
     // When analyzing IR, instructions that point to this instruction in the "old ir"
     // can find the instruction that corresponds to this value in the "new ir"
     // with this child field.
-    IrInstruction *child;
-    IrBasicBlock *owner_bb;
+    IrInstGen *child;
+    IrBasicBlockSrc *owner_bb;
+
+    // for debugging purposes, these are useful to call to inspect the instruction
+    void dump();
+    void src();
+};
+
+struct IrInstGen {
+    IrInst base;
+
+    IrInstGenId id;
+
+    LLVMValueRef llvm_value;
+    ZigValue *value;
+    IrBasicBlockGen *owner_bb;
     // Nearly any instruction can have to be stored as a local variable before suspending
     // and then loaded after resuming, in case there is an expression with a suspend point
     // in it, such as: x + await y
-    IrInstruction *spill;
-    IrInstructionId id;
-    // true if this instruction was generated by zig and not from user code
-    bool is_gen;
+    IrInstGen *spill;
 
     // for debugging purposes, these are useful to call to inspect the instruction
     void dump();
     void src();
 };
 
-struct IrInstructionDeclVarSrc {
-    IrInstruction base;
+struct IrInstSrcDeclVar {
+    IrInstSrc base;
 
     ZigVar *var;
-    IrInstruction *var_type;
-    IrInstruction *align_value;
-    IrInstruction *ptr;
+    IrInstSrc *var_type;
+    IrInstSrc *align_value;
+    IrInstSrc *ptr;
 };
 
-struct IrInstructionDeclVarGen {
-    IrInstruction base;
+struct IrInstGenDeclVar {
+    IrInstGen base;
 
     ZigVar *var;
-    IrInstruction *var_ptr;
+    IrInstGen *var_ptr;
 };
 
-struct IrInstructionCondBr {
-    IrInstruction base;
+struct IrInstSrcCondBr {
+    IrInstSrc base;
 
-    IrInstruction *condition;
-    IrBasicBlock *then_block;
-    IrBasicBlock *else_block;
-    IrInstruction *is_comptime;
+    IrInstSrc *condition;
+    IrBasicBlockSrc *then_block;
+    IrBasicBlockSrc *else_block;
+    IrInstSrc *is_comptime;
     ResultLoc *result_loc;
 };
 
-struct IrInstructionBr {
-    IrInstruction base;
+struct IrInstGenCondBr {
+    IrInstGen base;
+
+    IrInstGen *condition;
+    IrBasicBlockGen *then_block;
+    IrBasicBlockGen *else_block;
+};
+
+struct IrInstSrcBr {
+    IrInstSrc base;
+
+    IrBasicBlockSrc *dest_block;
+    IrInstSrc *is_comptime;
+};
+
+struct IrInstGenBr {
+    IrInstGen base;
+
+    IrBasicBlockGen *dest_block;
+};
+
+struct IrInstSrcSwitchBrCase {
+    IrInstSrc *value;
+    IrBasicBlockSrc *block;
+};
+
+struct IrInstSrcSwitchBr {
+    IrInstSrc base;
 
-    IrBasicBlock *dest_block;
-    IrInstruction *is_comptime;
+    IrInstSrc *target_value;
+    IrBasicBlockSrc *else_block;
+    size_t case_count;
+    IrInstSrcSwitchBrCase *cases;
+    IrInstSrc *is_comptime;
+    IrInstSrc *switch_prongs_void;
 };
 
-struct IrInstructionSwitchBrCase {
-    IrInstruction *value;
-    IrBasicBlock *block;
+struct IrInstGenSwitchBrCase {
+    IrInstGen *value;
+    IrBasicBlockGen *block;
 };
 
-struct IrInstructionSwitchBr {
-    IrInstruction base;
+struct IrInstGenSwitchBr {
+    IrInstGen base;
 
-    IrInstruction *target_value;
-    IrBasicBlock *else_block;
+    IrInstGen *target_value;
+    IrBasicBlockGen *else_block;
     size_t case_count;
-    IrInstructionSwitchBrCase *cases;
-    IrInstruction *is_comptime;
-    IrInstruction *switch_prongs_void;
+    IrInstGenSwitchBrCase *cases;
 };
 
-struct IrInstructionSwitchVar {
-    IrInstruction base;
+struct IrInstSrcSwitchVar {
+    IrInstSrc base;
 
-    IrInstruction *target_value_ptr;
-    IrInstruction **prongs_ptr;
+    IrInstSrc *target_value_ptr;
+    IrInstSrc **prongs_ptr;
     size_t prongs_len;
 };
 
-struct IrInstructionSwitchElseVar {
-    IrInstruction base;
+struct IrInstSrcSwitchElseVar {
+    IrInstSrc base;
 
-    IrInstruction *target_value_ptr;
-    IrInstructionSwitchBr *switch_br;
+    IrInstSrc *target_value_ptr;
+    IrInstSrcSwitchBr *switch_br;
 };
 
-struct IrInstructionSwitchTarget {
-    IrInstruction base;
+struct IrInstSrcSwitchTarget {
+    IrInstSrc base;
 
-    IrInstruction *target_value_ptr;
+    IrInstSrc *target_value_ptr;
 };
 
-struct IrInstructionPhi {
-    IrInstruction base;
+struct IrInstSrcPhi {
+    IrInstSrc base;
 
     size_t incoming_count;
-    IrBasicBlock **incoming_blocks;
-    IrInstruction **incoming_values;
+    IrBasicBlockSrc **incoming_blocks;
+    IrInstSrc **incoming_values;
     ResultLocPeerParent *peer_parent;
 };
 
+struct IrInstGenPhi {
+    IrInstGen base;
+
+    size_t incoming_count;
+    IrBasicBlockGen **incoming_blocks;
+    IrInstGen **incoming_values;
+};
+
 enum IrUnOp {
     IrUnOpInvalid,
     IrUnOpBinNot,
@@ -2794,15 +2955,30 @@ enum IrUnOp {
     IrUnOpOptional,
 };
 
-struct IrInstructionUnOp {
-    IrInstruction base;
+struct IrInstSrcUnOp {
+    IrInstSrc base;
 
     IrUnOp op_id;
     LVal lval;
-    IrInstruction *value;
+    IrInstSrc *value;
     ResultLoc *result_loc;
 };
 
+struct IrInstGenBinaryNot {
+    IrInstGen base;
+    IrInstGen *operand;
+};
+
+struct IrInstGenNegation {
+    IrInstGen base;
+    IrInstGen *operand;
+};
+
+struct IrInstGenNegationWrapping {
+    IrInstGen base;
+    IrInstGen *operand;
+};
+
 enum IrBinOp {
     IrBinOpInvalid,
     IrBinOpBoolOr,
@@ -2837,113 +3013,144 @@ enum IrBinOp {
     IrBinOpArrayMult,
 };
 
-struct IrInstructionBinOp {
-    IrInstruction base;
+struct IrInstSrcBinOp {
+    IrInstSrc base;
+
+    IrInstSrc *op1;
+    IrInstSrc *op2;
+    IrBinOp op_id;
+    bool safety_check_on;
+};
+
+struct IrInstGenBinOp {
+    IrInstGen base;
 
-    IrInstruction *op1;
-    IrInstruction *op2;
+    IrInstGen *op1;
+    IrInstGen *op2;
     IrBinOp op_id;
     bool safety_check_on;
 };
 
-struct IrInstructionMergeErrSets {
-    IrInstruction base;
+struct IrInstSrcMergeErrSets {
+    IrInstSrc base;
 
-    IrInstruction *op1;
-    IrInstruction *op2;
+    IrInstSrc *op1;
+    IrInstSrc *op2;
     Buf *type_name;
 };
 
-struct IrInstructionLoadPtr {
-    IrInstruction base;
+struct IrInstSrcLoadPtr {
+    IrInstSrc base;
 
-    IrInstruction *ptr;
+    IrInstSrc *ptr;
 };
 
-struct IrInstructionLoadPtrGen {
-    IrInstruction base;
+struct IrInstGenLoadPtr {
+    IrInstGen base;
 
-    IrInstruction *ptr;
-    IrInstruction *result_loc;
+    IrInstGen *ptr;
+    IrInstGen *result_loc;
 };
 
-struct IrInstructionStorePtr {
-    IrInstruction base;
+struct IrInstSrcStorePtr {
+    IrInstSrc base;
+
+    IrInstSrc *ptr;
+    IrInstSrc *value;
 
     bool allow_write_through_const;
-    IrInstruction *ptr;
-    IrInstruction *value;
 };
 
-struct IrInstructionVectorStoreElem {
-    IrInstruction base;
+struct IrInstGenStorePtr {
+    IrInstGen base;
 
-    IrInstruction *vector_ptr;
-    IrInstruction *index;
-    IrInstruction *value;
+    IrInstGen *ptr;
+    IrInstGen *value;
 };
 
-struct IrInstructionFieldPtr {
-    IrInstruction base;
+struct IrInstGenVectorStoreElem {
+    IrInstGen base;
 
-    bool initializing;
-    IrInstruction *container_ptr;
+    IrInstGen *vector_ptr;
+    IrInstGen *index;
+    IrInstGen *value;
+};
+
+struct IrInstSrcFieldPtr {
+    IrInstSrc base;
+
+    IrInstSrc *container_ptr;
     Buf *field_name_buffer;
-    IrInstruction *field_name_expr;
+    IrInstSrc *field_name_expr;
+    bool initializing;
 };
 
-struct IrInstructionStructFieldPtr {
-    IrInstruction base;
+struct IrInstGenStructFieldPtr {
+    IrInstGen base;
 
-    IrInstruction *struct_ptr;
+    IrInstGen *struct_ptr;
     TypeStructField *field;
     bool is_const;
 };
 
-struct IrInstructionUnionFieldPtr {
-    IrInstruction base;
+struct IrInstGenUnionFieldPtr {
+    IrInstGen base;
 
+    IrInstGen *union_ptr;
+    TypeUnionField *field;
     bool safety_check_on;
     bool initializing;
-    IrInstruction *union_ptr;
-    TypeUnionField *field;
 };
 
-struct IrInstructionElemPtr {
-    IrInstruction base;
+struct IrInstSrcElemPtr {
+    IrInstSrc base;
 
-    IrInstruction *array_ptr;
-    IrInstruction *elem_index;
+    IrInstSrc *array_ptr;
+    IrInstSrc *elem_index;
     AstNode *init_array_type_source_node;
     PtrLen ptr_len;
     bool safety_check_on;
 };
 
-struct IrInstructionVarPtr {
-    IrInstruction base;
+struct IrInstGenElemPtr {
+    IrInstGen base;
+
+    IrInstGen *array_ptr;
+    IrInstGen *elem_index;
+    bool safety_check_on;
+};
+
+struct IrInstSrcVarPtr {
+    IrInstSrc base;
 
     ZigVar *var;
     ScopeFnDef *crossed_fndef_scope;
 };
 
+struct IrInstGenVarPtr {
+    IrInstGen base;
+
+    ZigVar *var;
+};
+
 // For functions that have a return type for which handle_is_ptr is true, a
 // result location pointer is the secret first parameter ("sret"). This
 // instruction returns that pointer.
-struct IrInstructionReturnPtr {
-    IrInstruction base;
+struct IrInstGenReturnPtr {
+    IrInstGen base;
 };
 
-struct IrInstructionCallSrc {
-    IrInstruction base;
+struct IrInstSrcCall {
+    IrInstSrc base;
 
-    IrInstruction *fn_ref;
+    IrInstSrc *fn_ref;
     ZigFn *fn_entry;
     size_t arg_count;
-    IrInstruction **args;
-    IrInstruction *ret_ptr;
+    IrInstSrc **args;
+    IrInstSrc *ret_ptr;
     ResultLoc *result_loc;
 
-    IrInstruction *new_stack;
+    IrInstSrc *new_stack;
 
     CallModifier modifier;
     bool is_async_call_builtin;
@@ -2951,12 +3158,12 @@ struct IrInstructionCallSrc {
 
 // This is a pass1 instruction, used by @call when the args node is
 // a tuple or struct literal.
-struct IrInstructionCallSrcArgs {
-    IrInstruction base;
+struct IrInstSrcCallArgs {
+    IrInstSrc base;
 
-    IrInstruction *options;
-    IrInstruction *fn_ref;
-    IrInstruction **args_ptr;
+    IrInstSrc *options;
+    IrInstSrc *fn_ref;
+    IrInstSrc **args_ptr;
     size_t args_len;
     ResultLoc *result_loc;
 };
@@ -2964,42 +3171,54 @@ struct IrInstructionCallSrcArgs {
 // This is a pass1 instruction, used by @call, when the args node
 // is not a literal.
 // `args` is expected to be either a struct or a tuple.
-struct IrInstructionCallExtra {
-    IrInstruction base;
+struct IrInstSrcCallExtra {
+    IrInstSrc base;
 
-    IrInstruction *options;
-    IrInstruction *fn_ref;
-    IrInstruction *args;
+    IrInstSrc *options;
+    IrInstSrc *fn_ref;
+    IrInstSrc *args;
     ResultLoc *result_loc;
 };
 
-struct IrInstructionCallGen {
-    IrInstruction base;
+struct IrInstGenCall {
+    IrInstGen base;
 
-    IrInstruction *fn_ref;
+    IrInstGen *fn_ref;
     ZigFn *fn_entry;
     size_t arg_count;
-    IrInstruction **args;
-    IrInstruction *result_loc;
-    IrInstruction *frame_result_loc;
-    IrInstruction *new_stack;
+    IrInstGen **args;
+    IrInstGen *result_loc;
+    IrInstGen *frame_result_loc;
+    IrInstGen *new_stack;
 
     CallModifier modifier;
 
     bool is_async_call_builtin;
 };
 
-struct IrInstructionConst {
-    IrInstruction base;
+struct IrInstSrcConst {
+    IrInstSrc base;
+
+    ZigValue *value;
+};
+
+struct IrInstGenConst {
+    IrInstGen base;
+};
+
+struct IrInstSrcReturn {
+    IrInstSrc base;
+
+    IrInstSrc *operand;
 };
 
 // When an IrExecutable is not in a function, a return instruction means that
 // the expression returns with that value, even though a return statement from
 // an AST perspective is invalid.
-struct IrInstructionReturn {
-    IrInstruction base;
+struct IrInstGenReturn {
+    IrInstGen base;
 
-    IrInstruction *operand;
+    IrInstGen *operand;
 };
 
 enum CastOp {
@@ -3014,89 +3233,92 @@ enum CastOp {
 };
 
 // TODO get rid of this instruction, replace with instructions for each op code
-struct IrInstructionCast {
-    IrInstruction base;
+struct IrInstGenCast {
+    IrInstGen base;
 
-    IrInstruction *value;
-    ZigType *dest_type;
+    IrInstGen *value;
     CastOp cast_op;
 };
 
-struct IrInstructionResizeSlice {
-    IrInstruction base;
+struct IrInstGenResizeSlice {
+    IrInstGen base;
 
-    IrInstruction *operand;
-    IrInstruction *result_loc;
+    IrInstGen *operand;
+    IrInstGen *result_loc;
 };
 
-struct IrInstructionContainerInitList {
-    IrInstruction base;
+struct IrInstSrcContainerInitList {
+    IrInstSrc base;
 
-    IrInstruction *elem_type;
+    IrInstSrc *elem_type;
     size_t item_count;
-    IrInstruction **elem_result_loc_list;
-    IrInstruction *result_loc;
+    IrInstSrc **elem_result_loc_list;
+    IrInstSrc *result_loc;
     AstNode *init_array_type_source_node;
 };
 
-struct IrInstructionContainerInitFieldsField {
+struct IrInstSrcContainerInitFieldsField {
     Buf *name;
     AstNode *source_node;
     TypeStructField *type_struct_field;
-    IrInstruction *result_loc;
+    IrInstSrc *result_loc;
 };
 
-struct IrInstructionContainerInitFields {
-    IrInstruction base;
+struct IrInstSrcContainerInitFields {
+    IrInstSrc base;
 
     size_t field_count;
-    IrInstructionContainerInitFieldsField *fields;
-    IrInstruction *result_loc;
+    IrInstSrcContainerInitFieldsField *fields;
+    IrInstSrc *result_loc;
+};
+
+struct IrInstSrcUnreachable {
+    IrInstSrc base;
 };
 
-struct IrInstructionUnreachable {
-    IrInstruction base;
+struct IrInstGenUnreachable {
+    IrInstGen base;
 };
 
-struct IrInstructionTypeOf {
-    IrInstruction base;
+struct IrInstSrcTypeOf {
+    IrInstSrc base;
 
-    IrInstruction *value;
+    IrInstSrc *value;
 };
 
-struct IrInstructionSetCold {
-    IrInstruction base;
+struct IrInstSrcSetCold {
+    IrInstSrc base;
 
-    IrInstruction *is_cold;
+    IrInstSrc *is_cold;
 };
 
-struct IrInstructionSetRuntimeSafety {
-    IrInstruction base;
+struct IrInstSrcSetRuntimeSafety {
+    IrInstSrc base;
 
-    IrInstruction *safety_on;
+    IrInstSrc *safety_on;
 };
 
-struct IrInstructionSetFloatMode {
-    IrInstruction base;
+struct IrInstSrcSetFloatMode {
+    IrInstSrc base;
 
-    IrInstruction *scope_value;
-    IrInstruction *mode_value;
+    IrInstSrc *scope_value;
+    IrInstSrc *mode_value;
 };
 
-struct IrInstructionArrayType {
-    IrInstruction base;
+struct IrInstSrcArrayType {
+    IrInstSrc base;
 
-    IrInstruction *size;
-    IrInstruction *sentinel;
-    IrInstruction *child_type;
+    IrInstSrc *size;
+    IrInstSrc *sentinel;
+    IrInstSrc *child_type;
 };
 
-struct IrInstructionPtrType {
-    IrInstruction base;
+struct IrInstSrcPtrType {
+    IrInstSrc base;
 
-    IrInstruction *sentinel;
-    IrInstruction *align_value;
-    IrInstruction *child_type;
+    IrInstSrc *sentinel;
+    IrInstSrc *align_value;
+    IrInstSrc *child_type;
     uint32_t bit_offset_start;
     uint32_t host_int_bytes;
     PtrLen ptr_len;
@@ -3105,375 +3327,459 @@ struct IrInstructionPtrType {
     bool is_allow_zero;
 };
 
-struct IrInstructionAnyFrameType {
-    IrInstruction base;
+struct IrInstSrcAnyFrameType {
+    IrInstSrc base;
 
-    IrInstruction *payload_type;
+    IrInstSrc *payload_type;
 };
 
-struct IrInstructionSliceType {
-    IrInstruction base;
+struct IrInstSrcSliceType {
+    IrInstSrc base;
 
-    IrInstruction *sentinel;
-    IrInstruction *align_value;
-    IrInstruction *child_type;
+    IrInstSrc *sentinel;
+    IrInstSrc *align_value;
+    IrInstSrc *child_type;
     bool is_const;
     bool is_volatile;
     bool is_allow_zero;
 };
 
-struct IrInstructionAsmSrc {
-    IrInstruction base;
+struct IrInstSrcAsm {
+    IrInstSrc base;
 
-    IrInstruction *asm_template;
-    IrInstruction **input_list;
-    IrInstruction **output_types;
+    IrInstSrc *asm_template;
+    IrInstSrc **input_list;
+    IrInstSrc **output_types;
     ZigVar **output_vars;
     size_t return_count;
     bool has_side_effects;
     bool is_global;
 };
 
-struct IrInstructionAsmGen {
-    IrInstruction base;
+struct IrInstGenAsm {
+    IrInstGen base;
 
     Buf *asm_template;
     AsmToken *token_list;
     size_t token_list_len;
-    IrInstruction **input_list;
-    IrInstruction **output_types;
+    IrInstGen **input_list;
+    IrInstGen **output_types;
     ZigVar **output_vars;
     size_t return_count;
     bool has_side_effects;
 };
 
-struct IrInstructionSizeOf {
-    IrInstruction base;
+struct IrInstSrcSizeOf {
+    IrInstSrc base;
 
+    IrInstSrc *type_value;
     bool bit_size;
-    IrInstruction *type_value;
 };
 
 // returns true if nonnull, returns false if null
-// this is so that `zeroes` sets maybe values to null
-struct IrInstructionTestNonNull {
-    IrInstruction base;
+struct IrInstSrcTestNonNull {
+    IrInstSrc base;
+
+    IrInstSrc *value;
+};
+
+struct IrInstGenTestNonNull {
+    IrInstGen base;
 
-    IrInstruction *value;
+    IrInstGen *value;
 };
 
 // Takes a pointer to an optional value, returns a pointer
 // to the payload.
-struct IrInstructionOptionalUnwrapPtr {
-    IrInstruction base;
+struct IrInstSrcOptionalUnwrapPtr {
+    IrInstSrc base;
+
+    IrInstSrc *base_ptr;
+    bool safety_check_on;
+    bool initializing;
+};
 
+struct IrInstGenOptionalUnwrapPtr {
+    IrInstGen base;
+
+    IrInstGen *base_ptr;
     bool safety_check_on;
     bool initializing;
-    IrInstruction *base_ptr;
 };
 
-struct IrInstructionCtz {
-    IrInstruction base;
+struct IrInstSrcCtz {
+    IrInstSrc base;
+
+    IrInstSrc *type;
+    IrInstSrc *op;
+};
+
+struct IrInstGenCtz {
+    IrInstGen base;
+
+    IrInstGen *op;
+};
+
+struct IrInstSrcClz {
+    IrInstSrc base;
+
+    IrInstSrc *type;
+    IrInstSrc *op;
+};
+
+struct IrInstGenClz {
+    IrInstGen base;
 
-    IrInstruction *type;
-    IrInstruction *op;
+    IrInstGen *op;
 };
 
-struct IrInstructionClz {
-    IrInstruction base;
+struct IrInstSrcPopCount {
+    IrInstSrc base;
 
-    IrInstruction *type;
-    IrInstruction *op;
+    IrInstSrc *type;
+    IrInstSrc *op;
 };
 
-struct IrInstructionPopCount {
-    IrInstruction base;
+struct IrInstGenPopCount {
+    IrInstGen base;
 
-    IrInstruction *type;
-    IrInstruction *op;
+    IrInstGen *op;
 };
 
-struct IrInstructionUnionTag {
-    IrInstruction base;
+struct IrInstGenUnionTag {
+    IrInstGen base;
 
-    IrInstruction *value;
+    IrInstGen *value;
 };
 
-struct IrInstructionImport {
-    IrInstruction base;
+struct IrInstSrcImport {
+    IrInstSrc base;
 
-    IrInstruction *name;
+    IrInstSrc *name;
 };
 
-struct IrInstructionRef {
-    IrInstruction base;
+struct IrInstSrcRef {
+    IrInstSrc base;
 
-    IrInstruction *value;
+    IrInstSrc *value;
     bool is_const;
     bool is_volatile;
 };
 
-struct IrInstructionRefGen {
-    IrInstruction base;
+struct IrInstGenRef {
+    IrInstGen base;
 
-    IrInstruction *operand;
-    IrInstruction *result_loc;
+    IrInstGen *operand;
+    IrInstGen *result_loc;
 };
 
-struct IrInstructionCompileErr {
-    IrInstruction base;
+struct IrInstSrcCompileErr {
+    IrInstSrc base;
 
-    IrInstruction *msg;
+    IrInstSrc *msg;
 };
 
-struct IrInstructionCompileLog {
-    IrInstruction base;
+struct IrInstSrcCompileLog {
+    IrInstSrc base;
 
     size_t msg_count;
-    IrInstruction **msg_list;
+    IrInstSrc **msg_list;
 };
 
-struct IrInstructionErrName {
-    IrInstruction base;
+struct IrInstSrcErrName {
+    IrInstSrc base;
 
-    IrInstruction *value;
+    IrInstSrc *value;
 };
 
-struct IrInstructionCImport {
-    IrInstruction base;
+struct IrInstGenErrName {
+    IrInstGen base;
+
+    IrInstGen *value;
+};
+
+struct IrInstSrcCImport {
+    IrInstSrc base;
 };
 
-struct IrInstructionCInclude {
-    IrInstruction base;
+struct IrInstSrcCInclude {
+    IrInstSrc base;
 
-    IrInstruction *name;
+    IrInstSrc *name;
 };
 
-struct IrInstructionCDefine {
-    IrInstruction base;
+struct IrInstSrcCDefine {
+    IrInstSrc base;
 
-    IrInstruction *name;
-    IrInstruction *value;
+    IrInstSrc *name;
+    IrInstSrc *value;
 };
 
-struct IrInstructionCUndef {
-    IrInstruction base;
+struct IrInstSrcCUndef {
+    IrInstSrc base;
 
-    IrInstruction *name;
+    IrInstSrc *name;
 };
 
-struct IrInstructionEmbedFile {
-    IrInstruction base;
+struct IrInstSrcEmbedFile {
+    IrInstSrc base;
 
-    IrInstruction *name;
+    IrInstSrc *name;
 };
 
-struct IrInstructionCmpxchgSrc {
-    IrInstruction base;
+struct IrInstSrcCmpxchg {
+    IrInstSrc base;
 
     bool is_weak;
-    IrInstruction *type_value;
-    IrInstruction *ptr;
-    IrInstruction *cmp_value;
-    IrInstruction *new_value;
-    IrInstruction *success_order_value;
-    IrInstruction *failure_order_value;
+    IrInstSrc *type_value;
+    IrInstSrc *ptr;
+    IrInstSrc *cmp_value;
+    IrInstSrc *new_value;
+    IrInstSrc *success_order_value;
+    IrInstSrc *failure_order_value;
     ResultLoc *result_loc;
 };
 
-struct IrInstructionCmpxchgGen {
-    IrInstruction base;
+struct IrInstGenCmpxchg {
+    IrInstGen base;
 
-    bool is_weak;
     AtomicOrder success_order;
     AtomicOrder failure_order;
-    IrInstruction *ptr;
-    IrInstruction *cmp_value;
-    IrInstruction *new_value;
-    IrInstruction *result_loc;
+    IrInstGen *ptr;
+    IrInstGen *cmp_value;
+    IrInstGen *new_value;
+    IrInstGen *result_loc;
+    bool is_weak;
 };
 
-struct IrInstructionFence {
-    IrInstruction base;
+struct IrInstSrcFence {
+    IrInstSrc base;
+
+    IrInstSrc *order;
+};
 
-    IrInstruction *order_value;
+struct IrInstGenFence {
+    IrInstGen base;
 
-    // if this instruction gets to runtime then we know these values:
     AtomicOrder order;
 };
 
-struct IrInstructionTruncate {
-    IrInstruction base;
+struct IrInstSrcTruncate {
+    IrInstSrc base;
+
+    IrInstSrc *dest_type;
+    IrInstSrc *target;
+};
+
+struct IrInstGenTruncate {
+    IrInstGen base;
 
-    IrInstruction *dest_type;
-    IrInstruction *target;
+    IrInstGen *target;
 };
 
-struct IrInstructionIntCast {
-    IrInstruction base;
+struct IrInstSrcIntCast {
+    IrInstSrc base;
 
-    IrInstruction *dest_type;
-    IrInstruction *target;
+    IrInstSrc *dest_type;
+    IrInstSrc *target;
 };
 
-struct IrInstructionFloatCast {
-    IrInstruction base;
+struct IrInstSrcFloatCast {
+    IrInstSrc base;
 
-    IrInstruction *dest_type;
-    IrInstruction *target;
+    IrInstSrc *dest_type;
+    IrInstSrc *target;
 };
 
-struct IrInstructionErrSetCast {
-    IrInstruction base;
+struct IrInstSrcErrSetCast {
+    IrInstSrc base;
 
-    IrInstruction *dest_type;
-    IrInstruction *target;
+    IrInstSrc *dest_type;
+    IrInstSrc *target;
 };
 
-struct IrInstructionToBytes {
-    IrInstruction base;
+struct IrInstSrcToBytes {
+    IrInstSrc base;
 
-    IrInstruction *target;
+    IrInstSrc *target;
     ResultLoc *result_loc;
 };
 
-struct IrInstructionFromBytes {
-    IrInstruction base;
+struct IrInstSrcFromBytes {
+    IrInstSrc base;
 
-    IrInstruction *dest_child_type;
-    IrInstruction *target;
+    IrInstSrc *dest_child_type;
+    IrInstSrc *target;
     ResultLoc *result_loc;
 };
 
-struct IrInstructionIntToFloat {
-    IrInstruction base;
+struct IrInstSrcIntToFloat {
+    IrInstSrc base;
 
-    IrInstruction *dest_type;
-    IrInstruction *target;
+    IrInstSrc *dest_type;
+    IrInstSrc *target;
 };
 
-struct IrInstructionFloatToInt {
-    IrInstruction base;
+struct IrInstSrcFloatToInt {
+    IrInstSrc base;
 
-    IrInstruction *dest_type;
-    IrInstruction *target;
+    IrInstSrc *dest_type;
+    IrInstSrc *target;
 };
 
-struct IrInstructionBoolToInt {
-    IrInstruction base;
+struct IrInstSrcBoolToInt {
+    IrInstSrc base;
 
-    IrInstruction *target;
+    IrInstSrc *target;
 };
 
-struct IrInstructionIntType {
-    IrInstruction base;
+struct IrInstSrcIntType {
+    IrInstSrc base;
 
-    IrInstruction *is_signed;
-    IrInstruction *bit_count;
+    IrInstSrc *is_signed;
+    IrInstSrc *bit_count;
 };
 
-struct IrInstructionVectorType {
-    IrInstruction base;
+struct IrInstSrcVectorType {
+    IrInstSrc base;
 
-    IrInstruction *len;
-    IrInstruction *elem_type;
+    IrInstSrc *len;
+    IrInstSrc *elem_type;
 };
 
-struct IrInstructionBoolNot {
-    IrInstruction base;
+struct IrInstSrcBoolNot {
+    IrInstSrc base;
 
-    IrInstruction *value;
+    IrInstSrc *value;
 };
 
-struct IrInstructionMemset {
-    IrInstruction base;
+struct IrInstGenBoolNot {
+    IrInstGen base;
 
-    IrInstruction *dest_ptr;
-    IrInstruction *byte;
-    IrInstruction *count;
+    IrInstGen *value;
 };
 
-struct IrInstructionMemcpy {
-    IrInstruction base;
+struct IrInstSrcMemset {
+    IrInstSrc base;
 
-    IrInstruction *dest_ptr;
-    IrInstruction *src_ptr;
-    IrInstruction *count;
+    IrInstSrc *dest_ptr;
+    IrInstSrc *byte;
+    IrInstSrc *count;
 };
 
-struct IrInstructionSliceSrc {
-    IrInstruction base;
+struct IrInstGenMemset {
+    IrInstGen base;
 
-    bool safety_check_on;
-    IrInstruction *ptr;
-    IrInstruction *start;
-    IrInstruction *end;
-    IrInstruction *sentinel;
+    IrInstGen *dest_ptr;
+    IrInstGen *byte;
+    IrInstGen *count;
+};
+
+struct IrInstSrcMemcpy {
+    IrInstSrc base;
+
+    IrInstSrc *dest_ptr;
+    IrInstSrc *src_ptr;
+    IrInstSrc *count;
+};
+
+struct IrInstGenMemcpy {
+    IrInstGen base;
+
+    IrInstGen *dest_ptr;
+    IrInstGen *src_ptr;
+    IrInstGen *count;
+};
+
+struct IrInstSrcSlice {
+    IrInstSrc base;
+
+    IrInstSrc *ptr;
+    IrInstSrc *start;
+    IrInstSrc *end;
+    IrInstSrc *sentinel;
     ResultLoc *result_loc;
+    bool safety_check_on;
 };
 
-struct IrInstructionSliceGen {
-    IrInstruction base;
+struct IrInstGenSlice {
+    IrInstGen base;
 
+    IrInstGen *ptr;
+    IrInstGen *start;
+    IrInstGen *end;
+    IrInstGen *result_loc;
     bool safety_check_on;
-    IrInstruction *ptr;
-    IrInstruction *start;
-    IrInstruction *end;
-    IrInstruction *result_loc;
 };
 
-struct IrInstructionMemberCount {
-    IrInstruction base;
+struct IrInstSrcMemberCount {
+    IrInstSrc base;
+
+    IrInstSrc *container;
+};
+
+struct IrInstSrcMemberType {
+    IrInstSrc base;
 
-    IrInstruction *container;
+    IrInstSrc *container_type;
+    IrInstSrc *member_index;
 };
 
-struct IrInstructionMemberType {
-    IrInstruction base;
+struct IrInstSrcMemberName {
+    IrInstSrc base;
+
+    IrInstSrc *container_type;
+    IrInstSrc *member_index;
+};
+
+struct IrInstSrcBreakpoint {
+    IrInstSrc base;
+};
 
-    IrInstruction *container_type;
-    IrInstruction *member_index;
+struct IrInstGenBreakpoint {
+    IrInstGen base;
 };
 
-struct IrInstructionMemberName {
-    IrInstruction base;
+struct IrInstSrcReturnAddress {
+    IrInstSrc base;
+};
 
-    IrInstruction *container_type;
-    IrInstruction *member_index;
+struct IrInstGenReturnAddress {
+    IrInstGen base;
 };
 
-struct IrInstructionBreakpoint {
-    IrInstruction base;
+struct IrInstSrcFrameAddress {
+    IrInstSrc base;
 };
 
-struct IrInstructionReturnAddress {
-    IrInstruction base;
+struct IrInstGenFrameAddress {
+    IrInstGen base;
 };
 
-struct IrInstructionFrameAddress {
-    IrInstruction base;
+struct IrInstSrcFrameHandle {
+    IrInstSrc base;
 };
 
-struct IrInstructionFrameHandle {
-    IrInstruction base;
+struct IrInstGenFrameHandle {
+    IrInstGen base;
 };
 
-struct IrInstructionFrameType {
-    IrInstruction base;
+struct IrInstSrcFrameType {
+    IrInstSrc base;
 
-    IrInstruction *fn;
+    IrInstSrc *fn;
 };
 
-struct IrInstructionFrameSizeSrc {
-    IrInstruction base;
+struct IrInstSrcFrameSize {
+    IrInstSrc base;
 
-    IrInstruction *fn;
+    IrInstSrc *fn;
 };
 
-struct IrInstructionFrameSizeGen {
-    IrInstruction base;
+struct IrInstGenFrameSize {
+    IrInstGen base;
 
-    IrInstruction *fn;
+    IrInstGen *fn;
 };
 
 enum IrOverflowOp {
@@ -3483,560 +3789,713 @@ enum IrOverflowOp {
     IrOverflowOpShl,
 };
 
-struct IrInstructionOverflowOp {
-    IrInstruction base;
+struct IrInstSrcOverflowOp {
+    IrInstSrc base;
+
+    IrOverflowOp op;
+    IrInstSrc *type_value;
+    IrInstSrc *op1;
+    IrInstSrc *op2;
+    IrInstSrc *result_ptr;
+};
+
+struct IrInstGenOverflowOp {
+    IrInstGen base;
 
     IrOverflowOp op;
-    IrInstruction *type_value;
-    IrInstruction *op1;
-    IrInstruction *op2;
-    IrInstruction *result_ptr;
+    IrInstGen *op1;
+    IrInstGen *op2;
+    IrInstGen *result_ptr;
 
+    // TODO can this field be removed?
     ZigType *result_ptr_type;
 };
 
-struct IrInstructionMulAdd {
-    IrInstruction base;
+struct IrInstSrcMulAdd {
+    IrInstSrc base;
+
+    IrInstSrc *type_value;
+    IrInstSrc *op1;
+    IrInstSrc *op2;
+    IrInstSrc *op3;
+};
+
+struct IrInstGenMulAdd {
+    IrInstGen base;
 
-    IrInstruction *type_value;
-    IrInstruction *op1;
-    IrInstruction *op2;
-    IrInstruction *op3;
+    IrInstGen *op1;
+    IrInstGen *op2;
+    IrInstGen *op3;
 };
 
-struct IrInstructionAlignOf {
-    IrInstruction base;
+struct IrInstSrcAlignOf {
+    IrInstSrc base;
 
-    IrInstruction *type_value;
+    IrInstSrc *type_value;
 };
 
 // returns true if error, returns false if not error
-struct IrInstructionTestErrSrc {
-    IrInstruction base;
+struct IrInstSrcTestErr {
+    IrInstSrc base;
 
+    IrInstSrc *base_ptr;
     bool resolve_err_set;
     bool base_ptr_is_payload;
-    IrInstruction *base_ptr;
 };
 
-struct IrInstructionTestErrGen {
-    IrInstruction base;
+struct IrInstGenTestErr {
+    IrInstGen base;
 
-    IrInstruction *err_union;
+    IrInstGen *err_union;
 };
 
 // Takes an error union pointer, returns a pointer to the error code.
-struct IrInstructionUnwrapErrCode {
-    IrInstruction base;
+struct IrInstSrcUnwrapErrCode {
+    IrInstSrc base;
 
+    IrInstSrc *err_union_ptr;
     bool initializing;
-    IrInstruction *err_union_ptr;
 };
 
-struct IrInstructionUnwrapErrPayload {
-    IrInstruction base;
+struct IrInstGenUnwrapErrCode {
+    IrInstGen base;
 
+    IrInstGen *err_union_ptr;
+    bool initializing;
+};
+
+struct IrInstSrcUnwrapErrPayload {
+    IrInstSrc base;
+
+    IrInstSrc *value;
+    bool safety_check_on;
+    bool initializing;
+};
+
+struct IrInstGenUnwrapErrPayload {
+    IrInstGen base;
+
+    IrInstGen *value;
     bool safety_check_on;
     bool initializing;
-    IrInstruction *value;
 };
 
-struct IrInstructionOptionalWrap {
-    IrInstruction base;
+struct IrInstGenOptionalWrap {
+    IrInstGen base;
 
-    IrInstruction *operand;
-    IrInstruction *result_loc;
+    IrInstGen *operand;
+    IrInstGen *result_loc;
 };
 
-struct IrInstructionErrWrapPayload {
-    IrInstruction base;
+struct IrInstGenErrWrapPayload {
+    IrInstGen base;
 
-    IrInstruction *operand;
-    IrInstruction *result_loc;
+    IrInstGen *operand;
+    IrInstGen *result_loc;
 };
 
-struct IrInstructionErrWrapCode {
-    IrInstruction base;
+struct IrInstGenErrWrapCode {
+    IrInstGen base;
 
-    IrInstruction *operand;
-    IrInstruction *result_loc;
+    IrInstGen *operand;
+    IrInstGen *result_loc;
 };
 
-struct IrInstructionFnProto {
-    IrInstruction base;
+struct IrInstSrcFnProto {
+    IrInstSrc base;
 
-    IrInstruction **param_types;
-    IrInstruction *align_value;
-    IrInstruction *callconv_value;
-    IrInstruction *return_type;
+    IrInstSrc **param_types;
+    IrInstSrc *align_value;
+    IrInstSrc *callconv_value;
+    IrInstSrc *return_type;
     bool is_var_args;
 };
 
 // true if the target value is compile time known, false otherwise
-struct IrInstructionTestComptime {
-    IrInstruction base;
+struct IrInstSrcTestComptime {
+    IrInstSrc base;
 
-    IrInstruction *value;
+    IrInstSrc *value;
 };
 
-struct IrInstructionPtrCastSrc {
-    IrInstruction base;
+struct IrInstSrcPtrCast {
+    IrInstSrc base;
 
-    IrInstruction *dest_type;
-    IrInstruction *ptr;
+    IrInstSrc *dest_type;
+    IrInstSrc *ptr;
     bool safety_check_on;
 };
 
-struct IrInstructionPtrCastGen {
-    IrInstruction base;
+struct IrInstGenPtrCast {
+    IrInstGen base;
 
-    IrInstruction *ptr;
+    IrInstGen *ptr;
     bool safety_check_on;
 };
 
-struct IrInstructionImplicitCast {
-    IrInstruction base;
+struct IrInstSrcImplicitCast {
+    IrInstSrc base;
 
-    IrInstruction *operand;
+    IrInstSrc *operand;
     ResultLocCast *result_loc_cast;
 };
 
-struct IrInstructionBitCastSrc {
-    IrInstruction base;
+struct IrInstSrcBitCast {
+    IrInstSrc base;
 
-    IrInstruction *operand;
+    IrInstSrc *operand;
     ResultLocBitCast *result_loc_bit_cast;
 };
 
-struct IrInstructionBitCastGen {
-    IrInstruction base;
+struct IrInstGenBitCast {
+    IrInstGen base;
+
+    IrInstGen *operand;
+};
+
+struct IrInstGenWidenOrShorten {
+    IrInstGen base;
+
+    IrInstGen *target;
+};
+
+struct IrInstSrcPtrToInt {
+    IrInstSrc base;
+
+    IrInstSrc *target;
+};
+
+struct IrInstGenPtrToInt {
+    IrInstGen base;
+
+    IrInstGen *target;
+};
+
+struct IrInstSrcIntToPtr {
+    IrInstSrc base;
+
+    IrInstSrc *dest_type;
+    IrInstSrc *target;
+};
+
+struct IrInstGenIntToPtr {
+    IrInstGen base;
 
-    IrInstruction *operand;
+    IrInstGen *target;
 };
 
-struct IrInstructionWidenOrShorten {
-    IrInstruction base;
+struct IrInstSrcIntToEnum {
+    IrInstSrc base;
 
-    IrInstruction *target;
+    IrInstSrc *dest_type;
+    IrInstSrc *target;
 };
 
-struct IrInstructionPtrToInt {
-    IrInstruction base;
+struct IrInstGenIntToEnum {
+    IrInstGen base;
 
-    IrInstruction *target;
+    IrInstGen *target;
 };
 
-struct IrInstructionIntToPtr {
-    IrInstruction base;
+struct IrInstSrcEnumToInt {
+    IrInstSrc base;
 
-    IrInstruction *dest_type;
-    IrInstruction *target;
+    IrInstSrc *target;
 };
 
-struct IrInstructionIntToEnum {
-    IrInstruction base;
+struct IrInstSrcIntToErr {
+    IrInstSrc base;
 
-    IrInstruction *dest_type;
-    IrInstruction *target;
+    IrInstSrc *target;
 };
 
-struct IrInstructionEnumToInt {
-    IrInstruction base;
+struct IrInstGenIntToErr {
+    IrInstGen base;
 
-    IrInstruction *target;
+    IrInstGen *target;
 };
 
-struct IrInstructionIntToErr {
-    IrInstruction base;
+struct IrInstSrcErrToInt {
+    IrInstSrc base;
 
-    IrInstruction *target;
+    IrInstSrc *target;
 };
 
-struct IrInstructionErrToInt {
-    IrInstruction base;
+struct IrInstGenErrToInt {
+    IrInstGen base;
 
-    IrInstruction *target;
+    IrInstGen *target;
 };
 
-struct IrInstructionCheckSwitchProngsRange {
-    IrInstruction *start;
-    IrInstruction *end;
+struct IrInstSrcCheckSwitchProngsRange {
+    IrInstSrc *start;
+    IrInstSrc *end;
 };
 
-struct IrInstructionCheckSwitchProngs {
-    IrInstruction base;
+struct IrInstSrcCheckSwitchProngs {
+    IrInstSrc base;
 
-    IrInstruction *target_value;
-    IrInstructionCheckSwitchProngsRange *ranges;
+    IrInstSrc *target_value;
+    IrInstSrcCheckSwitchProngsRange *ranges;
     size_t range_count;
     bool have_else_prong;
     bool have_underscore_prong;
 };
 
-struct IrInstructionCheckStatementIsVoid {
-    IrInstruction base;
+struct IrInstSrcCheckStatementIsVoid {
+    IrInstSrc base;
 
-    IrInstruction *statement_value;
+    IrInstSrc *statement_value;
 };
 
-struct IrInstructionTypeName {
-    IrInstruction base;
+struct IrInstSrcTypeName {
+    IrInstSrc base;
 
-    IrInstruction *type_value;
+    IrInstSrc *type_value;
 };
 
-struct IrInstructionDeclRef {
-    IrInstruction base;
+struct IrInstSrcDeclRef {
+    IrInstSrc base;
 
     LVal lval;
     Tld *tld;
 };
 
-struct IrInstructionPanic {
-    IrInstruction base;
+struct IrInstSrcPanic {
+    IrInstSrc base;
+
+    IrInstSrc *msg;
+};
+
+struct IrInstGenPanic {
+    IrInstGen base;
+
+    IrInstGen *msg;
+};
+
+struct IrInstSrcTagName {
+    IrInstSrc base;
+
+    IrInstSrc *target;
+};
+
+struct IrInstGenTagName {
+    IrInstGen base;
 
-    IrInstruction *msg;
+    IrInstGen *target;
 };
 
-struct IrInstructionTagName {
-    IrInstruction base;
+struct IrInstSrcTagType {
+    IrInstSrc base;
 
-    IrInstruction *target;
+    IrInstSrc *target;
 };
 
-struct IrInstructionTagType {
-    IrInstruction base;
+struct IrInstSrcFieldParentPtr {
+    IrInstSrc base;
 
-    IrInstruction *target;
+    IrInstSrc *type_value;
+    IrInstSrc *field_name;
+    IrInstSrc *field_ptr;
 };
 
-struct IrInstructionFieldParentPtr {
-    IrInstruction base;
+struct IrInstGenFieldParentPtr {
+    IrInstGen base;
 
-    IrInstruction *type_value;
-    IrInstruction *field_name;
-    IrInstruction *field_ptr;
+    IrInstGen *field_ptr;
     TypeStructField *field;
 };
 
-struct IrInstructionByteOffsetOf {
-    IrInstruction base;
+struct IrInstSrcByteOffsetOf {
+    IrInstSrc base;
+
+    IrInstSrc *type_value;
+    IrInstSrc *field_name;
+};
+
+struct IrInstSrcBitOffsetOf {
+    IrInstSrc base;
 
-    IrInstruction *type_value;
-    IrInstruction *field_name;
+    IrInstSrc *type_value;
+    IrInstSrc *field_name;
 };
 
-struct IrInstructionBitOffsetOf {
-    IrInstruction base;
+struct IrInstSrcTypeInfo {
+    IrInstSrc base;
 
-    IrInstruction *type_value;
-    IrInstruction *field_name;
+    IrInstSrc *type_value;
 };
 
-struct IrInstructionTypeInfo {
-    IrInstruction base;
+struct IrInstSrcType {
+    IrInstSrc base;
 
-    IrInstruction *type_value;
+    IrInstSrc *type_info;
 };
 
-struct IrInstructionType {
-    IrInstruction base;
+struct IrInstSrcHasField {
+    IrInstSrc base;
 
-    IrInstruction *type_info;
+    IrInstSrc *container_type;
+    IrInstSrc *field_name;
 };
 
-struct IrInstructionHasField {
-    IrInstruction base;
+struct IrInstSrcTypeId {
+    IrInstSrc base;
 
-    IrInstruction *container_type;
-    IrInstruction *field_name;
+    IrInstSrc *type_value;
 };
 
-struct IrInstructionTypeId {
-    IrInstruction base;
+struct IrInstSrcSetEvalBranchQuota {
+    IrInstSrc base;
 
-    IrInstruction *type_value;
+    IrInstSrc *new_quota;
 };
 
-struct IrInstructionSetEvalBranchQuota {
-    IrInstruction base;
+struct IrInstSrcAlignCast {
+    IrInstSrc base;
 
-    IrInstruction *new_quota;
+    IrInstSrc *align_bytes;
+    IrInstSrc *target;
 };
 
-struct IrInstructionAlignCast {
-    IrInstruction base;
+struct IrInstGenAlignCast {
+    IrInstGen base;
 
-    IrInstruction *align_bytes;
-    IrInstruction *target;
+    IrInstGen *target;
 };
 
-struct IrInstructionOpaqueType {
-    IrInstruction base;
+struct IrInstSrcOpaqueType {
+    IrInstSrc base;
 };
 
-struct IrInstructionSetAlignStack {
-    IrInstruction base;
+struct IrInstSrcSetAlignStack {
+    IrInstSrc base;
 
-    IrInstruction *align_bytes;
+    IrInstSrc *align_bytes;
 };
 
-struct IrInstructionArgType {
-    IrInstruction base;
+struct IrInstSrcArgType {
+    IrInstSrc base;
 
-    IrInstruction *fn_type;
-    IrInstruction *arg_index;
+    IrInstSrc *fn_type;
+    IrInstSrc *arg_index;
     bool allow_var;
 };
 
-struct IrInstructionExport {
-    IrInstruction base;
+struct IrInstSrcExport {
+    IrInstSrc base;
+
+    IrInstSrc *target;
+    IrInstSrc *options;
+};
+
+enum IrInstErrorReturnTraceOptional {
+    IrInstErrorReturnTraceNull,
+    IrInstErrorReturnTraceNonNull,
+};
+
+struct IrInstSrcErrorReturnTrace {
+    IrInstSrc base;
 
-    IrInstruction *target;
-    IrInstruction *options;
+    IrInstErrorReturnTraceOptional optional;
 };
 
-struct IrInstructionErrorReturnTrace {
-    IrInstruction base;
+struct IrInstGenErrorReturnTrace {
+    IrInstGen base;
 
-    enum Optional {
-        Null,
-        NonNull,
-    } optional;
+    IrInstErrorReturnTraceOptional optional;
 };
 
-struct IrInstructionErrorUnion {
-    IrInstruction base;
+struct IrInstSrcErrorUnion {
+    IrInstSrc base;
 
-    IrInstruction *err_set;
-    IrInstruction *payload;
+    IrInstSrc *err_set;
+    IrInstSrc *payload;
     Buf *type_name;
 };
 
-struct IrInstructionAtomicRmw {
-    IrInstruction base;
+struct IrInstSrcAtomicRmw {
+    IrInstSrc base;
+
+    IrInstSrc *operand_type;
+    IrInstSrc *ptr;
+    IrInstSrc *op;
+    IrInstSrc *operand;
+    IrInstSrc *ordering;
+};
+
+struct IrInstGenAtomicRmw {
+    IrInstGen base;
+
+    IrInstGen *ptr;
+    IrInstGen *operand;
+    AtomicRmwOp op;
+    AtomicOrder ordering;
+};
+
+struct IrInstSrcAtomicLoad {
+    IrInstSrc base;
+
+    IrInstSrc *operand_type;
+    IrInstSrc *ptr;
+    IrInstSrc *ordering;
+};
+
+struct IrInstGenAtomicLoad {
+    IrInstGen base;
 
-    IrInstruction *operand_type;
-    IrInstruction *ptr;
-    IrInstruction *op;
-    AtomicRmwOp resolved_op;
-    IrInstruction *operand;
-    IrInstruction *ordering;
-    AtomicOrder resolved_ordering;
+    IrInstGen *ptr;
+    AtomicOrder ordering;
 };
 
-struct IrInstructionAtomicLoad {
-    IrInstruction base;
+struct IrInstSrcAtomicStore {
+    IrInstSrc base;
 
-    IrInstruction *operand_type;
-    IrInstruction *ptr;
-    IrInstruction *ordering;
-    AtomicOrder resolved_ordering;
+    IrInstSrc *operand_type;
+    IrInstSrc *ptr;
+    IrInstSrc *value;
+    IrInstSrc *ordering;
 };
 
-struct IrInstructionAtomicStore {
-    IrInstruction base;
+struct IrInstGenAtomicStore {
+    IrInstGen base;
+
+    IrInstGen *ptr;
+    IrInstGen *value;
+    AtomicOrder ordering;
+};
 
-    IrInstruction *operand_type;
-    IrInstruction *ptr;
-    IrInstruction *value;
-    IrInstruction *ordering;
-    AtomicOrder resolved_ordering;
+struct IrInstSrcSaveErrRetAddr {
+    IrInstSrc base;
 };
 
-struct IrInstructionSaveErrRetAddr {
-    IrInstruction base;
+struct IrInstGenSaveErrRetAddr {
+    IrInstGen base;
 };
 
-struct IrInstructionAddImplicitReturnType {
-    IrInstruction base;
+struct IrInstSrcAddImplicitReturnType {
+    IrInstSrc base;
 
-    IrInstruction *value;
+    IrInstSrc *value;
     ResultLocReturn *result_loc_ret;
 };
 
-// For float ops which take a single argument
-struct IrInstructionFloatOp {
-    IrInstruction base;
+// For float ops that take a single argument
+struct IrInstSrcFloatOp {
+    IrInstSrc base;
+
+    IrInstSrc *operand;
+    BuiltinFnId fn_id;
+};
+
+struct IrInstGenFloatOp {
+    IrInstGen base;
 
+    IrInstGen *operand;
     BuiltinFnId fn_id;
-    IrInstruction *operand;
 };
 
-struct IrInstructionCheckRuntimeScope {
-    IrInstruction base;
+struct IrInstSrcCheckRuntimeScope {
+    IrInstSrc base;
+
+    IrInstSrc *scope_is_comptime;
+    IrInstSrc *is_comptime;
+};
+
+struct IrInstSrcBswap {
+    IrInstSrc base;
+
+    IrInstSrc *type;
+    IrInstSrc *op;
+};
+
+struct IrInstGenBswap {
+    IrInstGen base;
+
+    IrInstGen *op;
+};
+
+struct IrInstSrcBitReverse {
+    IrInstSrc base;
 
-    IrInstruction *scope_is_comptime;
-    IrInstruction *is_comptime;
+    IrInstSrc *type;
+    IrInstSrc *op;
 };
 
-struct IrInstructionBswap {
-    IrInstruction base;
+struct IrInstGenBitReverse {
+    IrInstGen base;
 
-    IrInstruction *type;
-    IrInstruction *op;
+    IrInstGen *op;
 };
 
-struct IrInstructionBitReverse {
-    IrInstruction base;
+struct IrInstGenArrayToVector {
+    IrInstGen base;
 
-    IrInstruction *type;
-    IrInstruction *op;
+    IrInstGen *array;
 };
 
-struct IrInstructionArrayToVector {
-    IrInstruction base;
+struct IrInstGenVectorToArray {
+    IrInstGen base;
 
-    IrInstruction *array;
+    IrInstGen *vector;
+    IrInstGen *result_loc;
 };
 
-struct IrInstructionVectorToArray {
-    IrInstruction base;
+struct IrInstSrcShuffleVector {
+    IrInstSrc base;
 
-    IrInstruction *vector;
-    IrInstruction *result_loc;
+    IrInstSrc *scalar_type;
+    IrInstSrc *a;
+    IrInstSrc *b;
+    IrInstSrc *mask; // This is in zig-format, not llvm format
 };
 
-struct IrInstructionShuffleVector {
-    IrInstruction base;
+struct IrInstGenShuffleVector {
+    IrInstGen base;
 
-    IrInstruction *scalar_type;
-    IrInstruction *a;
-    IrInstruction *b;
-    IrInstruction *mask; // This is in zig-format, not llvm format
+    IrInstGen *a;
+    IrInstGen *b;
+    IrInstGen *mask; // This is in zig-format, not llvm format
 };
 
-struct IrInstructionSplatSrc {
-    IrInstruction base;
+struct IrInstSrcSplat {
+    IrInstSrc base;
 
-    IrInstruction *len;
-    IrInstruction *scalar;
+    IrInstSrc *len;
+    IrInstSrc *scalar;
 };
 
-struct IrInstructionSplatGen {
-    IrInstruction base;
+struct IrInstGenSplat {
+    IrInstGen base;
 
-    IrInstruction *scalar;
+    IrInstGen *scalar;
 };
 
-struct IrInstructionAssertZero {
-    IrInstruction base;
+struct IrInstGenAssertZero {
+    IrInstGen base;
 
-    IrInstruction *target;
+    IrInstGen *target;
 };
 
-struct IrInstructionAssertNonNull {
-    IrInstruction base;
+struct IrInstGenAssertNonNull {
+    IrInstGen base;
 
-    IrInstruction *target;
+    IrInstGen *target;
 };
 
-struct IrInstructionUnionInitNamedField {
-    IrInstruction base;
+struct IrInstSrcUnionInitNamedField {
+    IrInstSrc base;
 
-    IrInstruction *union_type;
-    IrInstruction *field_name;
-    IrInstruction *field_result_loc;
-    IrInstruction *result_loc;
+    IrInstSrc *union_type;
+    IrInstSrc *field_name;
+    IrInstSrc *field_result_loc;
+    IrInstSrc *result_loc;
 };
 
-struct IrInstructionHasDecl {
-    IrInstruction base;
+struct IrInstSrcHasDecl {
+    IrInstSrc base;
 
-    IrInstruction *container;
-    IrInstruction *name;
+    IrInstSrc *container;
+    IrInstSrc *name;
 };
 
-struct IrInstructionUndeclaredIdent {
-    IrInstruction base;
+struct IrInstSrcUndeclaredIdent {
+    IrInstSrc base;
 
     Buf *name;
 };
 
-struct IrInstructionAllocaSrc {
-    IrInstruction base;
+struct IrInstSrcAlloca {
+    IrInstSrc base;
 
-    IrInstruction *align;
-    IrInstruction *is_comptime;
+    IrInstSrc *align;
+    IrInstSrc *is_comptime;
     const char *name_hint;
 };
 
-struct IrInstructionAllocaGen {
-    IrInstruction base;
+struct IrInstGenAlloca {
+    IrInstGen base;
 
     uint32_t align;
     const char *name_hint;
     size_t field_index;
 };
 
-struct IrInstructionEndExpr {
-    IrInstruction base;
+struct IrInstSrcEndExpr {
+    IrInstSrc base;
 
-    IrInstruction *value;
+    IrInstSrc *value;
     ResultLoc *result_loc;
 };
 
 // This one is for writing through the result pointer.
-struct IrInstructionResolveResult {
-    IrInstruction base;
+struct IrInstSrcResolveResult {
+    IrInstSrc base;
 
     ResultLoc *result_loc;
-    IrInstruction *ty;
+    IrInstSrc *ty;
 };
 
-// This one is when you want to read the value of the result.
-// You have to give the value in case it is comptime.
-struct IrInstructionResultPtr {
-    IrInstruction base;
+struct IrInstSrcResetResult {
+    IrInstSrc base;
 
     ResultLoc *result_loc;
-    IrInstruction *result;
 };
 
-struct IrInstructionResetResult {
-    IrInstruction base;
+struct IrInstGenPtrOfArrayToSlice {
+    IrInstGen base;
 
-    ResultLoc *result_loc;
+    IrInstGen *operand;
+    IrInstGen *result_loc;
 };
 
-struct IrInstructionPtrOfArrayToSlice {
-    IrInstruction base;
-
-    IrInstruction *operand;
-    IrInstruction *result_loc;
+struct IrInstSrcSuspendBegin {
+    IrInstSrc base;
 };
 
-struct IrInstructionSuspendBegin {
-    IrInstruction base;
+struct IrInstGenSuspendBegin {
+    IrInstGen base;
 
     LLVMBasicBlockRef resume_bb;
 };
 
-struct IrInstructionSuspendFinish {
-    IrInstruction base;
+struct IrInstSrcSuspendFinish {
+    IrInstSrc base;
+
+    IrInstSrcSuspendBegin *begin;
+};
+
+struct IrInstGenSuspendFinish {
+    IrInstGen base;
 
-    IrInstructionSuspendBegin *begin;
+    IrInstGenSuspendBegin *begin;
 };
 
-struct IrInstructionAwaitSrc {
-    IrInstruction base;
+struct IrInstSrcAwait {
+    IrInstSrc base;
 
-    IrInstruction *frame;
+    IrInstSrc *frame;
     ResultLoc *result_loc;
 };
 
-struct IrInstructionAwaitGen {
-    IrInstruction base;
+struct IrInstGenAwait {
+    IrInstGen base;
 
-    IrInstruction *frame;
-    IrInstruction *result_loc;
+    IrInstGen *frame;
+    IrInstGen *result_loc;
     ZigFn *target_fn;
 };
 
-struct IrInstructionResume {
-    IrInstruction base;
+struct IrInstSrcResume {
+    IrInstSrc base;
+
+    IrInstSrc *frame;
+};
+
+struct IrInstGenResume {
+    IrInstGen base;
 
-    IrInstruction *frame;
+    IrInstGen *frame;
 };
 
 enum SpillId {
@@ -4044,24 +4503,37 @@ enum SpillId {
     SpillIdRetErrCode,
 };
 
-struct IrInstructionSpillBegin {
-    IrInstruction base;
+struct IrInstSrcSpillBegin {
+    IrInstSrc base;
+
+    IrInstSrc *operand;
+    SpillId spill_id;
+};
+
+struct IrInstGenSpillBegin {
+    IrInstGen base;
 
     SpillId spill_id;
-    IrInstruction *operand;
+    IrInstGen *operand;
+};
+
+struct IrInstSrcSpillEnd {
+    IrInstSrc base;
+
+    IrInstSrcSpillBegin *begin;
 };
 
-struct IrInstructionSpillEnd {
-    IrInstruction base;
+struct IrInstGenSpillEnd {
+    IrInstGen base;
 
-    IrInstructionSpillBegin *begin;
+    IrInstGenSpillBegin *begin;
 };
 
-struct IrInstructionVectorExtractElem {
-    IrInstruction base;
+struct IrInstGenVectorExtractElem {
+    IrInstGen base;
 
-    IrInstruction *vector;
-    IrInstruction *index;
+    IrInstGen *vector;
+    IrInstGen *index;
 };
 
 enum ResultLocId {
@@ -4082,9 +4554,9 @@ struct ResultLoc {
     ResultLocId id;
     bool written;
     bool allow_write_through_const;
-    IrInstruction *resolved_loc; // result ptr
-    IrInstruction *source_instruction;
-    IrInstruction *gen_instruction; // value to store to the result loc
+    IrInstGen *resolved_loc; // result ptr
+    IrInstSrc *source_instruction;
+    IrInstGen *gen_instruction; // value to store to the result loc
     ZigType *implicit_elem_type;
 };
 
@@ -4114,18 +4586,18 @@ struct ResultLocPeerParent {
 
     bool skipped;
     bool done_resuming;
-    IrBasicBlock *end_bb;
+    IrBasicBlockSrc *end_bb;
     ResultLoc *parent;
     ZigList<ResultLocPeer *> peers;
     ZigType *resolved_type;
-    IrInstruction *is_comptime;
+    IrInstSrc *is_comptime;
 };
 
 struct ResultLocPeer {
     ResultLoc base;
 
     ResultLocPeerParent *parent;
-    IrBasicBlock *next_bb;
+    IrBasicBlockSrc *next_bb;
     IrSuspendPosition suspend_pos;
 };
 
@@ -4196,7 +4668,7 @@ struct FnWalkAttrs {
 struct FnWalkCall {
     ZigList<LLVMValueRef> *gen_param_values;
     ZigList<ZigType *> *gen_param_types;
-    IrInstructionCallGen *inst;
+    IrInstGenCall *inst;
     bool is_var_args;
 };