diff --git a/src/all_types.hpp b/src/all_types.hpp
index 5b062efc9..227018f5e 100644
--- a/src/all_types.hpp
+++ b/src/all_types.hpp
@@ -1565,7 +1565,7 @@ struct ZigFn {
     // in the case of async functions this is the implicit return type according to the
     // zig source code, not according to zig ir
     ZigType *src_implicit_return_type;
-    IrExecutable ir_executable;
+    IrExecutable *ir_executable;
     IrExecutable analyzed_executable;
     size_t prealloc_bbc;
     size_t prealloc_backward_branch_quota;
@@ -2204,6 +2204,8 @@ struct ZigVar {
     bool src_is_const;
     bool gen_is_const;
     bool is_thread_local;
+    bool is_comptime_memoized;
+    bool is_comptime_memoized_value;
 };
 
 struct ErrorTableEntry {
diff --git a/src/analyze.cpp b/src/analyze.cpp
index c0d2d636e..0f2df5835 100644
--- a/src/analyze.cpp
+++ b/src/analyze.cpp
@@ -3275,14 +3275,15 @@ static void get_fully_qualified_decl_name(CodeGen *g, Buf *buf, Tld *tld, bool i
 }
 
 ZigFn *create_fn_raw(CodeGen *g, FnInline inline_value) {
-    ZigFn *fn_entry = allocate<ZigFn>(1);
+    ZigFn *fn_entry = allocate<ZigFn>(1, "ZigFn");
+    fn_entry->ir_executable = allocate<IrExecutable>(1, "IrExecutablePass1");
 
     fn_entry->prealloc_backward_branch_quota = default_backward_branch_quota;
 
     fn_entry->analyzed_executable.backward_branch_count = &fn_entry->prealloc_bbc;
     fn_entry->analyzed_executable.backward_branch_quota = &fn_entry->prealloc_backward_branch_quota;
     fn_entry->analyzed_executable.fn_entry = fn_entry;
-    fn_entry->ir_executable.fn_entry = fn_entry;
+    fn_entry->ir_executable->fn_entry = fn_entry;
     fn_entry->fn_inline = inline_value;
 
     return fn_entry;
@@ -4610,7 +4611,7 @@ static void analyze_fn_ir(CodeGen *g, ZigFn *fn, AstNode *return_type_node) {
     assert(!fn_type->data.fn.is_generic);
     FnTypeId *fn_type_id = &fn_type->data.fn.fn_type_id;
 
-    ZigType *block_return_type = ir_analyze(g, &fn->ir_executable,
+    ZigType *block_return_type = ir_analyze(g, fn->ir_executable,
             &fn->analyzed_executable, fn_type_id->return_type, return_type_node);
     fn->src_implicit_return_type = block_return_type;
 
@@ -4706,7 +4707,7 @@ static void analyze_fn_body(CodeGen *g, ZigFn *fn_table_entry) {
     assert(!fn_type->data.fn.is_generic);
 
     ir_gen_fn(g, fn_table_entry);
-    if (fn_table_entry->ir_executable.first_err_trace_msg != nullptr) {
+    if (fn_table_entry->ir_executable->first_err_trace_msg != nullptr) {
         fn_table_entry->anal_state = FnAnalStateInvalid;
         return;
     }
@@ -4714,7 +4715,7 @@ static void analyze_fn_body(CodeGen *g, ZigFn *fn_table_entry) {
         fprintf(stderr, "\n");
         ast_render(stderr, fn_table_entry->body_node, 4);
         fprintf(stderr, "\nfn %s() { // (IR)\n", buf_ptr(&fn_table_entry->symbol_name));
-        ir_print(g, stderr, &fn_table_entry->ir_executable, 4, IrPassSrc);
+        ir_print(g, stderr, fn_table_entry->ir_executable, 4, IrPassSrc);
         fprintf(stderr, "}\n");
     }
 
@@ -6453,20 +6454,31 @@ Error type_resolve(CodeGen *g, ZigType *ty, ResolveStatus status) {
 }
 
 bool ir_get_var_is_comptime(ZigVar *var) {
+    if (var->is_comptime_memoized)
+        return var->is_comptime_memoized_value;
+
+    var->is_comptime_memoized = true;
+
     // The is_comptime field can be left null, which means not comptime.
-    if (var->is_comptime == nullptr)
-        return false;
+    if (var->is_comptime == nullptr) {
+        var->is_comptime_memoized_value = false;
+        return var->is_comptime_memoized_value;
+    }
     // When the is_comptime field references an instruction that has to get analyzed, this
     // is the value.
     if (var->is_comptime->child != nullptr) {
         assert(var->is_comptime->child->value->type->id == ZigTypeIdBool);
-        return var->is_comptime->child->value->data.x_bool;
+        var->is_comptime_memoized_value = var->is_comptime->child->value->data.x_bool;
+        var->is_comptime = nullptr;
+        return var->is_comptime_memoized_value;
     }
     // As an optimization, is_comptime values which are constant are allowed
     // to be omitted from analysis. In this case, there is no child instruction
     // and we simply look at the unanalyzed const parent instruction.
     assert(var->is_comptime->value->type->id == ZigTypeIdBool);
-    return var->is_comptime->value->data.x_bool;
+    var->is_comptime_memoized_value = var->is_comptime->value->data.x_bool;
+    var->is_comptime = nullptr;
+    return var->is_comptime_memoized_value;
 }
 
 bool const_values_equal_ptr(ZigValue *a, ZigValue *b) {
diff --git a/src/ir.cpp b/src/ir.cpp
index e0ebe8468..93b16dc8d 100644
--- a/src/ir.cpp
+++ b/src/ir.cpp
@@ -253,6 +253,353 @@ static IrInstruction *ir_analyze_inferred_field_ptr(IrAnalyze *ira, Buf *field_n
     IrInstruction *source_instr, IrInstruction *container_ptr, ZigType *container_type);
 static ResultLoc *no_result_loc(void);
 
+static void destroy_instruction(IrInstruction *inst) {
+#ifdef ZIG_ENABLE_MEM_PROFILE
+    const char *name = ir_instruction_type_str(inst->id);
+#else
+    const char *name = nullptr;
+#endif
+    switch (inst->id) {
+        case IrInstructionIdInvalid:
+            zig_unreachable();
+        case IrInstructionIdReturn:
+            return destroy(reinterpret_cast<IrInstructionReturn *>(inst), name);
+        case IrInstructionIdConst:
+            return destroy(reinterpret_cast<IrInstructionConst *>(inst), name);
+        case IrInstructionIdBinOp:
+            return destroy(reinterpret_cast<IrInstructionBinOp *>(inst), name);
+        case IrInstructionIdMergeErrSets:
+            return destroy(reinterpret_cast<IrInstructionMergeErrSets *>(inst), name);
+        case IrInstructionIdDeclVarSrc:
+            return destroy(reinterpret_cast<IrInstructionDeclVarSrc *>(inst), name);
+        case IrInstructionIdCast:
+            return destroy(reinterpret_cast<IrInstructionCast *>(inst), name);
+        case IrInstructionIdCallSrc:
+            return destroy(reinterpret_cast<IrInstructionCallSrc *>(inst), name);
+        case IrInstructionIdCallGen:
+            return destroy(reinterpret_cast<IrInstructionCallGen *>(inst), name);
+        case IrInstructionIdUnOp:
+            return destroy(reinterpret_cast<IrInstructionUnOp *>(inst), name);
+        case IrInstructionIdCondBr:
+            return destroy(reinterpret_cast<IrInstructionCondBr *>(inst), name);
+        case IrInstructionIdBr:
+            return destroy(reinterpret_cast<IrInstructionBr *>(inst), name);
+        case IrInstructionIdPhi:
+            return destroy(reinterpret_cast<IrInstructionPhi *>(inst), name);
+        case IrInstructionIdContainerInitList:
+            return destroy(reinterpret_cast<IrInstructionContainerInitList *>(inst), name);
+        case IrInstructionIdContainerInitFields:
+            return destroy(reinterpret_cast<IrInstructionContainerInitFields *>(inst), name);
+        case IrInstructionIdUnreachable:
+            return destroy(reinterpret_cast<IrInstructionUnreachable *>(inst), name);
+        case IrInstructionIdElemPtr:
+            return destroy(reinterpret_cast<IrInstructionElemPtr *>(inst), name);
+        case IrInstructionIdVarPtr:
+            return destroy(reinterpret_cast<IrInstructionVarPtr *>(inst), name);
+        case IrInstructionIdReturnPtr:
+            return destroy(reinterpret_cast<IrInstructionReturnPtr *>(inst), name);
+        case IrInstructionIdLoadPtr:
+            return destroy(reinterpret_cast<IrInstructionLoadPtr *>(inst), name);
+        case IrInstructionIdLoadPtrGen:
+            return destroy(reinterpret_cast<IrInstructionLoadPtrGen *>(inst), name);
+        case IrInstructionIdStorePtr:
+            return destroy(reinterpret_cast<IrInstructionStorePtr *>(inst), name);
+        case IrInstructionIdVectorStoreElem:
+            return destroy(reinterpret_cast<IrInstructionVectorStoreElem *>(inst), name);
+        case IrInstructionIdTypeOf:
+            return destroy(reinterpret_cast<IrInstructionTypeOf *>(inst), name);
+        case IrInstructionIdFieldPtr:
+            return destroy(reinterpret_cast<IrInstructionFieldPtr *>(inst), name);
+        case IrInstructionIdStructFieldPtr:
+            return destroy(reinterpret_cast<IrInstructionStructFieldPtr *>(inst), name);
+        case IrInstructionIdUnionFieldPtr:
+            return destroy(reinterpret_cast<IrInstructionUnionFieldPtr *>(inst), name);
+        case IrInstructionIdSetCold:
+            return destroy(reinterpret_cast<IrInstructionSetCold *>(inst), name);
+        case IrInstructionIdSetRuntimeSafety:
+            return destroy(reinterpret_cast<IrInstructionSetRuntimeSafety *>(inst), name);
+        case IrInstructionIdSetFloatMode:
+            return destroy(reinterpret_cast<IrInstructionSetFloatMode *>(inst), name);
+        case IrInstructionIdArrayType:
+            return destroy(reinterpret_cast<IrInstructionArrayType *>(inst), name);
+        case IrInstructionIdSliceType:
+            return destroy(reinterpret_cast<IrInstructionSliceType *>(inst), name);
+        case IrInstructionIdAnyFrameType:
+            return destroy(reinterpret_cast<IrInstructionAnyFrameType *>(inst), name);
+        case IrInstructionIdGlobalAsm:
+            return destroy(reinterpret_cast<IrInstructionGlobalAsm *>(inst), name);
+        case IrInstructionIdAsm:
+            return destroy(reinterpret_cast<IrInstructionAsm *>(inst), name);
+        case IrInstructionIdSizeOf:
+            return destroy(reinterpret_cast<IrInstructionSizeOf *>(inst), name);
+        case IrInstructionIdTestNonNull:
+            return destroy(reinterpret_cast<IrInstructionTestNonNull *>(inst), name);
+        case IrInstructionIdOptionalUnwrapPtr:
+            return destroy(reinterpret_cast<IrInstructionOptionalUnwrapPtr *>(inst), name);
+        case IrInstructionIdPopCount:
+            return destroy(reinterpret_cast<IrInstructionPopCount *>(inst), name);
+        case IrInstructionIdClz:
+            return destroy(reinterpret_cast<IrInstructionClz *>(inst), name);
+        case IrInstructionIdCtz:
+            return destroy(reinterpret_cast<IrInstructionCtz *>(inst), name);
+        case IrInstructionIdBswap:
+            return destroy(reinterpret_cast<IrInstructionBswap *>(inst), name);
+        case IrInstructionIdBitReverse:
+            return destroy(reinterpret_cast<IrInstructionBitReverse *>(inst), name);
+        case IrInstructionIdSwitchBr:
+            return destroy(reinterpret_cast<IrInstructionSwitchBr *>(inst), name);
+        case IrInstructionIdSwitchVar:
+            return destroy(reinterpret_cast<IrInstructionSwitchVar *>(inst), name);
+        case IrInstructionIdSwitchElseVar:
+            return destroy(reinterpret_cast<IrInstructionSwitchElseVar *>(inst), name);
+        case IrInstructionIdSwitchTarget:
+            return destroy(reinterpret_cast<IrInstructionSwitchTarget *>(inst), name);
+        case IrInstructionIdUnionTag:
+            return destroy(reinterpret_cast<IrInstructionUnionTag *>(inst), name);
+        case IrInstructionIdImport:
+            return destroy(reinterpret_cast<IrInstructionImport *>(inst), name);
+        case IrInstructionIdRef:
+            return destroy(reinterpret_cast<IrInstructionRef *>(inst), name);
+        case IrInstructionIdRefGen:
+            return destroy(reinterpret_cast<IrInstructionRefGen *>(inst), name);
+        case IrInstructionIdCompileErr:
+            return destroy(reinterpret_cast<IrInstructionCompileErr *>(inst), name);
+        case IrInstructionIdCompileLog:
+            return destroy(reinterpret_cast<IrInstructionCompileLog *>(inst), name);
+        case IrInstructionIdErrName:
+            return destroy(reinterpret_cast<IrInstructionErrName *>(inst), name);
+        case IrInstructionIdCImport:
+            return destroy(reinterpret_cast<IrInstructionCImport *>(inst), name);
+        case IrInstructionIdCInclude:
+            return destroy(reinterpret_cast<IrInstructionCInclude *>(inst), name);
+        case IrInstructionIdCDefine:
+            return destroy(reinterpret_cast<IrInstructionCDefine *>(inst), name);
+        case IrInstructionIdCUndef:
+            return destroy(reinterpret_cast<IrInstructionCUndef *>(inst), name);
+        case IrInstructionIdEmbedFile:
+            return destroy(reinterpret_cast<IrInstructionEmbedFile *>(inst), name);
+        case IrInstructionIdCmpxchgSrc:
+            return destroy(reinterpret_cast<IrInstructionCmpxchgSrc *>(inst), name);
+        case IrInstructionIdCmpxchgGen:
+            return destroy(reinterpret_cast<IrInstructionCmpxchgGen *>(inst), name);
+        case IrInstructionIdFence:
+            return destroy(reinterpret_cast<IrInstructionFence *>(inst), name);
+        case IrInstructionIdTruncate:
+            return destroy(reinterpret_cast<IrInstructionTruncate *>(inst), name);
+        case IrInstructionIdIntCast:
+            return destroy(reinterpret_cast<IrInstructionIntCast *>(inst), name);
+        case IrInstructionIdFloatCast:
+            return destroy(reinterpret_cast<IrInstructionFloatCast *>(inst), name);
+        case IrInstructionIdErrSetCast:
+            return destroy(reinterpret_cast<IrInstructionErrSetCast *>(inst), name);
+        case IrInstructionIdFromBytes:
+            return destroy(reinterpret_cast<IrInstructionFromBytes *>(inst), name);
+        case IrInstructionIdToBytes:
+            return destroy(reinterpret_cast<IrInstructionToBytes *>(inst), name);
+        case IrInstructionIdIntToFloat:
+            return destroy(reinterpret_cast<IrInstructionIntToFloat *>(inst), name);
+        case IrInstructionIdFloatToInt:
+            return destroy(reinterpret_cast<IrInstructionFloatToInt *>(inst), name);
+        case IrInstructionIdBoolToInt:
+            return destroy(reinterpret_cast<IrInstructionBoolToInt *>(inst), name);
+        case IrInstructionIdIntType:
+            return destroy(reinterpret_cast<IrInstructionIntType *>(inst), name);
+        case IrInstructionIdVectorType:
+            return destroy(reinterpret_cast<IrInstructionVectorType *>(inst), name);
+        case IrInstructionIdShuffleVector:
+            return destroy(reinterpret_cast<IrInstructionShuffleVector *>(inst), name);
+        case IrInstructionIdSplatSrc:
+            return destroy(reinterpret_cast<IrInstructionSplatSrc *>(inst), name);
+        case IrInstructionIdSplatGen:
+            return destroy(reinterpret_cast<IrInstructionSplatGen *>(inst), name);
+        case IrInstructionIdBoolNot:
+            return destroy(reinterpret_cast<IrInstructionBoolNot *>(inst), name);
+        case IrInstructionIdMemset:
+            return destroy(reinterpret_cast<IrInstructionMemset *>(inst), name);
+        case IrInstructionIdMemcpy:
+            return destroy(reinterpret_cast<IrInstructionMemcpy *>(inst), name);
+        case IrInstructionIdSliceSrc:
+            return destroy(reinterpret_cast<IrInstructionSliceSrc *>(inst), name);
+        case IrInstructionIdSliceGen:
+            return destroy(reinterpret_cast<IrInstructionSliceGen *>(inst), name);
+        case IrInstructionIdMemberCount:
+            return destroy(reinterpret_cast<IrInstructionMemberCount *>(inst), name);
+        case IrInstructionIdMemberType:
+            return destroy(reinterpret_cast<IrInstructionMemberType *>(inst), name);
+        case IrInstructionIdMemberName:
+            return destroy(reinterpret_cast<IrInstructionMemberName *>(inst), name);
+        case IrInstructionIdBreakpoint:
+            return destroy(reinterpret_cast<IrInstructionBreakpoint *>(inst), name);
+        case IrInstructionIdReturnAddress:
+            return destroy(reinterpret_cast<IrInstructionReturnAddress *>(inst), name);
+        case IrInstructionIdFrameAddress:
+            return destroy(reinterpret_cast<IrInstructionFrameAddress *>(inst), name);
+        case IrInstructionIdFrameHandle:
+            return destroy(reinterpret_cast<IrInstructionFrameHandle *>(inst), name);
+        case IrInstructionIdFrameType:
+            return destroy(reinterpret_cast<IrInstructionFrameType *>(inst), name);
+        case IrInstructionIdFrameSizeSrc:
+            return destroy(reinterpret_cast<IrInstructionFrameSizeSrc *>(inst), name);
+        case IrInstructionIdFrameSizeGen:
+            return destroy(reinterpret_cast<IrInstructionFrameSizeGen *>(inst), name);
+        case IrInstructionIdAlignOf:
+            return destroy(reinterpret_cast<IrInstructionAlignOf *>(inst), name);
+        case IrInstructionIdOverflowOp:
+            return destroy(reinterpret_cast<IrInstructionOverflowOp *>(inst), name);
+        case IrInstructionIdTestErrSrc:
+            return destroy(reinterpret_cast<IrInstructionTestErrSrc *>(inst), name);
+        case IrInstructionIdTestErrGen:
+            return destroy(reinterpret_cast<IrInstructionTestErrGen *>(inst), name);
+        case IrInstructionIdUnwrapErrCode:
+            return destroy(reinterpret_cast<IrInstructionUnwrapErrCode *>(inst), name);
+        case IrInstructionIdUnwrapErrPayload:
+            return destroy(reinterpret_cast<IrInstructionUnwrapErrPayload *>(inst), name);
+        case IrInstructionIdOptionalWrap:
+            return destroy(reinterpret_cast<IrInstructionOptionalWrap *>(inst), name);
+        case IrInstructionIdErrWrapCode:
+            return destroy(reinterpret_cast<IrInstructionErrWrapCode *>(inst), name);
+        case IrInstructionIdErrWrapPayload:
+            return destroy(reinterpret_cast<IrInstructionErrWrapPayload *>(inst), name);
+        case IrInstructionIdFnProto:
+            return destroy(reinterpret_cast<IrInstructionFnProto *>(inst), name);
+        case IrInstructionIdTestComptime:
+            return destroy(reinterpret_cast<IrInstructionTestComptime *>(inst), name);
+        case IrInstructionIdPtrCastSrc:
+            return destroy(reinterpret_cast<IrInstructionPtrCastSrc *>(inst), name);
+        case IrInstructionIdPtrCastGen:
+            return destroy(reinterpret_cast<IrInstructionPtrCastGen *>(inst), name);
+        case IrInstructionIdBitCastSrc:
+            return destroy(reinterpret_cast<IrInstructionBitCastSrc *>(inst), name);
+        case IrInstructionIdBitCastGen:
+            return destroy(reinterpret_cast<IrInstructionBitCastGen *>(inst), name);
+        case IrInstructionIdWidenOrShorten:
+            return destroy(reinterpret_cast<IrInstructionWidenOrShorten *>(inst), name);
+        case IrInstructionIdPtrToInt:
+            return destroy(reinterpret_cast<IrInstructionPtrToInt *>(inst), name);
+        case IrInstructionIdIntToPtr:
+            return destroy(reinterpret_cast<IrInstructionIntToPtr *>(inst), name);
+        case IrInstructionIdIntToEnum:
+            return destroy(reinterpret_cast<IrInstructionIntToEnum *>(inst), name);
+        case IrInstructionIdIntToErr:
+            return destroy(reinterpret_cast<IrInstructionIntToErr *>(inst), name);
+        case IrInstructionIdErrToInt:
+            return destroy(reinterpret_cast<IrInstructionErrToInt *>(inst), name);
+        case IrInstructionIdCheckSwitchProngs:
+            return destroy(reinterpret_cast<IrInstructionCheckSwitchProngs *>(inst), name);
+        case IrInstructionIdCheckStatementIsVoid:
+            return destroy(reinterpret_cast<IrInstructionCheckStatementIsVoid *>(inst), name);
+        case IrInstructionIdTypeName:
+            return destroy(reinterpret_cast<IrInstructionTypeName *>(inst), name);
+        case IrInstructionIdTagName:
+            return destroy(reinterpret_cast<IrInstructionTagName *>(inst), name);
+        case IrInstructionIdPtrType:
+            return destroy(reinterpret_cast<IrInstructionPtrType *>(inst), name);
+        case IrInstructionIdDeclRef:
+            return destroy(reinterpret_cast<IrInstructionDeclRef *>(inst), name);
+        case IrInstructionIdPanic:
+            return destroy(reinterpret_cast<IrInstructionPanic *>(inst), name);
+        case IrInstructionIdFieldParentPtr:
+            return destroy(reinterpret_cast<IrInstructionFieldParentPtr *>(inst), name);
+        case IrInstructionIdByteOffsetOf:
+            return destroy(reinterpret_cast<IrInstructionByteOffsetOf *>(inst), name);
+        case IrInstructionIdBitOffsetOf:
+            return destroy(reinterpret_cast<IrInstructionBitOffsetOf *>(inst), name);
+        case IrInstructionIdTypeInfo:
+            return destroy(reinterpret_cast<IrInstructionTypeInfo *>(inst), name);
+        case IrInstructionIdType:
+            return destroy(reinterpret_cast<IrInstructionType *>(inst), name);
+        case IrInstructionIdHasField:
+            return destroy(reinterpret_cast<IrInstructionHasField *>(inst), name);
+        case IrInstructionIdTypeId:
+            return destroy(reinterpret_cast<IrInstructionTypeId *>(inst), name);
+        case IrInstructionIdSetEvalBranchQuota:
+            return destroy(reinterpret_cast<IrInstructionSetEvalBranchQuota *>(inst), name);
+        case IrInstructionIdAlignCast:
+            return destroy(reinterpret_cast<IrInstructionAlignCast *>(inst), name);
+        case IrInstructionIdImplicitCast:
+            return destroy(reinterpret_cast<IrInstructionImplicitCast *>(inst), name);
+        case IrInstructionIdResolveResult:
+            return destroy(reinterpret_cast<IrInstructionResolveResult *>(inst), name);
+        case IrInstructionIdResetResult:
+            return destroy(reinterpret_cast<IrInstructionResetResult *>(inst), name);
+        case IrInstructionIdOpaqueType:
+            return destroy(reinterpret_cast<IrInstructionOpaqueType *>(inst), name);
+        case IrInstructionIdSetAlignStack:
+            return destroy(reinterpret_cast<IrInstructionSetAlignStack *>(inst), name);
+        case IrInstructionIdArgType:
+            return destroy(reinterpret_cast<IrInstructionArgType *>(inst), name);
+        case IrInstructionIdTagType:
+            return destroy(reinterpret_cast<IrInstructionTagType *>(inst), name);
+        case IrInstructionIdExport:
+            return destroy(reinterpret_cast<IrInstructionExport *>(inst), name);
+        case IrInstructionIdErrorReturnTrace:
+            return destroy(reinterpret_cast<IrInstructionErrorReturnTrace *>(inst), name);
+        case IrInstructionIdErrorUnion:
+            return destroy(reinterpret_cast<IrInstructionErrorUnion *>(inst), name);
+        case IrInstructionIdAtomicRmw:
+            return destroy(reinterpret_cast<IrInstructionAtomicRmw *>(inst), name);
+        case IrInstructionIdSaveErrRetAddr:
+            return destroy(reinterpret_cast<IrInstructionSaveErrRetAddr *>(inst), name);
+        case IrInstructionIdAddImplicitReturnType:
+            return destroy(reinterpret_cast<IrInstructionAddImplicitReturnType *>(inst), name);
+        case IrInstructionIdFloatOp:
+            return destroy(reinterpret_cast<IrInstructionFloatOp *>(inst), name);
+        case IrInstructionIdMulAdd:
+            return destroy(reinterpret_cast<IrInstructionMulAdd *>(inst), name);
+        case IrInstructionIdAtomicLoad:
+            return destroy(reinterpret_cast<IrInstructionAtomicLoad *>(inst), name);
+        case IrInstructionIdAtomicStore:
+            return destroy(reinterpret_cast<IrInstructionAtomicStore *>(inst), name);
+        case IrInstructionIdEnumToInt:
+            return destroy(reinterpret_cast<IrInstructionEnumToInt *>(inst), name);
+        case IrInstructionIdCheckRuntimeScope:
+            return destroy(reinterpret_cast<IrInstructionCheckRuntimeScope *>(inst), name);
+        case IrInstructionIdDeclVarGen:
+            return destroy(reinterpret_cast<IrInstructionDeclVarGen *>(inst), name);
+        case IrInstructionIdArrayToVector:
+            return destroy(reinterpret_cast<IrInstructionArrayToVector *>(inst), name);
+        case IrInstructionIdVectorToArray:
+            return destroy(reinterpret_cast<IrInstructionVectorToArray *>(inst), name);
+        case IrInstructionIdPtrOfArrayToSlice:
+            return destroy(reinterpret_cast<IrInstructionPtrOfArrayToSlice *>(inst), name);
+        case IrInstructionIdAssertZero:
+            return destroy(reinterpret_cast<IrInstructionAssertZero *>(inst), name);
+        case IrInstructionIdAssertNonNull:
+            return destroy(reinterpret_cast<IrInstructionAssertNonNull *>(inst), name);
+        case IrInstructionIdResizeSlice:
+            return destroy(reinterpret_cast<IrInstructionResizeSlice *>(inst), name);
+        case IrInstructionIdHasDecl:
+            return destroy(reinterpret_cast<IrInstructionHasDecl *>(inst), name);
+        case IrInstructionIdUndeclaredIdent:
+            return destroy(reinterpret_cast<IrInstructionUndeclaredIdent *>(inst), name);
+        case IrInstructionIdAllocaSrc:
+            return destroy(reinterpret_cast<IrInstructionAllocaSrc *>(inst), name);
+        case IrInstructionIdAllocaGen:
+            return destroy(reinterpret_cast<IrInstructionAllocaGen *>(inst), name);
+        case IrInstructionIdEndExpr:
+            return destroy(reinterpret_cast<IrInstructionEndExpr *>(inst), name);
+        case IrInstructionIdUnionInitNamedField:
+            return destroy(reinterpret_cast<IrInstructionUnionInitNamedField *>(inst), name);
+        case IrInstructionIdSuspendBegin:
+            return destroy(reinterpret_cast<IrInstructionSuspendBegin *>(inst), name);
+        case IrInstructionIdSuspendFinish:
+            return destroy(reinterpret_cast<IrInstructionSuspendFinish *>(inst), name);
+        case IrInstructionIdResume:
+            return destroy(reinterpret_cast<IrInstructionResume *>(inst), name);
+        case IrInstructionIdAwaitSrc:
+            return destroy(reinterpret_cast<IrInstructionAwaitSrc *>(inst), name);
+        case IrInstructionIdAwaitGen:
+            return destroy(reinterpret_cast<IrInstructionAwaitGen *>(inst), name);
+        case IrInstructionIdSpillBegin:
+            return destroy(reinterpret_cast<IrInstructionSpillBegin *>(inst), name);
+        case IrInstructionIdSpillEnd:
+            return destroy(reinterpret_cast<IrInstructionSpillEnd *>(inst), name);
+        case IrInstructionIdVectorExtractElem:
+            return destroy(reinterpret_cast<IrInstructionVectorExtractElem *>(inst), name);
+    }
+    zig_unreachable();
+}
+
 static void ira_ref(IrAnalyze *ira) {
     ira->ref_count += 1;
 }
@@ -262,6 +609,22 @@ static void ira_deref(IrAnalyze *ira) {
         return;
     }
     assert(ira->ref_count != 0);
+
+    for (size_t bb_i = 0; bb_i < ira->old_irb.exec->basic_block_list.length; bb_i += 1) {
+        IrBasicBlock *pass1_bb = ira->old_irb.exec->basic_block_list.items[bb_i];
+        for (size_t inst_i = 0; inst_i < pass1_bb->instruction_list.length; inst_i += 1) {
+            IrInstruction *pass1_inst = pass1_bb->instruction_list.items[inst_i];
+            destroy_instruction(pass1_inst);
+        }
+        destroy(pass1_bb, "IrBasicBlock");
+    }
+    ira->old_irb.exec->basic_block_list.deinit();
+    ira->old_irb.exec->tld_list.deinit();
+    // cannot destroy here because of var->owner_exec
+    //destroy(ira->old_irb.exec, "IrExecutablePass1");
+    ira->src_implicit_return_type_list.deinit();
+    ira->resume_stack.deinit();
+    ira->exec_context.mem_slot_list.deinit();
     destroy(ira, "IrAnalyze");
 }
 
@@ -4202,7 +4565,7 @@ static IrInstruction *ir_gen_bool_and(IrBuilder *irb, Scope *scope, AstNode *nod
     IrInstruction **incoming_values = allocate<IrInstruction *>(2);
     incoming_values[0] = val1;
     incoming_values[1] = val2;
-    IrBasicBlock **incoming_blocks = allocate<IrBasicBlock *>(2);
+    IrBasicBlock **incoming_blocks = allocate<IrBasicBlock *>(2, "IrBasicBlock *");
     incoming_blocks[0] = post_val1_block;
     incoming_blocks[1] = post_val2_block;
 
@@ -4292,7 +4655,7 @@ static IrInstruction *ir_gen_orelse(IrBuilder *irb, Scope *parent_scope, AstNode
     IrInstruction **incoming_values = allocate<IrInstruction *>(2);
     incoming_values[0] = null_result;
     incoming_values[1] = unwrapped_payload;
-    IrBasicBlock **incoming_blocks = allocate<IrBasicBlock *>(2);
+    IrBasicBlock **incoming_blocks = allocate<IrBasicBlock *>(2, "IrBasicBlock *");
     incoming_blocks[0] = after_null_block;
     incoming_blocks[1] = after_ok_block;
     IrInstruction *phi = ir_build_phi(irb, parent_scope, node, 2, incoming_blocks, incoming_values, peer_parent);
@@ -6057,7 +6420,7 @@ static IrInstruction *ir_gen_if_bool_expr(IrBuilder *irb, Scope *scope, AstNode
     IrInstruction **incoming_values = allocate<IrInstruction *>(2);
     incoming_values[0] = then_expr_result;
     incoming_values[1] = else_expr_result;
-    IrBasicBlock **incoming_blocks = allocate<IrBasicBlock *>(2);
+    IrBasicBlock **incoming_blocks = allocate<IrBasicBlock *>(2, "IrBasicBlock *");
     incoming_blocks[0] = after_then_block;
     incoming_blocks[1] = after_else_block;
 
@@ -7409,7 +7772,7 @@ static IrInstruction *ir_gen_if_optional_expr(IrBuilder *irb, Scope *scope, AstN
     IrInstruction **incoming_values = allocate<IrInstruction *>(2);
     incoming_values[0] = then_expr_result;
     incoming_values[1] = else_expr_result;
-    IrBasicBlock **incoming_blocks = allocate<IrBasicBlock *>(2);
+    IrBasicBlock **incoming_blocks = allocate<IrBasicBlock *>(2, "IrBasicBlock *");
     incoming_blocks[0] = after_then_block;
     incoming_blocks[1] = after_else_block;
 
@@ -7506,7 +7869,7 @@ static IrInstruction *ir_gen_if_err_expr(IrBuilder *irb, Scope *scope, AstNode *
     IrInstruction **incoming_values = allocate<IrInstruction *>(2);
     incoming_values[0] = then_expr_result;
     incoming_values[1] = else_expr_result;
-    IrBasicBlock **incoming_blocks = allocate<IrBasicBlock *>(2);
+    IrBasicBlock **incoming_blocks = allocate<IrBasicBlock *>(2, "IrBasicBlock *");
     incoming_blocks[0] = after_then_block;
     incoming_blocks[1] = after_else_block;
 
@@ -8102,7 +8465,7 @@ static IrInstruction *ir_gen_catch(IrBuilder *irb, Scope *parent_scope, AstNode
     IrInstruction **incoming_values = allocate<IrInstruction *>(2);
     incoming_values[0] = err_result;
     incoming_values[1] = unwrapped_payload;
-    IrBasicBlock **incoming_blocks = allocate<IrBasicBlock *>(2);
+    IrBasicBlock **incoming_blocks = allocate<IrBasicBlock *>(2, "IrBasicBlock *");
     incoming_blocks[0] = after_err_block;
     incoming_blocks[1] = after_ok_block;
     IrInstruction *phi = ir_build_phi(irb, parent_scope, node, 2, incoming_blocks, incoming_values, peer_parent);
@@ -8690,7 +9053,7 @@ bool ir_gen(CodeGen *codegen, AstNode *node, Scope *scope, IrExecutable *ir_exec
 bool ir_gen_fn(CodeGen *codegen, ZigFn *fn_entry) {
     assert(fn_entry);
 
-    IrExecutable *ir_executable = &fn_entry->ir_executable;
+    IrExecutable *ir_executable = fn_entry->ir_executable;
     AstNode *body_node = fn_entry->body_node;
 
     assert(fn_entry->child_scope);
@@ -11565,7 +11928,7 @@ ZigValue *ir_eval_const_value(CodeGen *codegen, Scope *scope, AstNode *node,
     if (expected_type != nullptr && type_is_invalid(expected_type))
         return codegen->invalid_instruction->value;
 
-    IrExecutable *ir_executable = allocate<IrExecutable>(1);
+    IrExecutable *ir_executable = allocate<IrExecutable>(1, "IrExecutablePass1");
     ir_executable->source_node = source_node;
     ir_executable->parent_exec = parent_exec;
     ir_executable->name = exec_name;
@@ -11587,7 +11950,7 @@ ZigValue *ir_eval_const_value(CodeGen *codegen, Scope *scope, AstNode *node,
         ir_print(codegen, stderr, ir_executable, 2, IrPassSrc);
         fprintf(stderr, "}\n");
     }
-    IrExecutable *analyzed_executable = allocate<IrExecutable>(1);
+    IrExecutable *analyzed_executable = allocate<IrExecutable>(1, "IrExecutablePass2");
     analyzed_executable->source_node = source_node;
     analyzed_executable->parent_exec = parent_exec;
     analyzed_executable->source_exec = ir_executable;
@@ -15752,6 +16115,7 @@ static IrInstruction *ir_analyze_instruction_decl_var(IrAnalyze *ira,
             assert(var->mem_slot_index < ira->exec_context.mem_slot_list.length);
             ZigValue *mem_slot = ira->exec_context.mem_slot_list.at(var->mem_slot_index);
             copy_const_val(mem_slot, init_val, !is_comptime_var || var->gen_is_const);
+            ira_ref(var->owner_exec->analysis);
 
             if (is_comptime_var || (var_class_requires_const && var->gen_is_const)) {
                 return ir_const_void(ira, &decl_var_instruction->base);
@@ -17522,8 +17886,8 @@ static IrInstruction *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCallSrc *c
             if (type_is_invalid(impl_fn->type_entry))
                 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;
+            impl_fn->ir_executable->source_node = call_instruction->base.source_node;
+            impl_fn->ir_executable->parent_exec = ira->new_irb.exec;
             impl_fn->analyzed_executable.source_node = call_instruction->base.source_node;
             impl_fn->analyzed_executable.parent_exec = ira->new_irb.exec;
             impl_fn->analyzed_executable.backward_branch_quota = ira->new_irb.exec->backward_branch_quota;
diff --git a/src/list.hpp b/src/list.hpp
index 59782b46a..4b2833843 100644
--- a/src/list.hpp
+++ b/src/list.hpp
@@ -13,7 +13,7 @@
 template<typename T>
 struct ZigList {
     void deinit() {
-        free(items);
+        deallocate(items, capacity);
     }
     void append(const T& item) {
         ensure_capacity(length + 1);