Commit 4e9b1f5479e3b7ce47d059e0e6f3d62cd4ee7254 | zig

author	Andrew Kelley <andrew@ziglang.org> 2020-01-25 23:24:41-05:00
committer	GitHub <noreply@github.com> 2020-01-25 23:24:41-05:00
log	4e9b1f5479e3b7ce47d059e0e6f3d62cd4ee7254
tree	05564ca6ace71b9baf054099a0e79b473d47b9ff
parent	aaa2f9ab2febf9e8be9bb284cd8d5e3f6c2c54f1
parent	32f0039b436a4c30b1bffef28e2f5c00ad5974bb
signature	Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #4290 from ziglang/split-ir-structs

split IrInstruction into IrInst, IrInstSrc, IrInstGen

9 files changed, 11124 insertions(+), 9106 deletions(-)

src/all_types.hpp+1380-908

...	...	@@ -33,12 +33,15 @@ struct BuiltinFnEntry;
33	33	struct TypeStructField;
34	34	struct CodeGen;
35	35	struct ZigValue;
36		struct IrInstruction;
37		struct IrInstructionCast;
38		struct IrInstructionAllocaGen;
39		struct IrInstructionCallGen;
40		struct IrInstructionAwaitGen;
41		struct IrBasicBlock;
	36	struct IrInst;
	37	struct IrInstSrc;
	38	struct IrInstGen;
	39	struct IrInstGenCast;
	40	struct IrInstGenAlloca;
	41	struct IrInstGenCall;
	42	struct IrInstGenAwait;
	43	struct IrBasicBlockSrc;
	44	struct IrBasicBlockGen;
42	45	struct ScopeDecls;
43	46	struct ZigWindowsSDK;
44	47	struct Tld;
...	...	@@ -50,6 +53,7 @@ struct ResultLocPeerParent;
50	53	struct ResultLocBitCast;
51	54	struct ResultLocCast;
52	55	struct ResultLocReturn;
	56	struct IrExecutableGen;
53	57
54	58	enum PtrLen {
55	59	PtrLenUnknown,
...	...	@@ -97,8 +101,8 @@ enum X64CABIClass {
97	101	X64CABIClass_SSE,
98	102	};
99	103
100		struct IrExecutable {
101		ZigList<IrBasicBlock *> basic_block_list;
	104	struct IrExecutableSrc {
	105	ZigList<IrBasicBlockSrc *> basic_block_list;
102	106	Buf *name;
103	107	ZigFn *name_fn;
104	108	size_t mem_slot_count;
...	...	@@ -108,8 +112,7 @@ struct IrExecutable {
108	112	ZigFn *fn_entry;
109	113	Buf *c_import_buf;
110	114	AstNode *source_node;
111		IrExecutable *parent_exec;
112		IrExecutable *source_exec;
	115	IrExecutableGen *parent_exec;
113	116	IrAnalyze *analysis;
114	117	Scope *begin_scope;
115	118	ErrorMsg *first_err_trace_msg;
...	...	@@ -124,6 +127,32 @@ struct IrExecutable {
124	127	void src();
125	128	};
126	129
	130	struct IrExecutableGen {
	131	ZigList<IrBasicBlockGen *> basic_block_list;
	132	Buf *name;
	133	ZigFn *name_fn;
	134	size_t mem_slot_count;
	135	size_t next_debug_id;
	136	size_t *backward_branch_count;
	137	size_t *backward_branch_quota;
	138	ZigFn *fn_entry;
	139	Buf *c_import_buf;
	140	AstNode *source_node;
	141	IrExecutableGen *parent_exec;
	142	IrExecutableSrc *source_exec;
	143	Scope *begin_scope;
	144	ErrorMsg *first_err_trace_msg;
	145	ZigList<Tld *> tld_list;
	146
	147	bool is_inline;
	148	bool is_generic_instantiation;
	149	bool need_err_code_spill;
	150
	151	// This is a function for use in the debugger to print
	152	// the source location.
	153	void src();
	154	};
	155
127	156	enum OutType {
128	157	OutTypeUnknown,
129	158	OutTypeExe,
...	...	@@ -287,7 +316,7 @@ struct ConstErrValue {
287	316
288	317	struct ConstBoundFnValue {
289	318	ZigFn *fn;
290		IrInstruction *first_arg;
	319	IrInstGen *first_arg;
291	320	};
292	321
293	322	struct ConstArgTuple {
...	...	@@ -350,14 +379,14 @@ struct LazyValueAlignOf {
350	379	LazyValue base;
351	380
352	381	IrAnalyze *ira;
353		IrInstruction *target_type;
	382	IrInstGen *target_type;
354	383	};
355	384
356	385	struct LazyValueSizeOf {
357	386	LazyValue base;
358	387
359	388	IrAnalyze *ira;
360		IrInstruction *target_type;
	389	IrInstGen *target_type;
361	390
362	391	bool bit_size;
363	392	};
...	...	@@ -366,9 +395,9 @@ struct LazyValueSliceType {
366	395	LazyValue base;
367	396
368	397	IrAnalyze *ira;
369		IrInstruction *sentinel; // can be null
370		IrInstruction *elem_type;
371		IrInstruction *align_inst; // can be null
	398	IrInstGen *sentinel; // can be null
	399	IrInstGen *elem_type;
	400	IrInstGen *align_inst; // can be null
372	401
373	402	bool is_const;
374	403	bool is_volatile;
...	...	@@ -379,8 +408,8 @@ struct LazyValueArrayType {
379	408	LazyValue base;
380	409
381	410	IrAnalyze *ira;
382		IrInstruction *sentinel; // can be null
383		IrInstruction *elem_type;
	411	IrInstGen *sentinel; // can be null
	412	IrInstGen *elem_type;
384	413	uint64_t length;
385	414	};
386	415
...	...	@@ -388,9 +417,9 @@ struct LazyValuePtrType {
388	417	LazyValue base;
389	418
390	419	IrAnalyze *ira;
391		IrInstruction *sentinel; // can be null
392		IrInstruction *elem_type;
393		IrInstruction *align_inst; // can be null
	420	IrInstGen *sentinel; // can be null
	421	IrInstGen *elem_type;
	422	IrInstGen *align_inst; // can be null
394	423
395	424	PtrLen ptr_len;
396	425	uint32_t bit_offset_in_host;
...	...	@@ -405,7 +434,7 @@ struct LazyValueOptType {
405	434	LazyValue base;
406	435
407	436	IrAnalyze *ira;
408		IrInstruction *payload_type;
	437	IrInstGen *payload_type;
409	438	};
410	439
411	440	struct LazyValueFnType {
...	...	@@ -413,9 +442,9 @@ struct LazyValueFnType {
413	442
414	443	IrAnalyze *ira;
415	444	AstNode *proto_node;
416		IrInstruction **param_types;
417		IrInstruction *align_inst; // can be null
418		IrInstruction *return_type;
	445	IrInstGen **param_types;
	446	IrInstGen *align_inst; // can be null
	447	IrInstGen *return_type;
419	448
420	449	CallingConvention cc;
421	450	bool is_generic;
...	...	@@ -425,8 +454,8 @@ struct LazyValueErrUnionType {
425	454	LazyValue base;
426	455
427	456	IrAnalyze *ira;
428		IrInstruction *err_set_type;
429		IrInstruction *payload_type;
	457	IrInstGen *err_set_type;
	458	IrInstGen *payload_type;
430	459	Buf *type_name;
431	460	};
432	461
...	...	@@ -1602,19 +1631,19 @@ struct ZigFn {
1602	1631	// in the case of async functions this is the implicit return type according to the
1603	1632	// zig source code, not according to zig ir
1604	1633	ZigType *src_implicit_return_type;
1605		IrExecutable *ir_executable;
1606		IrExecutable analyzed_executable;
	1634	IrExecutableSrc *ir_executable;
	1635	IrExecutableGen analyzed_executable;
1607	1636	size_t prealloc_bbc;
1608	1637	size_t prealloc_backward_branch_quota;
1609	1638	AstNode **param_source_nodes;
1610	1639	Buf **param_names;
1611		IrInstruction *err_code_spill;
	1640	IrInstGen *err_code_spill;
1612	1641	AstNode *assumed_non_async;
1613	1642
1614	1643	AstNode *fn_no_inline_set_node;
1615	1644	AstNode *fn_static_eval_set_node;
1616	1645
1617		ZigList<IrInstructionAllocaGen *> alloca_gen_list;
	1646	ZigList<IrInstGenAlloca *> alloca_gen_list;
1618	1647	ZigList<ZigVar *> variable_list;
1619	1648
1620	1649	Buf *section_name;
...	...	@@ -1626,8 +1655,8 @@ struct ZigFn {
1626	1655	AstNode *non_async_node;
1627	1656
1628	1657	ZigList<GlobalExport> export_list;
1629		ZigList<IrInstructionCallGen *> call_list;
1630		ZigList<IrInstructionAwaitGen *> await_list;
	1658	ZigList<IrInstGenCall *> call_list;
	1659	ZigList<IrInstGenAwait *> await_list;
1631	1660
1632	1661	LLVMValueRef valgrind_client_request_array;
1633	1662
...	...	@@ -2098,8 +2127,9 @@ struct CodeGen {
2098	2127	Buf *zig_c_headers_dir; // Cannot be overridden; derived from zig_lib_dir.
2099	2128	Buf *zig_std_special_dir; // Cannot be overridden; derived from zig_lib_dir.
2100	2129
2101		IrInstruction *invalid_instruction;
2102		IrInstruction *unreach_instruction;
	2130	IrInstSrc *invalid_inst_src;
	2131	IrInstGen *invalid_inst_gen;
	2132	IrInstGen *unreach_instruction;
2103	2133
2104	2134	ZigValue panic_msg_vals[PanicMsgIdCount];
2105	2135
...	...	@@ -2222,8 +2252,8 @@ struct ZigVar {
2222	2252	ZigValue *const_value;
2223	2253	ZigType *var_type;
2224	2254	LLVMValueRef value_ref;
2225		IrInstruction *is_comptime;
2226		IrInstruction *ptr_instruction;
	2255	IrInstSrc *is_comptime;
	2256	IrInstGen *ptr_instruction;
2227	2257	// which node is the declaration of the variable
2228	2258	AstNode *decl_node;
2229	2259	ZigLLVMDILocalVariable *di_loc_var;
...	...	@@ -2232,7 +2262,7 @@ struct ZigVar {
2232	2262	Scope *child_scope;
2233	2263	LLVMValueRef param_value_ref;
2234	2264	size_t mem_slot_index;
2235		IrExecutable *owner_exec;
	2265	IrExecutableSrc *owner_exec;
2236	2266
2237	2267	Buf *section_name;
2238	2268
...	...	@@ -2323,11 +2353,11 @@ struct ScopeBlock {
2323	2353	Scope base;
2324	2354
2325	2355	Buf *name;
2326		IrBasicBlock *end_block;
2327		IrInstruction *is_comptime;
	2356	IrBasicBlockSrc *end_block;
	2357	IrInstSrc *is_comptime;
2328	2358	ResultLocPeerParent *peer_parent;
2329		ZigList<IrInstruction > incoming_values;
2330		ZigList<IrBasicBlock > incoming_blocks;
	2359	ZigList<IrInstSrc > incoming_values;
	2360	ZigList<IrBasicBlockSrc > incoming_blocks;
2331	2361
2332	2362	AstNode *safety_set_node;
2333	2363	AstNode *fast_math_set_node;
...	...	@@ -2378,11 +2408,11 @@ struct ScopeLoop {
2378	2408
2379	2409	LVal lval;
2380	2410	Buf *name;
2381		IrBasicBlock *break_block;
2382		IrBasicBlock *continue_block;
2383		IrInstruction *is_comptime;
2384		ZigList<IrInstruction > incoming_values;
2385		ZigList<IrBasicBlock > incoming_blocks;
	2411	IrBasicBlockSrc *break_block;
	2412	IrBasicBlockSrc *continue_block;
	2413	IrInstSrc *is_comptime;
	2414	ZigList<IrInstSrc > incoming_values;
	2415	ZigList<IrBasicBlockSrc > incoming_blocks;
2386	2416	ResultLocPeerParent *peer_parent;
2387	2417	ScopeExpr *spill_scope;
2388	2418	};
...	...	@@ -2393,7 +2423,7 @@ struct ScopeLoop {
2393	2423	struct ScopeRuntime {
2394	2424	Scope base;
2395	2425
2396		IrInstruction *is_comptime;
	2426	IrInstSrc *is_comptime;
2397	2427	};
2398	2428
2399	2429	// This scope is created for a suspend block in order to have labeled
...	...	@@ -2472,319 +2502,450 @@ enum AtomicRmwOp {
2472	2502	// to another basic block.
2473	2503	// Phi instructions must be first in a basic block.
2474	2504	// The last instruction in a basic block must be of type unreachable.
2475		struct IrBasicBlock {
2476		ZigList<IrInstruction *> instruction_list;
2477		IrBasicBlock *other;
	2505	struct IrBasicBlockSrc {
	2506	ZigList<IrInstSrc *> instruction_list;
	2507	IrBasicBlockGen *child;
	2508	Scope *scope;
	2509	const char *name_hint;
	2510	IrInst *suspend_instruction_ref;
	2511
	2512	uint32_t ref_count;
	2513	uint32_t index; // index into the basic block list
	2514
	2515	uint32_t debug_id;
	2516	bool suspended;
	2517	bool in_resume_stack;
	2518	};
	2519
	2520	struct IrBasicBlockGen {
	2521	ZigList<IrInstGen *> instruction_list;
	2522	IrBasicBlockSrc *parent;
2478	2523	Scope *scope;
2479	2524	const char *name_hint;
2480		size_t debug_id;
2481		size_t ref_count;
2482		// index into the basic block list
2483		size_t index;
	2525	uint32_t index; // index into the basic block list
	2526	uint32_t ref_count;
2484	2527	LLVMBasicBlockRef llvm_block;
2485	2528	LLVMBasicBlockRef llvm_exit_block;
2486	2529	// The instruction that referenced this basic block and caused us to
2487	2530	// analyze the basic block. If the same instruction wants us to emit
2488	2531	// the same basic block, then we re-generate it instead of saving it.
2489		IrInstruction *ref_instruction;
	2532	IrInst *ref_instruction;
2490	2533	// When this is non-null, a branch to this basic block is only allowed
2491	2534	// if the branch is comptime. The instruction points to the reason
2492	2535	// the basic block must be comptime.
2493		IrInstruction *must_be_comptime_source_instr;
2494		IrInstruction *suspend_instruction_ref;
	2536	IrInst *must_be_comptime_source_instr;
	2537
	2538	uint32_t debug_id;
2495	2539	bool already_appended;
2496		bool suspended;
2497		bool in_resume_stack;
2498	2540	};
2499	2541
2500		// These instructions are in transition to having "pass 1" instructions
2501		// and "pass 2" instructions. The pass 1 instructions are suffixed with Src
2502		// and pass 2 are suffixed with Gen.
2503		// Once all instructions are separated in this way, they'll have different
2504		// base types for better type safety.
2505	2542	// Src instructions are generated by ir_gen_* functions in ir.cpp from AST.
2506	2543	// ir_analyze_* functions consume Src instructions and produce Gen instructions.
	2544	// Src instructions do not have type information; Gen instructions do.
	2545	enum IrInstSrcId {
	2546	IrInstSrcIdInvalid,
	2547	IrInstSrcIdDeclVar,
	2548	IrInstSrcIdBr,
	2549	IrInstSrcIdCondBr,
	2550	IrInstSrcIdSwitchBr,
	2551	IrInstSrcIdSwitchVar,
	2552	IrInstSrcIdSwitchElseVar,
	2553	IrInstSrcIdSwitchTarget,
	2554	IrInstSrcIdPhi,
	2555	IrInstSrcIdUnOp,
	2556	IrInstSrcIdBinOp,
	2557	IrInstSrcIdMergeErrSets,
	2558	IrInstSrcIdLoadPtr,
	2559	IrInstSrcIdStorePtr,
	2560	IrInstSrcIdFieldPtr,
	2561	IrInstSrcIdElemPtr,
	2562	IrInstSrcIdVarPtr,
	2563	IrInstSrcIdCall,
	2564	IrInstSrcIdCallArgs,
	2565	IrInstSrcIdCallExtra,
	2566	IrInstSrcIdConst,
	2567	IrInstSrcIdReturn,
	2568	IrInstSrcIdContainerInitList,
	2569	IrInstSrcIdContainerInitFields,
	2570	IrInstSrcIdUnreachable,
	2571	IrInstSrcIdTypeOf,
	2572	IrInstSrcIdSetCold,
	2573	IrInstSrcIdSetRuntimeSafety,
	2574	IrInstSrcIdSetFloatMode,
	2575	IrInstSrcIdArrayType,
	2576	IrInstSrcIdAnyFrameType,
	2577	IrInstSrcIdSliceType,
	2578	IrInstSrcIdAsm,
	2579	IrInstSrcIdSizeOf,
	2580	IrInstSrcIdTestNonNull,
	2581	IrInstSrcIdOptionalUnwrapPtr,
	2582	IrInstSrcIdClz,
	2583	IrInstSrcIdCtz,
	2584	IrInstSrcIdPopCount,
	2585	IrInstSrcIdBswap,
	2586	IrInstSrcIdBitReverse,
	2587	IrInstSrcIdImport,
	2588	IrInstSrcIdCImport,
	2589	IrInstSrcIdCInclude,
	2590	IrInstSrcIdCDefine,
	2591	IrInstSrcIdCUndef,
	2592	IrInstSrcIdRef,
	2593	IrInstSrcIdCompileErr,
	2594	IrInstSrcIdCompileLog,
	2595	IrInstSrcIdErrName,
	2596	IrInstSrcIdEmbedFile,
	2597	IrInstSrcIdCmpxchg,
	2598	IrInstSrcIdFence,
	2599	IrInstSrcIdTruncate,
	2600	IrInstSrcIdIntCast,
	2601	IrInstSrcIdFloatCast,
	2602	IrInstSrcIdIntToFloat,
	2603	IrInstSrcIdFloatToInt,
	2604	IrInstSrcIdBoolToInt,
	2605	IrInstSrcIdIntType,
	2606	IrInstSrcIdVectorType,
	2607	IrInstSrcIdShuffleVector,
	2608	IrInstSrcIdSplat,
	2609	IrInstSrcIdBoolNot,
	2610	IrInstSrcIdMemset,
	2611	IrInstSrcIdMemcpy,
	2612	IrInstSrcIdSlice,
	2613	IrInstSrcIdMemberCount,
	2614	IrInstSrcIdMemberType,
	2615	IrInstSrcIdMemberName,
	2616	IrInstSrcIdBreakpoint,
	2617	IrInstSrcIdReturnAddress,
	2618	IrInstSrcIdFrameAddress,
	2619	IrInstSrcIdFrameHandle,
	2620	IrInstSrcIdFrameType,
	2621	IrInstSrcIdFrameSize,
	2622	IrInstSrcIdAlignOf,
	2623	IrInstSrcIdOverflowOp,
	2624	IrInstSrcIdTestErr,
	2625	IrInstSrcIdMulAdd,
	2626	IrInstSrcIdFloatOp,
	2627	IrInstSrcIdUnwrapErrCode,
	2628	IrInstSrcIdUnwrapErrPayload,
	2629	IrInstSrcIdFnProto,
	2630	IrInstSrcIdTestComptime,
	2631	IrInstSrcIdPtrCast,
	2632	IrInstSrcIdBitCast,
	2633	IrInstSrcIdIntToPtr,
	2634	IrInstSrcIdPtrToInt,
	2635	IrInstSrcIdIntToEnum,
	2636	IrInstSrcIdEnumToInt,
	2637	IrInstSrcIdIntToErr,
	2638	IrInstSrcIdErrToInt,
	2639	IrInstSrcIdCheckSwitchProngs,
	2640	IrInstSrcIdCheckStatementIsVoid,
	2641	IrInstSrcIdTypeName,
	2642	IrInstSrcIdDeclRef,
	2643	IrInstSrcIdPanic,
	2644	IrInstSrcIdTagName,
	2645	IrInstSrcIdTagType,
	2646	IrInstSrcIdFieldParentPtr,
	2647	IrInstSrcIdByteOffsetOf,
	2648	IrInstSrcIdBitOffsetOf,
	2649	IrInstSrcIdTypeInfo,
	2650	IrInstSrcIdType,
	2651	IrInstSrcIdHasField,
	2652	IrInstSrcIdTypeId,
	2653	IrInstSrcIdSetEvalBranchQuota,
	2654	IrInstSrcIdPtrType,
	2655	IrInstSrcIdAlignCast,
	2656	IrInstSrcIdImplicitCast,
	2657	IrInstSrcIdResolveResult,
	2658	IrInstSrcIdResetResult,
	2659	IrInstSrcIdOpaqueType,
	2660	IrInstSrcIdSetAlignStack,
	2661	IrInstSrcIdArgType,
	2662	IrInstSrcIdExport,
	2663	IrInstSrcIdErrorReturnTrace,
	2664	IrInstSrcIdErrorUnion,
	2665	IrInstSrcIdAtomicRmw,
	2666	IrInstSrcIdAtomicLoad,
	2667	IrInstSrcIdAtomicStore,
	2668	IrInstSrcIdSaveErrRetAddr,
	2669	IrInstSrcIdAddImplicitReturnType,
	2670	IrInstSrcIdErrSetCast,
	2671	IrInstSrcIdToBytes,
	2672	IrInstSrcIdFromBytes,
	2673	IrInstSrcIdCheckRuntimeScope,
	2674	IrInstSrcIdHasDecl,
	2675	IrInstSrcIdUndeclaredIdent,
	2676	IrInstSrcIdAlloca,
	2677	IrInstSrcIdEndExpr,
	2678	IrInstSrcIdUnionInitNamedField,
	2679	IrInstSrcIdSuspendBegin,
	2680	IrInstSrcIdSuspendFinish,
	2681	IrInstSrcIdAwait,
	2682	IrInstSrcIdResume,
	2683	IrInstSrcIdSpillBegin,
	2684	IrInstSrcIdSpillEnd,
	2685	};
	2686
2507	2687	// ir_render_* functions in codegen.cpp consume Gen instructions and produce LLVM IR.
2508	2688	// Src instructions do not have type information; Gen instructions do.
2509		enum IrInstructionId {
2510		IrInstructionIdInvalid,
2511		IrInstructionIdDeclVarSrc,
2512		IrInstructionIdDeclVarGen,
2513		IrInstructionIdBr,
2514		IrInstructionIdCondBr,
2515		IrInstructionIdSwitchBr,
2516		IrInstructionIdSwitchVar,
2517		IrInstructionIdSwitchElseVar,
2518		IrInstructionIdSwitchTarget,
2519		IrInstructionIdPhi,
2520		IrInstructionIdUnOp,
2521		IrInstructionIdBinOp,
2522		IrInstructionIdMergeErrSets,
2523		IrInstructionIdLoadPtr,
2524		IrInstructionIdLoadPtrGen,
2525		IrInstructionIdStorePtr,
2526		IrInstructionIdVectorStoreElem,
2527		IrInstructionIdFieldPtr,
2528		IrInstructionIdStructFieldPtr,
2529		IrInstructionIdUnionFieldPtr,
2530		IrInstructionIdElemPtr,
2531		IrInstructionIdVarPtr,
2532		IrInstructionIdReturnPtr,
2533		IrInstructionIdCallSrc,
2534		IrInstructionIdCallSrcArgs,
2535		IrInstructionIdCallExtra,
2536		IrInstructionIdCallGen,
2537		IrInstructionIdConst,
2538		IrInstructionIdReturn,
2539		IrInstructionIdCast,
2540		IrInstructionIdResizeSlice,
2541		IrInstructionIdContainerInitList,
2542		IrInstructionIdContainerInitFields,
2543		IrInstructionIdUnreachable,
2544		IrInstructionIdTypeOf,
2545		IrInstructionIdSetCold,
2546		IrInstructionIdSetRuntimeSafety,
2547		IrInstructionIdSetFloatMode,
2548		IrInstructionIdArrayType,
2549		IrInstructionIdAnyFrameType,
2550		IrInstructionIdSliceType,
2551		IrInstructionIdAsmSrc,
2552		IrInstructionIdAsmGen,
2553		IrInstructionIdSizeOf,
2554		IrInstructionIdTestNonNull,
2555		IrInstructionIdOptionalUnwrapPtr,
2556		IrInstructionIdOptionalWrap,
2557		IrInstructionIdUnionTag,
2558		IrInstructionIdClz,
2559		IrInstructionIdCtz,
2560		IrInstructionIdPopCount,
2561		IrInstructionIdBswap,
2562		IrInstructionIdBitReverse,
2563		IrInstructionIdImport,
2564		IrInstructionIdCImport,
2565		IrInstructionIdCInclude,
2566		IrInstructionIdCDefine,
2567		IrInstructionIdCUndef,
2568		IrInstructionIdRef,
2569		IrInstructionIdRefGen,
2570		IrInstructionIdCompileErr,
2571		IrInstructionIdCompileLog,
2572		IrInstructionIdErrName,
2573		IrInstructionIdEmbedFile,
2574		IrInstructionIdCmpxchgSrc,
2575		IrInstructionIdCmpxchgGen,
2576		IrInstructionIdFence,
2577		IrInstructionIdTruncate,
2578		IrInstructionIdIntCast,
2579		IrInstructionIdFloatCast,
2580		IrInstructionIdIntToFloat,
2581		IrInstructionIdFloatToInt,
2582		IrInstructionIdBoolToInt,
2583		IrInstructionIdIntType,
2584		IrInstructionIdVectorType,
2585		IrInstructionIdShuffleVector,
2586		IrInstructionIdSplatSrc,
2587		IrInstructionIdSplatGen,
2588		IrInstructionIdBoolNot,
2589		IrInstructionIdMemset,
2590		IrInstructionIdMemcpy,
2591		IrInstructionIdSliceSrc,
2592		IrInstructionIdSliceGen,
2593		IrInstructionIdMemberCount,
2594		IrInstructionIdMemberType,
2595		IrInstructionIdMemberName,
2596		IrInstructionIdBreakpoint,
2597		IrInstructionIdReturnAddress,
2598		IrInstructionIdFrameAddress,
2599		IrInstructionIdFrameHandle,
2600		IrInstructionIdFrameType,
2601		IrInstructionIdFrameSizeSrc,
2602		IrInstructionIdFrameSizeGen,
2603		IrInstructionIdAlignOf,
2604		IrInstructionIdOverflowOp,
2605		IrInstructionIdTestErrSrc,
2606		IrInstructionIdTestErrGen,
2607		IrInstructionIdMulAdd,
2608		IrInstructionIdFloatOp,
2609		IrInstructionIdUnwrapErrCode,
2610		IrInstructionIdUnwrapErrPayload,
2611		IrInstructionIdErrWrapCode,
2612		IrInstructionIdErrWrapPayload,
2613		IrInstructionIdFnProto,
2614		IrInstructionIdTestComptime,
2615		IrInstructionIdPtrCastSrc,
2616		IrInstructionIdPtrCastGen,
2617		IrInstructionIdBitCastSrc,
2618		IrInstructionIdBitCastGen,
2619		IrInstructionIdWidenOrShorten,
2620		IrInstructionIdIntToPtr,
2621		IrInstructionIdPtrToInt,
2622		IrInstructionIdIntToEnum,
2623		IrInstructionIdEnumToInt,
2624		IrInstructionIdIntToErr,
2625		IrInstructionIdErrToInt,
2626		IrInstructionIdCheckSwitchProngs,
2627		IrInstructionIdCheckStatementIsVoid,
2628		IrInstructionIdTypeName,
2629		IrInstructionIdDeclRef,
2630		IrInstructionIdPanic,
2631		IrInstructionIdTagName,
2632		IrInstructionIdTagType,
2633		IrInstructionIdFieldParentPtr,
2634		IrInstructionIdByteOffsetOf,
2635		IrInstructionIdBitOffsetOf,
2636		IrInstructionIdTypeInfo,
2637		IrInstructionIdType,
2638		IrInstructionIdHasField,
2639		IrInstructionIdTypeId,
2640		IrInstructionIdSetEvalBranchQuota,
2641		IrInstructionIdPtrType,
2642		IrInstructionIdAlignCast,
2643		IrInstructionIdImplicitCast,
2644		IrInstructionIdResolveResult,
2645		IrInstructionIdResetResult,
2646		IrInstructionIdOpaqueType,
2647		IrInstructionIdSetAlignStack,
2648		IrInstructionIdArgType,
2649		IrInstructionIdExport,
2650		IrInstructionIdErrorReturnTrace,
2651		IrInstructionIdErrorUnion,
2652		IrInstructionIdAtomicRmw,
2653		IrInstructionIdAtomicLoad,
2654		IrInstructionIdAtomicStore,
2655		IrInstructionIdSaveErrRetAddr,
2656		IrInstructionIdAddImplicitReturnType,
2657		IrInstructionIdErrSetCast,
2658		IrInstructionIdToBytes,
2659		IrInstructionIdFromBytes,
2660		IrInstructionIdCheckRuntimeScope,
2661		IrInstructionIdVectorToArray,
2662		IrInstructionIdArrayToVector,
2663		IrInstructionIdAssertZero,
2664		IrInstructionIdAssertNonNull,
2665		IrInstructionIdHasDecl,
2666		IrInstructionIdUndeclaredIdent,
2667		IrInstructionIdAllocaSrc,
2668		IrInstructionIdAllocaGen,
2669		IrInstructionIdEndExpr,
2670		IrInstructionIdPtrOfArrayToSlice,
2671		IrInstructionIdUnionInitNamedField,
2672		IrInstructionIdSuspendBegin,
2673		IrInstructionIdSuspendFinish,
2674		IrInstructionIdAwaitSrc,
2675		IrInstructionIdAwaitGen,
2676		IrInstructionIdResume,
2677		IrInstructionIdSpillBegin,
2678		IrInstructionIdSpillEnd,
2679		IrInstructionIdVectorExtractElem,
2680		};
2681
2682		struct IrInstruction {
2683		Scope *scope;
2684		AstNode *source_node;
2685		LLVMValueRef llvm_value;
2686		ZigValue *value;
2687		uint32_t debug_id;
	2689	enum IrInstGenId {
	2690	IrInstGenIdInvalid,
	2691	IrInstGenIdDeclVar,
	2692	IrInstGenIdBr,
	2693	IrInstGenIdCondBr,
	2694	IrInstGenIdSwitchBr,
	2695	IrInstGenIdPhi,
	2696	IrInstGenIdBinaryNot,
	2697	IrInstGenIdNegation,
	2698	IrInstGenIdNegationWrapping,
	2699	IrInstGenIdBinOp,
	2700	IrInstGenIdLoadPtr,
	2701	IrInstGenIdStorePtr,
	2702	IrInstGenIdVectorStoreElem,
	2703	IrInstGenIdStructFieldPtr,
	2704	IrInstGenIdUnionFieldPtr,
	2705	IrInstGenIdElemPtr,
	2706	IrInstGenIdVarPtr,
	2707	IrInstGenIdReturnPtr,
	2708	IrInstGenIdCall,
	2709	IrInstGenIdReturn,
	2710	IrInstGenIdCast,
	2711	IrInstGenIdResizeSlice,
	2712	IrInstGenIdUnreachable,
	2713	IrInstGenIdAsm,
	2714	IrInstGenIdTestNonNull,
	2715	IrInstGenIdOptionalUnwrapPtr,
	2716	IrInstGenIdOptionalWrap,
	2717	IrInstGenIdUnionTag,
	2718	IrInstGenIdClz,
	2719	IrInstGenIdCtz,
	2720	IrInstGenIdPopCount,
	2721	IrInstGenIdBswap,
	2722	IrInstGenIdBitReverse,
	2723	IrInstGenIdRef,
	2724	IrInstGenIdErrName,
	2725	IrInstGenIdCmpxchg,
	2726	IrInstGenIdFence,
	2727	IrInstGenIdTruncate,
	2728	IrInstGenIdShuffleVector,
	2729	IrInstGenIdSplat,
	2730	IrInstGenIdBoolNot,
	2731	IrInstGenIdMemset,
	2732	IrInstGenIdMemcpy,
	2733	IrInstGenIdSlice,
	2734	IrInstGenIdBreakpoint,
	2735	IrInstGenIdReturnAddress,
	2736	IrInstGenIdFrameAddress,
	2737	IrInstGenIdFrameHandle,
	2738	IrInstGenIdFrameSize,
	2739	IrInstGenIdOverflowOp,
	2740	IrInstGenIdTestErr,
	2741	IrInstGenIdMulAdd,
	2742	IrInstGenIdFloatOp,
	2743	IrInstGenIdUnwrapErrCode,
	2744	IrInstGenIdUnwrapErrPayload,
	2745	IrInstGenIdErrWrapCode,
	2746	IrInstGenIdErrWrapPayload,
	2747	IrInstGenIdPtrCast,
	2748	IrInstGenIdBitCast,
	2749	IrInstGenIdWidenOrShorten,
	2750	IrInstGenIdIntToPtr,
	2751	IrInstGenIdPtrToInt,
	2752	IrInstGenIdIntToEnum,
	2753	IrInstGenIdIntToErr,
	2754	IrInstGenIdErrToInt,
	2755	IrInstGenIdPanic,
	2756	IrInstGenIdTagName,
	2757	IrInstGenIdFieldParentPtr,
	2758	IrInstGenIdAlignCast,
	2759	IrInstGenIdErrorReturnTrace,
	2760	IrInstGenIdAtomicRmw,
	2761	IrInstGenIdAtomicLoad,
	2762	IrInstGenIdAtomicStore,
	2763	IrInstGenIdSaveErrRetAddr,
	2764	IrInstGenIdVectorToArray,
	2765	IrInstGenIdArrayToVector,
	2766	IrInstGenIdAssertZero,
	2767	IrInstGenIdAssertNonNull,
	2768	IrInstGenIdPtrOfArrayToSlice,
	2769	IrInstGenIdSuspendBegin,
	2770	IrInstGenIdSuspendFinish,
	2771	IrInstGenIdAwait,
	2772	IrInstGenIdResume,
	2773	IrInstGenIdSpillBegin,
	2774	IrInstGenIdSpillEnd,
	2775	IrInstGenIdVectorExtractElem,
	2776	IrInstGenIdAlloca,
	2777	IrInstGenIdConst,
	2778	};
	2779
	2780	// Common fields between IrInstSrc and IrInstGen. This allows future passes
	2781	// after pass2 to be added to zig.
	2782	struct IrInst {
2688	2783	// if ref_count is zero and the instruction has no side effects,
2689	2784	// the instruction can be omitted in codegen
2690	2785	uint32_t ref_count;
	2786	uint32_t debug_id;
	2787
	2788	Scope *scope;
	2789	AstNode *source_node;
	2790
	2791	// for debugging purposes, these are useful to call to inspect the instruction
	2792	void dump();
	2793	void src();
	2794	};
	2795
	2796	struct IrInstSrc {
	2797	IrInst base;
	2798
	2799	IrInstSrcId id;
	2800	// true if this instruction was generated by zig and not from user code
	2801	// this matters for the "unreachable code" compile error
	2802	bool is_gen;
	2803	bool is_noreturn;
	2804
2691	2805	// When analyzing IR, instructions that point to this instruction in the "old ir"
2692	2806	// can find the instruction that corresponds to this value in the "new ir"
2693	2807	// with this child field.
2694		IrInstruction *child;
2695		IrBasicBlock *owner_bb;
	2808	IrInstGen *child;
	2809	IrBasicBlockSrc *owner_bb;
	2810
	2811	// for debugging purposes, these are useful to call to inspect the instruction
	2812	void dump();
	2813	void src();
	2814	};
	2815
	2816	struct IrInstGen {
	2817	IrInst base;
	2818
	2819	IrInstGenId id;
	2820
	2821	LLVMValueRef llvm_value;
	2822	ZigValue *value;
	2823	IrBasicBlockGen *owner_bb;
2696	2824	// Nearly any instruction can have to be stored as a local variable before suspending
2697	2825	// and then loaded after resuming, in case there is an expression with a suspend point
2698	2826	// in it, such as: x + await y
2699		IrInstruction *spill;
2700		IrInstructionId id;
2701		// true if this instruction was generated by zig and not from user code
2702		bool is_gen;
	2827	IrInstGen *spill;
2703	2828
2704	2829	// for debugging purposes, these are useful to call to inspect the instruction
2705	2830	void dump();
2706	2831	void src();
2707	2832	};
2708	2833
2709		struct IrInstructionDeclVarSrc {
2710		IrInstruction base;
	2834	struct IrInstSrcDeclVar {
	2835	IrInstSrc base;
2711	2836
2712	2837	ZigVar *var;
2713		IrInstruction *var_type;
2714		IrInstruction *align_value;
2715		IrInstruction *ptr;
	2838	IrInstSrc *var_type;
	2839	IrInstSrc *align_value;
	2840	IrInstSrc *ptr;
2716	2841	};
2717	2842
2718		struct IrInstructionDeclVarGen {
2719		IrInstruction base;
	2843	struct IrInstGenDeclVar {
	2844	IrInstGen base;
2720	2845
2721	2846	ZigVar *var;
2722		IrInstruction *var_ptr;
	2847	IrInstGen *var_ptr;
2723	2848	};
2724	2849
2725		struct IrInstructionCondBr {
2726		IrInstruction base;
	2850	struct IrInstSrcCondBr {
	2851	IrInstSrc base;
2727	2852
2728		IrInstruction *condition;
2729		IrBasicBlock *then_block;
2730		IrBasicBlock *else_block;
2731		IrInstruction *is_comptime;
	2853	IrInstSrc *condition;
	2854	IrBasicBlockSrc *then_block;
	2855	IrBasicBlockSrc *else_block;
	2856	IrInstSrc *is_comptime;
2732	2857	ResultLoc *result_loc;
2733	2858	};
2734	2859
2735		struct IrInstructionBr {
2736		IrInstruction base;
	2860	struct IrInstGenCondBr {
	2861	IrInstGen base;
	2862
	2863	IrInstGen *condition;
	2864	IrBasicBlockGen *then_block;
	2865	IrBasicBlockGen *else_block;
	2866	};
	2867
	2868	struct IrInstSrcBr {
	2869	IrInstSrc base;
	2870
	2871	IrBasicBlockSrc *dest_block;
	2872	IrInstSrc *is_comptime;
	2873	};
	2874
	2875	struct IrInstGenBr {
	2876	IrInstGen base;
	2877
	2878	IrBasicBlockGen *dest_block;
	2879	};
	2880
	2881	struct IrInstSrcSwitchBrCase {
	2882	IrInstSrc *value;
	2883	IrBasicBlockSrc *block;
	2884	};
	2885
	2886	struct IrInstSrcSwitchBr {
	2887	IrInstSrc base;
2737	2888
2738		IrBasicBlock *dest_block;
2739		IrInstruction *is_comptime;
	2889	IrInstSrc *target_value;
	2890	IrBasicBlockSrc *else_block;
	2891	size_t case_count;
	2892	IrInstSrcSwitchBrCase *cases;
	2893	IrInstSrc *is_comptime;
	2894	IrInstSrc *switch_prongs_void;
2740	2895	};
2741	2896
2742		struct IrInstructionSwitchBrCase {
2743		IrInstruction *value;
2744		IrBasicBlock *block;
	2897	struct IrInstGenSwitchBrCase {
	2898	IrInstGen *value;
	2899	IrBasicBlockGen *block;
2745	2900	};
2746	2901
2747		struct IrInstructionSwitchBr {
2748		IrInstruction base;
	2902	struct IrInstGenSwitchBr {
	2903	IrInstGen base;
2749	2904
2750		IrInstruction *target_value;
2751		IrBasicBlock *else_block;
	2905	IrInstGen *target_value;
	2906	IrBasicBlockGen *else_block;
2752	2907	size_t case_count;
2753		IrInstructionSwitchBrCase *cases;
2754		IrInstruction *is_comptime;
2755		IrInstruction *switch_prongs_void;
	2908	IrInstGenSwitchBrCase *cases;
2756	2909	};
2757	2910
2758		struct IrInstructionSwitchVar {
2759		IrInstruction base;
	2911	struct IrInstSrcSwitchVar {
	2912	IrInstSrc base;
2760	2913
2761		IrInstruction *target_value_ptr;
2762		IrInstruction **prongs_ptr;
	2914	IrInstSrc *target_value_ptr;
	2915	IrInstSrc **prongs_ptr;
2763	2916	size_t prongs_len;
2764	2917	};
2765	2918
2766		struct IrInstructionSwitchElseVar {
2767		IrInstruction base;
	2919	struct IrInstSrcSwitchElseVar {
	2920	IrInstSrc base;
2768	2921
2769		IrInstruction *target_value_ptr;
2770		IrInstructionSwitchBr *switch_br;
	2922	IrInstSrc *target_value_ptr;
	2923	IrInstSrcSwitchBr *switch_br;
2771	2924	};
2772	2925
2773		struct IrInstructionSwitchTarget {
2774		IrInstruction base;
	2926	struct IrInstSrcSwitchTarget {
	2927	IrInstSrc base;
2775	2928
2776		IrInstruction *target_value_ptr;
	2929	IrInstSrc *target_value_ptr;
2777	2930	};
2778	2931
2779		struct IrInstructionPhi {
2780		IrInstruction base;
	2932	struct IrInstSrcPhi {
	2933	IrInstSrc base;
2781	2934
2782	2935	size_t incoming_count;
2783		IrBasicBlock **incoming_blocks;
2784		IrInstruction **incoming_values;
	2936	IrBasicBlockSrc **incoming_blocks;
	2937	IrInstSrc **incoming_values;
2785	2938	ResultLocPeerParent *peer_parent;
2786	2939	};
2787	2940
	2941	struct IrInstGenPhi {
	2942	IrInstGen base;
	2943
	2944	size_t incoming_count;
	2945	IrBasicBlockGen **incoming_blocks;
	2946	IrInstGen **incoming_values;
	2947	};
	2948
2788	2949	enum IrUnOp {
2789	2950	IrUnOpInvalid,
2790	2951	IrUnOpBinNot,
...	...	@@ -2794,15 +2955,30 @@ enum IrUnOp {
2794	2955	IrUnOpOptional,
2795	2956	};
2796	2957
2797		struct IrInstructionUnOp {
2798		IrInstruction base;
	2958	struct IrInstSrcUnOp {
	2959	IrInstSrc base;
2799	2960
2800	2961	IrUnOp op_id;
2801	2962	LVal lval;
2802		IrInstruction *value;
	2963	IrInstSrc *value;
2803	2964	ResultLoc *result_loc;
2804	2965	};
2805	2966
	2967	struct IrInstGenBinaryNot {
	2968	IrInstGen base;
	2969	IrInstGen *operand;
	2970	};
	2971
	2972	struct IrInstGenNegation {
	2973	IrInstGen base;
	2974	IrInstGen *operand;
	2975	};
	2976
	2977	struct IrInstGenNegationWrapping {
	2978	IrInstGen base;
	2979	IrInstGen *operand;
	2980	};
	2981
2806	2982	enum IrBinOp {
2807	2983	IrBinOpInvalid,
2808	2984	IrBinOpBoolOr,
...	...	@@ -2837,113 +3013,144 @@ enum IrBinOp {
2837	3013	IrBinOpArrayMult,
2838	3014	};
2839	3015
2840		struct IrInstructionBinOp {
2841		IrInstruction base;
	3016	struct IrInstSrcBinOp {
	3017	IrInstSrc base;
	3018
	3019	IrInstSrc *op1;
	3020	IrInstSrc *op2;
	3021	IrBinOp op_id;
	3022	bool safety_check_on;
	3023	};
	3024
	3025	struct IrInstGenBinOp {
	3026	IrInstGen base;
2842	3027
2843		IrInstruction *op1;
2844		IrInstruction *op2;
	3028	IrInstGen *op1;
	3029	IrInstGen *op2;
2845	3030	IrBinOp op_id;
2846	3031	bool safety_check_on;
2847	3032	};
2848	3033
2849		struct IrInstructionMergeErrSets {
2850		IrInstruction base;
	3034	struct IrInstSrcMergeErrSets {
	3035	IrInstSrc base;
2851	3036
2852		IrInstruction *op1;
2853		IrInstruction *op2;
	3037	IrInstSrc *op1;
	3038	IrInstSrc *op2;
2854	3039	Buf *type_name;
2855	3040	};
2856	3041
2857		struct IrInstructionLoadPtr {
2858		IrInstruction base;
	3042	struct IrInstSrcLoadPtr {
	3043	IrInstSrc base;
2859	3044
2860		IrInstruction *ptr;
	3045	IrInstSrc *ptr;
2861	3046	};
2862	3047
2863		struct IrInstructionLoadPtrGen {
2864		IrInstruction base;
	3048	struct IrInstGenLoadPtr {
	3049	IrInstGen base;
2865	3050
2866		IrInstruction *ptr;
2867		IrInstruction *result_loc;
	3051	IrInstGen *ptr;
	3052	IrInstGen *result_loc;
2868	3053	};
2869	3054
2870		struct IrInstructionStorePtr {
2871		IrInstruction base;
	3055	struct IrInstSrcStorePtr {
	3056	IrInstSrc base;
	3057
	3058	IrInstSrc *ptr;
	3059	IrInstSrc *value;
2872	3060
2873	3061	bool allow_write_through_const;
2874		IrInstruction *ptr;
2875		IrInstruction *value;
2876	3062	};
2877	3063
2878		struct IrInstructionVectorStoreElem {
2879		IrInstruction base;
	3064	struct IrInstGenStorePtr {
	3065	IrInstGen base;
2880	3066
2881		IrInstruction *vector_ptr;
2882		IrInstruction *index;
2883		IrInstruction *value;
	3067	IrInstGen *ptr;
	3068	IrInstGen *value;
2884	3069	};
2885	3070
2886		struct IrInstructionFieldPtr {
2887		IrInstruction base;
	3071	struct IrInstGenVectorStoreElem {
	3072	IrInstGen base;
2888	3073
2889		bool initializing;
2890		IrInstruction *container_ptr;
	3074	IrInstGen *vector_ptr;
	3075	IrInstGen *index;
	3076	IrInstGen *value;
	3077	};
	3078
	3079	struct IrInstSrcFieldPtr {
	3080	IrInstSrc base;
	3081
	3082	IrInstSrc *container_ptr;
2891	3083	Buf *field_name_buffer;
2892		IrInstruction *field_name_expr;
	3084	IrInstSrc *field_name_expr;
	3085	bool initializing;
2893	3086	};
2894	3087
2895		struct IrInstructionStructFieldPtr {
2896		IrInstruction base;
	3088	struct IrInstGenStructFieldPtr {
	3089	IrInstGen base;
2897	3090
2898		IrInstruction *struct_ptr;
	3091	IrInstGen *struct_ptr;
2899	3092	TypeStructField *field;
2900	3093	bool is_const;
2901	3094	};
2902	3095
2903		struct IrInstructionUnionFieldPtr {
2904		IrInstruction base;
	3096	struct IrInstGenUnionFieldPtr {
	3097	IrInstGen base;
2905	3098
	3099	IrInstGen *union_ptr;
	3100	TypeUnionField *field;
2906	3101	bool safety_check_on;
2907	3102	bool initializing;
2908		IrInstruction *union_ptr;
2909		TypeUnionField *field;
2910	3103	};
2911	3104
2912		struct IrInstructionElemPtr {
2913		IrInstruction base;
	3105	struct IrInstSrcElemPtr {
	3106	IrInstSrc base;
2914	3107
2915		IrInstruction *array_ptr;
2916		IrInstruction *elem_index;
	3108	IrInstSrc *array_ptr;
	3109	IrInstSrc *elem_index;
2917	3110	AstNode *init_array_type_source_node;
2918	3111	PtrLen ptr_len;
2919	3112	bool safety_check_on;
2920	3113	};
2921	3114
2922		struct IrInstructionVarPtr {
2923		IrInstruction base;
	3115	struct IrInstGenElemPtr {
	3116	IrInstGen base;
	3117
	3118	IrInstGen *array_ptr;
	3119	IrInstGen *elem_index;
	3120	bool safety_check_on;
	3121	};
	3122
	3123	struct IrInstSrcVarPtr {
	3124	IrInstSrc base;
2924	3125
2925	3126	ZigVar *var;
2926	3127	ScopeFnDef *crossed_fndef_scope;
2927	3128	};
2928	3129
	3130	struct IrInstGenVarPtr {
	3131	IrInstGen base;
	3132
	3133	ZigVar *var;
	3134	};
	3135
2929	3136	// For functions that have a return type for which handle_is_ptr is true, a
2930	3137	// result location pointer is the secret first parameter ("sret"). This
2931	3138	// instruction returns that pointer.
2932		struct IrInstructionReturnPtr {
2933		IrInstruction base;
	3139	struct IrInstGenReturnPtr {
	3140	IrInstGen base;
2934	3141	};
2935	3142
2936		struct IrInstructionCallSrc {
2937		IrInstruction base;
	3143	struct IrInstSrcCall {
	3144	IrInstSrc base;
2938	3145
2939		IrInstruction *fn_ref;
	3146	IrInstSrc *fn_ref;
2940	3147	ZigFn *fn_entry;
2941	3148	size_t arg_count;
2942		IrInstruction **args;
2943		IrInstruction *ret_ptr;
	3149	IrInstSrc **args;
	3150	IrInstSrc *ret_ptr;
2944	3151	ResultLoc *result_loc;
2945	3152
2946		IrInstruction *new_stack;
	3153	IrInstSrc *new_stack;
2947	3154
2948	3155	CallModifier modifier;
2949	3156	bool is_async_call_builtin;
...	...	@@ -2951,12 +3158,12 @@ struct IrInstructionCallSrc {
2951	3158
2952	3159	// This is a pass1 instruction, used by @call when the args node is
2953	3160	// a tuple or struct literal.
2954		struct IrInstructionCallSrcArgs {
2955		IrInstruction base;
	3161	struct IrInstSrcCallArgs {
	3162	IrInstSrc base;
2956	3163
2957		IrInstruction *options;
2958		IrInstruction *fn_ref;
2959		IrInstruction **args_ptr;
	3164	IrInstSrc *options;
	3165	IrInstSrc *fn_ref;
	3166	IrInstSrc **args_ptr;
2960	3167	size_t args_len;
2961	3168	ResultLoc *result_loc;
2962	3169	};
...	...	@@ -2964,42 +3171,54 @@ struct IrInstructionCallSrcArgs {
2964	3171	// This is a pass1 instruction, used by @call, when the args node
2965	3172	// is not a literal.
2966	3173	// `args` is expected to be either a struct or a tuple.
2967		struct IrInstructionCallExtra {
2968		IrInstruction base;
	3174	struct IrInstSrcCallExtra {
	3175	IrInstSrc base;
2969	3176
2970		IrInstruction *options;
2971		IrInstruction *fn_ref;
2972		IrInstruction *args;
	3177	IrInstSrc *options;
	3178	IrInstSrc *fn_ref;
	3179	IrInstSrc *args;
2973	3180	ResultLoc *result_loc;
2974	3181	};
2975	3182
2976		struct IrInstructionCallGen {
2977		IrInstruction base;
	3183	struct IrInstGenCall {
	3184	IrInstGen base;
2978	3185
2979		IrInstruction *fn_ref;
	3186	IrInstGen *fn_ref;
2980	3187	ZigFn *fn_entry;
2981	3188	size_t arg_count;
2982		IrInstruction **args;
2983		IrInstruction *result_loc;
2984		IrInstruction *frame_result_loc;
2985		IrInstruction *new_stack;
	3189	IrInstGen **args;
	3190	IrInstGen *result_loc;
	3191	IrInstGen *frame_result_loc;
	3192	IrInstGen *new_stack;
2986	3193
2987	3194	CallModifier modifier;
2988	3195
2989	3196	bool is_async_call_builtin;
2990	3197	};
2991	3198
2992		struct IrInstructionConst {
2993		IrInstruction base;
	3199	struct IrInstSrcConst {
	3200	IrInstSrc base;
	3201
	3202	ZigValue *value;
	3203	};
	3204
	3205	struct IrInstGenConst {
	3206	IrInstGen base;
	3207	};
	3208
	3209	struct IrInstSrcReturn {
	3210	IrInstSrc base;
	3211
	3212	IrInstSrc *operand;
2994	3213	};
2995	3214
2996	3215	// When an IrExecutable is not in a function, a return instruction means that
2997	3216	// the expression returns with that value, even though a return statement from
2998	3217	// an AST perspective is invalid.
2999		struct IrInstructionReturn {
3000		IrInstruction base;
	3218	struct IrInstGenReturn {
	3219	IrInstGen base;
3001	3220
3002		IrInstruction *operand;
	3221	IrInstGen *operand;
3003	3222	};
3004	3223
3005	3224	enum CastOp {
...	...	@@ -3014,89 +3233,92 @@ enum CastOp {
3014	3233	};
3015	3234
3016	3235	// TODO get rid of this instruction, replace with instructions for each op code
3017		struct IrInstructionCast {
3018		IrInstruction base;
	3236	struct IrInstGenCast {
	3237	IrInstGen base;
3019	3238
3020		IrInstruction *value;
3021		ZigType *dest_type;
	3239	IrInstGen *value;
3022	3240	CastOp cast_op;
3023	3241	};
3024	3242
3025		struct IrInstructionResizeSlice {
3026		IrInstruction base;
	3243	struct IrInstGenResizeSlice {
	3244	IrInstGen base;
3027	3245
3028		IrInstruction *operand;
3029		IrInstruction *result_loc;
	3246	IrInstGen *operand;
	3247	IrInstGen *result_loc;
3030	3248	};
3031	3249
3032		struct IrInstructionContainerInitList {
3033		IrInstruction base;
	3250	struct IrInstSrcContainerInitList {
	3251	IrInstSrc base;
3034	3252
3035		IrInstruction *elem_type;
	3253	IrInstSrc *elem_type;
3036	3254	size_t item_count;
3037		IrInstruction **elem_result_loc_list;
3038		IrInstruction *result_loc;
	3255	IrInstSrc **elem_result_loc_list;
	3256	IrInstSrc *result_loc;
3039	3257	AstNode *init_array_type_source_node;
3040	3258	};
3041	3259
3042		struct IrInstructionContainerInitFieldsField {
	3260	struct IrInstSrcContainerInitFieldsField {
3043	3261	Buf *name;
3044	3262	AstNode *source_node;
3045	3263	TypeStructField *type_struct_field;
3046		IrInstruction *result_loc;
	3264	IrInstSrc *result_loc;
3047	3265	};
3048	3266
3049		struct IrInstructionContainerInitFields {
3050		IrInstruction base;
	3267	struct IrInstSrcContainerInitFields {
	3268	IrInstSrc base;
3051	3269
3052	3270	size_t field_count;
3053		IrInstructionContainerInitFieldsField *fields;
3054		IrInstruction *result_loc;
	3271	IrInstSrcContainerInitFieldsField *fields;
	3272	IrInstSrc *result_loc;
	3273	};
	3274
	3275	struct IrInstSrcUnreachable {
	3276	IrInstSrc base;
3055	3277	};
3056	3278
3057		struct IrInstructionUnreachable {
3058		IrInstruction base;
	3279	struct IrInstGenUnreachable {
	3280	IrInstGen base;
3059	3281	};
3060	3282
3061		struct IrInstructionTypeOf {
3062		IrInstruction base;
	3283	struct IrInstSrcTypeOf {
	3284	IrInstSrc base;
3063	3285
3064		IrInstruction *value;
	3286	IrInstSrc *value;
3065	3287	};
3066	3288
3067		struct IrInstructionSetCold {
3068		IrInstruction base;
	3289	struct IrInstSrcSetCold {
	3290	IrInstSrc base;
3069	3291
3070		IrInstruction *is_cold;
	3292	IrInstSrc *is_cold;
3071	3293	};
3072	3294
3073		struct IrInstructionSetRuntimeSafety {
3074		IrInstruction base;
	3295	struct IrInstSrcSetRuntimeSafety {
	3296	IrInstSrc base;
3075	3297
3076		IrInstruction *safety_on;
	3298	IrInstSrc *safety_on;
3077	3299	};
3078	3300
3079		struct IrInstructionSetFloatMode {
3080		IrInstruction base;
	3301	struct IrInstSrcSetFloatMode {
	3302	IrInstSrc base;
3081	3303
3082		IrInstruction *scope_value;
3083		IrInstruction *mode_value;
	3304	IrInstSrc *scope_value;
	3305	IrInstSrc *mode_value;
3084	3306	};
3085	3307
3086		struct IrInstructionArrayType {
3087		IrInstruction base;
	3308	struct IrInstSrcArrayType {
	3309	IrInstSrc base;
3088	3310
3089		IrInstruction *size;
3090		IrInstruction *sentinel;
3091		IrInstruction *child_type;
	3311	IrInstSrc *size;
	3312	IrInstSrc *sentinel;
	3313	IrInstSrc *child_type;
3092	3314	};
3093	3315
3094		struct IrInstructionPtrType {
3095		IrInstruction base;
	3316	struct IrInstSrcPtrType {
	3317	IrInstSrc base;
3096	3318
3097		IrInstruction *sentinel;
3098		IrInstruction *align_value;
3099		IrInstruction *child_type;
	3319	IrInstSrc *sentinel;
	3320	IrInstSrc *align_value;
	3321	IrInstSrc *child_type;
3100	3322	uint32_t bit_offset_start;
3101	3323	uint32_t host_int_bytes;
3102	3324	PtrLen ptr_len;
...	...	@@ -3105,375 +3327,459 @@ struct IrInstructionPtrType {
3105	3327	bool is_allow_zero;
3106	3328	};
3107	3329
3108		struct IrInstructionAnyFrameType {
3109		IrInstruction base;
	3330	struct IrInstSrcAnyFrameType {
	3331	IrInstSrc base;
3110	3332
3111		IrInstruction *payload_type;
	3333	IrInstSrc *payload_type;
3112	3334	};
3113	3335
3114		struct IrInstructionSliceType {
3115		IrInstruction base;
	3336	struct IrInstSrcSliceType {
	3337	IrInstSrc base;
3116	3338
3117		IrInstruction *sentinel;
3118		IrInstruction *align_value;
3119		IrInstruction *child_type;
	3339	IrInstSrc *sentinel;
	3340	IrInstSrc *align_value;
	3341	IrInstSrc *child_type;
3120	3342	bool is_const;
3121	3343	bool is_volatile;
3122	3344	bool is_allow_zero;
3123	3345	};
3124	3346
3125		struct IrInstructionAsmSrc {
3126		IrInstruction base;
	3347	struct IrInstSrcAsm {
	3348	IrInstSrc base;
3127	3349
3128		IrInstruction *asm_template;
3129		IrInstruction **input_list;
3130		IrInstruction **output_types;
	3350	IrInstSrc *asm_template;
	3351	IrInstSrc **input_list;
	3352	IrInstSrc **output_types;
3131	3353	ZigVar **output_vars;
3132	3354	size_t return_count;
3133	3355	bool has_side_effects;
3134	3356	bool is_global;
3135	3357	};
3136	3358
3137		struct IrInstructionAsmGen {
3138		IrInstruction base;
	3359	struct IrInstGenAsm {
	3360	IrInstGen base;
3139	3361
3140	3362	Buf *asm_template;
3141	3363	AsmToken *token_list;
3142	3364	size_t token_list_len;
3143		IrInstruction **input_list;
3144		IrInstruction **output_types;
	3365	IrInstGen **input_list;
	3366	IrInstGen **output_types;
3145	3367	ZigVar **output_vars;
3146	3368	size_t return_count;
3147	3369	bool has_side_effects;
3148	3370	};
3149	3371
3150		struct IrInstructionSizeOf {
3151		IrInstruction base;
	3372	struct IrInstSrcSizeOf {
	3373	IrInstSrc base;
3152	3374
	3375	IrInstSrc *type_value;
3153	3376	bool bit_size;
3154		IrInstruction *type_value;
3155	3377	};
3156	3378
3157	3379	// returns true if nonnull, returns false if null
3158		// this is so that `zeroes` sets maybe values to null
3159		struct IrInstructionTestNonNull {
3160		IrInstruction base;
	3380	struct IrInstSrcTestNonNull {
	3381	IrInstSrc base;
	3382
	3383	IrInstSrc *value;
	3384	};
	3385
	3386	struct IrInstGenTestNonNull {
	3387	IrInstGen base;
3161	3388
3162		IrInstruction *value;
	3389	IrInstGen *value;
3163	3390	};
3164	3391
3165	3392	// Takes a pointer to an optional value, returns a pointer
3166	3393	// to the payload.
3167		struct IrInstructionOptionalUnwrapPtr {
3168		IrInstruction base;
	3394	struct IrInstSrcOptionalUnwrapPtr {
	3395	IrInstSrc base;
	3396
	3397	IrInstSrc *base_ptr;
	3398	bool safety_check_on;
	3399	bool initializing;
	3400	};
3169	3401
	3402	struct IrInstGenOptionalUnwrapPtr {
	3403	IrInstGen base;
	3404
	3405	IrInstGen *base_ptr;
3170	3406	bool safety_check_on;
3171	3407	bool initializing;
3172		IrInstruction *base_ptr;
3173	3408	};
3174	3409
3175		struct IrInstructionCtz {
3176		IrInstruction base;
	3410	struct IrInstSrcCtz {
	3411	IrInstSrc base;
	3412
	3413	IrInstSrc *type;
	3414	IrInstSrc *op;
	3415	};
	3416
	3417	struct IrInstGenCtz {
	3418	IrInstGen base;
	3419
	3420	IrInstGen *op;
	3421	};
	3422
	3423	struct IrInstSrcClz {
	3424	IrInstSrc base;
	3425
	3426	IrInstSrc *type;
	3427	IrInstSrc *op;
	3428	};
	3429
	3430	struct IrInstGenClz {
	3431	IrInstGen base;
3177	3432
3178		IrInstruction *type;
3179		IrInstruction *op;
	3433	IrInstGen *op;
3180	3434	};
3181	3435
3182		struct IrInstructionClz {
3183		IrInstruction base;
	3436	struct IrInstSrcPopCount {
	3437	IrInstSrc base;
3184	3438
3185		IrInstruction *type;
3186		IrInstruction *op;
	3439	IrInstSrc *type;
	3440	IrInstSrc *op;
3187	3441	};
3188	3442
3189		struct IrInstructionPopCount {
3190		IrInstruction base;
	3443	struct IrInstGenPopCount {
	3444	IrInstGen base;
3191	3445
3192		IrInstruction *type;
3193		IrInstruction *op;
	3446	IrInstGen *op;
3194	3447	};
3195	3448
3196		struct IrInstructionUnionTag {
3197		IrInstruction base;
	3449	struct IrInstGenUnionTag {
	3450	IrInstGen base;
3198	3451
3199		IrInstruction *value;
	3452	IrInstGen *value;
3200	3453	};
3201	3454
3202		struct IrInstructionImport {
3203		IrInstruction base;
	3455	struct IrInstSrcImport {
	3456	IrInstSrc base;
3204	3457
3205		IrInstruction *name;
	3458	IrInstSrc *name;
3206	3459	};
3207	3460
3208		struct IrInstructionRef {
3209		IrInstruction base;
	3461	struct IrInstSrcRef {
	3462	IrInstSrc base;
3210	3463
3211		IrInstruction *value;
	3464	IrInstSrc *value;
3212	3465	bool is_const;
3213	3466	bool is_volatile;
3214	3467	};
3215	3468
3216		struct IrInstructionRefGen {
3217		IrInstruction base;
	3469	struct IrInstGenRef {
	3470	IrInstGen base;
3218	3471
3219		IrInstruction *operand;
3220		IrInstruction *result_loc;
	3472	IrInstGen *operand;
	3473	IrInstGen *result_loc;
3221	3474	};
3222	3475
3223		struct IrInstructionCompileErr {
3224		IrInstruction base;
	3476	struct IrInstSrcCompileErr {
	3477	IrInstSrc base;
3225	3478
3226		IrInstruction *msg;
	3479	IrInstSrc *msg;
3227	3480	};
3228	3481
3229		struct IrInstructionCompileLog {
3230		IrInstruction base;
	3482	struct IrInstSrcCompileLog {
	3483	IrInstSrc base;
3231	3484
3232	3485	size_t msg_count;
3233		IrInstruction **msg_list;
	3486	IrInstSrc **msg_list;
3234	3487	};
3235	3488
3236		struct IrInstructionErrName {
3237		IrInstruction base;
	3489	struct IrInstSrcErrName {
	3490	IrInstSrc base;
3238	3491
3239		IrInstruction *value;
	3492	IrInstSrc *value;
3240	3493	};
3241	3494
3242		struct IrInstructionCImport {
3243		IrInstruction base;
	3495	struct IrInstGenErrName {
	3496	IrInstGen base;
	3497
	3498	IrInstGen *value;
	3499	};
	3500
	3501	struct IrInstSrcCImport {
	3502	IrInstSrc base;
3244	3503	};
3245	3504
3246		struct IrInstructionCInclude {
3247		IrInstruction base;
	3505	struct IrInstSrcCInclude {
	3506	IrInstSrc base;
3248	3507
3249		IrInstruction *name;
	3508	IrInstSrc *name;
3250	3509	};
3251	3510
3252		struct IrInstructionCDefine {
3253		IrInstruction base;
	3511	struct IrInstSrcCDefine {
	3512	IrInstSrc base;
3254	3513
3255		IrInstruction *name;
3256		IrInstruction *value;
	3514	IrInstSrc *name;
	3515	IrInstSrc *value;
3257	3516	};
3258	3517
3259		struct IrInstructionCUndef {
3260		IrInstruction base;
	3518	struct IrInstSrcCUndef {
	3519	IrInstSrc base;
3261	3520
3262		IrInstruction *name;
	3521	IrInstSrc *name;
3263	3522	};
3264	3523
3265		struct IrInstructionEmbedFile {
3266		IrInstruction base;
	3524	struct IrInstSrcEmbedFile {
	3525	IrInstSrc base;
3267	3526
3268		IrInstruction *name;
	3527	IrInstSrc *name;
3269	3528	};
3270	3529
3271		struct IrInstructionCmpxchgSrc {
3272		IrInstruction base;
	3530	struct IrInstSrcCmpxchg {
	3531	IrInstSrc base;
3273	3532
3274	3533	bool is_weak;
3275		IrInstruction *type_value;
3276		IrInstruction *ptr;
3277		IrInstruction *cmp_value;
3278		IrInstruction *new_value;
3279		IrInstruction *success_order_value;
3280		IrInstruction *failure_order_value;
	3534	IrInstSrc *type_value;
	3535	IrInstSrc *ptr;
	3536	IrInstSrc *cmp_value;
	3537	IrInstSrc *new_value;
	3538	IrInstSrc *success_order_value;
	3539	IrInstSrc *failure_order_value;
3281	3540	ResultLoc *result_loc;
3282	3541	};
3283	3542
3284		struct IrInstructionCmpxchgGen {
3285		IrInstruction base;
	3543	struct IrInstGenCmpxchg {
	3544	IrInstGen base;
3286	3545
3287		bool is_weak;
3288	3546	AtomicOrder success_order;
3289	3547	AtomicOrder failure_order;
3290		IrInstruction *ptr;
3291		IrInstruction *cmp_value;
3292		IrInstruction *new_value;
3293		IrInstruction *result_loc;
	3548	IrInstGen *ptr;
	3549	IrInstGen *cmp_value;
	3550	IrInstGen *new_value;
	3551	IrInstGen *result_loc;
	3552	bool is_weak;
3294	3553	};
3295	3554
3296		struct IrInstructionFence {
3297		IrInstruction base;
	3555	struct IrInstSrcFence {
	3556	IrInstSrc base;
	3557
	3558	IrInstSrc *order;
	3559	};
3298	3560
3299		IrInstruction *order_value;
	3561	struct IrInstGenFence {
	3562	IrInstGen base;
3300	3563
3301		// if this instruction gets to runtime then we know these values:
3302	3564	AtomicOrder order;
3303	3565	};
3304	3566
3305		struct IrInstructionTruncate {
3306		IrInstruction base;
	3567	struct IrInstSrcTruncate {
	3568	IrInstSrc base;
	3569
	3570	IrInstSrc *dest_type;
	3571	IrInstSrc *target;
	3572	};
	3573
	3574	struct IrInstGenTruncate {
	3575	IrInstGen base;
3307	3576
3308		IrInstruction *dest_type;
3309		IrInstruction *target;
	3577	IrInstGen *target;
3310	3578	};
3311	3579
3312		struct IrInstructionIntCast {
3313		IrInstruction base;
	3580	struct IrInstSrcIntCast {
	3581	IrInstSrc base;
3314	3582
3315		IrInstruction *dest_type;
3316		IrInstruction *target;
	3583	IrInstSrc *dest_type;
	3584	IrInstSrc *target;
3317	3585	};
3318	3586
3319		struct IrInstructionFloatCast {
3320		IrInstruction base;
	3587	struct IrInstSrcFloatCast {
	3588	IrInstSrc base;
3321	3589
3322		IrInstruction *dest_type;
3323		IrInstruction *target;
	3590	IrInstSrc *dest_type;
	3591	IrInstSrc *target;
3324	3592	};
3325	3593
3326		struct IrInstructionErrSetCast {
3327		IrInstruction base;
	3594	struct IrInstSrcErrSetCast {
	3595	IrInstSrc base;
3328	3596
3329		IrInstruction *dest_type;
3330		IrInstruction *target;
	3597	IrInstSrc *dest_type;
	3598	IrInstSrc *target;
3331	3599	};
3332	3600
3333		struct IrInstructionToBytes {
3334		IrInstruction base;
	3601	struct IrInstSrcToBytes {
	3602	IrInstSrc base;
3335	3603
3336		IrInstruction *target;
	3604	IrInstSrc *target;
3337	3605	ResultLoc *result_loc;
3338	3606	};
3339	3607
3340		struct IrInstructionFromBytes {
3341		IrInstruction base;
	3608	struct IrInstSrcFromBytes {
	3609	IrInstSrc base;
3342	3610
3343		IrInstruction *dest_child_type;
3344		IrInstruction *target;
	3611	IrInstSrc *dest_child_type;
	3612	IrInstSrc *target;
3345	3613	ResultLoc *result_loc;
3346	3614	};
3347	3615
3348		struct IrInstructionIntToFloat {
3349		IrInstruction base;
	3616	struct IrInstSrcIntToFloat {
	3617	IrInstSrc base;
3350	3618
3351		IrInstruction *dest_type;
3352		IrInstruction *target;
	3619	IrInstSrc *dest_type;
	3620	IrInstSrc *target;
3353	3621	};
3354	3622
3355		struct IrInstructionFloatToInt {
3356		IrInstruction base;
	3623	struct IrInstSrcFloatToInt {
	3624	IrInstSrc base;
3357	3625
3358		IrInstruction *dest_type;
3359		IrInstruction *target;
	3626	IrInstSrc *dest_type;
	3627	IrInstSrc *target;
3360	3628	};
3361	3629
3362		struct IrInstructionBoolToInt {
3363		IrInstruction base;
	3630	struct IrInstSrcBoolToInt {
	3631	IrInstSrc base;
3364	3632
3365		IrInstruction *target;
	3633	IrInstSrc *target;
3366	3634	};
3367	3635
3368		struct IrInstructionIntType {
3369		IrInstruction base;
	3636	struct IrInstSrcIntType {
	3637	IrInstSrc base;
3370	3638
3371		IrInstruction *is_signed;
3372		IrInstruction *bit_count;
	3639	IrInstSrc *is_signed;
	3640	IrInstSrc *bit_count;
3373	3641	};
3374	3642
3375		struct IrInstructionVectorType {
3376		IrInstruction base;
	3643	struct IrInstSrcVectorType {
	3644	IrInstSrc base;
3377	3645
3378		IrInstruction *len;
3379		IrInstruction *elem_type;
	3646	IrInstSrc *len;
	3647	IrInstSrc *elem_type;
3380	3648	};
3381	3649
3382		struct IrInstructionBoolNot {
3383		IrInstruction base;
	3650	struct IrInstSrcBoolNot {
	3651	IrInstSrc base;
3384	3652
3385		IrInstruction *value;
	3653	IrInstSrc *value;
3386	3654	};
3387	3655
3388		struct IrInstructionMemset {
3389		IrInstruction base;
	3656	struct IrInstGenBoolNot {
	3657	IrInstGen base;
3390	3658
3391		IrInstruction *dest_ptr;
3392		IrInstruction *byte;
3393		IrInstruction *count;
	3659	IrInstGen *value;
3394	3660	};
3395	3661
3396		struct IrInstructionMemcpy {
3397		IrInstruction base;
	3662	struct IrInstSrcMemset {
	3663	IrInstSrc base;
3398	3664
3399		IrInstruction *dest_ptr;
3400		IrInstruction *src_ptr;
3401		IrInstruction *count;
	3665	IrInstSrc *dest_ptr;
	3666	IrInstSrc *byte;
	3667	IrInstSrc *count;
3402	3668	};
3403	3669
3404		struct IrInstructionSliceSrc {
3405		IrInstruction base;
	3670	struct IrInstGenMemset {
	3671	IrInstGen base;
3406	3672
3407		bool safety_check_on;
3408		IrInstruction *ptr;
3409		IrInstruction *start;
3410		IrInstruction *end;
3411		IrInstruction *sentinel;
	3673	IrInstGen *dest_ptr;
	3674	IrInstGen *byte;
	3675	IrInstGen *count;
	3676	};
	3677
	3678	struct IrInstSrcMemcpy {
	3679	IrInstSrc base;
	3680
	3681	IrInstSrc *dest_ptr;
	3682	IrInstSrc *src_ptr;
	3683	IrInstSrc *count;
	3684	};
	3685
	3686	struct IrInstGenMemcpy {
	3687	IrInstGen base;
	3688
	3689	IrInstGen *dest_ptr;
	3690	IrInstGen *src_ptr;
	3691	IrInstGen *count;
	3692	};
	3693
	3694	struct IrInstSrcSlice {
	3695	IrInstSrc base;
	3696
	3697	IrInstSrc *ptr;
	3698	IrInstSrc *start;
	3699	IrInstSrc *end;
	3700	IrInstSrc *sentinel;
3412	3701	ResultLoc *result_loc;
	3702	bool safety_check_on;
3413	3703	};
3414	3704
3415		struct IrInstructionSliceGen {
3416		IrInstruction base;
	3705	struct IrInstGenSlice {
	3706	IrInstGen base;
3417	3707
	3708	IrInstGen *ptr;
	3709	IrInstGen *start;
	3710	IrInstGen *end;
	3711	IrInstGen *result_loc;
3418	3712	bool safety_check_on;
3419		IrInstruction *ptr;
3420		IrInstruction *start;
3421		IrInstruction *end;
3422		IrInstruction *result_loc;
3423	3713	};
3424	3714
3425		struct IrInstructionMemberCount {
3426		IrInstruction base;
	3715	struct IrInstSrcMemberCount {
	3716	IrInstSrc base;
	3717
	3718	IrInstSrc *container;
	3719	};
	3720
	3721	struct IrInstSrcMemberType {
	3722	IrInstSrc base;
3427	3723
3428		IrInstruction *container;
	3724	IrInstSrc *container_type;
	3725	IrInstSrc *member_index;
3429	3726	};
3430	3727
3431		struct IrInstructionMemberType {
3432		IrInstruction base;
	3728	struct IrInstSrcMemberName {
	3729	IrInstSrc base;
	3730
	3731	IrInstSrc *container_type;
	3732	IrInstSrc *member_index;
	3733	};
	3734
	3735	struct IrInstSrcBreakpoint {
	3736	IrInstSrc base;
	3737	};
3433	3738
3434		IrInstruction *container_type;
3435		IrInstruction *member_index;
	3739	struct IrInstGenBreakpoint {
	3740	IrInstGen base;
3436	3741	};
3437	3742
3438		struct IrInstructionMemberName {
3439		IrInstruction base;
	3743	struct IrInstSrcReturnAddress {
	3744	IrInstSrc base;
	3745	};
3440	3746
3441		IrInstruction *container_type;
3442		IrInstruction *member_index;
	3747	struct IrInstGenReturnAddress {
	3748	IrInstGen base;
3443	3749	};
3444	3750
3445		struct IrInstructionBreakpoint {
3446		IrInstruction base;
	3751	struct IrInstSrcFrameAddress {
	3752	IrInstSrc base;
3447	3753	};
3448	3754
3449		struct IrInstructionReturnAddress {
3450		IrInstruction base;
	3755	struct IrInstGenFrameAddress {
	3756	IrInstGen base;
3451	3757	};
3452	3758
3453		struct IrInstructionFrameAddress {
3454		IrInstruction base;
	3759	struct IrInstSrcFrameHandle {
	3760	IrInstSrc base;
3455	3761	};
3456	3762
3457		struct IrInstructionFrameHandle {
3458		IrInstruction base;
	3763	struct IrInstGenFrameHandle {
	3764	IrInstGen base;
3459	3765	};
3460	3766
3461		struct IrInstructionFrameType {
3462		IrInstruction base;
	3767	struct IrInstSrcFrameType {
	3768	IrInstSrc base;
3463	3769
3464		IrInstruction *fn;
	3770	IrInstSrc *fn;
3465	3771	};
3466	3772
3467		struct IrInstructionFrameSizeSrc {
3468		IrInstruction base;
	3773	struct IrInstSrcFrameSize {
	3774	IrInstSrc base;
3469	3775
3470		IrInstruction *fn;
	3776	IrInstSrc *fn;
3471	3777	};
3472	3778
3473		struct IrInstructionFrameSizeGen {
3474		IrInstruction base;
	3779	struct IrInstGenFrameSize {
	3780	IrInstGen base;
3475	3781
3476		IrInstruction *fn;
	3782	IrInstGen *fn;
3477	3783	};
3478	3784
3479	3785	enum IrOverflowOp {
...	...	@@ -3483,560 +3789,713 @@ enum IrOverflowOp {
3483	3789	IrOverflowOpShl,
3484	3790	};
3485	3791
3486		struct IrInstructionOverflowOp {
3487		IrInstruction base;
	3792	struct IrInstSrcOverflowOp {
	3793	IrInstSrc base;
	3794
	3795	IrOverflowOp op;
	3796	IrInstSrc *type_value;
	3797	IrInstSrc *op1;
	3798	IrInstSrc *op2;
	3799	IrInstSrc *result_ptr;
	3800	};
	3801
	3802	struct IrInstGenOverflowOp {
	3803	IrInstGen base;
3488	3804
3489	3805	IrOverflowOp op;
3490		IrInstruction *type_value;
3491		IrInstruction *op1;
3492		IrInstruction *op2;
3493		IrInstruction *result_ptr;
	3806	IrInstGen *op1;
	3807	IrInstGen *op2;
	3808	IrInstGen *result_ptr;
3494	3809
	3810	// TODO can this field be removed?
3495	3811	ZigType *result_ptr_type;
3496	3812	};
3497	3813
3498		struct IrInstructionMulAdd {
3499		IrInstruction base;
	3814	struct IrInstSrcMulAdd {
	3815	IrInstSrc base;
	3816
	3817	IrInstSrc *type_value;
	3818	IrInstSrc *op1;
	3819	IrInstSrc *op2;
	3820	IrInstSrc *op3;
	3821	};
	3822
	3823	struct IrInstGenMulAdd {
	3824	IrInstGen base;
3500	3825
3501		IrInstruction *type_value;
3502		IrInstruction *op1;
3503		IrInstruction *op2;
3504		IrInstruction *op3;
	3826	IrInstGen *op1;
	3827	IrInstGen *op2;
	3828	IrInstGen *op3;
3505	3829	};
3506	3830
3507		struct IrInstructionAlignOf {
3508		IrInstruction base;
	3831	struct IrInstSrcAlignOf {
	3832	IrInstSrc base;
3509	3833
3510		IrInstruction *type_value;
	3834	IrInstSrc *type_value;
3511	3835	};
3512	3836
3513	3837	// returns true if error, returns false if not error
3514		struct IrInstructionTestErrSrc {
3515		IrInstruction base;
	3838	struct IrInstSrcTestErr {
	3839	IrInstSrc base;
3516	3840
	3841	IrInstSrc *base_ptr;
3517	3842	bool resolve_err_set;
3518	3843	bool base_ptr_is_payload;
3519		IrInstruction *base_ptr;
3520	3844	};
3521	3845
3522		struct IrInstructionTestErrGen {
3523		IrInstruction base;
	3846	struct IrInstGenTestErr {
	3847	IrInstGen base;
3524	3848
3525		IrInstruction *err_union;
	3849	IrInstGen *err_union;
3526	3850	};
3527	3851
3528	3852	// Takes an error union pointer, returns a pointer to the error code.
3529		struct IrInstructionUnwrapErrCode {
3530		IrInstruction base;
	3853	struct IrInstSrcUnwrapErrCode {
	3854	IrInstSrc base;
3531	3855
	3856	IrInstSrc *err_union_ptr;
3532	3857	bool initializing;
3533		IrInstruction *err_union_ptr;
3534	3858	};
3535	3859
3536		struct IrInstructionUnwrapErrPayload {
3537		IrInstruction base;
	3860	struct IrInstGenUnwrapErrCode {
	3861	IrInstGen base;
3538	3862
	3863	IrInstGen *err_union_ptr;
	3864	bool initializing;
	3865	};
	3866
	3867	struct IrInstSrcUnwrapErrPayload {
	3868	IrInstSrc base;
	3869
	3870	IrInstSrc *value;
	3871	bool safety_check_on;
	3872	bool initializing;
	3873	};
	3874
	3875	struct IrInstGenUnwrapErrPayload {
	3876	IrInstGen base;
	3877
	3878	IrInstGen *value;
3539	3879	bool safety_check_on;
3540	3880	bool initializing;
3541		IrInstruction *value;
3542	3881	};
3543	3882
3544		struct IrInstructionOptionalWrap {
3545		IrInstruction base;
	3883	struct IrInstGenOptionalWrap {
	3884	IrInstGen base;
3546	3885
3547		IrInstruction *operand;
3548		IrInstruction *result_loc;
	3886	IrInstGen *operand;
	3887	IrInstGen *result_loc;
3549	3888	};
3550	3889
3551		struct IrInstructionErrWrapPayload {
3552		IrInstruction base;
	3890	struct IrInstGenErrWrapPayload {
	3891	IrInstGen base;
3553	3892
3554		IrInstruction *operand;
3555		IrInstruction *result_loc;
	3893	IrInstGen *operand;
	3894	IrInstGen *result_loc;
3556	3895	};
3557	3896
3558		struct IrInstructionErrWrapCode {
3559		IrInstruction base;
	3897	struct IrInstGenErrWrapCode {
	3898	IrInstGen base;
3560	3899
3561		IrInstruction *operand;
3562		IrInstruction *result_loc;
	3900	IrInstGen *operand;
	3901	IrInstGen *result_loc;
3563	3902	};
3564	3903
3565		struct IrInstructionFnProto {
3566		IrInstruction base;
	3904	struct IrInstSrcFnProto {
	3905	IrInstSrc base;
3567	3906
3568		IrInstruction **param_types;
3569		IrInstruction *align_value;
3570		IrInstruction *callconv_value;
3571		IrInstruction *return_type;
	3907	IrInstSrc **param_types;
	3908	IrInstSrc *align_value;
	3909	IrInstSrc *callconv_value;
	3910	IrInstSrc *return_type;
3572	3911	bool is_var_args;
3573	3912	};
3574	3913
3575	3914	// true if the target value is compile time known, false otherwise
3576		struct IrInstructionTestComptime {
3577		IrInstruction base;
	3915	struct IrInstSrcTestComptime {
	3916	IrInstSrc base;
3578	3917
3579		IrInstruction *value;
	3918	IrInstSrc *value;
3580	3919	};
3581	3920
3582		struct IrInstructionPtrCastSrc {
3583		IrInstruction base;
	3921	struct IrInstSrcPtrCast {
	3922	IrInstSrc base;
3584	3923
3585		IrInstruction *dest_type;
3586		IrInstruction *ptr;
	3924	IrInstSrc *dest_type;
	3925	IrInstSrc *ptr;
3587	3926	bool safety_check_on;
3588	3927	};
3589	3928
3590		struct IrInstructionPtrCastGen {
3591		IrInstruction base;
	3929	struct IrInstGenPtrCast {
	3930	IrInstGen base;
3592	3931
3593		IrInstruction *ptr;
	3932	IrInstGen *ptr;
3594	3933	bool safety_check_on;
3595	3934	};
3596	3935
3597		struct IrInstructionImplicitCast {
3598		IrInstruction base;
	3936	struct IrInstSrcImplicitCast {
	3937	IrInstSrc base;
3599	3938
3600		IrInstruction *operand;
	3939	IrInstSrc *operand;
3601	3940	ResultLocCast *result_loc_cast;
3602	3941	};
3603	3942
3604		struct IrInstructionBitCastSrc {
3605		IrInstruction base;
	3943	struct IrInstSrcBitCast {
	3944	IrInstSrc base;
3606	3945
3607		IrInstruction *operand;
	3946	IrInstSrc *operand;
3608	3947	ResultLocBitCast *result_loc_bit_cast;
3609	3948	};
3610	3949
3611		struct IrInstructionBitCastGen {
3612		IrInstruction base;
	3950	struct IrInstGenBitCast {
	3951	IrInstGen base;
	3952
	3953	IrInstGen *operand;
	3954	};
	3955
	3956	struct IrInstGenWidenOrShorten {
	3957	IrInstGen base;
	3958
	3959	IrInstGen *target;
	3960	};
	3961
	3962	struct IrInstSrcPtrToInt {
	3963	IrInstSrc base;
	3964
	3965	IrInstSrc *target;
	3966	};
	3967
	3968	struct IrInstGenPtrToInt {
	3969	IrInstGen base;
	3970
	3971	IrInstGen *target;
	3972	};
	3973
	3974	struct IrInstSrcIntToPtr {
	3975	IrInstSrc base;
	3976
	3977	IrInstSrc *dest_type;
	3978	IrInstSrc *target;
	3979	};
	3980
	3981	struct IrInstGenIntToPtr {
	3982	IrInstGen base;
3613	3983
3614		IrInstruction *operand;
	3984	IrInstGen *target;
3615	3985	};
3616	3986
3617		struct IrInstructionWidenOrShorten {
3618		IrInstruction base;
	3987	struct IrInstSrcIntToEnum {
	3988	IrInstSrc base;
3619	3989
3620		IrInstruction *target;
	3990	IrInstSrc *dest_type;
	3991	IrInstSrc *target;
3621	3992	};
3622	3993
3623		struct IrInstructionPtrToInt {
3624		IrInstruction base;
	3994	struct IrInstGenIntToEnum {
	3995	IrInstGen base;
3625	3996
3626		IrInstruction *target;
	3997	IrInstGen *target;
3627	3998	};
3628	3999
3629		struct IrInstructionIntToPtr {
3630		IrInstruction base;
	4000	struct IrInstSrcEnumToInt {
	4001	IrInstSrc base;
3631	4002
3632		IrInstruction *dest_type;
3633		IrInstruction *target;
	4003	IrInstSrc *target;
3634	4004	};
3635	4005
3636		struct IrInstructionIntToEnum {
3637		IrInstruction base;
	4006	struct IrInstSrcIntToErr {
	4007	IrInstSrc base;
3638	4008
3639		IrInstruction *dest_type;
3640		IrInstruction *target;
	4009	IrInstSrc *target;
3641	4010	};
3642	4011
3643		struct IrInstructionEnumToInt {
3644		IrInstruction base;
	4012	struct IrInstGenIntToErr {
	4013	IrInstGen base;
3645	4014
3646		IrInstruction *target;
	4015	IrInstGen *target;
3647	4016	};
3648	4017
3649		struct IrInstructionIntToErr {
3650		IrInstruction base;
	4018	struct IrInstSrcErrToInt {
	4019	IrInstSrc base;
3651	4020
3652		IrInstruction *target;
	4021	IrInstSrc *target;
3653	4022	};
3654	4023
3655		struct IrInstructionErrToInt {
3656		IrInstruction base;
	4024	struct IrInstGenErrToInt {
	4025	IrInstGen base;
3657	4026
3658		IrInstruction *target;
	4027	IrInstGen *target;
3659	4028	};
3660	4029
3661		struct IrInstructionCheckSwitchProngsRange {
3662		IrInstruction *start;
3663		IrInstruction *end;
	4030	struct IrInstSrcCheckSwitchProngsRange {
	4031	IrInstSrc *start;
	4032	IrInstSrc *end;
3664	4033	};
3665	4034
3666		struct IrInstructionCheckSwitchProngs {
3667		IrInstruction base;
	4035	struct IrInstSrcCheckSwitchProngs {
	4036	IrInstSrc base;
3668	4037
3669		IrInstruction *target_value;
3670		IrInstructionCheckSwitchProngsRange *ranges;
	4038	IrInstSrc *target_value;
	4039	IrInstSrcCheckSwitchProngsRange *ranges;
3671	4040	size_t range_count;
3672	4041	bool have_else_prong;
3673	4042	bool have_underscore_prong;
3674	4043	};
3675	4044
3676		struct IrInstructionCheckStatementIsVoid {
3677		IrInstruction base;
	4045	struct IrInstSrcCheckStatementIsVoid {
	4046	IrInstSrc base;
3678	4047
3679		IrInstruction *statement_value;
	4048	IrInstSrc *statement_value;
3680	4049	};
3681	4050
3682		struct IrInstructionTypeName {
3683		IrInstruction base;
	4051	struct IrInstSrcTypeName {
	4052	IrInstSrc base;
3684	4053
3685		IrInstruction *type_value;
	4054	IrInstSrc *type_value;
3686	4055	};
3687	4056
3688		struct IrInstructionDeclRef {
3689		IrInstruction base;
	4057	struct IrInstSrcDeclRef {
	4058	IrInstSrc base;
3690	4059
3691	4060	LVal lval;
3692	4061	Tld *tld;
3693	4062	};
3694	4063
3695		struct IrInstructionPanic {
3696		IrInstruction base;
	4064	struct IrInstSrcPanic {
	4065	IrInstSrc base;
	4066
	4067	IrInstSrc *msg;
	4068	};
	4069
	4070	struct IrInstGenPanic {
	4071	IrInstGen base;
	4072
	4073	IrInstGen *msg;
	4074	};
	4075
	4076	struct IrInstSrcTagName {
	4077	IrInstSrc base;
	4078
	4079	IrInstSrc *target;
	4080	};
	4081
	4082	struct IrInstGenTagName {
	4083	IrInstGen base;
3697	4084
3698		IrInstruction *msg;
	4085	IrInstGen *target;
3699	4086	};
3700	4087
3701		struct IrInstructionTagName {
3702		IrInstruction base;
	4088	struct IrInstSrcTagType {
	4089	IrInstSrc base;
3703	4090
3704		IrInstruction *target;
	4091	IrInstSrc *target;
3705	4092	};
3706	4093
3707		struct IrInstructionTagType {
3708		IrInstruction base;
	4094	struct IrInstSrcFieldParentPtr {
	4095	IrInstSrc base;
3709	4096
3710		IrInstruction *target;
	4097	IrInstSrc *type_value;
	4098	IrInstSrc *field_name;
	4099	IrInstSrc *field_ptr;
3711	4100	};
3712	4101
3713		struct IrInstructionFieldParentPtr {
3714		IrInstruction base;
	4102	struct IrInstGenFieldParentPtr {
	4103	IrInstGen base;
3715	4104
3716		IrInstruction *type_value;
3717		IrInstruction *field_name;
3718		IrInstruction *field_ptr;
	4105	IrInstGen *field_ptr;
3719	4106	TypeStructField *field;
3720	4107	};
3721	4108
3722		struct IrInstructionByteOffsetOf {
3723		IrInstruction base;
	4109	struct IrInstSrcByteOffsetOf {
	4110	IrInstSrc base;
	4111
	4112	IrInstSrc *type_value;
	4113	IrInstSrc *field_name;
	4114	};
	4115
	4116	struct IrInstSrcBitOffsetOf {
	4117	IrInstSrc base;
3724	4118
3725		IrInstruction *type_value;
3726		IrInstruction *field_name;
	4119	IrInstSrc *type_value;
	4120	IrInstSrc *field_name;
3727	4121	};
3728	4122
3729		struct IrInstructionBitOffsetOf {
3730		IrInstruction base;
	4123	struct IrInstSrcTypeInfo {
	4124	IrInstSrc base;
3731	4125
3732		IrInstruction *type_value;
3733		IrInstruction *field_name;
	4126	IrInstSrc *type_value;
3734	4127	};
3735	4128
3736		struct IrInstructionTypeInfo {
3737		IrInstruction base;
	4129	struct IrInstSrcType {
	4130	IrInstSrc base;
3738	4131
3739		IrInstruction *type_value;
	4132	IrInstSrc *type_info;
3740	4133	};
3741	4134
3742		struct IrInstructionType {
3743		IrInstruction base;
	4135	struct IrInstSrcHasField {
	4136	IrInstSrc base;
3744	4137
3745		IrInstruction *type_info;
	4138	IrInstSrc *container_type;
	4139	IrInstSrc *field_name;
3746	4140	};
3747	4141
3748		struct IrInstructionHasField {
3749		IrInstruction base;
	4142	struct IrInstSrcTypeId {
	4143	IrInstSrc base;
3750	4144
3751		IrInstruction *container_type;
3752		IrInstruction *field_name;
	4145	IrInstSrc *type_value;
3753	4146	};
3754	4147
3755		struct IrInstructionTypeId {
3756		IrInstruction base;
	4148	struct IrInstSrcSetEvalBranchQuota {
	4149	IrInstSrc base;
3757	4150
3758		IrInstruction *type_value;
	4151	IrInstSrc *new_quota;
3759	4152	};
3760	4153
3761		struct IrInstructionSetEvalBranchQuota {
3762		IrInstruction base;
	4154	struct IrInstSrcAlignCast {
	4155	IrInstSrc base;
3763	4156
3764		IrInstruction *new_quota;
	4157	IrInstSrc *align_bytes;
	4158	IrInstSrc *target;
3765	4159	};
3766	4160
3767		struct IrInstructionAlignCast {
3768		IrInstruction base;
	4161	struct IrInstGenAlignCast {
	4162	IrInstGen base;
3769	4163
3770		IrInstruction *align_bytes;
3771		IrInstruction *target;
	4164	IrInstGen *target;
3772	4165	};
3773	4166
3774		struct IrInstructionOpaqueType {
3775		IrInstruction base;
	4167	struct IrInstSrcOpaqueType {
	4168	IrInstSrc base;
3776	4169	};
3777	4170
3778		struct IrInstructionSetAlignStack {
3779		IrInstruction base;
	4171	struct IrInstSrcSetAlignStack {
	4172	IrInstSrc base;
3780	4173
3781		IrInstruction *align_bytes;
	4174	IrInstSrc *align_bytes;
3782	4175	};
3783	4176
3784		struct IrInstructionArgType {
3785		IrInstruction base;
	4177	struct IrInstSrcArgType {
	4178	IrInstSrc base;
3786	4179
3787		IrInstruction *fn_type;
3788		IrInstruction *arg_index;
	4180	IrInstSrc *fn_type;
	4181	IrInstSrc *arg_index;
3789	4182	bool allow_var;
3790	4183	};
3791	4184
3792		struct IrInstructionExport {
3793		IrInstruction base;
	4185	struct IrInstSrcExport {
	4186	IrInstSrc base;
	4187
	4188	IrInstSrc *target;
	4189	IrInstSrc *options;
	4190	};
	4191
	4192	enum IrInstErrorReturnTraceOptional {
	4193	IrInstErrorReturnTraceNull,
	4194	IrInstErrorReturnTraceNonNull,
	4195	};
	4196
	4197	struct IrInstSrcErrorReturnTrace {
	4198	IrInstSrc base;
3794	4199
3795		IrInstruction *target;
3796		IrInstruction *options;
	4200	IrInstErrorReturnTraceOptional optional;
3797	4201	};
3798	4202
3799		struct IrInstructionErrorReturnTrace {
3800		IrInstruction base;
	4203	struct IrInstGenErrorReturnTrace {
	4204	IrInstGen base;
3801	4205
3802		enum Optional {
3803		Null,
3804		NonNull,
3805		} optional;
	4206	IrInstErrorReturnTraceOptional optional;
3806	4207	};
3807	4208
3808		struct IrInstructionErrorUnion {
3809		IrInstruction base;
	4209	struct IrInstSrcErrorUnion {
	4210	IrInstSrc base;
3810	4211
3811		IrInstruction *err_set;
3812		IrInstruction *payload;
	4212	IrInstSrc *err_set;
	4213	IrInstSrc *payload;
3813	4214	Buf *type_name;
3814	4215	};
3815	4216
3816		struct IrInstructionAtomicRmw {
3817		IrInstruction base;
	4217	struct IrInstSrcAtomicRmw {
	4218	IrInstSrc base;
	4219
	4220	IrInstSrc *operand_type;
	4221	IrInstSrc *ptr;
	4222	IrInstSrc *op;
	4223	IrInstSrc *operand;
	4224	IrInstSrc *ordering;
	4225	};
	4226
	4227	struct IrInstGenAtomicRmw {
	4228	IrInstGen base;
	4229
	4230	IrInstGen *ptr;
	4231	IrInstGen *operand;
	4232	AtomicRmwOp op;
	4233	AtomicOrder ordering;
	4234	};
	4235
	4236	struct IrInstSrcAtomicLoad {
	4237	IrInstSrc base;
	4238
	4239	IrInstSrc *operand_type;
	4240	IrInstSrc *ptr;
	4241	IrInstSrc *ordering;
	4242	};
	4243
	4244	struct IrInstGenAtomicLoad {
	4245	IrInstGen base;
3818	4246
3819		IrInstruction *operand_type;
3820		IrInstruction *ptr;
3821		IrInstruction *op;
3822		AtomicRmwOp resolved_op;
3823		IrInstruction *operand;
3824		IrInstruction *ordering;
3825		AtomicOrder resolved_ordering;
	4247	IrInstGen *ptr;
	4248	AtomicOrder ordering;
3826	4249	};
3827	4250
3828		struct IrInstructionAtomicLoad {
3829		IrInstruction base;
	4251	struct IrInstSrcAtomicStore {
	4252	IrInstSrc base;
3830	4253
3831		IrInstruction *operand_type;
3832		IrInstruction *ptr;
3833		IrInstruction *ordering;
3834		AtomicOrder resolved_ordering;
	4254	IrInstSrc *operand_type;
	4255	IrInstSrc *ptr;
	4256	IrInstSrc *value;
	4257	IrInstSrc *ordering;
3835	4258	};
3836	4259
3837		struct IrInstructionAtomicStore {
3838		IrInstruction base;
	4260	struct IrInstGenAtomicStore {
	4261	IrInstGen base;
	4262
	4263	IrInstGen *ptr;
	4264	IrInstGen *value;
	4265	AtomicOrder ordering;
	4266	};
3839	4267
3840		IrInstruction *operand_type;
3841		IrInstruction *ptr;
3842		IrInstruction *value;
3843		IrInstruction *ordering;
3844		AtomicOrder resolved_ordering;
	4268	struct IrInstSrcSaveErrRetAddr {
	4269	IrInstSrc base;
3845	4270	};
3846	4271
3847		struct IrInstructionSaveErrRetAddr {
3848		IrInstruction base;
	4272	struct IrInstGenSaveErrRetAddr {
	4273	IrInstGen base;
3849	4274	};
3850	4275
3851		struct IrInstructionAddImplicitReturnType {
3852		IrInstruction base;
	4276	struct IrInstSrcAddImplicitReturnType {
	4277	IrInstSrc base;
3853	4278
3854		IrInstruction *value;
	4279	IrInstSrc *value;
3855	4280	ResultLocReturn *result_loc_ret;
3856	4281	};
3857	4282
3858		// For float ops which take a single argument
3859		struct IrInstructionFloatOp {
3860		IrInstruction base;
	4283	// For float ops that take a single argument
	4284	struct IrInstSrcFloatOp {
	4285	IrInstSrc base;
	4286
	4287	IrInstSrc *operand;
	4288	BuiltinFnId fn_id;
	4289	};
	4290
	4291	struct IrInstGenFloatOp {
	4292	IrInstGen base;
3861	4293
	4294	IrInstGen *operand;
3862	4295	BuiltinFnId fn_id;
3863		IrInstruction *operand;
3864	4296	};
3865	4297
3866		struct IrInstructionCheckRuntimeScope {
3867		IrInstruction base;
	4298	struct IrInstSrcCheckRuntimeScope {
	4299	IrInstSrc base;
	4300
	4301	IrInstSrc *scope_is_comptime;
	4302	IrInstSrc *is_comptime;
	4303	};
	4304
	4305	struct IrInstSrcBswap {
	4306	IrInstSrc base;
	4307
	4308	IrInstSrc *type;
	4309	IrInstSrc *op;
	4310	};
	4311
	4312	struct IrInstGenBswap {
	4313	IrInstGen base;
	4314
	4315	IrInstGen *op;
	4316	};
	4317
	4318	struct IrInstSrcBitReverse {
	4319	IrInstSrc base;
3868	4320
3869		IrInstruction *scope_is_comptime;
3870		IrInstruction *is_comptime;
	4321	IrInstSrc *type;
	4322	IrInstSrc *op;
3871	4323	};
3872	4324
3873		struct IrInstructionBswap {
3874		IrInstruction base;
	4325	struct IrInstGenBitReverse {
	4326	IrInstGen base;
3875	4327
3876		IrInstruction *type;
3877		IrInstruction *op;
	4328	IrInstGen *op;
3878	4329	};
3879	4330
3880		struct IrInstructionBitReverse {
3881		IrInstruction base;
	4331	struct IrInstGenArrayToVector {
	4332	IrInstGen base;
3882	4333
3883		IrInstruction *type;
3884		IrInstruction *op;
	4334	IrInstGen *array;
3885	4335	};
3886	4336
3887		struct IrInstructionArrayToVector {
3888		IrInstruction base;
	4337	struct IrInstGenVectorToArray {
	4338	IrInstGen base;
3889	4339
3890		IrInstruction *array;
	4340	IrInstGen *vector;
	4341	IrInstGen *result_loc;
3891	4342	};
3892	4343
3893		struct IrInstructionVectorToArray {
3894		IrInstruction base;
	4344	struct IrInstSrcShuffleVector {
	4345	IrInstSrc base;
3895	4346
3896		IrInstruction *vector;
3897		IrInstruction *result_loc;
	4347	IrInstSrc *scalar_type;
	4348	IrInstSrc *a;
	4349	IrInstSrc *b;
	4350	IrInstSrc *mask; // This is in zig-format, not llvm format
3898	4351	};
3899	4352
3900		struct IrInstructionShuffleVector {
3901		IrInstruction base;
	4353	struct IrInstGenShuffleVector {
	4354	IrInstGen base;
3902	4355
3903		IrInstruction *scalar_type;
3904		IrInstruction *a;
3905		IrInstruction *b;
3906		IrInstruction *mask; // This is in zig-format, not llvm format
	4356	IrInstGen *a;
	4357	IrInstGen *b;
	4358	IrInstGen *mask; // This is in zig-format, not llvm format
3907	4359	};
3908	4360
3909		struct IrInstructionSplatSrc {
3910		IrInstruction base;
	4361	struct IrInstSrcSplat {
	4362	IrInstSrc base;
3911	4363
3912		IrInstruction *len;
3913		IrInstruction *scalar;
	4364	IrInstSrc *len;
	4365	IrInstSrc *scalar;
3914	4366	};
3915	4367
3916		struct IrInstructionSplatGen {
3917		IrInstruction base;
	4368	struct IrInstGenSplat {
	4369	IrInstGen base;
3918	4370
3919		IrInstruction *scalar;
	4371	IrInstGen *scalar;
3920	4372	};
3921	4373
3922		struct IrInstructionAssertZero {
3923		IrInstruction base;
	4374	struct IrInstGenAssertZero {
	4375	IrInstGen base;
3924	4376
3925		IrInstruction *target;
	4377	IrInstGen *target;
3926	4378	};
3927	4379
3928		struct IrInstructionAssertNonNull {
3929		IrInstruction base;
	4380	struct IrInstGenAssertNonNull {
	4381	IrInstGen base;
3930	4382
3931		IrInstruction *target;
	4383	IrInstGen *target;
3932	4384	};
3933	4385
3934		struct IrInstructionUnionInitNamedField {
3935		IrInstruction base;
	4386	struct IrInstSrcUnionInitNamedField {
	4387	IrInstSrc base;
3936	4388
3937		IrInstruction *union_type;
3938		IrInstruction *field_name;
3939		IrInstruction *field_result_loc;
3940		IrInstruction *result_loc;
	4389	IrInstSrc *union_type;
	4390	IrInstSrc *field_name;
	4391	IrInstSrc *field_result_loc;
	4392	IrInstSrc *result_loc;
3941	4393	};
3942	4394
3943		struct IrInstructionHasDecl {
3944		IrInstruction base;
	4395	struct IrInstSrcHasDecl {
	4396	IrInstSrc base;
3945	4397
3946		IrInstruction *container;
3947		IrInstruction *name;
	4398	IrInstSrc *container;
	4399	IrInstSrc *name;
3948	4400	};
3949	4401
3950		struct IrInstructionUndeclaredIdent {
3951		IrInstruction base;
	4402	struct IrInstSrcUndeclaredIdent {
	4403	IrInstSrc base;
3952	4404
3953	4405	Buf *name;
3954	4406	};
3955	4407
3956		struct IrInstructionAllocaSrc {
3957		IrInstruction base;
	4408	struct IrInstSrcAlloca {
	4409	IrInstSrc base;
3958	4410
3959		IrInstruction *align;
3960		IrInstruction *is_comptime;
	4411	IrInstSrc *align;
	4412	IrInstSrc *is_comptime;
3961	4413	const char *name_hint;
3962	4414	};
3963	4415
3964		struct IrInstructionAllocaGen {
3965		IrInstruction base;
	4416	struct IrInstGenAlloca {
	4417	IrInstGen base;
3966	4418
3967	4419	uint32_t align;
3968	4420	const char *name_hint;
3969	4421	size_t field_index;
3970	4422	};
3971	4423
3972		struct IrInstructionEndExpr {
3973		IrInstruction base;
	4424	struct IrInstSrcEndExpr {
	4425	IrInstSrc base;
3974	4426
3975		IrInstruction *value;
	4427	IrInstSrc *value;
3976	4428	ResultLoc *result_loc;
3977	4429	};
3978	4430
3979	4431	// This one is for writing through the result pointer.
3980		struct IrInstructionResolveResult {
3981		IrInstruction base;
	4432	struct IrInstSrcResolveResult {
	4433	IrInstSrc base;
3982	4434
3983	4435	ResultLoc *result_loc;
3984		IrInstruction *ty;
	4436	IrInstSrc *ty;
3985	4437	};
3986	4438
3987		// This one is when you want to read the value of the result.
3988		// You have to give the value in case it is comptime.
3989		struct IrInstructionResultPtr {
3990		IrInstruction base;
	4439	struct IrInstSrcResetResult {
	4440	IrInstSrc base;
3991	4441
3992	4442	ResultLoc *result_loc;
3993		IrInstruction *result;
3994	4443	};
3995	4444
3996		struct IrInstructionResetResult {
3997		IrInstruction base;
	4445	struct IrInstGenPtrOfArrayToSlice {
	4446	IrInstGen base;
3998	4447
3999		ResultLoc *result_loc;
	4448	IrInstGen *operand;
	4449	IrInstGen *result_loc;
4000	4450	};
4001	4451
4002		struct IrInstructionPtrOfArrayToSlice {
4003		IrInstruction base;
4004
4005		IrInstruction *operand;
4006		IrInstruction *result_loc;
	4452	struct IrInstSrcSuspendBegin {
	4453	IrInstSrc base;
4007	4454	};
4008	4455
4009		struct IrInstructionSuspendBegin {
4010		IrInstruction base;
	4456	struct IrInstGenSuspendBegin {
	4457	IrInstGen base;
4011	4458
4012	4459	LLVMBasicBlockRef resume_bb;
4013	4460	};
4014	4461
4015		struct IrInstructionSuspendFinish {
4016		IrInstruction base;
	4462	struct IrInstSrcSuspendFinish {
	4463	IrInstSrc base;
	4464
	4465	IrInstSrcSuspendBegin *begin;
	4466	};
	4467
	4468	struct IrInstGenSuspendFinish {
	4469	IrInstGen base;
4017	4470
4018		IrInstructionSuspendBegin *begin;
	4471	IrInstGenSuspendBegin *begin;
4019	4472	};
4020	4473
4021		struct IrInstructionAwaitSrc {
4022		IrInstruction base;
	4474	struct IrInstSrcAwait {
	4475	IrInstSrc base;
4023	4476
4024		IrInstruction *frame;
	4477	IrInstSrc *frame;
4025	4478	ResultLoc *result_loc;
4026	4479	};
4027	4480
4028		struct IrInstructionAwaitGen {
4029		IrInstruction base;
	4481	struct IrInstGenAwait {
	4482	IrInstGen base;
4030	4483
4031		IrInstruction *frame;
4032		IrInstruction *result_loc;
	4484	IrInstGen *frame;
	4485	IrInstGen *result_loc;
4033	4486	ZigFn *target_fn;
4034	4487	};
4035	4488
4036		struct IrInstructionResume {
4037		IrInstruction base;
	4489	struct IrInstSrcResume {
	4490	IrInstSrc base;
	4491
	4492	IrInstSrc *frame;
	4493	};
	4494
	4495	struct IrInstGenResume {
	4496	IrInstGen base;
4038	4497
4039		IrInstruction *frame;
	4498	IrInstGen *frame;
4040	4499	};
4041	4500
4042	4501	enum SpillId {
...	...	@@ -4044,24 +4503,37 @@ enum SpillId {
4044	4503	SpillIdRetErrCode,
4045	4504	};
4046	4505
4047		struct IrInstructionSpillBegin {
4048		IrInstruction base;
	4506	struct IrInstSrcSpillBegin {
	4507	IrInstSrc base;
	4508
	4509	IrInstSrc *operand;
	4510	SpillId spill_id;
	4511	};
	4512
	4513	struct IrInstGenSpillBegin {
	4514	IrInstGen base;
4049	4515
4050	4516	SpillId spill_id;
4051		IrInstruction *operand;
	4517	IrInstGen *operand;
	4518	};
	4519
	4520	struct IrInstSrcSpillEnd {
	4521	IrInstSrc base;
	4522
	4523	IrInstSrcSpillBegin *begin;
4052	4524	};
4053	4525
4054		struct IrInstructionSpillEnd {
4055		IrInstruction base;
	4526	struct IrInstGenSpillEnd {
	4527	IrInstGen base;
4056	4528
4057		IrInstructionSpillBegin *begin;
	4529	IrInstGenSpillBegin *begin;
4058	4530	};
4059	4531
4060		struct IrInstructionVectorExtractElem {
4061		IrInstruction base;
	4532	struct IrInstGenVectorExtractElem {
	4533	IrInstGen base;
4062	4534
4063		IrInstruction *vector;
4064		IrInstruction *index;
	4535	IrInstGen *vector;
	4536	IrInstGen *index;
4065	4537	};
4066	4538
4067	4539	enum ResultLocId {
...	...	@@ -4082,9 +4554,9 @@ struct ResultLoc {
4082	4554	ResultLocId id;
4083	4555	bool written;
4084	4556	bool allow_write_through_const;
4085		IrInstruction *resolved_loc; // result ptr
4086		IrInstruction *source_instruction;
4087		IrInstruction *gen_instruction; // value to store to the result loc
	4557	IrInstGen *resolved_loc; // result ptr
	4558	IrInstSrc *source_instruction;
	4559	IrInstGen *gen_instruction; // value to store to the result loc
4088	4560	ZigType *implicit_elem_type;
4089	4561	};
4090	4562
...	...	@@ -4114,18 +4586,18 @@ struct ResultLocPeerParent {
4114	4586
4115	4587	bool skipped;
4116	4588	bool done_resuming;
4117		IrBasicBlock *end_bb;
	4589	IrBasicBlockSrc *end_bb;
4118	4590	ResultLoc *parent;
4119	4591	ZigList<ResultLocPeer *> peers;
4120	4592	ZigType *resolved_type;
4121		IrInstruction *is_comptime;
	4593	IrInstSrc *is_comptime;
4122	4594	};
4123	4595
4124	4596	struct ResultLocPeer {
4125	4597	ResultLoc base;
4126	4598
4127	4599	ResultLocPeerParent *parent;
4128		IrBasicBlock *next_bb;
	4600	IrBasicBlockSrc *next_bb;
4129	4601	IrSuspendPosition suspend_pos;
4130	4602	};
4131	4603
...	...	@@ -4196,7 +4668,7 @@ struct FnWalkAttrs {
4196	4668	struct FnWalkCall {
4197	4669	ZigList<LLVMValueRef> *gen_param_values;
4198	4670	ZigList<ZigType > gen_param_types;
4199		IrInstructionCallGen *inst;
	4671	IrInstGenCall *inst;
4200	4672	bool is_var_args;
4201	4673	};
4202	4674

src/analyze.cpp+94-61

...	...	@@ -199,7 +199,7 @@ ScopeLoop create_loop_scope(CodeGen g, AstNode node, Scope parent) {
199	199	return scope;
200	200	}
201	201
202		Scope create_runtime_scope(CodeGen g, AstNode node, Scope parent, IrInstruction *is_comptime) {
	202	Scope create_runtime_scope(CodeGen g, AstNode node, Scope parent, IrInstSrc *is_comptime) {
203	203	ScopeRuntime *scope = allocate<ScopeRuntime>(1);
204	204	scope->is_comptime = is_comptime;
205	205	init_scope(g, &scope->base, ScopeIdRuntime, node, parent);
...	...	@@ -3350,7 +3350,7 @@ static void get_fully_qualified_decl_name(CodeGen g, Buf buf, Tld *tld, bool i
3350	3350
3351	3351	ZigFn create_fn_raw(CodeGen g, FnInline inline_value) {
3352	3352	ZigFn *fn_entry = allocate<ZigFn>(1, "ZigFn");
3353		fn_entry->ir_executable = allocate<IrExecutable>(1, "IrExecutablePass1");
	3353	fn_entry->ir_executable = allocate<IrExecutableSrc>(1, "IrExecutableSrc");
3354	3354
3355	3355	fn_entry->prealloc_backward_branch_quota = default_backward_branch_quota;
3356	3356
...	...	@@ -4097,7 +4097,7 @@ static void preview_use_decl(CodeGen g, TldUsingNamespace using_namespace, Sco
4097	4097	if (type_is_invalid(result->type)) {
4098	4098	dest_decls_scope->any_imports_failed = true;
4099	4099	using_namespace->base.resolution = TldResolutionInvalid;
4100		using_namespace->using_namespace_value = g->invalid_instruction->value;
	4100	using_namespace->using_namespace_value = g->invalid_inst_gen->value;
4101	4101	return;
4102	4102	}
4103	4103
...	...	@@ -4106,7 +4106,7 @@ static void preview_use_decl(CodeGen g, TldUsingNamespace using_namespace, Sco
4106	4106	buf_sprintf("expected struct, enum, or union; found '%s'", buf_ptr(&result->data.x_type->name)));
4107	4107	dest_decls_scope->any_imports_failed = true;
4108	4108	using_namespace->base.resolution = TldResolutionInvalid;
4109		using_namespace->using_namespace_value = g->invalid_instruction->value;
	4109	using_namespace->using_namespace_value = g->invalid_inst_gen->value;
4110	4110	return;
4111	4111	}
4112	4112	}
...	...	@@ -4667,12 +4667,12 @@ static void analyze_fn_async(CodeGen g, ZigFn fn, bool resolve_frame) {
4667	4667	}
4668	4668
4669	4669	for (size_t i = 0; i < fn->call_list.length; i += 1) {
4670		IrInstructionCallGen *call = fn->call_list.at(i);
	4670	IrInstGenCall *call = fn->call_list.at(i);
4671	4671	if (call->fn_entry == nullptr) {
4672	4672	// TODO function pointer call here, could be anything
4673	4673	continue;
4674	4674	}
4675		switch (analyze_callee_async(g, fn, call->fn_entry, call->base.source_node, must_not_be_async,
	4675	switch (analyze_callee_async(g, fn, call->fn_entry, call->base.base.source_node, must_not_be_async,
4676	4676	call->modifier))
4677	4677	{
4678	4678	case ErrorSemanticAnalyzeFail:
...	...	@@ -4690,10 +4690,10 @@ static void analyze_fn_async(CodeGen g, ZigFn fn, bool resolve_frame) {
4690	4690	}
4691	4691	}
4692	4692	for (size_t i = 0; i < fn->await_list.length; i += 1) {
4693		IrInstructionAwaitGen *await = fn->await_list.at(i);
	4693	IrInstGenAwait *await = fn->await_list.at(i);
4694	4694	// TODO If this is a noasync await, it doesn't count
4695	4695	// https://github.com/ziglang/zig/issues/3157
4696		switch (analyze_callee_async(g, fn, await->target_fn, await->base.source_node, must_not_be_async,
	4696	switch (analyze_callee_async(g, fn, await->target_fn, await->base.base.source_node, must_not_be_async,
4697	4697	CallModifierNone))
4698	4698	{
4699	4699	case ErrorSemanticAnalyzeFail:
...	...	@@ -4784,7 +4784,7 @@ static void analyze_fn_ir(CodeGen g, ZigFn fn, AstNode *return_type_node) {
4784	4784
4785	4785	if (g->verbose_ir) {
4786	4786	fprintf(stderr, "fn %s() { // (analyzed)\n", buf_ptr(&fn->symbol_name));
4787		ir_print(g, stderr, &fn->analyzed_executable, 4, IrPassGen);
	4787	ir_print_gen(g, stderr, &fn->analyzed_executable, 4);
4788	4788	fprintf(stderr, "}\n");
4789	4789	}
4790	4790	fn->anal_state = FnAnalStateComplete;
...	...	@@ -4827,7 +4827,7 @@ static void analyze_fn_body(CodeGen g, ZigFn fn_table_entry) {
4827	4827	fprintf(stderr, "\n");
4828	4828	ast_render(stderr, fn_table_entry->body_node, 4);
4829	4829	fprintf(stderr, "\nfn %s() { // (IR)\n", buf_ptr(&fn_table_entry->symbol_name));
4830		ir_print(g, stderr, fn_table_entry->ir_executable, 4, IrPassSrc);
	4830	ir_print_src(g, stderr, fn_table_entry->ir_executable, 4);
4831	4831	fprintf(stderr, "}\n");
4832	4832	}
4833	4833
...	...	@@ -6191,13 +6191,13 @@ static Error resolve_async_frame(CodeGen g, ZigType frame_type) {
6191	6191	ZigType *fn_type = get_async_fn_type(g, fn->type_entry);
6192	6192
6193	6193	if (fn->analyzed_executable.need_err_code_spill) {
6194		IrInstructionAllocaGen *alloca_gen = allocate<IrInstructionAllocaGen>(1);
6195		alloca_gen->base.id = IrInstructionIdAllocaGen;
6196		alloca_gen->base.source_node = fn->proto_node;
6197		alloca_gen->base.scope = fn->child_scope;
	6194	IrInstGenAlloca *alloca_gen = allocate<IrInstGenAlloca>(1);
	6195	alloca_gen->base.id = IrInstGenIdAlloca;
	6196	alloca_gen->base.base.source_node = fn->proto_node;
	6197	alloca_gen->base.base.scope = fn->child_scope;
6198	6198	alloca_gen->base.value = allocate<ZigValue>(1, "ZigValue");
6199	6199	alloca_gen->base.value->type = get_pointer_to_type(g, g->builtin_types.entry_global_error_set, false);
6200		alloca_gen->base.ref_count = 1;
	6200	alloca_gen->base.base.ref_count = 1;
6201	6201	alloca_gen->name_hint = "";
6202	6202	fn->alloca_gen_list.append(alloca_gen);
6203	6203	fn->err_code_spill = &alloca_gen->base;
...	...	@@ -6205,18 +6205,18 @@ static Error resolve_async_frame(CodeGen g, ZigType frame_type) {
6205	6205
6206	6206	ZigType *largest_call_frame_type = nullptr;
6207	6207	// Later we'll change this to be largest_call_frame_type instead of void.
6208		IrInstruction *all_calls_alloca = ir_create_alloca(g, &fn->fndef_scope->base, fn->body_node,
	6208	IrInstGen *all_calls_alloca = ir_create_alloca(g, &fn->fndef_scope->base, fn->body_node,
6209	6209	fn, g->builtin_types.entry_void, "@async_call_frame");
6210	6210
6211	6211	for (size_t i = 0; i < fn->call_list.length; i += 1) {
6212		IrInstructionCallGen *call = fn->call_list.at(i);
	6212	IrInstGenCall *call = fn->call_list.at(i);
6213	6213	if (call->new_stack != nullptr) {
6214	6214	// don't need to allocate a frame for this
6215	6215	continue;
6216	6216	}
6217	6217	ZigFn *callee = call->fn_entry;
6218	6218	if (callee == nullptr) {
6219		add_node_error(g, call->base.source_node,
	6219	add_node_error(g, call->base.base.source_node,
6220	6220	buf_sprintf("function is not comptime-known; @asyncCall required"));
6221	6221	return ErrorSemanticAnalyzeFail;
6222	6222	}
...	...	@@ -6226,14 +6226,14 @@ static Error resolve_async_frame(CodeGen g, ZigType frame_type) {
6226	6226	if (callee->anal_state == FnAnalStateProbing) {
6227	6227	ErrorMsg *msg = add_node_error(g, fn->proto_node,
6228	6228	buf_sprintf("unable to determine async function frame of '%s'", buf_ptr(&fn->symbol_name)));
6229		g->trace_err = add_error_note(g, msg, call->base.source_node,
	6229	g->trace_err = add_error_note(g, msg, call->base.base.source_node,
6230	6230	buf_sprintf("analysis of function '%s' depends on the frame", buf_ptr(&callee->symbol_name)));
6231	6231	return ErrorSemanticAnalyzeFail;
6232	6232	}
6233	6233
6234	6234	ZigType *callee_frame_type = get_fn_frame_type(g, callee);
6235	6235	frame_type->data.frame.resolve_loop_type = callee_frame_type;
6236		frame_type->data.frame.resolve_loop_src_node = call->base.source_node;
	6236	frame_type->data.frame.resolve_loop_src_node = call->base.base.source_node;
6237	6237
6238	6238	analyze_fn_body(g, callee);
6239	6239	if (callee->anal_state == FnAnalStateInvalid) {
...	...	@@ -6249,7 +6249,7 @@ static Error resolve_async_frame(CodeGen g, ZigType frame_type) {
6249	6249	if (!fn_is_async(callee))
6250	6250	continue;
6251	6251
6252		mark_suspension_point(call->base.scope);
	6252	mark_suspension_point(call->base.base.scope);
6253	6253
6254	6254	if ((err = type_resolve(g, callee_frame_type, ResolveStatusSizeKnown))) {
6255	6255	return err;
...	...	@@ -6271,7 +6271,7 @@ static Error resolve_async_frame(CodeGen g, ZigType frame_type) {
6271	6271	// For example: foo() + await z
6272	6272	// The funtion call result of foo() must be spilled.
6273	6273	for (size_t i = 0; i < fn->await_list.length; i += 1) {
6274		IrInstructionAwaitGen *await = fn->await_list.at(i);
	6274	IrInstGenAwait *await = fn->await_list.at(i);
6275	6275	// TODO If this is a noasync await, it doesn't suspend
6276	6276	// https://github.com/ziglang/zig/issues/3157
6277	6277	if (await->base.value->special != ConstValSpecialRuntime) {
...	...	@@ -6293,52 +6293,51 @@ static Error resolve_async_frame(CodeGen g, ZigType frame_type) {
6293	6293	}
6294	6294	// This await is a suspend point, but it might not need a spill.
6295	6295	// We do need to mark the ExprScope as having a suspend point in it.
6296		mark_suspension_point(await->base.scope);
	6296	mark_suspension_point(await->base.base.scope);
6297	6297
6298	6298	if (await->result_loc != nullptr) {
6299	6299	// If there's a result location, that is the spill
6300	6300	continue;
6301	6301	}
6302		if (await->base.ref_count == 0)
	6302	if (await->base.base.ref_count == 0)
6303	6303	continue;
6304	6304	if (!type_has_bits(await->base.value->type))
6305	6305	continue;
6306		await->result_loc = ir_create_alloca(g, await->base.scope, await->base.source_node, fn,
	6306	await->result_loc = ir_create_alloca(g, await->base.base.scope, await->base.base.source_node, fn,
6307	6307	await->base.value->type, "");
6308	6308	}
6309	6309	for (size_t block_i = 0; block_i < fn->analyzed_executable.basic_block_list.length; block_i += 1) {
6310		IrBasicBlock *block = fn->analyzed_executable.basic_block_list.at(block_i);
	6310	IrBasicBlockGen *block = fn->analyzed_executable.basic_block_list.at(block_i);
6311	6311	for (size_t instr_i = 0; instr_i < block->instruction_list.length; instr_i += 1) {
6312		IrInstruction *instruction = block->instruction_list.at(instr_i);
6313		if (instruction->id == IrInstructionIdSuspendFinish) {
6314		mark_suspension_point(instruction->scope);
	6312	IrInstGen *instruction = block->instruction_list.at(instr_i);
	6313	if (instruction->id == IrInstGenIdSuspendFinish) {
	6314	mark_suspension_point(instruction->base.scope);
6315	6315	}
6316	6316	}
6317	6317	}
6318	6318	// Now that we've marked all the expr scopes that have to spill, we go over the instructions
6319	6319	// and spill the relevant ones.
6320	6320	for (size_t block_i = 0; block_i < fn->analyzed_executable.basic_block_list.length; block_i += 1) {
6321		IrBasicBlock *block = fn->analyzed_executable.basic_block_list.at(block_i);
	6321	IrBasicBlockGen *block = fn->analyzed_executable.basic_block_list.at(block_i);
6322	6322	for (size_t instr_i = 0; instr_i < block->instruction_list.length; instr_i += 1) {
6323		IrInstruction *instruction = block->instruction_list.at(instr_i);
6324		if (instruction->id == IrInstructionIdAwaitGen \|\|
6325		instruction->id == IrInstructionIdVarPtr \|\|
6326		instruction->id == IrInstructionIdDeclRef \|\|
6327		instruction->id == IrInstructionIdAllocaGen)
	6323	IrInstGen *instruction = block->instruction_list.at(instr_i);
	6324	if (instruction->id == IrInstGenIdAwait \|\|
	6325	instruction->id == IrInstGenIdVarPtr \|\|
	6326	instruction->id == IrInstGenIdAlloca)
6328	6327	{
6329	6328	// This instruction does its own spilling specially, or otherwise doesn't need it.
6330	6329	continue;
6331	6330	}
6332	6331	if (instruction->value->special != ConstValSpecialRuntime)
6333	6332	continue;
6334		if (instruction->ref_count == 0)
	6333	if (instruction->base.ref_count == 0)
6335	6334	continue;
6336	6335	if ((err = type_resolve(g, instruction->value->type, ResolveStatusZeroBitsKnown)))
6337	6336	return ErrorSemanticAnalyzeFail;
6338	6337	if (!type_has_bits(instruction->value->type))
6339	6338	continue;
6340		if (scope_needs_spill(instruction->scope)) {
6341		instruction->spill = ir_create_alloca(g, instruction->scope, instruction->source_node,
	6339	if (scope_needs_spill(instruction->base.scope)) {
	6340	instruction->spill = ir_create_alloca(g, instruction->base.scope, instruction->base.source_node,
6342	6341	fn, instruction->value->type, "");
6343	6342	}
6344	6343	}
...	...	@@ -6389,14 +6388,14 @@ static Error resolve_async_frame(CodeGen g, ZigType frame_type) {
6389	6388	}
6390	6389
6391	6390	for (size_t alloca_i = 0; alloca_i < fn->alloca_gen_list.length; alloca_i += 1) {
6392		IrInstructionAllocaGen *instruction = fn->alloca_gen_list.at(alloca_i);
	6391	IrInstGenAlloca *instruction = fn->alloca_gen_list.at(alloca_i);
6393	6392	instruction->field_index = SIZE_MAX;
6394	6393	ZigType *ptr_type = instruction->base.value->type;
6395	6394	assert(ptr_type->id == ZigTypeIdPointer);
6396	6395	ZigType *child_type = ptr_type->data.pointer.child_type;
6397	6396	if (!type_has_bits(child_type))
6398	6397	continue;
6399		if (instruction->base.ref_count == 0)
	6398	if (instruction->base.base.ref_count == 0)
6400	6399	continue;
6401	6400	if (instruction->base.value->special != ConstValSpecialRuntime) {
6402	6401	if (const_ptr_pointee(nullptr, g, instruction->base.value, nullptr)->special !=
...	...	@@ -6407,7 +6406,7 @@ static Error resolve_async_frame(CodeGen g, ZigType frame_type) {
6407	6406	}
6408	6407
6409	6408	frame_type->data.frame.resolve_loop_type = child_type;
6410		frame_type->data.frame.resolve_loop_src_node = instruction->base.source_node;
	6409	frame_type->data.frame.resolve_loop_src_node = instruction->base.base.source_node;
6411	6410	if ((err = type_resolve(g, child_type, ResolveStatusSizeKnown))) {
6412	6411	return err;
6413	6412	}
...	...	@@ -6421,7 +6420,7 @@ static Error resolve_async_frame(CodeGen g, ZigType frame_type) {
6421	6420	instruction->field_index = fields.length;
6422	6421
6423	6422	src_assert(child_type->id != ZigTypeIdPointer \|\| child_type->data.pointer.inferred_struct_field == nullptr,
6424		instruction->base.source_node);
	6423	instruction->base.base.source_node);
6425	6424	fields.append({name, child_type, instruction->align});
6426	6425	}
6427	6426
...	...	@@ -6554,8 +6553,10 @@ bool ir_get_var_is_comptime(ZigVar *var) {
6554	6553	// As an optimization, is_comptime values which are constant are allowed
6555	6554	// to be omitted from analysis. In this case, there is no child instruction
6556	6555	// and we simply look at the unanalyzed const parent instruction.
6557		assert(var->is_comptime->value->type->id == ZigTypeIdBool);
6558		var->is_comptime_memoized_value = var->is_comptime->value->data.x_bool;
	6556	assert(var->is_comptime->id == IrInstSrcIdConst);
	6557	IrInstSrcConst const_inst = reinterpret_cast<IrInstSrcConst >(var->is_comptime);
	6558	assert(const_inst->value->type->id == ZigTypeIdBool);
	6559	var->is_comptime_memoized_value = const_inst->value->data.x_bool;
6559	6560	var->is_comptime = nullptr;
6560	6561	return var->is_comptime_memoized_value;
6561	6562	}
...	...	@@ -9193,21 +9194,6 @@ void src_assert(bool ok, AstNode *source_node) {
9193	9194	stage2_panic(msg, strlen(msg));
9194	9195	}
9195	9196
9196		IrInstruction ir_create_alloca(CodeGen g, Scope scope, AstNode source_node, ZigFn *fn,
9197		ZigType var_type, const char name_hint)
9198		{
9199		IrInstructionAllocaGen *alloca_gen = allocate<IrInstructionAllocaGen>(1);
9200		alloca_gen->base.id = IrInstructionIdAllocaGen;
9201		alloca_gen->base.source_node = source_node;
9202		alloca_gen->base.scope = scope;
9203		alloca_gen->base.value = allocate<ZigValue>(1, "ZigValue");
9204		alloca_gen->base.value->type = get_pointer_to_type(g, var_type, false);
9205		alloca_gen->base.ref_count = 1;
9206		alloca_gen->name_hint = name_hint;
9207		fn->alloca_gen_list.append(alloca_gen);
9208		return &alloca_gen->base;
9209		}
9210
9211	9197	Error analyze_import(CodeGen g, ZigType source_import, Buf *import_target_str,
9212	9198	ZigType out_import, Buf out_import_target_path, Buf *out_full_path)
9213	9199	{
...	...	@@ -9268,8 +9254,17 @@ Error analyze_import(CodeGen g, ZigType source_import, Buf *import_target_str,
9268	9254	}
9269	9255
9270	9256
9271		void IrExecutable::src() {
9272		IrExecutable *it;
	9257	void IrExecutableSrc::src() {
	9258	if (this->source_node != nullptr) {
	9259	this->source_node->src();
	9260	}
	9261	if (this->parent_exec != nullptr) {
	9262	this->parent_exec->src();
	9263	}
	9264	}
	9265
	9266	void IrExecutableGen::src() {
	9267	IrExecutableGen *it;
9273	9268	for (it = this; it != nullptr && it->source_node != nullptr; it = it->parent_exec) {
9274	9269	it->source_node->src();
9275	9270	}
...	...	@@ -9357,3 +9352,41 @@ bool type_is_numeric(ZigType *ty) {
9357	9352	}
9358	9353	zig_unreachable();
9359	9354	}
	9355
	9356	// float ops that take a single argument
	9357	//TODO Powi, Pow, minnum, maxnum, maximum, minimum, copysign, lround, llround, lrint, llrint
	9358	const char *float_op_to_name(BuiltinFnId op) {
	9359	switch (op) {
	9360	case BuiltinFnIdSqrt:
	9361	return "sqrt";
	9362	case BuiltinFnIdSin:
	9363	return "sin";
	9364	case BuiltinFnIdCos:
	9365	return "cos";
	9366	case BuiltinFnIdExp:
	9367	return "exp";
	9368	case BuiltinFnIdExp2:
	9369	return "exp2";
	9370	case BuiltinFnIdLog:
	9371	return "log";
	9372	case BuiltinFnIdLog10:
	9373	return "log10";
	9374	case BuiltinFnIdLog2:
	9375	return "log2";
	9376	case BuiltinFnIdFabs:
	9377	return "fabs";
	9378	case BuiltinFnIdFloor:
	9379	return "floor";
	9380	case BuiltinFnIdCeil:
	9381	return "ceil";
	9382	case BuiltinFnIdTrunc:
	9383	return "trunc";
	9384	case BuiltinFnIdNearbyInt:
	9385	return "nearbyint";
	9386	case BuiltinFnIdRound:
	9387	return "round";
	9388	default:
	9389	zig_unreachable();
	9390	}
	9391	}
	9392

src/analyze.hpp+2-3

...	...	@@ -120,7 +120,7 @@ ScopeLoop create_loop_scope(CodeGen g, AstNode node, Scope parent);
120	120	ScopeSuspend create_suspend_scope(CodeGen g, AstNode node, Scope parent);
121	121	ScopeFnDef create_fndef_scope(CodeGen g, AstNode node, Scope parent, ZigFn *fn_entry);
122	122	Scope create_comptime_scope(CodeGen g, AstNode node, Scope parent);
123		Scope create_runtime_scope(CodeGen g, AstNode node, Scope parent, IrInstruction *is_comptime);
	123	Scope create_runtime_scope(CodeGen g, AstNode node, Scope parent, IrInstSrc *is_comptime);
124	124	Scope create_typeof_scope(CodeGen g, AstNode node, Scope parent);
125	125	ScopeExpr create_expr_scope(CodeGen g, AstNode node, Scope parent);
126	126
...	...	@@ -271,8 +271,6 @@ ZigType resolve_struct_field_type(CodeGen g, TypeStructField *struct_field);
271	271
272	272	void add_async_error_notes(CodeGen g, ErrorMsg msg, ZigFn *fn);
273	273
274		IrInstruction ir_create_alloca(CodeGen g, Scope scope, AstNode source_node, ZigFn *fn,
275		ZigType var_type, const char name_hint);
276	274	Error analyze_import(CodeGen codegen, ZigType source_import, Buf *import_target_str,
277	275	ZigType out_import, Buf out_import_target_path, Buf *out_full_path);
278	276	ZigValue get_the_one_possible_value(CodeGen g, ZigType *type_entry);
...	...	@@ -281,4 +279,5 @@ void copy_const_val(ZigValue dest, ZigValue src);
281	279	bool type_has_optional_repr(ZigType *ty);
282	280	bool is_opt_err_set(ZigType *ty);
283	281	bool type_is_numeric(ZigType *ty);
	282	const char *float_op_to_name(BuiltinFnId op);
284	283	#endif

src/codegen.cpp+408-475

...	...	@@ -191,7 +191,7 @@ static void generate_error_name_table(CodeGen *g);
191	191	static bool value_is_all_undef(CodeGen g, ZigValue const_val);
192	192	static void gen_undef_init(CodeGen g, uint32_t ptr_align_bytes, ZigType value_type, LLVMValueRef ptr);
193	193	static LLVMValueRef build_alloca(CodeGen g, ZigType type_entry, const char *name, uint32_t alignment);
194		static LLVMValueRef gen_await_early_return(CodeGen g, IrInstruction source_instr,
	194	static LLVMValueRef gen_await_early_return(CodeGen g, IrInstGen source_instr,
195	195	LLVMValueRef target_frame_ptr, ZigType result_type, ZigType ptr_result_type,
196	196	LLVMValueRef result_loc, bool non_async);
197	197	static Error get_tmp_filename(CodeGen g, Buf out, Buf *suffix);
...	...	@@ -877,14 +877,14 @@ static LLVMValueRef get_handle_value(CodeGen g, LLVMValueRef ptr, ZigType type
877	877	}
878	878	}
879	879
880		static void ir_assert(bool ok, IrInstruction *source_instruction) {
	880	static void ir_assert(bool ok, IrInstGen *source_instruction) {
881	881	if (ok) return;
882		src_assert(ok, source_instruction->source_node);
	882	src_assert(ok, source_instruction->base.source_node);
883	883	}
884	884
885		static bool ir_want_fast_math(CodeGen g, IrInstruction instruction) {
	885	static bool ir_want_fast_math(CodeGen g, IrInstGen instruction) {
886	886	// TODO memoize
887		Scope *scope = instruction->scope;
	887	Scope *scope = instruction->base.scope;
888	888	while (scope) {
889	889	if (scope->id == ScopeIdBlock) {
890	890	ScopeBlock block_scope = (ScopeBlock )scope;
...	...	@@ -919,8 +919,8 @@ static bool ir_want_runtime_safety_scope(CodeGen g, Scope scope) {
919	919	g->build_mode != BuildModeSmallRelease);
920	920	}
921	921
922		static bool ir_want_runtime_safety(CodeGen g, IrInstruction instruction) {
923		return ir_want_runtime_safety_scope(g, instruction->scope);
	922	static bool ir_want_runtime_safety(CodeGen g, IrInstGen instruction) {
	923	return ir_want_runtime_safety_scope(g, instruction->base.scope);
924	924	}
925	925
926	926	static Buf *panic_msg_buf(PanicMsgId msg_id) {
...	...	@@ -1046,8 +1046,8 @@ static void gen_assertion_scope(CodeGen g, PanicMsgId msg_id, Scope source_sco
1046	1046	}
1047	1047	}
1048	1048
1049		static void gen_assertion(CodeGen g, PanicMsgId msg_id, IrInstruction source_instruction) {
1050		return gen_assertion_scope(g, msg_id, source_instruction->scope);
	1049	static void gen_assertion(CodeGen g, PanicMsgId msg_id, IrInstGen source_instruction) {
	1050	return gen_assertion_scope(g, msg_id, source_instruction->base.scope);
1051	1051	}
1052	1052
1053	1053	static LLVMValueRef get_stacksave_fn_val(CodeGen *g) {
...	...	@@ -1761,7 +1761,7 @@ static void gen_var_debug_decl(CodeGen g, ZigVar var) {
1761	1761	LLVMGetInsertBlock(g->builder));
1762	1762	}
1763	1763
1764		static LLVMValueRef ir_llvm_value(CodeGen g, IrInstruction instruction) {
	1764	static LLVMValueRef ir_llvm_value(CodeGen g, IrInstGen instruction) {
1765	1765	Error err;
1766	1766
1767	1767	bool value_has_bits;
...	...	@@ -1772,8 +1772,8 @@ static LLVMValueRef ir_llvm_value(CodeGen g, IrInstruction instruction) {
1772	1772	return nullptr;
1773	1773
1774	1774	if (!instruction->llvm_value) {
1775		if (instruction->id == IrInstructionIdAwaitGen) {
1776		IrInstructionAwaitGen await = reinterpret_cast<IrInstructionAwaitGen>(instruction);
	1775	if (instruction->id == IrInstGenIdAwait) {
	1776	IrInstGenAwait await = reinterpret_cast<IrInstGenAwait>(instruction);
1777	1777	if (await->result_loc != nullptr) {
1778	1778	return get_handle_value(g, ir_llvm_value(g, await->result_loc),
1779	1779	await->result_loc->value->type->data.pointer.child_type, await->result_loc->value->type);
...	...	@@ -1856,9 +1856,9 @@ static bool iter_function_params_c_abi(CodeGen g, ZigType fn_type, FnWalk *fn_
1856	1856	case FnWalkIdCall: {
1857	1857	if (src_i >= fn_walk->data.call.inst->arg_count)
1858	1858	return false;
1859		IrInstruction *arg = fn_walk->data.call.inst->args[src_i];
	1859	IrInstGen *arg = fn_walk->data.call.inst->args[src_i];
1860	1860	ty = arg->value->type;
1861		source_node = arg->source_node;
	1861	source_node = arg->base.source_node;
1862	1862	val = ir_llvm_value(g, arg);
1863	1863	break;
1864	1864	}
...	...	@@ -2091,10 +2091,10 @@ void walk_function_params(CodeGen g, ZigType fn_type, FnWalk *fn_walk) {
2091	2091	return;
2092	2092	}
2093	2093	if (fn_walk->id == FnWalkIdCall) {
2094		IrInstructionCallGen *instruction = fn_walk->data.call.inst;
	2094	IrInstGenCall *instruction = fn_walk->data.call.inst;
2095	2095	bool is_var_args = fn_walk->data.call.is_var_args;
2096	2096	for (size_t call_i = 0; call_i < instruction->arg_count; call_i += 1) {
2097		IrInstruction *param_instruction = instruction->args[call_i];
	2097	IrInstGen *param_instruction = instruction->args[call_i];
2098	2098	ZigType *param_type = param_instruction->value->type;
2099	2099	if (is_var_args \|\| type_has_bits(param_type)) {
2100	2100	LLVMValueRef param_value = ir_llvm_value(g, param_instruction);
...	...	@@ -2309,14 +2309,14 @@ static LLVMValueRef get_merge_err_ret_traces_fn_val(CodeGen *g) {
2309	2309	return fn_val;
2310	2310
2311	2311	}
2312		static LLVMValueRef ir_render_save_err_ret_addr(CodeGen g, IrExecutable executable,
2313		IrInstructionSaveErrRetAddr *save_err_ret_addr_instruction)
	2312	static LLVMValueRef ir_render_save_err_ret_addr(CodeGen g, IrExecutableGen executable,
	2313	IrInstGenSaveErrRetAddr *save_err_ret_addr_instruction)
2314	2314	{
2315	2315	assert(g->have_err_ret_tracing);
2316	2316
2317	2317	LLVMValueRef return_err_fn = get_return_err_fn(g);
2318	2318	bool is_llvm_alloca;
2319		LLVMValueRef my_err_trace_val = get_cur_err_ret_trace_val(g, save_err_ret_addr_instruction->base.scope,
	2319	LLVMValueRef my_err_trace_val = get_cur_err_ret_trace_val(g, save_err_ret_addr_instruction->base.base.scope,
2320	2320	&is_llvm_alloca);
2321	2321	ZigLLVMBuildCall(g->builder, return_err_fn, &my_err_trace_val, 1,
2322	2322	get_llvm_cc(g, CallingConventionUnspecified), ZigLLVM_CallAttrAuto, "");
...	...	@@ -2331,7 +2331,7 @@ static LLVMValueRef ir_render_save_err_ret_addr(CodeGen g, IrExecutable execut
2331	2331	return nullptr;
2332	2332	}
2333	2333
2334		static void gen_assert_resume_id(CodeGen g, IrInstruction source_instr, ResumeId resume_id, PanicMsgId msg_id,
	2334	static void gen_assert_resume_id(CodeGen g, IrInstGen source_instr, ResumeId resume_id, PanicMsgId msg_id,
2335	2335	LLVMBasicBlockRef end_bb)
2336	2336	{
2337	2337	LLVMTypeRef usize_type_ref = g->builtin_types.entry_usize->llvm_type;
...	...	@@ -2408,7 +2408,7 @@ static LLVMValueRef gen_maybe_atomic_op(CodeGen *g, LLVMAtomicRMWBinOp op, LLVMV
2408	2408	}
2409	2409	}
2410	2410
2411		static void gen_async_return(CodeGen g, IrInstructionReturn instruction) {
	2411	static void gen_async_return(CodeGen g, IrInstGenReturn instruction) {
2412	2412	LLVMTypeRef usize_type_ref = g->builtin_types.entry_usize->llvm_type;
2413	2413
2414	2414	ZigType *operand_type = (instruction->operand != nullptr) ? instruction->operand->value->type : nullptr;
...	...	@@ -2487,7 +2487,7 @@ static void gen_async_return(CodeGen g, IrInstructionReturn instruction) {
2487	2487	frame_index_trace_arg(g, ret_type) + 1, "");
2488	2488	LLVMValueRef dest_trace_ptr = LLVMBuildLoad(g->builder, awaiter_trace_ptr_ptr, "");
2489	2489	bool is_llvm_alloca;
2490		LLVMValueRef my_err_trace_val = get_cur_err_ret_trace_val(g, instruction->base.scope, &is_llvm_alloca);
	2490	LLVMValueRef my_err_trace_val = get_cur_err_ret_trace_val(g, instruction->base.base.scope, &is_llvm_alloca);
2491	2491	LLVMValueRef args[] = { dest_trace_ptr, my_err_trace_val };
2492	2492	ZigLLVMBuildCall(g->builder, get_merge_err_ret_traces_fn_val(g), args, 2,
2493	2493	get_llvm_cc(g, CallingConventionUnspecified), ZigLLVM_CallAttrAuto, "");
...	...	@@ -2502,7 +2502,7 @@ static void gen_async_return(CodeGen g, IrInstructionReturn instruction) {
2502	2502	LLVMBuildRetVoid(g->builder);
2503	2503	}
2504	2504
2505		static LLVMValueRef ir_render_return(CodeGen g, IrExecutable executable, IrInstructionReturn *instruction) {
	2505	static LLVMValueRef ir_render_return(CodeGen g, IrExecutableGen executable, IrInstGenReturn *instruction) {
2506	2506	if (fn_is_async(g->cur_fn)) {
2507	2507	gen_async_return(g, instruction);
2508	2508	return nullptr;
...	...	@@ -2843,12 +2843,12 @@ static LLVMValueRef gen_rem(CodeGen *g, bool want_runtime_safety, bool want_fast
2843	2843
2844	2844	}
2845	2845
2846		static LLVMValueRef ir_render_bin_op(CodeGen g, IrExecutable executable,
2847		IrInstructionBinOp *bin_op_instruction)
	2846	static LLVMValueRef ir_render_bin_op(CodeGen g, IrExecutableGen executable,
	2847	IrInstGenBinOp *bin_op_instruction)
2848	2848	{
2849	2849	IrBinOp op_id = bin_op_instruction->op_id;
2850		IrInstruction *op1 = bin_op_instruction->op1;
2851		IrInstruction *op2 = bin_op_instruction->op2;
	2850	IrInstGen *op1 = bin_op_instruction->op1;
	2851	IrInstGen *op2 = bin_op_instruction->op2;
2852	2852
2853	2853	ZigType *operand_type = op1->value->type;
2854	2854	ZigType *scalar_type = (operand_type->id == ZigTypeIdVector) ? operand_type->data.vector.elem_type : operand_type;
...	...	@@ -3053,8 +3053,8 @@ static void add_error_range_check(CodeGen g, ZigType err_set_type, ZigType *in
3053	3053	}
3054	3054	}
3055	3055
3056		static LLVMValueRef ir_render_resize_slice(CodeGen g, IrExecutable executable,
3057		IrInstructionResizeSlice *instruction)
	3056	static LLVMValueRef ir_render_resize_slice(CodeGen g, IrExecutableGen executable,
	3057	IrInstGenResizeSlice *instruction)
3058	3058	{
3059	3059	ZigType *actual_type = instruction->operand->value->type;
3060	3060	ZigType *wanted_type = instruction->base.value->type;
...	...	@@ -3121,8 +3121,8 @@ static LLVMValueRef ir_render_resize_slice(CodeGen g, IrExecutable executable,
3121	3121	return result_loc;
3122	3122	}
3123	3123
3124		static LLVMValueRef ir_render_cast(CodeGen g, IrExecutable executable,
3125		IrInstructionCast *cast_instruction)
	3124	static LLVMValueRef ir_render_cast(CodeGen g, IrExecutableGen executable,
	3125	IrInstGenCast *cast_instruction)
3126	3126	{
3127	3127	ZigType *actual_type = cast_instruction->value->value->type;
3128	3128	ZigType *wanted_type = cast_instruction->base.value->type;
...	...	@@ -3199,8 +3199,8 @@ static LLVMValueRef ir_render_cast(CodeGen g, IrExecutable executable,
3199	3199	zig_unreachable();
3200	3200	}
3201	3201
3202		static LLVMValueRef ir_render_ptr_of_array_to_slice(CodeGen g, IrExecutable executable,
3203		IrInstructionPtrOfArrayToSlice *instruction)
	3202	static LLVMValueRef ir_render_ptr_of_array_to_slice(CodeGen g, IrExecutableGen executable,
	3203	IrInstGenPtrOfArrayToSlice *instruction)
3204	3204	{
3205	3205	ZigType *actual_type = instruction->operand->value->type;
3206	3206	ZigType *slice_type = instruction->base.value->type;
...	...	@@ -3236,8 +3236,8 @@ static LLVMValueRef ir_render_ptr_of_array_to_slice(CodeGen g, IrExecutable ex
3236	3236	return result_loc;
3237	3237	}
3238	3238
3239		static LLVMValueRef ir_render_ptr_cast(CodeGen g, IrExecutable executable,
3240		IrInstructionPtrCastGen *instruction)
	3239	static LLVMValueRef ir_render_ptr_cast(CodeGen g, IrExecutableGen executable,
	3240	IrInstGenPtrCast *instruction)
3241	3241	{
3242	3242	ZigType *wanted_type = instruction->base.value->type;
3243	3243	if (!type_has_bits(wanted_type)) {
...	...	@@ -3262,8 +3262,8 @@ static LLVMValueRef ir_render_ptr_cast(CodeGen g, IrExecutable executable,
3262	3262	return result_ptr;
3263	3263	}
3264	3264
3265		static LLVMValueRef ir_render_bit_cast(CodeGen g, IrExecutable executable,
3266		IrInstructionBitCastGen *instruction)
	3265	static LLVMValueRef ir_render_bit_cast(CodeGen g, IrExecutableGen executable,
	3266	IrInstGenBitCast *instruction)
3267	3267	{
3268	3268	ZigType *wanted_type = instruction->base.value->type;
3269	3269	ZigType *actual_type = instruction->operand->value->type;
...	...	@@ -3286,8 +3286,8 @@ static LLVMValueRef ir_render_bit_cast(CodeGen g, IrExecutable executable,
3286	3286	}
3287	3287	}
3288	3288
3289		static LLVMValueRef ir_render_widen_or_shorten(CodeGen g, IrExecutable executable,
3290		IrInstructionWidenOrShorten *instruction)
	3289	static LLVMValueRef ir_render_widen_or_shorten(CodeGen g, IrExecutableGen executable,
	3290	IrInstGenWidenOrShorten *instruction)
3291	3291	{
3292	3292	ZigType *actual_type = instruction->target->value->type;
3293	3293	// TODO instead of this logic, use the Noop instruction to change the type from
...	...	@@ -3303,7 +3303,7 @@ static LLVMValueRef ir_render_widen_or_shorten(CodeGen g, IrExecutable executa
3303	3303	instruction->base.value->type, target_val);
3304	3304	}
3305	3305
3306		static LLVMValueRef ir_render_int_to_ptr(CodeGen g, IrExecutable executable, IrInstructionIntToPtr *instruction) {
	3306	static LLVMValueRef ir_render_int_to_ptr(CodeGen g, IrExecutableGen executable, IrInstGenIntToPtr *instruction) {
3307	3307	ZigType *wanted_type = instruction->base.value->type;
3308	3308	LLVMValueRef target_val = ir_llvm_value(g, instruction->target);
3309	3309
...	...	@@ -3341,13 +3341,13 @@ static LLVMValueRef ir_render_int_to_ptr(CodeGen g, IrExecutable executable, I
3341	3341	return LLVMBuildIntToPtr(g->builder, target_val, get_llvm_type(g, wanted_type), "");
3342	3342	}
3343	3343
3344		static LLVMValueRef ir_render_ptr_to_int(CodeGen g, IrExecutable executable, IrInstructionPtrToInt *instruction) {
	3344	static LLVMValueRef ir_render_ptr_to_int(CodeGen g, IrExecutableGen executable, IrInstGenPtrToInt *instruction) {
3345	3345	ZigType *wanted_type = instruction->base.value->type;
3346	3346	LLVMValueRef target_val = ir_llvm_value(g, instruction->target);
3347	3347	return LLVMBuildPtrToInt(g->builder, target_val, get_llvm_type(g, wanted_type), "");
3348	3348	}
3349	3349
3350		static LLVMValueRef ir_render_int_to_enum(CodeGen g, IrExecutable executable, IrInstructionIntToEnum *instruction) {
	3350	static LLVMValueRef ir_render_int_to_enum(CodeGen g, IrExecutableGen executable, IrInstGenIntToEnum *instruction) {
3351	3351	ZigType *wanted_type = instruction->base.value->type;
3352	3352	assert(wanted_type->id == ZigTypeIdEnum);
3353	3353	ZigType *tag_int_type = wanted_type->data.enumeration.tag_int_type;
...	...	@@ -3374,7 +3374,7 @@ static LLVMValueRef ir_render_int_to_enum(CodeGen g, IrExecutable executable,
3374	3374	return tag_int_value;
3375	3375	}
3376	3376
3377		static LLVMValueRef ir_render_int_to_err(CodeGen g, IrExecutable executable, IrInstructionIntToErr *instruction) {
	3377	static LLVMValueRef ir_render_int_to_err(CodeGen g, IrExecutableGen executable, IrInstGenIntToErr *instruction) {
3378	3378	ZigType *wanted_type = instruction->base.value->type;
3379	3379	assert(wanted_type->id == ZigTypeIdErrorSet);
3380	3380
...	...	@@ -3391,7 +3391,7 @@ static LLVMValueRef ir_render_int_to_err(CodeGen g, IrExecutable executable, I
3391	3391	return gen_widen_or_shorten(g, false, actual_type, g->err_tag_type, target_val);
3392	3392	}
3393	3393
3394		static LLVMValueRef ir_render_err_to_int(CodeGen g, IrExecutable executable, IrInstructionErrToInt *instruction) {
	3394	static LLVMValueRef ir_render_err_to_int(CodeGen g, IrExecutableGen executable, IrInstGenErrToInt *instruction) {
3395	3395	ZigType *wanted_type = instruction->base.value->type;
3396	3396	assert(wanted_type->id == ZigTypeIdInt);
3397	3397	assert(!wanted_type->data.integral.is_signed);
...	...	@@ -3417,8 +3417,8 @@ static LLVMValueRef ir_render_err_to_int(CodeGen g, IrExecutable executable, I
3417	3417	}
3418	3418	}
3419	3419
3420		static LLVMValueRef ir_render_unreachable(CodeGen g, IrExecutable executable,
3421		IrInstructionUnreachable *unreachable_instruction)
	3420	static LLVMValueRef ir_render_unreachable(CodeGen g, IrExecutableGen executable,
	3421	IrInstGenUnreachable *unreachable_instruction)
3422	3422	{
3423	3423	if (ir_want_runtime_safety(g, &unreachable_instruction->base)) {
3424	3424	gen_safety_crash(g, PanicMsgIdUnreachable);
...	...	@@ -3428,8 +3428,8 @@ static LLVMValueRef ir_render_unreachable(CodeGen g, IrExecutable executable,
3428	3428	return nullptr;
3429	3429	}
3430	3430
3431		static LLVMValueRef ir_render_cond_br(CodeGen g, IrExecutable executable,
3432		IrInstructionCondBr *cond_br_instruction)
	3431	static LLVMValueRef ir_render_cond_br(CodeGen g, IrExecutableGen executable,
	3432	IrInstGenCondBr *cond_br_instruction)
3433	3433	{
3434	3434	LLVMBuildCondBr(g->builder,
3435	3435	ir_llvm_value(g, cond_br_instruction->condition),
...	...	@@ -3438,51 +3438,56 @@ static LLVMValueRef ir_render_cond_br(CodeGen g, IrExecutable executable,
3438	3438	return nullptr;
3439	3439	}
3440	3440
3441		static LLVMValueRef ir_render_br(CodeGen g, IrExecutable executable, IrInstructionBr *br_instruction) {
	3441	static LLVMValueRef ir_render_br(CodeGen g, IrExecutableGen executable, IrInstGenBr *br_instruction) {
3442	3442	LLVMBuildBr(g->builder, br_instruction->dest_block->llvm_block);
3443	3443	return nullptr;
3444	3444	}
3445	3445
3446		static LLVMValueRef ir_render_un_op(CodeGen g, IrExecutable executable, IrInstructionUnOp *un_op_instruction) {
3447		IrUnOp op_id = un_op_instruction->op_id;
3448		LLVMValueRef expr = ir_llvm_value(g, un_op_instruction->value);
3449		ZigType *operand_type = un_op_instruction->value->value->type;
3450		ZigType *scalar_type = (operand_type->id == ZigTypeIdVector) ? operand_type->data.vector.elem_type : operand_type;
3451
3452		switch (op_id) {
3453		case IrUnOpInvalid:
3454		case IrUnOpOptional:
3455		case IrUnOpDereference:
3456		zig_unreachable();
3457		case IrUnOpNegation:
3458		case IrUnOpNegationWrap:
3459		{
3460		if (scalar_type->id == ZigTypeIdFloat) {
3461		ZigLLVMSetFastMath(g->builder, ir_want_fast_math(g, &un_op_instruction->base));
3462		return LLVMBuildFNeg(g->builder, expr, "");
3463		} else if (scalar_type->id == ZigTypeIdInt) {
3464		if (op_id == IrUnOpNegationWrap) {
3465		return LLVMBuildNeg(g->builder, expr, "");
3466		} else if (ir_want_runtime_safety(g, &un_op_instruction->base)) {
3467		LLVMValueRef zero = LLVMConstNull(LLVMTypeOf(expr));
3468		return gen_overflow_op(g, operand_type, AddSubMulSub, zero, expr);
3469		} else if (scalar_type->data.integral.is_signed) {
3470		return LLVMBuildNSWNeg(g->builder, expr, "");
3471		} else {
3472		return LLVMBuildNUWNeg(g->builder, expr, "");
3473		}
3474		} else {
3475		zig_unreachable();
3476		}
3477		}
3478		case IrUnOpBinNot:
3479		return LLVMBuildNot(g->builder, expr, "");
	3446	static LLVMValueRef ir_render_binary_not(CodeGen g, IrExecutableGen executable,
	3447	IrInstGenBinaryNot *inst)
	3448	{
	3449	LLVMValueRef operand = ir_llvm_value(g, inst->operand);
	3450	return LLVMBuildNot(g->builder, operand, "");
	3451	}
	3452
	3453	static LLVMValueRef ir_gen_negation(CodeGen g, IrInstGen inst, IrInstGen *operand, bool wrapping) {
	3454	LLVMValueRef llvm_operand = ir_llvm_value(g, operand);
	3455	ZigType *operand_type = operand->value->type;
	3456	ZigType *scalar_type = (operand_type->id == ZigTypeIdVector) ?
	3457	operand_type->data.vector.elem_type : operand_type;
	3458
	3459	if (scalar_type->id == ZigTypeIdFloat) {
	3460	ZigLLVMSetFastMath(g->builder, ir_want_fast_math(g, inst));
	3461	return LLVMBuildFNeg(g->builder, llvm_operand, "");
	3462	} else if (scalar_type->id == ZigTypeIdInt) {
	3463	if (wrapping) {
	3464	return LLVMBuildNeg(g->builder, llvm_operand, "");
	3465	} else if (ir_want_runtime_safety(g, inst)) {
	3466	LLVMValueRef zero = LLVMConstNull(LLVMTypeOf(llvm_operand));
	3467	return gen_overflow_op(g, operand_type, AddSubMulSub, zero, llvm_operand);
	3468	} else if (scalar_type->data.integral.is_signed) {
	3469	return LLVMBuildNSWNeg(g->builder, llvm_operand, "");
	3470	} else {
	3471	return LLVMBuildNUWNeg(g->builder, llvm_operand, "");
	3472	}
	3473	} else {
	3474	zig_unreachable();
3480	3475	}
	3476	}
3481	3477
3482		zig_unreachable();
	3478	static LLVMValueRef ir_render_negation(CodeGen g, IrExecutableGen executable,
	3479	IrInstGenNegation *inst)
	3480	{
	3481	return ir_gen_negation(g, &inst->base, inst->operand, false);
3483	3482	}
3484	3483
3485		static LLVMValueRef ir_render_bool_not(CodeGen g, IrExecutable executable, IrInstructionBoolNot *instruction) {
	3484	static LLVMValueRef ir_render_negation_wrapping(CodeGen g, IrExecutableGen executable,
	3485	IrInstGenNegationWrapping *inst)
	3486	{
	3487	return ir_gen_negation(g, &inst->base, inst->operand, true);
	3488	}
	3489
	3490	static LLVMValueRef ir_render_bool_not(CodeGen g, IrExecutableGen executable, IrInstGenBoolNot *instruction) {
3486	3491	LLVMValueRef value = ir_llvm_value(g, instruction->value);
3487	3492	LLVMValueRef zero = LLVMConstNull(LLVMTypeOf(value));
3488	3493	return LLVMBuildICmp(g->builder, LLVMIntEQ, value, zero, "");
...	...	@@ -3496,14 +3501,14 @@ static void render_decl_var(CodeGen g, ZigVar var) {
3496	3501	gen_var_debug_decl(g, var);
3497	3502	}
3498	3503
3499		static LLVMValueRef ir_render_decl_var(CodeGen g, IrExecutable executable, IrInstructionDeclVarGen *instruction) {
	3504	static LLVMValueRef ir_render_decl_var(CodeGen g, IrExecutableGen executable, IrInstGenDeclVar *instruction) {
3500	3505	instruction->var->ptr_instruction = instruction->var_ptr;
3501	3506	render_decl_var(g, instruction->var);
3502	3507	return nullptr;
3503	3508	}
3504	3509
3505		static LLVMValueRef ir_render_load_ptr(CodeGen g, IrExecutable executable,
3506		IrInstructionLoadPtrGen *instruction)
	3510	static LLVMValueRef ir_render_load_ptr(CodeGen g, IrExecutableGen executable,
	3511	IrInstGenLoadPtr *instruction)
3507	3512	{
3508	3513	ZigType *child_type = instruction->base.value->type;
3509	3514	if (!type_has_bits(child_type))
...	...	@@ -3705,7 +3710,7 @@ static void gen_undef_init(CodeGen g, uint32_t ptr_align_bytes, ZigType value_
3705	3710	}
3706	3711	}
3707	3712
3708		static LLVMValueRef ir_render_store_ptr(CodeGen g, IrExecutable executable, IrInstructionStorePtr *instruction) {
	3713	static LLVMValueRef ir_render_store_ptr(CodeGen g, IrExecutableGen executable, IrInstGenStorePtr *instruction) {
3709	3714	Error err;
3710	3715
3711	3716	ZigType *ptr_type = instruction->ptr->value->type;
...	...	@@ -3715,7 +3720,7 @@ static LLVMValueRef ir_render_store_ptr(CodeGen g, IrExecutable executable, Ir
3715	3720	codegen_report_errors_and_exit(g);
3716	3721	if (!ptr_type_has_bits)
3717	3722	return nullptr;
3718		if (instruction->ptr->ref_count == 0) {
	3723	if (instruction->ptr->base.ref_count == 0) {
3719	3724	// In this case, this StorePtr instruction should be elided. Something happened like this:
3720	3725	// var t = true;
3721	3726	// const x = if (t) Num.Two else unreachable;
...	...	@@ -3737,8 +3742,8 @@ static LLVMValueRef ir_render_store_ptr(CodeGen g, IrExecutable executable, Ir
3737	3742	return nullptr;
3738	3743	}
3739	3744
3740		static LLVMValueRef ir_render_vector_store_elem(CodeGen g, IrExecutable executable,
3741		IrInstructionVectorStoreElem *instruction)
	3745	static LLVMValueRef ir_render_vector_store_elem(CodeGen g, IrExecutableGen executable,
	3746	IrInstGenVectorStoreElem *instruction)
3742	3747	{
3743	3748	LLVMValueRef vector_ptr = ir_llvm_value(g, instruction->vector_ptr);
3744	3749	LLVMValueRef index = ir_llvm_value(g, instruction->index);
...	...	@@ -3750,7 +3755,7 @@ static LLVMValueRef ir_render_vector_store_elem(CodeGen g, IrExecutable execut
3750	3755	return nullptr;
3751	3756	}
3752	3757
3753		static LLVMValueRef ir_render_var_ptr(CodeGen g, IrExecutable executable, IrInstructionVarPtr *instruction) {
	3758	static LLVMValueRef ir_render_var_ptr(CodeGen g, IrExecutableGen executable, IrInstGenVarPtr *instruction) {
3754	3759	if (instruction->base.value->special != ConstValSpecialRuntime)
3755	3760	return ir_llvm_value(g, &instruction->base);
3756	3761	ZigVar *var = instruction->var;
...	...	@@ -3762,8 +3767,8 @@ static LLVMValueRef ir_render_var_ptr(CodeGen g, IrExecutable executable, IrIn
3762	3767	}
3763	3768	}
3764	3769
3765		static LLVMValueRef ir_render_return_ptr(CodeGen g, IrExecutable executable,
3766		IrInstructionReturnPtr *instruction)
	3770	static LLVMValueRef ir_render_return_ptr(CodeGen g, IrExecutableGen executable,
	3771	IrInstGenReturnPtr *instruction)
3767	3772	{
3768	3773	if (!type_has_bits(instruction->base.value->type))
3769	3774	return nullptr;
...	...	@@ -3771,7 +3776,7 @@ static LLVMValueRef ir_render_return_ptr(CodeGen g, IrExecutable executable,
3771	3776	return g->cur_ret_ptr;
3772	3777	}
3773	3778
3774		static LLVMValueRef ir_render_elem_ptr(CodeGen g, IrExecutable executable, IrInstructionElemPtr *instruction) {
	3779	static LLVMValueRef ir_render_elem_ptr(CodeGen g, IrExecutableGen executable, IrInstGenElemPtr *instruction) {
3775	3780	LLVMValueRef array_ptr_ptr = ir_llvm_value(g, instruction->array_ptr);
3776	3781	ZigType *array_ptr_type = instruction->array_ptr->value->type;
3777	3782	assert(array_ptr_type->id == ZigTypeIdPointer);
...	...	@@ -3947,7 +3952,7 @@ static void render_async_spills(CodeGen *g) {
3947	3952	ZigType *frame_type = g->cur_fn->frame_type->data.frame.locals_struct;
3948	3953
3949	3954	for (size_t alloca_i = 0; alloca_i < g->cur_fn->alloca_gen_list.length; alloca_i += 1) {
3950		IrInstructionAllocaGen *instruction = g->cur_fn->alloca_gen_list.at(alloca_i);
	3955	IrInstGenAlloca *instruction = g->cur_fn->alloca_gen_list.at(alloca_i);
3951	3956	if (instruction->field_index == SIZE_MAX)
3952	3957	continue;
3953	3958
...	...	@@ -4014,7 +4019,7 @@ static void gen_init_stack_trace(CodeGen *g, LLVMValueRef trace_field_ptr, LLVMV
4014	4019	LLVMBuildStore(g->builder, LLVMConstInt(usize_type_ref, stack_trace_ptr_count, false), addrs_len_ptr);
4015	4020	}
4016	4021
4017		static LLVMValueRef ir_render_call(CodeGen g, IrExecutable executable, IrInstructionCallGen *instruction) {
	4022	static LLVMValueRef ir_render_call(CodeGen g, IrExecutableGen executable, IrInstGenCall *instruction) {
4018	4023	LLVMTypeRef usize_type_ref = g->builtin_types.entry_usize->llvm_type;
4019	4024
4020	4025	LLVMValueRef fn_val;
...	...	@@ -4149,7 +4154,7 @@ static LLVMValueRef ir_render_call(CodeGen g, IrExecutable executable, IrInstr
4149	4154	LLVMValueRef err_ret_trace_ptr_ptr = LLVMBuildStructGEP(g->builder, frame_result_loc,
4150	4155	frame_index_trace_arg(g, src_return_type) + 1, "");
4151	4156	bool is_llvm_alloca;
4152		LLVMValueRef my_err_ret_trace_val = get_cur_err_ret_trace_val(g, instruction->base.scope,
	4157	LLVMValueRef my_err_ret_trace_val = get_cur_err_ret_trace_val(g, instruction->base.base.scope,
4153	4158	&is_llvm_alloca);
4154	4159	LLVMBuildStore(g->builder, my_err_ret_trace_val, err_ret_trace_ptr_ptr);
4155	4160	}
...	...	@@ -4208,7 +4213,7 @@ static LLVMValueRef ir_render_call(CodeGen g, IrExecutable executable, IrInstr
4208	4213	gen_init_stack_trace(g, trace_field_ptr, addrs_field_ptr);
4209	4214
4210	4215	bool is_llvm_alloca;
4211		gen_param_values.append(get_cur_err_ret_trace_val(g, instruction->base.scope, &is_llvm_alloca));
	4216	gen_param_values.append(get_cur_err_ret_trace_val(g, instruction->base.base.scope, &is_llvm_alloca));
4212	4217	}
4213	4218	}
4214	4219	} else {
...	...	@@ -4217,7 +4222,7 @@ static LLVMValueRef ir_render_call(CodeGen g, IrExecutable executable, IrInstr
4217	4222	}
4218	4223	if (prefix_arg_err_ret_stack) {
4219	4224	bool is_llvm_alloca;
4220		gen_param_values.append(get_cur_err_ret_trace_val(g, instruction->base.scope, &is_llvm_alloca));
	4225	gen_param_values.append(get_cur_err_ret_trace_val(g, instruction->base.base.scope, &is_llvm_alloca));
4221	4226	}
4222	4227	}
4223	4228	FnWalk fn_walk = {};
...	...	@@ -4327,13 +4332,13 @@ static LLVMValueRef ir_render_call(CodeGen g, IrExecutable executable, IrInstr
4327	4332
4328	4333	LLVMPositionBuilderAtEnd(g->builder, call_bb);
4329	4334	gen_assert_resume_id(g, &instruction->base, ResumeIdReturn, PanicMsgIdResumedAnAwaitingFn, nullptr);
4330		render_async_var_decls(g, instruction->base.scope);
	4335	render_async_var_decls(g, instruction->base.base.scope);
4331	4336
4332	4337	if (!type_has_bits(src_return_type))
4333	4338	return nullptr;
4334	4339
4335	4340	if (result_loc != nullptr) {
4336		if (instruction->result_loc->id == IrInstructionIdReturnPtr) {
	4341	if (instruction->result_loc->id == IrInstGenIdReturnPtr) {
4337	4342	instruction->base.spill = nullptr;
4338	4343	return g->cur_ret_ptr;
4339	4344	} else {
...	...	@@ -4393,8 +4398,8 @@ static LLVMValueRef ir_render_call(CodeGen g, IrExecutable executable, IrInstr
4393	4398	}
4394	4399	}
4395	4400
4396		static LLVMValueRef ir_render_struct_field_ptr(CodeGen g, IrExecutable executable,
4397		IrInstructionStructFieldPtr *instruction)
	4401	static LLVMValueRef ir_render_struct_field_ptr(CodeGen g, IrExecutableGen executable,
	4402	IrInstGenStructFieldPtr *instruction)
4398	4403	{
4399	4404	Error err;
4400	4405
...	...	@@ -4444,8 +4449,8 @@ static LLVMValueRef ir_render_struct_field_ptr(CodeGen g, IrExecutable executa
4444	4449	return field_ptr_val;
4445	4450	}
4446	4451
4447		static LLVMValueRef ir_render_union_field_ptr(CodeGen g, IrExecutable executable,
4448		IrInstructionUnionFieldPtr *instruction)
	4452	static LLVMValueRef ir_render_union_field_ptr(CodeGen g, IrExecutableGen executable,
	4453	IrInstGenUnionFieldPtr *instruction)
4449	4454	{
4450	4455	if (instruction->base.value->special != ConstValSpecialRuntime)
4451	4456	return nullptr;
...	...	@@ -4544,8 +4549,8 @@ static size_t find_asm_index(CodeGen g, AstNode node, AsmToken tok, Buf src_
4544	4549	return SIZE_MAX;
4545	4550	}
4546	4551
4547		static LLVMValueRef ir_render_asm_gen(CodeGen g, IrExecutable executable, IrInstructionAsmGen *instruction) {
4548		AstNode *asm_node = instruction->base.source_node;
	4552	static LLVMValueRef ir_render_asm_gen(CodeGen g, IrExecutableGen executable, IrInstGenAsm *instruction) {
	4553	AstNode *asm_node = instruction->base.base.source_node;
4549	4554	assert(asm_node->type == NodeTypeAsmExpr);
4550	4555	AstNodeAsmExpr *asm_expr = &asm_node->data.asm_expr;
4551	4556
...	...	@@ -4629,7 +4634,7 @@ static LLVMValueRef ir_render_asm_gen(CodeGen g, IrExecutable executable, IrIn
4629	4634	for (size_t i = 0; i < asm_expr->input_list.length; i += 1, total_index += 1, param_index += 1) {
4630	4635	AsmInput *asm_input = asm_expr->input_list.at(i);
4631	4636	buf_replace(asm_input->constraint, ',', '\|');
4632		IrInstruction *ir_input = instruction->input_list[i];
	4637	IrInstGen *ir_input = instruction->input_list[i];
4633	4638	buf_append_buf(&constraint_buf, asm_input->constraint);
4634	4639	if (total_index + 1 < total_constraint_count) {
4635	4640	buf_append_char(&constraint_buf, ',');
...	...	@@ -4692,14 +4697,14 @@ static LLVMValueRef gen_non_null_bit(CodeGen g, ZigType maybe_type, LLVMValueR
4692	4697	return gen_load_untyped(g, maybe_field_ptr, 0, false, "");
4693	4698	}
4694	4699
4695		static LLVMValueRef ir_render_test_non_null(CodeGen g, IrExecutable executable,
4696		IrInstructionTestNonNull *instruction)
	4700	static LLVMValueRef ir_render_test_non_null(CodeGen g, IrExecutableGen executable,
	4701	IrInstGenTestNonNull *instruction)
4697	4702	{
4698	4703	return gen_non_null_bit(g, instruction->value->value->type, ir_llvm_value(g, instruction->value));
4699	4704	}
4700	4705
4701		static LLVMValueRef ir_render_optional_unwrap_ptr(CodeGen g, IrExecutable executable,
4702		IrInstructionOptionalUnwrapPtr *instruction)
	4706	static LLVMValueRef ir_render_optional_unwrap_ptr(CodeGen g, IrExecutableGen executable,
	4707	IrInstGenOptionalUnwrapPtr *instruction)
4703	4708	{
4704	4709	if (instruction->base.value->special != ConstValSpecialRuntime)
4705	4710	return nullptr;
...	...	@@ -4801,7 +4806,7 @@ static LLVMValueRef get_int_builtin_fn(CodeGen g, ZigType expr_type, BuiltinFn
4801	4806	return fn_val;
4802	4807	}
4803	4808
4804		static LLVMValueRef ir_render_clz(CodeGen g, IrExecutable executable, IrInstructionClz *instruction) {
	4809	static LLVMValueRef ir_render_clz(CodeGen g, IrExecutableGen executable, IrInstGenClz *instruction) {
4805	4810	ZigType *int_type = instruction->op->value->type;
4806	4811	LLVMValueRef fn_val = get_int_builtin_fn(g, int_type, BuiltinFnIdClz);
4807	4812	LLVMValueRef operand = ir_llvm_value(g, instruction->op);
...	...	@@ -4813,7 +4818,7 @@ static LLVMValueRef ir_render_clz(CodeGen g, IrExecutable executable, IrInstru
4813	4818	return gen_widen_or_shorten(g, false, int_type, instruction->base.value->type, wrong_size_int);
4814	4819	}
4815	4820
4816		static LLVMValueRef ir_render_ctz(CodeGen g, IrExecutable executable, IrInstructionCtz *instruction) {
	4821	static LLVMValueRef ir_render_ctz(CodeGen g, IrExecutableGen executable, IrInstGenCtz *instruction) {
4817	4822	ZigType *int_type = instruction->op->value->type;
4818	4823	LLVMValueRef fn_val = get_int_builtin_fn(g, int_type, BuiltinFnIdCtz);
4819	4824	LLVMValueRef operand = ir_llvm_value(g, instruction->op);
...	...	@@ -4825,7 +4830,7 @@ static LLVMValueRef ir_render_ctz(CodeGen g, IrExecutable executable, IrInstru
4825	4830	return gen_widen_or_shorten(g, false, int_type, instruction->base.value->type, wrong_size_int);
4826	4831	}
4827	4832
4828		static LLVMValueRef ir_render_shuffle_vector(CodeGen g, IrExecutable executable, IrInstructionShuffleVector *instruction) {
	4833	static LLVMValueRef ir_render_shuffle_vector(CodeGen g, IrExecutableGen executable, IrInstGenShuffleVector *instruction) {
4829	4834	uint64_t len_a = instruction->a->value->type->data.vector.len;
4830	4835	uint64_t len_mask = instruction->mask->value->type->data.vector.len;
4831	4836
...	...	@@ -4834,7 +4839,7 @@ static LLVMValueRef ir_render_shuffle_vector(CodeGen g, IrExecutable executabl
4834	4839	// when changing code, so Zig uses negative numbers to index the
4835	4840	// second vector. These start at -1 and go down, and are easiest to use
4836	4841	// with the ~ operator. Here we convert between the two formats.
4837		IrInstruction *mask = instruction->mask;
	4842	IrInstGen *mask = instruction->mask;
4838	4843	LLVMValueRef *values = allocate<LLVMValueRef>(len_mask);
4839	4844	for (uint64_t i = 0; i < len_mask; i++) {
4840	4845	if (mask->value->data.x_array.data.s_none.elements[i].special == ConstValSpecialUndef) {
...	...	@@ -4855,7 +4860,7 @@ static LLVMValueRef ir_render_shuffle_vector(CodeGen g, IrExecutable executabl
4855	4860	llvm_mask_value, "");
4856	4861	}
4857	4862
4858		static LLVMValueRef ir_render_splat(CodeGen g, IrExecutable executable, IrInstructionSplatGen *instruction) {
	4863	static LLVMValueRef ir_render_splat(CodeGen g, IrExecutableGen executable, IrInstGenSplat *instruction) {
4859	4864	ZigType *result_type = instruction->base.value->type;
4860	4865	ir_assert(result_type->id == ZigTypeIdVector, &instruction->base);
4861	4866	uint32_t len = result_type->data.vector.len;
...	...	@@ -4867,7 +4872,7 @@ static LLVMValueRef ir_render_splat(CodeGen g, IrExecutable executable, IrInst
4867	4872	return LLVMBuildShuffleVector(g->builder, op_vector, undef_vector, LLVMConstNull(mask_llvm_type), "");
4868	4873	}
4869	4874
4870		static LLVMValueRef ir_render_pop_count(CodeGen g, IrExecutable executable, IrInstructionPopCount *instruction) {
	4875	static LLVMValueRef ir_render_pop_count(CodeGen g, IrExecutableGen executable, IrInstGenPopCount *instruction) {
4871	4876	ZigType *int_type = instruction->op->value->type;
4872	4877	LLVMValueRef fn_val = get_int_builtin_fn(g, int_type, BuiltinFnIdPopCount);
4873	4878	LLVMValueRef operand = ir_llvm_value(g, instruction->op);
...	...	@@ -4875,7 +4880,7 @@ static LLVMValueRef ir_render_pop_count(CodeGen g, IrExecutable executable, Ir
4875	4880	return gen_widen_or_shorten(g, false, int_type, instruction->base.value->type, wrong_size_int);
4876	4881	}
4877	4882
4878		static LLVMValueRef ir_render_switch_br(CodeGen g, IrExecutable executable, IrInstructionSwitchBr *instruction) {
	4883	static LLVMValueRef ir_render_switch_br(CodeGen g, IrExecutableGen executable, IrInstGenSwitchBr *instruction) {
4879	4884	ZigType *target_type = instruction->target_value->value->type;
4880	4885	LLVMBasicBlockRef else_block = instruction->else_block->llvm_block;
4881	4886
...	...	@@ -4889,7 +4894,7 @@ static LLVMValueRef ir_render_switch_br(CodeGen g, IrExecutable executable, Ir
4889	4894	(unsigned)instruction->case_count);
4890	4895
4891	4896	for (size_t i = 0; i < instruction->case_count; i += 1) {
4892		IrInstructionSwitchBrCase *this_case = &instruction->cases[i];
	4897	IrInstGenSwitchBrCase *this_case = &instruction->cases[i];
4893	4898
4894	4899	LLVMValueRef case_value = ir_llvm_value(g, this_case->value);
4895	4900	if (target_type->id == ZigTypeIdPointer) {
...	...	@@ -4903,7 +4908,7 @@ static LLVMValueRef ir_render_switch_br(CodeGen g, IrExecutable executable, Ir
4903	4908	return nullptr;
4904	4909	}
4905	4910
4906		static LLVMValueRef ir_render_phi(CodeGen g, IrExecutable executable, IrInstructionPhi *instruction) {
	4911	static LLVMValueRef ir_render_phi(CodeGen g, IrExecutableGen executable, IrInstGenPhi *instruction) {
4907	4912	if (!type_has_bits(instruction->base.value->type))
4908	4913	return nullptr;
4909	4914
...	...	@@ -4925,7 +4930,7 @@ static LLVMValueRef ir_render_phi(CodeGen g, IrExecutable executable, IrInstru
4925	4930	return phi;
4926	4931	}
4927	4932
4928		static LLVMValueRef ir_render_ref(CodeGen g, IrExecutable executable, IrInstructionRefGen *instruction) {
	4933	static LLVMValueRef ir_render_ref(CodeGen g, IrExecutableGen executable, IrInstGenRef *instruction) {
4929	4934	if (!type_has_bits(instruction->base.value->type)) {
4930	4935	return nullptr;
4931	4936	}
...	...	@@ -4939,7 +4944,7 @@ static LLVMValueRef ir_render_ref(CodeGen g, IrExecutable executable, IrInstru
4939	4944	}
4940	4945	}
4941	4946
4942		static LLVMValueRef ir_render_err_name(CodeGen g, IrExecutable executable, IrInstructionErrName *instruction) {
	4947	static LLVMValueRef ir_render_err_name(CodeGen g, IrExecutableGen executable, IrInstGenErrName *instruction) {
4943	4948	assert(g->generate_error_name_table);
4944	4949
4945	4950	if (g->errors_by_index.length == 1) {
...	...	@@ -5060,13 +5065,13 @@ static LLVMValueRef get_enum_tag_name_function(CodeGen g, ZigType enum_type) {
5060	5065	return fn_val;
5061	5066	}
5062	5067
5063		static LLVMValueRef ir_render_enum_tag_name(CodeGen g, IrExecutable executable,
5064		IrInstructionTagName *instruction)
	5068	static LLVMValueRef ir_render_enum_tag_name(CodeGen g, IrExecutableGen executable,
	5069	IrInstGenTagName *instruction)
5065	5070	{
5066	5071	ZigType *enum_type = instruction->target->value->type;
5067	5072	assert(enum_type->id == ZigTypeIdEnum);
5068	5073	if (enum_type->data.enumeration.non_exhaustive) {
5069		add_node_error(g, instruction->base.source_node,
	5074	add_node_error(g, instruction->base.base.source_node,
5070	5075	buf_sprintf("TODO @tagName on non-exhaustive enum https://github.com/ziglang/zig/issues/3991"));
5071	5076	codegen_report_errors_and_exit(g);
5072	5077	}
...	...	@@ -5078,8 +5083,8 @@ static LLVMValueRef ir_render_enum_tag_name(CodeGen g, IrExecutable executable
5078	5083	get_llvm_cc(g, CallingConventionUnspecified), ZigLLVM_CallAttrAuto, "");
5079	5084	}
5080	5085
5081		static LLVMValueRef ir_render_field_parent_ptr(CodeGen g, IrExecutable executable,
5082		IrInstructionFieldParentPtr *instruction)
	5086	static LLVMValueRef ir_render_field_parent_ptr(CodeGen g, IrExecutableGen executable,
	5087	IrInstGenFieldParentPtr *instruction)
5083	5088	{
5084	5089	ZigType *container_ptr_type = instruction->base.value->type;
5085	5090	assert(container_ptr_type->id == ZigTypeIdPointer);
...	...	@@ -5105,7 +5110,7 @@ static LLVMValueRef ir_render_field_parent_ptr(CodeGen g, IrExecutable executa
5105	5110	}
5106	5111	}
5107	5112
5108		static LLVMValueRef ir_render_align_cast(CodeGen g, IrExecutable executable, IrInstructionAlignCast *instruction) {
	5113	static LLVMValueRef ir_render_align_cast(CodeGen g, IrExecutableGen executable, IrInstGenAlignCast *instruction) {
5109	5114	LLVMValueRef target_val = ir_llvm_value(g, instruction->target);
5110	5115	assert(target_val);
5111	5116
...	...	@@ -5168,11 +5173,11 @@ static LLVMValueRef ir_render_align_cast(CodeGen g, IrExecutable executable, I
5168	5173	return target_val;
5169	5174	}
5170	5175
5171		static LLVMValueRef ir_render_error_return_trace(CodeGen g, IrExecutable executable,
5172		IrInstructionErrorReturnTrace *instruction)
	5176	static LLVMValueRef ir_render_error_return_trace(CodeGen g, IrExecutableGen executable,
	5177	IrInstGenErrorReturnTrace *instruction)
5173	5178	{
5174	5179	bool is_llvm_alloca;
5175		LLVMValueRef cur_err_ret_trace_val = get_cur_err_ret_trace_val(g, instruction->base.scope, &is_llvm_alloca);
	5180	LLVMValueRef cur_err_ret_trace_val = get_cur_err_ret_trace_val(g, instruction->base.base.scope, &is_llvm_alloca);
5176	5181	if (cur_err_ret_trace_val == nullptr) {
5177	5182	return LLVMConstNull(get_llvm_type(g, ptr_to_stack_trace_type(g)));
5178	5183	}
...	...	@@ -5210,7 +5215,7 @@ static enum ZigLLVM_AtomicRMWBinOp to_ZigLLVMAtomicRMWBinOp(AtomicRmwOp op, bool
5210	5215	zig_unreachable();
5211	5216	}
5212	5217
5213		static LLVMValueRef ir_render_cmpxchg(CodeGen g, IrExecutable executable, IrInstructionCmpxchgGen *instruction) {
	5218	static LLVMValueRef ir_render_cmpxchg(CodeGen g, IrExecutableGen executable, IrInstGenCmpxchg *instruction) {
5214	5219	LLVMValueRef ptr_val = ir_llvm_value(g, instruction->ptr);
5215	5220	LLVMValueRef cmp_val = ir_llvm_value(g, instruction->cmp_value);
5216	5221	LLVMValueRef new_val = ir_llvm_value(g, instruction->new_value);
...	...	@@ -5251,13 +5256,13 @@ static LLVMValueRef ir_render_cmpxchg(CodeGen g, IrExecutable executable, IrIn
5251	5256	return result_loc;
5252	5257	}
5253	5258
5254		static LLVMValueRef ir_render_fence(CodeGen g, IrExecutable executable, IrInstructionFence *instruction) {
	5259	static LLVMValueRef ir_render_fence(CodeGen g, IrExecutableGen executable, IrInstGenFence *instruction) {
5255	5260	LLVMAtomicOrdering atomic_order = to_LLVMAtomicOrdering(instruction->order);
5256	5261	LLVMBuildFence(g->builder, atomic_order, false, "");
5257	5262	return nullptr;
5258	5263	}
5259	5264
5260		static LLVMValueRef ir_render_truncate(CodeGen g, IrExecutable executable, IrInstructionTruncate *instruction) {
	5265	static LLVMValueRef ir_render_truncate(CodeGen g, IrExecutableGen executable, IrInstGenTruncate *instruction) {
5261	5266	LLVMValueRef target_val = ir_llvm_value(g, instruction->target);
5262	5267	ZigType *dest_type = instruction->base.value->type;
5263	5268	ZigType *src_type = instruction->target->value->type;
...	...	@@ -5272,7 +5277,7 @@ static LLVMValueRef ir_render_truncate(CodeGen g, IrExecutable executable, IrI
5272	5277	}
5273	5278	}
5274	5279
5275		static LLVMValueRef ir_render_memset(CodeGen g, IrExecutable executable, IrInstructionMemset *instruction) {
	5280	static LLVMValueRef ir_render_memset(CodeGen g, IrExecutableGen executable, IrInstGenMemset *instruction) {
5276	5281	LLVMValueRef dest_ptr = ir_llvm_value(g, instruction->dest_ptr);
5277	5282	LLVMValueRef len_val = ir_llvm_value(g, instruction->count);
5278	5283
...	...	@@ -5284,7 +5289,7 @@ static LLVMValueRef ir_render_memset(CodeGen g, IrExecutable executable, IrIns
5284	5289
5285	5290	bool val_is_undef = value_is_all_undef(g, instruction->byte->value);
5286	5291	LLVMValueRef fill_char;
5287		if (val_is_undef && ir_want_runtime_safety_scope(g, instruction->base.scope)) {
	5292	if (val_is_undef && ir_want_runtime_safety_scope(g, instruction->base.base.scope)) {
5288	5293	fill_char = LLVMConstInt(LLVMInt8Type(), 0xaa, false);
5289	5294	} else {
5290	5295	fill_char = ir_llvm_value(g, instruction->byte);
...	...	@@ -5298,7 +5303,7 @@ static LLVMValueRef ir_render_memset(CodeGen g, IrExecutable executable, IrIns
5298	5303	return nullptr;
5299	5304	}
5300	5305
5301		static LLVMValueRef ir_render_memcpy(CodeGen g, IrExecutable executable, IrInstructionMemcpy *instruction) {
	5306	static LLVMValueRef ir_render_memcpy(CodeGen g, IrExecutableGen executable, IrInstGenMemcpy *instruction) {
5302	5307	LLVMValueRef dest_ptr = ir_llvm_value(g, instruction->dest_ptr);
5303	5308	LLVMValueRef src_ptr = ir_llvm_value(g, instruction->src_ptr);
5304	5309	LLVMValueRef len_val = ir_llvm_value(g, instruction->count);
...	...	@@ -5320,7 +5325,7 @@ static LLVMValueRef ir_render_memcpy(CodeGen g, IrExecutable executable, IrIns
5320	5325	return nullptr;
5321	5326	}
5322	5327
5323		static LLVMValueRef ir_render_slice(CodeGen g, IrExecutable executable, IrInstructionSliceGen *instruction) {
	5328	static LLVMValueRef ir_render_slice(CodeGen g, IrExecutableGen executable, IrInstGenSlice *instruction) {
5324	5329	LLVMValueRef array_ptr_ptr = ir_llvm_value(g, instruction->ptr);
5325	5330	ZigType *array_ptr_type = instruction->ptr->value->type;
5326	5331	assert(array_ptr_type->id == ZigTypeIdPointer);
...	...	@@ -5482,13 +5487,13 @@ static LLVMValueRef get_trap_fn_val(CodeGen *g) {
5482	5487	}
5483	5488
5484	5489
5485		static LLVMValueRef ir_render_breakpoint(CodeGen g, IrExecutable executable, IrInstructionBreakpoint *instruction) {
	5490	static LLVMValueRef ir_render_breakpoint(CodeGen g, IrExecutableGen executable, IrInstGenBreakpoint *instruction) {
5486	5491	LLVMBuildCall(g->builder, get_trap_fn_val(g), nullptr, 0, "");
5487	5492	return nullptr;
5488	5493	}
5489	5494
5490		static LLVMValueRef ir_render_return_address(CodeGen g, IrExecutable executable,
5491		IrInstructionReturnAddress *instruction)
	5495	static LLVMValueRef ir_render_return_address(CodeGen g, IrExecutableGen executable,
	5496	IrInstGenReturnAddress *instruction)
5492	5497	{
5493	5498	LLVMValueRef zero = LLVMConstNull(g->builtin_types.entry_i32->llvm_type);
5494	5499	LLVMValueRef ptr_val = LLVMBuildCall(g->builder, get_return_address_fn_val(g), &zero, 1, "");
...	...	@@ -5509,19 +5514,19 @@ static LLVMValueRef get_frame_address_fn_val(CodeGen *g) {
5509	5514	return g->frame_address_fn_val;
5510	5515	}
5511	5516
5512		static LLVMValueRef ir_render_frame_address(CodeGen g, IrExecutable executable,
5513		IrInstructionFrameAddress *instruction)
	5517	static LLVMValueRef ir_render_frame_address(CodeGen g, IrExecutableGen executable,
	5518	IrInstGenFrameAddress *instruction)
5514	5519	{
5515	5520	LLVMValueRef zero = LLVMConstNull(g->builtin_types.entry_i32->llvm_type);
5516	5521	LLVMValueRef ptr_val = LLVMBuildCall(g->builder, get_frame_address_fn_val(g), &zero, 1, "");
5517	5522	return LLVMBuildPtrToInt(g->builder, ptr_val, g->builtin_types.entry_usize->llvm_type, "");
5518	5523	}
5519	5524
5520		static LLVMValueRef ir_render_handle(CodeGen g, IrExecutable executable, IrInstructionFrameHandle *instruction) {
	5525	static LLVMValueRef ir_render_handle(CodeGen g, IrExecutableGen executable, IrInstGenFrameHandle *instruction) {
5521	5526	return g->cur_frame_ptr;
5522	5527	}
5523	5528
5524		static LLVMValueRef render_shl_with_overflow(CodeGen g, IrInstructionOverflowOp instruction) {
	5529	static LLVMValueRef render_shl_with_overflow(CodeGen g, IrInstGenOverflowOp instruction) {
5525	5530	ZigType *int_type = instruction->result_ptr_type;
5526	5531	assert(int_type->id == ZigTypeIdInt);
5527	5532
...	...	@@ -5546,7 +5551,7 @@ static LLVMValueRef render_shl_with_overflow(CodeGen *g, IrInstructionOverflowOp
5546	5551	return overflow_bit;
5547	5552	}
5548	5553
5549		static LLVMValueRef ir_render_overflow_op(CodeGen g, IrExecutable executable, IrInstructionOverflowOp *instruction) {
	5554	static LLVMValueRef ir_render_overflow_op(CodeGen g, IrExecutableGen executable, IrInstGenOverflowOp *instruction) {
5550	5555	AddSubMul add_sub_mul;
5551	5556	switch (instruction->op) {
5552	5557	case IrOverflowOpAdd:
...	...	@@ -5584,7 +5589,7 @@ static LLVMValueRef ir_render_overflow_op(CodeGen g, IrExecutable executable,
5584	5589	return overflow_bit;
5585	5590	}
5586	5591
5587		static LLVMValueRef ir_render_test_err(CodeGen g, IrExecutable executable, IrInstructionTestErrGen *instruction) {
	5592	static LLVMValueRef ir_render_test_err(CodeGen g, IrExecutableGen executable, IrInstGenTestErr *instruction) {
5588	5593	ZigType *err_union_type = instruction->err_union->value->type;
5589	5594	ZigType *payload_type = err_union_type->data.error_union.payload_type;
5590	5595	LLVMValueRef err_union_handle = ir_llvm_value(g, instruction->err_union);
...	...	@@ -5601,8 +5606,8 @@ static LLVMValueRef ir_render_test_err(CodeGen g, IrExecutable executable, IrI
5601	5606	return LLVMBuildICmp(g->builder, LLVMIntNE, err_val, zero, "");
5602	5607	}
5603	5608
5604		static LLVMValueRef ir_render_unwrap_err_code(CodeGen g, IrExecutable executable,
5605		IrInstructionUnwrapErrCode *instruction)
	5609	static LLVMValueRef ir_render_unwrap_err_code(CodeGen g, IrExecutableGen executable,
	5610	IrInstGenUnwrapErrCode *instruction)
5606	5611	{
5607	5612	if (instruction->base.value->special != ConstValSpecialRuntime)
5608	5613	return nullptr;
...	...	@@ -5621,8 +5626,8 @@ static LLVMValueRef ir_render_unwrap_err_code(CodeGen g, IrExecutable executab
5621	5626	}
5622	5627	}
5623	5628
5624		static LLVMValueRef ir_render_unwrap_err_payload(CodeGen g, IrExecutable executable,
5625		IrInstructionUnwrapErrPayload *instruction)
	5629	static LLVMValueRef ir_render_unwrap_err_payload(CodeGen g, IrExecutableGen executable,
	5630	IrInstGenUnwrapErrPayload *instruction)
5626	5631	{
5627	5632	Error err;
5628	5633
...	...	@@ -5665,7 +5670,7 @@ static LLVMValueRef ir_render_unwrap_err_payload(CodeGen g, IrExecutable execu
5665	5670	LLVMBuildCondBr(g->builder, cond_val, ok_block, err_block);
5666	5671
5667	5672	LLVMPositionBuilderAtEnd(g->builder, err_block);
5668		gen_safety_crash_for_err(g, err_val, instruction->base.scope);
	5673	gen_safety_crash_for_err(g, err_val, instruction->base.base.scope);
5669	5674
5670	5675	LLVMPositionBuilderAtEnd(g->builder, ok_block);
5671	5676	}
...	...	@@ -5682,7 +5687,7 @@ static LLVMValueRef ir_render_unwrap_err_payload(CodeGen g, IrExecutable execu
5682	5687	}
5683	5688	}
5684	5689
5685		static LLVMValueRef ir_render_optional_wrap(CodeGen g, IrExecutable executable, IrInstructionOptionalWrap *instruction) {
	5690	static LLVMValueRef ir_render_optional_wrap(CodeGen g, IrExecutableGen executable, IrInstGenOptionalWrap *instruction) {
5686	5691	ZigType *wanted_type = instruction->base.value->type;
5687	5692
5688	5693	assert(wanted_type->id == ZigTypeIdOptional);
...	...	@@ -5718,7 +5723,7 @@ static LLVMValueRef ir_render_optional_wrap(CodeGen g, IrExecutable executable
5718	5723	return result_loc;
5719	5724	}
5720	5725
5721		static LLVMValueRef ir_render_err_wrap_code(CodeGen g, IrExecutable executable, IrInstructionErrWrapCode *instruction) {
	5726	static LLVMValueRef ir_render_err_wrap_code(CodeGen g, IrExecutableGen executable, IrInstGenErrWrapCode *instruction) {
5722	5727	ZigType *wanted_type = instruction->base.value->type;
5723	5728
5724	5729	assert(wanted_type->id == ZigTypeIdErrorUnion);
...	...	@@ -5738,7 +5743,7 @@ static LLVMValueRef ir_render_err_wrap_code(CodeGen g, IrExecutable executable
5738	5743	return result_loc;
5739	5744	}
5740	5745
5741		static LLVMValueRef ir_render_err_wrap_payload(CodeGen g, IrExecutable executable, IrInstructionErrWrapPayload *instruction) {
	5746	static LLVMValueRef ir_render_err_wrap_payload(CodeGen g, IrExecutableGen executable, IrInstGenErrWrapPayload *instruction) {
5742	5747	ZigType *wanted_type = instruction->base.value->type;
5743	5748
5744	5749	assert(wanted_type->id == ZigTypeIdErrorUnion);
...	...	@@ -5769,7 +5774,7 @@ static LLVMValueRef ir_render_err_wrap_payload(CodeGen g, IrExecutable executa
5769	5774	return result_loc;
5770	5775	}
5771	5776
5772		static LLVMValueRef ir_render_union_tag(CodeGen g, IrExecutable executable, IrInstructionUnionTag *instruction) {
	5777	static LLVMValueRef ir_render_union_tag(CodeGen g, IrExecutableGen executable, IrInstGenUnionTag *instruction) {
5773	5778	ZigType *union_type = instruction->value->value->type;
5774	5779
5775	5780	ZigType *tag_type = union_type->data.unionation.tag_type;
...	...	@@ -5787,15 +5792,15 @@ static LLVMValueRef ir_render_union_tag(CodeGen g, IrExecutable executable, Ir
5787	5792	return get_handle_value(g, tag_field_ptr, tag_type, ptr_type);
5788	5793	}
5789	5794
5790		static LLVMValueRef ir_render_panic(CodeGen g, IrExecutable executable, IrInstructionPanic *instruction) {
	5795	static LLVMValueRef ir_render_panic(CodeGen g, IrExecutableGen executable, IrInstGenPanic *instruction) {
5791	5796	bool is_llvm_alloca;
5792		LLVMValueRef err_ret_trace_val = get_cur_err_ret_trace_val(g, instruction->base.scope, &is_llvm_alloca);
	5797	LLVMValueRef err_ret_trace_val = get_cur_err_ret_trace_val(g, instruction->base.base.scope, &is_llvm_alloca);
5793	5798	gen_panic(g, ir_llvm_value(g, instruction->msg), err_ret_trace_val, is_llvm_alloca);
5794	5799	return nullptr;
5795	5800	}
5796	5801
5797		static LLVMValueRef ir_render_atomic_rmw(CodeGen g, IrExecutable executable,
5798		IrInstructionAtomicRmw *instruction)
	5802	static LLVMValueRef ir_render_atomic_rmw(CodeGen g, IrExecutableGen executable,
	5803	IrInstGenAtomicRmw *instruction)
5799	5804	{
5800	5805	bool is_signed;
5801	5806	ZigType *operand_type = instruction->operand->value->type;
...	...	@@ -5805,8 +5810,8 @@ static LLVMValueRef ir_render_atomic_rmw(CodeGen g, IrExecutable executable,
5805	5810	} else {
5806	5811	is_signed = false;
5807	5812	}
5808		enum ZigLLVM_AtomicRMWBinOp op = to_ZigLLVMAtomicRMWBinOp(instruction->resolved_op, is_signed, is_float);
5809		LLVMAtomicOrdering ordering = to_LLVMAtomicOrdering(instruction->resolved_ordering);
	5813	enum ZigLLVM_AtomicRMWBinOp op = to_ZigLLVMAtomicRMWBinOp(instruction->op, is_signed, is_float);
	5814	LLVMAtomicOrdering ordering = to_LLVMAtomicOrdering(instruction->ordering);
5810	5815	LLVMValueRef ptr = ir_llvm_value(g, instruction->ptr);
5811	5816	LLVMValueRef operand = ir_llvm_value(g, instruction->operand);
5812	5817
...	...	@@ -5823,20 +5828,20 @@ static LLVMValueRef ir_render_atomic_rmw(CodeGen g, IrExecutable executable,
5823	5828	return LLVMBuildIntToPtr(g->builder, uncasted_result, get_llvm_type(g, operand_type), "");
5824	5829	}
5825	5830
5826		static LLVMValueRef ir_render_atomic_load(CodeGen g, IrExecutable executable,
5827		IrInstructionAtomicLoad *instruction)
	5831	static LLVMValueRef ir_render_atomic_load(CodeGen g, IrExecutableGen executable,
	5832	IrInstGenAtomicLoad *instruction)
5828	5833	{
5829		LLVMAtomicOrdering ordering = to_LLVMAtomicOrdering(instruction->resolved_ordering);
	5834	LLVMAtomicOrdering ordering = to_LLVMAtomicOrdering(instruction->ordering);
5830	5835	LLVMValueRef ptr = ir_llvm_value(g, instruction->ptr);
5831	5836	LLVMValueRef load_inst = gen_load(g, ptr, instruction->ptr->value->type, "");
5832	5837	LLVMSetOrdering(load_inst, ordering);
5833	5838	return load_inst;
5834	5839	}
5835	5840
5836		static LLVMValueRef ir_render_atomic_store(CodeGen g, IrExecutable executable,
5837		IrInstructionAtomicStore *instruction)
	5841	static LLVMValueRef ir_render_atomic_store(CodeGen g, IrExecutableGen executable,
	5842	IrInstGenAtomicStore *instruction)
5838	5843	{
5839		LLVMAtomicOrdering ordering = to_LLVMAtomicOrdering(instruction->resolved_ordering);
	5844	LLVMAtomicOrdering ordering = to_LLVMAtomicOrdering(instruction->ordering);
5840	5845	LLVMValueRef ptr = ir_llvm_value(g, instruction->ptr);
5841	5846	LLVMValueRef value = ir_llvm_value(g, instruction->value);
5842	5847	LLVMValueRef store_inst = gen_store(g, value, ptr, instruction->ptr->value->type);
...	...	@@ -5844,13 +5849,13 @@ static LLVMValueRef ir_render_atomic_store(CodeGen g, IrExecutable executable,
5844	5849	return nullptr;
5845	5850	}
5846	5851
5847		static LLVMValueRef ir_render_float_op(CodeGen g, IrExecutable executable, IrInstructionFloatOp *instruction) {
	5852	static LLVMValueRef ir_render_float_op(CodeGen g, IrExecutableGen executable, IrInstGenFloatOp *instruction) {
5848	5853	LLVMValueRef operand = ir_llvm_value(g, instruction->operand);
5849	5854	LLVMValueRef fn_val = get_float_fn(g, instruction->base.value->type, ZigLLVMFnIdFloatOp, instruction->fn_id);
5850	5855	return LLVMBuildCall(g->builder, fn_val, &operand, 1, "");
5851	5856	}
5852	5857
5853		static LLVMValueRef ir_render_mul_add(CodeGen g, IrExecutable executable, IrInstructionMulAdd *instruction) {
	5858	static LLVMValueRef ir_render_mul_add(CodeGen g, IrExecutableGen executable, IrInstGenMulAdd *instruction) {
5854	5859	LLVMValueRef op1 = ir_llvm_value(g, instruction->op1);
5855	5860	LLVMValueRef op2 = ir_llvm_value(g, instruction->op2);
5856	5861	LLVMValueRef op3 = ir_llvm_value(g, instruction->op3);
...	...	@@ -5865,7 +5870,7 @@ static LLVMValueRef ir_render_mul_add(CodeGen g, IrExecutable executable, IrIn
5865	5870	return LLVMBuildCall(g->builder, fn_val, args, 3, "");
5866	5871	}
5867	5872
5868		static LLVMValueRef ir_render_bswap(CodeGen g, IrExecutable executable, IrInstructionBswap *instruction) {
	5873	static LLVMValueRef ir_render_bswap(CodeGen g, IrExecutableGen executable, IrInstGenBswap *instruction) {
5869	5874	LLVMValueRef op = ir_llvm_value(g, instruction->op);
5870	5875	ZigType *expr_type = instruction->base.value->type;
5871	5876	bool is_vector = expr_type->id == ZigTypeIdVector;
...	...	@@ -5899,7 +5904,7 @@ static LLVMValueRef ir_render_bswap(CodeGen g, IrExecutable executable, IrInst
5899	5904	return LLVMBuildTrunc(g->builder, shifted, get_llvm_type(g, expr_type), "");
5900	5905	}
5901	5906
5902		static LLVMValueRef ir_render_bit_reverse(CodeGen g, IrExecutable executable, IrInstructionBitReverse *instruction) {
	5907	static LLVMValueRef ir_render_bit_reverse(CodeGen g, IrExecutableGen executable, IrInstGenBitReverse *instruction) {
5903	5908	LLVMValueRef op = ir_llvm_value(g, instruction->op);
5904	5909	ZigType *int_type = instruction->base.value->type;
5905	5910	assert(int_type->id == ZigTypeIdInt);
...	...	@@ -5907,8 +5912,8 @@ static LLVMValueRef ir_render_bit_reverse(CodeGen g, IrExecutable executable,
5907	5912	return LLVMBuildCall(g->builder, fn_val, &op, 1, "");
5908	5913	}
5909	5914
5910		static LLVMValueRef ir_render_vector_to_array(CodeGen g, IrExecutable executable,
5911		IrInstructionVectorToArray *instruction)
	5915	static LLVMValueRef ir_render_vector_to_array(CodeGen g, IrExecutableGen executable,
	5916	IrInstGenVectorToArray *instruction)
5912	5917	{
5913	5918	ZigType *array_type = instruction->base.value->type;
5914	5919	assert(array_type->id == ZigTypeIdArray);
...	...	@@ -5941,8 +5946,8 @@ static LLVMValueRef ir_render_vector_to_array(CodeGen g, IrExecutable executab
5941	5946	return result_loc;
5942	5947	}
5943	5948
5944		static LLVMValueRef ir_render_array_to_vector(CodeGen g, IrExecutable executable,
5945		IrInstructionArrayToVector *instruction)
	5949	static LLVMValueRef ir_render_array_to_vector(CodeGen g, IrExecutableGen executable,
	5950	IrInstGenArrayToVector *instruction)
5946	5951	{
5947	5952	ZigType *vector_type = instruction->base.value->type;
5948	5953	assert(vector_type->id == ZigTypeIdVector);
...	...	@@ -5978,8 +5983,8 @@ static LLVMValueRef ir_render_array_to_vector(CodeGen g, IrExecutable executab
5978	5983	}
5979	5984	}
5980	5985
5981		static LLVMValueRef ir_render_assert_zero(CodeGen g, IrExecutable executable,
5982		IrInstructionAssertZero *instruction)
	5986	static LLVMValueRef ir_render_assert_zero(CodeGen g, IrExecutableGen executable,
	5987	IrInstGenAssertZero *instruction)
5983	5988	{
5984	5989	LLVMValueRef target = ir_llvm_value(g, instruction->target);
5985	5990	ZigType *int_type = instruction->target->value->type;
...	...	@@ -5989,8 +5994,8 @@ static LLVMValueRef ir_render_assert_zero(CodeGen g, IrExecutable executable,
5989	5994	return nullptr;
5990	5995	}
5991	5996
5992		static LLVMValueRef ir_render_assert_non_null(CodeGen g, IrExecutable executable,
5993		IrInstructionAssertNonNull *instruction)
	5997	static LLVMValueRef ir_render_assert_non_null(CodeGen g, IrExecutableGen executable,
	5998	IrInstGenAssertNonNull *instruction)
5994	5999	{
5995	6000	LLVMValueRef target = ir_llvm_value(g, instruction->target);
5996	6001	ZigType *target_type = instruction->target->value->type;
...	...	@@ -6014,8 +6019,8 @@ static LLVMValueRef ir_render_assert_non_null(CodeGen g, IrExecutable executab
6014	6019	return nullptr;
6015	6020	}
6016	6021
6017		static LLVMValueRef ir_render_suspend_begin(CodeGen g, IrExecutable executable,
6018		IrInstructionSuspendBegin *instruction)
	6022	static LLVMValueRef ir_render_suspend_begin(CodeGen g, IrExecutableGen executable,
	6023	IrInstGenSuspendBegin *instruction)
6019	6024	{
6020	6025	if (fn_is_async(g->cur_fn)) {
6021	6026	instruction->resume_bb = gen_suspend_begin(g, "SuspendResume");
...	...	@@ -6023,8 +6028,8 @@ static LLVMValueRef ir_render_suspend_begin(CodeGen g, IrExecutable executable
6023	6028	return nullptr;
6024	6029	}
6025	6030
6026		static LLVMValueRef ir_render_suspend_finish(CodeGen g, IrExecutable executable,
6027		IrInstructionSuspendFinish *instruction)
	6031	static LLVMValueRef ir_render_suspend_finish(CodeGen g, IrExecutableGen executable,
	6032	IrInstGenSuspendFinish *instruction)
6028	6033	{
6029	6034	LLVMBuildRetVoid(g->builder);
6030	6035
...	...	@@ -6032,11 +6037,11 @@ static LLVMValueRef ir_render_suspend_finish(CodeGen g, IrExecutable executabl
6032	6037	if (ir_want_runtime_safety(g, &instruction->base)) {
6033	6038	LLVMBuildStore(g->builder, g->cur_bad_not_suspended_index, g->cur_async_resume_index_ptr);
6034	6039	}
6035		render_async_var_decls(g, instruction->base.scope);
	6040	render_async_var_decls(g, instruction->base.base.scope);
6036	6041	return nullptr;
6037	6042	}
6038	6043
6039		static LLVMValueRef gen_await_early_return(CodeGen g, IrInstruction source_instr,
	6044	static LLVMValueRef gen_await_early_return(CodeGen g, IrInstGen source_instr,
6040	6045	LLVMValueRef target_frame_ptr, ZigType result_type, ZigType ptr_result_type,
6041	6046	LLVMValueRef result_loc, bool non_async)
6042	6047	{
...	...	@@ -6062,7 +6067,7 @@ static LLVMValueRef gen_await_early_return(CodeGen g, IrInstruction source_ins
6062	6067	frame_index_trace_arg(g, result_type), "");
6063	6068	LLVMValueRef src_trace_ptr = LLVMBuildLoad(g->builder, their_trace_ptr_ptr, "");
6064	6069	bool is_llvm_alloca;
6065		LLVMValueRef dest_trace_ptr = get_cur_err_ret_trace_val(g, source_instr->scope, &is_llvm_alloca);
	6070	LLVMValueRef dest_trace_ptr = get_cur_err_ret_trace_val(g, source_instr->base.scope, &is_llvm_alloca);
6066	6071	LLVMValueRef args[] = { dest_trace_ptr, src_trace_ptr };
6067	6072	ZigLLVMBuildCall(g->builder, get_merge_err_ret_traces_fn_val(g), args, 2,
6068	6073	get_llvm_cc(g, CallingConventionUnspecified), ZigLLVM_CallAttrAuto, "");
...	...	@@ -6075,7 +6080,7 @@ static LLVMValueRef gen_await_early_return(CodeGen g, IrInstruction source_ins
6075	6080	}
6076	6081	}
6077	6082
6078		static LLVMValueRef ir_render_await(CodeGen g, IrExecutable executable, IrInstructionAwaitGen *instruction) {
	6083	static LLVMValueRef ir_render_await(CodeGen g, IrExecutableGen executable, IrInstGenAwait *instruction) {
6079	6084	LLVMTypeRef usize_type_ref = g->builtin_types.entry_usize->llvm_type;
6080	6085	LLVMValueRef zero = LLVMConstNull(usize_type_ref);
6081	6086	LLVMValueRef target_frame_ptr = ir_llvm_value(g, instruction->frame);
...	...	@@ -6112,7 +6117,7 @@ static LLVMValueRef ir_render_await(CodeGen g, IrExecutable executable, IrInst
6112	6117	// supply the error return trace pointer
6113	6118	if (codegen_fn_has_err_ret_tracing_arg(g, result_type)) {
6114	6119	bool is_llvm_alloca;
6115		LLVMValueRef my_err_ret_trace_val = get_cur_err_ret_trace_val(g, instruction->base.scope, &is_llvm_alloca);
	6120	LLVMValueRef my_err_ret_trace_val = get_cur_err_ret_trace_val(g, instruction->base.base.scope, &is_llvm_alloca);
6116	6121	assert(my_err_ret_trace_val != nullptr);
6117	6122	LLVMValueRef err_ret_trace_ptr_ptr = LLVMBuildStructGEP(g->builder, target_frame_ptr,
6118	6123	frame_index_trace_arg(g, result_type) + 1, "");
...	...	@@ -6160,7 +6165,7 @@ static LLVMValueRef ir_render_await(CodeGen g, IrExecutable executable, IrInst
6160	6165	return nullptr;
6161	6166	}
6162	6167
6163		static LLVMValueRef ir_render_resume(CodeGen g, IrExecutable executable, IrInstructionResume *instruction) {
	6168	static LLVMValueRef ir_render_resume(CodeGen g, IrExecutableGen executable, IrInstGenResume *instruction) {
6164	6169	LLVMValueRef frame = ir_llvm_value(g, instruction->frame);
6165	6170	ZigType *frame_type = instruction->frame->value->type;
6166	6171	assert(frame_type->id == ZigTypeIdAnyFrame);
...	...	@@ -6169,15 +6174,15 @@ static LLVMValueRef ir_render_resume(CodeGen g, IrExecutable executable, IrIns
6169	6174	return nullptr;
6170	6175	}
6171	6176
6172		static LLVMValueRef ir_render_frame_size(CodeGen g, IrExecutable executable,
6173		IrInstructionFrameSizeGen *instruction)
	6177	static LLVMValueRef ir_render_frame_size(CodeGen g, IrExecutableGen executable,
	6178	IrInstGenFrameSize *instruction)
6174	6179	{
6175	6180	LLVMValueRef fn_val = ir_llvm_value(g, instruction->fn);
6176	6181	return gen_frame_size(g, fn_val);
6177	6182	}
6178	6183
6179		static LLVMValueRef ir_render_spill_begin(CodeGen g, IrExecutable executable,
6180		IrInstructionSpillBegin *instruction)
	6184	static LLVMValueRef ir_render_spill_begin(CodeGen g, IrExecutableGen executable,
	6185	IrInstGenSpillBegin *instruction)
6181	6186	{
6182	6187	if (!fn_is_async(g->cur_fn))
6183	6188	return nullptr;
...	...	@@ -6196,7 +6201,7 @@ static LLVMValueRef ir_render_spill_begin(CodeGen g, IrExecutable executable,
6196	6201	zig_unreachable();
6197	6202	}
6198	6203
6199		static LLVMValueRef ir_render_spill_end(CodeGen g, IrExecutable executable, IrInstructionSpillEnd *instruction) {
	6204	static LLVMValueRef ir_render_spill_end(CodeGen g, IrExecutableGen executable, IrInstGenSpillEnd *instruction) {
6200	6205	if (!fn_is_async(g->cur_fn))
6201	6206	return ir_llvm_value(g, instruction->begin->operand);
6202	6207
...	...	@@ -6212,17 +6217,17 @@ static LLVMValueRef ir_render_spill_end(CodeGen g, IrExecutable executable, Ir
6212	6217	zig_unreachable();
6213	6218	}
6214	6219
6215		static LLVMValueRef ir_render_vector_extract_elem(CodeGen g, IrExecutable executable,
6216		IrInstructionVectorExtractElem *instruction)
	6220	static LLVMValueRef ir_render_vector_extract_elem(CodeGen g, IrExecutableGen executable,
	6221	IrInstGenVectorExtractElem *instruction)
6217	6222	{
6218	6223	LLVMValueRef vector = ir_llvm_value(g, instruction->vector);
6219	6224	LLVMValueRef index = ir_llvm_value(g, instruction->index);
6220	6225	return LLVMBuildExtractElement(g->builder, vector, index, "");
6221	6226	}
6222	6227
6223		static void set_debug_location(CodeGen g, IrInstruction instruction) {
6224		AstNode *source_node = instruction->source_node;
6225		Scope *scope = instruction->scope;
	6228	static void set_debug_location(CodeGen g, IrInstGen instruction) {
	6229	AstNode *source_node = instruction->base.source_node;
	6230	Scope *scope = instruction->base.scope;
6226	6231
6227	6232	assert(source_node);
6228	6233	assert(scope);
...	...	@@ -6231,263 +6236,183 @@ static void set_debug_location(CodeGen g, IrInstruction instruction) {
6231	6236	(int)source_node->column + 1, get_di_scope(g, scope));
6232	6237	}
6233	6238
6234		static LLVMValueRef ir_render_instruction(CodeGen g, IrExecutable executable, IrInstruction *instruction) {
	6239	static LLVMValueRef ir_render_instruction(CodeGen g, IrExecutableGen executable, IrInstGen *instruction) {
6235	6240	switch (instruction->id) {
6236		case IrInstructionIdInvalid:
6237		case IrInstructionIdConst:
6238		case IrInstructionIdTypeOf:
6239		case IrInstructionIdFieldPtr:
6240		case IrInstructionIdSetCold:
6241		case IrInstructionIdSetRuntimeSafety:
6242		case IrInstructionIdSetFloatMode:
6243		case IrInstructionIdArrayType:
6244		case IrInstructionIdAnyFrameType:
6245		case IrInstructionIdSliceType:
6246		case IrInstructionIdSizeOf:
6247		case IrInstructionIdSwitchTarget:
6248		case IrInstructionIdContainerInitFields:
6249		case IrInstructionIdCompileErr:
6250		case IrInstructionIdCompileLog:
6251		case IrInstructionIdImport:
6252		case IrInstructionIdCImport:
6253		case IrInstructionIdCInclude:
6254		case IrInstructionIdCDefine:
6255		case IrInstructionIdCUndef:
6256		case IrInstructionIdEmbedFile:
6257		case IrInstructionIdIntType:
6258		case IrInstructionIdVectorType:
6259		case IrInstructionIdMemberCount:
6260		case IrInstructionIdMemberType:
6261		case IrInstructionIdMemberName:
6262		case IrInstructionIdAlignOf:
6263		case IrInstructionIdFnProto:
6264		case IrInstructionIdTestComptime:
6265		case IrInstructionIdCheckSwitchProngs:
6266		case IrInstructionIdCheckStatementIsVoid:
6267		case IrInstructionIdTypeName:
6268		case IrInstructionIdDeclRef:
6269		case IrInstructionIdSwitchVar:
6270		case IrInstructionIdSwitchElseVar:
6271		case IrInstructionIdByteOffsetOf:
6272		case IrInstructionIdBitOffsetOf:
6273		case IrInstructionIdTypeInfo:
6274		case IrInstructionIdType:
6275		case IrInstructionIdHasField:
6276		case IrInstructionIdTypeId:
6277		case IrInstructionIdSetEvalBranchQuota:
6278		case IrInstructionIdPtrType:
6279		case IrInstructionIdOpaqueType:
6280		case IrInstructionIdSetAlignStack:
6281		case IrInstructionIdArgType:
6282		case IrInstructionIdTagType:
6283		case IrInstructionIdExport:
6284		case IrInstructionIdErrorUnion:
6285		case IrInstructionIdAddImplicitReturnType:
6286		case IrInstructionIdIntCast:
6287		case IrInstructionIdFloatCast:
6288		case IrInstructionIdIntToFloat:
6289		case IrInstructionIdFloatToInt:
6290		case IrInstructionIdBoolToInt:
6291		case IrInstructionIdErrSetCast:
6292		case IrInstructionIdFromBytes:
6293		case IrInstructionIdToBytes:
6294		case IrInstructionIdEnumToInt:
6295		case IrInstructionIdCheckRuntimeScope:
6296		case IrInstructionIdDeclVarSrc:
6297		case IrInstructionIdPtrCastSrc:
6298		case IrInstructionIdCmpxchgSrc:
6299		case IrInstructionIdLoadPtr:
6300		case IrInstructionIdHasDecl:
6301		case IrInstructionIdUndeclaredIdent:
6302		case IrInstructionIdCallExtra:
6303		case IrInstructionIdCallSrc:
6304		case IrInstructionIdCallSrcArgs:
6305		case IrInstructionIdAllocaSrc:
6306		case IrInstructionIdEndExpr:
6307		case IrInstructionIdImplicitCast:
6308		case IrInstructionIdResolveResult:
6309		case IrInstructionIdResetResult:
6310		case IrInstructionIdContainerInitList:
6311		case IrInstructionIdSliceSrc:
6312		case IrInstructionIdRef:
6313		case IrInstructionIdBitCastSrc:
6314		case IrInstructionIdTestErrSrc:
6315		case IrInstructionIdUnionInitNamedField:
6316		case IrInstructionIdFrameType:
6317		case IrInstructionIdFrameSizeSrc:
6318		case IrInstructionIdAllocaGen:
6319		case IrInstructionIdAwaitSrc:
6320		case IrInstructionIdSplatSrc:
6321		case IrInstructionIdMergeErrSets:
6322		case IrInstructionIdAsmSrc:
	6241	case IrInstGenIdInvalid:
	6242	case IrInstGenIdConst:
	6243	case IrInstGenIdAlloca:
6323	6244	zig_unreachable();
6324	6245
6325		case IrInstructionIdDeclVarGen:
6326		return ir_render_decl_var(g, executable, (IrInstructionDeclVarGen *)instruction);
6327		case IrInstructionIdReturn:
6328		return ir_render_return(g, executable, (IrInstructionReturn *)instruction);
6329		case IrInstructionIdBinOp:
6330		return ir_render_bin_op(g, executable, (IrInstructionBinOp *)instruction);
6331		case IrInstructionIdCast:
6332		return ir_render_cast(g, executable, (IrInstructionCast *)instruction);
6333		case IrInstructionIdUnreachable:
6334		return ir_render_unreachable(g, executable, (IrInstructionUnreachable *)instruction);
6335		case IrInstructionIdCondBr:
6336		return ir_render_cond_br(g, executable, (IrInstructionCondBr *)instruction);
6337		case IrInstructionIdBr:
6338		return ir_render_br(g, executable, (IrInstructionBr *)instruction);
6339		case IrInstructionIdUnOp:
6340		return ir_render_un_op(g, executable, (IrInstructionUnOp *)instruction);
6341		case IrInstructionIdLoadPtrGen:
6342		return ir_render_load_ptr(g, executable, (IrInstructionLoadPtrGen *)instruction);
6343		case IrInstructionIdStorePtr:
6344		return ir_render_store_ptr(g, executable, (IrInstructionStorePtr *)instruction);
6345		case IrInstructionIdVectorStoreElem:
6346		return ir_render_vector_store_elem(g, executable, (IrInstructionVectorStoreElem *)instruction);
6347		case IrInstructionIdVarPtr:
6348		return ir_render_var_ptr(g, executable, (IrInstructionVarPtr *)instruction);
6349		case IrInstructionIdReturnPtr:
6350		return ir_render_return_ptr(g, executable, (IrInstructionReturnPtr *)instruction);
6351		case IrInstructionIdElemPtr:
6352		return ir_render_elem_ptr(g, executable, (IrInstructionElemPtr *)instruction);
6353		case IrInstructionIdCallGen:
6354		return ir_render_call(g, executable, (IrInstructionCallGen *)instruction);
6355		case IrInstructionIdStructFieldPtr:
6356		return ir_render_struct_field_ptr(g, executable, (IrInstructionStructFieldPtr *)instruction);
6357		case IrInstructionIdUnionFieldPtr:
6358		return ir_render_union_field_ptr(g, executable, (IrInstructionUnionFieldPtr *)instruction);
6359		case IrInstructionIdAsmGen:
6360		return ir_render_asm_gen(g, executable, (IrInstructionAsmGen *)instruction);
6361		case IrInstructionIdTestNonNull:
6362		return ir_render_test_non_null(g, executable, (IrInstructionTestNonNull *)instruction);
6363		case IrInstructionIdOptionalUnwrapPtr:
6364		return ir_render_optional_unwrap_ptr(g, executable, (IrInstructionOptionalUnwrapPtr *)instruction);
6365		case IrInstructionIdClz:
6366		return ir_render_clz(g, executable, (IrInstructionClz *)instruction);
6367		case IrInstructionIdCtz:
6368		return ir_render_ctz(g, executable, (IrInstructionCtz *)instruction);
6369		case IrInstructionIdPopCount:
6370		return ir_render_pop_count(g, executable, (IrInstructionPopCount *)instruction);
6371		case IrInstructionIdSwitchBr:
6372		return ir_render_switch_br(g, executable, (IrInstructionSwitchBr *)instruction);
6373		case IrInstructionIdBswap:
6374		return ir_render_bswap(g, executable, (IrInstructionBswap *)instruction);
6375		case IrInstructionIdBitReverse:
6376		return ir_render_bit_reverse(g, executable, (IrInstructionBitReverse *)instruction);
6377		case IrInstructionIdPhi:
6378		return ir_render_phi(g, executable, (IrInstructionPhi *)instruction);
6379		case IrInstructionIdRefGen:
6380		return ir_render_ref(g, executable, (IrInstructionRefGen *)instruction);
6381		case IrInstructionIdErrName:
6382		return ir_render_err_name(g, executable, (IrInstructionErrName *)instruction);
6383		case IrInstructionIdCmpxchgGen:
6384		return ir_render_cmpxchg(g, executable, (IrInstructionCmpxchgGen *)instruction);
6385		case IrInstructionIdFence:
6386		return ir_render_fence(g, executable, (IrInstructionFence *)instruction);
6387		case IrInstructionIdTruncate:
6388		return ir_render_truncate(g, executable, (IrInstructionTruncate *)instruction);
6389		case IrInstructionIdBoolNot:
6390		return ir_render_bool_not(g, executable, (IrInstructionBoolNot *)instruction);
6391		case IrInstructionIdMemset:
6392		return ir_render_memset(g, executable, (IrInstructionMemset *)instruction);
6393		case IrInstructionIdMemcpy:
6394		return ir_render_memcpy(g, executable, (IrInstructionMemcpy *)instruction);
6395		case IrInstructionIdSliceGen:
6396		return ir_render_slice(g, executable, (IrInstructionSliceGen *)instruction);
6397		case IrInstructionIdBreakpoint:
6398		return ir_render_breakpoint(g, executable, (IrInstructionBreakpoint *)instruction);
6399		case IrInstructionIdReturnAddress:
6400		return ir_render_return_address(g, executable, (IrInstructionReturnAddress *)instruction);
6401		case IrInstructionIdFrameAddress:
6402		return ir_render_frame_address(g, executable, (IrInstructionFrameAddress *)instruction);
6403		case IrInstructionIdFrameHandle:
6404		return ir_render_handle(g, executable, (IrInstructionFrameHandle *)instruction);
6405		case IrInstructionIdOverflowOp:
6406		return ir_render_overflow_op(g, executable, (IrInstructionOverflowOp *)instruction);
6407		case IrInstructionIdTestErrGen:
6408		return ir_render_test_err(g, executable, (IrInstructionTestErrGen *)instruction);
6409		case IrInstructionIdUnwrapErrCode:
6410		return ir_render_unwrap_err_code(g, executable, (IrInstructionUnwrapErrCode *)instruction);
6411		case IrInstructionIdUnwrapErrPayload:
6412		return ir_render_unwrap_err_payload(g, executable, (IrInstructionUnwrapErrPayload *)instruction);
6413		case IrInstructionIdOptionalWrap:
6414		return ir_render_optional_wrap(g, executable, (IrInstructionOptionalWrap *)instruction);
6415		case IrInstructionIdErrWrapCode:
6416		return ir_render_err_wrap_code(g, executable, (IrInstructionErrWrapCode *)instruction);
6417		case IrInstructionIdErrWrapPayload:
6418		return ir_render_err_wrap_payload(g, executable, (IrInstructionErrWrapPayload *)instruction);
6419		case IrInstructionIdUnionTag:
6420		return ir_render_union_tag(g, executable, (IrInstructionUnionTag *)instruction);
6421		case IrInstructionIdPtrCastGen:
6422		return ir_render_ptr_cast(g, executable, (IrInstructionPtrCastGen *)instruction);
6423		case IrInstructionIdBitCastGen:
6424		return ir_render_bit_cast(g, executable, (IrInstructionBitCastGen *)instruction);
6425		case IrInstructionIdWidenOrShorten:
6426		return ir_render_widen_or_shorten(g, executable, (IrInstructionWidenOrShorten *)instruction);
6427		case IrInstructionIdPtrToInt:
6428		return ir_render_ptr_to_int(g, executable, (IrInstructionPtrToInt *)instruction);
6429		case IrInstructionIdIntToPtr:
6430		return ir_render_int_to_ptr(g, executable, (IrInstructionIntToPtr *)instruction);
6431		case IrInstructionIdIntToEnum:
6432		return ir_render_int_to_enum(g, executable, (IrInstructionIntToEnum *)instruction);
6433		case IrInstructionIdIntToErr:
6434		return ir_render_int_to_err(g, executable, (IrInstructionIntToErr *)instruction);
6435		case IrInstructionIdErrToInt:
6436		return ir_render_err_to_int(g, executable, (IrInstructionErrToInt *)instruction);
6437		case IrInstructionIdPanic:
6438		return ir_render_panic(g, executable, (IrInstructionPanic *)instruction);
6439		case IrInstructionIdTagName:
6440		return ir_render_enum_tag_name(g, executable, (IrInstructionTagName *)instruction);
6441		case IrInstructionIdFieldParentPtr:
6442		return ir_render_field_parent_ptr(g, executable, (IrInstructionFieldParentPtr *)instruction);
6443		case IrInstructionIdAlignCast:
6444		return ir_render_align_cast(g, executable, (IrInstructionAlignCast *)instruction);
6445		case IrInstructionIdErrorReturnTrace:
6446		return ir_render_error_return_trace(g, executable, (IrInstructionErrorReturnTrace *)instruction);
6447		case IrInstructionIdAtomicRmw:
6448		return ir_render_atomic_rmw(g, executable, (IrInstructionAtomicRmw *)instruction);
6449		case IrInstructionIdAtomicLoad:
6450		return ir_render_atomic_load(g, executable, (IrInstructionAtomicLoad *)instruction);
6451		case IrInstructionIdAtomicStore:
6452		return ir_render_atomic_store(g, executable, (IrInstructionAtomicStore *)instruction);
6453		case IrInstructionIdSaveErrRetAddr:
6454		return ir_render_save_err_ret_addr(g, executable, (IrInstructionSaveErrRetAddr *)instruction);
6455		case IrInstructionIdFloatOp:
6456		return ir_render_float_op(g, executable, (IrInstructionFloatOp *)instruction);
6457		case IrInstructionIdMulAdd:
6458		return ir_render_mul_add(g, executable, (IrInstructionMulAdd *)instruction);
6459		case IrInstructionIdArrayToVector:
6460		return ir_render_array_to_vector(g, executable, (IrInstructionArrayToVector *)instruction);
6461		case IrInstructionIdVectorToArray:
6462		return ir_render_vector_to_array(g, executable, (IrInstructionVectorToArray *)instruction);
6463		case IrInstructionIdAssertZero:
6464		return ir_render_assert_zero(g, executable, (IrInstructionAssertZero *)instruction);
6465		case IrInstructionIdAssertNonNull:
6466		return ir_render_assert_non_null(g, executable, (IrInstructionAssertNonNull *)instruction);
6467		case IrInstructionIdResizeSlice:
6468		return ir_render_resize_slice(g, executable, (IrInstructionResizeSlice *)instruction);
6469		case IrInstructionIdPtrOfArrayToSlice:
6470		return ir_render_ptr_of_array_to_slice(g, executable, (IrInstructionPtrOfArrayToSlice *)instruction);
6471		case IrInstructionIdSuspendBegin:
6472		return ir_render_suspend_begin(g, executable, (IrInstructionSuspendBegin *)instruction);
6473		case IrInstructionIdSuspendFinish:
6474		return ir_render_suspend_finish(g, executable, (IrInstructionSuspendFinish *)instruction);
6475		case IrInstructionIdResume:
6476		return ir_render_resume(g, executable, (IrInstructionResume *)instruction);
6477		case IrInstructionIdFrameSizeGen:
6478		return ir_render_frame_size(g, executable, (IrInstructionFrameSizeGen *)instruction);
6479		case IrInstructionIdAwaitGen:
6480		return ir_render_await(g, executable, (IrInstructionAwaitGen *)instruction);
6481		case IrInstructionIdSpillBegin:
6482		return ir_render_spill_begin(g, executable, (IrInstructionSpillBegin *)instruction);
6483		case IrInstructionIdSpillEnd:
6484		return ir_render_spill_end(g, executable, (IrInstructionSpillEnd *)instruction);
6485		case IrInstructionIdShuffleVector:
6486		return ir_render_shuffle_vector(g, executable, (IrInstructionShuffleVector *) instruction);
6487		case IrInstructionIdSplatGen:
6488		return ir_render_splat(g, executable, (IrInstructionSplatGen *) instruction);
6489		case IrInstructionIdVectorExtractElem:
6490		return ir_render_vector_extract_elem(g, executable, (IrInstructionVectorExtractElem *) instruction);
	6246	case IrInstGenIdDeclVar:
	6247	return ir_render_decl_var(g, executable, (IrInstGenDeclVar *)instruction);
	6248	case IrInstGenIdReturn:
	6249	return ir_render_return(g, executable, (IrInstGenReturn *)instruction);
	6250	case IrInstGenIdBinOp:
	6251	return ir_render_bin_op(g, executable, (IrInstGenBinOp *)instruction);
	6252	case IrInstGenIdCast:
	6253	return ir_render_cast(g, executable, (IrInstGenCast *)instruction);
	6254	case IrInstGenIdUnreachable:
	6255	return ir_render_unreachable(g, executable, (IrInstGenUnreachable *)instruction);
	6256	case IrInstGenIdCondBr:
	6257	return ir_render_cond_br(g, executable, (IrInstGenCondBr *)instruction);
	6258	case IrInstGenIdBr:
	6259	return ir_render_br(g, executable, (IrInstGenBr *)instruction);
	6260	case IrInstGenIdBinaryNot:
	6261	return ir_render_binary_not(g, executable, (IrInstGenBinaryNot *)instruction);
	6262	case IrInstGenIdNegation:
	6263	return ir_render_negation(g, executable, (IrInstGenNegation *)instruction);
	6264	case IrInstGenIdNegationWrapping:
	6265	return ir_render_negation_wrapping(g, executable, (IrInstGenNegationWrapping *)instruction);
	6266	case IrInstGenIdLoadPtr:
	6267	return ir_render_load_ptr(g, executable, (IrInstGenLoadPtr *)instruction);
	6268	case IrInstGenIdStorePtr:
	6269	return ir_render_store_ptr(g, executable, (IrInstGenStorePtr *)instruction);
	6270	case IrInstGenIdVectorStoreElem:
	6271	return ir_render_vector_store_elem(g, executable, (IrInstGenVectorStoreElem *)instruction);
	6272	case IrInstGenIdVarPtr:
	6273	return ir_render_var_ptr(g, executable, (IrInstGenVarPtr *)instruction);
	6274	case IrInstGenIdReturnPtr:
	6275	return ir_render_return_ptr(g, executable, (IrInstGenReturnPtr *)instruction);
	6276	case IrInstGenIdElemPtr:
	6277	return ir_render_elem_ptr(g, executable, (IrInstGenElemPtr *)instruction);
	6278	case IrInstGenIdCall:
	6279	return ir_render_call(g, executable, (IrInstGenCall *)instruction);
	6280	case IrInstGenIdStructFieldPtr:
	6281	return ir_render_struct_field_ptr(g, executable, (IrInstGenStructFieldPtr *)instruction);
	6282	case IrInstGenIdUnionFieldPtr:
	6283	return ir_render_union_field_ptr(g, executable, (IrInstGenUnionFieldPtr *)instruction);
	6284	case IrInstGenIdAsm:
	6285	return ir_render_asm_gen(g, executable, (IrInstGenAsm *)instruction);
	6286	case IrInstGenIdTestNonNull:
	6287	return ir_render_test_non_null(g, executable, (IrInstGenTestNonNull *)instruction);
	6288	case IrInstGenIdOptionalUnwrapPtr:
	6289	return ir_render_optional_unwrap_ptr(g, executable, (IrInstGenOptionalUnwrapPtr *)instruction);
	6290	case IrInstGenIdClz:
	6291	return ir_render_clz(g, executable, (IrInstGenClz *)instruction);
	6292	case IrInstGenIdCtz:
	6293	return ir_render_ctz(g, executable, (IrInstGenCtz *)instruction);
	6294	case IrInstGenIdPopCount:
	6295	return ir_render_pop_count(g, executable, (IrInstGenPopCount *)instruction);
	6296	case IrInstGenIdSwitchBr:
	6297	return ir_render_switch_br(g, executable, (IrInstGenSwitchBr *)instruction);
	6298	case IrInstGenIdBswap:
	6299	return ir_render_bswap(g, executable, (IrInstGenBswap *)instruction);
	6300	case IrInstGenIdBitReverse:
	6301	return ir_render_bit_reverse(g, executable, (IrInstGenBitReverse *)instruction);
	6302	case IrInstGenIdPhi:
	6303	return ir_render_phi(g, executable, (IrInstGenPhi *)instruction);
	6304	case IrInstGenIdRef:
	6305	return ir_render_ref(g, executable, (IrInstGenRef *)instruction);
	6306	case IrInstGenIdErrName:
	6307	return ir_render_err_name(g, executable, (IrInstGenErrName *)instruction);
	6308	case IrInstGenIdCmpxchg:
	6309	return ir_render_cmpxchg(g, executable, (IrInstGenCmpxchg *)instruction);
	6310	case IrInstGenIdFence:
	6311	return ir_render_fence(g, executable, (IrInstGenFence *)instruction);
	6312	case IrInstGenIdTruncate:
	6313	return ir_render_truncate(g, executable, (IrInstGenTruncate *)instruction);
	6314	case IrInstGenIdBoolNot:
	6315	return ir_render_bool_not(g, executable, (IrInstGenBoolNot *)instruction);
	6316	case IrInstGenIdMemset:
	6317	return ir_render_memset(g, executable, (IrInstGenMemset *)instruction);
	6318	case IrInstGenIdMemcpy:
	6319	return ir_render_memcpy(g, executable, (IrInstGenMemcpy *)instruction);
	6320	case IrInstGenIdSlice:
	6321	return ir_render_slice(g, executable, (IrInstGenSlice *)instruction);
	6322	case IrInstGenIdBreakpoint:
	6323	return ir_render_breakpoint(g, executable, (IrInstGenBreakpoint *)instruction);
	6324	case IrInstGenIdReturnAddress:
	6325	return ir_render_return_address(g, executable, (IrInstGenReturnAddress *)instruction);
	6326	case IrInstGenIdFrameAddress:
	6327	return ir_render_frame_address(g, executable, (IrInstGenFrameAddress *)instruction);
	6328	case IrInstGenIdFrameHandle:
	6329	return ir_render_handle(g, executable, (IrInstGenFrameHandle *)instruction);
	6330	case IrInstGenIdOverflowOp:
	6331	return ir_render_overflow_op(g, executable, (IrInstGenOverflowOp *)instruction);
	6332	case IrInstGenIdTestErr:
	6333	return ir_render_test_err(g, executable, (IrInstGenTestErr *)instruction);
	6334	case IrInstGenIdUnwrapErrCode:
	6335	return ir_render_unwrap_err_code(g, executable, (IrInstGenUnwrapErrCode *)instruction);
	6336	case IrInstGenIdUnwrapErrPayload:
	6337	return ir_render_unwrap_err_payload(g, executable, (IrInstGenUnwrapErrPayload *)instruction);
	6338	case IrInstGenIdOptionalWrap:
	6339	return ir_render_optional_wrap(g, executable, (IrInstGenOptionalWrap *)instruction);
	6340	case IrInstGenIdErrWrapCode:
	6341	return ir_render_err_wrap_code(g, executable, (IrInstGenErrWrapCode *)instruction);
	6342	case IrInstGenIdErrWrapPayload:
	6343	return ir_render_err_wrap_payload(g, executable, (IrInstGenErrWrapPayload *)instruction);
	6344	case IrInstGenIdUnionTag:
	6345	return ir_render_union_tag(g, executable, (IrInstGenUnionTag *)instruction);
	6346	case IrInstGenIdPtrCast:
	6347	return ir_render_ptr_cast(g, executable, (IrInstGenPtrCast *)instruction);
	6348	case IrInstGenIdBitCast:
	6349	return ir_render_bit_cast(g, executable, (IrInstGenBitCast *)instruction);
	6350	case IrInstGenIdWidenOrShorten:
	6351	return ir_render_widen_or_shorten(g, executable, (IrInstGenWidenOrShorten *)instruction);
	6352	case IrInstGenIdPtrToInt:
	6353	return ir_render_ptr_to_int(g, executable, (IrInstGenPtrToInt *)instruction);
	6354	case IrInstGenIdIntToPtr:
	6355	return ir_render_int_to_ptr(g, executable, (IrInstGenIntToPtr *)instruction);
	6356	case IrInstGenIdIntToEnum:
	6357	return ir_render_int_to_enum(g, executable, (IrInstGenIntToEnum *)instruction);
	6358	case IrInstGenIdIntToErr:
	6359	return ir_render_int_to_err(g, executable, (IrInstGenIntToErr *)instruction);
	6360	case IrInstGenIdErrToInt:
	6361	return ir_render_err_to_int(g, executable, (IrInstGenErrToInt *)instruction);
	6362	case IrInstGenIdPanic:
	6363	return ir_render_panic(g, executable, (IrInstGenPanic *)instruction);
	6364	case IrInstGenIdTagName:
	6365	return ir_render_enum_tag_name(g, executable, (IrInstGenTagName *)instruction);
	6366	case IrInstGenIdFieldParentPtr:
	6367	return ir_render_field_parent_ptr(g, executable, (IrInstGenFieldParentPtr *)instruction);
	6368	case IrInstGenIdAlignCast:
	6369	return ir_render_align_cast(g, executable, (IrInstGenAlignCast *)instruction);
	6370	case IrInstGenIdErrorReturnTrace:
	6371	return ir_render_error_return_trace(g, executable, (IrInstGenErrorReturnTrace *)instruction);
	6372	case IrInstGenIdAtomicRmw:
	6373	return ir_render_atomic_rmw(g, executable, (IrInstGenAtomicRmw *)instruction);
	6374	case IrInstGenIdAtomicLoad:
	6375	return ir_render_atomic_load(g, executable, (IrInstGenAtomicLoad *)instruction);
	6376	case IrInstGenIdAtomicStore:
	6377	return ir_render_atomic_store(g, executable, (IrInstGenAtomicStore *)instruction);
	6378	case IrInstGenIdSaveErrRetAddr:
	6379	return ir_render_save_err_ret_addr(g, executable, (IrInstGenSaveErrRetAddr *)instruction);
	6380	case IrInstGenIdFloatOp:
	6381	return ir_render_float_op(g, executable, (IrInstGenFloatOp *)instruction);
	6382	case IrInstGenIdMulAdd:
	6383	return ir_render_mul_add(g, executable, (IrInstGenMulAdd *)instruction);
	6384	case IrInstGenIdArrayToVector:
	6385	return ir_render_array_to_vector(g, executable, (IrInstGenArrayToVector *)instruction);
	6386	case IrInstGenIdVectorToArray:
	6387	return ir_render_vector_to_array(g, executable, (IrInstGenVectorToArray *)instruction);
	6388	case IrInstGenIdAssertZero:
	6389	return ir_render_assert_zero(g, executable, (IrInstGenAssertZero *)instruction);
	6390	case IrInstGenIdAssertNonNull:
	6391	return ir_render_assert_non_null(g, executable, (IrInstGenAssertNonNull *)instruction);
	6392	case IrInstGenIdResizeSlice:
	6393	return ir_render_resize_slice(g, executable, (IrInstGenResizeSlice *)instruction);
	6394	case IrInstGenIdPtrOfArrayToSlice:
	6395	return ir_render_ptr_of_array_to_slice(g, executable, (IrInstGenPtrOfArrayToSlice *)instruction);
	6396	case IrInstGenIdSuspendBegin:
	6397	return ir_render_suspend_begin(g, executable, (IrInstGenSuspendBegin *)instruction);
	6398	case IrInstGenIdSuspendFinish:
	6399	return ir_render_suspend_finish(g, executable, (IrInstGenSuspendFinish *)instruction);
	6400	case IrInstGenIdResume:
	6401	return ir_render_resume(g, executable, (IrInstGenResume *)instruction);
	6402	case IrInstGenIdFrameSize:
	6403	return ir_render_frame_size(g, executable, (IrInstGenFrameSize *)instruction);
	6404	case IrInstGenIdAwait:
	6405	return ir_render_await(g, executable, (IrInstGenAwait *)instruction);
	6406	case IrInstGenIdSpillBegin:
	6407	return ir_render_spill_begin(g, executable, (IrInstGenSpillBegin *)instruction);
	6408	case IrInstGenIdSpillEnd:
	6409	return ir_render_spill_end(g, executable, (IrInstGenSpillEnd *)instruction);
	6410	case IrInstGenIdShuffleVector:
	6411	return ir_render_shuffle_vector(g, executable, (IrInstGenShuffleVector *) instruction);
	6412	case IrInstGenIdSplat:
	6413	return ir_render_splat(g, executable, (IrInstGenSplat *) instruction);
	6414	case IrInstGenIdVectorExtractElem:
	6415	return ir_render_vector_extract_elem(g, executable, (IrInstGenVectorExtractElem *) instruction);
6491	6416	}
6492	6417	zig_unreachable();
6493	6418	}
...	...	@@ -6495,21 +6420,21 @@ static LLVMValueRef ir_render_instruction(CodeGen g, IrExecutable executable,
6495	6420	static void ir_render(CodeGen g, ZigFn fn_entry) {
6496	6421	assert(fn_entry);
6497	6422
6498		IrExecutable *executable = &fn_entry->analyzed_executable;
	6423	IrExecutableGen *executable = &fn_entry->analyzed_executable;
6499	6424	assert(executable->basic_block_list.length > 0);
6500	6425
6501	6426	for (size_t block_i = 0; block_i < executable->basic_block_list.length; block_i += 1) {
6502		IrBasicBlock *current_block = executable->basic_block_list.at(block_i);
	6427	IrBasicBlockGen *current_block = executable->basic_block_list.at(block_i);
6503	6428	if (get_scope_typeof(current_block->scope) != nullptr) {
6504	6429	LLVMBuildBr(g->builder, current_block->llvm_block);
6505	6430	}
6506	6431	assert(current_block->llvm_block);
6507	6432	LLVMPositionBuilderAtEnd(g->builder, current_block->llvm_block);
6508	6433	for (size_t instr_i = 0; instr_i < current_block->instruction_list.length; instr_i += 1) {
6509		IrInstruction *instruction = current_block->instruction_list.at(instr_i);
6510		if (instruction->ref_count == 0 && !ir_has_side_effects(instruction))
	6434	IrInstGen *instruction = current_block->instruction_list.at(instr_i);
	6435	if (instruction->base.ref_count == 0 && !ir_inst_gen_has_side_effects(instruction))
6511	6436	continue;
6512		if (get_scope_typeof(instruction->scope) != nullptr)
	6437	if (get_scope_typeof(instruction->base.scope) != nullptr)
6513	6438	continue;
6514	6439
6515	6440	if (!g->strip_debug_symbols) {
...	...	@@ -7401,7 +7326,7 @@ static void generate_error_name_table(CodeGen *g) {
7401	7326	}
7402	7327
7403	7328	static void build_all_basic_blocks(CodeGen g, ZigFn fn) {
7404		IrExecutable *executable = &fn->analyzed_executable;
	7329	IrExecutableGen *executable = &fn->analyzed_executable;
7405	7330	assert(executable->basic_block_list.length > 0);
7406	7331	LLVMValueRef fn_val = fn_llvm_value(g, fn);
7407	7332	LLVMBasicBlockRef first_bb = nullptr;
...	...	@@ -7410,7 +7335,7 @@ static void build_all_basic_blocks(CodeGen g, ZigFn fn) {
7410	7335	g->cur_preamble_llvm_block = first_bb;
7411	7336	}
7412	7337	for (size_t block_i = 0; block_i < executable->basic_block_list.length; block_i += 1) {
7413		IrBasicBlock *bb = executable->basic_block_list.at(block_i);
	7338	IrBasicBlockGen *bb = executable->basic_block_list.at(block_i);
7414	7339	bb->llvm_block = LLVMAppendBasicBlock(fn_val, bb->name_hint);
7415	7340	}
7416	7341	if (first_bb == nullptr) {
...	...	@@ -7643,10 +7568,10 @@ static void do_code_gen(CodeGen *g) {
7643	7568	if (!is_async) {
7644	7569	// allocate async frames for noasync calls & awaits to async functions
7645	7570	ZigType *largest_call_frame_type = nullptr;
7646		IrInstruction *all_calls_alloca = ir_create_alloca(g, &fn_table_entry->fndef_scope->base,
	7571	IrInstGen *all_calls_alloca = ir_create_alloca(g, &fn_table_entry->fndef_scope->base,
7647	7572	fn_table_entry->body_node, fn_table_entry, g->builtin_types.entry_void, "@async_call_frame");
7648	7573	for (size_t i = 0; i < fn_table_entry->call_list.length; i += 1) {
7649		IrInstructionCallGen *call = fn_table_entry->call_list.at(i);
	7574	IrInstGenCall *call = fn_table_entry->call_list.at(i);
7650	7575	if (call->fn_entry == nullptr)
7651	7576	continue;
7652	7577	if (!fn_is_async(call->fn_entry))
...	...	@@ -7668,7 +7593,7 @@ static void do_code_gen(CodeGen *g) {
7668	7593	}
7669	7594	// allocate temporary stack data
7670	7595	for (size_t alloca_i = 0; alloca_i < fn_table_entry->alloca_gen_list.length; alloca_i += 1) {
7671		IrInstructionAllocaGen *instruction = fn_table_entry->alloca_gen_list.at(alloca_i);
	7596	IrInstGenAlloca *instruction = fn_table_entry->alloca_gen_list.at(alloca_i);
7672	7597	ZigType *ptr_type = instruction->base.value->type;
7673	7598	assert(ptr_type->id == ZigTypeIdPointer);
7674	7599	ZigType *child_type = ptr_type->data.pointer.child_type;
...	...	@@ -7676,7 +7601,7 @@ static void do_code_gen(CodeGen *g) {
7676	7601	zig_unreachable();
7677	7602	if (!type_has_bits(child_type))
7678	7603	continue;
7679		if (instruction->base.ref_count == 0)
	7604	if (instruction->base.base.ref_count == 0)
7680	7605	continue;
7681	7606	if (instruction->base.value->special != ConstValSpecialRuntime) {
7682	7607	if (const_ptr_pointee(nullptr, g, instruction->base.value, nullptr)->special !=
...	...	@@ -7793,7 +7718,7 @@ static void do_code_gen(CodeGen *g) {
7793	7718	ZigLLVMSetCurrentDebugLocation(g->builder, (int)source_node->line + 1,
7794	7719	(int)source_node->column + 1, get_di_scope(g, fn_table_entry->child_scope));
7795	7720	}
7796		IrExecutable *executable = &fn_table_entry->analyzed_executable;
	7721	IrExecutableGen *executable = &fn_table_entry->analyzed_executable;
7797	7722	LLVMBasicBlockRef bad_resume_block = LLVMAppendBasicBlock(g->cur_fn_val, "BadResume");
7798	7723	LLVMPositionBuilderAtEnd(g->builder, bad_resume_block);
7799	7724	gen_assertion_scope(g, PanicMsgIdBadResume, fn_table_entry->child_scope);
...	...	@@ -7820,7 +7745,7 @@ static void do_code_gen(CodeGen *g) {
7820	7745	g->cur_async_switch_instr = switch_instr;
7821	7746
7822	7747	LLVMValueRef zero = LLVMConstNull(usize_type_ref);
7823		IrBasicBlock *entry_block = executable->basic_block_list.at(0);
	7748	IrBasicBlockGen *entry_block = executable->basic_block_list.at(0);
7824	7749	LLVMAddCase(switch_instr, zero, entry_block->llvm_block);
7825	7750	g->cur_resume_block_count += 1;
7826	7751
...	...	@@ -7852,7 +7777,7 @@ static void do_code_gen(CodeGen *g) {
7852	7777
7853	7778	gen_init_stack_trace(g, trace_field_ptr, addrs_field_ptr);
7854	7779	}
7855		render_async_var_decls(g, entry_block->instruction_list.at(0)->scope);
	7780	render_async_var_decls(g, entry_block->instruction_list.at(0)->base.scope);
7856	7781	} else {
7857	7782	// create debug variable declarations for parameters
7858	7783	// rely on the first variables in the variable_list being parameters.
...	...	@@ -7941,6 +7866,12 @@ static void zig_llvm_emit_output(CodeGen *g) {
7941	7866	default:
7942	7867	zig_unreachable();
7943	7868	}
	7869	LLVMDisposeModule(g->module);
	7870	g->module = nullptr;
	7871	LLVMDisposeTargetData(g->target_data_ref);
	7872	g->target_data_ref = nullptr;
	7873	LLVMDisposeTargetMachine(g->target_machine);
	7874	g->target_machine = nullptr;
7944	7875	}
7945	7876
7946	7877	struct CIntTypeInfo {
...	...	@@ -8846,15 +8777,17 @@ static void init(CodeGen *g) {
8846	8777	define_builtin_types(g);
8847	8778	define_intern_values(g);
8848	8779
8849		IrInstruction *sentinel_instructions = allocate<IrInstruction>(2);
8850		g->invalid_instruction = &sentinel_instructions[0];
8851		g->invalid_instruction->value = allocate<ZigValue>(1, "ZigValue");
8852		g->invalid_instruction->value->type = g->builtin_types.entry_invalid;
	8780	IrInstGen *sentinel_instructions = allocate<IrInstGen>(2);
	8781	g->invalid_inst_gen = &sentinel_instructions[0];
	8782	g->invalid_inst_gen->value = allocate<ZigValue>(1, "ZigValue");
	8783	g->invalid_inst_gen->value->type = g->builtin_types.entry_invalid;
8853	8784
8854	8785	g->unreach_instruction = &sentinel_instructions[1];
8855	8786	g->unreach_instruction->value = allocate<ZigValue>(1, "ZigValue");
8856	8787	g->unreach_instruction->value->type = g->builtin_types.entry_unreachable;
8857	8788
	8789	g->invalid_inst_src = allocate<IrInstSrc>(1);
	8790
8858	8791	define_builtin_fns(g);
8859	8792	Error err;
8860	8793	if ((err = define_builtin_compile_vars(g))) {

src/ir.cpp+7223-6362

...	...	@@ -21,25 +21,31 @@ struct IrExecContext {
21	21	ZigList<ZigValue *> mem_slot_list;
22	22	};
23	23
24		struct IrBuilder {
	24	struct IrBuilderSrc {
25	25	CodeGen *codegen;
26		IrExecutable *exec;
27		IrBasicBlock *current_basic_block;
	26	IrExecutableSrc *exec;
	27	IrBasicBlockSrc *current_basic_block;
28	28	AstNode *main_block_node;
29	29	};
30	30
	31	struct IrBuilderGen {
	32	CodeGen *codegen;
	33	IrExecutableGen *exec;
	34	IrBasicBlockGen *current_basic_block;
	35	};
	36
31	37	struct IrAnalyze {
32	38	CodeGen *codegen;
33		IrBuilder old_irb;
34		IrBuilder new_irb;
	39	IrBuilderSrc old_irb;
	40	IrBuilderGen new_irb;
35	41	IrExecContext exec_context;
36	42	size_t old_bb_index;
37	43	size_t instruction_index;
38	44	ZigType *explicit_return_type;
39	45	AstNode *explicit_return_type_source_node;
40		ZigList<IrInstruction *> src_implicit_return_type_list;
	46	ZigList<IrInstGen *> src_implicit_return_type_list;
41	47	ZigList<IrSuspendPosition> resume_stack;
42		IrBasicBlock *const_predecessor_bb;
	48	IrBasicBlockSrc *const_predecessor_bb;
43	49	size_t ref_count;
44	50	size_t break_debug_id; // for debugging purposes
45	51
...	...	@@ -206,412 +212,538 @@ struct DbgIrBreakPoint {
206	212	DbgIrBreakPoint dbg_ir_breakpoints_buf[20];
207	213	size_t dbg_ir_breakpoints_count = 0;
208	214
209		static IrInstruction ir_gen_node(IrBuilder irb, AstNode node, Scope scope);
210		static IrInstruction ir_gen_node_extra(IrBuilder irb, AstNode node, Scope scope, LVal lval,
	215	static IrInstSrc ir_gen_node(IrBuilderSrc irb, AstNode node, Scope scope);
	216	static IrInstSrc ir_gen_node_extra(IrBuilderSrc irb, AstNode node, Scope scope, LVal lval,
211	217	ResultLoc *result_loc);
212		static IrInstruction ir_implicit_cast(IrAnalyze ira, IrInstruction value, ZigType expected_type);
213		static IrInstruction ir_implicit_cast2(IrAnalyze ira, IrInstruction *value_source_instr,
214		IrInstruction value, ZigType expected_type);
215		static IrInstruction ir_get_deref(IrAnalyze ira, IrInstruction source_instruction, IrInstruction ptr,
	218	static IrInstGen ir_implicit_cast(IrAnalyze ira, IrInstGen value, ZigType expected_type);
	219	static IrInstGen ir_implicit_cast2(IrAnalyze ira, IrInst *value_source_instr,
	220	IrInstGen value, ZigType expected_type);
	221	static IrInstGen ir_get_deref(IrAnalyze ira, IrInst source_instr, IrInstGen ptr,
216	222	ResultLoc *result_loc);
217		static ErrorMsg exec_add_error_node(CodeGen codegen, IrExecutable exec, AstNode source_node, Buf *msg);
218		static IrInstruction ir_analyze_container_field_ptr(IrAnalyze ira, Buf *field_name,
219		IrInstruction source_instr, IrInstruction container_ptr, ZigType *container_type, bool initializing);
220		static void ir_assert(bool ok, IrInstruction *source_instruction);
221		static IrInstruction ir_get_var_ptr(IrAnalyze ira, IrInstruction instruction, ZigVar var);
222		static ZigType ir_resolve_atomic_operand_type(IrAnalyze ira, IrInstruction *op);
223		static IrInstruction ir_lval_wrap(IrBuilder irb, Scope scope, IrInstruction value, LVal lval, ResultLoc *result_loc);
224		static IrInstruction ir_expr_wrap(IrBuilder irb, Scope scope, IrInstruction inst, ResultLoc *result_loc);
	223	static ErrorMsg exec_add_error_node(CodeGen codegen, IrExecutableSrc exec, AstNode source_node, Buf *msg);
	224	static IrInstGen ir_analyze_container_field_ptr(IrAnalyze ira, Buf *field_name,
	225	IrInst* source_instr, IrInstGen container_ptr, ZigType container_type, bool initializing);
	226	static void ir_assert(bool ok, IrInst* source_instruction);
	227	static void ir_assert_gen(bool ok, IrInstGen *source_instruction);
	228	static IrInstGen ir_get_var_ptr(IrAnalyze ira, IrInst source_instr, ZigVar var);
	229	static ZigType ir_resolve_atomic_operand_type(IrAnalyze ira, IrInstGen *op);
	230	static IrInstSrc ir_lval_wrap(IrBuilderSrc irb, Scope scope, IrInstSrc value, LVal lval, ResultLoc *result_loc);
	231	static IrInstSrc ir_expr_wrap(IrBuilderSrc irb, Scope scope, IrInstSrc inst, ResultLoc *result_loc);
225	232	static ZigType adjust_ptr_align(CodeGen g, ZigType *ptr_type, uint32_t new_align);
226	233	static ZigType adjust_slice_align(CodeGen g, ZigType *slice_type, uint32_t new_align);
227	234	static Error buf_read_value_bytes(IrAnalyze ira, CodeGen codegen, AstNode source_node, uint8_t buf, ZigValue *val);
228	235	static void buf_write_value_bytes(CodeGen codegen, uint8_t buf, ZigValue *val);
229	236	static Error ir_read_const_ptr(IrAnalyze ira, CodeGen codegen, AstNode *source_node,
230	237	ZigValue out_val, ZigValue ptr_val);
231		static IrInstruction ir_analyze_ptr_cast(IrAnalyze ira, IrInstruction source_instr, IrInstruction ptr,
232		ZigType dest_type, IrInstruction dest_type_src, bool safety_check_on);
233		static ZigValue ir_resolve_const(IrAnalyze ira, IrInstruction *value, UndefAllowed undef_allowed);
	238	static IrInstGen ir_analyze_ptr_cast(IrAnalyze ira, IrInst* source_instr, IrInstGen *ptr,
	239	ZigType dest_type, IrInst dest_type_src, bool safety_check_on);
	240	static ZigValue ir_resolve_const(IrAnalyze ira, IrInstGen *value, UndefAllowed undef_allowed);
234	241	static Error resolve_ptr_align(IrAnalyze ira, ZigType ty, uint32_t *result_align);
235		static IrInstruction ir_analyze_int_to_ptr(IrAnalyze ira, IrInstruction source_instr, IrInstruction target,
	242	static IrInstGen ir_analyze_int_to_ptr(IrAnalyze ira, IrInst* source_instr, IrInstGen *target,
236	243	ZigType *ptr_type);
237		static IrInstruction ir_analyze_bit_cast(IrAnalyze ira, IrInstruction source_instr, IrInstruction value,
	244	static IrInstGen ir_analyze_bit_cast(IrAnalyze ira, IrInst* source_instr, IrInstGen *value,
238	245	ZigType *dest_type);
239		static IrInstruction ir_resolve_result_raw(IrAnalyze ira, IrInstruction *suspend_source_instr,
240		ResultLoc result_loc, ZigType value_type, IrInstruction *value, bool force_runtime,
	246	static IrInstGen ir_resolve_result_raw(IrAnalyze ira, IrInst *suspend_source_instr,
	247	ResultLoc result_loc, ZigType value_type, IrInstGen *value, bool force_runtime,
241	248	bool non_null_comptime, bool allow_discard);
242		static IrInstruction ir_resolve_result(IrAnalyze ira, IrInstruction *suspend_source_instr,
243		ResultLoc result_loc, ZigType value_type, IrInstruction *value, bool force_runtime,
	249	static IrInstGen ir_resolve_result(IrAnalyze ira, IrInst *suspend_source_instr,
	250	ResultLoc result_loc, ZigType value_type, IrInstGen *value, bool force_runtime,
244	251	bool non_null_comptime, bool allow_discard);
245		static IrInstruction ir_analyze_unwrap_optional_payload(IrAnalyze ira, IrInstruction *source_instr,
246		IrInstruction *base_ptr, bool safety_check_on, bool initializing);
247		static IrInstruction ir_analyze_unwrap_error_payload(IrAnalyze ira, IrInstruction *source_instr,
248		IrInstruction *base_ptr, bool safety_check_on, bool initializing);
249		static IrInstruction ir_analyze_unwrap_err_code(IrAnalyze ira, IrInstruction *source_instr,
250		IrInstruction *base_ptr, bool initializing);
251		static IrInstruction ir_analyze_store_ptr(IrAnalyze ira, IrInstruction *source_instr,
252		IrInstruction ptr, IrInstruction uncasted_value, bool allow_write_through_const);
253		static IrInstruction ir_gen_union_init_expr(IrBuilder irb, Scope scope, AstNode source_node,
254		IrInstruction union_type, IrInstruction field_name, AstNode *expr_node,
	252	static IrInstGen ir_analyze_unwrap_optional_payload(IrAnalyze ira, IrInst* source_instr,
	253	IrInstGen *base_ptr, bool safety_check_on, bool initializing);
	254	static IrInstGen ir_analyze_unwrap_error_payload(IrAnalyze ira, IrInst* source_instr,
	255	IrInstGen *base_ptr, bool safety_check_on, bool initializing);
	256	static IrInstGen ir_analyze_unwrap_err_code(IrAnalyze ira, IrInst* source_instr,
	257	IrInstGen *base_ptr, bool initializing);
	258	static IrInstGen ir_analyze_store_ptr(IrAnalyze ira, IrInst* source_instr,
	259	IrInstGen ptr, IrInstGen uncasted_value, bool allow_write_through_const);
	260	static IrInstSrc ir_gen_union_init_expr(IrBuilderSrc irb, Scope scope, AstNode source_node,
	261	IrInstSrc union_type, IrInstSrc field_name, AstNode *expr_node,
255	262	LVal lval, ResultLoc *parent_result_loc);
256	263	static void ir_reset_result(ResultLoc *result_loc);
257		static Buf get_anon_type_name(CodeGen codegen, IrExecutable exec, const char kind_name,
	264	static Buf get_anon_type_name(CodeGen codegen, IrExecutableSrc exec, const char kind_name,
258	265	Scope scope, AstNode source_node, Buf *out_bare_name);
259		static ResultLocCast ir_build_cast_result_loc(IrBuilder irb, IrInstruction *dest_type,
	266	static ResultLocCast ir_build_cast_result_loc(IrBuilderSrc irb, IrInstSrc *dest_type,
260	267	ResultLoc *parent_result_loc);
261		static IrInstruction ir_analyze_struct_field_ptr(IrAnalyze ira, IrInstruction *source_instr,
262		TypeStructField field, IrInstruction struct_ptr, ZigType *struct_type, bool initializing);
263		static IrInstruction ir_analyze_inferred_field_ptr(IrAnalyze ira, Buf *field_name,
264		IrInstruction source_instr, IrInstruction container_ptr, ZigType *container_type);
	268	static IrInstGen ir_analyze_struct_field_ptr(IrAnalyze ira, IrInst* source_instr,
	269	TypeStructField field, IrInstGen struct_ptr, ZigType *struct_type, bool initializing);
	270	static IrInstGen ir_analyze_inferred_field_ptr(IrAnalyze ira, Buf *field_name,
	271	IrInst* source_instr, IrInstGen container_ptr, ZigType container_type);
265	272	static ResultLoc *no_result_loc(void);
266		static IrInstruction ir_analyze_test_non_null(IrAnalyze ira, IrInstruction source_inst, IrInstruction value);
	273	static IrInstGen ir_analyze_test_non_null(IrAnalyze ira, IrInst source_inst, IrInstGen value);
	274
	275	static void destroy_instruction_src(IrInstSrc *inst) {
	276	#ifdef ZIG_ENABLE_MEM_PROFILE
	277	const char *name = ir_inst_src_type_str(inst->id);
	278	#else
	279	const char *name = nullptr;
	280	#endif
	281	switch (inst->id) {
	282	case IrInstSrcIdInvalid:
	283	zig_unreachable();
	284	case IrInstSrcIdReturn:
	285	return destroy(reinterpret_cast<IrInstSrcReturn *>(inst), name);
	286	case IrInstSrcIdConst:
	287	return destroy(reinterpret_cast<IrInstSrcConst *>(inst), name);
	288	case IrInstSrcIdBinOp:
	289	return destroy(reinterpret_cast<IrInstSrcBinOp *>(inst), name);
	290	case IrInstSrcIdMergeErrSets:
	291	return destroy(reinterpret_cast<IrInstSrcMergeErrSets *>(inst), name);
	292	case IrInstSrcIdDeclVar:
	293	return destroy(reinterpret_cast<IrInstSrcDeclVar *>(inst), name);
	294	case IrInstSrcIdCall:
	295	return destroy(reinterpret_cast<IrInstSrcCall *>(inst), name);
	296	case IrInstSrcIdCallExtra:
	297	return destroy(reinterpret_cast<IrInstSrcCallExtra *>(inst), name);
	298	case IrInstSrcIdUnOp:
	299	return destroy(reinterpret_cast<IrInstSrcUnOp *>(inst), name);
	300	case IrInstSrcIdCondBr:
	301	return destroy(reinterpret_cast<IrInstSrcCondBr *>(inst), name);
	302	case IrInstSrcIdBr:
	303	return destroy(reinterpret_cast<IrInstSrcBr *>(inst), name);
	304	case IrInstSrcIdPhi:
	305	return destroy(reinterpret_cast<IrInstSrcPhi *>(inst), name);
	306	case IrInstSrcIdContainerInitList:
	307	return destroy(reinterpret_cast<IrInstSrcContainerInitList *>(inst), name);
	308	case IrInstSrcIdContainerInitFields:
	309	return destroy(reinterpret_cast<IrInstSrcContainerInitFields *>(inst), name);
	310	case IrInstSrcIdUnreachable:
	311	return destroy(reinterpret_cast<IrInstSrcUnreachable *>(inst), name);
	312	case IrInstSrcIdElemPtr:
	313	return destroy(reinterpret_cast<IrInstSrcElemPtr *>(inst), name);
	314	case IrInstSrcIdVarPtr:
	315	return destroy(reinterpret_cast<IrInstSrcVarPtr *>(inst), name);
	316	case IrInstSrcIdLoadPtr:
	317	return destroy(reinterpret_cast<IrInstSrcLoadPtr *>(inst), name);
	318	case IrInstSrcIdStorePtr:
	319	return destroy(reinterpret_cast<IrInstSrcStorePtr *>(inst), name);
	320	case IrInstSrcIdTypeOf:
	321	return destroy(reinterpret_cast<IrInstSrcTypeOf *>(inst), name);
	322	case IrInstSrcIdFieldPtr:
	323	return destroy(reinterpret_cast<IrInstSrcFieldPtr *>(inst), name);
	324	case IrInstSrcIdSetCold:
	325	return destroy(reinterpret_cast<IrInstSrcSetCold *>(inst), name);
	326	case IrInstSrcIdSetRuntimeSafety:
	327	return destroy(reinterpret_cast<IrInstSrcSetRuntimeSafety *>(inst), name);
	328	case IrInstSrcIdSetFloatMode:
	329	return destroy(reinterpret_cast<IrInstSrcSetFloatMode *>(inst), name);
	330	case IrInstSrcIdArrayType:
	331	return destroy(reinterpret_cast<IrInstSrcArrayType *>(inst), name);
	332	case IrInstSrcIdSliceType:
	333	return destroy(reinterpret_cast<IrInstSrcSliceType *>(inst), name);
	334	case IrInstSrcIdAnyFrameType:
	335	return destroy(reinterpret_cast<IrInstSrcAnyFrameType *>(inst), name);
	336	case IrInstSrcIdAsm:
	337	return destroy(reinterpret_cast<IrInstSrcAsm *>(inst), name);
	338	case IrInstSrcIdSizeOf:
	339	return destroy(reinterpret_cast<IrInstSrcSizeOf *>(inst), name);
	340	case IrInstSrcIdTestNonNull:
	341	return destroy(reinterpret_cast<IrInstSrcTestNonNull *>(inst), name);
	342	case IrInstSrcIdOptionalUnwrapPtr:
	343	return destroy(reinterpret_cast<IrInstSrcOptionalUnwrapPtr *>(inst), name);
	344	case IrInstSrcIdPopCount:
	345	return destroy(reinterpret_cast<IrInstSrcPopCount *>(inst), name);
	346	case IrInstSrcIdClz:
	347	return destroy(reinterpret_cast<IrInstSrcClz *>(inst), name);
	348	case IrInstSrcIdCtz:
	349	return destroy(reinterpret_cast<IrInstSrcCtz *>(inst), name);
	350	case IrInstSrcIdBswap:
	351	return destroy(reinterpret_cast<IrInstSrcBswap *>(inst), name);
	352	case IrInstSrcIdBitReverse:
	353	return destroy(reinterpret_cast<IrInstSrcBitReverse *>(inst), name);
	354	case IrInstSrcIdSwitchBr:
	355	return destroy(reinterpret_cast<IrInstSrcSwitchBr *>(inst), name);
	356	case IrInstSrcIdSwitchVar:
	357	return destroy(reinterpret_cast<IrInstSrcSwitchVar *>(inst), name);
	358	case IrInstSrcIdSwitchElseVar:
	359	return destroy(reinterpret_cast<IrInstSrcSwitchElseVar *>(inst), name);
	360	case IrInstSrcIdSwitchTarget:
	361	return destroy(reinterpret_cast<IrInstSrcSwitchTarget *>(inst), name);
	362	case IrInstSrcIdImport:
	363	return destroy(reinterpret_cast<IrInstSrcImport *>(inst), name);
	364	case IrInstSrcIdRef:
	365	return destroy(reinterpret_cast<IrInstSrcRef *>(inst), name);
	366	case IrInstSrcIdCompileErr:
	367	return destroy(reinterpret_cast<IrInstSrcCompileErr *>(inst), name);
	368	case IrInstSrcIdCompileLog:
	369	return destroy(reinterpret_cast<IrInstSrcCompileLog *>(inst), name);
	370	case IrInstSrcIdErrName:
	371	return destroy(reinterpret_cast<IrInstSrcErrName *>(inst), name);
	372	case IrInstSrcIdCImport:
	373	return destroy(reinterpret_cast<IrInstSrcCImport *>(inst), name);
	374	case IrInstSrcIdCInclude:
	375	return destroy(reinterpret_cast<IrInstSrcCInclude *>(inst), name);
	376	case IrInstSrcIdCDefine:
	377	return destroy(reinterpret_cast<IrInstSrcCDefine *>(inst), name);
	378	case IrInstSrcIdCUndef:
	379	return destroy(reinterpret_cast<IrInstSrcCUndef *>(inst), name);
	380	case IrInstSrcIdEmbedFile:
	381	return destroy(reinterpret_cast<IrInstSrcEmbedFile *>(inst), name);
	382	case IrInstSrcIdCmpxchg:
	383	return destroy(reinterpret_cast<IrInstSrcCmpxchg *>(inst), name);
	384	case IrInstSrcIdFence:
	385	return destroy(reinterpret_cast<IrInstSrcFence *>(inst), name);
	386	case IrInstSrcIdTruncate:
	387	return destroy(reinterpret_cast<IrInstSrcTruncate *>(inst), name);
	388	case IrInstSrcIdIntCast:
	389	return destroy(reinterpret_cast<IrInstSrcIntCast *>(inst), name);
	390	case IrInstSrcIdFloatCast:
	391	return destroy(reinterpret_cast<IrInstSrcFloatCast *>(inst), name);
	392	case IrInstSrcIdErrSetCast:
	393	return destroy(reinterpret_cast<IrInstSrcErrSetCast *>(inst), name);
	394	case IrInstSrcIdFromBytes:
	395	return destroy(reinterpret_cast<IrInstSrcFromBytes *>(inst), name);
	396	case IrInstSrcIdToBytes:
	397	return destroy(reinterpret_cast<IrInstSrcToBytes *>(inst), name);
	398	case IrInstSrcIdIntToFloat:
	399	return destroy(reinterpret_cast<IrInstSrcIntToFloat *>(inst), name);
	400	case IrInstSrcIdFloatToInt:
	401	return destroy(reinterpret_cast<IrInstSrcFloatToInt *>(inst), name);
	402	case IrInstSrcIdBoolToInt:
	403	return destroy(reinterpret_cast<IrInstSrcBoolToInt *>(inst), name);
	404	case IrInstSrcIdIntType:
	405	return destroy(reinterpret_cast<IrInstSrcIntType *>(inst), name);
	406	case IrInstSrcIdVectorType:
	407	return destroy(reinterpret_cast<IrInstSrcVectorType *>(inst), name);
	408	case IrInstSrcIdShuffleVector:
	409	return destroy(reinterpret_cast<IrInstSrcShuffleVector *>(inst), name);
	410	case IrInstSrcIdSplat:
	411	return destroy(reinterpret_cast<IrInstSrcSplat *>(inst), name);
	412	case IrInstSrcIdBoolNot:
	413	return destroy(reinterpret_cast<IrInstSrcBoolNot *>(inst), name);
	414	case IrInstSrcIdMemset:
	415	return destroy(reinterpret_cast<IrInstSrcMemset *>(inst), name);
	416	case IrInstSrcIdMemcpy:
	417	return destroy(reinterpret_cast<IrInstSrcMemcpy *>(inst), name);
	418	case IrInstSrcIdSlice:
	419	return destroy(reinterpret_cast<IrInstSrcSlice *>(inst), name);
	420	case IrInstSrcIdMemberCount:
	421	return destroy(reinterpret_cast<IrInstSrcMemberCount *>(inst), name);
	422	case IrInstSrcIdMemberType:
	423	return destroy(reinterpret_cast<IrInstSrcMemberType *>(inst), name);
	424	case IrInstSrcIdMemberName:
	425	return destroy(reinterpret_cast<IrInstSrcMemberName *>(inst), name);
	426	case IrInstSrcIdBreakpoint:
	427	return destroy(reinterpret_cast<IrInstSrcBreakpoint *>(inst), name);
	428	case IrInstSrcIdReturnAddress:
	429	return destroy(reinterpret_cast<IrInstSrcReturnAddress *>(inst), name);
	430	case IrInstSrcIdFrameAddress:
	431	return destroy(reinterpret_cast<IrInstSrcFrameAddress *>(inst), name);
	432	case IrInstSrcIdFrameHandle:
	433	return destroy(reinterpret_cast<IrInstSrcFrameHandle *>(inst), name);
	434	case IrInstSrcIdFrameType:
	435	return destroy(reinterpret_cast<IrInstSrcFrameType *>(inst), name);
	436	case IrInstSrcIdFrameSize:
	437	return destroy(reinterpret_cast<IrInstSrcFrameSize *>(inst), name);
	438	case IrInstSrcIdAlignOf:
	439	return destroy(reinterpret_cast<IrInstSrcAlignOf *>(inst), name);
	440	case IrInstSrcIdOverflowOp:
	441	return destroy(reinterpret_cast<IrInstSrcOverflowOp *>(inst), name);
	442	case IrInstSrcIdTestErr:
	443	return destroy(reinterpret_cast<IrInstSrcTestErr *>(inst), name);
	444	case IrInstSrcIdUnwrapErrCode:
	445	return destroy(reinterpret_cast<IrInstSrcUnwrapErrCode *>(inst), name);
	446	case IrInstSrcIdUnwrapErrPayload:
	447	return destroy(reinterpret_cast<IrInstSrcUnwrapErrPayload *>(inst), name);
	448	case IrInstSrcIdFnProto:
	449	return destroy(reinterpret_cast<IrInstSrcFnProto *>(inst), name);
	450	case IrInstSrcIdTestComptime:
	451	return destroy(reinterpret_cast<IrInstSrcTestComptime *>(inst), name);
	452	case IrInstSrcIdPtrCast:
	453	return destroy(reinterpret_cast<IrInstSrcPtrCast *>(inst), name);
	454	case IrInstSrcIdBitCast:
	455	return destroy(reinterpret_cast<IrInstSrcBitCast *>(inst), name);
	456	case IrInstSrcIdPtrToInt:
	457	return destroy(reinterpret_cast<IrInstSrcPtrToInt *>(inst), name);
	458	case IrInstSrcIdIntToPtr:
	459	return destroy(reinterpret_cast<IrInstSrcIntToPtr *>(inst), name);
	460	case IrInstSrcIdIntToEnum:
	461	return destroy(reinterpret_cast<IrInstSrcIntToEnum *>(inst), name);
	462	case IrInstSrcIdIntToErr:
	463	return destroy(reinterpret_cast<IrInstSrcIntToErr *>(inst), name);
	464	case IrInstSrcIdErrToInt:
	465	return destroy(reinterpret_cast<IrInstSrcErrToInt *>(inst), name);
	466	case IrInstSrcIdCheckSwitchProngs:
	467	return destroy(reinterpret_cast<IrInstSrcCheckSwitchProngs *>(inst), name);
	468	case IrInstSrcIdCheckStatementIsVoid:
	469	return destroy(reinterpret_cast<IrInstSrcCheckStatementIsVoid *>(inst), name);
	470	case IrInstSrcIdTypeName:
	471	return destroy(reinterpret_cast<IrInstSrcTypeName *>(inst), name);
	472	case IrInstSrcIdTagName:
	473	return destroy(reinterpret_cast<IrInstSrcTagName *>(inst), name);
	474	case IrInstSrcIdPtrType:
	475	return destroy(reinterpret_cast<IrInstSrcPtrType *>(inst), name);
	476	case IrInstSrcIdDeclRef:
	477	return destroy(reinterpret_cast<IrInstSrcDeclRef *>(inst), name);
	478	case IrInstSrcIdPanic:
	479	return destroy(reinterpret_cast<IrInstSrcPanic *>(inst), name);
	480	case IrInstSrcIdFieldParentPtr:
	481	return destroy(reinterpret_cast<IrInstSrcFieldParentPtr *>(inst), name);
	482	case IrInstSrcIdByteOffsetOf:
	483	return destroy(reinterpret_cast<IrInstSrcByteOffsetOf *>(inst), name);
	484	case IrInstSrcIdBitOffsetOf:
	485	return destroy(reinterpret_cast<IrInstSrcBitOffsetOf *>(inst), name);
	486	case IrInstSrcIdTypeInfo:
	487	return destroy(reinterpret_cast<IrInstSrcTypeInfo *>(inst), name);
	488	case IrInstSrcIdType:
	489	return destroy(reinterpret_cast<IrInstSrcType *>(inst), name);
	490	case IrInstSrcIdHasField:
	491	return destroy(reinterpret_cast<IrInstSrcHasField *>(inst), name);
	492	case IrInstSrcIdTypeId:
	493	return destroy(reinterpret_cast<IrInstSrcTypeId *>(inst), name);
	494	case IrInstSrcIdSetEvalBranchQuota:
	495	return destroy(reinterpret_cast<IrInstSrcSetEvalBranchQuota *>(inst), name);
	496	case IrInstSrcIdAlignCast:
	497	return destroy(reinterpret_cast<IrInstSrcAlignCast *>(inst), name);
	498	case IrInstSrcIdImplicitCast:
	499	return destroy(reinterpret_cast<IrInstSrcImplicitCast *>(inst), name);
	500	case IrInstSrcIdResolveResult:
	501	return destroy(reinterpret_cast<IrInstSrcResolveResult *>(inst), name);
	502	case IrInstSrcIdResetResult:
	503	return destroy(reinterpret_cast<IrInstSrcResetResult *>(inst), name);
	504	case IrInstSrcIdOpaqueType:
	505	return destroy(reinterpret_cast<IrInstSrcOpaqueType *>(inst), name);
	506	case IrInstSrcIdSetAlignStack:
	507	return destroy(reinterpret_cast<IrInstSrcSetAlignStack *>(inst), name);
	508	case IrInstSrcIdArgType:
	509	return destroy(reinterpret_cast<IrInstSrcArgType *>(inst), name);
	510	case IrInstSrcIdTagType:
	511	return destroy(reinterpret_cast<IrInstSrcTagType *>(inst), name);
	512	case IrInstSrcIdExport:
	513	return destroy(reinterpret_cast<IrInstSrcExport *>(inst), name);
	514	case IrInstSrcIdErrorReturnTrace:
	515	return destroy(reinterpret_cast<IrInstSrcErrorReturnTrace *>(inst), name);
	516	case IrInstSrcIdErrorUnion:
	517	return destroy(reinterpret_cast<IrInstSrcErrorUnion *>(inst), name);
	518	case IrInstSrcIdAtomicRmw:
	519	return destroy(reinterpret_cast<IrInstSrcAtomicRmw *>(inst), name);
	520	case IrInstSrcIdSaveErrRetAddr:
	521	return destroy(reinterpret_cast<IrInstSrcSaveErrRetAddr *>(inst), name);
	522	case IrInstSrcIdAddImplicitReturnType:
	523	return destroy(reinterpret_cast<IrInstSrcAddImplicitReturnType *>(inst), name);
	524	case IrInstSrcIdFloatOp:
	525	return destroy(reinterpret_cast<IrInstSrcFloatOp *>(inst), name);
	526	case IrInstSrcIdMulAdd:
	527	return destroy(reinterpret_cast<IrInstSrcMulAdd *>(inst), name);
	528	case IrInstSrcIdAtomicLoad:
	529	return destroy(reinterpret_cast<IrInstSrcAtomicLoad *>(inst), name);
	530	case IrInstSrcIdAtomicStore:
	531	return destroy(reinterpret_cast<IrInstSrcAtomicStore *>(inst), name);
	532	case IrInstSrcIdEnumToInt:
	533	return destroy(reinterpret_cast<IrInstSrcEnumToInt *>(inst), name);
	534	case IrInstSrcIdCheckRuntimeScope:
	535	return destroy(reinterpret_cast<IrInstSrcCheckRuntimeScope *>(inst), name);
	536	case IrInstSrcIdHasDecl:
	537	return destroy(reinterpret_cast<IrInstSrcHasDecl *>(inst), name);
	538	case IrInstSrcIdUndeclaredIdent:
	539	return destroy(reinterpret_cast<IrInstSrcUndeclaredIdent *>(inst), name);
	540	case IrInstSrcIdAlloca:
	541	return destroy(reinterpret_cast<IrInstSrcAlloca *>(inst), name);
	542	case IrInstSrcIdEndExpr:
	543	return destroy(reinterpret_cast<IrInstSrcEndExpr *>(inst), name);
	544	case IrInstSrcIdUnionInitNamedField:
	545	return destroy(reinterpret_cast<IrInstSrcUnionInitNamedField *>(inst), name);
	546	case IrInstSrcIdSuspendBegin:
	547	return destroy(reinterpret_cast<IrInstSrcSuspendBegin *>(inst), name);
	548	case IrInstSrcIdSuspendFinish:
	549	return destroy(reinterpret_cast<IrInstSrcSuspendFinish *>(inst), name);
	550	case IrInstSrcIdResume:
	551	return destroy(reinterpret_cast<IrInstSrcResume *>(inst), name);
	552	case IrInstSrcIdAwait:
	553	return destroy(reinterpret_cast<IrInstSrcAwait *>(inst), name);
	554	case IrInstSrcIdSpillBegin:
	555	return destroy(reinterpret_cast<IrInstSrcSpillBegin *>(inst), name);
	556	case IrInstSrcIdSpillEnd:
	557	return destroy(reinterpret_cast<IrInstSrcSpillEnd *>(inst), name);
	558	case IrInstSrcIdCallArgs:
	559	return destroy(reinterpret_cast<IrInstSrcCallArgs *>(inst), name);
	560	}
	561	zig_unreachable();
	562	}
267	563
268		static void destroy_instruction(IrInstruction *inst) {
	564	void destroy_instruction_gen(IrInstGen *inst) {
269	565	#ifdef ZIG_ENABLE_MEM_PROFILE
270		const char *name = ir_instruction_type_str(inst->id);
	566	const char *name = ir_inst_gen_type_str(inst->id);
271	567	#else
272	568	const char *name = nullptr;
273	569	#endif
274	570	switch (inst->id) {
275		case IrInstructionIdInvalid:
	571	case IrInstGenIdInvalid:
276	572	zig_unreachable();
277		case IrInstructionIdReturn:
278		return destroy(reinterpret_cast<IrInstructionReturn *>(inst), name);
279		case IrInstructionIdConst:
280		return destroy(reinterpret_cast<IrInstructionConst *>(inst), name);
281		case IrInstructionIdBinOp:
282		return destroy(reinterpret_cast<IrInstructionBinOp *>(inst), name);
283		case IrInstructionIdMergeErrSets:
284		return destroy(reinterpret_cast<IrInstructionMergeErrSets *>(inst), name);
285		case IrInstructionIdDeclVarSrc:
286		return destroy(reinterpret_cast<IrInstructionDeclVarSrc *>(inst), name);
287		case IrInstructionIdCast:
288		return destroy(reinterpret_cast<IrInstructionCast *>(inst), name);
289		case IrInstructionIdCallSrc:
290		return destroy(reinterpret_cast<IrInstructionCallSrc *>(inst), name);
291		case IrInstructionIdCallSrcArgs:
292		return destroy(reinterpret_cast<IrInstructionCallSrcArgs *>(inst), name);
293		case IrInstructionIdCallExtra:
294		return destroy(reinterpret_cast<IrInstructionCallExtra *>(inst), name);
295		case IrInstructionIdCallGen:
296		return destroy(reinterpret_cast<IrInstructionCallGen *>(inst), name);
297		case IrInstructionIdUnOp:
298		return destroy(reinterpret_cast<IrInstructionUnOp *>(inst), name);
299		case IrInstructionIdCondBr:
300		return destroy(reinterpret_cast<IrInstructionCondBr *>(inst), name);
301		case IrInstructionIdBr:
302		return destroy(reinterpret_cast<IrInstructionBr *>(inst), name);
303		case IrInstructionIdPhi:
304		return destroy(reinterpret_cast<IrInstructionPhi *>(inst), name);
305		case IrInstructionIdContainerInitList:
306		return destroy(reinterpret_cast<IrInstructionContainerInitList *>(inst), name);
307		case IrInstructionIdContainerInitFields:
308		return destroy(reinterpret_cast<IrInstructionContainerInitFields *>(inst), name);
309		case IrInstructionIdUnreachable:
310		return destroy(reinterpret_cast<IrInstructionUnreachable *>(inst), name);
311		case IrInstructionIdElemPtr:
312		return destroy(reinterpret_cast<IrInstructionElemPtr *>(inst), name);
313		case IrInstructionIdVarPtr:
314		return destroy(reinterpret_cast<IrInstructionVarPtr *>(inst), name);
315		case IrInstructionIdReturnPtr:
316		return destroy(reinterpret_cast<IrInstructionReturnPtr *>(inst), name);
317		case IrInstructionIdLoadPtr:
318		return destroy(reinterpret_cast<IrInstructionLoadPtr *>(inst), name);
319		case IrInstructionIdLoadPtrGen:
320		return destroy(reinterpret_cast<IrInstructionLoadPtrGen *>(inst), name);
321		case IrInstructionIdStorePtr:
322		return destroy(reinterpret_cast<IrInstructionStorePtr *>(inst), name);
323		case IrInstructionIdVectorStoreElem:
324		return destroy(reinterpret_cast<IrInstructionVectorStoreElem *>(inst), name);
325		case IrInstructionIdTypeOf:
326		return destroy(reinterpret_cast<IrInstructionTypeOf *>(inst), name);
327		case IrInstructionIdFieldPtr:
328		return destroy(reinterpret_cast<IrInstructionFieldPtr *>(inst), name);
329		case IrInstructionIdStructFieldPtr:
330		return destroy(reinterpret_cast<IrInstructionStructFieldPtr *>(inst), name);
331		case IrInstructionIdUnionFieldPtr:
332		return destroy(reinterpret_cast<IrInstructionUnionFieldPtr *>(inst), name);
333		case IrInstructionIdSetCold:
334		return destroy(reinterpret_cast<IrInstructionSetCold *>(inst), name);
335		case IrInstructionIdSetRuntimeSafety:
336		return destroy(reinterpret_cast<IrInstructionSetRuntimeSafety *>(inst), name);
337		case IrInstructionIdSetFloatMode:
338		return destroy(reinterpret_cast<IrInstructionSetFloatMode *>(inst), name);
339		case IrInstructionIdArrayType:
340		return destroy(reinterpret_cast<IrInstructionArrayType *>(inst), name);
341		case IrInstructionIdSliceType:
342		return destroy(reinterpret_cast<IrInstructionSliceType *>(inst), name);
343		case IrInstructionIdAnyFrameType:
344		return destroy(reinterpret_cast<IrInstructionAnyFrameType *>(inst), name);
345		case IrInstructionIdAsmSrc:
346		return destroy(reinterpret_cast<IrInstructionAsmSrc *>(inst), name);
347		case IrInstructionIdAsmGen:
348		return destroy(reinterpret_cast<IrInstructionAsmGen *>(inst), name);
349		case IrInstructionIdSizeOf:
350		return destroy(reinterpret_cast<IrInstructionSizeOf *>(inst), name);
351		case IrInstructionIdTestNonNull:
352		return destroy(reinterpret_cast<IrInstructionTestNonNull *>(inst), name);
353		case IrInstructionIdOptionalUnwrapPtr:
354		return destroy(reinterpret_cast<IrInstructionOptionalUnwrapPtr *>(inst), name);
355		case IrInstructionIdPopCount:
356		return destroy(reinterpret_cast<IrInstructionPopCount *>(inst), name);
357		case IrInstructionIdClz:
358		return destroy(reinterpret_cast<IrInstructionClz *>(inst), name);
359		case IrInstructionIdCtz:
360		return destroy(reinterpret_cast<IrInstructionCtz *>(inst), name);
361		case IrInstructionIdBswap:
362		return destroy(reinterpret_cast<IrInstructionBswap *>(inst), name);
363		case IrInstructionIdBitReverse:
364		return destroy(reinterpret_cast<IrInstructionBitReverse *>(inst), name);
365		case IrInstructionIdSwitchBr:
366		return destroy(reinterpret_cast<IrInstructionSwitchBr *>(inst), name);
367		case IrInstructionIdSwitchVar:
368		return destroy(reinterpret_cast<IrInstructionSwitchVar *>(inst), name);
369		case IrInstructionIdSwitchElseVar:
370		return destroy(reinterpret_cast<IrInstructionSwitchElseVar *>(inst), name);
371		case IrInstructionIdSwitchTarget:
372		return destroy(reinterpret_cast<IrInstructionSwitchTarget *>(inst), name);
373		case IrInstructionIdUnionTag:
374		return destroy(reinterpret_cast<IrInstructionUnionTag *>(inst), name);
375		case IrInstructionIdImport:
376		return destroy(reinterpret_cast<IrInstructionImport *>(inst), name);
377		case IrInstructionIdRef:
378		return destroy(reinterpret_cast<IrInstructionRef *>(inst), name);
379		case IrInstructionIdRefGen:
380		return destroy(reinterpret_cast<IrInstructionRefGen *>(inst), name);
381		case IrInstructionIdCompileErr:
382		return destroy(reinterpret_cast<IrInstructionCompileErr *>(inst), name);
383		case IrInstructionIdCompileLog:
384		return destroy(reinterpret_cast<IrInstructionCompileLog *>(inst), name);
385		case IrInstructionIdErrName:
386		return destroy(reinterpret_cast<IrInstructionErrName *>(inst), name);
387		case IrInstructionIdCImport:
388		return destroy(reinterpret_cast<IrInstructionCImport *>(inst), name);
389		case IrInstructionIdCInclude:
390		return destroy(reinterpret_cast<IrInstructionCInclude *>(inst), name);
391		case IrInstructionIdCDefine:
392		return destroy(reinterpret_cast<IrInstructionCDefine *>(inst), name);
393		case IrInstructionIdCUndef:
394		return destroy(reinterpret_cast<IrInstructionCUndef *>(inst), name);
395		case IrInstructionIdEmbedFile:
396		return destroy(reinterpret_cast<IrInstructionEmbedFile *>(inst), name);
397		case IrInstructionIdCmpxchgSrc:
398		return destroy(reinterpret_cast<IrInstructionCmpxchgSrc *>(inst), name);
399		case IrInstructionIdCmpxchgGen:
400		return destroy(reinterpret_cast<IrInstructionCmpxchgGen *>(inst), name);
401		case IrInstructionIdFence:
402		return destroy(reinterpret_cast<IrInstructionFence *>(inst), name);
403		case IrInstructionIdTruncate:
404		return destroy(reinterpret_cast<IrInstructionTruncate *>(inst), name);
405		case IrInstructionIdIntCast:
406		return destroy(reinterpret_cast<IrInstructionIntCast *>(inst), name);
407		case IrInstructionIdFloatCast:
408		return destroy(reinterpret_cast<IrInstructionFloatCast *>(inst), name);
409		case IrInstructionIdErrSetCast:
410		return destroy(reinterpret_cast<IrInstructionErrSetCast *>(inst), name);
411		case IrInstructionIdFromBytes:
412		return destroy(reinterpret_cast<IrInstructionFromBytes *>(inst), name);
413		case IrInstructionIdToBytes:
414		return destroy(reinterpret_cast<IrInstructionToBytes *>(inst), name);
415		case IrInstructionIdIntToFloat:
416		return destroy(reinterpret_cast<IrInstructionIntToFloat *>(inst), name);
417		case IrInstructionIdFloatToInt:
418		return destroy(reinterpret_cast<IrInstructionFloatToInt *>(inst), name);
419		case IrInstructionIdBoolToInt:
420		return destroy(reinterpret_cast<IrInstructionBoolToInt *>(inst), name);
421		case IrInstructionIdIntType:
422		return destroy(reinterpret_cast<IrInstructionIntType *>(inst), name);
423		case IrInstructionIdVectorType:
424		return destroy(reinterpret_cast<IrInstructionVectorType *>(inst), name);
425		case IrInstructionIdShuffleVector:
426		return destroy(reinterpret_cast<IrInstructionShuffleVector *>(inst), name);
427		case IrInstructionIdSplatSrc:
428		return destroy(reinterpret_cast<IrInstructionSplatSrc *>(inst), name);
429		case IrInstructionIdSplatGen:
430		return destroy(reinterpret_cast<IrInstructionSplatGen *>(inst), name);
431		case IrInstructionIdBoolNot:
432		return destroy(reinterpret_cast<IrInstructionBoolNot *>(inst), name);
433		case IrInstructionIdMemset:
434		return destroy(reinterpret_cast<IrInstructionMemset *>(inst), name);
435		case IrInstructionIdMemcpy:
436		return destroy(reinterpret_cast<IrInstructionMemcpy *>(inst), name);
437		case IrInstructionIdSliceSrc:
438		return destroy(reinterpret_cast<IrInstructionSliceSrc *>(inst), name);
439		case IrInstructionIdSliceGen:
440		return destroy(reinterpret_cast<IrInstructionSliceGen *>(inst), name);
441		case IrInstructionIdMemberCount:
442		return destroy(reinterpret_cast<IrInstructionMemberCount *>(inst), name);
443		case IrInstructionIdMemberType:
444		return destroy(reinterpret_cast<IrInstructionMemberType *>(inst), name);
445		case IrInstructionIdMemberName:
446		return destroy(reinterpret_cast<IrInstructionMemberName *>(inst), name);
447		case IrInstructionIdBreakpoint:
448		return destroy(reinterpret_cast<IrInstructionBreakpoint *>(inst), name);
449		case IrInstructionIdReturnAddress:
450		return destroy(reinterpret_cast<IrInstructionReturnAddress *>(inst), name);
451		case IrInstructionIdFrameAddress:
452		return destroy(reinterpret_cast<IrInstructionFrameAddress *>(inst), name);
453		case IrInstructionIdFrameHandle:
454		return destroy(reinterpret_cast<IrInstructionFrameHandle *>(inst), name);
455		case IrInstructionIdFrameType:
456		return destroy(reinterpret_cast<IrInstructionFrameType *>(inst), name);
457		case IrInstructionIdFrameSizeSrc:
458		return destroy(reinterpret_cast<IrInstructionFrameSizeSrc *>(inst), name);
459		case IrInstructionIdFrameSizeGen:
460		return destroy(reinterpret_cast<IrInstructionFrameSizeGen *>(inst), name);
461		case IrInstructionIdAlignOf:
462		return destroy(reinterpret_cast<IrInstructionAlignOf *>(inst), name);
463		case IrInstructionIdOverflowOp:
464		return destroy(reinterpret_cast<IrInstructionOverflowOp *>(inst), name);
465		case IrInstructionIdTestErrSrc:
466		return destroy(reinterpret_cast<IrInstructionTestErrSrc *>(inst), name);
467		case IrInstructionIdTestErrGen:
468		return destroy(reinterpret_cast<IrInstructionTestErrGen *>(inst), name);
469		case IrInstructionIdUnwrapErrCode:
470		return destroy(reinterpret_cast<IrInstructionUnwrapErrCode *>(inst), name);
471		case IrInstructionIdUnwrapErrPayload:
472		return destroy(reinterpret_cast<IrInstructionUnwrapErrPayload *>(inst), name);
473		case IrInstructionIdOptionalWrap:
474		return destroy(reinterpret_cast<IrInstructionOptionalWrap *>(inst), name);
475		case IrInstructionIdErrWrapCode:
476		return destroy(reinterpret_cast<IrInstructionErrWrapCode *>(inst), name);
477		case IrInstructionIdErrWrapPayload:
478		return destroy(reinterpret_cast<IrInstructionErrWrapPayload *>(inst), name);
479		case IrInstructionIdFnProto:
480		return destroy(reinterpret_cast<IrInstructionFnProto *>(inst), name);
481		case IrInstructionIdTestComptime:
482		return destroy(reinterpret_cast<IrInstructionTestComptime *>(inst), name);
483		case IrInstructionIdPtrCastSrc:
484		return destroy(reinterpret_cast<IrInstructionPtrCastSrc *>(inst), name);
485		case IrInstructionIdPtrCastGen:
486		return destroy(reinterpret_cast<IrInstructionPtrCastGen *>(inst), name);
487		case IrInstructionIdBitCastSrc:
488		return destroy(reinterpret_cast<IrInstructionBitCastSrc *>(inst), name);
489		case IrInstructionIdBitCastGen:
490		return destroy(reinterpret_cast<IrInstructionBitCastGen *>(inst), name);
491		case IrInstructionIdWidenOrShorten:
492		return destroy(reinterpret_cast<IrInstructionWidenOrShorten *>(inst), name);
493		case IrInstructionIdPtrToInt:
494		return destroy(reinterpret_cast<IrInstructionPtrToInt *>(inst), name);
495		case IrInstructionIdIntToPtr:
496		return destroy(reinterpret_cast<IrInstructionIntToPtr *>(inst), name);
497		case IrInstructionIdIntToEnum:
498		return destroy(reinterpret_cast<IrInstructionIntToEnum *>(inst), name);
499		case IrInstructionIdIntToErr:
500		return destroy(reinterpret_cast<IrInstructionIntToErr *>(inst), name);
501		case IrInstructionIdErrToInt:
502		return destroy(reinterpret_cast<IrInstructionErrToInt *>(inst), name);
503		case IrInstructionIdCheckSwitchProngs:
504		return destroy(reinterpret_cast<IrInstructionCheckSwitchProngs *>(inst), name);
505		case IrInstructionIdCheckStatementIsVoid:
506		return destroy(reinterpret_cast<IrInstructionCheckStatementIsVoid *>(inst), name);
507		case IrInstructionIdTypeName:
508		return destroy(reinterpret_cast<IrInstructionTypeName *>(inst), name);
509		case IrInstructionIdTagName:
510		return destroy(reinterpret_cast<IrInstructionTagName *>(inst), name);
511		case IrInstructionIdPtrType:
512		return destroy(reinterpret_cast<IrInstructionPtrType *>(inst), name);
513		case IrInstructionIdDeclRef:
514		return destroy(reinterpret_cast<IrInstructionDeclRef *>(inst), name);
515		case IrInstructionIdPanic:
516		return destroy(reinterpret_cast<IrInstructionPanic *>(inst), name);
517		case IrInstructionIdFieldParentPtr:
518		return destroy(reinterpret_cast<IrInstructionFieldParentPtr *>(inst), name);
519		case IrInstructionIdByteOffsetOf:
520		return destroy(reinterpret_cast<IrInstructionByteOffsetOf *>(inst), name);
521		case IrInstructionIdBitOffsetOf:
522		return destroy(reinterpret_cast<IrInstructionBitOffsetOf *>(inst), name);
523		case IrInstructionIdTypeInfo:
524		return destroy(reinterpret_cast<IrInstructionTypeInfo *>(inst), name);
525		case IrInstructionIdType:
526		return destroy(reinterpret_cast<IrInstructionType *>(inst), name);
527		case IrInstructionIdHasField:
528		return destroy(reinterpret_cast<IrInstructionHasField *>(inst), name);
529		case IrInstructionIdTypeId:
530		return destroy(reinterpret_cast<IrInstructionTypeId *>(inst), name);
531		case IrInstructionIdSetEvalBranchQuota:
532		return destroy(reinterpret_cast<IrInstructionSetEvalBranchQuota *>(inst), name);
533		case IrInstructionIdAlignCast:
534		return destroy(reinterpret_cast<IrInstructionAlignCast *>(inst), name);
535		case IrInstructionIdImplicitCast:
536		return destroy(reinterpret_cast<IrInstructionImplicitCast *>(inst), name);
537		case IrInstructionIdResolveResult:
538		return destroy(reinterpret_cast<IrInstructionResolveResult *>(inst), name);
539		case IrInstructionIdResetResult:
540		return destroy(reinterpret_cast<IrInstructionResetResult *>(inst), name);
541		case IrInstructionIdOpaqueType:
542		return destroy(reinterpret_cast<IrInstructionOpaqueType *>(inst), name);
543		case IrInstructionIdSetAlignStack:
544		return destroy(reinterpret_cast<IrInstructionSetAlignStack *>(inst), name);
545		case IrInstructionIdArgType:
546		return destroy(reinterpret_cast<IrInstructionArgType *>(inst), name);
547		case IrInstructionIdTagType:
548		return destroy(reinterpret_cast<IrInstructionTagType *>(inst), name);
549		case IrInstructionIdExport:
550		return destroy(reinterpret_cast<IrInstructionExport *>(inst), name);
551		case IrInstructionIdErrorReturnTrace:
552		return destroy(reinterpret_cast<IrInstructionErrorReturnTrace *>(inst), name);
553		case IrInstructionIdErrorUnion:
554		return destroy(reinterpret_cast<IrInstructionErrorUnion *>(inst), name);
555		case IrInstructionIdAtomicRmw:
556		return destroy(reinterpret_cast<IrInstructionAtomicRmw *>(inst), name);
557		case IrInstructionIdSaveErrRetAddr:
558		return destroy(reinterpret_cast<IrInstructionSaveErrRetAddr *>(inst), name);
559		case IrInstructionIdAddImplicitReturnType:
560		return destroy(reinterpret_cast<IrInstructionAddImplicitReturnType *>(inst), name);
561		case IrInstructionIdFloatOp:
562		return destroy(reinterpret_cast<IrInstructionFloatOp *>(inst), name);
563		case IrInstructionIdMulAdd:
564		return destroy(reinterpret_cast<IrInstructionMulAdd *>(inst), name);
565		case IrInstructionIdAtomicLoad:
566		return destroy(reinterpret_cast<IrInstructionAtomicLoad *>(inst), name);
567		case IrInstructionIdAtomicStore:
568		return destroy(reinterpret_cast<IrInstructionAtomicStore *>(inst), name);
569		case IrInstructionIdEnumToInt:
570		return destroy(reinterpret_cast<IrInstructionEnumToInt *>(inst), name);
571		case IrInstructionIdCheckRuntimeScope:
572		return destroy(reinterpret_cast<IrInstructionCheckRuntimeScope *>(inst), name);
573		case IrInstructionIdDeclVarGen:
574		return destroy(reinterpret_cast<IrInstructionDeclVarGen *>(inst), name);
575		case IrInstructionIdArrayToVector:
576		return destroy(reinterpret_cast<IrInstructionArrayToVector *>(inst), name);
577		case IrInstructionIdVectorToArray:
578		return destroy(reinterpret_cast<IrInstructionVectorToArray *>(inst), name);
579		case IrInstructionIdPtrOfArrayToSlice:
580		return destroy(reinterpret_cast<IrInstructionPtrOfArrayToSlice *>(inst), name);
581		case IrInstructionIdAssertZero:
582		return destroy(reinterpret_cast<IrInstructionAssertZero *>(inst), name);
583		case IrInstructionIdAssertNonNull:
584		return destroy(reinterpret_cast<IrInstructionAssertNonNull *>(inst), name);
585		case IrInstructionIdResizeSlice:
586		return destroy(reinterpret_cast<IrInstructionResizeSlice *>(inst), name);
587		case IrInstructionIdHasDecl:
588		return destroy(reinterpret_cast<IrInstructionHasDecl *>(inst), name);
589		case IrInstructionIdUndeclaredIdent:
590		return destroy(reinterpret_cast<IrInstructionUndeclaredIdent *>(inst), name);
591		case IrInstructionIdAllocaSrc:
592		return destroy(reinterpret_cast<IrInstructionAllocaSrc *>(inst), name);
593		case IrInstructionIdAllocaGen:
594		return destroy(reinterpret_cast<IrInstructionAllocaGen *>(inst), name);
595		case IrInstructionIdEndExpr:
596		return destroy(reinterpret_cast<IrInstructionEndExpr *>(inst), name);
597		case IrInstructionIdUnionInitNamedField:
598		return destroy(reinterpret_cast<IrInstructionUnionInitNamedField *>(inst), name);
599		case IrInstructionIdSuspendBegin:
600		return destroy(reinterpret_cast<IrInstructionSuspendBegin *>(inst), name);
601		case IrInstructionIdSuspendFinish:
602		return destroy(reinterpret_cast<IrInstructionSuspendFinish *>(inst), name);
603		case IrInstructionIdResume:
604		return destroy(reinterpret_cast<IrInstructionResume *>(inst), name);
605		case IrInstructionIdAwaitSrc:
606		return destroy(reinterpret_cast<IrInstructionAwaitSrc *>(inst), name);
607		case IrInstructionIdAwaitGen:
608		return destroy(reinterpret_cast<IrInstructionAwaitGen *>(inst), name);
609		case IrInstructionIdSpillBegin:
610		return destroy(reinterpret_cast<IrInstructionSpillBegin *>(inst), name);
611		case IrInstructionIdSpillEnd:
612		return destroy(reinterpret_cast<IrInstructionSpillEnd *>(inst), name);
613		case IrInstructionIdVectorExtractElem:
614		return destroy(reinterpret_cast<IrInstructionVectorExtractElem *>(inst), name);
	573	case IrInstGenIdReturn:
	574	return destroy(reinterpret_cast<IrInstGenReturn *>(inst), name);
	575	case IrInstGenIdConst:
	576	return destroy(reinterpret_cast<IrInstGenConst *>(inst), name);
	577	case IrInstGenIdBinOp:
	578	return destroy(reinterpret_cast<IrInstGenBinOp *>(inst), name);
	579	case IrInstGenIdCast:
	580	return destroy(reinterpret_cast<IrInstGenCast *>(inst), name);
	581	case IrInstGenIdCall:
	582	return destroy(reinterpret_cast<IrInstGenCall *>(inst), name);
	583	case IrInstGenIdCondBr:
	584	return destroy(reinterpret_cast<IrInstGenCondBr *>(inst), name);
	585	case IrInstGenIdBr:
	586	return destroy(reinterpret_cast<IrInstGenBr *>(inst), name);
	587	case IrInstGenIdPhi:
	588	return destroy(reinterpret_cast<IrInstGenPhi *>(inst), name);
	589	case IrInstGenIdUnreachable:
	590	return destroy(reinterpret_cast<IrInstGenUnreachable *>(inst), name);
	591	case IrInstGenIdElemPtr:
	592	return destroy(reinterpret_cast<IrInstGenElemPtr *>(inst), name);
	593	case IrInstGenIdVarPtr:
	594	return destroy(reinterpret_cast<IrInstGenVarPtr *>(inst), name);
	595	case IrInstGenIdReturnPtr:
	596	return destroy(reinterpret_cast<IrInstGenReturnPtr *>(inst), name);
	597	case IrInstGenIdLoadPtr:
	598	return destroy(reinterpret_cast<IrInstGenLoadPtr *>(inst), name);
	599	case IrInstGenIdStorePtr:
	600	return destroy(reinterpret_cast<IrInstGenStorePtr *>(inst), name);
	601	case IrInstGenIdVectorStoreElem:
	602	return destroy(reinterpret_cast<IrInstGenVectorStoreElem *>(inst), name);
	603	case IrInstGenIdStructFieldPtr:
	604	return destroy(reinterpret_cast<IrInstGenStructFieldPtr *>(inst), name);
	605	case IrInstGenIdUnionFieldPtr:
	606	return destroy(reinterpret_cast<IrInstGenUnionFieldPtr *>(inst), name);
	607	case IrInstGenIdAsm:
	608	return destroy(reinterpret_cast<IrInstGenAsm *>(inst), name);
	609	case IrInstGenIdTestNonNull:
	610	return destroy(reinterpret_cast<IrInstGenTestNonNull *>(inst), name);
	611	case IrInstGenIdOptionalUnwrapPtr:
	612	return destroy(reinterpret_cast<IrInstGenOptionalUnwrapPtr *>(inst), name);
	613	case IrInstGenIdPopCount:
	614	return destroy(reinterpret_cast<IrInstGenPopCount *>(inst), name);
	615	case IrInstGenIdClz:
	616	return destroy(reinterpret_cast<IrInstGenClz *>(inst), name);
	617	case IrInstGenIdCtz:
	618	return destroy(reinterpret_cast<IrInstGenCtz *>(inst), name);
	619	case IrInstGenIdBswap:
	620	return destroy(reinterpret_cast<IrInstGenBswap *>(inst), name);
	621	case IrInstGenIdBitReverse:
	622	return destroy(reinterpret_cast<IrInstGenBitReverse *>(inst), name);
	623	case IrInstGenIdSwitchBr:
	624	return destroy(reinterpret_cast<IrInstGenSwitchBr *>(inst), name);
	625	case IrInstGenIdUnionTag:
	626	return destroy(reinterpret_cast<IrInstGenUnionTag *>(inst), name);
	627	case IrInstGenIdRef:
	628	return destroy(reinterpret_cast<IrInstGenRef *>(inst), name);
	629	case IrInstGenIdErrName:
	630	return destroy(reinterpret_cast<IrInstGenErrName *>(inst), name);
	631	case IrInstGenIdCmpxchg:
	632	return destroy(reinterpret_cast<IrInstGenCmpxchg *>(inst), name);
	633	case IrInstGenIdFence:
	634	return destroy(reinterpret_cast<IrInstGenFence *>(inst), name);
	635	case IrInstGenIdTruncate:
	636	return destroy(reinterpret_cast<IrInstGenTruncate *>(inst), name);
	637	case IrInstGenIdShuffleVector:
	638	return destroy(reinterpret_cast<IrInstGenShuffleVector *>(inst), name);
	639	case IrInstGenIdSplat:
	640	return destroy(reinterpret_cast<IrInstGenSplat *>(inst), name);
	641	case IrInstGenIdBoolNot:
	642	return destroy(reinterpret_cast<IrInstGenBoolNot *>(inst), name);
	643	case IrInstGenIdMemset:
	644	return destroy(reinterpret_cast<IrInstGenMemset *>(inst), name);
	645	case IrInstGenIdMemcpy:
	646	return destroy(reinterpret_cast<IrInstGenMemcpy *>(inst), name);
	647	case IrInstGenIdSlice:
	648	return destroy(reinterpret_cast<IrInstGenSlice *>(inst), name);
	649	case IrInstGenIdBreakpoint:
	650	return destroy(reinterpret_cast<IrInstGenBreakpoint *>(inst), name);
	651	case IrInstGenIdReturnAddress:
	652	return destroy(reinterpret_cast<IrInstGenReturnAddress *>(inst), name);
	653	case IrInstGenIdFrameAddress:
	654	return destroy(reinterpret_cast<IrInstGenFrameAddress *>(inst), name);
	655	case IrInstGenIdFrameHandle:
	656	return destroy(reinterpret_cast<IrInstGenFrameHandle *>(inst), name);
	657	case IrInstGenIdFrameSize:
	658	return destroy(reinterpret_cast<IrInstGenFrameSize *>(inst), name);
	659	case IrInstGenIdOverflowOp:
	660	return destroy(reinterpret_cast<IrInstGenOverflowOp *>(inst), name);
	661	case IrInstGenIdTestErr:
	662	return destroy(reinterpret_cast<IrInstGenTestErr *>(inst), name);
	663	case IrInstGenIdUnwrapErrCode:
	664	return destroy(reinterpret_cast<IrInstGenUnwrapErrCode *>(inst), name);
	665	case IrInstGenIdUnwrapErrPayload:
	666	return destroy(reinterpret_cast<IrInstGenUnwrapErrPayload *>(inst), name);
	667	case IrInstGenIdOptionalWrap:
	668	return destroy(reinterpret_cast<IrInstGenOptionalWrap *>(inst), name);
	669	case IrInstGenIdErrWrapCode:
	670	return destroy(reinterpret_cast<IrInstGenErrWrapCode *>(inst), name);
	671	case IrInstGenIdErrWrapPayload:
	672	return destroy(reinterpret_cast<IrInstGenErrWrapPayload *>(inst), name);
	673	case IrInstGenIdPtrCast:
	674	return destroy(reinterpret_cast<IrInstGenPtrCast *>(inst), name);
	675	case IrInstGenIdBitCast:
	676	return destroy(reinterpret_cast<IrInstGenBitCast *>(inst), name);
	677	case IrInstGenIdWidenOrShorten:
	678	return destroy(reinterpret_cast<IrInstGenWidenOrShorten *>(inst), name);
	679	case IrInstGenIdPtrToInt:
	680	return destroy(reinterpret_cast<IrInstGenPtrToInt *>(inst), name);
	681	case IrInstGenIdIntToPtr:
	682	return destroy(reinterpret_cast<IrInstGenIntToPtr *>(inst), name);
	683	case IrInstGenIdIntToEnum:
	684	return destroy(reinterpret_cast<IrInstGenIntToEnum *>(inst), name);
	685	case IrInstGenIdIntToErr:
	686	return destroy(reinterpret_cast<IrInstGenIntToErr *>(inst), name);
	687	case IrInstGenIdErrToInt:
	688	return destroy(reinterpret_cast<IrInstGenErrToInt *>(inst), name);
	689	case IrInstGenIdTagName:
	690	return destroy(reinterpret_cast<IrInstGenTagName *>(inst), name);
	691	case IrInstGenIdPanic:
	692	return destroy(reinterpret_cast<IrInstGenPanic *>(inst), name);
	693	case IrInstGenIdFieldParentPtr:
	694	return destroy(reinterpret_cast<IrInstGenFieldParentPtr *>(inst), name);
	695	case IrInstGenIdAlignCast:
	696	return destroy(reinterpret_cast<IrInstGenAlignCast *>(inst), name);
	697	case IrInstGenIdErrorReturnTrace:
	698	return destroy(reinterpret_cast<IrInstGenErrorReturnTrace *>(inst), name);
	699	case IrInstGenIdAtomicRmw:
	700	return destroy(reinterpret_cast<IrInstGenAtomicRmw *>(inst), name);
	701	case IrInstGenIdSaveErrRetAddr:
	702	return destroy(reinterpret_cast<IrInstGenSaveErrRetAddr *>(inst), name);
	703	case IrInstGenIdFloatOp:
	704	return destroy(reinterpret_cast<IrInstGenFloatOp *>(inst), name);
	705	case IrInstGenIdMulAdd:
	706	return destroy(reinterpret_cast<IrInstGenMulAdd *>(inst), name);
	707	case IrInstGenIdAtomicLoad:
	708	return destroy(reinterpret_cast<IrInstGenAtomicLoad *>(inst), name);
	709	case IrInstGenIdAtomicStore:
	710	return destroy(reinterpret_cast<IrInstGenAtomicStore *>(inst), name);
	711	case IrInstGenIdDeclVar:
	712	return destroy(reinterpret_cast<IrInstGenDeclVar *>(inst), name);
	713	case IrInstGenIdArrayToVector:
	714	return destroy(reinterpret_cast<IrInstGenArrayToVector *>(inst), name);
	715	case IrInstGenIdVectorToArray:
	716	return destroy(reinterpret_cast<IrInstGenVectorToArray *>(inst), name);
	717	case IrInstGenIdPtrOfArrayToSlice:
	718	return destroy(reinterpret_cast<IrInstGenPtrOfArrayToSlice *>(inst), name);
	719	case IrInstGenIdAssertZero:
	720	return destroy(reinterpret_cast<IrInstGenAssertZero *>(inst), name);
	721	case IrInstGenIdAssertNonNull:
	722	return destroy(reinterpret_cast<IrInstGenAssertNonNull *>(inst), name);
	723	case IrInstGenIdResizeSlice:
	724	return destroy(reinterpret_cast<IrInstGenResizeSlice *>(inst), name);
	725	case IrInstGenIdAlloca:
	726	return destroy(reinterpret_cast<IrInstGenAlloca *>(inst), name);
	727	case IrInstGenIdSuspendBegin:
	728	return destroy(reinterpret_cast<IrInstGenSuspendBegin *>(inst), name);
	729	case IrInstGenIdSuspendFinish:
	730	return destroy(reinterpret_cast<IrInstGenSuspendFinish *>(inst), name);
	731	case IrInstGenIdResume:
	732	return destroy(reinterpret_cast<IrInstGenResume *>(inst), name);
	733	case IrInstGenIdAwait:
	734	return destroy(reinterpret_cast<IrInstGenAwait *>(inst), name);
	735	case IrInstGenIdSpillBegin:
	736	return destroy(reinterpret_cast<IrInstGenSpillBegin *>(inst), name);
	737	case IrInstGenIdSpillEnd:
	738	return destroy(reinterpret_cast<IrInstGenSpillEnd *>(inst), name);
	739	case IrInstGenIdVectorExtractElem:
	740	return destroy(reinterpret_cast<IrInstGenVectorExtractElem *>(inst), name);
	741	case IrInstGenIdBinaryNot:
	742	return destroy(reinterpret_cast<IrInstGenBinaryNot *>(inst), name);
	743	case IrInstGenIdNegation:
	744	return destroy(reinterpret_cast<IrInstGenNegation *>(inst), name);
	745	case IrInstGenIdNegationWrapping:
	746	return destroy(reinterpret_cast<IrInstGenNegationWrapping *>(inst), name);
615	747	}
616	748	zig_unreachable();
617	749	}
...	...	@@ -627,17 +759,17 @@ static void ira_deref(IrAnalyze *ira) {
627	759	assert(ira->ref_count != 0);
628	760
629	761	for (size_t bb_i = 0; bb_i < ira->old_irb.exec->basic_block_list.length; bb_i += 1) {
630		IrBasicBlock *pass1_bb = ira->old_irb.exec->basic_block_list.items[bb_i];
	762	IrBasicBlockSrc *pass1_bb = ira->old_irb.exec->basic_block_list.items[bb_i];
631	763	for (size_t inst_i = 0; inst_i < pass1_bb->instruction_list.length; inst_i += 1) {
632		IrInstruction *pass1_inst = pass1_bb->instruction_list.items[inst_i];
633		destroy_instruction(pass1_inst);
	764	IrInstSrc *pass1_inst = pass1_bb->instruction_list.items[inst_i];
	765	destroy_instruction_src(pass1_inst);
634	766	}
635		destroy(pass1_bb, "IrBasicBlock");
	767	destroy(pass1_bb, "IrBasicBlockSrc");
636	768	}
637	769	ira->old_irb.exec->basic_block_list.deinit();
638	770	ira->old_irb.exec->tld_list.deinit();
639	771	// cannot destroy here because of var->owner_exec
640		//destroy(ira->old_irb.exec, "IrExecutablePass1");
	772	//destroy(ira->old_irb.exec, "IrExecutableSrc");
641	773	ira->src_implicit_return_type_list.deinit();
642	774	ira->resume_stack.deinit();
643	775	ira->exec_context.mem_slot_list.deinit();
...	...	@@ -785,7 +917,7 @@ static bool types_have_same_zig_comptime_repr(CodeGen codegen, ZigType expecte
785	917	zig_unreachable();
786	918	}
787	919
788		static bool ir_should_inline(IrExecutable exec, Scope scope) {
	920	static bool ir_should_inline(IrExecutableSrc exec, Scope scope) {
789	921	if (exec->is_inline)
790	922	return true;
791	923
...	...	@@ -801,29 +933,41 @@ static bool ir_should_inline(IrExecutable exec, Scope scope) {
801	933	return false;
802	934	}
803	935
804		static void ir_instruction_append(IrBasicBlock basic_block, IrInstruction instruction) {
	936	static void ir_instruction_append(IrBasicBlockSrc basic_block, IrInstSrc instruction) {
	937	assert(basic_block);
	938	assert(instruction);
	939	basic_block->instruction_list.append(instruction);
	940	}
	941
	942	static void ir_inst_gen_append(IrBasicBlockGen basic_block, IrInstGen instruction) {
805	943	assert(basic_block);
806	944	assert(instruction);
807	945	basic_block->instruction_list.append(instruction);
808	946	}
809	947
810		static size_t exec_next_debug_id(IrExecutable *exec) {
	948	static size_t exec_next_debug_id(IrExecutableSrc *exec) {
	949	size_t result = exec->next_debug_id;
	950	exec->next_debug_id += 1;
	951	return result;
	952	}
	953
	954	static size_t exec_next_debug_id_gen(IrExecutableGen *exec) {
811	955	size_t result = exec->next_debug_id;
812	956	exec->next_debug_id += 1;
813	957	return result;
814	958	}
815	959
816		static size_t exec_next_mem_slot(IrExecutable *exec) {
	960	static size_t exec_next_mem_slot(IrExecutableSrc *exec) {
817	961	size_t result = exec->mem_slot_count;
818	962	exec->mem_slot_count += 1;
819	963	return result;
820	964	}
821	965
822		static ZigFn exec_fn_entry(IrExecutable exec) {
	966	static ZigFn exec_fn_entry(IrExecutableSrc exec) {
823	967	return exec->fn_entry;
824	968	}
825	969
826		static Buf exec_c_import_buf(IrExecutable exec) {
	970	static Buf exec_c_import_buf(IrExecutableSrc exec) {
827	971	return exec->c_import_buf;
828	972	}
829	973
...	...	@@ -831,28 +975,42 @@ static bool value_is_comptime(ZigValue *const_val) {
831	975	return const_val->special != ConstValSpecialRuntime;
832	976	}
833	977
834		static bool instr_is_comptime(IrInstruction *instruction) {
	978	static bool instr_is_comptime(IrInstGen *instruction) {
835	979	return value_is_comptime(instruction->value);
836	980	}
837	981
838		static bool instr_is_unreachable(IrInstruction *instruction) {
839		return instruction->value->type && instruction->value->type->id == ZigTypeIdUnreachable;
	982	static bool instr_is_unreachable(IrInstSrc *instruction) {
	983	return instruction->is_noreturn;
840	984	}
841	985
842		static void ir_link_new_bb(IrBasicBlock new_bb, IrBasicBlock old_bb) {
843		new_bb->other = old_bb;
844		old_bb->other = new_bb;
	986	static void ir_link_new_bb(IrBasicBlockGen new_bb, IrBasicBlockSrc old_bb) {
	987	new_bb->parent = old_bb;
	988	old_bb->child = new_bb;
845	989	}
846	990
847		static void ir_ref_bb(IrBasicBlock *bb) {
	991	static void ir_ref_bb(IrBasicBlockSrc *bb) {
848	992	bb->ref_count += 1;
849	993	}
850	994
851		static void ir_ref_instruction(IrInstruction instruction, IrBasicBlock cur_bb) {
852		assert(instruction->id != IrInstructionIdInvalid);
853		instruction->ref_count += 1;
854		if (instruction->owner_bb != cur_bb && !instr_is_comptime(instruction))
	995	static void ir_ref_bb_gen(IrBasicBlockGen *bb) {
	996	bb->ref_count += 1;
	997	}
	998
	999	static void ir_ref_instruction(IrInstSrc instruction, IrBasicBlockSrc cur_bb) {
	1000	assert(instruction->id != IrInstSrcIdInvalid);
	1001	instruction->base.ref_count += 1;
	1002	if (instruction->owner_bb != cur_bb && !instr_is_unreachable(instruction)
	1003	&& instruction->id != IrInstSrcIdConst)
	1004	{
855	1005	ir_ref_bb(instruction->owner_bb);
	1006	}
	1007	}
	1008
	1009	static void ir_ref_inst_gen(IrInstGen instruction, IrBasicBlockGen cur_bb) {
	1010	assert(instruction->id != IrInstGenIdInvalid);
	1011	instruction->base.ref_count += 1;
	1012	if (instruction->owner_bb != cur_bb && !instr_is_comptime(instruction))
	1013	ir_ref_bb_gen(instruction->owner_bb);
856	1014	}
857	1015
858	1016	static void ir_ref_var(ZigVar *var) {
...	...	@@ -871,962 +1029,1259 @@ ZigType ir_analyze_type_expr(IrAnalyze ira, Scope scope, AstNode node) {
871	1029	return result->data.x_type;
872	1030	}
873	1031
874		static IrBasicBlock ir_create_basic_block(IrBuilder irb, Scope scope, const char name_hint) {
875		IrBasicBlock *result = allocate<IrBasicBlock>(1, "IrBasicBlock");
	1032	static IrBasicBlockSrc ir_create_basic_block(IrBuilderSrc irb, Scope scope, const char name_hint) {
	1033	IrBasicBlockSrc *result = allocate<IrBasicBlockSrc>(1, "IrBasicBlockSrc");
876	1034	result->scope = scope;
877	1035	result->name_hint = name_hint;
878	1036	result->debug_id = exec_next_debug_id(irb->exec);
879		result->index = SIZE_MAX; // set later
	1037	result->index = UINT32_MAX; // set later
880	1038	return result;
881	1039	}
882	1040
883		static IrBasicBlock ir_build_bb_from(IrBuilder irb, IrBasicBlock *other_bb) {
884		IrBasicBlock *new_bb = ir_create_basic_block(irb, other_bb->scope, other_bb->name_hint);
	1041	static IrBasicBlockGen ir_create_basic_block_gen(IrAnalyze ira, Scope scope, const char name_hint) {
	1042	IrBasicBlockGen *result = allocate<IrBasicBlockGen>(1, "IrBasicBlockGen");
	1043	result->scope = scope;
	1044	result->name_hint = name_hint;
	1045	result->debug_id = exec_next_debug_id_gen(ira->new_irb.exec);
	1046	result->index = UINT32_MAX; // set later
	1047	return result;
	1048	}
	1049
	1050	static IrBasicBlockGen ir_build_bb_from(IrAnalyze ira, IrBasicBlockSrc *other_bb) {
	1051	IrBasicBlockGen *new_bb = ir_create_basic_block_gen(ira, other_bb->scope, other_bb->name_hint);
885	1052	ir_link_new_bb(new_bb, other_bb);
886	1053	return new_bb;
887	1054	}
888	1055
889		static constexpr IrInstructionId ir_instruction_id(IrInstructionDeclVarSrc *) {
890		return IrInstructionIdDeclVarSrc;
	1056	static constexpr IrInstSrcId ir_inst_id(IrInstSrcDeclVar *) {
	1057	return IrInstSrcIdDeclVar;
	1058	}
	1059
	1060	static constexpr IrInstSrcId ir_inst_id(IrInstSrcBr *) {
	1061	return IrInstSrcIdBr;
	1062	}
	1063
	1064	static constexpr IrInstSrcId ir_inst_id(IrInstSrcCondBr *) {
	1065	return IrInstSrcIdCondBr;
	1066	}
	1067
	1068	static constexpr IrInstSrcId ir_inst_id(IrInstSrcSwitchBr *) {
	1069	return IrInstSrcIdSwitchBr;
	1070	}
	1071
	1072	static constexpr IrInstSrcId ir_inst_id(IrInstSrcSwitchVar *) {
	1073	return IrInstSrcIdSwitchVar;
	1074	}
	1075
	1076	static constexpr IrInstSrcId ir_inst_id(IrInstSrcSwitchElseVar *) {
	1077	return IrInstSrcIdSwitchElseVar;
	1078	}
	1079
	1080	static constexpr IrInstSrcId ir_inst_id(IrInstSrcSwitchTarget *) {
	1081	return IrInstSrcIdSwitchTarget;
	1082	}
	1083
	1084	static constexpr IrInstSrcId ir_inst_id(IrInstSrcPhi *) {
	1085	return IrInstSrcIdPhi;
	1086	}
	1087
	1088	static constexpr IrInstSrcId ir_inst_id(IrInstSrcUnOp *) {
	1089	return IrInstSrcIdUnOp;
	1090	}
	1091
	1092	static constexpr IrInstSrcId ir_inst_id(IrInstSrcBinOp *) {
	1093	return IrInstSrcIdBinOp;
	1094	}
	1095
	1096	static constexpr IrInstSrcId ir_inst_id(IrInstSrcMergeErrSets *) {
	1097	return IrInstSrcIdMergeErrSets;
	1098	}
	1099
	1100	static constexpr IrInstSrcId ir_inst_id(IrInstSrcLoadPtr *) {
	1101	return IrInstSrcIdLoadPtr;
	1102	}
	1103
	1104	static constexpr IrInstSrcId ir_inst_id(IrInstSrcStorePtr *) {
	1105	return IrInstSrcIdStorePtr;
	1106	}
	1107
	1108	static constexpr IrInstSrcId ir_inst_id(IrInstSrcFieldPtr *) {
	1109	return IrInstSrcIdFieldPtr;
	1110	}
	1111
	1112	static constexpr IrInstSrcId ir_inst_id(IrInstSrcElemPtr *) {
	1113	return IrInstSrcIdElemPtr;
	1114	}
	1115
	1116	static constexpr IrInstSrcId ir_inst_id(IrInstSrcVarPtr *) {
	1117	return IrInstSrcIdVarPtr;
	1118	}
	1119
	1120	static constexpr IrInstSrcId ir_inst_id(IrInstSrcCall *) {
	1121	return IrInstSrcIdCall;
	1122	}
	1123
	1124	static constexpr IrInstSrcId ir_inst_id(IrInstSrcCallArgs *) {
	1125	return IrInstSrcIdCallArgs;
	1126	}
	1127
	1128	static constexpr IrInstSrcId ir_inst_id(IrInstSrcCallExtra *) {
	1129	return IrInstSrcIdCallExtra;
	1130	}
	1131
	1132	static constexpr IrInstSrcId ir_inst_id(IrInstSrcConst *) {
	1133	return IrInstSrcIdConst;
	1134	}
	1135
	1136	static constexpr IrInstSrcId ir_inst_id(IrInstSrcReturn *) {
	1137	return IrInstSrcIdReturn;
	1138	}
	1139
	1140	static constexpr IrInstSrcId ir_inst_id(IrInstSrcContainerInitList *) {
	1141	return IrInstSrcIdContainerInitList;
	1142	}
	1143
	1144	static constexpr IrInstSrcId ir_inst_id(IrInstSrcContainerInitFields *) {
	1145	return IrInstSrcIdContainerInitFields;
	1146	}
	1147
	1148	static constexpr IrInstSrcId ir_inst_id(IrInstSrcUnreachable *) {
	1149	return IrInstSrcIdUnreachable;
	1150	}
	1151
	1152	static constexpr IrInstSrcId ir_inst_id(IrInstSrcTypeOf *) {
	1153	return IrInstSrcIdTypeOf;
	1154	}
	1155
	1156	static constexpr IrInstSrcId ir_inst_id(IrInstSrcSetCold *) {
	1157	return IrInstSrcIdSetCold;
	1158	}
	1159
	1160	static constexpr IrInstSrcId ir_inst_id(IrInstSrcSetRuntimeSafety *) {
	1161	return IrInstSrcIdSetRuntimeSafety;
	1162	}
	1163
	1164	static constexpr IrInstSrcId ir_inst_id(IrInstSrcSetFloatMode *) {
	1165	return IrInstSrcIdSetFloatMode;
	1166	}
	1167
	1168	static constexpr IrInstSrcId ir_inst_id(IrInstSrcArrayType *) {
	1169	return IrInstSrcIdArrayType;
	1170	}
	1171
	1172	static constexpr IrInstSrcId ir_inst_id(IrInstSrcAnyFrameType *) {
	1173	return IrInstSrcIdAnyFrameType;
	1174	}
	1175
	1176	static constexpr IrInstSrcId ir_inst_id(IrInstSrcSliceType *) {
	1177	return IrInstSrcIdSliceType;
	1178	}
	1179
	1180	static constexpr IrInstSrcId ir_inst_id(IrInstSrcAsm *) {
	1181	return IrInstSrcIdAsm;
	1182	}
	1183
	1184	static constexpr IrInstSrcId ir_inst_id(IrInstSrcSizeOf *) {
	1185	return IrInstSrcIdSizeOf;
	1186	}
	1187
	1188	static constexpr IrInstSrcId ir_inst_id(IrInstSrcTestNonNull *) {
	1189	return IrInstSrcIdTestNonNull;
	1190	}
	1191
	1192	static constexpr IrInstSrcId ir_inst_id(IrInstSrcOptionalUnwrapPtr *) {
	1193	return IrInstSrcIdOptionalUnwrapPtr;
	1194	}
	1195
	1196	static constexpr IrInstSrcId ir_inst_id(IrInstSrcClz *) {
	1197	return IrInstSrcIdClz;
	1198	}
	1199
	1200	static constexpr IrInstSrcId ir_inst_id(IrInstSrcCtz *) {
	1201	return IrInstSrcIdCtz;
	1202	}
	1203
	1204	static constexpr IrInstSrcId ir_inst_id(IrInstSrcPopCount *) {
	1205	return IrInstSrcIdPopCount;
	1206	}
	1207
	1208	static constexpr IrInstSrcId ir_inst_id(IrInstSrcBswap *) {
	1209	return IrInstSrcIdBswap;
	1210	}
	1211
	1212	static constexpr IrInstSrcId ir_inst_id(IrInstSrcBitReverse *) {
	1213	return IrInstSrcIdBitReverse;
	1214	}
	1215
	1216	static constexpr IrInstSrcId ir_inst_id(IrInstSrcImport *) {
	1217	return IrInstSrcIdImport;
	1218	}
	1219
	1220	static constexpr IrInstSrcId ir_inst_id(IrInstSrcCImport *) {
	1221	return IrInstSrcIdCImport;
	1222	}
	1223
	1224	static constexpr IrInstSrcId ir_inst_id(IrInstSrcCInclude *) {
	1225	return IrInstSrcIdCInclude;
	1226	}
	1227
	1228	static constexpr IrInstSrcId ir_inst_id(IrInstSrcCDefine *) {
	1229	return IrInstSrcIdCDefine;
	1230	}
	1231
	1232	static constexpr IrInstSrcId ir_inst_id(IrInstSrcCUndef *) {
	1233	return IrInstSrcIdCUndef;
	1234	}
	1235
	1236	static constexpr IrInstSrcId ir_inst_id(IrInstSrcRef *) {
	1237	return IrInstSrcIdRef;
	1238	}
	1239
	1240	static constexpr IrInstSrcId ir_inst_id(IrInstSrcCompileErr *) {
	1241	return IrInstSrcIdCompileErr;
	1242	}
	1243
	1244	static constexpr IrInstSrcId ir_inst_id(IrInstSrcCompileLog *) {
	1245	return IrInstSrcIdCompileLog;
	1246	}
	1247
	1248	static constexpr IrInstSrcId ir_inst_id(IrInstSrcErrName *) {
	1249	return IrInstSrcIdErrName;
	1250	}
	1251
	1252	static constexpr IrInstSrcId ir_inst_id(IrInstSrcEmbedFile *) {
	1253	return IrInstSrcIdEmbedFile;
	1254	}
	1255
	1256	static constexpr IrInstSrcId ir_inst_id(IrInstSrcCmpxchg *) {
	1257	return IrInstSrcIdCmpxchg;
	1258	}
	1259
	1260	static constexpr IrInstSrcId ir_inst_id(IrInstSrcFence *) {
	1261	return IrInstSrcIdFence;
	1262	}
	1263
	1264	static constexpr IrInstSrcId ir_inst_id(IrInstSrcTruncate *) {
	1265	return IrInstSrcIdTruncate;
	1266	}
	1267
	1268	static constexpr IrInstSrcId ir_inst_id(IrInstSrcIntCast *) {
	1269	return IrInstSrcIdIntCast;
	1270	}
	1271
	1272	static constexpr IrInstSrcId ir_inst_id(IrInstSrcFloatCast *) {
	1273	return IrInstSrcIdFloatCast;
	1274	}
	1275
	1276	static constexpr IrInstSrcId ir_inst_id(IrInstSrcIntToFloat *) {
	1277	return IrInstSrcIdIntToFloat;
	1278	}
	1279
	1280	static constexpr IrInstSrcId ir_inst_id(IrInstSrcFloatToInt *) {
	1281	return IrInstSrcIdFloatToInt;
	1282	}
	1283
	1284	static constexpr IrInstSrcId ir_inst_id(IrInstSrcBoolToInt *) {
	1285	return IrInstSrcIdBoolToInt;
891	1286	}
892	1287
893		static constexpr IrInstructionId ir_instruction_id(IrInstructionDeclVarGen *) {
894		return IrInstructionIdDeclVarGen;
	1288	static constexpr IrInstSrcId ir_inst_id(IrInstSrcIntType *) {
	1289	return IrInstSrcIdIntType;
895	1290	}
896	1291
897		static constexpr IrInstructionId ir_instruction_id(IrInstructionCondBr *) {
898		return IrInstructionIdCondBr;
	1292	static constexpr IrInstSrcId ir_inst_id(IrInstSrcVectorType *) {
	1293	return IrInstSrcIdVectorType;
899	1294	}
900	1295
901		static constexpr IrInstructionId ir_instruction_id(IrInstructionBr *) {
902		return IrInstructionIdBr;
	1296	static constexpr IrInstSrcId ir_inst_id(IrInstSrcShuffleVector *) {
	1297	return IrInstSrcIdShuffleVector;
903	1298	}
904	1299
905		static constexpr IrInstructionId ir_instruction_id(IrInstructionSwitchBr *) {
906		return IrInstructionIdSwitchBr;
	1300	static constexpr IrInstSrcId ir_inst_id(IrInstSrcSplat *) {
	1301	return IrInstSrcIdSplat;
907	1302	}
908	1303
909		static constexpr IrInstructionId ir_instruction_id(IrInstructionSwitchVar *) {
910		return IrInstructionIdSwitchVar;
	1304	static constexpr IrInstSrcId ir_inst_id(IrInstSrcBoolNot *) {
	1305	return IrInstSrcIdBoolNot;
911	1306	}
912	1307
913		static constexpr IrInstructionId ir_instruction_id(IrInstructionSwitchElseVar *) {
914		return IrInstructionIdSwitchElseVar;
	1308	static constexpr IrInstSrcId ir_inst_id(IrInstSrcMemset *) {
	1309	return IrInstSrcIdMemset;
915	1310	}
916	1311
917		static constexpr IrInstructionId ir_instruction_id(IrInstructionSwitchTarget *) {
918		return IrInstructionIdSwitchTarget;
	1312	static constexpr IrInstSrcId ir_inst_id(IrInstSrcMemcpy *) {
	1313	return IrInstSrcIdMemcpy;
919	1314	}
920	1315
921		static constexpr IrInstructionId ir_instruction_id(IrInstructionPhi *) {
922		return IrInstructionIdPhi;
	1316	static constexpr IrInstSrcId ir_inst_id(IrInstSrcSlice *) {
	1317	return IrInstSrcIdSlice;
923	1318	}
924	1319
925		static constexpr IrInstructionId ir_instruction_id(IrInstructionUnOp *) {
926		return IrInstructionIdUnOp;
	1320	static constexpr IrInstSrcId ir_inst_id(IrInstSrcMemberCount *) {
	1321	return IrInstSrcIdMemberCount;
927	1322	}
928	1323
929		static constexpr IrInstructionId ir_instruction_id(IrInstructionBinOp *) {
930		return IrInstructionIdBinOp;
	1324	static constexpr IrInstSrcId ir_inst_id(IrInstSrcMemberType *) {
	1325	return IrInstSrcIdMemberType;
931	1326	}
932	1327
933		static constexpr IrInstructionId ir_instruction_id(IrInstructionMergeErrSets *) {
934		return IrInstructionIdMergeErrSets;
	1328	static constexpr IrInstSrcId ir_inst_id(IrInstSrcMemberName *) {
	1329	return IrInstSrcIdMemberName;
935	1330	}
936	1331
937		static constexpr IrInstructionId ir_instruction_id(IrInstructionExport *) {
938		return IrInstructionIdExport;
	1332	static constexpr IrInstSrcId ir_inst_id(IrInstSrcBreakpoint *) {
	1333	return IrInstSrcIdBreakpoint;
939	1334	}
940	1335
941		static constexpr IrInstructionId ir_instruction_id(IrInstructionLoadPtr *) {
942		return IrInstructionIdLoadPtr;
	1336	static constexpr IrInstSrcId ir_inst_id(IrInstSrcReturnAddress *) {
	1337	return IrInstSrcIdReturnAddress;
943	1338	}
944	1339
945		static constexpr IrInstructionId ir_instruction_id(IrInstructionLoadPtrGen *) {
946		return IrInstructionIdLoadPtrGen;
	1340	static constexpr IrInstSrcId ir_inst_id(IrInstSrcFrameAddress *) {
	1341	return IrInstSrcIdFrameAddress;
947	1342	}
948	1343
949		static constexpr IrInstructionId ir_instruction_id(IrInstructionStorePtr *) {
950		return IrInstructionIdStorePtr;
	1344	static constexpr IrInstSrcId ir_inst_id(IrInstSrcFrameHandle *) {
	1345	return IrInstSrcIdFrameHandle;
951	1346	}
952	1347
953		static constexpr IrInstructionId ir_instruction_id(IrInstructionVectorStoreElem *) {
954		return IrInstructionIdVectorStoreElem;
	1348	static constexpr IrInstSrcId ir_inst_id(IrInstSrcFrameType *) {
	1349	return IrInstSrcIdFrameType;
955	1350	}
956	1351
957		static constexpr IrInstructionId ir_instruction_id(IrInstructionFieldPtr *) {
958		return IrInstructionIdFieldPtr;
	1352	static constexpr IrInstSrcId ir_inst_id(IrInstSrcFrameSize *) {
	1353	return IrInstSrcIdFrameSize;
959	1354	}
960	1355
961		static constexpr IrInstructionId ir_instruction_id(IrInstructionStructFieldPtr *) {
962		return IrInstructionIdStructFieldPtr;
	1356	static constexpr IrInstSrcId ir_inst_id(IrInstSrcAlignOf *) {
	1357	return IrInstSrcIdAlignOf;
963	1358	}
964	1359
965		static constexpr IrInstructionId ir_instruction_id(IrInstructionUnionFieldPtr *) {
966		return IrInstructionIdUnionFieldPtr;
	1360	static constexpr IrInstSrcId ir_inst_id(IrInstSrcOverflowOp *) {
	1361	return IrInstSrcIdOverflowOp;
967	1362	}
968	1363
969		static constexpr IrInstructionId ir_instruction_id(IrInstructionElemPtr *) {
970		return IrInstructionIdElemPtr;
	1364	static constexpr IrInstSrcId ir_inst_id(IrInstSrcTestErr *) {
	1365	return IrInstSrcIdTestErr;
971	1366	}
972	1367
973		static constexpr IrInstructionId ir_instruction_id(IrInstructionVarPtr *) {
974		return IrInstructionIdVarPtr;
	1368	static constexpr IrInstSrcId ir_inst_id(IrInstSrcMulAdd *) {
	1369	return IrInstSrcIdMulAdd;
975	1370	}
976	1371
977		static constexpr IrInstructionId ir_instruction_id(IrInstructionReturnPtr *) {
978		return IrInstructionIdReturnPtr;
	1372	static constexpr IrInstSrcId ir_inst_id(IrInstSrcFloatOp *) {
	1373	return IrInstSrcIdFloatOp;
979	1374	}
980	1375
981		static constexpr IrInstructionId ir_instruction_id(IrInstructionCallSrc *) {
982		return IrInstructionIdCallSrc;
	1376	static constexpr IrInstSrcId ir_inst_id(IrInstSrcUnwrapErrCode *) {
	1377	return IrInstSrcIdUnwrapErrCode;
983	1378	}
984	1379
985		static constexpr IrInstructionId ir_instruction_id(IrInstructionCallSrcArgs *) {
986		return IrInstructionIdCallSrcArgs;
	1380	static constexpr IrInstSrcId ir_inst_id(IrInstSrcUnwrapErrPayload *) {
	1381	return IrInstSrcIdUnwrapErrPayload;
987	1382	}
988	1383
989		static constexpr IrInstructionId ir_instruction_id(IrInstructionCallExtra *) {
990		return IrInstructionIdCallExtra;
	1384	static constexpr IrInstSrcId ir_inst_id(IrInstSrcFnProto *) {
	1385	return IrInstSrcIdFnProto;
991	1386	}
992	1387
993		static constexpr IrInstructionId ir_instruction_id(IrInstructionCallGen *) {
994		return IrInstructionIdCallGen;
	1388	static constexpr IrInstSrcId ir_inst_id(IrInstSrcTestComptime *) {
	1389	return IrInstSrcIdTestComptime;
995	1390	}
996	1391
997		static constexpr IrInstructionId ir_instruction_id(IrInstructionConst *) {
998		return IrInstructionIdConst;
	1392	static constexpr IrInstSrcId ir_inst_id(IrInstSrcPtrCast *) {
	1393	return IrInstSrcIdPtrCast;
999	1394	}
1000	1395
1001		static constexpr IrInstructionId ir_instruction_id(IrInstructionReturn *) {
1002		return IrInstructionIdReturn;
	1396	static constexpr IrInstSrcId ir_inst_id(IrInstSrcBitCast *) {
	1397	return IrInstSrcIdBitCast;
1003	1398	}
1004	1399
1005		static constexpr IrInstructionId ir_instruction_id(IrInstructionCast *) {
1006		return IrInstructionIdCast;
	1400	static constexpr IrInstSrcId ir_inst_id(IrInstSrcIntToPtr *) {
	1401	return IrInstSrcIdIntToPtr;
1007	1402	}
1008	1403
1009		static constexpr IrInstructionId ir_instruction_id(IrInstructionResizeSlice *) {
1010		return IrInstructionIdResizeSlice;
	1404	static constexpr IrInstSrcId ir_inst_id(IrInstSrcPtrToInt *) {
	1405	return IrInstSrcIdPtrToInt;
1011	1406	}
1012	1407
1013		static constexpr IrInstructionId ir_instruction_id(IrInstructionContainerInitList *) {
1014		return IrInstructionIdContainerInitList;
	1408	static constexpr IrInstSrcId ir_inst_id(IrInstSrcIntToEnum *) {
	1409	return IrInstSrcIdIntToEnum;
1015	1410	}
1016	1411
1017		static constexpr IrInstructionId ir_instruction_id(IrInstructionContainerInitFields *) {
1018		return IrInstructionIdContainerInitFields;
	1412	static constexpr IrInstSrcId ir_inst_id(IrInstSrcEnumToInt *) {
	1413	return IrInstSrcIdEnumToInt;
1019	1414	}
1020	1415
1021		static constexpr IrInstructionId ir_instruction_id(IrInstructionUnreachable *) {
1022		return IrInstructionIdUnreachable;
	1416	static constexpr IrInstSrcId ir_inst_id(IrInstSrcIntToErr *) {
	1417	return IrInstSrcIdIntToErr;
1023	1418	}
1024	1419
1025		static constexpr IrInstructionId ir_instruction_id(IrInstructionTypeOf *) {
1026		return IrInstructionIdTypeOf;
	1420	static constexpr IrInstSrcId ir_inst_id(IrInstSrcErrToInt *) {
	1421	return IrInstSrcIdErrToInt;
1027	1422	}
1028	1423
1029		static constexpr IrInstructionId ir_instruction_id(IrInstructionSetCold *) {
1030		return IrInstructionIdSetCold;
	1424	static constexpr IrInstSrcId ir_inst_id(IrInstSrcCheckSwitchProngs *) {
	1425	return IrInstSrcIdCheckSwitchProngs;
1031	1426	}
1032	1427
1033		static constexpr IrInstructionId ir_instruction_id(IrInstructionSetRuntimeSafety *) {
1034		return IrInstructionIdSetRuntimeSafety;
	1428	static constexpr IrInstSrcId ir_inst_id(IrInstSrcCheckStatementIsVoid *) {
	1429	return IrInstSrcIdCheckStatementIsVoid;
1035	1430	}
1036	1431
1037		static constexpr IrInstructionId ir_instruction_id(IrInstructionSetFloatMode *) {
1038		return IrInstructionIdSetFloatMode;
	1432	static constexpr IrInstSrcId ir_inst_id(IrInstSrcTypeName *) {
	1433	return IrInstSrcIdTypeName;
1039	1434	}
1040	1435
1041		static constexpr IrInstructionId ir_instruction_id(IrInstructionArrayType *) {
1042		return IrInstructionIdArrayType;
	1436	static constexpr IrInstSrcId ir_inst_id(IrInstSrcDeclRef *) {
	1437	return IrInstSrcIdDeclRef;
1043	1438	}
1044	1439
1045		static constexpr IrInstructionId ir_instruction_id(IrInstructionAnyFrameType *) {
1046		return IrInstructionIdAnyFrameType;
	1440	static constexpr IrInstSrcId ir_inst_id(IrInstSrcPanic *) {
	1441	return IrInstSrcIdPanic;
1047	1442	}
1048	1443
1049		static constexpr IrInstructionId ir_instruction_id(IrInstructionSliceType *) {
1050		return IrInstructionIdSliceType;
	1444	static constexpr IrInstSrcId ir_inst_id(IrInstSrcTagName *) {
	1445	return IrInstSrcIdTagName;
1051	1446	}
1052	1447
1053		static constexpr IrInstructionId ir_instruction_id(IrInstructionAsmSrc *) {
1054		return IrInstructionIdAsmSrc;
	1448	static constexpr IrInstSrcId ir_inst_id(IrInstSrcTagType *) {
	1449	return IrInstSrcIdTagType;
1055	1450	}
1056	1451
1057		static constexpr IrInstructionId ir_instruction_id(IrInstructionAsmGen *) {
1058		return IrInstructionIdAsmGen;
	1452	static constexpr IrInstSrcId ir_inst_id(IrInstSrcFieldParentPtr *) {
	1453	return IrInstSrcIdFieldParentPtr;
1059	1454	}
1060	1455
1061		static constexpr IrInstructionId ir_instruction_id(IrInstructionSizeOf *) {
1062		return IrInstructionIdSizeOf;
	1456	static constexpr IrInstSrcId ir_inst_id(IrInstSrcByteOffsetOf *) {
	1457	return IrInstSrcIdByteOffsetOf;
1063	1458	}
1064	1459
1065		static constexpr IrInstructionId ir_instruction_id(IrInstructionTestNonNull *) {
1066		return IrInstructionIdTestNonNull;
	1460	static constexpr IrInstSrcId ir_inst_id(IrInstSrcBitOffsetOf *) {
	1461	return IrInstSrcIdBitOffsetOf;
1067	1462	}
1068	1463
1069		static constexpr IrInstructionId ir_instruction_id(IrInstructionOptionalUnwrapPtr *) {
1070		return IrInstructionIdOptionalUnwrapPtr;
	1464	static constexpr IrInstSrcId ir_inst_id(IrInstSrcTypeInfo *) {
	1465	return IrInstSrcIdTypeInfo;
1071	1466	}
1072	1467
1073		static constexpr IrInstructionId ir_instruction_id(IrInstructionClz *) {
1074		return IrInstructionIdClz;
	1468	static constexpr IrInstSrcId ir_inst_id(IrInstSrcType *) {
	1469	return IrInstSrcIdType;
1075	1470	}
1076	1471
1077		static constexpr IrInstructionId ir_instruction_id(IrInstructionCtz *) {
1078		return IrInstructionIdCtz;
	1472	static constexpr IrInstSrcId ir_inst_id(IrInstSrcHasField *) {
	1473	return IrInstSrcIdHasField;
1079	1474	}
1080	1475
1081		static constexpr IrInstructionId ir_instruction_id(IrInstructionPopCount *) {
1082		return IrInstructionIdPopCount;
	1476	static constexpr IrInstSrcId ir_inst_id(IrInstSrcTypeId *) {
	1477	return IrInstSrcIdTypeId;
1083	1478	}
1084	1479
1085		static constexpr IrInstructionId ir_instruction_id(IrInstructionBswap *) {
1086		return IrInstructionIdBswap;
	1480	static constexpr IrInstSrcId ir_inst_id(IrInstSrcSetEvalBranchQuota *) {
	1481	return IrInstSrcIdSetEvalBranchQuota;
1087	1482	}
1088	1483
1089		static constexpr IrInstructionId ir_instruction_id(IrInstructionBitReverse *) {
1090		return IrInstructionIdBitReverse;
	1484	static constexpr IrInstSrcId ir_inst_id(IrInstSrcPtrType *) {
	1485	return IrInstSrcIdPtrType;
1091	1486	}
1092	1487
1093		static constexpr IrInstructionId ir_instruction_id(IrInstructionUnionTag *) {
1094		return IrInstructionIdUnionTag;
	1488	static constexpr IrInstSrcId ir_inst_id(IrInstSrcAlignCast *) {
	1489	return IrInstSrcIdAlignCast;
1095	1490	}
1096	1491
1097		static constexpr IrInstructionId ir_instruction_id(IrInstructionImport *) {
1098		return IrInstructionIdImport;
	1492	static constexpr IrInstSrcId ir_inst_id(IrInstSrcImplicitCast *) {
	1493	return IrInstSrcIdImplicitCast;
1099	1494	}
1100	1495
1101		static constexpr IrInstructionId ir_instruction_id(IrInstructionCImport *) {
1102		return IrInstructionIdCImport;
	1496	static constexpr IrInstSrcId ir_inst_id(IrInstSrcResolveResult *) {
	1497	return IrInstSrcIdResolveResult;
1103	1498	}
1104	1499
1105		static constexpr IrInstructionId ir_instruction_id(IrInstructionCInclude *) {
1106		return IrInstructionIdCInclude;
	1500	static constexpr IrInstSrcId ir_inst_id(IrInstSrcResetResult *) {
	1501	return IrInstSrcIdResetResult;
1107	1502	}
1108	1503
1109		static constexpr IrInstructionId ir_instruction_id(IrInstructionCDefine *) {
1110		return IrInstructionIdCDefine;
	1504	static constexpr IrInstSrcId ir_inst_id(IrInstSrcOpaqueType *) {
	1505	return IrInstSrcIdOpaqueType;
1111	1506	}
1112	1507
1113		static constexpr IrInstructionId ir_instruction_id(IrInstructionCUndef *) {
1114		return IrInstructionIdCUndef;
	1508	static constexpr IrInstSrcId ir_inst_id(IrInstSrcSetAlignStack *) {
	1509	return IrInstSrcIdSetAlignStack;
1115	1510	}
1116	1511
1117		static constexpr IrInstructionId ir_instruction_id(IrInstructionRef *) {
1118		return IrInstructionIdRef;
	1512	static constexpr IrInstSrcId ir_inst_id(IrInstSrcArgType *) {
	1513	return IrInstSrcIdArgType;
1119	1514	}
1120	1515
1121		static constexpr IrInstructionId ir_instruction_id(IrInstructionRefGen *) {
1122		return IrInstructionIdRefGen;
	1516	static constexpr IrInstSrcId ir_inst_id(IrInstSrcExport *) {
	1517	return IrInstSrcIdExport;
1123	1518	}
1124	1519
1125		static constexpr IrInstructionId ir_instruction_id(IrInstructionCompileErr *) {
1126		return IrInstructionIdCompileErr;
	1520	static constexpr IrInstSrcId ir_inst_id(IrInstSrcErrorReturnTrace *) {
	1521	return IrInstSrcIdErrorReturnTrace;
1127	1522	}
1128	1523
1129		static constexpr IrInstructionId ir_instruction_id(IrInstructionCompileLog *) {
1130		return IrInstructionIdCompileLog;
	1524	static constexpr IrInstSrcId ir_inst_id(IrInstSrcErrorUnion *) {
	1525	return IrInstSrcIdErrorUnion;
1131	1526	}
1132	1527
1133		static constexpr IrInstructionId ir_instruction_id(IrInstructionErrName *) {
1134		return IrInstructionIdErrName;
	1528	static constexpr IrInstSrcId ir_inst_id(IrInstSrcAtomicRmw *) {
	1529	return IrInstSrcIdAtomicRmw;
1135	1530	}
1136	1531
1137		static constexpr IrInstructionId ir_instruction_id(IrInstructionEmbedFile *) {
1138		return IrInstructionIdEmbedFile;
	1532	static constexpr IrInstSrcId ir_inst_id(IrInstSrcAtomicLoad *) {
	1533	return IrInstSrcIdAtomicLoad;
1139	1534	}
1140	1535
1141		static constexpr IrInstructionId ir_instruction_id(IrInstructionCmpxchgSrc *) {
1142		return IrInstructionIdCmpxchgSrc;
	1536	static constexpr IrInstSrcId ir_inst_id(IrInstSrcAtomicStore *) {
	1537	return IrInstSrcIdAtomicStore;
1143	1538	}
1144	1539
1145		static constexpr IrInstructionId ir_instruction_id(IrInstructionCmpxchgGen *) {
1146		return IrInstructionIdCmpxchgGen;
	1540	static constexpr IrInstSrcId ir_inst_id(IrInstSrcSaveErrRetAddr *) {
	1541	return IrInstSrcIdSaveErrRetAddr;
1147	1542	}
1148	1543
1149		static constexpr IrInstructionId ir_instruction_id(IrInstructionFence *) {
1150		return IrInstructionIdFence;
	1544	static constexpr IrInstSrcId ir_inst_id(IrInstSrcAddImplicitReturnType *) {
	1545	return IrInstSrcIdAddImplicitReturnType;
1151	1546	}
1152	1547
1153		static constexpr IrInstructionId ir_instruction_id(IrInstructionTruncate *) {
1154		return IrInstructionIdTruncate;
	1548	static constexpr IrInstSrcId ir_inst_id(IrInstSrcErrSetCast *) {
	1549	return IrInstSrcIdErrSetCast;
1155	1550	}
1156	1551
1157		static constexpr IrInstructionId ir_instruction_id(IrInstructionIntCast *) {
1158		return IrInstructionIdIntCast;
	1552	static constexpr IrInstSrcId ir_inst_id(IrInstSrcToBytes *) {
	1553	return IrInstSrcIdToBytes;
1159	1554	}
1160	1555
1161		static constexpr IrInstructionId ir_instruction_id(IrInstructionFloatCast *) {
1162		return IrInstructionIdFloatCast;
	1556	static constexpr IrInstSrcId ir_inst_id(IrInstSrcFromBytes *) {
	1557	return IrInstSrcIdFromBytes;
1163	1558	}
1164	1559
1165		static constexpr IrInstructionId ir_instruction_id(IrInstructionErrSetCast *) {
1166		return IrInstructionIdErrSetCast;
	1560	static constexpr IrInstSrcId ir_inst_id(IrInstSrcCheckRuntimeScope *) {
	1561	return IrInstSrcIdCheckRuntimeScope;
1167	1562	}
1168	1563
1169		static constexpr IrInstructionId ir_instruction_id(IrInstructionToBytes *) {
1170		return IrInstructionIdToBytes;
	1564	static constexpr IrInstSrcId ir_inst_id(IrInstSrcHasDecl *) {
	1565	return IrInstSrcIdHasDecl;
1171	1566	}
1172	1567
1173		static constexpr IrInstructionId ir_instruction_id(IrInstructionFromBytes *) {
1174		return IrInstructionIdFromBytes;
	1568	static constexpr IrInstSrcId ir_inst_id(IrInstSrcUndeclaredIdent *) {
	1569	return IrInstSrcIdUndeclaredIdent;
1175	1570	}
1176	1571
1177		static constexpr IrInstructionId ir_instruction_id(IrInstructionIntToFloat *) {
1178		return IrInstructionIdIntToFloat;
	1572	static constexpr IrInstSrcId ir_inst_id(IrInstSrcAlloca *) {
	1573	return IrInstSrcIdAlloca;
1179	1574	}
1180	1575
1181		static constexpr IrInstructionId ir_instruction_id(IrInstructionFloatToInt *) {
1182		return IrInstructionIdFloatToInt;
	1576	static constexpr IrInstSrcId ir_inst_id(IrInstSrcEndExpr *) {
	1577	return IrInstSrcIdEndExpr;
1183	1578	}
1184	1579
1185		static constexpr IrInstructionId ir_instruction_id(IrInstructionBoolToInt *) {
1186		return IrInstructionIdBoolToInt;
	1580	static constexpr IrInstSrcId ir_inst_id(IrInstSrcUnionInitNamedField *) {
	1581	return IrInstSrcIdUnionInitNamedField;
1187	1582	}
1188	1583
1189		static constexpr IrInstructionId ir_instruction_id(IrInstructionIntType *) {
1190		return IrInstructionIdIntType;
	1584	static constexpr IrInstSrcId ir_inst_id(IrInstSrcSuspendBegin *) {
	1585	return IrInstSrcIdSuspendBegin;
1191	1586	}
1192	1587
1193		static constexpr IrInstructionId ir_instruction_id(IrInstructionVectorType *) {
1194		return IrInstructionIdVectorType;
	1588	static constexpr IrInstSrcId ir_inst_id(IrInstSrcSuspendFinish *) {
	1589	return IrInstSrcIdSuspendFinish;
1195	1590	}
1196	1591
1197		static constexpr IrInstructionId ir_instruction_id(IrInstructionShuffleVector *) {
1198		return IrInstructionIdShuffleVector;
	1592	static constexpr IrInstSrcId ir_inst_id(IrInstSrcAwait *) {
	1593	return IrInstSrcIdAwait;
1199	1594	}
1200	1595
1201		static constexpr IrInstructionId ir_instruction_id(IrInstructionSplatSrc *) {
1202		return IrInstructionIdSplatSrc;
	1596	static constexpr IrInstSrcId ir_inst_id(IrInstSrcResume *) {
	1597	return IrInstSrcIdResume;
1203	1598	}
1204	1599
1205		static constexpr IrInstructionId ir_instruction_id(IrInstructionSplatGen *) {
1206		return IrInstructionIdSplatGen;
	1600	static constexpr IrInstSrcId ir_inst_id(IrInstSrcSpillBegin *) {
	1601	return IrInstSrcIdSpillBegin;
1207	1602	}
1208	1603
1209		static constexpr IrInstructionId ir_instruction_id(IrInstructionBoolNot *) {
1210		return IrInstructionIdBoolNot;
	1604	static constexpr IrInstSrcId ir_inst_id(IrInstSrcSpillEnd *) {
	1605	return IrInstSrcIdSpillEnd;
1211	1606	}
1212	1607
1213		static constexpr IrInstructionId ir_instruction_id(IrInstructionMemset *) {
1214		return IrInstructionIdMemset;
	1608
	1609	static constexpr IrInstGenId ir_inst_id(IrInstGenDeclVar *) {
	1610	return IrInstGenIdDeclVar;
1215	1611	}
1216	1612
1217		static constexpr IrInstructionId ir_instruction_id(IrInstructionMemcpy *) {
1218		return IrInstructionIdMemcpy;
	1613	static constexpr IrInstGenId ir_inst_id(IrInstGenBr *) {
	1614	return IrInstGenIdBr;
1219	1615	}
1220	1616
1221		static constexpr IrInstructionId ir_instruction_id(IrInstructionSliceSrc *) {
1222		return IrInstructionIdSliceSrc;
	1617	static constexpr IrInstGenId ir_inst_id(IrInstGenCondBr *) {
	1618	return IrInstGenIdCondBr;
1223	1619	}
1224	1620
1225		static constexpr IrInstructionId ir_instruction_id(IrInstructionSliceGen *) {
1226		return IrInstructionIdSliceGen;
	1621	static constexpr IrInstGenId ir_inst_id(IrInstGenSwitchBr *) {
	1622	return IrInstGenIdSwitchBr;
1227	1623	}
1228	1624
1229		static constexpr IrInstructionId ir_instruction_id(IrInstructionMemberCount *) {
1230		return IrInstructionIdMemberCount;
	1625	static constexpr IrInstGenId ir_inst_id(IrInstGenPhi *) {
	1626	return IrInstGenIdPhi;
1231	1627	}
1232	1628
1233		static constexpr IrInstructionId ir_instruction_id(IrInstructionMemberType *) {
1234		return IrInstructionIdMemberType;
	1629	static constexpr IrInstGenId ir_inst_id(IrInstGenBinaryNot *) {
	1630	return IrInstGenIdBinaryNot;
1235	1631	}
1236	1632
1237		static constexpr IrInstructionId ir_instruction_id(IrInstructionMemberName *) {
1238		return IrInstructionIdMemberName;
	1633	static constexpr IrInstGenId ir_inst_id(IrInstGenNegation *) {
	1634	return IrInstGenIdNegation;
1239	1635	}
1240	1636
1241		static constexpr IrInstructionId ir_instruction_id(IrInstructionBreakpoint *) {
1242		return IrInstructionIdBreakpoint;
	1637	static constexpr IrInstGenId ir_inst_id(IrInstGenNegationWrapping *) {
	1638	return IrInstGenIdNegationWrapping;
1243	1639	}
1244	1640
1245		static constexpr IrInstructionId ir_instruction_id(IrInstructionReturnAddress *) {
1246		return IrInstructionIdReturnAddress;
	1641	static constexpr IrInstGenId ir_inst_id(IrInstGenBinOp *) {
	1642	return IrInstGenIdBinOp;
1247	1643	}
1248	1644
1249		static constexpr IrInstructionId ir_instruction_id(IrInstructionFrameAddress *) {
1250		return IrInstructionIdFrameAddress;
	1645	static constexpr IrInstGenId ir_inst_id(IrInstGenLoadPtr *) {
	1646	return IrInstGenIdLoadPtr;
1251	1647	}
1252	1648
1253		static constexpr IrInstructionId ir_instruction_id(IrInstructionFrameHandle *) {
1254		return IrInstructionIdFrameHandle;
	1649	static constexpr IrInstGenId ir_inst_id(IrInstGenStorePtr *) {
	1650	return IrInstGenIdStorePtr;
1255	1651	}
1256	1652
1257		static constexpr IrInstructionId ir_instruction_id(IrInstructionFrameType *) {
1258		return IrInstructionIdFrameType;
	1653	static constexpr IrInstGenId ir_inst_id(IrInstGenVectorStoreElem *) {
	1654	return IrInstGenIdVectorStoreElem;
1259	1655	}
1260	1656
1261		static constexpr IrInstructionId ir_instruction_id(IrInstructionFrameSizeSrc *) {
1262		return IrInstructionIdFrameSizeSrc;
	1657	static constexpr IrInstGenId ir_inst_id(IrInstGenStructFieldPtr *) {
	1658	return IrInstGenIdStructFieldPtr;
1263	1659	}
1264	1660
1265		static constexpr IrInstructionId ir_instruction_id(IrInstructionFrameSizeGen *) {
1266		return IrInstructionIdFrameSizeGen;
	1661	static constexpr IrInstGenId ir_inst_id(IrInstGenUnionFieldPtr *) {
	1662	return IrInstGenIdUnionFieldPtr;
1267	1663	}
1268	1664
1269		static constexpr IrInstructionId ir_instruction_id(IrInstructionAlignOf *) {
1270		return IrInstructionIdAlignOf;
	1665	static constexpr IrInstGenId ir_inst_id(IrInstGenElemPtr *) {
	1666	return IrInstGenIdElemPtr;
1271	1667	}
1272	1668
1273		static constexpr IrInstructionId ir_instruction_id(IrInstructionOverflowOp *) {
1274		return IrInstructionIdOverflowOp;
	1669	static constexpr IrInstGenId ir_inst_id(IrInstGenVarPtr *) {
	1670	return IrInstGenIdVarPtr;
1275	1671	}
1276	1672
1277		static constexpr IrInstructionId ir_instruction_id(IrInstructionTestErrSrc *) {
1278		return IrInstructionIdTestErrSrc;
	1673	static constexpr IrInstGenId ir_inst_id(IrInstGenReturnPtr *) {
	1674	return IrInstGenIdReturnPtr;
1279	1675	}
1280	1676
1281		static constexpr IrInstructionId ir_instruction_id(IrInstructionTestErrGen *) {
1282		return IrInstructionIdTestErrGen;
	1677	static constexpr IrInstGenId ir_inst_id(IrInstGenCall *) {
	1678	return IrInstGenIdCall;
1283	1679	}
1284	1680
1285		static constexpr IrInstructionId ir_instruction_id(IrInstructionMulAdd *) {
1286		return IrInstructionIdMulAdd;
	1681	static constexpr IrInstGenId ir_inst_id(IrInstGenReturn *) {
	1682	return IrInstGenIdReturn;
1287	1683	}
1288	1684
1289		static constexpr IrInstructionId ir_instruction_id(IrInstructionUnwrapErrCode *) {
1290		return IrInstructionIdUnwrapErrCode;
	1685	static constexpr IrInstGenId ir_inst_id(IrInstGenCast *) {
	1686	return IrInstGenIdCast;
1291	1687	}
1292	1688
1293		static constexpr IrInstructionId ir_instruction_id(IrInstructionUnwrapErrPayload *) {
1294		return IrInstructionIdUnwrapErrPayload;
	1689	static constexpr IrInstGenId ir_inst_id(IrInstGenResizeSlice *) {
	1690	return IrInstGenIdResizeSlice;
1295	1691	}
1296	1692
1297		static constexpr IrInstructionId ir_instruction_id(IrInstructionOptionalWrap *) {
1298		return IrInstructionIdOptionalWrap;
	1693	static constexpr IrInstGenId ir_inst_id(IrInstGenUnreachable *) {
	1694	return IrInstGenIdUnreachable;
1299	1695	}
1300	1696
1301		static constexpr IrInstructionId ir_instruction_id(IrInstructionErrWrapPayload *) {
1302		return IrInstructionIdErrWrapPayload;
	1697	static constexpr IrInstGenId ir_inst_id(IrInstGenAsm *) {
	1698	return IrInstGenIdAsm;
1303	1699	}
1304	1700
1305		static constexpr IrInstructionId ir_instruction_id(IrInstructionErrWrapCode *) {
1306		return IrInstructionIdErrWrapCode;
	1701	static constexpr IrInstGenId ir_inst_id(IrInstGenTestNonNull *) {
	1702	return IrInstGenIdTestNonNull;
1307	1703	}
1308	1704
1309		static constexpr IrInstructionId ir_instruction_id(IrInstructionFnProto *) {
1310		return IrInstructionIdFnProto;
	1705	static constexpr IrInstGenId ir_inst_id(IrInstGenOptionalUnwrapPtr *) {
	1706	return IrInstGenIdOptionalUnwrapPtr;
1311	1707	}
1312	1708
1313		static constexpr IrInstructionId ir_instruction_id(IrInstructionTestComptime *) {
1314		return IrInstructionIdTestComptime;
	1709	static constexpr IrInstGenId ir_inst_id(IrInstGenOptionalWrap *) {
	1710	return IrInstGenIdOptionalWrap;
1315	1711	}
1316	1712
1317		static constexpr IrInstructionId ir_instruction_id(IrInstructionPtrCastSrc *) {
1318		return IrInstructionIdPtrCastSrc;
	1713	static constexpr IrInstGenId ir_inst_id(IrInstGenUnionTag *) {
	1714	return IrInstGenIdUnionTag;
1319	1715	}
1320	1716
1321		static constexpr IrInstructionId ir_instruction_id(IrInstructionPtrCastGen *) {
1322		return IrInstructionIdPtrCastGen;
	1717	static constexpr IrInstGenId ir_inst_id(IrInstGenClz *) {
	1718	return IrInstGenIdClz;
1323	1719	}
1324	1720
1325		static constexpr IrInstructionId ir_instruction_id(IrInstructionBitCastSrc *) {
1326		return IrInstructionIdBitCastSrc;
	1721	static constexpr IrInstGenId ir_inst_id(IrInstGenCtz *) {
	1722	return IrInstGenIdCtz;
1327	1723	}
1328	1724
1329		static constexpr IrInstructionId ir_instruction_id(IrInstructionBitCastGen *) {
1330		return IrInstructionIdBitCastGen;
	1725	static constexpr IrInstGenId ir_inst_id(IrInstGenPopCount *) {
	1726	return IrInstGenIdPopCount;
1331	1727	}
1332	1728
1333		static constexpr IrInstructionId ir_instruction_id(IrInstructionWidenOrShorten *) {
1334		return IrInstructionIdWidenOrShorten;
	1729	static constexpr IrInstGenId ir_inst_id(IrInstGenBswap *) {
	1730	return IrInstGenIdBswap;
1335	1731	}
1336	1732
1337		static constexpr IrInstructionId ir_instruction_id(IrInstructionPtrToInt *) {
1338		return IrInstructionIdPtrToInt;
	1733	static constexpr IrInstGenId ir_inst_id(IrInstGenBitReverse *) {
	1734	return IrInstGenIdBitReverse;
1339	1735	}
1340	1736
1341		static constexpr IrInstructionId ir_instruction_id(IrInstructionIntToPtr *) {
1342		return IrInstructionIdIntToPtr;
	1737	static constexpr IrInstGenId ir_inst_id(IrInstGenRef *) {
	1738	return IrInstGenIdRef;
1343	1739	}
1344	1740
1345		static constexpr IrInstructionId ir_instruction_id(IrInstructionIntToEnum *) {
1346		return IrInstructionIdIntToEnum;
	1741	static constexpr IrInstGenId ir_inst_id(IrInstGenErrName *) {
	1742	return IrInstGenIdErrName;
1347	1743	}
1348	1744
1349		static constexpr IrInstructionId ir_instruction_id(IrInstructionEnumToInt *) {
1350		return IrInstructionIdEnumToInt;
	1745	static constexpr IrInstGenId ir_inst_id(IrInstGenCmpxchg *) {
	1746	return IrInstGenIdCmpxchg;
1351	1747	}
1352	1748
1353		static constexpr IrInstructionId ir_instruction_id(IrInstructionIntToErr *) {
1354		return IrInstructionIdIntToErr;
	1749	static constexpr IrInstGenId ir_inst_id(IrInstGenFence *) {
	1750	return IrInstGenIdFence;
1355	1751	}
1356	1752
1357		static constexpr IrInstructionId ir_instruction_id(IrInstructionErrToInt *) {
1358		return IrInstructionIdErrToInt;
	1753	static constexpr IrInstGenId ir_inst_id(IrInstGenTruncate *) {
	1754	return IrInstGenIdTruncate;
1359	1755	}
1360	1756
1361		static constexpr IrInstructionId ir_instruction_id(IrInstructionCheckSwitchProngs *) {
1362		return IrInstructionIdCheckSwitchProngs;
	1757	static constexpr IrInstGenId ir_inst_id(IrInstGenShuffleVector *) {
	1758	return IrInstGenIdShuffleVector;
1363	1759	}
1364	1760
1365		static constexpr IrInstructionId ir_instruction_id(IrInstructionCheckStatementIsVoid *) {
1366		return IrInstructionIdCheckStatementIsVoid;
	1761	static constexpr IrInstGenId ir_inst_id(IrInstGenSplat *) {
	1762	return IrInstGenIdSplat;
1367	1763	}
1368	1764
1369		static constexpr IrInstructionId ir_instruction_id(IrInstructionTypeName *) {
1370		return IrInstructionIdTypeName;
	1765	static constexpr IrInstGenId ir_inst_id(IrInstGenBoolNot *) {
	1766	return IrInstGenIdBoolNot;
1371	1767	}
1372	1768
1373		static constexpr IrInstructionId ir_instruction_id(IrInstructionDeclRef *) {
1374		return IrInstructionIdDeclRef;
	1769	static constexpr IrInstGenId ir_inst_id(IrInstGenMemset *) {
	1770	return IrInstGenIdMemset;
1375	1771	}
1376	1772
1377		static constexpr IrInstructionId ir_instruction_id(IrInstructionPanic *) {
1378		return IrInstructionIdPanic;
	1773	static constexpr IrInstGenId ir_inst_id(IrInstGenMemcpy *) {
	1774	return IrInstGenIdMemcpy;
1379	1775	}
1380	1776
1381		static constexpr IrInstructionId ir_instruction_id(IrInstructionTagName *) {
1382		return IrInstructionIdTagName;
	1777	static constexpr IrInstGenId ir_inst_id(IrInstGenSlice *) {
	1778	return IrInstGenIdSlice;
1383	1779	}
1384	1780
1385		static constexpr IrInstructionId ir_instruction_id(IrInstructionTagType *) {
1386		return IrInstructionIdTagType;
	1781	static constexpr IrInstGenId ir_inst_id(IrInstGenBreakpoint *) {
	1782	return IrInstGenIdBreakpoint;
1387	1783	}
1388	1784
1389		static constexpr IrInstructionId ir_instruction_id(IrInstructionFieldParentPtr *) {
1390		return IrInstructionIdFieldParentPtr;
	1785	static constexpr IrInstGenId ir_inst_id(IrInstGenReturnAddress *) {
	1786	return IrInstGenIdReturnAddress;
1391	1787	}
1392	1788
1393		static constexpr IrInstructionId ir_instruction_id(IrInstructionByteOffsetOf *) {
1394		return IrInstructionIdByteOffsetOf;
	1789	static constexpr IrInstGenId ir_inst_id(IrInstGenFrameAddress *) {
	1790	return IrInstGenIdFrameAddress;
1395	1791	}
1396	1792
1397		static constexpr IrInstructionId ir_instruction_id(IrInstructionBitOffsetOf *) {
1398		return IrInstructionIdBitOffsetOf;
	1793	static constexpr IrInstGenId ir_inst_id(IrInstGenFrameHandle *) {
	1794	return IrInstGenIdFrameHandle;
1399	1795	}
1400	1796
1401		static constexpr IrInstructionId ir_instruction_id(IrInstructionTypeInfo *) {
1402		return IrInstructionIdTypeInfo;
	1797	static constexpr IrInstGenId ir_inst_id(IrInstGenFrameSize *) {
	1798	return IrInstGenIdFrameSize;
1403	1799	}
1404	1800
1405		static constexpr IrInstructionId ir_instruction_id(IrInstructionType *) {
1406		return IrInstructionIdType;
	1801	static constexpr IrInstGenId ir_inst_id(IrInstGenOverflowOp *) {
	1802	return IrInstGenIdOverflowOp;
1407	1803	}
1408	1804
1409		static constexpr IrInstructionId ir_instruction_id(IrInstructionHasField *) {
1410		return IrInstructionIdHasField;
	1805	static constexpr IrInstGenId ir_inst_id(IrInstGenTestErr *) {
	1806	return IrInstGenIdTestErr;
1411	1807	}
1412	1808
1413		static constexpr IrInstructionId ir_instruction_id(IrInstructionTypeId *) {
1414		return IrInstructionIdTypeId;
	1809	static constexpr IrInstGenId ir_inst_id(IrInstGenMulAdd *) {
	1810	return IrInstGenIdMulAdd;
1415	1811	}
1416	1812
1417		static constexpr IrInstructionId ir_instruction_id(IrInstructionSetEvalBranchQuota *) {
1418		return IrInstructionIdSetEvalBranchQuota;
	1813	static constexpr IrInstGenId ir_inst_id(IrInstGenFloatOp *) {
	1814	return IrInstGenIdFloatOp;
1419	1815	}
1420	1816
1421		static constexpr IrInstructionId ir_instruction_id(IrInstructionPtrType *) {
1422		return IrInstructionIdPtrType;
	1817	static constexpr IrInstGenId ir_inst_id(IrInstGenUnwrapErrCode *) {
	1818	return IrInstGenIdUnwrapErrCode;
1423	1819	}
1424	1820
1425		static constexpr IrInstructionId ir_instruction_id(IrInstructionAlignCast *) {
1426		return IrInstructionIdAlignCast;
	1821	static constexpr IrInstGenId ir_inst_id(IrInstGenUnwrapErrPayload *) {
	1822	return IrInstGenIdUnwrapErrPayload;
1427	1823	}
1428	1824
1429		static constexpr IrInstructionId ir_instruction_id(IrInstructionImplicitCast *) {
1430		return IrInstructionIdImplicitCast;
	1825	static constexpr IrInstGenId ir_inst_id(IrInstGenErrWrapCode *) {
	1826	return IrInstGenIdErrWrapCode;
1431	1827	}
1432	1828
1433		static constexpr IrInstructionId ir_instruction_id(IrInstructionResolveResult *) {
1434		return IrInstructionIdResolveResult;
	1829	static constexpr IrInstGenId ir_inst_id(IrInstGenErrWrapPayload *) {
	1830	return IrInstGenIdErrWrapPayload;
1435	1831	}
1436	1832
1437		static constexpr IrInstructionId ir_instruction_id(IrInstructionResetResult *) {
1438		return IrInstructionIdResetResult;
	1833	static constexpr IrInstGenId ir_inst_id(IrInstGenPtrCast *) {
	1834	return IrInstGenIdPtrCast;
1439	1835	}
1440	1836
1441		static constexpr IrInstructionId ir_instruction_id(IrInstructionPtrOfArrayToSlice *) {
1442		return IrInstructionIdPtrOfArrayToSlice;
	1837	static constexpr IrInstGenId ir_inst_id(IrInstGenBitCast *) {
	1838	return IrInstGenIdBitCast;
1443	1839	}
1444	1840
1445		static constexpr IrInstructionId ir_instruction_id(IrInstructionOpaqueType *) {
1446		return IrInstructionIdOpaqueType;
	1841	static constexpr IrInstGenId ir_inst_id(IrInstGenWidenOrShorten *) {
	1842	return IrInstGenIdWidenOrShorten;
1447	1843	}
1448	1844
1449		static constexpr IrInstructionId ir_instruction_id(IrInstructionSetAlignStack *) {
1450		return IrInstructionIdSetAlignStack;
	1845	static constexpr IrInstGenId ir_inst_id(IrInstGenIntToPtr *) {
	1846	return IrInstGenIdIntToPtr;
1451	1847	}
1452	1848
1453		static constexpr IrInstructionId ir_instruction_id(IrInstructionArgType *) {
1454		return IrInstructionIdArgType;
	1849	static constexpr IrInstGenId ir_inst_id(IrInstGenPtrToInt *) {
	1850	return IrInstGenIdPtrToInt;
1455	1851	}
1456	1852
1457		static constexpr IrInstructionId ir_instruction_id(IrInstructionErrorReturnTrace *) {
1458		return IrInstructionIdErrorReturnTrace;
	1853	static constexpr IrInstGenId ir_inst_id(IrInstGenIntToEnum *) {
	1854	return IrInstGenIdIntToEnum;
1459	1855	}
1460	1856
1461		static constexpr IrInstructionId ir_instruction_id(IrInstructionErrorUnion *) {
1462		return IrInstructionIdErrorUnion;
	1857	static constexpr IrInstGenId ir_inst_id(IrInstGenIntToErr *) {
	1858	return IrInstGenIdIntToErr;
1463	1859	}
1464	1860
1465		static constexpr IrInstructionId ir_instruction_id(IrInstructionAtomicRmw *) {
1466		return IrInstructionIdAtomicRmw;
	1861	static constexpr IrInstGenId ir_inst_id(IrInstGenErrToInt *) {
	1862	return IrInstGenIdErrToInt;
1467	1863	}
1468	1864
1469		static constexpr IrInstructionId ir_instruction_id(IrInstructionAtomicLoad *) {
1470		return IrInstructionIdAtomicLoad;
	1865	static constexpr IrInstGenId ir_inst_id(IrInstGenPanic *) {
	1866	return IrInstGenIdPanic;
1471	1867	}
1472	1868
1473		static constexpr IrInstructionId ir_instruction_id(IrInstructionAtomicStore *) {
1474		return IrInstructionIdAtomicStore;
	1869	static constexpr IrInstGenId ir_inst_id(IrInstGenTagName *) {
	1870	return IrInstGenIdTagName;
1475	1871	}
1476	1872
1477		static constexpr IrInstructionId ir_instruction_id(IrInstructionSaveErrRetAddr *) {
1478		return IrInstructionIdSaveErrRetAddr;
	1873	static constexpr IrInstGenId ir_inst_id(IrInstGenFieldParentPtr *) {
	1874	return IrInstGenIdFieldParentPtr;
1479	1875	}
1480	1876
1481		static constexpr IrInstructionId ir_instruction_id(IrInstructionAddImplicitReturnType *) {
1482		return IrInstructionIdAddImplicitReturnType;
	1877	static constexpr IrInstGenId ir_inst_id(IrInstGenAlignCast *) {
	1878	return IrInstGenIdAlignCast;
1483	1879	}
1484	1880
1485		static constexpr IrInstructionId ir_instruction_id(IrInstructionFloatOp *) {
1486		return IrInstructionIdFloatOp;
	1881	static constexpr IrInstGenId ir_inst_id(IrInstGenErrorReturnTrace *) {
	1882	return IrInstGenIdErrorReturnTrace;
1487	1883	}
1488	1884
1489		static constexpr IrInstructionId ir_instruction_id(IrInstructionCheckRuntimeScope *) {
1490		return IrInstructionIdCheckRuntimeScope;
	1885	static constexpr IrInstGenId ir_inst_id(IrInstGenAtomicRmw *) {
	1886	return IrInstGenIdAtomicRmw;
1491	1887	}
1492	1888
1493		static constexpr IrInstructionId ir_instruction_id(IrInstructionVectorToArray *) {
1494		return IrInstructionIdVectorToArray;
	1889	static constexpr IrInstGenId ir_inst_id(IrInstGenAtomicLoad *) {
	1890	return IrInstGenIdAtomicLoad;
1495	1891	}
1496	1892
1497		static constexpr IrInstructionId ir_instruction_id(IrInstructionArrayToVector *) {
1498		return IrInstructionIdArrayToVector;
	1893	static constexpr IrInstGenId ir_inst_id(IrInstGenAtomicStore *) {
	1894	return IrInstGenIdAtomicStore;
1499	1895	}
1500	1896
1501		static constexpr IrInstructionId ir_instruction_id(IrInstructionAssertZero *) {
1502		return IrInstructionIdAssertZero;
	1897	static constexpr IrInstGenId ir_inst_id(IrInstGenSaveErrRetAddr *) {
	1898	return IrInstGenIdSaveErrRetAddr;
1503	1899	}
1504	1900
1505		static constexpr IrInstructionId ir_instruction_id(IrInstructionAssertNonNull *) {
1506		return IrInstructionIdAssertNonNull;
	1901	static constexpr IrInstGenId ir_inst_id(IrInstGenVectorToArray *) {
	1902	return IrInstGenIdVectorToArray;
1507	1903	}
1508	1904
1509		static constexpr IrInstructionId ir_instruction_id(IrInstructionHasDecl *) {
1510		return IrInstructionIdHasDecl;
	1905	static constexpr IrInstGenId ir_inst_id(IrInstGenArrayToVector *) {
	1906	return IrInstGenIdArrayToVector;
1511	1907	}
1512	1908
1513		static constexpr IrInstructionId ir_instruction_id(IrInstructionUndeclaredIdent *) {
1514		return IrInstructionIdUndeclaredIdent;
	1909	static constexpr IrInstGenId ir_inst_id(IrInstGenAssertZero *) {
	1910	return IrInstGenIdAssertZero;
1515	1911	}
1516	1912
1517		static constexpr IrInstructionId ir_instruction_id(IrInstructionAllocaSrc *) {
1518		return IrInstructionIdAllocaSrc;
	1913	static constexpr IrInstGenId ir_inst_id(IrInstGenAssertNonNull *) {
	1914	return IrInstGenIdAssertNonNull;
1519	1915	}
1520	1916
1521		static constexpr IrInstructionId ir_instruction_id(IrInstructionAllocaGen *) {
1522		return IrInstructionIdAllocaGen;
	1917	static constexpr IrInstGenId ir_inst_id(IrInstGenPtrOfArrayToSlice *) {
	1918	return IrInstGenIdPtrOfArrayToSlice;
1523	1919	}
1524	1920
1525		static constexpr IrInstructionId ir_instruction_id(IrInstructionEndExpr *) {
1526		return IrInstructionIdEndExpr;
	1921	static constexpr IrInstGenId ir_inst_id(IrInstGenSuspendBegin *) {
	1922	return IrInstGenIdSuspendBegin;
1527	1923	}
1528	1924
1529		static constexpr IrInstructionId ir_instruction_id(IrInstructionUnionInitNamedField *) {
1530		return IrInstructionIdUnionInitNamedField;
	1925	static constexpr IrInstGenId ir_inst_id(IrInstGenSuspendFinish *) {
	1926	return IrInstGenIdSuspendFinish;
1531	1927	}
1532	1928
1533		static constexpr IrInstructionId ir_instruction_id(IrInstructionSuspendBegin *) {
1534		return IrInstructionIdSuspendBegin;
	1929	static constexpr IrInstGenId ir_inst_id(IrInstGenAwait *) {
	1930	return IrInstGenIdAwait;
1535	1931	}
1536	1932
1537		static constexpr IrInstructionId ir_instruction_id(IrInstructionSuspendFinish *) {
1538		return IrInstructionIdSuspendFinish;
	1933	static constexpr IrInstGenId ir_inst_id(IrInstGenResume *) {
	1934	return IrInstGenIdResume;
1539	1935	}
1540	1936
1541		static constexpr IrInstructionId ir_instruction_id(IrInstructionAwaitSrc *) {
1542		return IrInstructionIdAwaitSrc;
	1937	static constexpr IrInstGenId ir_inst_id(IrInstGenSpillBegin *) {
	1938	return IrInstGenIdSpillBegin;
1543	1939	}
1544	1940
1545		static constexpr IrInstructionId ir_instruction_id(IrInstructionAwaitGen *) {
1546		return IrInstructionIdAwaitGen;
	1941	static constexpr IrInstGenId ir_inst_id(IrInstGenSpillEnd *) {
	1942	return IrInstGenIdSpillEnd;
1547	1943	}
1548	1944
1549		static constexpr IrInstructionId ir_instruction_id(IrInstructionResume *) {
1550		return IrInstructionIdResume;
	1945	static constexpr IrInstGenId ir_inst_id(IrInstGenVectorExtractElem *) {
	1946	return IrInstGenIdVectorExtractElem;
1551	1947	}
1552	1948
1553		static constexpr IrInstructionId ir_instruction_id(IrInstructionSpillBegin *) {
1554		return IrInstructionIdSpillBegin;
	1949	static constexpr IrInstGenId ir_inst_id(IrInstGenAlloca *) {
	1950	return IrInstGenIdAlloca;
1555	1951	}
1556	1952
1557		static constexpr IrInstructionId ir_instruction_id(IrInstructionSpillEnd *) {
1558		return IrInstructionIdSpillEnd;
	1953	static constexpr IrInstGenId ir_inst_id(IrInstGenConst *) {
	1954	return IrInstGenIdConst;
1559	1955	}
1560	1956
1561		static constexpr IrInstructionId ir_instruction_id(IrInstructionVectorExtractElem *) {
1562		return IrInstructionIdVectorExtractElem;
	1957	template<typename T>
	1958	static T ir_create_instruction(IrBuilderSrc irb, Scope scope, AstNode source_node) {
	1959	const char *name = nullptr;
	1960	#ifdef ZIG_ENABLE_MEM_PROFILE
	1961	T *dummy = nullptr;
	1962	name = ir_inst_src_type_str(ir_inst_id(dummy));
	1963	#endif
	1964	T *special_instruction = allocate<T>(1, name);
	1965	special_instruction->base.id = ir_inst_id(special_instruction);
	1966	special_instruction->base.base.scope = scope;
	1967	special_instruction->base.base.source_node = source_node;
	1968	special_instruction->base.base.debug_id = exec_next_debug_id(irb->exec);
	1969	special_instruction->base.owner_bb = irb->current_basic_block;
	1970	return special_instruction;
1563	1971	}
1564	1972
1565	1973	template<typename T>
1566		static T ir_create_instruction(IrBuilder irb, Scope scope, AstNode source_node) {
	1974	static T ir_create_inst_gen(IrBuilderGen irb, Scope scope, AstNode source_node) {
1567	1975	const char *name = nullptr;
1568	1976	#ifdef ZIG_ENABLE_MEM_PROFILE
1569	1977	T *dummy = nullptr;
1570		name = ir_instruction_type_str(ir_instruction_id(dummy));
	1978	name = ir_inst_gen_type_str(ir_inst_id(dummy));
1571	1979	#endif
1572	1980	T *special_instruction = allocate<T>(1, name);
1573		special_instruction->base.id = ir_instruction_id(special_instruction);
1574		special_instruction->base.scope = scope;
1575		special_instruction->base.source_node = source_node;
1576		special_instruction->base.debug_id = exec_next_debug_id(irb->exec);
	1981	special_instruction->base.id = ir_inst_id(special_instruction);
	1982	special_instruction->base.base.scope = scope;
	1983	special_instruction->base.base.source_node = source_node;
	1984	special_instruction->base.base.debug_id = exec_next_debug_id_gen(irb->exec);
1577	1985	special_instruction->base.owner_bb = irb->current_basic_block;
1578	1986	special_instruction->base.value = allocate<ZigValue>(1, "ZigValue");
1579	1987	return special_instruction;
1580	1988	}
1581	1989
1582	1990	template<typename T>
1583		static T ir_create_instruction_noval(IrBuilder irb, Scope scope, AstNode source_node) {
	1991	static T ir_create_inst_noval(IrBuilderGen irb, Scope scope, AstNode source_node) {
1584	1992	const char *name = nullptr;
1585	1993	#ifdef ZIG_ENABLE_MEM_PROFILE
1586	1994	T *dummy = nullptr;
1587		name = ir_instruction_type_str(ir_instruction_id(dummy));
	1995	name = ir_inst_gen_type_str(ir_inst_id(dummy));
1588	1996	#endif
1589	1997	T *special_instruction = allocate<T>(1, name);
1590		special_instruction->base.id = ir_instruction_id(special_instruction);
1591		special_instruction->base.scope = scope;
1592		special_instruction->base.source_node = source_node;
1593		special_instruction->base.debug_id = exec_next_debug_id(irb->exec);
	1998	special_instruction->base.id = ir_inst_id(special_instruction);
	1999	special_instruction->base.base.scope = scope;
	2000	special_instruction->base.base.source_node = source_node;
	2001	special_instruction->base.base.debug_id = exec_next_debug_id_gen(irb->exec);
1594	2002	special_instruction->base.owner_bb = irb->current_basic_block;
1595	2003	return special_instruction;
1596	2004	}
1597	2005
1598	2006	template<typename T>
1599		static T ir_build_instruction(IrBuilder irb, Scope scope, AstNode source_node) {
	2007	static T ir_build_instruction(IrBuilderSrc irb, Scope scope, AstNode source_node) {
1600	2008	T *special_instruction = ir_create_instruction<T>(irb, scope, source_node);
1601	2009	ir_instruction_append(irb->current_basic_block, &special_instruction->base);
1602	2010	return special_instruction;
1603	2011	}
1604	2012
1605		static IrInstruction ir_build_cast(IrBuilder irb, Scope scope, AstNode source_node, ZigType *dest_type,
1606		IrInstruction *value, CastOp cast_op)
	2013	template<typename T>
	2014	static T ir_build_inst_gen(IrBuilderGen irb, Scope scope, AstNode source_node) {
	2015	T *special_instruction = ir_create_inst_gen<T>(irb, scope, source_node);
	2016	ir_inst_gen_append(irb->current_basic_block, &special_instruction->base);
	2017	return special_instruction;
	2018	}
	2019
	2020	template<typename T>
	2021	static T ir_build_inst_noreturn(IrBuilderGen irb, Scope scope, AstNode source_node) {
	2022	T *special_instruction = ir_create_inst_noval<T>(irb, scope, source_node);
	2023	special_instruction->base.value = irb->codegen->intern.for_unreachable();
	2024	ir_inst_gen_append(irb->current_basic_block, &special_instruction->base);
	2025	return special_instruction;
	2026	}
	2027
	2028	template<typename T>
	2029	static T ir_build_inst_void(IrBuilderGen irb, Scope scope, AstNode source_node) {
	2030	T *special_instruction = ir_create_inst_noval<T>(irb, scope, source_node);
	2031	special_instruction->base.value = irb->codegen->intern.for_void();
	2032	ir_inst_gen_append(irb->current_basic_block, &special_instruction->base);
	2033	return special_instruction;
	2034	}
	2035
	2036	IrInstGen ir_create_alloca(CodeGen g, Scope scope, AstNode source_node, ZigFn *fn,
	2037	ZigType var_type, const char name_hint)
1607	2038	{
1608		IrInstructionCast *cast_instruction = ir_build_instruction<IrInstructionCast>(irb, scope, source_node);
1609		cast_instruction->dest_type = dest_type;
1610		cast_instruction->value = value;
1611		cast_instruction->cast_op = cast_op;
	2039	IrInstGenAlloca *alloca_gen = allocate<IrInstGenAlloca>(1);
	2040	alloca_gen->base.id = IrInstGenIdAlloca;
	2041	alloca_gen->base.base.source_node = source_node;
	2042	alloca_gen->base.base.scope = scope;
	2043	alloca_gen->base.value = allocate<ZigValue>(1, "ZigValue");
	2044	alloca_gen->base.value->type = get_pointer_to_type(g, var_type, false);
	2045	alloca_gen->base.base.ref_count = 1;
	2046	alloca_gen->name_hint = name_hint;
	2047	fn->alloca_gen_list.append(alloca_gen);
	2048	return &alloca_gen->base;
	2049	}
1612	2050
1613		ir_ref_instruction(value, irb->current_basic_block);
	2051	static IrInstGen ir_build_cast(IrAnalyze ira, IrInst source_instr,ZigType dest_type,
	2052	IrInstGen *value, CastOp cast_op)
	2053	{
	2054	IrInstGenCast *inst = ir_build_inst_gen<IrInstGenCast>(&ira->new_irb, source_instr->scope, source_instr->source_node);
	2055	inst->base.value->type = dest_type;
	2056	inst->value = value;
	2057	inst->cast_op = cast_op;
1614	2058
1615		return &cast_instruction->base;
	2059	ir_ref_inst_gen(value, ira->new_irb.current_basic_block);
	2060
	2061	return &inst->base;
1616	2062	}
1617	2063
1618		static IrInstruction ir_build_cond_br(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *condition,
1619		IrBasicBlock then_block, IrBasicBlock else_block, IrInstruction *is_comptime)
	2064	static IrInstSrc ir_build_cond_br(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *condition,
	2065	IrBasicBlockSrc then_block, IrBasicBlockSrc else_block, IrInstSrc *is_comptime)
1620	2066	{
1621		IrInstructionCondBr *cond_br_instruction = ir_build_instruction<IrInstructionCondBr>(irb, scope, source_node);
1622		cond_br_instruction->base.value->type = irb->codegen->builtin_types.entry_unreachable;
1623		cond_br_instruction->base.value->special = ConstValSpecialStatic;
1624		cond_br_instruction->condition = condition;
1625		cond_br_instruction->then_block = then_block;
1626		cond_br_instruction->else_block = else_block;
1627		cond_br_instruction->is_comptime = is_comptime;
	2067	IrInstSrcCondBr *inst = ir_build_instruction<IrInstSrcCondBr>(irb, scope, source_node);
	2068	inst->base.is_noreturn = true;
	2069	inst->condition = condition;
	2070	inst->then_block = then_block;
	2071	inst->else_block = else_block;
	2072	inst->is_comptime = is_comptime;
1628	2073
1629	2074	ir_ref_instruction(condition, irb->current_basic_block);
1630	2075	ir_ref_bb(then_block);
1631	2076	ir_ref_bb(else_block);
1632	2077	if (is_comptime != nullptr) ir_ref_instruction(is_comptime, irb->current_basic_block);
1633	2078
1634		return &cond_br_instruction->base;
	2079	return &inst->base;
1635	2080	}
1636	2081
1637		static IrInstruction ir_build_return(IrBuilder irb, Scope scope, AstNode source_node,
1638		IrInstruction *operand)
	2082	static IrInstGen ir_build_cond_br_gen(IrAnalyze ira, IrInst source_instr, IrInstGen condition,
	2083	IrBasicBlockGen then_block, IrBasicBlockGen else_block)
1639	2084	{
1640		IrInstructionReturn *return_instruction = ir_build_instruction<IrInstructionReturn>(irb, scope, source_node);
1641		return_instruction->base.value->type = irb->codegen->builtin_types.entry_unreachable;
1642		return_instruction->base.value->special = ConstValSpecialStatic;
1643		return_instruction->operand = operand;
	2085	IrInstGenCondBr *inst = ir_build_inst_noreturn<IrInstGenCondBr>(&ira->new_irb, source_instr->scope, source_instr->source_node);
	2086	inst->condition = condition;
	2087	inst->then_block = then_block;
	2088	inst->else_block = else_block;
	2089
	2090	ir_ref_inst_gen(condition, ira->new_irb.current_basic_block);
	2091	ir_ref_bb_gen(then_block);
	2092	ir_ref_bb_gen(else_block);
	2093
	2094	return &inst->base;
	2095	}
	2096
	2097	static IrInstSrc ir_build_return_src(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *operand) {
	2098	IrInstSrcReturn *inst = ir_build_instruction<IrInstSrcReturn>(irb, scope, source_node);
	2099	inst->base.is_noreturn = true;
	2100	inst->operand = operand;
1644	2101
1645	2102	if (operand != nullptr) ir_ref_instruction(operand, irb->current_basic_block);
1646	2103
1647		return &return_instruction->base;
	2104	return &inst->base;
	2105	}
	2106
	2107	static IrInstGen ir_build_return_gen(IrAnalyze ira, IrInst source_inst, IrInstGen operand) {
	2108	IrInstGenReturn *inst = ir_build_inst_noreturn<IrInstGenReturn>(&ira->new_irb,
	2109	source_inst->scope, source_inst->source_node);
	2110	inst->operand = operand;
	2111
	2112	if (operand != nullptr) ir_ref_inst_gen(operand, ira->new_irb.current_basic_block);
	2113
	2114	return &inst->base;
1648	2115	}
1649	2116
1650		static IrInstruction ir_build_const_void(IrBuilder irb, Scope scope, AstNode source_node) {
1651		IrInstructionConst *const_instruction = ir_create_instruction_noval<IrInstructionConst>(irb, scope, source_node);
	2117	static IrInstSrc ir_build_const_void(IrBuilderSrc irb, Scope scope, AstNode source_node) {
	2118	IrInstSrcConst *const_instruction = ir_create_instruction<IrInstSrcConst>(irb, scope, source_node);
1652	2119	ir_instruction_append(irb->current_basic_block, &const_instruction->base);
1653		const_instruction->base.value = irb->codegen->intern.for_void();
	2120	const_instruction->value = irb->codegen->intern.for_void();
1654	2121	return &const_instruction->base;
1655	2122	}
1656	2123
1657		static IrInstruction ir_build_const_undefined(IrBuilder irb, Scope scope, AstNode source_node) {
1658		IrInstructionConst *const_instruction = ir_create_instruction_noval<IrInstructionConst>(irb, scope, source_node);
	2124	static IrInstSrc ir_build_const_undefined(IrBuilderSrc irb, Scope scope, AstNode source_node) {
	2125	IrInstSrcConst *const_instruction = ir_create_instruction<IrInstSrcConst>(irb, scope, source_node);
1659	2126	ir_instruction_append(irb->current_basic_block, &const_instruction->base);
1660		const_instruction->base.value = irb->codegen->intern.for_undefined();
	2127	const_instruction->value = irb->codegen->intern.for_undefined();
1661	2128	return &const_instruction->base;
1662	2129	}
1663	2130
1664		static IrInstruction ir_build_const_uint(IrBuilder irb, Scope scope, AstNode source_node, uint64_t value) {
1665		IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, scope, source_node);
1666		const_instruction->base.value->type = irb->codegen->builtin_types.entry_num_lit_int;
1667		const_instruction->base.value->special = ConstValSpecialStatic;
1668		bigint_init_unsigned(&const_instruction->base.value->data.x_bigint, value);
	2131	static IrInstSrc ir_build_const_uint(IrBuilderSrc irb, Scope scope, AstNode source_node, uint64_t value) {
	2132	IrInstSrcConst *const_instruction = ir_build_instruction<IrInstSrcConst>(irb, scope, source_node);
	2133	const_instruction->value = create_const_vals(1);
	2134	const_instruction->value->type = irb->codegen->builtin_types.entry_num_lit_int;
	2135	const_instruction->value->special = ConstValSpecialStatic;
	2136	bigint_init_unsigned(&const_instruction->value->data.x_bigint, value);
1669	2137	return &const_instruction->base;
1670	2138	}
1671	2139
1672		static IrInstruction ir_build_const_bigint(IrBuilder irb, Scope scope, AstNode source_node, BigInt *bigint) {
1673		IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, scope, source_node);
1674		const_instruction->base.value->type = irb->codegen->builtin_types.entry_num_lit_int;
1675		const_instruction->base.value->special = ConstValSpecialStatic;
1676		bigint_init_bigint(&const_instruction->base.value->data.x_bigint, bigint);
	2140	static IrInstSrc ir_build_const_bigint(IrBuilderSrc irb, Scope scope, AstNode source_node, BigInt *bigint) {
	2141	IrInstSrcConst *const_instruction = ir_build_instruction<IrInstSrcConst>(irb, scope, source_node);
	2142	const_instruction->value = create_const_vals(1);
	2143	const_instruction->value->type = irb->codegen->builtin_types.entry_num_lit_int;
	2144	const_instruction->value->special = ConstValSpecialStatic;
	2145	bigint_init_bigint(&const_instruction->value->data.x_bigint, bigint);
1677	2146	return &const_instruction->base;
1678	2147	}
1679	2148
1680		static IrInstruction ir_build_const_bigfloat(IrBuilder irb, Scope scope, AstNode source_node, BigFloat *bigfloat) {
1681		IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, scope, source_node);
1682		const_instruction->base.value->type = irb->codegen->builtin_types.entry_num_lit_float;
1683		const_instruction->base.value->special = ConstValSpecialStatic;
1684		bigfloat_init_bigfloat(&const_instruction->base.value->data.x_bigfloat, bigfloat);
	2149	static IrInstSrc ir_build_const_bigfloat(IrBuilderSrc irb, Scope scope, AstNode source_node, BigFloat *bigfloat) {
	2150	IrInstSrcConst *const_instruction = ir_build_instruction<IrInstSrcConst>(irb, scope, source_node);
	2151	const_instruction->value = create_const_vals(1);
	2152	const_instruction->value->type = irb->codegen->builtin_types.entry_num_lit_float;
	2153	const_instruction->value->special = ConstValSpecialStatic;
	2154	bigfloat_init_bigfloat(&const_instruction->value->data.x_bigfloat, bigfloat);
1685	2155	return &const_instruction->base;
1686	2156	}
1687	2157
1688		static IrInstruction ir_build_const_null(IrBuilder irb, Scope scope, AstNode source_node) {
1689		IrInstructionConst *const_instruction = ir_create_instruction_noval<IrInstructionConst>(irb, scope, source_node);
	2158	static IrInstSrc ir_build_const_null(IrBuilderSrc irb, Scope scope, AstNode source_node) {
	2159	IrInstSrcConst *const_instruction = ir_create_instruction<IrInstSrcConst>(irb, scope, source_node);
1690	2160	ir_instruction_append(irb->current_basic_block, &const_instruction->base);
1691		const_instruction->base.value = irb->codegen->intern.for_null();
	2161	const_instruction->value = irb->codegen->intern.for_null();
1692	2162	return &const_instruction->base;
1693	2163	}
1694	2164
1695		static IrInstruction ir_build_const_usize(IrBuilder irb, Scope scope, AstNode source_node, uint64_t value) {
1696		IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, scope, source_node);
1697		const_instruction->base.value->type = irb->codegen->builtin_types.entry_usize;
1698		const_instruction->base.value->special = ConstValSpecialStatic;
1699		bigint_init_unsigned(&const_instruction->base.value->data.x_bigint, value);
	2165	static IrInstSrc ir_build_const_usize(IrBuilderSrc irb, Scope scope, AstNode source_node, uint64_t value) {
	2166	IrInstSrcConst *const_instruction = ir_build_instruction<IrInstSrcConst>(irb, scope, source_node);
	2167	const_instruction->value = create_const_vals(1);
	2168	const_instruction->value->type = irb->codegen->builtin_types.entry_usize;
	2169	const_instruction->value->special = ConstValSpecialStatic;
	2170	bigint_init_unsigned(&const_instruction->value->data.x_bigint, value);
1700	2171	return &const_instruction->base;
1701	2172	}
1702	2173
1703		static IrInstruction ir_create_const_type(IrBuilder irb, Scope scope, AstNode source_node,
	2174	static IrInstSrc ir_create_const_type(IrBuilderSrc irb, Scope scope, AstNode source_node,
1704	2175	ZigType *type_entry)
1705	2176	{
1706		IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(irb, scope, source_node);
1707		const_instruction->base.value->type = irb->codegen->builtin_types.entry_type;
1708		const_instruction->base.value->special = ConstValSpecialStatic;
1709		const_instruction->base.value->data.x_type = type_entry;
	2177	IrInstSrcConst *const_instruction = ir_create_instruction<IrInstSrcConst>(irb, scope, source_node);
	2178	const_instruction->value = create_const_vals(1);
	2179	const_instruction->value->type = irb->codegen->builtin_types.entry_type;
	2180	const_instruction->value->special = ConstValSpecialStatic;
	2181	const_instruction->value->data.x_type = type_entry;
1710	2182	return &const_instruction->base;
1711	2183	}
1712	2184
1713		static IrInstruction ir_build_const_type(IrBuilder irb, Scope scope, AstNode source_node,
	2185	static IrInstSrc ir_build_const_type(IrBuilderSrc irb, Scope scope, AstNode source_node,
1714	2186	ZigType *type_entry)
1715	2187	{
1716		IrInstruction *instruction = ir_create_const_type(irb, scope, source_node, type_entry);
	2188	IrInstSrc *instruction = ir_create_const_type(irb, scope, source_node, type_entry);
1717	2189	ir_instruction_append(irb->current_basic_block, instruction);
1718	2190	return instruction;
1719	2191	}
1720	2192
1721		static IrInstruction ir_create_const_fn(IrBuilder irb, Scope scope, AstNode source_node, ZigFn *fn_entry) {
1722		IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(irb, scope, source_node);
1723		const_instruction->base.value->type = fn_entry->type_entry;
1724		const_instruction->base.value->special = ConstValSpecialStatic;
1725		const_instruction->base.value->data.x_ptr.data.fn.fn_entry = fn_entry;
1726		const_instruction->base.value->data.x_ptr.mut = ConstPtrMutComptimeConst;
1727		const_instruction->base.value->data.x_ptr.special = ConstPtrSpecialFunction;
1728		return &const_instruction->base;
1729		}
1730
1731		static IrInstruction ir_build_const_import(IrBuilder irb, Scope scope, AstNode source_node, ZigType *import) {
1732		IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, scope, source_node);
1733		const_instruction->base.value->type = irb->codegen->builtin_types.entry_type;
1734		const_instruction->base.value->special = ConstValSpecialStatic;
1735		const_instruction->base.value->data.x_type = import;
1736		return &const_instruction->base;
1737		}
1738
1739		static IrInstruction ir_build_const_bool(IrBuilder irb, Scope scope, AstNode source_node, bool value) {
1740		IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, scope, source_node);
1741		const_instruction->base.value->type = irb->codegen->builtin_types.entry_bool;
1742		const_instruction->base.value->special = ConstValSpecialStatic;
1743		const_instruction->base.value->data.x_bool = value;
	2193	static IrInstSrc ir_build_const_import(IrBuilderSrc irb, Scope scope, AstNode source_node, ZigType *import) {
	2194	IrInstSrcConst *const_instruction = ir_build_instruction<IrInstSrcConst>(irb, scope, source_node);
	2195	const_instruction->value = create_const_vals(1);
	2196	const_instruction->value->type = irb->codegen->builtin_types.entry_type;
	2197	const_instruction->value->special = ConstValSpecialStatic;
	2198	const_instruction->value->data.x_type = import;
1744	2199	return &const_instruction->base;
1745	2200	}
1746	2201
1747		static IrInstruction ir_build_const_enum_literal(IrBuilder irb, Scope scope, AstNode source_node, Buf *name) {
1748		IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, scope, source_node);
1749		const_instruction->base.value->type = irb->codegen->builtin_types.entry_enum_literal;
1750		const_instruction->base.value->special = ConstValSpecialStatic;
1751		const_instruction->base.value->data.x_enum_literal = name;
	2202	static IrInstSrc ir_build_const_bool(IrBuilderSrc irb, Scope scope, AstNode source_node, bool value) {
	2203	IrInstSrcConst *const_instruction = ir_build_instruction<IrInstSrcConst>(irb, scope, source_node);
	2204	const_instruction->value = create_const_vals(1);
	2205	const_instruction->value->type = irb->codegen->builtin_types.entry_bool;
	2206	const_instruction->value->special = ConstValSpecialStatic;
	2207	const_instruction->value->data.x_bool = value;
1752	2208	return &const_instruction->base;
1753	2209	}
1754	2210
1755		static IrInstruction ir_build_const_bound_fn(IrBuilder irb, Scope scope, AstNode source_node,
1756		ZigFn fn_entry, IrInstruction first_arg)
1757		{
1758		IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, scope, source_node);
1759		const_instruction->base.value->type = get_bound_fn_type(irb->codegen, fn_entry);
1760		const_instruction->base.value->special = ConstValSpecialStatic;
1761		const_instruction->base.value->data.x_bound_fn.fn = fn_entry;
1762		const_instruction->base.value->data.x_bound_fn.first_arg = first_arg;
	2211	static IrInstSrc ir_build_const_enum_literal(IrBuilderSrc irb, Scope scope, AstNode source_node, Buf *name) {
	2212	IrInstSrcConst *const_instruction = ir_build_instruction<IrInstSrcConst>(irb, scope, source_node);
	2213	const_instruction->value = create_const_vals(1);
	2214	const_instruction->value->type = irb->codegen->builtin_types.entry_enum_literal;
	2215	const_instruction->value->special = ConstValSpecialStatic;
	2216	const_instruction->value->data.x_enum_literal = name;
1763	2217	return &const_instruction->base;
1764	2218	}
1765	2219
1766		static IrInstruction ir_create_const_str_lit(IrBuilder irb, Scope scope, AstNode source_node, Buf *str) {
1767		IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(irb, scope, source_node);
1768		init_const_str_lit(irb->codegen, const_instruction->base.value, str);
	2220	static IrInstSrc ir_create_const_str_lit(IrBuilderSrc irb, Scope scope, AstNode source_node, Buf *str) {
	2221	IrInstSrcConst *const_instruction = ir_create_instruction<IrInstSrcConst>(irb, scope, source_node);
	2222	const_instruction->value = create_const_vals(1);
	2223	init_const_str_lit(irb->codegen, const_instruction->value, str);
1769	2224
1770	2225	return &const_instruction->base;
1771	2226	}
1772	2227
1773		static IrInstruction ir_build_const_str_lit(IrBuilder irb, Scope scope, AstNode source_node, Buf *str) {
1774		IrInstruction *instruction = ir_create_const_str_lit(irb, scope, source_node, str);
	2228	static IrInstSrc ir_build_const_str_lit(IrBuilderSrc irb, Scope scope, AstNode source_node, Buf *str) {
	2229	IrInstSrc *instruction = ir_create_const_str_lit(irb, scope, source_node, str);
1775	2230	ir_instruction_append(irb->current_basic_block, instruction);
1776	2231	return instruction;
1777	2232	}
1778	2233
1779		static IrInstruction ir_build_bin_op(IrBuilder irb, Scope scope, AstNode source_node, IrBinOp op_id,
1780		IrInstruction op1, IrInstruction op2, bool safety_check_on)
	2234	static IrInstSrc ir_build_bin_op(IrBuilderSrc irb, Scope scope, AstNode source_node, IrBinOp op_id,
	2235	IrInstSrc op1, IrInstSrc op2, bool safety_check_on)
1781	2236	{
1782		IrInstructionBinOp *bin_op_instruction = ir_build_instruction<IrInstructionBinOp>(irb, scope, source_node);
1783		bin_op_instruction->op_id = op_id;
1784		bin_op_instruction->op1 = op1;
1785		bin_op_instruction->op2 = op2;
1786		bin_op_instruction->safety_check_on = safety_check_on;
	2237	IrInstSrcBinOp *inst = ir_build_instruction<IrInstSrcBinOp>(irb, scope, source_node);
	2238	inst->op_id = op_id;
	2239	inst->op1 = op1;
	2240	inst->op2 = op2;
	2241	inst->safety_check_on = safety_check_on;
1787	2242
1788	2243	ir_ref_instruction(op1, irb->current_basic_block);
1789	2244	ir_ref_instruction(op2, irb->current_basic_block);
1790	2245
1791		return &bin_op_instruction->base;
	2246	return &inst->base;
1792	2247	}
1793	2248
1794		static IrInstruction ir_build_bin_op_gen(IrAnalyze ira, IrInstruction source_instr, ZigType res_type,
1795		IrBinOp op_id, IrInstruction op1, IrInstruction op2, bool safety_check_on)
	2249	static IrInstGen ir_build_bin_op_gen(IrAnalyze ira, IrInst source_instr, ZigType res_type,
	2250	IrBinOp op_id, IrInstGen op1, IrInstGen op2, bool safety_check_on)
1796	2251	{
1797		IrInstructionBinOp *bin_op_instruction = ir_build_instruction<IrInstructionBinOp>(&ira->new_irb,
	2252	IrInstGenBinOp *inst = ir_build_inst_gen<IrInstGenBinOp>(&ira->new_irb,
1798	2253	source_instr->scope, source_instr->source_node);
1799		bin_op_instruction->base.value->type = res_type;
1800		bin_op_instruction->op_id = op_id;
1801		bin_op_instruction->op1 = op1;
1802		bin_op_instruction->op2 = op2;
1803		bin_op_instruction->safety_check_on = safety_check_on;
	2254	inst->base.value->type = res_type;
	2255	inst->op_id = op_id;
	2256	inst->op1 = op1;
	2257	inst->op2 = op2;
	2258	inst->safety_check_on = safety_check_on;
1804	2259
1805		ir_ref_instruction(op1, ira->new_irb.current_basic_block);
1806		ir_ref_instruction(op2, ira->new_irb.current_basic_block);
	2260	ir_ref_inst_gen(op1, ira->new_irb.current_basic_block);
	2261	ir_ref_inst_gen(op2, ira->new_irb.current_basic_block);
1807	2262
1808		return &bin_op_instruction->base;
	2263	return &inst->base;
1809	2264	}
1810	2265
1811	2266
1812		static IrInstruction ir_build_merge_err_sets(IrBuilder irb, Scope scope, AstNode source_node,
1813		IrInstruction op1, IrInstruction op2, Buf *type_name)
	2267	static IrInstSrc ir_build_merge_err_sets(IrBuilderSrc irb, Scope scope, AstNode source_node,
	2268	IrInstSrc op1, IrInstSrc op2, Buf *type_name)
1814	2269	{
1815		IrInstructionMergeErrSets *merge_err_sets_instruction = ir_build_instruction<IrInstructionMergeErrSets>(irb, scope, source_node);
1816		merge_err_sets_instruction->op1 = op1;
1817		merge_err_sets_instruction->op2 = op2;
1818		merge_err_sets_instruction->type_name = type_name;
	2270	IrInstSrcMergeErrSets *inst = ir_build_instruction<IrInstSrcMergeErrSets>(irb, scope, source_node);
	2271	inst->op1 = op1;
	2272	inst->op2 = op2;
	2273	inst->type_name = type_name;
1819	2274
1820	2275	ir_ref_instruction(op1, irb->current_basic_block);
1821	2276	ir_ref_instruction(op2, irb->current_basic_block);
1822	2277
1823		return &merge_err_sets_instruction->base;
	2278	return &inst->base;
1824	2279	}
1825	2280
1826		static IrInstruction ir_build_var_ptr_x(IrBuilder irb, Scope scope, AstNode source_node, ZigVar *var,
	2281	static IrInstSrc ir_build_var_ptr_x(IrBuilderSrc irb, Scope scope, AstNode source_node, ZigVar *var,
1827	2282	ScopeFnDef *crossed_fndef_scope)
1828	2283	{
1829		IrInstructionVarPtr *instruction = ir_build_instruction<IrInstructionVarPtr>(irb, scope, source_node);
	2284	IrInstSrcVarPtr *instruction = ir_build_instruction<IrInstSrcVarPtr>(irb, scope, source_node);
1830	2285	instruction->var = var;
1831	2286	instruction->crossed_fndef_scope = crossed_fndef_scope;
1832	2287
...	...	@@ -1835,22 +2290,31 @@ static IrInstruction ir_build_var_ptr_x(IrBuilder irb, Scope scope, AstNode
1835	2290	return &instruction->base;
1836	2291	}
1837	2292
1838		static IrInstruction ir_build_var_ptr(IrBuilder irb, Scope scope, AstNode source_node, ZigVar *var) {
	2293	static IrInstSrc ir_build_var_ptr(IrBuilderSrc irb, Scope scope, AstNode source_node, ZigVar *var) {
1839	2294	return ir_build_var_ptr_x(irb, scope, source_node, var, nullptr);
1840	2295	}
1841	2296
1842		static IrInstruction ir_build_return_ptr(IrAnalyze ira, IrInstruction source_instruction, ZigType ty) {
1843		IrInstructionReturnPtr *instruction = ir_build_instruction<IrInstructionReturnPtr>(&ira->new_irb,
	2297	static IrInstGen ir_build_var_ptr_gen(IrAnalyze ira, IrInst source_instr, ZigVar var) {
	2298	IrInstGenVarPtr *instruction = ir_build_inst_gen<IrInstGenVarPtr>(&ira->new_irb, source_instr->scope, source_instr->source_node);
	2299	instruction->var = var;
	2300
	2301	ir_ref_var(var);
	2302
	2303	return &instruction->base;
	2304	}
	2305
	2306	static IrInstGen ir_build_return_ptr(IrAnalyze ira, IrInst source_instruction, ZigType ty) {
	2307	IrInstGenReturnPtr *instruction = ir_build_inst_gen<IrInstGenReturnPtr>(&ira->new_irb,
1844	2308	source_instruction->scope, source_instruction->source_node);
1845	2309	instruction->base.value->type = ty;
1846	2310	return &instruction->base;
1847	2311	}
1848	2312
1849		static IrInstruction ir_build_elem_ptr(IrBuilder irb, Scope scope, AstNode source_node,
1850		IrInstruction array_ptr, IrInstruction elem_index, bool safety_check_on, PtrLen ptr_len,
	2313	static IrInstSrc ir_build_elem_ptr(IrBuilderSrc irb, Scope scope, AstNode source_node,
	2314	IrInstSrc array_ptr, IrInstSrc elem_index, bool safety_check_on, PtrLen ptr_len,
1851	2315	AstNode *init_array_type_source_node)
1852	2316	{
1853		IrInstructionElemPtr *instruction = ir_build_instruction<IrInstructionElemPtr>(irb, scope, source_node);
	2317	IrInstSrcElemPtr *instruction = ir_build_instruction<IrInstSrcElemPtr>(irb, scope, source_node);
1854	2318	instruction->array_ptr = array_ptr;
1855	2319	instruction->elem_index = elem_index;
1856	2320	instruction->safety_check_on = safety_check_on;
...	...	@@ -1863,10 +2327,25 @@ static IrInstruction ir_build_elem_ptr(IrBuilder irb, Scope scope, AstNode s
1863	2327	return &instruction->base;
1864	2328	}
1865	2329
1866		static IrInstruction ir_build_field_ptr_instruction(IrBuilder irb, Scope scope, AstNode source_node,
1867		IrInstruction container_ptr, IrInstruction field_name_expr, bool initializing)
	2330	static IrInstGen ir_build_elem_ptr_gen(IrAnalyze ira, Scope scope, AstNode source_node,
	2331	IrInstGen array_ptr, IrInstGen elem_index, bool safety_check_on, ZigType *return_type)
	2332	{
	2333	IrInstGenElemPtr *instruction = ir_build_inst_gen<IrInstGenElemPtr>(&ira->new_irb, scope, source_node);
	2334	instruction->base.value->type = return_type;
	2335	instruction->array_ptr = array_ptr;
	2336	instruction->elem_index = elem_index;
	2337	instruction->safety_check_on = safety_check_on;
	2338
	2339	ir_ref_inst_gen(array_ptr, ira->new_irb.current_basic_block);
	2340	ir_ref_inst_gen(elem_index, ira->new_irb.current_basic_block);
	2341
	2342	return &instruction->base;
	2343	}
	2344
	2345	static IrInstSrc ir_build_field_ptr_instruction(IrBuilderSrc irb, Scope scope, AstNode source_node,
	2346	IrInstSrc container_ptr, IrInstSrc field_name_expr, bool initializing)
1868	2347	{
1869		IrInstructionFieldPtr *instruction = ir_build_instruction<IrInstructionFieldPtr>(irb, scope, source_node);
	2348	IrInstSrcFieldPtr *instruction = ir_build_instruction<IrInstSrcFieldPtr>(irb, scope, source_node);
1870	2349	instruction->container_ptr = container_ptr;
1871	2350	instruction->field_name_buffer = nullptr;
1872	2351	instruction->field_name_expr = field_name_expr;
...	...	@@ -1878,10 +2357,10 @@ static IrInstruction ir_build_field_ptr_instruction(IrBuilder irb, Scope *scop
1878	2357	return &instruction->base;
1879	2358	}
1880	2359
1881		static IrInstruction ir_build_field_ptr(IrBuilder irb, Scope scope, AstNode source_node,
1882		IrInstruction container_ptr, Buf field_name, bool initializing)
	2360	static IrInstSrc ir_build_field_ptr(IrBuilderSrc irb, Scope scope, AstNode source_node,
	2361	IrInstSrc container_ptr, Buf field_name, bool initializing)
1883	2362	{
1884		IrInstructionFieldPtr *instruction = ir_build_instruction<IrInstructionFieldPtr>(irb, scope, source_node);
	2363	IrInstSrcFieldPtr *instruction = ir_build_instruction<IrInstSrcFieldPtr>(irb, scope, source_node);
1885	2364	instruction->container_ptr = container_ptr;
1886	2365	instruction->field_name_buffer = field_name;
1887	2366	instruction->field_name_expr = nullptr;
...	...	@@ -1892,10 +2371,10 @@ static IrInstruction ir_build_field_ptr(IrBuilder irb, Scope scope, AstNode
1892	2371	return &instruction->base;
1893	2372	}
1894	2373
1895		static IrInstruction ir_build_has_field(IrBuilder irb, Scope scope, AstNode source_node,
1896		IrInstruction container_type, IrInstruction field_name)
	2374	static IrInstSrc ir_build_has_field(IrBuilderSrc irb, Scope scope, AstNode source_node,
	2375	IrInstSrc container_type, IrInstSrc field_name)
1897	2376	{
1898		IrInstructionHasField *instruction = ir_build_instruction<IrInstructionHasField>(irb, scope, source_node);
	2377	IrInstSrcHasField *instruction = ir_build_instruction<IrInstSrcHasField>(irb, scope, source_node);
1899	2378	instruction->container_type = container_type;
1900	2379	instruction->field_name = field_name;
1901	2380
...	...	@@ -1905,36 +2384,39 @@ static IrInstruction ir_build_has_field(IrBuilder irb, Scope scope, AstNode
1905	2384	return &instruction->base;
1906	2385	}
1907	2386
1908		static IrInstruction ir_build_struct_field_ptr(IrBuilder irb, Scope scope, AstNode source_node,
1909		IrInstruction struct_ptr, TypeStructField field)
	2387	static IrInstGen ir_build_struct_field_ptr(IrAnalyze ira, IrInst *source_instr,
	2388	IrInstGen struct_ptr, TypeStructField field, ZigType *ptr_type)
1910	2389	{
1911		IrInstructionStructFieldPtr *instruction = ir_build_instruction<IrInstructionStructFieldPtr>(irb, scope, source_node);
1912		instruction->struct_ptr = struct_ptr;
1913		instruction->field = field;
	2390	IrInstGenStructFieldPtr *inst = ir_build_inst_gen<IrInstGenStructFieldPtr>(&ira->new_irb, source_instr->scope, source_instr->source_node);
	2391	inst->base.value->type = ptr_type;
	2392	inst->struct_ptr = struct_ptr;
	2393	inst->field = field;
1914	2394
1915		ir_ref_instruction(struct_ptr, irb->current_basic_block);
	2395	ir_ref_inst_gen(struct_ptr, ira->new_irb.current_basic_block);
1916	2396
1917		return &instruction->base;
	2397	return &inst->base;
1918	2398	}
1919	2399
1920		static IrInstruction ir_build_union_field_ptr(IrBuilder irb, Scope scope, AstNode source_node,
1921		IrInstruction union_ptr, TypeUnionField field, bool safety_check_on, bool initializing)
	2400	static IrInstGen ir_build_union_field_ptr(IrAnalyze ira, IrInst *source_instr,
	2401	IrInstGen union_ptr, TypeUnionField field, bool safety_check_on, bool initializing, ZigType *ptr_type)
1922	2402	{
1923		IrInstructionUnionFieldPtr *instruction = ir_build_instruction<IrInstructionUnionFieldPtr>(irb, scope, source_node);
1924		instruction->initializing = initializing;
1925		instruction->safety_check_on = safety_check_on;
1926		instruction->union_ptr = union_ptr;
1927		instruction->field = field;
	2403	IrInstGenUnionFieldPtr *inst = ir_build_inst_gen<IrInstGenUnionFieldPtr>(&ira->new_irb,
	2404	source_instr->scope, source_instr->source_node);
	2405	inst->base.value->type = ptr_type;
	2406	inst->initializing = initializing;
	2407	inst->safety_check_on = safety_check_on;
	2408	inst->union_ptr = union_ptr;
	2409	inst->field = field;
1928	2410
1929		ir_ref_instruction(union_ptr, irb->current_basic_block);
	2411	ir_ref_inst_gen(union_ptr, ira->new_irb.current_basic_block);
1930	2412
1931		return &instruction->base;
	2413	return &inst->base;
1932	2414	}
1933	2415
1934		static IrInstruction ir_build_call_extra(IrBuilder irb, Scope scope, AstNode source_node,
1935		IrInstruction options, IrInstruction fn_ref, IrInstruction args, ResultLoc result_loc)
	2416	static IrInstSrc ir_build_call_extra(IrBuilderSrc irb, Scope scope, AstNode source_node,
	2417	IrInstSrc options, IrInstSrc fn_ref, IrInstSrc args, ResultLoc result_loc)
1936	2418	{
1937		IrInstructionCallExtra *call_instruction = ir_build_instruction<IrInstructionCallExtra>(irb, scope, source_node);
	2419	IrInstSrcCallExtra *call_instruction = ir_build_instruction<IrInstSrcCallExtra>(irb, scope, source_node);
1938	2420	call_instruction->options = options;
1939	2421	call_instruction->fn_ref = fn_ref;
1940	2422	call_instruction->args = args;
...	...	@@ -1947,11 +2429,11 @@ static IrInstruction ir_build_call_extra(IrBuilder irb, Scope *scope, AstNode
1947	2429	return &call_instruction->base;
1948	2430	}
1949	2431
1950		static IrInstruction ir_build_call_src_args(IrBuilder irb, Scope scope, AstNode source_node,
1951		IrInstruction options, IrInstruction fn_ref, IrInstruction **args_ptr, size_t args_len,
	2432	static IrInstSrc ir_build_call_args(IrBuilderSrc irb, Scope scope, AstNode source_node,
	2433	IrInstSrc options, IrInstSrc fn_ref, IrInstSrc **args_ptr, size_t args_len,
1952	2434	ResultLoc *result_loc)
1953	2435	{
1954		IrInstructionCallSrcArgs *call_instruction = ir_build_instruction<IrInstructionCallSrcArgs>(irb, scope, source_node);
	2436	IrInstSrcCallArgs *call_instruction = ir_build_instruction<IrInstSrcCallArgs>(irb, scope, source_node);
1955	2437	call_instruction->options = options;
1956	2438	call_instruction->fn_ref = fn_ref;
1957	2439	call_instruction->args_ptr = args_ptr;
...	...	@@ -1966,12 +2448,12 @@ static IrInstruction ir_build_call_src_args(IrBuilder irb, Scope *scope, AstNo
1966	2448	return &call_instruction->base;
1967	2449	}
1968	2450
1969		static IrInstruction ir_build_call_src(IrBuilder irb, Scope scope, AstNode source_node,
1970		ZigFn fn_entry, IrInstruction fn_ref, size_t arg_count, IrInstruction **args,
1971		IrInstruction *ret_ptr, CallModifier modifier, bool is_async_call_builtin,
1972		IrInstruction new_stack, ResultLoc result_loc)
	2451	static IrInstSrc ir_build_call_src(IrBuilderSrc irb, Scope scope, AstNode source_node,
	2452	ZigFn fn_entry, IrInstSrc fn_ref, size_t arg_count, IrInstSrc **args,
	2453	IrInstSrc *ret_ptr, CallModifier modifier, bool is_async_call_builtin,
	2454	IrInstSrc new_stack, ResultLoc result_loc)
1973	2455	{
1974		IrInstructionCallSrc *call_instruction = ir_build_instruction<IrInstructionCallSrc>(irb, scope, source_node);
	2456	IrInstSrcCall *call_instruction = ir_build_instruction<IrInstSrcCall>(irb, scope, source_node);
1975	2457	call_instruction->fn_entry = fn_entry;
1976	2458	call_instruction->fn_ref = fn_ref;
1977	2459	call_instruction->args = args;
...	...	@@ -1991,12 +2473,12 @@ static IrInstruction ir_build_call_src(IrBuilder irb, Scope scope, AstNode s
1991	2473	return &call_instruction->base;
1992	2474	}
1993	2475
1994		static IrInstructionCallGen ir_build_call_gen(IrAnalyze ira, IrInstruction *source_instruction,
1995		ZigFn fn_entry, IrInstruction fn_ref, size_t arg_count, IrInstruction **args,
1996		CallModifier modifier, IrInstruction *new_stack, bool is_async_call_builtin,
1997		IrInstruction result_loc, ZigType return_type)
	2476	static IrInstGenCall ir_build_call_gen(IrAnalyze ira, IrInst *source_instruction,
	2477	ZigFn fn_entry, IrInstGen fn_ref, size_t arg_count, IrInstGen **args,
	2478	CallModifier modifier, IrInstGen *new_stack, bool is_async_call_builtin,
	2479	IrInstGen result_loc, ZigType return_type)
1998	2480	{
1999		IrInstructionCallGen *call_instruction = ir_build_instruction<IrInstructionCallGen>(&ira->new_irb,
	2481	IrInstGenCall *call_instruction = ir_build_inst_gen<IrInstGenCall>(&ira->new_irb,
2000	2482	source_instruction->scope, source_instruction->source_node);
2001	2483	call_instruction->base.value->type = return_type;
2002	2484	call_instruction->fn_entry = fn_entry;
...	...	@@ -2008,23 +2490,23 @@ static IrInstructionCallGen ir_build_call_gen(IrAnalyze ira, IrInstruction *so
2008	2490	call_instruction->new_stack = new_stack;
2009	2491	call_instruction->result_loc = result_loc;
2010	2492
2011		if (fn_ref != nullptr) ir_ref_instruction(fn_ref, ira->new_irb.current_basic_block);
	2493	if (fn_ref != nullptr) ir_ref_inst_gen(fn_ref, ira->new_irb.current_basic_block);
2012	2494	for (size_t i = 0; i < arg_count; i += 1)
2013		ir_ref_instruction(args[i], ira->new_irb.current_basic_block);
2014		if (new_stack != nullptr) ir_ref_instruction(new_stack, ira->new_irb.current_basic_block);
2015		if (result_loc != nullptr) ir_ref_instruction(result_loc, ira->new_irb.current_basic_block);
	2495	ir_ref_inst_gen(args[i], ira->new_irb.current_basic_block);
	2496	if (new_stack != nullptr) ir_ref_inst_gen(new_stack, ira->new_irb.current_basic_block);
	2497	if (result_loc != nullptr) ir_ref_inst_gen(result_loc, ira->new_irb.current_basic_block);
2016	2498
2017	2499	return call_instruction;
2018	2500	}
2019	2501
2020		static IrInstruction ir_build_phi(IrBuilder irb, Scope scope, AstNode source_node,
2021		size_t incoming_count, IrBasicBlock incoming_blocks, IrInstruction incoming_values,
	2502	static IrInstSrc ir_build_phi(IrBuilderSrc irb, Scope scope, AstNode source_node,
	2503	size_t incoming_count, IrBasicBlockSrc incoming_blocks, IrInstSrc incoming_values,
2022	2504	ResultLocPeerParent *peer_parent)
2023	2505	{
2024	2506	assert(incoming_count != 0);
2025	2507	assert(incoming_count != SIZE_MAX);
2026	2508
2027		IrInstructionPhi *phi_instruction = ir_build_instruction<IrInstructionPhi>(irb, scope, source_node);
	2509	IrInstSrcPhi *phi_instruction = ir_build_instruction<IrInstSrcPhi>(irb, scope, source_node);
2028	2510	phi_instruction->incoming_count = incoming_count;
2029	2511	phi_instruction->incoming_blocks = incoming_blocks;
2030	2512	phi_instruction->incoming_values = incoming_values;
...	...	@@ -2038,56 +2520,77 @@ static IrInstruction ir_build_phi(IrBuilder irb, Scope scope, AstNode source
2038	2520	return &phi_instruction->base;
2039	2521	}
2040	2522
2041		static IrInstruction ir_create_br(IrBuilder irb, Scope scope, AstNode source_node,
2042		IrBasicBlock dest_block, IrInstruction is_comptime)
	2523	static IrInstGen ir_build_phi_gen(IrAnalyze ira, IrInst *source_instr, size_t incoming_count,
	2524	IrBasicBlockGen incoming_blocks, IrInstGen incoming_values, ZigType *result_type)
	2525	{
	2526	assert(incoming_count != 0);
	2527	assert(incoming_count != SIZE_MAX);
	2528
	2529	IrInstGenPhi *phi_instruction = ir_build_inst_gen<IrInstGenPhi>(&ira->new_irb,
	2530	source_instr->scope, source_instr->source_node);
	2531	phi_instruction->base.value->type = result_type;
	2532	phi_instruction->incoming_count = incoming_count;
	2533	phi_instruction->incoming_blocks = incoming_blocks;
	2534	phi_instruction->incoming_values = incoming_values;
	2535
	2536	for (size_t i = 0; i < incoming_count; i += 1) {
	2537	ir_ref_bb_gen(incoming_blocks[i]);
	2538	ir_ref_inst_gen(incoming_values[i], ira->new_irb.current_basic_block);
	2539	}
	2540
	2541	return &phi_instruction->base;
	2542	}
	2543
	2544	static IrInstSrc ir_build_br(IrBuilderSrc irb, Scope scope, AstNode source_node,
	2545	IrBasicBlockSrc dest_block, IrInstSrc is_comptime)
2043	2546	{
2044		IrInstructionBr *br_instruction = ir_create_instruction<IrInstructionBr>(irb, scope, source_node);
2045		br_instruction->base.value->type = irb->codegen->builtin_types.entry_unreachable;
2046		br_instruction->base.value->special = ConstValSpecialStatic;
2047		br_instruction->dest_block = dest_block;
2048		br_instruction->is_comptime = is_comptime;
	2547	IrInstSrcBr *inst = ir_build_instruction<IrInstSrcBr>(irb, scope, source_node);
	2548	inst->base.is_noreturn = true;
	2549	inst->dest_block = dest_block;
	2550	inst->is_comptime = is_comptime;
2049	2551
2050	2552	ir_ref_bb(dest_block);
2051	2553	if (is_comptime) ir_ref_instruction(is_comptime, irb->current_basic_block);
2052	2554
2053		return &br_instruction->base;
	2555	return &inst->base;
2054	2556	}
2055	2557
2056		static IrInstruction ir_build_br(IrBuilder irb, Scope scope, AstNode source_node,
2057		IrBasicBlock dest_block, IrInstruction is_comptime)
2058		{
2059		IrInstruction *instruction = ir_create_br(irb, scope, source_node, dest_block, is_comptime);
2060		ir_instruction_append(irb->current_basic_block, instruction);
2061		return instruction;
	2558	static IrInstGen ir_build_br_gen(IrAnalyze ira, IrInst source_instr, IrBasicBlockGen dest_block) {
	2559	IrInstGenBr *inst = ir_build_inst_noreturn<IrInstGenBr>(&ira->new_irb, source_instr->scope, source_instr->source_node);
	2560	inst->dest_block = dest_block;
	2561
	2562	ir_ref_bb_gen(dest_block);
	2563
	2564	return &inst->base;
2062	2565	}
2063	2566
2064		static IrInstruction ir_build_ptr_type(IrBuilder irb, Scope scope, AstNode source_node,
2065		IrInstruction *child_type, bool is_const, bool is_volatile, PtrLen ptr_len,
2066		IrInstruction sentinel, IrInstruction align_value,
	2567	static IrInstSrc ir_build_ptr_type(IrBuilderSrc irb, Scope scope, AstNode source_node,
	2568	IrInstSrc *child_type, bool is_const, bool is_volatile, PtrLen ptr_len,
	2569	IrInstSrc sentinel, IrInstSrc align_value,
2067	2570	uint32_t bit_offset_start, uint32_t host_int_bytes, bool is_allow_zero)
2068	2571	{
2069		IrInstructionPtrType *ptr_type_of_instruction = ir_build_instruction<IrInstructionPtrType>(irb, scope, source_node);
2070		ptr_type_of_instruction->sentinel = sentinel;
2071		ptr_type_of_instruction->align_value = align_value;
2072		ptr_type_of_instruction->child_type = child_type;
2073		ptr_type_of_instruction->is_const = is_const;
2074		ptr_type_of_instruction->is_volatile = is_volatile;
2075		ptr_type_of_instruction->ptr_len = ptr_len;
2076		ptr_type_of_instruction->bit_offset_start = bit_offset_start;
2077		ptr_type_of_instruction->host_int_bytes = host_int_bytes;
2078		ptr_type_of_instruction->is_allow_zero = is_allow_zero;
	2572	IrInstSrcPtrType *inst = ir_build_instruction<IrInstSrcPtrType>(irb, scope, source_node);
	2573	inst->sentinel = sentinel;
	2574	inst->align_value = align_value;
	2575	inst->child_type = child_type;
	2576	inst->is_const = is_const;
	2577	inst->is_volatile = is_volatile;
	2578	inst->ptr_len = ptr_len;
	2579	inst->bit_offset_start = bit_offset_start;
	2580	inst->host_int_bytes = host_int_bytes;
	2581	inst->is_allow_zero = is_allow_zero;
2079	2582
2080	2583	if (sentinel) ir_ref_instruction(sentinel, irb->current_basic_block);
2081	2584	if (align_value) ir_ref_instruction(align_value, irb->current_basic_block);
2082	2585	ir_ref_instruction(child_type, irb->current_basic_block);
2083	2586
2084		return &ptr_type_of_instruction->base;
	2587	return &inst->base;
2085	2588	}
2086	2589
2087		static IrInstruction ir_build_un_op_lval(IrBuilder irb, Scope scope, AstNode source_node, IrUnOp op_id,
2088		IrInstruction value, LVal lval, ResultLoc result_loc)
	2590	static IrInstSrc ir_build_un_op_lval(IrBuilderSrc irb, Scope scope, AstNode source_node, IrUnOp op_id,
	2591	IrInstSrc value, LVal lval, ResultLoc result_loc)
2089	2592	{
2090		IrInstructionUnOp *instruction = ir_build_instruction<IrInstructionUnOp>(irb, scope, source_node);
	2593	IrInstSrcUnOp *instruction = ir_build_instruction<IrInstSrcUnOp>(irb, scope, source_node);
2091	2594	instruction->op_id = op_id;
2092	2595	instruction->value = value;
2093	2596	instruction->lval = lval;
...	...	@@ -2098,36 +2601,73 @@ static IrInstruction ir_build_un_op_lval(IrBuilder irb, Scope *scope, AstNode
2098	2601	return &instruction->base;
2099	2602	}
2100	2603
2101		static IrInstruction ir_build_un_op(IrBuilder irb, Scope scope, AstNode source_node, IrUnOp op_id,
2102		IrInstruction *value)
	2604	static IrInstSrc ir_build_un_op(IrBuilderSrc irb, Scope scope, AstNode source_node, IrUnOp op_id,
	2605	IrInstSrc *value)
2103	2606	{
2104	2607	return ir_build_un_op_lval(irb, scope, source_node, op_id, value, LValNone, nullptr);
2105	2608	}
2106	2609
2107		static IrInstruction ir_build_container_init_list(IrBuilder irb, Scope scope, AstNode source_node,
2108		size_t item_count, IrInstruction *elem_result_loc_list, IrInstruction result_loc,
2109		AstNode *init_array_type_source_node)
2110		{
2111		IrInstructionContainerInitList *container_init_list_instruction =
2112		ir_build_instruction<IrInstructionContainerInitList>(irb, scope, source_node);
2113		container_init_list_instruction->item_count = item_count;
2114		container_init_list_instruction->elem_result_loc_list = elem_result_loc_list;
2115		container_init_list_instruction->result_loc = result_loc;
2116		container_init_list_instruction->init_array_type_source_node = init_array_type_source_node;
	2610	static IrInstGen ir_build_negation(IrAnalyze ira, IrInst source_instr, IrInstGen operand, ZigType *expr_type) {
	2611	IrInstGenNegation *instruction = ir_build_inst_gen<IrInstGenNegation>(&ira->new_irb,
	2612	source_instr->scope, source_instr->source_node);
	2613	instruction->base.value->type = expr_type;
	2614	instruction->operand = operand;
2117	2615
2118		for (size_t i = 0; i < item_count; i += 1) {
2119		ir_ref_instruction(elem_result_loc_list[i], irb->current_basic_block);
	2616	ir_ref_inst_gen(operand, ira->new_irb.current_basic_block);
	2617
	2618	return &instruction->base;
	2619	}
	2620
	2621	static IrInstGen ir_build_negation_wrapping(IrAnalyze ira, IrInst source_instr, IrInstGen operand,
	2622	ZigType *expr_type)
	2623	{
	2624	IrInstGenNegationWrapping *instruction = ir_build_inst_gen<IrInstGenNegationWrapping>(&ira->new_irb,
	2625	source_instr->scope, source_instr->source_node);
	2626	instruction->base.value->type = expr_type;
	2627	instruction->operand = operand;
	2628
	2629	ir_ref_inst_gen(operand, ira->new_irb.current_basic_block);
	2630
	2631	return &instruction->base;
	2632	}
	2633
	2634	static IrInstGen ir_build_binary_not(IrAnalyze ira, IrInst source_instr, IrInstGen operand,
	2635	ZigType *expr_type)
	2636	{
	2637	IrInstGenBinaryNot *instruction = ir_build_inst_gen<IrInstGenBinaryNot>(&ira->new_irb,
	2638	source_instr->scope, source_instr->source_node);
	2639	instruction->base.value->type = expr_type;
	2640	instruction->operand = operand;
	2641
	2642	ir_ref_inst_gen(operand, ira->new_irb.current_basic_block);
	2643
	2644	return &instruction->base;
	2645	}
	2646
	2647	static IrInstSrc ir_build_container_init_list(IrBuilderSrc irb, Scope scope, AstNode source_node,
	2648	size_t item_count, IrInstSrc *elem_result_loc_list, IrInstSrc result_loc,
	2649	AstNode *init_array_type_source_node)
	2650	{
	2651	IrInstSrcContainerInitList *container_init_list_instruction =
	2652	ir_build_instruction<IrInstSrcContainerInitList>(irb, scope, source_node);
	2653	container_init_list_instruction->item_count = item_count;
	2654	container_init_list_instruction->elem_result_loc_list = elem_result_loc_list;
	2655	container_init_list_instruction->result_loc = result_loc;
	2656	container_init_list_instruction->init_array_type_source_node = init_array_type_source_node;
	2657
	2658	for (size_t i = 0; i < item_count; i += 1) {
	2659	ir_ref_instruction(elem_result_loc_list[i], irb->current_basic_block);
2120	2660	}
2121	2661	if (result_loc != nullptr) ir_ref_instruction(result_loc, irb->current_basic_block);
2122	2662
2123	2663	return &container_init_list_instruction->base;
2124	2664	}
2125	2665
2126		static IrInstruction ir_build_container_init_fields(IrBuilder irb, Scope scope, AstNode source_node,
2127		size_t field_count, IrInstructionContainerInitFieldsField fields, IrInstruction result_loc)
	2666	static IrInstSrc ir_build_container_init_fields(IrBuilderSrc irb, Scope scope, AstNode source_node,
	2667	size_t field_count, IrInstSrcContainerInitFieldsField fields, IrInstSrc result_loc)
2128	2668	{
2129		IrInstructionContainerInitFields *container_init_fields_instruction =
2130		ir_build_instruction<IrInstructionContainerInitFields>(irb, scope, source_node);
	2669	IrInstSrcContainerInitFields *container_init_fields_instruction =
	2670	ir_build_instruction<IrInstSrcContainerInitFields>(irb, scope, source_node);
2131	2671	container_init_fields_instruction->field_count = field_count;
2132	2672	container_init_fields_instruction->fields = fields;
2133	2673	container_init_fields_instruction->result_loc = result_loc;
...	...	@@ -2140,20 +2680,21 @@ static IrInstruction ir_build_container_init_fields(IrBuilder irb, Scope *scop
2140	2680	return &container_init_fields_instruction->base;
2141	2681	}
2142	2682
2143		static IrInstruction ir_build_unreachable(IrBuilder irb, Scope scope, AstNode source_node) {
2144		IrInstructionUnreachable *unreachable_instruction =
2145		ir_build_instruction<IrInstructionUnreachable>(irb, scope, source_node);
2146		unreachable_instruction->base.value->special = ConstValSpecialStatic;
2147		unreachable_instruction->base.value->type = irb->codegen->builtin_types.entry_unreachable;
2148		return &unreachable_instruction->base;
	2683	static IrInstSrc ir_build_unreachable(IrBuilderSrc irb, Scope scope, AstNode source_node) {
	2684	IrInstSrcUnreachable *inst = ir_build_instruction<IrInstSrcUnreachable>(irb, scope, source_node);
	2685	inst->base.is_noreturn = true;
	2686	return &inst->base;
2149	2687	}
2150	2688
2151		static IrInstructionStorePtr ir_build_store_ptr(IrBuilder irb, Scope scope, AstNode source_node,
2152		IrInstruction ptr, IrInstruction value)
	2689	static IrInstGen ir_build_unreachable_gen(IrAnalyze ira, IrInst *source_instr) {
	2690	IrInstGenUnreachable *inst = ir_build_inst_noreturn<IrInstGenUnreachable>(&ira->new_irb, source_instr->scope, source_instr->source_node);
	2691	return &inst->base;
	2692	}
	2693
	2694	static IrInstSrcStorePtr ir_build_store_ptr(IrBuilderSrc irb, Scope scope, AstNode source_node,
	2695	IrInstSrc ptr, IrInstSrc value)
2153	2696	{
2154		IrInstructionStorePtr *instruction = ir_build_instruction<IrInstructionStorePtr>(irb, scope, source_node);
2155		instruction->base.value->special = ConstValSpecialStatic;
2156		instruction->base.value->type = irb->codegen->builtin_types.entry_void;
	2697	IrInstSrcStorePtr *instruction = ir_build_instruction<IrInstSrcStorePtr>(irb, scope, source_node);
2157	2698	instruction->ptr = ptr;
2158	2699	instruction->value = value;
2159	2700
...	...	@@ -2163,76 +2704,83 @@ static IrInstructionStorePtr ir_build_store_ptr(IrBuilder irb, Scope *scope, A
2163	2704	return instruction;
2164	2705	}
2165	2706
2166		static IrInstruction ir_build_vector_store_elem(IrAnalyze ira, IrInstruction *source_instruction,
2167		IrInstruction vector_ptr, IrInstruction index, IrInstruction *value)
	2707	static IrInstGen ir_build_store_ptr_gen(IrAnalyze ira, IrInst source_instr, IrInstGen ptr, IrInstGen *value) {
	2708	IrInstGenStorePtr *instruction = ir_build_inst_void<IrInstGenStorePtr>(&ira->new_irb,
	2709	source_instr->scope, source_instr->source_node);
	2710	instruction->ptr = ptr;
	2711	instruction->value = value;
	2712
	2713	ir_ref_inst_gen(ptr, ira->new_irb.current_basic_block);
	2714	ir_ref_inst_gen(value, ira->new_irb.current_basic_block);
	2715
	2716	return &instruction->base;
	2717	}
	2718
	2719	static IrInstGen ir_build_vector_store_elem(IrAnalyze ira, IrInst *src_inst,
	2720	IrInstGen vector_ptr, IrInstGen index, IrInstGen *value)
2168	2721	{
2169		IrInstructionVectorStoreElem *inst = ir_build_instruction<IrInstructionVectorStoreElem>(
2170		&ira->new_irb, source_instruction->scope, source_instruction->source_node);
2171		inst->base.value->type = ira->codegen->builtin_types.entry_void;
	2722	IrInstGenVectorStoreElem *inst = ir_build_inst_void<IrInstGenVectorStoreElem>(
	2723	&ira->new_irb, src_inst->scope, src_inst->source_node);
2172	2724	inst->vector_ptr = vector_ptr;
2173	2725	inst->index = index;
2174	2726	inst->value = value;
2175	2727
2176		ir_ref_instruction(vector_ptr, ira->new_irb.current_basic_block);
2177		ir_ref_instruction(index, ira->new_irb.current_basic_block);
2178		ir_ref_instruction(value, ira->new_irb.current_basic_block);
	2728	ir_ref_inst_gen(vector_ptr, ira->new_irb.current_basic_block);
	2729	ir_ref_inst_gen(index, ira->new_irb.current_basic_block);
	2730	ir_ref_inst_gen(value, ira->new_irb.current_basic_block);
2179	2731
2180	2732	return &inst->base;
2181	2733	}
2182	2734
2183		static IrInstruction ir_build_var_decl_src(IrBuilder irb, Scope scope, AstNode source_node,
2184		ZigVar var, IrInstruction align_value, IrInstruction *ptr)
	2735	static IrInstSrc ir_build_var_decl_src(IrBuilderSrc irb, Scope scope, AstNode source_node,
	2736	ZigVar var, IrInstSrc align_value, IrInstSrc *ptr)
2185	2737	{
2186		IrInstructionDeclVarSrc *decl_var_instruction = ir_build_instruction<IrInstructionDeclVarSrc>(irb, scope, source_node);
2187		decl_var_instruction->base.value->special = ConstValSpecialStatic;
2188		decl_var_instruction->base.value->type = irb->codegen->builtin_types.entry_void;
2189		decl_var_instruction->var = var;
2190		decl_var_instruction->align_value = align_value;
2191		decl_var_instruction->ptr = ptr;
	2738	IrInstSrcDeclVar *inst = ir_build_instruction<IrInstSrcDeclVar>(irb, scope, source_node);
	2739	inst->var = var;
	2740	inst->align_value = align_value;
	2741	inst->ptr = ptr;
2192	2742
2193	2743	if (align_value != nullptr) ir_ref_instruction(align_value, irb->current_basic_block);
2194	2744	ir_ref_instruction(ptr, irb->current_basic_block);
2195	2745
2196		return &decl_var_instruction->base;
	2746	return &inst->base;
2197	2747	}
2198	2748
2199		static IrInstruction ir_build_var_decl_gen(IrAnalyze ira, IrInstruction *source_instruction,
2200		ZigVar var, IrInstruction var_ptr)
	2749	static IrInstGen ir_build_var_decl_gen(IrAnalyze ira, IrInst *source_instruction,
	2750	ZigVar var, IrInstGen var_ptr)
2201	2751	{
2202		IrInstructionDeclVarGen *decl_var_instruction = ir_build_instruction<IrInstructionDeclVarGen>(&ira->new_irb,
	2752	IrInstGenDeclVar *inst = ir_build_inst_gen<IrInstGenDeclVar>(&ira->new_irb,
2203	2753	source_instruction->scope, source_instruction->source_node);
2204		decl_var_instruction->base.value->special = ConstValSpecialStatic;
2205		decl_var_instruction->base.value->type = ira->codegen->builtin_types.entry_void;
2206		decl_var_instruction->var = var;
2207		decl_var_instruction->var_ptr = var_ptr;
	2754	inst->base.value->special = ConstValSpecialStatic;
	2755	inst->base.value->type = ira->codegen->builtin_types.entry_void;
	2756	inst->var = var;
	2757	inst->var_ptr = var_ptr;
2208	2758
2209		ir_ref_instruction(var_ptr, ira->new_irb.current_basic_block);
	2759	ir_ref_inst_gen(var_ptr, ira->new_irb.current_basic_block);
2210	2760
2211		return &decl_var_instruction->base;
	2761	return &inst->base;
2212	2762	}
2213	2763
2214		static IrInstruction ir_build_resize_slice(IrAnalyze ira, IrInstruction *source_instruction,
2215		IrInstruction operand, ZigType ty, IrInstruction *result_loc)
	2764	static IrInstGen ir_build_resize_slice(IrAnalyze ira, IrInst *source_instruction,
	2765	IrInstGen operand, ZigType ty, IrInstGen *result_loc)
2216	2766	{
2217		IrInstructionResizeSlice *instruction = ir_build_instruction<IrInstructionResizeSlice>(&ira->new_irb,
	2767	IrInstGenResizeSlice *instruction = ir_build_inst_gen<IrInstGenResizeSlice>(&ira->new_irb,
2218	2768	source_instruction->scope, source_instruction->source_node);
2219	2769	instruction->base.value->type = ty;
2220	2770	instruction->operand = operand;
2221	2771	instruction->result_loc = result_loc;
2222	2772
2223		ir_ref_instruction(operand, ira->new_irb.current_basic_block);
2224		if (result_loc != nullptr) ir_ref_instruction(result_loc, ira->new_irb.current_basic_block);
	2773	ir_ref_inst_gen(operand, ira->new_irb.current_basic_block);
	2774	if (result_loc != nullptr) ir_ref_inst_gen(result_loc, ira->new_irb.current_basic_block);
2225	2775
2226	2776	return &instruction->base;
2227	2777	}
2228	2778
2229		static IrInstruction ir_build_export(IrBuilder irb, Scope scope, AstNode source_node,
2230		IrInstruction target, IrInstruction options)
	2779	static IrInstSrc ir_build_export(IrBuilderSrc irb, Scope scope, AstNode source_node,
	2780	IrInstSrc target, IrInstSrc options)
2231	2781	{
2232		IrInstructionExport *export_instruction = ir_build_instruction<IrInstructionExport>(
	2782	IrInstSrcExport *export_instruction = ir_build_instruction<IrInstSrcExport>(
2233	2783	irb, scope, source_node);
2234		export_instruction->base.value->special = ConstValSpecialStatic;
2235		export_instruction->base.value->type = irb->codegen->builtin_types.entry_void;
2236	2784	export_instruction->target = target;
2237	2785	export_instruction->options = options;
2238	2786
...	...	@@ -2242,8 +2790,8 @@ static IrInstruction ir_build_export(IrBuilder irb, Scope scope, AstNode sou
2242	2790	return &export_instruction->base;
2243	2791	}
2244	2792
2245		static IrInstruction ir_build_load_ptr(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *ptr) {
2246		IrInstructionLoadPtr *instruction = ir_build_instruction<IrInstructionLoadPtr>(irb, scope, source_node);
	2793	static IrInstSrc ir_build_load_ptr(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *ptr) {
	2794	IrInstSrcLoadPtr *instruction = ir_build_instruction<IrInstSrcLoadPtr>(irb, scope, source_node);
2247	2795	instruction->ptr = ptr;
2248	2796
2249	2797	ir_ref_instruction(ptr, irb->current_basic_block);
...	...	@@ -2251,8 +2799,23 @@ static IrInstruction ir_build_load_ptr(IrBuilder irb, Scope scope, AstNode s
2251	2799	return &instruction->base;
2252	2800	}
2253	2801
2254		static IrInstruction ir_build_typeof(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *value) {
2255		IrInstructionTypeOf *instruction = ir_build_instruction<IrInstructionTypeOf>(irb, scope, source_node);
	2802	static IrInstGen ir_build_load_ptr_gen(IrAnalyze ira, IrInst *source_instruction,
	2803	IrInstGen ptr, ZigType ty, IrInstGen *result_loc)
	2804	{
	2805	IrInstGenLoadPtr *instruction = ir_build_inst_gen<IrInstGenLoadPtr>(
	2806	&ira->new_irb, source_instruction->scope, source_instruction->source_node);
	2807	instruction->base.value->type = ty;
	2808	instruction->ptr = ptr;
	2809	instruction->result_loc = result_loc;
	2810
	2811	ir_ref_inst_gen(ptr, ira->new_irb.current_basic_block);
	2812	if (result_loc != nullptr) ir_ref_inst_gen(result_loc, ira->new_irb.current_basic_block);
	2813
	2814	return &instruction->base;
	2815	}
	2816
	2817	static IrInstSrc ir_build_typeof(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *value) {
	2818	IrInstSrcTypeOf *instruction = ir_build_instruction<IrInstSrcTypeOf>(irb, scope, source_node);
2256	2819	instruction->value = value;
2257	2820
2258	2821	ir_ref_instruction(value, irb->current_basic_block);
...	...	@@ -2260,8 +2823,8 @@ static IrInstruction ir_build_typeof(IrBuilder irb, Scope scope, AstNode sou
2260	2823	return &instruction->base;
2261	2824	}
2262	2825
2263		static IrInstruction ir_build_set_cold(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *is_cold) {
2264		IrInstructionSetCold *instruction = ir_build_instruction<IrInstructionSetCold>(irb, scope, source_node);
	2826	static IrInstSrc ir_build_set_cold(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *is_cold) {
	2827	IrInstSrcSetCold *instruction = ir_build_instruction<IrInstSrcSetCold>(irb, scope, source_node);
2265	2828	instruction->is_cold = is_cold;
2266	2829
2267	2830	ir_ref_instruction(is_cold, irb->current_basic_block);
...	...	@@ -2269,21 +2832,21 @@ static IrInstruction ir_build_set_cold(IrBuilder irb, Scope scope, AstNode s
2269	2832	return &instruction->base;
2270	2833	}
2271	2834
2272		static IrInstruction ir_build_set_runtime_safety(IrBuilder irb, Scope scope, AstNode source_node,
2273		IrInstruction *safety_on)
	2835	static IrInstSrc ir_build_set_runtime_safety(IrBuilderSrc irb, Scope scope, AstNode source_node,
	2836	IrInstSrc *safety_on)
2274	2837	{
2275		IrInstructionSetRuntimeSafety *instruction = ir_build_instruction<IrInstructionSetRuntimeSafety>(irb, scope, source_node);
2276		instruction->safety_on = safety_on;
	2838	IrInstSrcSetRuntimeSafety *inst = ir_build_instruction<IrInstSrcSetRuntimeSafety>(irb, scope, source_node);
	2839	inst->safety_on = safety_on;
2277	2840
2278	2841	ir_ref_instruction(safety_on, irb->current_basic_block);
2279	2842
2280		return &instruction->base;
	2843	return &inst->base;
2281	2844	}
2282	2845
2283		static IrInstruction ir_build_set_float_mode(IrBuilder irb, Scope scope, AstNode source_node,
2284		IrInstruction *mode_value)
	2846	static IrInstSrc ir_build_set_float_mode(IrBuilderSrc irb, Scope scope, AstNode source_node,
	2847	IrInstSrc *mode_value)
2285	2848	{
2286		IrInstructionSetFloatMode *instruction = ir_build_instruction<IrInstructionSetFloatMode>(irb, scope, source_node);
	2849	IrInstSrcSetFloatMode *instruction = ir_build_instruction<IrInstSrcSetFloatMode>(irb, scope, source_node);
2287	2850	instruction->mode_value = mode_value;
2288	2851
2289	2852	ir_ref_instruction(mode_value, irb->current_basic_block);
...	...	@@ -2291,10 +2854,10 @@ static IrInstruction ir_build_set_float_mode(IrBuilder irb, Scope *scope, AstN
2291	2854	return &instruction->base;
2292	2855	}
2293	2856
2294		static IrInstruction ir_build_array_type(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *size,
2295		IrInstruction sentinel, IrInstruction child_type)
	2857	static IrInstSrc ir_build_array_type(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *size,
	2858	IrInstSrc sentinel, IrInstSrc child_type)
2296	2859	{
2297		IrInstructionArrayType *instruction = ir_build_instruction<IrInstructionArrayType>(irb, scope, source_node);
	2860	IrInstSrcArrayType *instruction = ir_build_instruction<IrInstSrcArrayType>(irb, scope, source_node);
2298	2861	instruction->size = size;
2299	2862	instruction->sentinel = sentinel;
2300	2863	instruction->child_type = child_type;
...	...	@@ -2306,10 +2869,10 @@ static IrInstruction ir_build_array_type(IrBuilder irb, Scope *scope, AstNode
2306	2869	return &instruction->base;
2307	2870	}
2308	2871
2309		static IrInstruction ir_build_anyframe_type(IrBuilder irb, Scope scope, AstNode source_node,
2310		IrInstruction *payload_type)
	2872	static IrInstSrc ir_build_anyframe_type(IrBuilderSrc irb, Scope scope, AstNode source_node,
	2873	IrInstSrc *payload_type)
2311	2874	{
2312		IrInstructionAnyFrameType *instruction = ir_build_instruction<IrInstructionAnyFrameType>(irb, scope, source_node);
	2875	IrInstSrcAnyFrameType *instruction = ir_build_instruction<IrInstSrcAnyFrameType>(irb, scope, source_node);
2313	2876	instruction->payload_type = payload_type;
2314	2877
2315	2878	if (payload_type != nullptr) ir_ref_instruction(payload_type, irb->current_basic_block);
...	...	@@ -2317,11 +2880,11 @@ static IrInstruction ir_build_anyframe_type(IrBuilder irb, Scope *scope, AstNo
2317	2880	return &instruction->base;
2318	2881	}
2319	2882
2320		static IrInstruction ir_build_slice_type(IrBuilder irb, Scope scope, AstNode source_node,
2321		IrInstruction *child_type, bool is_const, bool is_volatile,
2322		IrInstruction sentinel, IrInstruction align_value, bool is_allow_zero)
	2883	static IrInstSrc ir_build_slice_type(IrBuilderSrc irb, Scope scope, AstNode source_node,
	2884	IrInstSrc *child_type, bool is_const, bool is_volatile,
	2885	IrInstSrc sentinel, IrInstSrc align_value, bool is_allow_zero)
2323	2886	{
2324		IrInstructionSliceType *instruction = ir_build_instruction<IrInstructionSliceType>(irb, scope, source_node);
	2887	IrInstSrcSliceType *instruction = ir_build_instruction<IrInstSrcSliceType>(irb, scope, source_node);
2325	2888	instruction->is_const = is_const;
2326	2889	instruction->is_volatile = is_volatile;
2327	2890	instruction->child_type = child_type;
...	...	@@ -2336,11 +2899,11 @@ static IrInstruction ir_build_slice_type(IrBuilder irb, Scope *scope, AstNode
2336	2899	return &instruction->base;
2337	2900	}
2338	2901
2339		static IrInstruction ir_build_asm_src(IrBuilder irb, Scope scope, AstNode source_node,
2340		IrInstruction asm_template, IrInstruction input_list, IrInstruction *output_types,
	2902	static IrInstSrc ir_build_asm_src(IrBuilderSrc irb, Scope scope, AstNode source_node,
	2903	IrInstSrc asm_template, IrInstSrc input_list, IrInstSrc *output_types,
2341	2904	ZigVar **output_vars, size_t return_count, bool has_side_effects, bool is_global)
2342	2905	{
2343		IrInstructionAsmSrc *instruction = ir_build_instruction<IrInstructionAsmSrc>(irb, scope, source_node);
	2906	IrInstSrcAsm *instruction = ir_build_instruction<IrInstSrcAsm>(irb, scope, source_node);
2344	2907	instruction->asm_template = asm_template;
2345	2908	instruction->input_list = input_list;
2346	2909	instruction->output_types = output_types;
...	...	@@ -2351,24 +2914,25 @@ static IrInstruction ir_build_asm_src(IrBuilder irb, Scope scope, AstNode so
2351	2914
2352	2915	assert(source_node->type == NodeTypeAsmExpr);
2353	2916	for (size_t i = 0; i < source_node->data.asm_expr.output_list.length; i += 1) {
2354		IrInstruction *output_type = output_types[i];
	2917	IrInstSrc *output_type = output_types[i];
2355	2918	if (output_type) ir_ref_instruction(output_type, irb->current_basic_block);
2356	2919	}
2357	2920
2358	2921	for (size_t i = 0; i < source_node->data.asm_expr.input_list.length; i += 1) {
2359		IrInstruction *input_value = input_list[i];
	2922	IrInstSrc *input_value = input_list[i];
2360	2923	ir_ref_instruction(input_value, irb->current_basic_block);
2361	2924	}
2362	2925
2363	2926	return &instruction->base;
2364	2927	}
2365	2928
2366		static IrInstruction ir_build_asm_gen(IrAnalyze ira, Scope scope, AstNode source_node,
	2929	static IrInstGen ir_build_asm_gen(IrAnalyze ira, IrInst *source_instr,
2367	2930	Buf asm_template, AsmToken token_list, size_t token_list_len,
2368		IrInstruction input_list, IrInstruction output_types, ZigVar **output_vars, size_t return_count,
2369		bool has_side_effects)
	2931	IrInstGen input_list, IrInstGen output_types, ZigVar **output_vars, size_t return_count,
	2932	bool has_side_effects, ZigType *return_type)
2370	2933	{
2371		IrInstructionAsmGen *instruction = ir_build_instruction<IrInstructionAsmGen>(&ira->new_irb, scope, source_node);
	2934	IrInstGenAsm *instruction = ir_build_inst_gen<IrInstGenAsm>(&ira->new_irb, source_instr->scope, source_instr->source_node);
	2935	instruction->base.value->type = return_type;
2372	2936	instruction->asm_template = asm_template;
2373	2937	instruction->token_list = token_list;
2374	2938	instruction->token_list_len = token_list_len;
...	...	@@ -2378,22 +2942,24 @@ static IrInstruction ir_build_asm_gen(IrAnalyze ira, Scope scope, AstNode so
2378	2942	instruction->return_count = return_count;
2379	2943	instruction->has_side_effects = has_side_effects;
2380	2944
2381		assert(source_node->type == NodeTypeAsmExpr);
2382		for (size_t i = 0; i < source_node->data.asm_expr.output_list.length; i += 1) {
2383		IrInstruction *output_type = output_types[i];
2384		if (output_type) ir_ref_instruction(output_type, ira->new_irb.current_basic_block);
	2945	assert(source_instr->source_node->type == NodeTypeAsmExpr);
	2946	for (size_t i = 0; i < source_instr->source_node->data.asm_expr.output_list.length; i += 1) {
	2947	IrInstGen *output_type = output_types[i];
	2948	if (output_type) ir_ref_inst_gen(output_type, ira->new_irb.current_basic_block);
2385	2949	}
2386	2950
2387		for (size_t i = 0; i < source_node->data.asm_expr.input_list.length; i += 1) {
2388		IrInstruction *input_value = input_list[i];
2389		ir_ref_instruction(input_value, ira->new_irb.current_basic_block);
	2951	for (size_t i = 0; i < source_instr->source_node->data.asm_expr.input_list.length; i += 1) {
	2952	IrInstGen *input_value = input_list[i];
	2953	ir_ref_inst_gen(input_value, ira->new_irb.current_basic_block);
2390	2954	}
2391	2955
2392	2956	return &instruction->base;
2393	2957	}
2394	2958
2395		static IrInstruction ir_build_size_of(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *type_value, bool bit_size) {
2396		IrInstructionSizeOf *instruction = ir_build_instruction<IrInstructionSizeOf>(irb, scope, source_node);
	2959	static IrInstSrc ir_build_size_of(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *type_value,
	2960	bool bit_size)
	2961	{
	2962	IrInstSrcSizeOf *instruction = ir_build_instruction<IrInstSrcSizeOf>(irb, scope, source_node);
2397	2963	instruction->type_value = type_value;
2398	2964	instruction->bit_size = bit_size;
2399	2965
...	...	@@ -2402,8 +2968,10 @@ static IrInstruction ir_build_size_of(IrBuilder irb, Scope scope, AstNode so
2402	2968	return &instruction->base;
2403	2969	}
2404	2970
2405		static IrInstruction ir_build_test_nonnull(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *value) {
2406		IrInstructionTestNonNull *instruction = ir_build_instruction<IrInstructionTestNonNull>(irb, scope, source_node);
	2971	static IrInstSrc ir_build_test_non_null_src(IrBuilderSrc irb, Scope scope, AstNode source_node,
	2972	IrInstSrc *value)
	2973	{
	2974	IrInstSrcTestNonNull *instruction = ir_build_instruction<IrInstSrcTestNonNull>(irb, scope, source_node);
2407	2975	instruction->value = value;
2408	2976
2409	2977	ir_ref_instruction(value, irb->current_basic_block);
...	...	@@ -2411,10 +2979,21 @@ static IrInstruction ir_build_test_nonnull(IrBuilder irb, Scope *scope, AstNod
2411	2979	return &instruction->base;
2412	2980	}
2413	2981
2414		static IrInstruction ir_build_optional_unwrap_ptr(IrBuilder irb, Scope scope, AstNode source_node,
2415		IrInstruction *base_ptr, bool safety_check_on, bool initializing)
	2982	static IrInstGen ir_build_test_non_null_gen(IrAnalyze ira, IrInst source_instr, IrInstGen value) {
	2983	IrInstGenTestNonNull *inst = ir_build_inst_gen<IrInstGenTestNonNull>(&ira->new_irb,
	2984	source_instr->scope, source_instr->source_node);
	2985	inst->base.value->type = ira->codegen->builtin_types.entry_bool;
	2986	inst->value = value;
	2987
	2988	ir_ref_inst_gen(value, ira->new_irb.current_basic_block);
	2989
	2990	return &inst->base;
	2991	}
	2992
	2993	static IrInstSrc ir_build_optional_unwrap_ptr(IrBuilderSrc irb, Scope scope, AstNode source_node,
	2994	IrInstSrc *base_ptr, bool safety_check_on, bool initializing)
2416	2995	{
2417		IrInstructionOptionalUnwrapPtr *instruction = ir_build_instruction<IrInstructionOptionalUnwrapPtr>(irb, scope, source_node);
	2996	IrInstSrcOptionalUnwrapPtr *instruction = ir_build_instruction<IrInstSrcOptionalUnwrapPtr>(irb, scope, source_node);
2418	2997	instruction->base_ptr = base_ptr;
2419	2998	instruction->safety_check_on = safety_check_on;
2420	2999	instruction->initializing = initializing;
...	...	@@ -2424,113 +3003,198 @@ static IrInstruction ir_build_optional_unwrap_ptr(IrBuilder irb, Scope *scope,
2424	3003	return &instruction->base;
2425	3004	}
2426	3005
2427		static IrInstruction ir_build_optional_wrap(IrAnalyze ira, IrInstruction source_instruction, ZigType result_ty,
2428		IrInstruction operand, IrInstruction result_loc)
	3006	static IrInstGen ir_build_optional_unwrap_ptr_gen(IrAnalyze ira, IrInst *source_instr,
	3007	IrInstGen base_ptr, bool safety_check_on, bool initializing, ZigType result_type)
	3008	{
	3009	IrInstGenOptionalUnwrapPtr *inst = ir_build_inst_gen<IrInstGenOptionalUnwrapPtr>(&ira->new_irb,
	3010	source_instr->scope, source_instr->source_node);
	3011	inst->base.value->type = result_type;
	3012	inst->base_ptr = base_ptr;
	3013	inst->safety_check_on = safety_check_on;
	3014	inst->initializing = initializing;
	3015
	3016	ir_ref_inst_gen(base_ptr, ira->new_irb.current_basic_block);
	3017
	3018	return &inst->base;
	3019	}
	3020
	3021	static IrInstGen ir_build_optional_wrap(IrAnalyze ira, IrInst source_instruction, ZigType result_ty,
	3022	IrInstGen operand, IrInstGen result_loc)
2429	3023	{
2430		IrInstructionOptionalWrap *instruction = ir_build_instruction<IrInstructionOptionalWrap>(
	3024	IrInstGenOptionalWrap *instruction = ir_build_inst_gen<IrInstGenOptionalWrap>(
2431	3025	&ira->new_irb, source_instruction->scope, source_instruction->source_node);
2432	3026	instruction->base.value->type = result_ty;
2433	3027	instruction->operand = operand;
2434	3028	instruction->result_loc = result_loc;
2435	3029
2436		ir_ref_instruction(operand, ira->new_irb.current_basic_block);
2437		if (result_loc != nullptr) ir_ref_instruction(result_loc, ira->new_irb.current_basic_block);
	3030	ir_ref_inst_gen(operand, ira->new_irb.current_basic_block);
	3031	if (result_loc != nullptr) ir_ref_inst_gen(result_loc, ira->new_irb.current_basic_block);
2438	3032
2439	3033	return &instruction->base;
2440	3034	}
2441	3035
2442		static IrInstruction ir_build_err_wrap_payload(IrAnalyze ira, IrInstruction *source_instruction,
2443		ZigType result_type, IrInstruction operand, IrInstruction *result_loc)
	3036	static IrInstGen ir_build_err_wrap_payload(IrAnalyze ira, IrInst *source_instruction,
	3037	ZigType result_type, IrInstGen operand, IrInstGen *result_loc)
2444	3038	{
2445		IrInstructionErrWrapPayload *instruction = ir_build_instruction<IrInstructionErrWrapPayload>(
	3039	IrInstGenErrWrapPayload *instruction = ir_build_inst_gen<IrInstGenErrWrapPayload>(
2446	3040	&ira->new_irb, source_instruction->scope, source_instruction->source_node);
2447	3041	instruction->base.value->type = result_type;
2448	3042	instruction->operand = operand;
2449	3043	instruction->result_loc = result_loc;
2450	3044
2451		ir_ref_instruction(operand, ira->new_irb.current_basic_block);
2452		if (result_loc != nullptr) ir_ref_instruction(result_loc, ira->new_irb.current_basic_block);
	3045	ir_ref_inst_gen(operand, ira->new_irb.current_basic_block);
	3046	if (result_loc != nullptr) ir_ref_inst_gen(result_loc, ira->new_irb.current_basic_block);
2453	3047
2454	3048	return &instruction->base;
2455	3049	}
2456	3050
2457		static IrInstruction ir_build_err_wrap_code(IrAnalyze ira, IrInstruction *source_instruction,
2458		ZigType result_type, IrInstruction operand, IrInstruction *result_loc)
	3051	static IrInstGen ir_build_err_wrap_code(IrAnalyze ira, IrInst *source_instruction,
	3052	ZigType result_type, IrInstGen operand, IrInstGen *result_loc)
2459	3053	{
2460		IrInstructionErrWrapCode *instruction = ir_build_instruction<IrInstructionErrWrapCode>(
	3054	IrInstGenErrWrapCode *instruction = ir_build_inst_gen<IrInstGenErrWrapCode>(
2461	3055	&ira->new_irb, source_instruction->scope, source_instruction->source_node);
2462	3056	instruction->base.value->type = result_type;
2463	3057	instruction->operand = operand;
2464	3058	instruction->result_loc = result_loc;
2465	3059
2466		ir_ref_instruction(operand, ira->new_irb.current_basic_block);
2467		if (result_loc != nullptr) ir_ref_instruction(result_loc, ira->new_irb.current_basic_block);
	3060	ir_ref_inst_gen(operand, ira->new_irb.current_basic_block);
	3061	if (result_loc != nullptr) ir_ref_inst_gen(result_loc, ira->new_irb.current_basic_block);
2468	3062
2469	3063	return &instruction->base;
2470	3064	}
2471	3065
2472		static IrInstruction ir_build_clz(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction type, IrInstruction op) {
2473		IrInstructionClz *instruction = ir_build_instruction<IrInstructionClz>(irb, scope, source_node);
	3066	static IrInstSrc ir_build_clz(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *type,
	3067	IrInstSrc *op)
	3068	{
	3069	IrInstSrcClz *instruction = ir_build_instruction<IrInstSrcClz>(irb, scope, source_node);
2474	3070	instruction->type = type;
2475	3071	instruction->op = op;
2476	3072
2477		if (type != nullptr) ir_ref_instruction(type, irb->current_basic_block);
	3073	ir_ref_instruction(type, irb->current_basic_block);
2478	3074	ir_ref_instruction(op, irb->current_basic_block);
2479	3075
2480	3076	return &instruction->base;
2481	3077	}
2482	3078
2483		static IrInstruction ir_build_ctz(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction type, IrInstruction op) {
2484		IrInstructionCtz *instruction = ir_build_instruction<IrInstructionCtz>(irb, scope, source_node);
	3079	static IrInstGen ir_build_clz_gen(IrAnalyze ira, IrInst source_instr, ZigType result_type, IrInstGen *op) {
	3080	IrInstGenClz *instruction = ir_build_inst_gen<IrInstGenClz>(&ira->new_irb,
	3081	source_instr->scope, source_instr->source_node);
	3082	instruction->base.value->type = result_type;
	3083	instruction->op = op;
	3084
	3085	ir_ref_inst_gen(op, ira->new_irb.current_basic_block);
	3086
	3087	return &instruction->base;
	3088	}
	3089
	3090	static IrInstSrc ir_build_ctz(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *type,
	3091	IrInstSrc *op)
	3092	{
	3093	IrInstSrcCtz *instruction = ir_build_instruction<IrInstSrcCtz>(irb, scope, source_node);
2485	3094	instruction->type = type;
2486	3095	instruction->op = op;
2487	3096
2488		if (type != nullptr) ir_ref_instruction(type, irb->current_basic_block);
	3097	ir_ref_instruction(type, irb->current_basic_block);
2489	3098	ir_ref_instruction(op, irb->current_basic_block);
2490	3099
2491	3100	return &instruction->base;
2492	3101	}
2493	3102
2494		static IrInstruction ir_build_pop_count(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction type, IrInstruction op) {
2495		IrInstructionPopCount *instruction = ir_build_instruction<IrInstructionPopCount>(irb, scope, source_node);
	3103	static IrInstGen ir_build_ctz_gen(IrAnalyze ira, IrInst source_instr, ZigType result_type, IrInstGen *op) {
	3104	IrInstGenCtz *instruction = ir_build_inst_gen<IrInstGenCtz>(&ira->new_irb,
	3105	source_instr->scope, source_instr->source_node);
	3106	instruction->base.value->type = result_type;
	3107	instruction->op = op;
	3108
	3109	ir_ref_inst_gen(op, ira->new_irb.current_basic_block);
	3110
	3111	return &instruction->base;
	3112	}
	3113
	3114	static IrInstSrc ir_build_pop_count(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *type,
	3115	IrInstSrc *op)
	3116	{
	3117	IrInstSrcPopCount *instruction = ir_build_instruction<IrInstSrcPopCount>(irb, scope, source_node);
2496	3118	instruction->type = type;
2497	3119	instruction->op = op;
2498	3120
2499		if (type != nullptr) ir_ref_instruction(type, irb->current_basic_block);
	3121	ir_ref_instruction(type, irb->current_basic_block);
2500	3122	ir_ref_instruction(op, irb->current_basic_block);
2501	3123
2502	3124	return &instruction->base;
2503	3125	}
2504	3126
2505		static IrInstruction ir_build_bswap(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction type, IrInstruction op) {
2506		IrInstructionBswap *instruction = ir_build_instruction<IrInstructionBswap>(irb, scope, source_node);
	3127	static IrInstGen ir_build_pop_count_gen(IrAnalyze ira, IrInst source_instr, ZigType result_type,
	3128	IrInstGen *op)
	3129	{
	3130	IrInstGenPopCount *instruction = ir_build_inst_gen<IrInstGenPopCount>(&ira->new_irb,
	3131	source_instr->scope, source_instr->source_node);
	3132	instruction->base.value->type = result_type;
	3133	instruction->op = op;
	3134
	3135	ir_ref_inst_gen(op, ira->new_irb.current_basic_block);
	3136
	3137	return &instruction->base;
	3138	}
	3139
	3140	static IrInstSrc ir_build_bswap(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *type,
	3141	IrInstSrc *op)
	3142	{
	3143	IrInstSrcBswap *instruction = ir_build_instruction<IrInstSrcBswap>(irb, scope, source_node);
2507	3144	instruction->type = type;
2508	3145	instruction->op = op;
2509	3146
2510		if (type != nullptr) ir_ref_instruction(type, irb->current_basic_block);
	3147	ir_ref_instruction(type, irb->current_basic_block);
2511	3148	ir_ref_instruction(op, irb->current_basic_block);
2512	3149
2513	3150	return &instruction->base;
2514	3151	}
2515	3152
2516		static IrInstruction ir_build_bit_reverse(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction type, IrInstruction op) {
2517		IrInstructionBitReverse *instruction = ir_build_instruction<IrInstructionBitReverse>(irb, scope, source_node);
	3153	static IrInstGen ir_build_bswap_gen(IrAnalyze ira, IrInst source_instr, ZigType op_type,
	3154	IrInstGen *op)
	3155	{
	3156	IrInstGenBswap *instruction = ir_build_inst_gen<IrInstGenBswap>(&ira->new_irb,
	3157	source_instr->scope, source_instr->source_node);
	3158	instruction->base.value->type = op_type;
	3159	instruction->op = op;
	3160
	3161	ir_ref_inst_gen(op, ira->new_irb.current_basic_block);
	3162
	3163	return &instruction->base;
	3164	}
	3165
	3166	static IrInstSrc ir_build_bit_reverse(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *type,
	3167	IrInstSrc *op)
	3168	{
	3169	IrInstSrcBitReverse *instruction = ir_build_instruction<IrInstSrcBitReverse>(irb, scope, source_node);
2518	3170	instruction->type = type;
2519	3171	instruction->op = op;
2520	3172
2521		if (type != nullptr) ir_ref_instruction(type, irb->current_basic_block);
	3173	ir_ref_instruction(type, irb->current_basic_block);
2522	3174	ir_ref_instruction(op, irb->current_basic_block);
2523	3175
2524	3176	return &instruction->base;
2525	3177	}
2526	3178
2527		static IrInstructionSwitchBr ir_build_switch_br(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *target_value,
2528		IrBasicBlock else_block, size_t case_count, IrInstructionSwitchBrCase cases, IrInstruction *is_comptime,
2529		IrInstruction *switch_prongs_void)
	3179	static IrInstGen ir_build_bit_reverse_gen(IrAnalyze ira, IrInst source_instr, ZigType int_type,
	3180	IrInstGen *op)
	3181	{
	3182	IrInstGenBitReverse *instruction = ir_build_inst_gen<IrInstGenBitReverse>(&ira->new_irb,
	3183	source_instr->scope, source_instr->source_node);
	3184	instruction->base.value->type = int_type;
	3185	instruction->op = op;
	3186
	3187	ir_ref_inst_gen(op, ira->new_irb.current_basic_block);
	3188
	3189	return &instruction->base;
	3190	}
	3191
	3192	static IrInstSrcSwitchBr ir_build_switch_br_src(IrBuilderSrc irb, Scope scope, AstNode source_node,
	3193	IrInstSrc target_value, IrBasicBlockSrc else_block, size_t case_count, IrInstSrcSwitchBrCase *cases,
	3194	IrInstSrc is_comptime, IrInstSrc switch_prongs_void)
2530	3195	{
2531		IrInstructionSwitchBr *instruction = ir_build_instruction<IrInstructionSwitchBr>(irb, scope, source_node);
2532		instruction->base.value->type = irb->codegen->builtin_types.entry_unreachable;
2533		instruction->base.value->special = ConstValSpecialStatic;
	3196	IrInstSrcSwitchBr *instruction = ir_build_instruction<IrInstSrcSwitchBr>(irb, scope, source_node);
	3197	instruction->base.is_noreturn = true;
2534	3198	instruction->target_value = target_value;
2535	3199	instruction->else_block = else_block;
2536	3200	instruction->case_count = case_count;
...	...	@@ -2539,9 +3203,9 @@ static IrInstructionSwitchBr ir_build_switch_br(IrBuilder irb, Scope *scope, A
2539	3203	instruction->switch_prongs_void = switch_prongs_void;
2540	3204
2541	3205	ir_ref_instruction(target_value, irb->current_basic_block);
2542		if (is_comptime) ir_ref_instruction(is_comptime, irb->current_basic_block);
	3206	ir_ref_instruction(is_comptime, irb->current_basic_block);
2543	3207	ir_ref_bb(else_block);
2544		if (switch_prongs_void) ir_ref_instruction(switch_prongs_void, irb->current_basic_block);
	3208	ir_ref_instruction(switch_prongs_void, irb->current_basic_block);
2545	3209
2546	3210	for (size_t i = 0; i < case_count; i += 1) {
2547	3211	ir_ref_instruction(cases[i].value, irb->current_basic_block);
...	...	@@ -2551,10 +3215,31 @@ static IrInstructionSwitchBr ir_build_switch_br(IrBuilder irb, Scope *scope, A
2551	3215	return instruction;
2552	3216	}
2553	3217
2554		static IrInstruction ir_build_switch_target(IrBuilder irb, Scope scope, AstNode source_node,
2555		IrInstruction *target_value_ptr)
	3218	static IrInstGenSwitchBr ir_build_switch_br_gen(IrAnalyze ira, IrInst *source_instr,
	3219	IrInstGen target_value, IrBasicBlockGen else_block, size_t case_count, IrInstGenSwitchBrCase *cases)
2556	3220	{
2557		IrInstructionSwitchTarget *instruction = ir_build_instruction<IrInstructionSwitchTarget>(irb, scope, source_node);
	3221	IrInstGenSwitchBr *instruction = ir_build_inst_noreturn<IrInstGenSwitchBr>(&ira->new_irb,
	3222	source_instr->scope, source_instr->source_node);
	3223	instruction->target_value = target_value;
	3224	instruction->else_block = else_block;
	3225	instruction->case_count = case_count;
	3226	instruction->cases = cases;
	3227
	3228	ir_ref_inst_gen(target_value, ira->new_irb.current_basic_block);
	3229	ir_ref_bb_gen(else_block);
	3230
	3231	for (size_t i = 0; i < case_count; i += 1) {
	3232	ir_ref_inst_gen(cases[i].value, ira->new_irb.current_basic_block);
	3233	ir_ref_bb_gen(cases[i].block);
	3234	}
	3235
	3236	return instruction;
	3237	}
	3238
	3239	static IrInstSrc ir_build_switch_target(IrBuilderSrc irb, Scope scope, AstNode source_node,
	3240	IrInstSrc *target_value_ptr)
	3241	{
	3242	IrInstSrcSwitchTarget *instruction = ir_build_instruction<IrInstSrcSwitchTarget>(irb, scope, source_node);
2558	3243	instruction->target_value_ptr = target_value_ptr;
2559	3244
2560	3245	ir_ref_instruction(target_value_ptr, irb->current_basic_block);
...	...	@@ -2562,10 +3247,10 @@ static IrInstruction ir_build_switch_target(IrBuilder irb, Scope *scope, AstNo
2562	3247	return &instruction->base;
2563	3248	}
2564	3249
2565		static IrInstruction ir_build_switch_var(IrBuilder irb, Scope scope, AstNode source_node,
2566		IrInstruction target_value_ptr, IrInstruction *prongs_ptr, size_t prongs_len)
	3250	static IrInstSrc ir_build_switch_var(IrBuilderSrc irb, Scope scope, AstNode source_node,
	3251	IrInstSrc target_value_ptr, IrInstSrc *prongs_ptr, size_t prongs_len)
2567	3252	{
2568		IrInstructionSwitchVar *instruction = ir_build_instruction<IrInstructionSwitchVar>(irb, scope, source_node);
	3253	IrInstSrcSwitchVar *instruction = ir_build_instruction<IrInstSrcSwitchVar>(irb, scope, source_node);
2569	3254	instruction->target_value_ptr = target_value_ptr;
2570	3255	instruction->prongs_ptr = prongs_ptr;
2571	3256	instruction->prongs_len = prongs_len;
...	...	@@ -2579,10 +3264,10 @@ static IrInstruction ir_build_switch_var(IrBuilder irb, Scope *scope, AstNode
2579	3264	}
2580	3265
2581	3266	// For this instruction the switch_br must be set later.
2582		static IrInstructionSwitchElseVar ir_build_switch_else_var(IrBuilder irb, Scope scope, AstNode source_node,
2583		IrInstruction *target_value_ptr)
	3267	static IrInstSrcSwitchElseVar ir_build_switch_else_var(IrBuilderSrc irb, Scope scope, AstNode source_node,
	3268	IrInstSrc *target_value_ptr)
2584	3269	{
2585		IrInstructionSwitchElseVar *instruction = ir_build_instruction<IrInstructionSwitchElseVar>(irb, scope, source_node);
	3270	IrInstSrcSwitchElseVar *instruction = ir_build_instruction<IrInstSrcSwitchElseVar>(irb, scope, source_node);
2586	3271	instruction->target_value_ptr = target_value_ptr;
2587	3272
2588	3273	ir_ref_instruction(target_value_ptr, irb->current_basic_block);
...	...	@@ -2590,17 +3275,21 @@ static IrInstructionSwitchElseVar ir_build_switch_else_var(IrBuilder irb, Scop
2590	3275	return instruction;
2591	3276	}
2592	3277
2593		static IrInstruction ir_build_union_tag(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *value) {
2594		IrInstructionUnionTag *instruction = ir_build_instruction<IrInstructionUnionTag>(irb, scope, source_node);
	3278	static IrInstGen ir_build_union_tag(IrAnalyze ira, IrInst source_instr, IrInstGen value,
	3279	ZigType *tag_type)
	3280	{
	3281	IrInstGenUnionTag *instruction = ir_build_inst_gen<IrInstGenUnionTag>(&ira->new_irb,
	3282	source_instr->scope, source_instr->source_node);
2595	3283	instruction->value = value;
	3284	instruction->base.value->type = tag_type;
2596	3285
2597		ir_ref_instruction(value, irb->current_basic_block);
	3286	ir_ref_inst_gen(value, ira->new_irb.current_basic_block);
2598	3287
2599	3288	return &instruction->base;
2600	3289	}
2601	3290
2602		static IrInstruction ir_build_import(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *name) {
2603		IrInstructionImport *instruction = ir_build_instruction<IrInstructionImport>(irb, scope, source_node);
	3291	static IrInstSrc ir_build_import(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *name) {
	3292	IrInstSrcImport *instruction = ir_build_instruction<IrInstSrcImport>(irb, scope, source_node);
2604	3293	instruction->name = name;
2605	3294
2606	3295	ir_ref_instruction(name, irb->current_basic_block);
...	...	@@ -2608,10 +3297,10 @@ static IrInstruction ir_build_import(IrBuilder irb, Scope scope, AstNode sou
2608	3297	return &instruction->base;
2609	3298	}
2610	3299
2611		static IrInstruction ir_build_ref(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *value,
	3300	static IrInstSrc ir_build_ref_src(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *value,
2612	3301	bool is_const, bool is_volatile)
2613	3302	{
2614		IrInstructionRef *instruction = ir_build_instruction<IrInstructionRef>(irb, scope, source_node);
	3303	IrInstSrcRef *instruction = ir_build_instruction<IrInstSrcRef>(irb, scope, source_node);
2615	3304	instruction->value = value;
2616	3305	instruction->is_const = is_const;
2617	3306	instruction->is_volatile = is_volatile;
...	...	@@ -2621,23 +3310,23 @@ static IrInstruction ir_build_ref(IrBuilder irb, Scope scope, AstNode source
2621	3310	return &instruction->base;
2622	3311	}
2623	3312
2624		static IrInstruction ir_build_ref_gen(IrAnalyze ira, IrInstruction source_instruction, ZigType result_type,
2625		IrInstruction operand, IrInstruction result_loc)
	3313	static IrInstGen ir_build_ref_gen(IrAnalyze ira, IrInst source_instruction, ZigType result_type,
	3314	IrInstGen operand, IrInstGen result_loc)
2626	3315	{
2627		IrInstructionRefGen *instruction = ir_build_instruction<IrInstructionRefGen>(&ira->new_irb,
	3316	IrInstGenRef *instruction = ir_build_inst_gen<IrInstGenRef>(&ira->new_irb,
2628	3317	source_instruction->scope, source_instruction->source_node);
2629	3318	instruction->base.value->type = result_type;
2630	3319	instruction->operand = operand;
2631	3320	instruction->result_loc = result_loc;
2632	3321
2633		ir_ref_instruction(operand, ira->new_irb.current_basic_block);
2634		if (result_loc != nullptr) ir_ref_instruction(result_loc, ira->new_irb.current_basic_block);
	3322	ir_ref_inst_gen(operand, ira->new_irb.current_basic_block);
	3323	if (result_loc != nullptr) ir_ref_inst_gen(result_loc, ira->new_irb.current_basic_block);
2635	3324
2636	3325	return &instruction->base;
2637	3326	}
2638	3327
2639		static IrInstruction ir_build_compile_err(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *msg) {
2640		IrInstructionCompileErr *instruction = ir_build_instruction<IrInstructionCompileErr>(irb, scope, source_node);
	3328	static IrInstSrc ir_build_compile_err(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *msg) {
	3329	IrInstSrcCompileErr *instruction = ir_build_instruction<IrInstSrcCompileErr>(irb, scope, source_node);
2641	3330	instruction->msg = msg;
2642	3331
2643	3332	ir_ref_instruction(msg, irb->current_basic_block);
...	...	@@ -2645,10 +3334,10 @@ static IrInstruction ir_build_compile_err(IrBuilder irb, Scope *scope, AstNode
2645	3334	return &instruction->base;
2646	3335	}
2647	3336
2648		static IrInstruction ir_build_compile_log(IrBuilder irb, Scope scope, AstNode source_node,
2649		size_t msg_count, IrInstruction **msg_list)
	3337	static IrInstSrc ir_build_compile_log(IrBuilderSrc irb, Scope scope, AstNode source_node,
	3338	size_t msg_count, IrInstSrc **msg_list)
2650	3339	{
2651		IrInstructionCompileLog *instruction = ir_build_instruction<IrInstructionCompileLog>(irb, scope, source_node);
	3340	IrInstSrcCompileLog *instruction = ir_build_instruction<IrInstSrcCompileLog>(irb, scope, source_node);
2652	3341	instruction->msg_count = msg_count;
2653	3342	instruction->msg_list = msg_list;
2654	3343
...	...	@@ -2659,8 +3348,8 @@ static IrInstruction ir_build_compile_log(IrBuilder irb, Scope *scope, AstNode
2659	3348	return &instruction->base;
2660	3349	}
2661	3350
2662		static IrInstruction ir_build_err_name(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *value) {
2663		IrInstructionErrName *instruction = ir_build_instruction<IrInstructionErrName>(irb, scope, source_node);
	3351	static IrInstSrc ir_build_err_name(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *value) {
	3352	IrInstSrcErrName *instruction = ir_build_instruction<IrInstSrcErrName>(irb, scope, source_node);
2664	3353	instruction->value = value;
2665	3354
2666	3355	ir_ref_instruction(value, irb->current_basic_block);
...	...	@@ -2668,13 +3357,26 @@ static IrInstruction ir_build_err_name(IrBuilder irb, Scope scope, AstNode s
2668	3357	return &instruction->base;
2669	3358	}
2670	3359
2671		static IrInstruction ir_build_c_import(IrBuilder irb, Scope scope, AstNode source_node) {
2672		IrInstructionCImport *instruction = ir_build_instruction<IrInstructionCImport>(irb, scope, source_node);
	3360	static IrInstGen ir_build_err_name_gen(IrAnalyze ira, IrInst source_instr, IrInstGen value,
	3361	ZigType *str_type)
	3362	{
	3363	IrInstGenErrName *instruction = ir_build_inst_gen<IrInstGenErrName>(&ira->new_irb,
	3364	source_instr->scope, source_instr->source_node);
	3365	instruction->base.value->type = str_type;
	3366	instruction->value = value;
	3367
	3368	ir_ref_inst_gen(value, ira->new_irb.current_basic_block);
	3369
	3370	return &instruction->base;
	3371	}
	3372
	3373	static IrInstSrc ir_build_c_import(IrBuilderSrc irb, Scope scope, AstNode source_node) {
	3374	IrInstSrcCImport *instruction = ir_build_instruction<IrInstSrcCImport>(irb, scope, source_node);
2673	3375	return &instruction->base;
2674	3376	}
2675	3377
2676		static IrInstruction ir_build_c_include(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *name) {
2677		IrInstructionCInclude *instruction = ir_build_instruction<IrInstructionCInclude>(irb, scope, source_node);
	3378	static IrInstSrc ir_build_c_include(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *name) {
	3379	IrInstSrcCInclude *instruction = ir_build_instruction<IrInstSrcCInclude>(irb, scope, source_node);
2678	3380	instruction->name = name;
2679	3381
2680	3382	ir_ref_instruction(name, irb->current_basic_block);
...	...	@@ -2682,8 +3384,8 @@ static IrInstruction ir_build_c_include(IrBuilder irb, Scope scope, AstNode
2682	3384	return &instruction->base;
2683	3385	}
2684	3386
2685		static IrInstruction ir_build_c_define(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction name, IrInstruction value) {
2686		IrInstructionCDefine *instruction = ir_build_instruction<IrInstructionCDefine>(irb, scope, source_node);
	3387	static IrInstSrc ir_build_c_define(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc name, IrInstSrc value) {
	3388	IrInstSrcCDefine *instruction = ir_build_instruction<IrInstSrcCDefine>(irb, scope, source_node);
2687	3389	instruction->name = name;
2688	3390	instruction->value = value;
2689	3391
...	...	@@ -2693,8 +3395,8 @@ static IrInstruction ir_build_c_define(IrBuilder irb, Scope scope, AstNode s
2693	3395	return &instruction->base;
2694	3396	}
2695	3397
2696		static IrInstruction ir_build_c_undef(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *name) {
2697		IrInstructionCUndef *instruction = ir_build_instruction<IrInstructionCUndef>(irb, scope, source_node);
	3398	static IrInstSrc ir_build_c_undef(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *name) {
	3399	IrInstSrcCUndef *instruction = ir_build_instruction<IrInstSrcCUndef>(irb, scope, source_node);
2698	3400	instruction->name = name;
2699	3401
2700	3402	ir_ref_instruction(name, irb->current_basic_block);
...	...	@@ -2702,8 +3404,8 @@ static IrInstruction ir_build_c_undef(IrBuilder irb, Scope scope, AstNode so
2702	3404	return &instruction->base;
2703	3405	}
2704	3406
2705		static IrInstruction ir_build_embed_file(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *name) {
2706		IrInstructionEmbedFile *instruction = ir_build_instruction<IrInstructionEmbedFile>(irb, scope, source_node);
	3407	static IrInstSrc ir_build_embed_file(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *name) {
	3408	IrInstSrcEmbedFile *instruction = ir_build_instruction<IrInstSrcEmbedFile>(irb, scope, source_node);
2707	3409	instruction->name = name;
2708	3410
2709	3411	ir_ref_instruction(name, irb->current_basic_block);
...	...	@@ -2711,11 +3413,11 @@ static IrInstruction ir_build_embed_file(IrBuilder irb, Scope *scope, AstNode
2711	3413	return &instruction->base;
2712	3414	}
2713	3415
2714		static IrInstruction ir_build_cmpxchg_src(IrBuilder irb, Scope scope, AstNode source_node,
2715		IrInstruction type_value, IrInstruction ptr, IrInstruction cmp_value, IrInstruction new_value,
2716		IrInstruction success_order_value, IrInstruction failure_order_value, bool is_weak, ResultLoc *result_loc)
	3416	static IrInstSrc ir_build_cmpxchg_src(IrBuilderSrc irb, Scope scope, AstNode source_node,
	3417	IrInstSrc type_value, IrInstSrc ptr, IrInstSrc cmp_value, IrInstSrc new_value,
	3418	IrInstSrc success_order_value, IrInstSrc failure_order_value, bool is_weak, ResultLoc *result_loc)
2717	3419	{
2718		IrInstructionCmpxchgSrc *instruction = ir_build_instruction<IrInstructionCmpxchgSrc>(irb, scope, source_node);
	3420	IrInstSrcCmpxchg *instruction = ir_build_instruction<IrInstSrcCmpxchg>(irb, scope, source_node);
2719	3421	instruction->type_value = type_value;
2720	3422	instruction->ptr = ptr;
2721	3423	instruction->cmp_value = cmp_value;
...	...	@@ -2735,11 +3437,11 @@ static IrInstruction ir_build_cmpxchg_src(IrBuilder irb, Scope *scope, AstNode
2735	3437	return &instruction->base;
2736	3438	}
2737	3439
2738		static IrInstruction ir_build_cmpxchg_gen(IrAnalyze ira, IrInstruction source_instruction, ZigType result_type,
2739		IrInstruction ptr, IrInstruction cmp_value, IrInstruction *new_value,
2740		AtomicOrder success_order, AtomicOrder failure_order, bool is_weak, IrInstruction *result_loc)
	3440	static IrInstGen ir_build_cmpxchg_gen(IrAnalyze ira, IrInst source_instruction, ZigType result_type,
	3441	IrInstGen ptr, IrInstGen cmp_value, IrInstGen *new_value,
	3442	AtomicOrder success_order, AtomicOrder failure_order, bool is_weak, IrInstGen *result_loc)
2741	3443	{
2742		IrInstructionCmpxchgGen *instruction = ir_build_instruction<IrInstructionCmpxchgGen>(&ira->new_irb,
	3444	IrInstGenCmpxchg *instruction = ir_build_inst_gen<IrInstGenCmpxchg>(&ira->new_irb,
2743	3445	source_instruction->scope, source_instruction->source_node);
2744	3446	instruction->base.value->type = result_type;
2745	3447	instruction->ptr = ptr;
...	...	@@ -2750,26 +3452,35 @@ static IrInstruction ir_build_cmpxchg_gen(IrAnalyze ira, IrInstruction *source
2750	3452	instruction->is_weak = is_weak;
2751	3453	instruction->result_loc = result_loc;
2752	3454
2753		ir_ref_instruction(ptr, ira->new_irb.current_basic_block);
2754		ir_ref_instruction(cmp_value, ira->new_irb.current_basic_block);
2755		ir_ref_instruction(new_value, ira->new_irb.current_basic_block);
2756		if (result_loc != nullptr) ir_ref_instruction(result_loc, ira->new_irb.current_basic_block);
	3455	ir_ref_inst_gen(ptr, ira->new_irb.current_basic_block);
	3456	ir_ref_inst_gen(cmp_value, ira->new_irb.current_basic_block);
	3457	ir_ref_inst_gen(new_value, ira->new_irb.current_basic_block);
	3458	if (result_loc != nullptr) ir_ref_inst_gen(result_loc, ira->new_irb.current_basic_block);
2757	3459
2758	3460	return &instruction->base;
2759	3461	}
2760	3462
2761		static IrInstruction ir_build_fence(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *order_value, AtomicOrder order) {
2762		IrInstructionFence *instruction = ir_build_instruction<IrInstructionFence>(irb, scope, source_node);
2763		instruction->order_value = order_value;
	3463	static IrInstSrc ir_build_fence(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *order) {
	3464	IrInstSrcFence *instruction = ir_build_instruction<IrInstSrcFence>(irb, scope, source_node);
2764	3465	instruction->order = order;
2765	3466
2766		ir_ref_instruction(order_value, irb->current_basic_block);
	3467	ir_ref_instruction(order, irb->current_basic_block);
2767	3468
2768	3469	return &instruction->base;
2769	3470	}
2770	3471
2771		static IrInstruction ir_build_truncate(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction dest_type, IrInstruction target) {
2772		IrInstructionTruncate *instruction = ir_build_instruction<IrInstructionTruncate>(irb, scope, source_node);
	3472	static IrInstGen ir_build_fence_gen(IrAnalyze ira, IrInst *source_instr, AtomicOrder order) {
	3473	IrInstGenFence *instruction = ir_build_inst_void<IrInstGenFence>(&ira->new_irb,
	3474	source_instr->scope, source_instr->source_node);
	3475	instruction->order = order;
	3476
	3477	return &instruction->base;
	3478	}
	3479
	3480	static IrInstSrc ir_build_truncate(IrBuilderSrc irb, Scope scope, AstNode source_node,
	3481	IrInstSrc dest_type, IrInstSrc target)
	3482	{
	3483	IrInstSrcTruncate *instruction = ir_build_instruction<IrInstSrcTruncate>(irb, scope, source_node);
2773	3484	instruction->dest_type = dest_type;
2774	3485	instruction->target = target;
2775	3486
...	...	@@ -2779,8 +3490,23 @@ static IrInstruction ir_build_truncate(IrBuilder irb, Scope scope, AstNode s
2779	3490	return &instruction->base;
2780	3491	}
2781	3492
2782		static IrInstruction ir_build_int_cast(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction dest_type, IrInstruction target) {
2783		IrInstructionIntCast *instruction = ir_build_instruction<IrInstructionIntCast>(irb, scope, source_node);
	3493	static IrInstGen ir_build_truncate_gen(IrAnalyze ira, IrInst source_instr, ZigType dest_type,
	3494	IrInstGen *target)
	3495	{
	3496	IrInstGenTruncate *instruction = ir_build_inst_gen<IrInstGenTruncate>(&ira->new_irb,
	3497	source_instr->scope, source_instr->source_node);
	3498	instruction->base.value->type = dest_type;
	3499	instruction->target = target;
	3500
	3501	ir_ref_inst_gen(target, ira->new_irb.current_basic_block);
	3502
	3503	return &instruction->base;
	3504	}
	3505
	3506	static IrInstSrc ir_build_int_cast(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *dest_type,
	3507	IrInstSrc *target)
	3508	{
	3509	IrInstSrcIntCast *instruction = ir_build_instruction<IrInstSrcIntCast>(irb, scope, source_node);
2784	3510	instruction->dest_type = dest_type;
2785	3511	instruction->target = target;
2786	3512
...	...	@@ -2790,8 +3516,10 @@ static IrInstruction ir_build_int_cast(IrBuilder irb, Scope scope, AstNode s
2790	3516	return &instruction->base;
2791	3517	}
2792	3518
2793		static IrInstruction ir_build_float_cast(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction dest_type, IrInstruction target) {
2794		IrInstructionFloatCast *instruction = ir_build_instruction<IrInstructionFloatCast>(irb, scope, source_node);
	3519	static IrInstSrc ir_build_float_cast(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *dest_type,
	3520	IrInstSrc *target)
	3521	{
	3522	IrInstSrcFloatCast *instruction = ir_build_instruction<IrInstSrcFloatCast>(irb, scope, source_node);
2795	3523	instruction->dest_type = dest_type;
2796	3524	instruction->target = target;
2797	3525
...	...	@@ -2801,8 +3529,10 @@ static IrInstruction ir_build_float_cast(IrBuilder irb, Scope *scope, AstNode
2801	3529	return &instruction->base;
2802	3530	}
2803	3531
2804		static IrInstruction ir_build_err_set_cast(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction dest_type, IrInstruction target) {
2805		IrInstructionErrSetCast *instruction = ir_build_instruction<IrInstructionErrSetCast>(irb, scope, source_node);
	3532	static IrInstSrc ir_build_err_set_cast(IrBuilderSrc irb, Scope scope, AstNode source_node,
	3533	IrInstSrc dest_type, IrInstSrc target)
	3534	{
	3535	IrInstSrcErrSetCast *instruction = ir_build_instruction<IrInstSrcErrSetCast>(irb, scope, source_node);
2806	3536	instruction->dest_type = dest_type;
2807	3537	instruction->target = target;
2808	3538
...	...	@@ -2812,10 +3542,10 @@ static IrInstruction ir_build_err_set_cast(IrBuilder irb, Scope *scope, AstNod
2812	3542	return &instruction->base;
2813	3543	}
2814	3544
2815		static IrInstruction ir_build_to_bytes(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *target,
	3545	static IrInstSrc ir_build_to_bytes(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *target,
2816	3546	ResultLoc *result_loc)
2817	3547	{
2818		IrInstructionToBytes *instruction = ir_build_instruction<IrInstructionToBytes>(irb, scope, source_node);
	3548	IrInstSrcToBytes *instruction = ir_build_instruction<IrInstSrcToBytes>(irb, scope, source_node);
2819	3549	instruction->target = target;
2820	3550	instruction->result_loc = result_loc;
2821	3551
...	...	@@ -2824,10 +3554,10 @@ static IrInstruction ir_build_to_bytes(IrBuilder irb, Scope scope, AstNode s
2824	3554	return &instruction->base;
2825	3555	}
2826	3556
2827		static IrInstruction ir_build_from_bytes(IrBuilder irb, Scope scope, AstNode source_node,
2828		IrInstruction dest_child_type, IrInstruction target, ResultLoc *result_loc)
	3557	static IrInstSrc ir_build_from_bytes(IrBuilderSrc irb, Scope scope, AstNode source_node,
	3558	IrInstSrc dest_child_type, IrInstSrc target, ResultLoc *result_loc)
2829	3559	{
2830		IrInstructionFromBytes *instruction = ir_build_instruction<IrInstructionFromBytes>(irb, scope, source_node);
	3560	IrInstSrcFromBytes *instruction = ir_build_instruction<IrInstSrcFromBytes>(irb, scope, source_node);
2831	3561	instruction->dest_child_type = dest_child_type;
2832	3562	instruction->target = target;
2833	3563	instruction->result_loc = result_loc;
...	...	@@ -2838,8 +3568,10 @@ static IrInstruction ir_build_from_bytes(IrBuilder irb, Scope *scope, AstNode
2838	3568	return &instruction->base;
2839	3569	}
2840	3570
2841		static IrInstruction ir_build_int_to_float(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction dest_type, IrInstruction target) {
2842		IrInstructionIntToFloat *instruction = ir_build_instruction<IrInstructionIntToFloat>(irb, scope, source_node);
	3571	static IrInstSrc ir_build_int_to_float(IrBuilderSrc irb, Scope scope, AstNode source_node,
	3572	IrInstSrc dest_type, IrInstSrc target)
	3573	{
	3574	IrInstSrcIntToFloat *instruction = ir_build_instruction<IrInstSrcIntToFloat>(irb, scope, source_node);
2843	3575	instruction->dest_type = dest_type;
2844	3576	instruction->target = target;
2845	3577
...	...	@@ -2849,8 +3581,10 @@ static IrInstruction ir_build_int_to_float(IrBuilder irb, Scope *scope, AstNod
2849	3581	return &instruction->base;
2850	3582	}
2851	3583
2852		static IrInstruction ir_build_float_to_int(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction dest_type, IrInstruction target) {
2853		IrInstructionFloatToInt *instruction = ir_build_instruction<IrInstructionFloatToInt>(irb, scope, source_node);
	3584	static IrInstSrc ir_build_float_to_int(IrBuilderSrc irb, Scope scope, AstNode source_node,
	3585	IrInstSrc dest_type, IrInstSrc target)
	3586	{
	3587	IrInstSrcFloatToInt *instruction = ir_build_instruction<IrInstSrcFloatToInt>(irb, scope, source_node);
2854	3588	instruction->dest_type = dest_type;
2855	3589	instruction->target = target;
2856	3590
...	...	@@ -2860,8 +3594,8 @@ static IrInstruction ir_build_float_to_int(IrBuilder irb, Scope *scope, AstNod
2860	3594	return &instruction->base;
2861	3595	}
2862	3596
2863		static IrInstruction ir_build_bool_to_int(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *target) {
2864		IrInstructionBoolToInt *instruction = ir_build_instruction<IrInstructionBoolToInt>(irb, scope, source_node);
	3597	static IrInstSrc ir_build_bool_to_int(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *target) {
	3598	IrInstSrcBoolToInt *instruction = ir_build_instruction<IrInstSrcBoolToInt>(irb, scope, source_node);
2865	3599	instruction->target = target;
2866	3600
2867	3601	ir_ref_instruction(target, irb->current_basic_block);
...	...	@@ -2869,8 +3603,10 @@ static IrInstruction ir_build_bool_to_int(IrBuilder irb, Scope *scope, AstNode
2869	3603	return &instruction->base;
2870	3604	}
2871	3605
2872		static IrInstruction ir_build_int_type(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction is_signed, IrInstruction bit_count) {
2873		IrInstructionIntType *instruction = ir_build_instruction<IrInstructionIntType>(irb, scope, source_node);
	3606	static IrInstSrc ir_build_int_type(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *is_signed,
	3607	IrInstSrc *bit_count)
	3608	{
	3609	IrInstSrcIntType *instruction = ir_build_instruction<IrInstSrcIntType>(irb, scope, source_node);
2874	3610	instruction->is_signed = is_signed;
2875	3611	instruction->bit_count = bit_count;
2876	3612
...	...	@@ -2880,10 +3616,10 @@ static IrInstruction ir_build_int_type(IrBuilder irb, Scope scope, AstNode s
2880	3616	return &instruction->base;
2881	3617	}
2882	3618
2883		static IrInstruction ir_build_vector_type(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *len,
2884		IrInstruction *elem_type)
	3619	static IrInstSrc ir_build_vector_type(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *len,
	3620	IrInstSrc *elem_type)
2885	3621	{
2886		IrInstructionVectorType *instruction = ir_build_instruction<IrInstructionVectorType>(irb, scope, source_node);
	3622	IrInstSrcVectorType *instruction = ir_build_instruction<IrInstSrcVectorType>(irb, scope, source_node);
2887	3623	instruction->len = len;
2888	3624	instruction->elem_type = elem_type;
2889	3625
...	...	@@ -2893,18 +3629,16 @@ static IrInstruction ir_build_vector_type(IrBuilder irb, Scope *scope, AstNode
2893	3629	return &instruction->base;
2894	3630	}
2895	3631
2896		static IrInstruction ir_build_shuffle_vector(IrBuilder irb, Scope scope, AstNode source_node,
2897		IrInstruction scalar_type, IrInstruction a, IrInstruction b, IrInstruction mask)
	3632	static IrInstSrc ir_build_shuffle_vector(IrBuilderSrc irb, Scope scope, AstNode source_node,
	3633	IrInstSrc scalar_type, IrInstSrc a, IrInstSrc b, IrInstSrc mask)
2898	3634	{
2899		IrInstructionShuffleVector *instruction = ir_build_instruction<IrInstructionShuffleVector>(irb, scope, source_node);
	3635	IrInstSrcShuffleVector *instruction = ir_build_instruction<IrInstSrcShuffleVector>(irb, scope, source_node);
2900	3636	instruction->scalar_type = scalar_type;
2901	3637	instruction->a = a;
2902	3638	instruction->b = b;
2903	3639	instruction->mask = mask;
2904	3640
2905		if (scalar_type != nullptr) {
2906		ir_ref_instruction(scalar_type, irb->current_basic_block);
2907		}
	3641	if (scalar_type != nullptr) ir_ref_instruction(scalar_type, irb->current_basic_block);
2908	3642	ir_ref_instruction(a, irb->current_basic_block);
2909	3643	ir_ref_instruction(b, irb->current_basic_block);
2910	3644	ir_ref_instruction(mask, irb->current_basic_block);
...	...	@@ -2912,10 +3646,26 @@ static IrInstruction ir_build_shuffle_vector(IrBuilder irb, Scope *scope, AstN
2912	3646	return &instruction->base;
2913	3647	}
2914	3648
2915		static IrInstruction ir_build_splat_src(IrBuilder irb, Scope scope, AstNode source_node,
2916		IrInstruction len, IrInstruction scalar)
	3649	static IrInstGen ir_build_shuffle_vector_gen(IrAnalyze ira, Scope scope, AstNode source_node,
	3650	ZigType result_type, IrInstGen a, IrInstGen b, IrInstGen mask)
2917	3651	{
2918		IrInstructionSplatSrc *instruction = ir_build_instruction<IrInstructionSplatSrc>(irb, scope, source_node);
	3652	IrInstGenShuffleVector *inst = ir_build_inst_gen<IrInstGenShuffleVector>(&ira->new_irb, scope, source_node);
	3653	inst->base.value->type = result_type;
	3654	inst->a = a;
	3655	inst->b = b;
	3656	inst->mask = mask;
	3657
	3658	ir_ref_inst_gen(a, ira->new_irb.current_basic_block);
	3659	ir_ref_inst_gen(b, ira->new_irb.current_basic_block);
	3660	ir_ref_inst_gen(mask, ira->new_irb.current_basic_block);
	3661
	3662	return &inst->base;
	3663	}
	3664
	3665	static IrInstSrc ir_build_splat_src(IrBuilderSrc irb, Scope scope, AstNode source_node,
	3666	IrInstSrc len, IrInstSrc scalar)
	3667	{
	3668	IrInstSrcSplat *instruction = ir_build_instruction<IrInstSrcSplat>(irb, scope, source_node);
2919	3669	instruction->len = len;
2920	3670	instruction->scalar = scalar;
2921	3671
...	...	@@ -2925,8 +3675,21 @@ static IrInstruction ir_build_splat_src(IrBuilder irb, Scope scope, AstNode
2925	3675	return &instruction->base;
2926	3676	}
2927	3677
2928		static IrInstruction ir_build_bool_not(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *value) {
2929		IrInstructionBoolNot *instruction = ir_build_instruction<IrInstructionBoolNot>(irb, scope, source_node);
	3678	static IrInstGen ir_build_splat_gen(IrAnalyze ira, IrInst source_instruction, ZigType result_type,
	3679	IrInstGen *scalar)
	3680	{
	3681	IrInstGenSplat *instruction = ir_build_inst_gen<IrInstGenSplat>(
	3682	&ira->new_irb, source_instruction->scope, source_instruction->source_node);
	3683	instruction->base.value->type = result_type;
	3684	instruction->scalar = scalar;
	3685
	3686	ir_ref_inst_gen(scalar, ira->new_irb.current_basic_block);
	3687
	3688	return &instruction->base;
	3689	}
	3690
	3691	static IrInstSrc ir_build_bool_not(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *value) {
	3692	IrInstSrcBoolNot *instruction = ir_build_instruction<IrInstSrcBoolNot>(irb, scope, source_node);
2930	3693	instruction->value = value;
2931	3694
2932	3695	ir_ref_instruction(value, irb->current_basic_block);
...	...	@@ -2934,10 +3697,21 @@ static IrInstruction ir_build_bool_not(IrBuilder irb, Scope scope, AstNode s
2934	3697	return &instruction->base;
2935	3698	}
2936	3699
2937		static IrInstruction ir_build_memset(IrBuilder irb, Scope scope, AstNode source_node,
2938		IrInstruction dest_ptr, IrInstruction byte, IrInstruction *count)
	3700	static IrInstGen ir_build_bool_not_gen(IrAnalyze ira, IrInst source_instr, IrInstGen value) {
	3701	IrInstGenBoolNot *instruction = ir_build_inst_gen<IrInstGenBoolNot>(&ira->new_irb,
	3702	source_instr->scope, source_instr->source_node);
	3703	instruction->base.value->type = ira->codegen->builtin_types.entry_bool;
	3704	instruction->value = value;
	3705
	3706	ir_ref_inst_gen(value, ira->new_irb.current_basic_block);
	3707
	3708	return &instruction->base;
	3709	}
	3710
	3711	static IrInstSrc ir_build_memset_src(IrBuilderSrc irb, Scope scope, AstNode source_node,
	3712	IrInstSrc dest_ptr, IrInstSrc byte, IrInstSrc *count)
2939	3713	{
2940		IrInstructionMemset *instruction = ir_build_instruction<IrInstructionMemset>(irb, scope, source_node);
	3714	IrInstSrcMemset *instruction = ir_build_instruction<IrInstSrcMemset>(irb, scope, source_node);
2941	3715	instruction->dest_ptr = dest_ptr;
2942	3716	instruction->byte = byte;
2943	3717	instruction->count = count;
...	...	@@ -2949,10 +3723,26 @@ static IrInstruction ir_build_memset(IrBuilder irb, Scope scope, AstNode sou
2949	3723	return &instruction->base;
2950	3724	}
2951	3725
2952		static IrInstruction ir_build_memcpy(IrBuilder irb, Scope scope, AstNode source_node,
2953		IrInstruction dest_ptr, IrInstruction src_ptr, IrInstruction *count)
	3726	static IrInstGen ir_build_memset_gen(IrAnalyze ira, IrInst *source_instr,
	3727	IrInstGen dest_ptr, IrInstGen byte, IrInstGen *count)
	3728	{
	3729	IrInstGenMemset *instruction = ir_build_inst_void<IrInstGenMemset>(&ira->new_irb,
	3730	source_instr->scope, source_instr->source_node);
	3731	instruction->dest_ptr = dest_ptr;
	3732	instruction->byte = byte;
	3733	instruction->count = count;
	3734
	3735	ir_ref_inst_gen(dest_ptr, ira->new_irb.current_basic_block);
	3736	ir_ref_inst_gen(byte, ira->new_irb.current_basic_block);
	3737	ir_ref_inst_gen(count, ira->new_irb.current_basic_block);
	3738
	3739	return &instruction->base;
	3740	}
	3741
	3742	static IrInstSrc ir_build_memcpy_src(IrBuilderSrc irb, Scope scope, AstNode source_node,
	3743	IrInstSrc dest_ptr, IrInstSrc src_ptr, IrInstSrc *count)
2954	3744	{
2955		IrInstructionMemcpy *instruction = ir_build_instruction<IrInstructionMemcpy>(irb, scope, source_node);
	3745	IrInstSrcMemcpy *instruction = ir_build_instruction<IrInstSrcMemcpy>(irb, scope, source_node);
2956	3746	instruction->dest_ptr = dest_ptr;
2957	3747	instruction->src_ptr = src_ptr;
2958	3748	instruction->count = count;
...	...	@@ -2964,11 +3754,27 @@ static IrInstruction ir_build_memcpy(IrBuilder irb, Scope scope, AstNode sou
2964	3754	return &instruction->base;
2965	3755	}
2966	3756
2967		static IrInstruction ir_build_slice_src(IrBuilder irb, Scope scope, AstNode source_node,
2968		IrInstruction ptr, IrInstruction start, IrInstruction end, IrInstruction sentinel,
	3757	static IrInstGen ir_build_memcpy_gen(IrAnalyze ira, IrInst *source_instr,
	3758	IrInstGen dest_ptr, IrInstGen src_ptr, IrInstGen *count)
	3759	{
	3760	IrInstGenMemcpy *instruction = ir_build_inst_void<IrInstGenMemcpy>(&ira->new_irb,
	3761	source_instr->scope, source_instr->source_node);
	3762	instruction->dest_ptr = dest_ptr;
	3763	instruction->src_ptr = src_ptr;
	3764	instruction->count = count;
	3765
	3766	ir_ref_inst_gen(dest_ptr, ira->new_irb.current_basic_block);
	3767	ir_ref_inst_gen(src_ptr, ira->new_irb.current_basic_block);
	3768	ir_ref_inst_gen(count, ira->new_irb.current_basic_block);
	3769
	3770	return &instruction->base;
	3771	}
	3772
	3773	static IrInstSrc ir_build_slice_src(IrBuilderSrc irb, Scope scope, AstNode source_node,
	3774	IrInstSrc ptr, IrInstSrc start, IrInstSrc end, IrInstSrc sentinel,
2969	3775	bool safety_check_on, ResultLoc *result_loc)
2970	3776	{
2971		IrInstructionSliceSrc *instruction = ir_build_instruction<IrInstructionSliceSrc>(irb, scope, source_node);
	3777	IrInstSrcSlice *instruction = ir_build_instruction<IrInstSrcSlice>(irb, scope, source_node);
2972	3778	instruction->ptr = ptr;
2973	3779	instruction->start = start;
2974	3780	instruction->end = end;
...	...	@@ -2984,23 +3790,10 @@ static IrInstruction ir_build_slice_src(IrBuilder irb, Scope scope, AstNode
2984	3790	return &instruction->base;
2985	3791	}
2986	3792
2987		static IrInstruction ir_build_splat_gen(IrAnalyze ira, IrInstruction source_instruction, ZigType result_type,
2988		IrInstruction *scalar)
2989		{
2990		IrInstructionSplatGen *instruction = ir_build_instruction<IrInstructionSplatGen>(
2991		&ira->new_irb, source_instruction->scope, source_instruction->source_node);
2992		instruction->base.value->type = result_type;
2993		instruction->scalar = scalar;
2994
2995		ir_ref_instruction(scalar, ira->new_irb.current_basic_block);
2996
2997		return &instruction->base;
2998		}
2999
3000		static IrInstruction ir_build_slice_gen(IrAnalyze ira, IrInstruction source_instruction, ZigType slice_type,
3001		IrInstruction ptr, IrInstruction start, IrInstruction end, bool safety_check_on, IrInstruction result_loc)
	3793	static IrInstGen ir_build_slice_gen(IrAnalyze ira, IrInst source_instruction, ZigType slice_type,
	3794	IrInstGen ptr, IrInstGen start, IrInstGen end, bool safety_check_on, IrInstGen result_loc)
3002	3795	{
3003		IrInstructionSliceGen *instruction = ir_build_instruction<IrInstructionSliceGen>(
	3796	IrInstGenSlice *instruction = ir_build_inst_gen<IrInstGenSlice>(
3004	3797	&ira->new_irb, source_instruction->scope, source_instruction->source_node);
3005	3798	instruction->base.value->type = slice_type;
3006	3799	instruction->ptr = ptr;
...	...	@@ -3009,16 +3802,16 @@ static IrInstruction ir_build_slice_gen(IrAnalyze ira, IrInstruction *source_i
3009	3802	instruction->safety_check_on = safety_check_on;
3010	3803	instruction->result_loc = result_loc;
3011	3804
3012		ir_ref_instruction(ptr, ira->new_irb.current_basic_block);
3013		ir_ref_instruction(start, ira->new_irb.current_basic_block);
3014		if (end) ir_ref_instruction(end, ira->new_irb.current_basic_block);
3015		ir_ref_instruction(result_loc, ira->new_irb.current_basic_block);
	3805	ir_ref_inst_gen(ptr, ira->new_irb.current_basic_block);
	3806	ir_ref_inst_gen(start, ira->new_irb.current_basic_block);
	3807	if (end) ir_ref_inst_gen(end, ira->new_irb.current_basic_block);
	3808	ir_ref_inst_gen(result_loc, ira->new_irb.current_basic_block);
3016	3809
3017	3810	return &instruction->base;
3018	3811	}
3019	3812
3020		static IrInstruction ir_build_member_count(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *container) {
3021		IrInstructionMemberCount *instruction = ir_build_instruction<IrInstructionMemberCount>(irb, scope, source_node);
	3813	static IrInstSrc ir_build_member_count(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *container) {
	3814	IrInstSrcMemberCount *instruction = ir_build_instruction<IrInstSrcMemberCount>(irb, scope, source_node);
3022	3815	instruction->container = container;
3023	3816
3024	3817	ir_ref_instruction(container, irb->current_basic_block);
...	...	@@ -3026,10 +3819,10 @@ static IrInstruction ir_build_member_count(IrBuilder irb, Scope *scope, AstNod
3026	3819	return &instruction->base;
3027	3820	}
3028	3821
3029		static IrInstruction ir_build_member_type(IrBuilder irb, Scope scope, AstNode source_node,
3030		IrInstruction container_type, IrInstruction member_index)
	3822	static IrInstSrc ir_build_member_type(IrBuilderSrc irb, Scope scope, AstNode source_node,
	3823	IrInstSrc container_type, IrInstSrc member_index)
3031	3824	{
3032		IrInstructionMemberType *instruction = ir_build_instruction<IrInstructionMemberType>(irb, scope, source_node);
	3825	IrInstSrcMemberType *instruction = ir_build_instruction<IrInstSrcMemberType>(irb, scope, source_node);
3033	3826	instruction->container_type = container_type;
3034	3827	instruction->member_index = member_index;
3035	3828
...	...	@@ -3039,10 +3832,10 @@ static IrInstruction ir_build_member_type(IrBuilder irb, Scope *scope, AstNode
3039	3832	return &instruction->base;
3040	3833	}
3041	3834
3042		static IrInstruction ir_build_member_name(IrBuilder irb, Scope scope, AstNode source_node,
3043		IrInstruction container_type, IrInstruction member_index)
	3835	static IrInstSrc ir_build_member_name(IrBuilderSrc irb, Scope scope, AstNode source_node,
	3836	IrInstSrc container_type, IrInstSrc member_index)
3044	3837	{
3045		IrInstructionMemberName *instruction = ir_build_instruction<IrInstructionMemberName>(irb, scope, source_node);
	3838	IrInstSrcMemberName *instruction = ir_build_instruction<IrInstSrcMemberName>(irb, scope, source_node);
3046	3839	instruction->container_type = container_type;
3047	3840	instruction->member_index = member_index;
3048	3841
...	...	@@ -3052,65 +3845,88 @@ static IrInstruction ir_build_member_name(IrBuilder irb, Scope *scope, AstNode
3052	3845	return &instruction->base;
3053	3846	}
3054	3847
3055		static IrInstruction ir_build_breakpoint(IrBuilder irb, Scope scope, AstNode source_node) {
3056		IrInstructionBreakpoint *instruction = ir_build_instruction<IrInstructionBreakpoint>(irb, scope, source_node);
	3848	static IrInstSrc ir_build_breakpoint(IrBuilderSrc irb, Scope scope, AstNode source_node) {
	3849	IrInstSrcBreakpoint *instruction = ir_build_instruction<IrInstSrcBreakpoint>(irb, scope, source_node);
3057	3850	return &instruction->base;
3058	3851	}
3059	3852
3060		static IrInstruction ir_build_return_address(IrBuilder irb, Scope scope, AstNode source_node) {
3061		IrInstructionReturnAddress *instruction = ir_build_instruction<IrInstructionReturnAddress>(irb, scope, source_node);
	3853	static IrInstGen ir_build_breakpoint_gen(IrAnalyze ira, IrInst *source_instr) {
	3854	IrInstGenBreakpoint *instruction = ir_build_inst_void<IrInstGenBreakpoint>(&ira->new_irb,
	3855	source_instr->scope, source_instr->source_node);
3062	3856	return &instruction->base;
3063	3857	}
3064	3858
3065		static IrInstruction ir_build_frame_address(IrBuilder irb, Scope scope, AstNode source_node) {
3066		IrInstructionFrameAddress *instruction = ir_build_instruction<IrInstructionFrameAddress>(irb, scope, source_node);
	3859	static IrInstSrc ir_build_return_address_src(IrBuilderSrc irb, Scope scope, AstNode source_node) {
	3860	IrInstSrcReturnAddress *instruction = ir_build_instruction<IrInstSrcReturnAddress>(irb, scope, source_node);
3067	3861	return &instruction->base;
3068	3862	}
3069	3863
3070		static IrInstruction ir_build_handle(IrBuilder irb, Scope scope, AstNode source_node) {
3071		IrInstructionFrameHandle *instruction = ir_build_instruction<IrInstructionFrameHandle>(irb, scope, source_node);
3072		return &instruction->base;
	3864	static IrInstGen ir_build_return_address_gen(IrAnalyze ira, IrInst *source_instr) {
	3865	IrInstGenReturnAddress *inst = ir_build_inst_gen<IrInstGenReturnAddress>(&ira->new_irb, source_instr->scope, source_instr->source_node);
	3866	inst->base.value->type = ira->codegen->builtin_types.entry_usize;
	3867	return &inst->base;
	3868	}
	3869
	3870	static IrInstSrc ir_build_frame_address_src(IrBuilderSrc irb, Scope scope, AstNode source_node) {
	3871	IrInstSrcFrameAddress *inst = ir_build_instruction<IrInstSrcFrameAddress>(irb, scope, source_node);
	3872	return &inst->base;
	3873	}
	3874
	3875	static IrInstGen ir_build_frame_address_gen(IrAnalyze ira, IrInst *source_instr) {
	3876	IrInstGenFrameAddress *inst = ir_build_inst_gen<IrInstGenFrameAddress>(&ira->new_irb, source_instr->scope, source_instr->source_node);
	3877	inst->base.value->type = ira->codegen->builtin_types.entry_usize;
	3878	return &inst->base;
	3879	}
	3880
	3881	static IrInstSrc ir_build_handle_src(IrBuilderSrc irb, Scope scope, AstNode source_node) {
	3882	IrInstSrcFrameHandle *inst = ir_build_instruction<IrInstSrcFrameHandle>(irb, scope, source_node);
	3883	return &inst->base;
3073	3884	}
3074	3885
3075		static IrInstruction ir_build_frame_type(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *fn) {
3076		IrInstructionFrameType *instruction = ir_build_instruction<IrInstructionFrameType>(irb, scope, source_node);
3077		instruction->fn = fn;
	3886	static IrInstGen ir_build_handle_gen(IrAnalyze ira, IrInst source_instr, ZigType ty) {
	3887	IrInstGenFrameHandle *inst = ir_build_inst_gen<IrInstGenFrameHandle>(&ira->new_irb, source_instr->scope, source_instr->source_node);
	3888	inst->base.value->type = ty;
	3889	return &inst->base;
	3890	}
	3891
	3892	static IrInstSrc ir_build_frame_type(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *fn) {
	3893	IrInstSrcFrameType *inst = ir_build_instruction<IrInstSrcFrameType>(irb, scope, source_node);
	3894	inst->fn = fn;
3078	3895
3079	3896	ir_ref_instruction(fn, irb->current_basic_block);
3080	3897
3081		return &instruction->base;
	3898	return &inst->base;
3082	3899	}
3083	3900
3084		static IrInstruction ir_build_frame_size_src(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *fn) {
3085		IrInstructionFrameSizeSrc *instruction = ir_build_instruction<IrInstructionFrameSizeSrc>(irb, scope, source_node);
3086		instruction->fn = fn;
	3901	static IrInstSrc ir_build_frame_size_src(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *fn) {
	3902	IrInstSrcFrameSize *inst = ir_build_instruction<IrInstSrcFrameSize>(irb, scope, source_node);
	3903	inst->fn = fn;
3087	3904
3088	3905	ir_ref_instruction(fn, irb->current_basic_block);
3089	3906
3090		return &instruction->base;
	3907	return &inst->base;
3091	3908	}
3092	3909
3093		static IrInstruction ir_build_frame_size_gen(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *fn)
	3910	static IrInstGen ir_build_frame_size_gen(IrAnalyze ira, IrInst source_instr, IrInstGen fn)
3094	3911	{
3095		IrInstructionFrameSizeGen *instruction = ir_build_instruction<IrInstructionFrameSizeGen>(irb, scope, source_node);
3096		instruction->fn = fn;
	3912	IrInstGenFrameSize *inst = ir_build_inst_gen<IrInstGenFrameSize>(&ira->new_irb, source_instr->scope, source_instr->source_node);
	3913	inst->base.value->type = ira->codegen->builtin_types.entry_usize;
	3914	inst->fn = fn;
3097	3915
3098		ir_ref_instruction(fn, irb->current_basic_block);
	3916	ir_ref_inst_gen(fn, ira->new_irb.current_basic_block);
3099	3917
3100		return &instruction->base;
	3918	return &inst->base;
3101	3919	}
3102	3920
3103		static IrInstruction ir_build_overflow_op(IrBuilder irb, Scope scope, AstNode source_node,
3104		IrOverflowOp op, IrInstruction type_value, IrInstruction op1, IrInstruction *op2,
3105		IrInstruction result_ptr, ZigType result_ptr_type)
	3921	static IrInstSrc ir_build_overflow_op_src(IrBuilderSrc irb, Scope scope, AstNode source_node,
	3922	IrOverflowOp op, IrInstSrc type_value, IrInstSrc op1, IrInstSrc op2, IrInstSrc result_ptr)
3106	3923	{
3107		IrInstructionOverflowOp *instruction = ir_build_instruction<IrInstructionOverflowOp>(irb, scope, source_node);
	3924	IrInstSrcOverflowOp *instruction = ir_build_instruction<IrInstSrcOverflowOp>(irb, scope, source_node);
3108	3925	instruction->op = op;
3109	3926	instruction->type_value = type_value;
3110	3927	instruction->op1 = op1;
3111	3928	instruction->op2 = op2;
3112	3929	instruction->result_ptr = result_ptr;
3113		instruction->result_ptr_type = result_ptr_type;
3114	3930
3115	3931	ir_ref_instruction(type_value, irb->current_basic_block);
3116	3932	ir_ref_instruction(op1, irb->current_basic_block);
...	...	@@ -3120,49 +3936,30 @@ static IrInstruction ir_build_overflow_op(IrBuilder irb, Scope *scope, AstNode
3120	3936	return &instruction->base;
3121	3937	}
3122	3938
	3939	static IrInstGen ir_build_overflow_op_gen(IrAnalyze ira, IrInst *source_instr,
	3940	IrOverflowOp op, IrInstGen op1, IrInstGen op2, IrInstGen *result_ptr,
	3941	ZigType *result_ptr_type)
	3942	{
	3943	IrInstGenOverflowOp *instruction = ir_build_inst_gen<IrInstGenOverflowOp>(&ira->new_irb,
	3944	source_instr->scope, source_instr->source_node);
	3945	instruction->base.value->type = ira->codegen->builtin_types.entry_bool;
	3946	instruction->op = op;
	3947	instruction->op1 = op1;
	3948	instruction->op2 = op2;
	3949	instruction->result_ptr = result_ptr;
	3950	instruction->result_ptr_type = result_ptr_type;
3123	3951
3124		//TODO Powi, Pow, minnum, maxnum, maximum, minimum, copysign,
3125		// lround, llround, lrint, llrint
3126		// So far this is only non-complicated type functions.
3127		const char *float_op_to_name(BuiltinFnId op) {
3128		switch (op) {
3129		case BuiltinFnIdSqrt:
3130		return "sqrt";
3131		case BuiltinFnIdSin:
3132		return "sin";
3133		case BuiltinFnIdCos:
3134		return "cos";
3135		case BuiltinFnIdExp:
3136		return "exp";
3137		case BuiltinFnIdExp2:
3138		return "exp2";
3139		case BuiltinFnIdLog:
3140		return "log";
3141		case BuiltinFnIdLog10:
3142		return "log10";
3143		case BuiltinFnIdLog2:
3144		return "log2";
3145		case BuiltinFnIdFabs:
3146		return "fabs";
3147		case BuiltinFnIdFloor:
3148		return "floor";
3149		case BuiltinFnIdCeil:
3150		return "ceil";
3151		case BuiltinFnIdTrunc:
3152		return "trunc";
3153		case BuiltinFnIdNearbyInt:
3154		return "nearbyint";
3155		case BuiltinFnIdRound:
3156		return "round";
3157		default:
3158		zig_unreachable();
3159		}
	3952	ir_ref_inst_gen(op1, ira->new_irb.current_basic_block);
	3953	ir_ref_inst_gen(op2, ira->new_irb.current_basic_block);
	3954	ir_ref_inst_gen(result_ptr, ira->new_irb.current_basic_block);
	3955
	3956	return &instruction->base;
3160	3957	}
3161	3958
3162		static IrInstruction ir_build_float_op(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *operand,
	3959	static IrInstSrc ir_build_float_op_src(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *operand,
3163	3960	BuiltinFnId fn_id)
3164	3961	{
3165		IrInstructionFloatOp *instruction = ir_build_instruction<IrInstructionFloatOp>(irb, scope, source_node);
	3962	IrInstSrcFloatOp *instruction = ir_build_instruction<IrInstSrcFloatOp>(irb, scope, source_node);
3166	3963	instruction->operand = operand;
3167	3964	instruction->fn_id = fn_id;
3168	3965
...	...	@@ -3171,9 +3968,24 @@ static IrInstruction ir_build_float_op(IrBuilder irb, Scope scope, AstNode s
3171	3968	return &instruction->base;
3172	3969	}
3173	3970
3174		static IrInstruction ir_build_mul_add(IrBuilder irb, Scope scope, AstNode source_node,
3175		IrInstruction type_value, IrInstruction op1, IrInstruction op2, IrInstruction op3) {
3176		IrInstructionMulAdd *instruction = ir_build_instruction<IrInstructionMulAdd>(irb, scope, source_node);
	3971	static IrInstGen ir_build_float_op_gen(IrAnalyze ira, IrInst source_instr, IrInstGen operand,
	3972	BuiltinFnId fn_id, ZigType *operand_type)
	3973	{
	3974	IrInstGenFloatOp *instruction = ir_build_inst_gen<IrInstGenFloatOp>(&ira->new_irb,
	3975	source_instr->scope, source_instr->source_node);
	3976	instruction->base.value->type = operand_type;
	3977	instruction->operand = operand;
	3978	instruction->fn_id = fn_id;
	3979
	3980	ir_ref_inst_gen(operand, ira->new_irb.current_basic_block);
	3981
	3982	return &instruction->base;
	3983	}
	3984
	3985	static IrInstSrc ir_build_mul_add_src(IrBuilderSrc irb, Scope scope, AstNode source_node,
	3986	IrInstSrc type_value, IrInstSrc op1, IrInstSrc op2, IrInstSrc op3)
	3987	{
	3988	IrInstSrcMulAdd *instruction = ir_build_instruction<IrInstSrcMulAdd>(irb, scope, source_node);
3177	3989	instruction->type_value = type_value;
3178	3990	instruction->op1 = op1;
3179	3991	instruction->op2 = op2;
...	...	@@ -3187,8 +3999,25 @@ static IrInstruction ir_build_mul_add(IrBuilder irb, Scope scope, AstNode so
3187	3999	return &instruction->base;
3188	4000	}
3189	4001
3190		static IrInstruction ir_build_align_of(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *type_value) {
3191		IrInstructionAlignOf *instruction = ir_build_instruction<IrInstructionAlignOf>(irb, scope, source_node);
	4002	static IrInstGen ir_build_mul_add_gen(IrAnalyze ira, IrInst source_instr, IrInstGen op1, IrInstGen *op2,
	4003	IrInstGen op3, ZigType expr_type)
	4004	{
	4005	IrInstGenMulAdd *instruction = ir_build_inst_gen<IrInstGenMulAdd>(&ira->new_irb,
	4006	source_instr->scope, source_instr->source_node);
	4007	instruction->base.value->type = expr_type;
	4008	instruction->op1 = op1;
	4009	instruction->op2 = op2;
	4010	instruction->op3 = op3;
	4011
	4012	ir_ref_inst_gen(op1, ira->new_irb.current_basic_block);
	4013	ir_ref_inst_gen(op2, ira->new_irb.current_basic_block);
	4014	ir_ref_inst_gen(op3, ira->new_irb.current_basic_block);
	4015
	4016	return &instruction->base;
	4017	}
	4018
	4019	static IrInstSrc ir_build_align_of(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *type_value) {
	4020	IrInstSrcAlignOf *instruction = ir_build_instruction<IrInstSrcAlignOf>(irb, scope, source_node);
3192	4021	instruction->type_value = type_value;
3193	4022
3194	4023	ir_ref_instruction(type_value, irb->current_basic_block);
...	...	@@ -3196,10 +4025,10 @@ static IrInstruction ir_build_align_of(IrBuilder irb, Scope scope, AstNode s
3196	4025	return &instruction->base;
3197	4026	}
3198	4027
3199		static IrInstruction ir_build_test_err_src(IrBuilder irb, Scope scope, AstNode source_node,
3200		IrInstruction *base_ptr, bool resolve_err_set, bool base_ptr_is_payload)
	4028	static IrInstSrc ir_build_test_err_src(IrBuilderSrc irb, Scope scope, AstNode source_node,
	4029	IrInstSrc *base_ptr, bool resolve_err_set, bool base_ptr_is_payload)
3201	4030	{
3202		IrInstructionTestErrSrc *instruction = ir_build_instruction<IrInstructionTestErrSrc>(irb, scope, source_node);
	4031	IrInstSrcTestErr *instruction = ir_build_instruction<IrInstSrcTestErr>(irb, scope, source_node);
3203	4032	instruction->base_ptr = base_ptr;
3204	4033	instruction->resolve_err_set = resolve_err_set;
3205	4034	instruction->base_ptr_is_payload = base_ptr_is_payload;
...	...	@@ -3209,48 +4038,72 @@ static IrInstruction ir_build_test_err_src(IrBuilder irb, Scope *scope, AstNod
3209	4038	return &instruction->base;
3210	4039	}
3211	4040
3212		static IrInstruction ir_build_test_err_gen(IrAnalyze ira, IrInstruction *source_instruction,
3213		IrInstruction *err_union)
3214		{
3215		IrInstructionTestErrGen *instruction = ir_build_instruction<IrInstructionTestErrGen>(
	4041	static IrInstGen ir_build_test_err_gen(IrAnalyze ira, IrInst source_instruction, IrInstGen err_union) {
	4042	IrInstGenTestErr *instruction = ir_build_inst_gen<IrInstGenTestErr>(
3216	4043	&ira->new_irb, source_instruction->scope, source_instruction->source_node);
3217	4044	instruction->base.value->type = ira->codegen->builtin_types.entry_bool;
3218	4045	instruction->err_union = err_union;
3219	4046
3220		ir_ref_instruction(err_union, ira->new_irb.current_basic_block);
	4047	ir_ref_inst_gen(err_union, ira->new_irb.current_basic_block);
3221	4048
3222	4049	return &instruction->base;
3223	4050	}
3224	4051
3225		static IrInstruction ir_build_unwrap_err_code(IrBuilder irb, Scope scope, AstNode source_node,
3226		IrInstruction *err_union_ptr)
	4052	static IrInstSrc ir_build_unwrap_err_code_src(IrBuilderSrc irb, Scope scope, AstNode source_node,
	4053	IrInstSrc *err_union_ptr)
3227	4054	{
3228		IrInstructionUnwrapErrCode *instruction = ir_build_instruction<IrInstructionUnwrapErrCode>(irb, scope, source_node);
3229		instruction->err_union_ptr = err_union_ptr;
	4055	IrInstSrcUnwrapErrCode *inst = ir_build_instruction<IrInstSrcUnwrapErrCode>(irb, scope, source_node);
	4056	inst->err_union_ptr = err_union_ptr;
3230	4057
3231	4058	ir_ref_instruction(err_union_ptr, irb->current_basic_block);
3232	4059
3233		return &instruction->base;
	4060	return &inst->base;
3234	4061	}
3235	4062
3236		static IrInstruction ir_build_unwrap_err_payload(IrBuilder irb, Scope scope, AstNode source_node,
3237		IrInstruction *value, bool safety_check_on, bool initializing)
	4063	static IrInstGen ir_build_unwrap_err_code_gen(IrAnalyze ira, Scope scope, AstNode source_node,
	4064	IrInstGen err_union_ptr, ZigType result_type)
3238	4065	{
3239		IrInstructionUnwrapErrPayload *instruction = ir_build_instruction<IrInstructionUnwrapErrPayload>(irb, scope, source_node);
3240		instruction->value = value;
3241		instruction->safety_check_on = safety_check_on;
3242		instruction->initializing = initializing;
	4066	IrInstGenUnwrapErrCode *inst = ir_build_inst_gen<IrInstGenUnwrapErrCode>(&ira->new_irb, scope, source_node);
	4067	inst->base.value->type = result_type;
	4068	inst->err_union_ptr = err_union_ptr;
	4069
	4070	ir_ref_inst_gen(err_union_ptr, ira->new_irb.current_basic_block);
	4071
	4072	return &inst->base;
	4073	}
	4074
	4075	static IrInstSrc ir_build_unwrap_err_payload_src(IrBuilderSrc irb, Scope scope, AstNode source_node,
	4076	IrInstSrc *value, bool safety_check_on, bool initializing)
	4077	{
	4078	IrInstSrcUnwrapErrPayload *inst = ir_build_instruction<IrInstSrcUnwrapErrPayload>(irb, scope, source_node);
	4079	inst->value = value;
	4080	inst->safety_check_on = safety_check_on;
	4081	inst->initializing = initializing;
3243	4082
3244	4083	ir_ref_instruction(value, irb->current_basic_block);
3245	4084
3246		return &instruction->base;
	4085	return &inst->base;
	4086	}
	4087
	4088	static IrInstGen ir_build_unwrap_err_payload_gen(IrAnalyze ira, Scope scope, AstNode source_node,
	4089	IrInstGen value, bool safety_check_on, bool initializing, ZigType result_type)
	4090	{
	4091	IrInstGenUnwrapErrPayload *inst = ir_build_inst_gen<IrInstGenUnwrapErrPayload>(&ira->new_irb, scope, source_node);
	4092	inst->base.value->type = result_type;
	4093	inst->value = value;
	4094	inst->safety_check_on = safety_check_on;
	4095	inst->initializing = initializing;
	4096
	4097	ir_ref_inst_gen(value, ira->new_irb.current_basic_block);
	4098
	4099	return &inst->base;
3247	4100	}
3248	4101
3249		static IrInstruction ir_build_fn_proto(IrBuilder irb, Scope scope, AstNode source_node,
3250		IrInstruction *param_types, IrInstruction align_value, IrInstruction *callconv_value,
3251		IrInstruction *return_type, bool is_var_args)
	4102	static IrInstSrc ir_build_fn_proto(IrBuilderSrc irb, Scope scope, AstNode source_node,
	4103	IrInstSrc *param_types, IrInstSrc align_value, IrInstSrc *callconv_value,
	4104	IrInstSrc *return_type, bool is_var_args)
3252	4105	{
3253		IrInstructionFnProto *instruction = ir_build_instruction<IrInstructionFnProto>(irb, scope, source_node);
	4106	IrInstSrcFnProto *instruction = ir_build_instruction<IrInstSrcFnProto>(irb, scope, source_node);
3254	4107	instruction->param_types = param_types;
3255	4108	instruction->align_value = align_value;
3256	4109	instruction->callconv_value = callconv_value;
...	...	@@ -3270,8 +4123,8 @@ static IrInstruction ir_build_fn_proto(IrBuilder irb, Scope scope, AstNode s
3270	4123	return &instruction->base;
3271	4124	}
3272	4125
3273		static IrInstruction ir_build_test_comptime(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *value) {
3274		IrInstructionTestComptime *instruction = ir_build_instruction<IrInstructionTestComptime>(irb, scope, source_node);
	4126	static IrInstSrc ir_build_test_comptime(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *value) {
	4127	IrInstSrcTestComptime *instruction = ir_build_instruction<IrInstSrcTestComptime>(irb, scope, source_node);
3275	4128	instruction->value = value;
3276	4129
3277	4130	ir_ref_instruction(value, irb->current_basic_block);
...	...	@@ -3279,10 +4132,10 @@ static IrInstruction ir_build_test_comptime(IrBuilder irb, Scope *scope, AstNo
3279	4132	return &instruction->base;
3280	4133	}
3281	4134
3282		static IrInstruction ir_build_ptr_cast_src(IrBuilder irb, Scope scope, AstNode source_node,
3283		IrInstruction dest_type, IrInstruction ptr, bool safety_check_on)
	4135	static IrInstSrc ir_build_ptr_cast_src(IrBuilderSrc irb, Scope scope, AstNode source_node,
	4136	IrInstSrc dest_type, IrInstSrc ptr, bool safety_check_on)
3284	4137	{
3285		IrInstructionPtrCastSrc *instruction = ir_build_instruction<IrInstructionPtrCastSrc>(
	4138	IrInstSrcPtrCast *instruction = ir_build_instruction<IrInstSrcPtrCast>(
3286	4139	irb, scope, source_node);
3287	4140	instruction->dest_type = dest_type;
3288	4141	instruction->ptr = ptr;
...	...	@@ -3294,39 +4147,24 @@ static IrInstruction ir_build_ptr_cast_src(IrBuilder irb, Scope *scope, AstNod
3294	4147	return &instruction->base;
3295	4148	}
3296	4149
3297		static IrInstruction ir_build_ptr_cast_gen(IrAnalyze ira, IrInstruction *source_instruction,
3298		ZigType ptr_type, IrInstruction ptr, bool safety_check_on)
	4150	static IrInstGen ir_build_ptr_cast_gen(IrAnalyze ira, IrInst *source_instruction,
	4151	ZigType ptr_type, IrInstGen ptr, bool safety_check_on)
3299	4152	{
3300		IrInstructionPtrCastGen *instruction = ir_build_instruction<IrInstructionPtrCastGen>(
	4153	IrInstGenPtrCast *instruction = ir_build_inst_gen<IrInstGenPtrCast>(
3301	4154	&ira->new_irb, source_instruction->scope, source_instruction->source_node);
3302	4155	instruction->base.value->type = ptr_type;
3303	4156	instruction->ptr = ptr;
3304	4157	instruction->safety_check_on = safety_check_on;
3305	4158
3306		ir_ref_instruction(ptr, ira->new_irb.current_basic_block);
	4159	ir_ref_inst_gen(ptr, ira->new_irb.current_basic_block);
3307	4160
3308	4161	return &instruction->base;
3309	4162	}
3310	4163
3311		static IrInstruction ir_build_load_ptr_gen(IrAnalyze ira, IrInstruction *source_instruction,
3312		IrInstruction ptr, ZigType ty, IrInstruction *result_loc)
	4164	static IrInstSrc ir_build_implicit_cast(IrBuilderSrc irb, Scope scope, AstNode source_node,
	4165	IrInstSrc operand, ResultLocCast result_loc_cast)
3313	4166	{
3314		IrInstructionLoadPtrGen *instruction = ir_build_instruction<IrInstructionLoadPtrGen>(
3315		&ira->new_irb, source_instruction->scope, source_instruction->source_node);
3316		instruction->base.value->type = ty;
3317		instruction->ptr = ptr;
3318		instruction->result_loc = result_loc;
3319
3320		ir_ref_instruction(ptr, ira->new_irb.current_basic_block);
3321		if (result_loc != nullptr) ir_ref_instruction(result_loc, ira->new_irb.current_basic_block);
3322
3323		return &instruction->base;
3324		}
3325
3326		static IrInstruction ir_build_implicit_cast(IrBuilder irb, Scope scope, AstNode source_node,
3327		IrInstruction operand, ResultLocCast result_loc_cast)
3328		{
3329		IrInstructionImplicitCast *instruction = ir_build_instruction<IrInstructionImplicitCast>(irb, scope, source_node);
	4167	IrInstSrcImplicitCast *instruction = ir_build_instruction<IrInstSrcImplicitCast>(irb, scope, source_node);
3330	4168	instruction->operand = operand;
3331	4169	instruction->result_loc_cast = result_loc_cast;
3332	4170
...	...	@@ -3335,10 +4173,10 @@ static IrInstruction ir_build_implicit_cast(IrBuilder irb, Scope *scope, AstNo
3335	4173	return &instruction->base;
3336	4174	}
3337	4175
3338		static IrInstruction ir_build_bit_cast_src(IrBuilder irb, Scope scope, AstNode source_node,
3339		IrInstruction operand, ResultLocBitCast result_loc_bit_cast)
	4176	static IrInstSrc ir_build_bit_cast_src(IrBuilderSrc irb, Scope scope, AstNode source_node,
	4177	IrInstSrc operand, ResultLocBitCast result_loc_bit_cast)
3340	4178	{
3341		IrInstructionBitCastSrc *instruction = ir_build_instruction<IrInstructionBitCastSrc>(irb, scope, source_node);
	4179	IrInstSrcBitCast *instruction = ir_build_instruction<IrInstSrcBitCast>(irb, scope, source_node);
3342	4180	instruction->operand = operand;
3343	4181	instruction->result_loc_bit_cast = result_loc_bit_cast;
3344	4182
...	...	@@ -3347,62 +4185,81 @@ static IrInstruction ir_build_bit_cast_src(IrBuilder irb, Scope *scope, AstNod
3347	4185	return &instruction->base;
3348	4186	}
3349	4187
3350		static IrInstruction ir_build_bit_cast_gen(IrAnalyze ira, IrInstruction *source_instruction,
3351		IrInstruction operand, ZigType ty)
	4188	static IrInstGen ir_build_bit_cast_gen(IrAnalyze ira, IrInst *source_instruction,
	4189	IrInstGen operand, ZigType ty)
3352	4190	{
3353		IrInstructionBitCastGen *instruction = ir_build_instruction<IrInstructionBitCastGen>(
	4191	IrInstGenBitCast *instruction = ir_build_inst_gen<IrInstGenBitCast>(
3354	4192	&ira->new_irb, source_instruction->scope, source_instruction->source_node);
3355	4193	instruction->base.value->type = ty;
3356	4194	instruction->operand = operand;
3357	4195
3358		ir_ref_instruction(operand, ira->new_irb.current_basic_block);
	4196	ir_ref_inst_gen(operand, ira->new_irb.current_basic_block);
3359	4197
3360	4198	return &instruction->base;
3361	4199	}
3362	4200
3363		static IrInstruction ir_build_widen_or_shorten(IrBuilder irb, Scope scope, AstNode source_node,
3364		IrInstruction *target)
	4201	static IrInstGen ir_build_widen_or_shorten(IrAnalyze ira, Scope scope, AstNode source_node, IrInstGen *target,
	4202	ZigType *result_type)
3365	4203	{
3366		IrInstructionWidenOrShorten *instruction = ir_build_instruction<IrInstructionWidenOrShorten>(
3367		irb, scope, source_node);
3368		instruction->target = target;
	4204	IrInstGenWidenOrShorten *inst = ir_build_inst_gen<IrInstGenWidenOrShorten>(&ira->new_irb, scope, source_node);
	4205	inst->base.value->type = result_type;
	4206	inst->target = target;
3369	4207
3370		ir_ref_instruction(target, irb->current_basic_block);
	4208	ir_ref_inst_gen(target, ira->new_irb.current_basic_block);
3371	4209
3372		return &instruction->base;
	4210	return &inst->base;
3373	4211	}
3374	4212
3375		static IrInstruction ir_build_int_to_ptr(IrBuilder irb, Scope scope, AstNode source_node,
3376		IrInstruction dest_type, IrInstruction target)
	4213	static IrInstSrc ir_build_int_to_ptr_src(IrBuilderSrc irb, Scope scope, AstNode source_node,
	4214	IrInstSrc dest_type, IrInstSrc target)
3377	4215	{
3378		IrInstructionIntToPtr *instruction = ir_build_instruction<IrInstructionIntToPtr>(
3379		irb, scope, source_node);
	4216	IrInstSrcIntToPtr *instruction = ir_build_instruction<IrInstSrcIntToPtr>(irb, scope, source_node);
3380	4217	instruction->dest_type = dest_type;
3381	4218	instruction->target = target;
3382	4219
3383		if (dest_type) ir_ref_instruction(dest_type, irb->current_basic_block);
	4220	ir_ref_instruction(dest_type, irb->current_basic_block);
3384	4221	ir_ref_instruction(target, irb->current_basic_block);
3385	4222
3386	4223	return &instruction->base;
3387	4224	}
3388	4225
3389		static IrInstruction ir_build_ptr_to_int(IrBuilder irb, Scope scope, AstNode source_node,
3390		IrInstruction *target)
	4226	static IrInstGen ir_build_int_to_ptr_gen(IrAnalyze ira, Scope scope, AstNode source_node,
	4227	IrInstGen target, ZigType ptr_type)
3391	4228	{
3392		IrInstructionPtrToInt *instruction = ir_build_instruction<IrInstructionPtrToInt>(
3393		irb, scope, source_node);
	4229	IrInstGenIntToPtr *instruction = ir_build_inst_gen<IrInstGenIntToPtr>(&ira->new_irb, scope, source_node);
	4230	instruction->base.value->type = ptr_type;
3394	4231	instruction->target = target;
3395	4232
3396		ir_ref_instruction(target, irb->current_basic_block);
	4233	ir_ref_inst_gen(target, ira->new_irb.current_basic_block);
3397	4234
3398	4235	return &instruction->base;
3399	4236	}
3400	4237
3401		static IrInstruction ir_build_int_to_enum(IrBuilder irb, Scope scope, AstNode source_node,
3402		IrInstruction dest_type, IrInstruction target)
	4238	static IrInstSrc ir_build_ptr_to_int_src(IrBuilderSrc irb, Scope scope, AstNode source_node,
	4239	IrInstSrc *target)
3403	4240	{
3404		IrInstructionIntToEnum *instruction = ir_build_instruction<IrInstructionIntToEnum>(
3405		irb, scope, source_node);
	4241	IrInstSrcPtrToInt *inst = ir_build_instruction<IrInstSrcPtrToInt>(irb, scope, source_node);
	4242	inst->target = target;
	4243
	4244	ir_ref_instruction(target, irb->current_basic_block);
	4245
	4246	return &inst->base;
	4247	}
	4248
	4249	static IrInstGen ir_build_ptr_to_int_gen(IrAnalyze ira, IrInst source_instr, IrInstGen target) {
	4250	IrInstGenPtrToInt *inst = ir_build_inst_gen<IrInstGenPtrToInt>(&ira->new_irb, source_instr->scope, source_instr->source_node);
	4251	inst->base.value->type = ira->codegen->builtin_types.entry_usize;
	4252	inst->target = target;
	4253
	4254	ir_ref_inst_gen(target, ira->new_irb.current_basic_block);
	4255
	4256	return &inst->base;
	4257	}
	4258
	4259	static IrInstSrc ir_build_int_to_enum_src(IrBuilderSrc irb, Scope scope, AstNode source_node,
	4260	IrInstSrc dest_type, IrInstSrc target)
	4261	{
	4262	IrInstSrcIntToEnum *instruction = ir_build_instruction<IrInstSrcIntToEnum>(irb, scope, source_node);
3406	4263	instruction->dest_type = dest_type;
3407	4264	instruction->target = target;
3408	4265
...	...	@@ -3412,12 +4269,22 @@ static IrInstruction ir_build_int_to_enum(IrBuilder irb, Scope *scope, AstNode
3412	4269	return &instruction->base;
3413	4270	}
3414	4271
	4272	static IrInstGen ir_build_int_to_enum_gen(IrAnalyze ira, Scope scope, AstNode source_node,
	4273	ZigType dest_type, IrInstGen target)
	4274	{
	4275	IrInstGenIntToEnum *instruction = ir_build_inst_gen<IrInstGenIntToEnum>(&ira->new_irb, scope, source_node);
	4276	instruction->base.value->type = dest_type;
	4277	instruction->target = target;
3415	4278
	4279	ir_ref_inst_gen(target, ira->new_irb.current_basic_block);
3416	4280
3417		static IrInstruction ir_build_enum_to_int(IrBuilder irb, Scope scope, AstNode source_node,
3418		IrInstruction *target)
	4281	return &instruction->base;
	4282	}
	4283
	4284	static IrInstSrc ir_build_enum_to_int(IrBuilderSrc irb, Scope scope, AstNode source_node,
	4285	IrInstSrc *target)
3419	4286	{
3420		IrInstructionEnumToInt *instruction = ir_build_instruction<IrInstructionEnumToInt>(
	4287	IrInstSrcEnumToInt *instruction = ir_build_instruction<IrInstSrcEnumToInt>(
3421	4288	irb, scope, source_node);
3422	4289	instruction->target = target;
3423	4290
...	...	@@ -3426,11 +4293,10 @@ static IrInstruction ir_build_enum_to_int(IrBuilder irb, Scope *scope, AstNode
3426	4293	return &instruction->base;
3427	4294	}
3428	4295
3429		static IrInstruction ir_build_int_to_err(IrBuilder irb, Scope scope, AstNode source_node,
3430		IrInstruction *target)
	4296	static IrInstSrc ir_build_int_to_err_src(IrBuilderSrc irb, Scope scope, AstNode source_node,
	4297	IrInstSrc *target)
3431	4298	{
3432		IrInstructionIntToErr *instruction = ir_build_instruction<IrInstructionIntToErr>(
3433		irb, scope, source_node);
	4299	IrInstSrcIntToErr *instruction = ir_build_instruction<IrInstSrcIntToErr>(irb, scope, source_node);
3434	4300	instruction->target = target;
3435	4301
3436	4302	ir_ref_instruction(target, irb->current_basic_block);
...	...	@@ -3438,10 +4304,22 @@ static IrInstruction ir_build_int_to_err(IrBuilder irb, Scope *scope, AstNode
3438	4304	return &instruction->base;
3439	4305	}
3440	4306
3441		static IrInstruction ir_build_err_to_int(IrBuilder irb, Scope scope, AstNode source_node,
3442		IrInstruction *target)
	4307	static IrInstGen ir_build_int_to_err_gen(IrAnalyze ira, Scope scope, AstNode source_node, IrInstGen *target,
	4308	ZigType *wanted_type)
	4309	{
	4310	IrInstGenIntToErr *instruction = ir_build_inst_gen<IrInstGenIntToErr>(&ira->new_irb, scope, source_node);
	4311	instruction->base.value->type = wanted_type;
	4312	instruction->target = target;
	4313
	4314	ir_ref_inst_gen(target, ira->new_irb.current_basic_block);
	4315
	4316	return &instruction->base;
	4317	}
	4318
	4319	static IrInstSrc ir_build_err_to_int_src(IrBuilderSrc irb, Scope scope, AstNode source_node,
	4320	IrInstSrc *target)
3443	4321	{
3444		IrInstructionErrToInt *instruction = ir_build_instruction<IrInstructionErrToInt>(
	4322	IrInstSrcErrToInt *instruction = ir_build_instruction<IrInstSrcErrToInt>(
3445	4323	irb, scope, source_node);
3446	4324	instruction->target = target;
3447	4325
...	...	@@ -3450,11 +4328,23 @@ static IrInstruction ir_build_err_to_int(IrBuilder irb, Scope *scope, AstNode
3450	4328	return &instruction->base;
3451	4329	}
3452	4330
3453		static IrInstruction ir_build_check_switch_prongs(IrBuilder irb, Scope scope, AstNode source_node,
3454		IrInstruction target_value, IrInstructionCheckSwitchProngsRange ranges, size_t range_count,
	4331	static IrInstGen ir_build_err_to_int_gen(IrAnalyze ira, Scope scope, AstNode source_node, IrInstGen *target,
	4332	ZigType *wanted_type)
	4333	{
	4334	IrInstGenErrToInt *instruction = ir_build_inst_gen<IrInstGenErrToInt>(&ira->new_irb, scope, source_node);
	4335	instruction->base.value->type = wanted_type;
	4336	instruction->target = target;
	4337
	4338	ir_ref_inst_gen(target, ira->new_irb.current_basic_block);
	4339
	4340	return &instruction->base;
	4341	}
	4342
	4343	static IrInstSrc ir_build_check_switch_prongs(IrBuilderSrc irb, Scope scope, AstNode source_node,
	4344	IrInstSrc target_value, IrInstSrcCheckSwitchProngsRange ranges, size_t range_count,
3455	4345	bool have_else_prong, bool have_underscore_prong)
3456	4346	{
3457		IrInstructionCheckSwitchProngs *instruction = ir_build_instruction<IrInstructionCheckSwitchProngs>(
	4347	IrInstSrcCheckSwitchProngs *instruction = ir_build_instruction<IrInstSrcCheckSwitchProngs>(
3458	4348	irb, scope, source_node);
3459	4349	instruction->target_value = target_value;
3460	4350	instruction->ranges = ranges;
...	...	@@ -3471,10 +4361,10 @@ static IrInstruction ir_build_check_switch_prongs(IrBuilder irb, Scope *scope,
3471	4361	return &instruction->base;
3472	4362	}
3473	4363
3474		static IrInstruction ir_build_check_statement_is_void(IrBuilder irb, Scope scope, AstNode source_node,
3475		IrInstruction* statement_value)
	4364	static IrInstSrc ir_build_check_statement_is_void(IrBuilderSrc irb, Scope scope, AstNode source_node,
	4365	IrInstSrc* statement_value)
3476	4366	{
3477		IrInstructionCheckStatementIsVoid *instruction = ir_build_instruction<IrInstructionCheckStatementIsVoid>(
	4367	IrInstSrcCheckStatementIsVoid *instruction = ir_build_instruction<IrInstSrcCheckStatementIsVoid>(
3478	4368	irb, scope, source_node);
3479	4369	instruction->statement_value = statement_value;
3480	4370
...	...	@@ -3483,11 +4373,10 @@ static IrInstruction ir_build_check_statement_is_void(IrBuilder irb, Scope *sc
3483	4373	return &instruction->base;
3484	4374	}
3485	4375
3486		static IrInstruction ir_build_type_name(IrBuilder irb, Scope scope, AstNode source_node,
3487		IrInstruction *type_value)
	4376	static IrInstSrc ir_build_type_name(IrBuilderSrc irb, Scope scope, AstNode source_node,
	4377	IrInstSrc *type_value)
3488	4378	{
3489		IrInstructionTypeName *instruction = ir_build_instruction<IrInstructionTypeName>(
3490		irb, scope, source_node);
	4379	IrInstSrcTypeName *instruction = ir_build_instruction<IrInstSrcTypeName>(irb, scope, source_node);
3491	4380	instruction->type_value = type_value;
3492	4381
3493	4382	ir_ref_instruction(type_value, irb->current_basic_block);
...	...	@@ -3495,18 +4384,17 @@ static IrInstruction ir_build_type_name(IrBuilder irb, Scope scope, AstNode
3495	4384	return &instruction->base;
3496	4385	}
3497	4386
3498		static IrInstruction ir_build_decl_ref(IrBuilder irb, Scope scope, AstNode source_node, Tld *tld, LVal lval) {
3499		IrInstructionDeclRef *instruction = ir_build_instruction<IrInstructionDeclRef>(irb, scope, source_node);
	4387	static IrInstSrc ir_build_decl_ref(IrBuilderSrc irb, Scope scope, AstNode source_node, Tld *tld, LVal lval) {
	4388	IrInstSrcDeclRef *instruction = ir_build_instruction<IrInstSrcDeclRef>(irb, scope, source_node);
3500	4389	instruction->tld = tld;
3501	4390	instruction->lval = lval;
3502	4391
3503	4392	return &instruction->base;
3504	4393	}
3505	4394
3506		static IrInstruction ir_build_panic(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *msg) {
3507		IrInstructionPanic *instruction = ir_build_instruction<IrInstructionPanic>(irb, scope, source_node);
3508		instruction->base.value->special = ConstValSpecialStatic;
3509		instruction->base.value->type = irb->codegen->builtin_types.entry_unreachable;
	4395	static IrInstSrc ir_build_panic_src(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *msg) {
	4396	IrInstSrcPanic *instruction = ir_build_instruction<IrInstSrcPanic>(irb, scope, source_node);
	4397	instruction->base.is_noreturn = true;
3510	4398	instruction->msg = msg;
3511	4399
3512	4400	ir_ref_instruction(msg, irb->current_basic_block);
...	...	@@ -3514,10 +4402,18 @@ static IrInstruction ir_build_panic(IrBuilder irb, Scope scope, AstNode sour
3514	4402	return &instruction->base;
3515	4403	}
3516	4404
3517		static IrInstruction ir_build_tag_name(IrBuilder irb, Scope scope, AstNode source_node,
3518		IrInstruction *target)
3519		{
3520		IrInstructionTagName *instruction = ir_build_instruction<IrInstructionTagName>(irb, scope, source_node);
	4405	static IrInstGen ir_build_panic_gen(IrAnalyze ira, IrInst source_instr, IrInstGen msg) {
	4406	IrInstGenPanic *instruction = ir_build_inst_noreturn<IrInstGenPanic>(&ira->new_irb,
	4407	source_instr->scope, source_instr->source_node);
	4408	instruction->msg = msg;
	4409
	4410	ir_ref_inst_gen(msg, ira->new_irb.current_basic_block);
	4411
	4412	return &instruction->base;
	4413	}
	4414
	4415	static IrInstSrc ir_build_tag_name_src(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *target) {
	4416	IrInstSrcTagName *instruction = ir_build_instruction<IrInstSrcTagName>(irb, scope, source_node);
3521	4417	instruction->target = target;
3522	4418
3523	4419	ir_ref_instruction(target, irb->current_basic_block);
...	...	@@ -3525,10 +4421,23 @@ static IrInstruction ir_build_tag_name(IrBuilder irb, Scope scope, AstNode s
3525	4421	return &instruction->base;
3526	4422	}
3527	4423
3528		static IrInstruction ir_build_tag_type(IrBuilder irb, Scope scope, AstNode source_node,
3529		IrInstruction *target)
	4424	static IrInstGen ir_build_tag_name_gen(IrAnalyze ira, IrInst source_instr, IrInstGen target,
	4425	ZigType *result_type)
3530	4426	{
3531		IrInstructionTagType *instruction = ir_build_instruction<IrInstructionTagType>(irb, scope, source_node);
	4427	IrInstGenTagName *instruction = ir_build_inst_gen<IrInstGenTagName>(&ira->new_irb,
	4428	source_instr->scope, source_instr->source_node);
	4429	instruction->base.value->type = result_type;
	4430	instruction->target = target;
	4431
	4432	ir_ref_inst_gen(target, ira->new_irb.current_basic_block);
	4433
	4434	return &instruction->base;
	4435	}
	4436
	4437	static IrInstSrc ir_build_tag_type(IrBuilderSrc irb, Scope scope, AstNode source_node,
	4438	IrInstSrc *target)
	4439	{
	4440	IrInstSrcTagType *instruction = ir_build_instruction<IrInstSrcTagType>(irb, scope, source_node);
3532	4441	instruction->target = target;
3533	4442
3534	4443	ir_ref_instruction(target, irb->current_basic_block);
...	...	@@ -3536,27 +4445,40 @@ static IrInstruction ir_build_tag_type(IrBuilder irb, Scope scope, AstNode s
3536	4445	return &instruction->base;
3537	4446	}
3538	4447
3539		static IrInstruction ir_build_field_parent_ptr(IrBuilder irb, Scope scope, AstNode source_node,
3540		IrInstruction type_value, IrInstruction field_name, IrInstruction field_ptr, TypeStructField field)
	4448	static IrInstSrc ir_build_field_parent_ptr_src(IrBuilderSrc irb, Scope scope, AstNode source_node,
	4449	IrInstSrc type_value, IrInstSrc field_name, IrInstSrc *field_ptr)
3541	4450	{
3542		IrInstructionFieldParentPtr *instruction = ir_build_instruction<IrInstructionFieldParentPtr>(
	4451	IrInstSrcFieldParentPtr *inst = ir_build_instruction<IrInstSrcFieldParentPtr>(
3543	4452	irb, scope, source_node);
3544		instruction->type_value = type_value;
3545		instruction->field_name = field_name;
3546		instruction->field_ptr = field_ptr;
3547		instruction->field = field;
	4453	inst->type_value = type_value;
	4454	inst->field_name = field_name;
	4455	inst->field_ptr = field_ptr;
3548	4456
3549	4457	ir_ref_instruction(type_value, irb->current_basic_block);
3550	4458	ir_ref_instruction(field_name, irb->current_basic_block);
3551	4459	ir_ref_instruction(field_ptr, irb->current_basic_block);
3552	4460
3553		return &instruction->base;
	4461	return &inst->base;
	4462	}
	4463
	4464	static IrInstGen ir_build_field_parent_ptr_gen(IrAnalyze ira, IrInst *source_instr,
	4465	IrInstGen field_ptr, TypeStructField field, ZigType *result_type)
	4466	{
	4467	IrInstGenFieldParentPtr *inst = ir_build_inst_gen<IrInstGenFieldParentPtr>(&ira->new_irb,
	4468	source_instr->scope, source_instr->source_node);
	4469	inst->base.value->type = result_type;
	4470	inst->field_ptr = field_ptr;
	4471	inst->field = field;
	4472
	4473	ir_ref_inst_gen(field_ptr, ira->new_irb.current_basic_block);
	4474
	4475	return &inst->base;
3554	4476	}
3555	4477
3556		static IrInstruction ir_build_byte_offset_of(IrBuilder irb, Scope scope, AstNode source_node,
3557		IrInstruction type_value, IrInstruction field_name)
	4478	static IrInstSrc ir_build_byte_offset_of(IrBuilderSrc irb, Scope scope, AstNode source_node,
	4479	IrInstSrc type_value, IrInstSrc field_name)
3558	4480	{
3559		IrInstructionByteOffsetOf *instruction = ir_build_instruction<IrInstructionByteOffsetOf>(irb, scope, source_node);
	4481	IrInstSrcByteOffsetOf *instruction = ir_build_instruction<IrInstSrcByteOffsetOf>(irb, scope, source_node);
3560	4482	instruction->type_value = type_value;
3561	4483	instruction->field_name = field_name;
3562	4484
...	...	@@ -3566,10 +4488,10 @@ static IrInstruction ir_build_byte_offset_of(IrBuilder irb, Scope *scope, AstN
3566	4488	return &instruction->base;
3567	4489	}
3568	4490
3569		static IrInstruction ir_build_bit_offset_of(IrBuilder irb, Scope scope, AstNode source_node,
3570		IrInstruction type_value, IrInstruction field_name)
	4491	static IrInstSrc ir_build_bit_offset_of(IrBuilderSrc irb, Scope scope, AstNode source_node,
	4492	IrInstSrc type_value, IrInstSrc field_name)
3571	4493	{
3572		IrInstructionBitOffsetOf *instruction = ir_build_instruction<IrInstructionBitOffsetOf>(irb, scope, source_node);
	4494	IrInstSrcBitOffsetOf *instruction = ir_build_instruction<IrInstSrcBitOffsetOf>(irb, scope, source_node);
3573	4495	instruction->type_value = type_value;
3574	4496	instruction->field_name = field_name;
3575	4497
...	...	@@ -3579,9 +4501,8 @@ static IrInstruction ir_build_bit_offset_of(IrBuilder irb, Scope *scope, AstNo
3579	4501	return &instruction->base;
3580	4502	}
3581	4503
3582		static IrInstruction ir_build_type_info(IrBuilder irb, Scope scope, AstNode source_node,
3583		IrInstruction *type_value) {
3584		IrInstructionTypeInfo *instruction = ir_build_instruction<IrInstructionTypeInfo>(irb, scope, source_node);
	4504	static IrInstSrc ir_build_type_info(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *type_value) {
	4505	IrInstSrcTypeInfo *instruction = ir_build_instruction<IrInstSrcTypeInfo>(irb, scope, source_node);
3585	4506	instruction->type_value = type_value;
3586	4507
3587	4508	ir_ref_instruction(type_value, irb->current_basic_block);
...	...	@@ -3589,8 +4510,8 @@ static IrInstruction ir_build_type_info(IrBuilder irb, Scope scope, AstNode
3589	4510	return &instruction->base;
3590	4511	}
3591	4512
3592		static IrInstruction ir_build_type(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *type_info) {
3593		IrInstructionType *instruction = ir_build_instruction<IrInstructionType>(irb, scope, source_node);
	4513	static IrInstSrc ir_build_type(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *type_info) {
	4514	IrInstSrcType *instruction = ir_build_instruction<IrInstSrcType>(irb, scope, source_node);
3594	4515	instruction->type_info = type_info;
3595	4516
3596	4517	ir_ref_instruction(type_info, irb->current_basic_block);
...	...	@@ -3598,10 +4519,8 @@ static IrInstruction ir_build_type(IrBuilder irb, Scope scope, AstNode sourc
3598	4519	return &instruction->base;
3599	4520	}
3600	4521
3601		static IrInstruction ir_build_type_id(IrBuilder irb, Scope scope, AstNode source_node,
3602		IrInstruction *type_value)
3603		{
3604		IrInstructionTypeId *instruction = ir_build_instruction<IrInstructionTypeId>(irb, scope, source_node);
	4522	static IrInstSrc ir_build_type_id(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *type_value) {
	4523	IrInstSrcTypeId *instruction = ir_build_instruction<IrInstSrcTypeId>(irb, scope, source_node);
3605	4524	instruction->type_value = type_value;
3606	4525
3607	4526	ir_ref_instruction(type_value, irb->current_basic_block);
...	...	@@ -3609,10 +4528,10 @@ static IrInstruction ir_build_type_id(IrBuilder irb, Scope scope, AstNode so
3609	4528	return &instruction->base;
3610	4529	}
3611	4530
3612		static IrInstruction ir_build_set_eval_branch_quota(IrBuilder irb, Scope scope, AstNode source_node,
3613		IrInstruction *new_quota)
	4531	static IrInstSrc ir_build_set_eval_branch_quota(IrBuilderSrc irb, Scope scope, AstNode source_node,
	4532	IrInstSrc *new_quota)
3614	4533	{
3615		IrInstructionSetEvalBranchQuota *instruction = ir_build_instruction<IrInstructionSetEvalBranchQuota>(irb, scope, source_node);
	4534	IrInstSrcSetEvalBranchQuota *instruction = ir_build_instruction<IrInstSrcSetEvalBranchQuota>(irb, scope, source_node);
3616	4535	instruction->new_quota = new_quota;
3617	4536
3618	4537	ir_ref_instruction(new_quota, irb->current_basic_block);
...	...	@@ -3620,23 +4539,35 @@ static IrInstruction ir_build_set_eval_branch_quota(IrBuilder irb, Scope *scop
3620	4539	return &instruction->base;
3621	4540	}
3622	4541
3623		static IrInstruction ir_build_align_cast(IrBuilder irb, Scope scope, AstNode source_node,
3624		IrInstruction align_bytes, IrInstruction target)
	4542	static IrInstSrc ir_build_align_cast_src(IrBuilderSrc irb, Scope scope, AstNode source_node,
	4543	IrInstSrc align_bytes, IrInstSrc target)
3625	4544	{
3626		IrInstructionAlignCast *instruction = ir_build_instruction<IrInstructionAlignCast>(irb, scope, source_node);
	4545	IrInstSrcAlignCast *instruction = ir_build_instruction<IrInstSrcAlignCast>(irb, scope, source_node);
3627	4546	instruction->align_bytes = align_bytes;
3628	4547	instruction->target = target;
3629	4548
3630		if (align_bytes) ir_ref_instruction(align_bytes, irb->current_basic_block);
	4549	ir_ref_instruction(align_bytes, irb->current_basic_block);
3631	4550	ir_ref_instruction(target, irb->current_basic_block);
3632	4551
3633	4552	return &instruction->base;
3634	4553	}
3635	4554
3636		static IrInstruction ir_build_resolve_result(IrBuilder irb, Scope scope, AstNode source_node,
3637		ResultLoc result_loc, IrInstruction ty)
	4555	static IrInstGen ir_build_align_cast_gen(IrAnalyze ira, Scope scope, AstNode source_node, IrInstGen *target,
	4556	ZigType *result_type)
	4557	{
	4558	IrInstGenAlignCast *instruction = ir_build_inst_gen<IrInstGenAlignCast>(&ira->new_irb, scope, source_node);
	4559	instruction->base.value->type = result_type;
	4560	instruction->target = target;
	4561
	4562	ir_ref_inst_gen(target, ira->new_irb.current_basic_block);
	4563
	4564	return &instruction->base;
	4565	}
	4566
	4567	static IrInstSrc ir_build_resolve_result(IrBuilderSrc irb, Scope scope, AstNode source_node,
	4568	ResultLoc result_loc, IrInstSrc ty)
3638	4569	{
3639		IrInstructionResolveResult *instruction = ir_build_instruction<IrInstructionResolveResult>(irb, scope, source_node);
	4570	IrInstSrcResolveResult *instruction = ir_build_instruction<IrInstSrcResolveResult>(irb, scope, source_node);
3640	4571	instruction->result_loc = result_loc;
3641	4572	instruction->ty = ty;
3642	4573
...	...	@@ -3645,25 +4576,25 @@ static IrInstruction ir_build_resolve_result(IrBuilder irb, Scope *scope, AstN
3645	4576	return &instruction->base;
3646	4577	}
3647	4578
3648		static IrInstruction ir_build_reset_result(IrBuilder irb, Scope scope, AstNode source_node,
	4579	static IrInstSrc ir_build_reset_result(IrBuilderSrc irb, Scope scope, AstNode source_node,
3649	4580	ResultLoc *result_loc)
3650	4581	{
3651		IrInstructionResetResult *instruction = ir_build_instruction<IrInstructionResetResult>(irb, scope, source_node);
	4582	IrInstSrcResetResult *instruction = ir_build_instruction<IrInstSrcResetResult>(irb, scope, source_node);
3652	4583	instruction->result_loc = result_loc;
3653	4584
3654	4585	return &instruction->base;
3655	4586	}
3656	4587
3657		static IrInstruction ir_build_opaque_type(IrBuilder irb, Scope scope, AstNode source_node) {
3658		IrInstructionOpaqueType *instruction = ir_build_instruction<IrInstructionOpaqueType>(irb, scope, source_node);
	4588	static IrInstSrc ir_build_opaque_type(IrBuilderSrc irb, Scope scope, AstNode source_node) {
	4589	IrInstSrcOpaqueType *instruction = ir_build_instruction<IrInstSrcOpaqueType>(irb, scope, source_node);
3659	4590
3660	4591	return &instruction->base;
3661	4592	}
3662	4593
3663		static IrInstruction ir_build_set_align_stack(IrBuilder irb, Scope scope, AstNode source_node,
3664		IrInstruction *align_bytes)
	4594	static IrInstSrc ir_build_set_align_stack(IrBuilderSrc irb, Scope scope, AstNode source_node,
	4595	IrInstSrc *align_bytes)
3665	4596	{
3666		IrInstructionSetAlignStack *instruction = ir_build_instruction<IrInstructionSetAlignStack>(irb, scope, source_node);
	4597	IrInstSrcSetAlignStack *instruction = ir_build_instruction<IrInstSrcSetAlignStack>(irb, scope, source_node);
3667	4598	instruction->align_bytes = align_bytes;
3668	4599
3669	4600	ir_ref_instruction(align_bytes, irb->current_basic_block);
...	...	@@ -3671,10 +4602,10 @@ static IrInstruction ir_build_set_align_stack(IrBuilder irb, Scope *scope, Ast
3671	4602	return &instruction->base;
3672	4603	}
3673	4604
3674		static IrInstruction ir_build_arg_type(IrBuilder irb, Scope scope, AstNode source_node,
3675		IrInstruction fn_type, IrInstruction arg_index, bool allow_var)
	4605	static IrInstSrc ir_build_arg_type(IrBuilderSrc irb, Scope scope, AstNode source_node,
	4606	IrInstSrc fn_type, IrInstSrc arg_index, bool allow_var)
3676	4607	{
3677		IrInstructionArgType *instruction = ir_build_instruction<IrInstructionArgType>(irb, scope, source_node);
	4608	IrInstSrcArgType *instruction = ir_build_instruction<IrInstSrcArgType>(irb, scope, source_node);
3678	4609	instruction->fn_type = fn_type;
3679	4610	instruction->arg_index = arg_index;
3680	4611	instruction->allow_var = allow_var;
...	...	@@ -3685,17 +4616,29 @@ static IrInstruction ir_build_arg_type(IrBuilder irb, Scope scope, AstNode s
3685	4616	return &instruction->base;
3686	4617	}
3687	4618
3688		static IrInstruction ir_build_error_return_trace(IrBuilder irb, Scope scope, AstNode source_node, IrInstructionErrorReturnTrace::Optional optional) {
3689		IrInstructionErrorReturnTrace *instruction = ir_build_instruction<IrInstructionErrorReturnTrace>(irb, scope, source_node);
3690		instruction->optional = optional;
	4619	static IrInstSrc ir_build_error_return_trace_src(IrBuilderSrc irb, Scope scope, AstNode source_node,
	4620	IrInstErrorReturnTraceOptional optional)
	4621	{
	4622	IrInstSrcErrorReturnTrace *inst = ir_build_instruction<IrInstSrcErrorReturnTrace>(irb, scope, source_node);
	4623	inst->optional = optional;
	4624
	4625	return &inst->base;
	4626	}
	4627
	4628	static IrInstGen ir_build_error_return_trace_gen(IrAnalyze ira, Scope scope, AstNode source_node,
	4629	IrInstErrorReturnTraceOptional optional, ZigType *result_type)
	4630	{
	4631	IrInstGenErrorReturnTrace *inst = ir_build_inst_gen<IrInstGenErrorReturnTrace>(&ira->new_irb, scope, source_node);
	4632	inst->base.value->type = result_type;
	4633	inst->optional = optional;
3691	4634
3692		return &instruction->base;
	4635	return &inst->base;
3693	4636	}
3694	4637
3695		static IrInstruction ir_build_error_union(IrBuilder irb, Scope scope, AstNode source_node,
3696		IrInstruction err_set, IrInstruction payload)
	4638	static IrInstSrc ir_build_error_union(IrBuilderSrc irb, Scope scope, AstNode source_node,
	4639	IrInstSrc err_set, IrInstSrc payload)
3697	4640	{
3698		IrInstructionErrorUnion *instruction = ir_build_instruction<IrInstructionErrorUnion>(irb, scope, source_node);
	4641	IrInstSrcErrorUnion *instruction = ir_build_instruction<IrInstSrcErrorUnion>(irb, scope, source_node);
3699	4642	instruction->err_set = err_set;
3700	4643	instruction->payload = payload;
3701	4644
...	...	@@ -3705,85 +4648,130 @@ static IrInstruction ir_build_error_union(IrBuilder irb, Scope *scope, AstNode
3705	4648	return &instruction->base;
3706	4649	}
3707	4650
3708		static IrInstruction ir_build_atomic_rmw(IrBuilder irb, Scope scope, AstNode source_node,
3709		IrInstruction operand_type, IrInstruction ptr, IrInstruction op, IrInstruction operand,
3710		IrInstruction *ordering, AtomicRmwOp resolved_op, AtomicOrder resolved_ordering)
	4651	static IrInstSrc ir_build_atomic_rmw_src(IrBuilderSrc irb, Scope scope, AstNode source_node,
	4652	IrInstSrc operand_type, IrInstSrc ptr, IrInstSrc op, IrInstSrc operand,
	4653	IrInstSrc *ordering)
3711	4654	{
3712		IrInstructionAtomicRmw *instruction = ir_build_instruction<IrInstructionAtomicRmw>(irb, scope, source_node);
	4655	IrInstSrcAtomicRmw *instruction = ir_build_instruction<IrInstSrcAtomicRmw>(irb, scope, source_node);
3713	4656	instruction->operand_type = operand_type;
3714	4657	instruction->ptr = ptr;
3715		instruction->op = op;
3716		instruction->operand = operand;
	4658	instruction->op = op;
	4659	instruction->operand = operand;
	4660	instruction->ordering = ordering;
	4661
	4662	ir_ref_instruction(operand_type, irb->current_basic_block);
	4663	ir_ref_instruction(ptr, irb->current_basic_block);
	4664	ir_ref_instruction(op, irb->current_basic_block);
	4665	ir_ref_instruction(operand, irb->current_basic_block);
	4666	ir_ref_instruction(ordering, irb->current_basic_block);
	4667
	4668	return &instruction->base;
	4669	}
	4670
	4671	static IrInstGen ir_build_atomic_rmw_gen(IrAnalyze ira, IrInst *source_instr,
	4672	IrInstGen ptr, IrInstGen operand, AtomicRmwOp op, AtomicOrder ordering, ZigType *operand_type)
	4673	{
	4674	IrInstGenAtomicRmw *instruction = ir_build_inst_gen<IrInstGenAtomicRmw>(&ira->new_irb, source_instr->scope, source_instr->source_node);
	4675	instruction->base.value->type = operand_type;
	4676	instruction->ptr = ptr;
	4677	instruction->op = op;
	4678	instruction->operand = operand;
	4679	instruction->ordering = ordering;
	4680
	4681	ir_ref_inst_gen(ptr, ira->new_irb.current_basic_block);
	4682	ir_ref_inst_gen(operand, ira->new_irb.current_basic_block);
	4683
	4684	return &instruction->base;
	4685	}
	4686
	4687	static IrInstSrc ir_build_atomic_load_src(IrBuilderSrc irb, Scope scope, AstNode source_node,
	4688	IrInstSrc operand_type, IrInstSrc ptr, IrInstSrc *ordering)
	4689	{
	4690	IrInstSrcAtomicLoad *instruction = ir_build_instruction<IrInstSrcAtomicLoad>(irb, scope, source_node);
	4691	instruction->operand_type = operand_type;
	4692	instruction->ptr = ptr;
	4693	instruction->ordering = ordering;
	4694
	4695	ir_ref_instruction(operand_type, irb->current_basic_block);
	4696	ir_ref_instruction(ptr, irb->current_basic_block);
	4697	ir_ref_instruction(ordering, irb->current_basic_block);
	4698
	4699	return &instruction->base;
	4700	}
	4701
	4702	static IrInstGen ir_build_atomic_load_gen(IrAnalyze ira, IrInst *source_instr,
	4703	IrInstGen ptr, AtomicOrder ordering, ZigType operand_type)
	4704	{
	4705	IrInstGenAtomicLoad *instruction = ir_build_inst_gen<IrInstGenAtomicLoad>(&ira->new_irb,
	4706	source_instr->scope, source_instr->source_node);
	4707	instruction->base.value->type = operand_type;
	4708	instruction->ptr = ptr;
3717	4709	instruction->ordering = ordering;
3718		instruction->resolved_op = resolved_op;
3719		instruction->resolved_ordering = resolved_ordering;
3720	4710
3721		if (operand_type != nullptr) ir_ref_instruction(operand_type, irb->current_basic_block);
3722		ir_ref_instruction(ptr, irb->current_basic_block);
3723		if (op != nullptr) ir_ref_instruction(op, irb->current_basic_block);
3724		ir_ref_instruction(operand, irb->current_basic_block);
3725		if (ordering != nullptr) ir_ref_instruction(ordering, irb->current_basic_block);
	4711	ir_ref_inst_gen(ptr, ira->new_irb.current_basic_block);
3726	4712
3727	4713	return &instruction->base;
3728	4714	}
3729	4715
3730		static IrInstruction ir_build_atomic_load(IrBuilder irb, Scope scope, AstNode source_node,
3731		IrInstruction operand_type, IrInstruction ptr,
3732		IrInstruction *ordering, AtomicOrder resolved_ordering)
	4716	static IrInstSrc ir_build_atomic_store_src(IrBuilderSrc irb, Scope scope, AstNode source_node,
	4717	IrInstSrc operand_type, IrInstSrc ptr, IrInstSrc value, IrInstSrc ordering)
3733	4718	{
3734		IrInstructionAtomicLoad *instruction = ir_build_instruction<IrInstructionAtomicLoad>(irb, scope, source_node);
	4719	IrInstSrcAtomicStore *instruction = ir_build_instruction<IrInstSrcAtomicStore>(irb, scope, source_node);
3735	4720	instruction->operand_type = operand_type;
3736	4721	instruction->ptr = ptr;
	4722	instruction->value = value;
3737	4723	instruction->ordering = ordering;
3738		instruction->resolved_ordering = resolved_ordering;
3739	4724
3740		if (operand_type != nullptr) ir_ref_instruction(operand_type, irb->current_basic_block);
	4725	ir_ref_instruction(operand_type, irb->current_basic_block);
3741	4726	ir_ref_instruction(ptr, irb->current_basic_block);
3742		if (ordering != nullptr) ir_ref_instruction(ordering, irb->current_basic_block);
	4727	ir_ref_instruction(value, irb->current_basic_block);
	4728	ir_ref_instruction(ordering, irb->current_basic_block);
3743	4729
3744	4730	return &instruction->base;
3745	4731	}
3746	4732
3747		static IrInstruction ir_build_atomic_store(IrBuilder irb, Scope scope, AstNode source_node,
3748		IrInstruction operand_type, IrInstruction ptr, IrInstruction *value,
3749		IrInstruction *ordering, AtomicOrder resolved_ordering)
	4733	static IrInstGen ir_build_atomic_store_gen(IrAnalyze ira, IrInst *source_instr,
	4734	IrInstGen ptr, IrInstGen value, AtomicOrder ordering)
3750	4735	{
3751		IrInstructionAtomicStore *instruction = ir_build_instruction<IrInstructionAtomicStore>(irb, scope, source_node);
3752		instruction->operand_type = operand_type;
	4736	IrInstGenAtomicStore *instruction = ir_build_inst_void<IrInstGenAtomicStore>(&ira->new_irb,
	4737	source_instr->scope, source_instr->source_node);
3753	4738	instruction->ptr = ptr;
3754	4739	instruction->value = value;
3755	4740	instruction->ordering = ordering;
3756		instruction->resolved_ordering = resolved_ordering;
3757	4741
3758		if (operand_type != nullptr) ir_ref_instruction(operand_type, irb->current_basic_block);
3759		ir_ref_instruction(ptr, irb->current_basic_block);
3760		ir_ref_instruction(value, irb->current_basic_block);
3761		if (ordering != nullptr) ir_ref_instruction(ordering, irb->current_basic_block);
	4742	ir_ref_inst_gen(ptr, ira->new_irb.current_basic_block);
	4743	ir_ref_inst_gen(value, ira->new_irb.current_basic_block);
3762	4744
3763	4745	return &instruction->base;
3764	4746	}
3765	4747
3766		static IrInstruction ir_build_save_err_ret_addr(IrBuilder irb, Scope scope, AstNode source_node) {
3767		IrInstructionSaveErrRetAddr *instruction = ir_build_instruction<IrInstructionSaveErrRetAddr>(irb, scope, source_node);
3768		return &instruction->base;
	4748	static IrInstSrc ir_build_save_err_ret_addr_src(IrBuilderSrc irb, Scope scope, AstNode source_node) {
	4749	IrInstSrcSaveErrRetAddr *inst = ir_build_instruction<IrInstSrcSaveErrRetAddr>(irb, scope, source_node);
	4750	return &inst->base;
	4751	}
	4752
	4753	static IrInstGen ir_build_save_err_ret_addr_gen(IrAnalyze ira, IrInst *source_instr) {
	4754	IrInstGenSaveErrRetAddr *inst = ir_build_inst_void<IrInstGenSaveErrRetAddr>(&ira->new_irb,
	4755	source_instr->scope, source_instr->source_node);
	4756	return &inst->base;
3769	4757	}
3770	4758
3771		static IrInstruction ir_build_add_implicit_return_type(IrBuilder irb, Scope scope, AstNode source_node,
3772		IrInstruction value, ResultLocReturn result_loc_ret)
	4759	static IrInstSrc ir_build_add_implicit_return_type(IrBuilderSrc irb, Scope scope, AstNode source_node,
	4760	IrInstSrc value, ResultLocReturn result_loc_ret)
3773	4761	{
3774		IrInstructionAddImplicitReturnType *instruction = ir_build_instruction<IrInstructionAddImplicitReturnType>(irb, scope, source_node);
3775		instruction->value = value;
3776		instruction->result_loc_ret = result_loc_ret;
	4762	IrInstSrcAddImplicitReturnType *inst = ir_build_instruction<IrInstSrcAddImplicitReturnType>(irb, scope, source_node);
	4763	inst->value = value;
	4764	inst->result_loc_ret = result_loc_ret;
3777	4765
3778	4766	ir_ref_instruction(value, irb->current_basic_block);
3779	4767
3780		return &instruction->base;
	4768	return &inst->base;
3781	4769	}
3782	4770
3783		static IrInstruction ir_build_has_decl(IrBuilder irb, Scope scope, AstNode source_node,
3784		IrInstruction container, IrInstruction name)
	4771	static IrInstSrc ir_build_has_decl(IrBuilderSrc irb, Scope scope, AstNode source_node,
	4772	IrInstSrc container, IrInstSrc name)
3785	4773	{
3786		IrInstructionHasDecl *instruction = ir_build_instruction<IrInstructionHasDecl>(irb, scope, source_node);
	4774	IrInstSrcHasDecl *instruction = ir_build_instruction<IrInstSrcHasDecl>(irb, scope, source_node);
3787	4775	instruction->container = container;
3788	4776	instruction->name = name;
3789	4777
...	...	@@ -3793,17 +4781,15 @@ static IrInstruction ir_build_has_decl(IrBuilder irb, Scope scope, AstNode s
3793	4781	return &instruction->base;
3794	4782	}
3795	4783
3796		static IrInstruction ir_build_undeclared_identifier(IrBuilder irb, Scope scope, AstNode source_node,
3797		Buf *name)
3798		{
3799		IrInstructionUndeclaredIdent *instruction = ir_build_instruction<IrInstructionUndeclaredIdent>(irb, scope, source_node);
	4784	static IrInstSrc ir_build_undeclared_identifier(IrBuilderSrc irb, Scope scope, AstNode source_node, Buf *name) {
	4785	IrInstSrcUndeclaredIdent *instruction = ir_build_instruction<IrInstSrcUndeclaredIdent>(irb, scope, source_node);
3800	4786	instruction->name = name;
3801	4787
3802	4788	return &instruction->base;
3803	4789	}
3804	4790
3805		static IrInstruction ir_build_check_runtime_scope(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction scope_is_comptime, IrInstruction is_comptime) {
3806		IrInstructionCheckRuntimeScope *instruction = ir_build_instruction<IrInstructionCheckRuntimeScope>(irb, scope, source_node);
	4791	static IrInstSrc ir_build_check_runtime_scope(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc scope_is_comptime, IrInstSrc is_comptime) {
	4792	IrInstSrcCheckRuntimeScope *instruction = ir_build_instruction<IrInstSrcCheckRuntimeScope>(irb, scope, source_node);
3807	4793	instruction->scope_is_comptime = scope_is_comptime;
3808	4794	instruction->is_comptime = is_comptime;
3809	4795
...	...	@@ -3813,10 +4799,10 @@ static IrInstruction ir_build_check_runtime_scope(IrBuilder irb, Scope *scope,
3813	4799	return &instruction->base;
3814	4800	}
3815	4801
3816		static IrInstruction ir_build_union_init_named_field(IrBuilder irb, Scope scope, AstNode source_node,
3817		IrInstruction union_type, IrInstruction field_name, IrInstruction field_result_loc, IrInstruction result_loc)
	4802	static IrInstSrc ir_build_union_init_named_field(IrBuilderSrc irb, Scope scope, AstNode source_node,
	4803	IrInstSrc union_type, IrInstSrc field_name, IrInstSrc field_result_loc, IrInstSrc result_loc)
3818	4804	{
3819		IrInstructionUnionInitNamedField *instruction = ir_build_instruction<IrInstructionUnionInitNamedField>(irb, scope, source_node);
	4805	IrInstSrcUnionInitNamedField *instruction = ir_build_instruction<IrInstSrcUnionInitNamedField>(irb, scope, source_node);
3820	4806	instruction->union_type = union_type;
3821	4807	instruction->field_name = field_name;
3822	4808	instruction->field_result_loc = field_result_loc;
...	...	@@ -3831,79 +4817,79 @@ static IrInstruction ir_build_union_init_named_field(IrBuilder irb, Scope *sco
3831	4817	}
3832	4818
3833	4819
3834		static IrInstruction ir_build_vector_to_array(IrAnalyze ira, IrInstruction *source_instruction,
3835		ZigType result_type, IrInstruction vector, IrInstruction *result_loc)
	4820	static IrInstGen ir_build_vector_to_array(IrAnalyze ira, IrInst *source_instruction,
	4821	ZigType result_type, IrInstGen vector, IrInstGen *result_loc)
3836	4822	{
3837		IrInstructionVectorToArray *instruction = ir_build_instruction<IrInstructionVectorToArray>(&ira->new_irb,
	4823	IrInstGenVectorToArray *instruction = ir_build_inst_gen<IrInstGenVectorToArray>(&ira->new_irb,
3838	4824	source_instruction->scope, source_instruction->source_node);
3839	4825	instruction->base.value->type = result_type;
3840	4826	instruction->vector = vector;
3841	4827	instruction->result_loc = result_loc;
3842	4828
3843		ir_ref_instruction(vector, ira->new_irb.current_basic_block);
3844		ir_ref_instruction(result_loc, ira->new_irb.current_basic_block);
	4829	ir_ref_inst_gen(vector, ira->new_irb.current_basic_block);
	4830	ir_ref_inst_gen(result_loc, ira->new_irb.current_basic_block);
3845	4831
3846	4832	return &instruction->base;
3847	4833	}
3848	4834
3849		static IrInstruction ir_build_ptr_of_array_to_slice(IrAnalyze ira, IrInstruction *source_instruction,
3850		ZigType result_type, IrInstruction operand, IrInstruction *result_loc)
	4835	static IrInstGen ir_build_ptr_of_array_to_slice(IrAnalyze ira, IrInst *source_instruction,
	4836	ZigType result_type, IrInstGen operand, IrInstGen *result_loc)
3851	4837	{
3852		IrInstructionPtrOfArrayToSlice *instruction = ir_build_instruction<IrInstructionPtrOfArrayToSlice>(&ira->new_irb,
	4838	IrInstGenPtrOfArrayToSlice *instruction = ir_build_inst_gen<IrInstGenPtrOfArrayToSlice>(&ira->new_irb,
3853	4839	source_instruction->scope, source_instruction->source_node);
3854	4840	instruction->base.value->type = result_type;
3855	4841	instruction->operand = operand;
3856	4842	instruction->result_loc = result_loc;
3857	4843
3858		ir_ref_instruction(operand, ira->new_irb.current_basic_block);
3859		ir_ref_instruction(result_loc, ira->new_irb.current_basic_block);
	4844	ir_ref_inst_gen(operand, ira->new_irb.current_basic_block);
	4845	ir_ref_inst_gen(result_loc, ira->new_irb.current_basic_block);
3860	4846
3861	4847	return &instruction->base;
3862	4848	}
3863	4849
3864		static IrInstruction ir_build_array_to_vector(IrAnalyze ira, IrInstruction *source_instruction,
3865		IrInstruction array, ZigType result_type)
	4850	static IrInstGen ir_build_array_to_vector(IrAnalyze ira, IrInst *source_instruction,
	4851	IrInstGen array, ZigType result_type)
3866	4852	{
3867		IrInstructionArrayToVector *instruction = ir_build_instruction<IrInstructionArrayToVector>(&ira->new_irb,
	4853	IrInstGenArrayToVector *instruction = ir_build_inst_gen<IrInstGenArrayToVector>(&ira->new_irb,
3868	4854	source_instruction->scope, source_instruction->source_node);
3869	4855	instruction->base.value->type = result_type;
3870	4856	instruction->array = array;
3871	4857
3872		ir_ref_instruction(array, ira->new_irb.current_basic_block);
	4858	ir_ref_inst_gen(array, ira->new_irb.current_basic_block);
3873	4859
3874	4860	return &instruction->base;
3875	4861	}
3876	4862
3877		static IrInstruction ir_build_assert_zero(IrAnalyze ira, IrInstruction *source_instruction,
3878		IrInstruction *target)
	4863	static IrInstGen ir_build_assert_zero(IrAnalyze ira, IrInst *source_instruction,
	4864	IrInstGen *target)
3879	4865	{
3880		IrInstructionAssertZero *instruction = ir_build_instruction<IrInstructionAssertZero>(&ira->new_irb,
	4866	IrInstGenAssertZero *instruction = ir_build_inst_gen<IrInstGenAssertZero>(&ira->new_irb,
3881	4867	source_instruction->scope, source_instruction->source_node);
3882	4868	instruction->base.value->type = ira->codegen->builtin_types.entry_void;
3883	4869	instruction->target = target;
3884	4870
3885		ir_ref_instruction(target, ira->new_irb.current_basic_block);
	4871	ir_ref_inst_gen(target, ira->new_irb.current_basic_block);
3886	4872
3887	4873	return &instruction->base;
3888	4874	}
3889	4875
3890		static IrInstruction ir_build_assert_non_null(IrAnalyze ira, IrInstruction *source_instruction,
3891		IrInstruction *target)
	4876	static IrInstGen ir_build_assert_non_null(IrAnalyze ira, IrInst *source_instruction,
	4877	IrInstGen *target)
3892	4878	{
3893		IrInstructionAssertNonNull *instruction = ir_build_instruction<IrInstructionAssertNonNull>(&ira->new_irb,
	4879	IrInstGenAssertNonNull *instruction = ir_build_inst_gen<IrInstGenAssertNonNull>(&ira->new_irb,
3894	4880	source_instruction->scope, source_instruction->source_node);
3895	4881	instruction->base.value->type = ira->codegen->builtin_types.entry_void;
3896	4882	instruction->target = target;
3897	4883
3898		ir_ref_instruction(target, ira->new_irb.current_basic_block);
	4884	ir_ref_inst_gen(target, ira->new_irb.current_basic_block);
3899	4885
3900	4886	return &instruction->base;
3901	4887	}
3902	4888
3903		static IrInstruction ir_build_alloca_src(IrBuilder irb, Scope scope, AstNode source_node,
3904		IrInstruction align, const char name_hint, IrInstruction *is_comptime)
	4889	static IrInstSrc ir_build_alloca_src(IrBuilderSrc irb, Scope scope, AstNode source_node,
	4890	IrInstSrc align, const char name_hint, IrInstSrc *is_comptime)
3905	4891	{
3906		IrInstructionAllocaSrc *instruction = ir_build_instruction<IrInstructionAllocaSrc>(irb, scope, source_node);
	4892	IrInstSrcAlloca *instruction = ir_build_instruction<IrInstSrcAlloca>(irb, scope, source_node);
3907	4893	instruction->base.is_gen = true;
3908	4894	instruction->align = align;
3909	4895	instruction->name_hint = name_hint;
...	...	@@ -3915,10 +4901,10 @@ static IrInstruction ir_build_alloca_src(IrBuilder irb, Scope *scope, AstNode
3915	4901	return &instruction->base;
3916	4902	}
3917	4903
3918		static IrInstructionAllocaGen ir_build_alloca_gen(IrAnalyze ira, IrInstruction *source_instruction,
	4904	static IrInstGenAlloca ir_build_alloca_gen(IrAnalyze ira, IrInst *source_instruction,
3919	4905	uint32_t align, const char *name_hint)
3920	4906	{
3921		IrInstructionAllocaGen *instruction = ir_create_instruction<IrInstructionAllocaGen>(&ira->new_irb,
	4907	IrInstGenAlloca *instruction = ir_create_inst_gen<IrInstGenAlloca>(&ira->new_irb,
3922	4908	source_instruction->scope, source_instruction->source_node);
3923	4909	instruction->align = align;
3924	4910	instruction->name_hint = name_hint;
...	...	@@ -3926,10 +4912,10 @@ static IrInstructionAllocaGen ir_build_alloca_gen(IrAnalyze ira, IrInstruction
3926	4912	return instruction;
3927	4913	}
3928	4914
3929		static IrInstruction ir_build_end_expr(IrBuilder irb, Scope scope, AstNode source_node,
3930		IrInstruction value, ResultLoc result_loc)
	4915	static IrInstSrc ir_build_end_expr(IrBuilderSrc irb, Scope scope, AstNode source_node,
	4916	IrInstSrc value, ResultLoc result_loc)
3931	4917	{
3932		IrInstructionEndExpr *instruction = ir_build_instruction<IrInstructionEndExpr>(irb, scope, source_node);
	4918	IrInstSrcEndExpr *instruction = ir_build_instruction<IrInstSrcEndExpr>(irb, scope, source_node);
3933	4919	instruction->base.is_gen = true;
3934	4920	instruction->value = value;
3935	4921	instruction->result_loc = result_loc;
...	...	@@ -3939,29 +4925,41 @@ static IrInstruction ir_build_end_expr(IrBuilder irb, Scope scope, AstNode s
3939	4925	return &instruction->base;
3940	4926	}
3941	4927
3942		static IrInstructionSuspendBegin ir_build_suspend_begin(IrBuilder irb, Scope scope, AstNode source_node) {
3943		IrInstructionSuspendBegin *instruction = ir_build_instruction<IrInstructionSuspendBegin>(irb, scope, source_node);
3944		instruction->base.value->type = irb->codegen->builtin_types.entry_void;
	4928	static IrInstSrcSuspendBegin ir_build_suspend_begin_src(IrBuilderSrc irb, Scope scope, AstNode source_node) {
	4929	return ir_build_instruction<IrInstSrcSuspendBegin>(irb, scope, source_node);
	4930	}
3945	4931
3946		return instruction;
	4932	static IrInstGen ir_build_suspend_begin_gen(IrAnalyze ira, IrInst *source_instr) {
	4933	IrInstGenSuspendBegin *inst = ir_build_inst_void<IrInstGenSuspendBegin>(&ira->new_irb,
	4934	source_instr->scope, source_instr->source_node);
	4935	return &inst->base;
3947	4936	}
3948	4937
3949		static IrInstruction ir_build_suspend_finish(IrBuilder irb, Scope scope, AstNode source_node,
3950		IrInstructionSuspendBegin *begin)
	4938	static IrInstSrc ir_build_suspend_finish_src(IrBuilderSrc irb, Scope scope, AstNode source_node,
	4939	IrInstSrcSuspendBegin *begin)
3951	4940	{
3952		IrInstructionSuspendFinish *instruction = ir_build_instruction<IrInstructionSuspendFinish>(irb, scope, source_node);
3953		instruction->base.value->type = irb->codegen->builtin_types.entry_void;
3954		instruction->begin = begin;
	4941	IrInstSrcSuspendFinish *inst = ir_build_instruction<IrInstSrcSuspendFinish>(irb, scope, source_node);
	4942	inst->begin = begin;
3955	4943
3956	4944	ir_ref_instruction(&begin->base, irb->current_basic_block);
3957	4945
3958		return &instruction->base;
	4946	return &inst->base;
	4947	}
	4948
	4949	static IrInstGen ir_build_suspend_finish_gen(IrAnalyze ira, IrInst source_instr, IrInstGenSuspendBegin begin) {
	4950	IrInstGenSuspendFinish *inst = ir_build_inst_void<IrInstGenSuspendFinish>(&ira->new_irb,
	4951	source_instr->scope, source_instr->source_node);
	4952	inst->begin = begin;
	4953
	4954	ir_ref_inst_gen(&begin->base, ira->new_irb.current_basic_block);
	4955
	4956	return &inst->base;
3959	4957	}
3960	4958
3961		static IrInstruction ir_build_await_src(IrBuilder irb, Scope scope, AstNode source_node,
3962		IrInstruction frame, ResultLoc result_loc)
	4959	static IrInstSrc ir_build_await_src(IrBuilderSrc irb, Scope scope, AstNode source_node,
	4960	IrInstSrc frame, ResultLoc result_loc)
3963	4961	{
3964		IrInstructionAwaitSrc *instruction = ir_build_instruction<IrInstructionAwaitSrc>(irb, scope, source_node);
	4962	IrInstSrcAwait *instruction = ir_build_instruction<IrInstSrcAwait>(irb, scope, source_node);
3965	4963	instruction->frame = frame;
3966	4964	instruction->result_loc = result_loc;
3967	4965
...	...	@@ -3970,24 +4968,23 @@ static IrInstruction ir_build_await_src(IrBuilder irb, Scope scope, AstNode
3970	4968	return &instruction->base;
3971	4969	}
3972	4970
3973		static IrInstructionAwaitGen ir_build_await_gen(IrAnalyze ira, IrInstruction *source_instruction,
3974		IrInstruction frame, ZigType result_type, IrInstruction *result_loc)
	4971	static IrInstGenAwait ir_build_await_gen(IrAnalyze ira, IrInst *source_instruction,
	4972	IrInstGen frame, ZigType result_type, IrInstGen *result_loc)
3975	4973	{
3976		IrInstructionAwaitGen *instruction = ir_build_instruction<IrInstructionAwaitGen>(&ira->new_irb,
	4974	IrInstGenAwait *instruction = ir_build_inst_gen<IrInstGenAwait>(&ira->new_irb,
3977	4975	source_instruction->scope, source_instruction->source_node);
3978	4976	instruction->base.value->type = result_type;
3979	4977	instruction->frame = frame;
3980	4978	instruction->result_loc = result_loc;
3981	4979
3982		ir_ref_instruction(frame, ira->new_irb.current_basic_block);
3983		if (result_loc != nullptr) ir_ref_instruction(result_loc, ira->new_irb.current_basic_block);
	4980	ir_ref_inst_gen(frame, ira->new_irb.current_basic_block);
	4981	if (result_loc != nullptr) ir_ref_inst_gen(result_loc, ira->new_irb.current_basic_block);
3984	4982
3985	4983	return instruction;
3986	4984	}
3987	4985
3988		static IrInstruction ir_build_resume(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *frame) {
3989		IrInstructionResume *instruction = ir_build_instruction<IrInstructionResume>(irb, scope, source_node);
3990		instruction->base.value->type = irb->codegen->builtin_types.entry_void;
	4986	static IrInstSrc ir_build_resume_src(IrBuilderSrc irb, Scope scope, AstNode source_node, IrInstSrc *frame) {
	4987	IrInstSrcResume *instruction = ir_build_instruction<IrInstSrcResume>(irb, scope, source_node);
3991	4988	instruction->frame = frame;
3992	4989
3993	4990	ir_ref_instruction(frame, irb->current_basic_block);
...	...	@@ -3995,12 +4992,20 @@ static IrInstruction ir_build_resume(IrBuilder irb, Scope scope, AstNode sou
3995	4992	return &instruction->base;
3996	4993	}
3997	4994
3998		static IrInstructionSpillBegin ir_build_spill_begin(IrBuilder irb, Scope scope, AstNode source_node,
3999		IrInstruction *operand, SpillId spill_id)
	4995	static IrInstGen ir_build_resume_gen(IrAnalyze ira, IrInst source_instr, IrInstGen frame) {
	4996	IrInstGenResume *instruction = ir_build_inst_void<IrInstGenResume>(&ira->new_irb,
	4997	source_instr->scope, source_instr->source_node);
	4998	instruction->frame = frame;
	4999
	5000	ir_ref_inst_gen(frame, ira->new_irb.current_basic_block);
	5001
	5002	return &instruction->base;
	5003	}
	5004
	5005	static IrInstSrcSpillBegin ir_build_spill_begin_src(IrBuilderSrc irb, Scope scope, AstNode source_node,
	5006	IrInstSrc *operand, SpillId spill_id)
4000	5007	{
4001		IrInstructionSpillBegin *instruction = ir_build_instruction<IrInstructionSpillBegin>(irb, scope, source_node);
4002		instruction->base.value->special = ConstValSpecialStatic;
4003		instruction->base.value->type = irb->codegen->builtin_types.entry_void;
	5008	IrInstSrcSpillBegin *instruction = ir_build_instruction<IrInstSrcSpillBegin>(irb, scope, source_node);
4004	5009	instruction->operand = operand;
4005	5010	instruction->spill_id = spill_id;
4006	5011
...	...	@@ -4009,10 +5014,23 @@ static IrInstructionSpillBegin ir_build_spill_begin(IrBuilder irb, Scope *scop
4009	5014	return instruction;
4010	5015	}
4011	5016
4012		static IrInstruction ir_build_spill_end(IrBuilder irb, Scope scope, AstNode source_node,
4013		IrInstructionSpillBegin *begin)
	5017	static IrInstGen ir_build_spill_begin_gen(IrAnalyze ira, IrInst source_instr, IrInstGen operand,
	5018	SpillId spill_id)
	5019	{
	5020	IrInstGenSpillBegin *instruction = ir_build_inst_void<IrInstGenSpillBegin>(&ira->new_irb,
	5021	source_instr->scope, source_instr->source_node);
	5022	instruction->operand = operand;
	5023	instruction->spill_id = spill_id;
	5024
	5025	ir_ref_inst_gen(operand, ira->new_irb.current_basic_block);
	5026
	5027	return &instruction->base;
	5028	}
	5029
	5030	static IrInstSrc ir_build_spill_end_src(IrBuilderSrc irb, Scope scope, AstNode source_node,
	5031	IrInstSrcSpillBegin *begin)
4014	5032	{
4015		IrInstructionSpillEnd *instruction = ir_build_instruction<IrInstructionSpillEnd>(irb, scope, source_node);
	5033	IrInstSrcSpillEnd *instruction = ir_build_instruction<IrInstSrcSpillEnd>(irb, scope, source_node);
4016	5034	instruction->begin = begin;
4017	5035
4018	5036	ir_ref_instruction(&begin->base, irb->current_basic_block);
...	...	@@ -4020,22 +5038,35 @@ static IrInstruction ir_build_spill_end(IrBuilder irb, Scope scope, AstNode
4020	5038	return &instruction->base;
4021	5039	}
4022	5040
4023		static IrInstruction ir_build_vector_extract_elem(IrAnalyze ira, IrInstruction *source_instruction,
4024		IrInstruction vector, IrInstruction index)
	5041	static IrInstGen ir_build_spill_end_gen(IrAnalyze ira, IrInst source_instr, IrInstGenSpillBegin begin,
	5042	ZigType *result_type)
	5043	{
	5044	IrInstGenSpillEnd *instruction = ir_build_inst_gen<IrInstGenSpillEnd>(&ira->new_irb,
	5045	source_instr->scope, source_instr->source_node);
	5046	instruction->base.value->type = result_type;
	5047	instruction->begin = begin;
	5048
	5049	ir_ref_inst_gen(&begin->base, ira->new_irb.current_basic_block);
	5050
	5051	return &instruction->base;
	5052	}
	5053
	5054	static IrInstGen ir_build_vector_extract_elem(IrAnalyze ira, IrInst *source_instruction,
	5055	IrInstGen vector, IrInstGen index)
4025	5056	{
4026		IrInstructionVectorExtractElem *instruction = ir_build_instruction<IrInstructionVectorExtractElem>(
	5057	IrInstGenVectorExtractElem *instruction = ir_build_inst_gen<IrInstGenVectorExtractElem>(
4027	5058	&ira->new_irb, source_instruction->scope, source_instruction->source_node);
4028	5059	instruction->base.value->type = vector->value->type->data.vector.elem_type;
4029	5060	instruction->vector = vector;
4030	5061	instruction->index = index;
4031	5062
4032		ir_ref_instruction(vector, ira->new_irb.current_basic_block);
4033		ir_ref_instruction(index, ira->new_irb.current_basic_block);
	5063	ir_ref_inst_gen(vector, ira->new_irb.current_basic_block);
	5064	ir_ref_inst_gen(index, ira->new_irb.current_basic_block);
4034	5065
4035	5066	return &instruction->base;
4036	5067	}
4037	5068
4038		static void ir_count_defers(IrBuilder irb, Scope inner_scope, Scope outer_scope, size_t results) {
	5069	static void ir_count_defers(IrBuilderSrc irb, Scope inner_scope, Scope outer_scope, size_t results) {
4039	5070	results[ReturnKindUnconditional] = 0;
4040	5071	results[ReturnKindError] = 0;
4041	5072
...	...	@@ -4072,12 +5103,12 @@ static void ir_count_defers(IrBuilder irb, Scope inner_scope, Scope *outer_sco
4072	5103	}
4073	5104	}
4074	5105
4075		static IrInstruction ir_mark_gen(IrInstruction instruction) {
	5106	static IrInstSrc ir_mark_gen(IrInstSrc instruction) {
4076	5107	instruction->is_gen = true;
4077	5108	return instruction;
4078	5109	}
4079	5110
4080		static bool ir_gen_defers_for_block(IrBuilder irb, Scope inner_scope, Scope *outer_scope, bool gen_error_defers) {
	5111	static bool ir_gen_defers_for_block(IrBuilderSrc irb, Scope inner_scope, Scope *outer_scope, bool gen_error_defers) {
4081	5112	Scope *scope = inner_scope;
4082	5113	bool is_noreturn = false;
4083	5114	while (scope != outer_scope) {
...	...	@@ -4094,11 +5125,9 @@ static bool ir_gen_defers_for_block(IrBuilder irb, Scope inner_scope, Scope *o
4094	5125	{
4095	5126	AstNode *defer_expr_node = defer_node->data.defer.expr;
4096	5127	Scope *defer_expr_scope = defer_node->data.defer.expr_scope;
4097		IrInstruction *defer_expr_value = ir_gen_node(irb, defer_expr_node, defer_expr_scope);
4098		if (defer_expr_value != irb->codegen->invalid_instruction) {
4099		if (defer_expr_value->value->type != nullptr &&
4100		defer_expr_value->value->type->id == ZigTypeIdUnreachable)
4101		{
	5128	IrInstSrc *defer_expr_value = ir_gen_node(irb, defer_expr_node, defer_expr_scope);
	5129	if (defer_expr_value != irb->codegen->invalid_inst_src) {
	5130	if (defer_expr_value->is_noreturn) {
4102	5131	is_noreturn = true;
4103	5132	} else {
4104	5133	ir_mark_gen(ir_build_check_statement_is_void(irb, defer_expr_scope, defer_expr_node,
...	...	@@ -4130,13 +5159,17 @@ static bool ir_gen_defers_for_block(IrBuilder irb, Scope inner_scope, Scope *o
4130	5159	return is_noreturn;
4131	5160	}
4132	5161
4133		static void ir_set_cursor_at_end(IrBuilder irb, IrBasicBlock basic_block) {
	5162	static void ir_set_cursor_at_end_gen(IrBuilderGen irb, IrBasicBlockGen basic_block) {
4134	5163	assert(basic_block);
	5164	irb->current_basic_block = basic_block;
	5165	}
4135	5166
	5167	static void ir_set_cursor_at_end(IrBuilderSrc irb, IrBasicBlockSrc basic_block) {
	5168	assert(basic_block);
4136	5169	irb->current_basic_block = basic_block;
4137	5170	}
4138	5171
4139		static void ir_set_cursor_at_end_and_append_block(IrBuilder irb, IrBasicBlock basic_block) {
	5172	static void ir_set_cursor_at_end_and_append_block(IrBuilderSrc irb, IrBasicBlockSrc basic_block) {
4140	5173	basic_block->index = irb->exec->basic_block_list.length;
4141	5174	irb->exec->basic_block_list.append(basic_block);
4142	5175	ir_set_cursor_at_end(irb, basic_block);
...	...	@@ -4166,13 +5199,13 @@ static ScopeDeferExpr get_scope_defer_expr(Scope scope) {
4166	5199	return nullptr;
4167	5200	}
4168	5201
4169		static IrInstruction ir_gen_return(IrBuilder irb, Scope scope, AstNode node, LVal lval, ResultLoc *result_loc) {
	5202	static IrInstSrc ir_gen_return(IrBuilderSrc irb, Scope scope, AstNode node, LVal lval, ResultLoc *result_loc) {
4170	5203	assert(node->type == NodeTypeReturnExpr);
4171	5204
4172	5205	ZigFn *fn_entry = exec_fn_entry(irb->exec);
4173	5206	if (!fn_entry) {
4174	5207	add_node_error(irb->codegen, node, buf_sprintf("return expression outside function definition"));
4175		return irb->codegen->invalid_instruction;
	5208	return irb->codegen->invalid_inst_src;
4176	5209	}
4177	5210
4178	5211	ScopeDeferExpr *scope_defer_expr = get_scope_defer_expr(scope);
...	...	@@ -4181,7 +5214,7 @@ static IrInstruction ir_gen_return(IrBuilder irb, Scope scope, AstNode node,
4181	5214	add_node_error(irb->codegen, node, buf_sprintf("cannot return from defer expression"));
4182	5215	scope_defer_expr->reported_err = true;
4183	5216	}
4184		return irb->codegen->invalid_instruction;
	5217	return irb->codegen->invalid_inst_src;
4185	5218	}
4186	5219
4187	5220	Scope *outer_scope = irb->exec->begin_scope;
...	...	@@ -4194,15 +5227,15 @@ static IrInstruction ir_gen_return(IrBuilder irb, Scope scope, AstNode node,
4194	5227	result_loc_ret->base.id = ResultLocIdReturn;
4195	5228	ir_build_reset_result(irb, scope, node, &result_loc_ret->base);
4196	5229
4197		IrInstruction *return_value;
	5230	IrInstSrc *return_value;
4198	5231	if (expr_node) {
4199	5232	// Temporarily set this so that if we return a type it gets the name of the function
4200	5233	ZigFn *prev_name_fn = irb->exec->name_fn;
4201	5234	irb->exec->name_fn = exec_fn_entry(irb->exec);
4202	5235	return_value = ir_gen_node_extra(irb, expr_node, scope, LValNone, &result_loc_ret->base);
4203	5236	irb->exec->name_fn = prev_name_fn;
4204		if (return_value == irb->codegen->invalid_instruction)
4205		return irb->codegen->invalid_instruction;
	5237	if (return_value == irb->codegen->invalid_inst_src)
	5238	return irb->codegen->invalid_inst_src;
4206	5239	} else {
4207	5240	return_value = ir_build_const_void(irb, scope, node);
4208	5241	}
...	...	@@ -4215,22 +5248,22 @@ static IrInstruction ir_gen_return(IrBuilder irb, Scope scope, AstNode node,
4215	5248	if (!have_err_defers && !irb->codegen->have_err_ret_tracing) {
4216	5249	// only generate unconditional defers
4217	5250	ir_gen_defers_for_block(irb, scope, outer_scope, false);
4218		IrInstruction *result = ir_build_return(irb, scope, node, return_value);
	5251	IrInstSrc *result = ir_build_return_src(irb, scope, node, return_value);
4219	5252	result_loc_ret->base.source_instruction = result;
4220	5253	return result;
4221	5254	}
4222	5255	bool should_inline = ir_should_inline(irb->exec, scope);
4223	5256
4224		IrBasicBlock *err_block = ir_create_basic_block(irb, scope, "ErrRetErr");
4225		IrBasicBlock *ok_block = ir_create_basic_block(irb, scope, "ErrRetOk");
	5257	IrBasicBlockSrc *err_block = ir_create_basic_block(irb, scope, "ErrRetErr");
	5258	IrBasicBlockSrc *ok_block = ir_create_basic_block(irb, scope, "ErrRetOk");
4226	5259
4227	5260	if (!have_err_defers) {
4228	5261	ir_gen_defers_for_block(irb, scope, outer_scope, false);
4229	5262	}
4230	5263
4231		IrInstruction *is_err = ir_build_test_err_src(irb, scope, node, return_value, false, true);
	5264	IrInstSrc *is_err = ir_build_test_err_src(irb, scope, node, return_value, false, true);
4232	5265
4233		IrInstruction *is_comptime;
	5266	IrInstSrc *is_comptime;
4234	5267	if (should_inline) {
4235	5268	is_comptime = ir_build_const_bool(irb, scope, node, should_inline);
4236	5269	} else {
...	...	@@ -4238,14 +5271,14 @@ static IrInstruction ir_gen_return(IrBuilder irb, Scope scope, AstNode node,
4238	5271	}
4239	5272
4240	5273	ir_mark_gen(ir_build_cond_br(irb, scope, node, is_err, err_block, ok_block, is_comptime));
4241		IrBasicBlock *ret_stmt_block = ir_create_basic_block(irb, scope, "RetStmt");
	5274	IrBasicBlockSrc *ret_stmt_block = ir_create_basic_block(irb, scope, "RetStmt");
4242	5275
4243	5276	ir_set_cursor_at_end_and_append_block(irb, err_block);
4244	5277	if (have_err_defers) {
4245	5278	ir_gen_defers_for_block(irb, scope, outer_scope, true);
4246	5279	}
4247	5280	if (irb->codegen->have_err_ret_tracing && !should_inline) {
4248		ir_build_save_err_ret_addr(irb, scope, node);
	5281	ir_build_save_err_ret_addr_src(irb, scope, node);
4249	5282	}
4250	5283	ir_build_br(irb, scope, node, ret_stmt_block, is_comptime);
4251	5284
...	...	@@ -4256,21 +5289,21 @@ static IrInstruction ir_gen_return(IrBuilder irb, Scope scope, AstNode node,
4256	5289	ir_build_br(irb, scope, node, ret_stmt_block, is_comptime);
4257	5290
4258	5291	ir_set_cursor_at_end_and_append_block(irb, ret_stmt_block);
4259		IrInstruction *result = ir_build_return(irb, scope, node, return_value);
	5292	IrInstSrc *result = ir_build_return_src(irb, scope, node, return_value);
4260	5293	result_loc_ret->base.source_instruction = result;
4261	5294	return result;
4262	5295	}
4263	5296	case ReturnKindError:
4264	5297	{
4265	5298	assert(expr_node);
4266		IrInstruction *err_union_ptr = ir_gen_node_extra(irb, expr_node, scope, LValPtr, nullptr);
4267		if (err_union_ptr == irb->codegen->invalid_instruction)
4268		return irb->codegen->invalid_instruction;
4269		IrInstruction *is_err_val = ir_build_test_err_src(irb, scope, node, err_union_ptr, true, false);
4270
4271		IrBasicBlock *return_block = ir_create_basic_block(irb, scope, "ErrRetReturn");
4272		IrBasicBlock *continue_block = ir_create_basic_block(irb, scope, "ErrRetContinue");
4273		IrInstruction *is_comptime;
	5299	IrInstSrc *err_union_ptr = ir_gen_node_extra(irb, expr_node, scope, LValPtr, nullptr);
	5300	if (err_union_ptr == irb->codegen->invalid_inst_src)
	5301	return irb->codegen->invalid_inst_src;
	5302	IrInstSrc *is_err_val = ir_build_test_err_src(irb, scope, node, err_union_ptr, true, false);
	5303
	5304	IrBasicBlockSrc *return_block = ir_create_basic_block(irb, scope, "ErrRetReturn");
	5305	IrBasicBlockSrc *continue_block = ir_create_basic_block(irb, scope, "ErrRetContinue");
	5306	IrInstSrc *is_comptime;
4274	5307	bool should_inline = ir_should_inline(irb->exec, scope);
4275	5308	if (should_inline) {
4276	5309	is_comptime = ir_build_const_bool(irb, scope, node, true);
...	...	@@ -4280,10 +5313,10 @@ static IrInstruction ir_gen_return(IrBuilder irb, Scope scope, AstNode node,
4280	5313	ir_mark_gen(ir_build_cond_br(irb, scope, node, is_err_val, return_block, continue_block, is_comptime));
4281	5314
4282	5315	ir_set_cursor_at_end_and_append_block(irb, return_block);
4283		IrInstruction *err_val_ptr = ir_build_unwrap_err_code(irb, scope, node, err_union_ptr);
4284		IrInstruction *err_val = ir_build_load_ptr(irb, scope, node, err_val_ptr);
	5316	IrInstSrc *err_val_ptr = ir_build_unwrap_err_code_src(irb, scope, node, err_union_ptr);
	5317	IrInstSrc *err_val = ir_build_load_ptr(irb, scope, node, err_val_ptr);
4285	5318	ir_mark_gen(ir_build_add_implicit_return_type(irb, scope, node, err_val, nullptr));
4286		IrInstructionSpillBegin *spill_begin = ir_build_spill_begin(irb, scope, node, err_val,
	5319	IrInstSrcSpillBegin *spill_begin = ir_build_spill_begin_src(irb, scope, node, err_val,
4287	5320	SpillIdRetErrCode);
4288	5321	ResultLocReturn *result_loc_ret = allocate<ResultLocReturn>(1, "ResultLocReturn");
4289	5322	result_loc_ret->base.id = ResultLocIdReturn;
...	...	@@ -4291,15 +5324,15 @@ static IrInstruction ir_gen_return(IrBuilder irb, Scope scope, AstNode node,
4291	5324	ir_build_end_expr(irb, scope, node, err_val, &result_loc_ret->base);
4292	5325	if (!ir_gen_defers_for_block(irb, scope, outer_scope, true)) {
4293	5326	if (irb->codegen->have_err_ret_tracing && !should_inline) {
4294		ir_build_save_err_ret_addr(irb, scope, node);
	5327	ir_build_save_err_ret_addr_src(irb, scope, node);
4295	5328	}
4296		err_val = ir_build_spill_end(irb, scope, node, spill_begin);
4297		IrInstruction *ret_inst = ir_build_return(irb, scope, node, err_val);
	5329	err_val = ir_build_spill_end_src(irb, scope, node, spill_begin);
	5330	IrInstSrc *ret_inst = ir_build_return_src(irb, scope, node, err_val);
4298	5331	result_loc_ret->base.source_instruction = ret_inst;
4299	5332	}
4300	5333
4301	5334	ir_set_cursor_at_end_and_append_block(irb, continue_block);
4302		IrInstruction *unwrapped_ptr = ir_build_unwrap_err_payload(irb, scope, node, err_union_ptr, false, false);
	5335	IrInstSrc *unwrapped_ptr = ir_build_unwrap_err_payload_src(irb, scope, node, err_union_ptr, false, false);
4303	5336	if (lval == LValPtr)
4304	5337	return unwrapped_ptr;
4305	5338	else
...	...	@@ -4310,7 +5343,7 @@ static IrInstruction ir_gen_return(IrBuilder irb, Scope scope, AstNode node,
4310	5343	}
4311	5344
4312	5345	static ZigVar create_local_var(CodeGen codegen, AstNode node, Scope parent_scope,
4313		Buf name, bool src_is_const, bool gen_is_const, bool is_shadowable, IrInstruction is_comptime,
	5346	Buf name, bool src_is_const, bool gen_is_const, bool is_shadowable, IrInstSrc is_comptime,
4314	5347	bool skip_name_check)
4315	5348	{
4316	5349	ZigVar *variable_entry = allocate<ZigVar>(1, "ZigVar");
...	...	@@ -4322,7 +5355,7 @@ static ZigVar create_local_var(CodeGen codegen, AstNode node, Scope parent_s
4322	5355	variable_entry->const_value = create_const_vals(1);
4323	5356
4324	5357	if (is_comptime != nullptr) {
4325		is_comptime->ref_count += 1;
	5358	is_comptime->base.ref_count += 1;
4326	5359	}
4327	5360
4328	5361	if (name) {
...	...	@@ -4372,8 +5405,8 @@ static ZigVar create_local_var(CodeGen codegen, AstNode node, Scope parent_s
4372	5405
4373	5406	// Set name to nullptr to make the variable anonymous (not visible to programmer).
4374	5407	// After you call this function var->child_scope has the variable in scope
4375		static ZigVar ir_create_var(IrBuilder irb, AstNode node, Scope scope, Buf *name,
4376		bool src_is_const, bool gen_is_const, bool is_shadowable, IrInstruction *is_comptime)
	5408	static ZigVar ir_create_var(IrBuilderSrc irb, AstNode node, Scope scope, Buf *name,
	5409	bool src_is_const, bool gen_is_const, bool is_shadowable, IrInstSrc *is_comptime)
4377	5410	{
4378	5411	bool is_underscored = name ? buf_eql_str(name, "_") : false;
4379	5412	ZigVar *var = create_local_var(irb->codegen, node, scope,
...	...	@@ -4396,13 +5429,13 @@ static ResultLocPeer create_peer_result(ResultLocPeerParent peer_parent) {
4396	5429	return result;
4397	5430	}
4398	5431
4399		static IrInstruction ir_gen_block(IrBuilder irb, Scope parent_scope, AstNode block_node, LVal lval,
	5432	static IrInstSrc ir_gen_block(IrBuilderSrc irb, Scope parent_scope, AstNode block_node, LVal lval,
4400	5433	ResultLoc *result_loc)
4401	5434	{
4402	5435	assert(block_node->type == NodeTypeBlock);
4403	5436
4404		ZigList<IrInstruction *> incoming_values = {0};
4405		ZigList<IrBasicBlock *> incoming_blocks = {0};
	5437	ZigList<IrInstSrc *> incoming_values = {0};
	5438	ZigList<IrBasicBlockSrc *> incoming_blocks = {0};
4406	5439
4407	5440	ScopeBlock *scope_block = create_block_scope(irb->codegen, block_node, parent_scope);
4408	5441
...	...	@@ -4438,11 +5471,11 @@ static IrInstruction ir_gen_block(IrBuilder irb, Scope *parent_scope, AstNode
4438	5471	}
4439	5472
4440	5473	bool is_continuation_unreachable = false;
4441		IrInstruction *noreturn_return_value = nullptr;
	5474	IrInstSrc *noreturn_return_value = nullptr;
4442	5475	for (size_t i = 0; i < block_node->data.block.statements.length; i += 1) {
4443	5476	AstNode *statement_node = block_node->data.block.statements.at(i);
4444	5477
4445		IrInstruction *statement_value = ir_gen_node(irb, statement_node, child_scope);
	5478	IrInstSrc *statement_value = ir_gen_node(irb, statement_node, child_scope);
4446	5479	is_continuation_unreachable = instr_is_unreachable(statement_value);
4447	5480	if (is_continuation_unreachable) {
4448	5481	// keep the last noreturn statement value around in case we need to return it
...	...	@@ -4450,15 +5483,15 @@ static IrInstruction ir_gen_block(IrBuilder irb, Scope *parent_scope, AstNode
4450	5483	}
4451	5484	// This logic must be kept in sync with
4452	5485	// [STMT_EXPR_TEST_THING] <--- (search this token)
4453		if (statement_node->type == NodeTypeDefer && statement_value != irb->codegen->invalid_instruction) {
	5486	if (statement_node->type == NodeTypeDefer && statement_value != irb->codegen->invalid_inst_src) {
4454	5487	// defer starts a new scope
4455	5488	child_scope = statement_node->data.defer.child_scope;
4456	5489	assert(child_scope);
4457		} else if (statement_value->id == IrInstructionIdDeclVarSrc) {
	5490	} else if (statement_value->id == IrInstSrcIdDeclVar) {
4458	5491	// variable declarations start a new scope
4459		IrInstructionDeclVarSrc decl_var_instruction = (IrInstructionDeclVarSrc )statement_value;
	5492	IrInstSrcDeclVar decl_var_instruction = (IrInstSrcDeclVar )statement_value;
4460	5493	child_scope = decl_var_instruction->var->child_scope;
4461		} else if (statement_value != irb->codegen->invalid_instruction && !is_continuation_unreachable) {
	5494	} else if (statement_value != irb->codegen->invalid_inst_src && !is_continuation_unreachable) {
4462	5495	// this statement's value must be void
4463	5496	ir_mark_gen(ir_build_check_statement_is_void(irb, child_scope, statement_node, statement_value));
4464	5497	}
...	...	@@ -4474,12 +5507,12 @@ static IrInstruction ir_gen_block(IrBuilder irb, Scope *parent_scope, AstNode
4474	5507	scope_block->peer_parent->peers.last()->next_bb = scope_block->end_block;
4475	5508	}
4476	5509	ir_set_cursor_at_end_and_append_block(irb, scope_block->end_block);
4477		IrInstruction *phi = ir_build_phi(irb, parent_scope, block_node, incoming_blocks.length,
	5510	IrInstSrc *phi = ir_build_phi(irb, parent_scope, block_node, incoming_blocks.length,
4478	5511	incoming_blocks.items, incoming_values.items, scope_block->peer_parent);
4479	5512	return ir_expr_wrap(irb, parent_scope, phi, result_loc);
4480	5513	} else {
4481	5514	incoming_blocks.append(irb->current_basic_block);
4482		IrInstruction *else_expr_result = ir_mark_gen(ir_build_const_void(irb, parent_scope, block_node));
	5515	IrInstSrc *else_expr_result = ir_mark_gen(ir_build_const_void(irb, parent_scope, block_node));
4483	5516
4484	5517	if (scope_block->peer_parent != nullptr) {
4485	5518	ResultLocPeer *peer_result = create_peer_result(scope_block->peer_parent);
...	...	@@ -4499,15 +5532,15 @@ static IrInstruction ir_gen_block(IrBuilder irb, Scope *parent_scope, AstNode
4499	5532	ir_gen_defers_for_block(irb, child_scope, outer_block_scope, false);
4500	5533	}
4501	5534
4502		IrInstruction *result;
	5535	IrInstSrc *result;
4503	5536	if (block_node->data.block.name != nullptr) {
4504	5537	ir_mark_gen(ir_build_br(irb, parent_scope, block_node, scope_block->end_block, scope_block->is_comptime));
4505	5538	ir_set_cursor_at_end_and_append_block(irb, scope_block->end_block);
4506		IrInstruction *phi = ir_build_phi(irb, parent_scope, block_node, incoming_blocks.length,
	5539	IrInstSrc *phi = ir_build_phi(irb, parent_scope, block_node, incoming_blocks.length,
4507	5540	incoming_blocks.items, incoming_values.items, scope_block->peer_parent);
4508	5541	result = ir_expr_wrap(irb, parent_scope, phi, result_loc);
4509	5542	} else {
4510		IrInstruction *void_inst = ir_mark_gen(ir_build_const_void(irb, child_scope, block_node));
	5543	IrInstSrc *void_inst = ir_mark_gen(ir_build_const_void(irb, child_scope, block_node));
4511	5544	result = ir_lval_wrap(irb, parent_scope, void_inst, lval, result_loc);
4512	5545	}
4513	5546	if (!is_return_from_fn)
...	...	@@ -4518,30 +5551,30 @@ static IrInstruction ir_gen_block(IrBuilder irb, Scope *parent_scope, AstNode
4518	5551
4519	5552	ir_mark_gen(ir_build_add_implicit_return_type(irb, child_scope, block_node, result, nullptr));
4520	5553	ir_gen_defers_for_block(irb, child_scope, outer_block_scope, false);
4521		return ir_mark_gen(ir_build_return(irb, child_scope, result->source_node, result));
	5554	return ir_mark_gen(ir_build_return_src(irb, child_scope, result->base.source_node, result));
4522	5555	}
4523	5556
4524		static IrInstruction ir_gen_bin_op_id(IrBuilder irb, Scope scope, AstNode node, IrBinOp op_id) {
	5557	static IrInstSrc ir_gen_bin_op_id(IrBuilderSrc irb, Scope scope, AstNode node, IrBinOp op_id) {
4525	5558	Scope *inner_scope = scope;
4526	5559	if (op_id == IrBinOpArrayCat \|\| op_id == IrBinOpArrayMult) {
4527	5560	inner_scope = create_comptime_scope(irb->codegen, node, scope);
4528	5561	}
4529	5562
4530		IrInstruction *op1 = ir_gen_node(irb, node->data.bin_op_expr.op1, inner_scope);
4531		IrInstruction *op2 = ir_gen_node(irb, node->data.bin_op_expr.op2, inner_scope);
	5563	IrInstSrc *op1 = ir_gen_node(irb, node->data.bin_op_expr.op1, inner_scope);
	5564	IrInstSrc *op2 = ir_gen_node(irb, node->data.bin_op_expr.op2, inner_scope);
4532	5565
4533		if (op1 == irb->codegen->invalid_instruction \|\| op2 == irb->codegen->invalid_instruction)
4534		return irb->codegen->invalid_instruction;
	5566	if (op1 == irb->codegen->invalid_inst_src \|\| op2 == irb->codegen->invalid_inst_src)
	5567	return irb->codegen->invalid_inst_src;
4535	5568
4536	5569	return ir_build_bin_op(irb, scope, node, op_id, op1, op2, true);
4537	5570	}
4538	5571
4539		static IrInstruction ir_gen_merge_err_sets(IrBuilder irb, Scope scope, AstNode node) {
4540		IrInstruction *op1 = ir_gen_node(irb, node->data.bin_op_expr.op1, scope);
4541		IrInstruction *op2 = ir_gen_node(irb, node->data.bin_op_expr.op2, scope);
	5572	static IrInstSrc ir_gen_merge_err_sets(IrBuilderSrc irb, Scope scope, AstNode node) {
	5573	IrInstSrc *op1 = ir_gen_node(irb, node->data.bin_op_expr.op1, scope);
	5574	IrInstSrc *op2 = ir_gen_node(irb, node->data.bin_op_expr.op2, scope);
4542	5575
4543		if (op1 == irb->codegen->invalid_instruction \|\| op2 == irb->codegen->invalid_instruction)
4544		return irb->codegen->invalid_instruction;
	5576	if (op1 == irb->codegen->invalid_inst_src \|\| op2 == irb->codegen->invalid_inst_src)
	5577	return irb->codegen->invalid_inst_src;
4545	5578
4546	5579	// TODO only pass type_name when the \|\| operator is the top level AST node in the var decl expr
4547	5580	Buf bare_name = BUF_INIT;
...	...	@@ -4550,10 +5583,10 @@ static IrInstruction ir_gen_merge_err_sets(IrBuilder irb, Scope *scope, AstNod
4550	5583	return ir_build_merge_err_sets(irb, scope, node, op1, op2, type_name);
4551	5584	}
4552	5585
4553		static IrInstruction ir_gen_assign(IrBuilder irb, Scope scope, AstNode node) {
4554		IrInstruction *lvalue = ir_gen_node_extra(irb, node->data.bin_op_expr.op1, scope, LValPtr, nullptr);
4555		if (lvalue == irb->codegen->invalid_instruction)
4556		return irb->codegen->invalid_instruction;
	5586	static IrInstSrc ir_gen_assign(IrBuilderSrc irb, Scope scope, AstNode node) {
	5587	IrInstSrc *lvalue = ir_gen_node_extra(irb, node->data.bin_op_expr.op1, scope, LValPtr, nullptr);
	5588	if (lvalue == irb->codegen->invalid_inst_src)
	5589	return irb->codegen->invalid_inst_src;
4557	5590
4558	5591	ResultLocInstruction *result_loc_inst = allocate<ResultLocInstruction>(1, "ResultLocInstruction");
4559	5592	result_loc_inst->base.id = ResultLocIdInstruction;
...	...	@@ -4561,49 +5594,49 @@ static IrInstruction ir_gen_assign(IrBuilder irb, Scope scope, AstNode node)
4561	5594	ir_ref_instruction(lvalue, irb->current_basic_block);
4562	5595	ir_build_reset_result(irb, scope, node, &result_loc_inst->base);
4563	5596
4564		IrInstruction *rvalue = ir_gen_node_extra(irb, node->data.bin_op_expr.op2, scope, LValNone,
	5597	IrInstSrc *rvalue = ir_gen_node_extra(irb, node->data.bin_op_expr.op2, scope, LValNone,
4565	5598	&result_loc_inst->base);
4566		if (rvalue == irb->codegen->invalid_instruction)
4567		return irb->codegen->invalid_instruction;
	5599	if (rvalue == irb->codegen->invalid_inst_src)
	5600	return irb->codegen->invalid_inst_src;
4568	5601
4569	5602	return ir_build_const_void(irb, scope, node);
4570	5603	}
4571	5604
4572		static IrInstruction ir_gen_assign_merge_err_sets(IrBuilder irb, Scope scope, AstNode node) {
4573		IrInstruction *lvalue = ir_gen_node_extra(irb, node->data.bin_op_expr.op1, scope, LValPtr, nullptr);
4574		if (lvalue == irb->codegen->invalid_instruction)
	5605	static IrInstSrc ir_gen_assign_merge_err_sets(IrBuilderSrc irb, Scope scope, AstNode node) {
	5606	IrInstSrc *lvalue = ir_gen_node_extra(irb, node->data.bin_op_expr.op1, scope, LValPtr, nullptr);
	5607	if (lvalue == irb->codegen->invalid_inst_src)
4575	5608	return lvalue;
4576		IrInstruction *op1 = ir_build_load_ptr(irb, scope, node->data.bin_op_expr.op1, lvalue);
4577		IrInstruction *op2 = ir_gen_node(irb, node->data.bin_op_expr.op2, scope);
4578		if (op2 == irb->codegen->invalid_instruction)
	5609	IrInstSrc *op1 = ir_build_load_ptr(irb, scope, node->data.bin_op_expr.op1, lvalue);
	5610	IrInstSrc *op2 = ir_gen_node(irb, node->data.bin_op_expr.op2, scope);
	5611	if (op2 == irb->codegen->invalid_inst_src)
4579	5612	return op2;
4580		IrInstruction *result = ir_build_merge_err_sets(irb, scope, node, op1, op2, nullptr);
	5613	IrInstSrc *result = ir_build_merge_err_sets(irb, scope, node, op1, op2, nullptr);
4581	5614	ir_build_store_ptr(irb, scope, node, lvalue, result);
4582	5615	return ir_build_const_void(irb, scope, node);
4583	5616	}
4584	5617
4585		static IrInstruction ir_gen_assign_op(IrBuilder irb, Scope scope, AstNode node, IrBinOp op_id) {
4586		IrInstruction *lvalue = ir_gen_node_extra(irb, node->data.bin_op_expr.op1, scope, LValPtr, nullptr);
4587		if (lvalue == irb->codegen->invalid_instruction)
	5618	static IrInstSrc ir_gen_assign_op(IrBuilderSrc irb, Scope scope, AstNode node, IrBinOp op_id) {
	5619	IrInstSrc *lvalue = ir_gen_node_extra(irb, node->data.bin_op_expr.op1, scope, LValPtr, nullptr);
	5620	if (lvalue == irb->codegen->invalid_inst_src)
4588	5621	return lvalue;
4589		IrInstruction *op1 = ir_build_load_ptr(irb, scope, node->data.bin_op_expr.op1, lvalue);
4590		IrInstruction *op2 = ir_gen_node(irb, node->data.bin_op_expr.op2, scope);
4591		if (op2 == irb->codegen->invalid_instruction)
	5622	IrInstSrc *op1 = ir_build_load_ptr(irb, scope, node->data.bin_op_expr.op1, lvalue);
	5623	IrInstSrc *op2 = ir_gen_node(irb, node->data.bin_op_expr.op2, scope);
	5624	if (op2 == irb->codegen->invalid_inst_src)
4592	5625	return op2;
4593		IrInstruction *result = ir_build_bin_op(irb, scope, node, op_id, op1, op2, true);
	5626	IrInstSrc *result = ir_build_bin_op(irb, scope, node, op_id, op1, op2, true);
4594	5627	ir_build_store_ptr(irb, scope, node, lvalue, result);
4595	5628	return ir_build_const_void(irb, scope, node);
4596	5629	}
4597	5630
4598		static IrInstruction ir_gen_bool_or(IrBuilder irb, Scope scope, AstNode node) {
	5631	static IrInstSrc ir_gen_bool_or(IrBuilderSrc irb, Scope scope, AstNode node) {
4599	5632	assert(node->type == NodeTypeBinOpExpr);
4600	5633
4601		IrInstruction *val1 = ir_gen_node(irb, node->data.bin_op_expr.op1, scope);
4602		if (val1 == irb->codegen->invalid_instruction)
4603		return irb->codegen->invalid_instruction;
4604		IrBasicBlock *post_val1_block = irb->current_basic_block;
	5634	IrInstSrc *val1 = ir_gen_node(irb, node->data.bin_op_expr.op1, scope);
	5635	if (val1 == irb->codegen->invalid_inst_src)
	5636	return irb->codegen->invalid_inst_src;
	5637	IrBasicBlockSrc *post_val1_block = irb->current_basic_block;
4605	5638
4606		IrInstruction *is_comptime;
	5639	IrInstSrc *is_comptime;
4607	5640	if (ir_should_inline(irb->exec, scope)) {
4608	5641	is_comptime = ir_build_const_bool(irb, scope, node, true);
4609	5642	} else {
...	...	@@ -4611,41 +5644,41 @@ static IrInstruction ir_gen_bool_or(IrBuilder irb, Scope scope, AstNode node
4611	5644	}
4612	5645
4613	5646	// block for when val1 == false
4614		IrBasicBlock *false_block = ir_create_basic_block(irb, scope, "BoolOrFalse");
	5647	IrBasicBlockSrc *false_block = ir_create_basic_block(irb, scope, "BoolOrFalse");
4615	5648	// block for when val1 == true (don't even evaluate the second part)
4616		IrBasicBlock *true_block = ir_create_basic_block(irb, scope, "BoolOrTrue");
	5649	IrBasicBlockSrc *true_block = ir_create_basic_block(irb, scope, "BoolOrTrue");
4617	5650
4618	5651	ir_build_cond_br(irb, scope, node, val1, true_block, false_block, is_comptime);
4619	5652
4620	5653	ir_set_cursor_at_end_and_append_block(irb, false_block);
4621		IrInstruction *val2 = ir_gen_node(irb, node->data.bin_op_expr.op2, scope);
4622		if (val2 == irb->codegen->invalid_instruction)
4623		return irb->codegen->invalid_instruction;
4624		IrBasicBlock *post_val2_block = irb->current_basic_block;
	5654	IrInstSrc *val2 = ir_gen_node(irb, node->data.bin_op_expr.op2, scope);
	5655	if (val2 == irb->codegen->invalid_inst_src)
	5656	return irb->codegen->invalid_inst_src;
	5657	IrBasicBlockSrc *post_val2_block = irb->current_basic_block;
4625	5658
4626	5659	ir_build_br(irb, scope, node, true_block, is_comptime);
4627	5660
4628	5661	ir_set_cursor_at_end_and_append_block(irb, true_block);
4629	5662
4630		IrInstruction *incoming_values = allocate<IrInstruction >(2, "IrInstruction *");
	5663	IrInstSrc *incoming_values = allocate<IrInstSrc >(2, "IrInstSrc *");
4631	5664	incoming_values[0] = val1;
4632	5665	incoming_values[1] = val2;
4633		IrBasicBlock *incoming_blocks = allocate<IrBasicBlock >(2, "IrBasicBlock *");
	5666	IrBasicBlockSrc *incoming_blocks = allocate<IrBasicBlockSrc >(2, "IrBasicBlockSrc *");
4634	5667	incoming_blocks[0] = post_val1_block;
4635	5668	incoming_blocks[1] = post_val2_block;
4636	5669
4637	5670	return ir_build_phi(irb, scope, node, 2, incoming_blocks, incoming_values, nullptr);
4638	5671	}
4639	5672
4640		static IrInstruction ir_gen_bool_and(IrBuilder irb, Scope scope, AstNode node) {
	5673	static IrInstSrc ir_gen_bool_and(IrBuilderSrc irb, Scope scope, AstNode node) {
4641	5674	assert(node->type == NodeTypeBinOpExpr);
4642	5675
4643		IrInstruction *val1 = ir_gen_node(irb, node->data.bin_op_expr.op1, scope);
4644		if (val1 == irb->codegen->invalid_instruction)
4645		return irb->codegen->invalid_instruction;
4646		IrBasicBlock *post_val1_block = irb->current_basic_block;
	5676	IrInstSrc *val1 = ir_gen_node(irb, node->data.bin_op_expr.op1, scope);
	5677	if (val1 == irb->codegen->invalid_inst_src)
	5678	return irb->codegen->invalid_inst_src;
	5679	IrBasicBlockSrc *post_val1_block = irb->current_basic_block;
4647	5680
4648		IrInstruction *is_comptime;
	5681	IrInstSrc *is_comptime;
4649	5682	if (ir_should_inline(irb->exec, scope)) {
4650	5683	is_comptime = ir_build_const_bool(irb, scope, node, true);
4651	5684	} else {
...	...	@@ -4653,34 +5686,34 @@ static IrInstruction ir_gen_bool_and(IrBuilder irb, Scope scope, AstNode nod
4653	5686	}
4654	5687
4655	5688	// block for when val1 == true
4656		IrBasicBlock *true_block = ir_create_basic_block(irb, scope, "BoolAndTrue");
	5689	IrBasicBlockSrc *true_block = ir_create_basic_block(irb, scope, "BoolAndTrue");
4657	5690	// block for when val1 == false (don't even evaluate the second part)
4658		IrBasicBlock *false_block = ir_create_basic_block(irb, scope, "BoolAndFalse");
	5691	IrBasicBlockSrc *false_block = ir_create_basic_block(irb, scope, "BoolAndFalse");
4659	5692
4660	5693	ir_build_cond_br(irb, scope, node, val1, true_block, false_block, is_comptime);
4661	5694
4662	5695	ir_set_cursor_at_end_and_append_block(irb, true_block);
4663		IrInstruction *val2 = ir_gen_node(irb, node->data.bin_op_expr.op2, scope);
4664		if (val2 == irb->codegen->invalid_instruction)
4665		return irb->codegen->invalid_instruction;
4666		IrBasicBlock *post_val2_block = irb->current_basic_block;
	5696	IrInstSrc *val2 = ir_gen_node(irb, node->data.bin_op_expr.op2, scope);
	5697	if (val2 == irb->codegen->invalid_inst_src)
	5698	return irb->codegen->invalid_inst_src;
	5699	IrBasicBlockSrc *post_val2_block = irb->current_basic_block;
4667	5700
4668	5701	ir_build_br(irb, scope, node, false_block, is_comptime);
4669	5702
4670	5703	ir_set_cursor_at_end_and_append_block(irb, false_block);
4671	5704
4672		IrInstruction *incoming_values = allocate<IrInstruction >(2);
	5705	IrInstSrc *incoming_values = allocate<IrInstSrc >(2);
4673	5706	incoming_values[0] = val1;
4674	5707	incoming_values[1] = val2;
4675		IrBasicBlock *incoming_blocks = allocate<IrBasicBlock >(2, "IrBasicBlock *");
	5708	IrBasicBlockSrc *incoming_blocks = allocate<IrBasicBlockSrc >(2, "IrBasicBlockSrc *");
4676	5709	incoming_blocks[0] = post_val1_block;
4677	5710	incoming_blocks[1] = post_val2_block;
4678	5711
4679	5712	return ir_build_phi(irb, scope, node, 2, incoming_blocks, incoming_values, nullptr);
4680	5713	}
4681	5714
4682		static ResultLocPeerParent ir_build_result_peers(IrBuilder irb, IrInstruction *cond_br_inst,
4683		IrBasicBlock end_block, ResultLoc parent, IrInstruction *is_comptime)
	5715	static ResultLocPeerParent ir_build_result_peers(IrBuilderSrc irb, IrInstSrc *cond_br_inst,
	5716	IrBasicBlockSrc end_block, ResultLoc parent, IrInstSrc *is_comptime)
4684	5717	{
4685	5718	ResultLocPeerParent *peer_parent = allocate<ResultLocPeerParent>(1);
4686	5719	peer_parent->base.id = ResultLocIdPeerParent;
...	...	@@ -4690,17 +5723,17 @@ static ResultLocPeerParent ir_build_result_peers(IrBuilder irb, IrInstruction
4690	5723	peer_parent->is_comptime = is_comptime;
4691	5724	peer_parent->parent = parent;
4692	5725
4693		IrInstruction *popped_inst = irb->current_basic_block->instruction_list.pop();
4694		ir_assert(popped_inst == cond_br_inst, cond_br_inst);
	5726	IrInstSrc *popped_inst = irb->current_basic_block->instruction_list.pop();
	5727	ir_assert(popped_inst == cond_br_inst, &cond_br_inst->base);
4695	5728
4696		ir_build_reset_result(irb, cond_br_inst->scope, cond_br_inst->source_node, &peer_parent->base);
	5729	ir_build_reset_result(irb, cond_br_inst->base.scope, cond_br_inst->base.source_node, &peer_parent->base);
4697	5730	irb->current_basic_block->instruction_list.append(popped_inst);
4698	5731
4699	5732	return peer_parent;
4700	5733	}
4701	5734
4702		static ResultLocPeerParent ir_build_binary_result_peers(IrBuilder irb, IrInstruction *cond_br_inst,
4703		IrBasicBlock else_block, IrBasicBlock end_block, ResultLoc parent, IrInstruction is_comptime)
	5735	static ResultLocPeerParent ir_build_binary_result_peers(IrBuilderSrc irb, IrInstSrc *cond_br_inst,
	5736	IrBasicBlockSrc else_block, IrBasicBlockSrc end_block, ResultLoc parent, IrInstSrc is_comptime)
4704	5737	{
4705	5738	ResultLocPeerParent *peer_parent = ir_build_result_peers(irb, cond_br_inst, end_block, parent, is_comptime);
4706	5739
...	...	@@ -4713,7 +5746,7 @@ static ResultLocPeerParent ir_build_binary_result_peers(IrBuilder irb, IrInstr
4713	5746	return peer_parent;
4714	5747	}
4715	5748
4716		static IrInstruction ir_gen_orelse(IrBuilder irb, Scope parent_scope, AstNode node, LVal lval,
	5749	static IrInstSrc ir_gen_orelse(IrBuilderSrc irb, Scope parent_scope, AstNode node, LVal lval,
4717	5750	ResultLoc *result_loc)
4718	5751	{
4719	5752	assert(node->type == NodeTypeBinOpExpr);
...	...	@@ -4721,73 +5754,73 @@ static IrInstruction ir_gen_orelse(IrBuilder irb, Scope *parent_scope, AstNode
4721	5754	AstNode *op1_node = node->data.bin_op_expr.op1;
4722	5755	AstNode *op2_node = node->data.bin_op_expr.op2;
4723	5756
4724		IrInstruction *maybe_ptr = ir_gen_node_extra(irb, op1_node, parent_scope, LValPtr, nullptr);
4725		if (maybe_ptr == irb->codegen->invalid_instruction)
4726		return irb->codegen->invalid_instruction;
	5757	IrInstSrc *maybe_ptr = ir_gen_node_extra(irb, op1_node, parent_scope, LValPtr, nullptr);
	5758	if (maybe_ptr == irb->codegen->invalid_inst_src)
	5759	return irb->codegen->invalid_inst_src;
4727	5760
4728		IrInstruction *maybe_val = ir_build_load_ptr(irb, parent_scope, node, maybe_ptr);
4729		IrInstruction *is_non_null = ir_build_test_nonnull(irb, parent_scope, node, maybe_val);
	5761	IrInstSrc *maybe_val = ir_build_load_ptr(irb, parent_scope, node, maybe_ptr);
	5762	IrInstSrc *is_non_null = ir_build_test_non_null_src(irb, parent_scope, node, maybe_val);
4730	5763
4731		IrInstruction *is_comptime;
	5764	IrInstSrc *is_comptime;
4732	5765	if (ir_should_inline(irb->exec, parent_scope)) {
4733	5766	is_comptime = ir_build_const_bool(irb, parent_scope, node, true);
4734	5767	} else {
4735	5768	is_comptime = ir_build_test_comptime(irb, parent_scope, node, is_non_null);
4736	5769	}
4737	5770
4738		IrBasicBlock *ok_block = ir_create_basic_block(irb, parent_scope, "OptionalNonNull");
4739		IrBasicBlock *null_block = ir_create_basic_block(irb, parent_scope, "OptionalNull");
4740		IrBasicBlock *end_block = ir_create_basic_block(irb, parent_scope, "OptionalEnd");
4741		IrInstruction *cond_br_inst = ir_build_cond_br(irb, parent_scope, node, is_non_null, ok_block, null_block, is_comptime);
	5771	IrBasicBlockSrc *ok_block = ir_create_basic_block(irb, parent_scope, "OptionalNonNull");
	5772	IrBasicBlockSrc *null_block = ir_create_basic_block(irb, parent_scope, "OptionalNull");
	5773	IrBasicBlockSrc *end_block = ir_create_basic_block(irb, parent_scope, "OptionalEnd");
	5774	IrInstSrc *cond_br_inst = ir_build_cond_br(irb, parent_scope, node, is_non_null, ok_block, null_block, is_comptime);
4742	5775
4743	5776	ResultLocPeerParent *peer_parent = ir_build_binary_result_peers(irb, cond_br_inst, ok_block, end_block,
4744	5777	result_loc, is_comptime);
4745	5778
4746	5779	ir_set_cursor_at_end_and_append_block(irb, null_block);
4747		IrInstruction *null_result = ir_gen_node_extra(irb, op2_node, parent_scope, LValNone,
	5780	IrInstSrc *null_result = ir_gen_node_extra(irb, op2_node, parent_scope, LValNone,
4748	5781	&peer_parent->peers.at(0)->base);
4749		if (null_result == irb->codegen->invalid_instruction)
4750		return irb->codegen->invalid_instruction;
4751		IrBasicBlock *after_null_block = irb->current_basic_block;
	5782	if (null_result == irb->codegen->invalid_inst_src)
	5783	return irb->codegen->invalid_inst_src;
	5784	IrBasicBlockSrc *after_null_block = irb->current_basic_block;
4752	5785	if (!instr_is_unreachable(null_result))
4753	5786	ir_mark_gen(ir_build_br(irb, parent_scope, node, end_block, is_comptime));
4754	5787
4755	5788	ir_set_cursor_at_end_and_append_block(irb, ok_block);
4756		IrInstruction *unwrapped_ptr = ir_build_optional_unwrap_ptr(irb, parent_scope, node, maybe_ptr, false, false);
4757		IrInstruction *unwrapped_payload = ir_build_load_ptr(irb, parent_scope, node, unwrapped_ptr);
	5789	IrInstSrc *unwrapped_ptr = ir_build_optional_unwrap_ptr(irb, parent_scope, node, maybe_ptr, false, false);
	5790	IrInstSrc *unwrapped_payload = ir_build_load_ptr(irb, parent_scope, node, unwrapped_ptr);
4758	5791	ir_build_end_expr(irb, parent_scope, node, unwrapped_payload, &peer_parent->peers.at(1)->base);
4759		IrBasicBlock *after_ok_block = irb->current_basic_block;
	5792	IrBasicBlockSrc *after_ok_block = irb->current_basic_block;
4760	5793	ir_build_br(irb, parent_scope, node, end_block, is_comptime);
4761	5794
4762	5795	ir_set_cursor_at_end_and_append_block(irb, end_block);
4763		IrInstruction *incoming_values = allocate<IrInstruction >(2);
	5796	IrInstSrc *incoming_values = allocate<IrInstSrc >(2);
4764	5797	incoming_values[0] = null_result;
4765	5798	incoming_values[1] = unwrapped_payload;
4766		IrBasicBlock *incoming_blocks = allocate<IrBasicBlock >(2, "IrBasicBlock *");
	5799	IrBasicBlockSrc *incoming_blocks = allocate<IrBasicBlockSrc >(2, "IrBasicBlockSrc *");
4767	5800	incoming_blocks[0] = after_null_block;
4768	5801	incoming_blocks[1] = after_ok_block;
4769		IrInstruction *phi = ir_build_phi(irb, parent_scope, node, 2, incoming_blocks, incoming_values, peer_parent);
	5802	IrInstSrc *phi = ir_build_phi(irb, parent_scope, node, 2, incoming_blocks, incoming_values, peer_parent);
4770	5803	return ir_lval_wrap(irb, parent_scope, phi, lval, result_loc);
4771	5804	}
4772	5805
4773		static IrInstruction ir_gen_error_union(IrBuilder irb, Scope parent_scope, AstNode node) {
	5806	static IrInstSrc ir_gen_error_union(IrBuilderSrc irb, Scope parent_scope, AstNode node) {
4774	5807	assert(node->type == NodeTypeBinOpExpr);
4775	5808
4776	5809	AstNode *op1_node = node->data.bin_op_expr.op1;
4777	5810	AstNode *op2_node = node->data.bin_op_expr.op2;
4778	5811
4779		IrInstruction *err_set = ir_gen_node(irb, op1_node, parent_scope);
4780		if (err_set == irb->codegen->invalid_instruction)
4781		return irb->codegen->invalid_instruction;
	5812	IrInstSrc *err_set = ir_gen_node(irb, op1_node, parent_scope);
	5813	if (err_set == irb->codegen->invalid_inst_src)
	5814	return irb->codegen->invalid_inst_src;
4782	5815
4783		IrInstruction *payload = ir_gen_node(irb, op2_node, parent_scope);
4784		if (payload == irb->codegen->invalid_instruction)
4785		return irb->codegen->invalid_instruction;
	5816	IrInstSrc *payload = ir_gen_node(irb, op2_node, parent_scope);
	5817	if (payload == irb->codegen->invalid_inst_src)
	5818	return irb->codegen->invalid_inst_src;
4786	5819
4787	5820	return ir_build_error_union(irb, parent_scope, node, err_set, payload);
4788	5821	}
4789	5822
4790		static IrInstruction ir_gen_bin_op(IrBuilder irb, Scope scope, AstNode node, LVal lval, ResultLoc *result_loc) {
	5823	static IrInstSrc ir_gen_bin_op(IrBuilderSrc irb, Scope scope, AstNode node, LVal lval, ResultLoc *result_loc) {
4791	5824	assert(node->type == NodeTypeBinOpExpr);
4792	5825
4793	5826	BinOpType bin_op_type = node->data.bin_op_expr.bin_op;
...	...	@@ -4880,30 +5913,30 @@ static IrInstruction ir_gen_bin_op(IrBuilder irb, Scope scope, AstNode node,
4880	5913	zig_unreachable();
4881	5914	}
4882	5915
4883		static IrInstruction ir_gen_int_lit(IrBuilder irb, Scope scope, AstNode node) {
	5916	static IrInstSrc ir_gen_int_lit(IrBuilderSrc irb, Scope scope, AstNode node) {
4884	5917	assert(node->type == NodeTypeIntLiteral);
4885	5918
4886	5919	return ir_build_const_bigint(irb, scope, node, node->data.int_literal.bigint);
4887	5920	}
4888	5921
4889		static IrInstruction ir_gen_float_lit(IrBuilder irb, Scope scope, AstNode node) {
	5922	static IrInstSrc ir_gen_float_lit(IrBuilderSrc irb, Scope scope, AstNode node) {
4890	5923	assert(node->type == NodeTypeFloatLiteral);
4891	5924
4892	5925	if (node->data.float_literal.overflow) {
4893	5926	add_node_error(irb->codegen, node, buf_sprintf("float literal out of range of any type"));
4894		return irb->codegen->invalid_instruction;
	5927	return irb->codegen->invalid_inst_src;
4895	5928	}
4896	5929
4897	5930	return ir_build_const_bigfloat(irb, scope, node, node->data.float_literal.bigfloat);
4898	5931	}
4899	5932
4900		static IrInstruction ir_gen_char_lit(IrBuilder irb, Scope scope, AstNode node) {
	5933	static IrInstSrc ir_gen_char_lit(IrBuilderSrc irb, Scope scope, AstNode node) {
4901	5934	assert(node->type == NodeTypeCharLiteral);
4902	5935
4903	5936	return ir_build_const_uint(irb, scope, node, node->data.char_literal.value);
4904	5937	}
4905	5938
4906		static IrInstruction ir_gen_null_literal(IrBuilder irb, Scope scope, AstNode node) {
	5939	static IrInstSrc ir_gen_null_literal(IrBuilderSrc irb, Scope scope, AstNode node) {
4907	5940	assert(node->type == NodeTypeNullLiteral);
4908	5941
4909	5942	return ir_build_const_null(irb, scope, node);
...	...	@@ -4921,11 +5954,11 @@ static void populate_invalid_variable_in_scope(CodeGen g, Scope scope, AstNode
4921	5954	init_tld(&tld_var->base, TldIdVar, var_name, VisibModPub, node, &scope_decls->base);
4922	5955	tld_var->base.resolution = TldResolutionInvalid;
4923	5956	tld_var->var = add_variable(g, node, &scope_decls->base, var_name, false,
4924		g->invalid_instruction->value, &tld_var->base, g->builtin_types.entry_invalid);
	5957	g->invalid_inst_gen->value, &tld_var->base, g->builtin_types.entry_invalid);
4925	5958	scope_decls->decl_table.put(var_name, &tld_var->base);
4926	5959	}
4927	5960
4928		static IrInstruction ir_gen_symbol(IrBuilder irb, Scope scope, AstNode node, LVal lval, ResultLoc *result_loc) {
	5961	static IrInstSrc ir_gen_symbol(IrBuilderSrc irb, Scope scope, AstNode node, LVal lval, ResultLoc *result_loc) {
4929	5962	Error err;
4930	5963	assert(node->type == NodeTypeSymbol);
4931	5964
...	...	@@ -4933,15 +5966,16 @@ static IrInstruction ir_gen_symbol(IrBuilder irb, Scope scope, AstNode node,
4933	5966
4934	5967	if (buf_eql_str(variable_name, "_")) {
4935	5968	if (lval == LValPtr) {
4936		IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, scope, node);
4937		const_instruction->base.value->type = get_pointer_to_type(irb->codegen,
	5969	IrInstSrcConst *const_instruction = ir_build_instruction<IrInstSrcConst>(irb, scope, node);
	5970	const_instruction->value = create_const_vals(1);
	5971	const_instruction->value->type = get_pointer_to_type(irb->codegen,
4938	5972	irb->codegen->builtin_types.entry_void, false);
4939		const_instruction->base.value->special = ConstValSpecialStatic;
4940		const_instruction->base.value->data.x_ptr.special = ConstPtrSpecialDiscard;
	5973	const_instruction->value->special = ConstValSpecialStatic;
	5974	const_instruction->value->data.x_ptr.special = ConstPtrSpecialDiscard;
4941	5975	return &const_instruction->base;
4942	5976	} else {
4943	5977	add_node_error(irb->codegen, node, buf_sprintf("`_` may only be used to assign things to"));
4944		return irb->codegen->invalid_instruction;
	5978	return irb->codegen->invalid_inst_src;
4945	5979	}
4946	5980	}
4947	5981
...	...	@@ -4951,13 +5985,13 @@ static IrInstruction ir_gen_symbol(IrBuilder irb, Scope scope, AstNode node,
4951	5985	add_node_error(irb->codegen, node,
4952	5986	buf_sprintf("primitive integer type '%s' exceeds maximum bit width of 65535",
4953	5987	buf_ptr(variable_name)));
4954		return irb->codegen->invalid_instruction;
	5988	return irb->codegen->invalid_inst_src;
4955	5989	}
4956	5990	assert(err == ErrorPrimitiveTypeNotFound);
4957	5991	} else {
4958		IrInstruction *value = ir_build_const_type(irb, scope, node, primitive_type);
	5992	IrInstSrc *value = ir_build_const_type(irb, scope, node, primitive_type);
4959	5993	if (lval == LValPtr) {
4960		return ir_build_ref(irb, scope, node, value, false, false);
	5994	return ir_build_ref_src(irb, scope, node, value, false, false);
4961	5995	} else {
4962	5996	return ir_expr_wrap(irb, scope, value, result_loc);
4963	5997	}
...	...	@@ -4966,7 +6000,7 @@ static IrInstruction ir_gen_symbol(IrBuilder irb, Scope scope, AstNode node,
4966	6000	ScopeFnDef *crossed_fndef_scope;
4967	6001	ZigVar *var = find_variable(irb->codegen, scope, variable_name, &crossed_fndef_scope);
4968	6002	if (var) {
4969		IrInstruction *var_ptr = ir_build_var_ptr_x(irb, scope, node, var, crossed_fndef_scope);
	6003	IrInstSrc *var_ptr = ir_build_var_ptr_x(irb, scope, node, var, crossed_fndef_scope);
4970	6004	if (lval == LValPtr) {
4971	6005	return var_ptr;
4972	6006	} else {
...	...	@@ -4976,7 +6010,7 @@ static IrInstruction ir_gen_symbol(IrBuilder irb, Scope scope, AstNode node,
4976	6010
4977	6011	Tld *tld = find_decl(irb->codegen, scope, variable_name);
4978	6012	if (tld) {
4979		IrInstruction *decl_ref = ir_build_decl_ref(irb, scope, node, tld, lval);
	6013	IrInstSrc *decl_ref = ir_build_decl_ref(irb, scope, node, tld, lval);
4980	6014	if (lval == LValPtr) {
4981	6015	return decl_ref;
4982	6016	} else {
...	...	@@ -4987,50 +6021,50 @@ static IrInstruction ir_gen_symbol(IrBuilder irb, Scope scope, AstNode node,
4987	6021	if (get_container_scope(node->owner)->any_imports_failed) {
4988	6022	// skip the error message since we had a failing import in this file
4989	6023	// if an import breaks we don't need redundant undeclared identifier errors
4990		return irb->codegen->invalid_instruction;
	6024	return irb->codegen->invalid_inst_src;
4991	6025	}
4992	6026
4993	6027	return ir_build_undeclared_identifier(irb, scope, node, variable_name);
4994	6028	}
4995	6029
4996		static IrInstruction ir_gen_array_access(IrBuilder irb, Scope scope, AstNode node, LVal lval,
	6030	static IrInstSrc ir_gen_array_access(IrBuilderSrc irb, Scope scope, AstNode node, LVal lval,
4997	6031	ResultLoc *result_loc)
4998	6032	{
4999	6033	assert(node->type == NodeTypeArrayAccessExpr);
5000	6034
5001	6035	AstNode *array_ref_node = node->data.array_access_expr.array_ref_expr;
5002		IrInstruction *array_ref_instruction = ir_gen_node_extra(irb, array_ref_node, scope, LValPtr, nullptr);
5003		if (array_ref_instruction == irb->codegen->invalid_instruction)
	6036	IrInstSrc *array_ref_instruction = ir_gen_node_extra(irb, array_ref_node, scope, LValPtr, nullptr);
	6037	if (array_ref_instruction == irb->codegen->invalid_inst_src)
5004	6038	return array_ref_instruction;
5005	6039
5006	6040	AstNode *subscript_node = node->data.array_access_expr.subscript;
5007		IrInstruction *subscript_instruction = ir_gen_node(irb, subscript_node, scope);
5008		if (subscript_instruction == irb->codegen->invalid_instruction)
	6041	IrInstSrc *subscript_instruction = ir_gen_node(irb, subscript_node, scope);
	6042	if (subscript_instruction == irb->codegen->invalid_inst_src)
5009	6043	return subscript_instruction;
5010	6044
5011		IrInstruction *ptr_instruction = ir_build_elem_ptr(irb, scope, node, array_ref_instruction,
	6045	IrInstSrc *ptr_instruction = ir_build_elem_ptr(irb, scope, node, array_ref_instruction,
5012	6046	subscript_instruction, true, PtrLenSingle, nullptr);
5013	6047	if (lval == LValPtr)
5014	6048	return ptr_instruction;
5015	6049
5016		IrInstruction *load_ptr = ir_build_load_ptr(irb, scope, node, ptr_instruction);
	6050	IrInstSrc *load_ptr = ir_build_load_ptr(irb, scope, node, ptr_instruction);
5017	6051	return ir_expr_wrap(irb, scope, load_ptr, result_loc);
5018	6052	}
5019	6053
5020		static IrInstruction ir_gen_field_access(IrBuilder irb, Scope scope, AstNode node) {
	6054	static IrInstSrc ir_gen_field_access(IrBuilderSrc irb, Scope scope, AstNode node) {
5021	6055	assert(node->type == NodeTypeFieldAccessExpr);
5022	6056
5023	6057	AstNode *container_ref_node = node->data.field_access_expr.struct_expr;
5024	6058	Buf *field_name = node->data.field_access_expr.field_name;
5025	6059
5026		IrInstruction *container_ref_instruction = ir_gen_node_extra(irb, container_ref_node, scope, LValPtr, nullptr);
5027		if (container_ref_instruction == irb->codegen->invalid_instruction)
	6060	IrInstSrc *container_ref_instruction = ir_gen_node_extra(irb, container_ref_node, scope, LValPtr, nullptr);
	6061	if (container_ref_instruction == irb->codegen->invalid_inst_src)
5028	6062	return container_ref_instruction;
5029	6063
5030	6064	return ir_build_field_ptr(irb, scope, node, container_ref_instruction, field_name, false);
5031	6065	}
5032	6066
5033		static IrInstruction ir_gen_overflow_op(IrBuilder irb, Scope scope, AstNode node, IrOverflowOp op) {
	6067	static IrInstSrc ir_gen_overflow_op(IrBuilderSrc irb, Scope scope, AstNode node, IrOverflowOp op) {
5034	6068	assert(node->type == NodeTypeFnCallExpr);
5035	6069
5036	6070	AstNode *type_node = node->data.fn_call_expr.params.at(0);
...	...	@@ -5039,26 +6073,26 @@ static IrInstruction ir_gen_overflow_op(IrBuilder irb, Scope scope, AstNode
5039	6073	AstNode *result_ptr_node = node->data.fn_call_expr.params.at(3);
5040	6074
5041	6075
5042		IrInstruction *type_value = ir_gen_node(irb, type_node, scope);
5043		if (type_value == irb->codegen->invalid_instruction)
5044		return irb->codegen->invalid_instruction;
	6076	IrInstSrc *type_value = ir_gen_node(irb, type_node, scope);
	6077	if (type_value == irb->codegen->invalid_inst_src)
	6078	return irb->codegen->invalid_inst_src;
5045	6079
5046		IrInstruction *op1 = ir_gen_node(irb, op1_node, scope);
5047		if (op1 == irb->codegen->invalid_instruction)
5048		return irb->codegen->invalid_instruction;
	6080	IrInstSrc *op1 = ir_gen_node(irb, op1_node, scope);
	6081	if (op1 == irb->codegen->invalid_inst_src)
	6082	return irb->codegen->invalid_inst_src;
5049	6083
5050		IrInstruction *op2 = ir_gen_node(irb, op2_node, scope);
5051		if (op2 == irb->codegen->invalid_instruction)
5052		return irb->codegen->invalid_instruction;
	6084	IrInstSrc *op2 = ir_gen_node(irb, op2_node, scope);
	6085	if (op2 == irb->codegen->invalid_inst_src)
	6086	return irb->codegen->invalid_inst_src;
5053	6087
5054		IrInstruction *result_ptr = ir_gen_node(irb, result_ptr_node, scope);
5055		if (result_ptr == irb->codegen->invalid_instruction)
5056		return irb->codegen->invalid_instruction;
	6088	IrInstSrc *result_ptr = ir_gen_node(irb, result_ptr_node, scope);
	6089	if (result_ptr == irb->codegen->invalid_inst_src)
	6090	return irb->codegen->invalid_inst_src;
5057	6091
5058		return ir_build_overflow_op(irb, scope, node, op, type_value, op1, op2, result_ptr, nullptr);
	6092	return ir_build_overflow_op_src(irb, scope, node, op, type_value, op1, op2, result_ptr);
5059	6093	}
5060	6094
5061		static IrInstruction ir_gen_mul_add(IrBuilder irb, Scope scope, AstNode node) {
	6095	static IrInstSrc ir_gen_mul_add(IrBuilderSrc irb, Scope scope, AstNode node) {
5062	6096	assert(node->type == NodeTypeFnCallExpr);
5063	6097
5064	6098	AstNode *type_node = node->data.fn_call_expr.params.at(0);
...	...	@@ -5066,26 +6100,26 @@ static IrInstruction ir_gen_mul_add(IrBuilder irb, Scope scope, AstNode node
5066	6100	AstNode *op2_node = node->data.fn_call_expr.params.at(2);
5067	6101	AstNode *op3_node = node->data.fn_call_expr.params.at(3);
5068	6102
5069		IrInstruction *type_value = ir_gen_node(irb, type_node, scope);
5070		if (type_value == irb->codegen->invalid_instruction)
5071		return irb->codegen->invalid_instruction;
	6103	IrInstSrc *type_value = ir_gen_node(irb, type_node, scope);
	6104	if (type_value == irb->codegen->invalid_inst_src)
	6105	return irb->codegen->invalid_inst_src;
5072	6106
5073		IrInstruction *op1 = ir_gen_node(irb, op1_node, scope);
5074		if (op1 == irb->codegen->invalid_instruction)
5075		return irb->codegen->invalid_instruction;
	6107	IrInstSrc *op1 = ir_gen_node(irb, op1_node, scope);
	6108	if (op1 == irb->codegen->invalid_inst_src)
	6109	return irb->codegen->invalid_inst_src;
5076	6110
5077		IrInstruction *op2 = ir_gen_node(irb, op2_node, scope);
5078		if (op2 == irb->codegen->invalid_instruction)
5079		return irb->codegen->invalid_instruction;
	6111	IrInstSrc *op2 = ir_gen_node(irb, op2_node, scope);
	6112	if (op2 == irb->codegen->invalid_inst_src)
	6113	return irb->codegen->invalid_inst_src;
5080	6114
5081		IrInstruction *op3 = ir_gen_node(irb, op3_node, scope);
5082		if (op3 == irb->codegen->invalid_instruction)
5083		return irb->codegen->invalid_instruction;
	6115	IrInstSrc *op3 = ir_gen_node(irb, op3_node, scope);
	6116	if (op3 == irb->codegen->invalid_inst_src)
	6117	return irb->codegen->invalid_inst_src;
5084	6118
5085		return ir_build_mul_add(irb, scope, node, type_value, op1, op2, op3);
	6119	return ir_build_mul_add_src(irb, scope, node, type_value, op1, op2, op3);
5086	6120	}
5087	6121
5088		static IrInstruction ir_gen_this(IrBuilder irb, Scope orig_scope, AstNode node) {
	6122	static IrInstSrc ir_gen_this(IrBuilderSrc irb, Scope orig_scope, AstNode node) {
5089	6123	for (Scope *it_scope = orig_scope; it_scope != nullptr; it_scope = it_scope->parent) {
5090	6124	if (it_scope->id == ScopeIdDecls) {
5091	6125	ScopeDecls decls_scope = (ScopeDecls )it_scope;
...	...	@@ -5100,7 +6134,7 @@ static IrInstruction ir_gen_this(IrBuilder irb, Scope orig_scope, AstNode no
5100	6134	zig_unreachable();
5101	6135	}
5102	6136
5103		static IrInstruction ir_gen_async_call(IrBuilder irb, Scope scope, AstNode await_node, AstNode *call_node,
	6137	static IrInstSrc ir_gen_async_call(IrBuilderSrc irb, Scope scope, AstNode await_node, AstNode *call_node,
5104	6138	LVal lval, ResultLoc *result_loc)
5105	6139	{
5106	6140	size_t arg_offset = 3;
...	...	@@ -5108,71 +6142,71 @@ static IrInstruction ir_gen_async_call(IrBuilder irb, Scope scope, AstNode a
5108	6142	add_node_error(irb->codegen, call_node,
5109	6143	buf_sprintf("expected at least %" ZIG_PRI_usize " arguments, found %" ZIG_PRI_usize,
5110	6144	arg_offset, call_node->data.fn_call_expr.params.length));
5111		return irb->codegen->invalid_instruction;
	6145	return irb->codegen->invalid_inst_src;
5112	6146	}
5113	6147
5114	6148	AstNode *bytes_node = call_node->data.fn_call_expr.params.at(0);
5115		IrInstruction *bytes = ir_gen_node(irb, bytes_node, scope);
5116		if (bytes == irb->codegen->invalid_instruction)
	6149	IrInstSrc *bytes = ir_gen_node(irb, bytes_node, scope);
	6150	if (bytes == irb->codegen->invalid_inst_src)
5117	6151	return bytes;
5118	6152
5119	6153	AstNode *ret_ptr_node = call_node->data.fn_call_expr.params.at(1);
5120		IrInstruction *ret_ptr = ir_gen_node(irb, ret_ptr_node, scope);
5121		if (ret_ptr == irb->codegen->invalid_instruction)
	6154	IrInstSrc *ret_ptr = ir_gen_node(irb, ret_ptr_node, scope);
	6155	if (ret_ptr == irb->codegen->invalid_inst_src)
5122	6156	return ret_ptr;
5123	6157
5124	6158	AstNode *fn_ref_node = call_node->data.fn_call_expr.params.at(2);
5125		IrInstruction *fn_ref = ir_gen_node(irb, fn_ref_node, scope);
5126		if (fn_ref == irb->codegen->invalid_instruction)
	6159	IrInstSrc *fn_ref = ir_gen_node(irb, fn_ref_node, scope);
	6160	if (fn_ref == irb->codegen->invalid_inst_src)
5127	6161	return fn_ref;
5128	6162
5129	6163	size_t arg_count = call_node->data.fn_call_expr.params.length - arg_offset;
5130		IrInstruction *args = allocate<IrInstruction>(arg_count);
	6164	IrInstSrc *args = allocate<IrInstSrc>(arg_count);
5131	6165	for (size_t i = 0; i < arg_count; i += 1) {
5132	6166	AstNode *arg_node = call_node->data.fn_call_expr.params.at(i + arg_offset);
5133		IrInstruction *arg = ir_gen_node(irb, arg_node, scope);
5134		if (arg == irb->codegen->invalid_instruction)
	6167	IrInstSrc *arg = ir_gen_node(irb, arg_node, scope);
	6168	if (arg == irb->codegen->invalid_inst_src)
5135	6169	return arg;
5136	6170	args[i] = arg;
5137	6171	}
5138	6172
5139	6173	CallModifier modifier = (await_node == nullptr) ? CallModifierAsync : CallModifierNone;
5140	6174	bool is_async_call_builtin = true;
5141		IrInstruction *call = ir_build_call_src(irb, scope, call_node, nullptr, fn_ref, arg_count, args,
	6175	IrInstSrc *call = ir_build_call_src(irb, scope, call_node, nullptr, fn_ref, arg_count, args,
5142	6176	ret_ptr, modifier, is_async_call_builtin, bytes, result_loc);
5143	6177	return ir_lval_wrap(irb, scope, call, lval, result_loc);
5144	6178	}
5145	6179
5146		static IrInstruction ir_gen_fn_call_with_args(IrBuilder irb, Scope scope, AstNode source_node,
5147		AstNode fn_ref_node, CallModifier modifier, IrInstruction options,
	6180	static IrInstSrc ir_gen_fn_call_with_args(IrBuilderSrc irb, Scope scope, AstNode source_node,
	6181	AstNode fn_ref_node, CallModifier modifier, IrInstSrc options,
5148	6182	AstNode *args_ptr, size_t args_len, LVal lval, ResultLoc result_loc)
5149	6183	{
5150		IrInstruction *fn_ref = ir_gen_node(irb, fn_ref_node, scope);
5151		if (fn_ref == irb->codegen->invalid_instruction)
	6184	IrInstSrc *fn_ref = ir_gen_node(irb, fn_ref_node, scope);
	6185	if (fn_ref == irb->codegen->invalid_inst_src)
5152	6186	return fn_ref;
5153	6187
5154		IrInstruction *fn_type = ir_build_typeof(irb, scope, source_node, fn_ref);
	6188	IrInstSrc *fn_type = ir_build_typeof(irb, scope, source_node, fn_ref);
5155	6189
5156		IrInstruction *args = allocate<IrInstruction>(args_len);
	6190	IrInstSrc *args = allocate<IrInstSrc>(args_len);
5157	6191	for (size_t i = 0; i < args_len; i += 1) {
5158	6192	AstNode *arg_node = args_ptr[i];
5159	6193
5160		IrInstruction *arg_index = ir_build_const_usize(irb, scope, arg_node, i);
5161		IrInstruction *arg_type = ir_build_arg_type(irb, scope, source_node, fn_type, arg_index, true);
	6194	IrInstSrc *arg_index = ir_build_const_usize(irb, scope, arg_node, i);
	6195	IrInstSrc *arg_type = ir_build_arg_type(irb, scope, source_node, fn_type, arg_index, true);
5162	6196	ResultLoc *no_result = no_result_loc();
5163	6197	ir_build_reset_result(irb, scope, source_node, no_result);
5164	6198	ResultLocCast *result_loc_cast = ir_build_cast_result_loc(irb, arg_type, no_result);
5165	6199
5166		IrInstruction *arg = ir_gen_node_extra(irb, arg_node, scope, LValNone, &result_loc_cast->base);
5167		if (arg == irb->codegen->invalid_instruction)
	6200	IrInstSrc *arg = ir_gen_node_extra(irb, arg_node, scope, LValNone, &result_loc_cast->base);
	6201	if (arg == irb->codegen->invalid_inst_src)
5168	6202	return arg;
5169	6203
5170	6204	args[i] = ir_build_implicit_cast(irb, scope, arg_node, arg, result_loc_cast);
5171	6205	}
5172	6206
5173		IrInstruction *fn_call;
	6207	IrInstSrc *fn_call;
5174	6208	if (options != nullptr) {
5175		fn_call = ir_build_call_src_args(irb, scope, source_node, options, fn_ref, args, args_len, result_loc);
	6209	fn_call = ir_build_call_args(irb, scope, source_node, options, fn_ref, args, args_len, result_loc);
5176	6210	} else {
5177	6211	fn_call = ir_build_call_src(irb, scope, source_node, nullptr, fn_ref, args_len, args, nullptr,
5178	6212	modifier, false, nullptr, result_loc);
...	...	@@ -5180,7 +6214,7 @@ static IrInstruction ir_gen_fn_call_with_args(IrBuilder irb, Scope *scope, Ast
5180	6214	return ir_lval_wrap(irb, scope, fn_call, lval, result_loc);
5181	6215	}
5182	6216
5183		static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope scope, AstNode node, LVal lval,
	6217	static IrInstSrc ir_gen_builtin_fn_call(IrBuilderSrc irb, Scope scope, AstNode node, LVal lval,
5184	6218	ResultLoc *result_loc)
5185	6219	{
5186	6220	assert(node->type == NodeTypeFnCallExpr);
...	...	@@ -5192,7 +6226,7 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
5192	6226	if (!entry) {
5193	6227	add_node_error(irb->codegen, node,
5194	6228	buf_sprintf("invalid builtin function: '%s'", buf_ptr(name)));
5195		return irb->codegen->invalid_instruction;
	6229	return irb->codegen->invalid_inst_src;
5196	6230	}
5197	6231
5198	6232	BuiltinFnEntry *builtin_fn = entry->value;
...	...	@@ -5202,7 +6236,7 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
5202	6236	add_node_error(irb->codegen, node,
5203	6237	buf_sprintf("expected %" ZIG_PRI_usize " arguments, found %" ZIG_PRI_usize,
5204	6238	builtin_fn->param_count, actual_param_count));
5205		return irb->codegen->invalid_instruction;
	6239	return irb->codegen->invalid_inst_src;
5206	6240	}
5207	6241
5208	6242	switch (builtin_fn->id) {
...	...	@@ -5213,197 +6247,197 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
5213	6247	Scope *sub_scope = create_typeof_scope(irb->codegen, node, scope);
5214	6248
5215	6249	AstNode *arg_node = node->data.fn_call_expr.params.at(0);
5216		IrInstruction *arg = ir_gen_node(irb, arg_node, sub_scope);
5217		if (arg == irb->codegen->invalid_instruction)
	6250	IrInstSrc *arg = ir_gen_node(irb, arg_node, sub_scope);
	6251	if (arg == irb->codegen->invalid_inst_src)
5218	6252	return arg;
5219	6253
5220		IrInstruction *type_of = ir_build_typeof(irb, scope, node, arg);
	6254	IrInstSrc *type_of = ir_build_typeof(irb, scope, node, arg);
5221	6255	return ir_lval_wrap(irb, scope, type_of, lval, result_loc);
5222	6256	}
5223	6257	case BuiltinFnIdSetCold:
5224	6258	{
5225	6259	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5226		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5227		if (arg0_value == irb->codegen->invalid_instruction)
	6260	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6261	if (arg0_value == irb->codegen->invalid_inst_src)
5228	6262	return arg0_value;
5229	6263
5230		IrInstruction *set_cold = ir_build_set_cold(irb, scope, node, arg0_value);
	6264	IrInstSrc *set_cold = ir_build_set_cold(irb, scope, node, arg0_value);
5231	6265	return ir_lval_wrap(irb, scope, set_cold, lval, result_loc);
5232	6266	}
5233	6267	case BuiltinFnIdSetRuntimeSafety:
5234	6268	{
5235	6269	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5236		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5237		if (arg0_value == irb->codegen->invalid_instruction)
	6270	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6271	if (arg0_value == irb->codegen->invalid_inst_src)
5238	6272	return arg0_value;
5239	6273
5240		IrInstruction *set_safety = ir_build_set_runtime_safety(irb, scope, node, arg0_value);
	6274	IrInstSrc *set_safety = ir_build_set_runtime_safety(irb, scope, node, arg0_value);
5241	6275	return ir_lval_wrap(irb, scope, set_safety, lval, result_loc);
5242	6276	}
5243	6277	case BuiltinFnIdSetFloatMode:
5244	6278	{
5245	6279	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5246		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5247		if (arg0_value == irb->codegen->invalid_instruction)
	6280	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6281	if (arg0_value == irb->codegen->invalid_inst_src)
5248	6282	return arg0_value;
5249	6283
5250		IrInstruction *set_float_mode = ir_build_set_float_mode(irb, scope, node, arg0_value);
	6284	IrInstSrc *set_float_mode = ir_build_set_float_mode(irb, scope, node, arg0_value);
5251	6285	return ir_lval_wrap(irb, scope, set_float_mode, lval, result_loc);
5252	6286	}
5253	6287	case BuiltinFnIdSizeof:
5254	6288	case BuiltinFnIdBitSizeof:
5255	6289	{
5256	6290	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5257		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5258		if (arg0_value == irb->codegen->invalid_instruction)
	6291	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6292	if (arg0_value == irb->codegen->invalid_inst_src)
5259	6293	return arg0_value;
5260	6294
5261		IrInstruction *size_of = ir_build_size_of(irb, scope, node, arg0_value, builtin_fn->id == BuiltinFnIdBitSizeof);
	6295	IrInstSrc *size_of = ir_build_size_of(irb, scope, node, arg0_value, builtin_fn->id == BuiltinFnIdBitSizeof);
5262	6296	return ir_lval_wrap(irb, scope, size_of, lval, result_loc);
5263	6297	}
5264	6298	case BuiltinFnIdImport:
5265	6299	{
5266	6300	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5267		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5268		if (arg0_value == irb->codegen->invalid_instruction)
	6301	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6302	if (arg0_value == irb->codegen->invalid_inst_src)
5269	6303	return arg0_value;
5270	6304
5271		IrInstruction *import = ir_build_import(irb, scope, node, arg0_value);
	6305	IrInstSrc *import = ir_build_import(irb, scope, node, arg0_value);
5272	6306	return ir_lval_wrap(irb, scope, import, lval, result_loc);
5273	6307	}
5274	6308	case BuiltinFnIdCImport:
5275	6309	{
5276		IrInstruction *c_import = ir_build_c_import(irb, scope, node);
	6310	IrInstSrc *c_import = ir_build_c_import(irb, scope, node);
5277	6311	return ir_lval_wrap(irb, scope, c_import, lval, result_loc);
5278	6312	}
5279	6313	case BuiltinFnIdCInclude:
5280	6314	{
5281	6315	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5282		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5283		if (arg0_value == irb->codegen->invalid_instruction)
	6316	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6317	if (arg0_value == irb->codegen->invalid_inst_src)
5284	6318	return arg0_value;
5285	6319
5286	6320	if (!exec_c_import_buf(irb->exec)) {
5287	6321	add_node_error(irb->codegen, node, buf_sprintf("C include valid only inside C import block"));
5288		return irb->codegen->invalid_instruction;
	6322	return irb->codegen->invalid_inst_src;
5289	6323	}
5290	6324
5291		IrInstruction *c_include = ir_build_c_include(irb, scope, node, arg0_value);
	6325	IrInstSrc *c_include = ir_build_c_include(irb, scope, node, arg0_value);
5292	6326	return ir_lval_wrap(irb, scope, c_include, lval, result_loc);
5293	6327	}
5294	6328	case BuiltinFnIdCDefine:
5295	6329	{
5296	6330	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5297		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5298		if (arg0_value == irb->codegen->invalid_instruction)
	6331	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6332	if (arg0_value == irb->codegen->invalid_inst_src)
5299	6333	return arg0_value;
5300	6334
5301	6335	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
5302		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
5303		if (arg1_value == irb->codegen->invalid_instruction)
	6336	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	6337	if (arg1_value == irb->codegen->invalid_inst_src)
5304	6338	return arg1_value;
5305	6339
5306	6340	if (!exec_c_import_buf(irb->exec)) {
5307	6341	add_node_error(irb->codegen, node, buf_sprintf("C define valid only inside C import block"));
5308		return irb->codegen->invalid_instruction;
	6342	return irb->codegen->invalid_inst_src;
5309	6343	}
5310	6344
5311		IrInstruction *c_define = ir_build_c_define(irb, scope, node, arg0_value, arg1_value);
	6345	IrInstSrc *c_define = ir_build_c_define(irb, scope, node, arg0_value, arg1_value);
5312	6346	return ir_lval_wrap(irb, scope, c_define, lval, result_loc);
5313	6347	}
5314	6348	case BuiltinFnIdCUndef:
5315	6349	{
5316	6350	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5317		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5318		if (arg0_value == irb->codegen->invalid_instruction)
	6351	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6352	if (arg0_value == irb->codegen->invalid_inst_src)
5319	6353	return arg0_value;
5320	6354
5321	6355	if (!exec_c_import_buf(irb->exec)) {
5322	6356	add_node_error(irb->codegen, node, buf_sprintf("C undef valid only inside C import block"));
5323		return irb->codegen->invalid_instruction;
	6357	return irb->codegen->invalid_inst_src;
5324	6358	}
5325	6359
5326		IrInstruction *c_undef = ir_build_c_undef(irb, scope, node, arg0_value);
	6360	IrInstSrc *c_undef = ir_build_c_undef(irb, scope, node, arg0_value);
5327	6361	return ir_lval_wrap(irb, scope, c_undef, lval, result_loc);
5328	6362	}
5329	6363	case BuiltinFnIdCompileErr:
5330	6364	{
5331	6365	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5332		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5333		if (arg0_value == irb->codegen->invalid_instruction)
	6366	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6367	if (arg0_value == irb->codegen->invalid_inst_src)
5334	6368	return arg0_value;
5335	6369
5336		IrInstruction *compile_err = ir_build_compile_err(irb, scope, node, arg0_value);
	6370	IrInstSrc *compile_err = ir_build_compile_err(irb, scope, node, arg0_value);
5337	6371	return ir_lval_wrap(irb, scope, compile_err, lval, result_loc);
5338	6372	}
5339	6373	case BuiltinFnIdCompileLog:
5340	6374	{
5341		IrInstruction *args = allocate<IrInstruction>(actual_param_count);
	6375	IrInstSrc *args = allocate<IrInstSrc>(actual_param_count);
5342	6376
5343	6377	for (size_t i = 0; i < actual_param_count; i += 1) {
5344	6378	AstNode *arg_node = node->data.fn_call_expr.params.at(i);
5345	6379	args[i] = ir_gen_node(irb, arg_node, scope);
5346		if (args[i] == irb->codegen->invalid_instruction)
5347		return irb->codegen->invalid_instruction;
	6380	if (args[i] == irb->codegen->invalid_inst_src)
	6381	return irb->codegen->invalid_inst_src;
5348	6382	}
5349	6383
5350		IrInstruction *compile_log = ir_build_compile_log(irb, scope, node, actual_param_count, args);
	6384	IrInstSrc *compile_log = ir_build_compile_log(irb, scope, node, actual_param_count, args);
5351	6385	return ir_lval_wrap(irb, scope, compile_log, lval, result_loc);
5352	6386	}
5353	6387	case BuiltinFnIdErrName:
5354	6388	{
5355	6389	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5356		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5357		if (arg0_value == irb->codegen->invalid_instruction)
	6390	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6391	if (arg0_value == irb->codegen->invalid_inst_src)
5358	6392	return arg0_value;
5359	6393
5360		IrInstruction *err_name = ir_build_err_name(irb, scope, node, arg0_value);
	6394	IrInstSrc *err_name = ir_build_err_name(irb, scope, node, arg0_value);
5361	6395	return ir_lval_wrap(irb, scope, err_name, lval, result_loc);
5362	6396	}
5363	6397	case BuiltinFnIdEmbedFile:
5364	6398	{
5365	6399	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5366		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5367		if (arg0_value == irb->codegen->invalid_instruction)
	6400	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6401	if (arg0_value == irb->codegen->invalid_inst_src)
5368	6402	return arg0_value;
5369	6403
5370		IrInstruction *embed_file = ir_build_embed_file(irb, scope, node, arg0_value);
	6404	IrInstSrc *embed_file = ir_build_embed_file(irb, scope, node, arg0_value);
5371	6405	return ir_lval_wrap(irb, scope, embed_file, lval, result_loc);
5372	6406	}
5373	6407	case BuiltinFnIdCmpxchgWeak:
5374	6408	case BuiltinFnIdCmpxchgStrong:
5375	6409	{
5376	6410	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5377		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5378		if (arg0_value == irb->codegen->invalid_instruction)
	6411	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6412	if (arg0_value == irb->codegen->invalid_inst_src)
5379	6413	return arg0_value;
5380	6414
5381	6415	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
5382		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
5383		if (arg1_value == irb->codegen->invalid_instruction)
	6416	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	6417	if (arg1_value == irb->codegen->invalid_inst_src)
5384	6418	return arg1_value;
5385	6419
5386	6420	AstNode *arg2_node = node->data.fn_call_expr.params.at(2);
5387		IrInstruction *arg2_value = ir_gen_node(irb, arg2_node, scope);
5388		if (arg2_value == irb->codegen->invalid_instruction)
	6421	IrInstSrc *arg2_value = ir_gen_node(irb, arg2_node, scope);
	6422	if (arg2_value == irb->codegen->invalid_inst_src)
5389	6423	return arg2_value;
5390	6424
5391	6425	AstNode *arg3_node = node->data.fn_call_expr.params.at(3);
5392		IrInstruction *arg3_value = ir_gen_node(irb, arg3_node, scope);
5393		if (arg3_value == irb->codegen->invalid_instruction)
	6426	IrInstSrc *arg3_value = ir_gen_node(irb, arg3_node, scope);
	6427	if (arg3_value == irb->codegen->invalid_inst_src)
5394	6428	return arg3_value;
5395	6429
5396	6430	AstNode *arg4_node = node->data.fn_call_expr.params.at(4);
5397		IrInstruction *arg4_value = ir_gen_node(irb, arg4_node, scope);
5398		if (arg4_value == irb->codegen->invalid_instruction)
	6431	IrInstSrc *arg4_value = ir_gen_node(irb, arg4_node, scope);
	6432	if (arg4_value == irb->codegen->invalid_inst_src)
5399	6433	return arg4_value;
5400	6434
5401	6435	AstNode *arg5_node = node->data.fn_call_expr.params.at(5);
5402		IrInstruction *arg5_value = ir_gen_node(irb, arg5_node, scope);
5403		if (arg5_value == irb->codegen->invalid_instruction)
	6436	IrInstSrc *arg5_value = ir_gen_node(irb, arg5_node, scope);
	6437	if (arg5_value == irb->codegen->invalid_inst_src)
5404	6438	return arg5_value;
5405	6439
5406		IrInstruction *cmpxchg = ir_build_cmpxchg_src(irb, scope, node, arg0_value, arg1_value,
	6440	IrInstSrc *cmpxchg = ir_build_cmpxchg_src(irb, scope, node, arg0_value, arg1_value,
5407	6441	arg2_value, arg3_value, arg4_value, arg5_value, (builtin_fn->id == BuiltinFnIdCmpxchgWeak),
5408	6442	result_loc);
5409	6443	return ir_lval_wrap(irb, scope, cmpxchg, lval, result_loc);
...	...	@@ -5411,86 +6445,86 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
5411	6445	case BuiltinFnIdFence:
5412	6446	{
5413	6447	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5414		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5415		if (arg0_value == irb->codegen->invalid_instruction)
	6448	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6449	if (arg0_value == irb->codegen->invalid_inst_src)
5416	6450	return arg0_value;
5417	6451
5418		IrInstruction *fence = ir_build_fence(irb, scope, node, arg0_value, AtomicOrderUnordered);
	6452	IrInstSrc *fence = ir_build_fence(irb, scope, node, arg0_value);
5419	6453	return ir_lval_wrap(irb, scope, fence, lval, result_loc);
5420	6454	}
5421	6455	case BuiltinFnIdDivExact:
5422	6456	{
5423	6457	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5424		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5425		if (arg0_value == irb->codegen->invalid_instruction)
	6458	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6459	if (arg0_value == irb->codegen->invalid_inst_src)
5426	6460	return arg0_value;
5427	6461
5428	6462	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
5429		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
5430		if (arg1_value == irb->codegen->invalid_instruction)
	6463	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	6464	if (arg1_value == irb->codegen->invalid_inst_src)
5431	6465	return arg1_value;
5432	6466
5433		IrInstruction *bin_op = ir_build_bin_op(irb, scope, node, IrBinOpDivExact, arg0_value, arg1_value, true);
	6467	IrInstSrc *bin_op = ir_build_bin_op(irb, scope, node, IrBinOpDivExact, arg0_value, arg1_value, true);
5434	6468	return ir_lval_wrap(irb, scope, bin_op, lval, result_loc);
5435	6469	}
5436	6470	case BuiltinFnIdDivTrunc:
5437	6471	{
5438	6472	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5439		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5440		if (arg0_value == irb->codegen->invalid_instruction)
	6473	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6474	if (arg0_value == irb->codegen->invalid_inst_src)
5441	6475	return arg0_value;
5442	6476
5443	6477	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
5444		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
5445		if (arg1_value == irb->codegen->invalid_instruction)
	6478	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	6479	if (arg1_value == irb->codegen->invalid_inst_src)
5446	6480	return arg1_value;
5447	6481
5448		IrInstruction *bin_op = ir_build_bin_op(irb, scope, node, IrBinOpDivTrunc, arg0_value, arg1_value, true);
	6482	IrInstSrc *bin_op = ir_build_bin_op(irb, scope, node, IrBinOpDivTrunc, arg0_value, arg1_value, true);
5449	6483	return ir_lval_wrap(irb, scope, bin_op, lval, result_loc);
5450	6484	}
5451	6485	case BuiltinFnIdDivFloor:
5452	6486	{
5453	6487	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5454		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5455		if (arg0_value == irb->codegen->invalid_instruction)
	6488	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6489	if (arg0_value == irb->codegen->invalid_inst_src)
5456	6490	return arg0_value;
5457	6491
5458	6492	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
5459		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
5460		if (arg1_value == irb->codegen->invalid_instruction)
	6493	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	6494	if (arg1_value == irb->codegen->invalid_inst_src)
5461	6495	return arg1_value;
5462	6496
5463		IrInstruction *bin_op = ir_build_bin_op(irb, scope, node, IrBinOpDivFloor, arg0_value, arg1_value, true);
	6497	IrInstSrc *bin_op = ir_build_bin_op(irb, scope, node, IrBinOpDivFloor, arg0_value, arg1_value, true);
5464	6498	return ir_lval_wrap(irb, scope, bin_op, lval, result_loc);
5465	6499	}
5466	6500	case BuiltinFnIdRem:
5467	6501	{
5468	6502	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5469		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5470		if (arg0_value == irb->codegen->invalid_instruction)
	6503	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6504	if (arg0_value == irb->codegen->invalid_inst_src)
5471	6505	return arg0_value;
5472	6506
5473	6507	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
5474		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
5475		if (arg1_value == irb->codegen->invalid_instruction)
	6508	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	6509	if (arg1_value == irb->codegen->invalid_inst_src)
5476	6510	return arg1_value;
5477	6511
5478		IrInstruction *bin_op = ir_build_bin_op(irb, scope, node, IrBinOpRemRem, arg0_value, arg1_value, true);
	6512	IrInstSrc *bin_op = ir_build_bin_op(irb, scope, node, IrBinOpRemRem, arg0_value, arg1_value, true);
5479	6513	return ir_lval_wrap(irb, scope, bin_op, lval, result_loc);
5480	6514	}
5481	6515	case BuiltinFnIdMod:
5482	6516	{
5483	6517	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5484		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5485		if (arg0_value == irb->codegen->invalid_instruction)
	6518	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6519	if (arg0_value == irb->codegen->invalid_inst_src)
5486	6520	return arg0_value;
5487	6521
5488	6522	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
5489		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
5490		if (arg1_value == irb->codegen->invalid_instruction)
	6523	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	6524	if (arg1_value == irb->codegen->invalid_inst_src)
5491	6525	return arg1_value;
5492	6526
5493		IrInstruction *bin_op = ir_build_bin_op(irb, scope, node, IrBinOpRemMod, arg0_value, arg1_value, true);
	6527	IrInstSrc *bin_op = ir_build_bin_op(irb, scope, node, IrBinOpRemMod, arg0_value, arg1_value, true);
5494	6528	return ir_lval_wrap(irb, scope, bin_op, lval, result_loc);
5495	6529	}
5496	6530	case BuiltinFnIdSqrt:
...	...	@@ -5509,406 +6543,406 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
5509	6543	case BuiltinFnIdRound:
5510	6544	{
5511	6545	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5512		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5513		if (arg0_value == irb->codegen->invalid_instruction)
	6546	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6547	if (arg0_value == irb->codegen->invalid_inst_src)
5514	6548	return arg0_value;
5515	6549
5516		IrInstruction *inst = ir_build_float_op(irb, scope, node, arg0_value, builtin_fn->id);
	6550	IrInstSrc *inst = ir_build_float_op_src(irb, scope, node, arg0_value, builtin_fn->id);
5517	6551	return ir_lval_wrap(irb, scope, inst, lval, result_loc);
5518	6552	}
5519	6553	case BuiltinFnIdTruncate:
5520	6554	{
5521	6555	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5522		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5523		if (arg0_value == irb->codegen->invalid_instruction)
	6556	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6557	if (arg0_value == irb->codegen->invalid_inst_src)
5524	6558	return arg0_value;
5525	6559
5526	6560	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
5527		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
5528		if (arg1_value == irb->codegen->invalid_instruction)
	6561	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	6562	if (arg1_value == irb->codegen->invalid_inst_src)
5529	6563	return arg1_value;
5530	6564
5531		IrInstruction *truncate = ir_build_truncate(irb, scope, node, arg0_value, arg1_value);
	6565	IrInstSrc *truncate = ir_build_truncate(irb, scope, node, arg0_value, arg1_value);
5532	6566	return ir_lval_wrap(irb, scope, truncate, lval, result_loc);
5533	6567	}
5534	6568	case BuiltinFnIdIntCast:
5535	6569	{
5536	6570	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5537		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5538		if (arg0_value == irb->codegen->invalid_instruction)
	6571	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6572	if (arg0_value == irb->codegen->invalid_inst_src)
5539	6573	return arg0_value;
5540	6574
5541	6575	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
5542		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
5543		if (arg1_value == irb->codegen->invalid_instruction)
	6576	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	6577	if (arg1_value == irb->codegen->invalid_inst_src)
5544	6578	return arg1_value;
5545	6579
5546		IrInstruction *result = ir_build_int_cast(irb, scope, node, arg0_value, arg1_value);
	6580	IrInstSrc *result = ir_build_int_cast(irb, scope, node, arg0_value, arg1_value);
5547	6581	return ir_lval_wrap(irb, scope, result, lval, result_loc);
5548	6582	}
5549	6583	case BuiltinFnIdFloatCast:
5550	6584	{
5551	6585	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5552		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5553		if (arg0_value == irb->codegen->invalid_instruction)
	6586	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6587	if (arg0_value == irb->codegen->invalid_inst_src)
5554	6588	return arg0_value;
5555	6589
5556	6590	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
5557		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
5558		if (arg1_value == irb->codegen->invalid_instruction)
	6591	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	6592	if (arg1_value == irb->codegen->invalid_inst_src)
5559	6593	return arg1_value;
5560	6594
5561		IrInstruction *result = ir_build_float_cast(irb, scope, node, arg0_value, arg1_value);
	6595	IrInstSrc *result = ir_build_float_cast(irb, scope, node, arg0_value, arg1_value);
5562	6596	return ir_lval_wrap(irb, scope, result, lval, result_loc);
5563	6597	}
5564	6598	case BuiltinFnIdErrSetCast:
5565	6599	{
5566	6600	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5567		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5568		if (arg0_value == irb->codegen->invalid_instruction)
	6601	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6602	if (arg0_value == irb->codegen->invalid_inst_src)
5569	6603	return arg0_value;
5570	6604
5571	6605	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
5572		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
5573		if (arg1_value == irb->codegen->invalid_instruction)
	6606	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	6607	if (arg1_value == irb->codegen->invalid_inst_src)
5574	6608	return arg1_value;
5575	6609
5576		IrInstruction *result = ir_build_err_set_cast(irb, scope, node, arg0_value, arg1_value);
	6610	IrInstSrc *result = ir_build_err_set_cast(irb, scope, node, arg0_value, arg1_value);
5577	6611	return ir_lval_wrap(irb, scope, result, lval, result_loc);
5578	6612	}
5579	6613	case BuiltinFnIdFromBytes:
5580	6614	{
5581	6615	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5582		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5583		if (arg0_value == irb->codegen->invalid_instruction)
	6616	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6617	if (arg0_value == irb->codegen->invalid_inst_src)
5584	6618	return arg0_value;
5585	6619
5586	6620	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
5587		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
5588		if (arg1_value == irb->codegen->invalid_instruction)
	6621	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	6622	if (arg1_value == irb->codegen->invalid_inst_src)
5589	6623	return arg1_value;
5590	6624
5591		IrInstruction *result = ir_build_from_bytes(irb, scope, node, arg0_value, arg1_value, result_loc);
	6625	IrInstSrc *result = ir_build_from_bytes(irb, scope, node, arg0_value, arg1_value, result_loc);
5592	6626	return ir_lval_wrap(irb, scope, result, lval, result_loc);
5593	6627	}
5594	6628	case BuiltinFnIdToBytes:
5595	6629	{
5596	6630	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5597		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5598		if (arg0_value == irb->codegen->invalid_instruction)
	6631	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6632	if (arg0_value == irb->codegen->invalid_inst_src)
5599	6633	return arg0_value;
5600	6634
5601		IrInstruction *result = ir_build_to_bytes(irb, scope, node, arg0_value, result_loc);
	6635	IrInstSrc *result = ir_build_to_bytes(irb, scope, node, arg0_value, result_loc);
5602	6636	return ir_lval_wrap(irb, scope, result, lval, result_loc);
5603	6637	}
5604	6638	case BuiltinFnIdIntToFloat:
5605	6639	{
5606	6640	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5607		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5608		if (arg0_value == irb->codegen->invalid_instruction)
	6641	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6642	if (arg0_value == irb->codegen->invalid_inst_src)
5609	6643	return arg0_value;
5610	6644
5611	6645	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
5612		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
5613		if (arg1_value == irb->codegen->invalid_instruction)
	6646	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	6647	if (arg1_value == irb->codegen->invalid_inst_src)
5614	6648	return arg1_value;
5615	6649
5616		IrInstruction *result = ir_build_int_to_float(irb, scope, node, arg0_value, arg1_value);
	6650	IrInstSrc *result = ir_build_int_to_float(irb, scope, node, arg0_value, arg1_value);
5617	6651	return ir_lval_wrap(irb, scope, result, lval, result_loc);
5618	6652	}
5619	6653	case BuiltinFnIdFloatToInt:
5620	6654	{
5621	6655	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5622		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5623		if (arg0_value == irb->codegen->invalid_instruction)
	6656	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6657	if (arg0_value == irb->codegen->invalid_inst_src)
5624	6658	return arg0_value;
5625	6659
5626	6660	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
5627		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
5628		if (arg1_value == irb->codegen->invalid_instruction)
	6661	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	6662	if (arg1_value == irb->codegen->invalid_inst_src)
5629	6663	return arg1_value;
5630	6664
5631		IrInstruction *result = ir_build_float_to_int(irb, scope, node, arg0_value, arg1_value);
	6665	IrInstSrc *result = ir_build_float_to_int(irb, scope, node, arg0_value, arg1_value);
5632	6666	return ir_lval_wrap(irb, scope, result, lval, result_loc);
5633	6667	}
5634	6668	case BuiltinFnIdErrToInt:
5635	6669	{
5636	6670	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5637		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5638		if (arg0_value == irb->codegen->invalid_instruction)
	6671	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6672	if (arg0_value == irb->codegen->invalid_inst_src)
5639	6673	return arg0_value;
5640	6674
5641		IrInstruction *result = ir_build_err_to_int(irb, scope, node, arg0_value);
	6675	IrInstSrc *result = ir_build_err_to_int_src(irb, scope, node, arg0_value);
5642	6676	return ir_lval_wrap(irb, scope, result, lval, result_loc);
5643	6677	}
5644	6678	case BuiltinFnIdIntToErr:
5645	6679	{
5646	6680	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5647		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5648		if (arg0_value == irb->codegen->invalid_instruction)
	6681	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6682	if (arg0_value == irb->codegen->invalid_inst_src)
5649	6683	return arg0_value;
5650	6684
5651		IrInstruction *result = ir_build_int_to_err(irb, scope, node, arg0_value);
	6685	IrInstSrc *result = ir_build_int_to_err_src(irb, scope, node, arg0_value);
5652	6686	return ir_lval_wrap(irb, scope, result, lval, result_loc);
5653	6687	}
5654	6688	case BuiltinFnIdBoolToInt:
5655	6689	{
5656	6690	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5657		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5658		if (arg0_value == irb->codegen->invalid_instruction)
	6691	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6692	if (arg0_value == irb->codegen->invalid_inst_src)
5659	6693	return arg0_value;
5660	6694
5661		IrInstruction *result = ir_build_bool_to_int(irb, scope, node, arg0_value);
	6695	IrInstSrc *result = ir_build_bool_to_int(irb, scope, node, arg0_value);
5662	6696	return ir_lval_wrap(irb, scope, result, lval, result_loc);
5663	6697	}
5664	6698	case BuiltinFnIdIntType:
5665	6699	{
5666	6700	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5667		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5668		if (arg0_value == irb->codegen->invalid_instruction)
	6701	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6702	if (arg0_value == irb->codegen->invalid_inst_src)
5669	6703	return arg0_value;
5670	6704
5671	6705	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
5672		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
5673		if (arg1_value == irb->codegen->invalid_instruction)
	6706	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	6707	if (arg1_value == irb->codegen->invalid_inst_src)
5674	6708	return arg1_value;
5675	6709
5676		IrInstruction *int_type = ir_build_int_type(irb, scope, node, arg0_value, arg1_value);
	6710	IrInstSrc *int_type = ir_build_int_type(irb, scope, node, arg0_value, arg1_value);
5677	6711	return ir_lval_wrap(irb, scope, int_type, lval, result_loc);
5678	6712	}
5679	6713	case BuiltinFnIdVectorType:
5680	6714	{
5681	6715	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5682		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5683		if (arg0_value == irb->codegen->invalid_instruction)
	6716	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6717	if (arg0_value == irb->codegen->invalid_inst_src)
5684	6718	return arg0_value;
5685	6719
5686	6720	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
5687		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
5688		if (arg1_value == irb->codegen->invalid_instruction)
	6721	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	6722	if (arg1_value == irb->codegen->invalid_inst_src)
5689	6723	return arg1_value;
5690	6724
5691		IrInstruction *vector_type = ir_build_vector_type(irb, scope, node, arg0_value, arg1_value);
	6725	IrInstSrc *vector_type = ir_build_vector_type(irb, scope, node, arg0_value, arg1_value);
5692	6726	return ir_lval_wrap(irb, scope, vector_type, lval, result_loc);
5693	6727	}
5694	6728	case BuiltinFnIdShuffle:
5695	6729	{
5696	6730	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5697		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5698		if (arg0_value == irb->codegen->invalid_instruction)
	6731	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6732	if (arg0_value == irb->codegen->invalid_inst_src)
5699	6733	return arg0_value;
5700	6734
5701	6735	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
5702		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
5703		if (arg1_value == irb->codegen->invalid_instruction)
	6736	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	6737	if (arg1_value == irb->codegen->invalid_inst_src)
5704	6738	return arg1_value;
5705	6739
5706	6740	AstNode *arg2_node = node->data.fn_call_expr.params.at(2);
5707		IrInstruction *arg2_value = ir_gen_node(irb, arg2_node, scope);
5708		if (arg2_value == irb->codegen->invalid_instruction)
	6741	IrInstSrc *arg2_value = ir_gen_node(irb, arg2_node, scope);
	6742	if (arg2_value == irb->codegen->invalid_inst_src)
5709	6743	return arg2_value;
5710	6744
5711	6745	AstNode *arg3_node = node->data.fn_call_expr.params.at(3);
5712		IrInstruction *arg3_value = ir_gen_node(irb, arg3_node, scope);
5713		if (arg3_value == irb->codegen->invalid_instruction)
	6746	IrInstSrc *arg3_value = ir_gen_node(irb, arg3_node, scope);
	6747	if (arg3_value == irb->codegen->invalid_inst_src)
5714	6748	return arg3_value;
5715	6749
5716		IrInstruction *shuffle_vector = ir_build_shuffle_vector(irb, scope, node,
	6750	IrInstSrc *shuffle_vector = ir_build_shuffle_vector(irb, scope, node,
5717	6751	arg0_value, arg1_value, arg2_value, arg3_value);
5718	6752	return ir_lval_wrap(irb, scope, shuffle_vector, lval, result_loc);
5719	6753	}
5720	6754	case BuiltinFnIdSplat:
5721	6755	{
5722	6756	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5723		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5724		if (arg0_value == irb->codegen->invalid_instruction)
	6757	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6758	if (arg0_value == irb->codegen->invalid_inst_src)
5725	6759	return arg0_value;
5726	6760
5727	6761	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
5728		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
5729		if (arg1_value == irb->codegen->invalid_instruction)
	6762	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	6763	if (arg1_value == irb->codegen->invalid_inst_src)
5730	6764	return arg1_value;
5731	6765
5732		IrInstruction *splat = ir_build_splat_src(irb, scope, node,
	6766	IrInstSrc *splat = ir_build_splat_src(irb, scope, node,
5733	6767	arg0_value, arg1_value);
5734	6768	return ir_lval_wrap(irb, scope, splat, lval, result_loc);
5735	6769	}
5736	6770	case BuiltinFnIdMemcpy:
5737	6771	{
5738	6772	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5739		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5740		if (arg0_value == irb->codegen->invalid_instruction)
	6773	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6774	if (arg0_value == irb->codegen->invalid_inst_src)
5741	6775	return arg0_value;
5742	6776
5743	6777	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
5744		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
5745		if (arg1_value == irb->codegen->invalid_instruction)
	6778	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	6779	if (arg1_value == irb->codegen->invalid_inst_src)
5746	6780	return arg1_value;
5747	6781
5748	6782	AstNode *arg2_node = node->data.fn_call_expr.params.at(2);
5749		IrInstruction *arg2_value = ir_gen_node(irb, arg2_node, scope);
5750		if (arg2_value == irb->codegen->invalid_instruction)
	6783	IrInstSrc *arg2_value = ir_gen_node(irb, arg2_node, scope);
	6784	if (arg2_value == irb->codegen->invalid_inst_src)
5751	6785	return arg2_value;
5752	6786
5753		IrInstruction *ir_memcpy = ir_build_memcpy(irb, scope, node, arg0_value, arg1_value, arg2_value);
	6787	IrInstSrc *ir_memcpy = ir_build_memcpy_src(irb, scope, node, arg0_value, arg1_value, arg2_value);
5754	6788	return ir_lval_wrap(irb, scope, ir_memcpy, lval, result_loc);
5755	6789	}
5756	6790	case BuiltinFnIdMemset:
5757	6791	{
5758	6792	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5759		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5760		if (arg0_value == irb->codegen->invalid_instruction)
	6793	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6794	if (arg0_value == irb->codegen->invalid_inst_src)
5761	6795	return arg0_value;
5762	6796
5763	6797	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
5764		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
5765		if (arg1_value == irb->codegen->invalid_instruction)
	6798	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	6799	if (arg1_value == irb->codegen->invalid_inst_src)
5766	6800	return arg1_value;
5767	6801
5768	6802	AstNode *arg2_node = node->data.fn_call_expr.params.at(2);
5769		IrInstruction *arg2_value = ir_gen_node(irb, arg2_node, scope);
5770		if (arg2_value == irb->codegen->invalid_instruction)
	6803	IrInstSrc *arg2_value = ir_gen_node(irb, arg2_node, scope);
	6804	if (arg2_value == irb->codegen->invalid_inst_src)
5771	6805	return arg2_value;
5772	6806
5773		IrInstruction *ir_memset = ir_build_memset(irb, scope, node, arg0_value, arg1_value, arg2_value);
	6807	IrInstSrc *ir_memset = ir_build_memset_src(irb, scope, node, arg0_value, arg1_value, arg2_value);
5774	6808	return ir_lval_wrap(irb, scope, ir_memset, lval, result_loc);
5775	6809	}
5776	6810	case BuiltinFnIdMemberCount:
5777	6811	{
5778	6812	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5779		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5780		if (arg0_value == irb->codegen->invalid_instruction)
	6813	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6814	if (arg0_value == irb->codegen->invalid_inst_src)
5781	6815	return arg0_value;
5782	6816
5783		IrInstruction *member_count = ir_build_member_count(irb, scope, node, arg0_value);
	6817	IrInstSrc *member_count = ir_build_member_count(irb, scope, node, arg0_value);
5784	6818	return ir_lval_wrap(irb, scope, member_count, lval, result_loc);
5785	6819	}
5786	6820	case BuiltinFnIdMemberType:
5787	6821	{
5788	6822	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5789		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5790		if (arg0_value == irb->codegen->invalid_instruction)
	6823	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6824	if (arg0_value == irb->codegen->invalid_inst_src)
5791	6825	return arg0_value;
5792	6826
5793	6827	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
5794		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
5795		if (arg1_value == irb->codegen->invalid_instruction)
	6828	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	6829	if (arg1_value == irb->codegen->invalid_inst_src)
5796	6830	return arg1_value;
5797	6831
5798	6832
5799		IrInstruction *member_type = ir_build_member_type(irb, scope, node, arg0_value, arg1_value);
	6833	IrInstSrc *member_type = ir_build_member_type(irb, scope, node, arg0_value, arg1_value);
5800	6834	return ir_lval_wrap(irb, scope, member_type, lval, result_loc);
5801	6835	}
5802	6836	case BuiltinFnIdMemberName:
5803	6837	{
5804	6838	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5805		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5806		if (arg0_value == irb->codegen->invalid_instruction)
	6839	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6840	if (arg0_value == irb->codegen->invalid_inst_src)
5807	6841	return arg0_value;
5808	6842
5809	6843	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
5810		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
5811		if (arg1_value == irb->codegen->invalid_instruction)
	6844	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	6845	if (arg1_value == irb->codegen->invalid_inst_src)
5812	6846	return arg1_value;
5813	6847
5814	6848
5815		IrInstruction *member_name = ir_build_member_name(irb, scope, node, arg0_value, arg1_value);
	6849	IrInstSrc *member_name = ir_build_member_name(irb, scope, node, arg0_value, arg1_value);
5816	6850	return ir_lval_wrap(irb, scope, member_name, lval, result_loc);
5817	6851	}
5818	6852	case BuiltinFnIdField:
5819	6853	{
5820	6854	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5821		IrInstruction *arg0_value = ir_gen_node_extra(irb, arg0_node, scope, LValPtr, nullptr);
5822		if (arg0_value == irb->codegen->invalid_instruction)
	6855	IrInstSrc *arg0_value = ir_gen_node_extra(irb, arg0_node, scope, LValPtr, nullptr);
	6856	if (arg0_value == irb->codegen->invalid_inst_src)
5823	6857	return arg0_value;
5824	6858
5825	6859	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
5826		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
5827		if (arg1_value == irb->codegen->invalid_instruction)
	6860	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	6861	if (arg1_value == irb->codegen->invalid_inst_src)
5828	6862	return arg1_value;
5829	6863
5830		IrInstruction *ptr_instruction = ir_build_field_ptr_instruction(irb, scope, node,
	6864	IrInstSrc *ptr_instruction = ir_build_field_ptr_instruction(irb, scope, node,
5831	6865	arg0_value, arg1_value, false);
5832	6866
5833	6867	if (lval == LValPtr)
5834	6868	return ptr_instruction;
5835	6869
5836		IrInstruction *load_ptr = ir_build_load_ptr(irb, scope, node, ptr_instruction);
	6870	IrInstSrc *load_ptr = ir_build_load_ptr(irb, scope, node, ptr_instruction);
5837	6871	return ir_expr_wrap(irb, scope, load_ptr, result_loc);
5838	6872	}
5839	6873	case BuiltinFnIdHasField:
5840	6874	{
5841	6875	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5842		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5843		if (arg0_value == irb->codegen->invalid_instruction)
	6876	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6877	if (arg0_value == irb->codegen->invalid_inst_src)
5844	6878	return arg0_value;
5845	6879
5846	6880	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
5847		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
5848		if (arg1_value == irb->codegen->invalid_instruction)
	6881	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	6882	if (arg1_value == irb->codegen->invalid_inst_src)
5849	6883	return arg1_value;
5850	6884
5851		IrInstruction *type_info = ir_build_has_field(irb, scope, node, arg0_value, arg1_value);
	6885	IrInstSrc *type_info = ir_build_has_field(irb, scope, node, arg0_value, arg1_value);
5852	6886	return ir_lval_wrap(irb, scope, type_info, lval, result_loc);
5853	6887	}
5854	6888	case BuiltinFnIdTypeInfo:
5855	6889	{
5856	6890	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5857		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5858		if (arg0_value == irb->codegen->invalid_instruction)
	6891	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6892	if (arg0_value == irb->codegen->invalid_inst_src)
5859	6893	return arg0_value;
5860	6894
5861		IrInstruction *type_info = ir_build_type_info(irb, scope, node, arg0_value);
	6895	IrInstSrc *type_info = ir_build_type_info(irb, scope, node, arg0_value);
5862	6896	return ir_lval_wrap(irb, scope, type_info, lval, result_loc);
5863	6897	}
5864	6898	case BuiltinFnIdType:
5865	6899	{
5866	6900	AstNode *arg_node = node->data.fn_call_expr.params.at(0);
5867		IrInstruction *arg = ir_gen_node(irb, arg_node, scope);
5868		if (arg == irb->codegen->invalid_instruction)
	6901	IrInstSrc *arg = ir_gen_node(irb, arg_node, scope);
	6902	if (arg == irb->codegen->invalid_inst_src)
5869	6903	return arg;
5870	6904
5871		IrInstruction *type = ir_build_type(irb, scope, node, arg);
	6905	IrInstSrc *type = ir_build_type(irb, scope, node, arg);
5872	6906	return ir_lval_wrap(irb, scope, type, lval, result_loc);
5873	6907	}
5874	6908	case BuiltinFnIdBreakpoint:
5875	6909	return ir_lval_wrap(irb, scope, ir_build_breakpoint(irb, scope, node), lval, result_loc);
5876	6910	case BuiltinFnIdReturnAddress:
5877		return ir_lval_wrap(irb, scope, ir_build_return_address(irb, scope, node), lval, result_loc);
	6911	return ir_lval_wrap(irb, scope, ir_build_return_address_src(irb, scope, node), lval, result_loc);
5878	6912	case BuiltinFnIdFrameAddress:
5879		return ir_lval_wrap(irb, scope, ir_build_frame_address(irb, scope, node), lval, result_loc);
	6913	return ir_lval_wrap(irb, scope, ir_build_frame_address_src(irb, scope, node), lval, result_loc);
5880	6914	case BuiltinFnIdFrameHandle:
5881	6915	if (!irb->exec->fn_entry) {
5882	6916	add_node_error(irb->codegen, node, buf_sprintf("@frame() called outside of function definition"));
5883		return irb->codegen->invalid_instruction;
	6917	return irb->codegen->invalid_inst_src;
5884	6918	}
5885		return ir_lval_wrap(irb, scope, ir_build_handle(irb, scope, node), lval, result_loc);
	6919	return ir_lval_wrap(irb, scope, ir_build_handle_src(irb, scope, node), lval, result_loc);
5886	6920	case BuiltinFnIdFrameType: {
5887	6921	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5888		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5889		if (arg0_value == irb->codegen->invalid_instruction)
	6922	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6923	if (arg0_value == irb->codegen->invalid_inst_src)
5890	6924	return arg0_value;
5891	6925
5892		IrInstruction *frame_type = ir_build_frame_type(irb, scope, node, arg0_value);
	6926	IrInstSrc *frame_type = ir_build_frame_type(irb, scope, node, arg0_value);
5893	6927	return ir_lval_wrap(irb, scope, frame_type, lval, result_loc);
5894	6928	}
5895	6929	case BuiltinFnIdFrameSize: {
5896	6930	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5897		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5898		if (arg0_value == irb->codegen->invalid_instruction)
	6931	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6932	if (arg0_value == irb->codegen->invalid_inst_src)
5899	6933	return arg0_value;
5900	6934
5901		IrInstruction *frame_size = ir_build_frame_size_src(irb, scope, node, arg0_value);
	6935	IrInstSrc *frame_size = ir_build_frame_size_src(irb, scope, node, arg0_value);
5902	6936	return ir_lval_wrap(irb, scope, frame_size, lval, result_loc);
5903	6937	}
5904	6938	case BuiltinFnIdAlignOf:
5905	6939	{
5906	6940	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5907		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5908		if (arg0_value == irb->codegen->invalid_instruction)
	6941	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6942	if (arg0_value == irb->codegen->invalid_inst_src)
5909	6943	return arg0_value;
5910	6944
5911		IrInstruction *align_of = ir_build_align_of(irb, scope, node, arg0_value);
	6945	IrInstSrc *align_of = ir_build_align_of(irb, scope, node, arg0_value);
5912	6946	return ir_lval_wrap(irb, scope, align_of, lval, result_loc);
5913	6947	}
5914	6948	case BuiltinFnIdAddWithOverflow:
...	...	@@ -5924,43 +6958,43 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
5924	6958	case BuiltinFnIdTypeName:
5925	6959	{
5926	6960	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5927		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5928		if (arg0_value == irb->codegen->invalid_instruction)
	6961	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6962	if (arg0_value == irb->codegen->invalid_inst_src)
5929	6963	return arg0_value;
5930	6964
5931		IrInstruction *type_name = ir_build_type_name(irb, scope, node, arg0_value);
	6965	IrInstSrc *type_name = ir_build_type_name(irb, scope, node, arg0_value);
5932	6966	return ir_lval_wrap(irb, scope, type_name, lval, result_loc);
5933	6967	}
5934	6968	case BuiltinFnIdPanic:
5935	6969	{
5936	6970	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5937		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5938		if (arg0_value == irb->codegen->invalid_instruction)
	6971	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6972	if (arg0_value == irb->codegen->invalid_inst_src)
5939	6973	return arg0_value;
5940	6974
5941		IrInstruction *panic = ir_build_panic(irb, scope, node, arg0_value);
	6975	IrInstSrc *panic = ir_build_panic_src(irb, scope, node, arg0_value);
5942	6976	return ir_lval_wrap(irb, scope, panic, lval, result_loc);
5943	6977	}
5944	6978	case BuiltinFnIdPtrCast:
5945	6979	{
5946	6980	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
5947		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
5948		if (arg0_value == irb->codegen->invalid_instruction)
	6981	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	6982	if (arg0_value == irb->codegen->invalid_inst_src)
5949	6983	return arg0_value;
5950	6984
5951	6985	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
5952		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
5953		if (arg1_value == irb->codegen->invalid_instruction)
	6986	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	6987	if (arg1_value == irb->codegen->invalid_inst_src)
5954	6988	return arg1_value;
5955	6989
5956		IrInstruction *ptr_cast = ir_build_ptr_cast_src(irb, scope, node, arg0_value, arg1_value, true);
	6990	IrInstSrc *ptr_cast = ir_build_ptr_cast_src(irb, scope, node, arg0_value, arg1_value, true);
5957	6991	return ir_lval_wrap(irb, scope, ptr_cast, lval, result_loc);
5958	6992	}
5959	6993	case BuiltinFnIdBitCast:
5960	6994	{
5961	6995	AstNode *dest_type_node = node->data.fn_call_expr.params.at(0);
5962		IrInstruction *dest_type = ir_gen_node(irb, dest_type_node, scope);
5963		if (dest_type == irb->codegen->invalid_instruction)
	6996	IrInstSrc *dest_type = ir_gen_node(irb, dest_type_node, scope);
	6997	if (dest_type == irb->codegen->invalid_inst_src)
5964	6998	return dest_type;
5965	6999
5966	7000	ResultLocBitCast *result_loc_bit_cast = allocate<ResultLocBitCast>(1);
...	...	@@ -5972,125 +7006,126 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
5972	7006	ir_build_reset_result(irb, scope, node, &result_loc_bit_cast->base);
5973	7007
5974	7008	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
5975		IrInstruction *arg1_value = ir_gen_node_extra(irb, arg1_node, scope, LValNone,
	7009	IrInstSrc *arg1_value = ir_gen_node_extra(irb, arg1_node, scope, LValNone,
5976	7010	&result_loc_bit_cast->base);
5977		if (arg1_value == irb->codegen->invalid_instruction)
	7011	if (arg1_value == irb->codegen->invalid_inst_src)
5978	7012	return arg1_value;
5979	7013
5980		IrInstruction *bitcast = ir_build_bit_cast_src(irb, scope, arg1_node, arg1_value, result_loc_bit_cast);
	7014	IrInstSrc *bitcast = ir_build_bit_cast_src(irb, scope, arg1_node, arg1_value, result_loc_bit_cast);
5981	7015	return ir_lval_wrap(irb, scope, bitcast, lval, result_loc);
5982	7016	}
5983	7017	case BuiltinFnIdAs:
5984	7018	{
5985	7019	AstNode *dest_type_node = node->data.fn_call_expr.params.at(0);
5986		IrInstruction *dest_type = ir_gen_node(irb, dest_type_node, scope);
5987		if (dest_type == irb->codegen->invalid_instruction)
	7020	IrInstSrc *dest_type = ir_gen_node(irb, dest_type_node, scope);
	7021	if (dest_type == irb->codegen->invalid_inst_src)
5988	7022	return dest_type;
5989	7023
5990	7024	ResultLocCast *result_loc_cast = ir_build_cast_result_loc(irb, dest_type, result_loc);
5991	7025
5992	7026	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
5993		IrInstruction *arg1_value = ir_gen_node_extra(irb, arg1_node, scope, LValNone,
	7027	IrInstSrc *arg1_value = ir_gen_node_extra(irb, arg1_node, scope, LValNone,
5994	7028	&result_loc_cast->base);
5995		if (arg1_value == irb->codegen->invalid_instruction)
	7029	if (arg1_value == irb->codegen->invalid_inst_src)
5996	7030	return arg1_value;
5997	7031
5998		IrInstruction *result = ir_build_implicit_cast(irb, scope, node, arg1_value, result_loc_cast);
	7032	IrInstSrc *result = ir_build_implicit_cast(irb, scope, node, arg1_value, result_loc_cast);
5999	7033	return ir_lval_wrap(irb, scope, result, lval, result_loc);
6000	7034	}
6001	7035	case BuiltinFnIdIntToPtr:
6002	7036	{
6003	7037	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
6004		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
6005		if (arg0_value == irb->codegen->invalid_instruction)
	7038	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	7039	if (arg0_value == irb->codegen->invalid_inst_src)
6006	7040	return arg0_value;
6007	7041
6008	7042	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
6009		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
6010		if (arg1_value == irb->codegen->invalid_instruction)
	7043	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	7044	if (arg1_value == irb->codegen->invalid_inst_src)
6011	7045	return arg1_value;
6012	7046
6013		IrInstruction *int_to_ptr = ir_build_int_to_ptr(irb, scope, node, arg0_value, arg1_value);
	7047	IrInstSrc *int_to_ptr = ir_build_int_to_ptr_src(irb, scope, node, arg0_value, arg1_value);
6014	7048	return ir_lval_wrap(irb, scope, int_to_ptr, lval, result_loc);
6015	7049	}
6016	7050	case BuiltinFnIdPtrToInt:
6017	7051	{
6018	7052	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
6019		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
6020		if (arg0_value == irb->codegen->invalid_instruction)
	7053	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	7054	if (arg0_value == irb->codegen->invalid_inst_src)
6021	7055	return arg0_value;
6022	7056
6023		IrInstruction *ptr_to_int = ir_build_ptr_to_int(irb, scope, node, arg0_value);
	7057	IrInstSrc *ptr_to_int = ir_build_ptr_to_int_src(irb, scope, node, arg0_value);
6024	7058	return ir_lval_wrap(irb, scope, ptr_to_int, lval, result_loc);
6025	7059	}
6026	7060	case BuiltinFnIdTagName:
6027	7061	{
6028	7062	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
6029		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
6030		if (arg0_value == irb->codegen->invalid_instruction)
	7063	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	7064	if (arg0_value == irb->codegen->invalid_inst_src)
6031	7065	return arg0_value;
6032	7066
6033		IrInstruction *tag_name = ir_build_tag_name(irb, scope, node, arg0_value);
	7067	IrInstSrc *tag_name = ir_build_tag_name_src(irb, scope, node, arg0_value);
6034	7068	return ir_lval_wrap(irb, scope, tag_name, lval, result_loc);
6035	7069	}
6036	7070	case BuiltinFnIdTagType:
6037	7071	{
6038	7072	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
6039		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
6040		if (arg0_value == irb->codegen->invalid_instruction)
	7073	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	7074	if (arg0_value == irb->codegen->invalid_inst_src)
6041	7075	return arg0_value;
6042	7076
6043		IrInstruction *tag_type = ir_build_tag_type(irb, scope, node, arg0_value);
	7077	IrInstSrc *tag_type = ir_build_tag_type(irb, scope, node, arg0_value);
6044	7078	return ir_lval_wrap(irb, scope, tag_type, lval, result_loc);
6045	7079	}
6046	7080	case BuiltinFnIdFieldParentPtr:
6047	7081	{
6048	7082	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
6049		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
6050		if (arg0_value == irb->codegen->invalid_instruction)
	7083	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	7084	if (arg0_value == irb->codegen->invalid_inst_src)
6051	7085	return arg0_value;
6052	7086
6053	7087	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
6054		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
6055		if (arg1_value == irb->codegen->invalid_instruction)
	7088	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	7089	if (arg1_value == irb->codegen->invalid_inst_src)
6056	7090	return arg1_value;
6057	7091
6058	7092	AstNode *arg2_node = node->data.fn_call_expr.params.at(2);
6059		IrInstruction *arg2_value = ir_gen_node(irb, arg2_node, scope);
6060		if (arg2_value == irb->codegen->invalid_instruction)
	7093	IrInstSrc *arg2_value = ir_gen_node(irb, arg2_node, scope);
	7094	if (arg2_value == irb->codegen->invalid_inst_src)
6061	7095	return arg2_value;
6062	7096
6063		IrInstruction *field_parent_ptr = ir_build_field_parent_ptr(irb, scope, node, arg0_value, arg1_value, arg2_value, nullptr);
	7097	IrInstSrc *field_parent_ptr = ir_build_field_parent_ptr_src(irb, scope, node,
	7098	arg0_value, arg1_value, arg2_value);
6064	7099	return ir_lval_wrap(irb, scope, field_parent_ptr, lval, result_loc);
6065	7100	}
6066	7101	case BuiltinFnIdByteOffsetOf:
6067	7102	{
6068	7103	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
6069		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
6070		if (arg0_value == irb->codegen->invalid_instruction)
	7104	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	7105	if (arg0_value == irb->codegen->invalid_inst_src)
6071	7106	return arg0_value;
6072	7107
6073	7108	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
6074		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
6075		if (arg1_value == irb->codegen->invalid_instruction)
	7109	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	7110	if (arg1_value == irb->codegen->invalid_inst_src)
6076	7111	return arg1_value;
6077	7112
6078		IrInstruction *offset_of = ir_build_byte_offset_of(irb, scope, node, arg0_value, arg1_value);
	7113	IrInstSrc *offset_of = ir_build_byte_offset_of(irb, scope, node, arg0_value, arg1_value);
6079	7114	return ir_lval_wrap(irb, scope, offset_of, lval, result_loc);
6080	7115	}
6081	7116	case BuiltinFnIdBitOffsetOf:
6082	7117	{
6083	7118	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
6084		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
6085		if (arg0_value == irb->codegen->invalid_instruction)
	7119	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	7120	if (arg0_value == irb->codegen->invalid_inst_src)
6086	7121	return arg0_value;
6087	7122
6088	7123	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
6089		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
6090		if (arg1_value == irb->codegen->invalid_instruction)
	7124	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	7125	if (arg1_value == irb->codegen->invalid_inst_src)
6091	7126	return arg1_value;
6092	7127
6093		IrInstruction *offset_of = ir_build_bit_offset_of(irb, scope, node, arg0_value, arg1_value);
	7128	IrInstSrc *offset_of = ir_build_bit_offset_of(irb, scope, node, arg0_value, arg1_value);
6094	7129	return ir_lval_wrap(irb, scope, offset_of, lval, result_loc);
6095	7130	}
6096	7131	case BuiltinFnIdNewStackCall:
...	...	@@ -6099,45 +7134,45 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
6099	7134	add_node_error(irb->codegen, node,
6100	7135	buf_sprintf("expected at least 2 arguments, found %" ZIG_PRI_usize,
6101	7136	node->data.fn_call_expr.params.length));
6102		return irb->codegen->invalid_instruction;
	7137	return irb->codegen->invalid_inst_src;
6103	7138	}
6104	7139
6105	7140	AstNode *new_stack_node = node->data.fn_call_expr.params.at(0);
6106		IrInstruction *new_stack = ir_gen_node(irb, new_stack_node, scope);
6107		if (new_stack == irb->codegen->invalid_instruction)
	7141	IrInstSrc *new_stack = ir_gen_node(irb, new_stack_node, scope);
	7142	if (new_stack == irb->codegen->invalid_inst_src)
6108	7143	return new_stack;
6109	7144
6110	7145	AstNode *fn_ref_node = node->data.fn_call_expr.params.at(1);
6111		IrInstruction *fn_ref = ir_gen_node(irb, fn_ref_node, scope);
6112		if (fn_ref == irb->codegen->invalid_instruction)
	7146	IrInstSrc *fn_ref = ir_gen_node(irb, fn_ref_node, scope);
	7147	if (fn_ref == irb->codegen->invalid_inst_src)
6113	7148	return fn_ref;
6114	7149
6115	7150	size_t arg_count = node->data.fn_call_expr.params.length - 2;
6116	7151
6117		IrInstruction *args = allocate<IrInstruction>(arg_count);
	7152	IrInstSrc *args = allocate<IrInstSrc>(arg_count);
6118	7153	for (size_t i = 0; i < arg_count; i += 1) {
6119	7154	AstNode *arg_node = node->data.fn_call_expr.params.at(i + 2);
6120	7155	args[i] = ir_gen_node(irb, arg_node, scope);
6121		if (args[i] == irb->codegen->invalid_instruction)
	7156	if (args[i] == irb->codegen->invalid_inst_src)
6122	7157	return args[i];
6123	7158	}
6124	7159
6125		IrInstruction *call = ir_build_call_src(irb, scope, node, nullptr, fn_ref, arg_count, args,
	7160	IrInstSrc *call = ir_build_call_src(irb, scope, node, nullptr, fn_ref, arg_count, args,
6126	7161	nullptr, CallModifierNone, false, new_stack, result_loc);
6127	7162	return ir_lval_wrap(irb, scope, call, lval, result_loc);
6128	7163	}
6129	7164	case BuiltinFnIdCall: {
6130	7165	// Cast the options parameter to the options type
6131	7166	ZigType *options_type = get_builtin_type(irb->codegen, "CallOptions");
6132		IrInstruction *options_type_inst = ir_build_const_type(irb, scope, node, options_type);
	7167	IrInstSrc *options_type_inst = ir_build_const_type(irb, scope, node, options_type);
6133	7168	ResultLocCast *result_loc_cast = ir_build_cast_result_loc(irb, options_type_inst, no_result_loc());
6134	7169
6135	7170	AstNode *options_node = node->data.fn_call_expr.params.at(0);
6136		IrInstruction *options_inner = ir_gen_node_extra(irb, options_node, scope,
	7171	IrInstSrc *options_inner = ir_gen_node_extra(irb, options_node, scope,
6137	7172	LValNone, &result_loc_cast->base);
6138		if (options_inner == irb->codegen->invalid_instruction)
	7173	if (options_inner == irb->codegen->invalid_inst_src)
6139	7174	return options_inner;
6140		IrInstruction *options = ir_build_implicit_cast(irb, scope, options_node, options_inner, result_loc_cast);
	7175	IrInstSrc *options = ir_build_implicit_cast(irb, scope, options_node, options_inner, result_loc_cast);
6141	7176
6142	7177	AstNode *fn_ref_node = node->data.fn_call_expr.params.at(1);
6143	7178	AstNode *args_node = node->data.fn_call_expr.params.at(2);
...	...	@@ -6153,18 +7188,18 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
6153	7188	} else {
6154	7189	exec_add_error_node(irb->codegen, irb->exec, args_node,
6155	7190	buf_sprintf("TODO: @call with anon struct literal"));
6156		return irb->codegen->invalid_instruction;
	7191	return irb->codegen->invalid_inst_src;
6157	7192	}
6158	7193	} else {
6159		IrInstruction *fn_ref = ir_gen_node(irb, fn_ref_node, scope);
6160		if (fn_ref == irb->codegen->invalid_instruction)
	7194	IrInstSrc *fn_ref = ir_gen_node(irb, fn_ref_node, scope);
	7195	if (fn_ref == irb->codegen->invalid_inst_src)
6161	7196	return fn_ref;
6162	7197
6163		IrInstruction *args = ir_gen_node(irb, args_node, scope);
6164		if (args == irb->codegen->invalid_instruction)
	7198	IrInstSrc *args = ir_gen_node(irb, args_node, scope);
	7199	if (args == irb->codegen->invalid_inst_src)
6165	7200	return args;
6166	7201
6167		IrInstruction *call = ir_build_call_extra(irb, scope, node, options, fn_ref, args, result_loc);
	7202	IrInstSrc *call = ir_build_call_extra(irb, scope, node, options, fn_ref, args, result_loc);
6168	7203	return ir_lval_wrap(irb, scope, call, lval, result_loc);
6169	7204	}
6170	7205	}
...	...	@@ -6173,237 +7208,233 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
6173	7208	case BuiltinFnIdTypeId:
6174	7209	{
6175	7210	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
6176		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
6177		if (arg0_value == irb->codegen->invalid_instruction)
	7211	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	7212	if (arg0_value == irb->codegen->invalid_inst_src)
6178	7213	return arg0_value;
6179	7214
6180		IrInstruction *type_id = ir_build_type_id(irb, scope, node, arg0_value);
	7215	IrInstSrc *type_id = ir_build_type_id(irb, scope, node, arg0_value);
6181	7216	return ir_lval_wrap(irb, scope, type_id, lval, result_loc);
6182	7217	}
6183	7218	case BuiltinFnIdShlExact:
6184	7219	{
6185	7220	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
6186		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
6187		if (arg0_value == irb->codegen->invalid_instruction)
	7221	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	7222	if (arg0_value == irb->codegen->invalid_inst_src)
6188	7223	return arg0_value;
6189	7224
6190	7225	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
6191		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
6192		if (arg1_value == irb->codegen->invalid_instruction)
	7226	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	7227	if (arg1_value == irb->codegen->invalid_inst_src)
6193	7228	return arg1_value;
6194	7229
6195		IrInstruction *bin_op = ir_build_bin_op(irb, scope, node, IrBinOpBitShiftLeftExact, arg0_value, arg1_value, true);
	7230	IrInstSrc *bin_op = ir_build_bin_op(irb, scope, node, IrBinOpBitShiftLeftExact, arg0_value, arg1_value, true);
6196	7231	return ir_lval_wrap(irb, scope, bin_op, lval, result_loc);
6197	7232	}
6198	7233	case BuiltinFnIdShrExact:
6199	7234	{
6200	7235	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
6201		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
6202		if (arg0_value == irb->codegen->invalid_instruction)
	7236	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	7237	if (arg0_value == irb->codegen->invalid_inst_src)
6203	7238	return arg0_value;
6204	7239
6205	7240	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
6206		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
6207		if (arg1_value == irb->codegen->invalid_instruction)
	7241	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	7242	if (arg1_value == irb->codegen->invalid_inst_src)
6208	7243	return arg1_value;
6209	7244
6210		IrInstruction *bin_op = ir_build_bin_op(irb, scope, node, IrBinOpBitShiftRightExact, arg0_value, arg1_value, true);
	7245	IrInstSrc *bin_op = ir_build_bin_op(irb, scope, node, IrBinOpBitShiftRightExact, arg0_value, arg1_value, true);
6211	7246	return ir_lval_wrap(irb, scope, bin_op, lval, result_loc);
6212	7247	}
6213	7248	case BuiltinFnIdSetEvalBranchQuota:
6214	7249	{
6215	7250	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
6216		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
6217		if (arg0_value == irb->codegen->invalid_instruction)
	7251	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	7252	if (arg0_value == irb->codegen->invalid_inst_src)
6218	7253	return arg0_value;
6219	7254
6220		IrInstruction *set_eval_branch_quota = ir_build_set_eval_branch_quota(irb, scope, node, arg0_value);
	7255	IrInstSrc *set_eval_branch_quota = ir_build_set_eval_branch_quota(irb, scope, node, arg0_value);
6221	7256	return ir_lval_wrap(irb, scope, set_eval_branch_quota, lval, result_loc);
6222	7257	}
6223	7258	case BuiltinFnIdAlignCast:
6224	7259	{
6225	7260	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
6226		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
6227		if (arg0_value == irb->codegen->invalid_instruction)
	7261	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	7262	if (arg0_value == irb->codegen->invalid_inst_src)
6228	7263	return arg0_value;
6229	7264
6230	7265	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
6231		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
6232		if (arg1_value == irb->codegen->invalid_instruction)
	7266	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	7267	if (arg1_value == irb->codegen->invalid_inst_src)
6233	7268	return arg1_value;
6234	7269
6235		IrInstruction *align_cast = ir_build_align_cast(irb, scope, node, arg0_value, arg1_value);
	7270	IrInstSrc *align_cast = ir_build_align_cast_src(irb, scope, node, arg0_value, arg1_value);
6236	7271	return ir_lval_wrap(irb, scope, align_cast, lval, result_loc);
6237	7272	}
6238	7273	case BuiltinFnIdOpaqueType:
6239	7274	{
6240		IrInstruction *opaque_type = ir_build_opaque_type(irb, scope, node);
	7275	IrInstSrc *opaque_type = ir_build_opaque_type(irb, scope, node);
6241	7276	return ir_lval_wrap(irb, scope, opaque_type, lval, result_loc);
6242	7277	}
6243	7278	case BuiltinFnIdThis:
6244	7279	{
6245		IrInstruction *this_inst = ir_gen_this(irb, scope, node);
	7280	IrInstSrc *this_inst = ir_gen_this(irb, scope, node);
6246	7281	return ir_lval_wrap(irb, scope, this_inst, lval, result_loc);
6247	7282	}
6248	7283	case BuiltinFnIdSetAlignStack:
6249	7284	{
6250	7285	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
6251		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
6252		if (arg0_value == irb->codegen->invalid_instruction)
	7286	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	7287	if (arg0_value == irb->codegen->invalid_inst_src)
6253	7288	return arg0_value;
6254	7289
6255		IrInstruction *set_align_stack = ir_build_set_align_stack(irb, scope, node, arg0_value);
	7290	IrInstSrc *set_align_stack = ir_build_set_align_stack(irb, scope, node, arg0_value);
6256	7291	return ir_lval_wrap(irb, scope, set_align_stack, lval, result_loc);
6257	7292	}
6258	7293	case BuiltinFnIdArgType:
6259	7294	{
6260	7295	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
6261		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
6262		if (arg0_value == irb->codegen->invalid_instruction)
	7296	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	7297	if (arg0_value == irb->codegen->invalid_inst_src)
6263	7298	return arg0_value;
6264	7299
6265	7300	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
6266		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
6267		if (arg1_value == irb->codegen->invalid_instruction)
	7301	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	7302	if (arg1_value == irb->codegen->invalid_inst_src)
6268	7303	return arg1_value;
6269	7304
6270		IrInstruction *arg_type = ir_build_arg_type(irb, scope, node, arg0_value, arg1_value, false);
	7305	IrInstSrc *arg_type = ir_build_arg_type(irb, scope, node, arg0_value, arg1_value, false);
6271	7306	return ir_lval_wrap(irb, scope, arg_type, lval, result_loc);
6272	7307	}
6273	7308	case BuiltinFnIdExport:
6274	7309	{
6275	7310	// Cast the options parameter to the options type
6276	7311	ZigType *options_type = get_builtin_type(irb->codegen, "ExportOptions");
6277		IrInstruction *options_type_inst = ir_build_const_type(irb, scope, node, options_type);
	7312	IrInstSrc *options_type_inst = ir_build_const_type(irb, scope, node, options_type);
6278	7313	ResultLocCast *result_loc_cast = ir_build_cast_result_loc(irb, options_type_inst, no_result_loc());
6279	7314
6280	7315	AstNode *target_node = node->data.fn_call_expr.params.at(0);
6281		IrInstruction *target_value = ir_gen_node(irb, target_node, scope);
6282		if (target_value == irb->codegen->invalid_instruction)
	7316	IrInstSrc *target_value = ir_gen_node(irb, target_node, scope);
	7317	if (target_value == irb->codegen->invalid_inst_src)
6283	7318	return target_value;
6284	7319
6285	7320	AstNode *options_node = node->data.fn_call_expr.params.at(1);
6286		IrInstruction *options_value = ir_gen_node_extra(irb, options_node,
	7321	IrInstSrc *options_value = ir_gen_node_extra(irb, options_node,
6287	7322	scope, LValNone, &result_loc_cast->base);
6288		if (options_value == irb->codegen->invalid_instruction)
	7323	if (options_value == irb->codegen->invalid_inst_src)
6289	7324	return options_value;
6290	7325
6291		IrInstruction *casted_options_value = ir_build_implicit_cast(
	7326	IrInstSrc *casted_options_value = ir_build_implicit_cast(
6292	7327	irb, scope, options_node, options_value, result_loc_cast);
6293	7328
6294		IrInstruction *ir_export = ir_build_export(irb, scope, node, target_value, casted_options_value);
	7329	IrInstSrc *ir_export = ir_build_export(irb, scope, node, target_value, casted_options_value);
6295	7330	return ir_lval_wrap(irb, scope, ir_export, lval, result_loc);
6296	7331	}
6297	7332	case BuiltinFnIdErrorReturnTrace:
6298	7333	{
6299		IrInstruction *error_return_trace = ir_build_error_return_trace(irb, scope, node, IrInstructionErrorReturnTrace::Null);
	7334	IrInstSrc *error_return_trace = ir_build_error_return_trace_src(irb, scope, node,
	7335	IrInstErrorReturnTraceNull);
6300	7336	return ir_lval_wrap(irb, scope, error_return_trace, lval, result_loc);
6301	7337	}
6302	7338	case BuiltinFnIdAtomicRmw:
6303	7339	{
6304	7340	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
6305		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
6306		if (arg0_value == irb->codegen->invalid_instruction)
	7341	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	7342	if (arg0_value == irb->codegen->invalid_inst_src)
6307	7343	return arg0_value;
6308	7344
6309	7345	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
6310		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
6311		if (arg1_value == irb->codegen->invalid_instruction)
	7346	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	7347	if (arg1_value == irb->codegen->invalid_inst_src)
6312	7348	return arg1_value;
6313	7349
6314	7350	AstNode *arg2_node = node->data.fn_call_expr.params.at(2);
6315		IrInstruction *arg2_value = ir_gen_node(irb, arg2_node, scope);
6316		if (arg2_value == irb->codegen->invalid_instruction)
	7351	IrInstSrc *arg2_value = ir_gen_node(irb, arg2_node, scope);
	7352	if (arg2_value == irb->codegen->invalid_inst_src)
6317	7353	return arg2_value;
6318	7354
6319	7355	AstNode *arg3_node = node->data.fn_call_expr.params.at(3);
6320		IrInstruction *arg3_value = ir_gen_node(irb, arg3_node, scope);
6321		if (arg3_value == irb->codegen->invalid_instruction)
	7356	IrInstSrc *arg3_value = ir_gen_node(irb, arg3_node, scope);
	7357	if (arg3_value == irb->codegen->invalid_inst_src)
6322	7358	return arg3_value;
6323	7359
6324	7360	AstNode *arg4_node = node->data.fn_call_expr.params.at(4);
6325		IrInstruction *arg4_value = ir_gen_node(irb, arg4_node, scope);
6326		if (arg4_value == irb->codegen->invalid_instruction)
	7361	IrInstSrc *arg4_value = ir_gen_node(irb, arg4_node, scope);
	7362	if (arg4_value == irb->codegen->invalid_inst_src)
6327	7363	return arg4_value;
6328	7364
6329		IrInstruction *inst = ir_build_atomic_rmw(irb, scope, node, arg0_value, arg1_value, arg2_value, arg3_value,
6330		arg4_value,
6331		// these 2 values don't mean anything since we passed non-null values for other args
6332		AtomicRmwOp_xchg, AtomicOrderMonotonic);
	7365	IrInstSrc *inst = ir_build_atomic_rmw_src(irb, scope, node,
	7366	arg0_value, arg1_value, arg2_value, arg3_value, arg4_value);
6333	7367	return ir_lval_wrap(irb, scope, inst, lval, result_loc);
6334	7368	}
6335	7369	case BuiltinFnIdAtomicLoad:
6336	7370	{
6337	7371	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
6338		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
6339		if (arg0_value == irb->codegen->invalid_instruction)
	7372	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	7373	if (arg0_value == irb->codegen->invalid_inst_src)
6340	7374	return arg0_value;
6341	7375
6342	7376	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
6343		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
6344		if (arg1_value == irb->codegen->invalid_instruction)
	7377	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	7378	if (arg1_value == irb->codegen->invalid_inst_src)
6345	7379	return arg1_value;
6346	7380
6347	7381	AstNode *arg2_node = node->data.fn_call_expr.params.at(2);
6348		IrInstruction *arg2_value = ir_gen_node(irb, arg2_node, scope);
6349		if (arg2_value == irb->codegen->invalid_instruction)
	7382	IrInstSrc *arg2_value = ir_gen_node(irb, arg2_node, scope);
	7383	if (arg2_value == irb->codegen->invalid_inst_src)
6350	7384	return arg2_value;
6351	7385
6352		IrInstruction *inst = ir_build_atomic_load(irb, scope, node, arg0_value, arg1_value, arg2_value,
6353		// this value does not mean anything since we passed non-null values for other arg
6354		AtomicOrderMonotonic);
	7386	IrInstSrc *inst = ir_build_atomic_load_src(irb, scope, node, arg0_value, arg1_value, arg2_value);
6355	7387	return ir_lval_wrap(irb, scope, inst, lval, result_loc);
6356	7388	}
6357	7389	case BuiltinFnIdAtomicStore:
6358	7390	{
6359	7391	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
6360		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
6361		if (arg0_value == irb->codegen->invalid_instruction)
	7392	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	7393	if (arg0_value == irb->codegen->invalid_inst_src)
6362	7394	return arg0_value;
6363	7395
6364	7396	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
6365		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
6366		if (arg1_value == irb->codegen->invalid_instruction)
	7397	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	7398	if (arg1_value == irb->codegen->invalid_inst_src)
6367	7399	return arg1_value;
6368	7400
6369	7401	AstNode *arg2_node = node->data.fn_call_expr.params.at(2);
6370		IrInstruction *arg2_value = ir_gen_node(irb, arg2_node, scope);
6371		if (arg2_value == irb->codegen->invalid_instruction)
	7402	IrInstSrc *arg2_value = ir_gen_node(irb, arg2_node, scope);
	7403	if (arg2_value == irb->codegen->invalid_inst_src)
6372	7404	return arg2_value;
6373	7405
6374	7406	AstNode *arg3_node = node->data.fn_call_expr.params.at(3);
6375		IrInstruction *arg3_value = ir_gen_node(irb, arg3_node, scope);
6376		if (arg3_value == irb->codegen->invalid_instruction)
	7407	IrInstSrc *arg3_value = ir_gen_node(irb, arg3_node, scope);
	7408	if (arg3_value == irb->codegen->invalid_inst_src)
6377	7409	return arg3_value;
6378	7410
6379		IrInstruction *inst = ir_build_atomic_store(irb, scope, node, arg0_value, arg1_value, arg2_value, arg3_value,
6380		// this value does not mean anything since we passed non-null values for other arg
6381		AtomicOrderMonotonic);
	7411	IrInstSrc *inst = ir_build_atomic_store_src(irb, scope, node, arg0_value, arg1_value,
	7412	arg2_value, arg3_value);
6382	7413	return ir_lval_wrap(irb, scope, inst, lval, result_loc);
6383	7414	}
6384	7415	case BuiltinFnIdIntToEnum:
6385	7416	{
6386	7417	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
6387		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
6388		if (arg0_value == irb->codegen->invalid_instruction)
	7418	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	7419	if (arg0_value == irb->codegen->invalid_inst_src)
6389	7420	return arg0_value;
6390	7421
6391	7422	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
6392		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
6393		if (arg1_value == irb->codegen->invalid_instruction)
	7423	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	7424	if (arg1_value == irb->codegen->invalid_inst_src)
6394	7425	return arg1_value;
6395	7426
6396		IrInstruction *result = ir_build_int_to_enum(irb, scope, node, arg0_value, arg1_value);
	7427	IrInstSrc *result = ir_build_int_to_enum_src(irb, scope, node, arg0_value, arg1_value);
6397	7428	return ir_lval_wrap(irb, scope, result, lval, result_loc);
6398	7429	}
6399	7430	case BuiltinFnIdEnumToInt:
6400	7431	{
6401	7432	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
6402		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
6403		if (arg0_value == irb->codegen->invalid_instruction)
	7433	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	7434	if (arg0_value == irb->codegen->invalid_inst_src)
6404	7435	return arg0_value;
6405	7436
6406		IrInstruction *result = ir_build_enum_to_int(irb, scope, node, arg0_value);
	7437	IrInstSrc *result = ir_build_enum_to_int(irb, scope, node, arg0_value);
6407	7438	return ir_lval_wrap(irb, scope, result, lval, result_loc);
6408	7439	}
6409	7440	case BuiltinFnIdCtz:
...	...	@@ -6413,16 +7444,16 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
6413	7444	case BuiltinFnIdBitReverse:
6414	7445	{
6415	7446	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
6416		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
6417		if (arg0_value == irb->codegen->invalid_instruction)
	7447	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	7448	if (arg0_value == irb->codegen->invalid_inst_src)
6418	7449	return arg0_value;
6419	7450
6420	7451	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
6421		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
6422		if (arg1_value == irb->codegen->invalid_instruction)
	7452	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	7453	if (arg1_value == irb->codegen->invalid_inst_src)
6423	7454	return arg1_value;
6424	7455
6425		IrInstruction *result;
	7456	IrInstSrc *result;
6426	7457	switch (builtin_fn->id) {
6427	7458	case BuiltinFnIdCtz:
6428	7459	result = ir_build_ctz(irb, scope, node, arg0_value, arg1_value);
...	...	@@ -6447,28 +7478,28 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
6447	7478	case BuiltinFnIdHasDecl:
6448	7479	{
6449	7480	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
6450		IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
6451		if (arg0_value == irb->codegen->invalid_instruction)
	7481	IrInstSrc *arg0_value = ir_gen_node(irb, arg0_node, scope);
	7482	if (arg0_value == irb->codegen->invalid_inst_src)
6452	7483	return arg0_value;
6453	7484
6454	7485	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
6455		IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
6456		if (arg1_value == irb->codegen->invalid_instruction)
	7486	IrInstSrc *arg1_value = ir_gen_node(irb, arg1_node, scope);
	7487	if (arg1_value == irb->codegen->invalid_inst_src)
6457	7488	return arg1_value;
6458	7489
6459		IrInstruction *has_decl = ir_build_has_decl(irb, scope, node, arg0_value, arg1_value);
	7490	IrInstSrc *has_decl = ir_build_has_decl(irb, scope, node, arg0_value, arg1_value);
6460	7491	return ir_lval_wrap(irb, scope, has_decl, lval, result_loc);
6461	7492	}
6462	7493	case BuiltinFnIdUnionInit:
6463	7494	{
6464	7495	AstNode *union_type_node = node->data.fn_call_expr.params.at(0);
6465		IrInstruction *union_type_inst = ir_gen_node(irb, union_type_node, scope);
6466		if (union_type_inst == irb->codegen->invalid_instruction)
	7496	IrInstSrc *union_type_inst = ir_gen_node(irb, union_type_node, scope);
	7497	if (union_type_inst == irb->codegen->invalid_inst_src)
6467	7498	return union_type_inst;
6468	7499
6469	7500	AstNode *name_node = node->data.fn_call_expr.params.at(1);
6470		IrInstruction *name_inst = ir_gen_node(irb, name_node, scope);
6471		if (name_inst == irb->codegen->invalid_instruction)
	7501	IrInstSrc *name_inst = ir_gen_node(irb, name_node, scope);
	7502	if (name_inst == irb->codegen->invalid_inst_src)
6472	7503	return name_inst;
6473	7504
6474	7505	AstNode *init_node = node->data.fn_call_expr.params.at(2);
...	...	@@ -6480,7 +7511,7 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
6480	7511	zig_unreachable();
6481	7512	}
6482	7513
6483		static IrInstruction ir_gen_fn_call(IrBuilder irb, Scope scope, AstNode node, LVal lval,
	7514	static IrInstSrc ir_gen_fn_call(IrBuilderSrc irb, Scope scope, AstNode node, LVal lval,
6484	7515	ResultLoc *result_loc)
6485	7516	{
6486	7517	assert(node->type == NodeTypeFnCallExpr);
...	...	@@ -6493,16 +7524,16 @@ static IrInstruction ir_gen_fn_call(IrBuilder irb, Scope scope, AstNode node
6493	7524	nullptr, node->data.fn_call_expr.params.items, node->data.fn_call_expr.params.length, lval, result_loc);
6494	7525	}
6495	7526
6496		static IrInstruction ir_gen_if_bool_expr(IrBuilder irb, Scope scope, AstNode node, LVal lval,
	7527	static IrInstSrc ir_gen_if_bool_expr(IrBuilderSrc irb, Scope scope, AstNode node, LVal lval,
6497	7528	ResultLoc *result_loc)
6498	7529	{
6499	7530	assert(node->type == NodeTypeIfBoolExpr);
6500	7531
6501		IrInstruction *condition = ir_gen_node(irb, node->data.if_bool_expr.condition, scope);
6502		if (condition == irb->codegen->invalid_instruction)
6503		return irb->codegen->invalid_instruction;
	7532	IrInstSrc *condition = ir_gen_node(irb, node->data.if_bool_expr.condition, scope);
	7533	if (condition == irb->codegen->invalid_inst_src)
	7534	return irb->codegen->invalid_inst_src;
6504	7535
6505		IrInstruction *is_comptime;
	7536	IrInstSrc *is_comptime;
6506	7537	if (ir_should_inline(irb->exec, scope)) {
6507	7538	is_comptime = ir_build_const_bool(irb, scope, node, true);
6508	7539	} else {
...	...	@@ -6512,11 +7543,11 @@ static IrInstruction ir_gen_if_bool_expr(IrBuilder irb, Scope *scope, AstNode
6512	7543	AstNode *then_node = node->data.if_bool_expr.then_block;
6513	7544	AstNode *else_node = node->data.if_bool_expr.else_node;
6514	7545
6515		IrBasicBlock *then_block = ir_create_basic_block(irb, scope, "Then");
6516		IrBasicBlock *else_block = ir_create_basic_block(irb, scope, "Else");
6517		IrBasicBlock *endif_block = ir_create_basic_block(irb, scope, "EndIf");
	7546	IrBasicBlockSrc *then_block = ir_create_basic_block(irb, scope, "Then");
	7547	IrBasicBlockSrc *else_block = ir_create_basic_block(irb, scope, "Else");
	7548	IrBasicBlockSrc *endif_block = ir_create_basic_block(irb, scope, "EndIf");
6518	7549
6519		IrInstruction *cond_br_inst = ir_build_cond_br(irb, scope, node, condition,
	7550	IrInstSrc *cond_br_inst = ir_build_cond_br(irb, scope, node, condition,
6520	7551	then_block, else_block, is_comptime);
6521	7552	ResultLocPeerParent *peer_parent = ir_build_binary_result_peers(irb, cond_br_inst, else_block, endif_block,
6522	7553	result_loc, is_comptime);
...	...	@@ -6524,70 +7555,70 @@ static IrInstruction ir_gen_if_bool_expr(IrBuilder irb, Scope *scope, AstNode
6524	7555	ir_set_cursor_at_end_and_append_block(irb, then_block);
6525	7556
6526	7557	Scope *subexpr_scope = create_runtime_scope(irb->codegen, node, scope, is_comptime);
6527		IrInstruction *then_expr_result = ir_gen_node_extra(irb, then_node, subexpr_scope, lval,
	7558	IrInstSrc *then_expr_result = ir_gen_node_extra(irb, then_node, subexpr_scope, lval,
6528	7559	&peer_parent->peers.at(0)->base);
6529		if (then_expr_result == irb->codegen->invalid_instruction)
6530		return irb->codegen->invalid_instruction;
6531		IrBasicBlock *after_then_block = irb->current_basic_block;
	7560	if (then_expr_result == irb->codegen->invalid_inst_src)
	7561	return irb->codegen->invalid_inst_src;
	7562	IrBasicBlockSrc *after_then_block = irb->current_basic_block;
6532	7563	if (!instr_is_unreachable(then_expr_result))
6533	7564	ir_mark_gen(ir_build_br(irb, scope, node, endif_block, is_comptime));
6534	7565
6535	7566	ir_set_cursor_at_end_and_append_block(irb, else_block);
6536		IrInstruction *else_expr_result;
	7567	IrInstSrc *else_expr_result;
6537	7568	if (else_node) {
6538	7569	else_expr_result = ir_gen_node_extra(irb, else_node, subexpr_scope, lval, &peer_parent->peers.at(1)->base);
6539		if (else_expr_result == irb->codegen->invalid_instruction)
6540		return irb->codegen->invalid_instruction;
	7570	if (else_expr_result == irb->codegen->invalid_inst_src)
	7571	return irb->codegen->invalid_inst_src;
6541	7572	} else {
6542	7573	else_expr_result = ir_build_const_void(irb, scope, node);
6543	7574	ir_build_end_expr(irb, scope, node, else_expr_result, &peer_parent->peers.at(1)->base);
6544	7575	}
6545		IrBasicBlock *after_else_block = irb->current_basic_block;
	7576	IrBasicBlockSrc *after_else_block = irb->current_basic_block;
6546	7577	if (!instr_is_unreachable(else_expr_result))
6547	7578	ir_mark_gen(ir_build_br(irb, scope, node, endif_block, is_comptime));
6548	7579
6549	7580	ir_set_cursor_at_end_and_append_block(irb, endif_block);
6550		IrInstruction *incoming_values = allocate<IrInstruction >(2);
	7581	IrInstSrc *incoming_values = allocate<IrInstSrc >(2);
6551	7582	incoming_values[0] = then_expr_result;
6552	7583	incoming_values[1] = else_expr_result;
6553		IrBasicBlock *incoming_blocks = allocate<IrBasicBlock >(2, "IrBasicBlock *");
	7584	IrBasicBlockSrc *incoming_blocks = allocate<IrBasicBlockSrc >(2, "IrBasicBlockSrc *");
6554	7585	incoming_blocks[0] = after_then_block;
6555	7586	incoming_blocks[1] = after_else_block;
6556	7587
6557		IrInstruction *phi = ir_build_phi(irb, scope, node, 2, incoming_blocks, incoming_values, peer_parent);
	7588	IrInstSrc *phi = ir_build_phi(irb, scope, node, 2, incoming_blocks, incoming_values, peer_parent);
6558	7589	return ir_expr_wrap(irb, scope, phi, result_loc);
6559	7590	}
6560	7591
6561		static IrInstruction ir_gen_prefix_op_id_lval(IrBuilder irb, Scope scope, AstNode node, IrUnOp op_id, LVal lval) {
	7592	static IrInstSrc ir_gen_prefix_op_id_lval(IrBuilderSrc irb, Scope scope, AstNode node, IrUnOp op_id, LVal lval) {
6562	7593	assert(node->type == NodeTypePrefixOpExpr);
6563	7594	AstNode *expr_node = node->data.prefix_op_expr.primary_expr;
6564	7595
6565		IrInstruction *value = ir_gen_node_extra(irb, expr_node, scope, lval, nullptr);
6566		if (value == irb->codegen->invalid_instruction)
	7596	IrInstSrc *value = ir_gen_node_extra(irb, expr_node, scope, lval, nullptr);
	7597	if (value == irb->codegen->invalid_inst_src)
6567	7598	return value;
6568	7599
6569	7600	return ir_build_un_op(irb, scope, node, op_id, value);
6570	7601	}
6571	7602
6572		static IrInstruction ir_gen_prefix_op_id(IrBuilder irb, Scope scope, AstNode node, IrUnOp op_id) {
	7603	static IrInstSrc ir_gen_prefix_op_id(IrBuilderSrc irb, Scope scope, AstNode node, IrUnOp op_id) {
6573	7604	return ir_gen_prefix_op_id_lval(irb, scope, node, op_id, LValNone);
6574	7605	}
6575	7606
6576		static IrInstruction ir_expr_wrap(IrBuilder irb, Scope scope, IrInstruction inst, ResultLoc *result_loc) {
6577		if (inst == irb->codegen->invalid_instruction) return inst;
6578		ir_build_end_expr(irb, scope, inst->source_node, inst, result_loc);
	7607	static IrInstSrc ir_expr_wrap(IrBuilderSrc irb, Scope scope, IrInstSrc inst, ResultLoc *result_loc) {
	7608	if (inst == irb->codegen->invalid_inst_src) return inst;
	7609	ir_build_end_expr(irb, scope, inst->base.source_node, inst, result_loc);
6579	7610	return inst;
6580	7611	}
6581	7612
6582		static IrInstruction ir_lval_wrap(IrBuilder irb, Scope scope, IrInstruction value, LVal lval,
	7613	static IrInstSrc ir_lval_wrap(IrBuilderSrc irb, Scope scope, IrInstSrc value, LVal lval,
6583	7614	ResultLoc *result_loc)
6584	7615	{
6585	7616	// This logic must be kept in sync with
6586	7617	// [STMT_EXPR_TEST_THING] <--- (search this token)
6587		if (value == irb->codegen->invalid_instruction \|\|
	7618	if (value == irb->codegen->invalid_inst_src \|\|
6588	7619	instr_is_unreachable(value) \|\|
6589		value->source_node->type == NodeTypeDefer \|\|
6590		value->id == IrInstructionIdDeclVarSrc)
	7620	value->base.source_node->type == NodeTypeDefer \|\|
	7621	value->id == IrInstSrcIdDeclVar)
6591	7622	{
6592	7623	return value;
6593	7624	}
...	...	@@ -6595,7 +7626,7 @@ static IrInstruction ir_lval_wrap(IrBuilder irb, Scope scope, IrInstruction
6595	7626	if (lval == LValPtr) {
6596	7627	// We needed a pointer to a value, but we got a value. So we create
6597	7628	// an instruction which just makes a pointer of it.
6598		return ir_build_ref(irb, scope, value->source_node, value, false, false);
	7629	return ir_build_ref_src(irb, scope, value->base.source_node, value, false, false);
6599	7630	} else if (result_loc != nullptr) {
6600	7631	return ir_expr_wrap(irb, scope, value, result_loc);
6601	7632	} else {
...	...	@@ -6618,7 +7649,7 @@ static PtrLen star_token_to_ptr_len(TokenId token_id) {
6618	7649	}
6619	7650	}
6620	7651
6621		static IrInstruction ir_gen_pointer_type(IrBuilder irb, Scope scope, AstNode node) {
	7652	static IrInstSrc ir_gen_pointer_type(IrBuilderSrc irb, Scope scope, AstNode node) {
6622	7653	assert(node->type == NodeTypePointerType);
6623	7654
6624	7655	PtrLen ptr_len = star_token_to_ptr_len(node->data.pointer_type.star_token->id);
...	...	@@ -6630,26 +7661,26 @@ static IrInstruction ir_gen_pointer_type(IrBuilder irb, Scope *scope, AstNode
6630	7661	AstNode *expr_node = node->data.pointer_type.op_expr;
6631	7662	AstNode *align_expr = node->data.pointer_type.align_expr;
6632	7663
6633		IrInstruction *sentinel;
	7664	IrInstSrc *sentinel;
6634	7665	if (sentinel_expr != nullptr) {
6635	7666	sentinel = ir_gen_node(irb, sentinel_expr, scope);
6636		if (sentinel == irb->codegen->invalid_instruction)
	7667	if (sentinel == irb->codegen->invalid_inst_src)
6637	7668	return sentinel;
6638	7669	} else {
6639	7670	sentinel = nullptr;
6640	7671	}
6641	7672
6642		IrInstruction *align_value;
	7673	IrInstSrc *align_value;
6643	7674	if (align_expr != nullptr) {
6644	7675	align_value = ir_gen_node(irb, align_expr, scope);
6645		if (align_value == irb->codegen->invalid_instruction)
	7676	if (align_value == irb->codegen->invalid_inst_src)
6646	7677	return align_value;
6647	7678	} else {
6648	7679	align_value = nullptr;
6649	7680	}
6650	7681
6651		IrInstruction *child_type = ir_gen_node(irb, expr_node, scope);
6652		if (child_type == irb->codegen->invalid_instruction)
	7682	IrInstSrc *child_type = ir_gen_node(irb, expr_node, scope);
	7683	if (child_type == irb->codegen->invalid_inst_src)
6653	7684	return child_type;
6654	7685
6655	7686	uint32_t bit_offset_start = 0;
...	...	@@ -6659,7 +7690,7 @@ static IrInstruction ir_gen_pointer_type(IrBuilder irb, Scope *scope, AstNode
6659	7690	bigint_append_buf(val_buf, node->data.pointer_type.bit_offset_start, 10);
6660	7691	exec_add_error_node(irb->codegen, irb->exec, node,
6661	7692	buf_sprintf("value %s too large for u32 bit offset", buf_ptr(val_buf)));
6662		return irb->codegen->invalid_instruction;
	7693	return irb->codegen->invalid_inst_src;
6663	7694	}
6664	7695	bit_offset_start = bigint_as_u32(node->data.pointer_type.bit_offset_start);
6665	7696	}
...	...	@@ -6671,7 +7702,7 @@ static IrInstruction ir_gen_pointer_type(IrBuilder irb, Scope *scope, AstNode
6671	7702	bigint_append_buf(val_buf, node->data.pointer_type.host_int_bytes, 10);
6672	7703	exec_add_error_node(irb->codegen, irb->exec, node,
6673	7704	buf_sprintf("value %s too large for u32 byte count", buf_ptr(val_buf)));
6674		return irb->codegen->invalid_instruction;
	7705	return irb->codegen->invalid_inst_src;
6675	7706	}
6676	7707	host_int_bytes = bigint_as_u32(node->data.pointer_type.host_int_bytes);
6677	7708	}
...	...	@@ -6679,43 +7710,43 @@ static IrInstruction ir_gen_pointer_type(IrBuilder irb, Scope *scope, AstNode
6679	7710	if (host_int_bytes != 0 && bit_offset_start >= host_int_bytes * 8) {
6680	7711	exec_add_error_node(irb->codegen, irb->exec, node,
6681	7712	buf_sprintf("bit offset starts after end of host integer"));
6682		return irb->codegen->invalid_instruction;
	7713	return irb->codegen->invalid_inst_src;
6683	7714	}
6684	7715
6685	7716	return ir_build_ptr_type(irb, scope, node, child_type, is_const, is_volatile,
6686	7717	ptr_len, sentinel, align_value, bit_offset_start, host_int_bytes, is_allow_zero);
6687	7718	}
6688	7719
6689		static IrInstruction ir_gen_catch_unreachable(IrBuilder irb, Scope scope, AstNode source_node,
	7720	static IrInstSrc ir_gen_catch_unreachable(IrBuilderSrc irb, Scope scope, AstNode source_node,
6690	7721	AstNode expr_node, LVal lval, ResultLoc result_loc)
6691	7722	{
6692		IrInstruction *err_union_ptr = ir_gen_node_extra(irb, expr_node, scope, LValPtr, nullptr);
6693		if (err_union_ptr == irb->codegen->invalid_instruction)
6694		return irb->codegen->invalid_instruction;
	7723	IrInstSrc *err_union_ptr = ir_gen_node_extra(irb, expr_node, scope, LValPtr, nullptr);
	7724	if (err_union_ptr == irb->codegen->invalid_inst_src)
	7725	return irb->codegen->invalid_inst_src;
6695	7726
6696		IrInstruction *payload_ptr = ir_build_unwrap_err_payload(irb, scope, source_node, err_union_ptr, true, false);
6697		if (payload_ptr == irb->codegen->invalid_instruction)
6698		return irb->codegen->invalid_instruction;
	7727	IrInstSrc *payload_ptr = ir_build_unwrap_err_payload_src(irb, scope, source_node, err_union_ptr, true, false);
	7728	if (payload_ptr == irb->codegen->invalid_inst_src)
	7729	return irb->codegen->invalid_inst_src;
6699	7730
6700	7731	if (lval == LValPtr)
6701	7732	return payload_ptr;
6702	7733
6703		IrInstruction *load_ptr = ir_build_load_ptr(irb, scope, source_node, payload_ptr);
	7734	IrInstSrc *load_ptr = ir_build_load_ptr(irb, scope, source_node, payload_ptr);
6704	7735	return ir_expr_wrap(irb, scope, load_ptr, result_loc);
6705	7736	}
6706	7737
6707		static IrInstruction ir_gen_bool_not(IrBuilder irb, Scope scope, AstNode node) {
	7738	static IrInstSrc ir_gen_bool_not(IrBuilderSrc irb, Scope scope, AstNode node) {
6708	7739	assert(node->type == NodeTypePrefixOpExpr);
6709	7740	AstNode *expr_node = node->data.prefix_op_expr.primary_expr;
6710	7741
6711		IrInstruction *value = ir_gen_node(irb, expr_node, scope);
6712		if (value == irb->codegen->invalid_instruction)
6713		return irb->codegen->invalid_instruction;
	7742	IrInstSrc *value = ir_gen_node(irb, expr_node, scope);
	7743	if (value == irb->codegen->invalid_inst_src)
	7744	return irb->codegen->invalid_inst_src;
6714	7745
6715	7746	return ir_build_bool_not(irb, scope, node, value);
6716	7747	}
6717	7748
6718		static IrInstruction ir_gen_prefix_op_expr(IrBuilder irb, Scope scope, AstNode node, LVal lval,
	7749	static IrInstSrc ir_gen_prefix_op_expr(IrBuilderSrc irb, Scope scope, AstNode node, LVal lval,
6719	7750	ResultLoc *result_loc)
6720	7751	{
6721	7752	assert(node->type == NodeTypePrefixOpExpr);
...	...	@@ -6743,12 +7774,12 @@ static IrInstruction ir_gen_prefix_op_expr(IrBuilder irb, Scope *scope, AstNod
6743	7774	zig_unreachable();
6744	7775	}
6745	7776
6746		static IrInstruction ir_gen_union_init_expr(IrBuilder irb, Scope scope, AstNode source_node,
6747		IrInstruction union_type, IrInstruction field_name, AstNode *expr_node,
	7777	static IrInstSrc ir_gen_union_init_expr(IrBuilderSrc irb, Scope scope, AstNode source_node,
	7778	IrInstSrc union_type, IrInstSrc field_name, AstNode *expr_node,
6748	7779	LVal lval, ResultLoc *parent_result_loc)
6749	7780	{
6750		IrInstruction *container_ptr = ir_build_resolve_result(irb, scope, source_node, parent_result_loc, union_type);
6751		IrInstruction *field_ptr = ir_build_field_ptr_instruction(irb, scope, source_node, container_ptr,
	7781	IrInstSrc *container_ptr = ir_build_resolve_result(irb, scope, source_node, parent_result_loc, union_type);
	7782	IrInstSrc *field_ptr = ir_build_field_ptr_instruction(irb, scope, source_node, container_ptr,
6752	7783	field_name, true);
6753	7784
6754	7785	ResultLocInstruction *result_loc_inst = allocate<ResultLocInstruction>(1);
...	...	@@ -6757,18 +7788,18 @@ static IrInstruction ir_gen_union_init_expr(IrBuilder irb, Scope *scope, AstNo
6757	7788	ir_ref_instruction(field_ptr, irb->current_basic_block);
6758	7789	ir_build_reset_result(irb, scope, expr_node, &result_loc_inst->base);
6759	7790
6760		IrInstruction *expr_value = ir_gen_node_extra(irb, expr_node, scope, LValNone,
	7791	IrInstSrc *expr_value = ir_gen_node_extra(irb, expr_node, scope, LValNone,
6761	7792	&result_loc_inst->base);
6762		if (expr_value == irb->codegen->invalid_instruction)
	7793	if (expr_value == irb->codegen->invalid_inst_src)
6763	7794	return expr_value;
6764	7795
6765		IrInstruction *init_union = ir_build_union_init_named_field(irb, scope, source_node, union_type,
	7796	IrInstSrc *init_union = ir_build_union_init_named_field(irb, scope, source_node, union_type,
6766	7797	field_name, field_ptr, container_ptr);
6767	7798
6768	7799	return ir_lval_wrap(irb, scope, init_union, lval, parent_result_loc);
6769	7800	}
6770	7801
6771		static IrInstruction ir_gen_container_init_expr(IrBuilder irb, Scope scope, AstNode node, LVal lval,
	7802	static IrInstSrc ir_gen_container_init_expr(IrBuilderSrc irb, Scope scope, AstNode node, LVal lval,
6772	7803	ResultLoc *parent_result_loc)
6773	7804	{
6774	7805	assert(node->type == NodeTypeContainerInitExpr);
...	...	@@ -6780,42 +7811,42 @@ static IrInstruction ir_gen_container_init_expr(IrBuilder irb, Scope *scope, A
6780	7811	ResultLoc *child_result_loc;
6781	7812	AstNode *init_array_type_source_node;
6782	7813	if (container_init_expr->type != nullptr) {
6783		IrInstruction *container_type;
	7814	IrInstSrc *container_type;
6784	7815	if (container_init_expr->type->type == NodeTypeInferredArrayType) {
6785	7816	if (kind == ContainerInitKindStruct) {
6786	7817	add_node_error(irb->codegen, container_init_expr->type,
6787	7818	buf_sprintf("initializing array with struct syntax"));
6788		return irb->codegen->invalid_instruction;
	7819	return irb->codegen->invalid_inst_src;
6789	7820	}
6790		IrInstruction *sentinel;
	7821	IrInstSrc *sentinel;
6791	7822	if (container_init_expr->type->data.inferred_array_type.sentinel != nullptr) {
6792	7823	sentinel = ir_gen_node(irb, container_init_expr->type->data.inferred_array_type.sentinel, scope);
6793		if (sentinel == irb->codegen->invalid_instruction)
	7824	if (sentinel == irb->codegen->invalid_inst_src)
6794	7825	return sentinel;
6795	7826	} else {
6796	7827	sentinel = nullptr;
6797	7828	}
6798	7829
6799		IrInstruction *elem_type = ir_gen_node(irb,
	7830	IrInstSrc *elem_type = ir_gen_node(irb,
6800	7831	container_init_expr->type->data.inferred_array_type.child_type, scope);
6801		if (elem_type == irb->codegen->invalid_instruction)
	7832	if (elem_type == irb->codegen->invalid_inst_src)
6802	7833	return elem_type;
6803	7834	size_t item_count = container_init_expr->entries.length;
6804		IrInstruction *item_count_inst = ir_build_const_usize(irb, scope, node, item_count);
	7835	IrInstSrc *item_count_inst = ir_build_const_usize(irb, scope, node, item_count);
6805	7836	container_type = ir_build_array_type(irb, scope, node, item_count_inst, sentinel, elem_type);
6806	7837	} else {
6807	7838	container_type = ir_gen_node(irb, container_init_expr->type, scope);
6808		if (container_type == irb->codegen->invalid_instruction)
	7839	if (container_type == irb->codegen->invalid_inst_src)
6809	7840	return container_type;
6810	7841	}
6811	7842
6812	7843	result_loc_cast = ir_build_cast_result_loc(irb, container_type, parent_result_loc);
6813	7844	child_result_loc = &result_loc_cast->base;
6814		init_array_type_source_node = container_type->source_node;
	7845	init_array_type_source_node = container_type->base.source_node;
6815	7846	} else {
6816	7847	child_result_loc = parent_result_loc;
6817	7848	if (parent_result_loc->source_instruction != nullptr) {
6818		init_array_type_source_node = parent_result_loc->source_instruction->source_node;
	7849	init_array_type_source_node = parent_result_loc->source_instruction->base.source_node;
6819	7850	} else {
6820	7851	init_array_type_source_node = node;
6821	7852	}
...	...	@@ -6823,11 +7854,11 @@ static IrInstruction ir_gen_container_init_expr(IrBuilder irb, Scope *scope, A
6823	7854
6824	7855	switch (kind) {
6825	7856	case ContainerInitKindStruct: {
6826		IrInstruction *container_ptr = ir_build_resolve_result(irb, scope, node, child_result_loc,
	7857	IrInstSrc *container_ptr = ir_build_resolve_result(irb, scope, node, child_result_loc,
6827	7858	nullptr);
6828	7859
6829	7860	size_t field_count = container_init_expr->entries.length;
6830		IrInstructionContainerInitFieldsField *fields = allocate<IrInstructionContainerInitFieldsField>(field_count);
	7861	IrInstSrcContainerInitFieldsField *fields = allocate<IrInstSrcContainerInitFieldsField>(field_count);
6831	7862	for (size_t i = 0; i < field_count; i += 1) {
6832	7863	AstNode *entry_node = container_init_expr->entries.at(i);
6833	7864	assert(entry_node->type == NodeTypeStructValueField);
...	...	@@ -6835,7 +7866,7 @@ static IrInstruction ir_gen_container_init_expr(IrBuilder irb, Scope *scope, A
6835	7866	Buf *name = entry_node->data.struct_val_field.name;
6836	7867	AstNode *expr_node = entry_node->data.struct_val_field.expr;
6837	7868
6838		IrInstruction *field_ptr = ir_build_field_ptr(irb, scope, entry_node, container_ptr, name, true);
	7869	IrInstSrc *field_ptr = ir_build_field_ptr(irb, scope, entry_node, container_ptr, name, true);
6839	7870	ResultLocInstruction *result_loc_inst = allocate<ResultLocInstruction>(1);
6840	7871	result_loc_inst->base.id = ResultLocIdInstruction;
6841	7872	result_loc_inst->base.source_instruction = field_ptr;
...	...	@@ -6843,16 +7874,16 @@ static IrInstruction ir_gen_container_init_expr(IrBuilder irb, Scope *scope, A
6843	7874	ir_ref_instruction(field_ptr, irb->current_basic_block);
6844	7875	ir_build_reset_result(irb, scope, expr_node, &result_loc_inst->base);
6845	7876
6846		IrInstruction *expr_value = ir_gen_node_extra(irb, expr_node, scope, LValNone,
	7877	IrInstSrc *expr_value = ir_gen_node_extra(irb, expr_node, scope, LValNone,
6847	7878	&result_loc_inst->base);
6848		if (expr_value == irb->codegen->invalid_instruction)
	7879	if (expr_value == irb->codegen->invalid_inst_src)
6849	7880	return expr_value;
6850	7881
6851	7882	fields[i].name = name;
6852	7883	fields[i].source_node = entry_node;
6853	7884	fields[i].result_loc = field_ptr;
6854	7885	}
6855		IrInstruction *result = ir_build_container_init_fields(irb, scope, node, field_count,
	7886	IrInstSrc *result = ir_build_container_init_fields(irb, scope, node, field_count,
6856	7887	fields, container_ptr);
6857	7888
6858	7889	if (result_loc_cast != nullptr) {
...	...	@@ -6863,15 +7894,15 @@ static IrInstruction ir_gen_container_init_expr(IrBuilder irb, Scope *scope, A
6863	7894	case ContainerInitKindArray: {
6864	7895	size_t item_count = container_init_expr->entries.length;
6865	7896
6866		IrInstruction *container_ptr = ir_build_resolve_result(irb, scope, node, child_result_loc,
	7897	IrInstSrc *container_ptr = ir_build_resolve_result(irb, scope, node, child_result_loc,
6867	7898	nullptr);
6868	7899
6869		IrInstruction *result_locs = allocate<IrInstruction >(item_count);
	7900	IrInstSrc *result_locs = allocate<IrInstSrc >(item_count);
6870	7901	for (size_t i = 0; i < item_count; i += 1) {
6871	7902	AstNode *expr_node = container_init_expr->entries.at(i);
6872	7903
6873		IrInstruction *elem_index = ir_build_const_usize(irb, scope, expr_node, i);
6874		IrInstruction *elem_ptr = ir_build_elem_ptr(irb, scope, expr_node, container_ptr,
	7904	IrInstSrc *elem_index = ir_build_const_usize(irb, scope, expr_node, i);
	7905	IrInstSrc *elem_ptr = ir_build_elem_ptr(irb, scope, expr_node, container_ptr,
6875	7906	elem_index, false, PtrLenSingle, init_array_type_source_node);
6876	7907	ResultLocInstruction *result_loc_inst = allocate<ResultLocInstruction>(1);
6877	7908	result_loc_inst->base.id = ResultLocIdInstruction;
...	...	@@ -6880,14 +7911,14 @@ static IrInstruction ir_gen_container_init_expr(IrBuilder irb, Scope *scope, A
6880	7911	ir_ref_instruction(elem_ptr, irb->current_basic_block);
6881	7912	ir_build_reset_result(irb, scope, expr_node, &result_loc_inst->base);
6882	7913
6883		IrInstruction *expr_value = ir_gen_node_extra(irb, expr_node, scope, LValNone,
	7914	IrInstSrc *expr_value = ir_gen_node_extra(irb, expr_node, scope, LValNone,
6884	7915	&result_loc_inst->base);
6885		if (expr_value == irb->codegen->invalid_instruction)
	7916	if (expr_value == irb->codegen->invalid_inst_src)
6886	7917	return expr_value;
6887	7918
6888	7919	result_locs[i] = elem_ptr;
6889	7920	}
6890		IrInstruction *result = ir_build_container_init_list(irb, scope, node, item_count,
	7921	IrInstSrc *result = ir_build_container_init_list(irb, scope, node, item_count,
6891	7922	result_locs, container_ptr, init_array_type_source_node);
6892	7923	if (result_loc_cast != nullptr) {
6893	7924	result = ir_build_implicit_cast(irb, scope, node, result, result_loc_cast);
...	...	@@ -6898,19 +7929,19 @@ static IrInstruction ir_gen_container_init_expr(IrBuilder irb, Scope *scope, A
6898	7929	zig_unreachable();
6899	7930	}
6900	7931
6901		static ResultLocVar ir_build_var_result_loc(IrBuilder irb, IrInstruction alloca, ZigVar var) {
	7932	static ResultLocVar ir_build_var_result_loc(IrBuilderSrc irb, IrInstSrc alloca, ZigVar var) {
6902	7933	ResultLocVar *result_loc_var = allocate<ResultLocVar>(1);
6903	7934	result_loc_var->base.id = ResultLocIdVar;
6904	7935	result_loc_var->base.source_instruction = alloca;
6905	7936	result_loc_var->base.allow_write_through_const = true;
6906	7937	result_loc_var->var = var;
6907	7938
6908		ir_build_reset_result(irb, alloca->scope, alloca->source_node, &result_loc_var->base);
	7939	ir_build_reset_result(irb, alloca->base.scope, alloca->base.source_node, &result_loc_var->base);
6909	7940
6910	7941	return result_loc_var;
6911	7942	}
6912	7943
6913		static ResultLocCast ir_build_cast_result_loc(IrBuilder irb, IrInstruction *dest_type,
	7944	static ResultLocCast ir_build_cast_result_loc(IrBuilderSrc irb, IrInstSrc *dest_type,
6914	7945	ResultLoc *parent_result_loc)
6915	7946	{
6916	7947	ResultLocCast *result_loc_cast = allocate<ResultLocCast>(1);
...	...	@@ -6920,37 +7951,37 @@ static ResultLocCast ir_build_cast_result_loc(IrBuilder irb, IrInstruction *de
6920	7951	ir_ref_instruction(dest_type, irb->current_basic_block);
6921	7952	result_loc_cast->parent = parent_result_loc;
6922	7953
6923		ir_build_reset_result(irb, dest_type->scope, dest_type->source_node, &result_loc_cast->base);
	7954	ir_build_reset_result(irb, dest_type->base.scope, dest_type->base.source_node, &result_loc_cast->base);
6924	7955
6925	7956	return result_loc_cast;
6926	7957	}
6927	7958
6928		static void build_decl_var_and_init(IrBuilder irb, Scope scope, AstNode source_node, ZigVar var,
6929		IrInstruction init, const char name_hint, IrInstruction *is_comptime)
	7959	static void build_decl_var_and_init(IrBuilderSrc irb, Scope scope, AstNode source_node, ZigVar var,
	7960	IrInstSrc init, const char name_hint, IrInstSrc *is_comptime)
6930	7961	{
6931		IrInstruction *alloca = ir_build_alloca_src(irb, scope, source_node, nullptr, name_hint, is_comptime);
	7962	IrInstSrc *alloca = ir_build_alloca_src(irb, scope, source_node, nullptr, name_hint, is_comptime);
6932	7963	ResultLocVar *var_result_loc = ir_build_var_result_loc(irb, alloca, var);
6933	7964	ir_build_end_expr(irb, scope, source_node, init, &var_result_loc->base);
6934	7965	ir_build_var_decl_src(irb, scope, source_node, var, nullptr, alloca);
6935	7966	}
6936	7967
6937		static IrInstruction ir_gen_var_decl(IrBuilder irb, Scope scope, AstNode node) {
	7968	static IrInstSrc ir_gen_var_decl(IrBuilderSrc irb, Scope scope, AstNode node) {
6938	7969	assert(node->type == NodeTypeVariableDeclaration);
6939	7970
6940	7971	AstNodeVariableDeclaration *variable_declaration = &node->data.variable_declaration;
6941	7972
6942	7973	if (buf_eql_str(variable_declaration->symbol, "_")) {
6943	7974	add_node_error(irb->codegen, node, buf_sprintf("`_` is not a declarable symbol"));
6944		return irb->codegen->invalid_instruction;
	7975	return irb->codegen->invalid_inst_src;
6945	7976	}
6946	7977
6947	7978	// Used for the type expr and the align expr
6948	7979	Scope *comptime_scope = create_comptime_scope(irb->codegen, node, scope);
6949	7980
6950		IrInstruction *type_instruction;
	7981	IrInstSrc *type_instruction;
6951	7982	if (variable_declaration->type != nullptr) {
6952	7983	type_instruction = ir_gen_node(irb, variable_declaration->type, comptime_scope);
6953		if (type_instruction == irb->codegen->invalid_instruction)
	7984	if (type_instruction == irb->codegen->invalid_inst_src)
6954	7985	return type_instruction;
6955	7986	} else {
6956	7987	type_instruction = nullptr;
...	...	@@ -6961,22 +7992,22 @@ static IrInstruction ir_gen_var_decl(IrBuilder irb, Scope scope, AstNode nod
6961	7992	bool is_extern = variable_declaration->is_extern;
6962	7993
6963	7994	bool is_comptime_scalar = ir_should_inline(irb->exec, scope) \|\| variable_declaration->is_comptime;
6964		IrInstruction *is_comptime = ir_build_const_bool(irb, scope, node, is_comptime_scalar);
	7995	IrInstSrc *is_comptime = ir_build_const_bool(irb, scope, node, is_comptime_scalar);
6965	7996	ZigVar *var = ir_create_var(irb, node, scope, variable_declaration->symbol,
6966	7997	is_const, is_const, is_shadowable, is_comptime);
6967		// we detect IrInstructionIdDeclVarSrc in gen_block to make sure the next node
	7998	// we detect IrInstSrcDeclVar in gen_block to make sure the next node
6968	7999	// is inside var->child_scope
6969	8000
6970	8001	if (!is_extern && !variable_declaration->expr) {
6971	8002	var->var_type = irb->codegen->builtin_types.entry_invalid;
6972	8003	add_node_error(irb->codegen, node, buf_sprintf("variables must be initialized"));
6973		return irb->codegen->invalid_instruction;
	8004	return irb->codegen->invalid_inst_src;
6974	8005	}
6975	8006
6976		IrInstruction *align_value = nullptr;
	8007	IrInstSrc *align_value = nullptr;
6977	8008	if (variable_declaration->align_expr != nullptr) {
6978	8009	align_value = ir_gen_node(irb, variable_declaration->align_expr, comptime_scope);
6979		if (align_value == irb->codegen->invalid_instruction)
	8010	if (align_value == irb->codegen->invalid_inst_src)
6980	8011	return align_value;
6981	8012	}
6982	8013
...	...	@@ -6988,7 +8019,7 @@ static IrInstruction ir_gen_var_decl(IrBuilder irb, Scope scope, AstNode nod
6988	8019	// Parser should ensure that this never happens
6989	8020	assert(variable_declaration->threadlocal_tok == nullptr);
6990	8021
6991		IrInstruction *alloca = ir_build_alloca_src(irb, scope, node, align_value,
	8022	IrInstSrc *alloca = ir_build_alloca_src(irb, scope, node, align_value,
6992	8023	buf_ptr(variable_declaration->symbol), is_comptime);
6993	8024
6994	8025	// Create a result location for the initialization expression.
...	...	@@ -7006,19 +8037,19 @@ static IrInstruction ir_gen_var_decl(IrBuilder irb, Scope scope, AstNode nod
7006	8037	Scope *init_scope = is_comptime_scalar ?
7007	8038	create_comptime_scope(irb->codegen, variable_declaration->expr, scope) : scope;
7008	8039
7009		// Temporarily set the name of the IrExecutable to the VariableDeclaration
	8040	// Temporarily set the name of the IrExecutableSrc to the VariableDeclaration
7010	8041	// so that the struct or enum from the init expression inherits the name.
7011	8042	Buf *old_exec_name = irb->exec->name;
7012	8043	irb->exec->name = variable_declaration->symbol;
7013		IrInstruction *init_value = ir_gen_node_extra(irb, variable_declaration->expr, init_scope,
	8044	IrInstSrc *init_value = ir_gen_node_extra(irb, variable_declaration->expr, init_scope,
7014	8045	LValNone, init_result_loc);
7015	8046	irb->exec->name = old_exec_name;
7016	8047
7017		if (init_value == irb->codegen->invalid_instruction)
7018		return irb->codegen->invalid_instruction;
	8048	if (init_value == irb->codegen->invalid_inst_src)
	8049	return irb->codegen->invalid_inst_src;
7019	8050
7020	8051	if (result_loc_cast != nullptr) {
7021		IrInstruction *implicit_cast = ir_build_implicit_cast(irb, scope, init_value->source_node,
	8052	IrInstSrc *implicit_cast = ir_build_implicit_cast(irb, scope, init_value->base.source_node,
7022	8053	init_value, result_loc_cast);
7023	8054	ir_build_end_expr(irb, scope, node, implicit_cast, &result_loc_var->base);
7024	8055	}
...	...	@@ -7026,7 +8057,7 @@ static IrInstruction ir_gen_var_decl(IrBuilder irb, Scope scope, AstNode nod
7026	8057	return ir_build_var_decl_src(irb, scope, node, var, align_value, alloca);
7027	8058	}
7028	8059
7029		static IrInstruction ir_gen_while_expr(IrBuilder irb, Scope scope, AstNode node, LVal lval,
	8060	static IrInstSrc ir_gen_while_expr(IrBuilderSrc irb, Scope scope, AstNode node, LVal lval,
7030	8061	ResultLoc *result_loc)
7031	8062	{
7032	8063	assert(node->type == NodeTypeWhileExpr);
...	...	@@ -7034,15 +8065,15 @@ static IrInstruction ir_gen_while_expr(IrBuilder irb, Scope scope, AstNode n
7034	8065	AstNode *continue_expr_node = node->data.while_expr.continue_expr;
7035	8066	AstNode *else_node = node->data.while_expr.else_node;
7036	8067
7037		IrBasicBlock *cond_block = ir_create_basic_block(irb, scope, "WhileCond");
7038		IrBasicBlock *body_block = ir_create_basic_block(irb, scope, "WhileBody");
7039		IrBasicBlock *continue_block = continue_expr_node ?
	8068	IrBasicBlockSrc *cond_block = ir_create_basic_block(irb, scope, "WhileCond");
	8069	IrBasicBlockSrc *body_block = ir_create_basic_block(irb, scope, "WhileBody");
	8070	IrBasicBlockSrc *continue_block = continue_expr_node ?
7040	8071	ir_create_basic_block(irb, scope, "WhileContinue") : cond_block;
7041		IrBasicBlock *end_block = ir_create_basic_block(irb, scope, "WhileEnd");
7042		IrBasicBlock *else_block = else_node ?
	8072	IrBasicBlockSrc *end_block = ir_create_basic_block(irb, scope, "WhileEnd");
	8073	IrBasicBlockSrc *else_block = else_node ?
7043	8074	ir_create_basic_block(irb, scope, "WhileElse") : end_block;
7044	8075
7045		IrInstruction *is_comptime = ir_build_const_bool(irb, scope, node,
	8076	IrInstSrc *is_comptime = ir_build_const_bool(irb, scope, node,
7046	8077	ir_should_inline(irb->exec, scope) \|\| node->data.while_expr.is_inline);
7047	8078	ir_build_br(irb, scope, node, cond_block, is_comptime);
7048	8079
...	...	@@ -7063,15 +8094,15 @@ static IrInstruction ir_gen_while_expr(IrBuilder irb, Scope scope, AstNode n
7063	8094	} else {
7064	8095	payload_scope = subexpr_scope;
7065	8096	}
7066		IrInstruction *err_val_ptr = ir_gen_node_extra(irb, node->data.while_expr.condition, subexpr_scope,
	8097	IrInstSrc *err_val_ptr = ir_gen_node_extra(irb, node->data.while_expr.condition, subexpr_scope,
7067	8098	LValPtr, nullptr);
7068		if (err_val_ptr == irb->codegen->invalid_instruction)
	8099	if (err_val_ptr == irb->codegen->invalid_inst_src)
7069	8100	return err_val_ptr;
7070		IrInstruction *is_err = ir_build_test_err_src(irb, scope, node->data.while_expr.condition, err_val_ptr,
	8101	IrInstSrc *is_err = ir_build_test_err_src(irb, scope, node->data.while_expr.condition, err_val_ptr,
7071	8102	true, false);
7072		IrBasicBlock *after_cond_block = irb->current_basic_block;
7073		IrInstruction *void_else_result = else_node ? nullptr : ir_mark_gen(ir_build_const_void(irb, scope, node));
7074		IrInstruction *cond_br_inst;
	8103	IrBasicBlockSrc *after_cond_block = irb->current_basic_block;
	8104	IrInstSrc *void_else_result = else_node ? nullptr : ir_mark_gen(ir_build_const_void(irb, scope, node));
	8105	IrInstSrc *cond_br_inst;
7075	8106	if (!instr_is_unreachable(is_err)) {
7076	8107	cond_br_inst = ir_build_cond_br(irb, scope, node->data.while_expr.condition, is_err,
7077	8108	else_block, body_block, is_comptime);
...	...	@@ -7086,15 +8117,15 @@ static IrInstruction ir_gen_while_expr(IrBuilder irb, Scope scope, AstNode n
7086	8117
7087	8118	ir_set_cursor_at_end_and_append_block(irb, body_block);
7088	8119	if (var_symbol) {
7089		IrInstruction *payload_ptr = ir_build_unwrap_err_payload(irb, payload_scope, symbol_node,
	8120	IrInstSrc *payload_ptr = ir_build_unwrap_err_payload_src(irb, payload_scope, symbol_node,
7090	8121	err_val_ptr, false, false);
7091		IrInstruction *var_ptr = node->data.while_expr.var_is_ptr ?
7092		ir_build_ref(irb, payload_scope, symbol_node, payload_ptr, true, false) : payload_ptr;
	8122	IrInstSrc *var_ptr = node->data.while_expr.var_is_ptr ?
	8123	ir_build_ref_src(irb, payload_scope, symbol_node, payload_ptr, true, false) : payload_ptr;
7093	8124	ir_build_var_decl_src(irb, payload_scope, symbol_node, payload_var, nullptr, var_ptr);
7094	8125	}
7095	8126
7096		ZigList<IrInstruction *> incoming_values = {0};
7097		ZigList<IrBasicBlock *> incoming_blocks = {0};
	8127	ZigList<IrInstSrc *> incoming_values = {0};
	8128	ZigList<IrBasicBlockSrc *> incoming_blocks = {0};
7098	8129
7099	8130	ScopeLoop *loop_scope = create_loop_scope(irb->codegen, node, payload_scope);
7100	8131	loop_scope->break_block = end_block;
...	...	@@ -7108,8 +8139,8 @@ static IrInstruction ir_gen_while_expr(IrBuilder irb, Scope scope, AstNode n
7108	8139	// Note the body block of the loop is not the place that lval and result_loc are used -
7109	8140	// it's actually in break statements, handled similarly to return statements.
7110	8141	// That is why we set those values in loop_scope above and not in this ir_gen_node call.
7111		IrInstruction *body_result = ir_gen_node(irb, node->data.while_expr.body, &loop_scope->base);
7112		if (body_result == irb->codegen->invalid_instruction)
	8142	IrInstSrc *body_result = ir_gen_node(irb, node->data.while_expr.body, &loop_scope->base);
	8143	if (body_result == irb->codegen->invalid_inst_src)
7113	8144	return body_result;
7114	8145
7115	8146	if (!instr_is_unreachable(body_result)) {
...	...	@@ -7119,8 +8150,8 @@ static IrInstruction ir_gen_while_expr(IrBuilder irb, Scope scope, AstNode n
7119	8150
7120	8151	if (continue_expr_node) {
7121	8152	ir_set_cursor_at_end_and_append_block(irb, continue_block);
7122		IrInstruction *expr_result = ir_gen_node(irb, continue_expr_node, payload_scope);
7123		if (expr_result == irb->codegen->invalid_instruction)
	8153	IrInstSrc *expr_result = ir_gen_node(irb, continue_expr_node, payload_scope);
	8154	if (expr_result == irb->codegen->invalid_inst_src)
7124	8155	return expr_result;
7125	8156	if (!instr_is_unreachable(expr_result)) {
7126	8157	ir_mark_gen(ir_build_check_statement_is_void(irb, payload_scope, continue_expr_node, expr_result));
...	...	@@ -7136,7 +8167,7 @@ static IrInstruction ir_gen_while_expr(IrBuilder irb, Scope scope, AstNode n
7136	8167	ZigVar *err_var = ir_create_var(irb, err_symbol_node, scope, err_symbol,
7137	8168	true, false, false, is_comptime);
7138	8169	Scope *err_scope = err_var->child_scope;
7139		IrInstruction *err_ptr = ir_build_unwrap_err_code(irb, err_scope, err_symbol_node, err_val_ptr);
	8170	IrInstSrc *err_ptr = ir_build_unwrap_err_code_src(irb, err_scope, err_symbol_node, err_val_ptr);
7140	8171	ir_build_var_decl_src(irb, err_scope, symbol_node, err_var, nullptr, err_ptr);
7141	8172
7142	8173	if (peer_parent->peers.length != 0) {
...	...	@@ -7144,12 +8175,12 @@ static IrInstruction ir_gen_while_expr(IrBuilder irb, Scope scope, AstNode n
7144	8175	}
7145	8176	ResultLocPeer *peer_result = create_peer_result(peer_parent);
7146	8177	peer_parent->peers.append(peer_result);
7147		IrInstruction *else_result = ir_gen_node_extra(irb, else_node, err_scope, lval, &peer_result->base);
7148		if (else_result == irb->codegen->invalid_instruction)
	8178	IrInstSrc *else_result = ir_gen_node_extra(irb, else_node, err_scope, lval, &peer_result->base);
	8179	if (else_result == irb->codegen->invalid_inst_src)
7149	8180	return else_result;
7150	8181	if (!instr_is_unreachable(else_result))
7151	8182	ir_mark_gen(ir_build_br(irb, scope, node, end_block, is_comptime));
7152		IrBasicBlock *after_else_block = irb->current_basic_block;
	8183	IrBasicBlockSrc *after_else_block = irb->current_basic_block;
7153	8184	ir_set_cursor_at_end_and_append_block(irb, end_block);
7154	8185	if (else_result) {
7155	8186	incoming_blocks.append(after_else_block);
...	...	@@ -7162,7 +8193,7 @@ static IrInstruction ir_gen_while_expr(IrBuilder irb, Scope scope, AstNode n
7162	8193	peer_parent->peers.last()->next_bb = end_block;
7163	8194	}
7164	8195
7165		IrInstruction *phi = ir_build_phi(irb, scope, node, incoming_blocks.length,
	8196	IrInstSrc *phi = ir_build_phi(irb, scope, node, incoming_blocks.length,
7166	8197	incoming_blocks.items, incoming_values.items, peer_parent);
7167	8198	return ir_expr_wrap(irb, scope, phi, result_loc);
7168	8199	} else if (var_symbol != nullptr) {
...	...	@@ -7174,15 +8205,15 @@ static IrInstruction ir_gen_while_expr(IrBuilder irb, Scope scope, AstNode n
7174	8205	ZigVar *payload_var = ir_create_var(irb, symbol_node, subexpr_scope, var_symbol,
7175	8206	true, false, false, is_comptime);
7176	8207	Scope *child_scope = payload_var->child_scope;
7177		IrInstruction *maybe_val_ptr = ir_gen_node_extra(irb, node->data.while_expr.condition, subexpr_scope,
	8208	IrInstSrc *maybe_val_ptr = ir_gen_node_extra(irb, node->data.while_expr.condition, subexpr_scope,
7178	8209	LValPtr, nullptr);
7179		if (maybe_val_ptr == irb->codegen->invalid_instruction)
	8210	if (maybe_val_ptr == irb->codegen->invalid_inst_src)
7180	8211	return maybe_val_ptr;
7181		IrInstruction *maybe_val = ir_build_load_ptr(irb, scope, node->data.while_expr.condition, maybe_val_ptr);
7182		IrInstruction *is_non_null = ir_build_test_nonnull(irb, scope, node->data.while_expr.condition, maybe_val);
7183		IrBasicBlock *after_cond_block = irb->current_basic_block;
7184		IrInstruction *void_else_result = else_node ? nullptr : ir_mark_gen(ir_build_const_void(irb, scope, node));
7185		IrInstruction *cond_br_inst;
	8212	IrInstSrc *maybe_val = ir_build_load_ptr(irb, scope, node->data.while_expr.condition, maybe_val_ptr);
	8213	IrInstSrc *is_non_null = ir_build_test_non_null_src(irb, scope, node->data.while_expr.condition, maybe_val);
	8214	IrBasicBlockSrc *after_cond_block = irb->current_basic_block;
	8215	IrInstSrc *void_else_result = else_node ? nullptr : ir_mark_gen(ir_build_const_void(irb, scope, node));
	8216	IrInstSrc *cond_br_inst;
7186	8217	if (!instr_is_unreachable(is_non_null)) {
7187	8218	cond_br_inst = ir_build_cond_br(irb, scope, node->data.while_expr.condition, is_non_null,
7188	8219	body_block, else_block, is_comptime);
...	...	@@ -7196,13 +8227,13 @@ static IrInstruction ir_gen_while_expr(IrBuilder irb, Scope scope, AstNode n
7196	8227	is_comptime);
7197	8228
7198	8229	ir_set_cursor_at_end_and_append_block(irb, body_block);
7199		IrInstruction *payload_ptr = ir_build_optional_unwrap_ptr(irb, child_scope, symbol_node, maybe_val_ptr, false, false);
7200		IrInstruction *var_ptr = node->data.while_expr.var_is_ptr ?
7201		ir_build_ref(irb, child_scope, symbol_node, payload_ptr, true, false) : payload_ptr;
	8230	IrInstSrc *payload_ptr = ir_build_optional_unwrap_ptr(irb, child_scope, symbol_node, maybe_val_ptr, false, false);
	8231	IrInstSrc *var_ptr = node->data.while_expr.var_is_ptr ?
	8232	ir_build_ref_src(irb, child_scope, symbol_node, payload_ptr, true, false) : payload_ptr;
7202	8233	ir_build_var_decl_src(irb, child_scope, symbol_node, payload_var, nullptr, var_ptr);
7203	8234
7204		ZigList<IrInstruction *> incoming_values = {0};
7205		ZigList<IrBasicBlock *> incoming_blocks = {0};
	8235	ZigList<IrInstSrc *> incoming_values = {0};
	8236	ZigList<IrBasicBlockSrc *> incoming_blocks = {0};
7206	8237
7207	8238	ScopeLoop *loop_scope = create_loop_scope(irb->codegen, node, child_scope);
7208	8239	loop_scope->break_block = end_block;
...	...	@@ -7216,8 +8247,8 @@ static IrInstruction ir_gen_while_expr(IrBuilder irb, Scope scope, AstNode n
7216	8247	// Note the body block of the loop is not the place that lval and result_loc are used -
7217	8248	// it's actually in break statements, handled similarly to return statements.
7218	8249	// That is why we set those values in loop_scope above and not in this ir_gen_node call.
7219		IrInstruction *body_result = ir_gen_node(irb, node->data.while_expr.body, &loop_scope->base);
7220		if (body_result == irb->codegen->invalid_instruction)
	8250	IrInstSrc *body_result = ir_gen_node(irb, node->data.while_expr.body, &loop_scope->base);
	8251	if (body_result == irb->codegen->invalid_inst_src)
7221	8252	return body_result;
7222	8253
7223	8254	if (!instr_is_unreachable(body_result)) {
...	...	@@ -7227,8 +8258,8 @@ static IrInstruction ir_gen_while_expr(IrBuilder irb, Scope scope, AstNode n
7227	8258
7228	8259	if (continue_expr_node) {
7229	8260	ir_set_cursor_at_end_and_append_block(irb, continue_block);
7230		IrInstruction *expr_result = ir_gen_node(irb, continue_expr_node, child_scope);
7231		if (expr_result == irb->codegen->invalid_instruction)
	8261	IrInstSrc *expr_result = ir_gen_node(irb, continue_expr_node, child_scope);
	8262	if (expr_result == irb->codegen->invalid_inst_src)
7232	8263	return expr_result;
7233	8264	if (!instr_is_unreachable(expr_result)) {
7234	8265	ir_mark_gen(ir_build_check_statement_is_void(irb, child_scope, continue_expr_node, expr_result));
...	...	@@ -7236,7 +8267,7 @@ static IrInstruction ir_gen_while_expr(IrBuilder irb, Scope scope, AstNode n
7236	8267	}
7237	8268	}
7238	8269
7239		IrInstruction *else_result = nullptr;
	8270	IrInstSrc *else_result = nullptr;
7240	8271	if (else_node) {
7241	8272	ir_set_cursor_at_end_and_append_block(irb, else_block);
7242	8273
...	...	@@ -7246,12 +8277,12 @@ static IrInstruction ir_gen_while_expr(IrBuilder irb, Scope scope, AstNode n
7246	8277	ResultLocPeer *peer_result = create_peer_result(peer_parent);
7247	8278	peer_parent->peers.append(peer_result);
7248	8279	else_result = ir_gen_node_extra(irb, else_node, scope, lval, &peer_result->base);
7249		if (else_result == irb->codegen->invalid_instruction)
	8280	if (else_result == irb->codegen->invalid_inst_src)
7250	8281	return else_result;
7251	8282	if (!instr_is_unreachable(else_result))
7252	8283	ir_mark_gen(ir_build_br(irb, scope, node, end_block, is_comptime));
7253	8284	}
7254		IrBasicBlock *after_else_block = irb->current_basic_block;
	8285	IrBasicBlockSrc *after_else_block = irb->current_basic_block;
7255	8286	ir_set_cursor_at_end_and_append_block(irb, end_block);
7256	8287	if (else_result) {
7257	8288	incoming_blocks.append(after_else_block);
...	...	@@ -7264,17 +8295,17 @@ static IrInstruction ir_gen_while_expr(IrBuilder irb, Scope scope, AstNode n
7264	8295	peer_parent->peers.last()->next_bb = end_block;
7265	8296	}
7266	8297
7267		IrInstruction *phi = ir_build_phi(irb, scope, node, incoming_blocks.length,
	8298	IrInstSrc *phi = ir_build_phi(irb, scope, node, incoming_blocks.length,
7268	8299	incoming_blocks.items, incoming_values.items, peer_parent);
7269	8300	return ir_expr_wrap(irb, scope, phi, result_loc);
7270	8301	} else {
7271	8302	ir_set_cursor_at_end_and_append_block(irb, cond_block);
7272		IrInstruction *cond_val = ir_gen_node(irb, node->data.while_expr.condition, scope);
7273		if (cond_val == irb->codegen->invalid_instruction)
	8303	IrInstSrc *cond_val = ir_gen_node(irb, node->data.while_expr.condition, scope);
	8304	if (cond_val == irb->codegen->invalid_inst_src)
7274	8305	return cond_val;
7275		IrBasicBlock *after_cond_block = irb->current_basic_block;
7276		IrInstruction *void_else_result = else_node ? nullptr : ir_mark_gen(ir_build_const_void(irb, scope, node));
7277		IrInstruction *cond_br_inst;
	8306	IrBasicBlockSrc *after_cond_block = irb->current_basic_block;
	8307	IrInstSrc *void_else_result = else_node ? nullptr : ir_mark_gen(ir_build_const_void(irb, scope, node));
	8308	IrInstSrc *cond_br_inst;
7278	8309	if (!instr_is_unreachable(cond_val)) {
7279	8310	cond_br_inst = ir_build_cond_br(irb, scope, node->data.while_expr.condition, cond_val,
7280	8311	body_block, else_block, is_comptime);
...	...	@@ -7288,8 +8319,8 @@ static IrInstruction ir_gen_while_expr(IrBuilder irb, Scope scope, AstNode n
7288	8319	is_comptime);
7289	8320	ir_set_cursor_at_end_and_append_block(irb, body_block);
7290	8321
7291		ZigList<IrInstruction *> incoming_values = {0};
7292		ZigList<IrBasicBlock *> incoming_blocks = {0};
	8322	ZigList<IrInstSrc *> incoming_values = {0};
	8323	ZigList<IrBasicBlockSrc *> incoming_blocks = {0};
7293	8324
7294	8325	Scope *subexpr_scope = create_runtime_scope(irb->codegen, node, scope, is_comptime);
7295	8326
...	...	@@ -7305,8 +8336,8 @@ static IrInstruction ir_gen_while_expr(IrBuilder irb, Scope scope, AstNode n
7305	8336	// Note the body block of the loop is not the place that lval and result_loc are used -
7306	8337	// it's actually in break statements, handled similarly to return statements.
7307	8338	// That is why we set those values in loop_scope above and not in this ir_gen_node call.
7308		IrInstruction *body_result = ir_gen_node(irb, node->data.while_expr.body, &loop_scope->base);
7309		if (body_result == irb->codegen->invalid_instruction)
	8339	IrInstSrc *body_result = ir_gen_node(irb, node->data.while_expr.body, &loop_scope->base);
	8340	if (body_result == irb->codegen->invalid_inst_src)
7310	8341	return body_result;
7311	8342
7312	8343	if (!instr_is_unreachable(body_result)) {
...	...	@@ -7316,8 +8347,8 @@ static IrInstruction ir_gen_while_expr(IrBuilder irb, Scope scope, AstNode n
7316	8347
7317	8348	if (continue_expr_node) {
7318	8349	ir_set_cursor_at_end_and_append_block(irb, continue_block);
7319		IrInstruction *expr_result = ir_gen_node(irb, continue_expr_node, subexpr_scope);
7320		if (expr_result == irb->codegen->invalid_instruction)
	8350	IrInstSrc *expr_result = ir_gen_node(irb, continue_expr_node, subexpr_scope);
	8351	if (expr_result == irb->codegen->invalid_inst_src)
7321	8352	return expr_result;
7322	8353	if (!instr_is_unreachable(expr_result)) {
7323	8354	ir_mark_gen(ir_build_check_statement_is_void(irb, scope, continue_expr_node, expr_result));
...	...	@@ -7325,7 +8356,7 @@ static IrInstruction ir_gen_while_expr(IrBuilder irb, Scope scope, AstNode n
7325	8356	}
7326	8357	}
7327	8358
7328		IrInstruction *else_result = nullptr;
	8359	IrInstSrc *else_result = nullptr;
7329	8360	if (else_node) {
7330	8361	ir_set_cursor_at_end_and_append_block(irb, else_block);
7331	8362
...	...	@@ -7336,12 +8367,12 @@ static IrInstruction ir_gen_while_expr(IrBuilder irb, Scope scope, AstNode n
7336	8367	peer_parent->peers.append(peer_result);
7337	8368
7338	8369	else_result = ir_gen_node_extra(irb, else_node, subexpr_scope, lval, &peer_result->base);
7339		if (else_result == irb->codegen->invalid_instruction)
	8370	if (else_result == irb->codegen->invalid_inst_src)
7340	8371	return else_result;
7341	8372	if (!instr_is_unreachable(else_result))
7342	8373	ir_mark_gen(ir_build_br(irb, scope, node, end_block, is_comptime));
7343	8374	}
7344		IrBasicBlock *after_else_block = irb->current_basic_block;
	8375	IrBasicBlockSrc *after_else_block = irb->current_basic_block;
7345	8376	ir_set_cursor_at_end_and_append_block(irb, end_block);
7346	8377	if (else_result) {
7347	8378	incoming_blocks.append(after_else_block);
...	...	@@ -7354,13 +8385,13 @@ static IrInstruction ir_gen_while_expr(IrBuilder irb, Scope scope, AstNode n
7354	8385	peer_parent->peers.last()->next_bb = end_block;
7355	8386	}
7356	8387
7357		IrInstruction *phi = ir_build_phi(irb, scope, node, incoming_blocks.length,
	8388	IrInstSrc *phi = ir_build_phi(irb, scope, node, incoming_blocks.length,
7358	8389	incoming_blocks.items, incoming_values.items, peer_parent);
7359	8390	return ir_expr_wrap(irb, scope, phi, result_loc);
7360	8391	}
7361	8392	}
7362	8393
7363		static IrInstruction ir_gen_for_expr(IrBuilder irb, Scope parent_scope, AstNode node, LVal lval,
	8394	static IrInstSrc ir_gen_for_expr(IrBuilderSrc irb, Scope parent_scope, AstNode node, LVal lval,
7364	8395	ResultLoc *result_loc)
7365	8396	{
7366	8397	assert(node->type == NodeTypeForExpr);
...	...	@@ -7373,17 +8404,17 @@ static IrInstruction ir_gen_for_expr(IrBuilder irb, Scope *parent_scope, AstNo
7373	8404
7374	8405	if (!elem_node) {
7375	8406	add_node_error(irb->codegen, node, buf_sprintf("for loop expression missing element parameter"));
7376		return irb->codegen->invalid_instruction;
	8407	return irb->codegen->invalid_inst_src;
7377	8408	}
7378	8409	assert(elem_node->type == NodeTypeSymbol);
7379	8410
7380	8411	ScopeExpr *spill_scope = create_expr_scope(irb->codegen, node, parent_scope);
7381	8412
7382		IrInstruction *array_val_ptr = ir_gen_node_extra(irb, array_node, &spill_scope->base, LValPtr, nullptr);
7383		if (array_val_ptr == irb->codegen->invalid_instruction)
	8413	IrInstSrc *array_val_ptr = ir_gen_node_extra(irb, array_node, &spill_scope->base, LValPtr, nullptr);
	8414	if (array_val_ptr == irb->codegen->invalid_inst_src)
7384	8415	return array_val_ptr;
7385	8416
7386		IrInstruction *is_comptime = ir_build_const_bool(irb, parent_scope, node,
	8417	IrInstSrc *is_comptime = ir_build_const_bool(irb, parent_scope, node,
7387	8418	ir_should_inline(irb->exec, parent_scope) \|\| node->data.for_expr.is_inline);
7388	8419
7389	8420	AstNode *index_var_source_node;
...	...	@@ -7400,50 +8431,50 @@ static IrInstruction ir_gen_for_expr(IrBuilder irb, Scope *parent_scope, AstNo
7400	8431	index_var_name = "i";
7401	8432	}
7402	8433
7403		IrInstruction *zero = ir_build_const_usize(irb, parent_scope, node, 0);
	8434	IrInstSrc *zero = ir_build_const_usize(irb, parent_scope, node, 0);
7404	8435	build_decl_var_and_init(irb, parent_scope, index_var_source_node, index_var, zero, index_var_name, is_comptime);
7405	8436	parent_scope = index_var->child_scope;
7406	8437
7407		IrInstruction *one = ir_build_const_usize(irb, parent_scope, node, 1);
7408		IrInstruction *index_ptr = ir_build_var_ptr(irb, parent_scope, node, index_var);
	8438	IrInstSrc *one = ir_build_const_usize(irb, parent_scope, node, 1);
	8439	IrInstSrc *index_ptr = ir_build_var_ptr(irb, parent_scope, node, index_var);
7409	8440
7410	8441
7411		IrBasicBlock *cond_block = ir_create_basic_block(irb, parent_scope, "ForCond");
7412		IrBasicBlock *body_block = ir_create_basic_block(irb, parent_scope, "ForBody");
7413		IrBasicBlock *end_block = ir_create_basic_block(irb, parent_scope, "ForEnd");
7414		IrBasicBlock *else_block = else_node ? ir_create_basic_block(irb, parent_scope, "ForElse") : end_block;
7415		IrBasicBlock *continue_block = ir_create_basic_block(irb, parent_scope, "ForContinue");
	8442	IrBasicBlockSrc *cond_block = ir_create_basic_block(irb, parent_scope, "ForCond");
	8443	IrBasicBlockSrc *body_block = ir_create_basic_block(irb, parent_scope, "ForBody");
	8444	IrBasicBlockSrc *end_block = ir_create_basic_block(irb, parent_scope, "ForEnd");
	8445	IrBasicBlockSrc *else_block = else_node ? ir_create_basic_block(irb, parent_scope, "ForElse") : end_block;
	8446	IrBasicBlockSrc *continue_block = ir_create_basic_block(irb, parent_scope, "ForContinue");
7416	8447
7417	8448	Buf *len_field_name = buf_create_from_str("len");
7418		IrInstruction *len_ref = ir_build_field_ptr(irb, parent_scope, node, array_val_ptr, len_field_name, false);
7419		IrInstruction *len_val = ir_build_load_ptr(irb, &spill_scope->base, node, len_ref);
	8449	IrInstSrc *len_ref = ir_build_field_ptr(irb, parent_scope, node, array_val_ptr, len_field_name, false);
	8450	IrInstSrc *len_val = ir_build_load_ptr(irb, &spill_scope->base, node, len_ref);
7420	8451	ir_build_br(irb, parent_scope, node, cond_block, is_comptime);
7421	8452
7422	8453	ir_set_cursor_at_end_and_append_block(irb, cond_block);
7423		IrInstruction *index_val = ir_build_load_ptr(irb, &spill_scope->base, node, index_ptr);
7424		IrInstruction *cond = ir_build_bin_op(irb, parent_scope, node, IrBinOpCmpLessThan, index_val, len_val, false);
7425		IrBasicBlock *after_cond_block = irb->current_basic_block;
7426		IrInstruction *void_else_value = else_node ? nullptr : ir_mark_gen(ir_build_const_void(irb, parent_scope, node));
7427		IrInstruction *cond_br_inst = ir_mark_gen(ir_build_cond_br(irb, parent_scope, node, cond,
	8454	IrInstSrc *index_val = ir_build_load_ptr(irb, &spill_scope->base, node, index_ptr);
	8455	IrInstSrc *cond = ir_build_bin_op(irb, parent_scope, node, IrBinOpCmpLessThan, index_val, len_val, false);
	8456	IrBasicBlockSrc *after_cond_block = irb->current_basic_block;
	8457	IrInstSrc *void_else_value = else_node ? nullptr : ir_mark_gen(ir_build_const_void(irb, parent_scope, node));
	8458	IrInstSrc *cond_br_inst = ir_mark_gen(ir_build_cond_br(irb, parent_scope, node, cond,
7428	8459	body_block, else_block, is_comptime));
7429	8460
7430	8461	ResultLocPeerParent *peer_parent = ir_build_result_peers(irb, cond_br_inst, end_block, result_loc, is_comptime);
7431	8462
7432	8463	ir_set_cursor_at_end_and_append_block(irb, body_block);
7433	8464	Scope *elem_ptr_scope = node->data.for_expr.elem_is_ptr ? parent_scope : &spill_scope->base;
7434		IrInstruction *elem_ptr = ir_build_elem_ptr(irb, elem_ptr_scope, node, array_val_ptr, index_val, false,
	8465	IrInstSrc *elem_ptr = ir_build_elem_ptr(irb, elem_ptr_scope, node, array_val_ptr, index_val, false,
7435	8466	PtrLenSingle, nullptr);
7436	8467	// TODO make it an error to write to element variable or i variable.
7437	8468	Buf *elem_var_name = elem_node->data.symbol_expr.symbol;
7438	8469	ZigVar *elem_var = ir_create_var(irb, elem_node, parent_scope, elem_var_name, true, false, false, is_comptime);
7439	8470	Scope *child_scope = elem_var->child_scope;
7440	8471
7441		IrInstruction *var_ptr = node->data.for_expr.elem_is_ptr ?
7442		ir_build_ref(irb, &spill_scope->base, elem_node, elem_ptr, true, false) : elem_ptr;
	8472	IrInstSrc *var_ptr = node->data.for_expr.elem_is_ptr ?
	8473	ir_build_ref_src(irb, &spill_scope->base, elem_node, elem_ptr, true, false) : elem_ptr;
7443	8474	ir_build_var_decl_src(irb, parent_scope, elem_node, elem_var, nullptr, var_ptr);
7444	8475
7445		ZigList<IrInstruction *> incoming_values = {0};
7446		ZigList<IrBasicBlock *> incoming_blocks = {0};
	8476	ZigList<IrInstSrc *> incoming_values = {0};
	8477	ZigList<IrBasicBlockSrc *> incoming_blocks = {0};
7447	8478	ScopeLoop *loop_scope = create_loop_scope(irb->codegen, node, child_scope);
7448	8479	loop_scope->break_block = end_block;
7449	8480	loop_scope->continue_block = continue_block;
...	...	@@ -7457,9 +8488,9 @@ static IrInstruction ir_gen_for_expr(IrBuilder irb, Scope *parent_scope, AstNo
7457	8488	// Note the body block of the loop is not the place that lval and result_loc are used -
7458	8489	// it's actually in break statements, handled similarly to return statements.
7459	8490	// That is why we set those values in loop_scope above and not in this ir_gen_node call.
7460		IrInstruction *body_result = ir_gen_node(irb, body_node, &loop_scope->base);
7461		if (body_result == irb->codegen->invalid_instruction)
7462		return irb->codegen->invalid_instruction;
	8491	IrInstSrc *body_result = ir_gen_node(irb, body_node, &loop_scope->base);
	8492	if (body_result == irb->codegen->invalid_inst_src)
	8493	return irb->codegen->invalid_inst_src;
7463	8494
7464	8495	if (!instr_is_unreachable(body_result)) {
7465	8496	ir_mark_gen(ir_build_check_statement_is_void(irb, child_scope, node->data.for_expr.body, body_result));
...	...	@@ -7467,11 +8498,11 @@ static IrInstruction ir_gen_for_expr(IrBuilder irb, Scope *parent_scope, AstNo
7467	8498	}
7468	8499
7469	8500	ir_set_cursor_at_end_and_append_block(irb, continue_block);
7470		IrInstruction *new_index_val = ir_build_bin_op(irb, child_scope, node, IrBinOpAdd, index_val, one, false);
	8501	IrInstSrc *new_index_val = ir_build_bin_op(irb, child_scope, node, IrBinOpAdd, index_val, one, false);
7471	8502	ir_build_store_ptr(irb, child_scope, node, index_ptr, new_index_val)->allow_write_through_const = true;
7472	8503	ir_build_br(irb, child_scope, node, cond_block, is_comptime);
7473	8504
7474		IrInstruction *else_result = nullptr;
	8505	IrInstSrc *else_result = nullptr;
7475	8506	if (else_node) {
7476	8507	ir_set_cursor_at_end_and_append_block(irb, else_block);
7477	8508
...	...	@@ -7481,12 +8512,12 @@ static IrInstruction ir_gen_for_expr(IrBuilder irb, Scope *parent_scope, AstNo
7481	8512	ResultLocPeer *peer_result = create_peer_result(peer_parent);
7482	8513	peer_parent->peers.append(peer_result);
7483	8514	else_result = ir_gen_node_extra(irb, else_node, parent_scope, LValNone, &peer_result->base);
7484		if (else_result == irb->codegen->invalid_instruction)
	8515	if (else_result == irb->codegen->invalid_inst_src)
7485	8516	return else_result;
7486	8517	if (!instr_is_unreachable(else_result))
7487	8518	ir_mark_gen(ir_build_br(irb, parent_scope, node, end_block, is_comptime));
7488	8519	}
7489		IrBasicBlock *after_else_block = irb->current_basic_block;
	8520	IrBasicBlockSrc *after_else_block = irb->current_basic_block;
7490	8521	ir_set_cursor_at_end_and_append_block(irb, end_block);
7491	8522
7492	8523	if (else_result) {
...	...	@@ -7500,29 +8531,29 @@ static IrInstruction ir_gen_for_expr(IrBuilder irb, Scope *parent_scope, AstNo
7500	8531	peer_parent->peers.last()->next_bb = end_block;
7501	8532	}
7502	8533
7503		IrInstruction *phi = ir_build_phi(irb, parent_scope, node, incoming_blocks.length,
	8534	IrInstSrc *phi = ir_build_phi(irb, parent_scope, node, incoming_blocks.length,
7504	8535	incoming_blocks.items, incoming_values.items, peer_parent);
7505	8536	return ir_lval_wrap(irb, parent_scope, phi, lval, result_loc);
7506	8537	}
7507	8538
7508		static IrInstruction ir_gen_bool_literal(IrBuilder irb, Scope scope, AstNode node) {
	8539	static IrInstSrc ir_gen_bool_literal(IrBuilderSrc irb, Scope scope, AstNode node) {
7509	8540	assert(node->type == NodeTypeBoolLiteral);
7510	8541	return ir_build_const_bool(irb, scope, node, node->data.bool_literal.value);
7511	8542	}
7512	8543
7513		static IrInstruction ir_gen_enum_literal(IrBuilder irb, Scope scope, AstNode node) {
	8544	static IrInstSrc ir_gen_enum_literal(IrBuilderSrc irb, Scope scope, AstNode node) {
7514	8545	assert(node->type == NodeTypeEnumLiteral);
7515	8546	Buf *name = &node->data.enum_literal.identifier->data.str_lit.str;
7516	8547	return ir_build_const_enum_literal(irb, scope, node, name);
7517	8548	}
7518	8549
7519		static IrInstruction ir_gen_string_literal(IrBuilder irb, Scope scope, AstNode node) {
	8550	static IrInstSrc ir_gen_string_literal(IrBuilderSrc irb, Scope scope, AstNode node) {
7520	8551	assert(node->type == NodeTypeStringLiteral);
7521	8552
7522	8553	return ir_build_const_str_lit(irb, scope, node, node->data.string_literal.buf);
7523	8554	}
7524	8555
7525		static IrInstruction ir_gen_array_type(IrBuilder irb, Scope scope, AstNode node) {
	8556	static IrInstSrc ir_gen_array_type(IrBuilderSrc irb, Scope scope, AstNode node) {
7526	8557	assert(node->type == NodeTypeArrayType);
7527	8558
7528	8559	AstNode *size_node = node->data.array_type.size;
...	...	@@ -7535,10 +8566,10 @@ static IrInstruction ir_gen_array_type(IrBuilder irb, Scope scope, AstNode n
7535	8566
7536	8567	Scope *comptime_scope = create_comptime_scope(irb->codegen, node, scope);
7537	8568
7538		IrInstruction *sentinel;
	8569	IrInstSrc *sentinel;
7539	8570	if (sentinel_expr != nullptr) {
7540	8571	sentinel = ir_gen_node(irb, sentinel_expr, comptime_scope);
7541		if (sentinel == irb->codegen->invalid_instruction)
	8572	if (sentinel == irb->codegen->invalid_inst_src)
7542	8573	return sentinel;
7543	8574	} else {
7544	8575	sentinel = nullptr;
...	...	@@ -7547,42 +8578,42 @@ static IrInstruction ir_gen_array_type(IrBuilder irb, Scope scope, AstNode n
7547	8578	if (size_node) {
7548	8579	if (is_const) {
7549	8580	add_node_error(irb->codegen, node, buf_create_from_str("const qualifier invalid on array type"));
7550		return irb->codegen->invalid_instruction;
	8581	return irb->codegen->invalid_inst_src;
7551	8582	}
7552	8583	if (is_volatile) {
7553	8584	add_node_error(irb->codegen, node, buf_create_from_str("volatile qualifier invalid on array type"));
7554		return irb->codegen->invalid_instruction;
	8585	return irb->codegen->invalid_inst_src;
7555	8586	}
7556	8587	if (is_allow_zero) {
7557	8588	add_node_error(irb->codegen, node, buf_create_from_str("allowzero qualifier invalid on array type"));
7558		return irb->codegen->invalid_instruction;
	8589	return irb->codegen->invalid_inst_src;
7559	8590	}
7560	8591	if (align_expr != nullptr) {
7561	8592	add_node_error(irb->codegen, node, buf_create_from_str("align qualifier invalid on array type"));
7562		return irb->codegen->invalid_instruction;
	8593	return irb->codegen->invalid_inst_src;
7563	8594	}
7564	8595
7565		IrInstruction *size_value = ir_gen_node(irb, size_node, comptime_scope);
7566		if (size_value == irb->codegen->invalid_instruction)
	8596	IrInstSrc *size_value = ir_gen_node(irb, size_node, comptime_scope);
	8597	if (size_value == irb->codegen->invalid_inst_src)
7567	8598	return size_value;
7568	8599
7569		IrInstruction *child_type = ir_gen_node(irb, child_type_node, comptime_scope);
7570		if (child_type == irb->codegen->invalid_instruction)
	8600	IrInstSrc *child_type = ir_gen_node(irb, child_type_node, comptime_scope);
	8601	if (child_type == irb->codegen->invalid_inst_src)
7571	8602	return child_type;
7572	8603
7573	8604	return ir_build_array_type(irb, scope, node, size_value, sentinel, child_type);
7574	8605	} else {
7575		IrInstruction *align_value;
	8606	IrInstSrc *align_value;
7576	8607	if (align_expr != nullptr) {
7577	8608	align_value = ir_gen_node(irb, align_expr, comptime_scope);
7578		if (align_value == irb->codegen->invalid_instruction)
	8609	if (align_value == irb->codegen->invalid_inst_src)
7579	8610	return align_value;
7580	8611	} else {
7581	8612	align_value = nullptr;
7582	8613	}
7583	8614
7584		IrInstruction *child_type = ir_gen_node(irb, child_type_node, comptime_scope);
7585		if (child_type == irb->codegen->invalid_instruction)
	8615	IrInstSrc *child_type = ir_gen_node(irb, child_type_node, comptime_scope);
	8616	if (child_type == irb->codegen->invalid_inst_src)
7586	8617	return child_type;
7587	8618
7588	8619	return ir_build_slice_type(irb, scope, node, child_type, is_const, is_volatile, sentinel,
...	...	@@ -7590,15 +8621,15 @@ static IrInstruction ir_gen_array_type(IrBuilder irb, Scope scope, AstNode n
7590	8621	}
7591	8622	}
7592	8623
7593		static IrInstruction ir_gen_anyframe_type(IrBuilder irb, Scope scope, AstNode node) {
	8624	static IrInstSrc ir_gen_anyframe_type(IrBuilderSrc irb, Scope scope, AstNode node) {
7594	8625	assert(node->type == NodeTypeAnyFrameType);
7595	8626
7596	8627	AstNode *payload_type_node = node->data.anyframe_type.payload_type;
7597		IrInstruction *payload_type_value = nullptr;
	8628	IrInstSrc *payload_type_value = nullptr;
7598	8629
7599	8630	if (payload_type_node != nullptr) {
7600	8631	payload_type_value = ir_gen_node(irb, payload_type_node, scope);
7601		if (payload_type_value == irb->codegen->invalid_instruction)
	8632	if (payload_type_value == irb->codegen->invalid_inst_src)
7602	8633	return payload_type_value;
7603	8634
7604	8635	}
...	...	@@ -7606,7 +8637,7 @@ static IrInstruction ir_gen_anyframe_type(IrBuilder irb, Scope *scope, AstNode
7606	8637	return ir_build_anyframe_type(irb, scope, node, payload_type_value);
7607	8638	}
7608	8639
7609		static IrInstruction ir_gen_undefined_literal(IrBuilder irb, Scope scope, AstNode node) {
	8640	static IrInstSrc ir_gen_undefined_literal(IrBuilderSrc irb, Scope scope, AstNode node) {
7610	8641	assert(node->type == NodeTypeUndefinedLiteral);
7611	8642	return ir_build_const_undefined(irb, scope, node);
7612	8643	}
...	...	@@ -7723,13 +8754,13 @@ static size_t find_asm_index(CodeGen g, AstNode node, AsmToken tok, Buf src_
7723	8754	return SIZE_MAX;
7724	8755	}
7725	8756
7726		static IrInstruction ir_gen_asm_expr(IrBuilder irb, Scope scope, AstNode node) {
	8757	static IrInstSrc ir_gen_asm_expr(IrBuilderSrc irb, Scope scope, AstNode node) {
7727	8758	assert(node->type == NodeTypeAsmExpr);
7728	8759	AstNodeAsmExpr *asm_expr = &node->data.asm_expr;
7729	8760
7730		IrInstruction *asm_template = ir_gen_node(irb, asm_expr->asm_template, scope);
7731		if (asm_template == irb->codegen->invalid_instruction)
7732		return irb->codegen->invalid_instruction;
	8761	IrInstSrc *asm_template = ir_gen_node(irb, asm_expr->asm_template, scope);
	8762	if (asm_template == irb->codegen->invalid_inst_src)
	8763	return irb->codegen->invalid_inst_src;
7733	8764
7734	8765	bool is_volatile = asm_expr->volatile_token != nullptr;
7735	8766	bool in_fn_scope = (scope_fn_entry(scope) != nullptr);
...	...	@@ -7738,7 +8769,7 @@ static IrInstruction ir_gen_asm_expr(IrBuilder irb, Scope scope, AstNode nod
7738	8769	if (is_volatile) {
7739	8770	add_token_error(irb->codegen, node->owner, asm_expr->volatile_token,
7740	8771	buf_sprintf("volatile is meaningless on global assembly"));
7741		return irb->codegen->invalid_instruction;
	8772	return irb->codegen->invalid_inst_src;
7742	8773	}
7743	8774
7744	8775	if (asm_expr->output_list.length != 0 \|\| asm_expr->input_list.length != 0 \|\|
...	...	@@ -7746,34 +8777,34 @@ static IrInstruction ir_gen_asm_expr(IrBuilder irb, Scope scope, AstNode nod
7746	8777	{
7747	8778	add_node_error(irb->codegen, node,
7748	8779	buf_sprintf("global assembly cannot have inputs, outputs, or clobbers"));
7749		return irb->codegen->invalid_instruction;
	8780	return irb->codegen->invalid_inst_src;
7750	8781	}
7751	8782
7752	8783	return ir_build_asm_src(irb, scope, node, asm_template, nullptr, nullptr,
7753	8784	nullptr, 0, is_volatile, true);
7754	8785	}
7755	8786
7756		IrInstruction *input_list = allocate<IrInstruction >(asm_expr->input_list.length);
7757		IrInstruction *output_types = allocate<IrInstruction >(asm_expr->output_list.length);
	8787	IrInstSrc *input_list = allocate<IrInstSrc >(asm_expr->input_list.length);
	8788	IrInstSrc *output_types = allocate<IrInstSrc >(asm_expr->output_list.length);
7758	8789	ZigVar *output_vars = allocate<ZigVar >(asm_expr->output_list.length);
7759	8790	size_t return_count = 0;
7760	8791	if (!is_volatile && asm_expr->output_list.length == 0) {
7761	8792	add_node_error(irb->codegen, node,
7762	8793	buf_sprintf("assembly expression with no output must be marked volatile"));
7763		return irb->codegen->invalid_instruction;
	8794	return irb->codegen->invalid_inst_src;
7764	8795	}
7765	8796	for (size_t i = 0; i < asm_expr->output_list.length; i += 1) {
7766	8797	AsmOutput *asm_output = asm_expr->output_list.at(i);
7767	8798	if (asm_output->return_type) {
7768	8799	return_count += 1;
7769	8800
7770		IrInstruction *return_type = ir_gen_node(irb, asm_output->return_type, scope);
7771		if (return_type == irb->codegen->invalid_instruction)
7772		return irb->codegen->invalid_instruction;
	8801	IrInstSrc *return_type = ir_gen_node(irb, asm_output->return_type, scope);
	8802	if (return_type == irb->codegen->invalid_inst_src)
	8803	return irb->codegen->invalid_inst_src;
7773	8804	if (return_count > 1) {
7774	8805	add_node_error(irb->codegen, node,
7775	8806	buf_sprintf("inline assembly allows up to one output value"));
7776		return irb->codegen->invalid_instruction;
	8807	return irb->codegen->invalid_inst_src;
7777	8808	}
7778	8809	output_types[i] = return_type;
7779	8810	} else {
...	...	@@ -7786,7 +8817,7 @@ static IrInstruction ir_gen_asm_expr(IrBuilder irb, Scope scope, AstNode nod
7786	8817	} else {
7787	8818	add_node_error(irb->codegen, node,
7788	8819	buf_sprintf("use of undeclared identifier '%s'", buf_ptr(variable_name)));
7789		return irb->codegen->invalid_instruction;
	8820	return irb->codegen->invalid_inst_src;
7790	8821	}
7791	8822	}
7792	8823
...	...	@@ -7796,14 +8827,14 @@ static IrInstruction ir_gen_asm_expr(IrBuilder irb, Scope scope, AstNode nod
7796	8827	buf_sprintf("invalid modifier starting output constraint for '%s': '%c', only '=' is supported."
7797	8828	" Compiler TODO: see https://github.com/ziglang/zig/issues/215",
7798	8829	buf_ptr(asm_output->asm_symbolic_name), modifier));
7799		return irb->codegen->invalid_instruction;
	8830	return irb->codegen->invalid_inst_src;
7800	8831	}
7801	8832	}
7802	8833	for (size_t i = 0; i < asm_expr->input_list.length; i += 1) {
7803	8834	AsmInput *asm_input = asm_expr->input_list.at(i);
7804		IrInstruction *input_value = ir_gen_node(irb, asm_input->expr, scope);
7805		if (input_value == irb->codegen->invalid_instruction)
7806		return irb->codegen->invalid_instruction;
	8835	IrInstSrc *input_value = ir_gen_node(irb, asm_input->expr, scope);
	8836	if (input_value == irb->codegen->invalid_inst_src)
	8837	return irb->codegen->invalid_inst_src;
7807	8838
7808	8839	input_list[i] = input_value;
7809	8840	}
...	...	@@ -7812,7 +8843,7 @@ static IrInstruction ir_gen_asm_expr(IrBuilder irb, Scope scope, AstNode nod
7812	8843	output_vars, return_count, is_volatile, false);
7813	8844	}
7814	8845
7815		static IrInstruction ir_gen_if_optional_expr(IrBuilder irb, Scope scope, AstNode node, LVal lval,
	8846	static IrInstSrc ir_gen_if_optional_expr(IrBuilderSrc irb, Scope scope, AstNode node, LVal lval,
7816	8847	ResultLoc *result_loc)
7817	8848	{
7818	8849	assert(node->type == NodeTypeIfOptional);
...	...	@@ -7823,24 +8854,24 @@ static IrInstruction ir_gen_if_optional_expr(IrBuilder irb, Scope *scope, AstN
7823	8854	AstNode *else_node = node->data.test_expr.else_node;
7824	8855	bool var_is_ptr = node->data.test_expr.var_is_ptr;
7825	8856
7826		IrInstruction *maybe_val_ptr = ir_gen_node_extra(irb, expr_node, scope, LValPtr, nullptr);
7827		if (maybe_val_ptr == irb->codegen->invalid_instruction)
	8857	IrInstSrc *maybe_val_ptr = ir_gen_node_extra(irb, expr_node, scope, LValPtr, nullptr);
	8858	if (maybe_val_ptr == irb->codegen->invalid_inst_src)
7828	8859	return maybe_val_ptr;
7829	8860
7830		IrInstruction *maybe_val = ir_build_load_ptr(irb, scope, node, maybe_val_ptr);
7831		IrInstruction *is_non_null = ir_build_test_nonnull(irb, scope, node, maybe_val);
	8861	IrInstSrc *maybe_val = ir_build_load_ptr(irb, scope, node, maybe_val_ptr);
	8862	IrInstSrc *is_non_null = ir_build_test_non_null_src(irb, scope, node, maybe_val);
7832	8863
7833		IrBasicBlock *then_block = ir_create_basic_block(irb, scope, "OptionalThen");
7834		IrBasicBlock *else_block = ir_create_basic_block(irb, scope, "OptionalElse");
7835		IrBasicBlock *endif_block = ir_create_basic_block(irb, scope, "OptionalEndIf");
	8864	IrBasicBlockSrc *then_block = ir_create_basic_block(irb, scope, "OptionalThen");
	8865	IrBasicBlockSrc *else_block = ir_create_basic_block(irb, scope, "OptionalElse");
	8866	IrBasicBlockSrc *endif_block = ir_create_basic_block(irb, scope, "OptionalEndIf");
7836	8867
7837		IrInstruction *is_comptime;
	8868	IrInstSrc *is_comptime;
7838	8869	if (ir_should_inline(irb->exec, scope)) {
7839	8870	is_comptime = ir_build_const_bool(irb, scope, node, true);
7840	8871	} else {
7841	8872	is_comptime = ir_build_test_comptime(irb, scope, node, is_non_null);
7842	8873	}
7843		IrInstruction *cond_br_inst = ir_build_cond_br(irb, scope, node, is_non_null,
	8874	IrInstSrc *cond_br_inst = ir_build_cond_br(irb, scope, node, is_non_null,
7844	8875	then_block, else_block, is_comptime);
7845	8876
7846	8877	ResultLocPeerParent *peer_parent = ir_build_binary_result_peers(irb, cond_br_inst, else_block, endif_block,
...	...	@@ -7856,48 +8887,48 @@ static IrInstruction ir_gen_if_optional_expr(IrBuilder irb, Scope *scope, AstN
7856	8887	ZigVar *var = ir_create_var(irb, node, subexpr_scope,
7857	8888	var_symbol, is_const, is_const, is_shadowable, is_comptime);
7858	8889
7859		IrInstruction *payload_ptr = ir_build_optional_unwrap_ptr(irb, subexpr_scope, node, maybe_val_ptr, false, false);
7860		IrInstruction *var_ptr = var_is_ptr ? ir_build_ref(irb, subexpr_scope, node, payload_ptr, true, false) : payload_ptr;
	8890	IrInstSrc *payload_ptr = ir_build_optional_unwrap_ptr(irb, subexpr_scope, node, maybe_val_ptr, false, false);
	8891	IrInstSrc *var_ptr = var_is_ptr ? ir_build_ref_src(irb, subexpr_scope, node, payload_ptr, true, false) : payload_ptr;
7861	8892	ir_build_var_decl_src(irb, subexpr_scope, node, var, nullptr, var_ptr);
7862	8893	var_scope = var->child_scope;
7863	8894	} else {
7864	8895	var_scope = subexpr_scope;
7865	8896	}
7866		IrInstruction *then_expr_result = ir_gen_node_extra(irb, then_node, var_scope, lval,
	8897	IrInstSrc *then_expr_result = ir_gen_node_extra(irb, then_node, var_scope, lval,
7867	8898	&peer_parent->peers.at(0)->base);
7868		if (then_expr_result == irb->codegen->invalid_instruction)
	8899	if (then_expr_result == irb->codegen->invalid_inst_src)
7869	8900	return then_expr_result;
7870		IrBasicBlock *after_then_block = irb->current_basic_block;
	8901	IrBasicBlockSrc *after_then_block = irb->current_basic_block;
7871	8902	if (!instr_is_unreachable(then_expr_result))
7872	8903	ir_mark_gen(ir_build_br(irb, scope, node, endif_block, is_comptime));
7873	8904
7874	8905	ir_set_cursor_at_end_and_append_block(irb, else_block);
7875		IrInstruction *else_expr_result;
	8906	IrInstSrc *else_expr_result;
7876	8907	if (else_node) {
7877	8908	else_expr_result = ir_gen_node_extra(irb, else_node, subexpr_scope, lval, &peer_parent->peers.at(1)->base);
7878		if (else_expr_result == irb->codegen->invalid_instruction)
	8909	if (else_expr_result == irb->codegen->invalid_inst_src)
7879	8910	return else_expr_result;
7880	8911	} else {
7881	8912	else_expr_result = ir_build_const_void(irb, scope, node);
7882	8913	ir_build_end_expr(irb, scope, node, else_expr_result, &peer_parent->peers.at(1)->base);
7883	8914	}
7884		IrBasicBlock *after_else_block = irb->current_basic_block;
	8915	IrBasicBlockSrc *after_else_block = irb->current_basic_block;
7885	8916	if (!instr_is_unreachable(else_expr_result))
7886	8917	ir_mark_gen(ir_build_br(irb, scope, node, endif_block, is_comptime));
7887	8918
7888	8919	ir_set_cursor_at_end_and_append_block(irb, endif_block);
7889		IrInstruction *incoming_values = allocate<IrInstruction >(2);
	8920	IrInstSrc *incoming_values = allocate<IrInstSrc >(2);
7890	8921	incoming_values[0] = then_expr_result;
7891	8922	incoming_values[1] = else_expr_result;
7892		IrBasicBlock *incoming_blocks = allocate<IrBasicBlock >(2, "IrBasicBlock *");
	8923	IrBasicBlockSrc *incoming_blocks = allocate<IrBasicBlockSrc >(2, "IrBasicBlockSrc *");
7893	8924	incoming_blocks[0] = after_then_block;
7894	8925	incoming_blocks[1] = after_else_block;
7895	8926
7896		IrInstruction *phi = ir_build_phi(irb, scope, node, 2, incoming_blocks, incoming_values, peer_parent);
	8927	IrInstSrc *phi = ir_build_phi(irb, scope, node, 2, incoming_blocks, incoming_values, peer_parent);
7897	8928	return ir_expr_wrap(irb, scope, phi, result_loc);
7898	8929	}
7899	8930
7900		static IrInstruction ir_gen_if_err_expr(IrBuilder irb, Scope scope, AstNode node, LVal lval,
	8931	static IrInstSrc ir_gen_if_err_expr(IrBuilderSrc irb, Scope scope, AstNode node, LVal lval,
7901	8932	ResultLoc *result_loc)
7902	8933	{
7903	8934	assert(node->type == NodeTypeIfErrorExpr);
...	...	@@ -7910,20 +8941,20 @@ static IrInstruction ir_gen_if_err_expr(IrBuilder irb, Scope scope, AstNode
7910	8941	Buf *var_symbol = node->data.if_err_expr.var_symbol;
7911	8942	Buf *err_symbol = node->data.if_err_expr.err_symbol;
7912	8943
7913		IrInstruction *err_val_ptr = ir_gen_node_extra(irb, target_node, scope, LValPtr, nullptr);
7914		if (err_val_ptr == irb->codegen->invalid_instruction)
	8944	IrInstSrc *err_val_ptr = ir_gen_node_extra(irb, target_node, scope, LValPtr, nullptr);
	8945	if (err_val_ptr == irb->codegen->invalid_inst_src)
7915	8946	return err_val_ptr;
7916	8947
7917		IrInstruction *err_val = ir_build_load_ptr(irb, scope, node, err_val_ptr);
7918		IrInstruction *is_err = ir_build_test_err_src(irb, scope, node, err_val_ptr, true, false);
	8948	IrInstSrc *err_val = ir_build_load_ptr(irb, scope, node, err_val_ptr);
	8949	IrInstSrc *is_err = ir_build_test_err_src(irb, scope, node, err_val_ptr, true, false);
7919	8950
7920		IrBasicBlock *ok_block = ir_create_basic_block(irb, scope, "TryOk");
7921		IrBasicBlock *else_block = ir_create_basic_block(irb, scope, "TryElse");
7922		IrBasicBlock *endif_block = ir_create_basic_block(irb, scope, "TryEnd");
	8951	IrBasicBlockSrc *ok_block = ir_create_basic_block(irb, scope, "TryOk");
	8952	IrBasicBlockSrc *else_block = ir_create_basic_block(irb, scope, "TryElse");
	8953	IrBasicBlockSrc *endif_block = ir_create_basic_block(irb, scope, "TryEnd");
7923	8954
7924	8955	bool force_comptime = ir_should_inline(irb->exec, scope);
7925		IrInstruction *is_comptime = force_comptime ? ir_build_const_bool(irb, scope, node, true) : ir_build_test_comptime(irb, scope, node, is_err);
7926		IrInstruction *cond_br_inst = ir_build_cond_br(irb, scope, node, is_err, else_block, ok_block, is_comptime);
	8956	IrInstSrc *is_comptime = force_comptime ? ir_build_const_bool(irb, scope, node, true) : ir_build_test_comptime(irb, scope, node, is_err);
	8957	IrInstSrc *cond_br_inst = ir_build_cond_br(irb, scope, node, is_err, else_block, ok_block, is_comptime);
7927	8958
7928	8959	ResultLocPeerParent *peer_parent = ir_build_binary_result_peers(irb, cond_br_inst, else_block, endif_block,
7929	8960	result_loc, is_comptime);
...	...	@@ -7934,29 +8965,29 @@ static IrInstruction ir_gen_if_err_expr(IrBuilder irb, Scope scope, AstNode
7934	8965	Scope *var_scope;
7935	8966	if (var_symbol) {
7936	8967	bool is_shadowable = false;
7937		IrInstruction *var_is_comptime = force_comptime ? ir_build_const_bool(irb, subexpr_scope, node, true) : ir_build_test_comptime(irb, subexpr_scope, node, err_val);
	8968	IrInstSrc *var_is_comptime = force_comptime ? ir_build_const_bool(irb, subexpr_scope, node, true) : ir_build_test_comptime(irb, subexpr_scope, node, err_val);
7938	8969	ZigVar *var = ir_create_var(irb, node, subexpr_scope,
7939	8970	var_symbol, var_is_const, var_is_const, is_shadowable, var_is_comptime);
7940	8971
7941		IrInstruction *payload_ptr = ir_build_unwrap_err_payload(irb, subexpr_scope, node, err_val_ptr, false, false);
7942		IrInstruction *var_ptr = var_is_ptr ?
7943		ir_build_ref(irb, subexpr_scope, node, payload_ptr, true, false) : payload_ptr;
	8972	IrInstSrc *payload_ptr = ir_build_unwrap_err_payload_src(irb, subexpr_scope, node, err_val_ptr, false, false);
	8973	IrInstSrc *var_ptr = var_is_ptr ?
	8974	ir_build_ref_src(irb, subexpr_scope, node, payload_ptr, true, false) : payload_ptr;
7944	8975	ir_build_var_decl_src(irb, subexpr_scope, node, var, nullptr, var_ptr);
7945	8976	var_scope = var->child_scope;
7946	8977	} else {
7947	8978	var_scope = subexpr_scope;
7948	8979	}
7949		IrInstruction *then_expr_result = ir_gen_node_extra(irb, then_node, var_scope, lval,
	8980	IrInstSrc *then_expr_result = ir_gen_node_extra(irb, then_node, var_scope, lval,
7950	8981	&peer_parent->peers.at(0)->base);
7951		if (then_expr_result == irb->codegen->invalid_instruction)
	8982	if (then_expr_result == irb->codegen->invalid_inst_src)
7952	8983	return then_expr_result;
7953		IrBasicBlock *after_then_block = irb->current_basic_block;
	8984	IrBasicBlockSrc *after_then_block = irb->current_basic_block;
7954	8985	if (!instr_is_unreachable(then_expr_result))
7955	8986	ir_mark_gen(ir_build_br(irb, scope, node, endif_block, is_comptime));
7956	8987
7957	8988	ir_set_cursor_at_end_and_append_block(irb, else_block);
7958	8989
7959		IrInstruction *else_expr_result;
	8990	IrInstSrc *else_expr_result;
7960	8991	if (else_node) {
7961	8992	Scope *err_var_scope;
7962	8993	if (err_symbol) {
...	...	@@ -7965,40 +8996,40 @@ static IrInstruction ir_gen_if_err_expr(IrBuilder irb, Scope scope, AstNode
7965	8996	ZigVar *var = ir_create_var(irb, node, subexpr_scope,
7966	8997	err_symbol, is_const, is_const, is_shadowable, is_comptime);
7967	8998
7968		IrInstruction *err_ptr = ir_build_unwrap_err_code(irb, subexpr_scope, node, err_val_ptr);
	8999	IrInstSrc *err_ptr = ir_build_unwrap_err_code_src(irb, subexpr_scope, node, err_val_ptr);
7969	9000	ir_build_var_decl_src(irb, subexpr_scope, node, var, nullptr, err_ptr);
7970	9001	err_var_scope = var->child_scope;
7971	9002	} else {
7972	9003	err_var_scope = subexpr_scope;
7973	9004	}
7974	9005	else_expr_result = ir_gen_node_extra(irb, else_node, err_var_scope, lval, &peer_parent->peers.at(1)->base);
7975		if (else_expr_result == irb->codegen->invalid_instruction)
	9006	if (else_expr_result == irb->codegen->invalid_inst_src)
7976	9007	return else_expr_result;
7977	9008	} else {
7978	9009	else_expr_result = ir_build_const_void(irb, scope, node);
7979	9010	ir_build_end_expr(irb, scope, node, else_expr_result, &peer_parent->peers.at(1)->base);
7980	9011	}
7981		IrBasicBlock *after_else_block = irb->current_basic_block;
	9012	IrBasicBlockSrc *after_else_block = irb->current_basic_block;
7982	9013	if (!instr_is_unreachable(else_expr_result))
7983	9014	ir_mark_gen(ir_build_br(irb, scope, node, endif_block, is_comptime));
7984	9015
7985	9016	ir_set_cursor_at_end_and_append_block(irb, endif_block);
7986		IrInstruction *incoming_values = allocate<IrInstruction >(2);
	9017	IrInstSrc *incoming_values = allocate<IrInstSrc >(2);
7987	9018	incoming_values[0] = then_expr_result;
7988	9019	incoming_values[1] = else_expr_result;
7989		IrBasicBlock *incoming_blocks = allocate<IrBasicBlock >(2, "IrBasicBlock *");
	9020	IrBasicBlockSrc *incoming_blocks = allocate<IrBasicBlockSrc >(2, "IrBasicBlockSrc *");
7990	9021	incoming_blocks[0] = after_then_block;
7991	9022	incoming_blocks[1] = after_else_block;
7992	9023
7993		IrInstruction *phi = ir_build_phi(irb, scope, node, 2, incoming_blocks, incoming_values, peer_parent);
	9024	IrInstSrc *phi = ir_build_phi(irb, scope, node, 2, incoming_blocks, incoming_values, peer_parent);
7994	9025	return ir_expr_wrap(irb, scope, phi, result_loc);
7995	9026	}
7996	9027
7997		static bool ir_gen_switch_prong_expr(IrBuilder irb, Scope scope, AstNode switch_node, AstNode prong_node,
7998		IrBasicBlock end_block, IrInstruction is_comptime, IrInstruction *var_is_comptime,
7999		IrInstruction target_value_ptr, IrInstruction *prong_values, size_t prong_values_len,
8000		ZigList<IrBasicBlock > incoming_blocks, ZigList<IrInstruction > incoming_values,
8001		IrInstructionSwitchElseVar *out_switch_else_var, LVal lval, ResultLoc result_loc)
	9028	static bool ir_gen_switch_prong_expr(IrBuilderSrc irb, Scope scope, AstNode switch_node, AstNode prong_node,
	9029	IrBasicBlockSrc end_block, IrInstSrc is_comptime, IrInstSrc *var_is_comptime,
	9030	IrInstSrc target_value_ptr, IrInstSrc *prong_values, size_t prong_values_len,
	9031	ZigList<IrBasicBlockSrc > incoming_blocks, ZigList<IrInstSrc > incoming_values,
	9032	IrInstSrcSwitchElseVar *out_switch_else_var, LVal lval, ResultLoc result_loc)
8002	9033	{
8003	9034	assert(switch_node->type == NodeTypeSwitchExpr);
8004	9035	assert(prong_node->type == NodeTypeSwitchProng);
...	...	@@ -8016,28 +9047,28 @@ static bool ir_gen_switch_prong_expr(IrBuilder irb, Scope scope, AstNode *swit
8016	9047	ZigVar *var = ir_create_var(irb, var_symbol_node, scope,
8017	9048	var_name, is_const, is_const, is_shadowable, var_is_comptime);
8018	9049	child_scope = var->child_scope;
8019		IrInstruction *var_ptr;
	9050	IrInstSrc *var_ptr;
8020	9051	if (out_switch_else_var != nullptr) {
8021		IrInstructionSwitchElseVar *switch_else_var = ir_build_switch_else_var(irb, scope, var_symbol_node,
	9052	IrInstSrcSwitchElseVar *switch_else_var = ir_build_switch_else_var(irb, scope, var_symbol_node,
8022	9053	target_value_ptr);
8023	9054	*out_switch_else_var = switch_else_var;
8024		IrInstruction *payload_ptr = &switch_else_var->base;
8025		var_ptr = var_is_ptr ? ir_build_ref(irb, scope, var_symbol_node, payload_ptr, true, false) : payload_ptr;
	9055	IrInstSrc *payload_ptr = &switch_else_var->base;
	9056	var_ptr = var_is_ptr ? ir_build_ref_src(irb, scope, var_symbol_node, payload_ptr, true, false) : payload_ptr;
8026	9057	} else if (prong_values != nullptr) {
8027		IrInstruction *payload_ptr = ir_build_switch_var(irb, scope, var_symbol_node, target_value_ptr,
	9058	IrInstSrc *payload_ptr = ir_build_switch_var(irb, scope, var_symbol_node, target_value_ptr,
8028	9059	prong_values, prong_values_len);
8029		var_ptr = var_is_ptr ? ir_build_ref(irb, scope, var_symbol_node, payload_ptr, true, false) : payload_ptr;
	9060	var_ptr = var_is_ptr ? ir_build_ref_src(irb, scope, var_symbol_node, payload_ptr, true, false) : payload_ptr;
8030	9061	} else {
8031	9062	var_ptr = var_is_ptr ?
8032		ir_build_ref(irb, scope, var_symbol_node, target_value_ptr, true, false) : target_value_ptr;
	9063	ir_build_ref_src(irb, scope, var_symbol_node, target_value_ptr, true, false) : target_value_ptr;
8033	9064	}
8034	9065	ir_build_var_decl_src(irb, scope, var_symbol_node, var, nullptr, var_ptr);
8035	9066	} else {
8036	9067	child_scope = scope;
8037	9068	}
8038	9069
8039		IrInstruction *expr_result = ir_gen_node_extra(irb, expr_node, child_scope, lval, result_loc);
8040		if (expr_result == irb->codegen->invalid_instruction)
	9070	IrInstSrc *expr_result = ir_gen_node_extra(irb, expr_node, child_scope, lval, result_loc);
	9071	if (expr_result == irb->codegen->invalid_inst_src)
8041	9072	return false;
8042	9073	if (!instr_is_unreachable(expr_result))
8043	9074	ir_mark_gen(ir_build_br(irb, scope, switch_node, end_block, is_comptime));
...	...	@@ -8046,25 +9077,25 @@ static bool ir_gen_switch_prong_expr(IrBuilder irb, Scope scope, AstNode *swit
8046	9077	return true;
8047	9078	}
8048	9079
8049		static IrInstruction ir_gen_switch_expr(IrBuilder irb, Scope scope, AstNode node, LVal lval,
	9080	static IrInstSrc ir_gen_switch_expr(IrBuilderSrc irb, Scope scope, AstNode node, LVal lval,
8050	9081	ResultLoc *result_loc)
8051	9082	{
8052	9083	assert(node->type == NodeTypeSwitchExpr);
8053	9084
8054	9085	AstNode *target_node = node->data.switch_expr.expr;
8055		IrInstruction *target_value_ptr = ir_gen_node_extra(irb, target_node, scope, LValPtr, nullptr);
8056		if (target_value_ptr == irb->codegen->invalid_instruction)
	9086	IrInstSrc *target_value_ptr = ir_gen_node_extra(irb, target_node, scope, LValPtr, nullptr);
	9087	if (target_value_ptr == irb->codegen->invalid_inst_src)
8057	9088	return target_value_ptr;
8058		IrInstruction *target_value = ir_build_switch_target(irb, scope, node, target_value_ptr);
	9089	IrInstSrc *target_value = ir_build_switch_target(irb, scope, node, target_value_ptr);
8059	9090
8060		IrBasicBlock *else_block = ir_create_basic_block(irb, scope, "SwitchElse");
8061		IrBasicBlock *end_block = ir_create_basic_block(irb, scope, "SwitchEnd");
	9091	IrBasicBlockSrc *else_block = ir_create_basic_block(irb, scope, "SwitchElse");
	9092	IrBasicBlockSrc *end_block = ir_create_basic_block(irb, scope, "SwitchEnd");
8062	9093
8063	9094	size_t prong_count = node->data.switch_expr.prongs.length;
8064		ZigList<IrInstructionSwitchBrCase> cases = {0};
	9095	ZigList<IrInstSrcSwitchBrCase> cases = {0};
8065	9096
8066		IrInstruction *is_comptime;
8067		IrInstruction *var_is_comptime;
	9097	IrInstSrc *is_comptime;
	9098	IrInstSrc *var_is_comptime;
8068	9099	if (ir_should_inline(irb->exec, scope)) {
8069	9100	is_comptime = ir_build_const_bool(irb, scope, node, true);
8070	9101	var_is_comptime = is_comptime;
...	...	@@ -8073,11 +9104,11 @@ static IrInstruction ir_gen_switch_expr(IrBuilder irb, Scope scope, AstNode
8073	9104	var_is_comptime = ir_build_test_comptime(irb, scope, node, target_value_ptr);
8074	9105	}
8075	9106
8076		ZigList<IrInstruction *> incoming_values = {0};
8077		ZigList<IrBasicBlock *> incoming_blocks = {0};
8078		ZigList<IrInstructionCheckSwitchProngsRange> check_ranges = {0};
	9107	ZigList<IrInstSrc *> incoming_values = {0};
	9108	ZigList<IrBasicBlockSrc *> incoming_blocks = {0};
	9109	ZigList<IrInstSrcCheckSwitchProngsRange> check_ranges = {0};
8079	9110
8080		IrInstructionSwitchElseVar *switch_else_var = nullptr;
	9111	IrInstSrcSwitchElseVar *switch_else_var = nullptr;
8081	9112
8082	9113	ResultLocPeerParent *peer_parent = allocate<ResultLocPeerParent>(1);
8083	9114	peer_parent->base.id = ResultLocIdPeerParent;
...	...	@@ -8099,7 +9130,7 @@ static IrInstruction ir_gen_switch_expr(IrBuilder irb, Scope scope, AstNode
8099	9130	if (prong_node->data.switch_prong.any_items_are_range) {
8100	9131	ResultLocPeer *this_peer_result_loc = create_peer_result(peer_parent);
8101	9132
8102		IrInstruction *ok_bit = nullptr;
	9133	IrInstSrc *ok_bit = nullptr;
8103	9134	AstNode *last_item_node = nullptr;
8104	9135	for (size_t item_i = 0; item_i < prong_item_count; item_i += 1) {
8105	9136	AstNode *item_node = prong_node->data.switch_prong.items.at(item_i);
...	...	@@ -8108,23 +9139,23 @@ static IrInstruction ir_gen_switch_expr(IrBuilder irb, Scope scope, AstNode
8108	9139	AstNode *start_node = item_node->data.switch_range.start;
8109	9140	AstNode *end_node = item_node->data.switch_range.end;
8110	9141
8111		IrInstruction *start_value = ir_gen_node(irb, start_node, comptime_scope);
8112		if (start_value == irb->codegen->invalid_instruction)
8113		return irb->codegen->invalid_instruction;
	9142	IrInstSrc *start_value = ir_gen_node(irb, start_node, comptime_scope);
	9143	if (start_value == irb->codegen->invalid_inst_src)
	9144	return irb->codegen->invalid_inst_src;
8114	9145
8115		IrInstruction *end_value = ir_gen_node(irb, end_node, comptime_scope);
8116		if (end_value == irb->codegen->invalid_instruction)
8117		return irb->codegen->invalid_instruction;
	9146	IrInstSrc *end_value = ir_gen_node(irb, end_node, comptime_scope);
	9147	if (end_value == irb->codegen->invalid_inst_src)
	9148	return irb->codegen->invalid_inst_src;
8118	9149
8119		IrInstructionCheckSwitchProngsRange *check_range = check_ranges.add_one();
	9150	IrInstSrcCheckSwitchProngsRange *check_range = check_ranges.add_one();
8120	9151	check_range->start = start_value;
8121	9152	check_range->end = end_value;
8122	9153
8123		IrInstruction *lower_range_ok = ir_build_bin_op(irb, scope, item_node, IrBinOpCmpGreaterOrEq,
	9154	IrInstSrc *lower_range_ok = ir_build_bin_op(irb, scope, item_node, IrBinOpCmpGreaterOrEq,
8124	9155	target_value, start_value, false);
8125		IrInstruction *upper_range_ok = ir_build_bin_op(irb, scope, item_node, IrBinOpCmpLessOrEq,
	9156	IrInstSrc *upper_range_ok = ir_build_bin_op(irb, scope, item_node, IrBinOpCmpLessOrEq,
8126	9157	target_value, end_value, false);
8127		IrInstruction *both_ok = ir_build_bin_op(irb, scope, item_node, IrBinOpBoolAnd,
	9158	IrInstSrc *both_ok = ir_build_bin_op(irb, scope, item_node, IrBinOpBoolAnd,
8128	9159	lower_range_ok, upper_range_ok, false);
8129	9160	if (ok_bit) {
8130	9161	ok_bit = ir_build_bin_op(irb, scope, item_node, IrBinOpBoolOr, both_ok, ok_bit, false);
...	...	@@ -8132,15 +9163,15 @@ static IrInstruction ir_gen_switch_expr(IrBuilder irb, Scope scope, AstNode
8132	9163	ok_bit = both_ok;
8133	9164	}
8134	9165	} else {
8135		IrInstruction *item_value = ir_gen_node(irb, item_node, comptime_scope);
8136		if (item_value == irb->codegen->invalid_instruction)
8137		return irb->codegen->invalid_instruction;
	9166	IrInstSrc *item_value = ir_gen_node(irb, item_node, comptime_scope);
	9167	if (item_value == irb->codegen->invalid_inst_src)
	9168	return irb->codegen->invalid_inst_src;
8138	9169
8139		IrInstructionCheckSwitchProngsRange *check_range = check_ranges.add_one();
	9170	IrInstSrcCheckSwitchProngsRange *check_range = check_ranges.add_one();
8140	9171	check_range->start = item_value;
8141	9172	check_range->end = item_value;
8142	9173
8143		IrInstruction *cmp_ok = ir_build_bin_op(irb, scope, item_node, IrBinOpCmpEq,
	9174	IrInstSrc *cmp_ok = ir_build_bin_op(irb, scope, item_node, IrBinOpCmpEq,
8144	9175	item_value, target_value, false);
8145	9176	if (ok_bit) {
8146	9177	ok_bit = ir_build_bin_op(irb, scope, item_node, IrBinOpBoolOr, cmp_ok, ok_bit, false);
...	...	@@ -8150,12 +9181,12 @@ static IrInstruction ir_gen_switch_expr(IrBuilder irb, Scope scope, AstNode
8150	9181	}
8151	9182	}
8152	9183
8153		IrBasicBlock *range_block_yes = ir_create_basic_block(irb, scope, "SwitchRangeYes");
8154		IrBasicBlock *range_block_no = ir_create_basic_block(irb, scope, "SwitchRangeNo");
	9184	IrBasicBlockSrc *range_block_yes = ir_create_basic_block(irb, scope, "SwitchRangeYes");
	9185	IrBasicBlockSrc *range_block_no = ir_create_basic_block(irb, scope, "SwitchRangeNo");
8155	9186
8156	9187	assert(ok_bit);
8157	9188	assert(last_item_node);
8158		IrInstruction *br_inst = ir_mark_gen(ir_build_cond_br(irb, scope, last_item_node, ok_bit,
	9189	IrInstSrc *br_inst = ir_mark_gen(ir_build_cond_br(irb, scope, last_item_node, ok_bit,
8159	9190	range_block_yes, range_block_no, is_comptime));
8160	9191	if (peer_parent->base.source_instruction == nullptr) {
8161	9192	peer_parent->base.source_instruction = br_inst;
...	...	@@ -8170,7 +9201,7 @@ static IrInstruction ir_gen_switch_expr(IrBuilder irb, Scope scope, AstNode
8170	9201	is_comptime, var_is_comptime, target_value_ptr, nullptr, 0,
8171	9202	&incoming_blocks, &incoming_values, nullptr, LValNone, &this_peer_result_loc->base))
8172	9203	{
8173		return irb->codegen->invalid_instruction;
	9204	return irb->codegen->invalid_inst_src;
8174	9205	}
8175	9206
8176	9207	ir_set_cursor_at_end_and_append_block(irb, range_block_no);
...	...	@@ -8181,7 +9212,7 @@ static IrInstruction ir_gen_switch_expr(IrBuilder irb, Scope scope, AstNode
8181	9212	buf_sprintf("multiple else prongs in switch expression"));
8182	9213	add_error_note(irb->codegen, msg, else_prong,
8183	9214	buf_sprintf("previous else prong is here"));
8184		return irb->codegen->invalid_instruction;
	9215	return irb->codegen->invalid_inst_src;
8185	9216	}
8186	9217	else_prong = prong_node;
8187	9218	} else if (prong_item_count == 1 &&
...	...	@@ -8192,7 +9223,7 @@ static IrInstruction ir_gen_switch_expr(IrBuilder irb, Scope scope, AstNode
8192	9223	buf_sprintf("multiple '_' prongs in switch expression"));
8193	9224	add_error_note(irb->codegen, msg, underscore_prong,
8194	9225	buf_sprintf("previous '_' prong is here"));
8195		return irb->codegen->invalid_instruction;
	9226	return irb->codegen->invalid_inst_src;
8196	9227	}
8197	9228	underscore_prong = prong_node;
8198	9229	} else {
...	...	@@ -8207,11 +9238,11 @@ static IrInstruction ir_gen_switch_expr(IrBuilder irb, Scope scope, AstNode
8207	9238	else
8208	9239	add_error_note(irb->codegen, msg, underscore_prong,
8209	9240	buf_sprintf("'_' prong is here"));
8210		return irb->codegen->invalid_instruction;
	9241	return irb->codegen->invalid_inst_src;
8211	9242	}
8212	9243	ResultLocPeer *this_peer_result_loc = create_peer_result(peer_parent);
8213	9244
8214		IrBasicBlock *prev_block = irb->current_basic_block;
	9245	IrBasicBlockSrc *prev_block = irb->current_basic_block;
8215	9246	if (peer_parent->peers.length > 0) {
8216	9247	peer_parent->peers.last()->next_bb = else_block;
8217	9248	}
...	...	@@ -8221,7 +9252,7 @@ static IrInstruction ir_gen_switch_expr(IrBuilder irb, Scope scope, AstNode
8221	9252	is_comptime, var_is_comptime, target_value_ptr, nullptr, 0, &incoming_blocks, &incoming_values,
8222	9253	&switch_else_var, LValNone, &this_peer_result_loc->base))
8223	9254	{
8224		return irb->codegen->invalid_instruction;
	9255	return irb->codegen->invalid_inst_src;
8225	9256	}
8226	9257	ir_set_cursor_at_end(irb, prev_block);
8227	9258	}
...	...	@@ -8240,29 +9271,29 @@ static IrInstruction ir_gen_switch_expr(IrBuilder irb, Scope scope, AstNode
8240	9271
8241	9272	ResultLocPeer *this_peer_result_loc = create_peer_result(peer_parent);
8242	9273
8243		IrBasicBlock *prong_block = ir_create_basic_block(irb, scope, "SwitchProng");
8244		IrInstruction *items = allocate<IrInstruction >(prong_item_count);
	9274	IrBasicBlockSrc *prong_block = ir_create_basic_block(irb, scope, "SwitchProng");
	9275	IrInstSrc *items = allocate<IrInstSrc >(prong_item_count);
8245	9276
8246	9277	for (size_t item_i = 0; item_i < prong_item_count; item_i += 1) {
8247	9278	AstNode *item_node = prong_node->data.switch_prong.items.at(item_i);
8248	9279	assert(item_node->type != NodeTypeSwitchRange);
8249	9280
8250		IrInstruction *item_value = ir_gen_node(irb, item_node, comptime_scope);
8251		if (item_value == irb->codegen->invalid_instruction)
8252		return irb->codegen->invalid_instruction;
	9281	IrInstSrc *item_value = ir_gen_node(irb, item_node, comptime_scope);
	9282	if (item_value == irb->codegen->invalid_inst_src)
	9283	return irb->codegen->invalid_inst_src;
8253	9284
8254		IrInstructionCheckSwitchProngsRange *check_range = check_ranges.add_one();
	9285	IrInstSrcCheckSwitchProngsRange *check_range = check_ranges.add_one();
8255	9286	check_range->start = item_value;
8256	9287	check_range->end = item_value;
8257	9288
8258		IrInstructionSwitchBrCase *this_case = cases.add_one();
	9289	IrInstSrcSwitchBrCase *this_case = cases.add_one();
8259	9290	this_case->value = item_value;
8260	9291	this_case->block = prong_block;
8261	9292
8262	9293	items[item_i] = item_value;
8263	9294	}
8264	9295
8265		IrBasicBlock *prev_block = irb->current_basic_block;
	9296	IrBasicBlockSrc *prev_block = irb->current_basic_block;
8266	9297	if (peer_parent->peers.length > 0) {
8267	9298	peer_parent->peers.last()->next_bb = prong_block;
8268	9299	}
...	...	@@ -8272,21 +9303,21 @@ static IrInstruction ir_gen_switch_expr(IrBuilder irb, Scope scope, AstNode
8272	9303	is_comptime, var_is_comptime, target_value_ptr, items, prong_item_count,
8273	9304	&incoming_blocks, &incoming_values, nullptr, LValNone, &this_peer_result_loc->base))
8274	9305	{
8275		return irb->codegen->invalid_instruction;
	9306	return irb->codegen->invalid_inst_src;
8276	9307	}
8277	9308
8278	9309	ir_set_cursor_at_end(irb, prev_block);
8279	9310
8280	9311	}
8281	9312
8282		IrInstruction *switch_prongs_void = ir_build_check_switch_prongs(irb, scope, node, target_value,
	9313	IrInstSrc *switch_prongs_void = ir_build_check_switch_prongs(irb, scope, node, target_value,
8283	9314	check_ranges.items, check_ranges.length, else_prong != nullptr, underscore_prong != nullptr);
8284	9315
8285		IrInstruction *br_instruction;
	9316	IrInstSrc *br_instruction;
8286	9317	if (cases.length == 0) {
8287	9318	br_instruction = ir_build_br(irb, scope, node, else_block, is_comptime);
8288	9319	} else {
8289		IrInstructionSwitchBr *switch_br = ir_build_switch_br(irb, scope, node, target_value, else_block,
	9320	IrInstSrcSwitchBr *switch_br = ir_build_switch_br_src(irb, scope, node, target_value, else_block,
8290	9321	cases.length, cases.items, is_comptime, switch_prongs_void);
8291	9322	if (switch_else_var != nullptr) {
8292	9323	switch_else_var->switch_br = switch_br;
...	...	@@ -8314,7 +9345,7 @@ static IrInstruction ir_gen_switch_expr(IrBuilder irb, Scope scope, AstNode
8314	9345
8315	9346	ir_set_cursor_at_end_and_append_block(irb, end_block);
8316	9347	assert(incoming_blocks.length == incoming_values.length);
8317		IrInstruction *result_instruction;
	9348	IrInstSrc *result_instruction;
8318	9349	if (incoming_blocks.length == 0) {
8319	9350	result_instruction = ir_build_const_void(irb, scope, node);
8320	9351	} else {
...	...	@@ -8324,7 +9355,7 @@ static IrInstruction ir_gen_switch_expr(IrBuilder irb, Scope scope, AstNode
8324	9355	return ir_lval_wrap(irb, scope, result_instruction, lval, result_loc);
8325	9356	}
8326	9357
8327		static IrInstruction ir_gen_comptime(IrBuilder irb, Scope parent_scope, AstNode node, LVal lval) {
	9358	static IrInstSrc ir_gen_comptime(IrBuilderSrc irb, Scope parent_scope, AstNode node, LVal lval) {
8328	9359	assert(node->type == NodeTypeCompTime);
8329	9360
8330	9361	Scope *child_scope = create_comptime_scope(irb->codegen, node, parent_scope);
...	...	@@ -8332,28 +9363,28 @@ static IrInstruction ir_gen_comptime(IrBuilder irb, Scope *parent_scope, AstNo
8332	9363	return ir_gen_node_extra(irb, node->data.comptime_expr.expr, child_scope, lval, nullptr);
8333	9364	}
8334	9365
8335		static IrInstruction ir_gen_return_from_block(IrBuilder irb, Scope break_scope, AstNode node, ScopeBlock *block_scope) {
8336		IrInstruction *is_comptime;
	9366	static IrInstSrc ir_gen_return_from_block(IrBuilderSrc irb, Scope break_scope, AstNode node, ScopeBlock *block_scope) {
	9367	IrInstSrc *is_comptime;
8337	9368	if (ir_should_inline(irb->exec, break_scope)) {
8338	9369	is_comptime = ir_build_const_bool(irb, break_scope, node, true);
8339	9370	} else {
8340	9371	is_comptime = block_scope->is_comptime;
8341	9372	}
8342	9373
8343		IrInstruction *result_value;
	9374	IrInstSrc *result_value;
8344	9375	if (node->data.break_expr.expr) {
8345	9376	ResultLocPeer *peer_result = create_peer_result(block_scope->peer_parent);
8346	9377	block_scope->peer_parent->peers.append(peer_result);
8347	9378
8348	9379	result_value = ir_gen_node_extra(irb, node->data.break_expr.expr, break_scope, block_scope->lval,
8349	9380	&peer_result->base);
8350		if (result_value == irb->codegen->invalid_instruction)
8351		return irb->codegen->invalid_instruction;
	9381	if (result_value == irb->codegen->invalid_inst_src)
	9382	return irb->codegen->invalid_inst_src;
8352	9383	} else {
8353	9384	result_value = ir_build_const_void(irb, break_scope, node);
8354	9385	}
8355	9386
8356		IrBasicBlock *dest_block = block_scope->end_block;
	9387	IrBasicBlockSrc *dest_block = block_scope->end_block;
8357	9388	ir_gen_defers_for_block(irb, break_scope, dest_block->scope, false);
8358	9389
8359	9390	block_scope->incoming_blocks->append(irb->current_basic_block);
...	...	@@ -8361,7 +9392,7 @@ static IrInstruction ir_gen_return_from_block(IrBuilder irb, Scope *break_scop
8361	9392	return ir_build_br(irb, break_scope, node, dest_block, is_comptime);
8362	9393	}
8363	9394
8364		static IrInstruction ir_gen_break(IrBuilder irb, Scope break_scope, AstNode node) {
	9395	static IrInstSrc ir_gen_break(IrBuilderSrc irb, Scope break_scope, AstNode node) {
8365	9396	assert(node->type == NodeTypeBreak);
8366	9397
8367	9398	// Search up the scope. We'll find one of these things first:
...	...	@@ -8376,14 +9407,14 @@ static IrInstruction ir_gen_break(IrBuilder irb, Scope break_scope, AstNode
8376	9407	if (search_scope == nullptr \|\| search_scope->id == ScopeIdFnDef) {
8377	9408	if (node->data.break_expr.name != nullptr) {
8378	9409	add_node_error(irb->codegen, node, buf_sprintf("label not found: '%s'", buf_ptr(node->data.break_expr.name)));
8379		return irb->codegen->invalid_instruction;
	9410	return irb->codegen->invalid_inst_src;
8380	9411	} else {
8381	9412	add_node_error(irb->codegen, node, buf_sprintf("break expression outside loop"));
8382		return irb->codegen->invalid_instruction;
	9413	return irb->codegen->invalid_inst_src;
8383	9414	}
8384	9415	} else if (search_scope->id == ScopeIdDeferExpr) {
8385	9416	add_node_error(irb->codegen, node, buf_sprintf("cannot break out of defer expression"));
8386		return irb->codegen->invalid_instruction;
	9417	return irb->codegen->invalid_inst_src;
8387	9418	} else if (search_scope->id == ScopeIdLoop) {
8388	9419	ScopeLoop this_loop_scope = (ScopeLoop )search_scope;
8389	9420	if (node->data.break_expr.name == nullptr \|\|
...	...	@@ -8402,32 +9433,32 @@ static IrInstruction ir_gen_break(IrBuilder irb, Scope break_scope, AstNode
8402	9433	}
8403	9434	} else if (search_scope->id == ScopeIdSuspend) {
8404	9435	add_node_error(irb->codegen, node, buf_sprintf("cannot break out of suspend block"));
8405		return irb->codegen->invalid_instruction;
	9436	return irb->codegen->invalid_inst_src;
8406	9437	}
8407	9438	search_scope = search_scope->parent;
8408	9439	}
8409	9440
8410		IrInstruction *is_comptime;
	9441	IrInstSrc *is_comptime;
8411	9442	if (ir_should_inline(irb->exec, break_scope)) {
8412	9443	is_comptime = ir_build_const_bool(irb, break_scope, node, true);
8413	9444	} else {
8414	9445	is_comptime = loop_scope->is_comptime;
8415	9446	}
8416	9447
8417		IrInstruction *result_value;
	9448	IrInstSrc *result_value;
8418	9449	if (node->data.break_expr.expr) {
8419	9450	ResultLocPeer *peer_result = create_peer_result(loop_scope->peer_parent);
8420	9451	loop_scope->peer_parent->peers.append(peer_result);
8421	9452
8422	9453	result_value = ir_gen_node_extra(irb, node->data.break_expr.expr, break_scope,
8423	9454	loop_scope->lval, &peer_result->base);
8424		if (result_value == irb->codegen->invalid_instruction)
8425		return irb->codegen->invalid_instruction;
	9455	if (result_value == irb->codegen->invalid_inst_src)
	9456	return irb->codegen->invalid_inst_src;
8426	9457	} else {
8427	9458	result_value = ir_build_const_void(irb, break_scope, node);
8428	9459	}
8429	9460
8430		IrBasicBlock *dest_block = loop_scope->break_block;
	9461	IrBasicBlockSrc *dest_block = loop_scope->break_block;
8431	9462	ir_gen_defers_for_block(irb, break_scope, dest_block->scope, false);
8432	9463
8433	9464	loop_scope->incoming_blocks->append(irb->current_basic_block);
...	...	@@ -8435,7 +9466,7 @@ static IrInstruction ir_gen_break(IrBuilder irb, Scope break_scope, AstNode
8435	9466	return ir_build_br(irb, break_scope, node, dest_block, is_comptime);
8436	9467	}
8437	9468
8438		static IrInstruction ir_gen_continue(IrBuilder irb, Scope continue_scope, AstNode node) {
	9469	static IrInstSrc ir_gen_continue(IrBuilderSrc irb, Scope continue_scope, AstNode node) {
8439	9470	assert(node->type == NodeTypeContinue);
8440	9471
8441	9472	// Search up the scope. We'll find one of these things first:
...	...	@@ -8451,14 +9482,14 @@ static IrInstruction ir_gen_continue(IrBuilder irb, Scope *continue_scope, Ast
8451	9482	if (search_scope == nullptr \|\| search_scope->id == ScopeIdFnDef) {
8452	9483	if (node->data.continue_expr.name != nullptr) {
8453	9484	add_node_error(irb->codegen, node, buf_sprintf("labeled loop not found: '%s'", buf_ptr(node->data.continue_expr.name)));
8454		return irb->codegen->invalid_instruction;
	9485	return irb->codegen->invalid_inst_src;
8455	9486	} else {
8456	9487	add_node_error(irb->codegen, node, buf_sprintf("continue expression outside loop"));
8457		return irb->codegen->invalid_instruction;
	9488	return irb->codegen->invalid_inst_src;
8458	9489	}
8459	9490	} else if (search_scope->id == ScopeIdDeferExpr) {
8460	9491	add_node_error(irb->codegen, node, buf_sprintf("cannot continue out of defer expression"));
8461		return irb->codegen->invalid_instruction;
	9492	return irb->codegen->invalid_inst_src;
8462	9493	} else if (search_scope->id == ScopeIdLoop) {
8463	9494	ScopeLoop this_loop_scope = (ScopeLoop )search_scope;
8464	9495	if (node->data.continue_expr.name == nullptr \|\|
...	...	@@ -8474,7 +9505,7 @@ static IrInstruction ir_gen_continue(IrBuilder irb, Scope *continue_scope, Ast
8474	9505	search_scope = search_scope->parent;
8475	9506	}
8476	9507
8477		IrInstruction *is_comptime;
	9508	IrInstSrc *is_comptime;
8478	9509	if (ir_should_inline(irb->exec, continue_scope)) {
8479	9510	is_comptime = ir_build_const_bool(irb, continue_scope, node, true);
8480	9511	} else {
...	...	@@ -8486,17 +9517,17 @@ static IrInstruction ir_gen_continue(IrBuilder irb, Scope *continue_scope, Ast
8486	9517	ir_mark_gen(ir_build_check_runtime_scope(irb, continue_scope, node, scope_runtime->is_comptime, is_comptime));
8487	9518	}
8488	9519
8489		IrBasicBlock *dest_block = loop_scope->continue_block;
	9520	IrBasicBlockSrc *dest_block = loop_scope->continue_block;
8490	9521	ir_gen_defers_for_block(irb, continue_scope, dest_block->scope, false);
8491	9522	return ir_mark_gen(ir_build_br(irb, continue_scope, node, dest_block, is_comptime));
8492	9523	}
8493	9524
8494		static IrInstruction ir_gen_error_type(IrBuilder irb, Scope scope, AstNode node) {
	9525	static IrInstSrc ir_gen_error_type(IrBuilderSrc irb, Scope scope, AstNode node) {
8495	9526	assert(node->type == NodeTypeErrorType);
8496	9527	return ir_build_const_type(irb, scope, node, irb->codegen->builtin_types.entry_global_error_set);
8497	9528	}
8498	9529
8499		static IrInstruction ir_gen_defer(IrBuilder irb, Scope parent_scope, AstNode node) {
	9530	static IrInstSrc ir_gen_defer(IrBuilderSrc irb, Scope parent_scope, AstNode node) {
8500	9531	assert(node->type == NodeTypeDefer);
8501	9532
8502	9533	ScopeDefer *defer_child_scope = create_defer_scope(irb->codegen, node, parent_scope);
...	...	@@ -8508,7 +9539,7 @@ static IrInstruction ir_gen_defer(IrBuilder irb, Scope *parent_scope, AstNode
8508	9539	return ir_build_const_void(irb, parent_scope, node);
8509	9540	}
8510	9541
8511		static IrInstruction ir_gen_slice(IrBuilder irb, Scope scope, AstNode node, LVal lval, ResultLoc *result_loc) {
	9542	static IrInstSrc ir_gen_slice(IrBuilderSrc irb, Scope scope, AstNode node, LVal lval, ResultLoc *result_loc) {
8512	9543	assert(node->type == NodeTypeSliceExpr);
8513	9544
8514	9545	AstNodeSliceExpr *slice_expr = &node->data.slice_expr;
...	...	@@ -8517,38 +9548,38 @@ static IrInstruction ir_gen_slice(IrBuilder irb, Scope scope, AstNode node,
8517	9548	AstNode *end_node = slice_expr->end;
8518	9549	AstNode *sentinel_node = slice_expr->sentinel;
8519	9550
8520		IrInstruction *ptr_value = ir_gen_node_extra(irb, array_node, scope, LValPtr, nullptr);
8521		if (ptr_value == irb->codegen->invalid_instruction)
8522		return irb->codegen->invalid_instruction;
	9551	IrInstSrc *ptr_value = ir_gen_node_extra(irb, array_node, scope, LValPtr, nullptr);
	9552	if (ptr_value == irb->codegen->invalid_inst_src)
	9553	return irb->codegen->invalid_inst_src;
8523	9554
8524		IrInstruction *start_value = ir_gen_node(irb, start_node, scope);
8525		if (start_value == irb->codegen->invalid_instruction)
8526		return irb->codegen->invalid_instruction;
	9555	IrInstSrc *start_value = ir_gen_node(irb, start_node, scope);
	9556	if (start_value == irb->codegen->invalid_inst_src)
	9557	return irb->codegen->invalid_inst_src;
8527	9558
8528		IrInstruction *end_value;
	9559	IrInstSrc *end_value;
8529	9560	if (end_node) {
8530	9561	end_value = ir_gen_node(irb, end_node, scope);
8531		if (end_value == irb->codegen->invalid_instruction)
8532		return irb->codegen->invalid_instruction;
	9562	if (end_value == irb->codegen->invalid_inst_src)
	9563	return irb->codegen->invalid_inst_src;
8533	9564	} else {
8534	9565	end_value = nullptr;
8535	9566	}
8536	9567
8537		IrInstruction *sentinel_value;
	9568	IrInstSrc *sentinel_value;
8538	9569	if (sentinel_node) {
8539	9570	sentinel_value = ir_gen_node(irb, sentinel_node, scope);
8540		if (sentinel_value == irb->codegen->invalid_instruction)
8541		return irb->codegen->invalid_instruction;
	9571	if (sentinel_value == irb->codegen->invalid_inst_src)
	9572	return irb->codegen->invalid_inst_src;
8542	9573	} else {
8543	9574	sentinel_value = nullptr;
8544	9575	}
8545	9576
8546		IrInstruction *slice = ir_build_slice_src(irb, scope, node, ptr_value, start_value, end_value,
	9577	IrInstSrc *slice = ir_build_slice_src(irb, scope, node, ptr_value, start_value, end_value,
8547	9578	sentinel_value, true, result_loc);
8548	9579	return ir_lval_wrap(irb, scope, slice, lval, result_loc);
8549	9580	}
8550	9581
8551		static IrInstruction ir_gen_catch(IrBuilder irb, Scope parent_scope, AstNode node, LVal lval,
	9582	static IrInstSrc ir_gen_catch(IrBuilderSrc irb, Scope parent_scope, AstNode node, LVal lval,
8552	9583	ResultLoc *result_loc)
8553	9584	{
8554	9585	assert(node->type == NodeTypeCatchExpr);
...	...	@@ -8562,29 +9593,29 @@ static IrInstruction ir_gen_catch(IrBuilder irb, Scope *parent_scope, AstNode
8562	9593	assert(var_node->type == NodeTypeSymbol);
8563	9594	Buf *var_name = var_node->data.symbol_expr.symbol;
8564	9595	add_node_error(irb->codegen, var_node, buf_sprintf("unused variable: '%s'", buf_ptr(var_name)));
8565		return irb->codegen->invalid_instruction;
	9596	return irb->codegen->invalid_inst_src;
8566	9597	}
8567	9598	return ir_gen_catch_unreachable(irb, parent_scope, node, op1_node, lval, result_loc);
8568	9599	}
8569	9600
8570	9601
8571		IrInstruction *err_union_ptr = ir_gen_node_extra(irb, op1_node, parent_scope, LValPtr, nullptr);
8572		if (err_union_ptr == irb->codegen->invalid_instruction)
8573		return irb->codegen->invalid_instruction;
	9602	IrInstSrc *err_union_ptr = ir_gen_node_extra(irb, op1_node, parent_scope, LValPtr, nullptr);
	9603	if (err_union_ptr == irb->codegen->invalid_inst_src)
	9604	return irb->codegen->invalid_inst_src;
8574	9605
8575		IrInstruction *is_err = ir_build_test_err_src(irb, parent_scope, node, err_union_ptr, true, false);
	9606	IrInstSrc *is_err = ir_build_test_err_src(irb, parent_scope, node, err_union_ptr, true, false);
8576	9607
8577		IrInstruction *is_comptime;
	9608	IrInstSrc *is_comptime;
8578	9609	if (ir_should_inline(irb->exec, parent_scope)) {
8579	9610	is_comptime = ir_build_const_bool(irb, parent_scope, node, true);
8580	9611	} else {
8581	9612	is_comptime = ir_build_test_comptime(irb, parent_scope, node, is_err);
8582	9613	}
8583	9614
8584		IrBasicBlock *ok_block = ir_create_basic_block(irb, parent_scope, "UnwrapErrOk");
8585		IrBasicBlock *err_block = ir_create_basic_block(irb, parent_scope, "UnwrapErrError");
8586		IrBasicBlock *end_block = ir_create_basic_block(irb, parent_scope, "UnwrapErrEnd");
8587		IrInstruction *cond_br_inst = ir_build_cond_br(irb, parent_scope, node, is_err, err_block, ok_block, is_comptime);
	9615	IrBasicBlockSrc *ok_block = ir_create_basic_block(irb, parent_scope, "UnwrapErrOk");
	9616	IrBasicBlockSrc *err_block = ir_create_basic_block(irb, parent_scope, "UnwrapErrError");
	9617	IrBasicBlockSrc *end_block = ir_create_basic_block(irb, parent_scope, "UnwrapErrEnd");
	9618	IrInstSrc *cond_br_inst = ir_build_cond_br(irb, parent_scope, node, is_err, err_block, ok_block, is_comptime);
8588	9619
8589	9620	ResultLocPeerParent *peer_parent = ir_build_binary_result_peers(irb, cond_br_inst, ok_block, end_block, result_loc,
8590	9621	is_comptime);
...	...	@@ -8600,33 +9631,33 @@ static IrInstruction ir_gen_catch(IrBuilder irb, Scope *parent_scope, AstNode
8600	9631	ZigVar *var = ir_create_var(irb, node, subexpr_scope, var_name,
8601	9632	is_const, is_const, is_shadowable, is_comptime);
8602	9633	err_scope = var->child_scope;
8603		IrInstruction *err_ptr = ir_build_unwrap_err_code(irb, err_scope, node, err_union_ptr);
	9634	IrInstSrc *err_ptr = ir_build_unwrap_err_code_src(irb, err_scope, node, err_union_ptr);
8604	9635	ir_build_var_decl_src(irb, err_scope, var_node, var, nullptr, err_ptr);
8605	9636	} else {
8606	9637	err_scope = subexpr_scope;
8607	9638	}
8608		IrInstruction *err_result = ir_gen_node_extra(irb, op2_node, err_scope, LValNone, &peer_parent->peers.at(0)->base);
8609		if (err_result == irb->codegen->invalid_instruction)
8610		return irb->codegen->invalid_instruction;
8611		IrBasicBlock *after_err_block = irb->current_basic_block;
	9639	IrInstSrc *err_result = ir_gen_node_extra(irb, op2_node, err_scope, LValNone, &peer_parent->peers.at(0)->base);
	9640	if (err_result == irb->codegen->invalid_inst_src)
	9641	return irb->codegen->invalid_inst_src;
	9642	IrBasicBlockSrc *after_err_block = irb->current_basic_block;
8612	9643	if (!instr_is_unreachable(err_result))
8613	9644	ir_mark_gen(ir_build_br(irb, parent_scope, node, end_block, is_comptime));
8614	9645
8615	9646	ir_set_cursor_at_end_and_append_block(irb, ok_block);
8616		IrInstruction *unwrapped_ptr = ir_build_unwrap_err_payload(irb, parent_scope, node, err_union_ptr, false, false);
8617		IrInstruction *unwrapped_payload = ir_build_load_ptr(irb, parent_scope, node, unwrapped_ptr);
	9647	IrInstSrc *unwrapped_ptr = ir_build_unwrap_err_payload_src(irb, parent_scope, node, err_union_ptr, false, false);
	9648	IrInstSrc *unwrapped_payload = ir_build_load_ptr(irb, parent_scope, node, unwrapped_ptr);
8618	9649	ir_build_end_expr(irb, parent_scope, node, unwrapped_payload, &peer_parent->peers.at(1)->base);
8619		IrBasicBlock *after_ok_block = irb->current_basic_block;
	9650	IrBasicBlockSrc *after_ok_block = irb->current_basic_block;
8620	9651	ir_build_br(irb, parent_scope, node, end_block, is_comptime);
8621	9652
8622	9653	ir_set_cursor_at_end_and_append_block(irb, end_block);
8623		IrInstruction *incoming_values = allocate<IrInstruction >(2);
	9654	IrInstSrc *incoming_values = allocate<IrInstSrc >(2);
8624	9655	incoming_values[0] = err_result;
8625	9656	incoming_values[1] = unwrapped_payload;
8626		IrBasicBlock *incoming_blocks = allocate<IrBasicBlock >(2, "IrBasicBlock *");
	9657	IrBasicBlockSrc *incoming_blocks = allocate<IrBasicBlockSrc >(2, "IrBasicBlockSrc *");
8627	9658	incoming_blocks[0] = after_err_block;
8628	9659	incoming_blocks[1] = after_ok_block;
8629		IrInstruction *phi = ir_build_phi(irb, parent_scope, node, 2, incoming_blocks, incoming_values, peer_parent);
	9660	IrInstSrc *phi = ir_build_phi(irb, parent_scope, node, 2, incoming_blocks, incoming_values, peer_parent);
8630	9661	return ir_lval_wrap(irb, parent_scope, phi, lval, result_loc);
8631	9662	}
8632	9663
...	...	@@ -8644,7 +9675,7 @@ static bool render_instance_name_recursive(CodeGen codegen, Buf name, Scope *o
8644	9675	return true;
8645	9676	}
8646	9677
8647		static Buf get_anon_type_name(CodeGen codegen, IrExecutable exec, const char kind_name,
	9678	static Buf get_anon_type_name(CodeGen codegen, IrExecutableSrc exec, const char kind_name,
8648	9679	Scope scope, AstNode source_node, Buf *out_bare_name)
8649	9680	{
8650	9681	if (exec != nullptr && exec->name) {
...	...	@@ -8673,7 +9704,7 @@ static Buf get_anon_type_name(CodeGen codegen, IrExecutable *exec, const char
8673	9704	}
8674	9705	}
8675	9706
8676		static IrInstruction ir_gen_container_decl(IrBuilder irb, Scope parent_scope, AstNode node) {
	9707	static IrInstSrc ir_gen_container_decl(IrBuilderSrc irb, Scope parent_scope, AstNode node) {
8677	9708	assert(node->type == NodeTypeContainerDecl);
8678	9709
8679	9710	ContainerKind kind = node->data.container_decl.kind;
...	...	@@ -8798,7 +9829,7 @@ static AstNode ast_field_to_symbol_node(AstNode err_set_field_node) {
8798	9829	}
8799	9830	}
8800	9831
8801		static IrInstruction ir_gen_err_set_decl(IrBuilder irb, Scope parent_scope, AstNode node) {
	9832	static IrInstSrc ir_gen_err_set_decl(IrBuilderSrc irb, Scope parent_scope, AstNode node) {
8802	9833	assert(node->type == NodeTypeErrorSetDecl);
8803	9834
8804	9835	uint32_t err_count = node->data.err_set_decl.decls.length;
...	...	@@ -8841,7 +9872,7 @@ static IrInstruction ir_gen_err_set_decl(IrBuilder irb, Scope *parent_scope, A
8841	9872	buf_sprintf("duplicate error: '%s'", buf_ptr(&err->name)));
8842	9873	add_error_note(irb->codegen, msg, ast_field_to_symbol_node(prev_err->decl_node),
8843	9874	buf_sprintf("other error here"));
8844		return irb->codegen->invalid_instruction;
	9875	return irb->codegen->invalid_inst_src;
8845	9876	}
8846	9877	errors[err->value] = err;
8847	9878	}
...	...	@@ -8849,11 +9880,11 @@ static IrInstruction ir_gen_err_set_decl(IrBuilder irb, Scope *parent_scope, A
8849	9880	return ir_build_const_type(irb, parent_scope, node, err_set_type);
8850	9881	}
8851	9882
8852		static IrInstruction ir_gen_fn_proto(IrBuilder irb, Scope parent_scope, AstNode node) {
	9883	static IrInstSrc ir_gen_fn_proto(IrBuilderSrc irb, Scope parent_scope, AstNode node) {
8853	9884	assert(node->type == NodeTypeFnProto);
8854	9885
8855	9886	size_t param_count = node->data.fn_proto.params.length;
8856		IrInstruction *param_types = allocate<IrInstruction>(param_count);
	9887	IrInstSrc *param_types = allocate<IrInstSrc>(param_count);
8857	9888
8858	9889	bool is_var_args = false;
8859	9890	for (size_t i = 0; i < param_count; i += 1) {
...	...	@@ -8864,59 +9895,59 @@ static IrInstruction ir_gen_fn_proto(IrBuilder irb, Scope *parent_scope, AstNo
8864	9895	}
8865	9896	if (param_node->data.param_decl.var_token == nullptr) {
8866	9897	AstNode *type_node = param_node->data.param_decl.type;
8867		IrInstruction *type_value = ir_gen_node(irb, type_node, parent_scope);
8868		if (type_value == irb->codegen->invalid_instruction)
8869		return irb->codegen->invalid_instruction;
	9898	IrInstSrc *type_value = ir_gen_node(irb, type_node, parent_scope);
	9899	if (type_value == irb->codegen->invalid_inst_src)
	9900	return irb->codegen->invalid_inst_src;
8870	9901	param_types[i] = type_value;
8871	9902	} else {
8872	9903	param_types[i] = nullptr;
8873	9904	}
8874	9905	}
8875	9906
8876		IrInstruction *align_value = nullptr;
	9907	IrInstSrc *align_value = nullptr;
8877	9908	if (node->data.fn_proto.align_expr != nullptr) {
8878	9909	align_value = ir_gen_node(irb, node->data.fn_proto.align_expr, parent_scope);
8879		if (align_value == irb->codegen->invalid_instruction)
8880		return irb->codegen->invalid_instruction;
	9910	if (align_value == irb->codegen->invalid_inst_src)
	9911	return irb->codegen->invalid_inst_src;
8881	9912	}
8882	9913
8883		IrInstruction *callconv_value = nullptr;
	9914	IrInstSrc *callconv_value = nullptr;
8884	9915	if (node->data.fn_proto.callconv_expr != nullptr) {
8885	9916	callconv_value = ir_gen_node(irb, node->data.fn_proto.callconv_expr, parent_scope);
8886		if (callconv_value == irb->codegen->invalid_instruction)
8887		return irb->codegen->invalid_instruction;
	9917	if (callconv_value == irb->codegen->invalid_inst_src)
	9918	return irb->codegen->invalid_inst_src;
8888	9919	}
8889	9920
8890		IrInstruction *return_type;
	9921	IrInstSrc *return_type;
8891	9922	if (node->data.fn_proto.return_var_token == nullptr) {
8892	9923	if (node->data.fn_proto.return_type == nullptr) {
8893	9924	return_type = ir_build_const_type(irb, parent_scope, node, irb->codegen->builtin_types.entry_void);
8894	9925	} else {
8895	9926	return_type = ir_gen_node(irb, node->data.fn_proto.return_type, parent_scope);
8896		if (return_type == irb->codegen->invalid_instruction)
8897		return irb->codegen->invalid_instruction;
	9927	if (return_type == irb->codegen->invalid_inst_src)
	9928	return irb->codegen->invalid_inst_src;
8898	9929	}
8899	9930	} else {
8900	9931	add_node_error(irb->codegen, node,
8901	9932	buf_sprintf("TODO implement inferred return types https://github.com/ziglang/zig/issues/447"));
8902		return irb->codegen->invalid_instruction;
	9933	return irb->codegen->invalid_inst_src;
8903	9934	//return_type = nullptr;
8904	9935	}
8905	9936
8906	9937	return ir_build_fn_proto(irb, parent_scope, node, param_types, align_value, callconv_value, return_type, is_var_args);
8907	9938	}
8908	9939
8909		static IrInstruction ir_gen_resume(IrBuilder irb, Scope scope, AstNode node) {
	9940	static IrInstSrc ir_gen_resume(IrBuilderSrc irb, Scope scope, AstNode node) {
8910	9941	assert(node->type == NodeTypeResume);
8911	9942
8912		IrInstruction *target_inst = ir_gen_node_extra(irb, node->data.resume_expr.expr, scope, LValPtr, nullptr);
8913		if (target_inst == irb->codegen->invalid_instruction)
8914		return irb->codegen->invalid_instruction;
	9943	IrInstSrc *target_inst = ir_gen_node_extra(irb, node->data.resume_expr.expr, scope, LValPtr, nullptr);
	9944	if (target_inst == irb->codegen->invalid_inst_src)
	9945	return irb->codegen->invalid_inst_src;
8915	9946
8916		return ir_build_resume(irb, scope, node, target_inst);
	9947	return ir_build_resume_src(irb, scope, node, target_inst);
8917	9948	}
8918	9949
8919		static IrInstruction ir_gen_await_expr(IrBuilder irb, Scope scope, AstNode node, LVal lval,
	9950	static IrInstSrc ir_gen_await_expr(IrBuilderSrc irb, Scope scope, AstNode node, LVal lval,
8920	9951	ResultLoc *result_loc)
8921	9952	{
8922	9953	assert(node->type == NodeTypeAwaitExpr);
...	...	@@ -8937,7 +9968,7 @@ static IrInstruction ir_gen_await_expr(IrBuilder irb, Scope scope, AstNode n
8937	9968	ZigFn *fn_entry = exec_fn_entry(irb->exec);
8938	9969	if (!fn_entry) {
8939	9970	add_node_error(irb->codegen, node, buf_sprintf("await outside function definition"));
8940		return irb->codegen->invalid_instruction;
	9971	return irb->codegen->invalid_inst_src;
8941	9972	}
8942	9973	ScopeSuspend *existing_suspend_scope = get_scope_suspend(scope);
8943	9974	if (existing_suspend_scope) {
...	...	@@ -8946,24 +9977,24 @@ static IrInstruction ir_gen_await_expr(IrBuilder irb, Scope scope, AstNode n
8946	9977	add_error_note(irb->codegen, msg, existing_suspend_scope->base.source_node, buf_sprintf("suspend block here"));
8947	9978	existing_suspend_scope->reported_err = true;
8948	9979	}
8949		return irb->codegen->invalid_instruction;
	9980	return irb->codegen->invalid_inst_src;
8950	9981	}
8951	9982
8952		IrInstruction *target_inst = ir_gen_node_extra(irb, expr_node, scope, LValPtr, nullptr);
8953		if (target_inst == irb->codegen->invalid_instruction)
8954		return irb->codegen->invalid_instruction;
	9983	IrInstSrc *target_inst = ir_gen_node_extra(irb, expr_node, scope, LValPtr, nullptr);
	9984	if (target_inst == irb->codegen->invalid_inst_src)
	9985	return irb->codegen->invalid_inst_src;
8955	9986
8956		IrInstruction *await_inst = ir_build_await_src(irb, scope, node, target_inst, result_loc);
	9987	IrInstSrc *await_inst = ir_build_await_src(irb, scope, node, target_inst, result_loc);
8957	9988	return ir_lval_wrap(irb, scope, await_inst, lval, result_loc);
8958	9989	}
8959	9990
8960		static IrInstruction ir_gen_suspend(IrBuilder irb, Scope parent_scope, AstNode node) {
	9991	static IrInstSrc ir_gen_suspend(IrBuilderSrc irb, Scope parent_scope, AstNode node) {
8961	9992	assert(node->type == NodeTypeSuspend);
8962	9993
8963	9994	ZigFn *fn_entry = exec_fn_entry(irb->exec);
8964	9995	if (!fn_entry) {
8965	9996	add_node_error(irb->codegen, node, buf_sprintf("suspend outside function definition"));
8966		return irb->codegen->invalid_instruction;
	9997	return irb->codegen->invalid_inst_src;
8967	9998	}
8968	9999	ScopeSuspend *existing_suspend_scope = get_scope_suspend(parent_scope);
8969	10000	if (existing_suspend_scope) {
...	...	@@ -8972,21 +10003,21 @@ static IrInstruction ir_gen_suspend(IrBuilder irb, Scope *parent_scope, AstNod
8972	10003	add_error_note(irb->codegen, msg, existing_suspend_scope->base.source_node, buf_sprintf("other suspend block here"));
8973	10004	existing_suspend_scope->reported_err = true;
8974	10005	}
8975		return irb->codegen->invalid_instruction;
	10006	return irb->codegen->invalid_inst_src;
8976	10007	}
8977	10008
8978		IrInstructionSuspendBegin *begin = ir_build_suspend_begin(irb, parent_scope, node);
	10009	IrInstSrcSuspendBegin *begin = ir_build_suspend_begin_src(irb, parent_scope, node);
8979	10010	if (node->data.suspend.block != nullptr) {
8980	10011	ScopeSuspend *suspend_scope = create_suspend_scope(irb->codegen, node, parent_scope);
8981	10012	Scope *child_scope = &suspend_scope->base;
8982		IrInstruction *susp_res = ir_gen_node(irb, node->data.suspend.block, child_scope);
	10013	IrInstSrc *susp_res = ir_gen_node(irb, node->data.suspend.block, child_scope);
8983	10014	ir_mark_gen(ir_build_check_statement_is_void(irb, child_scope, node->data.suspend.block, susp_res));
8984	10015	}
8985	10016
8986		return ir_mark_gen(ir_build_suspend_finish(irb, parent_scope, node, begin));
	10017	return ir_mark_gen(ir_build_suspend_finish_src(irb, parent_scope, node, begin));
8987	10018	}
8988	10019
8989		static IrInstruction ir_gen_node_raw(IrBuilder irb, AstNode node, Scope scope,
	10020	static IrInstSrc ir_gen_node_raw(IrBuilderSrc irb, AstNode node, Scope scope,
8990	10021	LVal lval, ResultLoc *result_loc)
8991	10022	{
8992	10023	assert(scope);
...	...	@@ -9035,39 +10066,39 @@ static IrInstruction ir_gen_node_raw(IrBuilder irb, AstNode node, Scope scop
9035	10066	return ir_gen_return(irb, scope, node, lval, result_loc);
9036	10067	case NodeTypeFieldAccessExpr:
9037	10068	{
9038		IrInstruction *ptr_instruction = ir_gen_field_access(irb, scope, node);
9039		if (ptr_instruction == irb->codegen->invalid_instruction)
	10069	IrInstSrc *ptr_instruction = ir_gen_field_access(irb, scope, node);
	10070	if (ptr_instruction == irb->codegen->invalid_inst_src)
9040	10071	return ptr_instruction;
9041	10072	if (lval == LValPtr)
9042	10073	return ptr_instruction;
9043	10074
9044		IrInstruction *load_ptr = ir_build_load_ptr(irb, scope, node, ptr_instruction);
	10075	IrInstSrc *load_ptr = ir_build_load_ptr(irb, scope, node, ptr_instruction);
9045	10076	return ir_expr_wrap(irb, scope, load_ptr, result_loc);
9046	10077	}
9047	10078	case NodeTypePtrDeref: {
9048	10079	AstNode *expr_node = node->data.ptr_deref_expr.target;
9049		IrInstruction *value = ir_gen_node_extra(irb, expr_node, scope, lval, nullptr);
9050		if (value == irb->codegen->invalid_instruction)
	10080	IrInstSrc *value = ir_gen_node_extra(irb, expr_node, scope, lval, nullptr);
	10081	if (value == irb->codegen->invalid_inst_src)
9051	10082	return value;
9052	10083
9053	10084	// We essentially just converted any lvalue from &(x.) to (&x).;
9054	10085	// this inhibits checking that x is a pointer later, so we directly
9055	10086	// record whether the pointer check is needed
9056		IrInstruction *un_op = ir_build_un_op_lval(irb, scope, node, IrUnOpDereference, value, lval, result_loc);
	10087	IrInstSrc *un_op = ir_build_un_op_lval(irb, scope, node, IrUnOpDereference, value, lval, result_loc);
9057	10088	return ir_expr_wrap(irb, scope, un_op, result_loc);
9058	10089	}
9059	10090	case NodeTypeUnwrapOptional: {
9060	10091	AstNode *expr_node = node->data.unwrap_optional.expr;
9061	10092
9062		IrInstruction *maybe_ptr = ir_gen_node_extra(irb, expr_node, scope, LValPtr, nullptr);
9063		if (maybe_ptr == irb->codegen->invalid_instruction)
9064		return irb->codegen->invalid_instruction;
	10093	IrInstSrc *maybe_ptr = ir_gen_node_extra(irb, expr_node, scope, LValPtr, nullptr);
	10094	if (maybe_ptr == irb->codegen->invalid_inst_src)
	10095	return irb->codegen->invalid_inst_src;
9065	10096
9066		IrInstruction *unwrapped_ptr = ir_build_optional_unwrap_ptr(irb, scope, node, maybe_ptr, true, false);
	10097	IrInstSrc *unwrapped_ptr = ir_build_optional_unwrap_ptr(irb, scope, node, maybe_ptr, true, false);
9067	10098	if (lval == LValPtr)
9068	10099	return unwrapped_ptr;
9069	10100
9070		IrInstruction *load_ptr = ir_build_load_ptr(irb, scope, node, unwrapped_ptr);
	10101	IrInstSrc *load_ptr = ir_build_load_ptr(irb, scope, node, unwrapped_ptr);
9071	10102	return ir_expr_wrap(irb, scope, load_ptr, result_loc);
9072	10103	}
9073	10104	case NodeTypeBoolLiteral:
...	...	@@ -9125,7 +10156,7 @@ static IrInstruction ir_gen_node_raw(IrBuilder irb, AstNode node, Scope scop
9125	10156	case NodeTypeInferredArrayType:
9126	10157	add_node_error(irb->codegen, node,
9127	10158	buf_sprintf("inferred array size invalid here"));
9128		return irb->codegen->invalid_instruction;
	10159	return irb->codegen->invalid_inst_src;
9129	10160	case NodeTypeVarFieldType:
9130	10161	return ir_lval_wrap(irb, scope,
9131	10162	ir_build_const_type(irb, scope, node, irb->codegen->builtin_types.entry_var), lval, result_loc);
...	...	@@ -9139,7 +10170,7 @@ static ResultLoc *no_result_loc(void) {
9139	10170	return &result_loc_none->base;
9140	10171	}
9141	10172
9142		static IrInstruction ir_gen_node_extra(IrBuilder irb, AstNode node, Scope scope, LVal lval,
	10173	static IrInstSrc ir_gen_node_extra(IrBuilderSrc irb, AstNode node, Scope scope, LVal lval,
9143	10174	ResultLoc *result_loc)
9144	10175	{
9145	10176	if (result_loc == nullptr) {
...	...	@@ -9156,8 +10187,8 @@ static IrInstruction ir_gen_node_extra(IrBuilder irb, AstNode node, Scope sc
9156	10187	} else {
9157	10188	child_scope = &create_expr_scope(irb->codegen, node, scope)->base;
9158	10189	}
9159		IrInstruction *result = ir_gen_node_raw(irb, node, child_scope, lval, result_loc);
9160		if (result == irb->codegen->invalid_instruction) {
	10190	IrInstSrc *result = ir_gen_node_raw(irb, node, child_scope, lval, result_loc);
	10191	if (result == irb->codegen->invalid_inst_src) {
9161	10192	if (irb->exec->first_err_trace_msg == nullptr) {
9162	10193	irb->exec->first_err_trace_msg = irb->codegen->trace_err;
9163	10194	}
...	...	@@ -9165,11 +10196,22 @@ static IrInstruction ir_gen_node_extra(IrBuilder irb, AstNode node, Scope sc
9165	10196	return result;
9166	10197	}
9167	10198
9168		static IrInstruction ir_gen_node(IrBuilder irb, AstNode node, Scope scope) {
	10199	static IrInstSrc ir_gen_node(IrBuilderSrc irb, AstNode node, Scope scope) {
9169	10200	return ir_gen_node_extra(irb, node, scope, LValNone, nullptr);
9170	10201	}
9171	10202
9172		static void invalidate_exec(IrExecutable exec, ErrorMsg msg) {
	10203	static void invalidate_exec(IrExecutableSrc exec, ErrorMsg msg) {
	10204	if (exec->first_err_trace_msg != nullptr)
	10205	return;
	10206
	10207	exec->first_err_trace_msg = msg;
	10208
	10209	for (size_t i = 0; i < exec->tld_list.length; i += 1) {
	10210	exec->tld_list.items[i]->resolution = TldResolutionInvalid;
	10211	}
	10212	}
	10213
	10214	static void invalidate_exec_gen(IrExecutableGen exec, ErrorMsg msg) {
9173	10215	if (exec->first_err_trace_msg != nullptr)
9174	10216	return;
9175	10217
...	...	@@ -9183,24 +10225,25 @@ static void invalidate_exec(IrExecutable exec, ErrorMsg msg) {
9183	10225	invalidate_exec(exec->source_exec, msg);
9184	10226	}
9185	10227
9186		bool ir_gen(CodeGen codegen, AstNode node, Scope scope, IrExecutable ir_executable) {
	10228
	10229	bool ir_gen(CodeGen codegen, AstNode node, Scope scope, IrExecutableSrc ir_executable) {
9187	10230	assert(node->owner);
9188	10231
9189		IrBuilder ir_builder = {0};
9190		IrBuilder *irb = &ir_builder;
	10232	IrBuilderSrc ir_builder = {0};
	10233	IrBuilderSrc *irb = &ir_builder;
9191	10234
9192	10235	irb->codegen = codegen;
9193	10236	irb->exec = ir_executable;
9194	10237	irb->main_block_node = node;
9195	10238
9196		IrBasicBlock *entry_block = ir_create_basic_block(irb, scope, "Entry");
	10239	IrBasicBlockSrc *entry_block = ir_create_basic_block(irb, scope, "Entry");
9197	10240	ir_set_cursor_at_end_and_append_block(irb, entry_block);
9198	10241	// Entry block gets a reference because we enter it to begin.
9199	10242	ir_ref_bb(irb->current_basic_block);
9200	10243
9201		IrInstruction *result = ir_gen_node_extra(irb, node, scope, LValNone, nullptr);
	10244	IrInstSrc *result = ir_gen_node_extra(irb, node, scope, LValNone, nullptr);
9202	10245
9203		if (result == irb->codegen->invalid_instruction)
	10246	if (result == irb->codegen->invalid_inst_src)
9204	10247	return false;
9205	10248
9206	10249	if (irb->exec->first_err_trace_msg != nullptr) {
...	...	@@ -9209,9 +10252,9 @@ bool ir_gen(CodeGen codegen, AstNode node, Scope scope, IrExecutable ir_exec
9209	10252	}
9210	10253
9211	10254	if (!instr_is_unreachable(result)) {
9212		ir_mark_gen(ir_build_add_implicit_return_type(irb, scope, result->source_node, result, nullptr));
	10255	ir_mark_gen(ir_build_add_implicit_return_type(irb, scope, result->base.source_node, result, nullptr));
9213	10256	// no need for save_err_ret_addr because this cannot return error
9214		ir_mark_gen(ir_build_return(irb, scope, result->source_node, result));
	10257	ir_mark_gen(ir_build_return_src(irb, scope, result->base.source_node, result));
9215	10258	}
9216	10259
9217	10260	return true;
...	...	@@ -9220,7 +10263,7 @@ bool ir_gen(CodeGen codegen, AstNode node, Scope scope, IrExecutable ir_exec
9220	10263	bool ir_gen_fn(CodeGen codegen, ZigFn fn_entry) {
9221	10264	assert(fn_entry);
9222	10265
9223		IrExecutable *ir_executable = fn_entry->ir_executable;
	10266	IrExecutableSrc *ir_executable = fn_entry->ir_executable;
9224	10267	AstNode *body_node = fn_entry->body_node;
9225	10268
9226	10269	assert(fn_entry->child_scope);
...	...	@@ -9228,14 +10271,21 @@ bool ir_gen_fn(CodeGen codegen, ZigFn fn_entry) {
9228	10271	return ir_gen(codegen, body_node, fn_entry->child_scope, ir_executable);
9229	10272	}
9230	10273
9231		static void ir_add_call_stack_errors(CodeGen codegen, IrExecutable exec, ErrorMsg *err_msg, int limit) {
	10274	static void ir_add_call_stack_errors_gen(CodeGen codegen, IrExecutableGen exec, ErrorMsg *err_msg, int limit) {
	10275	if (!exec \|\| !exec->source_node \|\| limit < 0) return;
	10276	add_error_note(codegen, err_msg, exec->source_node, buf_sprintf("called from here"));
	10277
	10278	ir_add_call_stack_errors_gen(codegen, exec->parent_exec, err_msg, limit - 1);
	10279	}
	10280
	10281	static void ir_add_call_stack_errors(CodeGen codegen, IrExecutableSrc exec, ErrorMsg *err_msg, int limit) {
9232	10282	if (!exec \|\| !exec->source_node \|\| limit < 0) return;
9233	10283	add_error_note(codegen, err_msg, exec->source_node, buf_sprintf("called from here"));
9234	10284
9235		ir_add_call_stack_errors(codegen, exec->parent_exec, err_msg, limit - 1);
	10285	ir_add_call_stack_errors_gen(codegen, exec->parent_exec, err_msg, limit - 1);
9236	10286	}
9237	10287
9238		static ErrorMsg exec_add_error_node(CodeGen codegen, IrExecutable exec, AstNode source_node, Buf *msg) {
	10288	static ErrorMsg exec_add_error_node(CodeGen codegen, IrExecutableSrc exec, AstNode source_node, Buf *msg) {
9239	10289	ErrorMsg *err_msg = add_node_error(codegen, source_node, msg);
9240	10290	invalidate_exec(exec, err_msg);
9241	10291	if (exec->parent_exec) {
...	...	@@ -9244,26 +10294,40 @@ static ErrorMsg exec_add_error_node(CodeGen codegen, IrExecutable *exec, AstNo
9244	10294	return err_msg;
9245	10295	}
9246	10296
	10297	static ErrorMsg exec_add_error_node_gen(CodeGen codegen, IrExecutableGen exec, AstNode source_node, Buf *msg) {
	10298	ErrorMsg *err_msg = add_node_error(codegen, source_node, msg);
	10299	invalidate_exec_gen(exec, err_msg);
	10300	if (exec->parent_exec) {
	10301	ir_add_call_stack_errors_gen(codegen, exec, err_msg, 10);
	10302	}
	10303	return err_msg;
	10304	}
	10305
9247	10306	static ErrorMsg ir_add_error_node(IrAnalyze ira, AstNode source_node, Buf msg) {
9248		return exec_add_error_node(ira->codegen, ira->new_irb.exec, source_node, msg);
	10307	return exec_add_error_node_gen(ira->codegen, ira->new_irb.exec, source_node, msg);
9249	10308	}
9250	10309
9251	10310	static ErrorMsg opt_ir_add_error_node(IrAnalyze ira, CodeGen codegen, AstNode source_node, Buf *msg) {
9252	10311	if (ira != nullptr)
9253		return exec_add_error_node(codegen, ira->new_irb.exec, source_node, msg);
	10312	return exec_add_error_node_gen(codegen, ira->new_irb.exec, source_node, msg);
9254	10313	else
9255	10314	return add_node_error(codegen, source_node, msg);
9256	10315	}
9257	10316
9258		static ErrorMsg ir_add_error(IrAnalyze ira, IrInstruction source_instruction, Buf msg) {
	10317	static ErrorMsg ir_add_error(IrAnalyze ira, IrInst source_instruction, Buf msg) {
9259	10318	return ir_add_error_node(ira, source_instruction->source_node, msg);
9260	10319	}
9261	10320
9262		static void ir_assert(bool ok, IrInstruction *source_instruction) {
	10321	static void ir_assert(bool ok, IrInst *source_instruction) {
9263	10322	if (ok) return;
9264	10323	src_assert(ok, source_instruction->source_node);
9265	10324	}
9266	10325
	10326	static void ir_assert_gen(bool ok, IrInstGen *source_instruction) {
	10327	if (ok) return;
	10328	src_assert(ok, source_instruction->base.source_node);
	10329	}
	10330
9267	10331	// This function takes a comptime ptr and makes the child const value conform to the type
9268	10332	// described by the pointer.
9269	10333	static Error eval_comptime_ptr_reinterpret(IrAnalyze ira, CodeGen codegen, AstNode *source_node,
...	...	@@ -9309,43 +10373,43 @@ ZigValue const_ptr_pointee(IrAnalyze ira, CodeGen codegen, ZigValue const_va
9309	10373	return val;
9310	10374	}
9311	10375
9312		static ZigValue ir_exec_const_result(CodeGen codegen, IrExecutable *exec) {
9313		IrBasicBlock *bb = exec->basic_block_list.at(0);
	10376	static ZigValue ir_exec_const_result(CodeGen codegen, IrExecutableGen *exec) {
	10377	IrBasicBlockGen *bb = exec->basic_block_list.at(0);
9314	10378	for (size_t i = 0; i < bb->instruction_list.length; i += 1) {
9315		IrInstruction *instruction = bb->instruction_list.at(i);
9316		if (instruction->id == IrInstructionIdReturn) {
9317		IrInstructionReturn ret_inst = (IrInstructionReturn )instruction;
9318		IrInstruction *operand = ret_inst->operand;
	10379	IrInstGen *instruction = bb->instruction_list.at(i);
	10380	if (instruction->id == IrInstGenIdReturn) {
	10381	IrInstGenReturn ret_inst = (IrInstGenReturn )instruction;
	10382	IrInstGen *operand = ret_inst->operand;
9319	10383	if (operand->value->special == ConstValSpecialRuntime) {
9320		exec_add_error_node(codegen, exec, operand->source_node,
	10384	exec_add_error_node_gen(codegen, exec, operand->base.source_node,
9321	10385	buf_sprintf("unable to evaluate constant expression"));
9322		return codegen->invalid_instruction->value;
	10386	return codegen->invalid_inst_gen->value;
9323	10387	}
9324	10388	return operand->value;
9325		} else if (ir_has_side_effects(instruction)) {
	10389	} else if (ir_inst_gen_has_side_effects(instruction)) {
9326	10390	if (instr_is_comptime(instruction)) {
9327	10391	switch (instruction->id) {
9328		case IrInstructionIdUnwrapErrPayload:
9329		case IrInstructionIdUnionFieldPtr:
	10392	case IrInstGenIdUnwrapErrPayload:
	10393	case IrInstGenIdUnionFieldPtr:
9330	10394	continue;
9331	10395	default:
9332	10396	break;
9333	10397	}
9334	10398	}
9335		if (get_scope_typeof(instruction->scope) != nullptr) {
	10399	if (get_scope_typeof(instruction->base.scope) != nullptr) {
9336	10400	// doesn't count, it's inside a @TypeOf()
9337	10401	continue;
9338	10402	}
9339		exec_add_error_node(codegen, exec, instruction->source_node,
	10403	exec_add_error_node_gen(codegen, exec, instruction->base.source_node,
9340	10404	buf_sprintf("unable to evaluate constant expression"));
9341		return codegen->invalid_instruction->value;
	10405	return codegen->invalid_inst_gen->value;
9342	10406	}
9343	10407	}
9344	10408	zig_unreachable();
9345	10409	}
9346	10410
9347		static bool ir_emit_global_runtime_side_effect(IrAnalyze ira, IrInstruction source_instruction) {
9348		if (ir_should_inline(ira->new_irb.exec, source_instruction->scope)) {
	10411	static bool ir_emit_global_runtime_side_effect(IrAnalyze ira, IrInst source_instruction) {
	10412	if (ir_should_inline(ira->old_irb.exec, source_instruction->scope)) {
9349	10413	ir_add_error(ira, source_instruction, buf_sprintf("unable to evaluate constant expression"));
9350	10414	return false;
9351	10415	}
...	...	@@ -10079,7 +11143,7 @@ void float_read_ieee597(ZigValue val, uint8_t buf, bool is_big_endian) {
10079	11143	}
10080	11144	}
10081	11145
10082		static bool ir_num_lit_fits_in_other_type(IrAnalyze ira, IrInstruction instruction, ZigType *other_type,
	11146	static bool ir_num_lit_fits_in_other_type(IrAnalyze ira, IrInstGen instruction, ZigType *other_type,
10083	11147	bool explicit_cast)
10084	11148	{
10085	11149	if (type_is_invalid(other_type)) {
...	...	@@ -10173,7 +11237,7 @@ static bool ir_num_lit_fits_in_other_type(IrAnalyze ira, IrInstruction instruc
10173	11237	}
10174	11238	Buf *val_buf = buf_alloc();
10175	11239	bigint_append_buf(val_buf, &const_val->data.x_bigint, 10);
10176		ir_add_error(ira, instruction,
	11240	ir_add_error_node(ira, instruction->base.source_node,
10177	11241	buf_sprintf("integer value %s has no representation in type '%s'",
10178	11242	buf_ptr(val_buf),
10179	11243	buf_ptr(&other_type->name)));
...	...	@@ -10268,7 +11332,7 @@ static bool ir_num_lit_fits_in_other_type(IrAnalyze ira, IrInstruction instruc
10268	11332	}
10269	11333	Buf *val_buf = buf_alloc();
10270	11334	float_append_buf(val_buf, const_val);
10271		ir_add_error(ira, instruction,
	11335	ir_add_error_node(ira, instruction->base.source_node,
10272	11336	buf_sprintf("cast of value %s to type '%s' loses information",
10273	11337	buf_ptr(val_buf),
10274	11338	buf_ptr(&other_type->name)));
...	...	@@ -10277,7 +11341,7 @@ static bool ir_num_lit_fits_in_other_type(IrAnalyze ira, IrInstruction instruc
10277	11341	if (!other_type->data.integral.is_signed && const_val->data.x_bigint.is_negative) {
10278	11342	Buf *val_buf = buf_alloc();
10279	11343	bigint_append_buf(val_buf, &const_val->data.x_bigint, 10);
10280		ir_add_error(ira, instruction,
	11344	ir_add_error_node(ira, instruction->base.source_node,
10281	11345	buf_sprintf("cannot cast negative value %s to unsigned integer type '%s'",
10282	11346	buf_ptr(val_buf),
10283	11347	buf_ptr(&other_type->name)));
...	...	@@ -10298,7 +11362,7 @@ static bool ir_num_lit_fits_in_other_type(IrAnalyze ira, IrInstruction instruc
10298	11362	if (!child_type->data.integral.is_signed && const_val->data.x_bigint.is_negative) {
10299	11363	Buf *val_buf = buf_alloc();
10300	11364	bigint_append_buf(val_buf, &const_val->data.x_bigint, 10);
10301		ir_add_error(ira, instruction,
	11365	ir_add_error_node(ira, instruction->base.source_node,
10302	11366	buf_sprintf("cannot cast negative value %s to unsigned integer type '%s'",
10303	11367	buf_ptr(val_buf),
10304	11368	buf_ptr(&child_type->name)));
...	...	@@ -10321,7 +11385,7 @@ static bool ir_num_lit_fits_in_other_type(IrAnalyze ira, IrInstruction instruc
10321	11385	Buf *val_buf = buf_alloc();
10322	11386	float_append_buf(val_buf, const_val);
10323	11387
10324		ir_add_error(ira, instruction,
	11388	ir_add_error_node(ira, instruction->base.source_node,
10325	11389	buf_sprintf("fractional component prevents float value %s from being casted to type '%s'",
10326	11390	buf_ptr(val_buf),
10327	11391	buf_ptr(&other_type->name)));
...	...	@@ -10351,7 +11415,7 @@ static bool ir_num_lit_fits_in_other_type(IrAnalyze ira, IrInstruction instruc
10351	11415	bigint_append_buf(val_buf, &const_val->data.x_bigint, 10);
10352	11416	}
10353	11417
10354		ir_add_error(ira, instruction,
	11418	ir_add_error_node(ira, instruction->base.source_node,
10355	11419	buf_sprintf("%s value %s cannot be coerced to type '%s'",
10356	11420	num_lit_str,
10357	11421	buf_ptr(val_buf),
...	...	@@ -10805,11 +11869,11 @@ static void update_errors_helper(CodeGen g, ErrorTableEntry *errors, size_t
10805	11869	}
10806	11870
10807	11871	static ZigType ir_resolve_peer_types(IrAnalyze ira, AstNode source_node, ZigType expected_type,
10808		IrInstruction **instructions, size_t instruction_count)
	11872	IrInstGen **instructions, size_t instruction_count)
10809	11873	{
10810	11874	Error err;
10811	11875	assert(instruction_count >= 1);
10812		IrInstruction *prev_inst;
	11876	IrInstGen *prev_inst;
10813	11877	size_t i = 0;
10814	11878	for (;;) {
10815	11879	prev_inst = instructions[i];
...	...	@@ -10829,7 +11893,7 @@ static ZigType ir_resolve_peer_types(IrAnalyze ira, AstNode *source_node, ZigT
10829	11893	size_t errors_count = 0;
10830	11894	ZigType *err_set_type = nullptr;
10831	11895	if (prev_inst->value->type->id == ZigTypeIdErrorSet) {
10832		if (!resolve_inferred_error_set(ira->codegen, prev_inst->value->type, prev_inst->source_node)) {
	11896	if (!resolve_inferred_error_set(ira->codegen, prev_inst->value->type, prev_inst->base.source_node)) {
10833	11897	return ira->codegen->builtin_types.entry_invalid;
10834	11898	}
10835	11899	if (type_is_global_error_set(prev_inst->value->type)) {
...	...	@@ -10849,7 +11913,7 @@ static ZigType ir_resolve_peer_types(IrAnalyze ira, AstNode *source_node, ZigT
10849	11913	bool any_are_null = (prev_inst->value->type->id == ZigTypeIdNull);
10850	11914	bool convert_to_const_slice = false;
10851	11915	for (; i < instruction_count; i += 1) {
10852		IrInstruction *cur_inst = instructions[i];
	11916	IrInstGen *cur_inst = instructions[i];
10853	11917	ZigType *cur_type = cur_inst->value->type;
10854	11918	ZigType *prev_type = prev_inst->value->type;
10855	11919
...	...	@@ -10871,14 +11935,14 @@ static ZigType ir_resolve_peer_types(IrAnalyze ira, AstNode *source_node, ZigT
10871	11935	}
10872	11936
10873	11937	if (prev_type->id == ZigTypeIdErrorSet) {
10874		ir_assert(err_set_type != nullptr, prev_inst);
	11938	ir_assert_gen(err_set_type != nullptr, prev_inst);
10875	11939	if (cur_type->id == ZigTypeIdErrorSet) {
10876	11940	if (type_is_global_error_set(err_set_type)) {
10877	11941	continue;
10878	11942	}
10879	11943	bool allow_infer = cur_type->data.error_set.infer_fn != nullptr &&
10880	11944	cur_type->data.error_set.infer_fn == ira->new_irb.exec->fn_entry;
10881		if (!allow_infer && !resolve_inferred_error_set(ira->codegen, cur_type, cur_inst->source_node)) {
	11945	if (!allow_infer && !resolve_inferred_error_set(ira->codegen, cur_type, cur_inst->base.source_node)) {
10882	11946	return ira->codegen->builtin_types.entry_invalid;
10883	11947	}
10884	11948	if (!allow_infer && type_is_global_error_set(cur_type)) {
...	...	@@ -10946,7 +12010,7 @@ static ZigType ir_resolve_peer_types(IrAnalyze ira, AstNode *source_node, ZigT
10946	12010	ZigType *cur_err_set_type = cur_type->data.error_union.err_set_type;
10947	12011	bool allow_infer = cur_err_set_type->data.error_set.infer_fn != nullptr &&
10948	12012	cur_err_set_type->data.error_set.infer_fn == ira->new_irb.exec->fn_entry;
10949		if (!allow_infer && !resolve_inferred_error_set(ira->codegen, cur_err_set_type, cur_inst->source_node)) {
	12013	if (!allow_infer && !resolve_inferred_error_set(ira->codegen, cur_err_set_type, cur_inst->base.source_node)) {
10950	12014	return ira->codegen->builtin_types.entry_invalid;
10951	12015	}
10952	12016	if (!allow_infer && type_is_global_error_set(cur_err_set_type)) {
...	...	@@ -11001,7 +12065,7 @@ static ZigType ir_resolve_peer_types(IrAnalyze ira, AstNode *source_node, ZigT
11001	12065	if (cur_type->id == ZigTypeIdErrorSet) {
11002	12066	bool allow_infer = cur_type->data.error_set.infer_fn != nullptr &&
11003	12067	cur_type->data.error_set.infer_fn == ira->new_irb.exec->fn_entry;
11004		if (!allow_infer && !resolve_inferred_error_set(ira->codegen, cur_type, cur_inst->source_node)) {
	12068	if (!allow_infer && !resolve_inferred_error_set(ira->codegen, cur_type, cur_inst->base.source_node)) {
11005	12069	return ira->codegen->builtin_types.entry_invalid;
11006	12070	}
11007	12071	if (!allow_infer && type_is_global_error_set(cur_type)) {
...	...	@@ -11024,7 +12088,7 @@ static ZigType ir_resolve_peer_types(IrAnalyze ira, AstNode *source_node, ZigT
11024	12088	err_set_type = cur_type;
11025	12089	}
11026	12090
11027		if (!allow_infer && !resolve_inferred_error_set(ira->codegen, err_set_type, cur_inst->source_node)) {
	12091	if (!allow_infer && !resolve_inferred_error_set(ira->codegen, err_set_type, cur_inst->base.source_node)) {
11028	12092	return ira->codegen->builtin_types.entry_invalid;
11029	12093	}
11030	12094
...	...	@@ -11087,11 +12151,11 @@ static ZigType ir_resolve_peer_types(IrAnalyze ira, AstNode *source_node, ZigT
11087	12151	bool allow_infer_cur = cur_err_set_type->data.error_set.infer_fn != nullptr &&
11088	12152	cur_err_set_type->data.error_set.infer_fn == ira->new_irb.exec->fn_entry;
11089	12153
11090		if (!allow_infer_prev && !resolve_inferred_error_set(ira->codegen, prev_err_set_type, cur_inst->source_node)) {
	12154	if (!allow_infer_prev && !resolve_inferred_error_set(ira->codegen, prev_err_set_type, cur_inst->base.source_node)) {
11091	12155	return ira->codegen->builtin_types.entry_invalid;
11092	12156	}
11093	12157
11094		if (!allow_infer_cur && !resolve_inferred_error_set(ira->codegen, cur_err_set_type, cur_inst->source_node)) {
	12158	if (!allow_infer_cur && !resolve_inferred_error_set(ira->codegen, cur_err_set_type, cur_inst->base.source_node)) {
11095	12159	return ira->codegen->builtin_types.entry_invalid;
11096	12160	}
11097	12161
...	...	@@ -11268,7 +12332,7 @@ static ZigType ir_resolve_peer_types(IrAnalyze ira, AstNode *source_node, ZigT
11268	12332	ZigType *cur_err_set_type = cur_type->data.error_union.err_set_type;
11269	12333	bool allow_infer = cur_err_set_type->data.error_set.infer_fn != nullptr &&
11270	12334	cur_err_set_type->data.error_set.infer_fn == ira->new_irb.exec->fn_entry;
11271		if (!allow_infer && !resolve_inferred_error_set(ira->codegen, cur_err_set_type, cur_inst->source_node)) {
	12335	if (!allow_infer && !resolve_inferred_error_set(ira->codegen, cur_err_set_type, cur_inst->base.source_node)) {
11272	12336	return ira->codegen->builtin_types.entry_invalid;
11273	12337	}
11274	12338	if ((!allow_infer && type_is_global_error_set(cur_err_set_type)) \|\|
...	...	@@ -11463,9 +12527,9 @@ static ZigType ir_resolve_peer_types(IrAnalyze ira, AstNode *source_node, ZigT
11463	12527	ErrorMsg *msg = ir_add_error_node(ira, source_node,
11464	12528	buf_sprintf("incompatible types: '%s' and '%s'",
11465	12529	buf_ptr(&prev_type->name), buf_ptr(&cur_type->name)));
11466		add_error_note(ira->codegen, msg, prev_inst->source_node,
	12530	add_error_note(ira->codegen, msg, prev_inst->base.source_node,
11467	12531	buf_sprintf("type '%s' here", buf_ptr(&prev_type->name)));
11468		add_error_note(ira->codegen, msg, cur_inst->source_node,
	12532	add_error_note(ira->codegen, msg, cur_inst->base.source_node,
11469	12533	buf_sprintf("type '%s' here", buf_ptr(&cur_type->name)));
11470	12534
11471	12535	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -11535,7 +12599,7 @@ static ZigType ir_resolve_peer_types(IrAnalyze ira, AstNode *source_node, ZigT
11535	12599	}
11536	12600	}
11537	12601
11538		static bool eval_const_expr_implicit_cast(IrAnalyze ira, IrInstruction source_instr,
	12602	static bool eval_const_expr_implicit_cast(IrAnalyze ira, IrInst source_instr,
11539	12603	CastOp cast_op,
11540	12604	ZigValue other_val, ZigType other_type,
11541	12605	ZigValue const_val, ZigType new_type)
...	...	@@ -11635,58 +12699,56 @@ static bool eval_const_expr_implicit_cast(IrAnalyze ira, IrInstruction source_
11635	12699	return true;
11636	12700	}
11637	12701
11638		static IrInstruction ir_const(IrAnalyze ira, IrInstruction old_instruction, ZigType ty) {
11639		IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(&ira->new_irb,
11640		old_instruction->scope, old_instruction->source_node);
11641		IrInstruction *new_instruction = &const_instruction->base;
	12702	static IrInstGen ir_const(IrAnalyze ira, IrInst inst, ZigType ty) {
	12703	IrInstGenConst *const_instruction = ir_create_inst_gen<IrInstGenConst>(&ira->new_irb,
	12704	inst->scope, inst->source_node);
	12705	IrInstGen *new_instruction = &const_instruction->base;
11642	12706	new_instruction->value->type = ty;
11643	12707	new_instruction->value->special = ConstValSpecialStatic;
11644	12708	return new_instruction;
11645	12709	}
11646	12710
11647		static IrInstruction ir_const_noval(IrAnalyze ira, IrInstruction *old_instruction) {
11648		IrInstructionConst *const_instruction = ir_create_instruction_noval<IrInstructionConst>(&ira->new_irb,
	12711	static IrInstGen ir_const_noval(IrAnalyze ira, IrInst *old_instruction) {
	12712	IrInstGenConst *const_instruction = ir_create_inst_noval<IrInstGenConst>(&ira->new_irb,
11649	12713	old_instruction->scope, old_instruction->source_node);
11650	12714	return &const_instruction->base;
11651	12715	}
11652	12716
11653		// This function initializes the new IrInstruction with the provided ZigValue,
	12717	// This function initializes the new IrInstGen with the provided ZigValue,
11654	12718	// rather than creating a new one.
11655		static IrInstruction ir_const_move(IrAnalyze ira, IrInstruction old_instruction, ZigValue val) {
11656		IrInstruction *result = ir_const_noval(ira, old_instruction);
	12719	static IrInstGen ir_const_move(IrAnalyze ira, IrInst old_instruction, ZigValue val) {
	12720	IrInstGen *result = ir_const_noval(ira, old_instruction);
11657	12721	result->value = val;
11658	12722	return result;
11659	12723	}
11660	12724
11661		static IrInstruction ir_resolve_cast(IrAnalyze ira, IrInstruction source_instr, IrInstruction value,
	12725	static IrInstGen ir_resolve_cast(IrAnalyze ira, IrInst source_instr, IrInstGen value,
11662	12726	ZigType *wanted_type, CastOp cast_op)
11663	12727	{
11664	12728	if (instr_is_comptime(value) \|\| !type_has_bits(wanted_type)) {
11665		IrInstruction *result = ir_const(ira, source_instr, wanted_type);
	12729	IrInstGen *result = ir_const(ira, source_instr, wanted_type);
11666	12730	if (!eval_const_expr_implicit_cast(ira, source_instr, cast_op, value->value, value->value->type,
11667	12731	result->value, wanted_type))
11668	12732	{
11669		return ira->codegen->invalid_instruction;
	12733	return ira->codegen->invalid_inst_gen;
11670	12734	}
11671	12735	return result;
11672	12736	} else {
11673		IrInstruction *result = ir_build_cast(&ira->new_irb, source_instr->scope, source_instr->source_node, wanted_type, value, cast_op);
11674		result->value->type = wanted_type;
11675		return result;
	12737	return ir_build_cast(ira, source_instr, wanted_type, value, cast_op);
11676	12738	}
11677	12739	}
11678	12740
11679		static IrInstruction ir_resolve_ptr_of_array_to_unknown_len_ptr(IrAnalyze ira, IrInstruction *source_instr,
11680		IrInstruction value, ZigType wanted_type)
	12741	static IrInstGen ir_resolve_ptr_of_array_to_unknown_len_ptr(IrAnalyze ira, IrInst* source_instr,
	12742	IrInstGen value, ZigType wanted_type)
11681	12743	{
11682		assert(value->value->type->id == ZigTypeIdPointer);
	12744	ir_assert(value->value->type->id == ZigTypeIdPointer, source_instr);
11683	12745
11684	12746	Error err;
11685	12747
11686	12748	if ((err = type_resolve(ira->codegen, value->value->type->data.pointer.child_type,
11687	12749	ResolveStatusAlignmentKnown)))
11688	12750	{
11689		return ira->codegen->invalid_instruction;
	12751	return ira->codegen->invalid_inst_gen;
11690	12752	}
11691	12753
11692	12754	wanted_type = adjust_ptr_align(ira->codegen, wanted_type, get_ptr_align(ira->codegen, value->value->type));
...	...	@@ -11694,9 +12756,9 @@ static IrInstruction ir_resolve_ptr_of_array_to_unknown_len_ptr(IrAnalyze ira,
11694	12756	if (instr_is_comptime(value)) {
11695	12757	ZigValue *pointee = const_ptr_pointee(ira, ira->codegen, value->value, source_instr->source_node);
11696	12758	if (pointee == nullptr)
11697		return ira->codegen->invalid_instruction;
	12759	return ira->codegen->invalid_inst_gen;
11698	12760	if (pointee->special != ConstValSpecialRuntime) {
11699		IrInstruction *result = ir_const(ira, source_instr, wanted_type);
	12761	IrInstGen *result = ir_const(ira, source_instr, wanted_type);
11700	12762	result->value->data.x_ptr.special = ConstPtrSpecialBaseArray;
11701	12763	result->value->data.x_ptr.mut = value->value->data.x_ptr.mut;
11702	12764	result->value->data.x_ptr.data.base_array.array_val = pointee;
...	...	@@ -11705,21 +12767,18 @@ static IrInstruction ir_resolve_ptr_of_array_to_unknown_len_ptr(IrAnalyze ira,
11705	12767	}
11706	12768	}
11707	12769
11708		IrInstruction *result = ir_build_cast(&ira->new_irb, source_instr->scope, source_instr->source_node,
11709		wanted_type, value, CastOpBitCast);
11710		result->value->type = wanted_type;
11711		return result;
	12770	return ir_build_cast(ira, source_instr, wanted_type, value, CastOpBitCast);
11712	12771	}
11713	12772
11714		static IrInstruction ir_resolve_ptr_of_array_to_slice(IrAnalyze ira, IrInstruction *source_instr,
11715		IrInstruction array_ptr, ZigType wanted_type, ResultLoc *result_loc)
	12773	static IrInstGen ir_resolve_ptr_of_array_to_slice(IrAnalyze ira, IrInst* source_instr,
	12774	IrInstGen array_ptr, ZigType wanted_type, ResultLoc *result_loc)
11716	12775	{
11717	12776	Error err;
11718	12777
11719	12778	if ((err = type_resolve(ira->codegen, array_ptr->value->type->data.pointer.child_type,
11720	12779	ResolveStatusAlignmentKnown)))
11721	12780	{
11722		return ira->codegen->invalid_instruction;
	12781	return ira->codegen->invalid_inst_gen;
11723	12782	}
11724	12783
11725	12784	wanted_type = adjust_slice_align(ira->codegen, wanted_type, get_ptr_align(ira->codegen, array_ptr->value->type));
...	...	@@ -11727,14 +12786,14 @@ static IrInstruction ir_resolve_ptr_of_array_to_slice(IrAnalyze ira, IrInstruc
11727	12786	if (instr_is_comptime(array_ptr)) {
11728	12787	ZigValue *pointee = const_ptr_pointee(ira, ira->codegen, array_ptr->value, source_instr->source_node);
11729	12788	if (pointee == nullptr)
11730		return ira->codegen->invalid_instruction;
	12789	return ira->codegen->invalid_inst_gen;
11731	12790	if (pointee->special != ConstValSpecialRuntime) {
11732	12791	assert(array_ptr->value->type->id == ZigTypeIdPointer);
11733	12792	ZigType *array_type = array_ptr->value->type->data.pointer.child_type;
11734	12793	assert(is_slice(wanted_type));
11735	12794	bool is_const = wanted_type->data.structure.fields[slice_ptr_index]->type_entry->data.pointer.is_const;
11736	12795
11737		IrInstruction *result = ir_const(ira, source_instr, wanted_type);
	12796	IrInstGen *result = ir_const(ira, source_instr, wanted_type);
11738	12797	init_const_slice(ira->codegen, result->value, pointee, 0, array_type->data.array.len, is_const);
11739	12798	result->value->data.x_struct.fields[slice_ptr_index]->data.x_ptr.mut = array_ptr->value->data.x_ptr.mut;
11740	12799	result->value->type = wanted_type;
...	...	@@ -11743,32 +12802,34 @@ static IrInstruction ir_resolve_ptr_of_array_to_slice(IrAnalyze ira, IrInstruc
11743	12802	}
11744	12803
11745	12804	if (result_loc == nullptr) result_loc = no_result_loc();
11746		IrInstruction *result_loc_inst = ir_resolve_result(ira, source_instr, result_loc, wanted_type, nullptr, true,
	12805	IrInstGen *result_loc_inst = ir_resolve_result(ira, source_instr, result_loc, wanted_type, nullptr, true,
11747	12806	false, true);
11748		if (type_is_invalid(result_loc_inst->value->type) \|\| instr_is_unreachable(result_loc_inst)) {
	12807	if (type_is_invalid(result_loc_inst->value->type) \|\|
	12808	result_loc_inst->value->type->id == ZigTypeIdUnreachable)
	12809	{
11749	12810	return result_loc_inst;
11750	12811	}
11751	12812	return ir_build_ptr_of_array_to_slice(ira, source_instr, wanted_type, array_ptr, result_loc_inst);
11752	12813	}
11753	12814
11754		static IrBasicBlock ir_get_new_bb(IrAnalyze ira, IrBasicBlock old_bb, IrInstruction ref_old_instruction) {
	12815	static IrBasicBlockGen ir_get_new_bb(IrAnalyze ira, IrBasicBlockSrc old_bb, IrInst ref_old_instruction) {
11755	12816	assert(old_bb);
11756	12817
11757		if (old_bb->other) {
11758		if (ref_old_instruction == nullptr \|\| old_bb->other->ref_instruction != ref_old_instruction) {
11759		return old_bb->other;
	12818	if (old_bb->child) {
	12819	if (ref_old_instruction == nullptr \|\| old_bb->child->ref_instruction != ref_old_instruction) {
	12820	return old_bb->child;
11760	12821	}
11761	12822	}
11762	12823
11763		IrBasicBlock *new_bb = ir_build_bb_from(&ira->new_irb, old_bb);
	12824	IrBasicBlockGen *new_bb = ir_build_bb_from(ira, old_bb);
11764	12825	new_bb->ref_instruction = ref_old_instruction;
11765	12826
11766	12827	return new_bb;
11767	12828	}
11768	12829
11769		static IrBasicBlock ir_get_new_bb_runtime(IrAnalyze ira, IrBasicBlock old_bb, IrInstruction ref_old_instruction) {
	12830	static IrBasicBlockGen ir_get_new_bb_runtime(IrAnalyze ira, IrBasicBlockSrc old_bb, IrInst ref_old_instruction) {
11770	12831	assert(ref_old_instruction != nullptr);
11771		IrBasicBlock *new_bb = ir_get_new_bb(ira, old_bb, ref_old_instruction);
	12832	IrBasicBlockGen *new_bb = ir_get_new_bb(ira, old_bb, ref_old_instruction);
11772	12833	if (new_bb->must_be_comptime_source_instr) {
11773	12834	ErrorMsg *msg = ir_add_error(ira, ref_old_instruction,
11774	12835	buf_sprintf("control flow attempts to use compile-time variable at runtime"));
...	...	@@ -11779,24 +12840,24 @@ static IrBasicBlock ir_get_new_bb_runtime(IrAnalyze ira, IrBasicBlock *old_bb,
11779	12840	return new_bb;
11780	12841	}
11781	12842
11782		static void ir_start_bb(IrAnalyze ira, IrBasicBlock old_bb, IrBasicBlock *const_predecessor_bb) {
11783		ir_assert(!old_bb->suspended, (old_bb->instruction_list.length != 0) ? old_bb->instruction_list.at(0) : nullptr);
	12843	static void ir_start_bb(IrAnalyze ira, IrBasicBlockSrc old_bb, IrBasicBlockSrc *const_predecessor_bb) {
	12844	ir_assert(!old_bb->suspended, (old_bb->instruction_list.length != 0) ? &old_bb->instruction_list.at(0)->base : nullptr);
11784	12845	ira->instruction_index = 0;
11785	12846	ira->old_irb.current_basic_block = old_bb;
11786	12847	ira->const_predecessor_bb = const_predecessor_bb;
11787	12848	ira->old_bb_index = old_bb->index;
11788	12849	}
11789	12850
11790		static IrInstruction ira_suspend(IrAnalyze ira, IrInstruction old_instruction, IrBasicBlock next_bb,
	12851	static IrInstGen ira_suspend(IrAnalyze ira, IrInst old_instruction, IrBasicBlockSrc next_bb,
11791	12852	IrSuspendPosition *suspend_pos)
11792	12853	{
11793	12854	if (ira->codegen->verbose_ir) {
11794		fprintf(stderr, "suspend %s_%zu %s_%zu #%" PRIu32 " (%zu,%zu)\n",
	12855	fprintf(stderr, "suspend %s_%" PRIu32 " %s_%" PRIu32 " #%" PRIu32 " (%zu,%zu)\n",
11795	12856	ira->old_irb.current_basic_block->name_hint,
11796	12857	ira->old_irb.current_basic_block->debug_id,
11797	12858	ira->old_irb.exec->basic_block_list.at(ira->old_bb_index)->name_hint,
11798	12859	ira->old_irb.exec->basic_block_list.at(ira->old_bb_index)->debug_id,
11799		ira->old_irb.current_basic_block->instruction_list.at(ira->instruction_index)->debug_id,
	12860	ira->old_irb.current_basic_block->instruction_list.at(ira->instruction_index)->base.debug_id,
11800	12861	ira->old_bb_index, ira->instruction_index);
11801	12862	}
11802	12863	suspend_pos->basic_block_index = ira->old_bb_index;
...	...	@@ -11811,13 +12872,13 @@ static IrInstruction ira_suspend(IrAnalyze ira, IrInstruction *old_instruction
11811	12872	assert(ira->old_irb.current_basic_block == next_bb);
11812	12873	ira->instruction_index = 0;
11813	12874	ira->const_predecessor_bb = nullptr;
11814		next_bb->other = ir_get_new_bb_runtime(ira, next_bb, old_instruction);
11815		ira->new_irb.current_basic_block = next_bb->other;
	12875	next_bb->child = ir_get_new_bb_runtime(ira, next_bb, old_instruction);
	12876	ira->new_irb.current_basic_block = next_bb->child;
11816	12877	}
11817	12878	return ira->codegen->unreach_instruction;
11818	12879	}
11819	12880
11820		static IrInstruction ira_resume(IrAnalyze ira) {
	12881	static IrInstGen ira_resume(IrAnalyze ira) {
11821	12882	IrSuspendPosition pos = ira->resume_stack.pop();
11822	12883	if (ira->codegen->verbose_ir) {
11823	12884	fprintf(stderr, "resume (%zu,%zu) ", pos.basic_block_index, pos.instruction_index);
...	...	@@ -11830,12 +12891,12 @@ static IrInstruction ira_resume(IrAnalyze ira) {
11830	12891	ira->instruction_index = pos.instruction_index;
11831	12892	assert(pos.instruction_index < ira->old_irb.current_basic_block->instruction_list.length);
11832	12893	if (ira->codegen->verbose_ir) {
11833		fprintf(stderr, "%s_%zu #%" PRIu32 "\n", ira->old_irb.current_basic_block->name_hint,
	12894	fprintf(stderr, "%s_%" PRIu32 " #%" PRIu32 "\n", ira->old_irb.current_basic_block->name_hint,
11834	12895	ira->old_irb.current_basic_block->debug_id,
11835		ira->old_irb.current_basic_block->instruction_list.at(pos.instruction_index)->debug_id);
	12896	ira->old_irb.current_basic_block->instruction_list.at(pos.instruction_index)->base.debug_id);
11836	12897	}
11837	12898	ira->const_predecessor_bb = nullptr;
11838		ira->new_irb.current_basic_block = ira->old_irb.current_basic_block->other;
	12899	ira->new_irb.current_basic_block = ira->old_irb.current_basic_block->child;
11839	12900	assert(ira->new_irb.current_basic_block != nullptr);
11840	12901	return ira->codegen->unreach_instruction;
11841	12902	}
...	...	@@ -11846,8 +12907,8 @@ static void ir_start_next_bb(IrAnalyze *ira) {
11846	12907	bool need_repeat = true;
11847	12908	for (;;) {
11848	12909	while (ira->old_bb_index < ira->old_irb.exec->basic_block_list.length) {
11849		IrBasicBlock *old_bb = ira->old_irb.exec->basic_block_list.at(ira->old_bb_index);
11850		if (old_bb->other == nullptr && old_bb->suspend_instruction_ref == nullptr) {
	12910	IrBasicBlockSrc *old_bb = ira->old_irb.exec->basic_block_list.at(ira->old_bb_index);
	12911	if (old_bb->child == nullptr && old_bb->suspend_instruction_ref == nullptr) {
11851	12912	ira->old_bb_index += 1;
11852	12913	continue;
11853	12914	}
...	...	@@ -11855,8 +12916,8 @@ static void ir_start_next_bb(IrAnalyze *ira) {
11855	12916	// if it's a suspended block,
11856	12917	// then skip it
11857	12918	if (old_bb->suspended \|\|
11858		(old_bb->other != nullptr && old_bb->other->instruction_list.length != 0) \|\|
11859		(old_bb->other != nullptr && old_bb->other->already_appended))
	12919	(old_bb->child != nullptr && old_bb->child->instruction_list.length != 0) \|\|
	12920	(old_bb->child != nullptr && old_bb->child->already_appended))
11860	12921	{
11861	12922	ira->old_bb_index += 1;
11862	12923	continue;
...	...	@@ -11870,10 +12931,10 @@ static void ir_start_next_bb(IrAnalyze *ira) {
11870	12931	return;
11871	12932	}
11872	12933
11873		if (old_bb->other == nullptr) {
11874		old_bb->other = ir_get_new_bb_runtime(ira, old_bb, old_bb->suspend_instruction_ref);
	12934	if (old_bb->child == nullptr) {
	12935	old_bb->child = ir_get_new_bb_runtime(ira, old_bb, old_bb->suspend_instruction_ref);
11875	12936	}
11876		ira->new_irb.current_basic_block = old_bb->other;
	12937	ira->new_irb.current_basic_block = old_bb->child;
11877	12938	ir_start_bb(ira, old_bb, nullptr);
11878	12939	return;
11879	12940	}
...	...	@@ -11893,16 +12954,16 @@ static void ir_finish_bb(IrAnalyze *ira) {
11893	12954	if (!ira->new_irb.current_basic_block->already_appended) {
11894	12955	ira->new_irb.current_basic_block->already_appended = true;
11895	12956	if (ira->codegen->verbose_ir) {
11896		fprintf(stderr, "append new bb %s_%zu\n", ira->new_irb.current_basic_block->name_hint,
	12957	fprintf(stderr, "append new bb %s_%" PRIu32 "\n", ira->new_irb.current_basic_block->name_hint,
11897	12958	ira->new_irb.current_basic_block->debug_id);
11898	12959	}
11899	12960	ira->new_irb.exec->basic_block_list.append(ira->new_irb.current_basic_block);
11900	12961	}
11901	12962	ira->instruction_index += 1;
11902	12963	while (ira->instruction_index < ira->old_irb.current_basic_block->instruction_list.length) {
11903		IrInstruction *next_instruction = ira->old_irb.current_basic_block->instruction_list.at(ira->instruction_index);
	12964	IrInstSrc *next_instruction = ira->old_irb.current_basic_block->instruction_list.at(ira->instruction_index);
11904	12965	if (!next_instruction->is_gen) {
11905		ir_add_error(ira, next_instruction, buf_sprintf("unreachable code"));
	12966	ir_add_error(ira, &next_instruction->base, buf_sprintf("unreachable code"));
11906	12967	break;
11907	12968	}
11908	12969	ira->instruction_index += 1;
...	...	@@ -11911,7 +12972,7 @@ static void ir_finish_bb(IrAnalyze *ira) {
11911	12972	ir_start_next_bb(ira);
11912	12973	}
11913	12974
11914		static IrInstruction ir_unreach_error(IrAnalyze ira) {
	12975	static IrInstGen ir_unreach_error(IrAnalyze ira) {
11915	12976	ira->old_bb_index = SIZE_MAX;
11916	12977	if (ira->new_irb.exec->first_err_trace_msg == nullptr) {
11917	12978	ira->new_irb.exec->first_err_trace_msg = ira->codegen->trace_err;
...	...	@@ -11919,7 +12980,7 @@ static IrInstruction ir_unreach_error(IrAnalyze ira) {
11919	12980	return ira->codegen->unreach_instruction;
11920	12981	}
11921	12982
11922		static bool ir_emit_backward_branch(IrAnalyze ira, IrInstruction source_instruction) {
	12983	static bool ir_emit_backward_branch(IrAnalyze ira, IrInst source_instruction) {
11923	12984	size_t *bbc = ira->new_irb.exec->backward_branch_count;
11924	12985	size_t *quota = ira->new_irb.exec->backward_branch_quota;
11925	12986
...	...	@@ -11938,66 +12999,82 @@ static bool ir_emit_backward_branch(IrAnalyze ira, IrInstruction source_instru
11938	12999	return true;
11939	13000	}
11940	13001
11941		static IrInstruction ir_inline_bb(IrAnalyze ira, IrInstruction source_instruction, IrBasicBlock old_bb) {
	13002	static IrInstGen ir_inline_bb(IrAnalyze ira, IrInst* source_instruction, IrBasicBlockSrc *old_bb) {
11942	13003	if (old_bb->debug_id <= ira->old_irb.current_basic_block->debug_id) {
11943	13004	if (!ir_emit_backward_branch(ira, source_instruction))
11944	13005	return ir_unreach_error(ira);
11945	13006	}
11946	13007
11947		old_bb->other = ira->old_irb.current_basic_block->other;
	13008	old_bb->child = ira->old_irb.current_basic_block->child;
11948	13009	ir_start_bb(ira, old_bb, ira->old_irb.current_basic_block);
11949	13010	return ira->codegen->unreach_instruction;
11950	13011	}
11951	13012
11952		static IrInstruction ir_finish_anal(IrAnalyze ira, IrInstruction *instruction) {
	13013	static IrInstGen ir_finish_anal(IrAnalyze ira, IrInstGen *instruction) {
11953	13014	if (instruction->value->type->id == ZigTypeIdUnreachable)
11954	13015	ir_finish_bb(ira);
11955	13016	return instruction;
11956	13017	}
11957	13018
11958		static IrInstruction ir_const_type(IrAnalyze ira, IrInstruction source_instruction, ZigType ty) {
11959		IrInstruction *result = ir_const(ira, source_instruction, ira->codegen->builtin_types.entry_type);
	13019	static IrInstGen ir_const_fn(IrAnalyze ira, IrInst source_instr, ZigFn fn_entry) {
	13020	IrInstGen *result = ir_const(ira, source_instr, fn_entry->type_entry);
	13021	result->value->special = ConstValSpecialStatic;
	13022	result->value->data.x_ptr.data.fn.fn_entry = fn_entry;
	13023	result->value->data.x_ptr.mut = ConstPtrMutComptimeConst;
	13024	result->value->data.x_ptr.special = ConstPtrSpecialFunction;
	13025	return result;
	13026	}
	13027
	13028	static IrInstGen ir_const_bound_fn(IrAnalyze ira, IrInst src_inst, ZigFn fn_entry, IrInstGen *first_arg) {
	13029	IrInstGen *result = ir_const(ira, src_inst, get_bound_fn_type(ira->codegen, fn_entry));
	13030	result->value->data.x_bound_fn.fn = fn_entry;
	13031	result->value->data.x_bound_fn.first_arg = first_arg;
	13032	return result;
	13033	}
	13034
	13035	static IrInstGen ir_const_type(IrAnalyze ira, IrInst source_instruction, ZigType ty) {
	13036	IrInstGen *result = ir_const(ira, source_instruction, ira->codegen->builtin_types.entry_type);
11960	13037	result->value->data.x_type = ty;
11961	13038	return result;
11962	13039	}
11963	13040
11964		static IrInstruction ir_const_bool(IrAnalyze ira, IrInstruction *source_instruction, bool value) {
11965		IrInstruction *result = ir_const(ira, source_instruction, ira->codegen->builtin_types.entry_bool);
	13041	static IrInstGen ir_const_bool(IrAnalyze ira, IrInst *source_instruction, bool value) {
	13042	IrInstGen *result = ir_const(ira, source_instruction, ira->codegen->builtin_types.entry_bool);
11966	13043	result->value->data.x_bool = value;
11967	13044	return result;
11968	13045	}
11969	13046
11970		static IrInstruction ir_const_undef(IrAnalyze ira, IrInstruction source_instruction, ZigType ty) {
11971		IrInstruction *result = ir_const(ira, source_instruction, ty);
	13047	static IrInstGen ir_const_undef(IrAnalyze ira, IrInst source_instruction, ZigType ty) {
	13048	IrInstGen *result = ir_const(ira, source_instruction, ty);
11972	13049	result->value->special = ConstValSpecialUndef;
11973	13050	return result;
11974	13051	}
11975	13052
11976		static IrInstruction ir_const_unreachable(IrAnalyze ira, IrInstruction *source_instruction) {
11977		IrInstruction *result = ir_const_noval(ira, source_instruction);
	13053	static IrInstGen ir_const_unreachable(IrAnalyze ira, IrInst *source_instruction) {
	13054	IrInstGen *result = ir_const_noval(ira, source_instruction);
11978	13055	result->value = ira->codegen->intern.for_unreachable();
11979	13056	return result;
11980	13057	}
11981	13058
11982		static IrInstruction ir_const_void(IrAnalyze ira, IrInstruction *source_instruction) {
11983		IrInstruction *result = ir_const_noval(ira, source_instruction);
	13059	static IrInstGen ir_const_void(IrAnalyze ira, IrInst *source_instruction) {
	13060	IrInstGen *result = ir_const_noval(ira, source_instruction);
11984	13061	result->value = ira->codegen->intern.for_void();
11985	13062	return result;
11986	13063	}
11987	13064
11988		static IrInstruction ir_const_unsigned(IrAnalyze ira, IrInstruction *source_instruction, uint64_t value) {
11989		IrInstruction *result = ir_const(ira, source_instruction, ira->codegen->builtin_types.entry_num_lit_int);
	13065	static IrInstGen ir_const_unsigned(IrAnalyze ira, IrInst *source_instruction, uint64_t value) {
	13066	IrInstGen *result = ir_const(ira, source_instruction, ira->codegen->builtin_types.entry_num_lit_int);
11990	13067	bigint_init_unsigned(&result->value->data.x_bigint, value);
11991	13068	return result;
11992	13069	}
11993	13070
11994		static IrInstruction ir_get_const_ptr(IrAnalyze ira, IrInstruction *instruction,
	13071	static IrInstGen ir_get_const_ptr(IrAnalyze ira, IrInst *instruction,
11995	13072	ZigValue pointee, ZigType pointee_type,
11996	13073	ConstPtrMut ptr_mut, bool ptr_is_const, bool ptr_is_volatile, uint32_t ptr_align)
11997	13074	{
11998	13075	ZigType *ptr_type = get_pointer_to_type_extra(ira->codegen, pointee_type,
11999	13076	ptr_is_const, ptr_is_volatile, PtrLenSingle, ptr_align, 0, 0, false);
12000		IrInstruction *const_instr = ir_const(ira, instruction, ptr_type);
	13077	IrInstGen *const_instr = ir_const(ira, instruction, ptr_type);
12001	13078	ZigValue *const_val = const_instr->value;
12002	13079	const_val->data.x_ptr.special = ConstPtrSpecialRef;
12003	13080	const_val->data.x_ptr.mut = ptr_mut;
...	...	@@ -12005,7 +13082,7 @@ static IrInstruction ir_get_const_ptr(IrAnalyze ira, IrInstruction *instructio
12005	13082	return const_instr;
12006	13083	}
12007	13084
12008		static Error ir_resolve_const_val(CodeGen codegen, IrExecutable exec, AstNode *source_node,
	13085	static Error ir_resolve_const_val(CodeGen codegen, IrExecutableGen exec, AstNode *source_node,
12009	13086	ZigValue *val, UndefAllowed undef_allowed)
12010	13087	{
12011	13088	Error err;
...	...	@@ -12017,14 +13094,14 @@ static Error ir_resolve_const_val(CodeGen codegen, IrExecutable exec, AstNode
12017	13094	if (!type_has_bits(val->type))
12018	13095	return ErrorNone;
12019	13096
12020		exec_add_error_node(codegen, exec, source_node,
	13097	exec_add_error_node_gen(codegen, exec, source_node,
12021	13098	buf_sprintf("unable to evaluate constant expression"));
12022	13099	return ErrorSemanticAnalyzeFail;
12023	13100	case ConstValSpecialUndef:
12024	13101	if (undef_allowed == UndefOk \|\| undef_allowed == LazyOk)
12025	13102	return ErrorNone;
12026	13103
12027		exec_add_error_node(codegen, exec, source_node,
	13104	exec_add_error_node_gen(codegen, exec, source_node,
12028	13105	buf_sprintf("use of undefined value here causes undefined behavior"));
12029	13106	return ErrorSemanticAnalyzeFail;
12030	13107	case ConstValSpecialLazy:
...	...	@@ -12039,9 +13116,9 @@ static Error ir_resolve_const_val(CodeGen codegen, IrExecutable exec, AstNode
12039	13116	}
12040	13117	}
12041	13118
12042		static ZigValue ir_resolve_const(IrAnalyze ira, IrInstruction *value, UndefAllowed undef_allowed) {
	13119	static ZigValue ir_resolve_const(IrAnalyze ira, IrInstGen *value, UndefAllowed undef_allowed) {
12043	13120	Error err;
12044		if ((err = ir_resolve_const_val(ira->codegen, ira->new_irb.exec, value->source_node,
	13121	if ((err = ir_resolve_const_val(ira->codegen, ira->new_irb.exec, value->base.source_node,
12045	13122	value->value, undef_allowed)))
12046	13123	{
12047	13124	return nullptr;
...	...	@@ -12052,14 +13129,14 @@ static ZigValue ir_resolve_const(IrAnalyze ira, IrInstruction *value, UndefAll
12052	13129	ZigValue ir_eval_const_value(CodeGen codegen, Scope scope, AstNode node,
12053	13130	ZigType expected_type, size_t backward_branch_count, size_t *backward_branch_quota,
12054	13131	ZigFn fn_entry, Buf c_import_buf, AstNode source_node, Buf exec_name,
12055		IrExecutable parent_exec, AstNode expected_type_source_node, UndefAllowed undef_allowed)
	13132	IrExecutableGen parent_exec, AstNode expected_type_source_node, UndefAllowed undef_allowed)
12056	13133	{
12057	13134	Error err;
12058	13135
12059	13136	if (expected_type != nullptr && type_is_invalid(expected_type))
12060		return codegen->invalid_instruction->value;
	13137	return codegen->invalid_inst_gen->value;
12061	13138
12062		IrExecutable *ir_executable = allocate<IrExecutable>(1, "IrExecutablePass1");
	13139	IrExecutableSrc *ir_executable = allocate<IrExecutableSrc>(1, "IrExecutableSrc");
12063	13140	ir_executable->source_node = source_node;
12064	13141	ir_executable->parent_exec = parent_exec;
12065	13142	ir_executable->name = exec_name;
...	...	@@ -12069,21 +13146,21 @@ ZigValue ir_eval_const_value(CodeGen codegen, Scope scope, AstNode node,
12069	13146	ir_executable->begin_scope = scope;
12070	13147
12071	13148	if (!ir_gen(codegen, node, scope, ir_executable))
12072		return codegen->invalid_instruction->value;
	13149	return codegen->invalid_inst_gen->value;
12073	13150
12074	13151	if (ir_executable->first_err_trace_msg != nullptr) {
12075	13152	codegen->trace_err = ir_executable->first_err_trace_msg;
12076		return codegen->invalid_instruction->value;
	13153	return codegen->invalid_inst_gen->value;
12077	13154	}
12078	13155
12079	13156	if (codegen->verbose_ir) {
12080	13157	fprintf(stderr, "\nSource: ");
12081	13158	ast_render(stderr, node, 4);
12082	13159	fprintf(stderr, "\n{ // (IR)\n");
12083		ir_print(codegen, stderr, ir_executable, 2, IrPassSrc);
	13160	ir_print_src(codegen, stderr, ir_executable, 2);
12084	13161	fprintf(stderr, "}\n");
12085	13162	}
12086		IrExecutable *analyzed_executable = allocate<IrExecutable>(1, "IrExecutablePass2");
	13163	IrExecutableGen *analyzed_executable = allocate<IrExecutableGen>(1, "IrExecutableGen");
12087	13164	analyzed_executable->source_node = source_node;
12088	13165	analyzed_executable->parent_exec = parent_exec;
12089	13166	analyzed_executable->source_exec = ir_executable;
...	...	@@ -12096,31 +13173,31 @@ ZigValue ir_eval_const_value(CodeGen codegen, Scope scope, AstNode node,
12096	13173	analyzed_executable->begin_scope = scope;
12097	13174	ZigType *result_type = ir_analyze(codegen, ir_executable, analyzed_executable, expected_type, expected_type_source_node);
12098	13175	if (type_is_invalid(result_type)) {
12099		return codegen->invalid_instruction->value;
	13176	return codegen->invalid_inst_gen->value;
12100	13177	}
12101	13178
12102	13179	if (codegen->verbose_ir) {
12103	13180	fprintf(stderr, "{ // (analyzed)\n");
12104		ir_print(codegen, stderr, analyzed_executable, 2, IrPassGen);
	13181	ir_print_gen(codegen, stderr, analyzed_executable, 2);
12105	13182	fprintf(stderr, "}\n");
12106	13183	}
12107	13184
12108	13185	ZigValue *result = ir_exec_const_result(codegen, analyzed_executable);
12109	13186	if (type_is_invalid(result->type))
12110		return codegen->invalid_instruction->value;
	13187	return codegen->invalid_inst_gen->value;
12111	13188
12112	13189	if ((err = ir_resolve_const_val(codegen, analyzed_executable, node, result, undef_allowed)))
12113		return codegen->invalid_instruction->value;
	13190	return codegen->invalid_inst_gen->value;
12114	13191
12115	13192	return result;
12116	13193	}
12117	13194
12118		static ErrorTableEntry ir_resolve_error(IrAnalyze ira, IrInstruction *err_value) {
	13195	static ErrorTableEntry ir_resolve_error(IrAnalyze ira, IrInstGen *err_value) {
12119	13196	if (type_is_invalid(err_value->value->type))
12120	13197	return nullptr;
12121	13198
12122	13199	if (err_value->value->type->id != ZigTypeIdErrorSet) {
12123		ir_add_error(ira, err_value,
	13200	ir_add_error_node(ira, err_value->base.source_node,
12124	13201	buf_sprintf("expected error, found '%s'", buf_ptr(&err_value->value->type->name)));
12125	13202	return nullptr;
12126	13203	}
...	...	@@ -12133,7 +13210,7 @@ static ErrorTableEntry ir_resolve_error(IrAnalyze ira, IrInstruction *err_valu
12133	13210	return const_val->data.x_err_set;
12134	13211	}
12135	13212
12136		static ZigType ir_resolve_const_type(CodeGen codegen, IrExecutable exec, AstNode source_node,
	13213	static ZigType ir_resolve_const_type(CodeGen codegen, IrExecutableGen exec, AstNode source_node,
12137	13214	ZigValue *val)
12138	13215	{
12139	13216	Error err;
...	...	@@ -12144,18 +13221,18 @@ static ZigType ir_resolve_const_type(CodeGen codegen, IrExecutable *exec, AstN
12144	13221	return val->data.x_type;
12145	13222	}
12146	13223
12147		static ZigValue ir_resolve_type_lazy(IrAnalyze ira, IrInstruction *type_value) {
	13224	static ZigValue ir_resolve_type_lazy(IrAnalyze ira, IrInstGen *type_value) {
12148	13225	if (type_is_invalid(type_value->value->type))
12149	13226	return nullptr;
12150	13227
12151	13228	if (type_value->value->type->id != ZigTypeIdMetaType) {
12152		ir_add_error(ira, type_value,
	13229	ir_add_error_node(ira, type_value->base.source_node,
12153	13230	buf_sprintf("expected type 'type', found '%s'", buf_ptr(&type_value->value->type->name)));
12154	13231	return nullptr;
12155	13232	}
12156	13233
12157	13234	Error err;
12158		if ((err = ir_resolve_const_val(ira->codegen, ira->new_irb.exec, type_value->source_node,
	13235	if ((err = ir_resolve_const_val(ira->codegen, ira->new_irb.exec, type_value->base.source_node,
12159	13236	type_value->value, LazyOk)))
12160	13237	{
12161	13238	return nullptr;
...	...	@@ -12164,17 +13241,17 @@ static ZigValue ir_resolve_type_lazy(IrAnalyze ira, IrInstruction *type_value)
12164	13241	return type_value->value;
12165	13242	}
12166	13243
12167		static ZigType ir_resolve_type(IrAnalyze ira, IrInstruction *type_value) {
	13244	static ZigType ir_resolve_type(IrAnalyze ira, IrInstGen *type_value) {
12168	13245	ZigValue *val = ir_resolve_type_lazy(ira, type_value);
12169	13246	if (val == nullptr)
12170	13247	return ira->codegen->builtin_types.entry_invalid;
12171	13248
12172		return ir_resolve_const_type(ira->codegen, ira->new_irb.exec, type_value->source_node, val);
	13249	return ir_resolve_const_type(ira->codegen, ira->new_irb.exec, type_value->base.source_node, val);
12173	13250	}
12174	13251
12175		static Error ir_validate_vector_elem_type(IrAnalyze ira, IrInstruction source_instr, ZigType *elem_type) {
	13252	static Error ir_validate_vector_elem_type(IrAnalyze ira, AstNode source_node, ZigType *elem_type) {
12176	13253	if (!is_valid_vector_elem_type(elem_type)) {
12177		ir_add_error(ira, source_instr,
	13254	ir_add_error_node(ira, source_node,
12178	13255	buf_sprintf("vector element type must be integer, float, bool, or pointer; '%s' is invalid",
12179	13256	buf_ptr(&elem_type->name)));
12180	13257	return ErrorSemanticAnalyzeFail;
...	...	@@ -12182,28 +13259,28 @@ static Error ir_validate_vector_elem_type(IrAnalyze ira, IrInstruction source_
12182	13259	return ErrorNone;
12183	13260	}
12184	13261
12185		static ZigType ir_resolve_vector_elem_type(IrAnalyze ira, IrInstruction *elem_type_value) {
	13262	static ZigType ir_resolve_vector_elem_type(IrAnalyze ira, IrInstGen *elem_type_value) {
12186	13263	Error err;
12187	13264	ZigType *elem_type = ir_resolve_type(ira, elem_type_value);
12188	13265	if (type_is_invalid(elem_type))
12189	13266	return ira->codegen->builtin_types.entry_invalid;
12190		if ((err = ir_validate_vector_elem_type(ira, elem_type_value, elem_type)))
	13267	if ((err = ir_validate_vector_elem_type(ira, elem_type_value->base.source_node, elem_type)))
12191	13268	return ira->codegen->builtin_types.entry_invalid;
12192	13269	return elem_type;
12193	13270	}
12194	13271
12195		static ZigType ir_resolve_int_type(IrAnalyze ira, IrInstruction *type_value) {
	13272	static ZigType ir_resolve_int_type(IrAnalyze ira, IrInstGen *type_value) {
12196	13273	ZigType *ty = ir_resolve_type(ira, type_value);
12197	13274	if (type_is_invalid(ty))
12198	13275	return ira->codegen->builtin_types.entry_invalid;
12199	13276
12200	13277	if (ty->id != ZigTypeIdInt) {
12201		ErrorMsg *msg = ir_add_error(ira, type_value,
	13278	ErrorMsg *msg = ir_add_error_node(ira, type_value->base.source_node,
12202	13279	buf_sprintf("expected integer type, found '%s'", buf_ptr(&ty->name)));
12203	13280	if (ty->id == ZigTypeIdVector &&
12204	13281	ty->data.vector.elem_type->id == ZigTypeIdInt)
12205	13282	{
12206		add_error_note(ira->codegen, msg, type_value->source_node,
	13283	add_error_note(ira->codegen, msg, type_value->base.source_node,
12207	13284	buf_sprintf("represent vectors with their element types, i.e. '%s'",
12208	13285	buf_ptr(&ty->data.vector.elem_type->name)));
12209	13286	}
...	...	@@ -12213,12 +13290,12 @@ static ZigType ir_resolve_int_type(IrAnalyze ira, IrInstruction *type_value) {
12213	13290	return ty;
12214	13291	}
12215	13292
12216		static ZigType ir_resolve_error_set_type(IrAnalyze ira, IrInstruction op_source, IrInstruction type_value) {
	13293	static ZigType ir_resolve_error_set_type(IrAnalyze ira, IrInst op_source, IrInstGen type_value) {
12217	13294	if (type_is_invalid(type_value->value->type))
12218	13295	return ira->codegen->builtin_types.entry_invalid;
12219	13296
12220	13297	if (type_value->value->type->id != ZigTypeIdMetaType) {
12221		ErrorMsg *msg = ir_add_error(ira, type_value,
	13298	ErrorMsg *msg = ir_add_error_node(ira, type_value->base.source_node,
12222	13299	buf_sprintf("expected error set type, found '%s'", buf_ptr(&type_value->value->type->name)));
12223	13300	add_error_note(ira->codegen, msg, op_source->source_node,
12224	13301	buf_sprintf("`\|\|` merges error sets; `or` performs boolean OR"));
...	...	@@ -12232,7 +13309,7 @@ static ZigType ir_resolve_error_set_type(IrAnalyze ira, IrInstruction *op_sour
12232	13309	assert(const_val->data.x_type != nullptr);
12233	13310	ZigType *result_type = const_val->data.x_type;
12234	13311	if (result_type->id != ZigTypeIdErrorSet) {
12235		ErrorMsg *msg = ir_add_error(ira, type_value,
	13312	ErrorMsg *msg = ir_add_error_node(ira, type_value->base.source_node,
12236	13313	buf_sprintf("expected error set type, found type '%s'", buf_ptr(&result_type->name)));
12237	13314	add_error_note(ira->codegen, msg, op_source->source_node,
12238	13315	buf_sprintf("`\|\|` merges error sets; `or` performs boolean OR"));
...	...	@@ -12241,15 +13318,12 @@ static ZigType ir_resolve_error_set_type(IrAnalyze ira, IrInstruction *op_sour
12241	13318	return result_type;
12242	13319	}
12243	13320
12244		static ZigFn ir_resolve_fn(IrAnalyze ira, IrInstruction *fn_value) {
12245		if (fn_value == ira->codegen->invalid_instruction)
12246		return nullptr;
12247
	13321	static ZigFn ir_resolve_fn(IrAnalyze ira, IrInstGen *fn_value) {
12248	13322	if (type_is_invalid(fn_value->value->type))
12249	13323	return nullptr;
12250	13324
12251	13325	if (fn_value->value->type->id != ZigTypeIdFn) {
12252		ir_add_error_node(ira, fn_value->source_node,
	13326	ir_add_error_node(ira, fn_value->base.source_node,
12253	13327	buf_sprintf("expected function type, found '%s'", buf_ptr(&fn_value->value->type->name)));
12254	13328	return nullptr;
12255	13329	}
...	...	@@ -12265,22 +13339,22 @@ static ZigFn ir_resolve_fn(IrAnalyze ira, IrInstruction *fn_value) {
12265	13339	return const_val->data.x_ptr.data.fn.fn_entry;
12266	13340	}
12267	13341
12268		static IrInstruction ir_analyze_optional_wrap(IrAnalyze ira, IrInstruction source_instr, IrInstruction value,
12269		ZigType wanted_type, ResultLoc result_loc)
	13342	static IrInstGen ir_analyze_optional_wrap(IrAnalyze ira, IrInst* source_instr,
	13343	IrInstGen value, ZigType wanted_type, ResultLoc *result_loc)
12270	13344	{
12271	13345	assert(wanted_type->id == ZigTypeIdOptional);
12272	13346
12273	13347	if (instr_is_comptime(value)) {
12274	13348	ZigType *payload_type = wanted_type->data.maybe.child_type;
12275		IrInstruction *casted_payload = ir_implicit_cast(ira, value, payload_type);
	13349	IrInstGen *casted_payload = ir_implicit_cast(ira, value, payload_type);
12276	13350	if (type_is_invalid(casted_payload->value->type))
12277		return ira->codegen->invalid_instruction;
	13351	return ira->codegen->invalid_inst_gen;
12278	13352
12279	13353	ZigValue *val = ir_resolve_const(ira, casted_payload, UndefOk);
12280	13354	if (!val)
12281		return ira->codegen->invalid_instruction;
	13355	return ira->codegen->invalid_inst_gen;
12282	13356
12283		IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(&ira->new_irb,
	13357	IrInstGenConst *const_instruction = ir_create_inst_gen<IrInstGenConst>(&ira->new_irb,
12284	13358	source_instr->scope, source_instr->source_node);
12285	13359	const_instruction->base.value->special = ConstValSpecialStatic;
12286	13360	if (types_have_same_zig_comptime_repr(ira->codegen, wanted_type, payload_type)) {
...	...	@@ -12295,40 +13369,42 @@ static IrInstruction ir_analyze_optional_wrap(IrAnalyze ira, IrInstruction *so
12295	13369	if (result_loc == nullptr && handle_is_ptr(wanted_type)) {
12296	13370	result_loc = no_result_loc();
12297	13371	}
12298		IrInstruction *result_loc_inst = nullptr;
	13372	IrInstGen *result_loc_inst = nullptr;
12299	13373	if (result_loc != nullptr) {
12300	13374	result_loc_inst = ir_resolve_result(ira, source_instr, result_loc, wanted_type, nullptr, true, false, true);
12301		if (type_is_invalid(result_loc_inst->value->type) \|\| instr_is_unreachable(result_loc_inst)) {
	13375	if (type_is_invalid(result_loc_inst->value->type) \|\|
	13376	result_loc_inst->value->type->id == ZigTypeIdUnreachable)
	13377	{
12302	13378	return result_loc_inst;
12303	13379	}
12304	13380	}
12305		IrInstruction *result = ir_build_optional_wrap(ira, source_instr, wanted_type, value, result_loc_inst);
	13381	IrInstGen *result = ir_build_optional_wrap(ira, source_instr, wanted_type, value, result_loc_inst);
12306	13382	result->value->data.rh_maybe = RuntimeHintOptionalNonNull;
12307	13383	return result;
12308	13384	}
12309	13385
12310		static IrInstruction ir_analyze_err_wrap_payload(IrAnalyze ira, IrInstruction *source_instr,
12311		IrInstruction value, ZigType wanted_type, ResultLoc *result_loc)
	13386	static IrInstGen ir_analyze_err_wrap_payload(IrAnalyze ira, IrInst* source_instr,
	13387	IrInstGen value, ZigType wanted_type, ResultLoc *result_loc)
12312	13388	{
12313	13389	assert(wanted_type->id == ZigTypeIdErrorUnion);
12314	13390
12315	13391	ZigType *payload_type = wanted_type->data.error_union.payload_type;
12316	13392	ZigType *err_set_type = wanted_type->data.error_union.err_set_type;
12317	13393	if (instr_is_comptime(value)) {
12318		IrInstruction *casted_payload = ir_implicit_cast(ira, value, payload_type);
	13394	IrInstGen *casted_payload = ir_implicit_cast(ira, value, payload_type);
12319	13395	if (type_is_invalid(casted_payload->value->type))
12320		return ira->codegen->invalid_instruction;
	13396	return ira->codegen->invalid_inst_gen;
12321	13397
12322	13398	ZigValue *val = ir_resolve_const(ira, casted_payload, UndefBad);
12323	13399	if (!val)
12324		return ira->codegen->invalid_instruction;
	13400	return ira->codegen->invalid_inst_gen;
12325	13401
12326	13402	ZigValue *err_set_val = create_const_vals(1);
12327	13403	err_set_val->type = err_set_type;
12328	13404	err_set_val->special = ConstValSpecialStatic;
12329	13405	err_set_val->data.x_err_set = nullptr;
12330	13406
12331		IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(&ira->new_irb,
	13407	IrInstGenConst *const_instruction = ir_create_inst_gen<IrInstGenConst>(&ira->new_irb,
12332	13408	source_instr->scope, source_instr->source_node);
12333	13409	const_instruction->base.value->type = wanted_type;
12334	13410	const_instruction->base.value->special = ConstValSpecialStatic;
...	...	@@ -12337,23 +13413,24 @@ static IrInstruction ir_analyze_err_wrap_payload(IrAnalyze ira, IrInstruction
12337	13413	return &const_instruction->base;
12338	13414	}
12339	13415
12340		IrInstruction *result_loc_inst;
	13416	IrInstGen *result_loc_inst;
12341	13417	if (handle_is_ptr(wanted_type)) {
12342	13418	if (result_loc == nullptr) result_loc = no_result_loc();
12343	13419	result_loc_inst = ir_resolve_result(ira, source_instr, result_loc, wanted_type, nullptr, true, false, true);
12344		if (type_is_invalid(result_loc_inst->value->type) \|\| instr_is_unreachable(result_loc_inst)) {
	13420	if (type_is_invalid(result_loc_inst->value->type) \|\|
	13421	result_loc_inst->value->type->id == ZigTypeIdUnreachable) {
12345	13422	return result_loc_inst;
12346	13423	}
12347	13424	} else {
12348	13425	result_loc_inst = nullptr;
12349	13426	}
12350	13427
12351		IrInstruction *result = ir_build_err_wrap_payload(ira, source_instr, wanted_type, value, result_loc_inst);
	13428	IrInstGen *result = ir_build_err_wrap_payload(ira, source_instr, wanted_type, value, result_loc_inst);
12352	13429	result->value->data.rh_error_union = RuntimeHintErrorUnionNonError;
12353	13430	return result;
12354	13431	}
12355	13432
12356		static IrInstruction ir_analyze_err_set_cast(IrAnalyze ira, IrInstruction source_instr, IrInstruction value,
	13433	static IrInstGen ir_analyze_err_set_cast(IrAnalyze ira, IrInst* source_instr, IrInstGen *value,
12357	13434	ZigType *wanted_type)
12358	13435	{
12359	13436	assert(value->value->type->id == ZigTypeIdErrorSet);
...	...	@@ -12362,10 +13439,10 @@ static IrInstruction ir_analyze_err_set_cast(IrAnalyze ira, IrInstruction *sou
12362	13439	if (instr_is_comptime(value)) {
12363	13440	ZigValue *val = ir_resolve_const(ira, value, UndefBad);
12364	13441	if (!val)
12365		return ira->codegen->invalid_instruction;
	13442	return ira->codegen->invalid_inst_gen;
12366	13443
12367	13444	if (!resolve_inferred_error_set(ira->codegen, wanted_type, source_instr->source_node)) {
12368		return ira->codegen->invalid_instruction;
	13445	return ira->codegen->invalid_inst_gen;
12369	13446	}
12370	13447	if (!type_is_global_error_set(wanted_type)) {
12371	13448	bool subset = false;
...	...	@@ -12379,11 +13456,11 @@ static IrInstruction ir_analyze_err_set_cast(IrAnalyze ira, IrInstruction *sou
12379	13456	ir_add_error(ira, source_instr,
12380	13457	buf_sprintf("error.%s not a member of error set '%s'",
12381	13458	buf_ptr(&val->data.x_err_set->name), buf_ptr(&wanted_type->name)));
12382		return ira->codegen->invalid_instruction;
	13459	return ira->codegen->invalid_inst_gen;
12383	13460	}
12384	13461	}
12385	13462
12386		IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(&ira->new_irb,
	13463	IrInstGenConst *const_instruction = ir_create_inst_gen<IrInstGenConst>(&ira->new_irb,
12387	13464	source_instr->scope, source_instr->source_node);
12388	13465	const_instruction->base.value->type = wanted_type;
12389	13466	const_instruction->base.value->special = ConstValSpecialStatic;
...	...	@@ -12391,18 +13468,16 @@ static IrInstruction ir_analyze_err_set_cast(IrAnalyze ira, IrInstruction *sou
12391	13468	return &const_instruction->base;
12392	13469	}
12393	13470
12394		IrInstruction *result = ir_build_cast(&ira->new_irb, source_instr->scope, source_instr->source_node, wanted_type, value, CastOpErrSet);
12395		result->value->type = wanted_type;
12396		return result;
	13471	return ir_build_cast(ira, source_instr, wanted_type, value, CastOpErrSet);
12397	13472	}
12398	13473
12399		static IrInstruction ir_analyze_frame_ptr_to_anyframe(IrAnalyze ira, IrInstruction *source_instr,
12400		IrInstruction frame_ptr, ZigType wanted_type)
	13474	static IrInstGen ir_analyze_frame_ptr_to_anyframe(IrAnalyze ira, IrInst* source_instr,
	13475	IrInstGen frame_ptr, ZigType wanted_type)
12401	13476	{
12402	13477	if (instr_is_comptime(frame_ptr)) {
12403	13478	ZigValue *ptr_val = ir_resolve_const(ira, frame_ptr, UndefBad);
12404	13479	if (ptr_val == nullptr)
12405		return ira->codegen->invalid_instruction;
	13480	return ira->codegen->invalid_inst_gen;
12406	13481
12407	13482	ir_assert(ptr_val->type->id == ZigTypeIdPointer, source_instr);
12408	13483	if (ptr_val->data.x_ptr.mut != ConstPtrMutRuntimeVar) {
...	...	@@ -12410,44 +13485,38 @@ static IrInstruction ir_analyze_frame_ptr_to_anyframe(IrAnalyze ira, IrInstruc
12410	13485	}
12411	13486	}
12412	13487
12413		IrInstruction *result = ir_build_cast(&ira->new_irb, source_instr->scope, source_instr->source_node,
12414		wanted_type, frame_ptr, CastOpBitCast);
12415		result->value->type = wanted_type;
12416		return result;
	13488	return ir_build_cast(ira, source_instr, wanted_type, frame_ptr, CastOpBitCast);
12417	13489	}
12418	13490
12419		static IrInstruction ir_analyze_anyframe_to_anyframe(IrAnalyze ira, IrInstruction *source_instr,
12420		IrInstruction value, ZigType wanted_type)
	13491	static IrInstGen ir_analyze_anyframe_to_anyframe(IrAnalyze ira, IrInst* source_instr,
	13492	IrInstGen value, ZigType wanted_type)
12421	13493	{
12422	13494	if (instr_is_comptime(value)) {
12423	13495	zig_panic("TODO comptime anyframe->T to anyframe");
12424	13496	}
12425	13497
12426		IrInstruction *result = ir_build_cast(&ira->new_irb, source_instr->scope, source_instr->source_node,
12427		wanted_type, value, CastOpBitCast);
12428		result->value->type = wanted_type;
12429		return result;
	13498	return ir_build_cast(ira, source_instr, wanted_type, value, CastOpBitCast);
12430	13499	}
12431	13500
12432	13501
12433		static IrInstruction ir_analyze_err_wrap_code(IrAnalyze ira, IrInstruction source_instr, IrInstruction value,
	13502	static IrInstGen ir_analyze_err_wrap_code(IrAnalyze ira, IrInst* source_instr, IrInstGen *value,
12434	13503	ZigType wanted_type, ResultLoc result_loc)
12435	13504	{
12436	13505	assert(wanted_type->id == ZigTypeIdErrorUnion);
12437	13506
12438		IrInstruction *casted_value = ir_implicit_cast(ira, value, wanted_type->data.error_union.err_set_type);
	13507	IrInstGen *casted_value = ir_implicit_cast(ira, value, wanted_type->data.error_union.err_set_type);
12439	13508
12440	13509	if (instr_is_comptime(casted_value)) {
12441	13510	ZigValue *val = ir_resolve_const(ira, casted_value, UndefBad);
12442	13511	if (!val)
12443		return ira->codegen->invalid_instruction;
	13512	return ira->codegen->invalid_inst_gen;
12444	13513
12445	13514	ZigValue *err_set_val = create_const_vals(1);
12446	13515	err_set_val->special = ConstValSpecialStatic;
12447	13516	err_set_val->type = wanted_type->data.error_union.err_set_type;
12448	13517	err_set_val->data.x_err_set = val->data.x_err_set;
12449	13518
12450		IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(&ira->new_irb,
	13519	IrInstGenConst *const_instruction = ir_create_inst_gen<IrInstGenConst>(&ira->new_irb,
12451	13520	source_instr->scope, source_instr->source_node);
12452	13521	const_instruction->base.value->type = wanted_type;
12453	13522	const_instruction->base.value->special = ConstValSpecialStatic;
...	...	@@ -12456,11 +13525,13 @@ static IrInstruction ir_analyze_err_wrap_code(IrAnalyze ira, IrInstruction *so
12456	13525	return &const_instruction->base;
12457	13526	}
12458	13527
12459		IrInstruction *result_loc_inst;
	13528	IrInstGen *result_loc_inst;
12460	13529	if (handle_is_ptr(wanted_type)) {
12461	13530	if (result_loc == nullptr) result_loc = no_result_loc();
12462	13531	result_loc_inst = ir_resolve_result(ira, source_instr, result_loc, wanted_type, nullptr, true, false, true);
12463		if (type_is_invalid(result_loc_inst->value->type) \|\| instr_is_unreachable(result_loc_inst)) {
	13532	if (type_is_invalid(result_loc_inst->value->type) \|\|
	13533	result_loc_inst->value->type->id == ZigTypeIdUnreachable)
	13534	{
12464	13535	return result_loc_inst;
12465	13536	}
12466	13537	} else {
...	...	@@ -12468,19 +13539,19 @@ static IrInstruction ir_analyze_err_wrap_code(IrAnalyze ira, IrInstruction *so
12468	13539	}
12469	13540
12470	13541
12471		IrInstruction *result = ir_build_err_wrap_code(ira, source_instr, wanted_type, value, result_loc_inst);
	13542	IrInstGen *result = ir_build_err_wrap_code(ira, source_instr, wanted_type, value, result_loc_inst);
12472	13543	result->value->data.rh_error_union = RuntimeHintErrorUnionError;
12473	13544	return result;
12474	13545	}
12475	13546
12476		static IrInstruction ir_analyze_null_to_maybe(IrAnalyze ira, IrInstruction source_instr, IrInstruction value, ZigType *wanted_type) {
	13547	static IrInstGen ir_analyze_null_to_maybe(IrAnalyze ira, IrInst source_instr, IrInstGen value, ZigType *wanted_type) {
12477	13548	assert(wanted_type->id == ZigTypeIdOptional);
12478	13549	assert(instr_is_comptime(value));
12479	13550
12480	13551	ZigValue *val = ir_resolve_const(ira, value, UndefBad);
12481	13552	assert(val != nullptr);
12482	13553
12483		IrInstruction *result = ir_const(ira, source_instr, wanted_type);
	13554	IrInstGen *result = ir_const(ira, source_instr, wanted_type);
12484	13555	result->value->special = ConstValSpecialStatic;
12485	13556	if (get_codegen_ptr_type(wanted_type) != nullptr) {
12486	13557	result->value->data.x_ptr.special = ConstPtrSpecialNull;
...	...	@@ -12492,8 +13563,8 @@ static IrInstruction ir_analyze_null_to_maybe(IrAnalyze ira, IrInstruction *so
12492	13563	return result;
12493	13564	}
12494	13565
12495		static IrInstruction ir_analyze_null_to_c_pointer(IrAnalyze ira, IrInstruction *source_instr,
12496		IrInstruction value, ZigType wanted_type)
	13566	static IrInstGen ir_analyze_null_to_c_pointer(IrAnalyze ira, IrInst *source_instr,
	13567	IrInstGen value, ZigType wanted_type)
12497	13568	{
12498	13569	assert(wanted_type->id == ZigTypeIdPointer);
12499	13570	assert(wanted_type->data.pointer.ptr_len == PtrLenC);
...	...	@@ -12502,24 +13573,24 @@ static IrInstruction ir_analyze_null_to_c_pointer(IrAnalyze ira, IrInstruction
12502	13573	ZigValue *val = ir_resolve_const(ira, value, UndefBad);
12503	13574	assert(val != nullptr);
12504	13575
12505		IrInstruction *result = ir_const(ira, source_instr, wanted_type);
	13576	IrInstGen *result = ir_const(ira, source_instr, wanted_type);
12506	13577	result->value->data.x_ptr.special = ConstPtrSpecialNull;
12507	13578	result->value->data.x_ptr.mut = ConstPtrMutComptimeConst;
12508	13579	return result;
12509	13580	}
12510	13581
12511		static IrInstruction ir_get_ref(IrAnalyze ira, IrInstruction source_instruction, IrInstruction value,
	13582	static IrInstGen ir_get_ref(IrAnalyze ira, IrInst* source_instruction, IrInstGen *value,
12512	13583	bool is_const, bool is_volatile)
12513	13584	{
12514	13585	Error err;
12515	13586
12516	13587	if (type_is_invalid(value->value->type))
12517		return ira->codegen->invalid_instruction;
	13588	return ira->codegen->invalid_inst_gen;
12518	13589
12519	13590	if (instr_is_comptime(value)) {
12520	13591	ZigValue *val = ir_resolve_const(ira, value, LazyOk);
12521	13592	if (!val)
12522		return ira->codegen->invalid_instruction;
	13593	return ira->codegen->invalid_inst_gen;
12523	13594	return ir_get_const_ptr(ira, source_instruction, val, value->value->type,
12524	13595	ConstPtrMutComptimeConst, is_const, is_volatile, 0);
12525	13596	}
...	...	@@ -12528,9 +13599,9 @@ static IrInstruction ir_get_ref(IrAnalyze ira, IrInstruction *source_instructi
12528	13599	is_const, is_volatile, PtrLenSingle, 0, 0, 0, false);
12529	13600
12530	13601	if ((err = type_resolve(ira->codegen, ptr_type, ResolveStatusZeroBitsKnown)))
12531		return ira->codegen->invalid_instruction;
	13602	return ira->codegen->invalid_inst_gen;
12532	13603
12533		IrInstruction *result_loc;
	13604	IrInstGen *result_loc;
12534	13605	if (type_has_bits(ptr_type) && !handle_is_ptr(value->value->type)) {
12535	13606	result_loc = ir_resolve_result(ira, source_instruction, no_result_loc(), value->value->type, nullptr, true,
12536	13607	false, true);
...	...	@@ -12538,12 +13609,12 @@ static IrInstruction ir_get_ref(IrAnalyze ira, IrInstruction *source_instructi
12538	13609	result_loc = nullptr;
12539	13610	}
12540	13611
12541		IrInstruction *new_instruction = ir_build_ref_gen(ira, source_instruction, ptr_type, value, result_loc);
	13612	IrInstGen *new_instruction = ir_build_ref_gen(ira, source_instruction, ptr_type, value, result_loc);
12542	13613	new_instruction->value->data.rh_ptr = RuntimeHintPtrStack;
12543	13614	return new_instruction;
12544	13615	}
12545	13616
12546		static ZigType ir_resolve_union_tag_type(IrAnalyze ira, IrInstruction source_instr, ZigType union_type) {
	13617	static ZigType ir_resolve_union_tag_type(IrAnalyze ira, AstNode source_node, ZigType union_type) {
12547	13618	assert(union_type->id == ZigTypeIdUnion);
12548	13619
12549	13620	Error err;
...	...	@@ -12555,36 +13626,36 @@ static ZigType ir_resolve_union_tag_type(IrAnalyze ira, IrInstruction *source_
12555	13626	assert(union_type->data.unionation.tag_type != nullptr);
12556	13627	return union_type->data.unionation.tag_type;
12557	13628	} else {
12558		ErrorMsg *msg = ir_add_error(ira, source_instr, buf_sprintf("union '%s' has no tag",
	13629	ErrorMsg *msg = ir_add_error_node(ira, source_node, buf_sprintf("union '%s' has no tag",
12559	13630	buf_ptr(&union_type->name)));
12560	13631	add_error_note(ira->codegen, msg, decl_node, buf_sprintf("consider 'union(enum)' here"));
12561	13632	return ira->codegen->builtin_types.entry_invalid;
12562	13633	}
12563	13634	}
12564	13635
12565		static IrInstruction ir_analyze_enum_to_int(IrAnalyze ira, IrInstruction source_instr, IrInstruction target) {
	13636	static IrInstGen ir_analyze_enum_to_int(IrAnalyze ira, IrInst source_instr, IrInstGen target) {
12566	13637	Error err;
12567	13638
12568		IrInstruction *enum_target;
	13639	IrInstGen *enum_target;
12569	13640	ZigType *enum_type;
12570	13641	if (target->value->type->id == ZigTypeIdUnion) {
12571		enum_type = ir_resolve_union_tag_type(ira, target, target->value->type);
	13642	enum_type = ir_resolve_union_tag_type(ira, target->base.source_node, target->value->type);
12572	13643	if (type_is_invalid(enum_type))
12573		return ira->codegen->invalid_instruction;
	13644	return ira->codegen->invalid_inst_gen;
12574	13645	enum_target = ir_implicit_cast(ira, target, enum_type);
12575	13646	if (type_is_invalid(enum_target->value->type))
12576		return ira->codegen->invalid_instruction;
	13647	return ira->codegen->invalid_inst_gen;
12577	13648	} else if (target->value->type->id == ZigTypeIdEnum) {
12578	13649	enum_target = target;
12579	13650	enum_type = target->value->type;
12580	13651	} else {
12581		ir_add_error(ira, target,
	13652	ir_add_error_node(ira, target->base.source_node,
12582	13653	buf_sprintf("expected enum, found type '%s'", buf_ptr(&target->value->type->name)));
12583		return ira->codegen->invalid_instruction;
	13654	return ira->codegen->invalid_inst_gen;
12584	13655	}
12585	13656
12586	13657	if ((err = type_resolve(ira->codegen, enum_type, ResolveStatusSizeKnown)))
12587		return ira->codegen->invalid_instruction;
	13658	return ira->codegen->invalid_inst_gen;
12588	13659
12589	13660	ZigType *tag_type = enum_type->data.enumeration.tag_int_type;
12590	13661	assert(tag_type->id == ZigTypeIdInt \|\| tag_type->id == ZigTypeIdComptimeInt);
...	...	@@ -12593,7 +13664,7 @@ static IrInstruction ir_analyze_enum_to_int(IrAnalyze ira, IrInstruction *sour
12593	13664	if (enum_type->data.enumeration.layout == ContainerLayoutAuto &&
12594	13665	enum_type->data.enumeration.src_field_count == 1)
12595	13666	{
12596		IrInstruction *result = ir_const(ira, source_instr, tag_type);
	13667	IrInstGen *result = ir_const(ira, source_instr, tag_type);
12597	13668	init_const_bigint(result->value, tag_type,
12598	13669	&enum_type->data.enumeration.fields[0].value);
12599	13670	return result;
...	...	@@ -12602,20 +13673,17 @@ static IrInstruction ir_analyze_enum_to_int(IrAnalyze ira, IrInstruction *sour
12602	13673	if (instr_is_comptime(enum_target)) {
12603	13674	ZigValue *val = ir_resolve_const(ira, enum_target, UndefBad);
12604	13675	if (!val)
12605		return ira->codegen->invalid_instruction;
12606		IrInstruction *result = ir_const(ira, source_instr, tag_type);
	13676	return ira->codegen->invalid_inst_gen;
	13677	IrInstGen *result = ir_const(ira, source_instr, tag_type);
12607	13678	init_const_bigint(result->value, tag_type, &val->data.x_enum_tag);
12608	13679	return result;
12609	13680	}
12610	13681
12611		IrInstruction *result = ir_build_widen_or_shorten(&ira->new_irb, source_instr->scope,
12612		source_instr->source_node, enum_target);
12613		result->value->type = tag_type;
12614		return result;
	13682	return ir_build_widen_or_shorten(ira, source_instr->scope, source_instr->source_node, enum_target, tag_type);
12615	13683	}
12616	13684
12617		static IrInstruction ir_analyze_union_to_tag(IrAnalyze ira, IrInstruction *source_instr,
12618		IrInstruction target, ZigType wanted_type)
	13685	static IrInstGen ir_analyze_union_to_tag(IrAnalyze ira, IrInst* source_instr,
	13686	IrInstGen target, ZigType wanted_type)
12619	13687	{
12620	13688	assert(target->value->type->id == ZigTypeIdUnion);
12621	13689	assert(wanted_type->id == ZigTypeIdEnum);
...	...	@@ -12624,8 +13692,8 @@ static IrInstruction ir_analyze_union_to_tag(IrAnalyze ira, IrInstruction *sou
12624	13692	if (instr_is_comptime(target)) {
12625	13693	ZigValue *val = ir_resolve_const(ira, target, UndefBad);
12626	13694	if (!val)
12627		return ira->codegen->invalid_instruction;
12628		IrInstruction *result = ir_const(ira, source_instr, wanted_type);
	13695	return ira->codegen->invalid_inst_gen;
	13696	IrInstGen *result = ir_const(ira, source_instr, wanted_type);
12629	13697	result->value->special = ConstValSpecialStatic;
12630	13698	result->value->type = wanted_type;
12631	13699	bigint_init_bigint(&result->value->data.x_enum_tag, &val->data.x_union.tag);
...	...	@@ -12636,7 +13704,7 @@ static IrInstruction ir_analyze_union_to_tag(IrAnalyze ira, IrInstruction *sou
12636	13704	if (wanted_type->data.enumeration.layout == ContainerLayoutAuto &&
12637	13705	wanted_type->data.enumeration.src_field_count == 1)
12638	13706	{
12639		IrInstruction *result = ir_const(ira, source_instr, wanted_type);
	13707	IrInstGen *result = ir_const(ira, source_instr, wanted_type);
12640	13708	result->value->special = ConstValSpecialStatic;
12641	13709	result->value->type = wanted_type;
12642	13710	TypeEnumField *enum_field = target->value->type->data.unionation.fields[0].enum_field;
...	...	@@ -12644,48 +13712,45 @@ static IrInstruction ir_analyze_union_to_tag(IrAnalyze ira, IrInstruction *sou
12644	13712	return result;
12645	13713	}
12646	13714
12647		IrInstruction *result = ir_build_union_tag(&ira->new_irb, source_instr->scope,
12648		source_instr->source_node, target);
12649		result->value->type = wanted_type;
12650		return result;
	13715	return ir_build_union_tag(ira, source_instr, target, wanted_type);
12651	13716	}
12652	13717
12653		static IrInstruction ir_analyze_undefined_to_anything(IrAnalyze ira, IrInstruction *source_instr,
12654		IrInstruction target, ZigType wanted_type)
	13718	static IrInstGen ir_analyze_undefined_to_anything(IrAnalyze ira, IrInst* source_instr,
	13719	IrInstGen target, ZigType wanted_type)
12655	13720	{
12656		IrInstruction *result = ir_const(ira, source_instr, wanted_type);
	13721	IrInstGen *result = ir_const(ira, source_instr, wanted_type);
12657	13722	result->value->special = ConstValSpecialUndef;
12658	13723	return result;
12659	13724	}
12660	13725
12661		static IrInstruction ir_analyze_enum_to_union(IrAnalyze ira, IrInstruction *source_instr,
12662		IrInstruction uncasted_target, ZigType wanted_type)
	13726	static IrInstGen ir_analyze_enum_to_union(IrAnalyze ira, IrInst* source_instr,
	13727	IrInstGen uncasted_target, ZigType wanted_type)
12663	13728	{
12664	13729	Error err;
12665	13730	assert(wanted_type->id == ZigTypeIdUnion);
12666	13731
12667	13732	if ((err = type_resolve(ira->codegen, wanted_type, ResolveStatusZeroBitsKnown)))
12668		return ira->codegen->invalid_instruction;
	13733	return ira->codegen->invalid_inst_gen;
12669	13734
12670		IrInstruction *target = ir_implicit_cast(ira, uncasted_target, wanted_type->data.unionation.tag_type);
	13735	IrInstGen *target = ir_implicit_cast(ira, uncasted_target, wanted_type->data.unionation.tag_type);
12671	13736	if (type_is_invalid(target->value->type))
12672		return ira->codegen->invalid_instruction;
	13737	return ira->codegen->invalid_inst_gen;
12673	13738
12674	13739	if (instr_is_comptime(target)) {
12675	13740	ZigValue *val = ir_resolve_const(ira, target, UndefBad);
12676	13741	if (!val)
12677		return ira->codegen->invalid_instruction;
	13742	return ira->codegen->invalid_inst_gen;
12678	13743	TypeUnionField *union_field = find_union_field_by_tag(wanted_type, &val->data.x_enum_tag);
12679	13744	assert(union_field != nullptr);
12680	13745	ZigType *field_type = resolve_union_field_type(ira->codegen, union_field);
12681	13746	if (field_type == nullptr)
12682		return ira->codegen->invalid_instruction;
	13747	return ira->codegen->invalid_inst_gen;
12683	13748	if ((err = type_resolve(ira->codegen, field_type, ResolveStatusZeroBitsKnown)))
12684		return ira->codegen->invalid_instruction;
	13749	return ira->codegen->invalid_inst_gen;
12685	13750
12686	13751	switch (type_has_one_possible_value(ira->codegen, field_type)) {
12687	13752	case OnePossibleValueInvalid:
12688		return ira->codegen->invalid_instruction;
	13753	return ira->codegen->invalid_inst_gen;
12689	13754	case OnePossibleValueNo: {
12690	13755	AstNode *field_node = wanted_type->data.unionation.decl_node->data.container_decl.fields.at(
12691	13756	union_field->enum_field->decl_index);
...	...	@@ -12696,13 +13761,13 @@ static IrInstruction ir_analyze_enum_to_union(IrAnalyze ira, IrInstruction *so
12696	13761	buf_ptr(union_field->name)));
12697	13762	add_error_note(ira->codegen, msg, field_node,
12698	13763	buf_sprintf("field '%s' declared here", buf_ptr(union_field->name)));
12699		return ira->codegen->invalid_instruction;
	13764	return ira->codegen->invalid_inst_gen;
12700	13765	}
12701	13766	case OnePossibleValueYes:
12702	13767	break;
12703	13768	}
12704	13769
12705		IrInstruction *result = ir_const(ira, source_instr, wanted_type);
	13770	IrInstGen *result = ir_const(ira, source_instr, wanted_type);
12706	13771	result->value->special = ConstValSpecialStatic;
12707	13772	result->value->type = wanted_type;
12708	13773	bigint_init_bigint(&result->value->data.x_union.tag, &val->data.x_enum_tag);
...	...	@@ -12715,9 +13780,7 @@ static IrInstruction ir_analyze_enum_to_union(IrAnalyze ira, IrInstruction *so
12715	13780	// if the union has all fields 0 bits, we can do it
12716	13781	// and in fact it's a noop cast because the union value is just the enum value
12717	13782	if (wanted_type->data.unionation.gen_field_count == 0) {
12718		IrInstruction *result = ir_build_cast(&ira->new_irb, target->scope, target->source_node, wanted_type, target, CastOpNoop);
12719		result->value->type = wanted_type;
12720		return result;
	13783	return ir_build_cast(ira, &target->base, wanted_type, target, CastOpNoop);
12721	13784	}
12722	13785
12723	13786	ErrorMsg *msg = ir_add_error(ira, source_instr,
...	...	@@ -12727,10 +13790,10 @@ static IrInstruction ir_analyze_enum_to_union(IrAnalyze ira, IrInstruction *so
12727	13790	TypeUnionField *union_field = &wanted_type->data.unionation.fields[i];
12728	13791	ZigType *field_type = resolve_union_field_type(ira->codegen, union_field);
12729	13792	if (field_type == nullptr)
12730		return ira->codegen->invalid_instruction;
	13793	return ira->codegen->invalid_inst_gen;
12731	13794	bool has_bits;
12732	13795	if ((err = type_has_bits2(ira->codegen, field_type, &has_bits)))
12733		return ira->codegen->invalid_instruction;
	13796	return ira->codegen->invalid_inst_gen;
12734	13797	if (has_bits) {
12735	13798	AstNode *field_node = wanted_type->data.unionation.decl_node->data.container_decl.fields.at(i);
12736	13799	add_error_note(ira->codegen, msg, field_node,
...	...	@@ -12739,23 +13802,23 @@ static IrInstruction ir_analyze_enum_to_union(IrAnalyze ira, IrInstruction *so
12739	13802	buf_ptr(&field_type->name)));
12740	13803	}
12741	13804	}
12742		return ira->codegen->invalid_instruction;
	13805	return ira->codegen->invalid_inst_gen;
12743	13806	}
12744	13807
12745		static IrInstruction ir_analyze_widen_or_shorten(IrAnalyze ira, IrInstruction *source_instr,
12746		IrInstruction target, ZigType wanted_type)
	13808	static IrInstGen ir_analyze_widen_or_shorten(IrAnalyze ira, IrInst* source_instr,
	13809	IrInstGen target, ZigType wanted_type)
12747	13810	{
12748	13811	assert(wanted_type->id == ZigTypeIdInt \|\| wanted_type->id == ZigTypeIdFloat);
12749	13812
12750	13813	if (instr_is_comptime(target)) {
12751	13814	ZigValue *val = ir_resolve_const(ira, target, UndefBad);
12752	13815	if (!val)
12753		return ira->codegen->invalid_instruction;
	13816	return ira->codegen->invalid_inst_gen;
12754	13817	if (wanted_type->id == ZigTypeIdInt) {
12755	13818	if (bigint_cmp_zero(&val->data.x_bigint) == CmpLT && !wanted_type->data.integral.is_signed) {
12756	13819	ir_add_error(ira, source_instr,
12757	13820	buf_sprintf("attempt to cast negative value to unsigned integer"));
12758		return ira->codegen->invalid_instruction;
	13821	return ira->codegen->invalid_inst_gen;
12759	13822	}
12760	13823	if (!bigint_fits_in_bits(&val->data.x_bigint, wanted_type->data.integral.bit_count,
12761	13824	wanted_type->data.integral.is_signed))
...	...	@@ -12763,10 +13826,10 @@ static IrInstruction ir_analyze_widen_or_shorten(IrAnalyze ira, IrInstruction
12763	13826	ir_add_error(ira, source_instr,
12764	13827	buf_sprintf("cast from '%s' to '%s' truncates bits",
12765	13828	buf_ptr(&target->value->type->name), buf_ptr(&wanted_type->name)));
12766		return ira->codegen->invalid_instruction;
	13829	return ira->codegen->invalid_inst_gen;
12767	13830	}
12768	13831	}
12769		IrInstruction *result = ir_const(ira, source_instr, wanted_type);
	13832	IrInstGen *result = ir_const(ira, source_instr, wanted_type);
12770	13833	result->value->type = wanted_type;
12771	13834	if (wanted_type->id == ZigTypeIdInt) {
12772	13835	bigint_init_bigint(&result->value->data.x_bigint, &val->data.x_bigint);
...	...	@@ -12783,19 +13846,16 @@ static IrInstruction ir_analyze_widen_or_shorten(IrAnalyze ira, IrInstruction
12783	13846	assert(wanted_type->id == ZigTypeIdInt);
12784	13847	assert(type_has_bits(target->value->type));
12785	13848	ir_build_assert_zero(ira, source_instr, target);
12786		IrInstruction *result = ir_const_unsigned(ira, source_instr, 0);
	13849	IrInstGen *result = ir_const_unsigned(ira, source_instr, 0);
12787	13850	result->value->type = wanted_type;
12788	13851	return result;
12789	13852	}
12790	13853
12791		IrInstruction *result = ir_build_widen_or_shorten(&ira->new_irb, source_instr->scope,
12792		source_instr->source_node, target);
12793		result->value->type = wanted_type;
12794		return result;
	13854	return ir_build_widen_or_shorten(ira, source_instr->scope, source_instr->source_node, target, wanted_type);
12795	13855	}
12796	13856
12797		static IrInstruction ir_analyze_int_to_enum(IrAnalyze ira, IrInstruction *source_instr,
12798		IrInstruction target, ZigType wanted_type)
	13857	static IrInstGen ir_analyze_int_to_enum(IrAnalyze ira, IrInst* source_instr,
	13858	IrInstGen target, ZigType wanted_type)
12799	13859	{
12800	13860	Error err;
12801	13861	assert(wanted_type->id == ZigTypeIdEnum);
...	...	@@ -12803,14 +13863,14 @@ static IrInstruction ir_analyze_int_to_enum(IrAnalyze ira, IrInstruction *sour
12803	13863	ZigType *actual_type = target->value->type;
12804	13864
12805	13865	if ((err = type_resolve(ira->codegen, wanted_type, ResolveStatusSizeKnown)))
12806		return ira->codegen->invalid_instruction;
	13866	return ira->codegen->invalid_inst_gen;
12807	13867
12808	13868	if (actual_type != wanted_type->data.enumeration.tag_int_type) {
12809	13869	ir_add_error(ira, source_instr,
12810	13870	buf_sprintf("integer to enum cast from '%s' instead of its tag type, '%s'",
12811	13871	buf_ptr(&actual_type->name),
12812	13872	buf_ptr(&wanted_type->data.enumeration.tag_int_type->name)));
12813		return ira->codegen->invalid_instruction;
	13873	return ira->codegen->invalid_inst_gen;
12814	13874	}
12815	13875
12816	13876	assert(actual_type->id == ZigTypeIdInt \|\| actual_type->id == ZigTypeIdComptimeInt);
...	...	@@ -12818,7 +13878,7 @@ static IrInstruction ir_analyze_int_to_enum(IrAnalyze ira, IrInstruction *sour
12818	13878	if (instr_is_comptime(target)) {
12819	13879	ZigValue *val = ir_resolve_const(ira, target, UndefBad);
12820	13880	if (!val)
12821		return ira->codegen->invalid_instruction;
	13881	return ira->codegen->invalid_inst_gen;
12822	13882
12823	13883	TypeEnumField *field = find_enum_field_by_tag(wanted_type, &val->data.x_bigint);
12824	13884	if (field == nullptr && !wanted_type->data.enumeration.non_exhaustive) {
...	...	@@ -12829,28 +13889,25 @@ static IrInstruction ir_analyze_int_to_enum(IrAnalyze ira, IrInstruction *sour
12829	13889	buf_ptr(&wanted_type->name), buf_ptr(val_buf)));
12830	13890	add_error_note(ira->codegen, msg, wanted_type->data.enumeration.decl_node,
12831	13891	buf_sprintf("'%s' declared here", buf_ptr(&wanted_type->name)));
12832		return ira->codegen->invalid_instruction;
	13892	return ira->codegen->invalid_inst_gen;
12833	13893	}
12834	13894
12835		IrInstruction *result = ir_const(ira, source_instr, wanted_type);
	13895	IrInstGen *result = ir_const(ira, source_instr, wanted_type);
12836	13896	bigint_init_bigint(&result->value->data.x_enum_tag, &val->data.x_bigint);
12837	13897	return result;
12838	13898	}
12839	13899
12840		IrInstruction *result = ir_build_int_to_enum(&ira->new_irb, source_instr->scope,
12841		source_instr->source_node, nullptr, target);
12842		result->value->type = wanted_type;
12843		return result;
	13900	return ir_build_int_to_enum_gen(ira, source_instr->scope, source_instr->source_node, wanted_type, target);
12844	13901	}
12845	13902
12846		static IrInstruction ir_analyze_number_to_literal(IrAnalyze ira, IrInstruction *source_instr,
12847		IrInstruction target, ZigType wanted_type)
	13903	static IrInstGen ir_analyze_number_to_literal(IrAnalyze ira, IrInst* source_instr,
	13904	IrInstGen target, ZigType wanted_type)
12848	13905	{
12849	13906	ZigValue *val = ir_resolve_const(ira, target, UndefBad);
12850	13907	if (!val)
12851		return ira->codegen->invalid_instruction;
	13908	return ira->codegen->invalid_inst_gen;
12852	13909
12853		IrInstruction *result = ir_const(ira, source_instr, wanted_type);
	13910	IrInstGen *result = ir_const(ira, source_instr, wanted_type);
12854	13911	if (wanted_type->id == ZigTypeIdComptimeFloat) {
12855	13912	float_init_float(result->value, val);
12856	13913	} else if (wanted_type->id == ZigTypeIdComptimeInt) {
...	...	@@ -12861,7 +13918,7 @@ static IrInstruction ir_analyze_number_to_literal(IrAnalyze ira, IrInstruction
12861	13918	return result;
12862	13919	}
12863	13920
12864		static IrInstruction ir_analyze_int_to_err(IrAnalyze ira, IrInstruction source_instr, IrInstruction target,
	13921	static IrInstGen ir_analyze_int_to_err(IrAnalyze ira, IrInst* source_instr, IrInstGen *target,
12865	13922	ZigType *wanted_type)
12866	13923	{
12867	13924	assert(target->value->type->id == ZigTypeIdInt);
...	...	@@ -12871,12 +13928,12 @@ static IrInstruction ir_analyze_int_to_err(IrAnalyze ira, IrInstruction *sourc
12871	13928	if (instr_is_comptime(target)) {
12872	13929	ZigValue *val = ir_resolve_const(ira, target, UndefBad);
12873	13930	if (!val)
12874		return ira->codegen->invalid_instruction;
	13931	return ira->codegen->invalid_inst_gen;
12875	13932
12876		IrInstruction *result = ir_const(ira, source_instr, wanted_type);
	13933	IrInstGen *result = ir_const(ira, source_instr, wanted_type);
12877	13934
12878	13935	if (!resolve_inferred_error_set(ira->codegen, wanted_type, source_instr->source_node)) {
12879		return ira->codegen->invalid_instruction;
	13936	return ira->codegen->invalid_inst_gen;
12880	13937	}
12881	13938
12882	13939	if (type_is_global_error_set(wanted_type)) {
...	...	@@ -12888,7 +13945,7 @@ static IrInstruction ir_analyze_int_to_err(IrAnalyze ira, IrInstruction *sourc
12888	13945	bigint_append_buf(val_buf, &val->data.x_bigint, 10);
12889	13946	ir_add_error(ira, source_instr,
12890	13947	buf_sprintf("integer value %s represents no error", buf_ptr(val_buf)));
12891		return ira->codegen->invalid_instruction;
	13948	return ira->codegen->invalid_inst_gen;
12892	13949	}
12893	13950
12894	13951	size_t index = bigint_as_usize(&val->data.x_bigint);
...	...	@@ -12912,7 +13969,7 @@ static IrInstruction ir_analyze_int_to_err(IrAnalyze ira, IrInstruction *sourc
12912	13969	bigint_append_buf(val_buf, &val->data.x_bigint, 10);
12913	13970	ir_add_error(ira, source_instr,
12914	13971	buf_sprintf("integer value %s represents no error in '%s'", buf_ptr(val_buf), buf_ptr(&wanted_type->name)));
12915		return ira->codegen->invalid_instruction;
	13972	return ira->codegen->invalid_inst_gen;
12916	13973	}
12917	13974
12918	13975	result->value->data.x_err_set = err;
...	...	@@ -12920,12 +13977,10 @@ static IrInstruction ir_analyze_int_to_err(IrAnalyze ira, IrInstruction *sourc
12920	13977	}
12921	13978	}
12922	13979
12923		IrInstruction *result = ir_build_int_to_err(&ira->new_irb, source_instr->scope, source_instr->source_node, target);
12924		result->value->type = wanted_type;
12925		return result;
	13980	return ir_build_int_to_err_gen(ira, source_instr->scope, source_instr->source_node, target, wanted_type);
12926	13981	}
12927	13982
12928		static IrInstruction ir_analyze_err_to_int(IrAnalyze ira, IrInstruction source_instr, IrInstruction target,
	13983	static IrInstGen ir_analyze_err_to_int(IrAnalyze ira, IrInst* source_instr, IrInstGen *target,
12929	13984	ZigType *wanted_type)
12930	13985	{
12931	13986	assert(wanted_type->id == ZigTypeIdInt);
...	...	@@ -12935,9 +13990,9 @@ static IrInstruction ir_analyze_err_to_int(IrAnalyze ira, IrInstruction *sourc
12935	13990	if (instr_is_comptime(target)) {
12936	13991	ZigValue *val = ir_resolve_const(ira, target, UndefBad);
12937	13992	if (!val)
12938		return ira->codegen->invalid_instruction;
	13993	return ira->codegen->invalid_inst_gen;
12939	13994
12940		IrInstruction *result = ir_const(ira, source_instr, wanted_type);
	13995	IrInstGen *result = ir_const(ira, source_instr, wanted_type);
12941	13996
12942	13997	ErrorTableEntry *err;
12943	13998	if (err_type->id == ZigTypeIdErrorUnion) {
...	...	@@ -12957,7 +14012,7 @@ static IrInstruction ir_analyze_err_to_int(IrAnalyze ira, IrInstruction *sourc
12957	14012	ir_add_error_node(ira, source_instr->source_node,
12958	14013	buf_sprintf("error code '%s' does not fit in '%s'",
12959	14014	buf_ptr(&err->name), buf_ptr(&wanted_type->name)));
12960		return ira->codegen->invalid_instruction;
	14015	return ira->codegen->invalid_inst_gen;
12961	14016	}
12962	14017
12963	14018	return result;
...	...	@@ -12973,14 +14028,14 @@ static IrInstruction ir_analyze_err_to_int(IrAnalyze ira, IrInstruction *sourc
12973	14028	}
12974	14029	if (!type_is_global_error_set(err_set_type)) {
12975	14030	if (!resolve_inferred_error_set(ira->codegen, err_set_type, source_instr->source_node)) {
12976		return ira->codegen->invalid_instruction;
	14031	return ira->codegen->invalid_inst_gen;
12977	14032	}
12978	14033	if (err_set_type->data.error_set.err_count == 0) {
12979		IrInstruction *result = ir_const(ira, source_instr, wanted_type);
	14034	IrInstGen *result = ir_const(ira, source_instr, wanted_type);
12980	14035	bigint_init_unsigned(&result->value->data.x_bigint, 0);
12981	14036	return result;
12982	14037	} else if (err_set_type->data.error_set.err_count == 1) {
12983		IrInstruction *result = ir_const(ira, source_instr, wanted_type);
	14038	IrInstGen *result = ir_const(ira, source_instr, wanted_type);
12984	14039	ErrorTableEntry *err = err_set_type->data.error_set.errors[0];
12985	14040	bigint_init_unsigned(&result->value->data.x_bigint, err->value);
12986	14041	return result;
...	...	@@ -12992,21 +14047,19 @@ static IrInstruction ir_analyze_err_to_int(IrAnalyze ira, IrInstruction *sourc
12992	14047	if (!bigint_fits_in_bits(&bn, wanted_type->data.integral.bit_count, wanted_type->data.integral.is_signed)) {
12993	14048	ir_add_error_node(ira, source_instr->source_node,
12994	14049	buf_sprintf("too many error values to fit in '%s'", buf_ptr(&wanted_type->name)));
12995		return ira->codegen->invalid_instruction;
	14050	return ira->codegen->invalid_inst_gen;
12996	14051	}
12997	14052
12998		IrInstruction *result = ir_build_err_to_int(&ira->new_irb, source_instr->scope, source_instr->source_node, target);
12999		result->value->type = wanted_type;
13000		return result;
	14053	return ir_build_err_to_int_gen(ira, source_instr->scope, source_instr->source_node, target, wanted_type);
13001	14054	}
13002	14055
13003		static IrInstruction ir_analyze_ptr_to_array(IrAnalyze ira, IrInstruction source_instr, IrInstruction target,
	14056	static IrInstGen ir_analyze_ptr_to_array(IrAnalyze ira, IrInst* source_instr, IrInstGen *target,
13004	14057	ZigType *wanted_type)
13005	14058	{
13006	14059	assert(wanted_type->id == ZigTypeIdPointer);
13007	14060	Error err;
13008	14061	if ((err = type_resolve(ira->codegen, target->value->type->data.pointer.child_type, ResolveStatusAlignmentKnown)))
13009		return ira->codegen->invalid_instruction;
	14062	return ira->codegen->invalid_inst_gen;
13010	14063	assert((wanted_type->data.pointer.is_const && target->value->type->data.pointer.is_const) \|\| !target->value->type->data.pointer.is_const);
13011	14064	wanted_type = adjust_ptr_align(ira->codegen, wanted_type, get_ptr_align(ira->codegen, target->value->type));
13012	14065	ZigType *array_type = wanted_type->data.pointer.child_type;
...	...	@@ -13016,12 +14069,12 @@ static IrInstruction ir_analyze_ptr_to_array(IrAnalyze ira, IrInstruction *sou
13016	14069	if (instr_is_comptime(target)) {
13017	14070	ZigValue *val = ir_resolve_const(ira, target, UndefBad);
13018	14071	if (!val)
13019		return ira->codegen->invalid_instruction;
	14072	return ira->codegen->invalid_inst_gen;
13020	14073
13021	14074	assert(val->type->id == ZigTypeIdPointer);
13022	14075	ZigValue *pointee = const_ptr_pointee(ira, ira->codegen, val, source_instr->source_node);
13023	14076	if (pointee == nullptr)
13024		return ira->codegen->invalid_instruction;
	14077	return ira->codegen->invalid_inst_gen;
13025	14078	if (pointee->special != ConstValSpecialRuntime) {
13026	14079	ZigValue *array_val = create_const_vals(1);
13027	14080	array_val->special = ConstValSpecialStatic;
...	...	@@ -13031,7 +14084,7 @@ static IrInstruction ir_analyze_ptr_to_array(IrAnalyze ira, IrInstruction *sou
13031	14084	array_val->parent.id = ConstParentIdScalar;
13032	14085	array_val->parent.data.p_scalar.scalar_val = pointee;
13033	14086
13034		IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(&ira->new_irb,
	14087	IrInstGenConst *const_instruction = ir_create_inst_gen<IrInstGenConst>(&ira->new_irb,
13035	14088	source_instr->scope, source_instr->source_node);
13036	14089	const_instruction->base.value->type = wanted_type;
13037	14090	const_instruction->base.value->special = ConstValSpecialStatic;
...	...	@@ -13043,10 +14096,7 @@ static IrInstruction ir_analyze_ptr_to_array(IrAnalyze ira, IrInstruction *sou
13043	14096	}
13044	14097
13045	14098	// pointer to array and pointer to single item are represented the same way at runtime
13046		IrInstruction *result = ir_build_cast(&ira->new_irb, target->scope, target->source_node,
13047		wanted_type, target, CastOpBitCast);
13048		result->value->type = wanted_type;
13049		return result;
	14099	return ir_build_cast(ira, &target->base, wanted_type, target, CastOpBitCast);
13050	14100	}
13051	14101
13052	14102	static void report_recursive_error(IrAnalyze ira, AstNode source_node, ConstCastOnly *cast_result,
...	...	@@ -13234,12 +14284,12 @@ static void report_recursive_error(IrAnalyze ira, AstNode source_node, ConstCa
13234	14284	}
13235	14285	}
13236	14286
13237		static IrInstruction ir_analyze_array_to_vector(IrAnalyze ira, IrInstruction *source_instr,
13238		IrInstruction array, ZigType vector_type)
	14287	static IrInstGen ir_analyze_array_to_vector(IrAnalyze ira, IrInst* source_instr,
	14288	IrInstGen array, ZigType vector_type)
13239	14289	{
13240	14290	if (instr_is_comptime(array)) {
13241	14291	// arrays and vectors have the same ZigValue representation
13242		IrInstruction *result = ir_const(ira, source_instr, vector_type);
	14292	IrInstGen *result = ir_const(ira, source_instr, vector_type);
13243	14293	copy_const_val(result->value, array->value);
13244	14294	result->value->type = vector_type;
13245	14295	return result;
...	...	@@ -13247,12 +14297,12 @@ static IrInstruction ir_analyze_array_to_vector(IrAnalyze ira, IrInstruction *
13247	14297	return ir_build_array_to_vector(ira, source_instr, array, vector_type);
13248	14298	}
13249	14299
13250		static IrInstruction ir_analyze_vector_to_array(IrAnalyze ira, IrInstruction *source_instr,
13251		IrInstruction vector, ZigType array_type, ResultLoc *result_loc)
	14300	static IrInstGen ir_analyze_vector_to_array(IrAnalyze ira, IrInst* source_instr,
	14301	IrInstGen vector, ZigType array_type, ResultLoc *result_loc)
13252	14302	{
13253	14303	if (instr_is_comptime(vector)) {
13254	14304	// arrays and vectors have the same ZigValue representation
13255		IrInstruction *result = ir_const(ira, source_instr, array_type);
	14305	IrInstGen *result = ir_const(ira, source_instr, array_type);
13256	14306	copy_const_val(result->value, vector->value);
13257	14307	result->value->type = array_type;
13258	14308	return result;
...	...	@@ -13260,18 +14310,18 @@ static IrInstruction ir_analyze_vector_to_array(IrAnalyze ira, IrInstruction *
13260	14310	if (result_loc == nullptr) {
13261	14311	result_loc = no_result_loc();
13262	14312	}
13263		IrInstruction *result_loc_inst = ir_resolve_result(ira, source_instr, result_loc, array_type, nullptr,
	14313	IrInstGen *result_loc_inst = ir_resolve_result(ira, source_instr, result_loc, array_type, nullptr,
13264	14314	true, false, true);
13265		if (type_is_invalid(result_loc_inst->value->type) \|\| instr_is_unreachable(result_loc_inst)) {
	14315	if (type_is_invalid(result_loc_inst->value->type) \|\| result_loc_inst->value->type->id == ZigTypeIdUnreachable) {
13266	14316	return result_loc_inst;
13267	14317	}
13268	14318	return ir_build_vector_to_array(ira, source_instr, array_type, vector, result_loc_inst);
13269	14319	}
13270	14320
13271		static IrInstruction ir_analyze_int_to_c_ptr(IrAnalyze ira, IrInstruction *source_instr,
13272		IrInstruction integer, ZigType dest_type)
	14321	static IrInstGen ir_analyze_int_to_c_ptr(IrAnalyze ira, IrInst* source_instr,
	14322	IrInstGen integer, ZigType dest_type)
13273	14323	{
13274		IrInstruction *unsigned_integer;
	14324	IrInstGen *unsigned_integer;
13275	14325	if (instr_is_comptime(integer)) {
13276	14326	unsigned_integer = integer;
13277	14327	} else {
...	...	@@ -13284,7 +14334,7 @@ static IrInstruction ir_analyze_int_to_c_ptr(IrAnalyze ira, IrInstruction *sou
13284	14334	buf_sprintf("integer type '%s' too big for implicit @intToPtr to type '%s'",
13285	14335	buf_ptr(&integer->value->type->name),
13286	14336	buf_ptr(&dest_type->name)));
13287		return ira->codegen->invalid_instruction;
	14337	return ira->codegen->invalid_inst_gen;
13288	14338	}
13289	14339
13290	14340	if (integer->value->type->data.integral.is_signed) {
...	...	@@ -13292,7 +14342,7 @@ static IrInstruction ir_analyze_int_to_c_ptr(IrAnalyze ira, IrInstruction *sou
13292	14342	integer->value->type->data.integral.bit_count);
13293	14343	unsigned_integer = ir_analyze_bit_cast(ira, source_instr, integer, unsigned_int_type);
13294	14344	if (type_is_invalid(unsigned_integer->value->type))
13295		return ira->codegen->invalid_instruction;
	14345	return ira->codegen->invalid_inst_gen;
13296	14346	} else {
13297	14347	unsigned_integer = integer;
13298	14348	}
...	...	@@ -13312,14 +14362,14 @@ static bool is_pointery_and_elem_is_not_pointery(ZigType *ty) {
13312	14362	return false;
13313	14363	}
13314	14364
13315		static IrInstruction ir_analyze_enum_literal(IrAnalyze ira, IrInstruction source_instr, IrInstruction value,
	14365	static IrInstGen ir_analyze_enum_literal(IrAnalyze ira, IrInst* source_instr, IrInstGen *value,
13316	14366	ZigType *enum_type)
13317	14367	{
13318	14368	assert(enum_type->id == ZigTypeIdEnum);
13319	14369
13320	14370	Error err;
13321	14371	if ((err = type_resolve(ira->codegen, enum_type, ResolveStatusZeroBitsKnown)))
13322		return ira->codegen->invalid_instruction;
	14372	return ira->codegen->invalid_inst_gen;
13323	14373
13324	14374	TypeEnumField *field = find_enum_type_field(enum_type, value->value->data.x_enum_literal);
13325	14375	if (field == nullptr) {
...	...	@@ -13327,40 +14377,40 @@ static IrInstruction ir_analyze_enum_literal(IrAnalyze ira, IrInstruction *sou
13327	14377	buf_ptr(&enum_type->name), buf_ptr(value->value->data.x_enum_literal)));
13328	14378	add_error_note(ira->codegen, msg, enum_type->data.enumeration.decl_node,
13329	14379	buf_sprintf("'%s' declared here", buf_ptr(&enum_type->name)));
13330		return ira->codegen->invalid_instruction;
	14380	return ira->codegen->invalid_inst_gen;
13331	14381	}
13332		IrInstruction *result = ir_const(ira, source_instr, enum_type);
	14382	IrInstGen *result = ir_const(ira, source_instr, enum_type);
13333	14383	bigint_init_bigint(&result->value->data.x_enum_tag, &field->value);
13334	14384
13335	14385	return result;
13336	14386	}
13337	14387
13338		static IrInstruction ir_analyze_struct_literal_to_array(IrAnalyze ira, IrInstruction *source_instr,
13339		IrInstruction value, ZigType wanted_type)
	14388	static IrInstGen ir_analyze_struct_literal_to_array(IrAnalyze ira, IrInst* source_instr,
	14389	IrInstGen value, ZigType wanted_type)
13340	14390	{
13341	14391	ir_add_error(ira, source_instr, buf_sprintf("TODO: type coercion of anon list literal to array"));
13342		return ira->codegen->invalid_instruction;
	14392	return ira->codegen->invalid_inst_gen;
13343	14393	}
13344	14394
13345		static IrInstruction ir_analyze_struct_literal_to_struct(IrAnalyze ira, IrInstruction *source_instr,
13346		IrInstruction value, ZigType wanted_type)
	14395	static IrInstGen ir_analyze_struct_literal_to_struct(IrAnalyze ira, IrInst* source_instr,
	14396	IrInstGen value, ZigType wanted_type)
13347	14397	{
13348	14398	ir_add_error(ira, source_instr, buf_sprintf("TODO: type coercion of anon struct literal to struct"));
13349		return ira->codegen->invalid_instruction;
	14399	return ira->codegen->invalid_inst_gen;
13350	14400	}
13351	14401
13352		static IrInstruction ir_analyze_struct_literal_to_union(IrAnalyze ira, IrInstruction *source_instr,
13353		IrInstruction value, ZigType wanted_type)
	14402	static IrInstGen ir_analyze_struct_literal_to_union(IrAnalyze ira, IrInst* source_instr,
	14403	IrInstGen value, ZigType wanted_type)
13354	14404	{
13355	14405	ir_add_error(ira, source_instr, buf_sprintf("TODO: type coercion of anon struct literal to union"));
13356		return ira->codegen->invalid_instruction;
	14406	return ira->codegen->invalid_inst_gen;
13357	14407	}
13358	14408
13359	14409	// Add a compile error and return ErrorSemanticAnalyzeFail if the pointer alignment does not work,
13360	14410	// otherwise return ErrorNone. Does not emit any instructions.
13361	14411	// Assumes that the pointer types have element types with the same ABI alignment. Avoids resolving the
13362	14412	// pointer types' alignments if both of the pointer types are ABI aligned.
13363		static Error ir_cast_ptr_align(IrAnalyze ira, IrInstruction source_instr, ZigType *dest_ptr_type,
	14413	static Error ir_cast_ptr_align(IrAnalyze ira, IrInst source_instr, ZigType *dest_ptr_type,
13364	14414	ZigType src_ptr_type, AstNode src_source_node)
13365	14415	{
13366	14416	Error err;
...	...	@@ -13394,37 +14444,37 @@ static Error ir_cast_ptr_align(IrAnalyze ira, IrInstruction source_instr, ZigT
13394	14444	return ErrorNone;
13395	14445	}
13396	14446
13397		static IrInstruction ir_analyze_struct_value_field_value(IrAnalyze ira, IrInstruction *source_instr,
13398		IrInstruction struct_operand, TypeStructField field)
	14447	static IrInstGen ir_analyze_struct_value_field_value(IrAnalyze ira, IrInst* source_instr,
	14448	IrInstGen struct_operand, TypeStructField field)
13399	14449	{
13400		IrInstruction *struct_ptr = ir_get_ref(ira, source_instr, struct_operand, true, false);
	14450	IrInstGen *struct_ptr = ir_get_ref(ira, source_instr, struct_operand, true, false);
13401	14451	if (type_is_invalid(struct_ptr->value->type))
13402		return ira->codegen->invalid_instruction;
13403		IrInstruction *field_ptr = ir_analyze_struct_field_ptr(ira, source_instr, field, struct_ptr,
	14452	return ira->codegen->invalid_inst_gen;
	14453	IrInstGen *field_ptr = ir_analyze_struct_field_ptr(ira, source_instr, field, struct_ptr,
13404	14454	struct_operand->value->type, false);
13405	14455	if (type_is_invalid(field_ptr->value->type))
13406		return ira->codegen->invalid_instruction;
	14456	return ira->codegen->invalid_inst_gen;
13407	14457	return ir_get_deref(ira, source_instr, field_ptr, nullptr);
13408	14458	}
13409	14459
13410		static IrInstruction ir_analyze_optional_value_payload_value(IrAnalyze ira, IrInstruction *source_instr,
13411		IrInstruction *optional_operand, bool safety_check_on)
	14460	static IrInstGen ir_analyze_optional_value_payload_value(IrAnalyze ira, IrInst* source_instr,
	14461	IrInstGen *optional_operand, bool safety_check_on)
13412	14462	{
13413		IrInstruction *opt_ptr = ir_get_ref(ira, source_instr, optional_operand, true, false);
13414		IrInstruction *payload_ptr = ir_analyze_unwrap_optional_payload(ira, source_instr, opt_ptr,
	14463	IrInstGen *opt_ptr = ir_get_ref(ira, source_instr, optional_operand, true, false);
	14464	IrInstGen *payload_ptr = ir_analyze_unwrap_optional_payload(ira, source_instr, opt_ptr,
13415	14465	safety_check_on, false);
13416	14466	return ir_get_deref(ira, source_instr, payload_ptr, nullptr);
13417	14467	}
13418	14468
13419		static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_instr,
13420		ZigType wanted_type, IrInstruction value)
	14469	static IrInstGen ir_analyze_cast(IrAnalyze ira, IrInst *source_instr,
	14470	ZigType wanted_type, IrInstGen value)
13421	14471	{
13422	14472	Error err;
13423	14473	ZigType *actual_type = value->value->type;
13424	14474	AstNode *source_node = source_instr->source_node;
13425	14475
13426	14476	if (type_is_invalid(wanted_type) \|\| type_is_invalid(actual_type)) {
13427		return ira->codegen->invalid_instruction;
	14477	return ira->codegen->invalid_inst_gen;
13428	14478	}
13429	14479
13430	14480	// This means the wanted type is anything.
...	...	@@ -13436,7 +14486,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
13436	14486	ConstCastOnly const_cast_result = types_match_const_cast_only(ira, wanted_type, actual_type,
13437	14487	source_node, false);
13438	14488	if (const_cast_result.id == ConstCastResultIdInvalid)
13439		return ira->codegen->invalid_instruction;
	14489	return ira->codegen->invalid_inst_gen;
13440	14490	if (const_cast_result.id == ConstCastResultIdOk) {
13441	14491	return ir_resolve_cast(ira, source_instr, value, wanted_type, CastOpNoop);
13442	14492	}
...	...	@@ -13470,7 +14520,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
13470	14520	if (ir_num_lit_fits_in_other_type(ira, value, wanted_child_type, true)) {
13471	14521	return ir_analyze_optional_wrap(ira, source_instr, value, wanted_type, nullptr);
13472	14522	} else {
13473		return ira->codegen->invalid_instruction;
	14523	return ira->codegen->invalid_inst_gen;
13474	14524	}
13475	14525	} else if (
13476	14526	wanted_child_type->id == ZigTypeIdPointer &&
...	...	@@ -13480,18 +14530,18 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
13480	14530	actual_type->data.pointer.child_type->id == ZigTypeIdArray)
13481	14531	{
13482	14532	if ((err = type_resolve(ira->codegen, actual_type->data.pointer.child_type, ResolveStatusAlignmentKnown)))
13483		return ira->codegen->invalid_instruction;
	14533	return ira->codegen->invalid_inst_gen;
13484	14534	if ((err = type_resolve(ira->codegen, wanted_child_type->data.pointer.child_type, ResolveStatusAlignmentKnown)))
13485		return ira->codegen->invalid_instruction;
	14535	return ira->codegen->invalid_inst_gen;
13486	14536	if (get_ptr_align(ira->codegen, actual_type) >= get_ptr_align(ira->codegen, wanted_child_type) &&
13487	14537	types_match_const_cast_only(ira, wanted_child_type->data.pointer.child_type,
13488	14538	actual_type->data.pointer.child_type->data.array.child_type, source_node,
13489	14539	!wanted_child_type->data.pointer.is_const).id == ConstCastResultIdOk)
13490	14540	{
13491		IrInstruction *cast1 = ir_resolve_ptr_of_array_to_unknown_len_ptr(ira, source_instr, value,
	14541	IrInstGen *cast1 = ir_resolve_ptr_of_array_to_unknown_len_ptr(ira, source_instr, value,
13492	14542	wanted_child_type);
13493	14543	if (type_is_invalid(cast1->value->type))
13494		return ira->codegen->invalid_instruction;
	14544	return ira->codegen->invalid_inst_gen;
13495	14545	return ir_analyze_optional_wrap(ira, source_instr, cast1, wanted_type, nullptr);
13496	14546	}
13497	14547	}
...	...	@@ -13509,7 +14559,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
13509	14559	if (ir_num_lit_fits_in_other_type(ira, value, wanted_type->data.error_union.payload_type, true)) {
13510	14560	return ir_analyze_err_wrap_payload(ira, source_instr, value, wanted_type, nullptr);
13511	14561	} else {
13512		return ira->codegen->invalid_instruction;
	14562	return ira->codegen->invalid_inst_gen;
13513	14563	}
13514	14564	}
13515	14565	}
...	...	@@ -13525,13 +14575,13 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
13525	14575	actual_type->id == ZigTypeIdComptimeInt \|\|
13526	14576	actual_type->id == ZigTypeIdComptimeFloat)
13527	14577	{
13528		IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, wanted_type->data.error_union.payload_type, value);
	14578	IrInstGen *cast1 = ir_analyze_cast(ira, source_instr, wanted_type->data.error_union.payload_type, value);
13529	14579	if (type_is_invalid(cast1->value->type))
13530		return ira->codegen->invalid_instruction;
	14580	return ira->codegen->invalid_inst_gen;
13531	14581
13532		IrInstruction *cast2 = ir_analyze_cast(ira, source_instr, wanted_type, cast1);
	14582	IrInstGen *cast2 = ir_analyze_cast(ira, source_instr, wanted_type, cast1);
13533	14583	if (type_is_invalid(cast2->value->type))
13534		return ira->codegen->invalid_instruction;
	14584	return ira->codegen->invalid_inst_gen;
13535	14585
13536	14586	return cast2;
13537	14587	}
...	...	@@ -13546,13 +14596,13 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
13546	14596	wanted_type->id == ZigTypeIdFloat \|\| wanted_type->id == ZigTypeIdComptimeFloat))
13547	14597	{
13548	14598	if (value->value->special == ConstValSpecialUndef) {
13549		IrInstruction *result = ir_const(ira, source_instr, wanted_type);
	14599	IrInstGen *result = ir_const(ira, source_instr, wanted_type);
13550	14600	result->value->special = ConstValSpecialUndef;
13551	14601	return result;
13552	14602	}
13553	14603	if (ir_num_lit_fits_in_other_type(ira, value, wanted_type, true)) {
13554	14604	if (wanted_type->id == ZigTypeIdComptimeInt \|\| wanted_type->id == ZigTypeIdInt) {
13555		IrInstruction *result = ir_const(ira, source_instr, wanted_type);
	14605	IrInstGen *result = ir_const(ira, source_instr, wanted_type);
13556	14606	if (actual_type->id == ZigTypeIdComptimeInt \|\| actual_type->id == ZigTypeIdInt) {
13557	14607	copy_const_val(result->value, value->value);
13558	14608	result->value->type = wanted_type;
...	...	@@ -13561,7 +14611,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
13561	14611	}
13562	14612	return result;
13563	14613	} else if (wanted_type->id == ZigTypeIdComptimeFloat \|\| wanted_type->id == ZigTypeIdFloat) {
13564		IrInstruction *result = ir_const(ira, source_instr, wanted_type);
	14614	IrInstGen *result = ir_const(ira, source_instr, wanted_type);
13565	14615	if (actual_type->id == ZigTypeIdComptimeInt \|\| actual_type->id == ZigTypeIdInt) {
13566	14616	BigFloat bf;
13567	14617	bigfloat_init_bigint(&bf, &value->value->data.x_bigint);
...	...	@@ -13573,7 +14623,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
13573	14623	}
13574	14624	zig_unreachable();
13575	14625	} else {
13576		return ira->codegen->invalid_instruction;
	14626	return ira->codegen->invalid_inst_gen;
13577	14627	}
13578	14628	}
13579	14629
...	...	@@ -13609,13 +14659,13 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
13609	14659	actual_type->data.pointer.ptr_len == PtrLenSingle &&
13610	14660	actual_type->data.pointer.child_type->id == ZigTypeIdArray)
13611	14661	{
13612		IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, wanted_type->data.maybe.child_type, value);
	14662	IrInstGen *cast1 = ir_analyze_cast(ira, source_instr, wanted_type->data.maybe.child_type, value);
13613	14663	if (type_is_invalid(cast1->value->type))
13614		return ira->codegen->invalid_instruction;
	14664	return ira->codegen->invalid_inst_gen;
13615	14665
13616		IrInstruction *cast2 = ir_analyze_cast(ira, source_instr, wanted_type, cast1);
	14666	IrInstGen *cast2 = ir_analyze_cast(ira, source_instr, wanted_type, cast1);
13617	14667	if (type_is_invalid(cast2->value->type))
13618		return ira->codegen->invalid_instruction;
	14668	return ira->codegen->invalid_inst_gen;
13619	14669
13620	14670	return cast2;
13621	14671	}
...	...	@@ -13636,9 +14686,9 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
13636	14686	actual_array_type->data.array.sentinel)))
13637	14687	{
13638	14688	if ((err = type_resolve(ira->codegen, actual_type->data.pointer.child_type, ResolveStatusAlignmentKnown)))
13639		return ira->codegen->invalid_instruction;
	14689	return ira->codegen->invalid_inst_gen;
13640	14690	if ((err = type_resolve(ira->codegen, wanted_type->data.pointer.child_type, ResolveStatusAlignmentKnown)))
13641		return ira->codegen->invalid_instruction;
	14691	return ira->codegen->invalid_inst_gen;
13642	14692	if (get_ptr_align(ira->codegen, actual_type) >= get_ptr_align(ira->codegen, wanted_type) &&
13643	14693	types_match_const_cast_only(ira, wanted_type->data.pointer.child_type,
13644	14694	actual_type->data.pointer.child_type->data.array.child_type, source_node,
...	...	@@ -13679,24 +14729,24 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
13679	14729	if ((err = type_resolve(ira->codegen, actual_type->data.pointer.child_type,
13680	14730	ResolveStatusAlignmentKnown)))
13681	14731	{
13682		return ira->codegen->invalid_instruction;
	14732	return ira->codegen->invalid_inst_gen;
13683	14733	}
13684	14734	if ((err = type_resolve(ira->codegen, slice_ptr_type->data.pointer.child_type,
13685	14735	ResolveStatusAlignmentKnown)))
13686	14736	{
13687		return ira->codegen->invalid_instruction;
	14737	return ira->codegen->invalid_inst_gen;
13688	14738	}
13689	14739	ok_align = get_ptr_align(ira->codegen, actual_type) >= get_ptr_align(ira->codegen, slice_ptr_type);
13690	14740	}
13691	14741	if (ok_align) {
13692	14742	if (wanted_type->id == ZigTypeIdErrorUnion) {
13693		IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, slice_type, value);
	14743	IrInstGen *cast1 = ir_analyze_cast(ira, source_instr, slice_type, value);
13694	14744	if (type_is_invalid(cast1->value->type))
13695		return ira->codegen->invalid_instruction;
	14745	return ira->codegen->invalid_inst_gen;
13696	14746
13697		IrInstruction *cast2 = ir_analyze_cast(ira, source_instr, wanted_type, cast1);
	14747	IrInstGen *cast2 = ir_analyze_cast(ira, source_instr, wanted_type, cast1);
13698	14748	if (type_is_invalid(cast2->value->type))
13699		return ira->codegen->invalid_instruction;
	14749	return ira->codegen->invalid_inst_gen;
13700	14750
13701	14751	return cast2;
13702	14752	} else {
...	...	@@ -13731,12 +14781,12 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
13731	14781	if ((err = type_resolve(ira->codegen, actual_type->data.pointer.child_type,
13732	14782	ResolveStatusAlignmentKnown)))
13733	14783	{
13734		return ira->codegen->invalid_instruction;
	14784	return ira->codegen->invalid_inst_gen;
13735	14785	}
13736	14786	if ((err = type_resolve(ira->codegen, slice_ptr_type->data.pointer.child_type,
13737	14787	ResolveStatusAlignmentKnown)))
13738	14788	{
13739		return ira->codegen->invalid_instruction;
	14789	return ira->codegen->invalid_inst_gen;
13740	14790	}
13741	14791	ok_align = get_ptr_align(ira->codegen, actual_type) >= get_ptr_align(ira->codegen, slice_ptr_type);
13742	14792	}
...	...	@@ -13777,7 +14827,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
13777	14827	}
13778	14828	}
13779	14829	if (ok) {
13780		IrInstruction *cast1 = ir_analyze_frame_ptr_to_anyframe(ira, source_instr, value, anyframe_type);
	14830	IrInstGen *cast1 = ir_analyze_frame_ptr_to_anyframe(ira, source_instr, value, anyframe_type);
13781	14831	if (anyframe_type == wanted_type)
13782	14832	return cast1;
13783	14833	return ir_analyze_cast(ira, source_instr, wanted_type, cast1);
...	...	@@ -13832,28 +14882,28 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
13832	14882	if (actual_type->id == ZigTypeIdEnumLiteral &&
13833	14883	(wanted_type->id == ZigTypeIdOptional && wanted_type->data.maybe.child_type->id == ZigTypeIdEnum))
13834	14884	{
13835		IrInstruction *result = ir_analyze_enum_literal(ira, source_instr, value, wanted_type->data.maybe.child_type);
13836		if (result == ira->codegen->invalid_instruction)
	14885	IrInstGen *result = ir_analyze_enum_literal(ira, source_instr, value, wanted_type->data.maybe.child_type);
	14886	if (type_is_invalid(result->value->type))
13837	14887	return result;
13838	14888
13839		return ir_analyze_optional_wrap(ira, result, value, wanted_type, nullptr);
	14889	return ir_analyze_optional_wrap(ira, source_instr, value, wanted_type, nullptr);
13840	14890	}
13841	14891
13842	14892	// cast from enum literal to error union when payload is an enum
13843	14893	if (actual_type->id == ZigTypeIdEnumLiteral &&
13844	14894	(wanted_type->id == ZigTypeIdErrorUnion && wanted_type->data.error_union.payload_type->id == ZigTypeIdEnum))
13845	14895	{
13846		IrInstruction *result = ir_analyze_enum_literal(ira, source_instr, value, wanted_type->data.error_union.payload_type);
13847		if (result == ira->codegen->invalid_instruction)
	14896	IrInstGen *result = ir_analyze_enum_literal(ira, source_instr, value, wanted_type->data.error_union.payload_type);
	14897	if (type_is_invalid(result->value->type))
13848	14898	return result;
13849	14899
13850		return ir_analyze_err_wrap_payload(ira, result, value, wanted_type, nullptr);
	14900	return ir_analyze_err_wrap_payload(ira, source_instr, value, wanted_type, nullptr);
13851	14901	}
13852	14902
13853	14903	// cast from union to the enum type of the union
13854	14904	if (actual_type->id == ZigTypeIdUnion && wanted_type->id == ZigTypeIdEnum) {
13855	14905	if ((err = type_resolve(ira->codegen, actual_type, ResolveStatusZeroBitsKnown)))
13856		return ira->codegen->invalid_instruction;
	14906	return ira->codegen->invalid_inst_gen;
13857	14907
13858	14908	if (actual_type->data.unionation.tag_type == wanted_type) {
13859	14909	return ir_analyze_union_to_tag(ira, source_instr, value, wanted_type);
...	...	@@ -13881,8 +14931,8 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
13881	14931	(!actual_type->data.pointer.is_const \|\| wanted_type->data.pointer.is_const) &&
13882	14932	(!actual_type->data.pointer.is_volatile \|\| wanted_type->data.pointer.is_volatile))
13883	14933	{
13884		if ((err = ir_cast_ptr_align(ira, source_instr, wanted_type, actual_type, value->source_node)))
13885		return ira->codegen->invalid_instruction;
	14934	if ((err = ir_cast_ptr_align(ira, source_instr, wanted_type, actual_type, value->base.source_node)))
	14935	return ira->codegen->invalid_inst_gen;
13886	14936
13887	14937	return ir_analyze_ptr_to_array(ira, source_instr, value, wanted_type);
13888	14938	}
...	...	@@ -13905,7 +14955,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
13905	14955	slice_ptr_type->data.pointer.sentinel))))
13906	14956	{
13907	14957	TypeStructField *ptr_field = actual_type->data.structure.fields[slice_ptr_index];
13908		IrInstruction *slice_ptr = ir_analyze_struct_value_field_value(ira, source_instr, value, ptr_field);
	14958	IrInstGen *slice_ptr = ir_analyze_struct_value_field_value(ira, source_instr, value, ptr_field);
13909	14959	return ir_implicit_cast2(ira, source_instr, slice_ptr, wanted_type);
13910	14960	}
13911	14961	}
...	...	@@ -13936,7 +14986,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
13936	14986	{
13937	14987	bool has_bits;
13938	14988	if ((err = type_has_bits2(ira->codegen, actual_type, &has_bits)))
13939		return ira->codegen->invalid_instruction;
	14989	return ira->codegen->invalid_inst_gen;
13940	14990	if (!has_bits) {
13941	14991	return ir_get_ref(ira, source_instr, value, false, false);
13942	14992	}
...	...	@@ -14003,9 +15053,9 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
14003	15053
14004	15054	// T to ?U, where T implicitly casts to U
14005	15055	if (wanted_type->id == ZigTypeIdOptional && actual_type->id != ZigTypeIdOptional) {
14006		IrInstruction *cast1 = ir_implicit_cast2(ira, source_instr, value, wanted_type->data.maybe.child_type);
	15056	IrInstGen *cast1 = ir_implicit_cast2(ira, source_instr, value, wanted_type->data.maybe.child_type);
14007	15057	if (type_is_invalid(cast1->value->type))
14008		return ira->codegen->invalid_instruction;
	15058	return ira->codegen->invalid_inst_gen;
14009	15059	return ir_implicit_cast2(ira, source_instr, cast1, wanted_type);
14010	15060	}
14011	15061
...	...	@@ -14013,9 +15063,9 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
14013	15063	if (wanted_type->id == ZigTypeIdErrorUnion && actual_type->id != ZigTypeIdErrorUnion &&
14014	15064	actual_type->id != ZigTypeIdErrorSet)
14015	15065	{
14016		IrInstruction *cast1 = ir_implicit_cast2(ira, source_instr, value, wanted_type->data.error_union.payload_type);
	15066	IrInstGen *cast1 = ir_implicit_cast2(ira, source_instr, value, wanted_type->data.error_union.payload_type);
14017	15067	if (type_is_invalid(cast1->value->type))
14018		return ira->codegen->invalid_instruction;
	15068	return ira->codegen->invalid_inst_gen;
14019	15069	return ir_implicit_cast2(ira, source_instr, cast1, wanted_type);
14020	15070	}
14021	15071
...	...	@@ -14024,14 +15074,13 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
14024	15074	buf_ptr(&wanted_type->name),
14025	15075	buf_ptr(&actual_type->name)));
14026	15076	report_recursive_error(ira, source_instr->source_node, &const_cast_result, parent_msg);
14027		return ira->codegen->invalid_instruction;
	15077	return ira->codegen->invalid_inst_gen;
14028	15078	}
14029	15079
14030		static IrInstruction ir_implicit_cast2(IrAnalyze ira, IrInstruction *value_source_instr,
14031		IrInstruction value, ZigType expected_type)
	15080	static IrInstGen ir_implicit_cast2(IrAnalyze ira, IrInst *value_source_instr,
	15081	IrInstGen value, ZigType expected_type)
14032	15082	{
14033	15083	assert(value);
14034		assert(value != ira->codegen->invalid_instruction);
14035	15084	assert(!expected_type \|\| !type_is_invalid(expected_type));
14036	15085	assert(value->value->type);
14037	15086	assert(!type_is_invalid(value->value->type));
...	...	@@ -14045,17 +15094,17 @@ static IrInstruction ir_implicit_cast2(IrAnalyze ira, IrInstruction *value_sou
14045	15094	return ir_analyze_cast(ira, value_source_instr, expected_type, value);
14046	15095	}
14047	15096
14048		static IrInstruction ir_implicit_cast(IrAnalyze ira, IrInstruction value, ZigType expected_type) {
14049		return ir_implicit_cast2(ira, value, value, expected_type);
	15097	static IrInstGen ir_implicit_cast(IrAnalyze ira, IrInstGen value, ZigType expected_type) {
	15098	return ir_implicit_cast2(ira, &value->base, value, expected_type);
14050	15099	}
14051	15100
14052		static ZigType get_ptr_elem_type(CodeGen g, IrInstruction *ptr) {
14053		ir_assert(ptr->value->type->id == ZigTypeIdPointer, ptr);
	15101	static ZigType get_ptr_elem_type(CodeGen g, IrInstGen *ptr) {
	15102	ir_assert_gen(ptr->value->type->id == ZigTypeIdPointer, ptr);
14054	15103	ZigType *elem_type = ptr->value->type->data.pointer.child_type;
14055	15104	if (elem_type != g->builtin_types.entry_var)
14056	15105	return elem_type;
14057	15106
14058		if (ir_resolve_lazy(g, ptr->source_node, ptr->value))
	15107	if (ir_resolve_lazy(g, ptr->base.source_node, ptr->value))
14059	15108	return g->builtin_types.entry_invalid;
14060	15109
14061	15110	assert(value_is_comptime(ptr->value));
...	...	@@ -14063,28 +15112,28 @@ static ZigType get_ptr_elem_type(CodeGen g, IrInstruction *ptr) {
14063	15112	return pointee->type;
14064	15113	}
14065	15114
14066		static IrInstruction ir_get_deref(IrAnalyze ira, IrInstruction source_instruction, IrInstruction ptr,
	15115	static IrInstGen ir_get_deref(IrAnalyze ira, IrInst* source_instruction, IrInstGen *ptr,
14067	15116	ResultLoc *result_loc)
14068	15117	{
14069	15118	Error err;
14070	15119	ZigType *ptr_type = ptr->value->type;
14071	15120	if (type_is_invalid(ptr_type))
14072		return ira->codegen->invalid_instruction;
	15121	return ira->codegen->invalid_inst_gen;
14073	15122
14074	15123	if (ptr_type->id != ZigTypeIdPointer) {
14075	15124	ir_add_error_node(ira, source_instruction->source_node,
14076	15125	buf_sprintf("attempt to dereference non-pointer type '%s'",
14077	15126	buf_ptr(&ptr_type->name)));
14078		return ira->codegen->invalid_instruction;
	15127	return ira->codegen->invalid_inst_gen;
14079	15128	}
14080	15129
14081	15130	ZigType *child_type = ptr_type->data.pointer.child_type;
14082	15131	if (type_is_invalid(child_type))
14083		return ira->codegen->invalid_instruction;
	15132	return ira->codegen->invalid_inst_gen;
14084	15133	// if the child type has one possible value, the deref is comptime
14085	15134	switch (type_has_one_possible_value(ira->codegen, child_type)) {
14086	15135	case OnePossibleValueInvalid:
14087		return ira->codegen->invalid_instruction;
	15136	return ira->codegen->invalid_inst_gen;
14088	15137	case OnePossibleValueYes:
14089	15138	return ir_const_move(ira, source_instruction,
14090	15139	get_the_one_possible_value(ira->codegen, child_type));
...	...	@@ -14093,8 +15142,8 @@ static IrInstruction ir_get_deref(IrAnalyze ira, IrInstruction *source_instruc
14093	15142	}
14094	15143	if (instr_is_comptime(ptr)) {
14095	15144	if (ptr->value->special == ConstValSpecialUndef) {
14096		ir_add_error(ira, ptr, buf_sprintf("attempt to dereference undefined value"));
14097		return ira->codegen->invalid_instruction;
	15145	ir_add_error(ira, &ptr->base, buf_sprintf("attempt to dereference undefined value"));
	15146	return ira->codegen->invalid_inst_gen;
14098	15147	}
14099	15148	if (ptr->value->data.x_ptr.mut != ConstPtrMutRuntimeVar) {
14100	15149	ZigValue *pointee = const_ptr_pointee_unchecked(ira->codegen, ptr->value);
...	...	@@ -14102,12 +15151,12 @@ static IrInstruction ir_get_deref(IrAnalyze ira, IrInstruction *source_instruc
14102	15151	child_type = pointee->type;
14103	15152	}
14104	15153	if (pointee->special != ConstValSpecialRuntime) {
14105		IrInstruction *result = ir_const(ira, source_instruction, child_type);
	15154	IrInstGen *result = ir_const(ira, source_instruction, child_type);
14106	15155
14107	15156	if ((err = ir_read_const_ptr(ira, ira->codegen, source_instruction->source_node, result->value,
14108	15157	ptr->value)))
14109	15158	{
14110		return ira->codegen->invalid_instruction;
	15159	return ira->codegen->invalid_inst_gen;
14111	15160	}
14112	15161	result->value->type = child_type;
14113	15162	return result;
...	...	@@ -14116,38 +15165,38 @@ static IrInstruction ir_get_deref(IrAnalyze ira, IrInstruction *source_instruc
14116	15165	}
14117	15166
14118	15167	// if the instruction is a const ref instruction we can skip it
14119		if (ptr->id == IrInstructionIdRef) {
14120		IrInstructionRef ref_inst = reinterpret_cast<IrInstructionRef >(ptr);
14121		return ref_inst->value;
	15168	if (ptr->id == IrInstGenIdRef) {
	15169	IrInstGenRef ref_inst = reinterpret_cast<IrInstGenRef >(ptr);
	15170	return ref_inst->operand;
14122	15171	}
14123	15172
14124	15173	// If the instruction is a element pointer instruction to a vector, we emit
14125	15174	// vector element extract instruction rather than load pointer. If the
14126	15175	// pointer type has non-VECTOR_INDEX_RUNTIME value, it would have been
14127		// possible to implement this in the codegen for IrInstructionLoadPtrGen.
	15176	// possible to implement this in the codegen for IrInstGenLoadPtr.
14128	15177	// However if it has VECTOR_INDEX_RUNTIME then we must emit a compile error
14129	15178	// if the vector index cannot be determined right here, right now, because
14130	15179	// the type information does not contain enough information to actually
14131	15180	// perform a dereference.
14132	15181	if (ptr_type->data.pointer.vector_index == VECTOR_INDEX_RUNTIME) {
14133		if (ptr->id == IrInstructionIdElemPtr) {
14134		IrInstructionElemPtr elem_ptr = (IrInstructionElemPtr )ptr;
14135		IrInstruction *vector_loaded = ir_get_deref(ira, elem_ptr->array_ptr,
	15182	if (ptr->id == IrInstGenIdElemPtr) {
	15183	IrInstGenElemPtr elem_ptr = (IrInstGenElemPtr )ptr;
	15184	IrInstGen *vector_loaded = ir_get_deref(ira, &elem_ptr->array_ptr->base,
14136	15185	elem_ptr->array_ptr, nullptr);
14137		IrInstruction *elem_index = elem_ptr->elem_index;
	15186	IrInstGen *elem_index = elem_ptr->elem_index;
14138	15187	return ir_build_vector_extract_elem(ira, source_instruction, vector_loaded, elem_index);
14139	15188	}
14140		ir_add_error(ira, ptr,
	15189	ir_add_error(ira, &ptr->base,
14141	15190	buf_sprintf("unable to determine vector element index of type '%s'", buf_ptr(&ptr_type->name)));
14142		return ira->codegen->invalid_instruction;
	15191	return ira->codegen->invalid_inst_gen;
14143	15192	}
14144	15193
14145		IrInstruction *result_loc_inst;
	15194	IrInstGen *result_loc_inst;
14146	15195	if (ptr_type->data.pointer.host_int_bytes != 0 && handle_is_ptr(child_type)) {
14147	15196	if (result_loc == nullptr) result_loc = no_result_loc();
14148	15197	result_loc_inst = ir_resolve_result(ira, source_instruction, result_loc, child_type, nullptr,
14149	15198	true, false, true);
14150		if (type_is_invalid(result_loc_inst->value->type) \|\| instr_is_unreachable(result_loc_inst)) {
	15199	if (type_is_invalid(result_loc_inst->value->type) \|\| result_loc_inst->value->type->id == ZigTypeIdUnreachable) {
14151	15200	return result_loc_inst;
14152	15201	}
14153	15202	} else {
...	...	@@ -14157,7 +15206,7 @@ static IrInstruction ir_get_deref(IrAnalyze ira, IrInstruction *source_instruc
14157	15206	return ir_build_load_ptr_gen(ira, source_instruction, ptr, child_type, result_loc_inst);
14158	15207	}
14159	15208
14160		static bool ir_resolve_const_align(CodeGen codegen, IrExecutable exec, AstNode *source_node,
	15209	static bool ir_resolve_const_align(CodeGen codegen, IrExecutableGen exec, AstNode *source_node,
14161	15210	ZigValue const_val, uint32_t out)
14162	15211	{
14163	15212	Error err;
...	...	@@ -14166,12 +15215,12 @@ static bool ir_resolve_const_align(CodeGen codegen, IrExecutable exec, AstNode
14166	15215
14167	15216	uint32_t align_bytes = bigint_as_u32(&const_val->data.x_bigint);
14168	15217	if (align_bytes == 0) {
14169		exec_add_error_node(codegen, exec, source_node, buf_sprintf("alignment must be >= 1"));
	15218	exec_add_error_node_gen(codegen, exec, source_node, buf_sprintf("alignment must be >= 1"));
14170	15219	return false;
14171	15220	}
14172	15221
14173	15222	if (!is_power_of_2(align_bytes)) {
14174		exec_add_error_node(codegen, exec, source_node,
	15223	exec_add_error_node_gen(codegen, exec, source_node,
14175	15224	buf_sprintf("alignment value %" PRIu32 " is not a power of 2", align_bytes));
14176	15225	return false;
14177	15226	}
...	...	@@ -14180,7 +15229,7 @@ static bool ir_resolve_const_align(CodeGen codegen, IrExecutable exec, AstNode
14180	15229	return true;
14181	15230	}
14182	15231
14183		static bool ir_resolve_align(IrAnalyze ira, IrInstruction value, ZigType elem_type, uint32_t out) {
	15232	static bool ir_resolve_align(IrAnalyze ira, IrInstGen value, ZigType elem_type, uint32_t out) {
14184	15233	if (type_is_invalid(value->value->type))
14185	15234	return false;
14186	15235
...	...	@@ -14201,19 +15250,19 @@ static bool ir_resolve_align(IrAnalyze ira, IrInstruction value, ZigType *elem
14201	15250	}
14202	15251	}
14203	15252
14204		IrInstruction *casted_value = ir_implicit_cast(ira, value, get_align_amt_type(ira->codegen));
	15253	IrInstGen *casted_value = ir_implicit_cast(ira, value, get_align_amt_type(ira->codegen));
14205	15254	if (type_is_invalid(casted_value->value->type))
14206	15255	return false;
14207	15256
14208		return ir_resolve_const_align(ira->codegen, ira->new_irb.exec, value->source_node,
	15257	return ir_resolve_const_align(ira->codegen, ira->new_irb.exec, value->base.source_node,
14209	15258	casted_value->value, out);
14210	15259	}
14211	15260
14212		static bool ir_resolve_unsigned(IrAnalyze ira, IrInstruction value, ZigType int_type, uint64_t out) {
	15261	static bool ir_resolve_unsigned(IrAnalyze ira, IrInstGen value, ZigType int_type, uint64_t out) {
14213	15262	if (type_is_invalid(value->value->type))
14214	15263	return false;
14215	15264
14216		IrInstruction *casted_value = ir_implicit_cast(ira, value, int_type);
	15265	IrInstGen *casted_value = ir_implicit_cast(ira, value, int_type);
14217	15266	if (type_is_invalid(casted_value->value->type))
14218	15267	return false;
14219	15268
...	...	@@ -14225,15 +15274,15 @@ static bool ir_resolve_unsigned(IrAnalyze ira, IrInstruction value, ZigType *i
14225	15274	return true;
14226	15275	}
14227	15276
14228		static bool ir_resolve_usize(IrAnalyze ira, IrInstruction value, uint64_t *out) {
	15277	static bool ir_resolve_usize(IrAnalyze ira, IrInstGen value, uint64_t *out) {
14229	15278	return ir_resolve_unsigned(ira, value, ira->codegen->builtin_types.entry_usize, out);
14230	15279	}
14231	15280
14232		static bool ir_resolve_bool(IrAnalyze ira, IrInstruction value, bool *out) {
	15281	static bool ir_resolve_bool(IrAnalyze ira, IrInstGen value, bool *out) {
14233	15282	if (type_is_invalid(value->value->type))
14234	15283	return false;
14235	15284
14236		IrInstruction *casted_value = ir_implicit_cast(ira, value, ira->codegen->builtin_types.entry_bool);
	15285	IrInstGen *casted_value = ir_implicit_cast(ira, value, ira->codegen->builtin_types.entry_bool);
14237	15286	if (type_is_invalid(casted_value->value->type))
14238	15287	return false;
14239	15288
...	...	@@ -14245,7 +15294,7 @@ static bool ir_resolve_bool(IrAnalyze ira, IrInstruction value, bool *out) {
14245	15294	return true;
14246	15295	}
14247	15296
14248		static bool ir_resolve_comptime(IrAnalyze ira, IrInstruction value, bool *out) {
	15297	static bool ir_resolve_comptime(IrAnalyze ira, IrInstGen value, bool *out) {
14249	15298	if (!value) {
14250	15299	*out = false;
14251	15300	return true;
...	...	@@ -14253,13 +15302,13 @@ static bool ir_resolve_comptime(IrAnalyze ira, IrInstruction value, bool *out)
14253	15302	return ir_resolve_bool(ira, value, out);
14254	15303	}
14255	15304
14256		static bool ir_resolve_atomic_order(IrAnalyze ira, IrInstruction value, AtomicOrder *out) {
	15305	static bool ir_resolve_atomic_order(IrAnalyze ira, IrInstGen value, AtomicOrder *out) {
14257	15306	if (type_is_invalid(value->value->type))
14258	15307	return false;
14259	15308
14260	15309	ZigType *atomic_order_type = get_builtin_type(ira->codegen, "AtomicOrder");
14261	15310
14262		IrInstruction *casted_value = ir_implicit_cast(ira, value, atomic_order_type);
	15311	IrInstGen *casted_value = ir_implicit_cast(ira, value, atomic_order_type);
14263	15312	if (type_is_invalid(casted_value->value->type))
14264	15313	return false;
14265	15314
...	...	@@ -14271,13 +15320,13 @@ static bool ir_resolve_atomic_order(IrAnalyze ira, IrInstruction value, Atomic
14271	15320	return true;
14272	15321	}
14273	15322
14274		static bool ir_resolve_atomic_rmw_op(IrAnalyze ira, IrInstruction value, AtomicRmwOp *out) {
	15323	static bool ir_resolve_atomic_rmw_op(IrAnalyze ira, IrInstGen value, AtomicRmwOp *out) {
14275	15324	if (type_is_invalid(value->value->type))
14276	15325	return false;
14277	15326
14278	15327	ZigType *atomic_rmw_op_type = get_builtin_type(ira->codegen, "AtomicRmwOp");
14279	15328
14280		IrInstruction *casted_value = ir_implicit_cast(ira, value, atomic_rmw_op_type);
	15329	IrInstGen *casted_value = ir_implicit_cast(ira, value, atomic_rmw_op_type);
14281	15330	if (type_is_invalid(casted_value->value->type))
14282	15331	return false;
14283	15332
...	...	@@ -14289,13 +15338,13 @@ static bool ir_resolve_atomic_rmw_op(IrAnalyze ira, IrInstruction value, Atomi
14289	15338	return true;
14290	15339	}
14291	15340
14292		static bool ir_resolve_global_linkage(IrAnalyze ira, IrInstruction value, GlobalLinkageId *out) {
	15341	static bool ir_resolve_global_linkage(IrAnalyze ira, IrInstGen value, GlobalLinkageId *out) {
14293	15342	if (type_is_invalid(value->value->type))
14294	15343	return false;
14295	15344
14296	15345	ZigType *global_linkage_type = get_builtin_type(ira->codegen, "GlobalLinkage");
14297	15346
14298		IrInstruction *casted_value = ir_implicit_cast(ira, value, global_linkage_type);
	15347	IrInstGen *casted_value = ir_implicit_cast(ira, value, global_linkage_type);
14299	15348	if (type_is_invalid(casted_value->value->type))
14300	15349	return false;
14301	15350
...	...	@@ -14307,13 +15356,13 @@ static bool ir_resolve_global_linkage(IrAnalyze ira, IrInstruction value, Glob
14307	15356	return true;
14308	15357	}
14309	15358
14310		static bool ir_resolve_float_mode(IrAnalyze ira, IrInstruction value, FloatMode *out) {
	15359	static bool ir_resolve_float_mode(IrAnalyze ira, IrInstGen value, FloatMode *out) {
14311	15360	if (type_is_invalid(value->value->type))
14312	15361	return false;
14313	15362
14314	15363	ZigType *float_mode_type = get_builtin_type(ira->codegen, "FloatMode");
14315	15364
14316		IrInstruction *casted_value = ir_implicit_cast(ira, value, float_mode_type);
	15365	IrInstGen *casted_value = ir_implicit_cast(ira, value, float_mode_type);
14317	15366	if (type_is_invalid(casted_value->value->type))
14318	15367	return false;
14319	15368
...	...	@@ -14325,14 +15374,14 @@ static bool ir_resolve_float_mode(IrAnalyze ira, IrInstruction value, FloatMod
14325	15374	return true;
14326	15375	}
14327	15376
14328		static Buf ir_resolve_str(IrAnalyze ira, IrInstruction *value) {
	15377	static Buf ir_resolve_str(IrAnalyze ira, IrInstGen *value) {
14329	15378	if (type_is_invalid(value->value->type))
14330	15379	return nullptr;
14331	15380
14332	15381	ZigType *ptr_type = get_pointer_to_type_extra(ira->codegen, ira->codegen->builtin_types.entry_u8,
14333	15382	true, false, PtrLenUnknown, 0, 0, 0, false);
14334	15383	ZigType *str_type = get_slice_type(ira->codegen, ptr_type);
14335		IrInstruction *casted_value = ir_implicit_cast(ira, value, str_type);
	15384	IrInstGen *casted_value = ir_implicit_cast(ira, value, str_type);
14336	15385	if (type_is_invalid(casted_value->value->type))
14337	15386	return nullptr;
14338	15387
...	...	@@ -14356,7 +15405,7 @@ static Buf ir_resolve_str(IrAnalyze ira, IrInstruction *value) {
14356	15405	size_t new_index = ptr_field->data.x_ptr.data.base_array.elem_index + i;
14357	15406	ZigValue *char_val = &array_val->data.x_array.data.s_none.elements[new_index];
14358	15407	if (char_val->special == ConstValSpecialUndef) {
14359		ir_add_error(ira, casted_value, buf_sprintf("use of undefined value"));
	15408	ir_add_error(ira, &casted_value->base, buf_sprintf("use of undefined value"));
14360	15409	return nullptr;
14361	15410	}
14362	15411	uint64_t big_c = bigint_as_u64(&char_val->data.x_bigint);
...	...	@@ -14367,10 +15416,10 @@ static Buf ir_resolve_str(IrAnalyze ira, IrInstruction *value) {
14367	15416	return result;
14368	15417	}
14369	15418
14370		static IrInstruction ir_analyze_instruction_add_implicit_return_type(IrAnalyze ira,
14371		IrInstructionAddImplicitReturnType *instruction)
	15419	static IrInstGen ir_analyze_instruction_add_implicit_return_type(IrAnalyze ira,
	15420	IrInstSrcAddImplicitReturnType *instruction)
14372	15421	{
14373		IrInstruction *value = instruction->value->child;
	15422	IrInstGen *value = instruction->value->child;
14374	15423	if (type_is_invalid(value->value->type))
14375	15424	return ir_unreach_error(ira);
14376	15425
...	...	@@ -14378,15 +15427,15 @@ static IrInstruction *ir_analyze_instruction_add_implicit_return_type(IrAnalyze
14378	15427	ira->src_implicit_return_type_list.append(value);
14379	15428	}
14380	15429
14381		return ir_const_void(ira, &instruction->base);
	15430	return ir_const_void(ira, &instruction->base.base);
14382	15431	}
14383	15432
14384		static IrInstruction ir_analyze_instruction_return(IrAnalyze ira, IrInstructionReturn *instruction) {
14385		IrInstruction *operand = instruction->operand->child;
	15433	static IrInstGen ir_analyze_instruction_return(IrAnalyze ira, IrInstSrcReturn *instruction) {
	15434	IrInstGen *operand = instruction->operand->child;
14386	15435	if (type_is_invalid(operand->value->type))
14387	15436	return ir_unreach_error(ira);
14388	15437
14389		IrInstruction *casted_operand = ir_implicit_cast(ira, operand, ira->explicit_return_type);
	15438	IrInstGen *casted_operand = ir_implicit_cast(ira, operand, ira->explicit_return_type);
14390	15439	if (type_is_invalid(casted_operand->value->type)) {
14391	15440	AstNode *source_node = ira->explicit_return_type_source_node;
14392	15441	if (source_node != nullptr) {
...	...	@@ -14401,9 +15450,7 @@ static IrInstruction ir_analyze_instruction_return(IrAnalyze ira, IrInstructio
14401	15450	handle_is_ptr(ira->explicit_return_type))
14402	15451	{
14403	15452	// result location mechanism took care of it.
14404		IrInstruction *result = ir_build_return(&ira->new_irb, instruction->base.scope,
14405		instruction->base.source_node, nullptr);
14406		result->value->type = ira->codegen->builtin_types.entry_unreachable;
	15453	IrInstGen *result = ir_build_return_gen(ira, &instruction->base.base, nullptr);
14407	15454	return ir_finish_anal(ira, result);
14408	15455	}
14409	15456
...	...	@@ -14411,47 +15458,45 @@ static IrInstruction ir_analyze_instruction_return(IrAnalyze ira, IrInstructio
14411	15458	casted_operand->value->type->id == ZigTypeIdPointer &&
14412	15459	casted_operand->value->data.rh_ptr == RuntimeHintPtrStack)
14413	15460	{
14414		ir_add_error(ira, casted_operand, buf_sprintf("function returns address of local variable"));
	15461	ir_add_error(ira, &casted_operand->base, buf_sprintf("function returns address of local variable"));
14415	15462	return ir_unreach_error(ira);
14416	15463	}
14417	15464
14418		IrInstruction *result = ir_build_return(&ira->new_irb, instruction->base.scope,
14419		instruction->base.source_node, casted_operand);
14420		result->value->type = ira->codegen->builtin_types.entry_unreachable;
	15465	IrInstGen *result = ir_build_return_gen(ira, &instruction->base.base, casted_operand);
14421	15466	return ir_finish_anal(ira, result);
14422	15467	}
14423	15468
14424		static IrInstruction ir_analyze_instruction_const(IrAnalyze ira, IrInstructionConst *instruction) {
14425		return ir_const_move(ira, &instruction->base, instruction->base.value);
	15469	static IrInstGen ir_analyze_instruction_const(IrAnalyze ira, IrInstSrcConst *instruction) {
	15470	return ir_const_move(ira, &instruction->base.base, instruction->value);
14426	15471	}
14427	15472
14428		static IrInstruction ir_analyze_bin_op_bool(IrAnalyze ira, IrInstructionBinOp *bin_op_instruction) {
14429		IrInstruction *op1 = bin_op_instruction->op1->child;
	15473	static IrInstGen ir_analyze_bin_op_bool(IrAnalyze ira, IrInstSrcBinOp *bin_op_instruction) {
	15474	IrInstGen *op1 = bin_op_instruction->op1->child;
14430	15475	if (type_is_invalid(op1->value->type))
14431		return ira->codegen->invalid_instruction;
	15476	return ira->codegen->invalid_inst_gen;
14432	15477
14433		IrInstruction *op2 = bin_op_instruction->op2->child;
	15478	IrInstGen *op2 = bin_op_instruction->op2->child;
14434	15479	if (type_is_invalid(op2->value->type))
14435		return ira->codegen->invalid_instruction;
	15480	return ira->codegen->invalid_inst_gen;
14436	15481
14437	15482	ZigType *bool_type = ira->codegen->builtin_types.entry_bool;
14438	15483
14439		IrInstruction *casted_op1 = ir_implicit_cast(ira, op1, bool_type);
14440		if (casted_op1 == ira->codegen->invalid_instruction)
14441		return ira->codegen->invalid_instruction;
	15484	IrInstGen *casted_op1 = ir_implicit_cast(ira, op1, bool_type);
	15485	if (type_is_invalid(casted_op1->value->type))
	15486	return ira->codegen->invalid_inst_gen;
14442	15487
14443		IrInstruction *casted_op2 = ir_implicit_cast(ira, op2, bool_type);
14444		if (casted_op2 == ira->codegen->invalid_instruction)
14445		return ira->codegen->invalid_instruction;
	15488	IrInstGen *casted_op2 = ir_implicit_cast(ira, op2, bool_type);
	15489	if (type_is_invalid(casted_op2->value->type))
	15490	return ira->codegen->invalid_inst_gen;
14446	15491
14447	15492	if (instr_is_comptime(casted_op1) && instr_is_comptime(casted_op2)) {
14448	15493	ZigValue *op1_val = ir_resolve_const(ira, casted_op1, UndefBad);
14449	15494	if (op1_val == nullptr)
14450		return ira->codegen->invalid_instruction;
	15495	return ira->codegen->invalid_inst_gen;
14451	15496
14452	15497	ZigValue *op2_val = ir_resolve_const(ira, casted_op2, UndefBad);
14453	15498	if (op2_val == nullptr)
14454		return ira->codegen->invalid_instruction;
	15499	return ira->codegen->invalid_inst_gen;
14455	15500
14456	15501	assert(casted_op1->value->type->id == ZigTypeIdBool);
14457	15502	assert(casted_op2->value->type->id == ZigTypeIdBool);
...	...	@@ -14463,14 +15508,11 @@ static IrInstruction ir_analyze_bin_op_bool(IrAnalyze ira, IrInstructionBinOp
14463	15508	} else {
14464	15509	zig_unreachable();
14465	15510	}
14466		return ir_const_bool(ira, &bin_op_instruction->base, result_bool);
	15511	return ir_const_bool(ira, &bin_op_instruction->base.base, result_bool);
14467	15512	}
14468	15513
14469		IrInstruction *result = ir_build_bin_op(&ira->new_irb,
14470		bin_op_instruction->base.scope, bin_op_instruction->base.source_node,
	15514	return ir_build_bin_op_gen(ira, &bin_op_instruction->base.base, bool_type,
14471	15515	bin_op_instruction->op_id, casted_op1, casted_op2, bin_op_instruction->safety_check_on);
14472		result->value->type = bool_type;
14473		return result;
14474	15516	}
14475	15517
14476	15518	static bool resolve_cmp_op_id(IrBinOp op_id, Cmp cmp) {
...	...	@@ -14535,12 +15577,13 @@ static void set_optional_payload(ZigValue opt_val, ZigValue payload) {
14535	15577	}
14536	15578	}
14537	15579
14538		static IrInstruction ir_evaluate_bin_op_cmp(IrAnalyze ira, ZigType *resolved_type,
14539		ZigValue op1_val, ZigValue op2_val, IrInstructionBinOp *bin_op_instruction, IrBinOp op_id,
14540		bool one_possible_value) {
	15580	static IrInstGen ir_evaluate_bin_op_cmp(IrAnalyze ira, ZigType *resolved_type,
	15581	ZigValue op1_val, ZigValue op2_val, IrInstSrcBinOp *bin_op_instruction, IrBinOp op_id,
	15582	bool one_possible_value)
	15583	{
14541	15584	if (op1_val->special == ConstValSpecialUndef \|\|
14542	15585	op2_val->special == ConstValSpecialUndef)
14543		return ir_const_undef(ira, &bin_op_instruction->base, resolved_type);
	15586	return ir_const_undef(ira, &bin_op_instruction->base.base, resolved_type);
14544	15587	if (resolved_type->id == ZigTypeIdPointer && op_id != IrBinOpCmpEq && op_id != IrBinOpCmpNotEq) {
14545	15588	if ((op1_val->data.x_ptr.special == ConstPtrSpecialHardCodedAddr \|\|
14546	15589	op1_val->data.x_ptr.special == ConstPtrSpecialNull) &&
...	...	@@ -14560,7 +15603,7 @@ static IrInstruction ir_evaluate_bin_op_cmp(IrAnalyze ira, ZigType *resolved_t
14560	15603	cmp_result = CmpEQ;
14561	15604	}
14562	15605	bool answer = resolve_cmp_op_id(op_id, cmp_result);
14563		return ir_const_bool(ira, &bin_op_instruction->base, answer);
	15606	return ir_const_bool(ira, &bin_op_instruction->base.base, answer);
14564	15607	}
14565	15608	} else {
14566	15609	bool are_equal = one_possible_value \|\| const_values_equal(ira->codegen, op1_val, op2_val);
...	...	@@ -14572,7 +15615,7 @@ static IrInstruction ir_evaluate_bin_op_cmp(IrAnalyze ira, ZigType *resolved_t
14572	15615	} else {
14573	15616	zig_unreachable();
14574	15617	}
14575		return ir_const_bool(ira, &bin_op_instruction->base, answer);
	15618	return ir_const_bool(ira, &bin_op_instruction->base.base, answer);
14576	15619	}
14577	15620	zig_unreachable();
14578	15621	}
...	...	@@ -14626,7 +15669,7 @@ static Error lazy_cmp_zero(AstNode source_node, ZigValue val, Cmp *result) {
14626	15669	zig_unreachable();
14627	15670	}
14628	15671
14629		static ErrorMsg ir_eval_bin_op_cmp_scalar(IrAnalyze ira, IrInstruction *source_instr,
	15672	static ErrorMsg ir_eval_bin_op_cmp_scalar(IrAnalyze ira, IrInst* source_instr,
14630	15673	ZigValue op1_val, IrBinOp op_id, ZigValue op2_val, ZigValue *out_val)
14631	15674	{
14632	15675	Error err;
...	...	@@ -14704,14 +15747,14 @@ never_mind_just_calculate_it_normally:
14704	15747	return nullptr;
14705	15748	}
14706	15749	if (op1_val->type->id == ZigTypeIdComptimeFloat) {
14707		IrInstruction *tmp = ir_const_noval(ira, source_instr);
	15750	IrInstGen *tmp = ir_const_noval(ira, source_instr);
14708	15751	tmp->value = op1_val;
14709		IrInstruction *casted = ir_implicit_cast(ira, tmp, op2_val->type);
	15752	IrInstGen *casted = ir_implicit_cast(ira, tmp, op2_val->type);
14710	15753	op1_val = casted->value;
14711	15754	} else if (op2_val->type->id == ZigTypeIdComptimeFloat) {
14712		IrInstruction *tmp = ir_const_noval(ira, source_instr);
	15755	IrInstGen *tmp = ir_const_noval(ira, source_instr);
14713	15756	tmp->value = op2_val;
14714		IrInstruction *casted = ir_implicit_cast(ira, tmp, op1_val->type);
	15757	IrInstGen *casted = ir_implicit_cast(ira, tmp, op1_val->type);
14715	15758	op2_val = casted->value;
14716	15759	}
14717	15760	Cmp cmp_result = float_cmp(op1_val, op2_val);
...	...	@@ -14753,8 +15796,8 @@ never_mind_just_calculate_it_normally:
14753	15796	return nullptr;
14754	15797	}
14755	15798
14756		static IrInstruction ir_analyze_bin_op_cmp_numeric(IrAnalyze ira, IrInstruction *source_instr,
14757		IrInstruction op1, IrInstruction op2, IrBinOp op_id)
	15799	static IrInstGen ir_analyze_bin_op_cmp_numeric(IrAnalyze ira, IrInst *source_instr,
	15800	IrInstGen op1, IrInstGen op2, IrBinOp op_id)
14758	15801	{
14759	15802	Error err;
14760	15803
...	...	@@ -14767,7 +15810,7 @@ static IrInstruction ir_analyze_bin_op_cmp_numeric(IrAnalyze ira, IrInstructio
14767	15810	ir_add_error(ira, source_instr,
14768	15811	buf_sprintf("vector length mismatch: %" PRIu32 " and %" PRIu32,
14769	15812	op1->value->type->data.vector.len, op2->value->type->data.vector.len));
14770		return ira->codegen->invalid_instruction;
	15813	return ira->codegen->invalid_inst_gen;
14771	15814	}
14772	15815	result_type = get_vector_type(ira->codegen, op1->value->type->data.vector.len, scalar_result_type);
14773	15816	op1_scalar_type = op1->value->type->data.vector.elem_type;
...	...	@@ -14776,13 +15819,13 @@ static IrInstruction ir_analyze_bin_op_cmp_numeric(IrAnalyze ira, IrInstructio
14776	15819	ir_add_error(ira, source_instr,
14777	15820	buf_sprintf("mixed scalar and vector operands to comparison operator: '%s' and '%s'",
14778	15821	buf_ptr(&op1->value->type->name), buf_ptr(&op2->value->type->name)));
14779		return ira->codegen->invalid_instruction;
	15822	return ira->codegen->invalid_inst_gen;
14780	15823	}
14781	15824
14782	15825	bool opv_op1;
14783	15826	switch (type_has_one_possible_value(ira->codegen, op1->value->type)) {
14784	15827	case OnePossibleValueInvalid:
14785		return ira->codegen->invalid_instruction;
	15828	return ira->codegen->invalid_inst_gen;
14786	15829	case OnePossibleValueYes:
14787	15830	opv_op1 = true;
14788	15831	break;
...	...	@@ -14793,7 +15836,7 @@ static IrInstruction ir_analyze_bin_op_cmp_numeric(IrAnalyze ira, IrInstructio
14793	15836	bool opv_op2;
14794	15837	switch (type_has_one_possible_value(ira->codegen, op2->value->type)) {
14795	15838	case OnePossibleValueInvalid:
14796		return ira->codegen->invalid_instruction;
	15839	return ira->codegen->invalid_inst_gen;
14797	15840	case OnePossibleValueYes:
14798	15841	opv_op2 = true;
14799	15842	break;
...	...	@@ -14804,21 +15847,21 @@ static IrInstruction ir_analyze_bin_op_cmp_numeric(IrAnalyze ira, IrInstructio
14804	15847	Cmp op1_cmp_zero;
14805	15848	bool have_op1_cmp_zero = false;
14806	15849	if ((err = lazy_cmp_zero(source_instr->source_node, op1->value, &op1_cmp_zero))) {
14807		if (err != ErrorNotLazy) return ira->codegen->invalid_instruction;
	15850	if (err != ErrorNotLazy) return ira->codegen->invalid_inst_gen;
14808	15851	} else {
14809	15852	have_op1_cmp_zero = true;
14810	15853	}
14811	15854	Cmp op2_cmp_zero;
14812	15855	bool have_op2_cmp_zero = false;
14813	15856	if ((err = lazy_cmp_zero(source_instr->source_node, op2->value, &op2_cmp_zero))) {
14814		if (err != ErrorNotLazy) return ira->codegen->invalid_instruction;
	15857	if (err != ErrorNotLazy) return ira->codegen->invalid_inst_gen;
14815	15858	} else {
14816	15859	have_op2_cmp_zero = true;
14817	15860	}
14818	15861	if (((opv_op1 \|\| instr_is_comptime(op1)) && (opv_op2 \|\| instr_is_comptime(op2))) \|\|
14819	15862	(have_op1_cmp_zero && have_op2_cmp_zero))
14820	15863	{
14821		IrInstruction *result_instruction = ir_const(ira, source_instr, result_type);
	15864	IrInstGen *result_instruction = ir_const(ira, source_instr, result_type);
14822	15865	ZigValue *out_val = result_instruction->value;
14823	15866	if (result_type->id == ZigTypeIdVector) {
14824	15867	size_t len = result_type->data.vector.len;
...	...	@@ -14836,7 +15879,7 @@ static IrInstruction ir_analyze_bin_op_cmp_numeric(IrAnalyze ira, IrInstructio
14836	15879	if (msg != nullptr) {
14837	15880	add_error_note(ira->codegen, msg, source_instr->source_node,
14838	15881	buf_sprintf("when computing vector element at index %" ZIG_PRI_usize, i));
14839		return ira->codegen->invalid_instruction;
	15882	return ira->codegen->invalid_inst_gen;
14840	15883	}
14841	15884	}
14842	15885	out_val->type = result_type;
...	...	@@ -14845,7 +15888,7 @@ static IrInstruction ir_analyze_bin_op_cmp_numeric(IrAnalyze ira, IrInstructio
14845	15888	if (ir_eval_bin_op_cmp_scalar(ira, source_instr, op1->value, op_id,
14846	15889	op2->value, out_val) != nullptr)
14847	15890	{
14848		return ira->codegen->invalid_instruction;
	15891	return ira->codegen->invalid_inst_gen;
14849	15892	}
14850	15893	}
14851	15894	return result_instruction;
...	...	@@ -14939,10 +15982,10 @@ static IrInstruction ir_analyze_bin_op_cmp_numeric(IrAnalyze ira, IrInstructio
14939	15982	}
14940	15983	ZigType *dest_type = (result_type->id == ZigTypeIdVector) ?
14941	15984	get_vector_type(ira->codegen, result_type->data.vector.len, dest_scalar_type) : dest_scalar_type;
14942		IrInstruction *casted_op1 = ir_implicit_cast(ira, op1, dest_type);
14943		IrInstruction *casted_op2 = ir_implicit_cast(ira, op2, dest_type);
	15985	IrInstGen *casted_op1 = ir_implicit_cast(ira, op1, dest_type);
	15986	IrInstGen *casted_op2 = ir_implicit_cast(ira, op2, dest_type);
14944	15987	if (type_is_invalid(casted_op1->value->type) \|\| type_is_invalid(casted_op2->value->type))
14945		return ira->codegen->invalid_instruction;
	15988	return ira->codegen->invalid_inst_gen;
14946	15989	return ir_build_bin_op_gen(ira, source_instr, result_type, op_id, casted_op1, casted_op2, true);
14947	15990	}
14948	15991
...	...	@@ -14972,12 +16015,12 @@ static IrInstruction ir_analyze_bin_op_cmp_numeric(IrAnalyze ira, IrInstructio
14972	16015	if (instr_is_comptime(op1)) {
14973	16016	ZigValue *op1_val = ir_resolve_const(ira, op1, UndefOk);
14974	16017	if (op1_val == nullptr)
14975		return ira->codegen->invalid_instruction;
	16018	return ira->codegen->invalid_inst_gen;
14976	16019	if (op1_val->special == ConstValSpecialUndef)
14977	16020	return ir_const_undef(ira, source_instr, ira->codegen->builtin_types.entry_bool);
14978	16021	if (result_type->id == ZigTypeIdVector) {
14979		ir_add_error(ira, op1, buf_sprintf("compiler bug: TODO: support comptime vector here"));
14980		return ira->codegen->invalid_instruction;
	16022	ir_add_error(ira, &op1->base, buf_sprintf("compiler bug: TODO: support comptime vector here"));
	16023	return ira->codegen->invalid_inst_gen;
14981	16024	}
14982	16025	bool is_unsigned;
14983	16026	if (op1_is_float) {
...	...	@@ -15016,12 +16059,12 @@ static IrInstruction ir_analyze_bin_op_cmp_numeric(IrAnalyze ira, IrInstructio
15016	16059	if (instr_is_comptime(op2)) {
15017	16060	ZigValue *op2_val = ir_resolve_const(ira, op2, UndefOk);
15018	16061	if (op2_val == nullptr)
15019		return ira->codegen->invalid_instruction;
	16062	return ira->codegen->invalid_inst_gen;
15020	16063	if (op2_val->special == ConstValSpecialUndef)
15021	16064	return ir_const_undef(ira, source_instr, ira->codegen->builtin_types.entry_bool);
15022	16065	if (result_type->id == ZigTypeIdVector) {
15023		ir_add_error(ira, op2, buf_sprintf("compiler bug: TODO: support comptime vector here"));
15024		return ira->codegen->invalid_instruction;
	16066	ir_add_error(ira, &op2->base, buf_sprintf("compiler bug: TODO: support comptime vector here"));
	16067	return ira->codegen->invalid_inst_gen;
15025	16068	}
15026	16069	bool is_unsigned;
15027	16070	if (op2_is_float) {
...	...	@@ -15062,35 +16105,35 @@ static IrInstruction ir_analyze_bin_op_cmp_numeric(IrAnalyze ira, IrInstructio
15062	16105	ZigType *dest_type = (result_type->id == ZigTypeIdVector) ?
15063	16106	get_vector_type(ira->codegen, result_type->data.vector.len, dest_scalar_type) : dest_scalar_type;
15064	16107
15065		IrInstruction *casted_op1 = ir_implicit_cast(ira, op1, dest_type);
	16108	IrInstGen *casted_op1 = ir_implicit_cast(ira, op1, dest_type);
15066	16109	if (type_is_invalid(casted_op1->value->type))
15067		return ira->codegen->invalid_instruction;
15068		IrInstruction *casted_op2 = ir_implicit_cast(ira, op2, dest_type);
	16110	return ira->codegen->invalid_inst_gen;
	16111	IrInstGen *casted_op2 = ir_implicit_cast(ira, op2, dest_type);
15069	16112	if (type_is_invalid(casted_op2->value->type))
15070		return ira->codegen->invalid_instruction;
	16113	return ira->codegen->invalid_inst_gen;
15071	16114	return ir_build_bin_op_gen(ira, source_instr, result_type, op_id, casted_op1, casted_op2, true);
15072	16115	}
15073	16116
15074		static IrInstruction ir_analyze_bin_op_cmp(IrAnalyze ira, IrInstructionBinOp *bin_op_instruction) {
15075		IrInstruction *op1 = bin_op_instruction->op1->child;
	16117	static IrInstGen ir_analyze_bin_op_cmp(IrAnalyze ira, IrInstSrcBinOp *bin_op_instruction) {
	16118	IrInstGen *op1 = bin_op_instruction->op1->child;
15076	16119	if (type_is_invalid(op1->value->type))
15077		return ira->codegen->invalid_instruction;
	16120	return ira->codegen->invalid_inst_gen;
15078	16121
15079		IrInstruction *op2 = bin_op_instruction->op2->child;
	16122	IrInstGen *op2 = bin_op_instruction->op2->child;
15080	16123	if (type_is_invalid(op2->value->type))
15081		return ira->codegen->invalid_instruction;
	16124	return ira->codegen->invalid_inst_gen;
15082	16125
15083		AstNode *source_node = bin_op_instruction->base.source_node;
	16126	AstNode *source_node = bin_op_instruction->base.base.source_node;
15084	16127
15085	16128	IrBinOp op_id = bin_op_instruction->op_id;
15086	16129	bool is_equality_cmp = (op_id == IrBinOpCmpEq \|\| op_id == IrBinOpCmpNotEq);
15087	16130	if (is_equality_cmp && op1->value->type->id == ZigTypeIdNull && op2->value->type->id == ZigTypeIdNull) {
15088		return ir_const_bool(ira, &bin_op_instruction->base, (op_id == IrBinOpCmpEq));
	16131	return ir_const_bool(ira, &bin_op_instruction->base.base, (op_id == IrBinOpCmpEq));
15089	16132	} else if (is_equality_cmp &&
15090	16133	((op1->value->type->id == ZigTypeIdNull && op2->value->type->id == ZigTypeIdOptional) \|\|
15091	16134	(op2->value->type->id == ZigTypeIdNull && op1->value->type->id == ZigTypeIdOptional)))
15092	16135	{
15093		IrInstruction *maybe_op;
	16136	IrInstGen *maybe_op;
15094	16137	if (op1->value->type->id == ZigTypeIdNull) {
15095	16138	maybe_op = op2;
15096	16139	} else if (op2->value->type->id == ZigTypeIdNull) {
...	...	@@ -15101,21 +16144,16 @@ static IrInstruction ir_analyze_bin_op_cmp(IrAnalyze ira, IrInstructionBinOp *
15101	16144	if (instr_is_comptime(maybe_op)) {
15102	16145	ZigValue *maybe_val = ir_resolve_const(ira, maybe_op, UndefBad);
15103	16146	if (!maybe_val)
15104		return ira->codegen->invalid_instruction;
	16147	return ira->codegen->invalid_inst_gen;
15105	16148	bool is_null = optional_value_is_null(maybe_val);
15106	16149	bool bool_result = (op_id == IrBinOpCmpEq) ? is_null : !is_null;
15107		return ir_const_bool(ira, &bin_op_instruction->base, bool_result);
	16150	return ir_const_bool(ira, &bin_op_instruction->base.base, bool_result);
15108	16151	}
15109	16152
15110		IrInstruction *is_non_null = ir_build_test_nonnull(&ira->new_irb, bin_op_instruction->base.scope,
15111		source_node, maybe_op);
15112		is_non_null->value->type = ira->codegen->builtin_types.entry_bool;
	16153	IrInstGen *is_non_null = ir_build_test_non_null_gen(ira, &bin_op_instruction->base.base, maybe_op);
15113	16154
15114	16155	if (op_id == IrBinOpCmpEq) {
15115		IrInstruction *result = ir_build_bool_not(&ira->new_irb, bin_op_instruction->base.scope,
15116		bin_op_instruction->base.source_node, is_non_null);
15117		result->value->type = ira->codegen->builtin_types.entry_bool;
15118		return result;
	16156	return ir_build_bool_not_gen(ira, &bin_op_instruction->base.base, is_non_null);
15119	16157	} else {
15120	16158	return is_non_null;
15121	16159	}
...	...	@@ -15125,7 +16163,7 @@ static IrInstruction ir_analyze_bin_op_cmp(IrAnalyze ira, IrInstructionBinOp *
15125	16163	(op2->value->type->id == ZigTypeIdNull && op1->value->type->id == ZigTypeIdPointer &&
15126	16164	op1->value->type->data.pointer.ptr_len == PtrLenC)))
15127	16165	{
15128		IrInstruction *c_ptr_op;
	16166	IrInstGen *c_ptr_op;
15129	16167	if (op1->value->type->id == ZigTypeIdNull) {
15130	16168	c_ptr_op = op2;
15131	16169	} else if (op2->value->type->id == ZigTypeIdNull) {
...	...	@@ -15136,24 +16174,19 @@ static IrInstruction ir_analyze_bin_op_cmp(IrAnalyze ira, IrInstructionBinOp *
15136	16174	if (instr_is_comptime(c_ptr_op)) {
15137	16175	ZigValue *c_ptr_val = ir_resolve_const(ira, c_ptr_op, UndefOk);
15138	16176	if (!c_ptr_val)
15139		return ira->codegen->invalid_instruction;
	16177	return ira->codegen->invalid_inst_gen;
15140	16178	if (c_ptr_val->special == ConstValSpecialUndef)
15141		return ir_const_undef(ira, &bin_op_instruction->base, ira->codegen->builtin_types.entry_bool);
	16179	return ir_const_undef(ira, &bin_op_instruction->base.base, ira->codegen->builtin_types.entry_bool);
15142	16180	bool is_null = c_ptr_val->data.x_ptr.special == ConstPtrSpecialNull \|\|
15143	16181	(c_ptr_val->data.x_ptr.special == ConstPtrSpecialHardCodedAddr &&
15144	16182	c_ptr_val->data.x_ptr.data.hard_coded_addr.addr == 0);
15145	16183	bool bool_result = (op_id == IrBinOpCmpEq) ? is_null : !is_null;
15146		return ir_const_bool(ira, &bin_op_instruction->base, bool_result);
	16184	return ir_const_bool(ira, &bin_op_instruction->base.base, bool_result);
15147	16185	}
15148		IrInstruction *is_non_null = ir_build_test_nonnull(&ira->new_irb, bin_op_instruction->base.scope,
15149		source_node, c_ptr_op);
15150		is_non_null->value->type = ira->codegen->builtin_types.entry_bool;
	16186	IrInstGen *is_non_null = ir_build_test_non_null_gen(ira, &bin_op_instruction->base.base, c_ptr_op);
15151	16187
15152	16188	if (op_id == IrBinOpCmpEq) {
15153		IrInstruction *result = ir_build_bool_not(&ira->new_irb, bin_op_instruction->base.scope,
15154		bin_op_instruction->base.source_node, is_non_null);
15155		result->value->type = ira->codegen->builtin_types.entry_bool;
15156		return result;
	16189	return ir_build_bool_not_gen(ira, &bin_op_instruction->base.base, is_non_null);
15157	16190	} else {
15158	16191	return is_non_null;
15159	16192	}
...	...	@@ -15161,61 +16194,57 @@ static IrInstruction ir_analyze_bin_op_cmp(IrAnalyze ira, IrInstructionBinOp *
15161	16194	ZigType *non_null_type = (op1->value->type->id == ZigTypeIdNull) ? op2->value->type : op1->value->type;
15162	16195	ir_add_error_node(ira, source_node, buf_sprintf("comparison of '%s' with null",
15163	16196	buf_ptr(&non_null_type->name)));
15164		return ira->codegen->invalid_instruction;
	16197	return ira->codegen->invalid_inst_gen;
15165	16198	} else if (is_equality_cmp && (
15166	16199	(op1->value->type->id == ZigTypeIdEnumLiteral && op2->value->type->id == ZigTypeIdUnion) \|\|
15167	16200	(op2->value->type->id == ZigTypeIdEnumLiteral && op1->value->type->id == ZigTypeIdUnion)))
15168	16201	{
15169	16202	// Support equality comparison between a union's tag value and a enum literal
15170		IrInstruction *union_val = op1->value->type->id == ZigTypeIdUnion ? op1 : op2;
15171		IrInstruction *enum_val = op1->value->type->id == ZigTypeIdUnion ? op2 : op1;
	16203	IrInstGen *union_val = op1->value->type->id == ZigTypeIdUnion ? op1 : op2;
	16204	IrInstGen *enum_val = op1->value->type->id == ZigTypeIdUnion ? op2 : op1;
15172	16205
15173	16206	ZigType *tag_type = union_val->value->type->data.unionation.tag_type;
15174	16207	assert(tag_type != nullptr);
15175	16208
15176		IrInstruction *casted_union = ir_implicit_cast(ira, union_val, tag_type);
	16209	IrInstGen *casted_union = ir_implicit_cast(ira, union_val, tag_type);
15177	16210	if (type_is_invalid(casted_union->value->type))
15178		return ira->codegen->invalid_instruction;
	16211	return ira->codegen->invalid_inst_gen;
15179	16212
15180		IrInstruction *casted_val = ir_implicit_cast(ira, enum_val, tag_type);
	16213	IrInstGen *casted_val = ir_implicit_cast(ira, enum_val, tag_type);
15181	16214	if (type_is_invalid(casted_val->value->type))
15182		return ira->codegen->invalid_instruction;
	16215	return ira->codegen->invalid_inst_gen;
15183	16216
15184	16217	if (instr_is_comptime(casted_union)) {
15185	16218	ZigValue *const_union_val = ir_resolve_const(ira, casted_union, UndefBad);
15186	16219	if (!const_union_val)
15187		return ira->codegen->invalid_instruction;
	16220	return ira->codegen->invalid_inst_gen;
15188	16221
15189	16222	ZigValue *const_enum_val = ir_resolve_const(ira, casted_val, UndefBad);
15190	16223	if (!const_enum_val)
15191		return ira->codegen->invalid_instruction;
	16224	return ira->codegen->invalid_inst_gen;
15192	16225
15193	16226	Cmp cmp_result = bigint_cmp(&const_union_val->data.x_union.tag, &const_enum_val->data.x_enum_tag);
15194	16227	bool bool_result = (op_id == IrBinOpCmpEq) ? cmp_result == CmpEQ : cmp_result != CmpEQ;
15195	16228
15196		return ir_const_bool(ira, &bin_op_instruction->base, bool_result);
	16229	return ir_const_bool(ira, &bin_op_instruction->base.base, bool_result);
15197	16230	}
15198	16231
15199		IrInstruction *result = ir_build_bin_op(&ira->new_irb,
15200		bin_op_instruction->base.scope, bin_op_instruction->base.source_node,
	16232	return ir_build_bin_op_gen(ira, &bin_op_instruction->base.base, ira->codegen->builtin_types.entry_bool,
15201	16233	op_id, casted_union, casted_val, bin_op_instruction->safety_check_on);
15202		result->value->type = ira->codegen->builtin_types.entry_bool;
15203
15204		return result;
15205	16234	}
15206	16235
15207	16236	if (op1->value->type->id == ZigTypeIdErrorSet && op2->value->type->id == ZigTypeIdErrorSet) {
15208	16237	if (!is_equality_cmp) {
15209	16238	ir_add_error_node(ira, source_node, buf_sprintf("operator not allowed for errors"));
15210		return ira->codegen->invalid_instruction;
	16239	return ira->codegen->invalid_inst_gen;
15211	16240	}
15212	16241	ZigType *intersect_type = get_error_set_intersection(ira, op1->value->type, op2->value->type, source_node);
15213	16242	if (type_is_invalid(intersect_type)) {
15214		return ira->codegen->invalid_instruction;
	16243	return ira->codegen->invalid_inst_gen;
15215	16244	}
15216	16245
15217	16246	if (!resolve_inferred_error_set(ira->codegen, intersect_type, source_node)) {
15218		return ira->codegen->invalid_instruction;
	16247	return ira->codegen->invalid_inst_gen;
15219	16248	}
15220	16249
15221	16250	// exception if one of the operators has the type of the empty error set, we allow the comparison
...	...	@@ -15232,7 +16261,7 @@ static IrInstruction ir_analyze_bin_op_cmp(IrAnalyze ira, IrInstructionBinOp *
15232	16261	} else {
15233	16262	zig_unreachable();
15234	16263	}
15235		return ir_const_bool(ira, &bin_op_instruction->base, answer);
	16264	return ir_const_bool(ira, &bin_op_instruction->base.base, answer);
15236	16265	}
15237	16266
15238	16267	if (!type_is_global_error_set(intersect_type)) {
...	...	@@ -15240,7 +16269,7 @@ static IrInstruction ir_analyze_bin_op_cmp(IrAnalyze ira, IrInstructionBinOp *
15240	16269	ir_add_error_node(ira, source_node,
15241	16270	buf_sprintf("error sets '%s' and '%s' have no common errors",
15242	16271	buf_ptr(&op1->value->type->name), buf_ptr(&op2->value->type->name)));
15243		return ira->codegen->invalid_instruction;
	16272	return ira->codegen->invalid_inst_gen;
15244	16273	}
15245	16274	if (op1->value->type->data.error_set.err_count == 1 && op2->value->type->data.error_set.err_count == 1) {
15246	16275	bool are_equal = true;
...	...	@@ -15252,17 +16281,17 @@ static IrInstruction ir_analyze_bin_op_cmp(IrAnalyze ira, IrInstructionBinOp *
15252	16281	} else {
15253	16282	zig_unreachable();
15254	16283	}
15255		return ir_const_bool(ira, &bin_op_instruction->base, answer);
	16284	return ir_const_bool(ira, &bin_op_instruction->base.base, answer);
15256	16285	}
15257	16286	}
15258	16287
15259	16288	if (instr_is_comptime(op1) && instr_is_comptime(op2)) {
15260	16289	ZigValue *op1_val = ir_resolve_const(ira, op1, UndefBad);
15261	16290	if (op1_val == nullptr)
15262		return ira->codegen->invalid_instruction;
	16291	return ira->codegen->invalid_inst_gen;
15263	16292	ZigValue *op2_val = ir_resolve_const(ira, op2, UndefBad);
15264	16293	if (op2_val == nullptr)
15265		return ira->codegen->invalid_instruction;
	16294	return ira->codegen->invalid_inst_gen;
15266	16295
15267	16296	bool answer;
15268	16297	bool are_equal = op1_val->data.x_err_set->value == op2_val->data.x_err_set->value;
...	...	@@ -15274,27 +16303,24 @@ static IrInstruction ir_analyze_bin_op_cmp(IrAnalyze ira, IrInstructionBinOp *
15274	16303	zig_unreachable();
15275	16304	}
15276	16305
15277		return ir_const_bool(ira, &bin_op_instruction->base, answer);
	16306	return ir_const_bool(ira, &bin_op_instruction->base.base, answer);
15278	16307	}
15279	16308
15280		IrInstruction *result = ir_build_bin_op(&ira->new_irb,
15281		bin_op_instruction->base.scope, bin_op_instruction->base.source_node,
	16309	return ir_build_bin_op_gen(ira, &bin_op_instruction->base.base, ira->codegen->builtin_types.entry_bool,
15282	16310	op_id, op1, op2, bin_op_instruction->safety_check_on);
15283		result->value->type = ira->codegen->builtin_types.entry_bool;
15284		return result;
15285	16311	}
15286	16312
15287	16313	if (type_is_numeric(op1->value->type) && type_is_numeric(op2->value->type)) {
15288	16314	// This operation allows any combination of integer and float types, regardless of the
15289	16315	// signed-ness, comptime-ness, and bit-width. So peer type resolution is incorrect for
15290	16316	// numeric types.
15291		return ir_analyze_bin_op_cmp_numeric(ira, &bin_op_instruction->base, op1, op2, op_id);
	16317	return ir_analyze_bin_op_cmp_numeric(ira, &bin_op_instruction->base.base, op1, op2, op_id);
15292	16318	}
15293	16319
15294		IrInstruction *instructions[] = {op1, op2};
	16320	IrInstGen *instructions[] = {op1, op2};
15295	16321	ZigType *resolved_type = ir_resolve_peer_types(ira, source_node, nullptr, instructions, 2);
15296	16322	if (type_is_invalid(resolved_type))
15297		return ira->codegen->invalid_instruction;
	16323	return ira->codegen->invalid_inst_gen;
15298	16324
15299	16325	bool operator_allowed;
15300	16326	switch (resolved_type->id) {
...	...	@@ -15342,21 +16368,21 @@ static IrInstruction ir_analyze_bin_op_cmp(IrAnalyze ira, IrInstructionBinOp *
15342	16368	if (!operator_allowed) {
15343	16369	ir_add_error_node(ira, source_node,
15344	16370	buf_sprintf("operator not allowed for type '%s'", buf_ptr(&resolved_type->name)));
15345		return ira->codegen->invalid_instruction;
	16371	return ira->codegen->invalid_inst_gen;
15346	16372	}
15347	16373
15348		IrInstruction *casted_op1 = ir_implicit_cast(ira, op1, resolved_type);
15349		if (casted_op1 == ira->codegen->invalid_instruction)
15350		return ira->codegen->invalid_instruction;
	16374	IrInstGen *casted_op1 = ir_implicit_cast(ira, op1, resolved_type);
	16375	if (type_is_invalid(casted_op1->value->type))
	16376	return ira->codegen->invalid_inst_gen;
15351	16377
15352		IrInstruction *casted_op2 = ir_implicit_cast(ira, op2, resolved_type);
15353		if (casted_op2 == ira->codegen->invalid_instruction)
15354		return ira->codegen->invalid_instruction;
	16378	IrInstGen *casted_op2 = ir_implicit_cast(ira, op2, resolved_type);
	16379	if (type_is_invalid(casted_op2->value->type))
	16380	return ira->codegen->invalid_inst_gen;
15355	16381
15356	16382	bool one_possible_value;
15357	16383	switch (type_has_one_possible_value(ira->codegen, resolved_type)) {
15358	16384	case OnePossibleValueInvalid:
15359		return ira->codegen->invalid_instruction;
	16385	return ira->codegen->invalid_inst_gen;
15360	16386	case OnePossibleValueYes:
15361	16387	one_possible_value = true;
15362	16388	break;
...	...	@@ -15368,20 +16394,20 @@ static IrInstruction ir_analyze_bin_op_cmp(IrAnalyze ira, IrInstructionBinOp *
15368	16394	if (one_possible_value \|\| (instr_is_comptime(casted_op1) && instr_is_comptime(casted_op2))) {
15369	16395	ZigValue *op1_val = one_possible_value ? casted_op1->value : ir_resolve_const(ira, casted_op1, UndefBad);
15370	16396	if (op1_val == nullptr)
15371		return ira->codegen->invalid_instruction;
	16397	return ira->codegen->invalid_inst_gen;
15372	16398	ZigValue *op2_val = one_possible_value ? casted_op2->value : ir_resolve_const(ira, casted_op2, UndefBad);
15373	16399	if (op2_val == nullptr)
15374		return ira->codegen->invalid_instruction;
	16400	return ira->codegen->invalid_inst_gen;
15375	16401	if (resolved_type->id != ZigTypeIdVector)
15376	16402	return ir_evaluate_bin_op_cmp(ira, resolved_type, op1_val, op2_val, bin_op_instruction, op_id, one_possible_value);
15377		IrInstruction *result = ir_const(ira, &bin_op_instruction->base,
	16403	IrInstGen *result = ir_const(ira, &bin_op_instruction->base.base,
15378	16404	get_vector_type(ira->codegen, resolved_type->data.vector.len, ira->codegen->builtin_types.entry_bool));
15379	16405	result->value->data.x_array.data.s_none.elements =
15380	16406	create_const_vals(resolved_type->data.vector.len);
15381	16407
15382	16408	expand_undef_array(ira->codegen, result->value);
15383	16409	for (size_t i = 0;i < resolved_type->data.vector.len;i++) {
15384		IrInstruction *cur_res = ir_evaluate_bin_op_cmp(ira, resolved_type->data.vector.elem_type,
	16410	IrInstGen *cur_res = ir_evaluate_bin_op_cmp(ira, resolved_type->data.vector.elem_type,
15385	16411	&op1_val->data.x_array.data.s_none.elements[i],
15386	16412	&op2_val->data.x_array.data.s_none.elements[i],
15387	16413	bin_op_instruction, op_id, one_possible_value);
...	...	@@ -15390,19 +16416,14 @@ static IrInstruction ir_analyze_bin_op_cmp(IrAnalyze ira, IrInstructionBinOp *
15390	16416	return result;
15391	16417	}
15392	16418
15393		IrInstruction *result = ir_build_bin_op(&ira->new_irb,
15394		bin_op_instruction->base.scope, bin_op_instruction->base.source_node,
	16419	ZigType *res_type = (resolved_type->id == ZigTypeIdVector) ?
	16420	get_vector_type(ira->codegen, resolved_type->data.vector.len, ira->codegen->builtin_types.entry_bool) :
	16421	ira->codegen->builtin_types.entry_bool;
	16422	return ir_build_bin_op_gen(ira, &bin_op_instruction->base.base, res_type,
15395	16423	op_id, casted_op1, casted_op2, bin_op_instruction->safety_check_on);
15396		if (resolved_type->id == ZigTypeIdVector) {
15397		result->value->type = get_vector_type(ira->codegen, resolved_type->data.vector.len,
15398		ira->codegen->builtin_types.entry_bool);
15399		} else {
15400		result->value->type = ira->codegen->builtin_types.entry_bool;
15401		}
15402		return result;
15403	16424	}
15404	16425
15405		static ErrorMsg ir_eval_math_op_scalar(IrAnalyze ira, IrInstruction source_instr, ZigType type_entry,
	16426	static ErrorMsg ir_eval_math_op_scalar(IrAnalyze ira, IrInst* source_instr, ZigType *type_entry,
15406	16427	ZigValue op1_val, IrBinOp op_id, ZigValue op2_val, ZigValue *out_val)
15407	16428	{
15408	16429	bool is_int;
...	...	@@ -15582,10 +16603,10 @@ static ErrorMsg ir_eval_math_op_scalar(IrAnalyze ira, IrInstruction *source_in
15582	16603	}
15583	16604
15584	16605	// This works on operands that have already been checked to be comptime known.
15585		static IrInstruction ir_analyze_math_op(IrAnalyze ira, IrInstruction *source_instr,
	16606	static IrInstGen ir_analyze_math_op(IrAnalyze ira, IrInst* source_instr,
15586	16607	ZigType type_entry, ZigValue op1_val, IrBinOp op_id, ZigValue *op2_val)
15587	16608	{
15588		IrInstruction *result_instruction = ir_const(ira, source_instr, type_entry);
	16609	IrInstGen *result_instruction = ir_const(ira, source_instr, type_entry);
15589	16610	ZigValue *out_val = result_instruction->value;
15590	16611	if (type_entry->id == ZigTypeIdVector) {
15591	16612	expand_undef_array(ira->codegen, op1_val);
...	...	@@ -15606,43 +16627,43 @@ static IrInstruction ir_analyze_math_op(IrAnalyze ira, IrInstruction *source_i
15606	16627	if (msg != nullptr) {
15607	16628	add_error_note(ira->codegen, msg, source_instr->source_node,
15608	16629	buf_sprintf("when computing vector element at index %" ZIG_PRI_usize, i));
15609		return ira->codegen->invalid_instruction;
	16630	return ira->codegen->invalid_inst_gen;
15610	16631	}
15611	16632	}
15612	16633	out_val->type = type_entry;
15613	16634	out_val->special = ConstValSpecialStatic;
15614	16635	} else {
15615	16636	if (ir_eval_math_op_scalar(ira, source_instr, type_entry, op1_val, op_id, op2_val, out_val) != nullptr) {
15616		return ira->codegen->invalid_instruction;
	16637	return ira->codegen->invalid_inst_gen;
15617	16638	}
15618	16639	}
15619	16640	return ir_implicit_cast(ira, result_instruction, type_entry);
15620	16641	}
15621	16642
15622		static IrInstruction ir_analyze_bit_shift(IrAnalyze ira, IrInstructionBinOp *bin_op_instruction) {
15623		IrInstruction *op1 = bin_op_instruction->op1->child;
	16643	static IrInstGen ir_analyze_bit_shift(IrAnalyze ira, IrInstSrcBinOp *bin_op_instruction) {
	16644	IrInstGen *op1 = bin_op_instruction->op1->child;
15624	16645	if (type_is_invalid(op1->value->type))
15625		return ira->codegen->invalid_instruction;
	16646	return ira->codegen->invalid_inst_gen;
15626	16647
15627	16648	if (op1->value->type->id != ZigTypeIdInt && op1->value->type->id != ZigTypeIdComptimeInt) {
15628		ir_add_error(ira, bin_op_instruction->op1,
	16649	ir_add_error(ira, &bin_op_instruction->op1->base,
15629	16650	buf_sprintf("bit shifting operation expected integer type, found '%s'",
15630	16651	buf_ptr(&op1->value->type->name)));
15631		return ira->codegen->invalid_instruction;
	16652	return ira->codegen->invalid_inst_gen;
15632	16653	}
15633	16654
15634		IrInstruction *op2 = bin_op_instruction->op2->child;
	16655	IrInstGen *op2 = bin_op_instruction->op2->child;
15635	16656	if (type_is_invalid(op2->value->type))
15636		return ira->codegen->invalid_instruction;
	16657	return ira->codegen->invalid_inst_gen;
15637	16658
15638	16659	if (op2->value->type->id != ZigTypeIdInt && op2->value->type->id != ZigTypeIdComptimeInt) {
15639		ir_add_error(ira, bin_op_instruction->op2,
	16660	ir_add_error(ira, &bin_op_instruction->op2->base,
15640	16661	buf_sprintf("shift amount has to be an integer type, but found '%s'",
15641	16662	buf_ptr(&op2->value->type->name)));
15642		return ira->codegen->invalid_instruction;
	16663	return ira->codegen->invalid_inst_gen;
15643	16664	}
15644	16665
15645		IrInstruction *casted_op2;
	16666	IrInstGen *casted_op2;
15646	16667	IrBinOp op_id = bin_op_instruction->op_id;
15647	16668	if (op1->value->type->id == ZigTypeIdComptimeInt) {
15648	16669	casted_op2 = op2;
...	...	@@ -15654,8 +16675,8 @@ static IrInstruction ir_analyze_bit_shift(IrAnalyze ira, IrInstructionBinOp *b
15654	16675	if (casted_op2->value->data.x_bigint.is_negative) {
15655	16676	Buf *val_buf = buf_alloc();
15656	16677	bigint_append_buf(val_buf, &casted_op2->value->data.x_bigint, 10);
15657		ir_add_error(ira, casted_op2, buf_sprintf("shift by negative value %s", buf_ptr(val_buf)));
15658		return ira->codegen->invalid_instruction;
	16678	ir_add_error(ira, &casted_op2->base, buf_sprintf("shift by negative value %s", buf_ptr(val_buf)));
	16679	return ira->codegen->invalid_inst_gen;
15659	16680	}
15660	16681	} else {
15661	16682	ZigType *shift_amt_type = get_smallest_unsigned_int_type(ira->codegen,
...	...	@@ -15665,57 +16686,51 @@ static IrInstruction ir_analyze_bit_shift(IrAnalyze ira, IrInstructionBinOp *b
15665	16686
15666	16687	ZigValue *op2_val = ir_resolve_const(ira, op2, UndefBad);
15667	16688	if (op2_val == nullptr)
15668		return ira->codegen->invalid_instruction;
	16689	return ira->codegen->invalid_inst_gen;
15669	16690	if (!bigint_fits_in_bits(&op2_val->data.x_bigint,
15670	16691	shift_amt_type->data.integral.bit_count,
15671	16692	op2_val->data.x_bigint.is_negative)) {
15672	16693	Buf *val_buf = buf_alloc();
15673	16694	bigint_append_buf(val_buf, &op2_val->data.x_bigint, 10);
15674	16695	ErrorMsg* msg = ir_add_error(ira,
15675		&bin_op_instruction->base,
	16696	&bin_op_instruction->base.base,
15676	16697	buf_sprintf("RHS of shift is too large for LHS type"));
15677	16698	add_error_note(
15678	16699	ira->codegen,
15679	16700	msg,
15680		op2->source_node,
	16701	op2->base.source_node,
15681	16702	buf_sprintf("value %s cannot fit into type %s",
15682	16703	buf_ptr(val_buf),
15683	16704	buf_ptr(&shift_amt_type->name)));
15684		return ira->codegen->invalid_instruction;
	16705	return ira->codegen->invalid_inst_gen;
15685	16706	}
15686	16707	}
15687	16708
15688	16709	casted_op2 = ir_implicit_cast(ira, op2, shift_amt_type);
15689		if (casted_op2 == ira->codegen->invalid_instruction)
15690		return ira->codegen->invalid_instruction;
	16710	if (type_is_invalid(casted_op2->value->type))
	16711	return ira->codegen->invalid_inst_gen;
15691	16712	}
15692	16713
15693	16714	if (instr_is_comptime(op1) && instr_is_comptime(casted_op2)) {
15694	16715	ZigValue *op1_val = ir_resolve_const(ira, op1, UndefBad);
15695	16716	if (op1_val == nullptr)
15696		return ira->codegen->invalid_instruction;
	16717	return ira->codegen->invalid_inst_gen;
15697	16718
15698	16719	ZigValue *op2_val = ir_resolve_const(ira, casted_op2, UndefBad);
15699	16720	if (op2_val == nullptr)
15700		return ira->codegen->invalid_instruction;
	16721	return ira->codegen->invalid_inst_gen;
15701	16722
15702		return ir_analyze_math_op(ira, &bin_op_instruction->base, op1->value->type, op1_val, op_id, op2_val);
	16723	return ir_analyze_math_op(ira, &bin_op_instruction->base.base, op1->value->type, op1_val, op_id, op2_val);
15703	16724	} else if (op1->value->type->id == ZigTypeIdComptimeInt) {
15704		ir_add_error(ira, &bin_op_instruction->base,
	16725	ir_add_error(ira, &bin_op_instruction->base.base,
15705	16726	buf_sprintf("LHS of shift must be an integer type, or RHS must be compile-time known"));
15706		return ira->codegen->invalid_instruction;
	16727	return ira->codegen->invalid_inst_gen;
15707	16728	} else if (instr_is_comptime(casted_op2) && bigint_cmp_zero(&casted_op2->value->data.x_bigint) == CmpEQ) {
15708		IrInstruction *result = ir_build_cast(&ira->new_irb, bin_op_instruction->base.scope,
15709		bin_op_instruction->base.source_node, op1->value->type, op1, CastOpNoop);
15710		result->value->type = op1->value->type;
15711		return result;
	16729	return ir_build_cast(ira, &bin_op_instruction->base.base, op1->value->type, op1, CastOpNoop);
15712	16730	}
15713	16731
15714		IrInstruction *result = ir_build_bin_op(&ira->new_irb, bin_op_instruction->base.scope,
15715		bin_op_instruction->base.source_node, op_id,
15716		op1, casted_op2, bin_op_instruction->safety_check_on);
15717		result->value->type = op1->value->type;
15718		return result;
	16732	return ir_build_bin_op_gen(ira, &bin_op_instruction->base.base, op1->value->type,
	16733	op_id, op1, casted_op2, bin_op_instruction->safety_check_on);
15719	16734	}
15720	16735
15721	16736	static bool ok_float_op(IrBinOp op) {
...	...	@@ -15779,24 +16794,24 @@ static bool is_pointer_arithmetic_allowed(ZigType *lhs_type, IrBinOp op) {
15779	16794	zig_unreachable();
15780	16795	}
15781	16796
15782		static IrInstruction ir_analyze_bin_op_math(IrAnalyze ira, IrInstructionBinOp *instruction) {
	16797	static IrInstGen ir_analyze_bin_op_math(IrAnalyze ira, IrInstSrcBinOp *instruction) {
15783	16798	Error err;
15784	16799
15785		IrInstruction *op1 = instruction->op1->child;
	16800	IrInstGen *op1 = instruction->op1->child;
15786	16801	if (type_is_invalid(op1->value->type))
15787		return ira->codegen->invalid_instruction;
	16802	return ira->codegen->invalid_inst_gen;
15788	16803
15789		IrInstruction *op2 = instruction->op2->child;
	16804	IrInstGen *op2 = instruction->op2->child;
15790	16805	if (type_is_invalid(op2->value->type))
15791		return ira->codegen->invalid_instruction;
	16806	return ira->codegen->invalid_inst_gen;
15792	16807
15793	16808	IrBinOp op_id = instruction->op_id;
15794	16809
15795	16810	// look for pointer math
15796	16811	if (is_pointer_arithmetic_allowed(op1->value->type, op_id)) {
15797		IrInstruction *casted_op2 = ir_implicit_cast(ira, op2, ira->codegen->builtin_types.entry_usize);
	16812	IrInstGen *casted_op2 = ir_implicit_cast(ira, op2, ira->codegen->builtin_types.entry_usize);
15798	16813	if (type_is_invalid(casted_op2->value->type))
15799		return ira->codegen->invalid_instruction;
	16814	return ira->codegen->invalid_inst_gen;
15800	16815
15801	16816	// If either operand is undef, result is undef.
15802	16817	ZigValue *op1_val = nullptr;
...	...	@@ -15804,28 +16819,28 @@ static IrInstruction ir_analyze_bin_op_math(IrAnalyze ira, IrInstructionBinOp
15804	16819	if (instr_is_comptime(op1)) {
15805	16820	op1_val = ir_resolve_const(ira, op1, UndefOk);
15806	16821	if (op1_val == nullptr)
15807		return ira->codegen->invalid_instruction;
	16822	return ira->codegen->invalid_inst_gen;
15808	16823	if (op1_val->special == ConstValSpecialUndef)
15809		return ir_const_undef(ira, &instruction->base, op1->value->type);
	16824	return ir_const_undef(ira, &instruction->base.base, op1->value->type);
15810	16825	}
15811	16826	if (instr_is_comptime(casted_op2)) {
15812	16827	op2_val = ir_resolve_const(ira, casted_op2, UndefOk);
15813	16828	if (op2_val == nullptr)
15814		return ira->codegen->invalid_instruction;
	16829	return ira->codegen->invalid_inst_gen;
15815	16830	if (op2_val->special == ConstValSpecialUndef)
15816		return ir_const_undef(ira, &instruction->base, op1->value->type);
	16831	return ir_const_undef(ira, &instruction->base.base, op1->value->type);
15817	16832	}
15818	16833
15819	16834	ZigType *elem_type = op1->value->type->data.pointer.child_type;
15820	16835	if ((err = type_resolve(ira->codegen, elem_type, ResolveStatusSizeKnown)))
15821		return ira->codegen->invalid_instruction;
	16836	return ira->codegen->invalid_inst_gen;
15822	16837
15823	16838	// NOTE: this variable is meaningful iff op2_val is not null!
15824	16839	uint64_t byte_offset;
15825	16840	if (op2_val != nullptr) {
15826	16841	uint64_t elem_offset;
15827	16842	if (!ir_resolve_usize(ira, casted_op2, &elem_offset))
15828		return ira->codegen->invalid_instruction;
	16843	return ira->codegen->invalid_inst_gen;
15829	16844
15830	16845	byte_offset = type_size(ira->codegen, elem_type) * elem_offset;
15831	16846	}
...	...	@@ -15840,7 +16855,7 @@ static IrInstruction ir_analyze_bin_op_math(IrAnalyze ira, IrInstructionBinOp
15840	16855	{
15841	16856	uint32_t align_bytes;
15842	16857	if ((err = resolve_ptr_align(ira, op1->value->type, &align_bytes)))
15843		return ira->codegen->invalid_instruction;
	16858	return ira->codegen->invalid_inst_gen;
15844	16859
15845	16860	// If the addend is not a comptime-known value we can still count on
15846	16861	// it being a multiple of the type size
...	...	@@ -15869,23 +16884,20 @@ static IrInstruction ir_analyze_bin_op_math(IrAnalyze ira, IrInstructionBinOp
15869	16884	} else {
15870	16885	zig_unreachable();
15871	16886	}
15872		IrInstruction *result = ir_const(ira, &instruction->base, result_type);
	16887	IrInstGen *result = ir_const(ira, &instruction->base.base, result_type);
15873	16888	result->value->data.x_ptr.special = ConstPtrSpecialHardCodedAddr;
15874	16889	result->value->data.x_ptr.mut = ConstPtrMutRuntimeVar;
15875	16890	result->value->data.x_ptr.data.hard_coded_addr.addr = new_addr;
15876	16891	return result;
15877	16892	}
15878	16893
15879		IrInstruction *result = ir_build_bin_op(&ira->new_irb, instruction->base.scope,
15880		instruction->base.source_node, op_id, op1, casted_op2, true);
15881		result->value->type = result_type;
15882		return result;
	16894	return ir_build_bin_op_gen(ira, &instruction->base.base, result_type, op_id, op1, casted_op2, true);
15883	16895	}
15884	16896
15885		IrInstruction *instructions[] = {op1, op2};
15886		ZigType *resolved_type = ir_resolve_peer_types(ira, instruction->base.source_node, nullptr, instructions, 2);
	16897	IrInstGen *instructions[] = {op1, op2};
	16898	ZigType *resolved_type = ir_resolve_peer_types(ira, instruction->base.base.source_node, nullptr, instructions, 2);
15887	16899	if (type_is_invalid(resolved_type))
15888		return ira->codegen->invalid_instruction;
	16900	return ira->codegen->invalid_inst_gen;
15889	16901
15890	16902	bool is_int = resolved_type->id == ZigTypeIdInt \|\| resolved_type->id == ZigTypeIdComptimeInt;
15891	16903	bool is_float = resolved_type->id == ZigTypeIdFloat \|\| resolved_type->id == ZigTypeIdComptimeFloat;
...	...	@@ -15905,11 +16917,11 @@ static IrInstruction ir_analyze_bin_op_math(IrAnalyze ira, IrInstructionBinOp
15905	16917	if (instr_is_comptime(op1) && instr_is_comptime(op2)) {
15906	16918	ZigValue *op1_val = ir_resolve_const(ira, op1, UndefBad);
15907	16919	if (op1_val == nullptr)
15908		return ira->codegen->invalid_instruction;
	16920	return ira->codegen->invalid_inst_gen;
15909	16921
15910	16922	ZigValue *op2_val = ir_resolve_const(ira, op2, UndefBad);
15911	16923	if (op2_val == nullptr)
15912		return ira->codegen->invalid_instruction;
	16924	return ira->codegen->invalid_inst_gen;
15913	16925
15914	16926	if (bigint_cmp_zero(&op2_val->data.x_bigint) == CmpEQ) {
15915	16927	// the division by zero error will be caught later, but we don't have a
...	...	@@ -15928,11 +16940,11 @@ static IrInstruction ir_analyze_bin_op_math(IrAnalyze ira, IrInstructionBinOp
15928	16940	}
15929	16941	}
15930	16942	if (!ok) {
15931		ir_add_error(ira, &instruction->base,
	16943	ir_add_error(ira, &instruction->base.base,
15932	16944	buf_sprintf("division with '%s' and '%s': signed integers must use @divTrunc, @divFloor, or @divExact",
15933	16945	buf_ptr(&op1->value->type->name),
15934	16946	buf_ptr(&op2->value->type->name)));
15935		return ira->codegen->invalid_instruction;
	16947	return ira->codegen->invalid_inst_gen;
15936	16948	}
15937	16949	} else {
15938	16950	op_id = IrBinOpDivTrunc;
...	...	@@ -15943,12 +16955,12 @@ static IrInstruction ir_analyze_bin_op_math(IrAnalyze ira, IrInstructionBinOp
15943	16955	if (instr_is_comptime(op1) && instr_is_comptime(op2)) {
15944	16956	ZigValue *op1_val = ir_resolve_const(ira, op1, UndefBad);
15945	16957	if (op1_val == nullptr)
15946		return ira->codegen->invalid_instruction;
	16958	return ira->codegen->invalid_inst_gen;
15947	16959
15948	16960	if (is_int) {
15949	16961	ZigValue *op2_val = ir_resolve_const(ira, op2, UndefBad);
15950	16962	if (op2_val == nullptr)
15951		return ira->codegen->invalid_instruction;
	16963	return ira->codegen->invalid_inst_gen;
15952	16964
15953	16965	if (bigint_cmp_zero(&op2->value->data.x_bigint) == CmpEQ) {
15954	16966	// the division by zero error will be caught later, but we don't
...	...	@@ -15962,13 +16974,13 @@ static IrInstruction ir_analyze_bin_op_math(IrAnalyze ira, IrInstructionBinOp
15962	16974	ok = bigint_cmp(&rem_result, &mod_result) == CmpEQ;
15963	16975	}
15964	16976	} else {
15965		IrInstruction *casted_op2 = ir_implicit_cast(ira, op2, resolved_type);
15966		if (casted_op2 == ira->codegen->invalid_instruction)
15967		return ira->codegen->invalid_instruction;
	16977	IrInstGen *casted_op2 = ir_implicit_cast(ira, op2, resolved_type);
	16978	if (type_is_invalid(casted_op2->value->type))
	16979	return ira->codegen->invalid_inst_gen;
15968	16980
15969	16981	ZigValue *op2_val = ir_resolve_const(ira, casted_op2, UndefBad);
15970	16982	if (op2_val == nullptr)
15971		return ira->codegen->invalid_instruction;
	16983	return ira->codegen->invalid_inst_gen;
15972	16984
15973	16985	if (float_cmp_zero(casted_op2->value) == CmpEQ) {
15974	16986	// the division by zero error will be caught later, but we don't
...	...	@@ -15984,11 +16996,11 @@ static IrInstruction ir_analyze_bin_op_math(IrAnalyze ira, IrInstructionBinOp
15984	16996	}
15985	16997	}
15986	16998	if (!ok) {
15987		ir_add_error(ira, &instruction->base,
	16999	ir_add_error(ira, &instruction->base.base,
15988	17000	buf_sprintf("remainder division with '%s' and '%s': signed integers and floats must use @rem or @mod",
15989	17001	buf_ptr(&op1->value->type->name),
15990	17002	buf_ptr(&op2->value->type->name)));
15991		return ira->codegen->invalid_instruction;
	17003	return ira->codegen->invalid_inst_gen;
15992	17004	}
15993	17005	}
15994	17006	op_id = IrBinOpRemRem;
...	...	@@ -16008,12 +17020,12 @@ static IrInstruction ir_analyze_bin_op_math(IrAnalyze ira, IrInstructionBinOp
16008	17020	}
16009	17021	}
16010	17022	if (!ok) {
16011		AstNode *source_node = instruction->base.source_node;
	17023	AstNode *source_node = instruction->base.base.source_node;
16012	17024	ir_add_error_node(ira, source_node,
16013	17025	buf_sprintf("invalid operands to binary expression: '%s' and '%s'",
16014	17026	buf_ptr(&op1->value->type->name),
16015	17027	buf_ptr(&op2->value->type->name)));
16016		return ira->codegen->invalid_instruction;
	17028	return ira->codegen->invalid_inst_gen;
16017	17029	}
16018	17030
16019	17031	if (resolved_type->id == ZigTypeIdComptimeInt) {
...	...	@@ -16026,33 +17038,31 @@ static IrInstruction ir_analyze_bin_op_math(IrAnalyze ira, IrInstructionBinOp
16026	17038	}
16027	17039	}
16028	17040
16029		IrInstruction *casted_op1 = ir_implicit_cast(ira, op1, resolved_type);
16030		if (casted_op1 == ira->codegen->invalid_instruction)
16031		return ira->codegen->invalid_instruction;
	17041	IrInstGen *casted_op1 = ir_implicit_cast(ira, op1, resolved_type);
	17042	if (type_is_invalid(casted_op1->value->type))
	17043	return ira->codegen->invalid_inst_gen;
16032	17044
16033		IrInstruction *casted_op2 = ir_implicit_cast(ira, op2, resolved_type);
16034		if (casted_op2 == ira->codegen->invalid_instruction)
16035		return ira->codegen->invalid_instruction;
	17045	IrInstGen *casted_op2 = ir_implicit_cast(ira, op2, resolved_type);
	17046	if (type_is_invalid(casted_op2->value->type))
	17047	return ira->codegen->invalid_inst_gen;
16036	17048
16037	17049	if (instr_is_comptime(casted_op1) && instr_is_comptime(casted_op2)) {
16038	17050	ZigValue *op1_val = ir_resolve_const(ira, casted_op1, UndefBad);
16039	17051	if (op1_val == nullptr)
16040		return ira->codegen->invalid_instruction;
	17052	return ira->codegen->invalid_inst_gen;
16041	17053	ZigValue *op2_val = ir_resolve_const(ira, casted_op2, UndefBad);
16042	17054	if (op2_val == nullptr)
16043		return ira->codegen->invalid_instruction;
	17055	return ira->codegen->invalid_inst_gen;
16044	17056
16045		return ir_analyze_math_op(ira, &instruction->base, resolved_type, op1_val, op_id, op2_val);
	17057	return ir_analyze_math_op(ira, &instruction->base.base, resolved_type, op1_val, op_id, op2_val);
16046	17058	}
16047	17059
16048		IrInstruction *result = ir_build_bin_op(&ira->new_irb, instruction->base.scope,
16049		instruction->base.source_node, op_id, casted_op1, casted_op2, instruction->safety_check_on);
16050		result->value->type = resolved_type;
16051		return result;
	17060	return ir_build_bin_op_gen(ira, &instruction->base.base, resolved_type,
	17061	op_id, casted_op1, casted_op2, instruction->safety_check_on);
16052	17062	}
16053	17063
16054		static IrInstruction ir_analyze_tuple_cat(IrAnalyze ira, IrInstruction *source_instr,
16055		IrInstruction op1, IrInstruction op2)
	17064	static IrInstGen ir_analyze_tuple_cat(IrAnalyze ira, IrInst* source_instr,
	17065	IrInstGen op1, IrInstGen op2)
16056	17066	{
16057	17067	Error err;
16058	17068	ZigType *op1_type = op1->value->type;
...	...	@@ -16069,9 +17079,9 @@ static IrInstruction ir_analyze_tuple_cat(IrAnalyze ira, IrInstruction *source
16069	17079	new_type->data.structure.special = StructSpecialInferredTuple;
16070	17080	new_type->data.structure.resolve_status = ResolveStatusBeingInferred;
16071	17081
16072		bool is_comptime = ir_should_inline(ira->new_irb.exec, source_instr->scope);
	17082	bool is_comptime = ir_should_inline(ira->old_irb.exec, source_instr->scope);
16073	17083
16074		IrInstruction *new_struct_ptr = ir_resolve_result(ira, source_instr, no_result_loc(),
	17084	IrInstGen *new_struct_ptr = ir_resolve_result(ira, source_instr, no_result_loc(),
16075	17085	new_type, nullptr, false, false, true);
16076	17086	uint32_t new_field_count = op1_field_count + op2_field_count;
16077	17087
...	...	@@ -16095,13 +17105,13 @@ static IrInstruction ir_analyze_tuple_cat(IrAnalyze ira, IrInstruction *source
16095	17105	new_field->is_comptime = src_field->is_comptime;
16096	17106	}
16097	17107	if ((err = type_resolve(ira->codegen, new_type, ResolveStatusZeroBitsKnown)))
16098		return ira->codegen->invalid_instruction;
	17108	return ira->codegen->invalid_inst_gen;
16099	17109
16100		ZigList<IrInstruction *> const_ptrs = {};
16101		IrInstruction *first_non_const_instruction = nullptr;
	17110	ZigList<IrInstGen *> const_ptrs = {};
	17111	IrInstGen *first_non_const_instruction = nullptr;
16102	17112	for (uint32_t i = 0; i < new_field_count; i += 1) {
16103	17113	TypeStructField *dst_field = new_type->data.structure.fields[i];
16104		IrInstruction *src_struct_op;
	17114	IrInstGen *src_struct_op;
16105	17115	TypeStructField *src_field;
16106	17116	if (i < op1_field_count) {
16107	17117	src_field = op1_type->data.structure.fields[i];
...	...	@@ -16110,73 +17120,73 @@ static IrInstruction ir_analyze_tuple_cat(IrAnalyze ira, IrInstruction *source
16110	17120	src_field = op2_type->data.structure.fields[i - op1_field_count];
16111	17121	src_struct_op = op2;
16112	17122	}
16113		IrInstruction *field_value = ir_analyze_struct_value_field_value(ira, source_instr,
	17123	IrInstGen *field_value = ir_analyze_struct_value_field_value(ira, source_instr,
16114	17124	src_struct_op, src_field);
16115	17125	if (type_is_invalid(field_value->value->type))
16116		return ira->codegen->invalid_instruction;
16117		IrInstruction *dest_ptr = ir_analyze_struct_field_ptr(ira, source_instr, dst_field,
	17126	return ira->codegen->invalid_inst_gen;
	17127	IrInstGen *dest_ptr = ir_analyze_struct_field_ptr(ira, source_instr, dst_field,
16118	17128	new_struct_ptr, new_type, true);
16119	17129	if (type_is_invalid(dest_ptr->value->type))
16120		return ira->codegen->invalid_instruction;
	17130	return ira->codegen->invalid_inst_gen;
16121	17131	if (instr_is_comptime(field_value)) {
16122	17132	const_ptrs.append(dest_ptr);
16123	17133	} else {
16124	17134	first_non_const_instruction = field_value;
16125	17135	}
16126		IrInstruction *store_ptr_inst = ir_analyze_store_ptr(ira, source_instr, dest_ptr, field_value,
	17136	IrInstGen *store_ptr_inst = ir_analyze_store_ptr(ira, source_instr, dest_ptr, field_value,
16127	17137	true);
16128	17138	if (type_is_invalid(store_ptr_inst->value->type))
16129		return ira->codegen->invalid_instruction;
	17139	return ira->codegen->invalid_inst_gen;
16130	17140	}
16131	17141	if (const_ptrs.length != new_field_count) {
16132	17142	new_struct_ptr->value->special = ConstValSpecialRuntime;
16133	17143	for (size_t i = 0; i < const_ptrs.length; i += 1) {
16134		IrInstruction *elem_result_loc = const_ptrs.at(i);
	17144	IrInstGen *elem_result_loc = const_ptrs.at(i);
16135	17145	assert(elem_result_loc->value->special == ConstValSpecialStatic);
16136	17146	if (elem_result_loc->value->type->data.pointer.inferred_struct_field != nullptr) {
16137	17147	// This field will be generated comptime; no need to do this.
16138	17148	continue;
16139	17149	}
16140		IrInstruction *deref = ir_get_deref(ira, elem_result_loc, elem_result_loc, nullptr);
	17150	IrInstGen *deref = ir_get_deref(ira, &elem_result_loc->base, elem_result_loc, nullptr);
16141	17151	elem_result_loc->value->special = ConstValSpecialRuntime;
16142		ir_analyze_store_ptr(ira, elem_result_loc, elem_result_loc, deref, false);
	17152	ir_analyze_store_ptr(ira, &elem_result_loc->base, elem_result_loc, deref, false);
16143	17153	}
16144	17154	}
16145		IrInstruction *result = ir_get_deref(ira, source_instr, new_struct_ptr, nullptr);
	17155	IrInstGen *result = ir_get_deref(ira, source_instr, new_struct_ptr, nullptr);
16146	17156	if (instr_is_comptime(result))
16147	17157	return result;
16148	17158
16149	17159	if (is_comptime) {
16150		ir_add_error_node(ira, first_non_const_instruction->source_node,
	17160	ir_add_error(ira, &first_non_const_instruction->base,
16151	17161	buf_sprintf("unable to evaluate constant expression"));
16152		return ira->codegen->invalid_instruction;
	17162	return ira->codegen->invalid_inst_gen;
16153	17163	}
16154	17164
16155	17165	return result;
16156	17166	}
16157	17167
16158		static IrInstruction ir_analyze_array_cat(IrAnalyze ira, IrInstructionBinOp *instruction) {
16159		IrInstruction *op1 = instruction->op1->child;
	17168	static IrInstGen ir_analyze_array_cat(IrAnalyze ira, IrInstSrcBinOp *instruction) {
	17169	IrInstGen *op1 = instruction->op1->child;
16160	17170	ZigType *op1_type = op1->value->type;
16161	17171	if (type_is_invalid(op1_type))
16162		return ira->codegen->invalid_instruction;
	17172	return ira->codegen->invalid_inst_gen;
16163	17173
16164		IrInstruction *op2 = instruction->op2->child;
	17174	IrInstGen *op2 = instruction->op2->child;
16165	17175	ZigType *op2_type = op2->value->type;
16166	17176	if (type_is_invalid(op2_type))
16167		return ira->codegen->invalid_instruction;
	17177	return ira->codegen->invalid_inst_gen;
16168	17178
16169	17179	if (is_tuple(op1_type) && is_tuple(op2_type)) {
16170		return ir_analyze_tuple_cat(ira, &instruction->base, op1, op2);
	17180	return ir_analyze_tuple_cat(ira, &instruction->base.base, op1, op2);
16171	17181	}
16172	17182
16173	17183	ZigValue *op1_val = ir_resolve_const(ira, op1, UndefBad);
16174	17184	if (!op1_val)
16175		return ira->codegen->invalid_instruction;
	17185	return ira->codegen->invalid_inst_gen;
16176	17186
16177	17187	ZigValue *op2_val = ir_resolve_const(ira, op2, UndefBad);
16178	17188	if (!op2_val)
16179		return ira->codegen->invalid_instruction;
	17189	return ira->codegen->invalid_inst_gen;
16180	17190
16181	17191	ZigValue *sentinel1 = nullptr;
16182	17192	ZigValue *op1_array_val;
...	...	@@ -16214,15 +17224,15 @@ static IrInstruction ir_analyze_array_cat(IrAnalyze ira, IrInstructionBinOp *i
16214	17224	{
16215	17225	ZigType *array_type = op1_type->data.pointer.child_type;
16216	17226	child_type = array_type->data.array.child_type;
16217		op1_array_val = const_ptr_pointee(ira, ira->codegen, op1_val, op1->source_node);
	17227	op1_array_val = const_ptr_pointee(ira, ira->codegen, op1_val, op1->base.source_node);
16218	17228	if (op1_array_val == nullptr)
16219		return ira->codegen->invalid_instruction;
	17229	return ira->codegen->invalid_inst_gen;
16220	17230	op1_array_index = 0;
16221	17231	op1_array_end = array_type->data.array.len;
16222	17232	sentinel1 = array_type->data.array.sentinel;
16223	17233	} else {
16224		ir_add_error(ira, op1, buf_sprintf("expected array, found '%s'", buf_ptr(&op1->value->type->name)));
16225		return ira->codegen->invalid_instruction;
	17234	ir_add_error(ira, &op1->base, buf_sprintf("expected array, found '%s'", buf_ptr(&op1->value->type->name)));
	17235	return ira->codegen->invalid_inst_gen;
16226	17236	}
16227	17237
16228	17238	ZigValue *sentinel2 = nullptr;
...	...	@@ -16262,23 +17272,23 @@ static IrInstruction ir_analyze_array_cat(IrAnalyze ira, IrInstructionBinOp *i
16262	17272	{
16263	17273	ZigType *array_type = op2_type->data.pointer.child_type;
16264	17274	op2_type_valid = array_type->data.array.child_type == child_type;
16265		op2_array_val = const_ptr_pointee(ira, ira->codegen, op2_val, op2->source_node);
	17275	op2_array_val = const_ptr_pointee(ira, ira->codegen, op2_val, op2->base.source_node);
16266	17276	if (op2_array_val == nullptr)
16267		return ira->codegen->invalid_instruction;
	17277	return ira->codegen->invalid_inst_gen;
16268	17278	op2_array_index = 0;
16269	17279	op2_array_end = array_type->data.array.len;
16270	17280
16271	17281	sentinel2 = array_type->data.array.sentinel;
16272	17282	} else {
16273		ir_add_error(ira, op2,
	17283	ir_add_error(ira, &op2->base,
16274	17284	buf_sprintf("expected array or C string literal, found '%s'", buf_ptr(&op2->value->type->name)));
16275		return ira->codegen->invalid_instruction;
	17285	return ira->codegen->invalid_inst_gen;
16276	17286	}
16277	17287	if (!op2_type_valid) {
16278		ir_add_error(ira, op2, buf_sprintf("expected array of type '%s', found '%s'",
	17288	ir_add_error(ira, &op2->base, buf_sprintf("expected array of type '%s', found '%s'",
16279	17289	buf_ptr(&child_type->name),
16280	17290	buf_ptr(&op2->value->type->name)));
16281		return ira->codegen->invalid_instruction;
	17291	return ira->codegen->invalid_inst_gen;
16282	17292	}
16283	17293
16284	17294	ZigValue *sentinel;
...	...	@@ -16295,7 +17305,7 @@ static IrInstruction ir_analyze_array_cat(IrAnalyze ira, IrInstructionBinOp *i
16295	17305	}
16296	17306
16297	17307	// The type of result is populated in the following if blocks
16298		IrInstruction *result = ir_const(ira, &instruction->base, nullptr);
	17308	IrInstGen *result = ir_const(ira, &instruction->base.base, nullptr);
16299	17309	ZigValue *out_val = result->value;
16300	17310
16301	17311	ZigValue *out_array_val;
...	...	@@ -16383,14 +17393,14 @@ static IrInstruction ir_analyze_array_cat(IrAnalyze ira, IrInstructionBinOp *i
16383	17393	return result;
16384	17394	}
16385	17395
16386		static IrInstruction ir_analyze_array_mult(IrAnalyze ira, IrInstructionBinOp *instruction) {
16387		IrInstruction *op1 = instruction->op1->child;
	17396	static IrInstGen ir_analyze_array_mult(IrAnalyze ira, IrInstSrcBinOp *instruction) {
	17397	IrInstGen *op1 = instruction->op1->child;
16388	17398	if (type_is_invalid(op1->value->type))
16389		return ira->codegen->invalid_instruction;
	17399	return ira->codegen->invalid_inst_gen;
16390	17400
16391		IrInstruction *op2 = instruction->op2->child;
	17401	IrInstGen *op2 = instruction->op2->child;
16392	17402	if (type_is_invalid(op2->value->type))
16393		return ira->codegen->invalid_instruction;
	17403	return ira->codegen->invalid_inst_gen;
16394	17404
16395	17405	bool want_ptr_to_array = false;
16396	17406	ZigType *array_type;
...	...	@@ -16399,49 +17409,49 @@ static IrInstruction ir_analyze_array_mult(IrAnalyze ira, IrInstructionBinOp *
16399	17409	array_type = op1->value->type;
16400	17410	array_val = ir_resolve_const(ira, op1, UndefOk);
16401	17411	if (array_val == nullptr)
16402		return ira->codegen->invalid_instruction;
	17412	return ira->codegen->invalid_inst_gen;
16403	17413	} else if (op1->value->type->id == ZigTypeIdPointer && op1->value->type->data.pointer.ptr_len == PtrLenSingle &&
16404	17414	op1->value->type->data.pointer.child_type->id == ZigTypeIdArray)
16405	17415	{
16406	17416	array_type = op1->value->type->data.pointer.child_type;
16407		IrInstruction *array_inst = ir_get_deref(ira, op1, op1, nullptr);
	17417	IrInstGen *array_inst = ir_get_deref(ira, &op1->base, op1, nullptr);
16408	17418	if (type_is_invalid(array_inst->value->type))
16409		return ira->codegen->invalid_instruction;
	17419	return ira->codegen->invalid_inst_gen;
16410	17420	array_val = ir_resolve_const(ira, array_inst, UndefOk);
16411	17421	if (array_val == nullptr)
16412		return ira->codegen->invalid_instruction;
	17422	return ira->codegen->invalid_inst_gen;
16413	17423	want_ptr_to_array = true;
16414	17424	} else {
16415		ir_add_error(ira, op1, buf_sprintf("expected array type, found '%s'", buf_ptr(&op1->value->type->name)));
16416		return ira->codegen->invalid_instruction;
	17425	ir_add_error(ira, &op1->base, buf_sprintf("expected array type, found '%s'", buf_ptr(&op1->value->type->name)));
	17426	return ira->codegen->invalid_inst_gen;
16417	17427	}
16418	17428
16419	17429	uint64_t mult_amt;
16420	17430	if (!ir_resolve_usize(ira, op2, &mult_amt))
16421		return ira->codegen->invalid_instruction;
	17431	return ira->codegen->invalid_inst_gen;
16422	17432
16423	17433	uint64_t old_array_len = array_type->data.array.len;
16424	17434	uint64_t new_array_len;
16425	17435
16426	17436	if (mul_u64_overflow(old_array_len, mult_amt, &new_array_len)) {
16427		ir_add_error(ira, &instruction->base, buf_sprintf("operation results in overflow"));
16428		return ira->codegen->invalid_instruction;
	17437	ir_add_error(ira, &instruction->base.base, buf_sprintf("operation results in overflow"));
	17438	return ira->codegen->invalid_inst_gen;
16429	17439	}
16430	17440
16431	17441	ZigType *child_type = array_type->data.array.child_type;
16432	17442	ZigType *result_array_type = get_array_type(ira->codegen, child_type, new_array_len,
16433	17443	array_type->data.array.sentinel);
16434	17444
16435		IrInstruction *array_result;
	17445	IrInstGen *array_result;
16436	17446	if (array_val->special == ConstValSpecialUndef \|\| array_val->data.x_array.special == ConstArraySpecialUndef) {
16437		array_result = ir_const_undef(ira, &instruction->base, result_array_type);
	17447	array_result = ir_const_undef(ira, &instruction->base.base, result_array_type);
16438	17448	} else {
16439		array_result = ir_const(ira, &instruction->base, result_array_type);
	17449	array_result = ir_const(ira, &instruction->base.base, result_array_type);
16440	17450	ZigValue *out_val = array_result->value;
16441	17451
16442	17452	switch (type_has_one_possible_value(ira->codegen, result_array_type)) {
16443	17453	case OnePossibleValueInvalid:
16444		return ira->codegen->invalid_instruction;
	17454	return ira->codegen->invalid_inst_gen;
16445	17455	case OnePossibleValueYes:
16446	17456	goto skip_computation;
16447	17457	case OnePossibleValueNo:
...	...	@@ -16477,35 +17487,35 @@ static IrInstruction ir_analyze_array_mult(IrAnalyze ira, IrInstructionBinOp *
16477	17487	}
16478	17488	skip_computation:
16479	17489	if (want_ptr_to_array) {
16480		return ir_get_ref(ira, &instruction->base, array_result, true, false);
	17490	return ir_get_ref(ira, &instruction->base.base, array_result, true, false);
16481	17491	} else {
16482	17492	return array_result;
16483	17493	}
16484	17494	}
16485	17495
16486		static IrInstruction ir_analyze_instruction_merge_err_sets(IrAnalyze ira,
16487		IrInstructionMergeErrSets *instruction)
	17496	static IrInstGen ir_analyze_instruction_merge_err_sets(IrAnalyze ira,
	17497	IrInstSrcMergeErrSets *instruction)
16488	17498	{
16489		ZigType *op1_type = ir_resolve_error_set_type(ira, &instruction->base, instruction->op1->child);
	17499	ZigType *op1_type = ir_resolve_error_set_type(ira, &instruction->base.base, instruction->op1->child);
16490	17500	if (type_is_invalid(op1_type))
16491		return ira->codegen->invalid_instruction;
	17501	return ira->codegen->invalid_inst_gen;
16492	17502
16493		ZigType *op2_type = ir_resolve_error_set_type(ira, &instruction->base, instruction->op2->child);
	17503	ZigType *op2_type = ir_resolve_error_set_type(ira, &instruction->base.base, instruction->op2->child);
16494	17504	if (type_is_invalid(op2_type))
16495		return ira->codegen->invalid_instruction;
	17505	return ira->codegen->invalid_inst_gen;
16496	17506
16497	17507	if (type_is_global_error_set(op1_type) \|\|
16498	17508	type_is_global_error_set(op2_type))
16499	17509	{
16500		return ir_const_type(ira, &instruction->base, ira->codegen->builtin_types.entry_global_error_set);
	17510	return ir_const_type(ira, &instruction->base.base, ira->codegen->builtin_types.entry_global_error_set);
16501	17511	}
16502	17512
16503		if (!resolve_inferred_error_set(ira->codegen, op1_type, instruction->op1->child->source_node)) {
16504		return ira->codegen->invalid_instruction;
	17513	if (!resolve_inferred_error_set(ira->codegen, op1_type, instruction->op1->child->base.source_node)) {
	17514	return ira->codegen->invalid_inst_gen;
16505	17515	}
16506	17516
16507		if (!resolve_inferred_error_set(ira->codegen, op2_type, instruction->op2->child->source_node)) {
16508		return ira->codegen->invalid_instruction;
	17517	if (!resolve_inferred_error_set(ira->codegen, op2_type, instruction->op2->child->base.source_node)) {
	17518	return ira->codegen->invalid_inst_gen;
16509	17519	}
16510	17520
16511	17521	size_t errors_count = ira->codegen->errors_by_index.length;
...	...	@@ -16518,11 +17528,11 @@ static IrInstruction ir_analyze_instruction_merge_err_sets(IrAnalyze ira,
16518	17528	ZigType *result_type = get_error_set_union(ira->codegen, errors, op1_type, op2_type, instruction->type_name);
16519	17529	deallocate(errors, errors_count, "ErrorTableEntry *");
16520	17530
16521		return ir_const_type(ira, &instruction->base, result_type);
	17531	return ir_const_type(ira, &instruction->base.base, result_type);
16522	17532	}
16523	17533
16524	17534
16525		static IrInstruction ir_analyze_instruction_bin_op(IrAnalyze ira, IrInstructionBinOp *bin_op_instruction) {
	17535	static IrInstGen ir_analyze_instruction_bin_op(IrAnalyze ira, IrInstSrcBinOp *bin_op_instruction) {
16526	17536	IrBinOp op_id = bin_op_instruction->op_id;
16527	17537	switch (op_id) {
16528	17538	case IrBinOpInvalid:
...	...	@@ -16567,41 +17577,39 @@ static IrInstruction ir_analyze_instruction_bin_op(IrAnalyze ira, IrInstructio
16567	17577	zig_unreachable();
16568	17578	}
16569	17579
16570		static IrInstruction ir_analyze_instruction_decl_var(IrAnalyze ira,
16571		IrInstructionDeclVarSrc *decl_var_instruction)
16572		{
	17580	static IrInstGen ir_analyze_instruction_decl_var(IrAnalyze ira, IrInstSrcDeclVar *decl_var_instruction) {
16573	17581	Error err;
16574	17582	ZigVar *var = decl_var_instruction->var;
16575	17583
16576	17584	ZigType *explicit_type = nullptr;
16577		IrInstruction *var_type = nullptr;
	17585	IrInstGen *var_type = nullptr;
16578	17586	if (decl_var_instruction->var_type != nullptr) {
16579	17587	var_type = decl_var_instruction->var_type->child;
16580	17588	ZigType *proposed_type = ir_resolve_type(ira, var_type);
16581		explicit_type = validate_var_type(ira->codegen, var_type->source_node, proposed_type);
	17589	explicit_type = validate_var_type(ira->codegen, var_type->base.source_node, proposed_type);
16582	17590	if (type_is_invalid(explicit_type)) {
16583	17591	var->var_type = ira->codegen->builtin_types.entry_invalid;
16584		return ira->codegen->invalid_instruction;
	17592	return ira->codegen->invalid_inst_gen;
16585	17593	}
16586	17594	}
16587	17595
16588		AstNode *source_node = decl_var_instruction->base.source_node;
	17596	AstNode *source_node = decl_var_instruction->base.base.source_node;
16589	17597
16590	17598	bool is_comptime_var = ir_get_var_is_comptime(var);
16591	17599
16592	17600	bool var_class_requires_const = false;
16593	17601
16594		IrInstruction *var_ptr = decl_var_instruction->ptr->child;
	17602	IrInstGen *var_ptr = decl_var_instruction->ptr->child;
16595	17603	// if this is null, a compiler error happened and did not initialize the variable.
16596	17604	// if there are no compile errors there may be a missing ir_expr_wrap in pass1 IR generation.
16597	17605	if (var_ptr == nullptr \|\| type_is_invalid(var_ptr->value->type)) {
16598		ir_assert(var_ptr != nullptr \|\| ira->codegen->errors.length != 0, &decl_var_instruction->base);
	17606	ir_assert(var_ptr != nullptr \|\| ira->codegen->errors.length != 0, &decl_var_instruction->base.base);
16599	17607	var->var_type = ira->codegen->builtin_types.entry_invalid;
16600		return ira->codegen->invalid_instruction;
	17608	return ira->codegen->invalid_inst_gen;
16601	17609	}
16602	17610
16603	17611	// The ir_build_var_decl_src call is supposed to pass a pointer to the allocation, not an initialization value.
16604		ir_assert(var_ptr->value->type->id == ZigTypeIdPointer, &decl_var_instruction->base);
	17612	ir_assert(var_ptr->value->type->id == ZigTypeIdPointer, &decl_var_instruction->base.base);
16605	17613
16606	17614	ZigType *result_type = var_ptr->value->type->data.pointer.child_type;
16607	17615	if (type_is_invalid(result_type)) {
...	...	@@ -16612,7 +17620,7 @@ static IrInstruction ir_analyze_instruction_decl_var(IrAnalyze ira,
16612	17620
16613	17621	ZigValue *init_val = nullptr;
16614	17622	if (instr_is_comptime(var_ptr) && var_ptr->value->data.x_ptr.mut != ConstPtrMutRuntimeVar) {
16615		init_val = const_ptr_pointee(ira, ira->codegen, var_ptr->value, decl_var_instruction->base.source_node);
	17623	init_val = const_ptr_pointee(ira, ira->codegen, var_ptr->value, decl_var_instruction->base.base.source_node);
16616	17624	if (is_comptime_var) {
16617	17625	if (var->gen_is_const) {
16618	17626	var->const_value = init_val;
...	...	@@ -16639,7 +17647,7 @@ static IrInstruction ir_analyze_instruction_decl_var(IrAnalyze ira,
16639	17647	case ReqCompTimeNo:
16640	17648	if (init_val != nullptr && value_is_comptime(init_val)) {
16641	17649	if ((err = ir_resolve_const_val(ira->codegen, ira->new_irb.exec,
16642		decl_var_instruction->base.source_node, init_val, UndefOk)))
	17650	decl_var_instruction->base.base.source_node, init_val, UndefOk)))
16643	17651	{
16644	17652	result_type = ira->codegen->builtin_types.entry_invalid;
16645	17653	} else if (init_val->type->id == ZigTypeIdFn &&
...	...	@@ -16687,13 +17695,13 @@ static IrInstruction ir_analyze_instruction_decl_var(IrAnalyze ira,
16687	17695	assert(var->var_type);
16688	17696
16689	17697	if (type_is_invalid(result_type)) {
16690		return ir_const_void(ira, &decl_var_instruction->base);
	17698	return ir_const_void(ira, &decl_var_instruction->base.base);
16691	17699	}
16692	17700
16693	17701	if (decl_var_instruction->align_value == nullptr) {
16694	17702	if ((err = type_resolve(ira->codegen, result_type, ResolveStatusAlignmentKnown))) {
16695	17703	var->var_type = ira->codegen->builtin_types.entry_invalid;
16696		return ir_const_void(ira, &decl_var_instruction->base);
	17704	return ir_const_void(ira, &decl_var_instruction->base.base);
16697	17705	}
16698	17706	var->align_bytes = get_abi_alignment(ira->codegen, result_type);
16699	17707	} else {
...	...	@@ -16712,17 +17720,17 @@ static IrInstruction ir_analyze_instruction_decl_var(IrAnalyze ira,
16712	17720	// we need a runtime ptr but we have a comptime val.
16713	17721	// since it's a comptime val there are no instructions for it.
16714	17722	// we memcpy the init value here
16715		IrInstruction *deref = ir_get_deref(ira, var_ptr, var_ptr, nullptr);
	17723	IrInstGen *deref = ir_get_deref(ira, &var_ptr->base, var_ptr, nullptr);
16716	17724	if (type_is_invalid(deref->value->type)) {
16717	17725	var->var_type = ira->codegen->builtin_types.entry_invalid;
16718		return ira->codegen->invalid_instruction;
	17726	return ira->codegen->invalid_inst_gen;
16719	17727	}
16720	17728	// If this assertion trips, something is wrong with the IR instructions, because
16721	17729	// we expected the above deref to return a constant value, but it created a runtime
16722	17730	// instruction.
16723	17731	assert(deref->value->special != ConstValSpecialRuntime);
16724	17732	var_ptr->value->special = ConstValSpecialRuntime;
16725		ir_analyze_store_ptr(ira, var_ptr, var_ptr, deref, false);
	17733	ir_analyze_store_ptr(ira, &var_ptr->base, var_ptr, deref, false);
16726	17734	}
16727	17735
16728	17736	if (instr_is_comptime(var_ptr) && var->mem_slot_index != SIZE_MAX) {
...	...	@@ -16732,84 +17740,84 @@ static IrInstruction ir_analyze_instruction_decl_var(IrAnalyze ira,
16732	17740	ira_ref(var->owner_exec->analysis);
16733	17741
16734	17742	if (is_comptime_var \|\| (var_class_requires_const && var->gen_is_const)) {
16735		return ir_const_void(ira, &decl_var_instruction->base);
	17743	return ir_const_void(ira, &decl_var_instruction->base.base);
16736	17744	}
16737	17745	}
16738	17746	} else if (is_comptime_var) {
16739		ir_add_error(ira, &decl_var_instruction->base,
	17747	ir_add_error(ira, &decl_var_instruction->base.base,
16740	17748	buf_sprintf("cannot store runtime value in compile time variable"));
16741	17749	var->var_type = ira->codegen->builtin_types.entry_invalid;
16742		return ira->codegen->invalid_instruction;
	17750	return ira->codegen->invalid_inst_gen;
16743	17751	}
16744	17752
16745		ZigFn *fn_entry = exec_fn_entry(ira->new_irb.exec);
	17753	ZigFn *fn_entry = ira->new_irb.exec->fn_entry;
16746	17754	if (fn_entry)
16747	17755	fn_entry->variable_list.append(var);
16748	17756
16749		return ir_build_var_decl_gen(ira, &decl_var_instruction->base, var, var_ptr);
	17757	return ir_build_var_decl_gen(ira, &decl_var_instruction->base.base, var, var_ptr);
16750	17758	}
16751	17759
16752		static IrInstruction ir_analyze_instruction_export(IrAnalyze ira, IrInstructionExport *instruction) {
16753		IrInstruction *target = instruction->target->child;
	17760	static IrInstGen ir_analyze_instruction_export(IrAnalyze ira, IrInstSrcExport *instruction) {
	17761	IrInstGen *target = instruction->target->child;
16754	17762	if (type_is_invalid(target->value->type))
16755		return ira->codegen->invalid_instruction;
	17763	return ira->codegen->invalid_inst_gen;
16756	17764
16757		IrInstruction *options = instruction->options->child;
	17765	IrInstGen *options = instruction->options->child;
16758	17766	if (type_is_invalid(options->value->type))
16759		return ira->codegen->invalid_instruction;
	17767	return ira->codegen->invalid_inst_gen;
16760	17768
16761	17769	ZigType *options_type = options->value->type;
16762	17770	assert(options_type->id == ZigTypeIdStruct);
16763	17771
16764	17772	TypeStructField *name_field = find_struct_type_field(options_type, buf_create_from_str("name"));
16765		ir_assert(name_field != nullptr, &instruction->base);
16766		IrInstruction *name_inst = ir_analyze_struct_value_field_value(ira, &instruction->base, options, name_field);
	17773	ir_assert(name_field != nullptr, &instruction->base.base);
	17774	IrInstGen *name_inst = ir_analyze_struct_value_field_value(ira, &instruction->base.base, options, name_field);
16767	17775	if (type_is_invalid(name_inst->value->type))
16768		return ira->codegen->invalid_instruction;
	17776	return ira->codegen->invalid_inst_gen;
16769	17777
16770	17778	TypeStructField *linkage_field = find_struct_type_field(options_type, buf_create_from_str("linkage"));
16771		ir_assert(linkage_field != nullptr, &instruction->base);
16772		IrInstruction *linkage_inst = ir_analyze_struct_value_field_value(ira, &instruction->base, options, linkage_field);
	17779	ir_assert(linkage_field != nullptr, &instruction->base.base);
	17780	IrInstGen *linkage_inst = ir_analyze_struct_value_field_value(ira, &instruction->base.base, options, linkage_field);
16773	17781	if (type_is_invalid(linkage_inst->value->type))
16774		return ira->codegen->invalid_instruction;
	17782	return ira->codegen->invalid_inst_gen;
16775	17783
16776	17784	TypeStructField *section_field = find_struct_type_field(options_type, buf_create_from_str("section"));
16777		ir_assert(section_field != nullptr, &instruction->base);
16778		IrInstruction *section_inst = ir_analyze_struct_value_field_value(ira, &instruction->base, options, section_field);
	17785	ir_assert(section_field != nullptr, &instruction->base.base);
	17786	IrInstGen *section_inst = ir_analyze_struct_value_field_value(ira, &instruction->base.base, options, section_field);
16779	17787	if (type_is_invalid(section_inst->value->type))
16780		return ira->codegen->invalid_instruction;
	17788	return ira->codegen->invalid_inst_gen;
16781	17789
16782	17790	// The `section` field is optional, we have to unwrap it first
16783		IrInstruction *non_null_check = ir_analyze_test_non_null(ira, &instruction->base, section_inst);
	17791	IrInstGen *non_null_check = ir_analyze_test_non_null(ira, &instruction->base.base, section_inst);
16784	17792	bool is_non_null;
16785	17793	if (!ir_resolve_bool(ira, non_null_check, &is_non_null))
16786		return ira->codegen->invalid_instruction;
	17794	return ira->codegen->invalid_inst_gen;
16787	17795
16788		IrInstruction *section_str_inst = nullptr;
	17796	IrInstGen *section_str_inst = nullptr;
16789	17797	if (is_non_null) {
16790		section_str_inst = ir_analyze_optional_value_payload_value(ira, &instruction->base, section_inst, false);
	17798	section_str_inst = ir_analyze_optional_value_payload_value(ira, &instruction->base.base, section_inst, false);
16791	17799	if (type_is_invalid(section_str_inst->value->type))
16792		return ira->codegen->invalid_instruction;
	17800	return ira->codegen->invalid_inst_gen;
16793	17801	}
16794	17802
16795	17803	// Resolve all the comptime values
16796	17804	Buf *symbol_name = ir_resolve_str(ira, name_inst);
16797	17805	if (!symbol_name)
16798		return ira->codegen->invalid_instruction;
	17806	return ira->codegen->invalid_inst_gen;
16799	17807
16800	17808	if (buf_len(symbol_name) < 1) {
16801		ir_add_error(ira, name_inst,
	17809	ir_add_error(ira, &name_inst->base,
16802	17810	buf_sprintf("exported symbol name cannot be empty"));
16803		return ira->codegen->invalid_instruction;
	17811	return ira->codegen->invalid_inst_gen;
16804	17812	}
16805	17813
16806	17814	GlobalLinkageId global_linkage_id;
16807	17815	if (!ir_resolve_global_linkage(ira, linkage_inst, &global_linkage_id))
16808		return ira->codegen->invalid_instruction;
	17816	return ira->codegen->invalid_inst_gen;
16809	17817
16810	17818	Buf *section_name = nullptr;
16811	17819	if (section_str_inst != nullptr && !(section_name = ir_resolve_str(ira, section_str_inst)))
16812		return ira->codegen->invalid_instruction;
	17820	return ira->codegen->invalid_inst_gen;
16813	17821
16814	17822	// TODO: This function needs to be audited.
16815	17823	// It's not clear how all the different types are supposed to be handled.
...	...	@@ -16817,15 +17825,15 @@ static IrInstruction ir_analyze_instruction_export(IrAnalyze ira, IrInstructio
16817	17825	// in another file.
16818	17826	TldFn *tld_fn = allocate<TldFn>(1);
16819	17827	tld_fn->base.id = TldIdFn;
16820		tld_fn->base.source_node = instruction->base.source_node;
	17828	tld_fn->base.source_node = instruction->base.base.source_node;
16821	17829
16822	17830	auto entry = ira->codegen->exported_symbol_names.put_unique(symbol_name, &tld_fn->base);
16823	17831	if (entry) {
16824	17832	AstNode *other_export_node = entry->value->source_node;
16825		ErrorMsg *msg = ir_add_error(ira, &instruction->base,
	17833	ErrorMsg *msg = ir_add_error(ira, &instruction->base.base,
16826	17834	buf_sprintf("exported symbol collision: '%s'", buf_ptr(symbol_name)));
16827	17835	add_error_note(ira->codegen, msg, other_export_node, buf_sprintf("other symbol is here"));
16828		return ira->codegen->invalid_instruction;
	17836	return ira->codegen->invalid_inst_gen;
16829	17837	}
16830	17838
16831	17839	Error err;
...	...	@@ -16841,12 +17849,12 @@ static IrInstruction ir_analyze_instruction_export(IrAnalyze ira, IrInstructio
16841	17849	CallingConvention cc = fn_entry->type_entry->data.fn.fn_type_id.cc;
16842	17850	switch (cc) {
16843	17851	case CallingConventionUnspecified: {
16844		ErrorMsg *msg = ir_add_error(ira, target,
	17852	ErrorMsg *msg = ir_add_error(ira, &target->base,
16845	17853	buf_sprintf("exported function must specify calling convention"));
16846	17854	add_error_note(ira->codegen, msg, fn_entry->proto_node, buf_sprintf("declared here"));
16847	17855	} break;
16848	17856	case CallingConventionAsync: {
16849		ErrorMsg *msg = ir_add_error(ira, target,
	17857	ErrorMsg *msg = ir_add_error(ira, &target->base,
16850	17858	buf_sprintf("exported function cannot be async"));
16851	17859	add_error_note(ira->codegen, msg, fn_entry->proto_node, buf_sprintf("declared here"));
16852	17860	} break;
...	...	@@ -16869,10 +17877,10 @@ static IrInstruction ir_analyze_instruction_export(IrAnalyze ira, IrInstructio
16869	17877	} break;
16870	17878	case ZigTypeIdStruct:
16871	17879	if (is_slice(target->value->type)) {
16872		ir_add_error(ira, target,
	17880	ir_add_error(ira, &target->base,
16873	17881	buf_sprintf("unable to export value of type '%s'", buf_ptr(&target->value->type->name)));
16874	17882	} else if (target->value->type->data.structure.layout != ContainerLayoutExtern) {
16875		ErrorMsg *msg = ir_add_error(ira, target,
	17883	ErrorMsg *msg = ir_add_error(ira, &target->base,
16876	17884	buf_sprintf("exported struct value must be declared extern"));
16877	17885	add_error_note(ira->codegen, msg, target->value->type->data.structure.decl_node, buf_sprintf("declared here"));
16878	17886	} else {
...	...	@@ -16881,7 +17889,7 @@ static IrInstruction ir_analyze_instruction_export(IrAnalyze ira, IrInstructio
16881	17889	break;
16882	17890	case ZigTypeIdUnion:
16883	17891	if (target->value->type->data.unionation.layout != ContainerLayoutExtern) {
16884		ErrorMsg *msg = ir_add_error(ira, target,
	17892	ErrorMsg *msg = ir_add_error(ira, &target->base,
16885	17893	buf_sprintf("exported union value must be declared extern"));
16886	17894	add_error_note(ira->codegen, msg, target->value->type->data.unionation.decl_node, buf_sprintf("declared here"));
16887	17895	} else {
...	...	@@ -16890,7 +17898,7 @@ static IrInstruction ir_analyze_instruction_export(IrAnalyze ira, IrInstructio
16890	17898	break;
16891	17899	case ZigTypeIdEnum:
16892	17900	if (target->value->type->data.enumeration.layout != ContainerLayoutExtern) {
16893		ErrorMsg *msg = ir_add_error(ira, target,
	17901	ErrorMsg *msg = ir_add_error(ira, &target->base,
16894	17902	buf_sprintf("exported enum value must be declared extern"));
16895	17903	add_error_note(ira->codegen, msg, target->value->type->data.enumeration.decl_node, buf_sprintf("declared here"));
16896	17904	} else {
...	...	@@ -16900,10 +17908,10 @@ static IrInstruction ir_analyze_instruction_export(IrAnalyze ira, IrInstructio
16900	17908	case ZigTypeIdArray: {
16901	17909	bool ok_type;
16902	17910	if ((err = type_allowed_in_extern(ira->codegen, target->value->type->data.array.child_type, &ok_type)))
16903		return ira->codegen->invalid_instruction;
	17911	return ira->codegen->invalid_inst_gen;
16904	17912
16905	17913	if (!ok_type) {
16906		ir_add_error(ira, target,
	17914	ir_add_error(ira, &target->base,
16907	17915	buf_sprintf("array element type '%s' not extern-compatible",
16908	17916	buf_ptr(&target->value->type->data.array.child_type->name)));
16909	17917	} else {
...	...	@@ -16918,31 +17926,31 @@ static IrInstruction ir_analyze_instruction_export(IrAnalyze ira, IrInstructio
16918	17926	zig_unreachable();
16919	17927	case ZigTypeIdStruct:
16920	17928	if (is_slice(type_value)) {
16921		ir_add_error(ira, target,
	17929	ir_add_error(ira, &target->base,
16922	17930	buf_sprintf("unable to export type '%s'", buf_ptr(&type_value->name)));
16923	17931	} else if (type_value->data.structure.layout != ContainerLayoutExtern) {
16924		ErrorMsg *msg = ir_add_error(ira, target,
	17932	ErrorMsg *msg = ir_add_error(ira, &target->base,
16925	17933	buf_sprintf("exported struct must be declared extern"));
16926	17934	add_error_note(ira->codegen, msg, type_value->data.structure.decl_node, buf_sprintf("declared here"));
16927	17935	}
16928	17936	break;
16929	17937	case ZigTypeIdUnion:
16930	17938	if (type_value->data.unionation.layout != ContainerLayoutExtern) {
16931		ErrorMsg *msg = ir_add_error(ira, target,
	17939	ErrorMsg *msg = ir_add_error(ira, &target->base,
16932	17940	buf_sprintf("exported union must be declared extern"));
16933	17941	add_error_note(ira->codegen, msg, type_value->data.unionation.decl_node, buf_sprintf("declared here"));
16934	17942	}
16935	17943	break;
16936	17944	case ZigTypeIdEnum:
16937	17945	if (type_value->data.enumeration.layout != ContainerLayoutExtern) {
16938		ErrorMsg *msg = ir_add_error(ira, target,
	17946	ErrorMsg *msg = ir_add_error(ira, &target->base,
16939	17947	buf_sprintf("exported enum must be declared extern"));
16940	17948	add_error_note(ira->codegen, msg, type_value->data.enumeration.decl_node, buf_sprintf("declared here"));
16941	17949	}
16942	17950	break;
16943	17951	case ZigTypeIdFn: {
16944	17952	if (type_value->data.fn.fn_type_id.cc == CallingConventionUnspecified) {
16945		ir_add_error(ira, target,
	17953	ir_add_error(ira, &target->base,
16946	17954	buf_sprintf("exported function type must specify calling convention"));
16947	17955	}
16948	17956	} break;
...	...	@@ -16968,7 +17976,7 @@ static IrInstruction ir_analyze_instruction_export(IrAnalyze ira, IrInstructio
16968	17976	case ZigTypeIdOpaque:
16969	17977	case ZigTypeIdFnFrame:
16970	17978	case ZigTypeIdAnyFrame:
16971		ir_add_error(ira, target,
	17979	ir_add_error(ira, &target->base,
16972	17980	buf_sprintf("invalid export target '%s'", buf_ptr(&type_value->name)));
16973	17981	break;
16974	17982	}
...	...	@@ -16993,61 +18001,55 @@ static IrInstruction ir_analyze_instruction_export(IrAnalyze ira, IrInstructio
16993	18001	case ZigTypeIdEnumLiteral:
16994	18002	case ZigTypeIdFnFrame:
16995	18003	case ZigTypeIdAnyFrame:
16996		ir_add_error(ira, target,
	18004	ir_add_error(ira, &target->base,
16997	18005	buf_sprintf("invalid export target type '%s'", buf_ptr(&target->value->type->name)));
16998	18006	break;
16999	18007	}
17000	18008
17001	18009	// TODO audit the various ways to use @export
17002		if (want_var_export && target->id == IrInstructionIdLoadPtrGen) {
17003		IrInstructionLoadPtrGen load_ptr = reinterpret_cast<IrInstructionLoadPtrGen >(target);
17004		if (load_ptr->ptr->id == IrInstructionIdVarPtr) {
17005		IrInstructionVarPtr var_ptr = reinterpret_cast<IrInstructionVarPtr >(load_ptr->ptr);
	18010	if (want_var_export && target->id == IrInstGenIdLoadPtr) {
	18011	IrInstGenLoadPtr load_ptr = reinterpret_cast<IrInstGenLoadPtr >(target);
	18012	if (load_ptr->ptr->id == IrInstGenIdVarPtr) {
	18013	IrInstGenVarPtr var_ptr = reinterpret_cast<IrInstGenVarPtr >(load_ptr->ptr);
17006	18014	ZigVar *var = var_ptr->var;
17007	18015	add_var_export(ira->codegen, var, buf_ptr(symbol_name), global_linkage_id);
17008	18016	var->section_name = section_name;
17009	18017	}
17010	18018	}
17011	18019
17012		return ir_const_void(ira, &instruction->base);
	18020	return ir_const_void(ira, &instruction->base.base);
17013	18021	}
17014	18022
17015		static bool exec_has_err_ret_trace(CodeGen g, IrExecutable exec) {
	18023	static bool exec_has_err_ret_trace(CodeGen g, IrExecutableSrc exec) {
17016	18024	ZigFn *fn_entry = exec_fn_entry(exec);
17017	18025	return fn_entry != nullptr && fn_entry->calls_or_awaits_errorable_fn && g->have_err_ret_tracing;
17018	18026	}
17019	18027
17020		static IrInstruction ir_analyze_instruction_error_return_trace(IrAnalyze ira,
17021		IrInstructionErrorReturnTrace *instruction)
	18028	static IrInstGen ir_analyze_instruction_error_return_trace(IrAnalyze ira,
	18029	IrInstSrcErrorReturnTrace *instruction)
17022	18030	{
17023	18031	ZigType *ptr_to_stack_trace_type = get_pointer_to_type(ira->codegen, get_stack_trace_type(ira->codegen), false);
17024		if (instruction->optional == IrInstructionErrorReturnTrace::Null) {
	18032	if (instruction->optional == IrInstErrorReturnTraceNull) {
17025	18033	ZigType *optional_type = get_optional_type(ira->codegen, ptr_to_stack_trace_type);
17026		if (!exec_has_err_ret_trace(ira->codegen, ira->new_irb.exec)) {
17027		IrInstruction *result = ir_const(ira, &instruction->base, optional_type);
	18034	if (!exec_has_err_ret_trace(ira->codegen, ira->old_irb.exec)) {
	18035	IrInstGen *result = ir_const(ira, &instruction->base.base, optional_type);
17028	18036	ZigValue *out_val = result->value;
17029	18037	assert(get_codegen_ptr_type(optional_type) != nullptr);
17030	18038	out_val->data.x_ptr.special = ConstPtrSpecialHardCodedAddr;
17031	18039	out_val->data.x_ptr.data.hard_coded_addr.addr = 0;
17032	18040	return result;
17033	18041	}
17034		IrInstruction *new_instruction = ir_build_error_return_trace(&ira->new_irb, instruction->base.scope,
17035		instruction->base.source_node, instruction->optional);
17036		new_instruction->value->type = optional_type;
17037		return new_instruction;
	18042	return ir_build_error_return_trace_gen(ira, instruction->base.base.scope,
	18043	instruction->base.base.source_node, instruction->optional, optional_type);
17038	18044	} else {
17039	18045	assert(ira->codegen->have_err_ret_tracing);
17040		IrInstruction *new_instruction = ir_build_error_return_trace(&ira->new_irb, instruction->base.scope,
17041		instruction->base.source_node, instruction->optional);
17042		new_instruction->value->type = ptr_to_stack_trace_type;
17043		return new_instruction;
	18046	return ir_build_error_return_trace_gen(ira, instruction->base.base.scope,
	18047	instruction->base.base.source_node, instruction->optional, ptr_to_stack_trace_type);
17044	18048	}
17045	18049	}
17046	18050
17047		static IrInstruction ir_analyze_instruction_error_union(IrAnalyze ira,
17048		IrInstructionErrorUnion *instruction)
17049		{
17050		IrInstruction *result = ir_const(ira, &instruction->base, ira->codegen->builtin_types.entry_type);
	18051	static IrInstGen ir_analyze_instruction_error_union(IrAnalyze ira, IrInstSrcErrorUnion *instruction) {
	18052	IrInstGen *result = ir_const(ira, &instruction->base.base, ira->codegen->builtin_types.entry_type);
17051	18053	result->value->special = ConstValSpecialLazy;
17052	18054
17053	18055	LazyValueErrUnionType *lazy_err_union_type = allocate<LazyValueErrUnionType>(1, "LazyValueErrUnionType");
...	...	@@ -17057,16 +18059,16 @@ static IrInstruction ir_analyze_instruction_error_union(IrAnalyze ira,
17057	18059
17058	18060	lazy_err_union_type->err_set_type = instruction->err_set->child;
17059	18061	if (ir_resolve_type_lazy(ira, lazy_err_union_type->err_set_type) == nullptr)
17060		return ira->codegen->invalid_instruction;
	18062	return ira->codegen->invalid_inst_gen;
17061	18063
17062	18064	lazy_err_union_type->payload_type = instruction->payload->child;
17063	18065	if (ir_resolve_type_lazy(ira, lazy_err_union_type->payload_type) == nullptr)
17064		return ira->codegen->invalid_instruction;
	18066	return ira->codegen->invalid_inst_gen;
17065	18067
17066	18068	return result;
17067	18069	}
17068	18070
17069		static IrInstruction ir_analyze_alloca(IrAnalyze ira, IrInstruction source_inst, ZigType var_type,
	18071	static IrInstGen ir_analyze_alloca(IrAnalyze ira, IrInst source_inst, ZigType var_type,
17070	18072	uint32_t align, const char *name_hint, bool force_comptime)
17071	18073	{
17072	18074	Error err;
...	...	@@ -17074,7 +18076,7 @@ static IrInstruction ir_analyze_alloca(IrAnalyze ira, IrInstruction *source_in
17074	18076	ZigValue *pointee = create_const_vals(1);
17075	18077	pointee->special = ConstValSpecialUndef;
17076	18078
17077		IrInstructionAllocaGen *result = ir_build_alloca_gen(ira, source_inst, align, name_hint);
	18079	IrInstGenAlloca *result = ir_build_alloca_gen(ira, source_inst, align, name_hint);
17078	18080	result->base.value->special = ConstValSpecialStatic;
17079	18081	result->base.value->data.x_ptr.special = ConstPtrSpecialRef;
17080	18082	result->base.value->data.x_ptr.mut = force_comptime ? ConstPtrMutComptimeVar : ConstPtrMutInfer;
...	...	@@ -17082,15 +18084,15 @@ static IrInstruction ir_analyze_alloca(IrAnalyze ira, IrInstruction *source_in
17082	18084
17083	18085	bool var_type_has_bits;
17084	18086	if ((err = type_has_bits2(ira->codegen, var_type, &var_type_has_bits)))
17085		return ira->codegen->invalid_instruction;
	18087	return ira->codegen->invalid_inst_gen;
17086	18088	if (align != 0) {
17087	18089	if ((err = type_resolve(ira->codegen, var_type, ResolveStatusAlignmentKnown)))
17088		return ira->codegen->invalid_instruction;
	18090	return ira->codegen->invalid_inst_gen;
17089	18091	if (!var_type_has_bits) {
17090	18092	ir_add_error(ira, source_inst,
17091	18093	buf_sprintf("variable '%s' of zero-bit type '%s' has no in-memory representation, it cannot be aligned",
17092	18094	name_hint, buf_ptr(&var_type->name)));
17093		return ira->codegen->invalid_instruction;
	18095	return ira->codegen->invalid_inst_gen;
17094	18096	}
17095	18097	}
17096	18098	assert(result->base.value->data.x_ptr.special != ConstPtrSpecialInvalid);
...	...	@@ -17099,15 +18101,14 @@ static IrInstruction ir_analyze_alloca(IrAnalyze ira, IrInstruction *source_in
17099	18101	result->base.value->type = get_pointer_to_type_extra(ira->codegen, var_type, false, false,
17100	18102	PtrLenSingle, align, 0, 0, false);
17101	18103
17102		ZigFn *fn_entry = exec_fn_entry(ira->new_irb.exec);
	18104	ZigFn *fn_entry = ira->new_irb.exec->fn_entry;
17103	18105	if (fn_entry != nullptr) {
17104	18106	fn_entry->alloca_gen_list.append(result);
17105	18107	}
17106		result->base.is_gen = true;
17107	18108	return &result->base;
17108	18109	}
17109	18110
17110		static ZigType ir_result_loc_expected_type(IrAnalyze ira, IrInstruction *suspend_source_instr,
	18111	static ZigType ir_result_loc_expected_type(IrAnalyze ira, IrInst *suspend_source_instr,
17111	18112	ResultLoc *result_loc)
17112	18113	{
17113	18114	switch (result_loc->id) {
...	...	@@ -17150,7 +18151,7 @@ static bool type_can_bit_cast(ZigType *t) {
17150	18151	}
17151	18152	}
17152	18153
17153		static void set_up_result_loc_for_inferred_comptime(IrInstruction *ptr) {
	18154	static void set_up_result_loc_for_inferred_comptime(IrInstGen *ptr) {
17154	18155	ZigValue *undef_child = create_const_vals(1);
17155	18156	undef_child->type = ptr->value->type->data.pointer.child_type;
17156	18157	undef_child->special = ConstValSpecialUndef;
...	...	@@ -17189,16 +18190,16 @@ static Error ir_result_has_type(IrAnalyze ira, ResultLoc result_loc, bool *out
17189	18190	zig_unreachable();
17190	18191	}
17191	18192
17192		static IrInstruction ir_resolve_no_result_loc(IrAnalyze ira, IrInstruction *suspend_source_instr,
	18193	static IrInstGen ir_resolve_no_result_loc(IrAnalyze ira, IrInst *suspend_source_instr,
17193	18194	ResultLoc result_loc, ZigType value_type, bool force_runtime, bool non_null_comptime)
17194	18195	{
17195	18196	if (type_is_invalid(value_type))
17196		return ira->codegen->invalid_instruction;
17197		IrInstructionAllocaGen *alloca_gen = ir_build_alloca_gen(ira, suspend_source_instr, 0, "");
	18197	return ira->codegen->invalid_inst_gen;
	18198	IrInstGenAlloca *alloca_gen = ir_build_alloca_gen(ira, suspend_source_instr, 0, "");
17198	18199	alloca_gen->base.value->type = get_pointer_to_type_extra(ira->codegen, value_type, false, false,
17199	18200	PtrLenSingle, 0, 0, 0, false);
17200	18201	set_up_result_loc_for_inferred_comptime(&alloca_gen->base);
17201		ZigFn *fn_entry = exec_fn_entry(ira->new_irb.exec);
	18202	ZigFn *fn_entry = ira->new_irb.exec->fn_entry;
17202	18203	if (fn_entry != nullptr && get_scope_typeof(suspend_source_instr->scope) == nullptr) {
17203	18204	fn_entry->alloca_gen_list.append(alloca_gen);
17204	18205	}
...	...	@@ -17208,8 +18209,8 @@ static IrInstruction ir_resolve_no_result_loc(IrAnalyze ira, IrInstruction *su
17208	18209	}
17209	18210
17210	18211	// when calling this function, at the callsite must check for result type noreturn and propagate it up
17211		static IrInstruction ir_resolve_result_raw(IrAnalyze ira, IrInstruction *suspend_source_instr,
17212		ResultLoc result_loc, ZigType value_type, IrInstruction *value, bool force_runtime,
	18212	static IrInstGen ir_resolve_result_raw(IrAnalyze ira, IrInst *suspend_source_instr,
	18213	ResultLoc result_loc, ZigType value_type, IrInstGen *value, bool force_runtime,
17213	18214	bool non_null_comptime, bool allow_discard)
17214	18215	{
17215	18216	Error err;
...	...	@@ -17235,35 +18236,34 @@ static IrInstruction ir_resolve_result_raw(IrAnalyze ira, IrInstruction *suspe
17235	18236	}
17236	18237	case ResultLocIdVar: {
17237	18238	ResultLocVar result_loc_var = reinterpret_cast<ResultLocVar >(result_loc);
17238		assert(result_loc->source_instruction->id == IrInstructionIdAllocaSrc);
	18239	assert(result_loc->source_instruction->id == IrInstSrcIdAlloca);
17239	18240
17240	18241	if (value_type->id == ZigTypeIdUnreachable \|\| value_type->id == ZigTypeIdOpaque) {
17241		ir_add_error(ira, result_loc->source_instruction,
	18242	ir_add_error(ira, &result_loc->source_instruction->base,
17242	18243	buf_sprintf("variable of type '%s' not allowed", buf_ptr(&value_type->name)));
17243		return ira->codegen->invalid_instruction;
	18244	return ira->codegen->invalid_inst_gen;
17244	18245	}
17245	18246
17246		IrInstructionAllocaSrc *alloca_src =
17247		reinterpret_cast<IrInstructionAllocaSrc *>(result_loc->source_instruction);
	18247	IrInstSrcAlloca alloca_src = reinterpret_cast<IrInstSrcAlloca >(result_loc->source_instruction);
17248	18248	bool force_comptime;
17249	18249	if (!ir_resolve_comptime(ira, alloca_src->is_comptime->child, &force_comptime))
17250		return ira->codegen->invalid_instruction;
	18250	return ira->codegen->invalid_inst_gen;
17251	18251	bool is_comptime = force_comptime \|\| (!force_runtime && value != nullptr &&
17252	18252	value->value->special != ConstValSpecialRuntime && result_loc_var->var->gen_is_const);
17253	18253
17254	18254	if (alloca_src->base.child == nullptr \|\| is_comptime) {
17255	18255	uint32_t align = 0;
17256	18256	if (alloca_src->align != nullptr && !ir_resolve_align(ira, alloca_src->align->child, nullptr, &align)) {
17257		return ira->codegen->invalid_instruction;
	18257	return ira->codegen->invalid_inst_gen;
17258	18258	}
17259		IrInstruction *alloca_gen;
	18259	IrInstGen *alloca_gen;
17260	18260	if (is_comptime && value != nullptr) {
17261	18261	if (align > value->value->llvm_align) {
17262	18262	value->value->llvm_align = align;
17263	18263	}
17264		alloca_gen = ir_get_ref(ira, result_loc->source_instruction, value, true, false);
	18264	alloca_gen = ir_get_ref(ira, &result_loc->source_instruction->base, value, true, false);
17265	18265	} else {
17266		alloca_gen = ir_analyze_alloca(ira, result_loc->source_instruction, value_type, align,
	18266	alloca_gen = ir_analyze_alloca(ira, &result_loc->source_instruction->base, value_type, align,
17267	18267	alloca_src->name_hint, force_comptime);
17268	18268	if (force_runtime) {
17269	18269	alloca_gen->value->data.x_ptr.mut = ConstPtrMutRuntimeVar;
...	...	@@ -17271,7 +18271,7 @@ static IrInstruction ir_resolve_result_raw(IrAnalyze ira, IrInstruction *suspe
17271	18271	}
17272	18272	}
17273	18273	if (alloca_src->base.child != nullptr && !result_loc->written) {
17274		alloca_src->base.child->ref_count = 0;
	18274	alloca_src->base.child->base.ref_count = 0;
17275	18275	}
17276	18276	alloca_src->base.child = alloca_gen;
17277	18277	}
...	...	@@ -17296,9 +18296,9 @@ static IrInstruction ir_resolve_result_raw(IrAnalyze ira, IrInstruction *suspe
17296	18296	}
17297	18297	bool has_bits;
17298	18298	if ((err = type_has_bits2(ira->codegen, ira->explicit_return_type, &has_bits)))
17299		return ira->codegen->invalid_instruction;
	18299	return ira->codegen->invalid_inst_gen;
17300	18300	if (!has_bits \|\| !handle_is_ptr(ira->explicit_return_type)) {
17301		ZigFn *fn_entry = exec_fn_entry(ira->new_irb.exec);
	18301	ZigFn *fn_entry = ira->new_irb.exec->fn_entry;
17302	18302	if (fn_entry == nullptr \|\| fn_entry->inferred_async_node == nullptr) {
17303	18303	return nullptr;
17304	18304	}
...	...	@@ -17306,8 +18306,8 @@ static IrInstruction ir_resolve_result_raw(IrAnalyze ira, IrInstruction *suspe
17306	18306
17307	18307	ZigType *ptr_return_type = get_pointer_to_type(ira->codegen, ira->explicit_return_type, false);
17308	18308	result_loc->written = true;
17309		result_loc->resolved_loc = ir_build_return_ptr(ira, result_loc->source_instruction, ptr_return_type);
17310		if (ir_should_inline(ira->old_irb.exec, result_loc->source_instruction->scope)) {
	18309	result_loc->resolved_loc = ir_build_return_ptr(ira, &result_loc->source_instruction->base, ptr_return_type);
	18310	if (ir_should_inline(ira->old_irb.exec, result_loc->source_instruction->base.scope)) {
17311	18311	set_up_result_loc_for_inferred_comptime(result_loc->resolved_loc);
17312	18312	}
17313	18313	return result_loc->resolved_loc;
...	...	@@ -17317,7 +18317,7 @@ static IrInstruction ir_resolve_result_raw(IrAnalyze ira, IrInstruction *suspe
17317	18317	ResultLocPeerParent *peer_parent = result_peer->parent;
17318	18318
17319	18319	if (peer_parent->peers.length == 1) {
17320		IrInstruction *parent_result_loc = ir_resolve_result(ira, suspend_source_instr, peer_parent->parent,
	18320	IrInstGen *parent_result_loc = ir_resolve_result(ira, suspend_source_instr, peer_parent->parent,
17321	18321	value_type, value, force_runtime, non_null_comptime, true);
17322	18322	result_peer->suspend_pos.basic_block_index = SIZE_MAX;
17323	18323	result_peer->suspend_pos.instruction_index = SIZE_MAX;
...	...	@@ -17333,7 +18333,7 @@ static IrInstruction ir_resolve_result_raw(IrAnalyze ira, IrInstruction *suspe
17333	18333
17334	18334	bool is_condition_comptime;
17335	18335	if (!ir_resolve_comptime(ira, peer_parent->is_comptime->child, &is_condition_comptime))
17336		return ira->codegen->invalid_instruction;
	18336	return ira->codegen->invalid_inst_gen;
17337	18337	if (is_condition_comptime) {
17338	18338	peer_parent->skipped = true;
17339	18339	if (non_null_comptime) {
...	...	@@ -17344,10 +18344,10 @@ static IrInstruction ir_resolve_result_raw(IrAnalyze ira, IrInstruction *suspe
17344	18344	}
17345	18345	bool peer_parent_has_type;
17346	18346	if ((err = ir_result_has_type(ira, peer_parent->parent, &peer_parent_has_type)))
17347		return ira->codegen->invalid_instruction;
	18347	return ira->codegen->invalid_inst_gen;
17348	18348	if (peer_parent_has_type) {
17349	18349	peer_parent->skipped = true;
17350		IrInstruction *parent_result_loc = ir_resolve_result(ira, suspend_source_instr, peer_parent->parent,
	18350	IrInstGen *parent_result_loc = ir_resolve_result(ira, suspend_source_instr, peer_parent->parent,
17351	18351	value_type, value, force_runtime \|\| !is_condition_comptime, true, true);
17352	18352	if (parent_result_loc == nullptr \|\| type_is_invalid(parent_result_loc->value->type) \|\|
17353	18353	parent_result_loc->value->type->id == ZigTypeIdUnreachable)
...	...	@@ -17364,7 +18364,7 @@ static IrInstruction ir_resolve_result_raw(IrAnalyze ira, IrInstruction *suspe
17364	18364	if (peer_parent->end_bb->suspend_instruction_ref == nullptr) {
17365	18365	peer_parent->end_bb->suspend_instruction_ref = suspend_source_instr;
17366	18366	}
17367		IrInstruction *unreach_inst = ira_suspend(ira, suspend_source_instr, result_peer->next_bb,
	18367	IrInstGen *unreach_inst = ira_suspend(ira, suspend_source_instr, result_peer->next_bb,
17368	18368	&result_peer->suspend_pos);
17369	18369	if (result_peer->next_bb == nullptr) {
17370	18370	ir_start_next_bb(ira);
...	...	@@ -17372,7 +18372,7 @@ static IrInstruction ir_resolve_result_raw(IrAnalyze ira, IrInstruction *suspe
17372	18372	return unreach_inst;
17373	18373	}
17374	18374
17375		IrInstruction *parent_result_loc = ir_resolve_result(ira, suspend_source_instr, peer_parent->parent,
	18375	IrInstGen *parent_result_loc = ir_resolve_result(ira, suspend_source_instr, peer_parent->parent,
17376	18376	peer_parent->resolved_type, nullptr, force_runtime, non_null_comptime, true);
17377	18377	if (parent_result_loc == nullptr \|\| type_is_invalid(parent_result_loc->value->type) \|\|
17378	18378	parent_result_loc->value->type->id == ZigTypeIdUnreachable)
...	...	@@ -17391,24 +18391,24 @@ static IrInstruction ir_resolve_result_raw(IrAnalyze ira, IrInstruction *suspe
17391	18391	ResultLocCast result_cast = reinterpret_cast<ResultLocCast >(result_loc);
17392	18392	ZigType *dest_type = ir_resolve_type(ira, result_cast->base.source_instruction->child);
17393	18393	if (type_is_invalid(dest_type))
17394		return ira->codegen->invalid_instruction;
	18394	return ira->codegen->invalid_inst_gen;
17395	18395
17396	18396	if (dest_type == ira->codegen->builtin_types.entry_var) {
17397	18397	return ir_resolve_no_result_loc(ira, suspend_source_instr, result_loc, value_type,
17398	18398	force_runtime, non_null_comptime);
17399	18399	}
17400	18400
17401		IrInstruction *casted_value;
	18401	IrInstGen *casted_value;
17402	18402	if (value != nullptr) {
17403	18403	casted_value = ir_implicit_cast(ira, value, dest_type);
17404	18404	if (type_is_invalid(casted_value->value->type))
17405		return ira->codegen->invalid_instruction;
	18405	return ira->codegen->invalid_inst_gen;
17406	18406	dest_type = casted_value->value->type;
17407	18407	} else {
17408	18408	casted_value = nullptr;
17409	18409	}
17410	18410
17411		IrInstruction *parent_result_loc = ir_resolve_result(ira, suspend_source_instr, result_cast->parent,
	18411	IrInstGen *parent_result_loc = ir_resolve_result(ira, suspend_source_instr, result_cast->parent,
17412	18412	dest_type, casted_value, force_runtime, non_null_comptime, true);
17413	18413	if (parent_result_loc == nullptr \|\| type_is_invalid(parent_result_loc->value->type) \|\|
17414	18414	parent_result_loc->value->type->id == ZigTypeIdUnreachable)
...	...	@@ -17422,11 +18422,11 @@ static IrInstruction ir_resolve_result_raw(IrAnalyze ira, IrInstruction *suspe
17422	18422	if ((err = type_resolve(ira->codegen, parent_ptr_type->data.pointer.child_type,
17423	18423	ResolveStatusAlignmentKnown)))
17424	18424	{
17425		return ira->codegen->invalid_instruction;
	18425	return ira->codegen->invalid_inst_gen;
17426	18426	}
17427	18427	uint64_t parent_ptr_align = get_ptr_align(ira->codegen, parent_ptr_type);
17428	18428	if ((err = type_resolve(ira->codegen, value_type, ResolveStatusAlignmentKnown))) {
17429		return ira->codegen->invalid_instruction;
	18429	return ira->codegen->invalid_inst_gen;
17430	18430	}
17431	18431	if (!type_has_bits(value_type)) {
17432	18432	parent_ptr_align = 0;
...	...	@@ -17449,9 +18449,9 @@ static IrInstruction ir_resolve_result_raw(IrAnalyze ira, IrInstruction *suspe
17449	18449
17450	18450	ConstCastOnly const_cast_result = types_match_const_cast_only(ira,
17451	18451	parent_result_loc->value->type, ptr_type,
17452		result_cast->base.source_instruction->source_node, false);
	18452	result_cast->base.source_instruction->base.source_node, false);
17453	18453	if (const_cast_result.id == ConstCastResultIdInvalid)
17454		return ira->codegen->invalid_instruction;
	18454	return ira->codegen->invalid_inst_gen;
17455	18455	if (const_cast_result.id != ConstCastResultIdOk) {
17456	18456	if (allow_discard) {
17457	18457	return parent_result_loc;
...	...	@@ -17465,42 +18465,42 @@ static IrInstruction ir_resolve_result_raw(IrAnalyze ira, IrInstruction *suspe
17465	18465
17466	18466	result_loc->written = true;
17467	18467	result_loc->resolved_loc = ir_analyze_ptr_cast(ira, suspend_source_instr, parent_result_loc,
17468		ptr_type, result_cast->base.source_instruction, false);
	18468	ptr_type, &result_cast->base.source_instruction->base, false);
17469	18469	return result_loc->resolved_loc;
17470	18470	}
17471	18471	case ResultLocIdBitCast: {
17472	18472	ResultLocBitCast result_bit_cast = reinterpret_cast<ResultLocBitCast >(result_loc);
17473	18473	ZigType *dest_type = ir_resolve_type(ira, result_bit_cast->base.source_instruction->child);
17474	18474	if (type_is_invalid(dest_type))
17475		return ira->codegen->invalid_instruction;
	18475	return ira->codegen->invalid_inst_gen;
17476	18476
17477	18477	if (get_codegen_ptr_type(dest_type) != nullptr) {
17478		ir_add_error(ira, result_loc->source_instruction,
	18478	ir_add_error(ira, &result_loc->source_instruction->base,
17479	18479	buf_sprintf("unable to @bitCast to pointer type '%s'", buf_ptr(&dest_type->name)));
17480		return ira->codegen->invalid_instruction;
	18480	return ira->codegen->invalid_inst_gen;
17481	18481	}
17482	18482
17483	18483	if (!type_can_bit_cast(dest_type)) {
17484		ir_add_error(ira, result_loc->source_instruction,
	18484	ir_add_error(ira, &result_loc->source_instruction->base,
17485	18485	buf_sprintf("unable to @bitCast to type '%s'", buf_ptr(&dest_type->name)));
17486		return ira->codegen->invalid_instruction;
	18486	return ira->codegen->invalid_inst_gen;
17487	18487	}
17488	18488
17489	18489	if (get_codegen_ptr_type(value_type) != nullptr) {
17490	18490	ir_add_error(ira, suspend_source_instr,
17491	18491	buf_sprintf("unable to @bitCast from pointer type '%s'", buf_ptr(&value_type->name)));
17492		return ira->codegen->invalid_instruction;
	18492	return ira->codegen->invalid_inst_gen;
17493	18493	}
17494	18494
17495	18495	if (!type_can_bit_cast(value_type)) {
17496	18496	ir_add_error(ira, suspend_source_instr,
17497	18497	buf_sprintf("unable to @bitCast from type '%s'", buf_ptr(&value_type->name)));
17498		return ira->codegen->invalid_instruction;
	18498	return ira->codegen->invalid_inst_gen;
17499	18499	}
17500	18500
17501		IrInstruction *bitcasted_value;
	18501	IrInstGen *bitcasted_value;
17502	18502	if (value != nullptr) {
17503		bitcasted_value = ir_analyze_bit_cast(ira, result_loc->source_instruction, value, dest_type);
	18503	bitcasted_value = ir_analyze_bit_cast(ira, &result_loc->source_instruction->base, value, dest_type);
17504	18504	dest_type = bitcasted_value->value->type;
17505	18505	} else {
17506	18506	bitcasted_value = nullptr;
...	...	@@ -17510,7 +18510,7 @@ static IrInstruction ir_resolve_result_raw(IrAnalyze ira, IrInstruction *suspe
17510	18510	return bitcasted_value;
17511	18511	}
17512	18512
17513		IrInstruction *parent_result_loc = ir_resolve_result(ira, suspend_source_instr, result_bit_cast->parent,
	18513	IrInstGen *parent_result_loc = ir_resolve_result(ira, suspend_source_instr, result_bit_cast->parent,
17514	18514	dest_type, bitcasted_value, force_runtime, non_null_comptime, true);
17515	18515	if (parent_result_loc == nullptr \|\| type_is_invalid(parent_result_loc->value->type) \|\|
17516	18516	parent_result_loc->value->type->id == ZigTypeIdUnreachable)
...	...	@@ -17523,7 +18523,7 @@ static IrInstruction ir_resolve_result_raw(IrAnalyze ira, IrInstruction *suspe
17523	18523
17524	18524	bool has_bits;
17525	18525	if ((err = type_has_bits2(ira->codegen, child_type, &has_bits))) {
17526		return ira->codegen->invalid_instruction;
	18526	return ira->codegen->invalid_inst_gen;
17527	18527	}
17528	18528
17529	18529	// This happens when the bitCast result is assigned to _
...	...	@@ -17533,12 +18533,12 @@ static IrInstruction ir_resolve_result_raw(IrAnalyze ira, IrInstruction *suspe
17533	18533	}
17534	18534
17535	18535	if ((err = type_resolve(ira->codegen, child_type, ResolveStatusAlignmentKnown))) {
17536		return ira->codegen->invalid_instruction;
	18536	return ira->codegen->invalid_inst_gen;
17537	18537	}
17538	18538
17539	18539	uint64_t parent_ptr_align = get_ptr_align(ira->codegen, parent_ptr_type);
17540	18540	if ((err = type_resolve(ira->codegen, value_type, ResolveStatusAlignmentKnown))) {
17541		return ira->codegen->invalid_instruction;
	18541	return ira->codegen->invalid_inst_gen;
17542	18542	}
17543	18543	ZigType *ptr_type = get_pointer_to_type_extra(ira->codegen, value_type,
17544	18544	parent_ptr_type->data.pointer.is_const, parent_ptr_type->data.pointer.is_volatile, PtrLenSingle,
...	...	@@ -17546,29 +18546,33 @@ static IrInstruction ir_resolve_result_raw(IrAnalyze ira, IrInstruction *suspe
17546	18546
17547	18547	result_loc->written = true;
17548	18548	result_loc->resolved_loc = ir_analyze_ptr_cast(ira, suspend_source_instr, parent_result_loc,
17549		ptr_type, result_bit_cast->base.source_instruction, false);
	18549	ptr_type, &result_bit_cast->base.source_instruction->base, false);
17550	18550	return result_loc->resolved_loc;
17551	18551	}
17552	18552	}
17553	18553	zig_unreachable();
17554	18554	}
17555	18555
17556		static IrInstruction ir_resolve_result(IrAnalyze ira, IrInstruction *suspend_source_instr,
17557		ResultLoc result_loc_pass1, ZigType value_type, IrInstruction *value, bool force_runtime,
	18556	static IrInstGen ir_resolve_result(IrAnalyze ira, IrInst *suspend_source_instr,
	18557	ResultLoc result_loc_pass1, ZigType value_type, IrInstGen *value, bool force_runtime,
17558	18558	bool non_null_comptime, bool allow_discard)
17559	18559	{
17560	18560	Error err;
17561	18561	if (!allow_discard && result_loc_pass1->id == ResultLocIdInstruction &&
17562		instr_is_comptime(result_loc_pass1->source_instruction) &&
17563		result_loc_pass1->source_instruction->value->type->id == ZigTypeIdPointer &&
17564		result_loc_pass1->source_instruction->value->data.x_ptr.special == ConstPtrSpecialDiscard)
	18562	result_loc_pass1->source_instruction->id == IrInstSrcIdConst)
17565	18563	{
17566		result_loc_pass1 = no_result_loc();
	18564	IrInstSrcConst const_inst = reinterpret_cast<IrInstSrcConst >(result_loc_pass1->source_instruction);
	18565	if (value_is_comptime(const_inst->value) &&
	18566	const_inst->value->type->id == ZigTypeIdPointer &&
	18567	const_inst->value->data.x_ptr.special == ConstPtrSpecialDiscard)
	18568	{
	18569	result_loc_pass1 = no_result_loc();
	18570	}
17567	18571	}
17568	18572	bool was_already_resolved = result_loc_pass1->resolved_loc != nullptr;
17569		IrInstruction *result_loc = ir_resolve_result_raw(ira, suspend_source_instr, result_loc_pass1, value_type,
	18573	IrInstGen *result_loc = ir_resolve_result_raw(ira, suspend_source_instr, result_loc_pass1, value_type,
17570	18574	value, force_runtime, non_null_comptime, allow_discard);
17571		if (result_loc == nullptr \|\| (instr_is_unreachable(result_loc) \|\| type_is_invalid(result_loc->value->type)))
	18575	if (result_loc == nullptr \|\| (result_loc->value->type->id == ZigTypeIdUnreachable \|\| type_is_invalid(result_loc->value->type)))
17572	18576	return result_loc;
17573	18577
17574	18578	if ((force_runtime \|\| (value != nullptr && !instr_is_comptime(value))) &&
...	...	@@ -17591,11 +18595,11 @@ static IrInstruction ir_resolve_result(IrAnalyze ira, IrInstruction *suspend_s
17591	18595	field->type_entry = value_type;
17592	18596	field->type_val = create_const_type(ira->codegen, field->type_entry);
17593	18597	field->src_index = old_field_count;
17594		field->decl_node = value ? value->source_node : suspend_source_instr->source_node;
	18598	field->decl_node = value ? value->base.source_node : suspend_source_instr->source_node;
17595	18599	if (value && instr_is_comptime(value)) {
17596	18600	ZigValue *val = ir_resolve_const(ira, value, UndefOk);
17597	18601	if (!val)
17598		return ira->codegen->invalid_instruction;
	18602	return ira->codegen->invalid_inst_gen;
17599	18603	field->is_comptime = true;
17600	18604	field->init_val = create_const_vals(1);
17601	18605	copy_const_val(field->init_val, val);
...	...	@@ -17603,7 +18607,7 @@ static IrInstruction ir_resolve_result(IrAnalyze ira, IrInstruction *suspend_s
17603	18607	}
17604	18608
17605	18609	ZigType *struct_ptr_type = get_pointer_to_type(ira->codegen, isf->inferred_struct_type, false);
17606		IrInstruction *casted_ptr;
	18610	IrInstGen *casted_ptr;
17607	18611	if (instr_is_comptime(result_loc)) {
17608	18612	casted_ptr = ir_const(ira, suspend_source_instr, struct_ptr_type);
17609	18613	copy_const_val(casted_ptr->value, result_loc->value);
...	...	@@ -17614,7 +18618,7 @@ static IrInstruction ir_resolve_result(IrAnalyze ira, IrInstruction *suspend_s
17614	18618	if (instr_is_comptime(casted_ptr)) {
17615	18619	ZigValue *ptr_val = ir_resolve_const(ira, casted_ptr, UndefBad);
17616	18620	if (!ptr_val)
17617		return ira->codegen->invalid_instruction;
	18621	return ira->codegen->invalid_inst_gen;
17618	18622	if (ptr_val->data.x_ptr.special != ConstPtrSpecialHardCodedAddr) {
17619	18623	ZigValue *struct_val = const_ptr_pointee(ira, ira->codegen, ptr_val,
17620	18624	suspend_source_instr->source_node);
...	...	@@ -17644,7 +18648,7 @@ static IrInstruction ir_resolve_result(IrAnalyze ira, IrInstruction *suspend_s
17644	18648	{
17645	18649	bool has_bits;
17646	18650	if ((err = type_has_bits2(ira->codegen, value_type, &has_bits)))
17647		return ira->codegen->invalid_instruction;
	18651	return ira->codegen->invalid_inst_gen;
17648	18652	if (has_bits) {
17649	18653	result_loc_pass1->written = false;
17650	18654	return ir_analyze_unwrap_optional_payload(ira, suspend_source_instr, result_loc, false, true);
...	...	@@ -17652,12 +18656,12 @@ static IrInstruction ir_resolve_result(IrAnalyze ira, IrInstruction *suspend_s
17652	18656	} else if (actual_elem_type->id == ZigTypeIdErrorUnion && value_type->id != ZigTypeIdErrorUnion) {
17653	18657	bool has_bits;
17654	18658	if ((err = type_has_bits2(ira->codegen, value_type, &has_bits)))
17655		return ira->codegen->invalid_instruction;
	18659	return ira->codegen->invalid_inst_gen;
17656	18660	if (has_bits) {
17657	18661	if (value_type->id == ZigTypeIdErrorSet) {
17658	18662	return ir_analyze_unwrap_err_code(ira, suspend_source_instr, result_loc, true);
17659	18663	} else {
17660		IrInstruction *unwrapped_err_ptr = ir_analyze_unwrap_error_payload(ira, suspend_source_instr,
	18664	IrInstGen *unwrapped_err_ptr = ir_analyze_unwrap_error_payload(ira, suspend_source_instr,
17661	18665	result_loc, false, true);
17662	18666	ZigType *actual_payload_type = actual_elem_type->data.error_union.payload_type;
17663	18667	if (actual_payload_type->id == ZigTypeIdOptional && value_type->id != ZigTypeIdOptional &&
...	...	@@ -17672,37 +18676,35 @@ static IrInstruction ir_resolve_result(IrAnalyze ira, IrInstruction *suspend_s
17672	18676	return result_loc;
17673	18677	}
17674	18678
17675		static IrInstruction ir_analyze_instruction_resolve_result(IrAnalyze ira,
17676		IrInstructionResolveResult *instruction)
17677		{
	18679	static IrInstGen ir_analyze_instruction_resolve_result(IrAnalyze ira, IrInstSrcResolveResult *instruction) {
17678	18680	ZigType *implicit_elem_type;
17679	18681	if (instruction->ty == nullptr) {
17680	18682	if (instruction->result_loc->id == ResultLocIdCast) {
17681	18683	implicit_elem_type = ir_resolve_type(ira,
17682	18684	instruction->result_loc->source_instruction->child);
17683	18685	if (type_is_invalid(implicit_elem_type))
17684		return ira->codegen->invalid_instruction;
	18686	return ira->codegen->invalid_inst_gen;
17685	18687	} else if (instruction->result_loc->id == ResultLocIdReturn) {
17686	18688	implicit_elem_type = ira->explicit_return_type;
17687	18689	if (type_is_invalid(implicit_elem_type))
17688		return ira->codegen->invalid_instruction;
	18690	return ira->codegen->invalid_inst_gen;
17689	18691	} else {
17690	18692	implicit_elem_type = ira->codegen->builtin_types.entry_var;
17691	18693	}
17692	18694	if (implicit_elem_type == ira->codegen->builtin_types.entry_var) {
17693	18695	Buf *bare_name = buf_alloc();
17694	18696	Buf *name = get_anon_type_name(ira->codegen, nullptr, container_string(ContainerKindStruct),
17695		instruction->base.scope, instruction->base.source_node, bare_name);
	18697	instruction->base.base.scope, instruction->base.base.source_node, bare_name);
17696	18698
17697	18699	StructSpecial struct_special = StructSpecialInferredStruct;
17698		if (instruction->base.source_node->type == NodeTypeContainerInitExpr &&
17699		instruction->base.source_node->data.container_init_expr.kind == ContainerInitKindArray)
	18700	if (instruction->base.base.source_node->type == NodeTypeContainerInitExpr &&
	18701	instruction->base.base.source_node->data.container_init_expr.kind == ContainerInitKindArray)
17700	18702	{
17701	18703	struct_special = StructSpecialInferredTuple;
17702	18704	}
17703	18705
17704	18706	ZigType *inferred_struct_type = get_partial_container_type(ira->codegen,
17705		instruction->base.scope, ContainerKindStruct, instruction->base.source_node,
	18707	instruction->base.base.scope, ContainerKindStruct, instruction->base.base.source_node,
17706	18708	buf_ptr(name), bare_name, ContainerLayoutAuto);
17707	18709	inferred_struct_type->data.structure.special = struct_special;
17708	18710	inferred_struct_type->data.structure.resolve_status = ResolveStatusBeingInferred;
...	...	@@ -17711,21 +18713,21 @@ static IrInstruction ir_analyze_instruction_resolve_result(IrAnalyze ira,
17711	18713	} else {
17712	18714	implicit_elem_type = ir_resolve_type(ira, instruction->ty->child);
17713	18715	if (type_is_invalid(implicit_elem_type))
17714		return ira->codegen->invalid_instruction;
	18716	return ira->codegen->invalid_inst_gen;
17715	18717	}
17716		IrInstruction *result_loc = ir_resolve_result(ira, &instruction->base, instruction->result_loc,
	18718	IrInstGen *result_loc = ir_resolve_result(ira, &instruction->base.base, instruction->result_loc,
17717	18719	implicit_elem_type, nullptr, false, true, true);
17718	18720	if (result_loc != nullptr)
17719	18721	return result_loc;
17720	18722
17721		ZigFn *fn = exec_fn_entry(ira->new_irb.exec);
	18723	ZigFn *fn = ira->new_irb.exec->fn_entry;
17722	18724	if (fn != nullptr && fn->type_entry->data.fn.fn_type_id.cc == CallingConventionAsync &&
17723	18725	instruction->result_loc->id == ResultLocIdReturn)
17724	18726	{
17725		result_loc = ir_resolve_result(ira, &instruction->base, no_result_loc(),
	18727	result_loc = ir_resolve_result(ira, &instruction->base.base, no_result_loc(),
17726	18728	implicit_elem_type, nullptr, false, true, true);
17727	18729	if (result_loc != nullptr &&
17728		(type_is_invalid(result_loc->value->type) \|\| instr_is_unreachable(result_loc)))
	18730	(type_is_invalid(result_loc->value->type) \|\| result_loc->value->type->id == ZigTypeIdUnreachable))
17729	18731	{
17730	18732	return result_loc;
17731	18733	}
...	...	@@ -17733,9 +18735,9 @@ static IrInstruction ir_analyze_instruction_resolve_result(IrAnalyze ira,
17733	18735	return result_loc;
17734	18736	}
17735	18737
17736		IrInstruction *result = ir_const(ira, &instruction->base, implicit_elem_type);
	18738	IrInstGen *result = ir_const(ira, &instruction->base.base, implicit_elem_type);
17737	18739	result->value->special = ConstValSpecialUndef;
17738		IrInstruction *ptr = ir_get_ref(ira, &instruction->base, result, false, false);
	18740	IrInstGen *ptr = ir_get_ref(ira, &instruction->base.base, result, false, false);
17739	18741	ptr->value->data.x_ptr.mut = ConstPtrMutComptimeVar;
17740	18742	return ptr;
17741	18743	}
...	...	@@ -17759,8 +18761,7 @@ static void ir_reset_result(ResultLoc *result_loc) {
17759	18761	break;
17760	18762	}
17761	18763	case ResultLocIdVar: {
17762		IrInstructionAllocaSrc *alloca_src =
17763		reinterpret_cast<IrInstructionAllocaSrc *>(result_loc->source_instruction);
	18764	IrInstSrcAlloca alloca_src = reinterpret_cast<IrInstSrcAlloca >(result_loc->source_instruction);
17764	18765	alloca_src->base.child = nullptr;
17765	18766	break;
17766	18767	}
...	...	@@ -17776,18 +18777,18 @@ static void ir_reset_result(ResultLoc *result_loc) {
17776	18777	}
17777	18778	}
17778	18779
17779		static IrInstruction ir_analyze_instruction_reset_result(IrAnalyze ira, IrInstructionResetResult *instruction) {
	18780	static IrInstGen ir_analyze_instruction_reset_result(IrAnalyze ira, IrInstSrcResetResult *instruction) {
17780	18781	ir_reset_result(instruction->result_loc);
17781		return ir_const_void(ira, &instruction->base);
	18782	return ir_const_void(ira, &instruction->base.base);
17782	18783	}
17783	18784
17784		static IrInstruction get_async_call_result_loc(IrAnalyze ira, IrInstruction *source_instr,
17785		ZigType fn_ret_type, bool is_async_call_builtin, IrInstruction *args_ptr, size_t args_len,
17786		IrInstruction *ret_ptr_uncasted)
	18785	static IrInstGen get_async_call_result_loc(IrAnalyze ira, IrInst* source_instr,
	18786	ZigType fn_ret_type, bool is_async_call_builtin, IrInstGen *args_ptr, size_t args_len,
	18787	IrInstGen *ret_ptr_uncasted)
17787	18788	{
17788	18789	ir_assert(is_async_call_builtin, source_instr);
17789	18790	if (type_is_invalid(ret_ptr_uncasted->value->type))
17790		return ira->codegen->invalid_instruction;
	18791	return ira->codegen->invalid_inst_gen;
17791	18792	if (ret_ptr_uncasted->value->type->id == ZigTypeIdVoid) {
17792	18793	// Result location will be inside the async frame.
17793	18794	return nullptr;
...	...	@@ -17795,57 +18796,57 @@ static IrInstruction get_async_call_result_loc(IrAnalyze ira, IrInstruction *s
17795	18796	return ir_implicit_cast(ira, ret_ptr_uncasted, get_pointer_to_type(ira->codegen, fn_ret_type, false));
17796	18797	}
17797	18798
17798		static IrInstruction ir_analyze_async_call(IrAnalyze ira, IrInstruction source_instr, ZigFn fn_entry,
17799		ZigType fn_type, IrInstruction fn_ref, IrInstruction **casted_args, size_t arg_count,
17800		IrInstruction casted_new_stack, bool is_async_call_builtin, IrInstruction ret_ptr_uncasted,
	18799	static IrInstGen ir_analyze_async_call(IrAnalyze ira, IrInst* source_instr, ZigFn *fn_entry,
	18800	ZigType fn_type, IrInstGen fn_ref, IrInstGen **casted_args, size_t arg_count,
	18801	IrInstGen casted_new_stack, bool is_async_call_builtin, IrInstGen ret_ptr_uncasted,
17801	18802	ResultLoc *call_result_loc)
17802	18803	{
17803	18804	if (fn_entry == nullptr) {
17804	18805	if (fn_type->data.fn.fn_type_id.cc != CallingConventionAsync) {
17805		ir_add_error(ira, fn_ref,
	18806	ir_add_error(ira, &fn_ref->base,
17806	18807	buf_sprintf("expected async function, found '%s'", buf_ptr(&fn_type->name)));
17807		return ira->codegen->invalid_instruction;
	18808	return ira->codegen->invalid_inst_gen;
17808	18809	}
17809	18810	if (casted_new_stack == nullptr) {
17810		ir_add_error(ira, fn_ref, buf_sprintf("function is not comptime-known; @asyncCall required"));
17811		return ira->codegen->invalid_instruction;
	18811	ir_add_error(ira, &fn_ref->base, buf_sprintf("function is not comptime-known; @asyncCall required"));
	18812	return ira->codegen->invalid_inst_gen;
17812	18813	}
17813	18814	}
17814	18815	if (casted_new_stack != nullptr) {
17815	18816	ZigType *fn_ret_type = fn_type->data.fn.fn_type_id.return_type;
17816		IrInstruction *ret_ptr = get_async_call_result_loc(ira, source_instr, fn_ret_type, is_async_call_builtin,
	18817	IrInstGen *ret_ptr = get_async_call_result_loc(ira, source_instr, fn_ret_type, is_async_call_builtin,
17817	18818	casted_args, arg_count, ret_ptr_uncasted);
17818	18819	if (ret_ptr != nullptr && type_is_invalid(ret_ptr->value->type))
17819		return ira->codegen->invalid_instruction;
	18820	return ira->codegen->invalid_inst_gen;
17820	18821
17821	18822	ZigType *anyframe_type = get_any_frame_type(ira->codegen, fn_ret_type);
17822	18823
17823		IrInstructionCallGen *call_gen = ir_build_call_gen(ira, source_instr, fn_entry, fn_ref,
	18824	IrInstGenCall *call_gen = ir_build_call_gen(ira, source_instr, fn_entry, fn_ref,
17824	18825	arg_count, casted_args, CallModifierAsync, casted_new_stack,
17825	18826	is_async_call_builtin, ret_ptr, anyframe_type);
17826	18827	return &call_gen->base;
17827	18828	} else {
17828	18829	ZigType *frame_type = get_fn_frame_type(ira->codegen, fn_entry);
17829		IrInstruction *result_loc = ir_resolve_result(ira, source_instr, call_result_loc,
	18830	IrInstGen *result_loc = ir_resolve_result(ira, source_instr, call_result_loc,
17830	18831	frame_type, nullptr, true, true, false);
17831		if (type_is_invalid(result_loc->value->type) \|\| instr_is_unreachable(result_loc)) {
	18832	if (type_is_invalid(result_loc->value->type) \|\| result_loc->value->type->id == ZigTypeIdUnreachable) {
17832	18833	return result_loc;
17833	18834	}
17834	18835	result_loc = ir_implicit_cast(ira, result_loc, get_pointer_to_type(ira->codegen, frame_type, false));
17835	18836	if (type_is_invalid(result_loc->value->type))
17836		return ira->codegen->invalid_instruction;
	18837	return ira->codegen->invalid_inst_gen;
17837	18838	return &ir_build_call_gen(ira, source_instr, fn_entry, fn_ref, arg_count,
17838	18839	casted_args, CallModifierAsync, casted_new_stack,
17839	18840	is_async_call_builtin, result_loc, frame_type)->base;
17840	18841	}
17841	18842	}
17842	18843	static bool ir_analyze_fn_call_inline_arg(IrAnalyze ira, AstNode fn_proto_node,
17843		IrInstruction arg, Scope exec_scope, size_t next_proto_i)
	18844	IrInstGen arg, Scope exec_scope, size_t next_proto_i)
17844	18845	{
17845	18846	AstNode param_decl_node = fn_proto_node->data.fn_proto.params.at(next_proto_i);
17846	18847	assert(param_decl_node->type == NodeTypeParamDecl);
17847	18848
17848		IrInstruction *casted_arg;
	18849	IrInstGen *casted_arg;
17849	18850	if (param_decl_node->data.param_decl.var_token == nullptr) {
17850	18851	AstNode *param_type_node = param_decl_node->data.param_decl.type;
17851	18852	ZigType param_type = ir_analyze_type_expr(ira, exec_scope, param_type_node);
...	...	@@ -17873,15 +18874,15 @@ static bool ir_analyze_fn_call_inline_arg(IrAnalyze ira, AstNode fn_proto_node
17873	18874	}
17874	18875
17875	18876	static bool ir_analyze_fn_call_generic_arg(IrAnalyze ira, AstNode fn_proto_node,
17876		IrInstruction arg, Scope child_scope, size_t next_proto_i,
17877		GenericFnTypeId generic_id, FnTypeId fn_type_id, IrInstruction **casted_args,
	18877	IrInstGen arg, Scope child_scope, size_t next_proto_i,
	18878	GenericFnTypeId generic_id, FnTypeId fn_type_id, IrInstGen **casted_args,
17878	18879	ZigFn *impl_fn)
17879	18880	{
17880	18881	AstNode param_decl_node = fn_proto_node->data.fn_proto.params.at(next_proto_i);
17881	18882	assert(param_decl_node->type == NodeTypeParamDecl);
17882	18883	bool is_var_args = param_decl_node->data.param_decl.is_var_args;
17883	18884	bool arg_part_of_generic_id = false;
17884		IrInstruction *casted_arg;
	18885	IrInstGen *casted_arg;
17885	18886	if (is_var_args) {
17886	18887	arg_part_of_generic_id = true;
17887	18888	casted_arg = arg;
...	...	@@ -17941,7 +18942,7 @@ static bool ir_analyze_fn_call_generic_arg(IrAnalyze ira, AstNode fn_proto_nod
17941	18942	} else if (casted_arg->value->type->id == ZigTypeIdComptimeInt \|\|
17942	18943	casted_arg->value->type->id == ZigTypeIdComptimeFloat)
17943	18944	{
17944		ir_add_error(ira, casted_arg,
	18945	ir_add_error(ira, &casted_arg->base,
17945	18946	buf_sprintf("compiler bug: integer and float literals in var args function must be casted. https://github.com/ziglang/zig/issues/557"));
17946	18947	return false;
17947	18948	}
...	...	@@ -17958,17 +18959,17 @@ static bool ir_analyze_fn_call_generic_arg(IrAnalyze ira, AstNode fn_proto_nod
17958	18959	return true;
17959	18960	}
17960	18961
17961		static IrInstruction ir_get_var_ptr(IrAnalyze ira, IrInstruction instruction, ZigVar var) {
	18962	static IrInstGen ir_get_var_ptr(IrAnalyze ira, IrInst source_instr, ZigVar var) {
17962	18963	while (var->next_var != nullptr) {
17963	18964	var = var->next_var;
17964	18965	}
17965	18966
17966	18967	if (var->mem_slot_index != SIZE_MAX && var->owner_exec->analysis == nullptr) {
17967	18968	assert(ira->codegen->errors.length != 0);
17968		return ira->codegen->invalid_instruction;
	18969	return ira->codegen->invalid_inst_gen;
17969	18970	}
17970	18971	if (var->var_type == nullptr \|\| type_is_invalid(var->var_type))
17971		return ira->codegen->invalid_instruction;
	18972	return ira->codegen->invalid_inst_gen;
17972	18973
17973	18974	ZigValue *mem_slot = nullptr;
17974	18975
...	...	@@ -17976,8 +18977,7 @@ static IrInstruction ir_get_var_ptr(IrAnalyze ira, IrInstruction *instruction,
17976	18977	bool linkage_makes_it_runtime = var->decl_node->data.variable_declaration.is_extern;
17977	18978	bool is_volatile = false;
17978	18979
17979		IrInstruction *result = ir_build_var_ptr(&ira->new_irb,
17980		instruction->scope, instruction->source_node, var);
	18980	IrInstGen *result = ir_build_var_ptr_gen(ira, source_instr, var);
17981	18981	result->value->type = get_pointer_to_type_extra(ira->codegen, var->var_type,
17982	18982	var->src_is_const, is_volatile, PtrLenSingle, var->align_bytes, 0, 0, false);
17983	18983
...	...	@@ -18030,7 +19030,7 @@ no_mem_slot:
18030	19030	}
18031	19031
18032	19032	// This function is called when a comptime value becomes accessible at runtime.
18033		static void mark_comptime_value_escape(IrAnalyze ira, IrInstruction source_instr, ZigValue *val) {
	19033	static void mark_comptime_value_escape(IrAnalyze ira, IrInst source_instr, ZigValue *val) {
18034	19034	ir_assert(value_is_comptime(val), source_instr);
18035	19035	if (val->special == ConstValSpecialUndef)
18036	19036	return;
...	...	@@ -18043,8 +19043,8 @@ static void mark_comptime_value_escape(IrAnalyze ira, IrInstruction source_ins
18043	19043	}
18044	19044	}
18045	19045
18046		static IrInstruction ir_analyze_store_ptr(IrAnalyze ira, IrInstruction *source_instr,
18047		IrInstruction ptr, IrInstruction uncasted_value, bool allow_write_through_const)
	19046	static IrInstGen ir_analyze_store_ptr(IrAnalyze ira, IrInst* source_instr,
	19047	IrInstGen ptr, IrInstGen uncasted_value, bool allow_write_through_const)
18048	19048	{
18049	19049	assert(ptr->value->type->id == ZigTypeIdPointer);
18050	19050
...	...	@@ -18053,24 +19053,24 @@ static IrInstruction ir_analyze_store_ptr(IrAnalyze ira, IrInstruction *source
18053	19053	uncasted_value->value->type->id == ZigTypeIdErrorSet)
18054	19054	{
18055	19055	ir_add_error(ira, source_instr, buf_sprintf("error is discarded"));
18056		return ira->codegen->invalid_instruction;
	19056	return ira->codegen->invalid_inst_gen;
18057	19057	}
18058	19058	return ir_const_void(ira, source_instr);
18059	19059	}
18060	19060
18061	19061	if (ptr->value->type->data.pointer.is_const && !allow_write_through_const) {
18062	19062	ir_add_error(ira, source_instr, buf_sprintf("cannot assign to constant"));
18063		return ira->codegen->invalid_instruction;
	19063	return ira->codegen->invalid_inst_gen;
18064	19064	}
18065	19065
18066	19066	ZigType *child_type = ptr->value->type->data.pointer.child_type;
18067		IrInstruction *value = ir_implicit_cast(ira, uncasted_value, child_type);
18068		if (value == ira->codegen->invalid_instruction)
18069		return ira->codegen->invalid_instruction;
	19067	IrInstGen *value = ir_implicit_cast(ira, uncasted_value, child_type);
	19068	if (type_is_invalid(value->value->type))
	19069	return ira->codegen->invalid_inst_gen;
18070	19070
18071	19071	switch (type_has_one_possible_value(ira->codegen, child_type)) {
18072	19072	case OnePossibleValueInvalid:
18073		return ira->codegen->invalid_instruction;
	19073	return ira->codegen->invalid_inst_gen;
18074	19074	case OnePossibleValueYes:
18075	19075	return ir_const_void(ira, source_instr);
18076	19076	case OnePossibleValueNo:
...	...	@@ -18080,7 +19080,7 @@ static IrInstruction ir_analyze_store_ptr(IrAnalyze ira, IrInstruction *source
18080	19080	if (instr_is_comptime(ptr) && ptr->value->data.x_ptr.special != ConstPtrSpecialHardCodedAddr) {
18081	19081	if (!allow_write_through_const && ptr->value->data.x_ptr.mut == ConstPtrMutComptimeConst) {
18082	19082	ir_add_error(ira, source_instr, buf_sprintf("cannot assign to constant"));
18083		return ira->codegen->invalid_instruction;
	19083	return ira->codegen->invalid_inst_gen;
18084	19084	}
18085	19085	if ((allow_write_through_const && ptr->value->data.x_ptr.mut == ConstPtrMutComptimeConst) \|\|
18086	19086	ptr->value->data.x_ptr.mut == ConstPtrMutComptimeVar \|\|
...	...	@@ -18089,7 +19089,7 @@ static IrInstruction ir_analyze_store_ptr(IrAnalyze ira, IrInstruction *source
18089	19089	if (instr_is_comptime(value)) {
18090	19090	ZigValue *dest_val = const_ptr_pointee(ira, ira->codegen, ptr->value, source_instr->source_node);
18091	19091	if (dest_val == nullptr)
18092		return ira->codegen->invalid_instruction;
	19092	return ira->codegen->invalid_inst_gen;
18093	19093	if (dest_val->special != ConstValSpecialRuntime) {
18094	19094	copy_const_val(dest_val, value->value);
18095	19095
...	...	@@ -18109,7 +19109,7 @@ static IrInstruction ir_analyze_store_ptr(IrAnalyze ira, IrInstruction *source
18109	19109	ZigValue *dest_val = const_ptr_pointee_unchecked(ira->codegen, ptr->value);
18110	19110	dest_val->type = ira->codegen->builtin_types.entry_invalid;
18111	19111
18112		return ira->codegen->invalid_instruction;
	19112	return ira->codegen->invalid_inst_gen;
18113	19113	}
18114	19114	}
18115	19115	}
...	...	@@ -18122,15 +19122,15 @@ static IrInstruction ir_analyze_store_ptr(IrAnalyze ira, IrInstruction *source
18122	19122
18123	19123	switch (type_requires_comptime(ira->codegen, child_type)) {
18124	19124	case ReqCompTimeInvalid:
18125		return ira->codegen->invalid_instruction;
	19125	return ira->codegen->invalid_inst_gen;
18126	19126	case ReqCompTimeYes:
18127	19127	switch (type_has_one_possible_value(ira->codegen, ptr->value->type)) {
18128	19128	case OnePossibleValueInvalid:
18129		return ira->codegen->invalid_instruction;
	19129	return ira->codegen->invalid_inst_gen;
18130	19130	case OnePossibleValueNo:
18131	19131	ir_add_error(ira, source_instr,
18132	19132	buf_sprintf("cannot store runtime value in type '%s'", buf_ptr(&child_type->name)));
18133		return ira->codegen->invalid_instruction;
	19133	return ira->codegen->invalid_inst_gen;
18134	19134	case OnePossibleValueYes:
18135	19135	return ir_const_void(ira, source_instr);
18136	19136	}
...	...	@@ -18144,30 +19144,28 @@ static IrInstruction ir_analyze_store_ptr(IrAnalyze ira, IrInstruction *source
18144	19144	}
18145	19145
18146	19146	// If this is a store to a pointer with a runtime-known vector index,
18147		// we have to figure out the IrInstruction which represents the index and
18148		// emit a IrInstructionVectorStoreElem, or emit a compile error
	19147	// we have to figure out the IrInstGen which represents the index and
	19148	// emit a IrInstGenVectorStoreElem, or emit a compile error
18149	19149	// explaining why it is impossible for this store to work. Which is that
18150	19150	// the pointer address is of the vector; without the element index being known
18151	19151	// we cannot properly perform the insertion.
18152	19152	if (ptr->value->type->data.pointer.vector_index == VECTOR_INDEX_RUNTIME) {
18153		if (ptr->id == IrInstructionIdElemPtr) {
18154		IrInstructionElemPtr elem_ptr = (IrInstructionElemPtr )ptr;
	19153	if (ptr->id == IrInstGenIdElemPtr) {
	19154	IrInstGenElemPtr elem_ptr = (IrInstGenElemPtr )ptr;
18155	19155	return ir_build_vector_store_elem(ira, source_instr, elem_ptr->array_ptr,
18156	19156	elem_ptr->elem_index, value);
18157	19157	}
18158		ir_add_error(ira, ptr,
	19158	ir_add_error(ira, &ptr->base,
18159	19159	buf_sprintf("unable to determine vector element index of type '%s'",
18160	19160	buf_ptr(&ptr->value->type->name)));
18161		return ira->codegen->invalid_instruction;
	19161	return ira->codegen->invalid_inst_gen;
18162	19162	}
18163	19163
18164		IrInstructionStorePtr *store_ptr = ir_build_store_ptr(&ira->new_irb, source_instr->scope,
18165		source_instr->source_node, ptr, value);
18166		return &store_ptr->base;
	19164	return ir_build_store_ptr_gen(ira, source_instr, ptr, value);
18167	19165	}
18168	19166
18169		static IrInstruction analyze_casted_new_stack(IrAnalyze ira, IrInstruction *source_instr,
18170		IrInstruction new_stack, bool is_async_call_builtin, ZigFn fn_entry)
	19167	static IrInstGen analyze_casted_new_stack(IrAnalyze ira, IrInst* source_instr,
	19168	IrInstGen new_stack, bool is_async_call_builtin, ZigFn fn_entry)
18171	19169	{
18172	19170	if (new_stack == nullptr)
18173	19171	return nullptr;
...	...	@@ -18196,11 +19194,11 @@ static IrInstruction analyze_casted_new_stack(IrAnalyze ira, IrInstruction *so
18196	19194	}
18197	19195	}
18198	19196
18199		static IrInstruction ir_analyze_fn_call(IrAnalyze ira, IrInstruction *source_instr,
18200		ZigFn fn_entry, ZigType fn_type, IrInstruction *fn_ref,
18201		IrInstruction *first_arg_ptr, CallModifier modifier,
18202		IrInstruction *new_stack, bool is_async_call_builtin,
18203		IrInstruction *args_ptr, size_t args_len, IrInstruction ret_ptr, ResultLoc *call_result_loc)
	19197	static IrInstGen ir_analyze_fn_call(IrAnalyze ira, IrInst* source_instr,
	19198	ZigFn fn_entry, ZigType fn_type, IrInstGen *fn_ref,
	19199	IrInstGen *first_arg_ptr, CallModifier modifier,
	19200	IrInstGen *new_stack, bool is_async_call_builtin,
	19201	IrInstGen *args_ptr, size_t args_len, IrInstGen ret_ptr, ResultLoc *call_result_loc)
18204	19202	{
18205	19203	Error err;
18206	19204	FnTypeId *fn_type_id = &fn_type->data.fn.fn_type_id;
...	...	@@ -18221,11 +19219,11 @@ static IrInstruction ir_analyze_fn_call(IrAnalyze ira, IrInstruction *source_i
18221	19219	AstNode *fn_proto_node = fn_entry ? fn_entry->proto_node : nullptr;;
18222	19220
18223	19221	if (fn_type_id->cc == CallingConventionNaked) {
18224		ErrorMsg *msg = ir_add_error(ira, fn_ref, buf_sprintf("unable to call function with naked calling convention"));
	19222	ErrorMsg *msg = ir_add_error(ira, &fn_ref->base, buf_sprintf("unable to call function with naked calling convention"));
18225	19223	if (fn_proto_node) {
18226	19224	add_error_note(ira->codegen, msg, fn_proto_node, buf_sprintf("declared here"));
18227	19225	}
18228		return ira->codegen->invalid_instruction;
	19226	return ira->codegen->invalid_inst_gen;
18229	19227	}
18230	19228
18231	19229	if (fn_type_id->is_var_args) {
...	...	@@ -18236,7 +19234,7 @@ static IrInstruction ir_analyze_fn_call(IrAnalyze ira, IrInstruction *source_i
18236	19234	add_error_note(ira->codegen, msg, fn_proto_node,
18237	19235	buf_sprintf("declared here"));
18238	19236	}
18239		return ira->codegen->invalid_instruction;
	19237	return ira->codegen->invalid_inst_gen;
18240	19238	}
18241	19239	} else if (src_param_count != call_param_count) {
18242	19240	ErrorMsg *msg = ir_add_error_node(ira, source_node,
...	...	@@ -18245,18 +19243,18 @@ static IrInstruction ir_analyze_fn_call(IrAnalyze ira, IrInstruction *source_i
18245	19243	add_error_note(ira->codegen, msg, fn_proto_node,
18246	19244	buf_sprintf("declared here"));
18247	19245	}
18248		return ira->codegen->invalid_instruction;
	19246	return ira->codegen->invalid_inst_gen;
18249	19247	}
18250	19248
18251	19249	if (modifier == CallModifierCompileTime) {
18252	19250	// No special handling is needed for compile time evaluation of generic functions.
18253	19251	if (!fn_entry \|\| fn_entry->body_node == nullptr) {
18254		ir_add_error(ira, fn_ref, buf_sprintf("unable to evaluate constant expression"));
18255		return ira->codegen->invalid_instruction;
	19252	ir_add_error(ira, &fn_ref->base, buf_sprintf("unable to evaluate constant expression"));
	19253	return ira->codegen->invalid_inst_gen;
18256	19254	}
18257	19255
18258	19256	if (!ir_emit_backward_branch(ira, source_instr))
18259		return ira->codegen->invalid_instruction;
	19257	return ira->codegen->invalid_inst_gen;
18260	19258
18261	19259	// Fork a scope of the function with known values for the parameters.
18262	19260	Scope *exec_scope = &fn_entry->fndef_scope->base;
...	...	@@ -18269,47 +19267,47 @@ static IrInstruction ir_analyze_fn_call(IrAnalyze ira, IrInstruction *source_i
18269	19267	if (fn_type_id->next_param_index >= 1) {
18270	19268	ZigType *param_type = fn_type_id->param_info[next_proto_i].type;
18271	19269	if (type_is_invalid(param_type))
18272		return ira->codegen->invalid_instruction;
	19270	return ira->codegen->invalid_inst_gen;
18273	19271	first_arg_known_bare = param_type->id != ZigTypeIdPointer;
18274	19272	}
18275	19273
18276		IrInstruction *first_arg;
	19274	IrInstGen *first_arg;
18277	19275	if (!first_arg_known_bare && handle_is_ptr(first_arg_ptr->value->type->data.pointer.child_type)) {
18278	19276	first_arg = first_arg_ptr;
18279	19277	} else {
18280		first_arg = ir_get_deref(ira, first_arg_ptr, first_arg_ptr, nullptr);
	19278	first_arg = ir_get_deref(ira, &first_arg_ptr->base, first_arg_ptr, nullptr);
18281	19279	if (type_is_invalid(first_arg->value->type))
18282		return ira->codegen->invalid_instruction;
	19280	return ira->codegen->invalid_inst_gen;
18283	19281	}
18284	19282
18285	19283	if (!ir_analyze_fn_call_inline_arg(ira, fn_proto_node, first_arg, &exec_scope, &next_proto_i))
18286		return ira->codegen->invalid_instruction;
	19284	return ira->codegen->invalid_inst_gen;
18287	19285	}
18288	19286
18289	19287	if (fn_proto_node->data.fn_proto.is_var_args) {
18290	19288	ir_add_error(ira, source_instr,
18291	19289	buf_sprintf("compiler bug: unable to call var args function at compile time. https://github.com/ziglang/zig/issues/313"));
18292		return ira->codegen->invalid_instruction;
	19290	return ira->codegen->invalid_inst_gen;
18293	19291	}
18294	19292
18295	19293
18296	19294	for (size_t call_i = 0; call_i < args_len; call_i += 1) {
18297		IrInstruction *old_arg = args_ptr[call_i];
	19295	IrInstGen *old_arg = args_ptr[call_i];
18298	19296
18299	19297	if (!ir_analyze_fn_call_inline_arg(ira, fn_proto_node, old_arg, &exec_scope, &next_proto_i))
18300		return ira->codegen->invalid_instruction;
	19298	return ira->codegen->invalid_inst_gen;
18301	19299	}
18302	19300
18303	19301	AstNode *return_type_node = fn_proto_node->data.fn_proto.return_type;
18304	19302	ZigType *specified_return_type = ir_analyze_type_expr(ira, exec_scope, return_type_node);
18305	19303	if (type_is_invalid(specified_return_type))
18306		return ira->codegen->invalid_instruction;
	19304	return ira->codegen->invalid_inst_gen;
18307	19305	ZigType *return_type;
18308	19306	ZigType *inferred_err_set_type = nullptr;
18309	19307	if (fn_proto_node->data.fn_proto.auto_err_set) {
18310	19308	inferred_err_set_type = get_auto_err_set_type(ira->codegen, fn_entry);
18311	19309	if ((err = type_resolve(ira->codegen, specified_return_type, ResolveStatusSizeKnown)))
18312		return ira->codegen->invalid_instruction;
	19310	return ira->codegen->invalid_inst_gen;
18313	19311	return_type = get_error_union_type(ira->codegen, inferred_err_set_type, specified_return_type);
18314	19312	} else {
18315	19313	return_type = specified_return_type;
...	...	@@ -18354,24 +19352,24 @@ static IrInstruction ir_analyze_fn_call(IrAnalyze ira, IrInstruction *source_i
18354	19352	}
18355	19353
18356	19354	if (type_is_invalid(result->type)) {
18357		return ira->codegen->invalid_instruction;
	19355	return ira->codegen->invalid_inst_gen;
18358	19356	}
18359	19357	}
18360	19358
18361		IrInstruction *new_instruction = ir_const_move(ira, source_instr, result);
	19359	IrInstGen *new_instruction = ir_const_move(ira, source_instr, result);
18362	19360	return ir_finish_anal(ira, new_instruction);
18363	19361	}
18364	19362
18365	19363	if (fn_type->data.fn.is_generic) {
18366	19364	if (!fn_entry) {
18367		ir_add_error(ira, fn_ref,
	19365	ir_add_error(ira, &fn_ref->base,
18368	19366	buf_sprintf("calling a generic function requires compile-time known function value"));
18369		return ira->codegen->invalid_instruction;
	19367	return ira->codegen->invalid_inst_gen;
18370	19368	}
18371	19369
18372	19370	size_t new_fn_arg_count = first_arg_1_or_0 + args_len;
18373	19371
18374		IrInstruction *casted_args = allocate<IrInstruction >(new_fn_arg_count);
	19372	IrInstGen *casted_args = allocate<IrInstGen >(new_fn_arg_count);
18375	19373
18376	19374	// Fork a scope of the function with known values for the parameters.
18377	19375	Scope *parent_scope = fn_entry->fndef_scope->base.parent;
...	...	@@ -18400,30 +19398,30 @@ static IrInstruction ir_analyze_fn_call(IrAnalyze ira, IrInstruction *source_i
18400	19398	if (fn_type_id->next_param_index >= 1) {
18401	19399	ZigType *param_type = fn_type_id->param_info[next_proto_i].type;
18402	19400	if (type_is_invalid(param_type))
18403		return ira->codegen->invalid_instruction;
	19401	return ira->codegen->invalid_inst_gen;
18404	19402	first_arg_known_bare = param_type->id != ZigTypeIdPointer;
18405	19403	}
18406	19404
18407		IrInstruction *first_arg;
	19405	IrInstGen *first_arg;
18408	19406	if (!first_arg_known_bare && handle_is_ptr(first_arg_ptr->value->type->data.pointer.child_type)) {
18409	19407	first_arg = first_arg_ptr;
18410	19408	} else {
18411		first_arg = ir_get_deref(ira, first_arg_ptr, first_arg_ptr, nullptr);
	19409	first_arg = ir_get_deref(ira, &first_arg_ptr->base, first_arg_ptr, nullptr);
18412	19410	if (type_is_invalid(first_arg->value->type))
18413		return ira->codegen->invalid_instruction;
	19411	return ira->codegen->invalid_inst_gen;
18414	19412	}
18415	19413
18416	19414	if (!ir_analyze_fn_call_generic_arg(ira, fn_proto_node, first_arg, &impl_fn->child_scope,
18417	19415	&next_proto_i, generic_id, &inst_fn_type_id, casted_args, impl_fn))
18418	19416	{
18419		return ira->codegen->invalid_instruction;
	19417	return ira->codegen->invalid_inst_gen;
18420	19418	}
18421	19419	}
18422	19420
18423		ZigFn *parent_fn_entry = exec_fn_entry(ira->new_irb.exec);
	19421	ZigFn *parent_fn_entry = ira->new_irb.exec->fn_entry;
18424	19422	assert(parent_fn_entry);
18425	19423	for (size_t call_i = 0; call_i < args_len; call_i += 1) {
18426		IrInstruction *arg = args_ptr[call_i];
	19424	IrInstGen *arg = args_ptr[call_i];
18427	19425
18428	19426	AstNode *param_decl_node = fn_proto_node->data.fn_proto.params.at(next_proto_i);
18429	19427	assert(param_decl_node->type == NodeTypeParamDecl);
...	...	@@ -18431,7 +19429,7 @@ static IrInstruction ir_analyze_fn_call(IrAnalyze ira, IrInstruction *source_i
18431	19429	if (!ir_analyze_fn_call_generic_arg(ira, fn_proto_node, arg, &impl_fn->child_scope,
18432	19430	&next_proto_i, generic_id, &inst_fn_type_id, casted_args, impl_fn))
18433	19431	{
18434		return ira->codegen->invalid_instruction;
	19432	return ira->codegen->invalid_inst_gen;
18435	19433	}
18436	19434	}
18437	19435
...	...	@@ -18441,7 +19439,7 @@ static IrInstruction ir_analyze_fn_call(IrAnalyze ira, IrInstruction *source_i
18441	19439	ira->new_irb.exec->backward_branch_count, ira->new_irb.exec->backward_branch_quota,
18442	19440	nullptr, nullptr, fn_proto_node->data.fn_proto.align_expr, nullptr, ira->new_irb.exec,
18443	19441	nullptr, UndefBad);
18444		IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(&ira->new_irb,
	19442	IrInstGenConst *const_instruction = ir_create_inst_gen<IrInstGenConst>(&ira->new_irb,
18445	19443	impl_fn->child_scope, fn_proto_node->data.fn_proto.align_expr);
18446	19444	copy_const_val(const_instruction->base.value, align_result);
18447	19445
...	...	@@ -18455,11 +19453,11 @@ static IrInstruction ir_analyze_fn_call(IrAnalyze ira, IrInstruction *source_i
18455	19453	AstNode *return_type_node = fn_proto_node->data.fn_proto.return_type;
18456	19454	ZigType *specified_return_type = ir_analyze_type_expr(ira, impl_fn->child_scope, return_type_node);
18457	19455	if (type_is_invalid(specified_return_type))
18458		return ira->codegen->invalid_instruction;
	19456	return ira->codegen->invalid_inst_gen;
18459	19457	if (fn_proto_node->data.fn_proto.auto_err_set) {
18460	19458	ZigType *inferred_err_set_type = get_auto_err_set_type(ira->codegen, impl_fn);
18461	19459	if ((err = type_resolve(ira->codegen, specified_return_type, ResolveStatusSizeKnown)))
18462		return ira->codegen->invalid_instruction;
	19460	return ira->codegen->invalid_inst_gen;
18463	19461	inst_fn_type_id.return_type = get_error_union_type(ira->codegen, inferred_err_set_type, specified_return_type);
18464	19462	} else {
18465	19463	inst_fn_type_id.return_type = specified_return_type;
...	...	@@ -18472,7 +19470,7 @@ static IrInstruction ir_analyze_fn_call(IrAnalyze ira, IrInstruction *source_i
18472	19470	CallModifierCompileTime, new_stack, is_async_call_builtin, args_ptr, args_len,
18473	19471	ret_ptr, call_result_loc);
18474	19472	case ReqCompTimeInvalid:
18475		return ira->codegen->invalid_instruction;
	19473	return ira->codegen->invalid_inst_gen;
18476	19474	case ReqCompTimeNo:
18477	19475	break;
18478	19476	}
...	...	@@ -18486,7 +19484,7 @@ static IrInstruction ir_analyze_fn_call(IrAnalyze ira, IrInstruction *source_i
18486	19484	// finish instantiating the function
18487	19485	impl_fn->type_entry = get_fn_type(ira->codegen, &inst_fn_type_id);
18488	19486	if (type_is_invalid(impl_fn->type_entry))
18489		return ira->codegen->invalid_instruction;
	19487	return ira->codegen->invalid_inst_gen;
18490	19488
18491	19489	impl_fn->ir_executable->source_node = source_instr->source_node;
18492	19490	impl_fn->ir_executable->parent_exec = ira->new_irb.exec;
...	...	@@ -18504,25 +19502,25 @@ static IrInstruction ir_analyze_fn_call(IrAnalyze ira, IrInstruction *source_i
18504	19502	parent_fn_entry->calls_or_awaits_errorable_fn = true;
18505	19503	}
18506	19504
18507		IrInstruction *casted_new_stack = analyze_casted_new_stack(ira, source_instr, new_stack,
	19505	IrInstGen *casted_new_stack = analyze_casted_new_stack(ira, source_instr, new_stack,
18508	19506	is_async_call_builtin, impl_fn);
18509	19507	if (casted_new_stack != nullptr && type_is_invalid(casted_new_stack->value->type))
18510		return ira->codegen->invalid_instruction;
	19508	return ira->codegen->invalid_inst_gen;
18511	19509
18512	19510	size_t impl_param_count = impl_fn_type_id->param_count;
18513	19511	if (modifier == CallModifierAsync) {
18514		IrInstruction *result = ir_analyze_async_call(ira, source_instr, impl_fn, impl_fn->type_entry,
	19512	IrInstGen *result = ir_analyze_async_call(ira, source_instr, impl_fn, impl_fn->type_entry,
18515	19513	nullptr, casted_args, impl_param_count, casted_new_stack, is_async_call_builtin, ret_ptr,
18516	19514	call_result_loc);
18517	19515	return ir_finish_anal(ira, result);
18518	19516	}
18519	19517
18520		IrInstruction *result_loc;
	19518	IrInstGen *result_loc;
18521	19519	if (handle_is_ptr(impl_fn_type_id->return_type)) {
18522	19520	result_loc = ir_resolve_result(ira, source_instr, call_result_loc,
18523	19521	impl_fn_type_id->return_type, nullptr, true, true, false);
18524	19522	if (result_loc != nullptr) {
18525		if (type_is_invalid(result_loc->value->type) \|\| instr_is_unreachable(result_loc)) {
	19523	if (type_is_invalid(result_loc->value->type) \|\| result_loc->value->type->id == ZigTypeIdUnreachable) {
18526	19524	return result_loc;
18527	19525	}
18528	19526	ZigType *res_child_type = result_loc->value->type->data.pointer.child_type;
...	...	@@ -18538,7 +19536,7 @@ static IrInstruction ir_analyze_fn_call(IrAnalyze ira, IrInstruction *source_i
18538	19536	result_loc = get_async_call_result_loc(ira, source_instr, impl_fn_type_id->return_type,
18539	19537	is_async_call_builtin, args_ptr, args_len, ret_ptr);
18540	19538	if (result_loc != nullptr && type_is_invalid(result_loc->value->type))
18541		return ira->codegen->invalid_instruction;
	19539	return ira->codegen->invalid_inst_gen;
18542	19540	} else {
18543	19541	result_loc = nullptr;
18544	19542	}
...	...	@@ -18547,11 +19545,11 @@ static IrInstruction ir_analyze_fn_call(IrAnalyze ira, IrInstruction *source_i
18547	19545	parent_fn_entry->inferred_async_node == nullptr &&
18548	19546	modifier != CallModifierNoAsync)
18549	19547	{
18550		parent_fn_entry->inferred_async_node = fn_ref->source_node;
	19548	parent_fn_entry->inferred_async_node = fn_ref->base.source_node;
18551	19549	parent_fn_entry->inferred_async_fn = impl_fn;
18552	19550	}
18553	19551
18554		IrInstructionCallGen *new_call_instruction = ir_build_call_gen(ira, source_instr,
	19552	IrInstGenCall *new_call_instruction = ir_build_call_gen(ira, source_instr,
18555	19553	impl_fn, nullptr, impl_param_count, casted_args, modifier, casted_new_stack,
18556	19554	is_async_call_builtin, result_loc, impl_fn_type_id->return_type);
18557	19555
...	...	@@ -18562,7 +19560,7 @@ static IrInstruction ir_analyze_fn_call(IrAnalyze ira, IrInstruction *source_i
18562	19560	return ir_finish_anal(ira, &new_call_instruction->base);
18563	19561	}
18564	19562
18565		ZigFn *parent_fn_entry = exec_fn_entry(ira->new_irb.exec);
	19563	ZigFn *parent_fn_entry = ira->new_irb.exec->fn_entry;
18566	19564	assert(fn_type_id->return_type != nullptr);
18567	19565	assert(parent_fn_entry != nullptr);
18568	19566	if (fn_type_can_fail(fn_type_id)) {
...	...	@@ -18570,46 +19568,46 @@ static IrInstruction ir_analyze_fn_call(IrAnalyze ira, IrInstruction *source_i
18570	19568	}
18571	19569
18572	19570
18573		IrInstruction *casted_args = allocate<IrInstruction >(call_param_count);
	19571	IrInstGen *casted_args = allocate<IrInstGen >(call_param_count);
18574	19572	size_t next_arg_index = 0;
18575	19573	if (first_arg_ptr) {
18576	19574	assert(first_arg_ptr->value->type->id == ZigTypeIdPointer);
18577	19575
18578	19576	ZigType *param_type = fn_type_id->param_info[next_arg_index].type;
18579	19577	if (type_is_invalid(param_type))
18580		return ira->codegen->invalid_instruction;
	19578	return ira->codegen->invalid_inst_gen;
18581	19579
18582		IrInstruction *first_arg;
	19580	IrInstGen *first_arg;
18583	19581	if (param_type->id == ZigTypeIdPointer &&
18584	19582	handle_is_ptr(first_arg_ptr->value->type->data.pointer.child_type))
18585	19583	{
18586	19584	first_arg = first_arg_ptr;
18587	19585	} else {
18588		first_arg = ir_get_deref(ira, first_arg_ptr, first_arg_ptr, nullptr);
	19586	first_arg = ir_get_deref(ira, &first_arg_ptr->base, first_arg_ptr, nullptr);
18589	19587	if (type_is_invalid(first_arg->value->type))
18590		return ira->codegen->invalid_instruction;
	19588	return ira->codegen->invalid_inst_gen;
18591	19589	}
18592	19590
18593		IrInstruction *casted_arg = ir_implicit_cast(ira, first_arg, param_type);
	19591	IrInstGen *casted_arg = ir_implicit_cast(ira, first_arg, param_type);
18594	19592	if (type_is_invalid(casted_arg->value->type))
18595		return ira->codegen->invalid_instruction;
	19593	return ira->codegen->invalid_inst_gen;
18596	19594
18597	19595	casted_args[next_arg_index] = casted_arg;
18598	19596	next_arg_index += 1;
18599	19597	}
18600	19598	for (size_t call_i = 0; call_i < args_len; call_i += 1) {
18601		IrInstruction *old_arg = args_ptr[call_i];
	19599	IrInstGen *old_arg = args_ptr[call_i];
18602	19600	if (type_is_invalid(old_arg->value->type))
18603		return ira->codegen->invalid_instruction;
	19601	return ira->codegen->invalid_inst_gen;
18604	19602
18605		IrInstruction *casted_arg;
	19603	IrInstGen *casted_arg;
18606	19604	if (next_arg_index < src_param_count) {
18607	19605	ZigType *param_type = fn_type_id->param_info[next_arg_index].type;
18608	19606	if (type_is_invalid(param_type))
18609		return ira->codegen->invalid_instruction;
	19607	return ira->codegen->invalid_inst_gen;
18610	19608	casted_arg = ir_implicit_cast(ira, old_arg, param_type);
18611	19609	if (type_is_invalid(casted_arg->value->type))
18612		return ira->codegen->invalid_instruction;
	19610	return ira->codegen->invalid_inst_gen;
18613	19611	} else {
18614	19612	casted_arg = old_arg;
18615	19613	}
...	...	@@ -18622,21 +19620,21 @@ static IrInstruction ir_analyze_fn_call(IrAnalyze ira, IrInstruction *source_i
18622	19620
18623	19621	ZigType *return_type = fn_type_id->return_type;
18624	19622	if (type_is_invalid(return_type))
18625		return ira->codegen->invalid_instruction;
	19623	return ira->codegen->invalid_inst_gen;
18626	19624
18627	19625	if (fn_entry != nullptr && fn_entry->fn_inline == FnInlineAlways && modifier == CallModifierNeverInline) {
18628	19626	ir_add_error(ira, source_instr,
18629	19627	buf_sprintf("no-inline call of inline function"));
18630		return ira->codegen->invalid_instruction;
	19628	return ira->codegen->invalid_inst_gen;
18631	19629	}
18632	19630
18633		IrInstruction *casted_new_stack = analyze_casted_new_stack(ira, source_instr, new_stack,
	19631	IrInstGen *casted_new_stack = analyze_casted_new_stack(ira, source_instr, new_stack,
18634	19632	is_async_call_builtin, fn_entry);
18635	19633	if (casted_new_stack != nullptr && type_is_invalid(casted_new_stack->value->type))
18636		return ira->codegen->invalid_instruction;
	19634	return ira->codegen->invalid_inst_gen;
18637	19635
18638	19636	if (modifier == CallModifierAsync) {
18639		IrInstruction *result = ir_analyze_async_call(ira, source_instr, fn_entry, fn_type, fn_ref,
	19637	IrInstGen *result = ir_analyze_async_call(ira, source_instr, fn_entry, fn_type, fn_ref,
18640	19638	casted_args, call_param_count, casted_new_stack, is_async_call_builtin, ret_ptr, call_result_loc);
18641	19639	return ir_finish_anal(ira, result);
18642	19640	}
...	...	@@ -18645,16 +19643,16 @@ static IrInstruction ir_analyze_fn_call(IrAnalyze ira, IrInstruction *source_i
18645	19643	parent_fn_entry->inferred_async_node == nullptr &&
18646	19644	modifier != CallModifierNoAsync)
18647	19645	{
18648		parent_fn_entry->inferred_async_node = fn_ref->source_node;
	19646	parent_fn_entry->inferred_async_node = fn_ref->base.source_node;
18649	19647	parent_fn_entry->inferred_async_fn = fn_entry;
18650	19648	}
18651	19649
18652		IrInstruction *result_loc;
	19650	IrInstGen *result_loc;
18653	19651	if (handle_is_ptr(return_type)) {
18654	19652	result_loc = ir_resolve_result(ira, source_instr, call_result_loc,
18655	19653	return_type, nullptr, true, true, false);
18656	19654	if (result_loc != nullptr) {
18657		if (type_is_invalid(result_loc->value->type) \|\| instr_is_unreachable(result_loc)) {
	19655	if (type_is_invalid(result_loc->value->type) \|\| result_loc->value->type->id == ZigTypeIdUnreachable) {
18658	19656	return result_loc;
18659	19657	}
18660	19658	ZigType *res_child_type = result_loc->value->type->data.pointer.child_type;
...	...	@@ -18670,12 +19668,12 @@ static IrInstruction ir_analyze_fn_call(IrAnalyze ira, IrInstruction *source_i
18670	19668	result_loc = get_async_call_result_loc(ira, source_instr, return_type, is_async_call_builtin,
18671	19669	args_ptr, args_len, ret_ptr);
18672	19670	if (result_loc != nullptr && type_is_invalid(result_loc->value->type))
18673		return ira->codegen->invalid_instruction;
	19671	return ira->codegen->invalid_inst_gen;
18674	19672	} else {
18675	19673	result_loc = nullptr;
18676	19674	}
18677	19675
18678		IrInstructionCallGen *new_call_instruction = ir_build_call_gen(ira, source_instr, fn_entry, fn_ref,
	19676	IrInstGenCall *new_call_instruction = ir_build_call_gen(ira, source_instr, fn_entry, fn_ref,
18679	19677	call_param_count, casted_args, modifier, casted_new_stack,
18680	19678	is_async_call_builtin, result_loc, return_type);
18681	19679	if (get_scope_typeof(source_instr->scope) == nullptr) {
...	...	@@ -18684,62 +19682,62 @@ static IrInstruction ir_analyze_fn_call(IrAnalyze ira, IrInstruction *source_i
18684	19682	return ir_finish_anal(ira, &new_call_instruction->base);
18685	19683	}
18686	19684
18687		static IrInstruction ir_analyze_fn_call_src(IrAnalyze ira, IrInstructionCallSrc *call_instruction,
18688		ZigFn fn_entry, ZigType fn_type, IrInstruction *fn_ref,
18689		IrInstruction *first_arg_ptr, CallModifier modifier)
	19685	static IrInstGen ir_analyze_fn_call_src(IrAnalyze ira, IrInstSrcCall *call_instruction,
	19686	ZigFn fn_entry, ZigType fn_type, IrInstGen *fn_ref,
	19687	IrInstGen *first_arg_ptr, CallModifier modifier)
18690	19688	{
18691		IrInstruction *new_stack = nullptr;
	19689	IrInstGen *new_stack = nullptr;
18692	19690	if (call_instruction->new_stack) {
18693	19691	new_stack = call_instruction->new_stack->child;
18694	19692	if (type_is_invalid(new_stack->value->type))
18695		return ira->codegen->invalid_instruction;
	19693	return ira->codegen->invalid_inst_gen;
18696	19694	}
18697		IrInstruction *args_ptr = allocate<IrInstruction >(call_instruction->arg_count, "IrInstruction *");
	19695	IrInstGen *args_ptr = allocate<IrInstGen >(call_instruction->arg_count, "IrInstGen *");
18698	19696	for (size_t i = 0; i < call_instruction->arg_count; i += 1) {
18699	19697	args_ptr[i] = call_instruction->args[i]->child;
18700	19698	if (type_is_invalid(args_ptr[i]->value->type))
18701		return ira->codegen->invalid_instruction;
	19699	return ira->codegen->invalid_inst_gen;
18702	19700	}
18703		IrInstruction *ret_ptr = nullptr;
	19701	IrInstGen *ret_ptr = nullptr;
18704	19702	if (call_instruction->ret_ptr != nullptr) {
18705	19703	ret_ptr = call_instruction->ret_ptr->child;
18706	19704	if (type_is_invalid(ret_ptr->value->type))
18707		return ira->codegen->invalid_instruction;
	19705	return ira->codegen->invalid_inst_gen;
18708	19706	}
18709		IrInstruction *result = ir_analyze_fn_call(ira, &call_instruction->base, fn_entry, fn_type, fn_ref,
	19707	IrInstGen *result = ir_analyze_fn_call(ira, &call_instruction->base.base, fn_entry, fn_type, fn_ref,
18710	19708	first_arg_ptr, modifier, new_stack, call_instruction->is_async_call_builtin,
18711	19709	args_ptr, call_instruction->arg_count, ret_ptr, call_instruction->result_loc);
18712		deallocate(args_ptr, call_instruction->arg_count, "IrInstruction *");
	19710	deallocate(args_ptr, call_instruction->arg_count, "IrInstGen *");
18713	19711	return result;
18714	19712	}
18715	19713
18716		static IrInstruction ir_analyze_call_extra(IrAnalyze ira, IrInstruction *source_instr,
18717		IrInstruction pass1_options, IrInstruction pass1_fn_ref, IrInstruction **args_ptr, size_t args_len,
	19714	static IrInstGen ir_analyze_call_extra(IrAnalyze ira, IrInst* source_instr,
	19715	IrInstSrc pass1_options, IrInstSrc pass1_fn_ref, IrInstGen **args_ptr, size_t args_len,
18718	19716	ResultLoc *result_loc)
18719	19717	{
18720		IrInstruction *options = pass1_options->child;
	19718	IrInstGen *options = pass1_options->child;
18721	19719	if (type_is_invalid(options->value->type))
18722		return ira->codegen->invalid_instruction;
	19720	return ira->codegen->invalid_inst_gen;
18723	19721
18724		IrInstruction *fn_ref = pass1_fn_ref->child;
	19722	IrInstGen *fn_ref = pass1_fn_ref->child;
18725	19723	if (type_is_invalid(fn_ref->value->type))
18726		return ira->codegen->invalid_instruction;
	19724	return ira->codegen->invalid_inst_gen;
18727	19725
18728	19726	TypeStructField *modifier_field = find_struct_type_field(options->value->type, buf_create_from_str("modifier"));
18729	19727	ir_assert(modifier_field != nullptr, source_instr);
18730		IrInstruction *modifier_inst = ir_analyze_struct_value_field_value(ira, source_instr, options, modifier_field);
	19728	IrInstGen *modifier_inst = ir_analyze_struct_value_field_value(ira, source_instr, options, modifier_field);
18731	19729	ZigValue *modifier_val = ir_resolve_const(ira, modifier_inst, UndefBad);
18732	19730	if (modifier_val == nullptr)
18733		return ira->codegen->invalid_instruction;
	19731	return ira->codegen->invalid_inst_gen;
18734	19732	CallModifier modifier = (CallModifier)bigint_as_u32(&modifier_val->data.x_enum_tag);
18735	19733
18736		if (ir_should_inline(ira->new_irb.exec, source_instr->scope)) {
	19734	if (ir_should_inline(ira->old_irb.exec, source_instr->scope)) {
18737	19735	switch (modifier) {
18738	19736	case CallModifierBuiltin:
18739	19737	zig_unreachable();
18740	19738	case CallModifierAsync:
18741	19739	ir_add_error(ira, source_instr, buf_sprintf("TODO: comptime @call with async modifier"));
18742		return ira->codegen->invalid_instruction;
	19740	return ira->codegen->invalid_inst_gen;
18743	19741	case CallModifierCompileTime:
18744	19742	case CallModifierNone:
18745	19743	case CallModifierAlwaysInline:
...	...	@@ -18750,15 +19748,15 @@ static IrInstruction ir_analyze_call_extra(IrAnalyze ira, IrInstruction *sourc
18750	19748	case CallModifierNeverInline:
18751	19749	ir_add_error(ira, source_instr,
18752	19750	buf_sprintf("unable to perform 'never_inline' call at compile-time"));
18753		return ira->codegen->invalid_instruction;
	19751	return ira->codegen->invalid_inst_gen;
18754	19752	case CallModifierNeverTail:
18755	19753	ir_add_error(ira, source_instr,
18756	19754	buf_sprintf("unable to perform 'never_tail' call at compile-time"));
18757		return ira->codegen->invalid_instruction;
	19755	return ira->codegen->invalid_inst_gen;
18758	19756	}
18759	19757	}
18760	19758
18761		IrInstruction *first_arg_ptr = nullptr;
	19759	IrInstGen *first_arg_ptr = nullptr;
18762	19760	ZigFn *fn = nullptr;
18763	19761	if (instr_is_comptime(fn_ref)) {
18764	19762	if (fn_ref->value->type->id == ZigTypeIdBoundFn) {
...	...	@@ -18766,7 +19764,7 @@ static IrInstruction ir_analyze_call_extra(IrAnalyze ira, IrInstruction *sourc
18766	19764	fn = fn_ref->value->data.x_bound_fn.fn;
18767	19765	first_arg_ptr = fn_ref->value->data.x_bound_fn.first_arg;
18768	19766	if (type_is_invalid(first_arg_ptr->value->type))
18769		return ira->codegen->invalid_instruction;
	19767	return ira->codegen->invalid_inst_gen;
18770	19768	} else {
18771	19769	fn = ir_resolve_fn(ira, fn_ref);
18772	19770	}
...	...	@@ -18778,9 +19776,9 @@ static IrInstruction ir_analyze_call_extra(IrAnalyze ira, IrInstruction *sourc
18778	19776	case CallModifierAlwaysInline:
18779	19777	case CallModifierAsync:
18780	19778	if (fn == nullptr) {
18781		ir_add_error(ira, modifier_inst,
	19779	ir_add_error(ira, &modifier_inst->base,
18782	19780	buf_sprintf("the specified modifier requires a comptime-known function"));
18783		return ira->codegen->invalid_instruction;
	19781	return ira->codegen->invalid_inst_gen;
18784	19782	}
18785	19783	default:
18786	19784	break;
...	...	@@ -18790,93 +19788,93 @@ static IrInstruction ir_analyze_call_extra(IrAnalyze ira, IrInstruction *sourc
18790	19788
18791	19789	TypeStructField *stack_field = find_struct_type_field(options->value->type, buf_create_from_str("stack"));
18792	19790	ir_assert(stack_field != nullptr, source_instr);
18793		IrInstruction *opt_stack = ir_analyze_struct_value_field_value(ira, source_instr, options, stack_field);
	19791	IrInstGen *opt_stack = ir_analyze_struct_value_field_value(ira, source_instr, options, stack_field);
18794	19792	if (type_is_invalid(opt_stack->value->type))
18795		return ira->codegen->invalid_instruction;
	19793	return ira->codegen->invalid_inst_gen;
18796	19794
18797		IrInstruction *stack_is_non_null_inst = ir_analyze_test_non_null(ira, source_instr, opt_stack);
	19795	IrInstGen *stack_is_non_null_inst = ir_analyze_test_non_null(ira, source_instr, opt_stack);
18798	19796	bool stack_is_non_null;
18799	19797	if (!ir_resolve_bool(ira, stack_is_non_null_inst, &stack_is_non_null))
18800		return ira->codegen->invalid_instruction;
	19798	return ira->codegen->invalid_inst_gen;
18801	19799
18802		IrInstruction *stack = nullptr;
	19800	IrInstGen *stack = nullptr;
18803	19801	if (stack_is_non_null) {
18804	19802	stack = ir_analyze_optional_value_payload_value(ira, source_instr, opt_stack, false);
18805	19803	if (type_is_invalid(stack->value->type))
18806		return ira->codegen->invalid_instruction;
	19804	return ira->codegen->invalid_inst_gen;
18807	19805	}
18808	19806
18809	19807	return ir_analyze_fn_call(ira, source_instr, fn, fn_type, fn_ref, first_arg_ptr,
18810	19808	modifier, stack, false, args_ptr, args_len, nullptr, result_loc);
18811	19809	}
18812	19810
18813		static IrInstruction ir_analyze_instruction_call_extra(IrAnalyze ira, IrInstructionCallExtra *instruction) {
18814		IrInstruction *args = instruction->args->child;
	19811	static IrInstGen ir_analyze_instruction_call_extra(IrAnalyze ira, IrInstSrcCallExtra *instruction) {
	19812	IrInstGen *args = instruction->args->child;
18815	19813	ZigType *args_type = args->value->type;
18816	19814	if (type_is_invalid(args_type))
18817		return ira->codegen->invalid_instruction;
	19815	return ira->codegen->invalid_inst_gen;
18818	19816
18819	19817	if (args_type->id != ZigTypeIdStruct) {
18820		ir_add_error(ira, args,
	19818	ir_add_error(ira, &args->base,
18821	19819	buf_sprintf("expected tuple or struct, found '%s'", buf_ptr(&args_type->name)));
18822		return ira->codegen->invalid_instruction;
	19820	return ira->codegen->invalid_inst_gen;
18823	19821	}
18824	19822
18825		IrInstruction **args_ptr = nullptr;
	19823	IrInstGen **args_ptr = nullptr;
18826	19824	size_t args_len = 0;
18827	19825
18828	19826	if (is_tuple(args_type)) {
18829	19827	args_len = args_type->data.structure.src_field_count;
18830		args_ptr = allocate<IrInstruction >(args_len, "IrInstruction ");
	19828	args_ptr = allocate<IrInstGen >(args_len, "IrInstGen ");
18831	19829	for (size_t i = 0; i < args_len; i += 1) {
18832	19830	TypeStructField *arg_field = args_type->data.structure.fields[i];
18833		args_ptr[i] = ir_analyze_struct_value_field_value(ira, &instruction->base, args, arg_field);
	19831	args_ptr[i] = ir_analyze_struct_value_field_value(ira, &instruction->base.base, args, arg_field);
18834	19832	if (type_is_invalid(args_ptr[i]->value->type))
18835		return ira->codegen->invalid_instruction;
	19833	return ira->codegen->invalid_inst_gen;
18836	19834	}
18837	19835	} else {
18838		ir_add_error(ira, args, buf_sprintf("TODO: struct args"));
18839		return ira->codegen->invalid_instruction;
	19836	ir_add_error(ira, &args->base, buf_sprintf("TODO: struct args"));
	19837	return ira->codegen->invalid_inst_gen;
18840	19838	}
18841		IrInstruction *result = ir_analyze_call_extra(ira, &instruction->base, instruction->options,
	19839	IrInstGen *result = ir_analyze_call_extra(ira, &instruction->base.base, instruction->options,
18842	19840	instruction->fn_ref, args_ptr, args_len, instruction->result_loc);
18843		deallocate(args_ptr, args_len, "IrInstruction *");
	19841	deallocate(args_ptr, args_len, "IrInstGen *");
18844	19842	return result;
18845	19843	}
18846	19844
18847		static IrInstruction ir_analyze_instruction_call_args(IrAnalyze ira, IrInstructionCallSrcArgs *instruction) {
18848		IrInstruction *args_ptr = allocate<IrInstruction >(instruction->args_len, "IrInstruction *");
	19845	static IrInstGen ir_analyze_instruction_call_args(IrAnalyze ira, IrInstSrcCallArgs *instruction) {
	19846	IrInstGen *args_ptr = allocate<IrInstGen >(instruction->args_len, "IrInstGen *");
18849	19847	for (size_t i = 0; i < instruction->args_len; i += 1) {
18850	19848	args_ptr[i] = instruction->args_ptr[i]->child;
18851	19849	if (type_is_invalid(args_ptr[i]->value->type))
18852		return ira->codegen->invalid_instruction;
	19850	return ira->codegen->invalid_inst_gen;
18853	19851	}
18854	19852
18855		IrInstruction *result = ir_analyze_call_extra(ira, &instruction->base, instruction->options,
	19853	IrInstGen *result = ir_analyze_call_extra(ira, &instruction->base.base, instruction->options,
18856	19854	instruction->fn_ref, args_ptr, instruction->args_len, instruction->result_loc);
18857		deallocate(args_ptr, instruction->args_len, "IrInstruction *");
	19855	deallocate(args_ptr, instruction->args_len, "IrInstGen *");
18858	19856	return result;
18859	19857	}
18860	19858
18861		static IrInstruction ir_analyze_instruction_call(IrAnalyze ira, IrInstructionCallSrc *call_instruction) {
18862		IrInstruction *fn_ref = call_instruction->fn_ref->child;
	19859	static IrInstGen ir_analyze_instruction_call(IrAnalyze ira, IrInstSrcCall *call_instruction) {
	19860	IrInstGen *fn_ref = call_instruction->fn_ref->child;
18863	19861	if (type_is_invalid(fn_ref->value->type))
18864		return ira->codegen->invalid_instruction;
	19862	return ira->codegen->invalid_inst_gen;
18865	19863
18866	19864	bool is_comptime = (call_instruction->modifier == CallModifierCompileTime) \|\|
18867		ir_should_inline(ira->new_irb.exec, call_instruction->base.scope);
	19865	ir_should_inline(ira->old_irb.exec, call_instruction->base.base.scope);
18868	19866	CallModifier modifier = is_comptime ? CallModifierCompileTime : call_instruction->modifier;
18869	19867
18870	19868	if (is_comptime \|\| instr_is_comptime(fn_ref)) {
18871	19869	if (fn_ref->value->type->id == ZigTypeIdMetaType) {
18872	19870	ZigType *ty = ir_resolve_type(ira, fn_ref);
18873	19871	if (ty == nullptr)
18874		return ira->codegen->invalid_instruction;
18875		ErrorMsg *msg = ir_add_error_node(ira, fn_ref->source_node,
	19872	return ira->codegen->invalid_inst_gen;
	19873	ErrorMsg *msg = ir_add_error(ira, &fn_ref->base,
18876	19874	buf_sprintf("type '%s' not a function", buf_ptr(&ty->name)));
18877		add_error_note(ira->codegen, msg, call_instruction->base.source_node,
	19875	add_error_note(ira->codegen, msg, call_instruction->base.base.source_node,
18878	19876	buf_sprintf("use @as builtin for type coercion"));
18879		return ira->codegen->invalid_instruction;
	19877	return ira->codegen->invalid_inst_gen;
18880	19878	} else if (fn_ref->value->type->id == ZigTypeIdFn) {
18881	19879	ZigFn *fn_table_entry = ir_resolve_fn(ira, fn_ref);
18882	19880	ZigType *fn_type = fn_table_entry ? fn_table_entry->type_entry : fn_ref->value->type;
...	...	@@ -18886,14 +19884,14 @@ static IrInstruction ir_analyze_instruction_call(IrAnalyze ira, IrInstructionC
18886	19884	} else if (fn_ref->value->type->id == ZigTypeIdBoundFn) {
18887	19885	assert(fn_ref->value->special == ConstValSpecialStatic);
18888	19886	ZigFn *fn_table_entry = fn_ref->value->data.x_bound_fn.fn;
18889		IrInstruction *first_arg_ptr = fn_ref->value->data.x_bound_fn.first_arg;
	19887	IrInstGen *first_arg_ptr = fn_ref->value->data.x_bound_fn.first_arg;
18890	19888	CallModifier modifier = is_comptime ? CallModifierCompileTime : call_instruction->modifier;
18891	19889	return ir_analyze_fn_call_src(ira, call_instruction, fn_table_entry, fn_table_entry->type_entry,
18892	19890	fn_ref, first_arg_ptr, modifier);
18893	19891	} else {
18894		ir_add_error_node(ira, fn_ref->source_node,
	19892	ir_add_error(ira, &fn_ref->base,
18895	19893	buf_sprintf("type '%s' not a function", buf_ptr(&fn_ref->value->type->name)));
18896		return ira->codegen->invalid_instruction;
	19894	return ira->codegen->invalid_inst_gen;
18897	19895	}
18898	19896	}
18899	19897
...	...	@@ -18901,9 +19899,9 @@ static IrInstruction ir_analyze_instruction_call(IrAnalyze ira, IrInstructionC
18901	19899	return ir_analyze_fn_call_src(ira, call_instruction, nullptr, fn_ref->value->type,
18902	19900	fn_ref, nullptr, modifier);
18903	19901	} else {
18904		ir_add_error_node(ira, fn_ref->source_node,
	19902	ir_add_error(ira, &fn_ref->base,
18905	19903	buf_sprintf("type '%s' not a function", buf_ptr(&fn_ref->value->type->name)));
18906		return ira->codegen->invalid_instruction;
	19904	return ira->codegen->invalid_inst_gen;
18907	19905	}
18908	19906	}
18909	19907
...	...	@@ -18992,8 +19990,8 @@ static Error ir_read_const_ptr(IrAnalyze ira, CodeGen codegen, AstNode *source
18992	19990	zig_unreachable();
18993	19991	}
18994	19992
18995		static IrInstruction ir_analyze_optional_type(IrAnalyze ira, IrInstructionUnOp *instruction) {
18996		IrInstruction *result = ir_const(ira, &instruction->base, ira->codegen->builtin_types.entry_type);
	19993	static IrInstGen ir_analyze_optional_type(IrAnalyze ira, IrInstSrcUnOp *instruction) {
	19994	IrInstGen *result = ir_const(ira, &instruction->base.base, ira->codegen->builtin_types.entry_type);
18997	19995	result->value->special = ConstValSpecialLazy;
18998	19996
18999	19997	LazyValueOptType *lazy_opt_type = allocate<LazyValueOptType>(1, "LazyValueOptType");
...	...	@@ -19003,12 +20001,12 @@ static IrInstruction ir_analyze_optional_type(IrAnalyze ira, IrInstructionUnOp
19003	20001
19004	20002	lazy_opt_type->payload_type = instruction->value->child;
19005	20003	if (ir_resolve_type_lazy(ira, lazy_opt_type->payload_type) == nullptr)
19006		return ira->codegen->invalid_instruction;
	20004	return ira->codegen->invalid_inst_gen;
19007	20005
19008	20006	return result;
19009	20007	}
19010	20008
19011		static ErrorMsg ir_eval_negation_scalar(IrAnalyze ira, IrInstruction source_instr, ZigType scalar_type,
	20009	static ErrorMsg ir_eval_negation_scalar(IrAnalyze ira, IrInst* source_instr, ZigType *scalar_type,
19012	20010	ZigValue operand_val, ZigValue scalar_out_val, bool is_wrap_op)
19013	20011	{
19014	20012	bool is_float = (scalar_type->id == ZigTypeIdFloat \|\| scalar_type->id == ZigTypeIdComptimeFloat);
...	...	@@ -19043,19 +20041,19 @@ static ErrorMsg ir_eval_negation_scalar(IrAnalyze ira, IrInstruction *source_i
19043	20041	return nullptr;
19044	20042	}
19045	20043
19046		static IrInstruction ir_analyze_negation(IrAnalyze ira, IrInstructionUnOp *instruction) {
19047		IrInstruction *value = instruction->value->child;
	20044	static IrInstGen ir_analyze_negation(IrAnalyze ira, IrInstSrcUnOp *instruction) {
	20045	IrInstGen *value = instruction->value->child;
19048	20046	ZigType *expr_type = value->value->type;
19049	20047	if (type_is_invalid(expr_type))
19050		return ira->codegen->invalid_instruction;
	20048	return ira->codegen->invalid_inst_gen;
19051	20049
19052	20050	if (!(expr_type->id == ZigTypeIdInt \|\| expr_type->id == ZigTypeIdComptimeInt \|\|
19053	20051	expr_type->id == ZigTypeIdFloat \|\| expr_type->id == ZigTypeIdComptimeFloat \|\|
19054	20052	expr_type->id == ZigTypeIdVector))
19055	20053	{
19056		ir_add_error(ira, &instruction->base,
	20054	ir_add_error(ira, &instruction->base.base,
19057	20055	buf_sprintf("negation of type '%s'", buf_ptr(&expr_type->name)));
19058		return ira->codegen->invalid_instruction;
	20056	return ira->codegen->invalid_inst_gen;
19059	20057	}
19060	20058
19061	20059	bool is_wrap_op = (instruction->op_id == IrUnOpNegationWrap);
...	...	@@ -19065,9 +20063,9 @@ static IrInstruction ir_analyze_negation(IrAnalyze ira, IrInstructionUnOp *ins
19065	20063	if (instr_is_comptime(value)) {
19066	20064	ZigValue *operand_val = ir_resolve_const(ira, value, UndefBad);
19067	20065	if (!operand_val)
19068		return ira->codegen->invalid_instruction;
	20066	return ira->codegen->invalid_inst_gen;
19069	20067
19070		IrInstruction *result_instruction = ir_const(ira, &instruction->base, expr_type);
	20068	IrInstGen *result_instruction = ir_const(ira, &instruction->base.base, expr_type);
19071	20069	ZigValue *out_val = result_instruction->value;
19072	20070	if (expr_type->id == ZigTypeIdVector) {
19073	20071	expand_undef_array(ira->codegen, operand_val);
...	...	@@ -19079,63 +20077,60 @@ static IrInstruction ir_analyze_negation(IrAnalyze ira, IrInstructionUnOp *ins
19079	20077	ZigValue *scalar_out_val = &out_val->data.x_array.data.s_none.elements[i];
19080	20078	assert(scalar_operand_val->type == scalar_type);
19081	20079	assert(scalar_out_val->type == scalar_type);
19082		ErrorMsg *msg = ir_eval_negation_scalar(ira, &instruction->base, scalar_type,
	20080	ErrorMsg *msg = ir_eval_negation_scalar(ira, &instruction->base.base, scalar_type,
19083	20081	scalar_operand_val, scalar_out_val, is_wrap_op);
19084	20082	if (msg != nullptr) {
19085		add_error_note(ira->codegen, msg, instruction->base.source_node,
	20083	add_error_note(ira->codegen, msg, instruction->base.base.source_node,
19086	20084	buf_sprintf("when computing vector element at index %" ZIG_PRI_usize, i));
19087		return ira->codegen->invalid_instruction;
	20085	return ira->codegen->invalid_inst_gen;
19088	20086	}
19089	20087	}
19090	20088	out_val->type = expr_type;
19091	20089	out_val->special = ConstValSpecialStatic;
19092	20090	} else {
19093		if (ir_eval_negation_scalar(ira, &instruction->base, scalar_type, operand_val, out_val,
	20091	if (ir_eval_negation_scalar(ira, &instruction->base.base, scalar_type, operand_val, out_val,
19094	20092	is_wrap_op) != nullptr)
19095	20093	{
19096		return ira->codegen->invalid_instruction;
	20094	return ira->codegen->invalid_inst_gen;
19097	20095	}
19098	20096	}
19099	20097	return result_instruction;
19100	20098	}
19101	20099
19102		IrInstruction *result = ir_build_un_op(&ira->new_irb,
19103		instruction->base.scope, instruction->base.source_node,
19104		instruction->op_id, value);
19105		result->value->type = expr_type;
19106		return result;
	20100	if (is_wrap_op) {
	20101	return ir_build_negation_wrapping(ira, &instruction->base.base, value, expr_type);
	20102	} else {
	20103	return ir_build_negation(ira, &instruction->base.base, value, expr_type);
	20104	}
19107	20105	}
19108	20106
19109		static IrInstruction ir_analyze_bin_not(IrAnalyze ira, IrInstructionUnOp *instruction) {
19110		IrInstruction *value = instruction->value->child;
	20107	static IrInstGen ir_analyze_bin_not(IrAnalyze ira, IrInstSrcUnOp *instruction) {
	20108	IrInstGen *value = instruction->value->child;
19111	20109	ZigType *expr_type = value->value->type;
19112	20110	if (type_is_invalid(expr_type))
19113		return ira->codegen->invalid_instruction;
	20111	return ira->codegen->invalid_inst_gen;
19114	20112
19115	20113	if (expr_type->id == ZigTypeIdInt) {
19116	20114	if (instr_is_comptime(value)) {
19117	20115	ZigValue *target_const_val = ir_resolve_const(ira, value, UndefBad);
19118	20116	if (target_const_val == nullptr)
19119		return ira->codegen->invalid_instruction;
	20117	return ira->codegen->invalid_inst_gen;
19120	20118
19121		IrInstruction *result = ir_const(ira, &instruction->base, expr_type);
	20119	IrInstGen *result = ir_const(ira, &instruction->base.base, expr_type);
19122	20120	bigint_not(&result->value->data.x_bigint, &target_const_val->data.x_bigint,
19123	20121	expr_type->data.integral.bit_count, expr_type->data.integral.is_signed);
19124	20122	return result;
19125	20123	}
19126	20124
19127		IrInstruction *result = ir_build_un_op(&ira->new_irb, instruction->base.scope,
19128		instruction->base.source_node, IrUnOpBinNot, value);
19129		result->value->type = expr_type;
19130		return result;
	20125	return ir_build_binary_not(ira, &instruction->base.base, value, expr_type);
19131	20126	}
19132	20127
19133		ir_add_error(ira, &instruction->base,
	20128	ir_add_error(ira, &instruction->base.base,
19134	20129	buf_sprintf("unable to perform binary not operation on type '%s'", buf_ptr(&expr_type->name)));
19135		return ira->codegen->invalid_instruction;
	20130	return ira->codegen->invalid_inst_gen;
19136	20131	}
19137	20132
19138		static IrInstruction ir_analyze_instruction_un_op(IrAnalyze ira, IrInstructionUnOp *instruction) {
	20133	static IrInstGen ir_analyze_instruction_un_op(IrAnalyze ira, IrInstSrcUnOp *instruction) {
19139	20134	IrUnOp op_id = instruction->op_id;
19140	20135	switch (op_id) {
19141	20136	case IrUnOpInvalid:
...	...	@@ -19146,26 +20141,26 @@ static IrInstruction ir_analyze_instruction_un_op(IrAnalyze ira, IrInstruction
19146	20141	case IrUnOpNegationWrap:
19147	20142	return ir_analyze_negation(ira, instruction);
19148	20143	case IrUnOpDereference: {
19149		IrInstruction *ptr = instruction->value->child;
	20144	IrInstGen *ptr = instruction->value->child;
19150	20145	if (type_is_invalid(ptr->value->type))
19151		return ira->codegen->invalid_instruction;
	20146	return ira->codegen->invalid_inst_gen;
19152	20147	ZigType *ptr_type = ptr->value->type;
19153	20148	if (ptr_type->id == ZigTypeIdPointer && ptr_type->data.pointer.ptr_len == PtrLenUnknown) {
19154		ir_add_error_node(ira, instruction->base.source_node,
	20149	ir_add_error_node(ira, instruction->base.base.source_node,
19155	20150	buf_sprintf("index syntax required for unknown-length pointer type '%s'",
19156	20151	buf_ptr(&ptr_type->name)));
19157		return ira->codegen->invalid_instruction;
	20152	return ira->codegen->invalid_inst_gen;
19158	20153	}
19159	20154
19160		IrInstruction *result = ir_get_deref(ira, &instruction->base, ptr, instruction->result_loc);
19161		if (result == ira->codegen->invalid_instruction)
19162		return ira->codegen->invalid_instruction;
	20155	IrInstGen *result = ir_get_deref(ira, &instruction->base.base, ptr, instruction->result_loc);
	20156	if (type_is_invalid(result->value->type))
	20157	return ira->codegen->invalid_inst_gen;
19163	20158
19164	20159	// If the result needs to be an lvalue, type check it
19165	20160	if (instruction->lval == LValPtr && result->value->type->id != ZigTypeIdPointer) {
19166		ir_add_error(ira, &instruction->base,
	20161	ir_add_error(ira, &instruction->base.base,
19167	20162	buf_sprintf("attempt to dereference non-pointer type '%s'", buf_ptr(&result->value->type->name)));
19168		return ira->codegen->invalid_instruction;
	20163	return ira->codegen->invalid_inst_gen;
19169	20164	}
19170	20165
19171	20166	return result;
...	...	@@ -19177,42 +20172,40 @@ static IrInstruction ir_analyze_instruction_un_op(IrAnalyze ira, IrInstruction
19177	20172	}
19178	20173
19179	20174	static void ir_push_resume(IrAnalyze *ira, IrSuspendPosition pos) {
19180		IrBasicBlock *old_bb = ira->old_irb.exec->basic_block_list.at(pos.basic_block_index);
	20175	IrBasicBlockSrc *old_bb = ira->old_irb.exec->basic_block_list.at(pos.basic_block_index);
19181	20176	if (old_bb->in_resume_stack) return;
19182	20177	ira->resume_stack.append(pos);
19183	20178	old_bb->in_resume_stack = true;
19184	20179	}
19185	20180
19186		static void ir_push_resume_block(IrAnalyze ira, IrBasicBlock old_bb) {
	20181	static void ir_push_resume_block(IrAnalyze ira, IrBasicBlockSrc old_bb) {
19187	20182	if (ira->resume_stack.length != 0) {
19188	20183	ir_push_resume(ira, {old_bb->index, 0});
19189	20184	}
19190	20185	}
19191	20186
19192		static IrInstruction ir_analyze_instruction_br(IrAnalyze ira, IrInstructionBr *br_instruction) {
19193		IrBasicBlock *old_dest_block = br_instruction->dest_block;
	20187	static IrInstGen ir_analyze_instruction_br(IrAnalyze ira, IrInstSrcBr *br_instruction) {
	20188	IrBasicBlockSrc *old_dest_block = br_instruction->dest_block;
19194	20189
19195	20190	bool is_comptime;
19196	20191	if (!ir_resolve_comptime(ira, br_instruction->is_comptime->child, &is_comptime))
19197	20192	return ir_unreach_error(ira);
19198	20193
19199	20194	if (is_comptime \|\| (old_dest_block->ref_count == 1 && old_dest_block->suspend_instruction_ref == nullptr))
19200		return ir_inline_bb(ira, &br_instruction->base, old_dest_block);
	20195	return ir_inline_bb(ira, &br_instruction->base.base, old_dest_block);
19201	20196
19202		IrBasicBlock *new_bb = ir_get_new_bb_runtime(ira, old_dest_block, &br_instruction->base);
	20197	IrBasicBlockGen *new_bb = ir_get_new_bb_runtime(ira, old_dest_block, &br_instruction->base.base);
19203	20198	if (new_bb == nullptr)
19204	20199	return ir_unreach_error(ira);
19205	20200
19206	20201	ir_push_resume_block(ira, old_dest_block);
19207	20202
19208		IrInstruction *result = ir_build_br(&ira->new_irb,
19209		br_instruction->base.scope, br_instruction->base.source_node, new_bb, nullptr);
19210		result->value->type = ira->codegen->builtin_types.entry_unreachable;
	20203	IrInstGen *result = ir_build_br_gen(ira, &br_instruction->base.base, new_bb);
19211	20204	return ir_finish_anal(ira, result);
19212	20205	}
19213	20206
19214		static IrInstruction ir_analyze_instruction_cond_br(IrAnalyze ira, IrInstructionCondBr *cond_br_instruction) {
19215		IrInstruction *condition = cond_br_instruction->condition->child;
	20207	static IrInstGen ir_analyze_instruction_cond_br(IrAnalyze ira, IrInstSrcCondBr *cond_br_instruction) {
	20208	IrInstGen *condition = cond_br_instruction->condition->child;
19216	20209	if (type_is_invalid(condition->value->type))
19217	20210	return ir_unreach_error(ira);
19218	20211
...	...	@@ -19221,7 +20214,7 @@ static IrInstruction ir_analyze_instruction_cond_br(IrAnalyze ira, IrInstructi
19221	20214	return ir_unreach_error(ira);
19222	20215
19223	20216	ZigType *bool_type = ira->codegen->builtin_types.entry_bool;
19224		IrInstruction *casted_condition = ir_implicit_cast(ira, condition, bool_type);
	20217	IrInstGen *casted_condition = ir_implicit_cast(ira, condition, bool_type);
19225	20218	if (type_is_invalid(casted_condition->value->type))
19226	20219	return ir_unreach_error(ira);
19227	20220
...	...	@@ -19230,67 +20223,61 @@ static IrInstruction ir_analyze_instruction_cond_br(IrAnalyze ira, IrInstructi
19230	20223	if (!ir_resolve_bool(ira, casted_condition, &cond_is_true))
19231	20224	return ir_unreach_error(ira);
19232	20225
19233		IrBasicBlock *old_dest_block = cond_is_true ?
	20226	IrBasicBlockSrc *old_dest_block = cond_is_true ?
19234	20227	cond_br_instruction->then_block : cond_br_instruction->else_block;
19235	20228
19236	20229	if (is_comptime \|\| (old_dest_block->ref_count == 1 && old_dest_block->suspend_instruction_ref == nullptr))
19237		return ir_inline_bb(ira, &cond_br_instruction->base, old_dest_block);
	20230	return ir_inline_bb(ira, &cond_br_instruction->base.base, old_dest_block);
19238	20231
19239		IrBasicBlock *new_dest_block = ir_get_new_bb_runtime(ira, old_dest_block, &cond_br_instruction->base);
	20232	IrBasicBlockGen *new_dest_block = ir_get_new_bb_runtime(ira, old_dest_block, &cond_br_instruction->base.base);
19240	20233	if (new_dest_block == nullptr)
19241	20234	return ir_unreach_error(ira);
19242	20235
19243	20236	ir_push_resume_block(ira, old_dest_block);
19244	20237
19245		IrInstruction *result = ir_build_br(&ira->new_irb,
19246		cond_br_instruction->base.scope, cond_br_instruction->base.source_node, new_dest_block, nullptr);
19247		result->value->type = ira->codegen->builtin_types.entry_unreachable;
	20238	IrInstGen *result = ir_build_br_gen(ira, &cond_br_instruction->base.base, new_dest_block);
19248	20239	return ir_finish_anal(ira, result);
19249	20240	}
19250	20241
19251	20242	assert(cond_br_instruction->then_block != cond_br_instruction->else_block);
19252		IrBasicBlock *new_then_block = ir_get_new_bb_runtime(ira, cond_br_instruction->then_block, &cond_br_instruction->base);
	20243	IrBasicBlockGen *new_then_block = ir_get_new_bb_runtime(ira, cond_br_instruction->then_block, &cond_br_instruction->base.base);
19253	20244	if (new_then_block == nullptr)
19254	20245	return ir_unreach_error(ira);
19255	20246
19256		IrBasicBlock *new_else_block = ir_get_new_bb_runtime(ira, cond_br_instruction->else_block, &cond_br_instruction->base);
	20247	IrBasicBlockGen *new_else_block = ir_get_new_bb_runtime(ira, cond_br_instruction->else_block, &cond_br_instruction->base.base);
19257	20248	if (new_else_block == nullptr)
19258	20249	return ir_unreach_error(ira);
19259	20250
19260	20251	ir_push_resume_block(ira, cond_br_instruction->else_block);
19261	20252	ir_push_resume_block(ira, cond_br_instruction->then_block);
19262	20253
19263		IrInstruction *result = ir_build_cond_br(&ira->new_irb,
19264		cond_br_instruction->base.scope, cond_br_instruction->base.source_node,
19265		casted_condition, new_then_block, new_else_block, nullptr);
19266		result->value->type = ira->codegen->builtin_types.entry_unreachable;
	20254	IrInstGen *result = ir_build_cond_br_gen(ira, &cond_br_instruction->base.base,
	20255	casted_condition, new_then_block, new_else_block);
19267	20256	return ir_finish_anal(ira, result);
19268	20257	}
19269	20258
19270		static IrInstruction ir_analyze_instruction_unreachable(IrAnalyze ira,
19271		IrInstructionUnreachable *unreachable_instruction)
	20259	static IrInstGen ir_analyze_instruction_unreachable(IrAnalyze ira,
	20260	IrInstSrcUnreachable *unreachable_instruction)
19272	20261	{
19273		IrInstruction *result = ir_build_unreachable(&ira->new_irb,
19274		unreachable_instruction->base.scope, unreachable_instruction->base.source_node);
19275		result->value->type = ira->codegen->builtin_types.entry_unreachable;
	20262	IrInstGen *result = ir_build_unreachable_gen(ira, &unreachable_instruction->base.base);
19276	20263	return ir_finish_anal(ira, result);
19277	20264	}
19278	20265
19279		static IrInstruction ir_analyze_instruction_phi(IrAnalyze ira, IrInstructionPhi *phi_instruction) {
	20266	static IrInstGen ir_analyze_instruction_phi(IrAnalyze ira, IrInstSrcPhi *phi_instruction) {
19280	20267	Error err;
19281	20268
19282	20269	if (ira->const_predecessor_bb) {
19283	20270	for (size_t i = 0; i < phi_instruction->incoming_count; i += 1) {
19284		IrBasicBlock *predecessor = phi_instruction->incoming_blocks[i];
	20271	IrBasicBlockSrc *predecessor = phi_instruction->incoming_blocks[i];
19285	20272	if (predecessor != ira->const_predecessor_bb)
19286	20273	continue;
19287		IrInstruction *value = phi_instruction->incoming_values[i]->child;
	20274	IrInstGen *value = phi_instruction->incoming_values[i]->child;
19288	20275	assert(value->value->type);
19289	20276	if (type_is_invalid(value->value->type))
19290		return ira->codegen->invalid_instruction;
	20277	return ira->codegen->invalid_inst_gen;
19291	20278
19292	20279	if (value->value->special != ConstValSpecialRuntime) {
19293		IrInstruction *result = ir_const(ira, &phi_instruction->base, nullptr);
	20280	IrInstGen *result = ir_const(ira, &phi_instruction->base.base, nullptr);
19294	20281	copy_const_val(result->value, value->value);
19295	20282	return result;
19296	20283	} else {
...	...	@@ -19305,17 +20292,17 @@ static IrInstruction ir_analyze_instruction_phi(IrAnalyze ira, IrInstructionPh
19305	20292	peer_parent->peers.length >= 2)
19306	20293	{
19307	20294	if (peer_parent->resolved_type == nullptr) {
19308		IrInstruction *instructions = allocate<IrInstruction >(peer_parent->peers.length);
	20295	IrInstGen *instructions = allocate<IrInstGen >(peer_parent->peers.length);
19309	20296	for (size_t i = 0; i < peer_parent->peers.length; i += 1) {
19310	20297	ResultLocPeer *this_peer = peer_parent->peers.at(i);
19311	20298
19312		IrInstruction *gen_instruction = this_peer->base.gen_instruction;
	20299	IrInstGen *gen_instruction = this_peer->base.gen_instruction;
19313	20300	if (gen_instruction == nullptr) {
19314	20301	// unreachable instructions will cause implicit_elem_type to be null
19315	20302	if (this_peer->base.implicit_elem_type == nullptr) {
19316		instructions[i] = ir_const_unreachable(ira, this_peer->base.source_instruction);
	20303	instructions[i] = ir_const_unreachable(ira, &this_peer->base.source_instruction->base);
19317	20304	} else {
19318		instructions[i] = ir_const(ira, this_peer->base.source_instruction,
	20305	instructions[i] = ir_const(ira, &this_peer->base.source_instruction->base,
19319	20306	this_peer->base.implicit_elem_type);
19320	20307	instructions[i]->value->special = ConstValSpecialRuntime;
19321	20308	}
...	...	@@ -19324,34 +20311,34 @@ static IrInstruction ir_analyze_instruction_phi(IrAnalyze ira, IrInstructionPh
19324	20311	}
19325	20312
19326	20313	}
19327		ZigType *expected_type = ir_result_loc_expected_type(ira, &phi_instruction->base, peer_parent->parent);
	20314	ZigType *expected_type = ir_result_loc_expected_type(ira, &phi_instruction->base.base, peer_parent->parent);
19328	20315	peer_parent->resolved_type = ir_resolve_peer_types(ira,
19329		peer_parent->base.source_instruction->source_node, expected_type, instructions,
	20316	peer_parent->base.source_instruction->base.source_node, expected_type, instructions,
19330	20317	peer_parent->peers.length);
19331	20318	if (type_is_invalid(peer_parent->resolved_type))
19332		return ira->codegen->invalid_instruction;
	20319	return ira->codegen->invalid_inst_gen;
19333	20320
19334	20321	// the logic below assumes there are no instructions in the new current basic block yet
19335		ir_assert(ira->new_irb.current_basic_block->instruction_list.length == 0, &phi_instruction->base);
	20322	ir_assert(ira->new_irb.current_basic_block->instruction_list.length == 0, &phi_instruction->base.base);
19336	20323
19337	20324	// In case resolving the parent activates a suspend, do it now
19338		IrInstruction *parent_result_loc = ir_resolve_result(ira, &phi_instruction->base, peer_parent->parent,
	20325	IrInstGen *parent_result_loc = ir_resolve_result(ira, &phi_instruction->base.base, peer_parent->parent,
19339	20326	peer_parent->resolved_type, nullptr, false, false, true);
19340	20327	if (parent_result_loc != nullptr &&
19341		(type_is_invalid(parent_result_loc->value->type) \|\| instr_is_unreachable(parent_result_loc)))
	20328	(type_is_invalid(parent_result_loc->value->type) \|\| parent_result_loc->value->type->id == ZigTypeIdUnreachable))
19342	20329	{
19343	20330	return parent_result_loc;
19344	20331	}
19345	20332	// If the above code generated any instructions in the current basic block, we need
19346	20333	// to move them to the peer parent predecessor.
19347		ZigList<IrInstruction *> instrs_to_move = {};
	20334	ZigList<IrInstGen *> instrs_to_move = {};
19348	20335	while (ira->new_irb.current_basic_block->instruction_list.length != 0) {
19349	20336	instrs_to_move.append(ira->new_irb.current_basic_block->instruction_list.pop());
19350	20337	}
19351	20338	if (instrs_to_move.length != 0) {
19352		IrBasicBlock *predecessor = peer_parent->base.source_instruction->child->owner_bb;
19353		IrInstruction *branch_instruction = predecessor->instruction_list.pop();
19354		ir_assert(branch_instruction->value->type->id == ZigTypeIdUnreachable, &phi_instruction->base);
	20339	IrBasicBlockGen *predecessor = peer_parent->base.source_instruction->child->owner_bb;
	20340	IrInstGen *branch_instruction = predecessor->instruction_list.pop();
	20341	ir_assert(branch_instruction->value->type->id == ZigTypeIdUnreachable, &phi_instruction->base.base);
19355	20342	while (instrs_to_move.length != 0) {
19356	20343	predecessor->instruction_list.append(instrs_to_move.pop());
19357	20344	}
...	...	@@ -19360,7 +20347,7 @@ static IrInstruction ir_analyze_instruction_phi(IrAnalyze ira, IrInstructionPh
19360	20347	}
19361	20348
19362	20349	IrSuspendPosition suspend_pos;
19363		ira_suspend(ira, &phi_instruction->base, nullptr, &suspend_pos);
	20350	ira_suspend(ira, &phi_instruction->base.base, nullptr, &suspend_pos);
19364	20351	ir_push_resume(ira, suspend_pos);
19365	20352
19366	20353	for (size_t i = 0; i < peer_parent->peers.length; i += 1) {
...	...	@@ -19376,34 +20363,32 @@ static IrInstruction ir_analyze_instruction_phi(IrAnalyze ira, IrInstructionPh
19376	20363	return ira_resume(ira);
19377	20364	}
19378	20365
19379		ZigList<IrBasicBlock*> new_incoming_blocks = {0};
19380		ZigList<IrInstruction*> new_incoming_values = {0};
	20366	ZigList<IrBasicBlockGen*> new_incoming_blocks = {0};
	20367	ZigList<IrInstGen*> new_incoming_values = {0};
19381	20368
19382	20369	for (size_t i = 0; i < phi_instruction->incoming_count; i += 1) {
19383		IrBasicBlock *predecessor = phi_instruction->incoming_blocks[i];
	20370	IrBasicBlockSrc *predecessor = phi_instruction->incoming_blocks[i];
19384	20371	if (predecessor->ref_count == 0)
19385	20372	continue;
19386	20373
19387	20374
19388		IrInstruction *old_value = phi_instruction->incoming_values[i];
	20375	IrInstSrc *old_value = phi_instruction->incoming_values[i];
19389	20376	assert(old_value);
19390		IrInstruction *new_value = old_value->child;
19391		if (!new_value \|\| new_value->value->type->id == ZigTypeIdUnreachable \|\| predecessor->other == nullptr)
	20377	IrInstGen *new_value = old_value->child;
	20378	if (!new_value \|\| new_value->value->type->id == ZigTypeIdUnreachable \|\| predecessor->child == nullptr)
19392	20379	continue;
19393	20380
19394	20381	if (type_is_invalid(new_value->value->type))
19395		return ira->codegen->invalid_instruction;
	20382	return ira->codegen->invalid_inst_gen;
19396	20383
19397	20384
19398		assert(predecessor->other);
19399		new_incoming_blocks.append(predecessor->other);
	20385	assert(predecessor->child);
	20386	new_incoming_blocks.append(predecessor->child);
19400	20387	new_incoming_values.append(new_value);
19401	20388	}
19402	20389
19403	20390	if (new_incoming_blocks.length == 0) {
19404		IrInstruction *result = ir_build_unreachable(&ira->new_irb,
19405		phi_instruction->base.scope, phi_instruction->base.source_node);
19406		result->value->type = ira->codegen->builtin_types.entry_unreachable;
	20391	IrInstGen *result = ir_build_unreachable_gen(ira, &phi_instruction->base.base);
19407	20392	return ir_finish_anal(ira, result);
19408	20393	}
19409	20394
...	...	@@ -19415,7 +20400,7 @@ static IrInstruction ir_analyze_instruction_phi(IrAnalyze ira, IrInstructionPh
19415	20400	if (peer_parent != nullptr) {
19416	20401	bool peer_parent_has_type;
19417	20402	if ((err = ir_result_has_type(ira, peer_parent->parent, &peer_parent_has_type)))
19418		return ira->codegen->invalid_instruction;
	20403	return ira->codegen->invalid_inst_gen;
19419	20404	if (peer_parent_has_type) {
19420	20405	if (peer_parent->parent->id == ResultLocIdReturn) {
19421	20406	resolved_type = ira->explicit_return_type;
...	...	@@ -19423,27 +20408,27 @@ static IrInstruction ir_analyze_instruction_phi(IrAnalyze ira, IrInstructionPh
19423	20408	resolved_type = ir_resolve_type(ira, peer_parent->parent->source_instruction->child);
19424	20409	} else if (peer_parent->parent->resolved_loc) {
19425	20410	ZigType *resolved_loc_ptr_type = peer_parent->parent->resolved_loc->value->type;
19426		ir_assert(resolved_loc_ptr_type->id == ZigTypeIdPointer, &phi_instruction->base);
	20411	ir_assert(resolved_loc_ptr_type->id == ZigTypeIdPointer, &phi_instruction->base.base);
19427	20412	resolved_type = resolved_loc_ptr_type->data.pointer.child_type;
19428	20413	}
19429	20414
19430	20415	if (resolved_type != nullptr && type_is_invalid(resolved_type))
19431		return ira->codegen->invalid_instruction;
	20416	return ira->codegen->invalid_inst_gen;
19432	20417	}
19433	20418	}
19434	20419
19435	20420	if (resolved_type == nullptr) {
19436		resolved_type = ir_resolve_peer_types(ira, phi_instruction->base.source_node, nullptr,
	20421	resolved_type = ir_resolve_peer_types(ira, phi_instruction->base.base.source_node, nullptr,
19437	20422	new_incoming_values.items, new_incoming_values.length);
19438	20423	if (type_is_invalid(resolved_type))
19439		return ira->codegen->invalid_instruction;
	20424	return ira->codegen->invalid_inst_gen;
19440	20425	}
19441	20426
19442	20427	switch (type_has_one_possible_value(ira->codegen, resolved_type)) {
19443	20428	case OnePossibleValueInvalid:
19444		return ira->codegen->invalid_instruction;
	20429	return ira->codegen->invalid_inst_gen;
19445	20430	case OnePossibleValueYes:
19446		return ir_const_move(ira, &phi_instruction->base,
	20431	return ir_const_move(ira, &phi_instruction->base.base,
19447	20432	get_the_one_possible_value(ira->codegen, resolved_type));
19448	20433	case OnePossibleValueNo:
19449	20434	break;
...	...	@@ -19451,11 +20436,11 @@ static IrInstruction ir_analyze_instruction_phi(IrAnalyze ira, IrInstructionPh
19451	20436
19452	20437	switch (type_requires_comptime(ira->codegen, resolved_type)) {
19453	20438	case ReqCompTimeInvalid:
19454		return ira->codegen->invalid_instruction;
	20439	return ira->codegen->invalid_inst_gen;
19455	20440	case ReqCompTimeYes:
19456		ir_add_error_node(ira, phi_instruction->base.source_node,
	20441	ir_add_error(ira, &phi_instruction->base.base,
19457	20442	buf_sprintf("values of type '%s' must be comptime known", buf_ptr(&resolved_type->name)));
19458		return ira->codegen->invalid_instruction;
	20443	return ira->codegen->invalid_inst_gen;
19459	20444	case ReqCompTimeNo:
19460	20445	break;
19461	20446	}
...	...	@@ -19465,16 +20450,16 @@ static IrInstruction ir_analyze_instruction_phi(IrAnalyze ira, IrInstructionPh
19465	20450	// cast all values to the resolved type. however we can't put cast instructions in front of the phi instruction.
19466	20451	// so we go back and insert the casts as the last instruction in the corresponding predecessor blocks, and
19467	20452	// then make sure the branch instruction is preserved.
19468		IrBasicBlock *cur_bb = ira->new_irb.current_basic_block;
	20453	IrBasicBlockGen *cur_bb = ira->new_irb.current_basic_block;
19469	20454	for (size_t i = 0; i < new_incoming_values.length; i += 1) {
19470		IrInstruction *new_value = new_incoming_values.at(i);
19471		IrBasicBlock *predecessor = new_incoming_blocks.at(i);
19472		ir_assert(predecessor->instruction_list.length != 0, &phi_instruction->base);
19473		IrInstruction *branch_instruction = predecessor->instruction_list.pop();
19474		ir_set_cursor_at_end(&ira->new_irb, predecessor);
19475		IrInstruction *casted_value = ir_implicit_cast(ira, new_value, resolved_type);
	20455	IrInstGen *new_value = new_incoming_values.at(i);
	20456	IrBasicBlockGen *predecessor = new_incoming_blocks.at(i);
	20457	ir_assert(predecessor->instruction_list.length != 0, &phi_instruction->base.base);
	20458	IrInstGen *branch_instruction = predecessor->instruction_list.pop();
	20459	ir_set_cursor_at_end_gen(&ira->new_irb, predecessor);
	20460	IrInstGen *casted_value = ir_implicit_cast(ira, new_value, resolved_type);
19476	20461	if (type_is_invalid(casted_value->value->type)) {
19477		return ira->codegen->invalid_instruction;
	20462	return ira->codegen->invalid_inst_gen;
19478	20463	}
19479	20464	new_incoming_values.items[i] = casted_value;
19480	20465	predecessor->instruction_list.append(branch_instruction);
...	...	@@ -19485,12 +20470,10 @@ static IrInstruction ir_analyze_instruction_phi(IrAnalyze ira, IrInstructionPh
19485	20470	all_stack_ptrs = false;
19486	20471	}
19487	20472	}
19488		ir_set_cursor_at_end(&ira->new_irb, cur_bb);
	20473	ir_set_cursor_at_end_gen(&ira->new_irb, cur_bb);
19489	20474
19490		IrInstruction *result = ir_build_phi(&ira->new_irb,
19491		phi_instruction->base.scope, phi_instruction->base.source_node,
19492		new_incoming_blocks.length, new_incoming_blocks.items, new_incoming_values.items, nullptr);
19493		result->value->type = resolved_type;
	20475	IrInstGen *result = ir_build_phi_gen(ira, &phi_instruction->base.base,
	20476	new_incoming_blocks.length, new_incoming_blocks.items, new_incoming_values.items, resolved_type);
19494	20477
19495	20478	if (all_stack_ptrs) {
19496	20479	assert(result->value->special == ConstValSpecialRuntime);
...	...	@@ -19500,17 +20483,17 @@ static IrInstruction ir_analyze_instruction_phi(IrAnalyze ira, IrInstructionPh
19500	20483	return result;
19501	20484	}
19502	20485
19503		static IrInstruction ir_analyze_instruction_var_ptr(IrAnalyze ira, IrInstructionVarPtr *instruction) {
	20486	static IrInstGen ir_analyze_instruction_var_ptr(IrAnalyze ira, IrInstSrcVarPtr *instruction) {
19504	20487	ZigVar *var = instruction->var;
19505		IrInstruction *result = ir_get_var_ptr(ira, &instruction->base, var);
	20488	IrInstGen *result = ir_get_var_ptr(ira, &instruction->base.base, var);
19506	20489	if (instruction->crossed_fndef_scope != nullptr && !instr_is_comptime(result)) {
19507		ErrorMsg *msg = ir_add_error(ira, &instruction->base,
	20490	ErrorMsg *msg = ir_add_error(ira, &instruction->base.base,
19508	20491	buf_sprintf("'%s' not accessible from inner function", var->name));
19509	20492	add_error_note(ira->codegen, msg, instruction->crossed_fndef_scope->base.source_node,
19510	20493	buf_sprintf("crossed function definition here"));
19511	20494	add_error_note(ira->codegen, msg, var->decl_node,
19512	20495	buf_sprintf("declared here"));
19513		return ira->codegen->invalid_instruction;
	20496	return ira->codegen->invalid_inst_gen;
19514	20497	}
19515	20498	return result;
19516	20499	}
...	...	@@ -19561,17 +20544,17 @@ static ZigType adjust_ptr_len(CodeGen g, ZigType *ptr_type, PtrLen ptr_len) {
19561	20544	ptr_type->data.pointer.allow_zero);
19562	20545	}
19563	20546
19564		static IrInstruction ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstructionElemPtr *elem_ptr_instruction) {
	20547	static IrInstGen ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstSrcElemPtr *elem_ptr_instruction) {
19565	20548	Error err;
19566		IrInstruction *array_ptr = elem_ptr_instruction->array_ptr->child;
	20549	IrInstGen *array_ptr = elem_ptr_instruction->array_ptr->child;
19567	20550	if (type_is_invalid(array_ptr->value->type))
19568		return ira->codegen->invalid_instruction;
	20551	return ira->codegen->invalid_inst_gen;
19569	20552
19570	20553	ZigValue *orig_array_ptr_val = array_ptr->value;
19571	20554
19572		IrInstruction *elem_index = elem_ptr_instruction->elem_index->child;
	20555	IrInstGen *elem_index = elem_ptr_instruction->elem_index->child;
19573	20556	if (type_is_invalid(elem_index->value->type))
19574		return ira->codegen->invalid_instruction;
	20557	return ira->codegen->invalid_inst_gen;
19575	20558
19576	20559	ZigType *ptr_type = orig_array_ptr_val->type;
19577	20560	assert(ptr_type->id == ZigTypeIdPointer);
...	...	@@ -19583,7 +20566,7 @@ static IrInstruction ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstruct
19583	20566	ZigType *return_type;
19584	20567
19585	20568	if (type_is_invalid(array_type)) {
19586		return ira->codegen->invalid_instruction;
	20569	return ira->codegen->invalid_inst_gen;
19587	20570	} else if (array_type->id == ZigTypeIdArray \|\|
19588	20571	(array_type->id == ZigTypeIdPointer &&
19589	20572	array_type->data.pointer.ptr_len == PtrLenSingle &&
...	...	@@ -19594,15 +20577,15 @@ static IrInstruction ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstruct
19594	20577	ptr_type = ptr_type->data.pointer.child_type;
19595	20578	if (orig_array_ptr_val->special != ConstValSpecialRuntime) {
19596	20579	orig_array_ptr_val = const_ptr_pointee(ira, ira->codegen, orig_array_ptr_val,
19597		elem_ptr_instruction->base.source_node);
	20580	elem_ptr_instruction->base.base.source_node);
19598	20581	if (orig_array_ptr_val == nullptr)
19599		return ira->codegen->invalid_instruction;
	20582	return ira->codegen->invalid_inst_gen;
19600	20583	}
19601	20584	}
19602	20585	if (array_type->data.array.len == 0) {
19603		ir_add_error_node(ira, elem_ptr_instruction->base.source_node,
	20586	ir_add_error_node(ira, elem_ptr_instruction->base.base.source_node,
19604	20587	buf_sprintf("index 0 outside array of size 0"));
19605		return ira->codegen->invalid_instruction;
	20588	return ira->codegen->invalid_inst_gen;
19606	20589	}
19607	20590	ZigType *child_type = array_type->data.array.child_type;
19608	20591	if (ptr_type->data.pointer.host_int_bytes == 0) {
...	...	@@ -19613,7 +20596,7 @@ static IrInstruction ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstruct
19613	20596	} else {
19614	20597	uint64_t elem_val_scalar;
19615	20598	if (!ir_resolve_usize(ira, elem_index, &elem_val_scalar))
19616		return ira->codegen->invalid_instruction;
	20599	return ira->codegen->invalid_inst_gen;
19617	20600
19618	20601	size_t bit_width = type_size_bits(ira->codegen, child_type);
19619	20602	size_t bit_offset = bit_width * elem_val_scalar;
...	...	@@ -19625,9 +20608,9 @@ static IrInstruction ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstruct
19625	20608	}
19626	20609	} else if (array_type->id == ZigTypeIdPointer) {
19627	20610	if (array_type->data.pointer.ptr_len == PtrLenSingle) {
19628		ir_add_error_node(ira, elem_ptr_instruction->base.source_node,
	20611	ir_add_error_node(ira, elem_ptr_instruction->base.base.source_node,
19629	20612	buf_sprintf("index of single-item pointer"));
19630		return ira->codegen->invalid_instruction;
	20613	return ira->codegen->invalid_inst_gen;
19631	20614	}
19632	20615	return_type = adjust_ptr_len(ira->codegen, array_type, elem_ptr_instruction->ptr_len);
19633	20616	} else if (is_slice(array_type)) {
...	...	@@ -19641,38 +20624,38 @@ static IrInstruction ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstruct
19641	20624	array_type->data.structure.resolve_status == ResolveStatusBeingInferred)
19642	20625	{
19643	20626	ZigType *usize = ira->codegen->builtin_types.entry_usize;
19644		IrInstruction *casted_elem_index = ir_implicit_cast(ira, elem_index, usize);
	20627	IrInstGen *casted_elem_index = ir_implicit_cast(ira, elem_index, usize);
19645	20628	if (type_is_invalid(casted_elem_index->value->type))
19646		return ira->codegen->invalid_instruction;
19647		ir_assert(instr_is_comptime(casted_elem_index), &elem_ptr_instruction->base);
	20629	return ira->codegen->invalid_inst_gen;
	20630	ir_assert(instr_is_comptime(casted_elem_index), &elem_ptr_instruction->base.base);
19648	20631	Buf *field_name = buf_alloc();
19649	20632	bigint_append_buf(field_name, &casted_elem_index->value->data.x_bigint, 10);
19650		return ir_analyze_inferred_field_ptr(ira, field_name, &elem_ptr_instruction->base,
	20633	return ir_analyze_inferred_field_ptr(ira, field_name, &elem_ptr_instruction->base.base,
19651	20634	array_ptr, array_type);
19652	20635	} else if (is_tuple(array_type)) {
19653	20636	uint64_t elem_index_scalar;
19654	20637	if (!ir_resolve_usize(ira, elem_index, &elem_index_scalar))
19655		return ira->codegen->invalid_instruction;
	20638	return ira->codegen->invalid_inst_gen;
19656	20639	if (elem_index_scalar >= array_type->data.structure.src_field_count) {
19657		ir_add_error(ira, &elem_ptr_instruction->base, buf_sprintf(
	20640	ir_add_error(ira, &elem_ptr_instruction->base.base, buf_sprintf(
19658	20641	"field index %" ZIG_PRI_u64 " outside tuple '%s' which has %" PRIu32 " fields",
19659	20642	elem_index_scalar, buf_ptr(&array_type->name),
19660	20643	array_type->data.structure.src_field_count));
19661		return ira->codegen->invalid_instruction;
	20644	return ira->codegen->invalid_inst_gen;
19662	20645	}
19663	20646	TypeStructField *field = array_type->data.structure.fields[elem_index_scalar];
19664		return ir_analyze_struct_field_ptr(ira, &elem_ptr_instruction->base, field, array_ptr,
	20647	return ir_analyze_struct_field_ptr(ira, &elem_ptr_instruction->base.base, field, array_ptr,
19665	20648	array_type, false);
19666	20649	} else {
19667		ir_add_error_node(ira, elem_ptr_instruction->base.source_node,
	20650	ir_add_error_node(ira, elem_ptr_instruction->base.base.source_node,
19668	20651	buf_sprintf("array access of non-array type '%s'", buf_ptr(&array_type->name)));
19669		return ira->codegen->invalid_instruction;
	20652	return ira->codegen->invalid_inst_gen;
19670	20653	}
19671	20654
19672	20655	ZigType *usize = ira->codegen->builtin_types.entry_usize;
19673		IrInstruction *casted_elem_index = ir_implicit_cast(ira, elem_index, usize);
19674		if (casted_elem_index == ira->codegen->invalid_instruction)
19675		return ira->codegen->invalid_instruction;
	20656	IrInstGen *casted_elem_index = ir_implicit_cast(ira, elem_index, usize);
	20657	if (type_is_invalid(casted_elem_index->value->type))
	20658	return ira->codegen->invalid_inst_gen;
19676	20659
19677	20660	bool safety_check_on = elem_ptr_instruction->safety_check_on;
19678	20661	if (instr_is_comptime(casted_elem_index)) {
...	...	@@ -19681,15 +20664,15 @@ static IrInstruction ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstruct
19681	20664	uint64_t array_len = array_type->data.array.len;
19682	20665	if (index == array_len && array_type->data.array.sentinel != nullptr) {
19683	20666	ZigType *elem_type = array_type->data.array.child_type;
19684		IrInstruction *sentinel_elem = ir_const(ira, &elem_ptr_instruction->base, elem_type);
	20667	IrInstGen *sentinel_elem = ir_const(ira, &elem_ptr_instruction->base.base, elem_type);
19685	20668	copy_const_val(sentinel_elem->value, array_type->data.array.sentinel);
19686		return ir_get_ref(ira, &elem_ptr_instruction->base, sentinel_elem, true, false);
	20669	return ir_get_ref(ira, &elem_ptr_instruction->base.base, sentinel_elem, true, false);
19687	20670	}
19688	20671	if (index >= array_len) {
19689		ir_add_error_node(ira, elem_ptr_instruction->base.source_node,
	20672	ir_add_error_node(ira, elem_ptr_instruction->base.base.source_node,
19690	20673	buf_sprintf("index %" ZIG_PRI_u64 " outside array of size %" ZIG_PRI_u64,
19691	20674	index, array_len));
19692		return ira->codegen->invalid_instruction;
	20675	return ira->codegen->invalid_inst_gen;
19693	20676	}
19694	20677	safety_check_on = false;
19695	20678	}
...	...	@@ -19705,7 +20688,7 @@ static IrInstruction ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstruct
19705	20688	// figure out the largest alignment possible
19706	20689
19707	20690	if ((err = type_resolve(ira->codegen, return_type->data.pointer.child_type, ResolveStatusSizeKnown)))
19708		return ira->codegen->invalid_instruction;
	20691	return ira->codegen->invalid_inst_gen;
19709	20692
19710	20693	uint64_t elem_size = type_size(ira->codegen, return_type->data.pointer.child_type);
19711	20694	uint64_t abi_align = get_abi_alignment(ira->codegen, return_type->data.pointer.child_type);
...	...	@@ -19735,9 +20718,9 @@ static IrInstruction ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstruct
19735	20718	array_type->id == ZigTypeIdArray))
19736	20719	{
19737	20720	ZigValue *array_ptr_val = const_ptr_pointee(ira, ira->codegen, orig_array_ptr_val,
19738		elem_ptr_instruction->base.source_node);
	20721	elem_ptr_instruction->base.base.source_node);
19739	20722	if (array_ptr_val == nullptr)
19740		return ira->codegen->invalid_instruction;
	20723	return ira->codegen->invalid_inst_gen;
19741	20724
19742	20725	if (array_ptr_val->special == ConstValSpecialUndef &&
19743	20726	elem_ptr_instruction->init_array_type_source_node != nullptr)
...	...	@@ -19755,16 +20738,16 @@ static IrInstruction ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstruct
19755	20738	elem_val->parent.data.p_array.elem_index = i;
19756	20739	}
19757	20740	} else if (is_slice(array_type)) {
19758		ir_assert(array_ptr->value->type->id == ZigTypeIdPointer, &elem_ptr_instruction->base);
	20741	ir_assert(array_ptr->value->type->id == ZigTypeIdPointer, &elem_ptr_instruction->base.base);
19759	20742	ZigType *actual_array_type = array_ptr->value->type->data.pointer.child_type;
19760	20743
19761	20744	if (type_is_invalid(actual_array_type))
19762		return ira->codegen->invalid_instruction;
	20745	return ira->codegen->invalid_inst_gen;
19763	20746	if (actual_array_type->id != ZigTypeIdArray) {
19764	20747	ir_add_error_node(ira, elem_ptr_instruction->init_array_type_source_node,
19765	20748	buf_sprintf("array literal requires address-of operator to coerce to slice type '%s'",
19766	20749	buf_ptr(&actual_array_type->name)));
19767		return ira->codegen->invalid_instruction;
	20750	return ira->codegen->invalid_inst_gen;
19768	20751	}
19769	20752
19770	20753	ZigValue *array_init_val = create_const_vals(1);
...	...	@@ -19789,7 +20772,7 @@ static IrInstruction ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstruct
19789	20772	ir_add_error_node(ira, elem_ptr_instruction->init_array_type_source_node,
19790	20773	buf_sprintf("expected array type or [_], found '%s'",
19791	20774	buf_ptr(&array_type->name)));
19792		return ira->codegen->invalid_instruction;
	20775	return ira->codegen->invalid_inst_gen;
19793	20776	}
19794	20777	}
19795	20778
...	...	@@ -19798,7 +20781,7 @@ static IrInstruction ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstruct
19798	20781	array_ptr_val->data.x_ptr.special != ConstPtrSpecialHardCodedAddr))
19799	20782	{
19800	20783	if (array_type->id == ZigTypeIdPointer) {
19801		IrInstruction *result = ir_const(ira, &elem_ptr_instruction->base, return_type);
	20784	IrInstGen *result = ir_const(ira, &elem_ptr_instruction->base.base, return_type);
19802	20785	ZigValue *out_val = result->value;
19803	20786	out_val->data.x_ptr.mut = array_ptr_val->data.x_ptr.mut;
19804	20787	size_t new_index;
...	...	@@ -19867,33 +20850,31 @@ static IrInstruction ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstruct
19867	20850	zig_panic("TODO elem ptr on a null pointer");
19868	20851	}
19869	20852	if (new_index >= mem_size) {
19870		ir_add_error_node(ira, elem_ptr_instruction->base.source_node,
	20853	ir_add_error_node(ira, elem_ptr_instruction->base.base.source_node,
19871	20854	buf_sprintf("index %" ZIG_PRI_u64 " outside pointer of size %" ZIG_PRI_usize "", index, old_size));
19872		return ira->codegen->invalid_instruction;
	20855	return ira->codegen->invalid_inst_gen;
19873	20856	}
19874	20857	return result;
19875	20858	} else if (is_slice(array_type)) {
19876	20859	ZigValue *ptr_field = array_ptr_val->data.x_struct.fields[slice_ptr_index];
19877		ir_assert(ptr_field != nullptr, &elem_ptr_instruction->base);
	20860	ir_assert(ptr_field != nullptr, &elem_ptr_instruction->base.base);
19878	20861	if (ptr_field->data.x_ptr.special == ConstPtrSpecialHardCodedAddr) {
19879		IrInstruction *result = ir_build_elem_ptr(&ira->new_irb, elem_ptr_instruction->base.scope,
19880		elem_ptr_instruction->base.source_node, array_ptr, casted_elem_index, false,
19881		elem_ptr_instruction->ptr_len, nullptr);
19882		result->value->type = return_type;
19883		return result;
	20862	return ir_build_elem_ptr_gen(ira, elem_ptr_instruction->base.base.scope,
	20863	elem_ptr_instruction->base.base.source_node, array_ptr, casted_elem_index, false,
	20864	return_type);
19884	20865	}
19885	20866	ZigValue *len_field = array_ptr_val->data.x_struct.fields[slice_len_index];
19886		IrInstruction *result = ir_const(ira, &elem_ptr_instruction->base, return_type);
	20867	IrInstGen *result = ir_const(ira, &elem_ptr_instruction->base.base, return_type);
19887	20868	ZigValue *out_val = result->value;
19888	20869	ZigType *slice_ptr_type = array_type->data.structure.fields[slice_ptr_index]->type_entry;
19889	20870	uint64_t slice_len = bigint_as_u64(&len_field->data.x_bigint);
19890	20871	uint64_t full_slice_len = slice_len +
19891	20872	((slice_ptr_type->data.pointer.sentinel != nullptr) ? 1 : 0);
19892	20873	if (index >= full_slice_len) {
19893		ir_add_error_node(ira, elem_ptr_instruction->base.source_node,
	20874	ir_add_error_node(ira, elem_ptr_instruction->base.base.source_node,
19894	20875	buf_sprintf("index %" ZIG_PRI_u64 " outside slice of size %" ZIG_PRI_u64,
19895	20876	index, slice_len));
19896		return ira->codegen->invalid_instruction;
	20877	return ira->codegen->invalid_inst_gen;
19897	20878	}
19898	20879	out_val->data.x_ptr.mut = ptr_field->data.x_ptr.mut;
19899	20880	switch (ptr_field->data.x_ptr.special) {
...	...	@@ -19913,7 +20894,7 @@ static IrInstruction ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstruct
19913	20894	{
19914	20895	ir_assert(new_index <
19915	20896	ptr_field->data.x_ptr.data.base_array.array_val->type->data.array.len,
19916		&elem_ptr_instruction->base);
	20897	&elem_ptr_instruction->base.base);
19917	20898	}
19918	20899	out_val->data.x_ptr.special = ConstPtrSpecialBaseArray;
19919	20900	out_val->data.x_ptr.data.base_array.array_val =
...	...	@@ -19938,15 +20919,14 @@ static IrInstruction ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstruct
19938	20919	}
19939	20920	return result;
19940	20921	} else if (array_type->id == ZigTypeIdArray \|\| array_type->id == ZigTypeIdVector) {
19941		IrInstruction *result;
	20922	IrInstGen *result;
19942	20923	if (orig_array_ptr_val->data.x_ptr.mut == ConstPtrMutInfer) {
19943		result = ir_build_elem_ptr(&ira->new_irb, elem_ptr_instruction->base.scope,
19944		elem_ptr_instruction->base.source_node, array_ptr, casted_elem_index,
19945		false, elem_ptr_instruction->ptr_len, nullptr);
19946		result->value->type = return_type;
	20924	result = ir_build_elem_ptr_gen(ira, elem_ptr_instruction->base.base.scope,
	20925	elem_ptr_instruction->base.base.source_node, array_ptr, casted_elem_index,
	20926	false, return_type);
19947	20927	result->value->special = ConstValSpecialStatic;
19948	20928	} else {
19949		result = ir_const(ira, &elem_ptr_instruction->base, return_type);
	20929	result = ir_const(ira, &elem_ptr_instruction->base.base, return_type);
19950	20930	}
19951	20931	ZigValue *out_val = result->value;
19952	20932	out_val->data.x_ptr.special = ConstPtrSpecialBaseArray;
...	...	@@ -19972,19 +20952,19 @@ static IrInstruction ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstruct
19972	20952	// runtime known element index
19973	20953	switch (type_requires_comptime(ira->codegen, return_type)) {
19974	20954	case ReqCompTimeYes:
19975		ir_add_error(ira, elem_index,
	20955	ir_add_error(ira, &elem_index->base,
19976	20956	buf_sprintf("values of type '%s' must be comptime known, but index value is runtime known",
19977	20957	buf_ptr(&return_type->data.pointer.child_type->name)));
19978		return ira->codegen->invalid_instruction;
	20958	return ira->codegen->invalid_inst_gen;
19979	20959	case ReqCompTimeInvalid:
19980		return ira->codegen->invalid_instruction;
	20960	return ira->codegen->invalid_inst_gen;
19981	20961	case ReqCompTimeNo:
19982	20962	break;
19983	20963	}
19984	20964
19985	20965	if (return_type->data.pointer.explicit_alignment != 0) {
19986	20966	if ((err = type_resolve(ira->codegen, return_type->data.pointer.child_type, ResolveStatusSizeKnown)))
19987		return ira->codegen->invalid_instruction;
	20967	return ira->codegen->invalid_inst_gen;
19988	20968
19989	20969	uint64_t elem_size = type_size(ira->codegen, return_type->data.pointer.child_type);
19990	20970	uint64_t abi_align = get_abi_alignment(ira->codegen, return_type->data.pointer.child_type);
...	...	@@ -20002,16 +20982,13 @@ static IrInstruction ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstruct
20002	20982	}
20003	20983	}
20004	20984
20005		IrInstruction *result = ir_build_elem_ptr(&ira->new_irb, elem_ptr_instruction->base.scope,
20006		elem_ptr_instruction->base.source_node, array_ptr, casted_elem_index, safety_check_on,
20007		elem_ptr_instruction->ptr_len, nullptr);
20008		result->value->type = return_type;
20009		return result;
	20985	return ir_build_elem_ptr_gen(ira, elem_ptr_instruction->base.base.scope,
	20986	elem_ptr_instruction->base.base.source_node, array_ptr, casted_elem_index, safety_check_on, return_type);
20010	20987	}
20011	20988
20012		static IrInstruction ir_analyze_container_member_access_inner(IrAnalyze ira,
20013		ZigType bare_struct_type, Buf field_name, IrInstruction *source_instr,
20014		IrInstruction container_ptr, ZigType container_type)
	20989	static IrInstGen ir_analyze_container_member_access_inner(IrAnalyze ira,
	20990	ZigType bare_struct_type, Buf field_name, IrInst* source_instr,
	20991	IrInstGen container_ptr, ZigType container_type)
20015	20992	{
20016	20993	if (!is_slice(bare_struct_type)) {
20017	20994	ScopeDecls *container_scope = get_container_scope(bare_struct_type);
...	...	@@ -20021,29 +20998,27 @@ static IrInstruction ir_analyze_container_member_access_inner(IrAnalyze ira,
20021	20998	if (tld->id == TldIdFn) {
20022	20999	resolve_top_level_decl(ira->codegen, tld, source_instr->source_node, false);
20023	21000	if (tld->resolution == TldResolutionInvalid)
20024		return ira->codegen->invalid_instruction;
	21001	return ira->codegen->invalid_inst_gen;
20025	21002	TldFn tld_fn = (TldFn )tld;
20026	21003	ZigFn *fn_entry = tld_fn->fn_entry;
20027	21004	if (type_is_invalid(fn_entry->type_entry))
20028		return ira->codegen->invalid_instruction;
	21005	return ira->codegen->invalid_inst_gen;
20029	21006
20030		IrInstruction *bound_fn_value = ir_build_const_bound_fn(&ira->new_irb, source_instr->scope,
20031		source_instr->source_node, fn_entry, container_ptr);
	21007	IrInstGen *bound_fn_value = ir_const_bound_fn(ira, source_instr, fn_entry, container_ptr);
20032	21008	return ir_get_ref(ira, source_instr, bound_fn_value, true, false);
20033	21009	} else if (tld->id == TldIdVar) {
20034	21010	resolve_top_level_decl(ira->codegen, tld, source_instr->source_node, false);
20035	21011	if (tld->resolution == TldResolutionInvalid)
20036		return ira->codegen->invalid_instruction;
	21012	return ira->codegen->invalid_inst_gen;
20037	21013	TldVar tld_var = (TldVar )tld;
20038	21014	ZigVar *var = tld_var->var;
20039	21015	if (type_is_invalid(var->var_type))
20040		return ira->codegen->invalid_instruction;
	21016	return ira->codegen->invalid_inst_gen;
20041	21017
20042	21018	if (var->const_value->type->id == ZigTypeIdFn) {
20043	21019	ir_assert(var->const_value->data.x_ptr.special == ConstPtrSpecialFunction, source_instr);
20044	21020	ZigFn *fn = var->const_value->data.x_ptr.data.fn.fn_entry;
20045		IrInstruction *bound_fn_value = ir_build_const_bound_fn(&ira->new_irb, source_instr->scope,
20046		source_instr->source_node, fn, container_ptr);
	21021	IrInstGen *bound_fn_value = ir_const_bound_fn(ira, source_instr, fn, container_ptr);
20047	21022	return ir_get_ref(ira, source_instr, bound_fn_value, true, false);
20048	21023	}
20049	21024	}
...	...	@@ -20063,7 +21038,7 @@ static IrInstruction ir_analyze_container_member_access_inner(IrAnalyze ira,
20063	21038	}
20064	21039	ir_add_error_node(ira, source_instr->source_node,
20065	21040	buf_sprintf("no member named '%s' in %s'%s'", buf_ptr(field_name), prefix_name, buf_ptr(&bare_struct_type->name)));
20066		return ira->codegen->invalid_instruction;
	21041	return ira->codegen->invalid_inst_gen;
20067	21042	}
20068	21043
20069	21044	static void memoize_field_init_val(CodeGen codegen, ZigType container_type, TypeStructField *field) {
...	...	@@ -20078,24 +21053,24 @@ static void memoize_field_init_val(CodeGen codegen, ZigType container_type, Ty
20078	21053	field->type_entry, nullptr, UndefOk);
20079	21054	}
20080	21055
20081		static IrInstruction ir_analyze_struct_field_ptr(IrAnalyze ira, IrInstruction *source_instr,
20082		TypeStructField field, IrInstruction struct_ptr, ZigType *struct_type, bool initializing)
	21056	static IrInstGen ir_analyze_struct_field_ptr(IrAnalyze ira, IrInst* source_instr,
	21057	TypeStructField field, IrInstGen struct_ptr, ZigType *struct_type, bool initializing)
20083	21058	{
20084	21059	Error err;
20085	21060	ZigType *field_type = resolve_struct_field_type(ira->codegen, field);
20086	21061	if (field_type == nullptr)
20087		return ira->codegen->invalid_instruction;
	21062	return ira->codegen->invalid_inst_gen;
20088	21063	if (field->is_comptime) {
20089		IrInstruction *elem = ir_const(ira, source_instr, field_type);
	21064	IrInstGen *elem = ir_const(ira, source_instr, field_type);
20090	21065	memoize_field_init_val(ira->codegen, struct_type, field);
20091	21066	copy_const_val(elem->value, field->init_val);
20092	21067	return ir_get_ref(ira, source_instr, elem, true, false);
20093	21068	}
20094	21069	switch (type_has_one_possible_value(ira->codegen, field_type)) {
20095	21070	case OnePossibleValueInvalid:
20096		return ira->codegen->invalid_instruction;
	21071	return ira->codegen->invalid_inst_gen;
20097	21072	case OnePossibleValueYes: {
20098		IrInstruction *elem = ir_const_move(ira, source_instr,
	21073	IrInstGen *elem = ir_const_move(ira, source_instr,
20099	21074	get_the_one_possible_value(ira->codegen, field_type));
20100	21075	return ir_get_ref(ira, source_instr, elem, false, false);
20101	21076	}
...	...	@@ -20113,7 +21088,7 @@ static IrInstruction ir_analyze_struct_field_ptr(IrAnalyze ira, IrInstruction
20113	21088	(struct_type->data.structure.layout == ContainerLayoutAuto) ?
20114	21089	ResolveStatusZeroBitsKnown : ResolveStatusSizeKnown;
20115	21090	if ((err = type_resolve(ira->codegen, struct_type, needed_resolve_status)))
20116		return ira->codegen->invalid_instruction;
	21091	return ira->codegen->invalid_inst_gen;
20117	21092	assert(struct_ptr->value->type->id == ZigTypeIdPointer);
20118	21093	uint32_t ptr_bit_offset = struct_ptr->value->type->data.pointer.bit_offset_in_host;
20119	21094	uint32_t ptr_host_int_bytes = struct_ptr->value->type->data.pointer.host_int_bytes;
...	...	@@ -20127,14 +21102,14 @@ static IrInstruction ir_analyze_struct_field_ptr(IrAnalyze ira, IrInstruction
20127	21102	if (instr_is_comptime(struct_ptr)) {
20128	21103	ZigValue *ptr_val = ir_resolve_const(ira, struct_ptr, UndefBad);
20129	21104	if (!ptr_val)
20130		return ira->codegen->invalid_instruction;
	21105	return ira->codegen->invalid_inst_gen;
20131	21106
20132	21107	if (ptr_val->data.x_ptr.special != ConstPtrSpecialHardCodedAddr) {
20133	21108	ZigValue *struct_val = const_ptr_pointee(ira, ira->codegen, ptr_val, source_instr->source_node);
20134	21109	if (struct_val == nullptr)
20135		return ira->codegen->invalid_instruction;
	21110	return ira->codegen->invalid_inst_gen;
20136	21111	if (type_is_invalid(struct_val->type))
20137		return ira->codegen->invalid_instruction;
	21112	return ira->codegen->invalid_inst_gen;
20138	21113	if (initializing && struct_val->special == ConstValSpecialUndef) {
20139	21114	struct_val->data.x_struct.fields = alloc_const_vals_ptrs(struct_type->data.structure.src_field_count);
20140	21115	struct_val->special = ConstValSpecialStatic;
...	...	@@ -20148,11 +21123,9 @@ static IrInstruction ir_analyze_struct_field_ptr(IrAnalyze ira, IrInstruction
20148	21123	field_val->parent.data.p_struct.field_index = i;
20149	21124	}
20150	21125	}
20151		IrInstruction *result;
	21126	IrInstGen *result;
20152	21127	if (ptr_val->data.x_ptr.mut == ConstPtrMutInfer) {
20153		result = ir_build_struct_field_ptr(&ira->new_irb, source_instr->scope,
20154		source_instr->source_node, struct_ptr, field);
20155		result->value->type = ptr_type;
	21128	result = ir_build_struct_field_ptr(ira, source_instr, struct_ptr, field, ptr_type);
20156	21129	result->value->special = ConstValSpecialStatic;
20157	21130	} else {
20158	21131	result = ir_const(ira, source_instr, ptr_type);
...	...	@@ -20165,14 +21138,11 @@ static IrInstruction ir_analyze_struct_field_ptr(IrAnalyze ira, IrInstruction
20165	21138	return result;
20166	21139	}
20167	21140	}
20168		IrInstruction *result = ir_build_struct_field_ptr(&ira->new_irb, source_instr->scope, source_instr->source_node,
20169		struct_ptr, field);
20170		result->value->type = ptr_type;
20171		return result;
	21141	return ir_build_struct_field_ptr(ira, source_instr, struct_ptr, field, ptr_type);
20172	21142	}
20173	21143
20174		static IrInstruction ir_analyze_inferred_field_ptr(IrAnalyze ira, Buf *field_name,
20175		IrInstruction source_instr, IrInstruction container_ptr, ZigType *container_type)
	21144	static IrInstGen ir_analyze_inferred_field_ptr(IrAnalyze ira, Buf *field_name,
	21145	IrInst* source_instr, IrInstGen container_ptr, ZigType container_type)
20176	21146	{
20177	21147	// The type of the field is not available until a store using this pointer happens.
20178	21148	// So, here we create a special pointer type which has the inferred struct type and
...	...	@@ -20195,12 +21165,11 @@ static IrInstruction ir_analyze_inferred_field_ptr(IrAnalyze ira, Buf *field_n
20195	21165	if (instr_is_comptime(container_ptr)) {
20196	21166	ZigValue *ptr_val = ir_resolve_const(ira, container_ptr, UndefBad);
20197	21167	if (ptr_val == nullptr)
20198		return ira->codegen->invalid_instruction;
	21168	return ira->codegen->invalid_inst_gen;
20199	21169
20200		IrInstruction *result;
	21170	IrInstGen *result;
20201	21171	if (ptr_val->data.x_ptr.mut == ConstPtrMutInfer) {
20202		result = ir_build_cast(&ira->new_irb, source_instr->scope,
20203		source_instr->source_node, container_ptr_type, container_ptr, CastOpNoop);
	21172	result = ir_build_cast(ira, source_instr, container_ptr_type, container_ptr, CastOpNoop);
20204	21173	} else {
20205	21174	result = ir_const(ira, source_instr, field_ptr_type);
20206	21175	}
...	...	@@ -20209,14 +21178,11 @@ static IrInstruction ir_analyze_inferred_field_ptr(IrAnalyze ira, Buf *field_n
20209	21178	return result;
20210	21179	}
20211	21180
20212		IrInstruction *result = ir_build_cast(&ira->new_irb, source_instr->scope,
20213		source_instr->source_node, field_ptr_type, container_ptr, CastOpNoop);
20214		result->value->type = field_ptr_type;
20215		return result;
	21181	return ir_build_cast(ira, source_instr, field_ptr_type, container_ptr, CastOpNoop);
20216	21182	}
20217	21183
20218		static IrInstruction ir_analyze_container_field_ptr(IrAnalyze ira, Buf *field_name,
20219		IrInstruction source_instr, IrInstruction container_ptr, ZigType *container_type, bool initializing)
	21184	static IrInstGen ir_analyze_container_field_ptr(IrAnalyze ira, Buf *field_name,
	21185	IrInst* source_instr, IrInstGen container_ptr, ZigType container_type, bool initializing)
20220	21186	{
20221	21187	Error err;
20222	21188
...	...	@@ -20229,7 +21195,7 @@ static IrInstruction ir_analyze_container_field_ptr(IrAnalyze ira, Buf *field_
20229	21195	}
20230	21196
20231	21197	if ((err = type_resolve(ira->codegen, bare_type, ResolveStatusZeroBitsKnown)))
20232		return ira->codegen->invalid_instruction;
	21198	return ira->codegen->invalid_inst_gen;
20233	21199
20234	21200	assert(container_ptr->value->type->id == ZigTypeIdPointer);
20235	21201	if (bare_type->id == ZigTypeIdStruct) {
...	...	@@ -20259,22 +21225,22 @@ static IrInstruction ir_analyze_container_field_ptr(IrAnalyze ira, Buf *field_
20259	21225
20260	21226	ZigType *field_type = resolve_union_field_type(ira->codegen, field);
20261	21227	if (field_type == nullptr)
20262		return ira->codegen->invalid_instruction;
	21228	return ira->codegen->invalid_inst_gen;
20263	21229
20264	21230	ZigType *ptr_type = get_pointer_to_type_extra(ira->codegen, field_type,
20265	21231	is_const, is_volatile, PtrLenSingle, 0, 0, 0, false);
20266	21232	if (instr_is_comptime(container_ptr)) {
20267	21233	ZigValue *ptr_val = ir_resolve_const(ira, container_ptr, UndefBad);
20268	21234	if (!ptr_val)
20269		return ira->codegen->invalid_instruction;
	21235	return ira->codegen->invalid_inst_gen;
20270	21236
20271	21237	if (ptr_val->data.x_ptr.mut != ConstPtrMutRuntimeVar &&
20272	21238	ptr_val->data.x_ptr.special != ConstPtrSpecialHardCodedAddr) {
20273	21239	ZigValue *union_val = const_ptr_pointee(ira, ira->codegen, ptr_val, source_instr->source_node);
20274	21240	if (union_val == nullptr)
20275		return ira->codegen->invalid_instruction;
	21241	return ira->codegen->invalid_inst_gen;
20276	21242	if (type_is_invalid(union_val->type))
20277		return ira->codegen->invalid_instruction;
	21243	return ira->codegen->invalid_inst_gen;
20278	21244
20279	21245	if (initializing) {
20280	21246	ZigValue *payload_val = create_const_vals(1);
...	...	@@ -20295,17 +21261,16 @@ static IrInstruction ir_analyze_container_field_ptr(IrAnalyze ira, Buf *field_
20295	21261	ir_add_error_node(ira, source_instr->source_node,
20296	21262	buf_sprintf("accessing union field '%s' while field '%s' is set", buf_ptr(field_name),
20297	21263	buf_ptr(actual_field->name)));
20298		return ira->codegen->invalid_instruction;
	21264	return ira->codegen->invalid_inst_gen;
20299	21265	}
20300	21266	}
20301	21267
20302	21268	ZigValue *payload_val = union_val->data.x_union.payload;
20303	21269
20304		IrInstruction *result;
	21270	IrInstGen *result;
20305	21271	if (ptr_val->data.x_ptr.mut == ConstPtrMutInfer) {
20306		result = ir_build_union_field_ptr(&ira->new_irb, source_instr->scope,
20307		source_instr->source_node, container_ptr, field, true, initializing);
20308		result->value->type = ptr_type;
	21272	result = ir_build_union_field_ptr(ira, source_instr, container_ptr, field, true,
	21273	initializing, ptr_type);
20309	21274	result->value->special = ConstValSpecialStatic;
20310	21275	} else {
20311	21276	result = ir_const(ira, source_instr, ptr_type);
...	...	@@ -20318,10 +21283,7 @@ static IrInstruction ir_analyze_container_field_ptr(IrAnalyze ira, Buf *field_
20318	21283	}
20319	21284	}
20320	21285
20321		IrInstruction *result = ir_build_union_field_ptr(&ira->new_irb, source_instr->scope,
20322		source_instr->source_node, container_ptr, field, true, initializing);
20323		result->value->type = ptr_type;
20324		return result;
	21286	return ir_build_union_field_ptr(ira, source_instr, container_ptr, field, true, initializing, ptr_type);
20325	21287	}
20326	21288
20327	21289	zig_unreachable();
...	...	@@ -20362,15 +21324,15 @@ static void add_link_lib_symbol(IrAnalyze ira, Buf lib_name, Buf *symbol_name,
20362	21324	link_lib->symbols.append(symbol_name);
20363	21325	}
20364	21326
20365		static IrInstruction ir_error_dependency_loop(IrAnalyze ira, IrInstruction *source_instr) {
	21327	static IrInstGen ir_error_dependency_loop(IrAnalyze ira, IrInst* source_instr) {
20366	21328	ir_add_error(ira, source_instr, buf_sprintf("dependency loop detected"));
20367		return ira->codegen->invalid_instruction;
	21329	return ira->codegen->invalid_inst_gen;
20368	21330	}
20369	21331
20370		static IrInstruction ir_analyze_decl_ref(IrAnalyze ira, IrInstruction source_instruction, Tld tld) {
	21332	static IrInstGen ir_analyze_decl_ref(IrAnalyze ira, IrInst* source_instruction, Tld *tld) {
20371	21333	resolve_top_level_decl(ira->codegen, tld, source_instruction->source_node, true);
20372	21334	if (tld->resolution == TldResolutionInvalid) {
20373		return ira->codegen->invalid_instruction;
	21335	return ira->codegen->invalid_inst_gen;
20374	21336	}
20375	21337
20376	21338	switch (tld->id) {
...	...	@@ -20397,14 +21359,13 @@ static IrInstruction ir_analyze_decl_ref(IrAnalyze ira, IrInstruction *source_
20397	21359	assert(fn_entry->type_entry);
20398	21360
20399	21361	if (type_is_invalid(fn_entry->type_entry))
20400		return ira->codegen->invalid_instruction;
	21362	return ira->codegen->invalid_inst_gen;
20401	21363
20402	21364	if (tld_fn->extern_lib_name != nullptr) {
20403	21365	add_link_lib_symbol(ira, tld_fn->extern_lib_name, &fn_entry->symbol_name, source_instruction->source_node);
20404	21366	}
20405	21367
20406		IrInstruction *fn_inst = ir_create_const_fn(&ira->new_irb, source_instruction->scope,
20407		source_instruction->source_node, fn_entry);
	21368	IrInstGen *fn_inst = ir_const_fn(ira, source_instruction, fn_entry);
20408	21369	return ir_get_ref(ira, source_instruction, fn_inst, true, false);
20409	21370	}
20410	21371	}
...	...	@@ -20422,40 +21383,40 @@ static ErrorTableEntry find_err_table_entry(ZigType err_set_type, Buf *field_n
20422	21383	return nullptr;
20423	21384	}
20424	21385
20425		static IrInstruction ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstructionFieldPtr *field_ptr_instruction) {
	21386	static IrInstGen ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstSrcFieldPtr *field_ptr_instruction) {
20426	21387	Error err;
20427		IrInstruction *container_ptr = field_ptr_instruction->container_ptr->child;
	21388	IrInstGen *container_ptr = field_ptr_instruction->container_ptr->child;
20428	21389	if (type_is_invalid(container_ptr->value->type))
20429		return ira->codegen->invalid_instruction;
	21390	return ira->codegen->invalid_inst_gen;
20430	21391
20431	21392	ZigType *container_type = container_ptr->value->type->data.pointer.child_type;
20432	21393
20433	21394	Buf *field_name = field_ptr_instruction->field_name_buffer;
20434	21395	if (!field_name) {
20435		IrInstruction *field_name_expr = field_ptr_instruction->field_name_expr->child;
	21396	IrInstGen *field_name_expr = field_ptr_instruction->field_name_expr->child;
20436	21397	field_name = ir_resolve_str(ira, field_name_expr);
20437	21398	if (!field_name)
20438		return ira->codegen->invalid_instruction;
	21399	return ira->codegen->invalid_inst_gen;
20439	21400	}
20440	21401
20441	21402
20442		AstNode *source_node = field_ptr_instruction->base.source_node;
	21403	AstNode *source_node = field_ptr_instruction->base.base.source_node;
20443	21404
20444	21405	if (type_is_invalid(container_type)) {
20445		return ira->codegen->invalid_instruction;
	21406	return ira->codegen->invalid_inst_gen;
20446	21407	} else if (is_tuple(container_type) && !field_ptr_instruction->initializing && buf_eql_str(field_name, "len")) {
20447		IrInstruction *len_inst = ir_const_unsigned(ira, &field_ptr_instruction->base,
	21408	IrInstGen *len_inst = ir_const_unsigned(ira, &field_ptr_instruction->base.base,
20448	21409	container_type->data.structure.src_field_count);
20449		return ir_get_ref(ira, &field_ptr_instruction->base, len_inst, true, false);
	21410	return ir_get_ref(ira, &field_ptr_instruction->base.base, len_inst, true, false);
20450	21411	} else if (is_slice(container_type) \|\| is_container_ref(container_type)) {
20451	21412	assert(container_ptr->value->type->id == ZigTypeIdPointer);
20452	21413	if (container_type->id == ZigTypeIdPointer) {
20453	21414	ZigType *bare_type = container_ref_type(container_type);
20454		IrInstruction *container_child = ir_get_deref(ira, &field_ptr_instruction->base, container_ptr, nullptr);
20455		IrInstruction *result = ir_analyze_container_field_ptr(ira, field_name, &field_ptr_instruction->base, container_child, bare_type, field_ptr_instruction->initializing);
	21415	IrInstGen *container_child = ir_get_deref(ira, &field_ptr_instruction->base.base, container_ptr, nullptr);
	21416	IrInstGen *result = ir_analyze_container_field_ptr(ira, field_name, &field_ptr_instruction->base.base, container_child, bare_type, field_ptr_instruction->initializing);
20456	21417	return result;
20457	21418	} else {
20458		IrInstruction *result = ir_analyze_container_field_ptr(ira, field_name, &field_ptr_instruction->base, container_ptr, container_type, field_ptr_instruction->initializing);
	21419	IrInstGen *result = ir_analyze_container_field_ptr(ira, field_name, &field_ptr_instruction->base.base, container_ptr, container_type, field_ptr_instruction->initializing);
20459	21420	return result;
20460	21421	}
20461	21422	} else if (is_array_ref(container_type) && !field_ptr_instruction->initializing) {
...	...	@@ -20470,42 +21431,42 @@ static IrInstruction ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstruc
20470	21431	ZigType *usize = ira->codegen->builtin_types.entry_usize;
20471	21432	bool ptr_is_const = true;
20472	21433	bool ptr_is_volatile = false;
20473		return ir_get_const_ptr(ira, &field_ptr_instruction->base, len_val,
	21434	return ir_get_const_ptr(ira, &field_ptr_instruction->base.base, len_val,
20474	21435	usize, ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
20475	21436	} else {
20476	21437	ir_add_error_node(ira, source_node,
20477	21438	buf_sprintf("no member named '%s' in '%s'", buf_ptr(field_name),
20478	21439	buf_ptr(&container_type->name)));
20479		return ira->codegen->invalid_instruction;
	21440	return ira->codegen->invalid_inst_gen;
20480	21441	}
20481	21442	} else if (container_type->id == ZigTypeIdMetaType) {
20482	21443	ZigValue *container_ptr_val = ir_resolve_const(ira, container_ptr, UndefBad);
20483	21444	if (!container_ptr_val)
20484		return ira->codegen->invalid_instruction;
	21445	return ira->codegen->invalid_inst_gen;
20485	21446
20486	21447	assert(container_ptr->value->type->id == ZigTypeIdPointer);
20487	21448	ZigValue *child_val = const_ptr_pointee(ira, ira->codegen, container_ptr_val, source_node);
20488	21449	if (child_val == nullptr)
20489		return ira->codegen->invalid_instruction;
	21450	return ira->codegen->invalid_inst_gen;
20490	21451	if ((err = ir_resolve_const_val(ira->codegen, ira->new_irb.exec,
20491		field_ptr_instruction->base.source_node, child_val, UndefBad)))
	21452	field_ptr_instruction->base.base.source_node, child_val, UndefBad)))
20492	21453	{
20493		return ira->codegen->invalid_instruction;
	21454	return ira->codegen->invalid_inst_gen;
20494	21455	}
20495	21456	ZigType *child_type = child_val->data.x_type;
20496	21457
20497	21458	if (type_is_invalid(child_type)) {
20498		return ira->codegen->invalid_instruction;
	21459	return ira->codegen->invalid_inst_gen;
20499	21460	} else if (is_container(child_type)) {
20500	21461	if (child_type->id == ZigTypeIdEnum) {
20501	21462	if ((err = type_resolve(ira->codegen, child_type, ResolveStatusSizeKnown)))
20502		return ira->codegen->invalid_instruction;
	21463	return ira->codegen->invalid_inst_gen;
20503	21464
20504	21465	TypeEnumField *field = find_enum_type_field(child_type, field_name);
20505	21466	if (field) {
20506	21467	bool ptr_is_const = true;
20507	21468	bool ptr_is_volatile = false;
20508		return ir_get_const_ptr(ira, &field_ptr_instruction->base,
	21469	return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
20509	21470	create_const_enum(child_type, &field->value), child_type,
20510	21471	ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
20511	21472	}
...	...	@@ -20514,37 +21475,37 @@ static IrInstruction ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstruc
20514	21475	Tld *tld = find_container_decl(ira->codegen, container_scope, field_name);
20515	21476	if (tld) {
20516	21477	if (tld->visib_mod == VisibModPrivate &&
20517		tld->import != get_scope_import(field_ptr_instruction->base.scope))
	21478	tld->import != get_scope_import(field_ptr_instruction->base.base.scope))
20518	21479	{
20519		ErrorMsg *msg = ir_add_error(ira, &field_ptr_instruction->base,
	21480	ErrorMsg *msg = ir_add_error(ira, &field_ptr_instruction->base.base,
20520	21481	buf_sprintf("'%s' is private", buf_ptr(field_name)));
20521	21482	add_error_note(ira->codegen, msg, tld->source_node, buf_sprintf("declared here"));
20522		return ira->codegen->invalid_instruction;
	21483	return ira->codegen->invalid_inst_gen;
20523	21484	}
20524		return ir_analyze_decl_ref(ira, &field_ptr_instruction->base, tld);
	21485	return ir_analyze_decl_ref(ira, &field_ptr_instruction->base.base, tld);
20525	21486	}
20526	21487	if (child_type->id == ZigTypeIdUnion &&
20527	21488	(child_type->data.unionation.decl_node->data.container_decl.init_arg_expr != nullptr \|\|
20528	21489	child_type->data.unionation.decl_node->data.container_decl.auto_enum))
20529	21490	{
20530	21491	if ((err = type_resolve(ira->codegen, child_type, ResolveStatusSizeKnown)))
20531		return ira->codegen->invalid_instruction;
	21492	return ira->codegen->invalid_inst_gen;
20532	21493	TypeUnionField *field = find_union_type_field(child_type, field_name);
20533	21494	if (field) {
20534	21495	ZigType *enum_type = child_type->data.unionation.tag_type;
20535	21496	bool ptr_is_const = true;
20536	21497	bool ptr_is_volatile = false;
20537		return ir_get_const_ptr(ira, &field_ptr_instruction->base,
	21498	return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
20538	21499	create_const_enum(enum_type, &field->enum_field->value), enum_type,
20539	21500	ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
20540	21501	}
20541	21502	}
20542	21503	const char *container_name = (child_type == ira->codegen->root_import) ?
20543	21504	"root source file" : buf_ptr(buf_sprintf("container '%s'", buf_ptr(&child_type->name)));
20544		ir_add_error(ira, &field_ptr_instruction->base,
	21505	ir_add_error(ira, &field_ptr_instruction->base.base,
20545	21506	buf_sprintf("%s has no member called '%s'",
20546	21507	container_name, buf_ptr(field_name)));
20547		return ira->codegen->invalid_instruction;
	21508	return ira->codegen->invalid_inst_gen;
20548	21509	} else if (child_type->id == ZigTypeIdErrorSet) {
20549	21510	ErrorTableEntry *err_entry;
20550	21511	ZigType *err_set_type;
...	...	@@ -20554,7 +21515,7 @@ static IrInstruction ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstruc
20554	21515	err_entry = existing_entry->value;
20555	21516	} else {
20556	21517	err_entry = allocate<ErrorTableEntry>(1);
20557		err_entry->decl_node = field_ptr_instruction->base.source_node;
	21518	err_entry->decl_node = field_ptr_instruction->base.base.source_node;
20558	21519	buf_init_from_buf(&err_entry->name, field_name);
20559	21520	size_t error_value_count = ira->codegen->errors_by_index.length;
20560	21521	assert((uint32_t)error_value_count < (((uint32_t)1) << (uint32_t)ira->codegen->err_tag_type->data.integral.bit_count));
...	...	@@ -20564,19 +21525,19 @@ static IrInstruction ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstruc
20564	21525	}
20565	21526	if (err_entry->set_with_only_this_in_it == nullptr) {
20566	21527	err_entry->set_with_only_this_in_it = make_err_set_with_one_item(ira->codegen,
20567		field_ptr_instruction->base.scope, field_ptr_instruction->base.source_node,
	21528	field_ptr_instruction->base.base.scope, field_ptr_instruction->base.base.source_node,
20568	21529	err_entry);
20569	21530	}
20570	21531	err_set_type = err_entry->set_with_only_this_in_it;
20571	21532	} else {
20572		if (!resolve_inferred_error_set(ira->codegen, child_type, field_ptr_instruction->base.source_node)) {
20573		return ira->codegen->invalid_instruction;
	21533	if (!resolve_inferred_error_set(ira->codegen, child_type, field_ptr_instruction->base.base.source_node)) {
	21534	return ira->codegen->invalid_inst_gen;
20574	21535	}
20575	21536	err_entry = find_err_table_entry(child_type, field_name);
20576	21537	if (err_entry == nullptr) {
20577		ir_add_error(ira, &field_ptr_instruction->base,
	21538	ir_add_error(ira, &field_ptr_instruction->base.base,
20578	21539	buf_sprintf("no error named '%s' in '%s'", buf_ptr(field_name), buf_ptr(&child_type->name)));
20579		return ira->codegen->invalid_instruction;
	21540	return ira->codegen->invalid_inst_gen;
20580	21541	}
20581	21542	err_set_type = child_type;
20582	21543	}
...	...	@@ -20587,13 +21548,13 @@ static IrInstruction ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstruc
20587	21548
20588	21549	bool ptr_is_const = true;
20589	21550	bool ptr_is_volatile = false;
20590		return ir_get_const_ptr(ira, &field_ptr_instruction->base, const_val,
	21551	return ir_get_const_ptr(ira, &field_ptr_instruction->base.base, const_val,
20591	21552	err_set_type, ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
20592	21553	} else if (child_type->id == ZigTypeIdInt) {
20593	21554	if (buf_eql_str(field_name, "bit_count")) {
20594	21555	bool ptr_is_const = true;
20595	21556	bool ptr_is_volatile = false;
20596		return ir_get_const_ptr(ira, &field_ptr_instruction->base,
	21557	return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
20597	21558	create_const_unsigned_negative(ira->codegen->builtin_types.entry_num_lit_int,
20598	21559	child_type->data.integral.bit_count, false),
20599	21560	ira->codegen->builtin_types.entry_num_lit_int,
...	...	@@ -20601,36 +21562,36 @@ static IrInstruction ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstruc
20601	21562	} else if (buf_eql_str(field_name, "is_signed")) {
20602	21563	bool ptr_is_const = true;
20603	21564	bool ptr_is_volatile = false;
20604		return ir_get_const_ptr(ira, &field_ptr_instruction->base,
	21565	return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
20605	21566	create_const_bool(ira->codegen, child_type->data.integral.is_signed),
20606	21567	ira->codegen->builtin_types.entry_bool,
20607	21568	ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
20608	21569	} else {
20609		ir_add_error(ira, &field_ptr_instruction->base,
	21570	ir_add_error(ira, &field_ptr_instruction->base.base,
20610	21571	buf_sprintf("type '%s' has no member called '%s'",
20611	21572	buf_ptr(&child_type->name), buf_ptr(field_name)));
20612		return ira->codegen->invalid_instruction;
	21573	return ira->codegen->invalid_inst_gen;
20613	21574	}
20614	21575	} else if (child_type->id == ZigTypeIdFloat) {
20615	21576	if (buf_eql_str(field_name, "bit_count")) {
20616	21577	bool ptr_is_const = true;
20617	21578	bool ptr_is_volatile = false;
20618		return ir_get_const_ptr(ira, &field_ptr_instruction->base,
	21579	return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
20619	21580	create_const_unsigned_negative(ira->codegen->builtin_types.entry_num_lit_int,
20620	21581	child_type->data.floating.bit_count, false),
20621	21582	ira->codegen->builtin_types.entry_num_lit_int,
20622	21583	ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
20623	21584	} else {
20624		ir_add_error(ira, &field_ptr_instruction->base,
	21585	ir_add_error(ira, &field_ptr_instruction->base.base,
20625	21586	buf_sprintf("type '%s' has no member called '%s'",
20626	21587	buf_ptr(&child_type->name), buf_ptr(field_name)));
20627		return ira->codegen->invalid_instruction;
	21588	return ira->codegen->invalid_inst_gen;
20628	21589	}
20629	21590	} else if (child_type->id == ZigTypeIdPointer) {
20630	21591	if (buf_eql_str(field_name, "Child")) {
20631	21592	bool ptr_is_const = true;
20632	21593	bool ptr_is_volatile = false;
20633		return ir_get_const_ptr(ira, &field_ptr_instruction->base,
	21594	return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
20634	21595	create_const_type(ira->codegen, child_type->data.pointer.child_type),
20635	21596	ira->codegen->builtin_types.entry_type,
20636	21597	ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
...	...	@@ -20640,75 +21601,75 @@ static IrInstruction ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstruc
20640	21601	if ((err = type_resolve(ira->codegen, child_type->data.pointer.child_type,
20641	21602	ResolveStatusAlignmentKnown)))
20642	21603	{
20643		return ira->codegen->invalid_instruction;
	21604	return ira->codegen->invalid_inst_gen;
20644	21605	}
20645		return ir_get_const_ptr(ira, &field_ptr_instruction->base,
	21606	return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
20646	21607	create_const_unsigned_negative(ira->codegen->builtin_types.entry_num_lit_int,
20647	21608	get_ptr_align(ira->codegen, child_type), false),
20648	21609	ira->codegen->builtin_types.entry_num_lit_int,
20649	21610	ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
20650	21611	} else {
20651		ir_add_error(ira, &field_ptr_instruction->base,
	21612	ir_add_error(ira, &field_ptr_instruction->base.base,
20652	21613	buf_sprintf("type '%s' has no member called '%s'",
20653	21614	buf_ptr(&child_type->name), buf_ptr(field_name)));
20654		return ira->codegen->invalid_instruction;
	21615	return ira->codegen->invalid_inst_gen;
20655	21616	}
20656	21617	} else if (child_type->id == ZigTypeIdArray) {
20657	21618	if (buf_eql_str(field_name, "Child")) {
20658	21619	bool ptr_is_const = true;
20659	21620	bool ptr_is_volatile = false;
20660		return ir_get_const_ptr(ira, &field_ptr_instruction->base,
	21621	return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
20661	21622	create_const_type(ira->codegen, child_type->data.array.child_type),
20662	21623	ira->codegen->builtin_types.entry_type,
20663	21624	ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
20664	21625	} else if (buf_eql_str(field_name, "len")) {
20665	21626	bool ptr_is_const = true;
20666	21627	bool ptr_is_volatile = false;
20667		return ir_get_const_ptr(ira, &field_ptr_instruction->base,
	21628	return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
20668	21629	create_const_unsigned_negative(ira->codegen->builtin_types.entry_num_lit_int,
20669	21630	child_type->data.array.len, false),
20670	21631	ira->codegen->builtin_types.entry_num_lit_int,
20671	21632	ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
20672	21633	} else {
20673		ir_add_error(ira, &field_ptr_instruction->base,
	21634	ir_add_error(ira, &field_ptr_instruction->base.base,
20674	21635	buf_sprintf("type '%s' has no member called '%s'",
20675	21636	buf_ptr(&child_type->name), buf_ptr(field_name)));
20676		return ira->codegen->invalid_instruction;
	21637	return ira->codegen->invalid_inst_gen;
20677	21638	}
20678	21639	} else if (child_type->id == ZigTypeIdErrorUnion) {
20679	21640	if (buf_eql_str(field_name, "Payload")) {
20680	21641	bool ptr_is_const = true;
20681	21642	bool ptr_is_volatile = false;
20682		return ir_get_const_ptr(ira, &field_ptr_instruction->base,
	21643	return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
20683	21644	create_const_type(ira->codegen, child_type->data.error_union.payload_type),
20684	21645	ira->codegen->builtin_types.entry_type,
20685	21646	ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
20686	21647	} else if (buf_eql_str(field_name, "ErrorSet")) {
20687	21648	bool ptr_is_const = true;
20688	21649	bool ptr_is_volatile = false;
20689		return ir_get_const_ptr(ira, &field_ptr_instruction->base,
	21650	return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
20690	21651	create_const_type(ira->codegen, child_type->data.error_union.err_set_type),
20691	21652	ira->codegen->builtin_types.entry_type,
20692	21653	ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
20693	21654	} else {
20694		ir_add_error(ira, &field_ptr_instruction->base,
	21655	ir_add_error(ira, &field_ptr_instruction->base.base,
20695	21656	buf_sprintf("type '%s' has no member called '%s'",
20696	21657	buf_ptr(&child_type->name), buf_ptr(field_name)));
20697		return ira->codegen->invalid_instruction;
	21658	return ira->codegen->invalid_inst_gen;
20698	21659	}
20699	21660	} else if (child_type->id == ZigTypeIdOptional) {
20700	21661	if (buf_eql_str(field_name, "Child")) {
20701	21662	bool ptr_is_const = true;
20702	21663	bool ptr_is_volatile = false;
20703		return ir_get_const_ptr(ira, &field_ptr_instruction->base,
	21664	return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
20704	21665	create_const_type(ira->codegen, child_type->data.maybe.child_type),
20705	21666	ira->codegen->builtin_types.entry_type,
20706	21667	ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
20707	21668	} else {
20708		ir_add_error(ira, &field_ptr_instruction->base,
	21669	ir_add_error(ira, &field_ptr_instruction->base.base,
20709	21670	buf_sprintf("type '%s' has no member called '%s'",
20710	21671	buf_ptr(&child_type->name), buf_ptr(field_name)));
20711		return ira->codegen->invalid_instruction;
	21672	return ira->codegen->invalid_inst_gen;
20712	21673	}
20713	21674	} else if (child_type->id == ZigTypeIdFn) {
20714	21675	if (buf_eql_str(field_name, "ReturnType")) {
...	...	@@ -20716,121 +21677,121 @@ static IrInstruction ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstruc
20716	21677	// Return type can only ever be null, if the function is generic
20717	21678	assert(child_type->data.fn.is_generic);
20718	21679
20719		ir_add_error(ira, &field_ptr_instruction->base,
	21680	ir_add_error(ira, &field_ptr_instruction->base.base,
20720	21681	buf_sprintf("ReturnType has not been resolved because '%s' is generic", buf_ptr(&child_type->name)));
20721		return ira->codegen->invalid_instruction;
	21682	return ira->codegen->invalid_inst_gen;
20722	21683	}
20723	21684
20724	21685	bool ptr_is_const = true;
20725	21686	bool ptr_is_volatile = false;
20726		return ir_get_const_ptr(ira, &field_ptr_instruction->base,
	21687	return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
20727	21688	create_const_type(ira->codegen, child_type->data.fn.fn_type_id.return_type),
20728	21689	ira->codegen->builtin_types.entry_type,
20729	21690	ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
20730	21691	} else if (buf_eql_str(field_name, "is_var_args")) {
20731	21692	bool ptr_is_const = true;
20732	21693	bool ptr_is_volatile = false;
20733		return ir_get_const_ptr(ira, &field_ptr_instruction->base,
	21694	return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
20734	21695	create_const_bool(ira->codegen, child_type->data.fn.fn_type_id.is_var_args),
20735	21696	ira->codegen->builtin_types.entry_bool,
20736	21697	ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
20737	21698	} else if (buf_eql_str(field_name, "arg_count")) {
20738	21699	bool ptr_is_const = true;
20739	21700	bool ptr_is_volatile = false;
20740		return ir_get_const_ptr(ira, &field_ptr_instruction->base,
	21701	return ir_get_const_ptr(ira, &field_ptr_instruction->base.base,
20741	21702	create_const_usize(ira->codegen, child_type->data.fn.fn_type_id.param_count),
20742	21703	ira->codegen->builtin_types.entry_usize,
20743	21704	ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile, 0);
20744	21705	} else {
20745		ir_add_error(ira, &field_ptr_instruction->base,
	21706	ir_add_error(ira, &field_ptr_instruction->base.base,
20746	21707	buf_sprintf("type '%s' has no member called '%s'",
20747	21708	buf_ptr(&child_type->name), buf_ptr(field_name)));
20748		return ira->codegen->invalid_instruction;
	21709	return ira->codegen->invalid_inst_gen;
20749	21710	}
20750	21711	} else {
20751		ir_add_error(ira, &field_ptr_instruction->base,
	21712	ir_add_error(ira, &field_ptr_instruction->base.base,
20752	21713	buf_sprintf("type '%s' does not support field access", buf_ptr(&child_type->name)));
20753		return ira->codegen->invalid_instruction;
	21714	return ira->codegen->invalid_inst_gen;
20754	21715	}
20755	21716	} else if (field_ptr_instruction->initializing) {
20756		ir_add_error(ira, &field_ptr_instruction->base,
	21717	ir_add_error(ira, &field_ptr_instruction->base.base,
20757	21718	buf_sprintf("type '%s' does not support struct initialization syntax", buf_ptr(&container_type->name)));
20758		return ira->codegen->invalid_instruction;
	21719	return ira->codegen->invalid_inst_gen;
20759	21720	} else {
20760		ir_add_error_node(ira, field_ptr_instruction->base.source_node,
	21721	ir_add_error_node(ira, field_ptr_instruction->base.base.source_node,
20761	21722	buf_sprintf("type '%s' does not support field access", buf_ptr(&container_type->name)));
20762		return ira->codegen->invalid_instruction;
	21723	return ira->codegen->invalid_inst_gen;
20763	21724	}
20764	21725	}
20765	21726
20766		static IrInstruction ir_analyze_instruction_store_ptr(IrAnalyze ira, IrInstructionStorePtr *instruction) {
20767		IrInstruction *ptr = instruction->ptr->child;
	21727	static IrInstGen ir_analyze_instruction_store_ptr(IrAnalyze ira, IrInstSrcStorePtr *instruction) {
	21728	IrInstGen *ptr = instruction->ptr->child;
20768	21729	if (type_is_invalid(ptr->value->type))
20769		return ira->codegen->invalid_instruction;
	21730	return ira->codegen->invalid_inst_gen;
20770	21731
20771		IrInstruction *value = instruction->value->child;
	21732	IrInstGen *value = instruction->value->child;
20772	21733	if (type_is_invalid(value->value->type))
20773		return ira->codegen->invalid_instruction;
	21734	return ira->codegen->invalid_inst_gen;
20774	21735
20775		return ir_analyze_store_ptr(ira, &instruction->base, ptr, value, instruction->allow_write_through_const);
	21736	return ir_analyze_store_ptr(ira, &instruction->base.base, ptr, value, instruction->allow_write_through_const);
20776	21737	}
20777	21738
20778		static IrInstruction ir_analyze_instruction_load_ptr(IrAnalyze ira, IrInstructionLoadPtr *instruction) {
20779		IrInstruction *ptr = instruction->ptr->child;
	21739	static IrInstGen ir_analyze_instruction_load_ptr(IrAnalyze ira, IrInstSrcLoadPtr *instruction) {
	21740	IrInstGen *ptr = instruction->ptr->child;
20780	21741	if (type_is_invalid(ptr->value->type))
20781		return ira->codegen->invalid_instruction;
20782		return ir_get_deref(ira, &instruction->base, ptr, nullptr);
	21742	return ira->codegen->invalid_inst_gen;
	21743	return ir_get_deref(ira, &instruction->base.base, ptr, nullptr);
20783	21744	}
20784	21745
20785		static IrInstruction ir_analyze_instruction_typeof(IrAnalyze ira, IrInstructionTypeOf *typeof_instruction) {
20786		IrInstruction *expr_value = typeof_instruction->value->child;
	21746	static IrInstGen ir_analyze_instruction_typeof(IrAnalyze ira, IrInstSrcTypeOf *typeof_instruction) {
	21747	IrInstGen *expr_value = typeof_instruction->value->child;
20787	21748	ZigType *type_entry = expr_value->value->type;
20788	21749	if (type_is_invalid(type_entry))
20789		return ira->codegen->invalid_instruction;
20790		return ir_const_type(ira, &typeof_instruction->base, type_entry);
	21750	return ira->codegen->invalid_inst_gen;
	21751	return ir_const_type(ira, &typeof_instruction->base.base, type_entry);
20791	21752	}
20792	21753
20793		static IrInstruction ir_analyze_instruction_set_cold(IrAnalyze ira, IrInstructionSetCold *instruction) {
	21754	static IrInstGen ir_analyze_instruction_set_cold(IrAnalyze ira, IrInstSrcSetCold *instruction) {
20794	21755	if (ira->new_irb.exec->is_inline) {
20795	21756	// ignore setCold when running functions at compile time
20796		return ir_const_void(ira, &instruction->base);
	21757	return ir_const_void(ira, &instruction->base.base);
20797	21758	}
20798	21759
20799		IrInstruction *is_cold_value = instruction->is_cold->child;
	21760	IrInstGen *is_cold_value = instruction->is_cold->child;
20800	21761	bool want_cold;
20801	21762	if (!ir_resolve_bool(ira, is_cold_value, &want_cold))
20802		return ira->codegen->invalid_instruction;
	21763	return ira->codegen->invalid_inst_gen;
20803	21764
20804		ZigFn *fn_entry = scope_fn_entry(instruction->base.scope);
	21765	ZigFn *fn_entry = scope_fn_entry(instruction->base.base.scope);
20805	21766	if (fn_entry == nullptr) {
20806		ir_add_error(ira, &instruction->base, buf_sprintf("@setCold outside function"));
20807		return ira->codegen->invalid_instruction;
	21767	ir_add_error(ira, &instruction->base.base, buf_sprintf("@setCold outside function"));
	21768	return ira->codegen->invalid_inst_gen;
20808	21769	}
20809	21770
20810	21771	if (fn_entry->set_cold_node != nullptr) {
20811		ErrorMsg *msg = ir_add_error(ira, &instruction->base, buf_sprintf("cold set twice in same function"));
	21772	ErrorMsg *msg = ir_add_error(ira, &instruction->base.base, buf_sprintf("cold set twice in same function"));
20812	21773	add_error_note(ira->codegen, msg, fn_entry->set_cold_node, buf_sprintf("first set here"));
20813		return ira->codegen->invalid_instruction;
	21774	return ira->codegen->invalid_inst_gen;
20814	21775	}
20815	21776
20816		fn_entry->set_cold_node = instruction->base.source_node;
	21777	fn_entry->set_cold_node = instruction->base.base.source_node;
20817	21778	fn_entry->is_cold = want_cold;
20818	21779
20819		return ir_const_void(ira, &instruction->base);
	21780	return ir_const_void(ira, &instruction->base.base);
20820	21781	}
20821	21782
20822		static IrInstruction ir_analyze_instruction_set_runtime_safety(IrAnalyze ira,
20823		IrInstructionSetRuntimeSafety *set_runtime_safety_instruction)
	21783	static IrInstGen ir_analyze_instruction_set_runtime_safety(IrAnalyze ira,
	21784	IrInstSrcSetRuntimeSafety *set_runtime_safety_instruction)
20824	21785	{
20825	21786	if (ira->new_irb.exec->is_inline) {
20826	21787	// ignore setRuntimeSafety when running functions at compile time
20827		return ir_const_void(ira, &set_runtime_safety_instruction->base);
	21788	return ir_const_void(ira, &set_runtime_safety_instruction->base.base);
20828	21789	}
20829	21790
20830	21791	bool *safety_off_ptr;
20831	21792	AstNode **safety_set_node_ptr;
20832	21793
20833		Scope *scope = set_runtime_safety_instruction->base.scope;
	21794	Scope *scope = set_runtime_safety_instruction->base.base.scope;
20834	21795	while (scope != nullptr) {
20835	21796	if (scope->id == ScopeIdBlock) {
20836	21797	ScopeBlock block_scope = (ScopeBlock )scope;
...	...	@@ -20856,36 +21817,36 @@ static IrInstruction ir_analyze_instruction_set_runtime_safety(IrAnalyze ira,
20856	21817	}
20857	21818	assert(scope != nullptr);
20858	21819
20859		IrInstruction *safety_on_value = set_runtime_safety_instruction->safety_on->child;
	21820	IrInstGen *safety_on_value = set_runtime_safety_instruction->safety_on->child;
20860	21821	bool want_runtime_safety;
20861	21822	if (!ir_resolve_bool(ira, safety_on_value, &want_runtime_safety))
20862		return ira->codegen->invalid_instruction;
	21823	return ira->codegen->invalid_inst_gen;
20863	21824
20864		AstNode *source_node = set_runtime_safety_instruction->base.source_node;
	21825	AstNode *source_node = set_runtime_safety_instruction->base.base.source_node;
20865	21826	if (*safety_set_node_ptr) {
20866	21827	ErrorMsg *msg = ir_add_error_node(ira, source_node,
20867	21828	buf_sprintf("runtime safety set twice for same scope"));
20868	21829	add_error_note(ira->codegen, msg, *safety_set_node_ptr, buf_sprintf("first set here"));
20869		return ira->codegen->invalid_instruction;
	21830	return ira->codegen->invalid_inst_gen;
20870	21831	}
20871	21832	*safety_set_node_ptr = source_node;
20872	21833	*safety_off_ptr = !want_runtime_safety;
20873	21834
20874		return ir_const_void(ira, &set_runtime_safety_instruction->base);
	21835	return ir_const_void(ira, &set_runtime_safety_instruction->base.base);
20875	21836	}
20876	21837
20877		static IrInstruction ir_analyze_instruction_set_float_mode(IrAnalyze ira,
20878		IrInstructionSetFloatMode *instruction)
	21838	static IrInstGen ir_analyze_instruction_set_float_mode(IrAnalyze ira,
	21839	IrInstSrcSetFloatMode *instruction)
20879	21840	{
20880	21841	if (ira->new_irb.exec->is_inline) {
20881	21842	// ignore setFloatMode when running functions at compile time
20882		return ir_const_void(ira, &instruction->base);
	21843	return ir_const_void(ira, &instruction->base.base);
20883	21844	}
20884	21845
20885	21846	bool *fast_math_on_ptr;
20886	21847	AstNode **fast_math_set_node_ptr;
20887	21848
20888		Scope *scope = instruction->base.scope;
	21849	Scope *scope = instruction->base.base.scope;
20889	21850	while (scope != nullptr) {
20890	21851	if (scope->id == ScopeIdBlock) {
20891	21852	ScopeBlock block_scope = (ScopeBlock )scope;
...	...	@@ -20911,42 +21872,38 @@ static IrInstruction ir_analyze_instruction_set_float_mode(IrAnalyze ira,
20911	21872	}
20912	21873	assert(scope != nullptr);
20913	21874
20914		IrInstruction *float_mode_value = instruction->mode_value->child;
	21875	IrInstGen *float_mode_value = instruction->mode_value->child;
20915	21876	FloatMode float_mode_scalar;
20916	21877	if (!ir_resolve_float_mode(ira, float_mode_value, &float_mode_scalar))
20917		return ira->codegen->invalid_instruction;
	21878	return ira->codegen->invalid_inst_gen;
20918	21879
20919		AstNode *source_node = instruction->base.source_node;
	21880	AstNode *source_node = instruction->base.base.source_node;
20920	21881	if (*fast_math_set_node_ptr) {
20921	21882	ErrorMsg *msg = ir_add_error_node(ira, source_node,
20922	21883	buf_sprintf("float mode set twice for same scope"));
20923	21884	add_error_note(ira->codegen, msg, *fast_math_set_node_ptr, buf_sprintf("first set here"));
20924		return ira->codegen->invalid_instruction;
	21885	return ira->codegen->invalid_inst_gen;
20925	21886	}
20926	21887	*fast_math_set_node_ptr = source_node;
20927	21888	*fast_math_on_ptr = (float_mode_scalar == FloatModeOptimized);
20928	21889
20929		return ir_const_void(ira, &instruction->base);
	21890	return ir_const_void(ira, &instruction->base.base);
20930	21891	}
20931	21892
20932		static IrInstruction ir_analyze_instruction_any_frame_type(IrAnalyze ira,
20933		IrInstructionAnyFrameType *instruction)
20934		{
	21893	static IrInstGen ir_analyze_instruction_any_frame_type(IrAnalyze ira, IrInstSrcAnyFrameType *instruction) {
20935	21894	ZigType *payload_type = nullptr;
20936	21895	if (instruction->payload_type != nullptr) {
20937	21896	payload_type = ir_resolve_type(ira, instruction->payload_type->child);
20938	21897	if (type_is_invalid(payload_type))
20939		return ira->codegen->invalid_instruction;
	21898	return ira->codegen->invalid_inst_gen;
20940	21899	}
20941	21900
20942	21901	ZigType *any_frame_type = get_any_frame_type(ira->codegen, payload_type);
20943		return ir_const_type(ira, &instruction->base, any_frame_type);
	21902	return ir_const_type(ira, &instruction->base.base, any_frame_type);
20944	21903	}
20945	21904
20946		static IrInstruction ir_analyze_instruction_slice_type(IrAnalyze ira,
20947		IrInstructionSliceType *slice_type_instruction)
20948		{
20949		IrInstruction *result = ir_const(ira, &slice_type_instruction->base, ira->codegen->builtin_types.entry_type);
	21905	static IrInstGen ir_analyze_instruction_slice_type(IrAnalyze ira, IrInstSrcSliceType *slice_type_instruction) {
	21906	IrInstGen *result = ir_const(ira, &slice_type_instruction->base.base, ira->codegen->builtin_types.entry_type);
20950	21907	result->value->special = ConstValSpecialLazy;
20951	21908
20952	21909	LazyValueSliceType *lazy_slice_type = allocate<LazyValueSliceType>(1, "LazyValueSliceType");
...	...	@@ -20957,18 +21914,18 @@ static IrInstruction ir_analyze_instruction_slice_type(IrAnalyze ira,
20957	21914	if (slice_type_instruction->align_value != nullptr) {
20958	21915	lazy_slice_type->align_inst = slice_type_instruction->align_value->child;
20959	21916	if (ir_resolve_const(ira, lazy_slice_type->align_inst, LazyOk) == nullptr)
20960		return ira->codegen->invalid_instruction;
	21917	return ira->codegen->invalid_inst_gen;
20961	21918	}
20962	21919
20963	21920	if (slice_type_instruction->sentinel != nullptr) {
20964	21921	lazy_slice_type->sentinel = slice_type_instruction->sentinel->child;
20965	21922	if (ir_resolve_const(ira, lazy_slice_type->sentinel, LazyOk) == nullptr)
20966		return ira->codegen->invalid_instruction;
	21923	return ira->codegen->invalid_inst_gen;
20967	21924	}
20968	21925
20969	21926	lazy_slice_type->elem_type = slice_type_instruction->child_type->child;
20970	21927	if (ir_resolve_type_lazy(ira, lazy_slice_type->elem_type) == nullptr)
20971		return ira->codegen->invalid_instruction;
	21928	return ira->codegen->invalid_inst_gen;
20972	21929
20973	21930	lazy_slice_type->is_const = slice_type_instruction->is_const;
20974	21931	lazy_slice_type->is_volatile = slice_type_instruction->is_volatile;
...	...	@@ -20977,31 +21934,31 @@ static IrInstruction ir_analyze_instruction_slice_type(IrAnalyze ira,
20977	21934	return result;
20978	21935	}
20979	21936
20980		static IrInstruction ir_analyze_instruction_asm(IrAnalyze ira, IrInstructionAsmSrc *asm_instruction) {
	21937	static IrInstGen ir_analyze_instruction_asm(IrAnalyze ira, IrInstSrcAsm *asm_instruction) {
20981	21938	Error err;
20982	21939
20983		assert(asm_instruction->base.source_node->type == NodeTypeAsmExpr);
	21940	assert(asm_instruction->base.base.source_node->type == NodeTypeAsmExpr);
20984	21941
20985		AstNode *node = asm_instruction->base.source_node;
20986		AstNodeAsmExpr *asm_expr = &asm_instruction->base.source_node->data.asm_expr;
	21942	AstNode *node = asm_instruction->base.base.source_node;
	21943	AstNodeAsmExpr *asm_expr = &asm_instruction->base.base.source_node->data.asm_expr;
20987	21944
20988	21945	Buf *template_buf = ir_resolve_str(ira, asm_instruction->asm_template->child);
20989	21946	if (template_buf == nullptr)
20990		return ira->codegen->invalid_instruction;
	21947	return ira->codegen->invalid_inst_gen;
20991	21948
20992	21949	if (asm_instruction->is_global) {
20993	21950	buf_append_char(&ira->codegen->global_asm, '\n');
20994	21951	buf_append_buf(&ira->codegen->global_asm, template_buf);
20995	21952
20996		return ir_const_void(ira, &asm_instruction->base);
	21953	return ir_const_void(ira, &asm_instruction->base.base);
20997	21954	}
20998	21955
20999		if (!ir_emit_global_runtime_side_effect(ira, &asm_instruction->base))
21000		return ira->codegen->invalid_instruction;
	21956	if (!ir_emit_global_runtime_side_effect(ira, &asm_instruction->base.base))
	21957	return ira->codegen->invalid_inst_gen;
21001	21958
21002	21959	ZigList<AsmToken> tok_list = {};
21003	21960	if ((err = parse_asm_template(ira, node, template_buf, &tok_list))) {
21004		return ira->codegen->invalid_instruction;
	21961	return ira->codegen->invalid_inst_gen;
21005	21962	}
21006	21963
21007	21964	for (size_t token_i = 0; token_i < tok_list.length; token_i += 1) {
...	...	@@ -21015,15 +21972,15 @@ static IrInstruction ir_analyze_instruction_asm(IrAnalyze ira, IrInstructionAs
21015	21972	add_node_error(ira->codegen, node,
21016	21973	buf_sprintf("could not find '%.*s' in the inputs or outputs",
21017	21974	len, ptr));
21018		return ira->codegen->invalid_instruction;
	21975	return ira->codegen->invalid_inst_gen;
21019	21976	}
21020	21977	}
21021	21978	}
21022	21979
21023	21980	// TODO validate the output types and variable types
21024	21981
21025		IrInstruction *input_list = allocate<IrInstruction >(asm_expr->input_list.length);
21026		IrInstruction *output_types = allocate<IrInstruction >(asm_expr->output_list.length);
	21982	IrInstGen *input_list = allocate<IrInstGen >(asm_expr->input_list.length);
	21983	IrInstGen *output_types = allocate<IrInstGen >(asm_expr->output_list.length);
21027	21984
21028	21985	ZigType *return_type = ira->codegen->builtin_types.entry_void;
21029	21986	for (size_t i = 0; i < asm_expr->output_list.length; i += 1) {
...	...	@@ -21032,39 +21989,34 @@ static IrInstruction ir_analyze_instruction_asm(IrAnalyze ira, IrInstructionAs
21032	21989	output_types[i] = asm_instruction->output_types[i]->child;
21033	21990	return_type = ir_resolve_type(ira, output_types[i]);
21034	21991	if (type_is_invalid(return_type))
21035		return ira->codegen->invalid_instruction;
	21992	return ira->codegen->invalid_inst_gen;
21036	21993	}
21037	21994	}
21038	21995
21039	21996	for (size_t i = 0; i < asm_expr->input_list.length; i += 1) {
21040		IrInstruction *const input_value = asm_instruction->input_list[i]->child;
	21997	IrInstGen *const input_value = asm_instruction->input_list[i]->child;
21041	21998	if (type_is_invalid(input_value->value->type))
21042		return ira->codegen->invalid_instruction;
	21999	return ira->codegen->invalid_inst_gen;
21043	22000
21044	22001	if (instr_is_comptime(input_value) &&
21045	22002	(input_value->value->type->id == ZigTypeIdComptimeInt \|\|
21046	22003	input_value->value->type->id == ZigTypeIdComptimeFloat)) {
21047		ir_add_error_node(ira, input_value->source_node,
	22004	ir_add_error(ira, &input_value->base,
21048	22005	buf_sprintf("expected sized integer or sized float, found %s", buf_ptr(&input_value->value->type->name)));
21049		return ira->codegen->invalid_instruction;
	22006	return ira->codegen->invalid_inst_gen;
21050	22007	}
21051	22008
21052	22009	input_list[i] = input_value;
21053	22010	}
21054	22011
21055		IrInstruction *result = ir_build_asm_gen(ira,
21056		asm_instruction->base.scope, asm_instruction->base.source_node,
	22012	return ir_build_asm_gen(ira, &asm_instruction->base.base,
21057	22013	template_buf, tok_list.items, tok_list.length,
21058	22014	input_list, output_types, asm_instruction->output_vars, asm_instruction->return_count,
21059		asm_instruction->has_side_effects);
21060		result->value->type = return_type;
21061		return result;
	22015	asm_instruction->has_side_effects, return_type);
21062	22016	}
21063	22017
21064		static IrInstruction ir_analyze_instruction_array_type(IrAnalyze ira,
21065		IrInstructionArrayType *array_type_instruction)
21066		{
21067		IrInstruction *result = ir_const(ira, &array_type_instruction->base, ira->codegen->builtin_types.entry_type);
	22018	static IrInstGen ir_analyze_instruction_array_type(IrAnalyze ira, IrInstSrcArrayType *array_type_instruction) {
	22019	IrInstGen *result = ir_const(ira, &array_type_instruction->base.base, ira->codegen->builtin_types.entry_type);
21068	22020	result->value->special = ConstValSpecialLazy;
21069	22021
21070	22022	LazyValueArrayType *lazy_array_type = allocate<LazyValueArrayType>(1, "LazyValueArrayType");
...	...	@@ -21074,22 +22026,22 @@ static IrInstruction ir_analyze_instruction_array_type(IrAnalyze ira,
21074	22026
21075	22027	lazy_array_type->elem_type = array_type_instruction->child_type->child;
21076	22028	if (ir_resolve_type_lazy(ira, lazy_array_type->elem_type) == nullptr)
21077		return ira->codegen->invalid_instruction;
	22029	return ira->codegen->invalid_inst_gen;
21078	22030
21079	22031	if (!ir_resolve_usize(ira, array_type_instruction->size->child, &lazy_array_type->length))
21080		return ira->codegen->invalid_instruction;
	22032	return ira->codegen->invalid_inst_gen;
21081	22033
21082	22034	if (array_type_instruction->sentinel != nullptr) {
21083	22035	lazy_array_type->sentinel = array_type_instruction->sentinel->child;
21084	22036	if (ir_resolve_const(ira, lazy_array_type->sentinel, LazyOk) == nullptr)
21085		return ira->codegen->invalid_instruction;
	22037	return ira->codegen->invalid_inst_gen;
21086	22038	}
21087	22039
21088	22040	return result;
21089	22041	}
21090	22042
21091		static IrInstruction ir_analyze_instruction_size_of(IrAnalyze ira, IrInstructionSizeOf *instruction) {
21092		IrInstruction *result = ir_const(ira, &instruction->base, ira->codegen->builtin_types.entry_num_lit_int);
	22043	static IrInstGen ir_analyze_instruction_size_of(IrAnalyze ira, IrInstSrcSizeOf *instruction) {
	22044	IrInstGen *result = ir_const(ira, &instruction->base.base, ira->codegen->builtin_types.entry_num_lit_int);
21093	22045	result->value->special = ConstValSpecialLazy;
21094	22046
21095	22047	LazyValueSizeOf *lazy_size_of = allocate<LazyValueSizeOf>(1, "LazyValueSizeOf");
...	...	@@ -21100,19 +22052,19 @@ static IrInstruction ir_analyze_instruction_size_of(IrAnalyze ira, IrInstructi
21100	22052
21101	22053	lazy_size_of->target_type = instruction->type_value->child;
21102	22054	if (ir_resolve_type_lazy(ira, lazy_size_of->target_type) == nullptr)
21103		return ira->codegen->invalid_instruction;
	22055	return ira->codegen->invalid_inst_gen;
21104	22056
21105	22057	return result;
21106	22058	}
21107	22059
21108		static IrInstruction ir_analyze_test_non_null(IrAnalyze ira, IrInstruction source_inst, IrInstruction value) {
	22060	static IrInstGen ir_analyze_test_non_null(IrAnalyze ira, IrInst source_inst, IrInstGen value) {
21109	22061	ZigType *type_entry = value->value->type;
21110	22062
21111	22063	if (type_entry->id == ZigTypeIdPointer && type_entry->data.pointer.allow_zero) {
21112	22064	if (instr_is_comptime(value)) {
21113	22065	ZigValue *c_ptr_val = ir_resolve_const(ira, value, UndefOk);
21114	22066	if (c_ptr_val == nullptr)
21115		return ira->codegen->invalid_instruction;
	22067	return ira->codegen->invalid_inst_gen;
21116	22068	if (c_ptr_val->special == ConstValSpecialUndef)
21117	22069	return ir_const_undef(ira, source_inst, ira->codegen->builtin_types.entry_bool);
21118	22070	bool is_null = c_ptr_val->data.x_ptr.special == ConstPtrSpecialNull \|\|
...	...	@@ -21121,25 +22073,19 @@ static IrInstruction ir_analyze_test_non_null(IrAnalyze ira, IrInstruction *so
21121	22073	return ir_const_bool(ira, source_inst, !is_null);
21122	22074	}
21123	22075
21124		IrInstruction *result = ir_build_test_nonnull(&ira->new_irb,
21125		source_inst->scope, source_inst->source_node, value);
21126		result->value->type = ira->codegen->builtin_types.entry_bool;
21127		return result;
	22076	return ir_build_test_non_null_gen(ira, source_inst, value);
21128	22077	} else if (type_entry->id == ZigTypeIdOptional) {
21129	22078	if (instr_is_comptime(value)) {
21130	22079	ZigValue *maybe_val = ir_resolve_const(ira, value, UndefOk);
21131	22080	if (maybe_val == nullptr)
21132		return ira->codegen->invalid_instruction;
	22081	return ira->codegen->invalid_inst_gen;
21133	22082	if (maybe_val->special == ConstValSpecialUndef)
21134	22083	return ir_const_undef(ira, source_inst, ira->codegen->builtin_types.entry_bool);
21135	22084
21136	22085	return ir_const_bool(ira, source_inst, !optional_value_is_null(maybe_val));
21137	22086	}
21138	22087
21139		IrInstruction *result = ir_build_test_nonnull(&ira->new_irb,
21140		source_inst->scope, source_inst->source_node, value);
21141		result->value->type = ira->codegen->builtin_types.entry_bool;
21142		return result;
	22088	return ir_build_test_non_null_gen(ira, source_inst, value);
21143	22089	} else if (type_entry->id == ZigTypeIdNull) {
21144	22090	return ir_const_bool(ira, source_inst, false);
21145	22091	} else {
...	...	@@ -21147,51 +22093,51 @@ static IrInstruction ir_analyze_test_non_null(IrAnalyze ira, IrInstruction *so
21147	22093	}
21148	22094	}
21149	22095
21150		static IrInstruction ir_analyze_instruction_test_non_null(IrAnalyze ira, IrInstructionTestNonNull *instruction) {
21151		IrInstruction *value = instruction->value->child;
	22096	static IrInstGen ir_analyze_instruction_test_non_null(IrAnalyze ira, IrInstSrcTestNonNull *instruction) {
	22097	IrInstGen *value = instruction->value->child;
21152	22098	if (type_is_invalid(value->value->type))
21153		return ira->codegen->invalid_instruction;
	22099	return ira->codegen->invalid_inst_gen;
21154	22100
21155		return ir_analyze_test_non_null(ira, &instruction->base, value);
	22101	return ir_analyze_test_non_null(ira, &instruction->base.base, value);
21156	22102	}
21157	22103
21158		static IrInstruction ir_analyze_unwrap_optional_payload(IrAnalyze ira, IrInstruction *source_instr,
21159		IrInstruction *base_ptr, bool safety_check_on, bool initializing)
	22104	static IrInstGen ir_analyze_unwrap_optional_payload(IrAnalyze ira, IrInst* source_instr,
	22105	IrInstGen *base_ptr, bool safety_check_on, bool initializing)
21160	22106	{
21161	22107	ZigType *type_entry = get_ptr_elem_type(ira->codegen, base_ptr);
21162	22108	if (type_is_invalid(type_entry))
21163		return ira->codegen->invalid_instruction;
	22109	return ira->codegen->invalid_inst_gen;
21164	22110
21165	22111	if (type_entry->id == ZigTypeIdPointer && type_entry->data.pointer.ptr_len == PtrLenC) {
21166	22112	if (instr_is_comptime(base_ptr)) {
21167	22113	ZigValue *val = ir_resolve_const(ira, base_ptr, UndefBad);
21168	22114	if (!val)
21169		return ira->codegen->invalid_instruction;
	22115	return ira->codegen->invalid_inst_gen;
21170	22116	if (val->data.x_ptr.mut != ConstPtrMutRuntimeVar) {
21171	22117	ZigValue *c_ptr_val = const_ptr_pointee(ira, ira->codegen, val, source_instr->source_node);
21172	22118	if (c_ptr_val == nullptr)
21173		return ira->codegen->invalid_instruction;
	22119	return ira->codegen->invalid_inst_gen;
21174	22120	bool is_null = c_ptr_val->data.x_ptr.special == ConstPtrSpecialNull \|\|
21175	22121	(c_ptr_val->data.x_ptr.special == ConstPtrSpecialHardCodedAddr &&
21176	22122	c_ptr_val->data.x_ptr.data.hard_coded_addr.addr == 0);
21177	22123	if (is_null) {
21178	22124	ir_add_error(ira, source_instr, buf_sprintf("unable to unwrap null"));
21179		return ira->codegen->invalid_instruction;
	22125	return ira->codegen->invalid_inst_gen;
21180	22126	}
21181	22127	return base_ptr;
21182	22128	}
21183	22129	}
21184	22130	if (!safety_check_on)
21185	22131	return base_ptr;
21186		IrInstruction *c_ptr_val = ir_get_deref(ira, source_instr, base_ptr, nullptr);
	22132	IrInstGen *c_ptr_val = ir_get_deref(ira, source_instr, base_ptr, nullptr);
21187	22133	ir_build_assert_non_null(ira, source_instr, c_ptr_val);
21188	22134	return base_ptr;
21189	22135	}
21190	22136
21191	22137	if (type_entry->id != ZigTypeIdOptional) {
21192		ir_add_error_node(ira, base_ptr->source_node,
	22138	ir_add_error(ira, &base_ptr->base,
21193	22139	buf_sprintf("expected optional type, found '%s'", buf_ptr(&type_entry->name)));
21194		return ira->codegen->invalid_instruction;
	22140	return ira->codegen->invalid_inst_gen;
21195	22141	}
21196	22142
21197	22143	ZigType *child_type = type_entry->data.maybe.child_type;
...	...	@@ -21204,16 +22150,16 @@ static IrInstruction ir_analyze_unwrap_optional_payload(IrAnalyze ira, IrInstr
21204	22150	if (instr_is_comptime(base_ptr)) {
21205	22151	ZigValue *ptr_val = ir_resolve_const(ira, base_ptr, UndefBad);
21206	22152	if (!ptr_val)
21207		return ira->codegen->invalid_instruction;
	22153	return ira->codegen->invalid_inst_gen;
21208	22154	if (ptr_val->data.x_ptr.mut != ConstPtrMutRuntimeVar) {
21209	22155	ZigValue *optional_val = const_ptr_pointee(ira, ira->codegen, ptr_val, source_instr->source_node);
21210	22156	if (optional_val == nullptr)
21211		return ira->codegen->invalid_instruction;
	22157	return ira->codegen->invalid_inst_gen;
21212	22158
21213	22159	if (initializing) {
21214	22160	switch (type_has_one_possible_value(ira->codegen, child_type)) {
21215	22161	case OnePossibleValueInvalid:
21216		return ira->codegen->invalid_instruction;
	22162	return ira->codegen->invalid_inst_gen;
21217	22163	case OnePossibleValueNo:
21218	22164	if (!same_comptime_repr) {
21219	22165	ZigValue *payload_val = create_const_vals(1);
...	...	@@ -21240,14 +22186,13 @@ static IrInstruction ir_analyze_unwrap_optional_payload(IrAnalyze ira, IrInstr
21240	22186	}
21241	22187	} else if (optional_value_is_null(optional_val)) {
21242	22188	ir_add_error(ira, source_instr, buf_sprintf("unable to unwrap null"));
21243		return ira->codegen->invalid_instruction;
	22189	return ira->codegen->invalid_inst_gen;
21244	22190	}
21245	22191
21246		IrInstruction *result;
	22192	IrInstGen *result;
21247	22193	if (ptr_val->data.x_ptr.mut == ConstPtrMutInfer) {
21248		result = ir_build_optional_unwrap_ptr(&ira->new_irb, source_instr->scope,
21249		source_instr->source_node, base_ptr, false, initializing);
21250		result->value->type = result_type;
	22194	result = ir_build_optional_unwrap_ptr_gen(ira, source_instr, base_ptr, false,
	22195	initializing, result_type);
21251	22196	result->value->special = ConstValSpecialStatic;
21252	22197	} else {
21253	22198	result = ir_const(ira, source_instr, result_type);
...	...	@@ -21257,7 +22202,7 @@ static IrInstruction ir_analyze_unwrap_optional_payload(IrAnalyze ira, IrInstr
21257	22202	result_val->data.x_ptr.mut = ptr_val->data.x_ptr.mut;
21258	22203	switch (type_has_one_possible_value(ira->codegen, child_type)) {
21259	22204	case OnePossibleValueInvalid:
21260		return ira->codegen->invalid_instruction;
	22205	return ira->codegen->invalid_inst_gen;
21261	22206	case OnePossibleValueNo:
21262	22207	if (same_comptime_repr) {
21263	22208	result_val->data.x_ptr.data.ref.pointee = optional_val;
...	...	@@ -21275,131 +22220,120 @@ static IrInstruction ir_analyze_unwrap_optional_payload(IrAnalyze ira, IrInstr
21275	22220	}
21276	22221	}
21277	22222
21278		IrInstruction *result = ir_build_optional_unwrap_ptr(&ira->new_irb, source_instr->scope,
21279		source_instr->source_node, base_ptr, safety_check_on, initializing);
21280		result->value->type = result_type;
21281		return result;
	22223	return ir_build_optional_unwrap_ptr_gen(ira, source_instr, base_ptr, safety_check_on,
	22224	initializing, result_type);
21282	22225	}
21283	22226
21284		static IrInstruction ir_analyze_instruction_optional_unwrap_ptr(IrAnalyze ira,
21285		IrInstructionOptionalUnwrapPtr *instruction)
	22227	static IrInstGen ir_analyze_instruction_optional_unwrap_ptr(IrAnalyze ira,
	22228	IrInstSrcOptionalUnwrapPtr *instruction)
21286	22229	{
21287		IrInstruction *base_ptr = instruction->base_ptr->child;
	22230	IrInstGen *base_ptr = instruction->base_ptr->child;
21288	22231	if (type_is_invalid(base_ptr->value->type))
21289		return ira->codegen->invalid_instruction;
	22232	return ira->codegen->invalid_inst_gen;
21290	22233
21291		return ir_analyze_unwrap_optional_payload(ira, &instruction->base, base_ptr,
	22234	return ir_analyze_unwrap_optional_payload(ira, &instruction->base.base, base_ptr,
21292	22235	instruction->safety_check_on, false);
21293	22236	}
21294	22237
21295		static IrInstruction ir_analyze_instruction_ctz(IrAnalyze ira, IrInstructionCtz *instruction) {
	22238	static IrInstGen ir_analyze_instruction_ctz(IrAnalyze ira, IrInstSrcCtz *instruction) {
21296	22239	ZigType *int_type = ir_resolve_int_type(ira, instruction->type->child);
21297	22240	if (type_is_invalid(int_type))
21298		return ira->codegen->invalid_instruction;
	22241	return ira->codegen->invalid_inst_gen;
21299	22242
21300		IrInstruction *op = ir_implicit_cast(ira, instruction->op->child, int_type);
	22243	IrInstGen *op = ir_implicit_cast(ira, instruction->op->child, int_type);
21301	22244	if (type_is_invalid(op->value->type))
21302		return ira->codegen->invalid_instruction;
	22245	return ira->codegen->invalid_inst_gen;
21303	22246
21304	22247	if (int_type->data.integral.bit_count == 0)
21305		return ir_const_unsigned(ira, &instruction->base, 0);
	22248	return ir_const_unsigned(ira, &instruction->base.base, 0);
21306	22249
21307	22250	if (instr_is_comptime(op)) {
21308	22251	ZigValue *val = ir_resolve_const(ira, op, UndefOk);
21309	22252	if (val == nullptr)
21310		return ira->codegen->invalid_instruction;
	22253	return ira->codegen->invalid_inst_gen;
21311	22254	if (val->special == ConstValSpecialUndef)
21312		return ir_const_undef(ira, &instruction->base, ira->codegen->builtin_types.entry_num_lit_int);
	22255	return ir_const_undef(ira, &instruction->base.base, ira->codegen->builtin_types.entry_num_lit_int);
21313	22256	size_t result_usize = bigint_ctz(&op->value->data.x_bigint, int_type->data.integral.bit_count);
21314		return ir_const_unsigned(ira, &instruction->base, result_usize);
	22257	return ir_const_unsigned(ira, &instruction->base.base, result_usize);
21315	22258	}
21316	22259
21317	22260	ZigType *return_type = get_smallest_unsigned_int_type(ira->codegen, int_type->data.integral.bit_count);
21318		IrInstruction *result = ir_build_ctz(&ira->new_irb, instruction->base.scope,
21319		instruction->base.source_node, nullptr, op);
21320		result->value->type = return_type;
21321		return result;
	22261	return ir_build_ctz_gen(ira, &instruction->base.base, return_type, op);
21322	22262	}
21323	22263
21324		static IrInstruction ir_analyze_instruction_clz(IrAnalyze ira, IrInstructionClz *instruction) {
	22264	static IrInstGen ir_analyze_instruction_clz(IrAnalyze ira, IrInstSrcClz *instruction) {
21325	22265	ZigType *int_type = ir_resolve_int_type(ira, instruction->type->child);
21326	22266	if (type_is_invalid(int_type))
21327		return ira->codegen->invalid_instruction;
	22267	return ira->codegen->invalid_inst_gen;
21328	22268
21329		IrInstruction *op = ir_implicit_cast(ira, instruction->op->child, int_type);
	22269	IrInstGen *op = ir_implicit_cast(ira, instruction->op->child, int_type);
21330	22270	if (type_is_invalid(op->value->type))
21331		return ira->codegen->invalid_instruction;
	22271	return ira->codegen->invalid_inst_gen;
21332	22272
21333	22273	if (int_type->data.integral.bit_count == 0)
21334		return ir_const_unsigned(ira, &instruction->base, 0);
	22274	return ir_const_unsigned(ira, &instruction->base.base, 0);
21335	22275
21336	22276	if (instr_is_comptime(op)) {
21337	22277	ZigValue *val = ir_resolve_const(ira, op, UndefOk);
21338	22278	if (val == nullptr)
21339		return ira->codegen->invalid_instruction;
	22279	return ira->codegen->invalid_inst_gen;
21340	22280	if (val->special == ConstValSpecialUndef)
21341		return ir_const_undef(ira, &instruction->base, ira->codegen->builtin_types.entry_num_lit_int);
	22281	return ir_const_undef(ira, &instruction->base.base, ira->codegen->builtin_types.entry_num_lit_int);
21342	22282	size_t result_usize = bigint_clz(&op->value->data.x_bigint, int_type->data.integral.bit_count);
21343		return ir_const_unsigned(ira, &instruction->base, result_usize);
	22283	return ir_const_unsigned(ira, &instruction->base.base, result_usize);
21344	22284	}
21345	22285
21346	22286	ZigType *return_type = get_smallest_unsigned_int_type(ira->codegen, int_type->data.integral.bit_count);
21347		IrInstruction *result = ir_build_clz(&ira->new_irb, instruction->base.scope,
21348		instruction->base.source_node, nullptr, op);
21349		result->value->type = return_type;
21350		return result;
	22287	return ir_build_clz_gen(ira, &instruction->base.base, return_type, op);
21351	22288	}
21352	22289
21353		static IrInstruction ir_analyze_instruction_pop_count(IrAnalyze ira, IrInstructionPopCount *instruction) {
	22290	static IrInstGen ir_analyze_instruction_pop_count(IrAnalyze ira, IrInstSrcPopCount *instruction) {
21354	22291	ZigType *int_type = ir_resolve_int_type(ira, instruction->type->child);
21355	22292	if (type_is_invalid(int_type))
21356		return ira->codegen->invalid_instruction;
	22293	return ira->codegen->invalid_inst_gen;
21357	22294
21358		IrInstruction *op = ir_implicit_cast(ira, instruction->op->child, int_type);
	22295	IrInstGen *op = ir_implicit_cast(ira, instruction->op->child, int_type);
21359	22296	if (type_is_invalid(op->value->type))
21360		return ira->codegen->invalid_instruction;
	22297	return ira->codegen->invalid_inst_gen;
21361	22298
21362	22299	if (int_type->data.integral.bit_count == 0)
21363		return ir_const_unsigned(ira, &instruction->base, 0);
	22300	return ir_const_unsigned(ira, &instruction->base.base, 0);
21364	22301
21365	22302	if (instr_is_comptime(op)) {
21366	22303	ZigValue *val = ir_resolve_const(ira, op, UndefOk);
21367	22304	if (val == nullptr)
21368		return ira->codegen->invalid_instruction;
	22305	return ira->codegen->invalid_inst_gen;
21369	22306	if (val->special == ConstValSpecialUndef)
21370		return ir_const_undef(ira, &instruction->base, ira->codegen->builtin_types.entry_num_lit_int);
	22307	return ir_const_undef(ira, &instruction->base.base, ira->codegen->builtin_types.entry_num_lit_int);
21371	22308
21372	22309	if (bigint_cmp_zero(&val->data.x_bigint) != CmpLT) {
21373	22310	size_t result = bigint_popcount_unsigned(&val->data.x_bigint);
21374		return ir_const_unsigned(ira, &instruction->base, result);
	22311	return ir_const_unsigned(ira, &instruction->base.base, result);
21375	22312	}
21376	22313	size_t result = bigint_popcount_signed(&val->data.x_bigint, int_type->data.integral.bit_count);
21377		return ir_const_unsigned(ira, &instruction->base, result);
	22314	return ir_const_unsigned(ira, &instruction->base.base, result);
21378	22315	}
21379	22316
21380	22317	ZigType *return_type = get_smallest_unsigned_int_type(ira->codegen, int_type->data.integral.bit_count);
21381		IrInstruction *result = ir_build_pop_count(&ira->new_irb, instruction->base.scope,
21382		instruction->base.source_node, nullptr, op);
21383		result->value->type = return_type;
21384		return result;
	22318	return ir_build_pop_count_gen(ira, &instruction->base.base, return_type, op);
21385	22319	}
21386	22320
21387		static IrInstruction ir_analyze_union_tag(IrAnalyze ira, IrInstruction source_instr, IrInstruction value) {
	22321	static IrInstGen ir_analyze_union_tag(IrAnalyze ira, IrInst* source_instr, IrInstGen *value, bool is_gen) {
21388	22322	if (type_is_invalid(value->value->type))
21389		return ira->codegen->invalid_instruction;
	22323	return ira->codegen->invalid_inst_gen;
21390	22324
21391	22325	if (value->value->type->id != ZigTypeIdUnion) {
21392		ir_add_error(ira, value,
	22326	ir_add_error(ira, &value->base,
21393	22327	buf_sprintf("expected enum or union type, found '%s'", buf_ptr(&value->value->type->name)));
21394		return ira->codegen->invalid_instruction;
	22328	return ira->codegen->invalid_inst_gen;
21395	22329	}
21396		if (!value->value->type->data.unionation.have_explicit_tag_type && !source_instr->is_gen) {
	22330	if (!value->value->type->data.unionation.have_explicit_tag_type && !is_gen) {
21397	22331	ErrorMsg *msg = ir_add_error(ira, source_instr, buf_sprintf("union has no associated enum"));
21398	22332	if (value->value->type->data.unionation.decl_node != nullptr) {
21399	22333	add_error_note(ira->codegen, msg, value->value->type->data.unionation.decl_node,
21400	22334	buf_sprintf("declared here"));
21401	22335	}
21402		return ira->codegen->invalid_instruction;
	22336	return ira->codegen->invalid_inst_gen;
21403	22337	}
21404	22338
21405	22339	ZigType *tag_type = value->value->type->data.unionation.tag_type;
...	...	@@ -21408,9 +22342,9 @@ static IrInstruction ir_analyze_union_tag(IrAnalyze ira, IrInstruction *source
21408	22342	if (instr_is_comptime(value)) {
21409	22343	ZigValue *val = ir_resolve_const(ira, value, UndefBad);
21410	22344	if (!val)
21411		return ira->codegen->invalid_instruction;
	22345	return ira->codegen->invalid_inst_gen;
21412	22346
21413		IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(&ira->new_irb,
	22347	IrInstGenConst *const_instruction = ir_create_inst_gen<IrInstGenConst>(&ira->new_irb,
21414	22348	source_instr->scope, source_instr->source_node);
21415	22349	const_instruction->base.value->type = tag_type;
21416	22350	const_instruction->base.value->special = ConstValSpecialStatic;
...	...	@@ -21418,15 +22352,13 @@ static IrInstruction ir_analyze_union_tag(IrAnalyze ira, IrInstruction *source
21418	22352	return &const_instruction->base;
21419	22353	}
21420	22354
21421		IrInstruction *result = ir_build_union_tag(&ira->new_irb, source_instr->scope, source_instr->source_node, value);
21422		result->value->type = tag_type;
21423		return result;
	22355	return ir_build_union_tag(ira, source_instr, value, tag_type);
21424	22356	}
21425	22357
21426		static IrInstruction ir_analyze_instruction_switch_br(IrAnalyze ira,
21427		IrInstructionSwitchBr *switch_br_instruction)
	22358	static IrInstGen ir_analyze_instruction_switch_br(IrAnalyze ira,
	22359	IrInstSrcSwitchBr *switch_br_instruction)
21428	22360	{
21429		IrInstruction *target_value = switch_br_instruction->target_value->child;
	22361	IrInstGen *target_value = switch_br_instruction->target_value->child;
21430	22362	if (type_is_invalid(target_value->value->type))
21431	22363	return ir_unreach_error(ira);
21432	22364
...	...	@@ -21441,21 +22373,21 @@ static IrInstruction ir_analyze_instruction_switch_br(IrAnalyze ira,
21441	22373
21442	22374	bool is_comptime;
21443	22375	if (!ir_resolve_comptime(ira, switch_br_instruction->is_comptime->child, &is_comptime))
21444		return ira->codegen->invalid_instruction;
	22376	return ira->codegen->invalid_inst_gen;
21445	22377
21446	22378	if (is_comptime \|\| instr_is_comptime(target_value)) {
21447	22379	ZigValue *target_val = ir_resolve_const(ira, target_value, UndefBad);
21448	22380	if (!target_val)
21449	22381	return ir_unreach_error(ira);
21450	22382
21451		IrBasicBlock *old_dest_block = switch_br_instruction->else_block;
	22383	IrBasicBlockSrc *old_dest_block = switch_br_instruction->else_block;
21452	22384	for (size_t i = 0; i < case_count; i += 1) {
21453		IrInstructionSwitchBrCase *old_case = &switch_br_instruction->cases[i];
21454		IrInstruction *case_value = old_case->value->child;
	22385	IrInstSrcSwitchBrCase *old_case = &switch_br_instruction->cases[i];
	22386	IrInstGen *case_value = old_case->value->child;
21455	22387	if (type_is_invalid(case_value->value->type))
21456	22388	return ir_unreach_error(ira);
21457	22389
21458		IrInstruction *casted_case_value = ir_implicit_cast(ira, case_value, target_value->value->type);
	22390	IrInstGen *casted_case_value = ir_implicit_cast(ira, case_value, target_value->value->type);
21459	22391	if (type_is_invalid(casted_case_value->value->type))
21460	22392	return ir_unreach_error(ira);
21461	22393
...	...	@@ -21470,23 +22402,20 @@ static IrInstruction ir_analyze_instruction_switch_br(IrAnalyze ira,
21470	22402	}
21471	22403
21472	22404	if (is_comptime \|\| old_dest_block->ref_count == 1) {
21473		return ir_inline_bb(ira, &switch_br_instruction->base, old_dest_block);
	22405	return ir_inline_bb(ira, &switch_br_instruction->base.base, old_dest_block);
21474	22406	} else {
21475		IrBasicBlock *new_dest_block = ir_get_new_bb(ira, old_dest_block, &switch_br_instruction->base);
21476		IrInstruction *result = ir_build_br(&ira->new_irb,
21477		switch_br_instruction->base.scope, switch_br_instruction->base.source_node,
21478		new_dest_block, nullptr);
21479		result->value->type = ira->codegen->builtin_types.entry_unreachable;
	22407	IrBasicBlockGen *new_dest_block = ir_get_new_bb(ira, old_dest_block, &switch_br_instruction->base.base);
	22408	IrInstGen *result = ir_build_br_gen(ira, &switch_br_instruction->base.base, new_dest_block);
21480	22409	return ir_finish_anal(ira, result);
21481	22410	}
21482	22411	}
21483	22412
21484		IrInstructionSwitchBrCase *cases = allocate<IrInstructionSwitchBrCase>(case_count);
	22413	IrInstGenSwitchBrCase *cases = allocate<IrInstGenSwitchBrCase>(case_count);
21485	22414	for (size_t i = 0; i < case_count; i += 1) {
21486		IrInstructionSwitchBrCase *old_case = &switch_br_instruction->cases[i];
21487		IrInstructionSwitchBrCase *new_case = &cases[i];
21488		new_case->block = ir_get_new_bb(ira, old_case->block, &switch_br_instruction->base);
21489		new_case->value = ira->codegen->invalid_instruction;
	22415	IrInstSrcSwitchBrCase *old_case = &switch_br_instruction->cases[i];
	22416	IrInstGenSwitchBrCase *new_case = &cases[i];
	22417	new_case->block = ir_get_new_bb(ira, old_case->block, &switch_br_instruction->base.base);
	22418	new_case->value = ira->codegen->invalid_inst_gen;
21490	22419
21491	22420	// Calling ir_get_new_bb set the ref_instruction on the new basic block.
21492	22421	// However a switch br may branch to the same basic block which would trigger an
...	...	@@ -21494,12 +22423,12 @@ static IrInstruction ir_analyze_instruction_switch_br(IrAnalyze ira,
21494	22423	// it back after the loop.
21495	22424	new_case->block->ref_instruction = nullptr;
21496	22425
21497		IrInstruction *old_value = old_case->value;
21498		IrInstruction *new_value = old_value->child;
	22426	IrInstSrc *old_value = old_case->value;
	22427	IrInstGen *new_value = old_value->child;
21499	22428	if (type_is_invalid(new_value->value->type))
21500	22429	continue;
21501	22430
21502		IrInstruction *casted_new_value = ir_implicit_cast(ira, new_value, target_value->value->type);
	22431	IrInstGen *casted_new_value = ir_implicit_cast(ira, new_value, target_value->value->type);
21503	22432	if (type_is_invalid(casted_new_value->value->type))
21504	22433	continue;
21505	22434
...	...	@@ -21510,47 +22439,45 @@ static IrInstruction ir_analyze_instruction_switch_br(IrAnalyze ira,
21510	22439	}
21511	22440
21512	22441	for (size_t i = 0; i < case_count; i += 1) {
21513		IrInstructionSwitchBrCase *new_case = &cases[i];
21514		if (new_case->value == ira->codegen->invalid_instruction)
	22442	IrInstGenSwitchBrCase *new_case = &cases[i];
	22443	if (type_is_invalid(new_case->value->value->type))
21515	22444	return ir_unreach_error(ira);
21516		new_case->block->ref_instruction = &switch_br_instruction->base;
	22445	new_case->block->ref_instruction = &switch_br_instruction->base.base;
21517	22446	}
21518	22447
21519		IrBasicBlock *new_else_block = ir_get_new_bb(ira, switch_br_instruction->else_block, &switch_br_instruction->base);
21520		IrInstructionSwitchBr *switch_br = ir_build_switch_br(&ira->new_irb,
21521		switch_br_instruction->base.scope, switch_br_instruction->base.source_node,
21522		target_value, new_else_block, case_count, cases, nullptr, nullptr);
21523		switch_br->base.value->type = ira->codegen->builtin_types.entry_unreachable;
	22448	IrBasicBlockGen *new_else_block = ir_get_new_bb(ira, switch_br_instruction->else_block, &switch_br_instruction->base.base);
	22449	IrInstGenSwitchBr *switch_br = ir_build_switch_br_gen(ira, &switch_br_instruction->base.base,
	22450	target_value, new_else_block, case_count, cases);
21524	22451	return ir_finish_anal(ira, &switch_br->base);
21525	22452	}
21526	22453
21527		static IrInstruction ir_analyze_instruction_switch_target(IrAnalyze ira,
21528		IrInstructionSwitchTarget *switch_target_instruction)
	22454	static IrInstGen ir_analyze_instruction_switch_target(IrAnalyze ira,
	22455	IrInstSrcSwitchTarget *switch_target_instruction)
21529	22456	{
21530	22457	Error err;
21531		IrInstruction *target_value_ptr = switch_target_instruction->target_value_ptr->child;
	22458	IrInstGen *target_value_ptr = switch_target_instruction->target_value_ptr->child;
21532	22459	if (type_is_invalid(target_value_ptr->value->type))
21533		return ira->codegen->invalid_instruction;
	22460	return ira->codegen->invalid_inst_gen;
21534	22461
21535	22462	if (target_value_ptr->value->type->id == ZigTypeIdMetaType) {
21536	22463	assert(instr_is_comptime(target_value_ptr));
21537	22464	ZigType *ptr_type = target_value_ptr->value->data.x_type;
21538	22465	assert(ptr_type->id == ZigTypeIdPointer);
21539		return ir_const_type(ira, &switch_target_instruction->base, ptr_type->data.pointer.child_type);
	22466	return ir_const_type(ira, &switch_target_instruction->base.base, ptr_type->data.pointer.child_type);
21540	22467	}
21541	22468
21542	22469	ZigType *target_type = target_value_ptr->value->type->data.pointer.child_type;
21543	22470	ZigValue *pointee_val = nullptr;
21544	22471	if (instr_is_comptime(target_value_ptr) && target_value_ptr->value->data.x_ptr.mut != ConstPtrMutRuntimeVar) {
21545		pointee_val = const_ptr_pointee(ira, ira->codegen, target_value_ptr->value, target_value_ptr->source_node);
	22472	pointee_val = const_ptr_pointee(ira, ira->codegen, target_value_ptr->value, target_value_ptr->base.source_node);
21546	22473	if (pointee_val == nullptr)
21547		return ira->codegen->invalid_instruction;
	22474	return ira->codegen->invalid_inst_gen;
21548	22475
21549	22476	if (pointee_val->special == ConstValSpecialRuntime)
21550	22477	pointee_val = nullptr;
21551	22478	}
21552	22479	if ((err = type_resolve(ira->codegen, target_type, ResolveStatusSizeKnown)))
21553		return ira->codegen->invalid_instruction;
	22480	return ira->codegen->invalid_inst_gen;
21554	22481
21555	22482	switch (target_type->id) {
21556	22483	case ZigTypeIdInvalid:
...	...	@@ -21567,13 +22494,13 @@ static IrInstruction ir_analyze_instruction_switch_target(IrAnalyze ira,
21567	22494	case ZigTypeIdFn:
21568	22495	case ZigTypeIdErrorSet: {
21569	22496	if (pointee_val) {
21570		IrInstruction *result = ir_const(ira, &switch_target_instruction->base, nullptr);
	22497	IrInstGen *result = ir_const(ira, &switch_target_instruction->base.base, nullptr);
21571	22498	copy_const_val(result->value, pointee_val);
21572	22499	result->value->type = target_type;
21573	22500	return result;
21574	22501	}
21575	22502
21576		IrInstruction *result = ir_get_deref(ira, &switch_target_instruction->base, target_value_ptr, nullptr);
	22503	IrInstGen *result = ir_get_deref(ira, &switch_target_instruction->base.base, target_value_ptr, nullptr);
21577	22504	result->value->type = target_type;
21578	22505	return result;
21579	22506	}
...	...	@@ -21582,52 +22509,49 @@ static IrInstruction ir_analyze_instruction_switch_target(IrAnalyze ira,
21582	22509	if (!decl_node->data.container_decl.auto_enum &&
21583	22510	decl_node->data.container_decl.init_arg_expr == nullptr)
21584	22511	{
21585		ErrorMsg *msg = ir_add_error(ira, target_value_ptr,
	22512	ErrorMsg *msg = ir_add_error(ira, &target_value_ptr->base,
21586	22513	buf_sprintf("switch on union which has no attached enum"));
21587	22514	add_error_note(ira->codegen, msg, decl_node,
21588	22515	buf_sprintf("consider 'union(enum)' here"));
21589		return ira->codegen->invalid_instruction;
	22516	return ira->codegen->invalid_inst_gen;
21590	22517	}
21591	22518	ZigType *tag_type = target_type->data.unionation.tag_type;
21592	22519	assert(tag_type != nullptr);
21593	22520	assert(tag_type->id == ZigTypeIdEnum);
21594	22521	if (pointee_val) {
21595		IrInstruction *result = ir_const(ira, &switch_target_instruction->base, tag_type);
	22522	IrInstGen *result = ir_const(ira, &switch_target_instruction->base.base, tag_type);
21596	22523	bigint_init_bigint(&result->value->data.x_enum_tag, &pointee_val->data.x_union.tag);
21597	22524	return result;
21598	22525	}
21599	22526	if (tag_type->data.enumeration.src_field_count == 1) {
21600		IrInstruction *result = ir_const(ira, &switch_target_instruction->base, tag_type);
	22527	IrInstGen *result = ir_const(ira, &switch_target_instruction->base.base, tag_type);
21601	22528	TypeEnumField *only_field = &tag_type->data.enumeration.fields[0];
21602	22529	bigint_init_bigint(&result->value->data.x_enum_tag, &only_field->value);
21603	22530	return result;
21604	22531	}
21605	22532
21606		IrInstruction *union_value = ir_get_deref(ira, &switch_target_instruction->base, target_value_ptr, nullptr);
	22533	IrInstGen *union_value = ir_get_deref(ira, &switch_target_instruction->base.base, target_value_ptr, nullptr);
21607	22534	union_value->value->type = target_type;
21608	22535
21609		IrInstruction *union_tag_inst = ir_build_union_tag(&ira->new_irb, switch_target_instruction->base.scope,
21610		switch_target_instruction->base.source_node, union_value);
21611		union_tag_inst->value->type = tag_type;
21612		return union_tag_inst;
	22536	return ir_build_union_tag(ira, &switch_target_instruction->base.base, union_value, tag_type);
21613	22537	}
21614	22538	case ZigTypeIdEnum: {
21615	22539	if ((err = type_resolve(ira->codegen, target_type, ResolveStatusZeroBitsKnown)))
21616		return ira->codegen->invalid_instruction;
	22540	return ira->codegen->invalid_inst_gen;
21617	22541	if (target_type->data.enumeration.src_field_count == 1) {
21618	22542	TypeEnumField *only_field = &target_type->data.enumeration.fields[0];
21619		IrInstruction *result = ir_const(ira, &switch_target_instruction->base, target_type);
	22543	IrInstGen *result = ir_const(ira, &switch_target_instruction->base.base, target_type);
21620	22544	bigint_init_bigint(&result->value->data.x_enum_tag, &only_field->value);
21621	22545	return result;
21622	22546	}
21623	22547
21624	22548	if (pointee_val) {
21625		IrInstruction *result = ir_const(ira, &switch_target_instruction->base, target_type);
	22549	IrInstGen *result = ir_const(ira, &switch_target_instruction->base.base, target_type);
21626	22550	bigint_init_bigint(&result->value->data.x_enum_tag, &pointee_val->data.x_enum_tag);
21627	22551	return result;
21628	22552	}
21629	22553
21630		IrInstruction *enum_value = ir_get_deref(ira, &switch_target_instruction->base, target_value_ptr, nullptr);
	22554	IrInstGen *enum_value = ir_get_deref(ira, &switch_target_instruction->base.base, target_value_ptr, nullptr);
21631	22555	enum_value->value->type = target_type;
21632	22556	return enum_value;
21633	22557	}
...	...	@@ -21643,17 +22567,17 @@ static IrInstruction ir_analyze_instruction_switch_target(IrAnalyze ira,
21643	22567	case ZigTypeIdVector:
21644	22568	case ZigTypeIdFnFrame:
21645	22569	case ZigTypeIdAnyFrame:
21646		ir_add_error(ira, &switch_target_instruction->base,
	22570	ir_add_error(ira, &switch_target_instruction->base.base,
21647	22571	buf_sprintf("invalid switch target type '%s'", buf_ptr(&target_type->name)));
21648		return ira->codegen->invalid_instruction;
	22572	return ira->codegen->invalid_inst_gen;
21649	22573	}
21650	22574	zig_unreachable();
21651	22575	}
21652	22576
21653		static IrInstruction ir_analyze_instruction_switch_var(IrAnalyze ira, IrInstructionSwitchVar *instruction) {
21654		IrInstruction *target_value_ptr = instruction->target_value_ptr->child;
	22577	static IrInstGen ir_analyze_instruction_switch_var(IrAnalyze ira, IrInstSrcSwitchVar *instruction) {
	22578	IrInstGen *target_value_ptr = instruction->target_value_ptr->child;
21655	22579	if (type_is_invalid(target_value_ptr->value->type))
21656		return ira->codegen->invalid_instruction;
	22580	return ira->codegen->invalid_inst_gen;
21657	22581
21658	22582	ZigType *ref_type = target_value_ptr->value->type;
21659	22583	assert(ref_type->id == ZigTypeIdPointer);
...	...	@@ -21664,62 +22588,62 @@ static IrInstruction ir_analyze_instruction_switch_var(IrAnalyze ira, IrInstru
21664	22588	assert(enum_type->id == ZigTypeIdEnum);
21665	22589	assert(instruction->prongs_len > 0);
21666	22590
21667		IrInstruction *first_prong_value = instruction->prongs_ptr[0]->child;
	22591	IrInstGen *first_prong_value = instruction->prongs_ptr[0]->child;
21668	22592	if (type_is_invalid(first_prong_value->value->type))
21669		return ira->codegen->invalid_instruction;
	22593	return ira->codegen->invalid_inst_gen;
21670	22594
21671		IrInstruction *first_casted_prong_value = ir_implicit_cast(ira, first_prong_value, enum_type);
	22595	IrInstGen *first_casted_prong_value = ir_implicit_cast(ira, first_prong_value, enum_type);
21672	22596	if (type_is_invalid(first_casted_prong_value->value->type))
21673		return ira->codegen->invalid_instruction;
	22597	return ira->codegen->invalid_inst_gen;
21674	22598
21675	22599	ZigValue *first_prong_val = ir_resolve_const(ira, first_casted_prong_value, UndefBad);
21676	22600	if (first_prong_val == nullptr)
21677		return ira->codegen->invalid_instruction;
	22601	return ira->codegen->invalid_inst_gen;
21678	22602
21679	22603	TypeUnionField *first_field = find_union_field_by_tag(target_type, &first_prong_val->data.x_enum_tag);
21680	22604
21681	22605	ErrorMsg *invalid_payload_msg = nullptr;
21682	22606	for (size_t prong_i = 1; prong_i < instruction->prongs_len; prong_i += 1) {
21683		IrInstruction *this_prong_inst = instruction->prongs_ptr[prong_i]->child;
	22607	IrInstGen *this_prong_inst = instruction->prongs_ptr[prong_i]->child;
21684	22608	if (type_is_invalid(this_prong_inst->value->type))
21685		return ira->codegen->invalid_instruction;
	22609	return ira->codegen->invalid_inst_gen;
21686	22610
21687		IrInstruction *this_casted_prong_value = ir_implicit_cast(ira, this_prong_inst, enum_type);
	22611	IrInstGen *this_casted_prong_value = ir_implicit_cast(ira, this_prong_inst, enum_type);
21688	22612	if (type_is_invalid(this_casted_prong_value->value->type))
21689		return ira->codegen->invalid_instruction;
	22613	return ira->codegen->invalid_inst_gen;
21690	22614
21691	22615	ZigValue *this_prong = ir_resolve_const(ira, this_casted_prong_value, UndefBad);
21692	22616	if (this_prong == nullptr)
21693		return ira->codegen->invalid_instruction;
	22617	return ira->codegen->invalid_inst_gen;
21694	22618
21695	22619	TypeUnionField *payload_field = find_union_field_by_tag(target_type, &this_prong->data.x_enum_tag);
21696	22620	ZigType *payload_type = payload_field->type_entry;
21697	22621	if (first_field->type_entry != payload_type) {
21698	22622	if (invalid_payload_msg == nullptr) {
21699		invalid_payload_msg = ir_add_error(ira, &instruction->base,
	22623	invalid_payload_msg = ir_add_error(ira, &instruction->base.base,
21700	22624	buf_sprintf("capture group with incompatible types"));
21701		add_error_note(ira->codegen, invalid_payload_msg, first_prong_value->source_node,
	22625	add_error_note(ira->codegen, invalid_payload_msg, first_prong_value->base.source_node,
21702	22626	buf_sprintf("type '%s' here", buf_ptr(&first_field->type_entry->name)));
21703	22627	}
21704		add_error_note(ira->codegen, invalid_payload_msg, this_prong_inst->source_node,
	22628	add_error_note(ira->codegen, invalid_payload_msg, this_prong_inst->base.source_node,
21705	22629	buf_sprintf("type '%s' here", buf_ptr(&payload_field->type_entry->name)));
21706	22630	}
21707	22631	}
21708	22632
21709	22633	if (invalid_payload_msg != nullptr) {
21710		return ira->codegen->invalid_instruction;
	22634	return ira->codegen->invalid_inst_gen;
21711	22635	}
21712	22636
21713	22637	if (instr_is_comptime(target_value_ptr)) {
21714	22638	ZigValue *target_val_ptr = ir_resolve_const(ira, target_value_ptr, UndefBad);
21715	22639	if (!target_value_ptr)
21716		return ira->codegen->invalid_instruction;
	22640	return ira->codegen->invalid_inst_gen;
21717	22641
21718		ZigValue *pointee_val = const_ptr_pointee(ira, ira->codegen, target_val_ptr, instruction->base.source_node);
	22642	ZigValue *pointee_val = const_ptr_pointee(ira, ira->codegen, target_val_ptr, instruction->base.base.source_node);
21719	22643	if (pointee_val == nullptr)
21720		return ira->codegen->invalid_instruction;
	22644	return ira->codegen->invalid_inst_gen;
21721	22645
21722		IrInstruction *result = ir_const(ira, &instruction->base,
	22646	IrInstGen *result = ir_const(ira, &instruction->base.base,
21723	22647	get_pointer_to_type(ira->codegen, first_field->type_entry,
21724	22648	target_val_ptr->type->data.pointer.is_const));
21725	22649	ZigValue *out_val = result->value;
...	...	@@ -21729,11 +22653,10 @@ static IrInstruction ir_analyze_instruction_switch_var(IrAnalyze ira, IrInstru
21729	22653	return result;
21730	22654	}
21731	22655
21732		IrInstruction *result = ir_build_union_field_ptr(&ira->new_irb,
21733		instruction->base.scope, instruction->base.source_node, target_value_ptr, first_field, false, false);
21734		result->value->type = get_pointer_to_type(ira->codegen, first_field->type_entry,
	22656	ZigType *result_type = get_pointer_to_type(ira->codegen, first_field->type_entry,
21735	22657	target_value_ptr->value->type->data.pointer.is_const);
21736		return result;
	22658	return ir_build_union_field_ptr(ira, &instruction->base.base, target_value_ptr, first_field,
	22659	false, false, result_type);
21737	22660	} else if (target_type->id == ZigTypeIdErrorSet) {
21738	22661	// construct an error set from the prong values
21739	22662	ZigType *err_set_type = new_type_table_entry(ZigTypeIdErrorSet);
...	...	@@ -21746,7 +22669,7 @@ static IrInstruction ir_analyze_instruction_switch_var(IrAnalyze ira, IrInstru
21746	22669	for (size_t i = 0; i < instruction->prongs_len; i += 1) {
21747	22670	ErrorTableEntry *err = ir_resolve_error(ira, instruction->prongs_ptr[i]->child);
21748	22671	if (err == nullptr)
21749		return ira->codegen->invalid_instruction;
	22672	return ira->codegen->invalid_inst_gen;
21750	22673	error_list.append(err);
21751	22674	buf_appendf(&err_set_type->name, "%s,", buf_ptr(&err->name));
21752	22675	}
...	...	@@ -21762,29 +22685,29 @@ static IrInstruction ir_analyze_instruction_switch_var(IrAnalyze ira, IrInstru
21762	22685	ref_type->data.pointer.explicit_alignment,
21763	22686	ref_type->data.pointer.bit_offset_in_host, ref_type->data.pointer.host_int_bytes,
21764	22687	ref_type->data.pointer.allow_zero);
21765		return ir_analyze_ptr_cast(ira, &instruction->base, target_value_ptr, new_target_value_ptr_type,
21766		&instruction->base, false);
	22688	return ir_analyze_ptr_cast(ira, &instruction->base.base, target_value_ptr, new_target_value_ptr_type,
	22689	&instruction->base.base, false);
21767	22690	} else {
21768		ir_add_error(ira, &instruction->base,
	22691	ir_add_error(ira, &instruction->base.base,
21769	22692	buf_sprintf("switch on type '%s' provides no expression parameter", buf_ptr(&target_type->name)));
21770		return ira->codegen->invalid_instruction;
	22693	return ira->codegen->invalid_inst_gen;
21771	22694	}
21772	22695	}
21773	22696
21774		static IrInstruction ir_analyze_instruction_switch_else_var(IrAnalyze ira,
21775		IrInstructionSwitchElseVar *instruction)
	22697	static IrInstGen ir_analyze_instruction_switch_else_var(IrAnalyze ira,
	22698	IrInstSrcSwitchElseVar *instruction)
21776	22699	{
21777		IrInstruction *target_value_ptr = instruction->target_value_ptr->child;
	22700	IrInstGen *target_value_ptr = instruction->target_value_ptr->child;
21778	22701	if (type_is_invalid(target_value_ptr->value->type))
21779		return ira->codegen->invalid_instruction;
	22702	return ira->codegen->invalid_inst_gen;
21780	22703
21781	22704	ZigType *ref_type = target_value_ptr->value->type;
21782	22705	assert(ref_type->id == ZigTypeIdPointer);
21783	22706	ZigType *target_type = target_value_ptr->value->type->data.pointer.child_type;
21784	22707	if (target_type->id == ZigTypeIdErrorSet) {
21785	22708	// make a new set that has the other cases removed
21786		if (!resolve_inferred_error_set(ira->codegen, target_type, instruction->base.source_node)) {
21787		return ira->codegen->invalid_instruction;
	22709	if (!resolve_inferred_error_set(ira->codegen, target_type, instruction->base.base.source_node)) {
	22710	return ira->codegen->invalid_inst_gen;
21788	22711	}
21789	22712	if (type_is_global_error_set(target_type)) {
21790	22713	// the type of the else capture variable still has to be the global error set.
...	...	@@ -21794,17 +22717,17 @@ static IrInstruction ir_analyze_instruction_switch_else_var(IrAnalyze ira,
21794	22717	// Make note of the errors handled by other cases
21795	22718	ErrorTableEntry *errors = allocate<ErrorTableEntry >(ira->codegen->errors_by_index.length);
21796	22719	for (size_t case_i = 0; case_i < instruction->switch_br->case_count; case_i += 1) {
21797		IrInstructionSwitchBrCase *br_case = &instruction->switch_br->cases[case_i];
21798		IrInstruction *case_expr = br_case->value->child;
	22720	IrInstSrcSwitchBrCase *br_case = &instruction->switch_br->cases[case_i];
	22721	IrInstGen *case_expr = br_case->value->child;
21799	22722	if (case_expr->value->type->id == ZigTypeIdErrorSet) {
21800	22723	ErrorTableEntry *err = ir_resolve_error(ira, case_expr);
21801	22724	if (err == nullptr)
21802		return ira->codegen->invalid_instruction;
	22725	return ira->codegen->invalid_inst_gen;
21803	22726	errors[err->value] = err;
21804	22727	} else if (case_expr->value->type->id == ZigTypeIdMetaType) {
21805	22728	ZigType *err_set_type = ir_resolve_type(ira, case_expr);
21806	22729	if (type_is_invalid(err_set_type))
21807		return ira->codegen->invalid_instruction;
	22730	return ira->codegen->invalid_inst_gen;
21808	22731	populate_error_set_table(errors, err_set_type);
21809	22732	} else {
21810	22733	zig_unreachable();
...	...	@@ -21843,27 +22766,22 @@ static IrInstruction ir_analyze_instruction_switch_else_var(IrAnalyze ira,
21843	22766	ref_type->data.pointer.explicit_alignment,
21844	22767	ref_type->data.pointer.bit_offset_in_host, ref_type->data.pointer.host_int_bytes,
21845	22768	ref_type->data.pointer.allow_zero);
21846		return ir_analyze_ptr_cast(ira, &instruction->base, target_value_ptr, new_target_value_ptr_type,
21847		&instruction->base, false);
	22769	return ir_analyze_ptr_cast(ira, &instruction->base.base, target_value_ptr, new_target_value_ptr_type,
	22770	&instruction->base.base, false);
21848	22771	}
21849	22772
21850	22773	return target_value_ptr;
21851	22774	}
21852	22775
21853		static IrInstruction ir_analyze_instruction_union_tag(IrAnalyze ira, IrInstructionUnionTag *instruction) {
21854		IrInstruction *value = instruction->value->child;
21855		return ir_analyze_union_tag(ira, &instruction->base, value);
21856		}
21857
21858		static IrInstruction ir_analyze_instruction_import(IrAnalyze ira, IrInstructionImport *import_instruction) {
	22776	static IrInstGen ir_analyze_instruction_import(IrAnalyze ira, IrInstSrcImport *import_instruction) {
21859	22777	Error err;
21860	22778
21861		IrInstruction *name_value = import_instruction->name->child;
	22779	IrInstGen *name_value = import_instruction->name->child;
21862	22780	Buf *import_target_str = ir_resolve_str(ira, name_value);
21863	22781	if (!import_target_str)
21864		return ira->codegen->invalid_instruction;
	22782	return ira->codegen->invalid_inst_gen;
21865	22783
21866		AstNode *source_node = import_instruction->base.source_node;
	22784	AstNode *source_node = import_instruction->base.base.source_node;
21867	22785	ZigType *import = source_node->owner;
21868	22786
21869	22787	ZigType *target_import;
...	...	@@ -21876,48 +22794,48 @@ static IrInstruction ir_analyze_instruction_import(IrAnalyze ira, IrInstructio
21876	22794	ir_add_error_node(ira, source_node,
21877	22795	buf_sprintf("import of file outside package path: '%s'",
21878	22796	buf_ptr(import_target_path)));
21879		return ira->codegen->invalid_instruction;
	22797	return ira->codegen->invalid_inst_gen;
21880	22798	} else if (err == ErrorFileNotFound) {
21881	22799	ir_add_error_node(ira, source_node,
21882	22800	buf_sprintf("unable to find '%s'", buf_ptr(import_target_path)));
21883		return ira->codegen->invalid_instruction;
	22801	return ira->codegen->invalid_inst_gen;
21884	22802	} else {
21885	22803	ir_add_error_node(ira, source_node,
21886	22804	buf_sprintf("unable to open '%s': %s", buf_ptr(&full_path), err_str(err)));
21887		return ira->codegen->invalid_instruction;
	22805	return ira->codegen->invalid_inst_gen;
21888	22806	}
21889	22807	}
21890	22808
21891		return ir_const_type(ira, &import_instruction->base, target_import);
	22809	return ir_const_type(ira, &import_instruction->base.base, target_import);
21892	22810	}
21893	22811
21894		static IrInstruction ir_analyze_instruction_ref(IrAnalyze ira, IrInstructionRef *ref_instruction) {
21895		IrInstruction *value = ref_instruction->value->child;
	22812	static IrInstGen ir_analyze_instruction_ref(IrAnalyze ira, IrInstSrcRef *ref_instruction) {
	22813	IrInstGen *value = ref_instruction->value->child;
21896	22814	if (type_is_invalid(value->value->type))
21897		return ira->codegen->invalid_instruction;
21898		return ir_get_ref(ira, &ref_instruction->base, value, ref_instruction->is_const, ref_instruction->is_volatile);
	22815	return ira->codegen->invalid_inst_gen;
	22816	return ir_get_ref(ira, &ref_instruction->base.base, value, ref_instruction->is_const, ref_instruction->is_volatile);
21899	22817	}
21900	22818
21901		static IrInstruction ir_analyze_union_init(IrAnalyze ira, IrInstruction *source_instruction,
21902		AstNode field_source_node, ZigType union_type, Buf field_name, IrInstruction field_result_loc,
21903		IrInstruction *result_loc)
	22819	static IrInstGen ir_analyze_union_init(IrAnalyze ira, IrInst* source_instruction,
	22820	AstNode field_source_node, ZigType union_type, Buf field_name, IrInstGen field_result_loc,
	22821	IrInstGen *result_loc)
21904	22822	{
21905	22823	Error err;
21906	22824	assert(union_type->id == ZigTypeIdUnion);
21907	22825
21908	22826	if ((err = type_resolve(ira->codegen, union_type, ResolveStatusSizeKnown)))
21909		return ira->codegen->invalid_instruction;
	22827	return ira->codegen->invalid_inst_gen;
21910	22828
21911	22829	TypeUnionField *type_field = find_union_type_field(union_type, field_name);
21912	22830	if (type_field == nullptr) {
21913	22831	ir_add_error_node(ira, field_source_node,
21914	22832	buf_sprintf("no member named '%s' in union '%s'",
21915	22833	buf_ptr(field_name), buf_ptr(&union_type->name)));
21916		return ira->codegen->invalid_instruction;
	22834	return ira->codegen->invalid_inst_gen;
21917	22835	}
21918	22836
21919	22837	if (type_is_invalid(type_field->type_entry))
21920		return ira->codegen->invalid_instruction;
	22838	return ira->codegen->invalid_inst_gen;
21921	22839
21922	22840	if (result_loc->value->data.x_ptr.mut == ConstPtrMutInfer) {
21923	22841	if (instr_is_comptime(field_result_loc) &&
...	...	@@ -21929,42 +22847,42 @@ static IrInstruction ir_analyze_union_init(IrAnalyze ira, IrInstruction *sourc
21929	22847	}
21930	22848	}
21931	22849
21932		bool is_comptime = ir_should_inline(ira->new_irb.exec, source_instruction->scope)
	22850	bool is_comptime = ir_should_inline(ira->old_irb.exec, source_instruction->scope)
21933	22851	\|\| type_requires_comptime(ira->codegen, union_type) == ReqCompTimeYes;
21934	22852
21935		IrInstruction *result = ir_get_deref(ira, source_instruction, result_loc, nullptr);
	22853	IrInstGen *result = ir_get_deref(ira, source_instruction, result_loc, nullptr);
21936	22854	if (is_comptime && !instr_is_comptime(result)) {
21937		ir_add_error(ira, field_result_loc,
	22855	ir_add_error(ira, &field_result_loc->base,
21938	22856	buf_sprintf("unable to evaluate constant expression"));
21939		return ira->codegen->invalid_instruction;
	22857	return ira->codegen->invalid_inst_gen;
21940	22858	}
21941	22859	return result;
21942	22860	}
21943	22861
21944		static IrInstruction ir_analyze_container_init_fields(IrAnalyze ira, IrInstruction *instruction,
21945		ZigType container_type, size_t instr_field_count, IrInstructionContainerInitFieldsField fields,
21946		IrInstruction *result_loc)
	22862	static IrInstGen ir_analyze_container_init_fields(IrAnalyze ira, IrInst *source_instr,
	22863	ZigType container_type, size_t instr_field_count, IrInstSrcContainerInitFieldsField fields,
	22864	IrInstGen *result_loc)
21947	22865	{
21948	22866	Error err;
21949	22867	if (container_type->id == ZigTypeIdUnion) {
21950	22868	if (instr_field_count != 1) {
21951		ir_add_error(ira, instruction,
	22869	ir_add_error(ira, source_instr,
21952	22870	buf_sprintf("union initialization expects exactly one field"));
21953		return ira->codegen->invalid_instruction;
	22871	return ira->codegen->invalid_inst_gen;
21954	22872	}
21955		IrInstructionContainerInitFieldsField *field = &fields[0];
21956		IrInstruction *field_result_loc = field->result_loc->child;
	22873	IrInstSrcContainerInitFieldsField *field = &fields[0];
	22874	IrInstGen *field_result_loc = field->result_loc->child;
21957	22875	if (type_is_invalid(field_result_loc->value->type))
21958		return ira->codegen->invalid_instruction;
	22876	return ira->codegen->invalid_inst_gen;
21959	22877
21960		return ir_analyze_union_init(ira, instruction, field->source_node, container_type, field->name,
	22878	return ir_analyze_union_init(ira, source_instr, field->source_node, container_type, field->name,
21961	22879	field_result_loc, result_loc);
21962	22880	}
21963	22881	if (container_type->id != ZigTypeIdStruct \|\| is_slice(container_type)) {
21964		ir_add_error(ira, instruction,
	22882	ir_add_error(ira, source_instr,
21965	22883	buf_sprintf("type '%s' does not support struct initialization syntax",
21966	22884	buf_ptr(&container_type->name)));
21967		return ira->codegen->invalid_instruction;
	22885	return ira->codegen->invalid_inst_gen;
21968	22886	}
21969	22887
21970	22888	if (container_type->data.structure.resolve_status == ResolveStatusBeingInferred) {
...	...	@@ -21973,16 +22891,16 @@ static IrInstruction ir_analyze_container_init_fields(IrAnalyze ira, IrInstruc
21973	22891	}
21974	22892
21975	22893	if ((err = type_resolve(ira->codegen, container_type, ResolveStatusSizeKnown)))
21976		return ira->codegen->invalid_instruction;
	22894	return ira->codegen->invalid_inst_gen;
21977	22895
21978	22896	size_t actual_field_count = container_type->data.structure.src_field_count;
21979	22897
21980		IrInstruction *first_non_const_instruction = nullptr;
	22898	IrInstGen *first_non_const_instruction = nullptr;
21981	22899
21982	22900	AstNode *field_assign_nodes = allocate<AstNode >(actual_field_count);
21983		ZigList<IrInstruction *> const_ptrs = {};
	22901	ZigList<IrInstGen *> const_ptrs = {};
21984	22902
21985		bool is_comptime = ir_should_inline(ira->new_irb.exec, instruction->scope)
	22903	bool is_comptime = ir_should_inline(ira->old_irb.exec, source_instr->scope)
21986	22904	\|\| type_requires_comptime(ira->codegen, container_type) == ReqCompTimeYes;
21987	22905
21988	22906
...	...	@@ -21998,29 +22916,29 @@ static IrInstruction ir_analyze_container_init_fields(IrAnalyze ira, IrInstruc
21998	22916	// comptime-known values.
21999	22917
22000	22918	for (size_t i = 0; i < instr_field_count; i += 1) {
22001		IrInstructionContainerInitFieldsField *field = &fields[i];
	22919	IrInstSrcContainerInitFieldsField *field = &fields[i];
22002	22920
22003		IrInstruction *field_result_loc = field->result_loc->child;
	22921	IrInstGen *field_result_loc = field->result_loc->child;
22004	22922	if (type_is_invalid(field_result_loc->value->type))
22005		return ira->codegen->invalid_instruction;
	22923	return ira->codegen->invalid_inst_gen;
22006	22924
22007	22925	TypeStructField *type_field = find_struct_type_field(container_type, field->name);
22008	22926	if (!type_field) {
22009	22927	ir_add_error_node(ira, field->source_node,
22010	22928	buf_sprintf("no member named '%s' in struct '%s'",
22011	22929	buf_ptr(field->name), buf_ptr(&container_type->name)));
22012		return ira->codegen->invalid_instruction;
	22930	return ira->codegen->invalid_inst_gen;
22013	22931	}
22014	22932
22015	22933	if (type_is_invalid(type_field->type_entry))
22016		return ira->codegen->invalid_instruction;
	22934	return ira->codegen->invalid_inst_gen;
22017	22935
22018	22936	size_t field_index = type_field->src_index;
22019	22937	AstNode *existing_assign_node = field_assign_nodes[field_index];
22020	22938	if (existing_assign_node) {
22021	22939	ErrorMsg *msg = ir_add_error_node(ira, field->source_node, buf_sprintf("duplicate field"));
22022	22940	add_error_note(ira->codegen, msg, existing_assign_node, buf_sprintf("other field here"));
22023		return ira->codegen->invalid_instruction;
	22941	return ira->codegen->invalid_inst_gen;
22024	22942	}
22025	22943	field_assign_nodes[field_index] = field->source_node;
22026	22944
...	...	@@ -22041,20 +22959,20 @@ static IrInstruction ir_analyze_container_init_fields(IrAnalyze ira, IrInstruc
22041	22959	TypeStructField *field = container_type->data.structure.fields[i];
22042	22960	memoize_field_init_val(ira->codegen, container_type, field);
22043	22961	if (field->init_val == nullptr) {
22044		ir_add_error_node(ira, instruction->source_node,
	22962	ir_add_error(ira, source_instr,
22045	22963	buf_sprintf("missing field: '%s'", buf_ptr(container_type->data.structure.fields[i]->name)));
22046	22964	any_missing = true;
22047	22965	continue;
22048	22966	}
22049	22967	if (type_is_invalid(field->init_val->type))
22050		return ira->codegen->invalid_instruction;
	22968	return ira->codegen->invalid_inst_gen;
22051	22969
22052		IrInstruction *runtime_inst = ir_const(ira, instruction, field->init_val->type);
	22970	IrInstGen *runtime_inst = ir_const(ira, source_instr, field->init_val->type);
22053	22971	copy_const_val(runtime_inst->value, field->init_val);
22054	22972
22055		IrInstruction *field_ptr = ir_analyze_struct_field_ptr(ira, instruction, field, result_loc,
	22973	IrInstGen *field_ptr = ir_analyze_struct_field_ptr(ira, source_instr, field, result_loc,
22056	22974	container_type, true);
22057		ir_analyze_store_ptr(ira, instruction, field_ptr, runtime_inst, false);
	22975	ir_analyze_store_ptr(ira, source_instr, field_ptr, runtime_inst, false);
22058	22976	if (instr_is_comptime(field_ptr) && field_ptr->value->data.x_ptr.mut != ConstPtrMutRuntimeVar) {
22059	22977	const_ptrs.append(field_ptr);
22060	22978	} else {
...	...	@@ -22062,39 +22980,39 @@ static IrInstruction ir_analyze_container_init_fields(IrAnalyze ira, IrInstruc
22062	22980	}
22063	22981	}
22064	22982	if (any_missing)
22065		return ira->codegen->invalid_instruction;
	22983	return ira->codegen->invalid_inst_gen;
22066	22984
22067	22985	if (result_loc->value->data.x_ptr.mut == ConstPtrMutInfer) {
22068	22986	if (const_ptrs.length != actual_field_count) {
22069	22987	result_loc->value->special = ConstValSpecialRuntime;
22070	22988	for (size_t i = 0; i < const_ptrs.length; i += 1) {
22071		IrInstruction *field_result_loc = const_ptrs.at(i);
22072		IrInstruction *deref = ir_get_deref(ira, field_result_loc, field_result_loc, nullptr);
	22989	IrInstGen *field_result_loc = const_ptrs.at(i);
	22990	IrInstGen *deref = ir_get_deref(ira, &field_result_loc->base, field_result_loc, nullptr);
22073	22991	field_result_loc->value->special = ConstValSpecialRuntime;
22074		ir_analyze_store_ptr(ira, field_result_loc, field_result_loc, deref, false);
	22992	ir_analyze_store_ptr(ira, &field_result_loc->base, field_result_loc, deref, false);
22075	22993	}
22076	22994	}
22077	22995	}
22078	22996
22079		IrInstruction *result = ir_get_deref(ira, instruction, result_loc, nullptr);
	22997	IrInstGen *result = ir_get_deref(ira, source_instr, result_loc, nullptr);
22080	22998
22081	22999	if (is_comptime && !instr_is_comptime(result)) {
22082		ir_add_error_node(ira, first_non_const_instruction->source_node,
	23000	ir_add_error_node(ira, first_non_const_instruction->base.source_node,
22083	23001	buf_sprintf("unable to evaluate constant expression"));
22084		return ira->codegen->invalid_instruction;
	23002	return ira->codegen->invalid_inst_gen;
22085	23003	}
22086	23004
22087	23005	return result;
22088	23006	}
22089	23007
22090		static IrInstruction ir_analyze_instruction_container_init_list(IrAnalyze ira,
22091		IrInstructionContainerInitList *instruction)
	23008	static IrInstGen ir_analyze_instruction_container_init_list(IrAnalyze ira,
	23009	IrInstSrcContainerInitList *instruction)
22092	23010	{
22093		ir_assert(instruction->result_loc != nullptr, &instruction->base);
22094		IrInstruction *result_loc = instruction->result_loc->child;
	23011	ir_assert(instruction->result_loc != nullptr, &instruction->base.base);
	23012	IrInstGen *result_loc = instruction->result_loc->child;
22095	23013	if (type_is_invalid(result_loc->value->type))
22096	23014	return result_loc;
22097		ir_assert(result_loc->value->type->id == ZigTypeIdPointer, &instruction->base);
	23015	ir_assert(result_loc->value->type->id == ZigTypeIdPointer, &instruction->base.base);
22098	23016
22099	23017	ZigType *container_type = result_loc->value->type->data.pointer.child_type;
22100	23018
...	...	@@ -22104,24 +23022,24 @@ static IrInstruction ir_analyze_instruction_container_init_list(IrAnalyze ira,
22104	23022	ir_add_error_node(ira, instruction->init_array_type_source_node,
22105	23023	buf_sprintf("array literal requires address-of operator to coerce to slice type '%s'",
22106	23024	buf_ptr(&container_type->name)));
22107		return ira->codegen->invalid_instruction;
	23025	return ira->codegen->invalid_inst_gen;
22108	23026	}
22109	23027
22110	23028	if (container_type->id == ZigTypeIdVoid) {
22111	23029	if (elem_count != 0) {
22112		ir_add_error_node(ira, instruction->base.source_node,
	23030	ir_add_error_node(ira, instruction->base.base.source_node,
22113	23031	buf_sprintf("void expression expects no arguments"));
22114		return ira->codegen->invalid_instruction;
	23032	return ira->codegen->invalid_inst_gen;
22115	23033	}
22116		return ir_const_void(ira, &instruction->base);
	23034	return ir_const_void(ira, &instruction->base.base);
22117	23035	}
22118	23036
22119	23037	if (container_type->id == ZigTypeIdStruct && elem_count == 0) {
22120		ir_assert(instruction->result_loc != nullptr, &instruction->base);
22121		IrInstruction *result_loc = instruction->result_loc->child;
	23038	ir_assert(instruction->result_loc != nullptr, &instruction->base.base);
	23039	IrInstGen *result_loc = instruction->result_loc->child;
22122	23040	if (type_is_invalid(result_loc->value->type))
22123	23041	return result_loc;
22124		return ir_analyze_container_init_fields(ira, &instruction->base, container_type, 0, nullptr, result_loc);
	23042	return ir_analyze_container_init_fields(ira, &instruction->base.base, container_type, 0, nullptr, result_loc);
22125	23043	}
22126	23044
22127	23045	if (container_type->id == ZigTypeIdArray) {
...	...	@@ -22129,10 +23047,10 @@ static IrInstruction ir_analyze_instruction_container_init_list(IrAnalyze ira,
22129	23047	if (container_type->data.array.len != elem_count) {
22130	23048	ZigType *literal_type = get_array_type(ira->codegen, child_type, elem_count, nullptr);
22131	23049
22132		ir_add_error(ira, &instruction->base,
	23050	ir_add_error(ira, &instruction->base.base,
22133	23051	buf_sprintf("expected %s literal, found %s literal",
22134	23052	buf_ptr(&container_type->name), buf_ptr(&literal_type->name)));
22135		return ira->codegen->invalid_instruction;
	23053	return ira->codegen->invalid_inst_gen;
22136	23054	}
22137	23055	} else if (container_type->id == ZigTypeIdStruct &&
22138	23056	container_type->data.structure.resolve_status == ResolveStatusBeingInferred)
...	...	@@ -22142,17 +23060,17 @@ static IrInstruction ir_analyze_instruction_container_init_list(IrAnalyze ira,
22142	23060	} else if (container_type->id == ZigTypeIdVector) {
22143	23061	// OK
22144	23062	} else {
22145		ir_add_error_node(ira, instruction->base.source_node,
	23063	ir_add_error(ira, &instruction->base.base,
22146	23064	buf_sprintf("type '%s' does not support array initialization",
22147	23065	buf_ptr(&container_type->name)));
22148		return ira->codegen->invalid_instruction;
	23066	return ira->codegen->invalid_inst_gen;
22149	23067	}
22150	23068
22151	23069	switch (type_has_one_possible_value(ira->codegen, container_type)) {
22152	23070	case OnePossibleValueInvalid:
22153		return ira->codegen->invalid_instruction;
	23071	return ira->codegen->invalid_inst_gen;
22154	23072	case OnePossibleValueYes:
22155		return ir_const_move(ira, &instruction->base,
	23073	return ir_const_move(ira, &instruction->base.base,
22156	23074	get_the_one_possible_value(ira->codegen, container_type));
22157	23075	case OnePossibleValueNo:
22158	23076	break;
...	...	@@ -22161,16 +23079,16 @@ static IrInstruction ir_analyze_instruction_container_init_list(IrAnalyze ira,
22161	23079	bool is_comptime;
22162	23080	switch (type_requires_comptime(ira->codegen, container_type)) {
22163	23081	case ReqCompTimeInvalid:
22164		return ira->codegen->invalid_instruction;
	23082	return ira->codegen->invalid_inst_gen;
22165	23083	case ReqCompTimeNo:
22166		is_comptime = ir_should_inline(ira->new_irb.exec, instruction->base.scope);
	23084	is_comptime = ir_should_inline(ira->old_irb.exec, instruction->base.base.scope);
22167	23085	break;
22168	23086	case ReqCompTimeYes:
22169	23087	is_comptime = true;
22170	23088	break;
22171	23089	}
22172	23090
22173		IrInstruction *first_non_const_instruction = nullptr;
	23091	IrInstGen *first_non_const_instruction = nullptr;
22174	23092
22175	23093	// The Result Location Mechanism has already emitted runtime instructions to
22176	23094	// initialize runtime elements and has omitted instructions for the comptime
...	...	@@ -22179,12 +23097,12 @@ static IrInstruction ir_analyze_instruction_container_init_list(IrAnalyze ira,
22179	23097	// array initialization can be a comptime value, overwrite ConstPtrMutInfer with
22180	23098	// ConstPtrMutComptimeConst. Otherwise, emit instructions to runtime-initialize the
22181	23099	// elements that have comptime-known values.
22182		ZigList<IrInstruction *> const_ptrs = {};
	23100	ZigList<IrInstGen *> const_ptrs = {};
22183	23101
22184	23102	for (size_t i = 0; i < elem_count; i += 1) {
22185		IrInstruction *elem_result_loc = instruction->elem_result_loc_list[i]->child;
	23103	IrInstGen *elem_result_loc = instruction->elem_result_loc_list[i]->child;
22186	23104	if (type_is_invalid(elem_result_loc->value->type))
22187		return ira->codegen->invalid_instruction;
	23105	return ira->codegen->invalid_inst_gen;
22188	23106
22189	23107	assert(elem_result_loc->value->type->id == ZigTypeIdPointer);
22190	23108
...	...	@@ -22201,81 +23119,79 @@ static IrInstruction ir_analyze_instruction_container_init_list(IrAnalyze ira,
22201	23119	if (const_ptrs.length != elem_count) {
22202	23120	result_loc->value->special = ConstValSpecialRuntime;
22203	23121	for (size_t i = 0; i < const_ptrs.length; i += 1) {
22204		IrInstruction *elem_result_loc = const_ptrs.at(i);
	23122	IrInstGen *elem_result_loc = const_ptrs.at(i);
22205	23123	assert(elem_result_loc->value->special == ConstValSpecialStatic);
22206	23124	if (elem_result_loc->value->type->data.pointer.inferred_struct_field != nullptr) {
22207	23125	// This field will be generated comptime; no need to do this.
22208	23126	continue;
22209	23127	}
22210		IrInstruction *deref = ir_get_deref(ira, elem_result_loc, elem_result_loc, nullptr);
	23128	IrInstGen *deref = ir_get_deref(ira, &elem_result_loc->base, elem_result_loc, nullptr);
22211	23129	elem_result_loc->value->special = ConstValSpecialRuntime;
22212		ir_analyze_store_ptr(ira, elem_result_loc, elem_result_loc, deref, false);
	23130	ir_analyze_store_ptr(ira, &elem_result_loc->base, elem_result_loc, deref, false);
22213	23131	}
22214	23132	}
22215	23133	}
22216	23134
22217		IrInstruction *result = ir_get_deref(ira, &instruction->base, result_loc, nullptr);
	23135	IrInstGen *result = ir_get_deref(ira, &instruction->base.base, result_loc, nullptr);
22218	23136	if (instr_is_comptime(result))
22219	23137	return result;
22220	23138
22221	23139	if (is_comptime) {
22222		ir_add_error_node(ira, first_non_const_instruction->source_node,
	23140	ir_add_error(ira, &first_non_const_instruction->base,
22223	23141	buf_sprintf("unable to evaluate constant expression"));
22224		return ira->codegen->invalid_instruction;
	23142	return ira->codegen->invalid_inst_gen;
22225	23143	}
22226	23144
22227	23145	ZigType *result_elem_type = result_loc->value->type->data.pointer.child_type;
22228	23146	if (is_slice(result_elem_type)) {
22229		ErrorMsg *msg = ir_add_error(ira, &instruction->base,
	23147	ErrorMsg *msg = ir_add_error(ira, &instruction->base.base,
22230	23148	buf_sprintf("runtime-initialized array cannot be casted to slice type '%s'",
22231	23149	buf_ptr(&result_elem_type->name)));
22232		add_error_note(ira->codegen, msg, first_non_const_instruction->source_node,
	23150	add_error_note(ira->codegen, msg, first_non_const_instruction->base.source_node,
22233	23151	buf_sprintf("this value is not comptime-known"));
22234		return ira->codegen->invalid_instruction;
	23152	return ira->codegen->invalid_inst_gen;
22235	23153	}
22236	23154	return result;
22237	23155	}
22238	23156
22239		static IrInstruction ir_analyze_instruction_container_init_fields(IrAnalyze ira,
22240		IrInstructionContainerInitFields *instruction)
	23157	static IrInstGen ir_analyze_instruction_container_init_fields(IrAnalyze ira,
	23158	IrInstSrcContainerInitFields *instruction)
22241	23159	{
22242		ir_assert(instruction->result_loc != nullptr, &instruction->base);
22243		IrInstruction *result_loc = instruction->result_loc->child;
	23160	ir_assert(instruction->result_loc != nullptr, &instruction->base.base);
	23161	IrInstGen *result_loc = instruction->result_loc->child;
22244	23162	if (type_is_invalid(result_loc->value->type))
22245	23163	return result_loc;
22246	23164
22247		ir_assert(result_loc->value->type->id == ZigTypeIdPointer, &instruction->base);
	23165	ir_assert(result_loc->value->type->id == ZigTypeIdPointer, &instruction->base.base);
22248	23166	ZigType *container_type = result_loc->value->type->data.pointer.child_type;
22249	23167
22250		return ir_analyze_container_init_fields(ira, &instruction->base, container_type,
	23168	return ir_analyze_container_init_fields(ira, &instruction->base.base, container_type,
22251	23169	instruction->field_count, instruction->fields, result_loc);
22252	23170	}
22253	23171
22254		static IrInstruction ir_analyze_instruction_compile_err(IrAnalyze ira,
22255		IrInstructionCompileErr *instruction)
22256		{
22257		IrInstruction *msg_value = instruction->msg->child;
	23172	static IrInstGen ir_analyze_instruction_compile_err(IrAnalyze ira, IrInstSrcCompileErr *instruction) {
	23173	IrInstGen *msg_value = instruction->msg->child;
22258	23174	Buf *msg_buf = ir_resolve_str(ira, msg_value);
22259	23175	if (!msg_buf)
22260		return ira->codegen->invalid_instruction;
	23176	return ira->codegen->invalid_inst_gen;
22261	23177
22262		ir_add_error(ira, &instruction->base, msg_buf);
	23178	ir_add_error(ira, &instruction->base.base, msg_buf);
22263	23179
22264		return ira->codegen->invalid_instruction;
	23180	return ira->codegen->invalid_inst_gen;
22265	23181	}
22266	23182
22267		static IrInstruction ir_analyze_instruction_compile_log(IrAnalyze ira, IrInstructionCompileLog *instruction) {
	23183	static IrInstGen ir_analyze_instruction_compile_log(IrAnalyze ira, IrInstSrcCompileLog *instruction) {
22268	23184	Buf buf = BUF_INIT;
22269	23185	fprintf(stderr, "\| ");
22270	23186	for (size_t i = 0; i < instruction->msg_count; i += 1) {
22271		IrInstruction *msg = instruction->msg_list[i]->child;
	23187	IrInstGen *msg = instruction->msg_list[i]->child;
22272	23188	if (type_is_invalid(msg->value->type))
22273		return ira->codegen->invalid_instruction;
	23189	return ira->codegen->invalid_inst_gen;
22274	23190	buf_resize(&buf, 0);
22275	23191	if (msg->value->special == ConstValSpecialLazy) {
22276	23192	// Resolve any lazy value that's passed, we need its value
22277		if (ir_resolve_lazy(ira->codegen, msg->source_node, msg->value))
22278		return ira->codegen->invalid_instruction;
	23193	if (ir_resolve_lazy(ira->codegen, msg->base.source_node, msg->value))
	23194	return ira->codegen->invalid_inst_gen;
22279	23195	}
22280	23196	render_const_value(ira->codegen, &buf, msg->value);
22281	23197	const char *comma_str = (i != 0) ? ", " : "";
...	...	@@ -22283,25 +23199,25 @@ static IrInstruction ir_analyze_instruction_compile_log(IrAnalyze ira, IrInstr
22283	23199	}
22284	23200	fprintf(stderr, "\n");
22285	23201
22286		auto *expr = &instruction->base.source_node->data.fn_call_expr;
	23202	auto *expr = &instruction->base.base.source_node->data.fn_call_expr;
22287	23203	if (!expr->seen) {
22288	23204	// Here we bypass higher level functions such as ir_add_error because we do not want
22289	23205	// invalidate_exec to be called.
22290		add_node_error(ira->codegen, instruction->base.source_node, buf_sprintf("found compile log statement"));
	23206	add_node_error(ira->codegen, instruction->base.base.source_node, buf_sprintf("found compile log statement"));
22291	23207	}
22292	23208	expr->seen = true;
22293	23209
22294		return ir_const_void(ira, &instruction->base);
	23210	return ir_const_void(ira, &instruction->base.base);
22295	23211	}
22296	23212
22297		static IrInstruction ir_analyze_instruction_err_name(IrAnalyze ira, IrInstructionErrName *instruction) {
22298		IrInstruction *value = instruction->value->child;
	23213	static IrInstGen ir_analyze_instruction_err_name(IrAnalyze ira, IrInstSrcErrName *instruction) {
	23214	IrInstGen *value = instruction->value->child;
22299	23215	if (type_is_invalid(value->value->type))
22300		return ira->codegen->invalid_instruction;
	23216	return ira->codegen->invalid_inst_gen;
22301	23217
22302		IrInstruction *casted_value = ir_implicit_cast(ira, value, ira->codegen->builtin_types.entry_global_error_set);
	23218	IrInstGen *casted_value = ir_implicit_cast(ira, value, ira->codegen->builtin_types.entry_global_error_set);
22303	23219	if (type_is_invalid(casted_value->value->type))
22304		return ira->codegen->invalid_instruction;
	23220	return ira->codegen->invalid_inst_gen;
22305	23221
22306	23222	ZigType *u8_ptr_type = get_pointer_to_type_extra(ira->codegen, ira->codegen->builtin_types.entry_u8,
22307	23223	true, false, PtrLenUnknown, 0, 0, 0, false);
...	...	@@ -22309,13 +23225,13 @@ static IrInstruction ir_analyze_instruction_err_name(IrAnalyze ira, IrInstruct
22309	23225	if (instr_is_comptime(casted_value)) {
22310	23226	ZigValue *val = ir_resolve_const(ira, casted_value, UndefBad);
22311	23227	if (val == nullptr)
22312		return ira->codegen->invalid_instruction;
	23228	return ira->codegen->invalid_inst_gen;
22313	23229	ErrorTableEntry *err = casted_value->value->data.x_err_set;
22314	23230	if (!err->cached_error_name_val) {
22315	23231	ZigValue *array_val = create_const_str_lit(ira->codegen, &err->name)->data.x_ptr.data.ref.pointee;
22316	23232	err->cached_error_name_val = create_const_slice(ira->codegen, array_val, 0, buf_len(&err->name), true);
22317	23233	}
22318		IrInstruction *result = ir_const(ira, &instruction->base, nullptr);
	23234	IrInstGen *result = ir_const(ira, &instruction->base.base, nullptr);
22319	23235	copy_const_val(result->value, err->cached_error_name_val);
22320	23236	result->value->type = str_type;
22321	23237	return result;
...	...	@@ -22323,20 +23239,17 @@ static IrInstruction ir_analyze_instruction_err_name(IrAnalyze ira, IrInstruct
22323	23239
22324	23240	ira->codegen->generate_error_name_table = true;
22325	23241
22326		IrInstruction *result = ir_build_err_name(&ira->new_irb,
22327		instruction->base.scope, instruction->base.source_node, value);
22328		result->value->type = str_type;
22329		return result;
	23242	return ir_build_err_name_gen(ira, &instruction->base.base, value, str_type);
22330	23243	}
22331	23244
22332		static IrInstruction ir_analyze_instruction_enum_tag_name(IrAnalyze ira, IrInstructionTagName *instruction) {
	23245	static IrInstGen ir_analyze_instruction_enum_tag_name(IrAnalyze ira, IrInstSrcTagName *instruction) {
22333	23246	Error err;
22334		IrInstruction *target = instruction->target->child;
	23247	IrInstGen *target = instruction->target->child;
22335	23248	if (type_is_invalid(target->value->type))
22336		return ira->codegen->invalid_instruction;
	23249	return ira->codegen->invalid_inst_gen;
22337	23250
22338	23251	if (target->value->type->id == ZigTypeIdEnumLiteral) {
22339		IrInstruction *result = ir_const(ira, &instruction->base, nullptr);
	23252	IrInstGen *result = ir_const(ira, &instruction->base.base, nullptr);
22340	23253	Buf *field_name = target->value->data.x_enum_literal;
22341	23254	ZigValue *array_val = create_const_str_lit(ira->codegen, field_name)->data.x_ptr.data.ref.pointee;
22342	23255	init_const_slice(ira->codegen, result->value, array_val, 0, buf_len(field_name), true);
...	...	@@ -22344,9 +23257,9 @@ static IrInstruction ir_analyze_instruction_enum_tag_name(IrAnalyze ira, IrIns
22344	23257	}
22345	23258
22346	23259	if (target->value->type->id == ZigTypeIdUnion) {
22347		target = ir_analyze_union_tag(ira, &instruction->base, target);
	23260	target = ir_analyze_union_tag(ira, &instruction->base.base, target, instruction->base.is_gen);
22348	23261	if (type_is_invalid(target->value->type))
22349		return ira->codegen->invalid_instruction;
	23262	return ira->codegen->invalid_inst_gen;
22350	23263	}
22351	23264
22352	23265	assert(target->value->type->id == ZigTypeIdEnum);
...	...	@@ -22355,75 +23268,73 @@ static IrInstruction ir_analyze_instruction_enum_tag_name(IrAnalyze ira, IrIns
22355	23268	!target->value->type->data.enumeration.non_exhaustive) {
22356	23269	TypeEnumField *only_field = &target->value->type->data.enumeration.fields[0];
22357	23270	ZigValue *array_val = create_const_str_lit(ira->codegen, only_field->name)->data.x_ptr.data.ref.pointee;
22358		IrInstruction *result = ir_const(ira, &instruction->base, nullptr);
	23271	IrInstGen *result = ir_const(ira, &instruction->base.base, nullptr);
22359	23272	init_const_slice(ira->codegen, result->value, array_val, 0, buf_len(only_field->name), true);
22360	23273	return result;
22361	23274	}
22362	23275
22363	23276	if (instr_is_comptime(target)) {
22364	23277	if ((err = type_resolve(ira->codegen, target->value->type, ResolveStatusZeroBitsKnown)))
22365		return ira->codegen->invalid_instruction;
	23278	return ira->codegen->invalid_inst_gen;
22366	23279	if (target->value->type->data.enumeration.non_exhaustive) {
22367		add_node_error(ira->codegen, instruction->base.source_node,
	23280	ir_add_error(ira, &instruction->base.base,
22368	23281	buf_sprintf("TODO @tagName on non-exhaustive enum https://github.com/ziglang/zig/issues/3991"));
22369		return ira->codegen->invalid_instruction;
	23282	return ira->codegen->invalid_inst_gen;
22370	23283	}
22371	23284	TypeEnumField *field = find_enum_field_by_tag(target->value->type, &target->value->data.x_bigint);
22372	23285	ZigValue *array_val = create_const_str_lit(ira->codegen, field->name)->data.x_ptr.data.ref.pointee;
22373		IrInstruction *result = ir_const(ira, &instruction->base, nullptr);
	23286	IrInstGen *result = ir_const(ira, &instruction->base.base, nullptr);
22374	23287	init_const_slice(ira->codegen, result->value, array_val, 0, buf_len(field->name), true);
22375	23288	return result;
22376	23289	}
22377	23290
22378		IrInstruction *result = ir_build_tag_name(&ira->new_irb, instruction->base.scope,
22379		instruction->base.source_node, target);
22380	23291	ZigType *u8_ptr_type = get_pointer_to_type_extra(
22381	23292	ira->codegen, ira->codegen->builtin_types.entry_u8,
22382	23293	true, false, PtrLenUnknown,
22383	23294	0, 0, 0, false);
22384		result->value->type = get_slice_type(ira->codegen, u8_ptr_type);
22385		return result;
	23295	ZigType *result_type = get_slice_type(ira->codegen, u8_ptr_type);
	23296	return ir_build_tag_name_gen(ira, &instruction->base.base, target, result_type);
22386	23297	}
22387	23298
22388		static IrInstruction ir_analyze_instruction_field_parent_ptr(IrAnalyze ira,
22389		IrInstructionFieldParentPtr *instruction)
	23299	static IrInstGen ir_analyze_instruction_field_parent_ptr(IrAnalyze ira,
	23300	IrInstSrcFieldParentPtr *instruction)
22390	23301	{
22391	23302	Error err;
22392		IrInstruction *type_value = instruction->type_value->child;
	23303	IrInstGen *type_value = instruction->type_value->child;
22393	23304	ZigType *container_type = ir_resolve_type(ira, type_value);
22394	23305	if (type_is_invalid(container_type))
22395		return ira->codegen->invalid_instruction;
	23306	return ira->codegen->invalid_inst_gen;
22396	23307
22397		IrInstruction *field_name_value = instruction->field_name->child;
	23308	IrInstGen *field_name_value = instruction->field_name->child;
22398	23309	Buf *field_name = ir_resolve_str(ira, field_name_value);
22399	23310	if (!field_name)
22400		return ira->codegen->invalid_instruction;
	23311	return ira->codegen->invalid_inst_gen;
22401	23312
22402		IrInstruction *field_ptr = instruction->field_ptr->child;
	23313	IrInstGen *field_ptr = instruction->field_ptr->child;
22403	23314	if (type_is_invalid(field_ptr->value->type))
22404		return ira->codegen->invalid_instruction;
	23315	return ira->codegen->invalid_inst_gen;
22405	23316
22406	23317	if (container_type->id != ZigTypeIdStruct) {
22407		ir_add_error(ira, type_value,
	23318	ir_add_error(ira, &type_value->base,
22408	23319	buf_sprintf("expected struct type, found '%s'", buf_ptr(&container_type->name)));
22409		return ira->codegen->invalid_instruction;
	23320	return ira->codegen->invalid_inst_gen;
22410	23321	}
22411	23322
22412	23323	if ((err = type_resolve(ira->codegen, container_type, ResolveStatusSizeKnown)))
22413		return ira->codegen->invalid_instruction;
	23324	return ira->codegen->invalid_inst_gen;
22414	23325
22415	23326	TypeStructField *field = find_struct_type_field(container_type, field_name);
22416	23327	if (field == nullptr) {
22417		ir_add_error(ira, field_name_value,
	23328	ir_add_error(ira, &field_name_value->base,
22418	23329	buf_sprintf("struct '%s' has no field '%s'",
22419	23330	buf_ptr(&container_type->name), buf_ptr(field_name)));
22420		return ira->codegen->invalid_instruction;
	23331	return ira->codegen->invalid_inst_gen;
22421	23332	}
22422	23333
22423	23334	if (field_ptr->value->type->id != ZigTypeIdPointer) {
22424		ir_add_error(ira, field_ptr,
	23335	ir_add_error(ira, &field_ptr->base,
22425	23336	buf_sprintf("expected pointer, found '%s'", buf_ptr(&field_ptr->value->type->name)));
22426		return ira->codegen->invalid_instruction;
	23337	return ira->codegen->invalid_inst_gen;
22427	23338	}
22428	23339
22429	23340	bool is_packed = (container_type->data.structure.layout == ContainerLayoutPacked);
...	...	@@ -22435,9 +23346,9 @@ static IrInstruction ir_analyze_instruction_field_parent_ptr(IrAnalyze ira,
22435	23346	field_ptr->value->type->data.pointer.is_volatile,
22436	23347	PtrLenSingle,
22437	23348	field_ptr_align, 0, 0, false);
22438		IrInstruction *casted_field_ptr = ir_implicit_cast(ira, field_ptr, field_ptr_type);
	23349	IrInstGen *casted_field_ptr = ir_implicit_cast(ira, field_ptr, field_ptr_type);
22439	23350	if (type_is_invalid(casted_field_ptr->value->type))
22440		return ira->codegen->invalid_instruction;
	23351	return ira->codegen->invalid_inst_gen;
22441	23352
22442	23353	ZigType *result_type = get_pointer_to_type_extra(ira->codegen, container_type,
22443	23354	casted_field_ptr->value->type->data.pointer.is_const,
...	...	@@ -22448,23 +23359,23 @@ static IrInstruction ir_analyze_instruction_field_parent_ptr(IrAnalyze ira,
22448	23359	if (instr_is_comptime(casted_field_ptr)) {
22449	23360	ZigValue *field_ptr_val = ir_resolve_const(ira, casted_field_ptr, UndefBad);
22450	23361	if (!field_ptr_val)
22451		return ira->codegen->invalid_instruction;
	23362	return ira->codegen->invalid_inst_gen;
22452	23363
22453	23364	if (field_ptr_val->data.x_ptr.special != ConstPtrSpecialBaseStruct) {
22454		ir_add_error(ira, field_ptr, buf_sprintf("pointer value not based on parent struct"));
22455		return ira->codegen->invalid_instruction;
	23365	ir_add_error(ira, &field_ptr->base, buf_sprintf("pointer value not based on parent struct"));
	23366	return ira->codegen->invalid_inst_gen;
22456	23367	}
22457	23368
22458	23369	size_t ptr_field_index = field_ptr_val->data.x_ptr.data.base_struct.field_index;
22459	23370	if (ptr_field_index != field->src_index) {
22460		ir_add_error(ira, &instruction->base,
	23371	ir_add_error(ira, &instruction->base.base,
22461	23372	buf_sprintf("field '%s' has index %" ZIG_PRI_usize " but pointer value is index %" ZIG_PRI_usize " of struct '%s'",
22462	23373	buf_ptr(field->name), field->src_index,
22463	23374	ptr_field_index, buf_ptr(&container_type->name)));
22464		return ira->codegen->invalid_instruction;
	23375	return ira->codegen->invalid_inst_gen;
22465	23376	}
22466	23377
22467		IrInstruction *result = ir_const(ira, &instruction->base, result_type);
	23378	IrInstGen *result = ir_const(ira, &instruction->base.base, result_type);
22468	23379	ZigValue *out_val = result->value;
22469	23380	out_val->data.x_ptr.special = ConstPtrSpecialRef;
22470	23381	out_val->data.x_ptr.data.ref.pointee = field_ptr_val->data.x_ptr.data.base_struct.struct_val;
...	...	@@ -22472,15 +23383,12 @@ static IrInstruction ir_analyze_instruction_field_parent_ptr(IrAnalyze ira,
22472	23383	return result;
22473	23384	}
22474	23385
22475		IrInstruction *result = ir_build_field_parent_ptr(&ira->new_irb, instruction->base.scope,
22476		instruction->base.source_node, type_value, field_name_value, casted_field_ptr, field);
22477		result->value->type = result_type;
22478		return result;
	23386	return ir_build_field_parent_ptr_gen(ira, &instruction->base.base, casted_field_ptr, field, result_type);
22479	23387	}
22480	23388
22481	23389	static TypeStructField validate_byte_offset(IrAnalyze ira,
22482		IrInstruction *type_value,
22483		IrInstruction *field_name_value,
	23390	IrInstGen *type_value,
	23391	IrInstGen *field_name_value,
22484	23392	size_t *byte_offset)
22485	23393	{
22486	23394	ZigType *container_type = ir_resolve_type(ira, type_value);
...	...	@@ -22496,21 +23404,21 @@ static TypeStructField validate_byte_offset(IrAnalyze ira,
22496	23404	return nullptr;
22497	23405
22498	23406	if (container_type->id != ZigTypeIdStruct) {
22499		ir_add_error(ira, type_value,
	23407	ir_add_error(ira, &type_value->base,
22500	23408	buf_sprintf("expected struct type, found '%s'", buf_ptr(&container_type->name)));
22501	23409	return nullptr;
22502	23410	}
22503	23411
22504	23412	TypeStructField *field = find_struct_type_field(container_type, field_name);
22505	23413	if (field == nullptr) {
22506		ir_add_error(ira, field_name_value,
	23414	ir_add_error(ira, &field_name_value->base,
22507	23415	buf_sprintf("struct '%s' has no field '%s'",
22508	23416	buf_ptr(&container_type->name), buf_ptr(field_name)));
22509	23417	return nullptr;
22510	23418	}
22511	23419
22512	23420	if (!type_has_bits(field->type_entry)) {
22513		ir_add_error(ira, field_name_value,
	23421	ir_add_error(ira, &field_name_value->base,
22514	23422	buf_sprintf("zero-bit field '%s' in struct '%s' has no offset",
22515	23423	buf_ptr(field_name), buf_ptr(&container_type->name)));
22516	23424	return nullptr;
...	...	@@ -22520,36 +23428,32 @@ static TypeStructField validate_byte_offset(IrAnalyze ira,
22520	23428	return field;
22521	23429	}
22522	23430
22523		static IrInstruction ir_analyze_instruction_byte_offset_of(IrAnalyze ira,
22524		IrInstructionByteOffsetOf *instruction)
22525		{
22526		IrInstruction *type_value = instruction->type_value->child;
	23431	static IrInstGen ir_analyze_instruction_byte_offset_of(IrAnalyze ira, IrInstSrcByteOffsetOf *instruction) {
	23432	IrInstGen *type_value = instruction->type_value->child;
22527	23433	if (type_is_invalid(type_value->value->type))
22528		return ira->codegen->invalid_instruction;
	23434	return ira->codegen->invalid_inst_gen;
22529	23435
22530		IrInstruction *field_name_value = instruction->field_name->child;
	23436	IrInstGen *field_name_value = instruction->field_name->child;
22531	23437	size_t byte_offset = 0;
22532	23438	if (!validate_byte_offset(ira, type_value, field_name_value, &byte_offset))
22533		return ira->codegen->invalid_instruction;
	23439	return ira->codegen->invalid_inst_gen;
22534	23440
22535	23441
22536		return ir_const_unsigned(ira, &instruction->base, byte_offset);
	23442	return ir_const_unsigned(ira, &instruction->base.base, byte_offset);
22537	23443	}
22538	23444
22539		static IrInstruction ir_analyze_instruction_bit_offset_of(IrAnalyze ira,
22540		IrInstructionBitOffsetOf *instruction)
22541		{
22542		IrInstruction *type_value = instruction->type_value->child;
	23445	static IrInstGen ir_analyze_instruction_bit_offset_of(IrAnalyze ira, IrInstSrcBitOffsetOf *instruction) {
	23446	IrInstGen *type_value = instruction->type_value->child;
22543	23447	if (type_is_invalid(type_value->value->type))
22544		return ira->codegen->invalid_instruction;
22545		IrInstruction *field_name_value = instruction->field_name->child;
	23448	return ira->codegen->invalid_inst_gen;
	23449	IrInstGen *field_name_value = instruction->field_name->child;
22546	23450	size_t byte_offset = 0;
22547	23451	TypeStructField *field = nullptr;
22548	23452	if (!(field = validate_byte_offset(ira, type_value, field_name_value, &byte_offset)))
22549		return ira->codegen->invalid_instruction;
	23453	return ira->codegen->invalid_inst_gen;
22550	23454
22551	23455	size_t bit_offset = byte_offset * 8 + field->bit_offset_in_host;
22552		return ir_const_unsigned(ira, &instruction->base, bit_offset);
	23456	return ir_const_unsigned(ira, &instruction->base.base, bit_offset);
22553	23457	}
22554	23458
22555	23459	static void ensure_field_index(ZigType type, const char field_name, size_t index) {
...	...	@@ -22597,7 +23501,7 @@ static ZigType ir_type_info_get_type(IrAnalyze ira, const char *type_name, Zig
22597	23501	return ir_resolve_const_type(ira->codegen, ira->new_irb.exec, nullptr, var->const_value);
22598	23502	}
22599	23503
22600		static Error ir_make_type_info_decls(IrAnalyze ira, IrInstruction source_instr, ZigValue *out_val,
	23504	static Error ir_make_type_info_decls(IrAnalyze ira, IrInst source_instr, ZigValue *out_val,
22601	23505	ScopeDecls *decls_scope)
22602	23506	{
22603	23507	Error err;
...	...	@@ -22955,7 +23859,7 @@ static void make_enum_field_val(IrAnalyze ira, ZigValue enum_field_val, TypeEn
22955	23859	enum_field_val->data.x_struct.fields = inner_fields;
22956	23860	}
22957	23861
22958		static Error ir_make_type_info_value(IrAnalyze ira, IrInstruction source_instr, ZigType *type_entry,
	23862	static Error ir_make_type_info_value(IrAnalyze ira, IrInst source_instr, ZigType *type_entry,
22959	23863	ZigValue **out)
22960	23864	{
22961	23865	Error err;
...	...	@@ -23543,22 +24447,20 @@ static Error ir_make_type_info_value(IrAnalyze ira, IrInstruction source_instr
23543	24447	return ErrorNone;
23544	24448	}
23545	24449
23546		static IrInstruction ir_analyze_instruction_type_info(IrAnalyze ira,
23547		IrInstructionTypeInfo *instruction)
23548		{
	24450	static IrInstGen ir_analyze_instruction_type_info(IrAnalyze ira, IrInstSrcTypeInfo *instruction) {
23549	24451	Error err;
23550		IrInstruction *type_value = instruction->type_value->child;
	24452	IrInstGen *type_value = instruction->type_value->child;
23551	24453	ZigType *type_entry = ir_resolve_type(ira, type_value);
23552	24454	if (type_is_invalid(type_entry))
23553		return ira->codegen->invalid_instruction;
	24455	return ira->codegen->invalid_inst_gen;
23554	24456
23555	24457	ZigType *result_type = ir_type_info_get_type(ira, nullptr, nullptr);
23556	24458
23557	24459	ZigValue *payload;
23558		if ((err = ir_make_type_info_value(ira, &instruction->base, type_entry, &payload)))
23559		return ira->codegen->invalid_instruction;
	24460	if ((err = ir_make_type_info_value(ira, &instruction->base.base, type_entry, &payload)))
	24461	return ira->codegen->invalid_inst_gen;
23560	24462
23561		IrInstruction *result = ir_const(ira, &instruction->base, result_type);
	24463	IrInstGen *result = ir_const(ira, &instruction->base.base, result_type);
23562	24464	ZigValue *out_val = result->value;
23563	24465	bigint_init_unsigned(&out_val->data.x_union.tag, type_id_index(type_entry));
23564	24466	out_val->data.x_union.payload = payload;
...	...	@@ -23582,15 +24484,15 @@ static ZigValue get_const_field(IrAnalyze ira, AstNode *source_node, ZigValue
23582	24484	return val;
23583	24485	}
23584	24486
23585		static Error get_const_field_sentinel(IrAnalyze ira, IrInstruction source_instr, ZigValue *struct_value,
	24487	static Error get_const_field_sentinel(IrAnalyze ira, IrInst source_instr, ZigValue *struct_value,
23586	24488	const char name, size_t field_index, ZigType elem_type, ZigValue **result)
23587	24489	{
23588	24490	ZigValue *field_val = get_const_field(ira, source_instr->source_node, struct_value, name, field_index);
23589	24491	if (field_val == nullptr)
23590	24492	return ErrorSemanticAnalyzeFail;
23591	24493
23592		IrInstruction *field_inst = ir_const_move(ira, source_instr, field_val);
23593		IrInstruction *casted_field_inst = ir_implicit_cast(ira, field_inst,
	24494	IrInstGen *field_inst = ir_const_move(ira, source_instr, field_val);
	24495	IrInstGen *casted_field_inst = ir_implicit_cast(ira, field_inst,
23594	24496	get_optional_type(ira->codegen, elem_type));
23595	24497	if (type_is_invalid(casted_field_inst->value->type))
23596	24498	return ErrorSemanticAnalyzeFail;
...	...	@@ -23629,12 +24531,12 @@ static ZigType get_const_field_meta_type(IrAnalyze ira, AstNode *source_node,
23629	24531	{
23630	24532	ZigValue *value = get_const_field(ira, source_node, struct_value, name, field_index);
23631	24533	if (value == nullptr)
23632		return ira->codegen->invalid_instruction->value->type;
	24534	return ira->codegen->invalid_inst_gen->value->type;
23633	24535	assert(value->type == ira->codegen->builtin_types.entry_type);
23634	24536	return value->data.x_type;
23635	24537	}
23636	24538
23637		static ZigType type_info_to_type(IrAnalyze ira, IrInstruction instruction, ZigTypeId tagTypeId, ZigValue payload) {
	24539	static ZigType type_info_to_type(IrAnalyze ira, IrInst source_instr, ZigTypeId tagTypeId, ZigValue payload) {
23638	24540	Error err;
23639	24541	switch (tagTypeId) {
23640	24542	case ZigTypeIdInvalid:
...	...	@@ -23650,21 +24552,21 @@ static ZigType type_info_to_type(IrAnalyze ira, IrInstruction *instruction, Zi
23650	24552	case ZigTypeIdInt: {
23651	24553	assert(payload->special == ConstValSpecialStatic);
23652	24554	assert(payload->type == ir_type_info_get_type(ira, "Int", nullptr));
23653		BigInt *bi = get_const_field_lit_int(ira, instruction->source_node, payload, "bits", 1);
	24555	BigInt *bi = get_const_field_lit_int(ira, source_instr->source_node, payload, "bits", 1);
23654	24556	if (bi == nullptr)
23655		return ira->codegen->invalid_instruction->value->type;
	24557	return ira->codegen->invalid_inst_gen->value->type;
23656	24558	bool is_signed;
23657		if ((err = get_const_field_bool(ira, instruction->source_node, payload, "is_signed", 0, &is_signed)))
23658		return ira->codegen->invalid_instruction->value->type;
	24559	if ((err = get_const_field_bool(ira, source_instr->source_node, payload, "is_signed", 0, &is_signed)))
	24560	return ira->codegen->invalid_inst_gen->value->type;
23659	24561	return get_int_type(ira->codegen, is_signed, bigint_as_u32(bi));
23660	24562	}
23661	24563	case ZigTypeIdFloat:
23662	24564	{
23663	24565	assert(payload->special == ConstValSpecialStatic);
23664	24566	assert(payload->type == ir_type_info_get_type(ira, "Float", nullptr));
23665		BigInt *bi = get_const_field_lit_int(ira, instruction->source_node, payload, "bits", 0);
	24567	BigInt *bi = get_const_field_lit_int(ira, source_instr->source_node, payload, "bits", 0);
23666	24568	if (bi == nullptr)
23667		return ira->codegen->invalid_instruction->value->type;
	24569	return ira->codegen->invalid_inst_gen->value->type;
23668	24570	uint32_t bits = bigint_as_u32(bi);
23669	24571	switch (bits) {
23670	24572	case 16: return ira->codegen->builtin_types.entry_f16;
...	...	@@ -23672,48 +24574,47 @@ static ZigType type_info_to_type(IrAnalyze ira, IrInstruction *instruction, Zi
23672	24574	case 64: return ira->codegen->builtin_types.entry_f64;
23673	24575	case 128: return ira->codegen->builtin_types.entry_f128;
23674	24576	}
23675		ir_add_error(ira, instruction,
23676		buf_sprintf("%d-bit float unsupported", bits));
23677		return ira->codegen->invalid_instruction->value->type;
	24577	ir_add_error(ira, source_instr, buf_sprintf("%d-bit float unsupported", bits));
	24578	return ira->codegen->invalid_inst_gen->value->type;
23678	24579	}
23679	24580	case ZigTypeIdPointer:
23680	24581	{
23681	24582	ZigType *type_info_pointer_type = ir_type_info_get_type(ira, "Pointer", nullptr);
23682	24583	assert(payload->special == ConstValSpecialStatic);
23683	24584	assert(payload->type == type_info_pointer_type);
23684		ZigValue *size_value = get_const_field(ira, instruction->source_node, payload, "size", 0);
	24585	ZigValue *size_value = get_const_field(ira, source_instr->source_node, payload, "size", 0);
23685	24586	assert(size_value->type == ir_type_info_get_type(ira, "Size", type_info_pointer_type));
23686	24587	BuiltinPtrSize size_enum_index = (BuiltinPtrSize)bigint_as_u32(&size_value->data.x_enum_tag);
23687	24588	PtrLen ptr_len = size_enum_index_to_ptr_len(size_enum_index);
23688		ZigType *elem_type = get_const_field_meta_type(ira, instruction->source_node, payload, "child", 4);
	24589	ZigType *elem_type = get_const_field_meta_type(ira, source_instr->source_node, payload, "child", 4);
23689	24590	if (type_is_invalid(elem_type))
23690		return ira->codegen->invalid_instruction->value->type;
	24591	return ira->codegen->invalid_inst_gen->value->type;
23691	24592	ZigValue *sentinel;
23692		if ((err = get_const_field_sentinel(ira, instruction, payload, "sentinel", 6,
	24593	if ((err = get_const_field_sentinel(ira, source_instr, payload, "sentinel", 6,
23693	24594	elem_type, &sentinel)))
23694	24595	{
23695		return ira->codegen->invalid_instruction->value->type;
	24596	return ira->codegen->invalid_inst_gen->value->type;
23696	24597	}
23697		BigInt *bi = get_const_field_lit_int(ira, instruction->source_node, payload, "alignment", 3);
	24598	BigInt *bi = get_const_field_lit_int(ira, source_instr->source_node, payload, "alignment", 3);
23698	24599	if (bi == nullptr)
23699		return ira->codegen->invalid_instruction->value->type;
	24600	return ira->codegen->invalid_inst_gen->value->type;
23700	24601
23701	24602	bool is_const;
23702		if ((err = get_const_field_bool(ira, instruction->source_node, payload, "is_const", 1, &is_const)))
23703		return ira->codegen->invalid_instruction->value->type;
	24603	if ((err = get_const_field_bool(ira, source_instr->source_node, payload, "is_const", 1, &is_const)))
	24604	return ira->codegen->invalid_inst_gen->value->type;
23704	24605
23705	24606	bool is_volatile;
23706		if ((err = get_const_field_bool(ira, instruction->source_node, payload, "is_volatile", 2,
	24607	if ((err = get_const_field_bool(ira, source_instr->source_node, payload, "is_volatile", 2,
23707	24608	&is_volatile)))
23708	24609	{
23709		return ira->codegen->invalid_instruction->value->type;
	24610	return ira->codegen->invalid_inst_gen->value->type;
23710	24611	}
23711	24612
23712	24613	bool is_allowzero;
23713		if ((err = get_const_field_bool(ira, instruction->source_node, payload, "is_allowzero", 5,
	24614	if ((err = get_const_field_bool(ira, source_instr->source_node, payload, "is_allowzero", 5,
23714	24615	&is_allowzero)))
23715	24616	{
23716		return ira->codegen->invalid_instruction->value->type;
	24617	return ira->codegen->invalid_inst_gen->value->type;
23717	24618	}
23718	24619
23719	24620
...	...	@@ -23734,18 +24635,18 @@ static ZigType type_info_to_type(IrAnalyze ira, IrInstruction *instruction, Zi
23734	24635	case ZigTypeIdArray: {
23735	24636	assert(payload->special == ConstValSpecialStatic);
23736	24637	assert(payload->type == ir_type_info_get_type(ira, "Array", nullptr));
23737		ZigType *elem_type = get_const_field_meta_type(ira, instruction->source_node, payload, "child", 1);
	24638	ZigType *elem_type = get_const_field_meta_type(ira, source_instr->source_node, payload, "child", 1);
23738	24639	if (type_is_invalid(elem_type))
23739		return ira->codegen->invalid_instruction->value->type;
	24640	return ira->codegen->invalid_inst_gen->value->type;
23740	24641	ZigValue *sentinel;
23741		if ((err = get_const_field_sentinel(ira, instruction, payload, "sentinel", 2,
	24642	if ((err = get_const_field_sentinel(ira, source_instr, payload, "sentinel", 2,
23742	24643	elem_type, &sentinel)))
23743	24644	{
23744		return ira->codegen->invalid_instruction->value->type;
	24645	return ira->codegen->invalid_inst_gen->value->type;
23745	24646	}
23746		BigInt *bi = get_const_field_lit_int(ira, instruction->source_node, payload, "len", 0);
	24647	BigInt *bi = get_const_field_lit_int(ira, source_instr->source_node, payload, "len", 0);
23747	24648	if (bi == nullptr)
23748		return ira->codegen->invalid_instruction->value->type;
	24649	return ira->codegen->invalid_inst_gen->value->type;
23749	24650	return get_array_type(ira->codegen, elem_type, bigint_as_u64(bi), sentinel);
23750	24651	}
23751	24652	case ZigTypeIdComptimeFloat:
...	...	@@ -23765,78 +24666,77 @@ static ZigType type_info_to_type(IrAnalyze ira, IrInstruction *instruction, Zi
23765	24666	case ZigTypeIdAnyFrame:
23766	24667	case ZigTypeIdVector:
23767	24668	case ZigTypeIdEnumLiteral:
23768		ir_add_error(ira, instruction, buf_sprintf(
	24669	ir_add_error(ira, source_instr, buf_sprintf(
23769	24670	"TODO implement @Type for 'TypeInfo.%s': see https://github.com/ziglang/zig/issues/2907", type_id_name(tagTypeId)));
23770		return ira->codegen->invalid_instruction->value->type;
	24671	return ira->codegen->invalid_inst_gen->value->type;
23771	24672	case ZigTypeIdUnion:
23772	24673	case ZigTypeIdFn:
23773	24674	case ZigTypeIdBoundFn:
23774	24675	case ZigTypeIdStruct:
23775		ir_add_error(ira, instruction, buf_sprintf(
	24676	ir_add_error(ira, source_instr, buf_sprintf(
23776	24677	"@Type not availble for 'TypeInfo.%s'", type_id_name(tagTypeId)));
23777		return ira->codegen->invalid_instruction->value->type;
	24678	return ira->codegen->invalid_inst_gen->value->type;
23778	24679	}
23779	24680	zig_unreachable();
23780	24681	}
23781	24682
23782		static IrInstruction ir_analyze_instruction_type(IrAnalyze ira, IrInstructionType *instruction) {
23783		IrInstruction *type_info_ir = instruction->type_info->child;
23784		if (type_is_invalid(type_info_ir->value->type))
23785		return ira->codegen->invalid_instruction;
	24683	static IrInstGen ir_analyze_instruction_type(IrAnalyze ira, IrInstSrcType *instruction) {
	24684	IrInstGen *uncasted_type_info = instruction->type_info->child;
	24685	if (type_is_invalid(uncasted_type_info->value->type))
	24686	return ira->codegen->invalid_inst_gen;
23786	24687
23787		IrInstruction *casted_ir = ir_implicit_cast(ira, type_info_ir, ir_type_info_get_type(ira, nullptr, nullptr));
23788		if (type_is_invalid(casted_ir->value->type))
23789		return ira->codegen->invalid_instruction;
	24688	IrInstGen *type_info = ir_implicit_cast(ira, uncasted_type_info, ir_type_info_get_type(ira, nullptr, nullptr));
	24689	if (type_is_invalid(type_info->value->type))
	24690	return ira->codegen->invalid_inst_gen;
23790	24691
23791		ZigValue *type_info_value = ir_resolve_const(ira, casted_ir, UndefBad);
23792		if (!type_info_value)
23793		return ira->codegen->invalid_instruction;
23794		ZigTypeId typeId = type_id_at_index(bigint_as_usize(&type_info_value->data.x_union.tag));
23795		ZigType *type = type_info_to_type(ira, type_info_ir, typeId, type_info_value->data.x_union.payload);
	24692	ZigValue *type_info_val = ir_resolve_const(ira, type_info, UndefBad);
	24693	if (type_info_val == nullptr)
	24694	return ira->codegen->invalid_inst_gen;
	24695	ZigTypeId type_id_tag = type_id_at_index(bigint_as_usize(&type_info_val->data.x_union.tag));
	24696	ZigType *type = type_info_to_type(ira, &uncasted_type_info->base, type_id_tag,
	24697	type_info_val->data.x_union.payload);
23796	24698	if (type_is_invalid(type))
23797		return ira->codegen->invalid_instruction;
23798		return ir_const_type(ira, &instruction->base, type);
	24699	return ira->codegen->invalid_inst_gen;
	24700	return ir_const_type(ira, &instruction->base.base, type);
23799	24701	}
23800	24702
23801		static IrInstruction ir_analyze_instruction_type_id(IrAnalyze ira,
23802		IrInstructionTypeId *instruction)
23803		{
23804		IrInstruction *type_value = instruction->type_value->child;
	24703	static IrInstGen ir_analyze_instruction_type_id(IrAnalyze ira, IrInstSrcTypeId *instruction) {
	24704	IrInstGen *type_value = instruction->type_value->child;
23805	24705	ZigType *type_entry = ir_resolve_type(ira, type_value);
23806	24706	if (type_is_invalid(type_entry))
23807		return ira->codegen->invalid_instruction;
	24707	return ira->codegen->invalid_inst_gen;
23808	24708
23809	24709	ZigType *result_type = get_builtin_type(ira->codegen, "TypeId");
23810	24710
23811		IrInstruction *result = ir_const(ira, &instruction->base, result_type);
	24711	IrInstGen *result = ir_const(ira, &instruction->base.base, result_type);
23812	24712	bigint_init_unsigned(&result->value->data.x_enum_tag, type_id_index(type_entry));
23813	24713	return result;
23814	24714	}
23815	24715
23816		static IrInstruction ir_analyze_instruction_set_eval_branch_quota(IrAnalyze ira,
23817		IrInstructionSetEvalBranchQuota *instruction)
	24716	static IrInstGen ir_analyze_instruction_set_eval_branch_quota(IrAnalyze ira,
	24717	IrInstSrcSetEvalBranchQuota *instruction)
23818	24718	{
23819	24719	uint64_t new_quota;
23820	24720	if (!ir_resolve_usize(ira, instruction->new_quota->child, &new_quota))
23821		return ira->codegen->invalid_instruction;
	24721	return ira->codegen->invalid_inst_gen;
23822	24722
23823	24723	if (new_quota > *ira->new_irb.exec->backward_branch_quota) {
23824	24724	*ira->new_irb.exec->backward_branch_quota = new_quota;
23825	24725	}
23826	24726
23827		return ir_const_void(ira, &instruction->base);
	24727	return ir_const_void(ira, &instruction->base.base);
23828	24728	}
23829	24729
23830		static IrInstruction ir_analyze_instruction_type_name(IrAnalyze ira, IrInstructionTypeName *instruction) {
23831		IrInstruction *type_value = instruction->type_value->child;
	24730	static IrInstGen ir_analyze_instruction_type_name(IrAnalyze ira, IrInstSrcTypeName *instruction) {
	24731	IrInstGen *type_value = instruction->type_value->child;
23832	24732	ZigType *type_entry = ir_resolve_type(ira, type_value);
23833	24733	if (type_is_invalid(type_entry))
23834		return ira->codegen->invalid_instruction;
	24734	return ira->codegen->invalid_inst_gen;
23835	24735
23836	24736	if (!type_entry->cached_const_name_val) {
23837	24737	type_entry->cached_const_name_val = create_const_str_lit(ira->codegen, type_bare_name(type_entry));
23838	24738	}
23839		IrInstruction *result = ir_const(ira, &instruction->base, nullptr);
	24739	IrInstGen *result = ir_const(ira, &instruction->base.base, nullptr);
23840	24740	copy_const_val(result->value, type_entry->cached_const_name_val);
23841	24741	return result;
23842	24742	}
...	...	@@ -23848,13 +24748,13 @@ static void ir_cimport_cache_paths(Buf cache_dir, Buf tmp_c_file_digest, Buf *
23848	24748	buf_ptr(cache_dir), buf_ptr(tmp_c_file_digest));
23849	24749	buf_appendf(out_zig_path, "%s" OS_SEP "cimport.zig", buf_ptr(out_zig_dir));
23850	24750	}
23851		static IrInstruction ir_analyze_instruction_c_import(IrAnalyze ira, IrInstructionCImport *instruction) {
	24751	static IrInstGen ir_analyze_instruction_c_import(IrAnalyze ira, IrInstSrcCImport *instruction) {
23852	24752	Error err;
23853		AstNode *node = instruction->base.source_node;
	24753	AstNode *node = instruction->base.base.source_node;
23854	24754	assert(node->type == NodeTypeFnCallExpr);
23855	24755	AstNode *block_node = node->data.fn_call_expr.params.at(0);
23856	24756
23857		ScopeCImport *cimport_scope = create_cimport_scope(ira->codegen, node, instruction->base.scope);
	24757	ScopeCImport *cimport_scope = create_cimport_scope(ira->codegen, node, instruction->base.base.scope);
23858	24758
23859	24759	// Execute the C import block like an inline function
23860	24760	ZigType *void_type = ira->codegen->builtin_types.entry_void;
...	...	@@ -23862,9 +24762,9 @@ static IrInstruction ir_analyze_instruction_c_import(IrAnalyze ira, IrInstruct
23862	24762	ira->new_irb.exec->backward_branch_count, ira->new_irb.exec->backward_branch_quota, nullptr,
23863	24763	&cimport_scope->buf, block_node, nullptr, nullptr, nullptr, UndefBad);
23864	24764	if (type_is_invalid(cimport_result->type))
23865		return ira->codegen->invalid_instruction;
	24765	return ira->codegen->invalid_inst_gen;
23866	24766
23867		ZigPackage *cur_scope_pkg = scope_package(instruction->base.scope);
	24767	ZigPackage *cur_scope_pkg = scope_package(instruction->base.base.scope);
23868	24768	Buf *namespace_name = buf_sprintf("%s.cimport:%" ZIG_PRI_usize ":%" ZIG_PRI_usize,
23869	24769	buf_ptr(&cur_scope_pkg->pkg_path), node->line + 1, node->column + 1);
23870	24770
...	...	@@ -23876,7 +24776,7 @@ static IrInstruction ir_analyze_instruction_c_import(IrAnalyze ira, IrInstruct
23876	24776	CacheHash *cache_hash;
23877	24777	if ((err = create_c_object_cache(ira->codegen, &cache_hash, false))) {
23878	24778	ir_add_error_node(ira, node, buf_sprintf("C import failed: unable to create cache: %s", err_str(err)));
23879		return ira->codegen->invalid_instruction;
	24779	return ira->codegen->invalid_inst_gen;
23880	24780	}
23881	24781	cache_buf(cache_hash, &cimport_scope->buf);
23882	24782
...	...	@@ -23888,7 +24788,7 @@ static IrInstruction ir_analyze_instruction_c_import(IrAnalyze ira, IrInstruct
23888	24788	if ((err = cache_hit(cache_hash, &tmp_c_file_digest))) {
23889	24789	if (err != ErrorInvalidFormat) {
23890	24790	ir_add_error_node(ira, node, buf_sprintf("C import failed: unable to check cache: %s", err_str(err)));
23891		return ira->codegen->invalid_instruction;
	24791	return ira->codegen->invalid_inst_gen;
23892	24792	}
23893	24793	}
23894	24794	ira->codegen->caches_to_release.append(cache_hash);
...	...	@@ -23907,12 +24807,12 @@ static IrInstruction ir_analyze_instruction_c_import(IrAnalyze ira, IrInstruct
23907	24807
23908	24808	if ((err = os_make_path(tmp_c_file_dir))) {
23909	24809	ir_add_error_node(ira, node, buf_sprintf("C import failed: unable to make dir: %s", err_str(err)));
23910		return ira->codegen->invalid_instruction;
	24810	return ira->codegen->invalid_inst_gen;
23911	24811	}
23912	24812
23913	24813	if ((err = os_write_file(&tmp_c_file_path, &cimport_scope->buf))) {
23914	24814	ir_add_error_node(ira, node, buf_sprintf("C import failed: unable to write .h file: %s", err_str(err)));
23915		return ira->codegen->invalid_instruction;
	24815	return ira->codegen->invalid_inst_gen;
23916	24816	}
23917	24817	if (ira->codegen->verbose_cimport) {
23918	24818	fprintf(stderr, "@cImport source: %s\n", buf_ptr(&tmp_c_file_path));
...	...	@@ -23947,7 +24847,7 @@ static IrInstruction ir_analyze_instruction_c_import(IrAnalyze ira, IrInstruct
23947	24847	{
23948	24848	if (err != ErrorCCompileErrors) {
23949	24849	ir_add_error_node(ira, node, buf_sprintf("C import failed: %s", err_str(err)));
23950		return ira->codegen->invalid_instruction;
	24850	return ira->codegen->invalid_inst_gen;
23951	24851	}
23952	24852
23953	24853	ErrorMsg *parent_err_msg = ir_add_error_node(ira, node, buf_sprintf("C import failed"));
...	...	@@ -23968,7 +24868,7 @@ static IrInstruction ir_analyze_instruction_c_import(IrAnalyze ira, IrInstruct
23968	24868	}
23969	24869	}
23970	24870
23971		return ira->codegen->invalid_instruction;
	24871	return ira->codegen->invalid_inst_gen;
23972	24872	}
23973	24873	if (ira->codegen->verbose_cimport) {
23974	24874	fprintf(stderr, "@cImport .d file: %s\n", buf_ptr(tmp_dep_file));
...	...	@@ -23976,29 +24876,29 @@ static IrInstruction ir_analyze_instruction_c_import(IrAnalyze ira, IrInstruct
23976	24876
23977	24877	if ((err = cache_add_dep_file(cache_hash, tmp_dep_file, false))) {
23978	24878	ir_add_error_node(ira, node, buf_sprintf("C import failed: unable to parse .d file: %s", err_str(err)));
23979		return ira->codegen->invalid_instruction;
	24879	return ira->codegen->invalid_inst_gen;
23980	24880	}
23981	24881	if ((err = cache_final(cache_hash, &tmp_c_file_digest))) {
23982	24882	ir_add_error_node(ira, node, buf_sprintf("C import failed: unable to finalize cache: %s", err_str(err)));
23983		return ira->codegen->invalid_instruction;
	24883	return ira->codegen->invalid_inst_gen;
23984	24884	}
23985	24885
23986	24886	ir_cimport_cache_paths(ira->codegen->cache_dir, &tmp_c_file_digest, out_zig_dir, out_zig_path);
23987	24887	if ((err = os_make_path(out_zig_dir))) {
23988	24888	ir_add_error_node(ira, node, buf_sprintf("C import failed: unable to make output dir: %s", err_str(err)));
23989		return ira->codegen->invalid_instruction;
	24889	return ira->codegen->invalid_inst_gen;
23990	24890	}
23991	24891	FILE *out_file = fopen(buf_ptr(out_zig_path), "wb");
23992	24892	if (out_file == nullptr) {
23993	24893	ir_add_error_node(ira, node,
23994	24894	buf_sprintf("C import failed: unable to open output file: %s", strerror(errno)));
23995		return ira->codegen->invalid_instruction;
	24895	return ira->codegen->invalid_inst_gen;
23996	24896	}
23997	24897	stage2_render_ast(ast, out_file);
23998	24898	if (fclose(out_file) != 0) {
23999	24899	ir_add_error_node(ira, node,
24000	24900	buf_sprintf("C import failed: unable to write to output file: %s", strerror(errno)));
24001		return ira->codegen->invalid_instruction;
	24901	return ira->codegen->invalid_inst_gen;
24002	24902	}
24003	24903
24004	24904	if (ira->codegen->verbose_cimport) {
...	...	@@ -24017,90 +24917,90 @@ static IrInstruction ir_analyze_instruction_c_import(IrAnalyze ira, IrInstruct
24017	24917	if ((err = file_fetch(ira->codegen, out_zig_path, import_code))) {
24018	24918	ir_add_error_node(ira, node,
24019	24919	buf_sprintf("unable to open '%s': %s", buf_ptr(out_zig_path), err_str(err)));
24020		return ira->codegen->invalid_instruction;
	24920	return ira->codegen->invalid_inst_gen;
24021	24921	}
24022	24922	ZigType *child_import = add_source_file(ira->codegen, cimport_pkg, out_zig_path,
24023	24923	import_code, SourceKindCImport);
24024		return ir_const_type(ira, &instruction->base, child_import);
	24924	return ir_const_type(ira, &instruction->base.base, child_import);
24025	24925	}
24026	24926
24027		static IrInstruction ir_analyze_instruction_c_include(IrAnalyze ira, IrInstructionCInclude *instruction) {
24028		IrInstruction *name_value = instruction->name->child;
	24927	static IrInstGen ir_analyze_instruction_c_include(IrAnalyze ira, IrInstSrcCInclude *instruction) {
	24928	IrInstGen *name_value = instruction->name->child;
24029	24929	if (type_is_invalid(name_value->value->type))
24030		return ira->codegen->invalid_instruction;
	24930	return ira->codegen->invalid_inst_gen;
24031	24931
24032	24932	Buf *include_name = ir_resolve_str(ira, name_value);
24033	24933	if (!include_name)
24034		return ira->codegen->invalid_instruction;
	24934	return ira->codegen->invalid_inst_gen;
24035	24935
24036		Buf *c_import_buf = exec_c_import_buf(ira->new_irb.exec);
	24936	Buf *c_import_buf = ira->new_irb.exec->c_import_buf;
24037	24937	// We check for this error in pass1
24038	24938	assert(c_import_buf);
24039	24939
24040	24940	buf_appendf(c_import_buf, "#include <%s>\n", buf_ptr(include_name));
24041	24941
24042		return ir_const_void(ira, &instruction->base);
	24942	return ir_const_void(ira, &instruction->base.base);
24043	24943	}
24044	24944
24045		static IrInstruction ir_analyze_instruction_c_define(IrAnalyze ira, IrInstructionCDefine *instruction) {
24046		IrInstruction *name = instruction->name->child;
	24945	static IrInstGen ir_analyze_instruction_c_define(IrAnalyze ira, IrInstSrcCDefine *instruction) {
	24946	IrInstGen *name = instruction->name->child;
24047	24947	if (type_is_invalid(name->value->type))
24048		return ira->codegen->invalid_instruction;
	24948	return ira->codegen->invalid_inst_gen;
24049	24949
24050	24950	Buf *define_name = ir_resolve_str(ira, name);
24051	24951	if (!define_name)
24052		return ira->codegen->invalid_instruction;
	24952	return ira->codegen->invalid_inst_gen;
24053	24953
24054		IrInstruction *value = instruction->value->child;
	24954	IrInstGen *value = instruction->value->child;
24055	24955	if (type_is_invalid(value->value->type))
24056		return ira->codegen->invalid_instruction;
	24956	return ira->codegen->invalid_inst_gen;
24057	24957
24058	24958	Buf *define_value = nullptr;
24059	24959	// The second parameter is either a string or void (equivalent to "")
24060	24960	if (value->value->type->id != ZigTypeIdVoid) {
24061	24961	define_value = ir_resolve_str(ira, value);
24062	24962	if (!define_value)
24063		return ira->codegen->invalid_instruction;
	24963	return ira->codegen->invalid_inst_gen;
24064	24964	}
24065	24965
24066		Buf *c_import_buf = exec_c_import_buf(ira->new_irb.exec);
	24966	Buf *c_import_buf = ira->new_irb.exec->c_import_buf;
24067	24967	// We check for this error in pass1
24068	24968	assert(c_import_buf);
24069	24969
24070	24970	buf_appendf(c_import_buf, "#define %s %s\n", buf_ptr(define_name),
24071	24971	define_value ? buf_ptr(define_value) : "");
24072	24972
24073		return ir_const_void(ira, &instruction->base);
	24973	return ir_const_void(ira, &instruction->base.base);
24074	24974	}
24075	24975
24076		static IrInstruction ir_analyze_instruction_c_undef(IrAnalyze ira, IrInstructionCUndef *instruction) {
24077		IrInstruction *name = instruction->name->child;
	24976	static IrInstGen ir_analyze_instruction_c_undef(IrAnalyze ira, IrInstSrcCUndef *instruction) {
	24977	IrInstGen *name = instruction->name->child;
24078	24978	if (type_is_invalid(name->value->type))
24079		return ira->codegen->invalid_instruction;
	24979	return ira->codegen->invalid_inst_gen;
24080	24980
24081	24981	Buf *undef_name = ir_resolve_str(ira, name);
24082	24982	if (!undef_name)
24083		return ira->codegen->invalid_instruction;
	24983	return ira->codegen->invalid_inst_gen;
24084	24984
24085		Buf *c_import_buf = exec_c_import_buf(ira->new_irb.exec);
	24985	Buf *c_import_buf = ira->new_irb.exec->c_import_buf;
24086	24986	// We check for this error in pass1
24087	24987	assert(c_import_buf);
24088	24988
24089	24989	buf_appendf(c_import_buf, "#undef %s\n", buf_ptr(undef_name));
24090	24990
24091		return ir_const_void(ira, &instruction->base);
	24991	return ir_const_void(ira, &instruction->base.base);
24092	24992	}
24093	24993
24094		static IrInstruction ir_analyze_instruction_embed_file(IrAnalyze ira, IrInstructionEmbedFile *instruction) {
24095		IrInstruction *name = instruction->name->child;
	24994	static IrInstGen ir_analyze_instruction_embed_file(IrAnalyze ira, IrInstSrcEmbedFile *instruction) {
	24995	IrInstGen *name = instruction->name->child;
24096	24996	if (type_is_invalid(name->value->type))
24097		return ira->codegen->invalid_instruction;
	24997	return ira->codegen->invalid_inst_gen;
24098	24998
24099	24999	Buf *rel_file_path = ir_resolve_str(ira, name);
24100	25000	if (!rel_file_path)
24101		return ira->codegen->invalid_instruction;
	25001	return ira->codegen->invalid_inst_gen;
24102	25002
24103		ZigType *import = get_scope_import(instruction->base.scope);
	25003	ZigType *import = get_scope_import(instruction->base.base.scope);
24104	25004	// figure out absolute path to resource
24105	25005	Buf source_dir_path = BUF_INIT;
24106	25006	os_path_dirname(import->data.structure.root_struct->path, &source_dir_path);
...	...	@@ -24117,93 +25017,95 @@ static IrInstruction ir_analyze_instruction_embed_file(IrAnalyze ira, IrInstru
24117	25017	Error err;
24118	25018	if ((err = file_fetch(ira->codegen, file_path, file_contents))) {
24119	25019	if (err == ErrorFileNotFound) {
24120		ir_add_error(ira, instruction->name, buf_sprintf("unable to find '%s'", buf_ptr(file_path)));
24121		return ira->codegen->invalid_instruction;
	25020	ir_add_error(ira, &instruction->name->base,
	25021	buf_sprintf("unable to find '%s'", buf_ptr(file_path)));
	25022	return ira->codegen->invalid_inst_gen;
24122	25023	} else {
24123		ir_add_error(ira, instruction->name, buf_sprintf("unable to open '%s': %s", buf_ptr(file_path), err_str(err)));
24124		return ira->codegen->invalid_instruction;
	25024	ir_add_error(ira, &instruction->name->base,
	25025	buf_sprintf("unable to open '%s': %s", buf_ptr(file_path), err_str(err)));
	25026	return ira->codegen->invalid_inst_gen;
24125	25027	}
24126	25028	}
24127	25029
24128	25030	ZigType *result_type = get_array_type(ira->codegen,
24129	25031	ira->codegen->builtin_types.entry_u8, buf_len(file_contents), nullptr);
24130		IrInstruction *result = ir_const(ira, &instruction->base, result_type);
	25032	IrInstGen *result = ir_const(ira, &instruction->base.base, result_type);
24131	25033	init_const_str_lit(ira->codegen, result->value, file_contents);
24132	25034	return result;
24133	25035	}
24134	25036
24135		static IrInstruction ir_analyze_instruction_cmpxchg(IrAnalyze ira, IrInstructionCmpxchgSrc *instruction) {
	25037	static IrInstGen ir_analyze_instruction_cmpxchg(IrAnalyze ira, IrInstSrcCmpxchg *instruction) {
24136	25038	ZigType *operand_type = ir_resolve_atomic_operand_type(ira, instruction->type_value->child);
24137	25039	if (type_is_invalid(operand_type))
24138		return ira->codegen->invalid_instruction;
	25040	return ira->codegen->invalid_inst_gen;
24139	25041
24140	25042	if (operand_type->id == ZigTypeIdFloat) {
24141		ir_add_error(ira, instruction->type_value->child,
	25043	ir_add_error(ira, &instruction->type_value->child->base,
24142	25044	buf_sprintf("expected integer, enum or pointer type, found '%s'", buf_ptr(&operand_type->name)));
24143		return ira->codegen->invalid_instruction;
	25045	return ira->codegen->invalid_inst_gen;
24144	25046	}
24145	25047
24146		IrInstruction *ptr = instruction->ptr->child;
	25048	IrInstGen *ptr = instruction->ptr->child;
24147	25049	if (type_is_invalid(ptr->value->type))
24148		return ira->codegen->invalid_instruction;
	25050	return ira->codegen->invalid_inst_gen;
24149	25051
24150	25052	// TODO let this be volatile
24151	25053	ZigType *ptr_type = get_pointer_to_type(ira->codegen, operand_type, false);
24152		IrInstruction *casted_ptr = ir_implicit_cast(ira, ptr, ptr_type);
	25054	IrInstGen *casted_ptr = ir_implicit_cast(ira, ptr, ptr_type);
24153	25055	if (type_is_invalid(casted_ptr->value->type))
24154		return ira->codegen->invalid_instruction;
	25056	return ira->codegen->invalid_inst_gen;
24155	25057
24156		IrInstruction *cmp_value = instruction->cmp_value->child;
	25058	IrInstGen *cmp_value = instruction->cmp_value->child;
24157	25059	if (type_is_invalid(cmp_value->value->type))
24158		return ira->codegen->invalid_instruction;
	25060	return ira->codegen->invalid_inst_gen;
24159	25061
24160		IrInstruction *new_value = instruction->new_value->child;
	25062	IrInstGen *new_value = instruction->new_value->child;
24161	25063	if (type_is_invalid(new_value->value->type))
24162		return ira->codegen->invalid_instruction;
	25064	return ira->codegen->invalid_inst_gen;
24163	25065
24164		IrInstruction *success_order_value = instruction->success_order_value->child;
	25066	IrInstGen *success_order_value = instruction->success_order_value->child;
24165	25067	if (type_is_invalid(success_order_value->value->type))
24166		return ira->codegen->invalid_instruction;
	25068	return ira->codegen->invalid_inst_gen;
24167	25069
24168	25070	AtomicOrder success_order;
24169	25071	if (!ir_resolve_atomic_order(ira, success_order_value, &success_order))
24170		return ira->codegen->invalid_instruction;
	25072	return ira->codegen->invalid_inst_gen;
24171	25073
24172		IrInstruction *failure_order_value = instruction->failure_order_value->child;
	25074	IrInstGen *failure_order_value = instruction->failure_order_value->child;
24173	25075	if (type_is_invalid(failure_order_value->value->type))
24174		return ira->codegen->invalid_instruction;
	25076	return ira->codegen->invalid_inst_gen;
24175	25077
24176	25078	AtomicOrder failure_order;
24177	25079	if (!ir_resolve_atomic_order(ira, failure_order_value, &failure_order))
24178		return ira->codegen->invalid_instruction;
	25080	return ira->codegen->invalid_inst_gen;
24179	25081
24180		IrInstruction *casted_cmp_value = ir_implicit_cast(ira, cmp_value, operand_type);
	25082	IrInstGen *casted_cmp_value = ir_implicit_cast(ira, cmp_value, operand_type);
24181	25083	if (type_is_invalid(casted_cmp_value->value->type))
24182		return ira->codegen->invalid_instruction;
	25084	return ira->codegen->invalid_inst_gen;
24183	25085
24184		IrInstruction *casted_new_value = ir_implicit_cast(ira, new_value, operand_type);
	25086	IrInstGen *casted_new_value = ir_implicit_cast(ira, new_value, operand_type);
24185	25087	if (type_is_invalid(casted_new_value->value->type))
24186		return ira->codegen->invalid_instruction;
	25088	return ira->codegen->invalid_inst_gen;
24187	25089
24188	25090	if (success_order < AtomicOrderMonotonic) {
24189		ir_add_error(ira, success_order_value,
	25091	ir_add_error(ira, &success_order_value->base,
24190	25092	buf_sprintf("success atomic ordering must be Monotonic or stricter"));
24191		return ira->codegen->invalid_instruction;
	25093	return ira->codegen->invalid_inst_gen;
24192	25094	}
24193	25095	if (failure_order < AtomicOrderMonotonic) {
24194		ir_add_error(ira, failure_order_value,
	25096	ir_add_error(ira, &failure_order_value->base,
24195	25097	buf_sprintf("failure atomic ordering must be Monotonic or stricter"));
24196		return ira->codegen->invalid_instruction;
	25098	return ira->codegen->invalid_inst_gen;
24197	25099	}
24198	25100	if (failure_order > success_order) {
24199		ir_add_error(ira, failure_order_value,
	25101	ir_add_error(ira, &failure_order_value->base,
24200	25102	buf_sprintf("failure atomic ordering must be no stricter than success"));
24201		return ira->codegen->invalid_instruction;
	25103	return ira->codegen->invalid_inst_gen;
24202	25104	}
24203	25105	if (failure_order == AtomicOrderRelease \|\| failure_order == AtomicOrderAcqRel) {
24204		ir_add_error(ira, failure_order_value,
	25106	ir_add_error(ira, &failure_order_value->base,
24205	25107	buf_sprintf("failure atomic ordering must not be Release or AcqRel"));
24206		return ira->codegen->invalid_instruction;
	25108	return ira->codegen->invalid_inst_gen;
24207	25109	}
24208	25110
24209	25111	if (instr_is_comptime(casted_ptr) && casted_ptr->value->data.x_ptr.mut != ConstPtrMutRuntimeVar &&
...	...	@@ -24212,66 +25114,63 @@ static IrInstruction ir_analyze_instruction_cmpxchg(IrAnalyze ira, IrInstructi
24212	25114	}
24213	25115
24214	25116	ZigType *result_type = get_optional_type(ira->codegen, operand_type);
24215		IrInstruction *result_loc;
	25117	IrInstGen *result_loc;
24216	25118	if (handle_is_ptr(result_type)) {
24217		result_loc = ir_resolve_result(ira, &instruction->base, instruction->result_loc,
	25119	result_loc = ir_resolve_result(ira, &instruction->base.base, instruction->result_loc,
24218	25120	result_type, nullptr, true, false, true);
24219		if (type_is_invalid(result_loc->value->type) \|\| instr_is_unreachable(result_loc)) {
	25121	if (type_is_invalid(result_loc->value->type) \|\| result_loc->value->type->id == ZigTypeIdUnreachable) {
24220	25122	return result_loc;
24221	25123	}
24222	25124	} else {
24223	25125	result_loc = nullptr;
24224	25126	}
24225	25127
24226		return ir_build_cmpxchg_gen(ira, &instruction->base, result_type,
	25128	return ir_build_cmpxchg_gen(ira, &instruction->base.base, result_type,
24227	25129	casted_ptr, casted_cmp_value, casted_new_value,
24228	25130	success_order, failure_order, instruction->is_weak, result_loc);
24229	25131	}
24230	25132
24231		static IrInstruction ir_analyze_instruction_fence(IrAnalyze ira, IrInstructionFence *instruction) {
24232		IrInstruction *order_value = instruction->order_value->child;
24233		if (type_is_invalid(order_value->value->type))
24234		return ira->codegen->invalid_instruction;
	25133	static IrInstGen ir_analyze_instruction_fence(IrAnalyze ira, IrInstSrcFence *instruction) {
	25134	IrInstGen *order_inst = instruction->order->child;
	25135	if (type_is_invalid(order_inst->value->type))
	25136	return ira->codegen->invalid_inst_gen;
24235	25137
24236	25138	AtomicOrder order;
24237		if (!ir_resolve_atomic_order(ira, order_value, &order))
24238		return ira->codegen->invalid_instruction;
	25139	if (!ir_resolve_atomic_order(ira, order_inst, &order))
	25140	return ira->codegen->invalid_inst_gen;
24239	25141
24240	25142	if (order < AtomicOrderAcquire) {
24241		ir_add_error(ira, order_value,
	25143	ir_add_error(ira, &order_inst->base,
24242	25144	buf_sprintf("atomic ordering must be Acquire or stricter"));
24243		return ira->codegen->invalid_instruction;
	25145	return ira->codegen->invalid_inst_gen;
24244	25146	}
24245	25147
24246		IrInstruction *result = ir_build_fence(&ira->new_irb,
24247		instruction->base.scope, instruction->base.source_node, order_value, order);
24248		result->value->type = ira->codegen->builtin_types.entry_void;
24249		return result;
	25148	return ir_build_fence_gen(ira, &instruction->base.base, order);
24250	25149	}
24251	25150
24252		static IrInstruction ir_analyze_instruction_truncate(IrAnalyze ira, IrInstructionTruncate *instruction) {
24253		IrInstruction *dest_type_value = instruction->dest_type->child;
	25151	static IrInstGen ir_analyze_instruction_truncate(IrAnalyze ira, IrInstSrcTruncate *instruction) {
	25152	IrInstGen *dest_type_value = instruction->dest_type->child;
24254	25153	ZigType *dest_type = ir_resolve_type(ira, dest_type_value);
24255	25154	if (type_is_invalid(dest_type))
24256		return ira->codegen->invalid_instruction;
	25155	return ira->codegen->invalid_inst_gen;
24257	25156
24258	25157	if (dest_type->id != ZigTypeIdInt &&
24259	25158	dest_type->id != ZigTypeIdComptimeInt)
24260	25159	{
24261		ir_add_error(ira, dest_type_value, buf_sprintf("expected integer type, found '%s'", buf_ptr(&dest_type->name)));
24262		return ira->codegen->invalid_instruction;
	25160	ir_add_error(ira, &dest_type_value->base, buf_sprintf("expected integer type, found '%s'", buf_ptr(&dest_type->name)));
	25161	return ira->codegen->invalid_inst_gen;
24263	25162	}
24264	25163
24265		IrInstruction *target = instruction->target->child;
	25164	IrInstGen *target = instruction->target->child;
24266	25165	ZigType *src_type = target->value->type;
24267	25166	if (type_is_invalid(src_type))
24268		return ira->codegen->invalid_instruction;
	25167	return ira->codegen->invalid_inst_gen;
24269	25168
24270	25169	if (src_type->id != ZigTypeIdInt &&
24271	25170	src_type->id != ZigTypeIdComptimeInt)
24272	25171	{
24273		ir_add_error(ira, target, buf_sprintf("expected integer type, found '%s'", buf_ptr(&src_type->name)));
24274		return ira->codegen->invalid_instruction;
	25172	ir_add_error(ira, &target->base, buf_sprintf("expected integer type, found '%s'", buf_ptr(&src_type->name)));
	25173	return ira->codegen->invalid_inst_gen;
24275	25174	}
24276	25175
24277	25176	if (dest_type->id == ZigTypeIdComptimeInt) {
...	...	@@ -24281,54 +25180,51 @@ static IrInstruction ir_analyze_instruction_truncate(IrAnalyze ira, IrInstruct
24281	25180	if (instr_is_comptime(target)) {
24282	25181	ZigValue *val = ir_resolve_const(ira, target, UndefBad);
24283	25182	if (val == nullptr)
24284		return ira->codegen->invalid_instruction;
	25183	return ira->codegen->invalid_inst_gen;
24285	25184
24286		IrInstruction *result = ir_const(ira, &instruction->base, dest_type);
	25185	IrInstGen *result = ir_const(ira, &instruction->base.base, dest_type);
24287	25186	bigint_truncate(&result->value->data.x_bigint, &val->data.x_bigint,
24288	25187	dest_type->data.integral.bit_count, dest_type->data.integral.is_signed);
24289	25188	return result;
24290	25189	}
24291	25190
24292	25191	if (src_type->data.integral.bit_count == 0 \|\| dest_type->data.integral.bit_count == 0) {
24293		IrInstruction *result = ir_const(ira, &instruction->base, dest_type);
	25192	IrInstGen *result = ir_const(ira, &instruction->base.base, dest_type);
24294	25193	bigint_init_unsigned(&result->value->data.x_bigint, 0);
24295	25194	return result;
24296	25195	}
24297	25196
24298	25197	if (src_type->data.integral.is_signed != dest_type->data.integral.is_signed) {
24299	25198	const char *sign_str = dest_type->data.integral.is_signed ? "signed" : "unsigned";
24300		ir_add_error(ira, target, buf_sprintf("expected %s integer type, found '%s'", sign_str, buf_ptr(&src_type->name)));
24301		return ira->codegen->invalid_instruction;
	25199	ir_add_error(ira, &target->base, buf_sprintf("expected %s integer type, found '%s'", sign_str, buf_ptr(&src_type->name)));
	25200	return ira->codegen->invalid_inst_gen;
24302	25201	} else if (src_type->data.integral.bit_count < dest_type->data.integral.bit_count) {
24303		ir_add_error(ira, target, buf_sprintf("type '%s' has fewer bits than destination type '%s'",
	25202	ir_add_error(ira, &target->base, buf_sprintf("type '%s' has fewer bits than destination type '%s'",
24304	25203	buf_ptr(&src_type->name), buf_ptr(&dest_type->name)));
24305		return ira->codegen->invalid_instruction;
	25204	return ira->codegen->invalid_inst_gen;
24306	25205	}
24307	25206
24308		IrInstruction *new_instruction = ir_build_truncate(&ira->new_irb, instruction->base.scope,
24309		instruction->base.source_node, dest_type_value, target);
24310		new_instruction->value->type = dest_type;
24311		return new_instruction;
	25207	return ir_build_truncate_gen(ira, &instruction->base.base, dest_type, target);
24312	25208	}
24313	25209
24314		static IrInstruction ir_analyze_instruction_int_cast(IrAnalyze ira, IrInstructionIntCast *instruction) {
	25210	static IrInstGen ir_analyze_instruction_int_cast(IrAnalyze ira, IrInstSrcIntCast *instruction) {
24315	25211	ZigType *dest_type = ir_resolve_type(ira, instruction->dest_type->child);
24316	25212	if (type_is_invalid(dest_type))
24317		return ira->codegen->invalid_instruction;
	25213	return ira->codegen->invalid_inst_gen;
24318	25214
24319	25215	if (dest_type->id != ZigTypeIdInt && dest_type->id != ZigTypeIdComptimeInt) {
24320		ir_add_error(ira, instruction->dest_type, buf_sprintf("expected integer type, found '%s'", buf_ptr(&dest_type->name)));
24321		return ira->codegen->invalid_instruction;
	25216	ir_add_error(ira, &instruction->dest_type->base, buf_sprintf("expected integer type, found '%s'", buf_ptr(&dest_type->name)));
	25217	return ira->codegen->invalid_inst_gen;
24322	25218	}
24323	25219
24324		IrInstruction *target = instruction->target->child;
	25220	IrInstGen *target = instruction->target->child;
24325	25221	if (type_is_invalid(target->value->type))
24326		return ira->codegen->invalid_instruction;
	25222	return ira->codegen->invalid_inst_gen;
24327	25223
24328	25224	if (target->value->type->id != ZigTypeIdInt && target->value->type->id != ZigTypeIdComptimeInt) {
24329		ir_add_error(ira, instruction->target, buf_sprintf("expected integer type, found '%s'",
	25225	ir_add_error(ira, &instruction->target->base, buf_sprintf("expected integer type, found '%s'",
24330	25226	buf_ptr(&target->value->type->name)));
24331		return ira->codegen->invalid_instruction;
	25227	return ira->codegen->invalid_inst_gen;
24332	25228	}
24333	25229
24334	25230	if (instr_is_comptime(target)) {
...	...	@@ -24336,28 +25232,28 @@ static IrInstruction ir_analyze_instruction_int_cast(IrAnalyze ira, IrInstruct
24336	25232	}
24337	25233
24338	25234	if (dest_type->id == ZigTypeIdComptimeInt) {
24339		ir_add_error(ira, instruction->target, buf_sprintf("attempt to cast runtime value to '%s'",
	25235	ir_add_error(ira, &instruction->target->base, buf_sprintf("attempt to cast runtime value to '%s'",
24340	25236	buf_ptr(&dest_type->name)));
24341		return ira->codegen->invalid_instruction;
	25237	return ira->codegen->invalid_inst_gen;
24342	25238	}
24343	25239
24344		return ir_analyze_widen_or_shorten(ira, &instruction->base, target, dest_type);
	25240	return ir_analyze_widen_or_shorten(ira, &instruction->base.base, target, dest_type);
24345	25241	}
24346	25242
24347		static IrInstruction ir_analyze_instruction_float_cast(IrAnalyze ira, IrInstructionFloatCast *instruction) {
	25243	static IrInstGen ir_analyze_instruction_float_cast(IrAnalyze ira, IrInstSrcFloatCast *instruction) {
24348	25244	ZigType *dest_type = ir_resolve_type(ira, instruction->dest_type->child);
24349	25245	if (type_is_invalid(dest_type))
24350		return ira->codegen->invalid_instruction;
	25246	return ira->codegen->invalid_inst_gen;
24351	25247
24352	25248	if (dest_type->id != ZigTypeIdFloat) {
24353		ir_add_error(ira, instruction->dest_type,
	25249	ir_add_error(ira, &instruction->dest_type->base,
24354	25250	buf_sprintf("expected float type, found '%s'", buf_ptr(&dest_type->name)));
24355		return ira->codegen->invalid_instruction;
	25251	return ira->codegen->invalid_inst_gen;
24356	25252	}
24357	25253
24358		IrInstruction *target = instruction->target->child;
	25254	IrInstGen *target = instruction->target->child;
24359	25255	if (type_is_invalid(target->value->type))
24360		return ira->codegen->invalid_instruction;
	25256	return ira->codegen->invalid_inst_gen;
24361	25257
24362	25258	if (target->value->type->id == ZigTypeIdComptimeInt \|\|
24363	25259	target->value->type->id == ZigTypeIdComptimeFloat)
...	...	@@ -24369,55 +25265,55 @@ static IrInstruction ir_analyze_instruction_float_cast(IrAnalyze ira, IrInstru
24369	25265	} else {
24370	25266	op = CastOpNumLitToConcrete;
24371	25267	}
24372		return ir_resolve_cast(ira, &instruction->base, target, dest_type, op);
	25268	return ir_resolve_cast(ira, &instruction->base.base, target, dest_type, op);
24373	25269	} else {
24374		return ira->codegen->invalid_instruction;
	25270	return ira->codegen->invalid_inst_gen;
24375	25271	}
24376	25272	}
24377	25273
24378	25274	if (target->value->type->id != ZigTypeIdFloat) {
24379		ir_add_error(ira, instruction->target, buf_sprintf("expected float type, found '%s'",
	25275	ir_add_error(ira, &instruction->target->base, buf_sprintf("expected float type, found '%s'",
24380	25276	buf_ptr(&target->value->type->name)));
24381		return ira->codegen->invalid_instruction;
	25277	return ira->codegen->invalid_inst_gen;
24382	25278	}
24383	25279
24384		return ir_analyze_widen_or_shorten(ira, &instruction->base, target, dest_type);
	25280	return ir_analyze_widen_or_shorten(ira, &instruction->base.base, target, dest_type);
24385	25281	}
24386	25282
24387		static IrInstruction ir_analyze_instruction_err_set_cast(IrAnalyze ira, IrInstructionErrSetCast *instruction) {
	25283	static IrInstGen ir_analyze_instruction_err_set_cast(IrAnalyze ira, IrInstSrcErrSetCast *instruction) {
24388	25284	ZigType *dest_type = ir_resolve_type(ira, instruction->dest_type->child);
24389	25285	if (type_is_invalid(dest_type))
24390		return ira->codegen->invalid_instruction;
	25286	return ira->codegen->invalid_inst_gen;
24391	25287
24392	25288	if (dest_type->id != ZigTypeIdErrorSet) {
24393		ir_add_error(ira, instruction->dest_type,
	25289	ir_add_error(ira, &instruction->dest_type->base,
24394	25290	buf_sprintf("expected error set type, found '%s'", buf_ptr(&dest_type->name)));
24395		return ira->codegen->invalid_instruction;
	25291	return ira->codegen->invalid_inst_gen;
24396	25292	}
24397	25293
24398		IrInstruction *target = instruction->target->child;
	25294	IrInstGen *target = instruction->target->child;
24399	25295	if (type_is_invalid(target->value->type))
24400		return ira->codegen->invalid_instruction;
	25296	return ira->codegen->invalid_inst_gen;
24401	25297
24402	25298	if (target->value->type->id != ZigTypeIdErrorSet) {
24403		ir_add_error(ira, instruction->target,
	25299	ir_add_error(ira, &instruction->target->base,
24404	25300	buf_sprintf("expected error set type, found '%s'", buf_ptr(&target->value->type->name)));
24405		return ira->codegen->invalid_instruction;
	25301	return ira->codegen->invalid_inst_gen;
24406	25302	}
24407	25303
24408		return ir_analyze_err_set_cast(ira, &instruction->base, target, dest_type);
	25304	return ir_analyze_err_set_cast(ira, &instruction->base.base, target, dest_type);
24409	25305	}
24410	25306
24411		static IrInstruction ir_analyze_instruction_from_bytes(IrAnalyze ira, IrInstructionFromBytes *instruction) {
	25307	static IrInstGen ir_analyze_instruction_from_bytes(IrAnalyze ira, IrInstSrcFromBytes *instruction) {
24412	25308	Error err;
24413	25309
24414	25310	ZigType *dest_child_type = ir_resolve_type(ira, instruction->dest_child_type->child);
24415	25311	if (type_is_invalid(dest_child_type))
24416		return ira->codegen->invalid_instruction;
	25312	return ira->codegen->invalid_inst_gen;
24417	25313
24418		IrInstruction *target = instruction->target->child;
	25314	IrInstGen *target = instruction->target->child;
24419	25315	if (type_is_invalid(target->value->type))
24420		return ira->codegen->invalid_instruction;
	25316	return ira->codegen->invalid_inst_gen;
24421	25317
24422	25318	bool src_ptr_const;
24423	25319	bool src_ptr_volatile;
...	...	@@ -24427,27 +25323,27 @@ static IrInstruction ir_analyze_instruction_from_bytes(IrAnalyze ira, IrInstru
24427	25323	src_ptr_volatile = target->value->type->data.pointer.is_volatile;
24428	25324
24429	25325	if ((err = resolve_ptr_align(ira, target->value->type, &src_ptr_align)))
24430		return ira->codegen->invalid_instruction;
	25326	return ira->codegen->invalid_inst_gen;
24431	25327	} else if (is_slice(target->value->type)) {
24432	25328	ZigType *src_ptr_type = target->value->type->data.structure.fields[slice_ptr_index]->type_entry;
24433	25329	src_ptr_const = src_ptr_type->data.pointer.is_const;
24434	25330	src_ptr_volatile = src_ptr_type->data.pointer.is_volatile;
24435	25331
24436	25332	if ((err = resolve_ptr_align(ira, src_ptr_type, &src_ptr_align)))
24437		return ira->codegen->invalid_instruction;
	25333	return ira->codegen->invalid_inst_gen;
24438	25334	} else {
24439	25335	src_ptr_const = true;
24440	25336	src_ptr_volatile = false;
24441	25337
24442	25338	if ((err = type_resolve(ira->codegen, target->value->type, ResolveStatusAlignmentKnown)))
24443		return ira->codegen->invalid_instruction;
	25339	return ira->codegen->invalid_inst_gen;
24444	25340
24445	25341	src_ptr_align = get_abi_alignment(ira->codegen, target->value->type);
24446	25342	}
24447	25343
24448	25344	if (src_ptr_align != 0) {
24449	25345	if ((err = type_resolve(ira->codegen, dest_child_type, ResolveStatusAlignmentKnown)))
24450		return ira->codegen->invalid_instruction;
	25346	return ira->codegen->invalid_inst_gen;
24451	25347	}
24452	25348
24453	25349	ZigType *dest_ptr_type = get_pointer_to_type_extra(ira->codegen, dest_child_type,
...	...	@@ -24460,9 +25356,9 @@ static IrInstruction ir_analyze_instruction_from_bytes(IrAnalyze ira, IrInstru
24460	25356	src_ptr_align, 0, 0, false);
24461	25357	ZigType *u8_slice = get_slice_type(ira->codegen, u8_ptr);
24462	25358
24463		IrInstruction *casted_value = ir_implicit_cast(ira, target, u8_slice);
	25359	IrInstGen *casted_value = ir_implicit_cast(ira, target, u8_slice);
24464	25360	if (type_is_invalid(casted_value->value->type))
24465		return ira->codegen->invalid_instruction;
	25361	return ira->codegen->invalid_inst_gen;
24466	25362
24467	25363	bool have_known_len = false;
24468	25364	uint64_t known_len;
...	...	@@ -24470,7 +25366,7 @@ static IrInstruction ir_analyze_instruction_from_bytes(IrAnalyze ira, IrInstru
24470	25366	if (instr_is_comptime(casted_value)) {
24471	25367	ZigValue *val = ir_resolve_const(ira, casted_value, UndefBad);
24472	25368	if (!val)
24473		return ira->codegen->invalid_instruction;
	25369	return ira->codegen->invalid_inst_gen;
24474	25370
24475	25371	ZigValue *len_val = val->data.x_struct.fields[slice_len_index];
24476	25372	if (value_is_comptime(len_val)) {
...	...	@@ -24479,9 +25375,9 @@ static IrInstruction ir_analyze_instruction_from_bytes(IrAnalyze ira, IrInstru
24479	25375	}
24480	25376	}
24481	25377
24482		IrInstruction *result_loc = ir_resolve_result(ira, &instruction->base, instruction->result_loc,
	25378	IrInstGen *result_loc = ir_resolve_result(ira, &instruction->base.base, instruction->result_loc,
24483	25379	dest_slice_type, nullptr, true, false, true);
24484		if (result_loc != nullptr && (type_is_invalid(result_loc->value->type) \|\| instr_is_unreachable(result_loc))) {
	25380	if (result_loc != nullptr && (type_is_invalid(result_loc->value->type) \|\| result_loc->value->type->id == ZigTypeIdUnreachable)) {
24485	25381	return result_loc;
24486	25382	}
24487	25383
...	...	@@ -24498,41 +25394,41 @@ static IrInstruction ir_analyze_instruction_from_bytes(IrAnalyze ira, IrInstru
24498	25394
24499	25395	if (have_known_len) {
24500	25396	if ((err = type_resolve(ira->codegen, dest_child_type, ResolveStatusSizeKnown)))
24501		return ira->codegen->invalid_instruction;
	25397	return ira->codegen->invalid_inst_gen;
24502	25398	uint64_t child_type_size = type_size(ira->codegen, dest_child_type);
24503	25399	uint64_t remainder = known_len % child_type_size;
24504	25400	if (remainder != 0) {
24505		ErrorMsg *msg = ir_add_error(ira, &instruction->base,
	25401	ErrorMsg *msg = ir_add_error(ira, &instruction->base.base,
24506	25402	buf_sprintf("unable to convert [%" ZIG_PRI_u64 "]u8 to %s: size mismatch",
24507	25403	known_len, buf_ptr(&dest_slice_type->name)));
24508		add_error_note(ira->codegen, msg, instruction->dest_child_type->source_node,
	25404	add_error_note(ira->codegen, msg, instruction->dest_child_type->base.source_node,
24509	25405	buf_sprintf("%s has size %" ZIG_PRI_u64 "; remaining bytes: %" ZIG_PRI_u64,
24510	25406	buf_ptr(&dest_child_type->name), child_type_size, remainder));
24511		return ira->codegen->invalid_instruction;
	25407	return ira->codegen->invalid_inst_gen;
24512	25408	}
24513	25409	}
24514	25410
24515		return ir_build_resize_slice(ira, &instruction->base, casted_value, dest_slice_type, result_loc);
	25411	return ir_build_resize_slice(ira, &instruction->base.base, casted_value, dest_slice_type, result_loc);
24516	25412	}
24517	25413
24518		static IrInstruction ir_analyze_instruction_to_bytes(IrAnalyze ira, IrInstructionToBytes *instruction) {
	25414	static IrInstGen ir_analyze_instruction_to_bytes(IrAnalyze ira, IrInstSrcToBytes *instruction) {
24519	25415	Error err;
24520	25416
24521		IrInstruction *target = instruction->target->child;
	25417	IrInstGen *target = instruction->target->child;
24522	25418	if (type_is_invalid(target->value->type))
24523		return ira->codegen->invalid_instruction;
	25419	return ira->codegen->invalid_inst_gen;
24524	25420
24525	25421	if (!is_slice(target->value->type)) {
24526		ir_add_error(ira, instruction->target,
	25422	ir_add_error(ira, &instruction->target->base,
24527	25423	buf_sprintf("expected slice, found '%s'", buf_ptr(&target->value->type->name)));
24528		return ira->codegen->invalid_instruction;
	25424	return ira->codegen->invalid_inst_gen;
24529	25425	}
24530	25426
24531	25427	ZigType *src_ptr_type = target->value->type->data.structure.fields[slice_ptr_index]->type_entry;
24532	25428
24533	25429	uint32_t alignment;
24534	25430	if ((err = resolve_ptr_align(ira, src_ptr_type, &alignment)))
24535		return ira->codegen->invalid_instruction;
	25431	return ira->codegen->invalid_inst_gen;
24536	25432
24537	25433	ZigType *dest_ptr_type = get_pointer_to_type_extra(ira->codegen, ira->codegen->builtin_types.entry_u8,
24538	25434	src_ptr_type->data.pointer.is_const, src_ptr_type->data.pointer.is_volatile, PtrLenUnknown,
...	...	@@ -24542,9 +25438,9 @@ static IrInstruction ir_analyze_instruction_to_bytes(IrAnalyze ira, IrInstruct
24542	25438	if (instr_is_comptime(target)) {
24543	25439	ZigValue *target_val = ir_resolve_const(ira, target, UndefBad);
24544	25440	if (target_val == nullptr)
24545		return ira->codegen->invalid_instruction;
	25441	return ira->codegen->invalid_inst_gen;
24546	25442
24547		IrInstruction *result = ir_const(ira, &instruction->base, dest_slice_type);
	25443	IrInstGen *result = ir_const(ira, &instruction->base.base, dest_slice_type);
24548	25444	result->value->data.x_struct.fields = alloc_const_vals_ptrs(2);
24549	25445
24550	25446	ZigValue *ptr_val = result->value->data.x_struct.fields[slice_ptr_index];
...	...	@@ -24564,13 +25460,13 @@ static IrInstruction ir_analyze_instruction_to_bytes(IrAnalyze ira, IrInstruct
24564	25460	return result;
24565	25461	}
24566	25462
24567		IrInstruction *result_loc = ir_resolve_result(ira, &instruction->base, instruction->result_loc,
	25463	IrInstGen *result_loc = ir_resolve_result(ira, &instruction->base.base, instruction->result_loc,
24568	25464	dest_slice_type, nullptr, true, false, true);
24569		if (type_is_invalid(result_loc->value->type) \|\| instr_is_unreachable(result_loc)) {
	25465	if (type_is_invalid(result_loc->value->type) \|\| result_loc->value->type->id == ZigTypeIdUnreachable) {
24570	25466	return result_loc;
24571	25467	}
24572	25468
24573		return ir_build_resize_slice(ira, &instruction->base, target, dest_slice_type, result_loc);
	25469	return ir_build_resize_slice(ira, &instruction->base.base, target, dest_slice_type, result_loc);
24574	25470	}
24575	25471
24576	25472	static Error resolve_ptr_align(IrAnalyze ira, ZigType ty, uint32_t *result_align) {
...	...	@@ -24587,26 +25483,26 @@ static Error resolve_ptr_align(IrAnalyze ira, ZigType ty, uint32_t *result_ali
24587	25483	return ErrorNone;
24588	25484	}
24589	25485
24590		static IrInstruction ir_analyze_instruction_int_to_float(IrAnalyze ira, IrInstructionIntToFloat *instruction) {
	25486	static IrInstGen ir_analyze_instruction_int_to_float(IrAnalyze ira, IrInstSrcIntToFloat *instruction) {
24591	25487	ZigType *dest_type = ir_resolve_type(ira, instruction->dest_type->child);
24592	25488	if (type_is_invalid(dest_type))
24593		return ira->codegen->invalid_instruction;
	25489	return ira->codegen->invalid_inst_gen;
24594	25490
24595		IrInstruction *target = instruction->target->child;
	25491	IrInstGen *target = instruction->target->child;
24596	25492	if (type_is_invalid(target->value->type))
24597		return ira->codegen->invalid_instruction;
	25493	return ira->codegen->invalid_inst_gen;
24598	25494
24599	25495	if (target->value->type->id != ZigTypeIdInt && target->value->type->id != ZigTypeIdComptimeInt) {
24600		ir_add_error(ira, instruction->target, buf_sprintf("expected int type, found '%s'",
	25496	ir_add_error(ira, &instruction->target->base, buf_sprintf("expected int type, found '%s'",
24601	25497	buf_ptr(&target->value->type->name)));
24602		return ira->codegen->invalid_instruction;
	25498	return ira->codegen->invalid_inst_gen;
24603	25499	}
24604	25500
24605		return ir_resolve_cast(ira, &instruction->base, target, dest_type, CastOpIntToFloat);
	25501	return ir_resolve_cast(ira, &instruction->base.base, target, dest_type, CastOpIntToFloat);
24606	25502	}
24607	25503
24608		static IrInstruction ir_analyze_float_to_int(IrAnalyze ira, IrInstruction *source_instr,
24609		ZigType dest_type, IrInstruction operand, AstNode *operand_source_node)
	25504	static IrInstGen ir_analyze_float_to_int(IrAnalyze ira, IrInst* source_instr,
	25505	ZigType dest_type, IrInstGen operand, AstNode *operand_source_node)
24610	25506	{
24611	25507	if (operand->value->type->id == ZigTypeIdComptimeInt) {
24612	25508	return ir_implicit_cast(ira, operand, dest_type);
...	...	@@ -24615,106 +25511,107 @@ static IrInstruction ir_analyze_float_to_int(IrAnalyze ira, IrInstruction *sou
24615	25511	if (operand->value->type->id != ZigTypeIdFloat && operand->value->type->id != ZigTypeIdComptimeFloat) {
24616	25512	ir_add_error_node(ira, operand_source_node, buf_sprintf("expected float type, found '%s'",
24617	25513	buf_ptr(&operand->value->type->name)));
24618		return ira->codegen->invalid_instruction;
	25514	return ira->codegen->invalid_inst_gen;
24619	25515	}
24620	25516
24621	25517	return ir_resolve_cast(ira, source_instr, operand, dest_type, CastOpFloatToInt);
24622	25518	}
24623	25519
24624		static IrInstruction ir_analyze_instruction_float_to_int(IrAnalyze ira, IrInstructionFloatToInt *instruction) {
	25520	static IrInstGen ir_analyze_instruction_float_to_int(IrAnalyze ira, IrInstSrcFloatToInt *instruction) {
24625	25521	ZigType *dest_type = ir_resolve_type(ira, instruction->dest_type->child);
24626	25522	if (type_is_invalid(dest_type))
24627		return ira->codegen->invalid_instruction;
	25523	return ira->codegen->invalid_inst_gen;
24628	25524
24629		IrInstruction *operand = instruction->target->child;
	25525	IrInstGen *operand = instruction->target->child;
24630	25526	if (type_is_invalid(operand->value->type))
24631		return ira->codegen->invalid_instruction;
	25527	return ira->codegen->invalid_inst_gen;
24632	25528
24633		return ir_analyze_float_to_int(ira, &instruction->base, dest_type, operand, instruction->target->source_node);
	25529	return ir_analyze_float_to_int(ira, &instruction->base.base, dest_type, operand,
	25530	instruction->target->base.source_node);
24634	25531	}
24635	25532
24636		static IrInstruction ir_analyze_instruction_err_to_int(IrAnalyze ira, IrInstructionErrToInt *instruction) {
24637		IrInstruction *target = instruction->target->child;
	25533	static IrInstGen ir_analyze_instruction_err_to_int(IrAnalyze ira, IrInstSrcErrToInt *instruction) {
	25534	IrInstGen *target = instruction->target->child;
24638	25535	if (type_is_invalid(target->value->type))
24639		return ira->codegen->invalid_instruction;
	25536	return ira->codegen->invalid_inst_gen;
24640	25537
24641		IrInstruction *casted_target;
	25538	IrInstGen *casted_target;
24642	25539	if (target->value->type->id == ZigTypeIdErrorSet) {
24643	25540	casted_target = target;
24644	25541	} else {
24645	25542	casted_target = ir_implicit_cast(ira, target, ira->codegen->builtin_types.entry_global_error_set);
24646	25543	if (type_is_invalid(casted_target->value->type))
24647		return ira->codegen->invalid_instruction;
	25544	return ira->codegen->invalid_inst_gen;
24648	25545	}
24649	25546
24650		return ir_analyze_err_to_int(ira, &instruction->base, casted_target, ira->codegen->err_tag_type);
	25547	return ir_analyze_err_to_int(ira, &instruction->base.base, casted_target, ira->codegen->err_tag_type);
24651	25548	}
24652	25549
24653		static IrInstruction ir_analyze_instruction_int_to_err(IrAnalyze ira, IrInstructionIntToErr *instruction) {
24654		IrInstruction *target = instruction->target->child;
	25550	static IrInstGen ir_analyze_instruction_int_to_err(IrAnalyze ira, IrInstSrcIntToErr *instruction) {
	25551	IrInstGen *target = instruction->target->child;
24655	25552	if (type_is_invalid(target->value->type))
24656		return ira->codegen->invalid_instruction;
	25553	return ira->codegen->invalid_inst_gen;
24657	25554
24658		IrInstruction *casted_target = ir_implicit_cast(ira, target, ira->codegen->err_tag_type);
	25555	IrInstGen *casted_target = ir_implicit_cast(ira, target, ira->codegen->err_tag_type);
24659	25556	if (type_is_invalid(casted_target->value->type))
24660		return ira->codegen->invalid_instruction;
	25557	return ira->codegen->invalid_inst_gen;
24661	25558
24662		return ir_analyze_int_to_err(ira, &instruction->base, casted_target, ira->codegen->builtin_types.entry_global_error_set);
	25559	return ir_analyze_int_to_err(ira, &instruction->base.base, casted_target, ira->codegen->builtin_types.entry_global_error_set);
24663	25560	}
24664	25561
24665		static IrInstruction ir_analyze_instruction_bool_to_int(IrAnalyze ira, IrInstructionBoolToInt *instruction) {
24666		IrInstruction *target = instruction->target->child;
	25562	static IrInstGen ir_analyze_instruction_bool_to_int(IrAnalyze ira, IrInstSrcBoolToInt *instruction) {
	25563	IrInstGen *target = instruction->target->child;
24667	25564	if (type_is_invalid(target->value->type))
24668		return ira->codegen->invalid_instruction;
	25565	return ira->codegen->invalid_inst_gen;
24669	25566
24670	25567	if (target->value->type->id != ZigTypeIdBool) {
24671		ir_add_error(ira, instruction->target, buf_sprintf("expected bool, found '%s'",
	25568	ir_add_error(ira, &instruction->target->base, buf_sprintf("expected bool, found '%s'",
24672	25569	buf_ptr(&target->value->type->name)));
24673		return ira->codegen->invalid_instruction;
	25570	return ira->codegen->invalid_inst_gen;
24674	25571	}
24675	25572
24676	25573	if (instr_is_comptime(target)) {
24677	25574	bool is_true;
24678	25575	if (!ir_resolve_bool(ira, target, &is_true))
24679		return ira->codegen->invalid_instruction;
	25576	return ira->codegen->invalid_inst_gen;
24680	25577
24681		return ir_const_unsigned(ira, &instruction->base, is_true ? 1 : 0);
	25578	return ir_const_unsigned(ira, &instruction->base.base, is_true ? 1 : 0);
24682	25579	}
24683	25580
24684	25581	ZigType *u1_type = get_int_type(ira->codegen, false, 1);
24685		return ir_resolve_cast(ira, &instruction->base, target, u1_type, CastOpBoolToInt);
	25582	return ir_resolve_cast(ira, &instruction->base.base, target, u1_type, CastOpBoolToInt);
24686	25583	}
24687	25584
24688		static IrInstruction ir_analyze_instruction_int_type(IrAnalyze ira, IrInstructionIntType *instruction) {
24689		IrInstruction *is_signed_value = instruction->is_signed->child;
	25585	static IrInstGen ir_analyze_instruction_int_type(IrAnalyze ira, IrInstSrcIntType *instruction) {
	25586	IrInstGen *is_signed_value = instruction->is_signed->child;
24690	25587	bool is_signed;
24691	25588	if (!ir_resolve_bool(ira, is_signed_value, &is_signed))
24692		return ira->codegen->invalid_instruction;
	25589	return ira->codegen->invalid_inst_gen;
24693	25590
24694		IrInstruction *bit_count_value = instruction->bit_count->child;
	25591	IrInstGen *bit_count_value = instruction->bit_count->child;
24695	25592	uint64_t bit_count;
24696	25593	if (!ir_resolve_unsigned(ira, bit_count_value, ira->codegen->builtin_types.entry_u16, &bit_count))
24697		return ira->codegen->invalid_instruction;
	25594	return ira->codegen->invalid_inst_gen;
24698	25595
24699		return ir_const_type(ira, &instruction->base, get_int_type(ira->codegen, is_signed, (uint32_t)bit_count));
	25596	return ir_const_type(ira, &instruction->base.base, get_int_type(ira->codegen, is_signed, (uint32_t)bit_count));
24700	25597	}
24701	25598
24702		static IrInstruction ir_analyze_instruction_vector_type(IrAnalyze ira, IrInstructionVectorType *instruction) {
	25599	static IrInstGen ir_analyze_instruction_vector_type(IrAnalyze ira, IrInstSrcVectorType *instruction) {
24703	25600	uint64_t len;
24704	25601	if (!ir_resolve_unsigned(ira, instruction->len->child, ira->codegen->builtin_types.entry_u32, &len))
24705		return ira->codegen->invalid_instruction;
	25602	return ira->codegen->invalid_inst_gen;
24706	25603
24707	25604	ZigType *elem_type = ir_resolve_vector_elem_type(ira, instruction->elem_type->child);
24708	25605	if (type_is_invalid(elem_type))
24709		return ira->codegen->invalid_instruction;
	25606	return ira->codegen->invalid_inst_gen;
24710	25607
24711	25608	ZigType *vector_type = get_vector_type(ira->codegen, len, elem_type);
24712	25609
24713		return ir_const_type(ira, &instruction->base, vector_type);
	25610	return ir_const_type(ira, &instruction->base.base, vector_type);
24714	25611	}
24715	25612
24716		static IrInstruction ir_analyze_shuffle_vector(IrAnalyze ira, IrInstruction *source_instr,
24717		ZigType scalar_type, IrInstruction a, IrInstruction b, IrInstruction mask)
	25613	static IrInstGen ir_analyze_shuffle_vector(IrAnalyze ira, IrInst* source_instr,
	25614	ZigType scalar_type, IrInstGen a, IrInstGen b, IrInstGen mask)
24718	25615	{
24719	25616	ir_assert(source_instr && scalar_type && a && b && mask, source_instr);
24720	25617	ir_assert(is_valid_vector_elem_type(scalar_type), source_instr);
...	...	@@ -24725,15 +25622,15 @@ static IrInstruction ir_analyze_shuffle_vector(IrAnalyze ira, IrInstruction *s
24725	25622	} else if (mask->value->type->id == ZigTypeIdArray) {
24726	25623	len_mask = mask->value->type->data.array.len;
24727	25624	} else {
24728		ir_add_error(ira, mask,
	25625	ir_add_error(ira, &mask->base,
24729	25626	buf_sprintf("expected vector or array, found '%s'",
24730	25627	buf_ptr(&mask->value->type->name)));
24731		return ira->codegen->invalid_instruction;
	25628	return ira->codegen->invalid_inst_gen;
24732	25629	}
24733	25630	mask = ir_implicit_cast(ira, mask, get_vector_type(ira->codegen, len_mask,
24734	25631	ira->codegen->builtin_types.entry_i32));
24735	25632	if (type_is_invalid(mask->value->type))
24736		return ira->codegen->invalid_instruction;
	25633	return ira->codegen->invalid_inst_gen;
24737	25634
24738	25635	uint32_t len_a;
24739	25636	if (a->value->type->id == ZigTypeIdVector) {
...	...	@@ -24743,11 +25640,11 @@ static IrInstruction ir_analyze_shuffle_vector(IrAnalyze ira, IrInstruction *s
24743	25640	} else if (a->value->type->id == ZigTypeIdUndefined) {
24744	25641	len_a = UINT32_MAX;
24745	25642	} else {
24746		ir_add_error(ira, a,
	25643	ir_add_error(ira, &a->base,
24747	25644	buf_sprintf("expected vector or array with element type '%s', found '%s'",
24748	25645	buf_ptr(&scalar_type->name),
24749	25646	buf_ptr(&a->value->type->name)));
24750		return ira->codegen->invalid_instruction;
	25647	return ira->codegen->invalid_inst_gen;
24751	25648	}
24752	25649
24753	25650	uint32_t len_b;
...	...	@@ -24758,38 +25655,38 @@ static IrInstruction ir_analyze_shuffle_vector(IrAnalyze ira, IrInstruction *s
24758	25655	} else if (b->value->type->id == ZigTypeIdUndefined) {
24759	25656	len_b = UINT32_MAX;
24760	25657	} else {
24761		ir_add_error(ira, b,
	25658	ir_add_error(ira, &b->base,
24762	25659	buf_sprintf("expected vector or array with element type '%s', found '%s'",
24763	25660	buf_ptr(&scalar_type->name),
24764	25661	buf_ptr(&b->value->type->name)));
24765		return ira->codegen->invalid_instruction;
	25662	return ira->codegen->invalid_inst_gen;
24766	25663	}
24767	25664
24768	25665	if (len_a == UINT32_MAX && len_b == UINT32_MAX) {
24769		return ir_const_undef(ira, a, get_vector_type(ira->codegen, len_mask, scalar_type));
	25666	return ir_const_undef(ira, &a->base, get_vector_type(ira->codegen, len_mask, scalar_type));
24770	25667	}
24771	25668
24772	25669	if (len_a == UINT32_MAX) {
24773	25670	len_a = len_b;
24774		a = ir_const_undef(ira, a, get_vector_type(ira->codegen, len_a, scalar_type));
	25671	a = ir_const_undef(ira, &a->base, get_vector_type(ira->codegen, len_a, scalar_type));
24775	25672	} else {
24776	25673	a = ir_implicit_cast(ira, a, get_vector_type(ira->codegen, len_a, scalar_type));
24777	25674	if (type_is_invalid(a->value->type))
24778		return ira->codegen->invalid_instruction;
	25675	return ira->codegen->invalid_inst_gen;
24779	25676	}
24780	25677
24781	25678	if (len_b == UINT32_MAX) {
24782	25679	len_b = len_a;
24783		b = ir_const_undef(ira, b, get_vector_type(ira->codegen, len_b, scalar_type));
	25680	b = ir_const_undef(ira, &b->base, get_vector_type(ira->codegen, len_b, scalar_type));
24784	25681	} else {
24785	25682	b = ir_implicit_cast(ira, b, get_vector_type(ira->codegen, len_b, scalar_type));
24786	25683	if (type_is_invalid(b->value->type))
24787		return ira->codegen->invalid_instruction;
	25684	return ira->codegen->invalid_inst_gen;
24788	25685	}
24789	25686
24790	25687	ZigValue *mask_val = ir_resolve_const(ira, mask, UndefOk);
24791	25688	if (mask_val == nullptr)
24792		return ira->codegen->invalid_instruction;
	25689	return ira->codegen->invalid_inst_gen;
24793	25690
24794	25691	expand_undef_array(ira->codegen, mask_val);
24795	25692
...	...	@@ -24799,7 +25696,7 @@ static IrInstruction ir_analyze_shuffle_vector(IrAnalyze ira, IrInstruction *s
24799	25696	continue;
24800	25697	int32_t v_i32 = bigint_as_signed(&mask_elem_val->data.x_bigint);
24801	25698	uint32_t v;
24802		IrInstruction *chosen_operand;
	25699	IrInstGen *chosen_operand;
24803	25700	if (v_i32 >= 0) {
24804	25701	v = (uint32_t)v_i32;
24805	25702	chosen_operand = a;
...	...	@@ -24808,16 +25705,16 @@ static IrInstruction ir_analyze_shuffle_vector(IrAnalyze ira, IrInstruction *s
24808	25705	chosen_operand = b;
24809	25706	}
24810	25707	if (v >= chosen_operand->value->type->data.vector.len) {
24811		ErrorMsg *msg = ir_add_error(ira, mask,
	25708	ErrorMsg *msg = ir_add_error(ira, &mask->base,
24812	25709	buf_sprintf("mask index '%u' has out-of-bounds selection", i));
24813		add_error_note(ira->codegen, msg, chosen_operand->source_node,
	25710	add_error_note(ira->codegen, msg, chosen_operand->base.source_node,
24814	25711	buf_sprintf("selected index '%u' out of bounds of %s", v,
24815	25712	buf_ptr(&chosen_operand->value->type->name)));
24816	25713	if (chosen_operand == a && v < len_a + len_b) {
24817		add_error_note(ira->codegen, msg, b->source_node,
	25714	add_error_note(ira->codegen, msg, b->base.source_node,
24818	25715	buf_create_from_str("selections from the second vector are specified with negative numbers"));
24819	25716	}
24820		return ira->codegen->invalid_instruction;
	25717	return ira->codegen->invalid_inst_gen;
24821	25718	}
24822	25719	}
24823	25720
...	...	@@ -24825,16 +25722,16 @@ static IrInstruction ir_analyze_shuffle_vector(IrAnalyze ira, IrInstruction *s
24825	25722	if (instr_is_comptime(a) && instr_is_comptime(b)) {
24826	25723	ZigValue *a_val = ir_resolve_const(ira, a, UndefOk);
24827	25724	if (a_val == nullptr)
24828		return ira->codegen->invalid_instruction;
	25725	return ira->codegen->invalid_inst_gen;
24829	25726
24830	25727	ZigValue *b_val = ir_resolve_const(ira, b, UndefOk);
24831	25728	if (b_val == nullptr)
24832		return ira->codegen->invalid_instruction;
	25729	return ira->codegen->invalid_inst_gen;
24833	25730
24834	25731	expand_undef_array(ira->codegen, a_val);
24835	25732	expand_undef_array(ira->codegen, b_val);
24836	25733
24837		IrInstruction *result = ir_const(ira, source_instr, result_type);
	25734	IrInstGen *result = ir_const(ira, source_instr, result_type);
24838	25735	result->value->data.x_array.data.s_none.elements = create_const_vals(len_mask);
24839	25736	for (uint32_t i = 0; i < mask_val->type->data.vector.len; i += 1) {
24840	25737	ZigValue *mask_elem_val = &mask_val->data.x_array.data.s_none.elements[i];
...	...	@@ -24866,7 +25763,7 @@ static IrInstruction ir_analyze_shuffle_vector(IrAnalyze ira, IrInstruction *s
24866	25763	uint32_t len_min = min(len_a, len_b);
24867	25764	uint32_t len_max = max(len_a, len_b);
24868	25765
24869		IrInstruction *expand_mask = ir_const(ira, mask,
	25766	IrInstGen *expand_mask = ir_const(ira, &mask->base,
24870	25767	get_vector_type(ira->codegen, len_max, ira->codegen->builtin_types.entry_i32));
24871	25768	expand_mask->value->data.x_array.data.s_none.elements = create_const_vals(len_max);
24872	25769	uint32_t i = 0;
...	...	@@ -24875,7 +25772,7 @@ static IrInstruction ir_analyze_shuffle_vector(IrAnalyze ira, IrInstruction *s
24875	25772	for (; i < len_max; i += 1)
24876	25773	bigint_init_signed(&expand_mask->value->data.x_array.data.s_none.elements[i].data.x_bigint, -1);
24877	25774
24878		IrInstruction *undef = ir_const_undef(ira, source_instr,
	25775	IrInstGen *undef = ir_const_undef(ira, source_instr,
24879	25776	get_vector_type(ira->codegen, len_min, scalar_type));
24880	25777
24881	25778	if (len_b < len_a) {
...	...	@@ -24885,62 +25782,59 @@ static IrInstruction ir_analyze_shuffle_vector(IrAnalyze ira, IrInstruction *s
24885	25782	}
24886	25783	}
24887	25784
24888		IrInstruction *result = ir_build_shuffle_vector(&ira->new_irb,
24889		source_instr->scope, source_instr->source_node,
24890		nullptr, a, b, mask);
24891		result->value->type = result_type;
24892		return result;
	25785	return ir_build_shuffle_vector_gen(ira, source_instr->scope, source_instr->source_node,
	25786	result_type, a, b, mask);
24893	25787	}
24894	25788
24895		static IrInstruction ir_analyze_instruction_shuffle_vector(IrAnalyze ira, IrInstructionShuffleVector *instruction) {
24896		ZigType *scalar_type = ir_resolve_vector_elem_type(ira, instruction->scalar_type);
	25789	static IrInstGen ir_analyze_instruction_shuffle_vector(IrAnalyze ira, IrInstSrcShuffleVector *instruction) {
	25790	ZigType *scalar_type = ir_resolve_vector_elem_type(ira, instruction->scalar_type->child);
24897	25791	if (type_is_invalid(scalar_type))
24898		return ira->codegen->invalid_instruction;
	25792	return ira->codegen->invalid_inst_gen;
24899	25793
24900		IrInstruction *a = instruction->a->child;
	25794	IrInstGen *a = instruction->a->child;
24901	25795	if (type_is_invalid(a->value->type))
24902		return ira->codegen->invalid_instruction;
	25796	return ira->codegen->invalid_inst_gen;
24903	25797
24904		IrInstruction *b = instruction->b->child;
	25798	IrInstGen *b = instruction->b->child;
24905	25799	if (type_is_invalid(b->value->type))
24906		return ira->codegen->invalid_instruction;
	25800	return ira->codegen->invalid_inst_gen;
24907	25801
24908		IrInstruction *mask = instruction->mask->child;
	25802	IrInstGen *mask = instruction->mask->child;
24909	25803	if (type_is_invalid(mask->value->type))
24910		return ira->codegen->invalid_instruction;
	25804	return ira->codegen->invalid_inst_gen;
24911	25805
24912		return ir_analyze_shuffle_vector(ira, &instruction->base, scalar_type, a, b, mask);
	25806	return ir_analyze_shuffle_vector(ira, &instruction->base.base, scalar_type, a, b, mask);
24913	25807	}
24914	25808
24915		static IrInstruction ir_analyze_instruction_splat(IrAnalyze ira, IrInstructionSplatSrc *instruction) {
	25809	static IrInstGen ir_analyze_instruction_splat(IrAnalyze ira, IrInstSrcSplat *instruction) {
24916	25810	Error err;
24917	25811
24918		IrInstruction *len = instruction->len->child;
	25812	IrInstGen *len = instruction->len->child;
24919	25813	if (type_is_invalid(len->value->type))
24920		return ira->codegen->invalid_instruction;
	25814	return ira->codegen->invalid_inst_gen;
24921	25815
24922		IrInstruction *scalar = instruction->scalar->child;
	25816	IrInstGen *scalar = instruction->scalar->child;
24923	25817	if (type_is_invalid(scalar->value->type))
24924		return ira->codegen->invalid_instruction;
	25818	return ira->codegen->invalid_inst_gen;
24925	25819
24926	25820	uint64_t len_u64;
24927	25821	if (!ir_resolve_unsigned(ira, len, ira->codegen->builtin_types.entry_u32, &len_u64))
24928		return ira->codegen->invalid_instruction;
	25822	return ira->codegen->invalid_inst_gen;
24929	25823	uint32_t len_int = len_u64;
24930	25824
24931		if ((err = ir_validate_vector_elem_type(ira, scalar, scalar->value->type)))
24932		return ira->codegen->invalid_instruction;
	25825	if ((err = ir_validate_vector_elem_type(ira, scalar->base.source_node, scalar->value->type)))
	25826	return ira->codegen->invalid_inst_gen;
24933	25827
24934	25828	ZigType *return_type = get_vector_type(ira->codegen, len_int, scalar->value->type);
24935	25829
24936	25830	if (instr_is_comptime(scalar)) {
24937	25831	ZigValue *scalar_val = ir_resolve_const(ira, scalar, UndefOk);
24938	25832	if (scalar_val == nullptr)
24939		return ira->codegen->invalid_instruction;
	25833	return ira->codegen->invalid_inst_gen;
24940	25834	if (scalar_val->special == ConstValSpecialUndef)
24941		return ir_const_undef(ira, &instruction->base, return_type);
	25835	return ir_const_undef(ira, &instruction->base.base, return_type);
24942	25836
24943		IrInstruction *result = ir_const(ira, &instruction->base, return_type);
	25837	IrInstGen *result = ir_const(ira, &instruction->base.base, return_type);
24944	25838	result->value->data.x_array.data.s_none.elements = create_const_vals(len_int);
24945	25839	for (uint32_t i = 0; i < len_int; i += 1) {
24946	25840	copy_const_val(&result->value->data.x_array.data.s_none.elements[i], scalar_val);
...	...	@@ -24948,48 +25842,45 @@ static IrInstruction ir_analyze_instruction_splat(IrAnalyze ira, IrInstruction
24948	25842	return result;
24949	25843	}
24950	25844
24951		return ir_build_splat_gen(ira, &instruction->base, return_type, scalar);
	25845	return ir_build_splat_gen(ira, &instruction->base.base, return_type, scalar);
24952	25846	}
24953	25847
24954		static IrInstruction ir_analyze_instruction_bool_not(IrAnalyze ira, IrInstructionBoolNot *instruction) {
24955		IrInstruction *value = instruction->value->child;
	25848	static IrInstGen ir_analyze_instruction_bool_not(IrAnalyze ira, IrInstSrcBoolNot *instruction) {
	25849	IrInstGen *value = instruction->value->child;
24956	25850	if (type_is_invalid(value->value->type))
24957		return ira->codegen->invalid_instruction;
	25851	return ira->codegen->invalid_inst_gen;
24958	25852
24959	25853	ZigType *bool_type = ira->codegen->builtin_types.entry_bool;
24960	25854
24961		IrInstruction *casted_value = ir_implicit_cast(ira, value, bool_type);
	25855	IrInstGen *casted_value = ir_implicit_cast(ira, value, bool_type);
24962	25856	if (type_is_invalid(casted_value->value->type))
24963		return ira->codegen->invalid_instruction;
	25857	return ira->codegen->invalid_inst_gen;
24964	25858
24965	25859	if (instr_is_comptime(casted_value)) {
24966	25860	ZigValue *value = ir_resolve_const(ira, casted_value, UndefBad);
24967	25861	if (value == nullptr)
24968		return ira->codegen->invalid_instruction;
	25862	return ira->codegen->invalid_inst_gen;
24969	25863
24970		return ir_const_bool(ira, &instruction->base, !value->data.x_bool);
	25864	return ir_const_bool(ira, &instruction->base.base, !value->data.x_bool);
24971	25865	}
24972	25866
24973		IrInstruction *result = ir_build_bool_not(&ira->new_irb, instruction->base.scope,
24974		instruction->base.source_node, casted_value);
24975		result->value->type = bool_type;
24976		return result;
	25867	return ir_build_bool_not_gen(ira, &instruction->base.base, casted_value);
24977	25868	}
24978	25869
24979		static IrInstruction ir_analyze_instruction_memset(IrAnalyze ira, IrInstructionMemset *instruction) {
	25870	static IrInstGen ir_analyze_instruction_memset(IrAnalyze ira, IrInstSrcMemset *instruction) {
24980	25871	Error err;
24981	25872
24982		IrInstruction *dest_ptr = instruction->dest_ptr->child;
	25873	IrInstGen *dest_ptr = instruction->dest_ptr->child;
24983	25874	if (type_is_invalid(dest_ptr->value->type))
24984		return ira->codegen->invalid_instruction;
	25875	return ira->codegen->invalid_inst_gen;
24985	25876
24986		IrInstruction *byte_value = instruction->byte->child;
	25877	IrInstGen *byte_value = instruction->byte->child;
24987	25878	if (type_is_invalid(byte_value->value->type))
24988		return ira->codegen->invalid_instruction;
	25879	return ira->codegen->invalid_inst_gen;
24989	25880
24990		IrInstruction *count_value = instruction->count->child;
	25881	IrInstGen *count_value = instruction->count->child;
24991	25882	if (type_is_invalid(count_value->value->type))
24992		return ira->codegen->invalid_instruction;
	25883	return ira->codegen->invalid_inst_gen;
24993	25884
24994	25885	ZigType *dest_uncasted_type = dest_ptr->value->type;
24995	25886	bool dest_is_volatile = (dest_uncasted_type->id == ZigTypeIdPointer) &&
...	...	@@ -25000,24 +25891,24 @@ static IrInstruction ir_analyze_instruction_memset(IrAnalyze ira, IrInstructio
25000	25891	uint32_t dest_align;
25001	25892	if (dest_uncasted_type->id == ZigTypeIdPointer) {
25002	25893	if ((err = resolve_ptr_align(ira, dest_uncasted_type, &dest_align)))
25003		return ira->codegen->invalid_instruction;
	25894	return ira->codegen->invalid_inst_gen;
25004	25895	} else {
25005	25896	dest_align = get_abi_alignment(ira->codegen, u8);
25006	25897	}
25007	25898	ZigType *u8_ptr = get_pointer_to_type_extra(ira->codegen, u8, false, dest_is_volatile,
25008	25899	PtrLenUnknown, dest_align, 0, 0, false);
25009	25900
25010		IrInstruction *casted_dest_ptr = ir_implicit_cast(ira, dest_ptr, u8_ptr);
	25901	IrInstGen *casted_dest_ptr = ir_implicit_cast(ira, dest_ptr, u8_ptr);
25011	25902	if (type_is_invalid(casted_dest_ptr->value->type))
25012		return ira->codegen->invalid_instruction;
	25903	return ira->codegen->invalid_inst_gen;
25013	25904
25014		IrInstruction *casted_byte = ir_implicit_cast(ira, byte_value, u8);
	25905	IrInstGen *casted_byte = ir_implicit_cast(ira, byte_value, u8);
25015	25906	if (type_is_invalid(casted_byte->value->type))
25016		return ira->codegen->invalid_instruction;
	25907	return ira->codegen->invalid_inst_gen;
25017	25908
25018		IrInstruction *casted_count = ir_implicit_cast(ira, count_value, usize);
	25909	IrInstGen *casted_count = ir_implicit_cast(ira, count_value, usize);
25019	25910	if (type_is_invalid(casted_count->value->type))
25020		return ira->codegen->invalid_instruction;
	25911	return ira->codegen->invalid_inst_gen;
25021	25912
25022	25913	// TODO test this at comptime with u8 and non-u8 types
25023	25914	if (instr_is_comptime(casted_dest_ptr) &&
...	...	@@ -25026,15 +25917,15 @@ static IrInstruction ir_analyze_instruction_memset(IrAnalyze ira, IrInstructio
25026	25917	{
25027	25918	ZigValue *dest_ptr_val = ir_resolve_const(ira, casted_dest_ptr, UndefBad);
25028	25919	if (dest_ptr_val == nullptr)
25029		return ira->codegen->invalid_instruction;
	25920	return ira->codegen->invalid_inst_gen;
25030	25921
25031	25922	ZigValue *byte_val = ir_resolve_const(ira, casted_byte, UndefOk);
25032	25923	if (byte_val == nullptr)
25033		return ira->codegen->invalid_instruction;
	25924	return ira->codegen->invalid_inst_gen;
25034	25925
25035	25926	ZigValue *count_val = ir_resolve_const(ira, casted_count, UndefBad);
25036	25927	if (count_val == nullptr)
25037		return ira->codegen->invalid_instruction;
	25928	return ira->codegen->invalid_inst_gen;
25038	25929
25039	25930	if (casted_dest_ptr->value->data.x_ptr.special != ConstPtrSpecialHardCodedAddr &&
25040	25931	casted_dest_ptr->value->data.x_ptr.mut != ConstPtrMutRuntimeVar)
...	...	@@ -25079,38 +25970,35 @@ static IrInstruction ir_analyze_instruction_memset(IrAnalyze ira, IrInstructio
25079	25970	size_t count = bigint_as_usize(&count_val->data.x_bigint);
25080	25971	size_t end = start + count;
25081	25972	if (end > bound_end) {
25082		ir_add_error(ira, count_value, buf_sprintf("out of bounds pointer access"));
25083		return ira->codegen->invalid_instruction;
	25973	ir_add_error(ira, &count_value->base, buf_sprintf("out of bounds pointer access"));
	25974	return ira->codegen->invalid_inst_gen;
25084	25975	}
25085	25976
25086	25977	for (size_t i = start; i < end; i += 1) {
25087	25978	copy_const_val(&dest_elements[i], byte_val);
25088	25979	}
25089	25980
25090		return ir_const_void(ira, &instruction->base);
	25981	return ir_const_void(ira, &instruction->base.base);
25091	25982	}
25092	25983	}
25093	25984
25094		IrInstruction *result = ir_build_memset(&ira->new_irb, instruction->base.scope, instruction->base.source_node,
25095		casted_dest_ptr, casted_byte, casted_count);
25096		result->value->type = ira->codegen->builtin_types.entry_void;
25097		return result;
	25985	return ir_build_memset_gen(ira, &instruction->base.base, casted_dest_ptr, casted_byte, casted_count);
25098	25986	}
25099	25987
25100		static IrInstruction ir_analyze_instruction_memcpy(IrAnalyze ira, IrInstructionMemcpy *instruction) {
	25988	static IrInstGen ir_analyze_instruction_memcpy(IrAnalyze ira, IrInstSrcMemcpy *instruction) {
25101	25989	Error err;
25102	25990
25103		IrInstruction *dest_ptr = instruction->dest_ptr->child;
	25991	IrInstGen *dest_ptr = instruction->dest_ptr->child;
25104	25992	if (type_is_invalid(dest_ptr->value->type))
25105		return ira->codegen->invalid_instruction;
	25993	return ira->codegen->invalid_inst_gen;
25106	25994
25107		IrInstruction *src_ptr = instruction->src_ptr->child;
	25995	IrInstGen *src_ptr = instruction->src_ptr->child;
25108	25996	if (type_is_invalid(src_ptr->value->type))
25109		return ira->codegen->invalid_instruction;
	25997	return ira->codegen->invalid_inst_gen;
25110	25998
25111		IrInstruction *count_value = instruction->count->child;
	25999	IrInstGen *count_value = instruction->count->child;
25112	26000	if (type_is_invalid(count_value->value->type))
25113		return ira->codegen->invalid_instruction;
	26001	return ira->codegen->invalid_inst_gen;
25114	26002
25115	26003	ZigType *u8 = ira->codegen->builtin_types.entry_u8;
25116	26004	ZigType *dest_uncasted_type = dest_ptr->value->type;
...	...	@@ -25123,7 +26011,7 @@ static IrInstruction ir_analyze_instruction_memcpy(IrAnalyze ira, IrInstructio
25123	26011	uint32_t dest_align;
25124	26012	if (dest_uncasted_type->id == ZigTypeIdPointer) {
25125	26013	if ((err = resolve_ptr_align(ira, dest_uncasted_type, &dest_align)))
25126		return ira->codegen->invalid_instruction;
	26014	return ira->codegen->invalid_inst_gen;
25127	26015	} else {
25128	26016	dest_align = get_abi_alignment(ira->codegen, u8);
25129	26017	}
...	...	@@ -25131,7 +26019,7 @@ static IrInstruction ir_analyze_instruction_memcpy(IrAnalyze ira, IrInstructio
25131	26019	uint32_t src_align;
25132	26020	if (src_uncasted_type->id == ZigTypeIdPointer) {
25133	26021	if ((err = resolve_ptr_align(ira, src_uncasted_type, &src_align)))
25134		return ira->codegen->invalid_instruction;
	26022	return ira->codegen->invalid_inst_gen;
25135	26023	} else {
25136	26024	src_align = get_abi_alignment(ira->codegen, u8);
25137	26025	}
...	...	@@ -25142,17 +26030,17 @@ static IrInstruction ir_analyze_instruction_memcpy(IrAnalyze ira, IrInstructio
25142	26030	ZigType *u8_ptr_const = get_pointer_to_type_extra(ira->codegen, u8, true, src_is_volatile,
25143	26031	PtrLenUnknown, src_align, 0, 0, false);
25144	26032
25145		IrInstruction *casted_dest_ptr = ir_implicit_cast(ira, dest_ptr, u8_ptr_mut);
	26033	IrInstGen *casted_dest_ptr = ir_implicit_cast(ira, dest_ptr, u8_ptr_mut);
25146	26034	if (type_is_invalid(casted_dest_ptr->value->type))
25147		return ira->codegen->invalid_instruction;
	26035	return ira->codegen->invalid_inst_gen;
25148	26036
25149		IrInstruction *casted_src_ptr = ir_implicit_cast(ira, src_ptr, u8_ptr_const);
	26037	IrInstGen *casted_src_ptr = ir_implicit_cast(ira, src_ptr, u8_ptr_const);
25150	26038	if (type_is_invalid(casted_src_ptr->value->type))
25151		return ira->codegen->invalid_instruction;
	26039	return ira->codegen->invalid_inst_gen;
25152	26040
25153		IrInstruction *casted_count = ir_implicit_cast(ira, count_value, usize);
	26041	IrInstGen *casted_count = ir_implicit_cast(ira, count_value, usize);
25154	26042	if (type_is_invalid(casted_count->value->type))
25155		return ira->codegen->invalid_instruction;
	26043	return ira->codegen->invalid_inst_gen;
25156	26044
25157	26045	// TODO test this at comptime with u8 and non-u8 types
25158	26046	// TODO test with dest ptr being a global runtime variable
...	...	@@ -25162,15 +26050,15 @@ static IrInstruction ir_analyze_instruction_memcpy(IrAnalyze ira, IrInstructio
25162	26050	{
25163	26051	ZigValue *dest_ptr_val = ir_resolve_const(ira, casted_dest_ptr, UndefBad);
25164	26052	if (dest_ptr_val == nullptr)
25165		return ira->codegen->invalid_instruction;
	26053	return ira->codegen->invalid_inst_gen;
25166	26054
25167	26055	ZigValue *src_ptr_val = ir_resolve_const(ira, casted_src_ptr, UndefBad);
25168	26056	if (src_ptr_val == nullptr)
25169		return ira->codegen->invalid_instruction;
	26057	return ira->codegen->invalid_inst_gen;
25170	26058
25171	26059	ZigValue *count_val = ir_resolve_const(ira, casted_count, UndefBad);
25172	26060	if (count_val == nullptr)
25173		return ira->codegen->invalid_instruction;
	26061	return ira->codegen->invalid_inst_gen;
25174	26062
25175	26063	if (dest_ptr_val->data.x_ptr.special != ConstPtrSpecialHardCodedAddr) {
25176	26064	size_t count = bigint_as_usize(&count_val->data.x_bigint);
...	...	@@ -25213,8 +26101,8 @@ static IrInstruction ir_analyze_instruction_memcpy(IrAnalyze ira, IrInstructio
25213	26101	}
25214	26102
25215	26103	if (dest_start + count > dest_end) {
25216		ir_add_error(ira, &instruction->base, buf_sprintf("out of bounds pointer access"));
25217		return ira->codegen->invalid_instruction;
	26104	ir_add_error(ira, &instruction->base.base, buf_sprintf("out of bounds pointer access"));
	26105	return ira->codegen->invalid_inst_gen;
25218	26106	}
25219	26107
25220	26108	ZigValue *src_elements;
...	...	@@ -25256,8 +26144,8 @@ static IrInstruction ir_analyze_instruction_memcpy(IrAnalyze ira, IrInstructio
25256	26144	}
25257	26145
25258	26146	if (src_start + count > src_end) {
25259		ir_add_error(ira, &instruction->base, buf_sprintf("out of bounds pointer access"));
25260		return ira->codegen->invalid_instruction;
	26147	ir_add_error(ira, &instruction->base.base, buf_sprintf("out of bounds pointer access"));
	26148	return ira->codegen->invalid_inst_gen;
25261	26149	}
25262	26150
25263	26151	// TODO check for noalias violations - this should be generalized to work for any function
...	...	@@ -25266,42 +26154,39 @@ static IrInstruction ir_analyze_instruction_memcpy(IrAnalyze ira, IrInstructio
25266	26154	copy_const_val(&dest_elements[dest_start + i], &src_elements[src_start + i]);
25267	26155	}
25268	26156
25269		return ir_const_void(ira, &instruction->base);
	26157	return ir_const_void(ira, &instruction->base.base);
25270	26158	}
25271	26159	}
25272	26160
25273		IrInstruction *result = ir_build_memcpy(&ira->new_irb, instruction->base.scope, instruction->base.source_node,
25274		casted_dest_ptr, casted_src_ptr, casted_count);
25275		result->value->type = ira->codegen->builtin_types.entry_void;
25276		return result;
	26161	return ir_build_memcpy_gen(ira, &instruction->base.base, casted_dest_ptr, casted_src_ptr, casted_count);
25277	26162	}
25278	26163
25279		static IrInstruction ir_analyze_instruction_slice(IrAnalyze ira, IrInstructionSliceSrc *instruction) {
25280		IrInstruction *ptr_ptr = instruction->ptr->child;
	26164	static IrInstGen ir_analyze_instruction_slice(IrAnalyze ira, IrInstSrcSlice *instruction) {
	26165	IrInstGen *ptr_ptr = instruction->ptr->child;
25281	26166	if (type_is_invalid(ptr_ptr->value->type))
25282		return ira->codegen->invalid_instruction;
	26167	return ira->codegen->invalid_inst_gen;
25283	26168
25284	26169	ZigType *ptr_ptr_type = ptr_ptr->value->type;
25285	26170	assert(ptr_ptr_type->id == ZigTypeIdPointer);
25286	26171	ZigType *array_type = ptr_ptr_type->data.pointer.child_type;
25287	26172
25288		IrInstruction *start = instruction->start->child;
	26173	IrInstGen *start = instruction->start->child;
25289	26174	if (type_is_invalid(start->value->type))
25290		return ira->codegen->invalid_instruction;
	26175	return ira->codegen->invalid_inst_gen;
25291	26176
25292	26177	ZigType *usize = ira->codegen->builtin_types.entry_usize;
25293		IrInstruction *casted_start = ir_implicit_cast(ira, start, usize);
	26178	IrInstGen *casted_start = ir_implicit_cast(ira, start, usize);
25294	26179	if (type_is_invalid(casted_start->value->type))
25295		return ira->codegen->invalid_instruction;
	26180	return ira->codegen->invalid_inst_gen;
25296	26181
25297		IrInstruction *end;
	26182	IrInstGen *end;
25298	26183	if (instruction->end) {
25299	26184	end = instruction->end->child;
25300	26185	if (type_is_invalid(end->value->type))
25301		return ira->codegen->invalid_instruction;
	26186	return ira->codegen->invalid_inst_gen;
25302	26187	end = ir_implicit_cast(ira, end, usize);
25303	26188	if (type_is_invalid(end->value->type))
25304		return ira->codegen->invalid_instruction;
	26189	return ira->codegen->invalid_inst_gen;
25305	26190	} else {
25306	26191	end = nullptr;
25307	26192	}
...	...	@@ -25329,8 +26214,8 @@ static IrInstruction ir_analyze_instruction_slice(IrAnalyze ira, IrInstruction
25329	26214	PtrLenUnknown,
25330	26215	array_type->data.pointer.explicit_alignment, 0, 0, false);
25331	26216	} else {
25332		ir_add_error(ira, &instruction->base, buf_sprintf("slice of single-item pointer"));
25333		return ira->codegen->invalid_instruction;
	26217	ir_add_error(ira, &instruction->base.base, buf_sprintf("slice of single-item pointer"));
	26218	return ira->codegen->invalid_inst_gen;
25334	26219	}
25335	26220	} else {
25336	26221	elem_type = array_type->data.pointer.child_type;
...	...	@@ -25340,8 +26225,8 @@ static IrInstruction ir_analyze_instruction_slice(IrAnalyze ira, IrInstruction
25340	26225	ZigType *maybe_sentineled_slice_ptr_type = array_type;
25341	26226	non_sentinel_slice_ptr_type = adjust_ptr_sentinel(ira->codegen, maybe_sentineled_slice_ptr_type, nullptr);
25342	26227	if (!end) {
25343		ir_add_error(ira, &instruction->base, buf_sprintf("slice of pointer must include end value"));
25344		return ira->codegen->invalid_instruction;
	26228	ir_add_error(ira, &instruction->base.base, buf_sprintf("slice of pointer must include end value"));
	26229	return ira->codegen->invalid_inst_gen;
25345	26230	}
25346	26231	}
25347	26232	} else if (is_slice(array_type)) {
...	...	@@ -25349,23 +26234,23 @@ static IrInstruction ir_analyze_instruction_slice(IrAnalyze ira, IrInstruction
25349	26234	non_sentinel_slice_ptr_type = adjust_ptr_sentinel(ira->codegen, maybe_sentineled_slice_ptr_type, nullptr);
25350	26235	elem_type = non_sentinel_slice_ptr_type->data.pointer.child_type;
25351	26236	} else {
25352		ir_add_error(ira, &instruction->base,
	26237	ir_add_error(ira, &instruction->base.base,
25353	26238	buf_sprintf("slice of non-array type '%s'", buf_ptr(&array_type->name)));
25354		return ira->codegen->invalid_instruction;
	26239	return ira->codegen->invalid_inst_gen;
25355	26240	}
25356	26241
25357	26242	ZigType *return_type;
25358	26243	ZigValue *sentinel_val = nullptr;
25359	26244	if (instruction->sentinel) {
25360		IrInstruction *uncasted_sentinel = instruction->sentinel->child;
	26245	IrInstGen *uncasted_sentinel = instruction->sentinel->child;
25361	26246	if (type_is_invalid(uncasted_sentinel->value->type))
25362		return ira->codegen->invalid_instruction;
25363		IrInstruction *sentinel = ir_implicit_cast(ira, uncasted_sentinel, elem_type);
	26247	return ira->codegen->invalid_inst_gen;
	26248	IrInstGen *sentinel = ir_implicit_cast(ira, uncasted_sentinel, elem_type);
25364	26249	if (type_is_invalid(sentinel->value->type))
25365		return ira->codegen->invalid_instruction;
	26250	return ira->codegen->invalid_inst_gen;
25366	26251	sentinel_val = ir_resolve_const(ira, sentinel, UndefBad);
25367	26252	if (sentinel_val == nullptr)
25368		return ira->codegen->invalid_instruction;
	26253	return ira->codegen->invalid_inst_gen;
25369	26254	ZigType *slice_ptr_type = adjust_ptr_sentinel(ira->codegen, non_sentinel_slice_ptr_type, sentinel_val);
25370	26255	return_type = get_slice_type(ira->codegen, slice_ptr_type);
25371	26256	} else {
...	...	@@ -25387,9 +26272,9 @@ static IrInstruction ir_analyze_instruction_slice(IrAnalyze ira, IrInstruction
25387	26272	if (array_type->id == ZigTypeIdPointer) {
25388	26273	ZigType *child_array_type = array_type->data.pointer.child_type;
25389	26274	assert(child_array_type->id == ZigTypeIdArray);
25390		parent_ptr = const_ptr_pointee(ira, ira->codegen, ptr_ptr->value, instruction->base.source_node);
	26275	parent_ptr = const_ptr_pointee(ira, ira->codegen, ptr_ptr->value, instruction->base.base.source_node);
25391	26276	if (parent_ptr == nullptr)
25392		return ira->codegen->invalid_instruction;
	26277	return ira->codegen->invalid_inst_gen;
25393	26278
25394	26279
25395	26280	if (parent_ptr->special == ConstValSpecialUndef) {
...	...	@@ -25398,26 +26283,26 @@ static IrInstruction ir_analyze_instruction_slice(IrAnalyze ira, IrInstruction
25398	26283	rel_end = SIZE_MAX;
25399	26284	ptr_is_undef = true;
25400	26285	} else {
25401		array_val = const_ptr_pointee(ira, ira->codegen, parent_ptr, instruction->base.source_node);
	26286	array_val = const_ptr_pointee(ira, ira->codegen, parent_ptr, instruction->base.base.source_node);
25402	26287	if (array_val == nullptr)
25403		return ira->codegen->invalid_instruction;
	26288	return ira->codegen->invalid_inst_gen;
25404	26289
25405	26290	rel_end = child_array_type->data.array.len;
25406	26291	abs_offset = 0;
25407	26292	}
25408	26293	} else {
25409		array_val = const_ptr_pointee(ira, ira->codegen, ptr_ptr->value, instruction->base.source_node);
	26294	array_val = const_ptr_pointee(ira, ira->codegen, ptr_ptr->value, instruction->base.base.source_node);
25410	26295	if (array_val == nullptr)
25411		return ira->codegen->invalid_instruction;
	26296	return ira->codegen->invalid_inst_gen;
25412	26297	rel_end = array_type->data.array.len;
25413	26298	parent_ptr = nullptr;
25414	26299	abs_offset = 0;
25415	26300	}
25416	26301	} else if (array_type->id == ZigTypeIdPointer) {
25417	26302	assert(array_type->data.pointer.ptr_len == PtrLenUnknown);
25418		parent_ptr = const_ptr_pointee(ira, ira->codegen, ptr_ptr->value, instruction->base.source_node);
	26303	parent_ptr = const_ptr_pointee(ira, ira->codegen, ptr_ptr->value, instruction->base.base.source_node);
25419	26304	if (parent_ptr == nullptr)
25420		return ira->codegen->invalid_instruction;
	26305	return ira->codegen->invalid_inst_gen;
25421	26306
25422	26307	if (parent_ptr->special == ConstValSpecialUndef) {
25423	26308	array_val = nullptr;
...	...	@@ -25463,19 +26348,19 @@ static IrInstruction ir_analyze_instruction_slice(IrAnalyze ira, IrInstruction
25463	26348	zig_panic("TODO slice of null ptr");
25464	26349	}
25465	26350	} else if (is_slice(array_type)) {
25466		ZigValue *slice_ptr = const_ptr_pointee(ira, ira->codegen, ptr_ptr->value, instruction->base.source_node);
	26351	ZigValue *slice_ptr = const_ptr_pointee(ira, ira->codegen, ptr_ptr->value, instruction->base.base.source_node);
25467	26352	if (slice_ptr == nullptr)
25468		return ira->codegen->invalid_instruction;
	26353	return ira->codegen->invalid_inst_gen;
25469	26354
25470	26355	if (slice_ptr->special == ConstValSpecialUndef) {
25471		ir_add_error(ira, &instruction->base, buf_sprintf("slice of undefined"));
25472		return ira->codegen->invalid_instruction;
	26356	ir_add_error(ira, &instruction->base.base, buf_sprintf("slice of undefined"));
	26357	return ira->codegen->invalid_inst_gen;
25473	26358	}
25474	26359
25475	26360	parent_ptr = slice_ptr->data.x_struct.fields[slice_ptr_index];
25476	26361	if (parent_ptr->special == ConstValSpecialUndef) {
25477		ir_add_error(ira, &instruction->base, buf_sprintf("slice of undefined"));
25478		return ira->codegen->invalid_instruction;
	26362	ir_add_error(ira, &instruction->base.base, buf_sprintf("slice of undefined"));
	26363	return ira->codegen->invalid_inst_gen;
25479	26364	}
25480	26365
25481	26366	ZigValue *len_val = slice_ptr->data.x_struct.fields[slice_len_index];
...	...	@@ -25518,37 +26403,37 @@ static IrInstruction ir_analyze_instruction_slice(IrAnalyze ira, IrInstruction
25518	26403
25519	26404	ZigValue *start_val = ir_resolve_const(ira, casted_start, UndefBad);
25520	26405	if (!start_val)
25521		return ira->codegen->invalid_instruction;
	26406	return ira->codegen->invalid_inst_gen;
25522	26407
25523	26408	uint64_t start_scalar = bigint_as_u64(&start_val->data.x_bigint);
25524	26409	if (!ptr_is_undef && start_scalar > rel_end) {
25525		ir_add_error(ira, &instruction->base, buf_sprintf("out of bounds slice"));
25526		return ira->codegen->invalid_instruction;
	26410	ir_add_error(ira, &instruction->base.base, buf_sprintf("out of bounds slice"));
	26411	return ira->codegen->invalid_inst_gen;
25527	26412	}
25528	26413
25529	26414	uint64_t end_scalar = rel_end;
25530	26415	if (end) {
25531	26416	ZigValue *end_val = ir_resolve_const(ira, end, UndefBad);
25532	26417	if (!end_val)
25533		return ira->codegen->invalid_instruction;
	26418	return ira->codegen->invalid_inst_gen;
25534	26419	end_scalar = bigint_as_u64(&end_val->data.x_bigint);
25535	26420	}
25536	26421	if (!ptr_is_undef) {
25537	26422	if (end_scalar > rel_end) {
25538		ir_add_error(ira, &instruction->base, buf_sprintf("out of bounds slice"));
25539		return ira->codegen->invalid_instruction;
	26423	ir_add_error(ira, &instruction->base.base, buf_sprintf("out of bounds slice"));
	26424	return ira->codegen->invalid_inst_gen;
25540	26425	}
25541	26426	if (start_scalar > end_scalar) {
25542		ir_add_error(ira, &instruction->base, buf_sprintf("slice start is greater than end"));
25543		return ira->codegen->invalid_instruction;
	26427	ir_add_error(ira, &instruction->base.base, buf_sprintf("slice start is greater than end"));
	26428	return ira->codegen->invalid_inst_gen;
25544	26429	}
25545	26430	}
25546	26431	if (ptr_is_undef && start_scalar != end_scalar) {
25547		ir_add_error(ira, &instruction->base, buf_sprintf("non-zero length slice of undefined pointer"));
25548		return ira->codegen->invalid_instruction;
	26432	ir_add_error(ira, &instruction->base.base, buf_sprintf("non-zero length slice of undefined pointer"));
	26433	return ira->codegen->invalid_inst_gen;
25549	26434	}
25550	26435
25551		IrInstruction *result = ir_const(ira, &instruction->base, return_type);
	26436	IrInstGen *result = ir_const(ira, &instruction->base.base, return_type);
25552	26437	ZigValue *out_val = result->value;
25553	26438	out_val->data.x_struct.fields = alloc_const_vals_ptrs(2);
25554	26439
...	...	@@ -25605,28 +26490,28 @@ static IrInstruction ir_analyze_instruction_slice(IrAnalyze ira, IrInstruction
25605	26490	return result;
25606	26491	}
25607	26492
25608		IrInstruction *result_loc = ir_resolve_result(ira, &instruction->base, instruction->result_loc,
	26493	IrInstGen *result_loc = ir_resolve_result(ira, &instruction->base.base, instruction->result_loc,
25609	26494	return_type, nullptr, true, false, true);
25610		if (type_is_invalid(result_loc->value->type) \|\| instr_is_unreachable(result_loc)) {
	26495	if (type_is_invalid(result_loc->value->type) \|\| result_loc->value->type->id == ZigTypeIdUnreachable) {
25611	26496	return result_loc;
25612	26497	}
25613		return ir_build_slice_gen(ira, &instruction->base, return_type,
	26498	return ir_build_slice_gen(ira, &instruction->base.base, return_type,
25614	26499	ptr_ptr, casted_start, end, instruction->safety_check_on, result_loc);
25615	26500	}
25616	26501
25617		static IrInstruction ir_analyze_instruction_member_count(IrAnalyze ira, IrInstructionMemberCount *instruction) {
	26502	static IrInstGen ir_analyze_instruction_member_count(IrAnalyze ira, IrInstSrcMemberCount *instruction) {
25618	26503	Error err;
25619		IrInstruction *container = instruction->container->child;
	26504	IrInstGen *container = instruction->container->child;
25620	26505	if (type_is_invalid(container->value->type))
25621		return ira->codegen->invalid_instruction;
	26506	return ira->codegen->invalid_inst_gen;
25622	26507	ZigType *container_type = ir_resolve_type(ira, container);
25623	26508
25624	26509	if ((err = type_resolve(ira->codegen, container_type, ResolveStatusSizeKnown)))
25625		return ira->codegen->invalid_instruction;
	26510	return ira->codegen->invalid_inst_gen;
25626	26511
25627	26512	uint64_t result;
25628	26513	if (type_is_invalid(container_type)) {
25629		return ira->codegen->invalid_instruction;
	26514	return ira->codegen->invalid_inst_gen;
25630	26515	} else if (container_type->id == ZigTypeIdEnum) {
25631	26516	result = container_type->data.enumeration.src_field_count;
25632	26517	} else if (container_type->id == ZigTypeIdStruct) {
...	...	@@ -25634,135 +26519,135 @@ static IrInstruction ir_analyze_instruction_member_count(IrAnalyze ira, IrInst
25634	26519	} else if (container_type->id == ZigTypeIdUnion) {
25635	26520	result = container_type->data.unionation.src_field_count;
25636	26521	} else if (container_type->id == ZigTypeIdErrorSet) {
25637		if (!resolve_inferred_error_set(ira->codegen, container_type, instruction->base.source_node)) {
25638		return ira->codegen->invalid_instruction;
	26522	if (!resolve_inferred_error_set(ira->codegen, container_type, instruction->base.base.source_node)) {
	26523	return ira->codegen->invalid_inst_gen;
25639	26524	}
25640	26525	if (type_is_global_error_set(container_type)) {
25641		ir_add_error(ira, &instruction->base, buf_sprintf("global error set member count not available at comptime"));
25642		return ira->codegen->invalid_instruction;
	26526	ir_add_error(ira, &instruction->base.base, buf_sprintf("global error set member count not available at comptime"));
	26527	return ira->codegen->invalid_inst_gen;
25643	26528	}
25644	26529	result = container_type->data.error_set.err_count;
25645	26530	} else {
25646		ir_add_error(ira, &instruction->base, buf_sprintf("no value count available for type '%s'", buf_ptr(&container_type->name)));
25647		return ira->codegen->invalid_instruction;
	26531	ir_add_error(ira, &instruction->base.base, buf_sprintf("no value count available for type '%s'", buf_ptr(&container_type->name)));
	26532	return ira->codegen->invalid_inst_gen;
25648	26533	}
25649	26534
25650		return ir_const_unsigned(ira, &instruction->base, result);
	26535	return ir_const_unsigned(ira, &instruction->base.base, result);
25651	26536	}
25652	26537
25653		static IrInstruction ir_analyze_instruction_member_type(IrAnalyze ira, IrInstructionMemberType *instruction) {
	26538	static IrInstGen ir_analyze_instruction_member_type(IrAnalyze ira, IrInstSrcMemberType *instruction) {
25654	26539	Error err;
25655		IrInstruction *container_type_value = instruction->container_type->child;
	26540	IrInstGen *container_type_value = instruction->container_type->child;
25656	26541	ZigType *container_type = ir_resolve_type(ira, container_type_value);
25657	26542	if (type_is_invalid(container_type))
25658		return ira->codegen->invalid_instruction;
	26543	return ira->codegen->invalid_inst_gen;
25659	26544
25660	26545	if ((err = type_resolve(ira->codegen, container_type, ResolveStatusSizeKnown)))
25661		return ira->codegen->invalid_instruction;
	26546	return ira->codegen->invalid_inst_gen;
25662	26547
25663	26548
25664	26549	uint64_t member_index;
25665		IrInstruction *index_value = instruction->member_index->child;
	26550	IrInstGen *index_value = instruction->member_index->child;
25666	26551	if (!ir_resolve_usize(ira, index_value, &member_index))
25667		return ira->codegen->invalid_instruction;
	26552	return ira->codegen->invalid_inst_gen;
25668	26553
25669	26554	if (container_type->id == ZigTypeIdStruct) {
25670	26555	if (member_index >= container_type->data.structure.src_field_count) {
25671		ir_add_error(ira, index_value,
	26556	ir_add_error(ira, &index_value->base,
25672	26557	buf_sprintf("member index %" ZIG_PRI_u64 " out of bounds; '%s' has %" PRIu32 " members",
25673	26558	member_index, buf_ptr(&container_type->name), container_type->data.structure.src_field_count));
25674		return ira->codegen->invalid_instruction;
	26559	return ira->codegen->invalid_inst_gen;
25675	26560	}
25676	26561	TypeStructField *field = container_type->data.structure.fields[member_index];
25677	26562
25678		return ir_const_type(ira, &instruction->base, field->type_entry);
	26563	return ir_const_type(ira, &instruction->base.base, field->type_entry);
25679	26564	} else if (container_type->id == ZigTypeIdUnion) {
25680	26565	if (member_index >= container_type->data.unionation.src_field_count) {
25681		ir_add_error(ira, index_value,
	26566	ir_add_error(ira, &index_value->base,
25682	26567	buf_sprintf("member index %" ZIG_PRI_u64 " out of bounds; '%s' has %" PRIu32 " members",
25683	26568	member_index, buf_ptr(&container_type->name), container_type->data.unionation.src_field_count));
25684		return ira->codegen->invalid_instruction;
	26569	return ira->codegen->invalid_inst_gen;
25685	26570	}
25686	26571	TypeUnionField *field = &container_type->data.unionation.fields[member_index];
25687	26572
25688		return ir_const_type(ira, &instruction->base, field->type_entry);
	26573	return ir_const_type(ira, &instruction->base.base, field->type_entry);
25689	26574	} else {
25690		ir_add_error(ira, container_type_value,
	26575	ir_add_error(ira, &container_type_value->base,
25691	26576	buf_sprintf("type '%s' does not support @memberType", buf_ptr(&container_type->name)));
25692		return ira->codegen->invalid_instruction;
	26577	return ira->codegen->invalid_inst_gen;
25693	26578	}
25694	26579	}
25695	26580
25696		static IrInstruction ir_analyze_instruction_member_name(IrAnalyze ira, IrInstructionMemberName *instruction) {
	26581	static IrInstGen ir_analyze_instruction_member_name(IrAnalyze ira, IrInstSrcMemberName *instruction) {
25697	26582	Error err;
25698		IrInstruction *container_type_value = instruction->container_type->child;
	26583	IrInstGen *container_type_value = instruction->container_type->child;
25699	26584	ZigType *container_type = ir_resolve_type(ira, container_type_value);
25700	26585	if (type_is_invalid(container_type))
25701		return ira->codegen->invalid_instruction;
	26586	return ira->codegen->invalid_inst_gen;
25702	26587
25703	26588	if ((err = type_resolve(ira->codegen, container_type, ResolveStatusSizeKnown)))
25704		return ira->codegen->invalid_instruction;
	26589	return ira->codegen->invalid_inst_gen;
25705	26590
25706	26591	uint64_t member_index;
25707		IrInstruction *index_value = instruction->member_index->child;
	26592	IrInstGen *index_value = instruction->member_index->child;
25708	26593	if (!ir_resolve_usize(ira, index_value, &member_index))
25709		return ira->codegen->invalid_instruction;
	26594	return ira->codegen->invalid_inst_gen;
25710	26595
25711	26596	if (container_type->id == ZigTypeIdStruct) {
25712	26597	if (member_index >= container_type->data.structure.src_field_count) {
25713		ir_add_error(ira, index_value,
	26598	ir_add_error(ira, &index_value->base,
25714	26599	buf_sprintf("member index %" ZIG_PRI_u64 " out of bounds; '%s' has %" PRIu32 " members",
25715	26600	member_index, buf_ptr(&container_type->name), container_type->data.structure.src_field_count));
25716		return ira->codegen->invalid_instruction;
	26601	return ira->codegen->invalid_inst_gen;
25717	26602	}
25718	26603	TypeStructField *field = container_type->data.structure.fields[member_index];
25719	26604
25720		IrInstruction *result = ir_const(ira, &instruction->base, nullptr);
	26605	IrInstGen *result = ir_const(ira, &instruction->base.base, nullptr);
25721	26606	init_const_str_lit(ira->codegen, result->value, field->name);
25722	26607	return result;
25723	26608	} else if (container_type->id == ZigTypeIdEnum) {
25724	26609	if (member_index >= container_type->data.enumeration.src_field_count) {
25725		ir_add_error(ira, index_value,
	26610	ir_add_error(ira, &index_value->base,
25726	26611	buf_sprintf("member index %" ZIG_PRI_u64 " out of bounds; '%s' has %" PRIu32 " members",
25727	26612	member_index, buf_ptr(&container_type->name), container_type->data.enumeration.src_field_count));
25728		return ira->codegen->invalid_instruction;
	26613	return ira->codegen->invalid_inst_gen;
25729	26614	}
25730	26615	TypeEnumField *field = &container_type->data.enumeration.fields[member_index];
25731	26616
25732		IrInstruction *result = ir_const(ira, &instruction->base, nullptr);
	26617	IrInstGen *result = ir_const(ira, &instruction->base.base, nullptr);
25733	26618	init_const_str_lit(ira->codegen, result->value, field->name);
25734	26619	return result;
25735	26620	} else if (container_type->id == ZigTypeIdUnion) {
25736	26621	if (member_index >= container_type->data.unionation.src_field_count) {
25737		ir_add_error(ira, index_value,
	26622	ir_add_error(ira, &index_value->base,
25738	26623	buf_sprintf("member index %" ZIG_PRI_u64 " out of bounds; '%s' has %" PRIu32 " members",
25739	26624	member_index, buf_ptr(&container_type->name), container_type->data.unionation.src_field_count));
25740		return ira->codegen->invalid_instruction;
	26625	return ira->codegen->invalid_inst_gen;
25741	26626	}
25742	26627	TypeUnionField *field = &container_type->data.unionation.fields[member_index];
25743	26628
25744		IrInstruction *result = ir_const(ira, &instruction->base, nullptr);
	26629	IrInstGen *result = ir_const(ira, &instruction->base.base, nullptr);
25745	26630	init_const_str_lit(ira->codegen, result->value, field->name);
25746	26631	return result;
25747	26632	} else {
25748		ir_add_error(ira, container_type_value,
	26633	ir_add_error(ira, &container_type_value->base,
25749	26634	buf_sprintf("type '%s' does not support @memberName", buf_ptr(&container_type->name)));
25750		return ira->codegen->invalid_instruction;
	26635	return ira->codegen->invalid_inst_gen;
25751	26636	}
25752	26637	}
25753	26638
25754		static IrInstruction ir_analyze_instruction_has_field(IrAnalyze ira, IrInstructionHasField *instruction) {
	26639	static IrInstGen ir_analyze_instruction_has_field(IrAnalyze ira, IrInstSrcHasField *instruction) {
25755	26640	Error err;
25756	26641	ZigType *container_type = ir_resolve_type(ira, instruction->container_type->child);
25757	26642	if (type_is_invalid(container_type))
25758		return ira->codegen->invalid_instruction;
	26643	return ira->codegen->invalid_inst_gen;
25759	26644
25760	26645	if ((err = type_resolve(ira->codegen, container_type, ResolveStatusZeroBitsKnown)))
25761		return ira->codegen->invalid_instruction;
	26646	return ira->codegen->invalid_inst_gen;
25762	26647
25763	26648	Buf *field_name = ir_resolve_str(ira, instruction->field_name->child);
25764	26649	if (field_name == nullptr)
25765		return ira->codegen->invalid_instruction;
	26650	return ira->codegen->invalid_inst_gen;
25766	26651
25767	26652	bool result;
25768	26653	if (container_type->id == ZigTypeIdStruct) {
...	...	@@ -25772,91 +26657,77 @@ static IrInstruction ir_analyze_instruction_has_field(IrAnalyze ira, IrInstruc
25772	26657	} else if (container_type->id == ZigTypeIdUnion) {
25773	26658	result = find_union_type_field(container_type, field_name) != nullptr;
25774	26659	} else {
25775		ir_add_error(ira, instruction->container_type,
	26660	ir_add_error(ira, &instruction->container_type->base,
25776	26661	buf_sprintf("type '%s' does not support @hasField", buf_ptr(&container_type->name)));
25777		return ira->codegen->invalid_instruction;
	26662	return ira->codegen->invalid_inst_gen;
25778	26663	}
25779		return ir_const_bool(ira, &instruction->base, result);
	26664	return ir_const_bool(ira, &instruction->base.base, result);
25780	26665	}
25781	26666
25782		static IrInstruction ir_analyze_instruction_breakpoint(IrAnalyze ira, IrInstructionBreakpoint *instruction) {
25783		IrInstruction *result = ir_build_breakpoint(&ira->new_irb,
25784		instruction->base.scope, instruction->base.source_node);
25785		result->value->type = ira->codegen->builtin_types.entry_void;
25786		return result;
	26667	static IrInstGen ir_analyze_instruction_breakpoint(IrAnalyze ira, IrInstSrcBreakpoint *instruction) {
	26668	return ir_build_breakpoint_gen(ira, &instruction->base.base);
25787	26669	}
25788	26670
25789		static IrInstruction ir_analyze_instruction_return_address(IrAnalyze ira, IrInstructionReturnAddress *instruction) {
25790		IrInstruction *result = ir_build_return_address(&ira->new_irb,
25791		instruction->base.scope, instruction->base.source_node);
25792		result->value->type = ira->codegen->builtin_types.entry_usize;
25793		return result;
	26671	static IrInstGen ir_analyze_instruction_return_address(IrAnalyze ira, IrInstSrcReturnAddress *instruction) {
	26672	return ir_build_return_address_gen(ira, &instruction->base.base);
25794	26673	}
25795	26674
25796		static IrInstruction ir_analyze_instruction_frame_address(IrAnalyze ira, IrInstructionFrameAddress *instruction) {
25797		IrInstruction *result = ir_build_frame_address(&ira->new_irb,
25798		instruction->base.scope, instruction->base.source_node);
25799		result->value->type = ira->codegen->builtin_types.entry_usize;
25800		return result;
	26675	static IrInstGen ir_analyze_instruction_frame_address(IrAnalyze ira, IrInstSrcFrameAddress *instruction) {
	26676	return ir_build_frame_address_gen(ira, &instruction->base.base);
25801	26677	}
25802	26678
25803		static IrInstruction ir_analyze_instruction_frame_handle(IrAnalyze ira, IrInstructionFrameHandle *instruction) {
25804		ZigFn *fn = exec_fn_entry(ira->new_irb.exec);
25805		ir_assert(fn != nullptr, &instruction->base);
	26679	static IrInstGen ir_analyze_instruction_frame_handle(IrAnalyze ira, IrInstSrcFrameHandle *instruction) {
	26680	ZigFn *fn = ira->new_irb.exec->fn_entry;
	26681	ir_assert(fn != nullptr, &instruction->base.base);
25806	26682
25807	26683	if (fn->inferred_async_node == nullptr) {
25808		fn->inferred_async_node = instruction->base.source_node;
	26684	fn->inferred_async_node = instruction->base.base.source_node;
25809	26685	}
25810	26686
25811	26687	ZigType *frame_type = get_fn_frame_type(ira->codegen, fn);
25812	26688	ZigType *ptr_frame_type = get_pointer_to_type(ira->codegen, frame_type, false);
25813	26689
25814		IrInstruction *result = ir_build_handle(&ira->new_irb, instruction->base.scope, instruction->base.source_node);
25815		result->value->type = ptr_frame_type;
25816		return result;
	26690	return ir_build_handle_gen(ira, &instruction->base.base, ptr_frame_type);
25817	26691	}
25818	26692
25819		static IrInstruction ir_analyze_instruction_frame_type(IrAnalyze ira, IrInstructionFrameType *instruction) {
	26693	static IrInstGen ir_analyze_instruction_frame_type(IrAnalyze ira, IrInstSrcFrameType *instruction) {
25820	26694	ZigFn *fn = ir_resolve_fn(ira, instruction->fn->child);
25821	26695	if (fn == nullptr)
25822		return ira->codegen->invalid_instruction;
	26696	return ira->codegen->invalid_inst_gen;
25823	26697
25824	26698	if (fn->type_entry->data.fn.is_generic) {
25825		ir_add_error(ira, &instruction->base,
	26699	ir_add_error(ira, &instruction->base.base,
25826	26700	buf_sprintf("@Frame() of generic function"));
25827		return ira->codegen->invalid_instruction;
	26701	return ira->codegen->invalid_inst_gen;
25828	26702	}
25829	26703
25830	26704	ZigType *ty = get_fn_frame_type(ira->codegen, fn);
25831		return ir_const_type(ira, &instruction->base, ty);
	26705	return ir_const_type(ira, &instruction->base.base, ty);
25832	26706	}
25833	26707
25834		static IrInstruction ir_analyze_instruction_frame_size(IrAnalyze ira, IrInstructionFrameSizeSrc *instruction) {
25835		IrInstruction *fn = instruction->fn->child;
	26708	static IrInstGen ir_analyze_instruction_frame_size(IrAnalyze ira, IrInstSrcFrameSize *instruction) {
	26709	IrInstGen *fn = instruction->fn->child;
25836	26710	if (type_is_invalid(fn->value->type))
25837		return ira->codegen->invalid_instruction;
	26711	return ira->codegen->invalid_inst_gen;
25838	26712
25839	26713	if (fn->value->type->id != ZigTypeIdFn) {
25840		ir_add_error(ira, fn,
	26714	ir_add_error(ira, &fn->base,
25841	26715	buf_sprintf("expected function, found '%s'", buf_ptr(&fn->value->type->name)));
25842		return ira->codegen->invalid_instruction;
	26716	return ira->codegen->invalid_inst_gen;
25843	26717	}
25844	26718
25845	26719	ira->codegen->need_frame_size_prefix_data = true;
25846	26720
25847		IrInstruction *result = ir_build_frame_size_gen(&ira->new_irb, instruction->base.scope,
25848		instruction->base.source_node, fn);
25849		result->value->type = ira->codegen->builtin_types.entry_usize;
25850		return result;
	26721	return ir_build_frame_size_gen(ira, &instruction->base.base, fn);
25851	26722	}
25852	26723
25853		static IrInstruction ir_analyze_instruction_align_of(IrAnalyze ira, IrInstructionAlignOf *instruction) {
	26724	static IrInstGen ir_analyze_instruction_align_of(IrAnalyze ira, IrInstSrcAlignOf *instruction) {
25854	26725	// Here we create a lazy value in order to avoid resolving the alignment of the type
25855	26726	// immediately. This avoids false positive dependency loops such as:
25856	26727	// const Node = struct {
25857	26728	// field: []align(@alignOf(Node)) Node,
25858	26729	// };
25859		IrInstruction *result = ir_const(ira, &instruction->base, ira->codegen->builtin_types.entry_num_lit_int);
	26730	IrInstGen *result = ir_const(ira, &instruction->base.base, ira->codegen->builtin_types.entry_num_lit_int);
25860	26731	result->value->special = ConstValSpecialLazy;
25861	26732
25862	26733	LazyValueAlignOf *lazy_align_of = allocate<LazyValueAlignOf>(1, "LazyValueAlignOf");
...	...	@@ -25866,41 +26737,41 @@ static IrInstruction ir_analyze_instruction_align_of(IrAnalyze ira, IrInstruct
25866	26737
25867	26738	lazy_align_of->target_type = instruction->type_value->child;
25868	26739	if (ir_resolve_type_lazy(ira, lazy_align_of->target_type) == nullptr)
25869		return ira->codegen->invalid_instruction;
	26740	return ira->codegen->invalid_inst_gen;
25870	26741
25871	26742	return result;
25872	26743	}
25873	26744
25874		static IrInstruction ir_analyze_instruction_overflow_op(IrAnalyze ira, IrInstructionOverflowOp *instruction) {
	26745	static IrInstGen ir_analyze_instruction_overflow_op(IrAnalyze ira, IrInstSrcOverflowOp *instruction) {
25875	26746	Error err;
25876	26747
25877		IrInstruction *type_value = instruction->type_value->child;
	26748	IrInstGen *type_value = instruction->type_value->child;
25878	26749	if (type_is_invalid(type_value->value->type))
25879		return ira->codegen->invalid_instruction;
	26750	return ira->codegen->invalid_inst_gen;
25880	26751
25881	26752	ZigType *dest_type = ir_resolve_type(ira, type_value);
25882	26753	if (type_is_invalid(dest_type))
25883		return ira->codegen->invalid_instruction;
	26754	return ira->codegen->invalid_inst_gen;
25884	26755
25885	26756	if (dest_type->id != ZigTypeIdInt) {
25886		ir_add_error(ira, type_value,
	26757	ir_add_error(ira, &type_value->base,
25887	26758	buf_sprintf("expected integer type, found '%s'", buf_ptr(&dest_type->name)));
25888		return ira->codegen->invalid_instruction;
	26759	return ira->codegen->invalid_inst_gen;
25889	26760	}
25890	26761
25891		IrInstruction *op1 = instruction->op1->child;
	26762	IrInstGen *op1 = instruction->op1->child;
25892	26763	if (type_is_invalid(op1->value->type))
25893		return ira->codegen->invalid_instruction;
	26764	return ira->codegen->invalid_inst_gen;
25894	26765
25895		IrInstruction *casted_op1 = ir_implicit_cast(ira, op1, dest_type);
	26766	IrInstGen *casted_op1 = ir_implicit_cast(ira, op1, dest_type);
25896	26767	if (type_is_invalid(casted_op1->value->type))
25897		return ira->codegen->invalid_instruction;
	26768	return ira->codegen->invalid_inst_gen;
25898	26769
25899		IrInstruction *op2 = instruction->op2->child;
	26770	IrInstGen *op2 = instruction->op2->child;
25900	26771	if (type_is_invalid(op2->value->type))
25901		return ira->codegen->invalid_instruction;
	26772	return ira->codegen->invalid_inst_gen;
25902	26773
25903		IrInstruction *casted_op2;
	26774	IrInstGen *casted_op2;
25904	26775	if (instruction->op == IrOverflowOpShl) {
25905	26776	ZigType *shift_amt_type = get_smallest_unsigned_int_type(ira->codegen,
25906	26777	dest_type->data.integral.bit_count - 1);
...	...	@@ -25909,17 +26780,17 @@ static IrInstruction ir_analyze_instruction_overflow_op(IrAnalyze ira, IrInstr
25909	26780	casted_op2 = ir_implicit_cast(ira, op2, dest_type);
25910	26781	}
25911	26782	if (type_is_invalid(casted_op2->value->type))
25912		return ira->codegen->invalid_instruction;
	26783	return ira->codegen->invalid_inst_gen;
25913	26784
25914		IrInstruction *result_ptr = instruction->result_ptr->child;
	26785	IrInstGen *result_ptr = instruction->result_ptr->child;
25915	26786	if (type_is_invalid(result_ptr->value->type))
25916		return ira->codegen->invalid_instruction;
	26787	return ira->codegen->invalid_inst_gen;
25917	26788
25918	26789	ZigType *expected_ptr_type;
25919	26790	if (result_ptr->value->type->id == ZigTypeIdPointer) {
25920	26791	uint32_t alignment;
25921	26792	if ((err = resolve_ptr_align(ira, result_ptr->value->type, &alignment)))
25922		return ira->codegen->invalid_instruction;
	26793	return ira->codegen->invalid_inst_gen;
25923	26794	expected_ptr_type = get_pointer_to_type_extra(ira->codegen, dest_type,
25924	26795	false, result_ptr->value->type->data.pointer.is_volatile,
25925	26796	PtrLenSingle,
...	...	@@ -25928,9 +26799,9 @@ static IrInstruction ir_analyze_instruction_overflow_op(IrAnalyze ira, IrInstr
25928	26799	expected_ptr_type = get_pointer_to_type(ira->codegen, dest_type, false);
25929	26800	}
25930	26801
25931		IrInstruction *casted_result_ptr = ir_implicit_cast(ira, result_ptr, expected_ptr_type);
	26802	IrInstGen *casted_result_ptr = ir_implicit_cast(ira, result_ptr, expected_ptr_type);
25932	26803	if (type_is_invalid(casted_result_ptr->value->type))
25933		return ira->codegen->invalid_instruction;
	26804	return ira->codegen->invalid_inst_gen;
25934	26805
25935	26806	if (instr_is_comptime(casted_op1) &&
25936	26807	instr_is_comptime(casted_op2) &&
...	...	@@ -25938,22 +26809,22 @@ static IrInstruction ir_analyze_instruction_overflow_op(IrAnalyze ira, IrInstr
25938	26809	{
25939	26810	ZigValue *op1_val = ir_resolve_const(ira, casted_op1, UndefBad);
25940	26811	if (op1_val == nullptr)
25941		return ira->codegen->invalid_instruction;
	26812	return ira->codegen->invalid_inst_gen;
25942	26813
25943	26814	ZigValue *op2_val = ir_resolve_const(ira, casted_op2, UndefBad);
25944	26815	if (op2_val == nullptr)
25945		return ira->codegen->invalid_instruction;
	26816	return ira->codegen->invalid_inst_gen;
25946	26817
25947	26818	ZigValue *result_val = ir_resolve_const(ira, casted_result_ptr, UndefBad);
25948	26819	if (result_val == nullptr)
25949		return ira->codegen->invalid_instruction;
	26820	return ira->codegen->invalid_inst_gen;
25950	26821
25951	26822	BigInt *op1_bigint = &op1_val->data.x_bigint;
25952	26823	BigInt *op2_bigint = &op2_val->data.x_bigint;
25953	26824	ZigValue *pointee_val = const_ptr_pointee(ira, ira->codegen, result_val,
25954		casted_result_ptr->source_node);
	26825	casted_result_ptr->base.source_node);
25955	26826	if (pointee_val == nullptr)
25956		return ira->codegen->invalid_instruction;
	26827	return ira->codegen->invalid_inst_gen;
25957	26828	BigInt *dest_bigint = &pointee_val->data.x_bigint;
25958	26829	switch (instruction->op) {
25959	26830	case IrOverflowOpAdd:
...	...	@@ -25980,17 +26851,14 @@ static IrInstruction ir_analyze_instruction_overflow_op(IrAnalyze ira, IrInstr
25980	26851	dest_type->data.integral.is_signed);
25981	26852	}
25982	26853	pointee_val->special = ConstValSpecialStatic;
25983		return ir_const_bool(ira, &instruction->base, result_bool);
	26854	return ir_const_bool(ira, &instruction->base.base, result_bool);
25984	26855	}
25985	26856
25986		IrInstruction *result = ir_build_overflow_op(&ira->new_irb,
25987		instruction->base.scope, instruction->base.source_node,
25988		instruction->op, type_value, casted_op1, casted_op2, casted_result_ptr, dest_type);
25989		result->value->type = ira->codegen->builtin_types.entry_bool;
25990		return result;
	26857	return ir_build_overflow_op_gen(ira, &instruction->base.base, instruction->op,
	26858	casted_op1, casted_op2, casted_result_ptr, dest_type);
25991	26859	}
25992	26860
25993		static void ir_eval_mul_add(IrAnalyze ira, IrInstructionMulAdd source_instr, ZigType *float_type,
	26861	static void ir_eval_mul_add(IrAnalyze ira, IrInstSrcMulAdd source_instr, ZigType *float_type,
25994	26862	ZigValue op1, ZigValue op2, ZigValue op3, ZigValue out_val) {
25995	26863	if (float_type->id == ZigTypeIdComptimeFloat) {
25996	26864	f128M_mulAdd(&out_val->data.x_bigfloat.value, &op1->data.x_bigfloat.value, &op2->data.x_bigfloat.value,
...	...	@@ -26017,61 +26885,61 @@ static void ir_eval_mul_add(IrAnalyze ira, IrInstructionMulAdd source_instr, Z
26017	26885	}
26018	26886	}
26019	26887
26020		static IrInstruction ir_analyze_instruction_mul_add(IrAnalyze ira, IrInstructionMulAdd *instruction) {
26021		IrInstruction *type_value = instruction->type_value->child;
	26888	static IrInstGen ir_analyze_instruction_mul_add(IrAnalyze ira, IrInstSrcMulAdd *instruction) {
	26889	IrInstGen *type_value = instruction->type_value->child;
26022	26890	if (type_is_invalid(type_value->value->type))
26023		return ira->codegen->invalid_instruction;
	26891	return ira->codegen->invalid_inst_gen;
26024	26892
26025	26893	ZigType *expr_type = ir_resolve_type(ira, type_value);
26026	26894	if (type_is_invalid(expr_type))
26027		return ira->codegen->invalid_instruction;
	26895	return ira->codegen->invalid_inst_gen;
26028	26896
26029	26897	// Only allow float types, and vectors of floats.
26030	26898	ZigType *float_type = (expr_type->id == ZigTypeIdVector) ? expr_type->data.vector.elem_type : expr_type;
26031	26899	if (float_type->id != ZigTypeIdFloat) {
26032		ir_add_error(ira, type_value,
	26900	ir_add_error(ira, &type_value->base,
26033	26901	buf_sprintf("expected float or vector of float type, found '%s'", buf_ptr(&float_type->name)));
26034		return ira->codegen->invalid_instruction;
	26902	return ira->codegen->invalid_inst_gen;
26035	26903	}
26036	26904
26037		IrInstruction *op1 = instruction->op1->child;
	26905	IrInstGen *op1 = instruction->op1->child;
26038	26906	if (type_is_invalid(op1->value->type))
26039		return ira->codegen->invalid_instruction;
	26907	return ira->codegen->invalid_inst_gen;
26040	26908
26041		IrInstruction *casted_op1 = ir_implicit_cast(ira, op1, expr_type);
	26909	IrInstGen *casted_op1 = ir_implicit_cast(ira, op1, expr_type);
26042	26910	if (type_is_invalid(casted_op1->value->type))
26043		return ira->codegen->invalid_instruction;
	26911	return ira->codegen->invalid_inst_gen;
26044	26912
26045		IrInstruction *op2 = instruction->op2->child;
	26913	IrInstGen *op2 = instruction->op2->child;
26046	26914	if (type_is_invalid(op2->value->type))
26047		return ira->codegen->invalid_instruction;
	26915	return ira->codegen->invalid_inst_gen;
26048	26916
26049		IrInstruction *casted_op2 = ir_implicit_cast(ira, op2, expr_type);
	26917	IrInstGen *casted_op2 = ir_implicit_cast(ira, op2, expr_type);
26050	26918	if (type_is_invalid(casted_op2->value->type))
26051		return ira->codegen->invalid_instruction;
	26919	return ira->codegen->invalid_inst_gen;
26052	26920
26053		IrInstruction *op3 = instruction->op3->child;
	26921	IrInstGen *op3 = instruction->op3->child;
26054	26922	if (type_is_invalid(op3->value->type))
26055		return ira->codegen->invalid_instruction;
	26923	return ira->codegen->invalid_inst_gen;
26056	26924
26057		IrInstruction *casted_op3 = ir_implicit_cast(ira, op3, expr_type);
	26925	IrInstGen *casted_op3 = ir_implicit_cast(ira, op3, expr_type);
26058	26926	if (type_is_invalid(casted_op3->value->type))
26059		return ira->codegen->invalid_instruction;
	26927	return ira->codegen->invalid_inst_gen;
26060	26928
26061	26929	if (instr_is_comptime(casted_op1) &&
26062	26930	instr_is_comptime(casted_op2) &&
26063	26931	instr_is_comptime(casted_op3)) {
26064	26932	ZigValue *op1_const = ir_resolve_const(ira, casted_op1, UndefBad);
26065	26933	if (!op1_const)
26066		return ira->codegen->invalid_instruction;
	26934	return ira->codegen->invalid_inst_gen;
26067	26935	ZigValue *op2_const = ir_resolve_const(ira, casted_op2, UndefBad);
26068	26936	if (!op2_const)
26069		return ira->codegen->invalid_instruction;
	26937	return ira->codegen->invalid_inst_gen;
26070	26938	ZigValue *op3_const = ir_resolve_const(ira, casted_op3, UndefBad);
26071	26939	if (!op3_const)
26072		return ira->codegen->invalid_instruction;
	26940	return ira->codegen->invalid_inst_gen;
26073	26941
26074		IrInstruction *result = ir_const(ira, &instruction->base, expr_type);
	26942	IrInstGen *result = ir_const(ira, &instruction->base.base, expr_type);
26075	26943	ZigValue *out_val = result->value;
26076	26944
26077	26945	if (expr_type->id == ZigTypeIdVector) {
...	...	@@ -26102,63 +26970,59 @@ static IrInstruction ir_analyze_instruction_mul_add(IrAnalyze ira, IrInstructi
26102	26970	return result;
26103	26971	}
26104	26972
26105		IrInstruction *result = ir_build_mul_add(&ira->new_irb,
26106		instruction->base.scope, instruction->base.source_node,
26107		type_value, casted_op1, casted_op2, casted_op3);
26108		result->value->type = expr_type;
26109		return result;
	26973	return ir_build_mul_add_gen(ira, &instruction->base.base, casted_op1, casted_op2, casted_op3, expr_type);
26110	26974	}
26111	26975
26112		static IrInstruction ir_analyze_instruction_test_err(IrAnalyze ira, IrInstructionTestErrSrc *instruction) {
26113		IrInstruction *base_ptr = instruction->base_ptr->child;
	26976	static IrInstGen ir_analyze_instruction_test_err(IrAnalyze ira, IrInstSrcTestErr *instruction) {
	26977	IrInstGen *base_ptr = instruction->base_ptr->child;
26114	26978	if (type_is_invalid(base_ptr->value->type))
26115		return ira->codegen->invalid_instruction;
	26979	return ira->codegen->invalid_inst_gen;
26116	26980
26117		IrInstruction *value;
	26981	IrInstGen *value;
26118	26982	if (instruction->base_ptr_is_payload) {
26119	26983	value = base_ptr;
26120	26984	} else {
26121		value = ir_get_deref(ira, &instruction->base, base_ptr, nullptr);
	26985	value = ir_get_deref(ira, &instruction->base.base, base_ptr, nullptr);
26122	26986	}
26123	26987
26124	26988	ZigType *type_entry = value->value->type;
26125	26989	if (type_is_invalid(type_entry))
26126		return ira->codegen->invalid_instruction;
	26990	return ira->codegen->invalid_inst_gen;
26127	26991	if (type_entry->id == ZigTypeIdErrorUnion) {
26128	26992	if (instr_is_comptime(value)) {
26129	26993	ZigValue *err_union_val = ir_resolve_const(ira, value, UndefBad);
26130	26994	if (!err_union_val)
26131		return ira->codegen->invalid_instruction;
	26995	return ira->codegen->invalid_inst_gen;
26132	26996
26133	26997	if (err_union_val->special != ConstValSpecialRuntime) {
26134	26998	ErrorTableEntry *err = err_union_val->data.x_err_union.error_set->data.x_err_set;
26135		return ir_const_bool(ira, &instruction->base, (err != nullptr));
	26999	return ir_const_bool(ira, &instruction->base.base, (err != nullptr));
26136	27000	}
26137	27001	}
26138	27002
26139	27003	if (instruction->resolve_err_set) {
26140	27004	ZigType *err_set_type = type_entry->data.error_union.err_set_type;
26141		if (!resolve_inferred_error_set(ira->codegen, err_set_type, instruction->base.source_node)) {
26142		return ira->codegen->invalid_instruction;
	27005	if (!resolve_inferred_error_set(ira->codegen, err_set_type, instruction->base.base.source_node)) {
	27006	return ira->codegen->invalid_inst_gen;
26143	27007	}
26144	27008	if (!type_is_global_error_set(err_set_type) &&
26145	27009	err_set_type->data.error_set.err_count == 0)
26146	27010	{
26147	27011	assert(!err_set_type->data.error_set.incomplete);
26148		return ir_const_bool(ira, &instruction->base, false);
	27012	return ir_const_bool(ira, &instruction->base.base, false);
26149	27013	}
26150	27014	}
26151	27015
26152		return ir_build_test_err_gen(ira, &instruction->base, value);
	27016	return ir_build_test_err_gen(ira, &instruction->base.base, value);
26153	27017	} else if (type_entry->id == ZigTypeIdErrorSet) {
26154		return ir_const_bool(ira, &instruction->base, true);
	27018	return ir_const_bool(ira, &instruction->base.base, true);
26155	27019	} else {
26156		return ir_const_bool(ira, &instruction->base, false);
	27020	return ir_const_bool(ira, &instruction->base.base, false);
26157	27021	}
26158	27022	}
26159	27023
26160		static IrInstruction ir_analyze_unwrap_err_code(IrAnalyze ira, IrInstruction *source_instr,
26161		IrInstruction *base_ptr, bool initializing)
	27024	static IrInstGen ir_analyze_unwrap_err_code(IrAnalyze ira, IrInst* source_instr,
	27025	IrInstGen *base_ptr, bool initializing)
26162	27026	{
26163	27027	ZigType *ptr_type = base_ptr->value->type;
26164	27028
...	...	@@ -26167,12 +27031,12 @@ static IrInstruction ir_analyze_unwrap_err_code(IrAnalyze ira, IrInstruction *
26167	27031
26168	27032	ZigType *type_entry = ptr_type->data.pointer.child_type;
26169	27033	if (type_is_invalid(type_entry))
26170		return ira->codegen->invalid_instruction;
	27034	return ira->codegen->invalid_inst_gen;
26171	27035
26172	27036	if (type_entry->id != ZigTypeIdErrorUnion) {
26173		ir_add_error(ira, base_ptr,
	27037	ir_add_error(ira, &base_ptr->base,
26174	27038	buf_sprintf("expected error union type, found '%s'", buf_ptr(&type_entry->name)));
26175		return ira->codegen->invalid_instruction;
	27039	return ira->codegen->invalid_inst_gen;
26176	27040	}
26177	27041
26178	27042	ZigType *err_set_type = type_entry->data.error_union.err_set_type;
...	...	@@ -26183,13 +27047,13 @@ static IrInstruction ir_analyze_unwrap_err_code(IrAnalyze ira, IrInstruction *
26183	27047	if (instr_is_comptime(base_ptr)) {
26184	27048	ZigValue *ptr_val = ir_resolve_const(ira, base_ptr, UndefBad);
26185	27049	if (!ptr_val)
26186		return ira->codegen->invalid_instruction;
	27050	return ira->codegen->invalid_inst_gen;
26187	27051	if (ptr_val->data.x_ptr.mut != ConstPtrMutRuntimeVar &&
26188	27052	ptr_val->data.x_ptr.special != ConstPtrSpecialHardCodedAddr)
26189	27053	{
26190	27054	ZigValue *err_union_val = const_ptr_pointee(ira, ira->codegen, ptr_val, source_instr->source_node);
26191	27055	if (err_union_val == nullptr)
26192		return ira->codegen->invalid_instruction;
	27056	return ira->codegen->invalid_inst_gen;
26193	27057
26194	27058	if (initializing && err_union_val->special == ConstValSpecialUndef) {
26195	27059	ZigValue *vals = create_const_vals(2);
...	...	@@ -26212,11 +27076,10 @@ static IrInstruction ir_analyze_unwrap_err_code(IrAnalyze ira, IrInstruction *
26212	27076	}
26213	27077	ir_assert(err_union_val->special != ConstValSpecialRuntime, source_instr);
26214	27078
26215		IrInstruction *result;
	27079	IrInstGen *result;
26216	27080	if (ptr_val->data.x_ptr.mut == ConstPtrMutInfer) {
26217		result = ir_build_unwrap_err_code(&ira->new_irb, source_instr->scope,
26218		source_instr->source_node, base_ptr);
26219		result->value->type = result_type;
	27081	result = ir_build_unwrap_err_code_gen(ira, source_instr->scope,
	27082	source_instr->source_node, base_ptr, result_type);
26220	27083	result->value->special = ConstValSpecialStatic;
26221	27084	} else {
26222	27085	result = ir_const(ira, source_instr, result_type);
...	...	@@ -26229,23 +27092,18 @@ static IrInstruction ir_analyze_unwrap_err_code(IrAnalyze ira, IrInstruction *
26229	27092	}
26230	27093	}
26231	27094
26232		IrInstruction *result = ir_build_unwrap_err_code(&ira->new_irb,
26233		source_instr->scope, source_instr->source_node, base_ptr);
26234		result->value->type = result_type;
26235		return result;
	27095	return ir_build_unwrap_err_code_gen(ira, source_instr->scope, source_instr->source_node, base_ptr, result_type);
26236	27096	}
26237	27097
26238		static IrInstruction ir_analyze_instruction_unwrap_err_code(IrAnalyze ira,
26239		IrInstructionUnwrapErrCode *instruction)
26240		{
26241		IrInstruction *base_ptr = instruction->err_union_ptr->child;
	27098	static IrInstGen ir_analyze_instruction_unwrap_err_code(IrAnalyze ira, IrInstSrcUnwrapErrCode *instruction) {
	27099	IrInstGen *base_ptr = instruction->err_union_ptr->child;
26242	27100	if (type_is_invalid(base_ptr->value->type))
26243		return ira->codegen->invalid_instruction;
26244		return ir_analyze_unwrap_err_code(ira, &instruction->base, base_ptr, false);
	27101	return ira->codegen->invalid_inst_gen;
	27102	return ir_analyze_unwrap_err_code(ira, &instruction->base.base, base_ptr, false);
26245	27103	}
26246	27104
26247		static IrInstruction ir_analyze_unwrap_error_payload(IrAnalyze ira, IrInstruction *source_instr,
26248		IrInstruction *base_ptr, bool safety_check_on, bool initializing)
	27105	static IrInstGen ir_analyze_unwrap_error_payload(IrAnalyze ira, IrInst* source_instr,
	27106	IrInstGen *base_ptr, bool safety_check_on, bool initializing)
26249	27107	{
26250	27108	ZigType *ptr_type = base_ptr->value->type;
26251	27109
...	...	@@ -26254,17 +27112,17 @@ static IrInstruction ir_analyze_unwrap_error_payload(IrAnalyze ira, IrInstruct
26254	27112
26255	27113	ZigType *type_entry = ptr_type->data.pointer.child_type;
26256	27114	if (type_is_invalid(type_entry))
26257		return ira->codegen->invalid_instruction;
	27115	return ira->codegen->invalid_inst_gen;
26258	27116
26259	27117	if (type_entry->id != ZigTypeIdErrorUnion) {
26260		ir_add_error(ira, base_ptr,
	27118	ir_add_error(ira, &base_ptr->base,
26261	27119	buf_sprintf("expected error union type, found '%s'", buf_ptr(&type_entry->name)));
26262		return ira->codegen->invalid_instruction;
	27120	return ira->codegen->invalid_inst_gen;
26263	27121	}
26264	27122
26265	27123	ZigType *payload_type = type_entry->data.error_union.payload_type;
26266	27124	if (type_is_invalid(payload_type))
26267		return ira->codegen->invalid_instruction;
	27125	return ira->codegen->invalid_inst_gen;
26268	27126
26269	27127	ZigType *result_type = get_pointer_to_type_extra(ira->codegen, payload_type,
26270	27128	ptr_type->data.pointer.is_const, ptr_type->data.pointer.is_volatile,
...	...	@@ -26273,11 +27131,11 @@ static IrInstruction ir_analyze_unwrap_error_payload(IrAnalyze ira, IrInstruct
26273	27131	if (instr_is_comptime(base_ptr)) {
26274	27132	ZigValue *ptr_val = ir_resolve_const(ira, base_ptr, UndefBad);
26275	27133	if (!ptr_val)
26276		return ira->codegen->invalid_instruction;
	27134	return ira->codegen->invalid_inst_gen;
26277	27135	if (ptr_val->data.x_ptr.mut != ConstPtrMutRuntimeVar) {
26278	27136	ZigValue *err_union_val = const_ptr_pointee(ira, ira->codegen, ptr_val, source_instr->source_node);
26279	27137	if (err_union_val == nullptr)
26280		return ira->codegen->invalid_instruction;
	27138	return ira->codegen->invalid_inst_gen;
26281	27139	if (initializing && err_union_val->special == ConstValSpecialUndef) {
26282	27140	ZigValue *vals = create_const_vals(2);
26283	27141	ZigValue *err_set_val = &vals[0];
...	...	@@ -26300,14 +27158,13 @@ static IrInstruction ir_analyze_unwrap_error_payload(IrAnalyze ira, IrInstruct
26300	27158	if (err != nullptr) {
26301	27159	ir_add_error(ira, source_instr,
26302	27160	buf_sprintf("caught unexpected error '%s'", buf_ptr(&err->name)));
26303		return ira->codegen->invalid_instruction;
	27161	return ira->codegen->invalid_inst_gen;
26304	27162	}
26305	27163
26306		IrInstruction *result;
	27164	IrInstGen *result;
26307	27165	if (ptr_val->data.x_ptr.mut == ConstPtrMutInfer) {
26308		result = ir_build_unwrap_err_payload(&ira->new_irb, source_instr->scope,
26309		source_instr->source_node, base_ptr, safety_check_on, initializing);
26310		result->value->type = result_type;
	27166	result = ir_build_unwrap_err_payload_gen(ira, source_instr->scope,
	27167	source_instr->source_node, base_ptr, safety_check_on, initializing, result_type);
26311	27168	result->value->special = ConstValSpecialStatic;
26312	27169	} else {
26313	27170	result = ir_const(ira, source_instr, result_type);
...	...	@@ -26320,28 +27177,26 @@ static IrInstruction ir_analyze_unwrap_error_payload(IrAnalyze ira, IrInstruct
26320	27177	}
26321	27178	}
26322	27179
26323		IrInstruction *result = ir_build_unwrap_err_payload(&ira->new_irb, source_instr->scope,
26324		source_instr->source_node, base_ptr, safety_check_on, initializing);
26325		result->value->type = result_type;
26326		return result;
	27180	return ir_build_unwrap_err_payload_gen(ira, source_instr->scope, source_instr->source_node,
	27181	base_ptr, safety_check_on, initializing, result_type);
26327	27182	}
26328	27183
26329		static IrInstruction ir_analyze_instruction_unwrap_err_payload(IrAnalyze ira,
26330		IrInstructionUnwrapErrPayload *instruction)
	27184	static IrInstGen ir_analyze_instruction_unwrap_err_payload(IrAnalyze ira,
	27185	IrInstSrcUnwrapErrPayload *instruction)
26331	27186	{
26332	27187	assert(instruction->value->child);
26333		IrInstruction *value = instruction->value->child;
	27188	IrInstGen *value = instruction->value->child;
26334	27189	if (type_is_invalid(value->value->type))
26335		return ira->codegen->invalid_instruction;
	27190	return ira->codegen->invalid_inst_gen;
26336	27191
26337		return ir_analyze_unwrap_error_payload(ira, &instruction->base, value, instruction->safety_check_on, false);
	27192	return ir_analyze_unwrap_error_payload(ira, &instruction->base.base, value, instruction->safety_check_on, false);
26338	27193	}
26339	27194
26340		static IrInstruction ir_analyze_instruction_fn_proto(IrAnalyze ira, IrInstructionFnProto *instruction) {
26341		AstNode *proto_node = instruction->base.source_node;
	27195	static IrInstGen ir_analyze_instruction_fn_proto(IrAnalyze ira, IrInstSrcFnProto *instruction) {
	27196	AstNode *proto_node = instruction->base.base.source_node;
26342	27197	assert(proto_node->type == NodeTypeFnProto);
26343	27198
26344		IrInstruction *result = ir_const(ira, &instruction->base, ira->codegen->builtin_types.entry_type);
	27199	IrInstGen *result = ir_const(ira, &instruction->base.base, ira->codegen->builtin_types.entry_type);
26345	27200	result->value->special = ConstValSpecialLazy;
26346	27201
26347	27202	LazyValueFnType *lazy_fn_type = allocate<LazyValueFnType>(1, "LazyValueFnType");
...	...	@@ -26350,29 +27205,29 @@ static IrInstruction ir_analyze_instruction_fn_proto(IrAnalyze ira, IrInstruct
26350	27205	lazy_fn_type->base.id = LazyValueIdFnType;
26351	27206
26352	27207	if (proto_node->data.fn_proto.auto_err_set) {
26353		ir_add_error(ira, &instruction->base,
	27208	ir_add_error(ira, &instruction->base.base,
26354	27209	buf_sprintf("inferring error set of return type valid only for function definitions"));
26355		return ira->codegen->invalid_instruction;
	27210	return ira->codegen->invalid_inst_gen;
26356	27211	}
26357	27212
26358	27213	lazy_fn_type->cc = cc_from_fn_proto(&proto_node->data.fn_proto);
26359	27214	if (instruction->callconv_value != nullptr) {
26360	27215	ZigType *cc_enum_type = get_builtin_type(ira->codegen, "CallingConvention");
26361	27216
26362		IrInstruction *casted_value = ir_implicit_cast(ira, instruction->callconv_value, cc_enum_type);
	27217	IrInstGen *casted_value = ir_implicit_cast(ira, instruction->callconv_value->child, cc_enum_type);
26363	27218	if (type_is_invalid(casted_value->value->type))
26364		return ira->codegen->invalid_instruction;
	27219	return ira->codegen->invalid_inst_gen;
26365	27220
26366	27221	ZigValue *const_value = ir_resolve_const(ira, casted_value, UndefBad);
26367	27222	if (const_value == nullptr)
26368		return ira->codegen->invalid_instruction;
	27223	return ira->codegen->invalid_inst_gen;
26369	27224
26370	27225	lazy_fn_type->cc = (CallingConvention)bigint_as_u32(&const_value->data.x_enum_tag);
26371	27226	}
26372	27227
26373	27228	size_t param_count = proto_node->data.fn_proto.params.length;
26374	27229	lazy_fn_type->proto_node = proto_node;
26375		lazy_fn_type->param_types = allocate<IrInstruction *>(param_count);
	27230	lazy_fn_type->param_types = allocate<IrInstGen *>(param_count);
26376	27231
26377	27232	for (size_t param_index = 0; param_index < param_count; param_index += 1) {
26378	27233	AstNode *param_node = proto_node->data.fn_proto.params.at(param_index);
...	...	@@ -26397,63 +27252,63 @@ static IrInstruction ir_analyze_instruction_fn_proto(IrAnalyze ira, IrInstruct
26397	27252	return result;
26398	27253	}
26399	27254
26400		IrInstruction *param_type_value = instruction->param_types[param_index]->child;
	27255	IrInstGen *param_type_value = instruction->param_types[param_index]->child;
26401	27256	if (type_is_invalid(param_type_value->value->type))
26402		return ira->codegen->invalid_instruction;
	27257	return ira->codegen->invalid_inst_gen;
26403	27258	if (ir_resolve_const(ira, param_type_value, LazyOk) == nullptr)
26404		return ira->codegen->invalid_instruction;
	27259	return ira->codegen->invalid_inst_gen;
26405	27260	lazy_fn_type->param_types[param_index] = param_type_value;
26406	27261	}
26407	27262
26408	27263	if (instruction->align_value != nullptr) {
26409	27264	lazy_fn_type->align_inst = instruction->align_value->child;
26410	27265	if (ir_resolve_const(ira, lazy_fn_type->align_inst, LazyOk) == nullptr)
26411		return ira->codegen->invalid_instruction;
	27266	return ira->codegen->invalid_inst_gen;
26412	27267	}
26413	27268
26414	27269	lazy_fn_type->return_type = instruction->return_type->child;
26415	27270	if (ir_resolve_const(ira, lazy_fn_type->return_type, LazyOk) == nullptr)
26416		return ira->codegen->invalid_instruction;
	27271	return ira->codegen->invalid_inst_gen;
26417	27272
26418	27273	return result;
26419	27274	}
26420	27275
26421		static IrInstruction ir_analyze_instruction_test_comptime(IrAnalyze ira, IrInstructionTestComptime *instruction) {
26422		IrInstruction *value = instruction->value->child;
	27276	static IrInstGen ir_analyze_instruction_test_comptime(IrAnalyze ira, IrInstSrcTestComptime *instruction) {
	27277	IrInstGen *value = instruction->value->child;
26423	27278	if (type_is_invalid(value->value->type))
26424		return ira->codegen->invalid_instruction;
	27279	return ira->codegen->invalid_inst_gen;
26425	27280
26426		return ir_const_bool(ira, &instruction->base, instr_is_comptime(value));
	27281	return ir_const_bool(ira, &instruction->base.base, instr_is_comptime(value));
26427	27282	}
26428	27283
26429		static IrInstruction ir_analyze_instruction_check_switch_prongs(IrAnalyze ira,
26430		IrInstructionCheckSwitchProngs *instruction)
	27284	static IrInstGen ir_analyze_instruction_check_switch_prongs(IrAnalyze ira,
	27285	IrInstSrcCheckSwitchProngs *instruction)
26431	27286	{
26432		IrInstruction *target_value = instruction->target_value->child;
	27287	IrInstGen *target_value = instruction->target_value->child;
26433	27288	ZigType *switch_type = target_value->value->type;
26434	27289	if (type_is_invalid(switch_type))
26435		return ira->codegen->invalid_instruction;
	27290	return ira->codegen->invalid_inst_gen;
26436	27291
26437	27292	if (switch_type->id == ZigTypeIdEnum) {
26438	27293	HashMap<BigInt, AstNode *, bigint_hash, bigint_eql> field_prev_uses = {};
26439	27294	field_prev_uses.init(switch_type->data.enumeration.src_field_count);
26440	27295
26441	27296	for (size_t range_i = 0; range_i < instruction->range_count; range_i += 1) {
26442		IrInstructionCheckSwitchProngsRange *range = &instruction->ranges[range_i];
	27297	IrInstSrcCheckSwitchProngsRange *range = &instruction->ranges[range_i];
26443	27298
26444		IrInstruction *start_value_uncasted = range->start->child;
	27299	IrInstGen *start_value_uncasted = range->start->child;
26445	27300	if (type_is_invalid(start_value_uncasted->value->type))
26446		return ira->codegen->invalid_instruction;
26447		IrInstruction *start_value = ir_implicit_cast(ira, start_value_uncasted, switch_type);
	27301	return ira->codegen->invalid_inst_gen;
	27302	IrInstGen *start_value = ir_implicit_cast(ira, start_value_uncasted, switch_type);
26448	27303	if (type_is_invalid(start_value->value->type))
26449		return ira->codegen->invalid_instruction;
	27304	return ira->codegen->invalid_inst_gen;
26450	27305
26451		IrInstruction *end_value_uncasted = range->end->child;
	27306	IrInstGen *end_value_uncasted = range->end->child;
26452	27307	if (type_is_invalid(end_value_uncasted->value->type))
26453		return ira->codegen->invalid_instruction;
26454		IrInstruction *end_value = ir_implicit_cast(ira, end_value_uncasted, switch_type);
	27308	return ira->codegen->invalid_inst_gen;
	27309	IrInstGen *end_value = ir_implicit_cast(ira, end_value_uncasted, switch_type);
26455	27310	if (type_is_invalid(end_value->value->type))
26456		return ira->codegen->invalid_instruction;
	27311	return ira->codegen->invalid_inst_gen;
26457	27312
26458	27313	assert(start_value->value->type->id == ZigTypeIdEnum);
26459	27314	BigInt start_index;
...	...	@@ -26464,7 +27319,7 @@ static IrInstruction ir_analyze_instruction_check_switch_prongs(IrAnalyze ira,
26464	27319	bigint_init_bigint(&end_index, &end_value->value->data.x_enum_tag);
26465	27320
26466	27321	if (bigint_cmp(&start_index, &end_index) == CmpGT) {
26467		ir_add_error(ira, start_value,
	27322	ir_add_error(ira, &start_value->base,
26468	27323	buf_sprintf("range start value is greater than the end value"));
26469	27324	}
26470	27325
...	...	@@ -26475,12 +27330,12 @@ static IrInstruction ir_analyze_instruction_check_switch_prongs(IrAnalyze ira,
26475	27330	if (cmp == CmpGT) {
26476	27331	break;
26477	27332	}
26478		auto entry = field_prev_uses.put_unique(field_index, start_value->source_node);
	27333	auto entry = field_prev_uses.put_unique(field_index, start_value->base.source_node);
26479	27334	if (entry) {
26480	27335	AstNode *prev_node = entry->value;
26481	27336	TypeEnumField *enum_field = find_enum_field_by_tag(switch_type, &field_index);
26482	27337	assert(enum_field != nullptr);
26483		ErrorMsg *msg = ir_add_error(ira, start_value,
	27338	ErrorMsg *msg = ir_add_error(ira, &start_value->base,
26484	27339	buf_sprintf("duplicate switch value: '%s.%s'", buf_ptr(&switch_type->name),
26485	27340	buf_ptr(enum_field->name)));
26486	27341	add_error_note(ira->codegen, msg, prev_node, buf_sprintf("other value is here"));
...	...	@@ -26490,7 +27345,7 @@ static IrInstruction ir_analyze_instruction_check_switch_prongs(IrAnalyze ira,
26490	27345	}
26491	27346	if (instruction->have_underscore_prong) {
26492	27347	if (!switch_type->data.enumeration.non_exhaustive){
26493		ir_add_error(ira, &instruction->base,
	27348	ir_add_error(ira, &instruction->base.base,
26494	27349	buf_sprintf("switch on non-exhaustive enum has `_` prong"));
26495	27350	}
26496	27351	for (uint32_t i = 0; i < switch_type->data.enumeration.src_field_count; i += 1) {
...	...	@@ -26500,14 +27355,14 @@ static IrInstruction ir_analyze_instruction_check_switch_prongs(IrAnalyze ira,
26500	27355
26501	27356	auto entry = field_prev_uses.maybe_get(enum_field->value);
26502	27357	if (!entry) {
26503		ir_add_error(ira, &instruction->base,
	27358	ir_add_error(ira, &instruction->base.base,
26504	27359	buf_sprintf("enumeration value '%s.%s' not handled in switch", buf_ptr(&switch_type->name),
26505	27360	buf_ptr(enum_field->name)));
26506	27361	}
26507	27362	}
26508	27363	} else if (!instruction->have_else_prong) {
26509	27364	if (switch_type->data.enumeration.non_exhaustive) {
26510		ir_add_error(ira, &instruction->base,
	27365	ir_add_error(ira, &instruction->base.base,
26511	27366	buf_sprintf("switch on non-exhaustive enum must include `else` or `_` prong"));
26512	27367	}
26513	27368	for (uint32_t i = 0; i < switch_type->data.enumeration.src_field_count; i += 1) {
...	...	@@ -26515,69 +27370,69 @@ static IrInstruction ir_analyze_instruction_check_switch_prongs(IrAnalyze ira,
26515	27370
26516	27371	auto entry = field_prev_uses.maybe_get(enum_field->value);
26517	27372	if (!entry) {
26518		ir_add_error(ira, &instruction->base,
	27373	ir_add_error(ira, &instruction->base.base,
26519	27374	buf_sprintf("enumeration value '%s.%s' not handled in switch", buf_ptr(&switch_type->name),
26520	27375	buf_ptr(enum_field->name)));
26521	27376	}
26522	27377	}
26523	27378	}
26524	27379	} else if (switch_type->id == ZigTypeIdErrorSet) {
26525		if (!resolve_inferred_error_set(ira->codegen, switch_type, target_value->source_node)) {
26526		return ira->codegen->invalid_instruction;
	27380	if (!resolve_inferred_error_set(ira->codegen, switch_type, target_value->base.source_node)) {
	27381	return ira->codegen->invalid_inst_gen;
26527	27382	}
26528	27383
26529	27384	size_t field_prev_uses_count = ira->codegen->errors_by_index.length;
26530	27385	AstNode *field_prev_uses = allocate<AstNode >(field_prev_uses_count, "AstNode *");
26531	27386
26532	27387	for (size_t range_i = 0; range_i < instruction->range_count; range_i += 1) {
26533		IrInstructionCheckSwitchProngsRange *range = &instruction->ranges[range_i];
	27388	IrInstSrcCheckSwitchProngsRange *range = &instruction->ranges[range_i];
26534	27389
26535		IrInstruction *start_value_uncasted = range->start->child;
	27390	IrInstGen *start_value_uncasted = range->start->child;
26536	27391	if (type_is_invalid(start_value_uncasted->value->type))
26537		return ira->codegen->invalid_instruction;
26538		IrInstruction *start_value = ir_implicit_cast(ira, start_value_uncasted, switch_type);
	27392	return ira->codegen->invalid_inst_gen;
	27393	IrInstGen *start_value = ir_implicit_cast(ira, start_value_uncasted, switch_type);
26539	27394	if (type_is_invalid(start_value->value->type))
26540		return ira->codegen->invalid_instruction;
	27395	return ira->codegen->invalid_inst_gen;
26541	27396
26542		IrInstruction *end_value_uncasted = range->end->child;
	27397	IrInstGen *end_value_uncasted = range->end->child;
26543	27398	if (type_is_invalid(end_value_uncasted->value->type))
26544		return ira->codegen->invalid_instruction;
26545		IrInstruction *end_value = ir_implicit_cast(ira, end_value_uncasted, switch_type);
	27399	return ira->codegen->invalid_inst_gen;
	27400	IrInstGen *end_value = ir_implicit_cast(ira, end_value_uncasted, switch_type);
26546	27401	if (type_is_invalid(end_value->value->type))
26547		return ira->codegen->invalid_instruction;
	27402	return ira->codegen->invalid_inst_gen;
26548	27403
26549		ir_assert(start_value->value->type->id == ZigTypeIdErrorSet, &instruction->base);
	27404	ir_assert(start_value->value->type->id == ZigTypeIdErrorSet, &instruction->base.base);
26550	27405	uint32_t start_index = start_value->value->data.x_err_set->value;
26551	27406
26552		ir_assert(end_value->value->type->id == ZigTypeIdErrorSet, &instruction->base);
	27407	ir_assert(end_value->value->type->id == ZigTypeIdErrorSet, &instruction->base.base);
26553	27408	uint32_t end_index = end_value->value->data.x_err_set->value;
26554	27409
26555	27410	if (start_index != end_index) {
26556		ir_add_error(ira, end_value, buf_sprintf("ranges not allowed when switching on errors"));
26557		return ira->codegen->invalid_instruction;
	27411	ir_add_error(ira, &end_value->base, buf_sprintf("ranges not allowed when switching on errors"));
	27412	return ira->codegen->invalid_inst_gen;
26558	27413	}
26559	27414
26560	27415	AstNode *prev_node = field_prev_uses[start_index];
26561	27416	if (prev_node != nullptr) {
26562	27417	Buf *err_name = &ira->codegen->errors_by_index.at(start_index)->name;
26563		ErrorMsg *msg = ir_add_error(ira, start_value,
	27418	ErrorMsg *msg = ir_add_error(ira, &start_value->base,
26564	27419	buf_sprintf("duplicate switch value: '%s.%s'", buf_ptr(&switch_type->name), buf_ptr(err_name)));
26565	27420	add_error_note(ira->codegen, msg, prev_node, buf_sprintf("other value is here"));
26566	27421	}
26567		field_prev_uses[start_index] = start_value->source_node;
	27422	field_prev_uses[start_index] = start_value->base.source_node;
26568	27423	}
26569	27424	if (!instruction->have_else_prong) {
26570	27425	if (type_is_global_error_set(switch_type)) {
26571		ir_add_error(ira, &instruction->base,
	27426	ir_add_error(ira, &instruction->base.base,
26572	27427	buf_sprintf("else prong required when switching on type 'anyerror'"));
26573		return ira->codegen->invalid_instruction;
	27428	return ira->codegen->invalid_inst_gen;
26574	27429	} else {
26575	27430	for (uint32_t i = 0; i < switch_type->data.error_set.err_count; i += 1) {
26576	27431	ErrorTableEntry *err_entry = switch_type->data.error_set.errors[i];
26577	27432
26578	27433	AstNode *prev_node = field_prev_uses[err_entry->value];
26579	27434	if (prev_node == nullptr) {
26580		ir_add_error(ira, &instruction->base,
	27435	ir_add_error(ira, &instruction->base.base,
26581	27436	buf_sprintf("error.%s not handled in switch", buf_ptr(&err_entry->name)));
26582	27437	}
26583	27438	}
...	...	@@ -26588,44 +27443,44 @@ static IrInstruction ir_analyze_instruction_check_switch_prongs(IrAnalyze ira,
26588	27443	} else if (switch_type->id == ZigTypeIdInt) {
26589	27444	RangeSet rs = {0};
26590	27445	for (size_t range_i = 0; range_i < instruction->range_count; range_i += 1) {
26591		IrInstructionCheckSwitchProngsRange *range = &instruction->ranges[range_i];
	27446	IrInstSrcCheckSwitchProngsRange *range = &instruction->ranges[range_i];
26592	27447
26593		IrInstruction *start_value = range->start->child;
	27448	IrInstGen *start_value = range->start->child;
26594	27449	if (type_is_invalid(start_value->value->type))
26595		return ira->codegen->invalid_instruction;
26596		IrInstruction *casted_start_value = ir_implicit_cast(ira, start_value, switch_type);
	27450	return ira->codegen->invalid_inst_gen;
	27451	IrInstGen *casted_start_value = ir_implicit_cast(ira, start_value, switch_type);
26597	27452	if (type_is_invalid(casted_start_value->value->type))
26598		return ira->codegen->invalid_instruction;
	27453	return ira->codegen->invalid_inst_gen;
26599	27454
26600		IrInstruction *end_value = range->end->child;
	27455	IrInstGen *end_value = range->end->child;
26601	27456	if (type_is_invalid(end_value->value->type))
26602		return ira->codegen->invalid_instruction;
26603		IrInstruction *casted_end_value = ir_implicit_cast(ira, end_value, switch_type);
	27457	return ira->codegen->invalid_inst_gen;
	27458	IrInstGen *casted_end_value = ir_implicit_cast(ira, end_value, switch_type);
26604	27459	if (type_is_invalid(casted_end_value->value->type))
26605		return ira->codegen->invalid_instruction;
	27460	return ira->codegen->invalid_inst_gen;
26606	27461
26607	27462	ZigValue *start_val = ir_resolve_const(ira, casted_start_value, UndefBad);
26608	27463	if (!start_val)
26609		return ira->codegen->invalid_instruction;
	27464	return ira->codegen->invalid_inst_gen;
26610	27465
26611	27466	ZigValue *end_val = ir_resolve_const(ira, casted_end_value, UndefBad);
26612	27467	if (!end_val)
26613		return ira->codegen->invalid_instruction;
	27468	return ira->codegen->invalid_inst_gen;
26614	27469
26615	27470	assert(start_val->type->id == ZigTypeIdInt \|\| start_val->type->id == ZigTypeIdComptimeInt);
26616	27471	assert(end_val->type->id == ZigTypeIdInt \|\| end_val->type->id == ZigTypeIdComptimeInt);
26617	27472
26618	27473	if (bigint_cmp(&start_val->data.x_bigint, &end_val->data.x_bigint) == CmpGT) {
26619		ir_add_error(ira, start_value,
	27474	ir_add_error(ira, &start_value->base,
26620	27475	buf_sprintf("range start value is greater than the end value"));
26621	27476	}
26622	27477
26623	27478	AstNode *prev_node = rangeset_add_range(&rs, &start_val->data.x_bigint, &end_val->data.x_bigint,
26624		start_value->source_node);
	27479	start_value->base.source_node);
26625	27480	if (prev_node != nullptr) {
26626		ErrorMsg *msg = ir_add_error(ira, start_value, buf_sprintf("duplicate switch value"));
	27481	ErrorMsg *msg = ir_add_error(ira, &start_value->base, buf_sprintf("duplicate switch value"));
26627	27482	add_error_note(ira->codegen, msg, prev_node, buf_sprintf("previous value is here"));
26628		return ira->codegen->invalid_instruction;
	27483	return ira->codegen->invalid_inst_gen;
26629	27484	}
26630	27485	}
26631	27486	if (!instruction->have_else_prong) {
...	...	@@ -26634,25 +27489,25 @@ static IrInstruction ir_analyze_instruction_check_switch_prongs(IrAnalyze ira,
26634	27489	BigInt max_val;
26635	27490	eval_min_max_value_int(ira->codegen, switch_type, &max_val, true);
26636	27491	if (!rangeset_spans(&rs, &min_val, &max_val)) {
26637		ir_add_error(ira, &instruction->base, buf_sprintf("switch must handle all possibilities"));
26638		return ira->codegen->invalid_instruction;
	27492	ir_add_error(ira, &instruction->base.base, buf_sprintf("switch must handle all possibilities"));
	27493	return ira->codegen->invalid_inst_gen;
26639	27494	}
26640	27495	}
26641	27496	} else if (switch_type->id == ZigTypeIdBool) {
26642	27497	int seenTrue = 0;
26643	27498	int seenFalse = 0;
26644	27499	for (size_t range_i = 0; range_i < instruction->range_count; range_i += 1) {
26645		IrInstructionCheckSwitchProngsRange *range = &instruction->ranges[range_i];
	27500	IrInstSrcCheckSwitchProngsRange *range = &instruction->ranges[range_i];
26646	27501
26647		IrInstruction *value = range->start->child;
	27502	IrInstGen *value = range->start->child;
26648	27503
26649		IrInstruction *casted_value = ir_implicit_cast(ira, value, switch_type);
	27504	IrInstGen *casted_value = ir_implicit_cast(ira, value, switch_type);
26650	27505	if (type_is_invalid(casted_value->value->type))
26651		return ira->codegen->invalid_instruction;
	27506	return ira->codegen->invalid_inst_gen;
26652	27507
26653	27508	ZigValue *const_expr_val = ir_resolve_const(ira, casted_value, UndefBad);
26654	27509	if (!const_expr_val)
26655		return ira->codegen->invalid_instruction;
	27510	return ira->codegen->invalid_inst_gen;
26656	27511
26657	27512	assert(const_expr_val->type->id == ZigTypeIdBool);
26658	27513
...	...	@@ -26663,60 +27518,59 @@ static IrInstruction ir_analyze_instruction_check_switch_prongs(IrAnalyze ira,
26663	27518	}
26664	27519
26665	27520	if ((seenTrue > 1) \|\| (seenFalse > 1)) {
26666		ir_add_error(ira, value, buf_sprintf("duplicate switch value"));
26667		return ira->codegen->invalid_instruction;
	27521	ir_add_error(ira, &value->base, buf_sprintf("duplicate switch value"));
	27522	return ira->codegen->invalid_inst_gen;
26668	27523	}
26669	27524	}
26670	27525	if (((seenTrue < 1) \|\| (seenFalse < 1)) && !instruction->have_else_prong) {
26671		ir_add_error(ira, &instruction->base, buf_sprintf("switch must handle all possibilities"));
26672		return ira->codegen->invalid_instruction;
	27526	ir_add_error(ira, &instruction->base.base, buf_sprintf("switch must handle all possibilities"));
	27527	return ira->codegen->invalid_inst_gen;
26673	27528	}
26674	27529	} else if (!instruction->have_else_prong) {
26675		ir_add_error(ira, &instruction->base,
	27530	ir_add_error(ira, &instruction->base.base,
26676	27531	buf_sprintf("else prong required when switching on type '%s'", buf_ptr(&switch_type->name)));
26677		return ira->codegen->invalid_instruction;
	27532	return ira->codegen->invalid_inst_gen;
26678	27533	}
26679		return ir_const_void(ira, &instruction->base);
	27534	return ir_const_void(ira, &instruction->base.base);
26680	27535	}
26681	27536
26682		static IrInstruction ir_analyze_instruction_check_statement_is_void(IrAnalyze ira,
26683		IrInstructionCheckStatementIsVoid *instruction)
	27537	static IrInstGen ir_analyze_instruction_check_statement_is_void(IrAnalyze ira,
	27538	IrInstSrcCheckStatementIsVoid *instruction)
26684	27539	{
26685		IrInstruction *statement_value = instruction->statement_value->child;
	27540	IrInstGen *statement_value = instruction->statement_value->child;
26686	27541	ZigType *statement_type = statement_value->value->type;
26687	27542	if (type_is_invalid(statement_type))
26688		return ira->codegen->invalid_instruction;
	27543	return ira->codegen->invalid_inst_gen;
26689	27544
26690	27545	if (statement_type->id != ZigTypeIdVoid && statement_type->id != ZigTypeIdUnreachable) {
26691		ir_add_error(ira, &instruction->base, buf_sprintf("expression value is ignored"));
	27546	ir_add_error(ira, &instruction->base.base, buf_sprintf("expression value is ignored"));
26692	27547	}
26693	27548
26694		return ir_const_void(ira, &instruction->base);
	27549	return ir_const_void(ira, &instruction->base.base);
26695	27550	}
26696	27551
26697		static IrInstruction ir_analyze_instruction_panic(IrAnalyze ira, IrInstructionPanic *instruction) {
26698		IrInstruction *msg = instruction->msg->child;
	27552	static IrInstGen ir_analyze_instruction_panic(IrAnalyze ira, IrInstSrcPanic *instruction) {
	27553	IrInstGen *msg = instruction->msg->child;
26699	27554	if (type_is_invalid(msg->value->type))
26700	27555	return ir_unreach_error(ira);
26701	27556
26702		if (ir_should_inline(ira->new_irb.exec, instruction->base.scope)) {
26703		ir_add_error(ira, &instruction->base, buf_sprintf("encountered @panic at compile-time"));
	27557	if (ir_should_inline(ira->old_irb.exec, instruction->base.base.scope)) {
	27558	ir_add_error(ira, &instruction->base.base, buf_sprintf("encountered @panic at compile-time"));
26704	27559	return ir_unreach_error(ira);
26705	27560	}
26706	27561
26707	27562	ZigType *u8_ptr_type = get_pointer_to_type_extra(ira->codegen, ira->codegen->builtin_types.entry_u8,
26708	27563	true, false, PtrLenUnknown, 0, 0, 0, false);
26709	27564	ZigType *str_type = get_slice_type(ira->codegen, u8_ptr_type);
26710		IrInstruction *casted_msg = ir_implicit_cast(ira, msg, str_type);
	27565	IrInstGen *casted_msg = ir_implicit_cast(ira, msg, str_type);
26711	27566	if (type_is_invalid(casted_msg->value->type))
26712	27567	return ir_unreach_error(ira);
26713	27568
26714		IrInstruction *new_instruction = ir_build_panic(&ira->new_irb, instruction->base.scope,
26715		instruction->base.source_node, casted_msg);
	27569	IrInstGen *new_instruction = ir_build_panic_gen(ira, &instruction->base.base, casted_msg);
26716	27570	return ir_finish_anal(ira, new_instruction);
26717	27571	}
26718	27572
26719		static IrInstruction ir_align_cast(IrAnalyze ira, IrInstruction *target, uint32_t align_bytes, bool safety_check_on) {
	27573	static IrInstGen ir_align_cast(IrAnalyze ira, IrInstGen *target, uint32_t align_bytes, bool safety_check_on) {
26720	27574	Error err;
26721	27575
26722	27576	ZigType *target_type = target->value->type;
...	...	@@ -26728,7 +27582,7 @@ static IrInstruction ir_align_cast(IrAnalyze ira, IrInstruction *target, uint3
26728	27582	if (target_type->id == ZigTypeIdPointer) {
26729	27583	result_type = adjust_ptr_align(ira->codegen, target_type, align_bytes);
26730	27584	if ((err = resolve_ptr_align(ira, target_type, &old_align_bytes)))
26731		return ira->codegen->invalid_instruction;
	27585	return ira->codegen->invalid_inst_gen;
26732	27586	} else if (target_type->id == ZigTypeIdFn) {
26733	27587	FnTypeId fn_type_id = target_type->data.fn.fn_type_id;
26734	27588	old_align_bytes = fn_type_id.alignment;
...	...	@@ -26739,7 +27593,7 @@ static IrInstruction ir_align_cast(IrAnalyze ira, IrInstruction *target, uint3
26739	27593	{
26740	27594	ZigType *ptr_type = target_type->data.maybe.child_type;
26741	27595	if ((err = resolve_ptr_align(ira, ptr_type, &old_align_bytes)))
26742		return ira->codegen->invalid_instruction;
	27596	return ira->codegen->invalid_inst_gen;
26743	27597	ZigType *better_ptr_type = adjust_ptr_align(ira->codegen, ptr_type, align_bytes);
26744	27598
26745	27599	result_type = get_optional_type(ira->codegen, better_ptr_type);
...	...	@@ -26754,47 +27608,44 @@ static IrInstruction ir_align_cast(IrAnalyze ira, IrInstruction *target, uint3
26754	27608	} else if (is_slice(target_type)) {
26755	27609	ZigType *slice_ptr_type = target_type->data.structure.fields[slice_ptr_index]->type_entry;
26756	27610	if ((err = resolve_ptr_align(ira, slice_ptr_type, &old_align_bytes)))
26757		return ira->codegen->invalid_instruction;
	27611	return ira->codegen->invalid_inst_gen;
26758	27612	ZigType *result_ptr_type = adjust_ptr_align(ira->codegen, slice_ptr_type, align_bytes);
26759	27613	result_type = get_slice_type(ira->codegen, result_ptr_type);
26760	27614	} else {
26761		ir_add_error(ira, target,
	27615	ir_add_error(ira, &target->base,
26762	27616	buf_sprintf("expected pointer or slice, found '%s'", buf_ptr(&target_type->name)));
26763		return ira->codegen->invalid_instruction;
	27617	return ira->codegen->invalid_inst_gen;
26764	27618	}
26765	27619
26766	27620	if (instr_is_comptime(target)) {
26767	27621	ZigValue *val = ir_resolve_const(ira, target, UndefBad);
26768	27622	if (!val)
26769		return ira->codegen->invalid_instruction;
	27623	return ira->codegen->invalid_inst_gen;
26770	27624
26771	27625	if (val->data.x_ptr.special == ConstPtrSpecialHardCodedAddr &&
26772	27626	val->data.x_ptr.data.hard_coded_addr.addr % align_bytes != 0)
26773	27627	{
26774		ir_add_error(ira, target,
	27628	ir_add_error(ira, &target->base,
26775	27629	buf_sprintf("pointer address 0x%" ZIG_PRI_x64 " is not aligned to %" PRIu32 " bytes",
26776	27630	val->data.x_ptr.data.hard_coded_addr.addr, align_bytes));
26777		return ira->codegen->invalid_instruction;
	27631	return ira->codegen->invalid_inst_gen;
26778	27632	}
26779	27633
26780		IrInstruction *result = ir_const(ira, target, result_type);
	27634	IrInstGen *result = ir_const(ira, &target->base, result_type);
26781	27635	copy_const_val(result->value, val);
26782	27636	result->value->type = result_type;
26783	27637	return result;
26784	27638	}
26785	27639
26786		IrInstruction *result;
26787	27640	if (safety_check_on && align_bytes > old_align_bytes && align_bytes != 1) {
26788		result = ir_build_align_cast(&ira->new_irb, target->scope, target->source_node, nullptr, target);
	27641	return ir_build_align_cast_gen(ira, target->base.scope, target->base.source_node, target, result_type);
26789	27642	} else {
26790		result = ir_build_cast(&ira->new_irb, target->scope, target->source_node, result_type, target, CastOpNoop);
	27643	return ir_build_cast(ira, &target->base, result_type, target, CastOpNoop);
26791	27644	}
26792		result->value->type = result_type;
26793		return result;
26794	27645	}
26795	27646
26796		static IrInstruction ir_analyze_ptr_cast(IrAnalyze ira, IrInstruction source_instr, IrInstruction ptr,
26797		ZigType dest_type, IrInstruction dest_type_src, bool safety_check_on)
	27647	static IrInstGen ir_analyze_ptr_cast(IrAnalyze ira, IrInst* source_instr, IrInstGen *ptr,
	27648	ZigType dest_type, IrInst dest_type_src, bool safety_check_on)
26798	27649	{
26799	27650	Error err;
26800	27651
...	...	@@ -26810,44 +27661,44 @@ static IrInstruction ir_analyze_ptr_cast(IrAnalyze ira, IrInstruction *source_
26810	27661
26811	27662	ZigType *src_ptr_type = get_src_ptr_type(src_type);
26812	27663	if (src_ptr_type == nullptr) {
26813		ir_add_error(ira, ptr, buf_sprintf("expected pointer, found '%s'", buf_ptr(&src_type->name)));
26814		return ira->codegen->invalid_instruction;
	27664	ir_add_error(ira, &ptr->base, buf_sprintf("expected pointer, found '%s'", buf_ptr(&src_type->name)));
	27665	return ira->codegen->invalid_inst_gen;
26815	27666	}
26816	27667
26817	27668	ZigType *dest_ptr_type = get_src_ptr_type(dest_type);
26818	27669	if (dest_ptr_type == nullptr) {
26819	27670	ir_add_error(ira, dest_type_src,
26820	27671	buf_sprintf("expected pointer, found '%s'", buf_ptr(&dest_type->name)));
26821		return ira->codegen->invalid_instruction;
	27672	return ira->codegen->invalid_inst_gen;
26822	27673	}
26823	27674
26824	27675	if (get_ptr_const(src_type) && !get_ptr_const(dest_type)) {
26825	27676	ir_add_error(ira, source_instr, buf_sprintf("cast discards const qualifier"));
26826		return ira->codegen->invalid_instruction;
	27677	return ira->codegen->invalid_inst_gen;
26827	27678	}
26828	27679	uint32_t src_align_bytes;
26829	27680	if ((err = resolve_ptr_align(ira, src_type, &src_align_bytes)))
26830		return ira->codegen->invalid_instruction;
	27681	return ira->codegen->invalid_inst_gen;
26831	27682
26832	27683	uint32_t dest_align_bytes;
26833	27684	if ((err = resolve_ptr_align(ira, dest_type, &dest_align_bytes)))
26834		return ira->codegen->invalid_instruction;
	27685	return ira->codegen->invalid_inst_gen;
26835	27686
26836	27687	if ((err = type_resolve(ira->codegen, dest_type, ResolveStatusZeroBitsKnown)))
26837		return ira->codegen->invalid_instruction;
	27688	return ira->codegen->invalid_inst_gen;
26838	27689
26839	27690	if ((err = type_resolve(ira->codegen, src_type, ResolveStatusZeroBitsKnown)))
26840		return ira->codegen->invalid_instruction;
	27691	return ira->codegen->invalid_inst_gen;
26841	27692
26842	27693	if (type_has_bits(dest_type) && !type_has_bits(src_type)) {
26843	27694	ErrorMsg *msg = ir_add_error(ira, source_instr,
26844	27695	buf_sprintf("'%s' and '%s' do not have the same in-memory representation",
26845	27696	buf_ptr(&src_type->name), buf_ptr(&dest_type->name)));
26846		add_error_note(ira->codegen, msg, ptr->source_node,
	27697	add_error_note(ira->codegen, msg, ptr->base.source_node,
26847	27698	buf_sprintf("'%s' has no in-memory bits", buf_ptr(&src_type->name)));
26848	27699	add_error_note(ira->codegen, msg, dest_type_src->source_node,
26849	27700	buf_sprintf("'%s' has in-memory bits", buf_ptr(&dest_type->name)));
26850		return ira->codegen->invalid_instruction;
	27701	return ira->codegen->invalid_inst_gen;
26851	27702	}
26852	27703
26853	27704	if (instr_is_comptime(ptr)) {
...	...	@@ -26855,7 +27706,7 @@ static IrInstruction ir_analyze_ptr_cast(IrAnalyze ira, IrInstruction *source_
26855	27706	UndefAllowed is_undef_allowed = dest_allows_addr_zero ? UndefOk : UndefBad;
26856	27707	ZigValue *val = ir_resolve_const(ira, ptr, is_undef_allowed);
26857	27708	if (!val)
26858		return ira->codegen->invalid_instruction;
	27709	return ira->codegen->invalid_inst_gen;
26859	27710
26860	27711	if (value_is_comptime(val) && val->special != ConstValSpecialUndef) {
26861	27712	bool is_addr_zero = val->data.x_ptr.special == ConstPtrSpecialNull \|\|
...	...	@@ -26864,16 +27715,16 @@ static IrInstruction ir_analyze_ptr_cast(IrAnalyze ira, IrInstruction *source_
26864	27715	if (is_addr_zero && !dest_allows_addr_zero) {
26865	27716	ir_add_error(ira, source_instr,
26866	27717	buf_sprintf("null pointer casted to type '%s'", buf_ptr(&dest_type->name)));
26867		return ira->codegen->invalid_instruction;
	27718	return ira->codegen->invalid_inst_gen;
26868	27719	}
26869	27720	}
26870	27721
26871		IrInstruction *result;
	27722	IrInstGen *result;
26872	27723	if (ptr->value->data.x_ptr.mut == ConstPtrMutInfer) {
26873	27724	result = ir_build_ptr_cast_gen(ira, source_instr, dest_type, ptr, safety_check_on);
26874	27725
26875	27726	if ((err = type_resolve(ira->codegen, dest_type, ResolveStatusZeroBitsKnown)))
26876		return ira->codegen->invalid_instruction;
	27727	return ira->codegen->invalid_inst_gen;
26877	27728	} else {
26878	27729	result = ir_const(ira, source_instr, dest_type);
26879	27730	}
...	...	@@ -26891,40 +27742,40 @@ static IrInstruction ir_analyze_ptr_cast(IrAnalyze ira, IrInstruction *source_
26891	27742
26892	27743	if (dest_align_bytes > src_align_bytes) {
26893	27744	ErrorMsg *msg = ir_add_error(ira, source_instr, buf_sprintf("cast increases pointer alignment"));
26894		add_error_note(ira->codegen, msg, ptr->source_node,
	27745	add_error_note(ira->codegen, msg, ptr->base.source_node,
26895	27746	buf_sprintf("'%s' has alignment %" PRIu32, buf_ptr(&src_type->name), src_align_bytes));
26896	27747	add_error_note(ira->codegen, msg, dest_type_src->source_node,
26897	27748	buf_sprintf("'%s' has alignment %" PRIu32, buf_ptr(&dest_type->name), dest_align_bytes));
26898		return ira->codegen->invalid_instruction;
	27749	return ira->codegen->invalid_inst_gen;
26899	27750	}
26900	27751
26901		IrInstruction *casted_ptr = ir_build_ptr_cast_gen(ira, source_instr, dest_type, ptr, safety_check_on);
	27752	IrInstGen *casted_ptr = ir_build_ptr_cast_gen(ira, source_instr, dest_type, ptr, safety_check_on);
26902	27753
26903	27754	// Keep the bigger alignment, it can only help-
26904	27755	// unless the target is zero bits.
26905		IrInstruction *result;
	27756	IrInstGen *result;
26906	27757	if (src_align_bytes > dest_align_bytes && type_has_bits(dest_type)) {
26907	27758	result = ir_align_cast(ira, casted_ptr, src_align_bytes, false);
26908	27759	if (type_is_invalid(result->value->type))
26909		return ira->codegen->invalid_instruction;
	27760	return ira->codegen->invalid_inst_gen;
26910	27761	} else {
26911	27762	result = casted_ptr;
26912	27763	}
26913	27764	return result;
26914	27765	}
26915	27766
26916		static IrInstruction ir_analyze_instruction_ptr_cast(IrAnalyze ira, IrInstructionPtrCastSrc *instruction) {
26917		IrInstruction *dest_type_value = instruction->dest_type->child;
	27767	static IrInstGen ir_analyze_instruction_ptr_cast(IrAnalyze ira, IrInstSrcPtrCast *instruction) {
	27768	IrInstGen *dest_type_value = instruction->dest_type->child;
26918	27769	ZigType *dest_type = ir_resolve_type(ira, dest_type_value);
26919	27770	if (type_is_invalid(dest_type))
26920		return ira->codegen->invalid_instruction;
	27771	return ira->codegen->invalid_inst_gen;
26921	27772
26922		IrInstruction *ptr = instruction->ptr->child;
	27773	IrInstGen *ptr = instruction->ptr->child;
26923	27774	ZigType *src_type = ptr->value->type;
26924	27775	if (type_is_invalid(src_type))
26925		return ira->codegen->invalid_instruction;
	27776	return ira->codegen->invalid_inst_gen;
26926	27777
26927		return ir_analyze_ptr_cast(ira, &instruction->base, ptr, dest_type, dest_type_value,
	27778	return ir_analyze_ptr_cast(ira, &instruction->base.base, ptr, dest_type, &dest_type_value->base,
26928	27779	instruction->safety_check_on);
26929	27780	}
26930	27781
...	...	@@ -27255,7 +28106,7 @@ static Error buf_read_value_bytes(IrAnalyze ira, CodeGen codegen, AstNode *sou
27255	28106	zig_unreachable();
27256	28107	}
27257	28108
27258		static IrInstruction ir_analyze_bit_cast(IrAnalyze ira, IrInstruction source_instr, IrInstruction value,
	28109	static IrInstGen ir_analyze_bit_cast(IrAnalyze ira, IrInst* source_instr, IrInstGen *value,
27259	28110	ZigType *dest_type)
27260	28111	{
27261	28112	Error err;
...	...	@@ -27271,14 +28122,14 @@ static IrInstruction ir_analyze_bit_cast(IrAnalyze ira, IrInstruction *source_
27271	28122	buf_sprintf("cannot cast a value of type '%s'", buf_ptr(&dest_type->name)));
27272	28123	add_error_note(ira->codegen, msg, source_instr->source_node,
27273	28124	buf_sprintf("use @intToEnum for type coercion"));
27274		return ira->codegen->invalid_instruction;
	28125	return ira->codegen->invalid_inst_gen;
27275	28126	}
27276	28127
27277	28128	if ((err = type_resolve(ira->codegen, dest_type, ResolveStatusSizeKnown)))
27278		return ira->codegen->invalid_instruction;
	28129	return ira->codegen->invalid_inst_gen;
27279	28130
27280	28131	if ((err = type_resolve(ira->codegen, src_type, ResolveStatusSizeKnown)))
27281		return ira->codegen->invalid_instruction;
	28132	return ira->codegen->invalid_inst_gen;
27282	28133
27283	28134	uint64_t dest_size_bytes = type_size(ira->codegen, dest_type);
27284	28135	uint64_t src_size_bytes = type_size(ira->codegen, src_type);
...	...	@@ -27287,7 +28138,7 @@ static IrInstruction ir_analyze_bit_cast(IrAnalyze ira, IrInstruction *source_
27287	28138	buf_sprintf("destination type '%s' has size %" ZIG_PRI_u64 " but source type '%s' has size %" ZIG_PRI_u64,
27288	28139	buf_ptr(&dest_type->name), dest_size_bytes,
27289	28140	buf_ptr(&src_type->name), src_size_bytes));
27290		return ira->codegen->invalid_instruction;
	28141	return ira->codegen->invalid_inst_gen;
27291	28142	}
27292	28143
27293	28144	uint64_t dest_size_bits = type_size_bits(ira->codegen, dest_type);
...	...	@@ -27297,26 +28148,26 @@ static IrInstruction ir_analyze_bit_cast(IrAnalyze ira, IrInstruction *source_
27297	28148	buf_sprintf("destination type '%s' has %" ZIG_PRI_u64 " bits but source type '%s' has %" ZIG_PRI_u64 " bits",
27298	28149	buf_ptr(&dest_type->name), dest_size_bits,
27299	28150	buf_ptr(&src_type->name), src_size_bits));
27300		return ira->codegen->invalid_instruction;
	28151	return ira->codegen->invalid_inst_gen;
27301	28152	}
27302	28153
27303	28154	if (instr_is_comptime(value)) {
27304	28155	ZigValue *val = ir_resolve_const(ira, value, UndefBad);
27305	28156	if (!val)
27306		return ira->codegen->invalid_instruction;
	28157	return ira->codegen->invalid_inst_gen;
27307	28158
27308		IrInstruction *result = ir_const(ira, source_instr, dest_type);
	28159	IrInstGen *result = ir_const(ira, source_instr, dest_type);
27309	28160	uint8_t *buf = allocate_nonzero<uint8_t>(src_size_bytes);
27310	28161	buf_write_value_bytes(ira->codegen, buf, val);
27311	28162	if ((err = buf_read_value_bytes(ira, ira->codegen, source_instr->source_node, buf, result->value)))
27312		return ira->codegen->invalid_instruction;
	28163	return ira->codegen->invalid_inst_gen;
27313	28164	return result;
27314	28165	}
27315	28166
27316	28167	return ir_build_bit_cast_gen(ira, source_instr, value, dest_type);
27317	28168	}
27318	28169
27319		static IrInstruction ir_analyze_int_to_ptr(IrAnalyze ira, IrInstruction source_instr, IrInstruction target,
	28170	static IrInstGen ir_analyze_int_to_ptr(IrAnalyze ira, IrInst* source_instr, IrInstGen *target,
27320	28171	ZigType *ptr_type)
27321	28172	{
27322	28173	Error err;
...	...	@@ -27324,136 +28175,128 @@ static IrInstruction ir_analyze_int_to_ptr(IrAnalyze ira, IrInstruction *sourc
27324	28175	ir_assert(get_src_ptr_type(ptr_type) != nullptr, source_instr);
27325	28176	ir_assert(type_has_bits(ptr_type), source_instr);
27326	28177
27327		IrInstruction *casted_int = ir_implicit_cast(ira, target, ira->codegen->builtin_types.entry_usize);
	28178	IrInstGen *casted_int = ir_implicit_cast(ira, target, ira->codegen->builtin_types.entry_usize);
27328	28179	if (type_is_invalid(casted_int->value->type))
27329		return ira->codegen->invalid_instruction;
	28180	return ira->codegen->invalid_inst_gen;
27330	28181
27331	28182	if (instr_is_comptime(casted_int)) {
27332	28183	ZigValue *val = ir_resolve_const(ira, casted_int, UndefBad);
27333	28184	if (!val)
27334		return ira->codegen->invalid_instruction;
	28185	return ira->codegen->invalid_inst_gen;
27335	28186
27336	28187	uint64_t addr = bigint_as_u64(&val->data.x_bigint);
27337	28188	if (!ptr_allows_addr_zero(ptr_type) && addr == 0) {
27338	28189	ir_add_error(ira, source_instr,
27339	28190	buf_sprintf("pointer type '%s' does not allow address zero", buf_ptr(&ptr_type->name)));
27340		return ira->codegen->invalid_instruction;
	28191	return ira->codegen->invalid_inst_gen;
27341	28192	}
27342	28193
27343	28194	uint32_t align_bytes;
27344	28195	if ((err = resolve_ptr_align(ira, ptr_type, &align_bytes)))
27345		return ira->codegen->invalid_instruction;
	28196	return ira->codegen->invalid_inst_gen;
27346	28197
27347	28198	if (addr != 0 && addr % align_bytes != 0) {
27348	28199	ir_add_error(ira, source_instr,
27349	28200	buf_sprintf("pointer type '%s' requires aligned address",
27350	28201	buf_ptr(&ptr_type->name)));
27351		return ira->codegen->invalid_instruction;
	28202	return ira->codegen->invalid_inst_gen;
27352	28203	}
27353	28204
27354		IrInstruction *result = ir_const(ira, source_instr, ptr_type);
	28205	IrInstGen *result = ir_const(ira, source_instr, ptr_type);
27355	28206	result->value->data.x_ptr.special = ConstPtrSpecialHardCodedAddr;
27356	28207	result->value->data.x_ptr.mut = ConstPtrMutRuntimeVar;
27357	28208	result->value->data.x_ptr.data.hard_coded_addr.addr = addr;
27358	28209	return result;
27359	28210	}
27360	28211
27361		IrInstruction *result = ir_build_int_to_ptr(&ira->new_irb, source_instr->scope,
27362		source_instr->source_node, nullptr, casted_int);
27363		result->value->type = ptr_type;
27364		return result;
	28212	return ir_build_int_to_ptr_gen(ira, source_instr->scope, source_instr->source_node, casted_int, ptr_type);
27365	28213	}
27366	28214
27367		static IrInstruction ir_analyze_instruction_int_to_ptr(IrAnalyze ira, IrInstructionIntToPtr *instruction) {
	28215	static IrInstGen ir_analyze_instruction_int_to_ptr(IrAnalyze ira, IrInstSrcIntToPtr *instruction) {
27368	28216	Error err;
27369		IrInstruction *dest_type_value = instruction->dest_type->child;
	28217	IrInstGen *dest_type_value = instruction->dest_type->child;
27370	28218	ZigType *dest_type = ir_resolve_type(ira, dest_type_value);
27371	28219	if (type_is_invalid(dest_type))
27372		return ira->codegen->invalid_instruction;
	28220	return ira->codegen->invalid_inst_gen;
27373	28221
27374	28222	// We explicitly check for the size, so we can use get_src_ptr_type
27375	28223	if (get_src_ptr_type(dest_type) == nullptr) {
27376		ir_add_error(ira, dest_type_value, buf_sprintf("expected pointer, found '%s'", buf_ptr(&dest_type->name)));
27377		return ira->codegen->invalid_instruction;
	28224	ir_add_error(ira, &dest_type_value->base, buf_sprintf("expected pointer, found '%s'", buf_ptr(&dest_type->name)));
	28225	return ira->codegen->invalid_inst_gen;
27378	28226	}
27379	28227
27380	28228	bool has_bits;
27381	28229	if ((err = type_has_bits2(ira->codegen, dest_type, &has_bits)))
27382		return ira->codegen->invalid_instruction;
	28230	return ira->codegen->invalid_inst_gen;
27383	28231
27384	28232	if (!has_bits) {
27385		ir_add_error(ira, dest_type_value,
	28233	ir_add_error(ira, &dest_type_value->base,
27386	28234	buf_sprintf("type '%s' has 0 bits and cannot store information", buf_ptr(&dest_type->name)));
27387		return ira->codegen->invalid_instruction;
	28235	return ira->codegen->invalid_inst_gen;
27388	28236	}
27389	28237
27390		IrInstruction *target = instruction->target->child;
	28238	IrInstGen *target = instruction->target->child;
27391	28239	if (type_is_invalid(target->value->type))
27392		return ira->codegen->invalid_instruction;
	28240	return ira->codegen->invalid_inst_gen;
27393	28241
27394		return ir_analyze_int_to_ptr(ira, &instruction->base, target, dest_type);
	28242	return ir_analyze_int_to_ptr(ira, &instruction->base.base, target, dest_type);
27395	28243	}
27396	28244
27397		static IrInstruction ir_analyze_instruction_decl_ref(IrAnalyze ira,
27398		IrInstructionDeclRef *instruction)
27399		{
27400		IrInstruction *ref_instruction = ir_analyze_decl_ref(ira, &instruction->base, instruction->tld);
	28245	static IrInstGen ir_analyze_instruction_decl_ref(IrAnalyze ira, IrInstSrcDeclRef *instruction) {
	28246	IrInstGen *ref_instruction = ir_analyze_decl_ref(ira, &instruction->base.base, instruction->tld);
27401	28247	if (type_is_invalid(ref_instruction->value->type)) {
27402		return ira->codegen->invalid_instruction;
	28248	return ira->codegen->invalid_inst_gen;
27403	28249	}
27404	28250
27405	28251	if (instruction->lval == LValPtr) {
27406	28252	return ref_instruction;
27407	28253	} else {
27408		return ir_get_deref(ira, &instruction->base, ref_instruction, nullptr);
	28254	return ir_get_deref(ira, &instruction->base.base, ref_instruction, nullptr);
27409	28255	}
27410	28256	}
27411	28257
27412		static IrInstruction ir_analyze_instruction_ptr_to_int(IrAnalyze ira, IrInstructionPtrToInt *instruction) {
	28258	static IrInstGen ir_analyze_instruction_ptr_to_int(IrAnalyze ira, IrInstSrcPtrToInt *instruction) {
27413	28259	Error err;
27414		IrInstruction *target = instruction->target->child;
	28260	IrInstGen *target = instruction->target->child;
27415	28261	if (type_is_invalid(target->value->type))
27416		return ira->codegen->invalid_instruction;
	28262	return ira->codegen->invalid_inst_gen;
27417	28263
27418	28264	ZigType *usize = ira->codegen->builtin_types.entry_usize;
27419	28265
27420	28266	// We check size explicitly so we can use get_src_ptr_type here.
27421	28267	if (get_src_ptr_type(target->value->type) == nullptr) {
27422		ir_add_error(ira, target,
	28268	ir_add_error(ira, &target->base,
27423	28269	buf_sprintf("expected pointer, found '%s'", buf_ptr(&target->value->type->name)));
27424		return ira->codegen->invalid_instruction;
	28270	return ira->codegen->invalid_inst_gen;
27425	28271	}
27426	28272
27427	28273	bool has_bits;
27428	28274	if ((err = type_has_bits2(ira->codegen, target->value->type, &has_bits)))
27429		return ira->codegen->invalid_instruction;
	28275	return ira->codegen->invalid_inst_gen;
27430	28276
27431	28277	if (!has_bits) {
27432		ir_add_error(ira, target,
	28278	ir_add_error(ira, &target->base,
27433	28279	buf_sprintf("pointer to size 0 type has no address"));
27434		return ira->codegen->invalid_instruction;
	28280	return ira->codegen->invalid_inst_gen;
27435	28281	}
27436	28282
27437	28283	if (instr_is_comptime(target)) {
27438	28284	ZigValue *val = ir_resolve_const(ira, target, UndefBad);
27439	28285	if (!val)
27440		return ira->codegen->invalid_instruction;
	28286	return ira->codegen->invalid_inst_gen;
27441	28287	if (val->type->id == ZigTypeIdPointer && val->data.x_ptr.special == ConstPtrSpecialHardCodedAddr) {
27442		IrInstruction *result = ir_const(ira, &instruction->base, usize);
	28288	IrInstGen *result = ir_const(ira, &instruction->base.base, usize);
27443	28289	bigint_init_unsigned(&result->value->data.x_bigint, val->data.x_ptr.data.hard_coded_addr.addr);
27444	28290	result->value->type = usize;
27445	28291	return result;
27446	28292	}
27447	28293	}
27448	28294
27449		IrInstruction *result = ir_build_ptr_to_int(&ira->new_irb, instruction->base.scope,
27450		instruction->base.source_node, target);
27451		result->value->type = usize;
27452		return result;
	28295	return ir_build_ptr_to_int_gen(ira, &instruction->base.base, target);
27453	28296	}
27454	28297
27455		static IrInstruction ir_analyze_instruction_ptr_type(IrAnalyze ira, IrInstructionPtrType *instruction) {
27456		IrInstruction *result = ir_const(ira, &instruction->base, ira->codegen->builtin_types.entry_type);
	28298	static IrInstGen ir_analyze_instruction_ptr_type(IrAnalyze ira, IrInstSrcPtrType *instruction) {
	28299	IrInstGen *result = ir_const(ira, &instruction->base.base, ira->codegen->builtin_types.entry_type);
27457	28300	result->value->special = ConstValSpecialLazy;
27458	28301
27459	28302	LazyValuePtrType *lazy_ptr_type = allocate<LazyValuePtrType>(1, "LazyValuePtrType");
...	...	@@ -27464,17 +28307,17 @@ static IrInstruction ir_analyze_instruction_ptr_type(IrAnalyze ira, IrInstruct
27464	28307	if (instruction->sentinel != nullptr) {
27465	28308	lazy_ptr_type->sentinel = instruction->sentinel->child;
27466	28309	if (ir_resolve_const(ira, lazy_ptr_type->sentinel, LazyOk) == nullptr)
27467		return ira->codegen->invalid_instruction;
	28310	return ira->codegen->invalid_inst_gen;
27468	28311	}
27469	28312
27470	28313	lazy_ptr_type->elem_type = instruction->child_type->child;
27471	28314	if (ir_resolve_type_lazy(ira, lazy_ptr_type->elem_type) == nullptr)
27472		return ira->codegen->invalid_instruction;
	28315	return ira->codegen->invalid_inst_gen;
27473	28316
27474	28317	if (instruction->align_value != nullptr) {
27475	28318	lazy_ptr_type->align_inst = instruction->align_value->child;
27476	28319	if (ir_resolve_const(ira, lazy_ptr_type->align_inst, LazyOk) == nullptr)
27477		return ira->codegen->invalid_instruction;
	28320	return ira->codegen->invalid_inst_gen;
27478	28321	}
27479	28322
27480	28323	lazy_ptr_type->ptr_len = instruction->ptr_len;
...	...	@@ -27487,10 +28330,10 @@ static IrInstruction ir_analyze_instruction_ptr_type(IrAnalyze ira, IrInstruct
27487	28330	return result;
27488	28331	}
27489	28332
27490		static IrInstruction ir_analyze_instruction_align_cast(IrAnalyze ira, IrInstructionAlignCast *instruction) {
27491		IrInstruction *target = instruction->target->child;
	28333	static IrInstGen ir_analyze_instruction_align_cast(IrAnalyze ira, IrInstSrcAlignCast *instruction) {
	28334	IrInstGen *target = instruction->target->child;
27492	28335	if (type_is_invalid(target->value->type))
27493		return ira->codegen->invalid_instruction;
	28336	return ira->codegen->invalid_inst_gen;
27494	28337
27495	28338	ZigType *elem_type = nullptr;
27496	28339	if (is_slice(target->value->type)) {
...	...	@@ -27501,192 +28344,192 @@ static IrInstruction ir_analyze_instruction_align_cast(IrAnalyze ira, IrInstru
27501	28344	}
27502	28345
27503	28346	uint32_t align_bytes;
27504		IrInstruction *align_bytes_inst = instruction->align_bytes->child;
	28347	IrInstGen *align_bytes_inst = instruction->align_bytes->child;
27505	28348	if (!ir_resolve_align(ira, align_bytes_inst, elem_type, &align_bytes))
27506		return ira->codegen->invalid_instruction;
	28349	return ira->codegen->invalid_inst_gen;
27507	28350
27508		IrInstruction *result = ir_align_cast(ira, target, align_bytes, true);
	28351	IrInstGen *result = ir_align_cast(ira, target, align_bytes, true);
27509	28352	if (type_is_invalid(result->value->type))
27510		return ira->codegen->invalid_instruction;
	28353	return ira->codegen->invalid_inst_gen;
27511	28354
27512	28355	return result;
27513	28356	}
27514	28357
27515		static IrInstruction ir_analyze_instruction_opaque_type(IrAnalyze ira, IrInstructionOpaqueType *instruction) {
	28358	static IrInstGen ir_analyze_instruction_opaque_type(IrAnalyze ira, IrInstSrcOpaqueType *instruction) {
27516	28359	Buf *bare_name = buf_alloc();
27517		Buf *full_name = get_anon_type_name(ira->codegen, ira->new_irb.exec, "opaque",
27518		instruction->base.scope, instruction->base.source_node, bare_name);
27519		ZigType *result_type = get_opaque_type(ira->codegen, instruction->base.scope, instruction->base.source_node,
27520		buf_ptr(full_name), bare_name);
27521		return ir_const_type(ira, &instruction->base, result_type);
	28360	Buf *full_name = get_anon_type_name(ira->codegen, ira->old_irb.exec, "opaque",
	28361	instruction->base.base.scope, instruction->base.base.source_node, bare_name);
	28362	ZigType *result_type = get_opaque_type(ira->codegen, instruction->base.base.scope,
	28363	instruction->base.base.source_node, buf_ptr(full_name), bare_name);
	28364	return ir_const_type(ira, &instruction->base.base, result_type);
27522	28365	}
27523	28366
27524		static IrInstruction ir_analyze_instruction_set_align_stack(IrAnalyze ira, IrInstructionSetAlignStack *instruction) {
	28367	static IrInstGen ir_analyze_instruction_set_align_stack(IrAnalyze ira, IrInstSrcSetAlignStack *instruction) {
27525	28368	uint32_t align_bytes;
27526		IrInstruction *align_bytes_inst = instruction->align_bytes->child;
	28369	IrInstGen *align_bytes_inst = instruction->align_bytes->child;
27527	28370	if (!ir_resolve_align(ira, align_bytes_inst, nullptr, &align_bytes))
27528		return ira->codegen->invalid_instruction;
	28371	return ira->codegen->invalid_inst_gen;
27529	28372
27530	28373	if (align_bytes > 256) {
27531		ir_add_error(ira, &instruction->base, buf_sprintf("attempt to @setAlignStack(%" PRIu32 "); maximum is 256", align_bytes));
27532		return ira->codegen->invalid_instruction;
	28374	ir_add_error(ira, &instruction->base.base, buf_sprintf("attempt to @setAlignStack(%" PRIu32 "); maximum is 256", align_bytes));
	28375	return ira->codegen->invalid_inst_gen;
27533	28376	}
27534	28377
27535		ZigFn *fn_entry = exec_fn_entry(ira->new_irb.exec);
	28378	ZigFn *fn_entry = ira->new_irb.exec->fn_entry;
27536	28379	if (fn_entry == nullptr) {
27537		ir_add_error(ira, &instruction->base, buf_sprintf("@setAlignStack outside function"));
27538		return ira->codegen->invalid_instruction;
	28380	ir_add_error(ira, &instruction->base.base, buf_sprintf("@setAlignStack outside function"));
	28381	return ira->codegen->invalid_inst_gen;
27539	28382	}
27540	28383	if (fn_entry->type_entry->data.fn.fn_type_id.cc == CallingConventionNaked) {
27541		ir_add_error(ira, &instruction->base, buf_sprintf("@setAlignStack in naked function"));
27542		return ira->codegen->invalid_instruction;
	28384	ir_add_error(ira, &instruction->base.base, buf_sprintf("@setAlignStack in naked function"));
	28385	return ira->codegen->invalid_inst_gen;
27543	28386	}
27544	28387
27545	28388	if (fn_entry->fn_inline == FnInlineAlways) {
27546		ir_add_error(ira, &instruction->base, buf_sprintf("@setAlignStack in inline function"));
27547		return ira->codegen->invalid_instruction;
	28389	ir_add_error(ira, &instruction->base.base, buf_sprintf("@setAlignStack in inline function"));
	28390	return ira->codegen->invalid_inst_gen;
27548	28391	}
27549	28392
27550	28393	if (fn_entry->set_alignstack_node != nullptr) {
27551		ErrorMsg *msg = ir_add_error_node(ira, instruction->base.source_node,
	28394	ErrorMsg *msg = ir_add_error(ira, &instruction->base.base,
27552	28395	buf_sprintf("alignstack set twice"));
27553	28396	add_error_note(ira->codegen, msg, fn_entry->set_alignstack_node, buf_sprintf("first set here"));
27554		return ira->codegen->invalid_instruction;
	28397	return ira->codegen->invalid_inst_gen;
27555	28398	}
27556	28399
27557		fn_entry->set_alignstack_node = instruction->base.source_node;
	28400	fn_entry->set_alignstack_node = instruction->base.base.source_node;
27558	28401	fn_entry->alignstack_value = align_bytes;
27559	28402
27560		return ir_const_void(ira, &instruction->base);
	28403	return ir_const_void(ira, &instruction->base.base);
27561	28404	}
27562	28405
27563		static IrInstruction ir_analyze_instruction_arg_type(IrAnalyze ira, IrInstructionArgType *instruction) {
27564		IrInstruction *fn_type_inst = instruction->fn_type->child;
	28406	static IrInstGen ir_analyze_instruction_arg_type(IrAnalyze ira, IrInstSrcArgType *instruction) {
	28407	IrInstGen *fn_type_inst = instruction->fn_type->child;
27565	28408	ZigType *fn_type = ir_resolve_type(ira, fn_type_inst);
27566	28409	if (type_is_invalid(fn_type))
27567		return ira->codegen->invalid_instruction;
	28410	return ira->codegen->invalid_inst_gen;
27568	28411
27569		IrInstruction *arg_index_inst = instruction->arg_index->child;
	28412	IrInstGen *arg_index_inst = instruction->arg_index->child;
27570	28413	uint64_t arg_index;
27571	28414	if (!ir_resolve_usize(ira, arg_index_inst, &arg_index))
27572		return ira->codegen->invalid_instruction;
	28415	return ira->codegen->invalid_inst_gen;
27573	28416
27574	28417	if (fn_type->id == ZigTypeIdBoundFn) {
27575	28418	fn_type = fn_type->data.bound_fn.fn_type;
27576	28419	arg_index += 1;
27577	28420	}
27578	28421	if (fn_type->id != ZigTypeIdFn) {
27579		ir_add_error(ira, fn_type_inst, buf_sprintf("expected function, found '%s'", buf_ptr(&fn_type->name)));
27580		return ira->codegen->invalid_instruction;
	28422	ir_add_error(ira, &fn_type_inst->base, buf_sprintf("expected function, found '%s'", buf_ptr(&fn_type->name)));
	28423	return ira->codegen->invalid_inst_gen;
27581	28424	}
27582	28425
27583	28426	FnTypeId *fn_type_id = &fn_type->data.fn.fn_type_id;
27584	28427	if (arg_index >= fn_type_id->param_count) {
27585	28428	if (instruction->allow_var) {
27586	28429	// TODO remove this with var args
27587		return ir_const_type(ira, &instruction->base, ira->codegen->builtin_types.entry_var);
	28430	return ir_const_type(ira, &instruction->base.base, ira->codegen->builtin_types.entry_var);
27588	28431	}
27589		ir_add_error(ira, arg_index_inst,
	28432	ir_add_error(ira, &arg_index_inst->base,
27590	28433	buf_sprintf("arg index %" ZIG_PRI_u64 " out of bounds; '%s' has %" ZIG_PRI_usize " arguments",
27591	28434	arg_index, buf_ptr(&fn_type->name), fn_type_id->param_count));
27592		return ira->codegen->invalid_instruction;
	28435	return ira->codegen->invalid_inst_gen;
27593	28436	}
27594	28437
27595	28438	ZigType *result_type = fn_type_id->param_info[arg_index].type;
27596	28439	if (result_type == nullptr) {
27597	28440	// Args are only unresolved if our function is generic.
27598		ir_assert(fn_type->data.fn.is_generic, &instruction->base);
	28441	ir_assert(fn_type->data.fn.is_generic, &instruction->base.base);
27599	28442
27600	28443	if (instruction->allow_var) {
27601		return ir_const_type(ira, &instruction->base, ira->codegen->builtin_types.entry_var);
	28444	return ir_const_type(ira, &instruction->base.base, ira->codegen->builtin_types.entry_var);
27602	28445	} else {
27603		ir_add_error(ira, arg_index_inst,
	28446	ir_add_error(ira, &arg_index_inst->base,
27604	28447	buf_sprintf("@ArgType could not resolve the type of arg %" ZIG_PRI_u64 " because '%s' is generic",
27605	28448	arg_index, buf_ptr(&fn_type->name)));
27606		return ira->codegen->invalid_instruction;
	28449	return ira->codegen->invalid_inst_gen;
27607	28450	}
27608	28451	}
27609		return ir_const_type(ira, &instruction->base, result_type);
	28452	return ir_const_type(ira, &instruction->base.base, result_type);
27610	28453	}
27611	28454
27612		static IrInstruction ir_analyze_instruction_tag_type(IrAnalyze ira, IrInstructionTagType *instruction) {
	28455	static IrInstGen ir_analyze_instruction_tag_type(IrAnalyze ira, IrInstSrcTagType *instruction) {
27613	28456	Error err;
27614		IrInstruction *target_inst = instruction->target->child;
	28457	IrInstGen *target_inst = instruction->target->child;
27615	28458	ZigType *enum_type = ir_resolve_type(ira, target_inst);
27616	28459	if (type_is_invalid(enum_type))
27617		return ira->codegen->invalid_instruction;
	28460	return ira->codegen->invalid_inst_gen;
27618	28461
27619	28462	if (enum_type->id == ZigTypeIdEnum) {
27620	28463	if ((err = type_resolve(ira->codegen, enum_type, ResolveStatusSizeKnown)))
27621		return ira->codegen->invalid_instruction;
	28464	return ira->codegen->invalid_inst_gen;
27622	28465
27623		return ir_const_type(ira, &instruction->base, enum_type->data.enumeration.tag_int_type);
	28466	return ir_const_type(ira, &instruction->base.base, enum_type->data.enumeration.tag_int_type);
27624	28467	} else if (enum_type->id == ZigTypeIdUnion) {
27625		ZigType *tag_type = ir_resolve_union_tag_type(ira, instruction->target, enum_type);
	28468	ZigType *tag_type = ir_resolve_union_tag_type(ira, instruction->target->base.source_node, enum_type);
27626	28469	if (type_is_invalid(tag_type))
27627		return ira->codegen->invalid_instruction;
27628		return ir_const_type(ira, &instruction->base, tag_type);
	28470	return ira->codegen->invalid_inst_gen;
	28471	return ir_const_type(ira, &instruction->base.base, tag_type);
27629	28472	} else {
27630		ir_add_error(ira, target_inst, buf_sprintf("expected enum or union, found '%s'",
	28473	ir_add_error(ira, &target_inst->base, buf_sprintf("expected enum or union, found '%s'",
27631	28474	buf_ptr(&enum_type->name)));
27632		return ira->codegen->invalid_instruction;
	28475	return ira->codegen->invalid_inst_gen;
27633	28476	}
27634	28477	}
27635	28478
27636		static ZigType ir_resolve_atomic_operand_type(IrAnalyze ira, IrInstruction *op) {
	28479	static ZigType ir_resolve_atomic_operand_type(IrAnalyze ira, IrInstGen *op) {
27637	28480	ZigType *operand_type = ir_resolve_type(ira, op);
27638	28481	if (type_is_invalid(operand_type))
27639	28482	return ira->codegen->builtin_types.entry_invalid;
27640	28483
27641	28484	if (operand_type->id == ZigTypeIdInt) {
27642	28485	if (operand_type->data.integral.bit_count < 8) {
27643		ir_add_error(ira, op,
	28486	ir_add_error(ira, &op->base,
27644	28487	buf_sprintf("expected integer type 8 bits or larger, found %" PRIu32 "-bit integer type",
27645	28488	operand_type->data.integral.bit_count));
27646	28489	return ira->codegen->builtin_types.entry_invalid;
27647	28490	}
27648	28491	uint32_t max_atomic_bits = target_arch_largest_atomic_bits(ira->codegen->zig_target->arch);
27649	28492	if (operand_type->data.integral.bit_count > max_atomic_bits) {
27650		ir_add_error(ira, op,
	28493	ir_add_error(ira, &op->base,
27651	28494	buf_sprintf("expected %" PRIu32 "-bit integer type or smaller, found %" PRIu32 "-bit integer type",
27652	28495	max_atomic_bits, operand_type->data.integral.bit_count));
27653	28496	return ira->codegen->builtin_types.entry_invalid;
27654	28497	}
27655	28498	if (!is_power_of_2(operand_type->data.integral.bit_count)) {
27656		ir_add_error(ira, op,
	28499	ir_add_error(ira, &op->base,
27657	28500	buf_sprintf("%" PRIu32 "-bit integer type is not a power of 2", operand_type->data.integral.bit_count));
27658	28501	return ira->codegen->builtin_types.entry_invalid;
27659	28502	}
27660	28503	} else if (operand_type->id == ZigTypeIdEnum) {
27661	28504	ZigType *int_type = operand_type->data.enumeration.tag_int_type;
27662	28505	if (int_type->data.integral.bit_count < 8) {
27663		ir_add_error(ira, op,
	28506	ir_add_error(ira, &op->base,
27664	28507	buf_sprintf("expected enum tag type 8 bits or larger, found %" PRIu32 "-bit tag type",
27665	28508	int_type->data.integral.bit_count));
27666	28509	return ira->codegen->builtin_types.entry_invalid;
27667	28510	}
27668	28511	uint32_t max_atomic_bits = target_arch_largest_atomic_bits(ira->codegen->zig_target->arch);
27669	28512	if (int_type->data.integral.bit_count > max_atomic_bits) {
27670		ir_add_error(ira, op,
	28513	ir_add_error(ira, &op->base,
27671	28514	buf_sprintf("expected %" PRIu32 "-bit enum tag type or smaller, found %" PRIu32 "-bit tag type",
27672	28515	max_atomic_bits, int_type->data.integral.bit_count));
27673	28516	return ira->codegen->builtin_types.entry_invalid;
27674	28517	}
27675	28518	if (!is_power_of_2(int_type->data.integral.bit_count)) {
27676		ir_add_error(ira, op,
	28519	ir_add_error(ira, &op->base,
27677	28520	buf_sprintf("%" PRIu32 "-bit enum tag type is not a power of 2", int_type->data.integral.bit_count));
27678	28521	return ira->codegen->builtin_types.entry_invalid;
27679	28522	}
27680	28523	} else if (operand_type->id == ZigTypeIdFloat) {
27681	28524	uint32_t max_atomic_bits = target_arch_largest_atomic_bits(ira->codegen->zig_target->arch);
27682	28525	if (operand_type->data.floating.bit_count > max_atomic_bits) {
27683		ir_add_error(ira, op,
	28526	ir_add_error(ira, &op->base,
27684	28527	buf_sprintf("expected %" PRIu32 "-bit float or smaller, found %" PRIu32 "-bit float",
27685	28528	max_atomic_bits, (uint32_t) operand_type->data.floating.bit_count));
27686	28529	return ira->codegen->builtin_types.entry_invalid;
27687	28530	}
27688	28531	} else if (get_codegen_ptr_type(operand_type) == nullptr) {
27689		ir_add_error(ira, op,
	28532	ir_add_error(ira, &op->base,
27690	28533	buf_sprintf("expected integer, float, enum or pointer type, found '%s'", buf_ptr(&operand_type->name)));
27691	28534	return ira->codegen->builtin_types.entry_invalid;
27692	28535	}
...	...	@@ -27694,172 +28537,146 @@ static ZigType ir_resolve_atomic_operand_type(IrAnalyze ira, IrInstruction *op
27694	28537	return operand_type;
27695	28538	}
27696	28539
27697		static IrInstruction ir_analyze_instruction_atomic_rmw(IrAnalyze ira, IrInstructionAtomicRmw *instruction) {
	28540	static IrInstGen ir_analyze_instruction_atomic_rmw(IrAnalyze ira, IrInstSrcAtomicRmw *instruction) {
27698	28541	ZigType *operand_type = ir_resolve_atomic_operand_type(ira, instruction->operand_type->child);
27699	28542	if (type_is_invalid(operand_type))
27700		return ira->codegen->invalid_instruction;
	28543	return ira->codegen->invalid_inst_gen;
27701	28544
27702		IrInstruction *ptr_inst = instruction->ptr->child;
	28545	IrInstGen *ptr_inst = instruction->ptr->child;
27703	28546	if (type_is_invalid(ptr_inst->value->type))
27704		return ira->codegen->invalid_instruction;
	28547	return ira->codegen->invalid_inst_gen;
27705	28548
27706	28549	// TODO let this be volatile
27707	28550	ZigType *ptr_type = get_pointer_to_type(ira->codegen, operand_type, false);
27708		IrInstruction *casted_ptr = ir_implicit_cast(ira, ptr_inst, ptr_type);
	28551	IrInstGen *casted_ptr = ir_implicit_cast(ira, ptr_inst, ptr_type);
27709	28552	if (type_is_invalid(casted_ptr->value->type))
27710		return ira->codegen->invalid_instruction;
	28553	return ira->codegen->invalid_inst_gen;
27711	28554
27712	28555	AtomicRmwOp op;
27713		if (instruction->op == nullptr) {
27714		op = instruction->resolved_op;
27715		} else {
27716		if (!ir_resolve_atomic_rmw_op(ira, instruction->op->child, &op)) {
27717		return ira->codegen->invalid_instruction;
27718		}
	28556	if (!ir_resolve_atomic_rmw_op(ira, instruction->op->child, &op)) {
	28557	return ira->codegen->invalid_inst_gen;
27719	28558	}
27720	28559
27721	28560	if (operand_type->id == ZigTypeIdEnum && op != AtomicRmwOp_xchg) {
27722		ir_add_error(ira, instruction->op,
	28561	ir_add_error(ira, &instruction->op->base,
27723	28562	buf_sprintf("@atomicRmw on enum only works with .Xchg"));
27724		return ira->codegen->invalid_instruction;
	28563	return ira->codegen->invalid_inst_gen;
27725	28564	} else if (operand_type->id == ZigTypeIdFloat && op > AtomicRmwOp_sub) {
27726		ir_add_error(ira, instruction->op,
	28565	ir_add_error(ira, &instruction->op->base,
27727	28566	buf_sprintf("@atomicRmw with float only works with .Xchg, .Add and .Sub"));
27728		return ira->codegen->invalid_instruction;
	28567	return ira->codegen->invalid_inst_gen;
27729	28568	}
27730	28569
27731		IrInstruction *operand = instruction->operand->child;
	28570	IrInstGen *operand = instruction->operand->child;
27732	28571	if (type_is_invalid(operand->value->type))
27733		return ira->codegen->invalid_instruction;
	28572	return ira->codegen->invalid_inst_gen;
27734	28573
27735		IrInstruction *casted_operand = ir_implicit_cast(ira, operand, operand_type);
	28574	IrInstGen *casted_operand = ir_implicit_cast(ira, operand, operand_type);
27736	28575	if (type_is_invalid(casted_operand->value->type))
27737		return ira->codegen->invalid_instruction;
	28576	return ira->codegen->invalid_inst_gen;
27738	28577
27739	28578	AtomicOrder ordering;
27740		if (instruction->ordering == nullptr) {
27741		ordering = instruction->resolved_ordering;
27742		} else {
27743		if (!ir_resolve_atomic_order(ira, instruction->ordering->child, &ordering))
27744		return ira->codegen->invalid_instruction;
27745		if (ordering == AtomicOrderUnordered) {
27746		ir_add_error(ira, instruction->ordering,
27747		buf_sprintf("@atomicRmw atomic ordering must not be Unordered"));
27748		return ira->codegen->invalid_instruction;
27749		}
	28579	if (!ir_resolve_atomic_order(ira, instruction->ordering->child, &ordering))
	28580	return ira->codegen->invalid_inst_gen;
	28581	if (ordering == AtomicOrderUnordered) {
	28582	ir_add_error(ira, &instruction->ordering->base,
	28583	buf_sprintf("@atomicRmw atomic ordering must not be Unordered"));
	28584	return ira->codegen->invalid_inst_gen;
27750	28585	}
27751	28586
27752	28587	if (instr_is_comptime(casted_operand) && instr_is_comptime(casted_ptr) && casted_ptr->value->data.x_ptr.mut == ConstPtrMutComptimeVar)
27753	28588	{
27754		zig_panic("TODO compile-time execution of atomicRmw");
	28589	ir_add_error(ira, &instruction->base.base,
	28590	buf_sprintf("compiler bug: TODO compile-time execution of @atomicRmw"));
	28591	return ira->codegen->invalid_inst_gen;
27755	28592	}
27756	28593
27757		IrInstruction *result = ir_build_atomic_rmw(&ira->new_irb, instruction->base.scope,
27758		instruction->base.source_node, nullptr, casted_ptr, nullptr, casted_operand, nullptr,
27759		op, ordering);
27760		result->value->type = operand_type;
27761		return result;
	28594	return ir_build_atomic_rmw_gen(ira, &instruction->base.base, casted_ptr, casted_operand, op,
	28595	ordering, operand_type);
27762	28596	}
27763	28597
27764		static IrInstruction ir_analyze_instruction_atomic_load(IrAnalyze ira, IrInstructionAtomicLoad *instruction) {
	28598	static IrInstGen ir_analyze_instruction_atomic_load(IrAnalyze ira, IrInstSrcAtomicLoad *instruction) {
27765	28599	ZigType *operand_type = ir_resolve_atomic_operand_type(ira, instruction->operand_type->child);
27766	28600	if (type_is_invalid(operand_type))
27767		return ira->codegen->invalid_instruction;
	28601	return ira->codegen->invalid_inst_gen;
27768	28602
27769		IrInstruction *ptr_inst = instruction->ptr->child;
	28603	IrInstGen *ptr_inst = instruction->ptr->child;
27770	28604	if (type_is_invalid(ptr_inst->value->type))
27771		return ira->codegen->invalid_instruction;
	28605	return ira->codegen->invalid_inst_gen;
27772	28606
27773	28607	ZigType *ptr_type = get_pointer_to_type(ira->codegen, operand_type, true);
27774		IrInstruction *casted_ptr = ir_implicit_cast(ira, ptr_inst, ptr_type);
	28608	IrInstGen *casted_ptr = ir_implicit_cast(ira, ptr_inst, ptr_type);
27775	28609	if (type_is_invalid(casted_ptr->value->type))
27776		return ira->codegen->invalid_instruction;
	28610	return ira->codegen->invalid_inst_gen;
27777	28611
27778	28612	AtomicOrder ordering;
27779		if (instruction->ordering == nullptr) {
27780		ordering = instruction->resolved_ordering;
27781		} else {
27782		if (!ir_resolve_atomic_order(ira, instruction->ordering->child, &ordering))
27783		return ira->codegen->invalid_instruction;
27784		}
	28613	if (!ir_resolve_atomic_order(ira, instruction->ordering->child, &ordering))
	28614	return ira->codegen->invalid_inst_gen;
27785	28615
27786	28616	if (ordering == AtomicOrderRelease \|\| ordering == AtomicOrderAcqRel) {
27787		ir_assert(instruction->ordering != nullptr, &instruction->base);
27788		ir_add_error(ira, instruction->ordering,
	28617	ir_assert(instruction->ordering != nullptr, &instruction->base.base);
	28618	ir_add_error(ira, &instruction->ordering->base,
27789	28619	buf_sprintf("@atomicLoad atomic ordering must not be Release or AcqRel"));
27790		return ira->codegen->invalid_instruction;
	28620	return ira->codegen->invalid_inst_gen;
27791	28621	}
27792	28622
27793	28623	if (instr_is_comptime(casted_ptr)) {
27794		IrInstruction *result = ir_get_deref(ira, &instruction->base, casted_ptr, nullptr);
27795		ir_assert(result->value->type != nullptr, &instruction->base);
	28624	IrInstGen *result = ir_get_deref(ira, &instruction->base.base, casted_ptr, nullptr);
	28625	ir_assert(result->value->type != nullptr, &instruction->base.base);
27796	28626	return result;
27797	28627	}
27798	28628
27799		IrInstruction *result = ir_build_atomic_load(&ira->new_irb, instruction->base.scope,
27800		instruction->base.source_node, nullptr, casted_ptr, nullptr, ordering);
27801		result->value->type = operand_type;
27802		return result;
	28629	return ir_build_atomic_load_gen(ira, &instruction->base.base, casted_ptr, ordering, operand_type);
27803	28630	}
27804	28631
27805		static IrInstruction ir_analyze_instruction_atomic_store(IrAnalyze ira, IrInstructionAtomicStore *instruction) {
	28632	static IrInstGen ir_analyze_instruction_atomic_store(IrAnalyze ira, IrInstSrcAtomicStore *instruction) {
27806	28633	ZigType *operand_type = ir_resolve_atomic_operand_type(ira, instruction->operand_type->child);
27807	28634	if (type_is_invalid(operand_type))
27808		return ira->codegen->invalid_instruction;
	28635	return ira->codegen->invalid_inst_gen;
27809	28636
27810		IrInstruction *ptr_inst = instruction->ptr->child;
	28637	IrInstGen *ptr_inst = instruction->ptr->child;
27811	28638	if (type_is_invalid(ptr_inst->value->type))
27812		return ira->codegen->invalid_instruction;
	28639	return ira->codegen->invalid_inst_gen;
27813	28640
27814	28641	ZigType *ptr_type = get_pointer_to_type(ira->codegen, operand_type, false);
27815		IrInstruction *casted_ptr = ir_implicit_cast(ira, ptr_inst, ptr_type);
	28642	IrInstGen *casted_ptr = ir_implicit_cast(ira, ptr_inst, ptr_type);
27816	28643	if (type_is_invalid(casted_ptr->value->type))
27817		return ira->codegen->invalid_instruction;
	28644	return ira->codegen->invalid_inst_gen;
27818	28645
27819		IrInstruction *value = instruction->value->child;
	28646	IrInstGen *value = instruction->value->child;
27820	28647	if (type_is_invalid(value->value->type))
27821		return ira->codegen->invalid_instruction;
	28648	return ira->codegen->invalid_inst_gen;
27822	28649
27823		IrInstruction *casted_value = ir_implicit_cast(ira, value, operand_type);
	28650	IrInstGen *casted_value = ir_implicit_cast(ira, value, operand_type);
27824	28651	if (type_is_invalid(casted_value->value->type))
27825		return ira->codegen->invalid_instruction;
	28652	return ira->codegen->invalid_inst_gen;
27826	28653
27827	28654
27828	28655	AtomicOrder ordering;
27829		if (instruction->ordering == nullptr) {
27830		ordering = instruction->resolved_ordering;
27831		} else {
27832		if (!ir_resolve_atomic_order(ira, instruction->ordering->child, &ordering))
27833		return ira->codegen->invalid_instruction;
27834		}
	28656	if (!ir_resolve_atomic_order(ira, instruction->ordering->child, &ordering))
	28657	return ira->codegen->invalid_inst_gen;
27835	28658
27836	28659	if (ordering == AtomicOrderAcquire \|\| ordering == AtomicOrderAcqRel) {
27837		ir_assert(instruction->ordering != nullptr, &instruction->base);
27838		ir_add_error(ira, instruction->ordering,
	28660	ir_assert(instruction->ordering != nullptr, &instruction->base.base);
	28661	ir_add_error(ira, &instruction->ordering->base,
27839	28662	buf_sprintf("@atomicStore atomic ordering must not be Acquire or AcqRel"));
27840		return ira->codegen->invalid_instruction;
	28663	return ira->codegen->invalid_inst_gen;
27841	28664	}
27842	28665
27843	28666	if (instr_is_comptime(casted_value) && instr_is_comptime(casted_ptr)) {
27844		IrInstruction *result = ir_analyze_store_ptr(ira, &instruction->base, casted_ptr, value, false);
	28667	IrInstGen *result = ir_analyze_store_ptr(ira, &instruction->base.base, casted_ptr, value, false);
27845	28668	result->value->type = ira->codegen->builtin_types.entry_void;
27846	28669	return result;
27847	28670	}
27848	28671
27849		IrInstruction *result = ir_build_atomic_store(&ira->new_irb, instruction->base.scope,
27850		instruction->base.source_node, nullptr, casted_ptr, casted_value, nullptr, ordering);
27851		result->value->type = ira->codegen->builtin_types.entry_void;
27852		return result;
	28672	return ir_build_atomic_store_gen(ira, &instruction->base.base, casted_ptr, casted_value, ordering);
27853	28673	}
27854	28674
27855		static IrInstruction ir_analyze_instruction_save_err_ret_addr(IrAnalyze ira, IrInstructionSaveErrRetAddr *instruction) {
27856		IrInstruction *result = ir_build_save_err_ret_addr(&ira->new_irb, instruction->base.scope,
27857		instruction->base.source_node);
27858		result->value->type = ira->codegen->builtin_types.entry_void;
27859		return result;
	28675	static IrInstGen ir_analyze_instruction_save_err_ret_addr(IrAnalyze ira, IrInstSrcSaveErrRetAddr *instruction) {
	28676	return ir_build_save_err_ret_addr_gen(ira, &instruction->base.base);
27860	28677	}
27861	28678
27862		static ErrorMsg ir_eval_float_op(IrAnalyze ira, IrInstruction source_instr, BuiltinFnId fop, ZigType float_type,
	28679	static ErrorMsg ir_eval_float_op(IrAnalyze ira, IrInst* source_instr, BuiltinFnId fop, ZigType *float_type,
27863	28680	ZigValue op, ZigValue out_val)
27864	28681	{
27865	28682	assert(ira && source_instr && float_type && out_val && op);
...	...	@@ -28072,30 +28889,30 @@ static ErrorMsg ir_eval_float_op(IrAnalyze ira, IrInstruction *source_instr, B
28072	28889	return nullptr;
28073	28890	}
28074	28891
28075		static IrInstruction ir_analyze_instruction_float_op(IrAnalyze ira, IrInstructionFloatOp *instruction) {
28076		IrInstruction *operand = instruction->operand->child;
	28892	static IrInstGen ir_analyze_instruction_float_op(IrAnalyze ira, IrInstSrcFloatOp *instruction) {
	28893	IrInstGen *operand = instruction->operand->child;
28077	28894	ZigType *operand_type = operand->value->type;
28078	28895	if (type_is_invalid(operand_type))
28079		return ira->codegen->invalid_instruction;
	28896	return ira->codegen->invalid_inst_gen;
28080	28897
28081	28898	// This instruction accepts floats and vectors of floats.
28082	28899	ZigType *scalar_type = (operand_type->id == ZigTypeIdVector) ?
28083	28900	operand_type->data.vector.elem_type : operand_type;
28084	28901
28085	28902	if (scalar_type->id != ZigTypeIdFloat && scalar_type->id != ZigTypeIdComptimeFloat) {
28086		ir_add_error(ira, operand,
	28903	ir_add_error(ira, &operand->base,
28087	28904	buf_sprintf("expected float type, found '%s'", buf_ptr(&scalar_type->name)));
28088		return ira->codegen->invalid_instruction;
	28905	return ira->codegen->invalid_inst_gen;
28089	28906	}
28090	28907
28091	28908	if (instr_is_comptime(operand)) {
28092	28909	ZigValue *operand_val = ir_resolve_const(ira, operand, UndefOk);
28093	28910	if (operand_val == nullptr)
28094		return ira->codegen->invalid_instruction;
	28911	return ira->codegen->invalid_inst_gen;
28095	28912	if (operand_val->special == ConstValSpecialUndef)
28096		return ir_const_undef(ira, &instruction->base, operand_type);
	28913	return ir_const_undef(ira, &instruction->base.base, operand_type);
28097	28914
28098		IrInstruction *result = ir_const(ira, &instruction->base, operand_type);
	28915	IrInstGen *result = ir_const(ira, &instruction->base.base, operand_type);
28099	28916	ZigValue *out_val = result->value;
28100	28917
28101	28918	if (operand_type->id == ZigTypeIdVector) {
...	...	@@ -28106,47 +28923,44 @@ static IrInstruction ir_analyze_instruction_float_op(IrAnalyze ira, IrInstruct
28106	28923	for (size_t i = 0; i < len; i += 1) {
28107	28924	ZigValue *elem_operand = &operand_val->data.x_array.data.s_none.elements[i];
28108	28925	ZigValue *float_out_val = &out_val->data.x_array.data.s_none.elements[i];
28109		ir_assert(elem_operand->type == scalar_type, &instruction->base);
28110		ir_assert(float_out_val->type == scalar_type, &instruction->base);
28111		ErrorMsg *msg = ir_eval_float_op(ira, &instruction->base, instruction->fn_id, scalar_type,
	28926	ir_assert(elem_operand->type == scalar_type, &instruction->base.base);
	28927	ir_assert(float_out_val->type == scalar_type, &instruction->base.base);
	28928	ErrorMsg *msg = ir_eval_float_op(ira, &instruction->base.base, instruction->fn_id, scalar_type,
28112	28929	elem_operand, float_out_val);
28113	28930	if (msg != nullptr) {
28114		add_error_note(ira->codegen, msg, instruction->base.source_node,
	28931	add_error_note(ira->codegen, msg, instruction->base.base.source_node,
28115	28932	buf_sprintf("when computing vector element at index %" ZIG_PRI_usize, i));
28116		return ira->codegen->invalid_instruction;
	28933	return ira->codegen->invalid_inst_gen;
28117	28934	}
28118	28935	float_out_val->type = scalar_type;
28119	28936	}
28120	28937	out_val->type = operand_type;
28121	28938	out_val->special = ConstValSpecialStatic;
28122	28939	} else {
28123		if (ir_eval_float_op(ira, &instruction->base, instruction->fn_id, scalar_type,
	28940	if (ir_eval_float_op(ira, &instruction->base.base, instruction->fn_id, scalar_type,
28124	28941	operand_val, out_val) != nullptr)
28125	28942	{
28126		return ira->codegen->invalid_instruction;
	28943	return ira->codegen->invalid_inst_gen;
28127	28944	}
28128	28945	}
28129	28946	return result;
28130	28947	}
28131	28948
28132		ir_assert(scalar_type->id == ZigTypeIdFloat, &instruction->base);
	28949	ir_assert(scalar_type->id == ZigTypeIdFloat, &instruction->base.base);
28133	28950
28134		IrInstruction *result = ir_build_float_op(&ira->new_irb, instruction->base.scope,
28135		instruction->base.source_node, operand, instruction->fn_id);
28136		result->value->type = operand_type;
28137		return result;
	28951	return ir_build_float_op_gen(ira, &instruction->base.base, operand, instruction->fn_id, operand_type);
28138	28952	}
28139	28953
28140		static IrInstruction ir_analyze_instruction_bswap(IrAnalyze ira, IrInstructionBswap *instruction) {
	28954	static IrInstGen ir_analyze_instruction_bswap(IrAnalyze ira, IrInstSrcBswap *instruction) {
28141	28955	Error err;
28142	28956
28143	28957	ZigType *int_type = ir_resolve_int_type(ira, instruction->type->child);
28144	28958	if (type_is_invalid(int_type))
28145		return ira->codegen->invalid_instruction;
	28959	return ira->codegen->invalid_inst_gen;
28146	28960
28147		IrInstruction *uncasted_op = instruction->op->child;
	28961	IrInstGen *uncasted_op = instruction->op->child;
28148	28962	if (type_is_invalid(uncasted_op->value->type))
28149		return ira->codegen->invalid_instruction;
	28963	return ira->codegen->invalid_inst_gen;
28150	28964
28151	28965	uint32_t vector_len; // UINT32_MAX means not a vector
28152	28966	if (uncasted_op->value->type->id == ZigTypeIdArray &&
...	...	@@ -28162,28 +28976,28 @@ static IrInstruction ir_analyze_instruction_bswap(IrAnalyze ira, IrInstruction
28162	28976	bool is_vector = (vector_len != UINT32_MAX);
28163	28977	ZigType *op_type = is_vector ? get_vector_type(ira->codegen, vector_len, int_type) : int_type;
28164	28978
28165		IrInstruction *op = ir_implicit_cast(ira, uncasted_op, op_type);
	28979	IrInstGen *op = ir_implicit_cast(ira, uncasted_op, op_type);
28166	28980	if (type_is_invalid(op->value->type))
28167		return ira->codegen->invalid_instruction;
	28981	return ira->codegen->invalid_inst_gen;
28168	28982
28169	28983	if (int_type->data.integral.bit_count == 8 \|\| int_type->data.integral.bit_count == 0)
28170	28984	return op;
28171	28985
28172	28986	if (int_type->data.integral.bit_count % 8 != 0) {
28173		ir_add_error(ira, instruction->op,
	28987	ir_add_error(ira, &instruction->op->base,
28174	28988	buf_sprintf("@byteSwap integer type '%s' has %" PRIu32 " bits which is not evenly divisible by 8",
28175	28989	buf_ptr(&int_type->name), int_type->data.integral.bit_count));
28176		return ira->codegen->invalid_instruction;
	28990	return ira->codegen->invalid_inst_gen;
28177	28991	}
28178	28992
28179	28993	if (instr_is_comptime(op)) {
28180	28994	ZigValue *val = ir_resolve_const(ira, op, UndefOk);
28181	28995	if (val == nullptr)
28182		return ira->codegen->invalid_instruction;
	28996	return ira->codegen->invalid_inst_gen;
28183	28997	if (val->special == ConstValSpecialUndef)
28184		return ir_const_undef(ira, &instruction->base, op_type);
	28998	return ir_const_undef(ira, &instruction->base.base, op_type);
28185	28999
28186		IrInstruction *result = ir_const(ira, &instruction->base, op_type);
	29000	IrInstGen *result = ir_const(ira, &instruction->base.base, op_type);
28187	29001	size_t buf_size = int_type->data.integral.bit_count / 8;
28188	29002	uint8_t *buf = allocate_nonzero<uint8_t>(buf_size);
28189	29003	if (is_vector) {
...	...	@@ -28191,10 +29005,10 @@ static IrInstruction ir_analyze_instruction_bswap(IrAnalyze ira, IrInstruction
28191	29005	result->value->data.x_array.data.s_none.elements = create_const_vals(op_type->data.vector.len);
28192	29006	for (unsigned i = 0; i < op_type->data.vector.len; i += 1) {
28193	29007	ZigValue *op_elem_val = &val->data.x_array.data.s_none.elements[i];
28194		if ((err = ir_resolve_const_val(ira->codegen, ira->new_irb.exec, instruction->base.source_node,
	29008	if ((err = ir_resolve_const_val(ira->codegen, ira->new_irb.exec, instruction->base.base.source_node,
28195	29009	op_elem_val, UndefOk)))
28196	29010	{
28197		return ira->codegen->invalid_instruction;
	29011	return ira->codegen->invalid_inst_gen;
28198	29012	}
28199	29013	ZigValue *result_elem_val = &result->value->data.x_array.data.s_none.elements[i];
28200	29014	result_elem_val->type = int_type;
...	...	@@ -28216,23 +29030,20 @@ static IrInstruction ir_analyze_instruction_bswap(IrAnalyze ira, IrInstruction
28216	29030	return result;
28217	29031	}
28218	29032
28219		IrInstruction *result = ir_build_bswap(&ira->new_irb, instruction->base.scope,
28220		instruction->base.source_node, nullptr, op);
28221		result->value->type = op_type;
28222		return result;
	29033	return ir_build_bswap_gen(ira, &instruction->base.base, op_type, op);
28223	29034	}
28224	29035
28225		static IrInstruction ir_analyze_instruction_bit_reverse(IrAnalyze ira, IrInstructionBitReverse *instruction) {
	29036	static IrInstGen ir_analyze_instruction_bit_reverse(IrAnalyze ira, IrInstSrcBitReverse *instruction) {
28226	29037	ZigType *int_type = ir_resolve_int_type(ira, instruction->type->child);
28227	29038	if (type_is_invalid(int_type))
28228		return ira->codegen->invalid_instruction;
	29039	return ira->codegen->invalid_inst_gen;
28229	29040
28230		IrInstruction *op = ir_implicit_cast(ira, instruction->op->child, int_type);
	29041	IrInstGen *op = ir_implicit_cast(ira, instruction->op->child, int_type);
28231	29042	if (type_is_invalid(op->value->type))
28232		return ira->codegen->invalid_instruction;
	29043	return ira->codegen->invalid_inst_gen;
28233	29044
28234	29045	if (int_type->data.integral.bit_count == 0) {
28235		IrInstruction *result = ir_const(ira, &instruction->base, int_type);
	29046	IrInstGen *result = ir_const(ira, &instruction->base.base, int_type);
28236	29047	bigint_init_unsigned(&result->value->data.x_bigint, 0);
28237	29048	return result;
28238	29049	}
...	...	@@ -28240,11 +29051,11 @@ static IrInstruction ir_analyze_instruction_bit_reverse(IrAnalyze ira, IrInstr
28240	29051	if (instr_is_comptime(op)) {
28241	29052	ZigValue *val = ir_resolve_const(ira, op, UndefOk);
28242	29053	if (val == nullptr)
28243		return ira->codegen->invalid_instruction;
	29054	return ira->codegen->invalid_inst_gen;
28244	29055	if (val->special == ConstValSpecialUndef)
28245		return ir_const_undef(ira, &instruction->base, int_type);
	29056	return ir_const_undef(ira, &instruction->base.base, int_type);
28246	29057
28247		IrInstruction *result = ir_const(ira, &instruction->base, int_type);
	29058	IrInstGen *result = ir_const(ira, &instruction->base.base, int_type);
28248	29059	size_t num_bits = int_type->data.integral.bit_count;
28249	29060	size_t buf_size = (num_bits + 7) / 8;
28250	29061	uint8_t *comptime_buf = allocate_nonzero<uint8_t>(buf_size);
...	...	@@ -28271,128 +29082,125 @@ static IrInstruction ir_analyze_instruction_bit_reverse(IrAnalyze ira, IrInstr
28271	29082	return result;
28272	29083	}
28273	29084
28274		IrInstruction *result = ir_build_bit_reverse(&ira->new_irb, instruction->base.scope,
28275		instruction->base.source_node, nullptr, op);
28276		result->value->type = int_type;
28277		return result;
	29085	return ir_build_bit_reverse_gen(ira, &instruction->base.base, int_type, op);
28278	29086	}
28279	29087
28280	29088
28281		static IrInstruction ir_analyze_instruction_enum_to_int(IrAnalyze ira, IrInstructionEnumToInt *instruction) {
28282		IrInstruction *target = instruction->target->child;
	29089	static IrInstGen ir_analyze_instruction_enum_to_int(IrAnalyze ira, IrInstSrcEnumToInt *instruction) {
	29090	IrInstGen *target = instruction->target->child;
28283	29091	if (type_is_invalid(target->value->type))
28284		return ira->codegen->invalid_instruction;
	29092	return ira->codegen->invalid_inst_gen;
28285	29093
28286		return ir_analyze_enum_to_int(ira, &instruction->base, target);
	29094	return ir_analyze_enum_to_int(ira, &instruction->base.base, target);
28287	29095	}
28288	29096
28289		static IrInstruction ir_analyze_instruction_int_to_enum(IrAnalyze ira, IrInstructionIntToEnum *instruction) {
	29097	static IrInstGen ir_analyze_instruction_int_to_enum(IrAnalyze ira, IrInstSrcIntToEnum *instruction) {
28290	29098	Error err;
28291		IrInstruction *dest_type_value = instruction->dest_type->child;
	29099	IrInstGen *dest_type_value = instruction->dest_type->child;
28292	29100	ZigType *dest_type = ir_resolve_type(ira, dest_type_value);
28293	29101	if (type_is_invalid(dest_type))
28294		return ira->codegen->invalid_instruction;
	29102	return ira->codegen->invalid_inst_gen;
28295	29103
28296	29104	if (dest_type->id != ZigTypeIdEnum) {
28297		ir_add_error(ira, instruction->dest_type,
	29105	ir_add_error(ira, &instruction->dest_type->base,
28298	29106	buf_sprintf("expected enum, found type '%s'", buf_ptr(&dest_type->name)));
28299		return ira->codegen->invalid_instruction;
	29107	return ira->codegen->invalid_inst_gen;
28300	29108	}
28301	29109
28302	29110	if ((err = type_resolve(ira->codegen, dest_type, ResolveStatusZeroBitsKnown)))
28303		return ira->codegen->invalid_instruction;
	29111	return ira->codegen->invalid_inst_gen;
28304	29112
28305	29113	ZigType *tag_type = dest_type->data.enumeration.tag_int_type;
28306	29114
28307		IrInstruction *target = instruction->target->child;
	29115	IrInstGen *target = instruction->target->child;
28308	29116	if (type_is_invalid(target->value->type))
28309		return ira->codegen->invalid_instruction;
	29117	return ira->codegen->invalid_inst_gen;
28310	29118
28311		IrInstruction *casted_target = ir_implicit_cast(ira, target, tag_type);
	29119	IrInstGen *casted_target = ir_implicit_cast(ira, target, tag_type);
28312	29120	if (type_is_invalid(casted_target->value->type))
28313		return ira->codegen->invalid_instruction;
	29121	return ira->codegen->invalid_inst_gen;
28314	29122
28315		return ir_analyze_int_to_enum(ira, &instruction->base, casted_target, dest_type);
	29123	return ir_analyze_int_to_enum(ira, &instruction->base.base, casted_target, dest_type);
28316	29124	}
28317	29125
28318		static IrInstruction ir_analyze_instruction_check_runtime_scope(IrAnalyze ira, IrInstructionCheckRuntimeScope *instruction) {
28319		IrInstruction *block_comptime_inst = instruction->scope_is_comptime->child;
	29126	static IrInstGen ir_analyze_instruction_check_runtime_scope(IrAnalyze ira, IrInstSrcCheckRuntimeScope *instruction) {
	29127	IrInstGen *block_comptime_inst = instruction->scope_is_comptime->child;
28320	29128	bool scope_is_comptime;
28321	29129	if (!ir_resolve_bool(ira, block_comptime_inst, &scope_is_comptime))
28322		return ira->codegen->invalid_instruction;
	29130	return ira->codegen->invalid_inst_gen;
28323	29131
28324		IrInstruction *is_comptime_inst = instruction->is_comptime->child;
	29132	IrInstGen *is_comptime_inst = instruction->is_comptime->child;
28325	29133	bool is_comptime;
28326	29134	if (!ir_resolve_bool(ira, is_comptime_inst, &is_comptime))
28327		return ira->codegen->invalid_instruction;
	29135	return ira->codegen->invalid_inst_gen;
28328	29136
28329	29137	if (!scope_is_comptime && is_comptime) {
28330		ErrorMsg *msg = ir_add_error(ira, &instruction->base,
	29138	ErrorMsg *msg = ir_add_error(ira, &instruction->base.base,
28331	29139	buf_sprintf("comptime control flow inside runtime block"));
28332		add_error_note(ira->codegen, msg, block_comptime_inst->source_node,
	29140	add_error_note(ira->codegen, msg, block_comptime_inst->base.source_node,
28333	29141	buf_sprintf("runtime block created here"));
28334		return ira->codegen->invalid_instruction;
	29142	return ira->codegen->invalid_inst_gen;
28335	29143	}
28336	29144
28337		return ir_const_void(ira, &instruction->base);
	29145	return ir_const_void(ira, &instruction->base.base);
28338	29146	}
28339	29147
28340		static IrInstruction ir_analyze_instruction_has_decl(IrAnalyze ira, IrInstructionHasDecl *instruction) {
	29148	static IrInstGen ir_analyze_instruction_has_decl(IrAnalyze ira, IrInstSrcHasDecl *instruction) {
28341	29149	ZigType *container_type = ir_resolve_type(ira, instruction->container->child);
28342	29150	if (type_is_invalid(container_type))
28343		return ira->codegen->invalid_instruction;
	29151	return ira->codegen->invalid_inst_gen;
28344	29152
28345	29153	Buf *name = ir_resolve_str(ira, instruction->name->child);
28346	29154	if (name == nullptr)
28347		return ira->codegen->invalid_instruction;
	29155	return ira->codegen->invalid_inst_gen;
28348	29156
28349	29157	if (!is_container(container_type)) {
28350		ir_add_error(ira, instruction->container,
	29158	ir_add_error(ira, &instruction->container->base,
28351	29159	buf_sprintf("expected struct, enum, or union; found '%s'", buf_ptr(&container_type->name)));
28352		return ira->codegen->invalid_instruction;
	29160	return ira->codegen->invalid_inst_gen;
28353	29161	}
28354	29162
28355	29163	ScopeDecls *container_scope = get_container_scope(container_type);
28356	29164	Tld *tld = find_container_decl(ira->codegen, container_scope, name);
28357	29165	if (tld == nullptr)
28358		return ir_const_bool(ira, &instruction->base, false);
	29166	return ir_const_bool(ira, &instruction->base.base, false);
28359	29167
28360		if (tld->visib_mod == VisibModPrivate && tld->import != get_scope_import(instruction->base.scope)) {
28361		return ir_const_bool(ira, &instruction->base, false);
	29168	if (tld->visib_mod == VisibModPrivate && tld->import != get_scope_import(instruction->base.base.scope)) {
	29169	return ir_const_bool(ira, &instruction->base.base, false);
28362	29170	}
28363	29171
28364		return ir_const_bool(ira, &instruction->base, true);
	29172	return ir_const_bool(ira, &instruction->base.base, true);
28365	29173	}
28366	29174
28367		static IrInstruction ir_analyze_instruction_undeclared_ident(IrAnalyze ira, IrInstructionUndeclaredIdent *instruction) {
	29175	static IrInstGen ir_analyze_instruction_undeclared_ident(IrAnalyze ira, IrInstSrcUndeclaredIdent *instruction) {
28368	29176	// put a variable of same name with invalid type in global scope
28369	29177	// so that future references to this same name will find a variable with an invalid type
28370		populate_invalid_variable_in_scope(ira->codegen, instruction->base.scope, instruction->base.source_node,
28371		instruction->name);
28372		ir_add_error(ira, &instruction->base,
	29178	populate_invalid_variable_in_scope(ira->codegen, instruction->base.base.scope,
	29179	instruction->base.base.source_node, instruction->name);
	29180	ir_add_error(ira, &instruction->base.base,
28373	29181	buf_sprintf("use of undeclared identifier '%s'", buf_ptr(instruction->name)));
28374		return ira->codegen->invalid_instruction;
	29182	return ira->codegen->invalid_inst_gen;
28375	29183	}
28376	29184
28377		static IrInstruction ir_analyze_instruction_end_expr(IrAnalyze ira, IrInstructionEndExpr *instruction) {
28378		IrInstruction *value = instruction->value->child;
	29185	static IrInstGen ir_analyze_instruction_end_expr(IrAnalyze ira, IrInstSrcEndExpr *instruction) {
	29186	IrInstGen *value = instruction->value->child;
28379	29187	if (type_is_invalid(value->value->type))
28380		return ira->codegen->invalid_instruction;
	29188	return ira->codegen->invalid_inst_gen;
28381	29189
28382	29190	bool was_written = instruction->result_loc->written;
28383		IrInstruction *result_loc = ir_resolve_result(ira, &instruction->base, instruction->result_loc,
	29191	IrInstGen *result_loc = ir_resolve_result(ira, &instruction->base.base, instruction->result_loc,
28384	29192	value->value->type, value, false, false, true);
28385	29193	if (result_loc != nullptr) {
28386	29194	if (type_is_invalid(result_loc->value->type))
28387		return ira->codegen->invalid_instruction;
	29195	return ira->codegen->invalid_inst_gen;
28388	29196	if (result_loc->value->type->id == ZigTypeIdUnreachable)
28389	29197	return result_loc;
28390	29198
28391	29199	if (!was_written \|\| instruction->result_loc->id == ResultLocIdPeer) {
28392		IrInstruction *store_ptr = ir_analyze_store_ptr(ira, &instruction->base, result_loc, value,
	29200	IrInstGen *store_ptr = ir_analyze_store_ptr(ira, &instruction->base.base, result_loc, value,
28393	29201	instruction->result_loc->allow_write_through_const);
28394	29202	if (type_is_invalid(store_ptr->value->type)) {
28395		return ira->codegen->invalid_instruction;
	29203	return ira->codegen->invalid_inst_gen;
28396	29204	}
28397	29205	}
28398	29206
...	...	@@ -28407,33 +29215,33 @@ static IrInstruction ir_analyze_instruction_end_expr(IrAnalyze ira, IrInstruct
28407	29215	}
28408	29216	}
28409	29217
28410		return ir_const_void(ira, &instruction->base);
	29218	return ir_const_void(ira, &instruction->base.base);
28411	29219	}
28412	29220
28413		static IrInstruction ir_analyze_instruction_implicit_cast(IrAnalyze ira, IrInstructionImplicitCast *instruction) {
28414		IrInstruction *operand = instruction->operand->child;
	29221	static IrInstGen ir_analyze_instruction_implicit_cast(IrAnalyze ira, IrInstSrcImplicitCast *instruction) {
	29222	IrInstGen *operand = instruction->operand->child;
28415	29223	if (type_is_invalid(operand->value->type))
28416	29224	return operand;
28417	29225
28418		IrInstruction *result_loc = ir_resolve_result(ira, &instruction->base,
	29226	IrInstGen *result_loc = ir_resolve_result(ira, &instruction->base.base,
28419	29227	&instruction->result_loc_cast->base, operand->value->type, operand, false, false, true);
28420		if (result_loc != nullptr && (type_is_invalid(result_loc->value->type) \|\| instr_is_unreachable(result_loc)))
	29228	if (result_loc != nullptr && (type_is_invalid(result_loc->value->type) \|\| result_loc->value->type->id == ZigTypeIdUnreachable))
28421	29229	return result_loc;
28422	29230
28423	29231	ZigType *dest_type = ir_resolve_type(ira, instruction->result_loc_cast->base.source_instruction->child);
28424	29232	if (type_is_invalid(dest_type))
28425		return ira->codegen->invalid_instruction;
28426		return ir_implicit_cast2(ira, &instruction->base, operand, dest_type);
	29233	return ira->codegen->invalid_inst_gen;
	29234	return ir_implicit_cast2(ira, &instruction->base.base, operand, dest_type);
28427	29235	}
28428	29236
28429		static IrInstruction ir_analyze_instruction_bit_cast_src(IrAnalyze ira, IrInstructionBitCastSrc *instruction) {
28430		IrInstruction *operand = instruction->operand->child;
	29237	static IrInstGen ir_analyze_instruction_bit_cast_src(IrAnalyze ira, IrInstSrcBitCast *instruction) {
	29238	IrInstGen *operand = instruction->operand->child;
28431	29239	if (type_is_invalid(operand->value->type))
28432	29240	return operand;
28433	29241
28434		IrInstruction *result_loc = ir_resolve_result(ira, &instruction->base,
	29242	IrInstGen *result_loc = ir_resolve_result(ira, &instruction->base.base,
28435	29243	&instruction->result_loc_bit_cast->base, operand->value->type, operand, false, false, true);
28436		if (result_loc != nullptr && (type_is_invalid(result_loc->value->type) \|\| instr_is_unreachable(result_loc)))
	29244	if (result_loc != nullptr && (type_is_invalid(result_loc->value->type) \|\| result_loc->value->type->id == ZigTypeIdUnreachable))
28437	29245	return result_loc;
28438	29246
28439	29247	if (instruction->result_loc_bit_cast->parent->gen_instruction != nullptr) {
...	...	@@ -28443,70 +29251,66 @@ static IrInstruction ir_analyze_instruction_bit_cast_src(IrAnalyze ira, IrInst
28443	29251	return result_loc;
28444	29252	}
28445	29253
28446		static IrInstruction ir_analyze_instruction_union_init_named_field(IrAnalyze ira,
28447		IrInstructionUnionInitNamedField *instruction)
	29254	static IrInstGen ir_analyze_instruction_union_init_named_field(IrAnalyze ira,
	29255	IrInstSrcUnionInitNamedField *instruction)
28448	29256	{
28449	29257	ZigType *union_type = ir_resolve_type(ira, instruction->union_type->child);
28450	29258	if (type_is_invalid(union_type))
28451		return ira->codegen->invalid_instruction;
	29259	return ira->codegen->invalid_inst_gen;
28452	29260
28453	29261	if (union_type->id != ZigTypeIdUnion) {
28454		ir_add_error(ira, instruction->union_type,
	29262	ir_add_error(ira, &instruction->union_type->base,
28455	29263	buf_sprintf("non-union type '%s' passed to @unionInit", buf_ptr(&union_type->name)));
28456		return ira->codegen->invalid_instruction;
	29264	return ira->codegen->invalid_inst_gen;
28457	29265	}
28458	29266
28459	29267	Buf *field_name = ir_resolve_str(ira, instruction->field_name->child);
28460	29268	if (field_name == nullptr)
28461		return ira->codegen->invalid_instruction;
	29269	return ira->codegen->invalid_inst_gen;
28462	29270
28463		IrInstruction *field_result_loc = instruction->field_result_loc->child;
	29271	IrInstGen *field_result_loc = instruction->field_result_loc->child;
28464	29272	if (type_is_invalid(field_result_loc->value->type))
28465		return ira->codegen->invalid_instruction;
	29273	return ira->codegen->invalid_inst_gen;
28466	29274
28467		IrInstruction *result_loc = instruction->result_loc->child;
	29275	IrInstGen *result_loc = instruction->result_loc->child;
28468	29276	if (type_is_invalid(result_loc->value->type))
28469		return ira->codegen->invalid_instruction;
	29277	return ira->codegen->invalid_inst_gen;
28470	29278
28471		return ir_analyze_union_init(ira, &instruction->base, instruction->base.source_node,
	29279	return ir_analyze_union_init(ira, &instruction->base.base, instruction->base.base.source_node,
28472	29280	union_type, field_name, field_result_loc, result_loc);
28473	29281	}
28474	29282
28475		static IrInstruction ir_analyze_instruction_suspend_begin(IrAnalyze ira, IrInstructionSuspendBegin *instruction) {
28476		IrInstructionSuspendBegin *result = ir_build_suspend_begin(&ira->new_irb, instruction->base.scope,
28477		instruction->base.source_node);
28478		return &result->base;
	29283	static IrInstGen ir_analyze_instruction_suspend_begin(IrAnalyze ira, IrInstSrcSuspendBegin *instruction) {
	29284	return ir_build_suspend_begin_gen(ira, &instruction->base.base);
28479	29285	}
28480	29286
28481		static IrInstruction ir_analyze_instruction_suspend_finish(IrAnalyze ira,
28482		IrInstructionSuspendFinish *instruction)
28483		{
28484		IrInstruction *begin_base = instruction->begin->base.child;
	29287	static IrInstGen ir_analyze_instruction_suspend_finish(IrAnalyze ira, IrInstSrcSuspendFinish *instruction) {
	29288	IrInstGen *begin_base = instruction->begin->base.child;
28485	29289	if (type_is_invalid(begin_base->value->type))
28486		return ira->codegen->invalid_instruction;
28487		ir_assert(begin_base->id == IrInstructionIdSuspendBegin, &instruction->base);
28488		IrInstructionSuspendBegin begin = reinterpret_cast<IrInstructionSuspendBegin >(begin_base);
	29290	return ira->codegen->invalid_inst_gen;
	29291	ir_assert(begin_base->id == IrInstGenIdSuspendBegin, &instruction->base.base);
	29292	IrInstGenSuspendBegin begin = reinterpret_cast<IrInstGenSuspendBegin >(begin_base);
28489	29293
28490		ZigFn *fn_entry = exec_fn_entry(ira->new_irb.exec);
28491		ir_assert(fn_entry != nullptr, &instruction->base);
	29294	ZigFn *fn_entry = ira->new_irb.exec->fn_entry;
	29295	ir_assert(fn_entry != nullptr, &instruction->base.base);
28492	29296
28493	29297	if (fn_entry->inferred_async_node == nullptr) {
28494		fn_entry->inferred_async_node = instruction->base.source_node;
	29298	fn_entry->inferred_async_node = instruction->base.base.source_node;
28495	29299	}
28496	29300
28497		return ir_build_suspend_finish(&ira->new_irb, instruction->base.scope, instruction->base.source_node, begin);
	29301	return ir_build_suspend_finish_gen(ira, &instruction->base.base, begin);
28498	29302	}
28499	29303
28500		static IrInstruction analyze_frame_ptr_to_anyframe_T(IrAnalyze ira, IrInstruction *source_instr,
28501		IrInstruction frame_ptr, ZigFn *target_fn)
	29304	static IrInstGen analyze_frame_ptr_to_anyframe_T(IrAnalyze ira, IrInst* source_instr,
	29305	IrInstGen frame_ptr, ZigFn *target_fn)
28502	29306	{
28503	29307	if (type_is_invalid(frame_ptr->value->type))
28504		return ira->codegen->invalid_instruction;
	29308	return ira->codegen->invalid_inst_gen;
28505	29309
28506	29310	*target_fn = nullptr;
28507	29311
28508	29312	ZigType *result_type;
28509		IrInstruction *frame;
	29313	IrInstGen *frame;
28510	29314	if (frame_ptr->value->type->id == ZigTypeIdPointer &&
28511	29315	frame_ptr->value->type->data.pointer.ptr_len == PtrLenSingle &&
28512	29316	frame_ptr->value->type->data.pointer.child_type->id == ZigTypeIdFnFrame)
...	...	@@ -28529,38 +29333,38 @@ static IrInstruction analyze_frame_ptr_to_anyframe_T(IrAnalyze ira, IrInstruct
28529	29333	{
28530	29334	ir_add_error(ira, source_instr,
28531	29335	buf_sprintf("expected anyframe->T, found '%s'", buf_ptr(&frame->value->type->name)));
28532		return ira->codegen->invalid_instruction;
	29336	return ira->codegen->invalid_inst_gen;
28533	29337	} else {
28534	29338	result_type = frame->value->type->data.any_frame.result_type;
28535	29339	}
28536	29340	}
28537	29341
28538	29342	ZigType *any_frame_type = get_any_frame_type(ira->codegen, result_type);
28539		IrInstruction *casted_frame = ir_implicit_cast(ira, frame, any_frame_type);
	29343	IrInstGen *casted_frame = ir_implicit_cast(ira, frame, any_frame_type);
28540	29344	if (type_is_invalid(casted_frame->value->type))
28541		return ira->codegen->invalid_instruction;
	29345	return ira->codegen->invalid_inst_gen;
28542	29346
28543	29347	return casted_frame;
28544	29348	}
28545	29349
28546		static IrInstruction ir_analyze_instruction_await(IrAnalyze ira, IrInstructionAwaitSrc *instruction) {
28547		IrInstruction *operand = instruction->frame->child;
	29350	static IrInstGen ir_analyze_instruction_await(IrAnalyze ira, IrInstSrcAwait *instruction) {
	29351	IrInstGen *operand = instruction->frame->child;
28548	29352	if (type_is_invalid(operand->value->type))
28549		return ira->codegen->invalid_instruction;
	29353	return ira->codegen->invalid_inst_gen;
28550	29354	ZigFn *target_fn;
28551		IrInstruction *frame = analyze_frame_ptr_to_anyframe_T(ira, &instruction->base, operand, &target_fn);
	29355	IrInstGen *frame = analyze_frame_ptr_to_anyframe_T(ira, &instruction->base.base, operand, &target_fn);
28552	29356	if (type_is_invalid(frame->value->type))
28553		return ira->codegen->invalid_instruction;
	29357	return ira->codegen->invalid_inst_gen;
28554	29358
28555	29359	ZigType *result_type = frame->value->type->data.any_frame.result_type;
28556	29360
28557		ZigFn *fn_entry = exec_fn_entry(ira->new_irb.exec);
28558		ir_assert(fn_entry != nullptr, &instruction->base);
	29361	ZigFn *fn_entry = ira->new_irb.exec->fn_entry;
	29362	ir_assert(fn_entry != nullptr, &instruction->base.base);
28559	29363
28560	29364	// If it's not @Frame(func) then it's definitely a suspend point
28561	29365	if (target_fn == nullptr) {
28562	29366	if (fn_entry->inferred_async_node == nullptr) {
28563		fn_entry->inferred_async_node = instruction->base.source_node;
	29367	fn_entry->inferred_async_node = instruction->base.base.source_node;
28564	29368	}
28565	29369	}
28566	29370
...	...	@@ -28568,401 +29372,364 @@ static IrInstruction ir_analyze_instruction_await(IrAnalyze ira, IrInstruction
28568	29372	fn_entry->calls_or_awaits_errorable_fn = true;
28569	29373	}
28570	29374
28571		IrInstruction *result_loc;
	29375	IrInstGen *result_loc;
28572	29376	if (type_has_bits(result_type)) {
28573		result_loc = ir_resolve_result(ira, &instruction->base, instruction->result_loc,
	29377	result_loc = ir_resolve_result(ira, &instruction->base.base, instruction->result_loc,
28574	29378	result_type, nullptr, true, true, true);
28575		if (result_loc != nullptr && (type_is_invalid(result_loc->value->type) \|\| instr_is_unreachable(result_loc)))
	29379	if (result_loc != nullptr && (type_is_invalid(result_loc->value->type) \|\| result_loc->value->type->id == ZigTypeIdUnreachable))
28576	29380	return result_loc;
28577	29381	} else {
28578	29382	result_loc = nullptr;
28579	29383	}
28580	29384
28581		IrInstructionAwaitGen *result = ir_build_await_gen(ira, &instruction->base, frame, result_type, result_loc);
	29385	IrInstGenAwait *result = ir_build_await_gen(ira, &instruction->base.base, frame, result_type, result_loc);
28582	29386	result->target_fn = target_fn;
28583	29387	fn_entry->await_list.append(result);
28584	29388	return ir_finish_anal(ira, &result->base);
28585	29389	}
28586	29390
28587		static IrInstruction ir_analyze_instruction_resume(IrAnalyze ira, IrInstructionResume *instruction) {
28588		IrInstruction *frame_ptr = instruction->frame->child;
	29391	static IrInstGen ir_analyze_instruction_resume(IrAnalyze ira, IrInstSrcResume *instruction) {
	29392	IrInstGen *frame_ptr = instruction->frame->child;
28589	29393	if (type_is_invalid(frame_ptr->value->type))
28590		return ira->codegen->invalid_instruction;
	29394	return ira->codegen->invalid_inst_gen;
28591	29395
28592		IrInstruction *frame;
	29396	IrInstGen *frame;
28593	29397	if (frame_ptr->value->type->id == ZigTypeIdPointer &&
28594	29398	frame_ptr->value->type->data.pointer.ptr_len == PtrLenSingle &&
28595	29399	frame_ptr->value->type->data.pointer.child_type->id == ZigTypeIdFnFrame)
28596	29400	{
28597	29401	frame = frame_ptr;
28598	29402	} else {
28599		frame = ir_get_deref(ira, &instruction->base, frame_ptr, nullptr);
	29403	frame = ir_get_deref(ira, &instruction->base.base, frame_ptr, nullptr);
28600	29404	}
28601	29405
28602	29406	ZigType *any_frame_type = get_any_frame_type(ira->codegen, nullptr);
28603		IrInstruction *casted_frame = ir_implicit_cast(ira, frame, any_frame_type);
	29407	IrInstGen *casted_frame = ir_implicit_cast(ira, frame, any_frame_type);
28604	29408	if (type_is_invalid(casted_frame->value->type))
28605		return ira->codegen->invalid_instruction;
	29409	return ira->codegen->invalid_inst_gen;
28606	29410
28607		return ir_build_resume(&ira->new_irb, instruction->base.scope, instruction->base.source_node, casted_frame);
	29411	return ir_build_resume_gen(ira, &instruction->base.base, casted_frame);
28608	29412	}
28609	29413
28610		static IrInstruction ir_analyze_instruction_spill_begin(IrAnalyze ira, IrInstructionSpillBegin *instruction) {
28611		if (ir_should_inline(ira->new_irb.exec, instruction->base.scope))
28612		return ir_const_void(ira, &instruction->base);
	29414	static IrInstGen ir_analyze_instruction_spill_begin(IrAnalyze ira, IrInstSrcSpillBegin *instruction) {
	29415	if (ir_should_inline(ira->old_irb.exec, instruction->base.base.scope))
	29416	return ir_const_void(ira, &instruction->base.base);
28613	29417
28614		IrInstruction *operand = instruction->operand->child;
	29418	IrInstGen *operand = instruction->operand->child;
28615	29419	if (type_is_invalid(operand->value->type))
28616		return ira->codegen->invalid_instruction;
	29420	return ira->codegen->invalid_inst_gen;
28617	29421
28618	29422	if (!type_has_bits(operand->value->type))
28619		return ir_const_void(ira, &instruction->base);
	29423	return ir_const_void(ira, &instruction->base.base);
28620	29424
28621		ir_assert(instruction->spill_id == SpillIdRetErrCode, &instruction->base);
	29425	ir_assert(instruction->spill_id == SpillIdRetErrCode, &instruction->base.base);
28622	29426	ira->new_irb.exec->need_err_code_spill = true;
28623	29427
28624		IrInstructionSpillBegin *result = ir_build_spill_begin(&ira->new_irb, instruction->base.scope,
28625		instruction->base.source_node, operand, instruction->spill_id);
28626		return &result->base;
	29428	return ir_build_spill_begin_gen(ira, &instruction->base.base, operand, instruction->spill_id);
28627	29429	}
28628	29430
28629		static IrInstruction ir_analyze_instruction_spill_end(IrAnalyze ira, IrInstructionSpillEnd *instruction) {
28630		IrInstruction *operand = instruction->begin->operand->child;
	29431	static IrInstGen ir_analyze_instruction_spill_end(IrAnalyze ira, IrInstSrcSpillEnd *instruction) {
	29432	IrInstGen *operand = instruction->begin->operand->child;
28631	29433	if (type_is_invalid(operand->value->type))
28632		return ira->codegen->invalid_instruction;
	29434	return ira->codegen->invalid_inst_gen;
28633	29435
28634		if (ir_should_inline(ira->new_irb.exec, instruction->base.scope) \|\| !type_has_bits(operand->value->type))
	29436	if (ir_should_inline(ira->old_irb.exec, instruction->base.base.scope) \|\| !type_has_bits(operand->value->type))
28635	29437	return operand;
28636	29438
28637		ir_assert(instruction->begin->base.child->id == IrInstructionIdSpillBegin, &instruction->base);
28638		IrInstructionSpillBegin begin = reinterpret_cast<IrInstructionSpillBegin >(instruction->begin->base.child);
	29439	ir_assert(instruction->begin->base.child->id == IrInstGenIdSpillBegin, &instruction->base.base);
	29440	IrInstGenSpillBegin begin = reinterpret_cast<IrInstGenSpillBegin >(instruction->begin->base.child);
28639	29441
28640		IrInstruction *result = ir_build_spill_end(&ira->new_irb, instruction->base.scope,
28641		instruction->base.source_node, begin);
28642		result->value->type = operand->value->type;
28643		return result;
	29442	return ir_build_spill_end_gen(ira, &instruction->base.base, begin, operand->value->type);
28644	29443	}
28645	29444
28646		static IrInstruction ir_analyze_instruction_base(IrAnalyze ira, IrInstruction *instruction) {
	29445	static IrInstGen ir_analyze_instruction_base(IrAnalyze ira, IrInstSrc *instruction) {
28647	29446	switch (instruction->id) {
28648		case IrInstructionIdInvalid:
28649		case IrInstructionIdWidenOrShorten:
28650		case IrInstructionIdStructFieldPtr:
28651		case IrInstructionIdUnionFieldPtr:
28652		case IrInstructionIdOptionalWrap:
28653		case IrInstructionIdErrWrapCode:
28654		case IrInstructionIdErrWrapPayload:
28655		case IrInstructionIdCast:
28656		case IrInstructionIdDeclVarGen:
28657		case IrInstructionIdPtrCastGen:
28658		case IrInstructionIdCmpxchgGen:
28659		case IrInstructionIdArrayToVector:
28660		case IrInstructionIdVectorToArray:
28661		case IrInstructionIdPtrOfArrayToSlice:
28662		case IrInstructionIdAssertZero:
28663		case IrInstructionIdAssertNonNull:
28664		case IrInstructionIdResizeSlice:
28665		case IrInstructionIdLoadPtrGen:
28666		case IrInstructionIdBitCastGen:
28667		case IrInstructionIdCallGen:
28668		case IrInstructionIdReturnPtr:
28669		case IrInstructionIdAllocaGen:
28670		case IrInstructionIdSliceGen:
28671		case IrInstructionIdRefGen:
28672		case IrInstructionIdTestErrGen:
28673		case IrInstructionIdFrameSizeGen:
28674		case IrInstructionIdAwaitGen:
28675		case IrInstructionIdSplatGen:
28676		case IrInstructionIdVectorExtractElem:
28677		case IrInstructionIdVectorStoreElem:
28678		case IrInstructionIdAsmGen:
	29447	case IrInstSrcIdInvalid:
28679	29448	zig_unreachable();
28680	29449
28681		case IrInstructionIdReturn:
28682		return ir_analyze_instruction_return(ira, (IrInstructionReturn *)instruction);
28683		case IrInstructionIdConst:
28684		return ir_analyze_instruction_const(ira, (IrInstructionConst *)instruction);
28685		case IrInstructionIdUnOp:
28686		return ir_analyze_instruction_un_op(ira, (IrInstructionUnOp *)instruction);
28687		case IrInstructionIdBinOp:
28688		return ir_analyze_instruction_bin_op(ira, (IrInstructionBinOp *)instruction);
28689		case IrInstructionIdMergeErrSets:
28690		return ir_analyze_instruction_merge_err_sets(ira, (IrInstructionMergeErrSets *)instruction);
28691		case IrInstructionIdDeclVarSrc:
28692		return ir_analyze_instruction_decl_var(ira, (IrInstructionDeclVarSrc *)instruction);
28693		case IrInstructionIdLoadPtr:
28694		return ir_analyze_instruction_load_ptr(ira, (IrInstructionLoadPtr *)instruction);
28695		case IrInstructionIdStorePtr:
28696		return ir_analyze_instruction_store_ptr(ira, (IrInstructionStorePtr *)instruction);
28697		case IrInstructionIdElemPtr:
28698		return ir_analyze_instruction_elem_ptr(ira, (IrInstructionElemPtr *)instruction);
28699		case IrInstructionIdVarPtr:
28700		return ir_analyze_instruction_var_ptr(ira, (IrInstructionVarPtr *)instruction);
28701		case IrInstructionIdFieldPtr:
28702		return ir_analyze_instruction_field_ptr(ira, (IrInstructionFieldPtr *)instruction);
28703		case IrInstructionIdCallSrc:
28704		return ir_analyze_instruction_call(ira, (IrInstructionCallSrc *)instruction);
28705		case IrInstructionIdCallSrcArgs:
28706		return ir_analyze_instruction_call_args(ira, (IrInstructionCallSrcArgs *)instruction);
28707		case IrInstructionIdCallExtra:
28708		return ir_analyze_instruction_call_extra(ira, (IrInstructionCallExtra *)instruction);
28709		case IrInstructionIdBr:
28710		return ir_analyze_instruction_br(ira, (IrInstructionBr *)instruction);
28711		case IrInstructionIdCondBr:
28712		return ir_analyze_instruction_cond_br(ira, (IrInstructionCondBr *)instruction);
28713		case IrInstructionIdUnreachable:
28714		return ir_analyze_instruction_unreachable(ira, (IrInstructionUnreachable *)instruction);
28715		case IrInstructionIdPhi:
28716		return ir_analyze_instruction_phi(ira, (IrInstructionPhi *)instruction);
28717		case IrInstructionIdTypeOf:
28718		return ir_analyze_instruction_typeof(ira, (IrInstructionTypeOf *)instruction);
28719		case IrInstructionIdSetCold:
28720		return ir_analyze_instruction_set_cold(ira, (IrInstructionSetCold *)instruction);
28721		case IrInstructionIdSetRuntimeSafety:
28722		return ir_analyze_instruction_set_runtime_safety(ira, (IrInstructionSetRuntimeSafety *)instruction);
28723		case IrInstructionIdSetFloatMode:
28724		return ir_analyze_instruction_set_float_mode(ira, (IrInstructionSetFloatMode *)instruction);
28725		case IrInstructionIdAnyFrameType:
28726		return ir_analyze_instruction_any_frame_type(ira, (IrInstructionAnyFrameType *)instruction);
28727		case IrInstructionIdSliceType:
28728		return ir_analyze_instruction_slice_type(ira, (IrInstructionSliceType *)instruction);
28729		case IrInstructionIdAsmSrc:
28730		return ir_analyze_instruction_asm(ira, (IrInstructionAsmSrc *)instruction);
28731		case IrInstructionIdArrayType:
28732		return ir_analyze_instruction_array_type(ira, (IrInstructionArrayType *)instruction);
28733		case IrInstructionIdSizeOf:
28734		return ir_analyze_instruction_size_of(ira, (IrInstructionSizeOf *)instruction);
28735		case IrInstructionIdTestNonNull:
28736		return ir_analyze_instruction_test_non_null(ira, (IrInstructionTestNonNull *)instruction);
28737		case IrInstructionIdOptionalUnwrapPtr:
28738		return ir_analyze_instruction_optional_unwrap_ptr(ira, (IrInstructionOptionalUnwrapPtr *)instruction);
28739		case IrInstructionIdClz:
28740		return ir_analyze_instruction_clz(ira, (IrInstructionClz *)instruction);
28741		case IrInstructionIdCtz:
28742		return ir_analyze_instruction_ctz(ira, (IrInstructionCtz *)instruction);
28743		case IrInstructionIdPopCount:
28744		return ir_analyze_instruction_pop_count(ira, (IrInstructionPopCount *)instruction);
28745		case IrInstructionIdBswap:
28746		return ir_analyze_instruction_bswap(ira, (IrInstructionBswap *)instruction);
28747		case IrInstructionIdBitReverse:
28748		return ir_analyze_instruction_bit_reverse(ira, (IrInstructionBitReverse *)instruction);
28749		case IrInstructionIdSwitchBr:
28750		return ir_analyze_instruction_switch_br(ira, (IrInstructionSwitchBr *)instruction);
28751		case IrInstructionIdSwitchTarget:
28752		return ir_analyze_instruction_switch_target(ira, (IrInstructionSwitchTarget *)instruction);
28753		case IrInstructionIdSwitchVar:
28754		return ir_analyze_instruction_switch_var(ira, (IrInstructionSwitchVar *)instruction);
28755		case IrInstructionIdSwitchElseVar:
28756		return ir_analyze_instruction_switch_else_var(ira, (IrInstructionSwitchElseVar *)instruction);
28757		case IrInstructionIdUnionTag:
28758		return ir_analyze_instruction_union_tag(ira, (IrInstructionUnionTag *)instruction);
28759		case IrInstructionIdImport:
28760		return ir_analyze_instruction_import(ira, (IrInstructionImport *)instruction);
28761		case IrInstructionIdRef:
28762		return ir_analyze_instruction_ref(ira, (IrInstructionRef *)instruction);
28763		case IrInstructionIdContainerInitList:
28764		return ir_analyze_instruction_container_init_list(ira, (IrInstructionContainerInitList *)instruction);
28765		case IrInstructionIdContainerInitFields:
28766		return ir_analyze_instruction_container_init_fields(ira, (IrInstructionContainerInitFields *)instruction);
28767		case IrInstructionIdCompileErr:
28768		return ir_analyze_instruction_compile_err(ira, (IrInstructionCompileErr *)instruction);
28769		case IrInstructionIdCompileLog:
28770		return ir_analyze_instruction_compile_log(ira, (IrInstructionCompileLog *)instruction);
28771		case IrInstructionIdErrName:
28772		return ir_analyze_instruction_err_name(ira, (IrInstructionErrName *)instruction);
28773		case IrInstructionIdTypeName:
28774		return ir_analyze_instruction_type_name(ira, (IrInstructionTypeName *)instruction);
28775		case IrInstructionIdCImport:
28776		return ir_analyze_instruction_c_import(ira, (IrInstructionCImport *)instruction);
28777		case IrInstructionIdCInclude:
28778		return ir_analyze_instruction_c_include(ira, (IrInstructionCInclude *)instruction);
28779		case IrInstructionIdCDefine:
28780		return ir_analyze_instruction_c_define(ira, (IrInstructionCDefine *)instruction);
28781		case IrInstructionIdCUndef:
28782		return ir_analyze_instruction_c_undef(ira, (IrInstructionCUndef *)instruction);
28783		case IrInstructionIdEmbedFile:
28784		return ir_analyze_instruction_embed_file(ira, (IrInstructionEmbedFile *)instruction);
28785		case IrInstructionIdCmpxchgSrc:
28786		return ir_analyze_instruction_cmpxchg(ira, (IrInstructionCmpxchgSrc *)instruction);
28787		case IrInstructionIdFence:
28788		return ir_analyze_instruction_fence(ira, (IrInstructionFence *)instruction);
28789		case IrInstructionIdTruncate:
28790		return ir_analyze_instruction_truncate(ira, (IrInstructionTruncate *)instruction);
28791		case IrInstructionIdIntCast:
28792		return ir_analyze_instruction_int_cast(ira, (IrInstructionIntCast *)instruction);
28793		case IrInstructionIdFloatCast:
28794		return ir_analyze_instruction_float_cast(ira, (IrInstructionFloatCast *)instruction);
28795		case IrInstructionIdErrSetCast:
28796		return ir_analyze_instruction_err_set_cast(ira, (IrInstructionErrSetCast *)instruction);
28797		case IrInstructionIdFromBytes:
28798		return ir_analyze_instruction_from_bytes(ira, (IrInstructionFromBytes *)instruction);
28799		case IrInstructionIdToBytes:
28800		return ir_analyze_instruction_to_bytes(ira, (IrInstructionToBytes *)instruction);
28801		case IrInstructionIdIntToFloat:
28802		return ir_analyze_instruction_int_to_float(ira, (IrInstructionIntToFloat *)instruction);
28803		case IrInstructionIdFloatToInt:
28804		return ir_analyze_instruction_float_to_int(ira, (IrInstructionFloatToInt *)instruction);
28805		case IrInstructionIdBoolToInt:
28806		return ir_analyze_instruction_bool_to_int(ira, (IrInstructionBoolToInt *)instruction);
28807		case IrInstructionIdIntType:
28808		return ir_analyze_instruction_int_type(ira, (IrInstructionIntType *)instruction);
28809		case IrInstructionIdVectorType:
28810		return ir_analyze_instruction_vector_type(ira, (IrInstructionVectorType *)instruction);
28811		case IrInstructionIdShuffleVector:
28812		return ir_analyze_instruction_shuffle_vector(ira, (IrInstructionShuffleVector *)instruction);
28813		case IrInstructionIdSplatSrc:
28814		return ir_analyze_instruction_splat(ira, (IrInstructionSplatSrc *)instruction);
28815		case IrInstructionIdBoolNot:
28816		return ir_analyze_instruction_bool_not(ira, (IrInstructionBoolNot *)instruction);
28817		case IrInstructionIdMemset:
28818		return ir_analyze_instruction_memset(ira, (IrInstructionMemset *)instruction);
28819		case IrInstructionIdMemcpy:
28820		return ir_analyze_instruction_memcpy(ira, (IrInstructionMemcpy *)instruction);
28821		case IrInstructionIdSliceSrc:
28822		return ir_analyze_instruction_slice(ira, (IrInstructionSliceSrc *)instruction);
28823		case IrInstructionIdMemberCount:
28824		return ir_analyze_instruction_member_count(ira, (IrInstructionMemberCount *)instruction);
28825		case IrInstructionIdMemberType:
28826		return ir_analyze_instruction_member_type(ira, (IrInstructionMemberType *)instruction);
28827		case IrInstructionIdMemberName:
28828		return ir_analyze_instruction_member_name(ira, (IrInstructionMemberName *)instruction);
28829		case IrInstructionIdBreakpoint:
28830		return ir_analyze_instruction_breakpoint(ira, (IrInstructionBreakpoint *)instruction);
28831		case IrInstructionIdReturnAddress:
28832		return ir_analyze_instruction_return_address(ira, (IrInstructionReturnAddress *)instruction);
28833		case IrInstructionIdFrameAddress:
28834		return ir_analyze_instruction_frame_address(ira, (IrInstructionFrameAddress *)instruction);
28835		case IrInstructionIdFrameHandle:
28836		return ir_analyze_instruction_frame_handle(ira, (IrInstructionFrameHandle *)instruction);
28837		case IrInstructionIdFrameType:
28838		return ir_analyze_instruction_frame_type(ira, (IrInstructionFrameType *)instruction);
28839		case IrInstructionIdFrameSizeSrc:
28840		return ir_analyze_instruction_frame_size(ira, (IrInstructionFrameSizeSrc *)instruction);
28841		case IrInstructionIdAlignOf:
28842		return ir_analyze_instruction_align_of(ira, (IrInstructionAlignOf *)instruction);
28843		case IrInstructionIdOverflowOp:
28844		return ir_analyze_instruction_overflow_op(ira, (IrInstructionOverflowOp *)instruction);
28845		case IrInstructionIdTestErrSrc:
28846		return ir_analyze_instruction_test_err(ira, (IrInstructionTestErrSrc *)instruction);
28847		case IrInstructionIdUnwrapErrCode:
28848		return ir_analyze_instruction_unwrap_err_code(ira, (IrInstructionUnwrapErrCode *)instruction);
28849		case IrInstructionIdUnwrapErrPayload:
28850		return ir_analyze_instruction_unwrap_err_payload(ira, (IrInstructionUnwrapErrPayload *)instruction);
28851		case IrInstructionIdFnProto:
28852		return ir_analyze_instruction_fn_proto(ira, (IrInstructionFnProto *)instruction);
28853		case IrInstructionIdTestComptime:
28854		return ir_analyze_instruction_test_comptime(ira, (IrInstructionTestComptime *)instruction);
28855		case IrInstructionIdCheckSwitchProngs:
28856		return ir_analyze_instruction_check_switch_prongs(ira, (IrInstructionCheckSwitchProngs *)instruction);
28857		case IrInstructionIdCheckStatementIsVoid:
28858		return ir_analyze_instruction_check_statement_is_void(ira, (IrInstructionCheckStatementIsVoid *)instruction);
28859		case IrInstructionIdDeclRef:
28860		return ir_analyze_instruction_decl_ref(ira, (IrInstructionDeclRef *)instruction);
28861		case IrInstructionIdPanic:
28862		return ir_analyze_instruction_panic(ira, (IrInstructionPanic *)instruction);
28863		case IrInstructionIdPtrCastSrc:
28864		return ir_analyze_instruction_ptr_cast(ira, (IrInstructionPtrCastSrc *)instruction);
28865		case IrInstructionIdIntToPtr:
28866		return ir_analyze_instruction_int_to_ptr(ira, (IrInstructionIntToPtr *)instruction);
28867		case IrInstructionIdPtrToInt:
28868		return ir_analyze_instruction_ptr_to_int(ira, (IrInstructionPtrToInt *)instruction);
28869		case IrInstructionIdTagName:
28870		return ir_analyze_instruction_enum_tag_name(ira, (IrInstructionTagName *)instruction);
28871		case IrInstructionIdFieldParentPtr:
28872		return ir_analyze_instruction_field_parent_ptr(ira, (IrInstructionFieldParentPtr *)instruction);
28873		case IrInstructionIdByteOffsetOf:
28874		return ir_analyze_instruction_byte_offset_of(ira, (IrInstructionByteOffsetOf *)instruction);
28875		case IrInstructionIdBitOffsetOf:
28876		return ir_analyze_instruction_bit_offset_of(ira, (IrInstructionBitOffsetOf *)instruction);
28877		case IrInstructionIdTypeInfo:
28878		return ir_analyze_instruction_type_info(ira, (IrInstructionTypeInfo *) instruction);
28879		case IrInstructionIdType:
28880		return ir_analyze_instruction_type(ira, (IrInstructionType *)instruction);
28881		case IrInstructionIdHasField:
28882		return ir_analyze_instruction_has_field(ira, (IrInstructionHasField *) instruction);
28883		case IrInstructionIdTypeId:
28884		return ir_analyze_instruction_type_id(ira, (IrInstructionTypeId *)instruction);
28885		case IrInstructionIdSetEvalBranchQuota:
28886		return ir_analyze_instruction_set_eval_branch_quota(ira, (IrInstructionSetEvalBranchQuota *)instruction);
28887		case IrInstructionIdPtrType:
28888		return ir_analyze_instruction_ptr_type(ira, (IrInstructionPtrType *)instruction);
28889		case IrInstructionIdAlignCast:
28890		return ir_analyze_instruction_align_cast(ira, (IrInstructionAlignCast *)instruction);
28891		case IrInstructionIdImplicitCast:
28892		return ir_analyze_instruction_implicit_cast(ira, (IrInstructionImplicitCast *)instruction);
28893		case IrInstructionIdResolveResult:
28894		return ir_analyze_instruction_resolve_result(ira, (IrInstructionResolveResult *)instruction);
28895		case IrInstructionIdResetResult:
28896		return ir_analyze_instruction_reset_result(ira, (IrInstructionResetResult *)instruction);
28897		case IrInstructionIdOpaqueType:
28898		return ir_analyze_instruction_opaque_type(ira, (IrInstructionOpaqueType *)instruction);
28899		case IrInstructionIdSetAlignStack:
28900		return ir_analyze_instruction_set_align_stack(ira, (IrInstructionSetAlignStack *)instruction);
28901		case IrInstructionIdArgType:
28902		return ir_analyze_instruction_arg_type(ira, (IrInstructionArgType *)instruction);
28903		case IrInstructionIdTagType:
28904		return ir_analyze_instruction_tag_type(ira, (IrInstructionTagType *)instruction);
28905		case IrInstructionIdExport:
28906		return ir_analyze_instruction_export(ira, (IrInstructionExport *)instruction);
28907		case IrInstructionIdErrorReturnTrace:
28908		return ir_analyze_instruction_error_return_trace(ira, (IrInstructionErrorReturnTrace *)instruction);
28909		case IrInstructionIdErrorUnion:
28910		return ir_analyze_instruction_error_union(ira, (IrInstructionErrorUnion *)instruction);
28911		case IrInstructionIdAtomicRmw:
28912		return ir_analyze_instruction_atomic_rmw(ira, (IrInstructionAtomicRmw *)instruction);
28913		case IrInstructionIdAtomicLoad:
28914		return ir_analyze_instruction_atomic_load(ira, (IrInstructionAtomicLoad *)instruction);
28915		case IrInstructionIdAtomicStore:
28916		return ir_analyze_instruction_atomic_store(ira, (IrInstructionAtomicStore *)instruction);
28917		case IrInstructionIdSaveErrRetAddr:
28918		return ir_analyze_instruction_save_err_ret_addr(ira, (IrInstructionSaveErrRetAddr *)instruction);
28919		case IrInstructionIdAddImplicitReturnType:
28920		return ir_analyze_instruction_add_implicit_return_type(ira, (IrInstructionAddImplicitReturnType *)instruction);
28921		case IrInstructionIdFloatOp:
28922		return ir_analyze_instruction_float_op(ira, (IrInstructionFloatOp *)instruction);
28923		case IrInstructionIdMulAdd:
28924		return ir_analyze_instruction_mul_add(ira, (IrInstructionMulAdd *)instruction);
28925		case IrInstructionIdIntToErr:
28926		return ir_analyze_instruction_int_to_err(ira, (IrInstructionIntToErr *)instruction);
28927		case IrInstructionIdErrToInt:
28928		return ir_analyze_instruction_err_to_int(ira, (IrInstructionErrToInt *)instruction);
28929		case IrInstructionIdIntToEnum:
28930		return ir_analyze_instruction_int_to_enum(ira, (IrInstructionIntToEnum *)instruction);
28931		case IrInstructionIdEnumToInt:
28932		return ir_analyze_instruction_enum_to_int(ira, (IrInstructionEnumToInt *)instruction);
28933		case IrInstructionIdCheckRuntimeScope:
28934		return ir_analyze_instruction_check_runtime_scope(ira, (IrInstructionCheckRuntimeScope *)instruction);
28935		case IrInstructionIdHasDecl:
28936		return ir_analyze_instruction_has_decl(ira, (IrInstructionHasDecl *)instruction);
28937		case IrInstructionIdUndeclaredIdent:
28938		return ir_analyze_instruction_undeclared_ident(ira, (IrInstructionUndeclaredIdent *)instruction);
28939		case IrInstructionIdAllocaSrc:
	29450	case IrInstSrcIdReturn:
	29451	return ir_analyze_instruction_return(ira, (IrInstSrcReturn *)instruction);
	29452	case IrInstSrcIdConst:
	29453	return ir_analyze_instruction_const(ira, (IrInstSrcConst *)instruction);
	29454	case IrInstSrcIdUnOp:
	29455	return ir_analyze_instruction_un_op(ira, (IrInstSrcUnOp *)instruction);
	29456	case IrInstSrcIdBinOp:
	29457	return ir_analyze_instruction_bin_op(ira, (IrInstSrcBinOp *)instruction);
	29458	case IrInstSrcIdMergeErrSets:
	29459	return ir_analyze_instruction_merge_err_sets(ira, (IrInstSrcMergeErrSets *)instruction);
	29460	case IrInstSrcIdDeclVar:
	29461	return ir_analyze_instruction_decl_var(ira, (IrInstSrcDeclVar *)instruction);
	29462	case IrInstSrcIdLoadPtr:
	29463	return ir_analyze_instruction_load_ptr(ira, (IrInstSrcLoadPtr *)instruction);
	29464	case IrInstSrcIdStorePtr:
	29465	return ir_analyze_instruction_store_ptr(ira, (IrInstSrcStorePtr *)instruction);
	29466	case IrInstSrcIdElemPtr:
	29467	return ir_analyze_instruction_elem_ptr(ira, (IrInstSrcElemPtr *)instruction);
	29468	case IrInstSrcIdVarPtr:
	29469	return ir_analyze_instruction_var_ptr(ira, (IrInstSrcVarPtr *)instruction);
	29470	case IrInstSrcIdFieldPtr:
	29471	return ir_analyze_instruction_field_ptr(ira, (IrInstSrcFieldPtr *)instruction);
	29472	case IrInstSrcIdCall:
	29473	return ir_analyze_instruction_call(ira, (IrInstSrcCall *)instruction);
	29474	case IrInstSrcIdCallArgs:
	29475	return ir_analyze_instruction_call_args(ira, (IrInstSrcCallArgs *)instruction);
	29476	case IrInstSrcIdCallExtra:
	29477	return ir_analyze_instruction_call_extra(ira, (IrInstSrcCallExtra *)instruction);
	29478	case IrInstSrcIdBr:
	29479	return ir_analyze_instruction_br(ira, (IrInstSrcBr *)instruction);
	29480	case IrInstSrcIdCondBr:
	29481	return ir_analyze_instruction_cond_br(ira, (IrInstSrcCondBr *)instruction);
	29482	case IrInstSrcIdUnreachable:
	29483	return ir_analyze_instruction_unreachable(ira, (IrInstSrcUnreachable *)instruction);
	29484	case IrInstSrcIdPhi:
	29485	return ir_analyze_instruction_phi(ira, (IrInstSrcPhi *)instruction);
	29486	case IrInstSrcIdTypeOf:
	29487	return ir_analyze_instruction_typeof(ira, (IrInstSrcTypeOf *)instruction);
	29488	case IrInstSrcIdSetCold:
	29489	return ir_analyze_instruction_set_cold(ira, (IrInstSrcSetCold *)instruction);
	29490	case IrInstSrcIdSetRuntimeSafety:
	29491	return ir_analyze_instruction_set_runtime_safety(ira, (IrInstSrcSetRuntimeSafety *)instruction);
	29492	case IrInstSrcIdSetFloatMode:
	29493	return ir_analyze_instruction_set_float_mode(ira, (IrInstSrcSetFloatMode *)instruction);
	29494	case IrInstSrcIdAnyFrameType:
	29495	return ir_analyze_instruction_any_frame_type(ira, (IrInstSrcAnyFrameType *)instruction);
	29496	case IrInstSrcIdSliceType:
	29497	return ir_analyze_instruction_slice_type(ira, (IrInstSrcSliceType *)instruction);
	29498	case IrInstSrcIdAsm:
	29499	return ir_analyze_instruction_asm(ira, (IrInstSrcAsm *)instruction);
	29500	case IrInstSrcIdArrayType:
	29501	return ir_analyze_instruction_array_type(ira, (IrInstSrcArrayType *)instruction);
	29502	case IrInstSrcIdSizeOf:
	29503	return ir_analyze_instruction_size_of(ira, (IrInstSrcSizeOf *)instruction);
	29504	case IrInstSrcIdTestNonNull:
	29505	return ir_analyze_instruction_test_non_null(ira, (IrInstSrcTestNonNull *)instruction);
	29506	case IrInstSrcIdOptionalUnwrapPtr:
	29507	return ir_analyze_instruction_optional_unwrap_ptr(ira, (IrInstSrcOptionalUnwrapPtr *)instruction);
	29508	case IrInstSrcIdClz:
	29509	return ir_analyze_instruction_clz(ira, (IrInstSrcClz *)instruction);
	29510	case IrInstSrcIdCtz:
	29511	return ir_analyze_instruction_ctz(ira, (IrInstSrcCtz *)instruction);
	29512	case IrInstSrcIdPopCount:
	29513	return ir_analyze_instruction_pop_count(ira, (IrInstSrcPopCount *)instruction);
	29514	case IrInstSrcIdBswap:
	29515	return ir_analyze_instruction_bswap(ira, (IrInstSrcBswap *)instruction);
	29516	case IrInstSrcIdBitReverse:
	29517	return ir_analyze_instruction_bit_reverse(ira, (IrInstSrcBitReverse *)instruction);
	29518	case IrInstSrcIdSwitchBr:
	29519	return ir_analyze_instruction_switch_br(ira, (IrInstSrcSwitchBr *)instruction);
	29520	case IrInstSrcIdSwitchTarget:
	29521	return ir_analyze_instruction_switch_target(ira, (IrInstSrcSwitchTarget *)instruction);
	29522	case IrInstSrcIdSwitchVar:
	29523	return ir_analyze_instruction_switch_var(ira, (IrInstSrcSwitchVar *)instruction);
	29524	case IrInstSrcIdSwitchElseVar:
	29525	return ir_analyze_instruction_switch_else_var(ira, (IrInstSrcSwitchElseVar *)instruction);
	29526	case IrInstSrcIdImport:
	29527	return ir_analyze_instruction_import(ira, (IrInstSrcImport *)instruction);
	29528	case IrInstSrcIdRef:
	29529	return ir_analyze_instruction_ref(ira, (IrInstSrcRef *)instruction);
	29530	case IrInstSrcIdContainerInitList:
	29531	return ir_analyze_instruction_container_init_list(ira, (IrInstSrcContainerInitList *)instruction);
	29532	case IrInstSrcIdContainerInitFields:
	29533	return ir_analyze_instruction_container_init_fields(ira, (IrInstSrcContainerInitFields *)instruction);
	29534	case IrInstSrcIdCompileErr:
	29535	return ir_analyze_instruction_compile_err(ira, (IrInstSrcCompileErr *)instruction);
	29536	case IrInstSrcIdCompileLog:
	29537	return ir_analyze_instruction_compile_log(ira, (IrInstSrcCompileLog *)instruction);
	29538	case IrInstSrcIdErrName:
	29539	return ir_analyze_instruction_err_name(ira, (IrInstSrcErrName *)instruction);
	29540	case IrInstSrcIdTypeName:
	29541	return ir_analyze_instruction_type_name(ira, (IrInstSrcTypeName *)instruction);
	29542	case IrInstSrcIdCImport:
	29543	return ir_analyze_instruction_c_import(ira, (IrInstSrcCImport *)instruction);
	29544	case IrInstSrcIdCInclude:
	29545	return ir_analyze_instruction_c_include(ira, (IrInstSrcCInclude *)instruction);
	29546	case IrInstSrcIdCDefine:
	29547	return ir_analyze_instruction_c_define(ira, (IrInstSrcCDefine *)instruction);
	29548	case IrInstSrcIdCUndef:
	29549	return ir_analyze_instruction_c_undef(ira, (IrInstSrcCUndef *)instruction);
	29550	case IrInstSrcIdEmbedFile:
	29551	return ir_analyze_instruction_embed_file(ira, (IrInstSrcEmbedFile *)instruction);
	29552	case IrInstSrcIdCmpxchg:
	29553	return ir_analyze_instruction_cmpxchg(ira, (IrInstSrcCmpxchg *)instruction);
	29554	case IrInstSrcIdFence:
	29555	return ir_analyze_instruction_fence(ira, (IrInstSrcFence *)instruction);
	29556	case IrInstSrcIdTruncate:
	29557	return ir_analyze_instruction_truncate(ira, (IrInstSrcTruncate *)instruction);
	29558	case IrInstSrcIdIntCast:
	29559	return ir_analyze_instruction_int_cast(ira, (IrInstSrcIntCast *)instruction);
	29560	case IrInstSrcIdFloatCast:
	29561	return ir_analyze_instruction_float_cast(ira, (IrInstSrcFloatCast *)instruction);
	29562	case IrInstSrcIdErrSetCast:
	29563	return ir_analyze_instruction_err_set_cast(ira, (IrInstSrcErrSetCast *)instruction);
	29564	case IrInstSrcIdFromBytes:
	29565	return ir_analyze_instruction_from_bytes(ira, (IrInstSrcFromBytes *)instruction);
	29566	case IrInstSrcIdToBytes:
	29567	return ir_analyze_instruction_to_bytes(ira, (IrInstSrcToBytes *)instruction);
	29568	case IrInstSrcIdIntToFloat:
	29569	return ir_analyze_instruction_int_to_float(ira, (IrInstSrcIntToFloat *)instruction);
	29570	case IrInstSrcIdFloatToInt:
	29571	return ir_analyze_instruction_float_to_int(ira, (IrInstSrcFloatToInt *)instruction);
	29572	case IrInstSrcIdBoolToInt:
	29573	return ir_analyze_instruction_bool_to_int(ira, (IrInstSrcBoolToInt *)instruction);
	29574	case IrInstSrcIdIntType:
	29575	return ir_analyze_instruction_int_type(ira, (IrInstSrcIntType *)instruction);
	29576	case IrInstSrcIdVectorType:
	29577	return ir_analyze_instruction_vector_type(ira, (IrInstSrcVectorType *)instruction);
	29578	case IrInstSrcIdShuffleVector:
	29579	return ir_analyze_instruction_shuffle_vector(ira, (IrInstSrcShuffleVector *)instruction);
	29580	case IrInstSrcIdSplat:
	29581	return ir_analyze_instruction_splat(ira, (IrInstSrcSplat *)instruction);
	29582	case IrInstSrcIdBoolNot:
	29583	return ir_analyze_instruction_bool_not(ira, (IrInstSrcBoolNot *)instruction);
	29584	case IrInstSrcIdMemset:
	29585	return ir_analyze_instruction_memset(ira, (IrInstSrcMemset *)instruction);
	29586	case IrInstSrcIdMemcpy:
	29587	return ir_analyze_instruction_memcpy(ira, (IrInstSrcMemcpy *)instruction);
	29588	case IrInstSrcIdSlice:
	29589	return ir_analyze_instruction_slice(ira, (IrInstSrcSlice *)instruction);
	29590	case IrInstSrcIdMemberCount:
	29591	return ir_analyze_instruction_member_count(ira, (IrInstSrcMemberCount *)instruction);
	29592	case IrInstSrcIdMemberType:
	29593	return ir_analyze_instruction_member_type(ira, (IrInstSrcMemberType *)instruction);
	29594	case IrInstSrcIdMemberName:
	29595	return ir_analyze_instruction_member_name(ira, (IrInstSrcMemberName *)instruction);
	29596	case IrInstSrcIdBreakpoint:
	29597	return ir_analyze_instruction_breakpoint(ira, (IrInstSrcBreakpoint *)instruction);
	29598	case IrInstSrcIdReturnAddress:
	29599	return ir_analyze_instruction_return_address(ira, (IrInstSrcReturnAddress *)instruction);
	29600	case IrInstSrcIdFrameAddress:
	29601	return ir_analyze_instruction_frame_address(ira, (IrInstSrcFrameAddress *)instruction);
	29602	case IrInstSrcIdFrameHandle:
	29603	return ir_analyze_instruction_frame_handle(ira, (IrInstSrcFrameHandle *)instruction);
	29604	case IrInstSrcIdFrameType:
	29605	return ir_analyze_instruction_frame_type(ira, (IrInstSrcFrameType *)instruction);
	29606	case IrInstSrcIdFrameSize:
	29607	return ir_analyze_instruction_frame_size(ira, (IrInstSrcFrameSize *)instruction);
	29608	case IrInstSrcIdAlignOf:
	29609	return ir_analyze_instruction_align_of(ira, (IrInstSrcAlignOf *)instruction);
	29610	case IrInstSrcIdOverflowOp:
	29611	return ir_analyze_instruction_overflow_op(ira, (IrInstSrcOverflowOp *)instruction);
	29612	case IrInstSrcIdTestErr:
	29613	return ir_analyze_instruction_test_err(ira, (IrInstSrcTestErr *)instruction);
	29614	case IrInstSrcIdUnwrapErrCode:
	29615	return ir_analyze_instruction_unwrap_err_code(ira, (IrInstSrcUnwrapErrCode *)instruction);
	29616	case IrInstSrcIdUnwrapErrPayload:
	29617	return ir_analyze_instruction_unwrap_err_payload(ira, (IrInstSrcUnwrapErrPayload *)instruction);
	29618	case IrInstSrcIdFnProto:
	29619	return ir_analyze_instruction_fn_proto(ira, (IrInstSrcFnProto *)instruction);
	29620	case IrInstSrcIdTestComptime:
	29621	return ir_analyze_instruction_test_comptime(ira, (IrInstSrcTestComptime *)instruction);
	29622	case IrInstSrcIdCheckSwitchProngs:
	29623	return ir_analyze_instruction_check_switch_prongs(ira, (IrInstSrcCheckSwitchProngs *)instruction);
	29624	case IrInstSrcIdCheckStatementIsVoid:
	29625	return ir_analyze_instruction_check_statement_is_void(ira, (IrInstSrcCheckStatementIsVoid *)instruction);
	29626	case IrInstSrcIdDeclRef:
	29627	return ir_analyze_instruction_decl_ref(ira, (IrInstSrcDeclRef *)instruction);
	29628	case IrInstSrcIdPanic:
	29629	return ir_analyze_instruction_panic(ira, (IrInstSrcPanic *)instruction);
	29630	case IrInstSrcIdPtrCast:
	29631	return ir_analyze_instruction_ptr_cast(ira, (IrInstSrcPtrCast *)instruction);
	29632	case IrInstSrcIdIntToPtr:
	29633	return ir_analyze_instruction_int_to_ptr(ira, (IrInstSrcIntToPtr *)instruction);
	29634	case IrInstSrcIdPtrToInt:
	29635	return ir_analyze_instruction_ptr_to_int(ira, (IrInstSrcPtrToInt *)instruction);
	29636	case IrInstSrcIdTagName:
	29637	return ir_analyze_instruction_enum_tag_name(ira, (IrInstSrcTagName *)instruction);
	29638	case IrInstSrcIdFieldParentPtr:
	29639	return ir_analyze_instruction_field_parent_ptr(ira, (IrInstSrcFieldParentPtr *)instruction);
	29640	case IrInstSrcIdByteOffsetOf:
	29641	return ir_analyze_instruction_byte_offset_of(ira, (IrInstSrcByteOffsetOf *)instruction);
	29642	case IrInstSrcIdBitOffsetOf:
	29643	return ir_analyze_instruction_bit_offset_of(ira, (IrInstSrcBitOffsetOf *)instruction);
	29644	case IrInstSrcIdTypeInfo:
	29645	return ir_analyze_instruction_type_info(ira, (IrInstSrcTypeInfo *) instruction);
	29646	case IrInstSrcIdType:
	29647	return ir_analyze_instruction_type(ira, (IrInstSrcType *)instruction);
	29648	case IrInstSrcIdHasField:
	29649	return ir_analyze_instruction_has_field(ira, (IrInstSrcHasField *) instruction);
	29650	case IrInstSrcIdTypeId:
	29651	return ir_analyze_instruction_type_id(ira, (IrInstSrcTypeId *)instruction);
	29652	case IrInstSrcIdSetEvalBranchQuota:
	29653	return ir_analyze_instruction_set_eval_branch_quota(ira, (IrInstSrcSetEvalBranchQuota *)instruction);
	29654	case IrInstSrcIdPtrType:
	29655	return ir_analyze_instruction_ptr_type(ira, (IrInstSrcPtrType *)instruction);
	29656	case IrInstSrcIdAlignCast:
	29657	return ir_analyze_instruction_align_cast(ira, (IrInstSrcAlignCast *)instruction);
	29658	case IrInstSrcIdImplicitCast:
	29659	return ir_analyze_instruction_implicit_cast(ira, (IrInstSrcImplicitCast *)instruction);
	29660	case IrInstSrcIdResolveResult:
	29661	return ir_analyze_instruction_resolve_result(ira, (IrInstSrcResolveResult *)instruction);
	29662	case IrInstSrcIdResetResult:
	29663	return ir_analyze_instruction_reset_result(ira, (IrInstSrcResetResult *)instruction);
	29664	case IrInstSrcIdOpaqueType:
	29665	return ir_analyze_instruction_opaque_type(ira, (IrInstSrcOpaqueType *)instruction);
	29666	case IrInstSrcIdSetAlignStack:
	29667	return ir_analyze_instruction_set_align_stack(ira, (IrInstSrcSetAlignStack *)instruction);
	29668	case IrInstSrcIdArgType:
	29669	return ir_analyze_instruction_arg_type(ira, (IrInstSrcArgType *)instruction);
	29670	case IrInstSrcIdTagType:
	29671	return ir_analyze_instruction_tag_type(ira, (IrInstSrcTagType *)instruction);
	29672	case IrInstSrcIdExport:
	29673	return ir_analyze_instruction_export(ira, (IrInstSrcExport *)instruction);
	29674	case IrInstSrcIdErrorReturnTrace:
	29675	return ir_analyze_instruction_error_return_trace(ira, (IrInstSrcErrorReturnTrace *)instruction);
	29676	case IrInstSrcIdErrorUnion:
	29677	return ir_analyze_instruction_error_union(ira, (IrInstSrcErrorUnion *)instruction);
	29678	case IrInstSrcIdAtomicRmw:
	29679	return ir_analyze_instruction_atomic_rmw(ira, (IrInstSrcAtomicRmw *)instruction);
	29680	case IrInstSrcIdAtomicLoad:
	29681	return ir_analyze_instruction_atomic_load(ira, (IrInstSrcAtomicLoad *)instruction);
	29682	case IrInstSrcIdAtomicStore:
	29683	return ir_analyze_instruction_atomic_store(ira, (IrInstSrcAtomicStore *)instruction);
	29684	case IrInstSrcIdSaveErrRetAddr:
	29685	return ir_analyze_instruction_save_err_ret_addr(ira, (IrInstSrcSaveErrRetAddr *)instruction);
	29686	case IrInstSrcIdAddImplicitReturnType:
	29687	return ir_analyze_instruction_add_implicit_return_type(ira, (IrInstSrcAddImplicitReturnType *)instruction);
	29688	case IrInstSrcIdFloatOp:
	29689	return ir_analyze_instruction_float_op(ira, (IrInstSrcFloatOp *)instruction);
	29690	case IrInstSrcIdMulAdd:
	29691	return ir_analyze_instruction_mul_add(ira, (IrInstSrcMulAdd *)instruction);
	29692	case IrInstSrcIdIntToErr:
	29693	return ir_analyze_instruction_int_to_err(ira, (IrInstSrcIntToErr *)instruction);
	29694	case IrInstSrcIdErrToInt:
	29695	return ir_analyze_instruction_err_to_int(ira, (IrInstSrcErrToInt *)instruction);
	29696	case IrInstSrcIdIntToEnum:
	29697	return ir_analyze_instruction_int_to_enum(ira, (IrInstSrcIntToEnum *)instruction);
	29698	case IrInstSrcIdEnumToInt:
	29699	return ir_analyze_instruction_enum_to_int(ira, (IrInstSrcEnumToInt *)instruction);
	29700	case IrInstSrcIdCheckRuntimeScope:
	29701	return ir_analyze_instruction_check_runtime_scope(ira, (IrInstSrcCheckRuntimeScope *)instruction);
	29702	case IrInstSrcIdHasDecl:
	29703	return ir_analyze_instruction_has_decl(ira, (IrInstSrcHasDecl *)instruction);
	29704	case IrInstSrcIdUndeclaredIdent:
	29705	return ir_analyze_instruction_undeclared_ident(ira, (IrInstSrcUndeclaredIdent *)instruction);
	29706	case IrInstSrcIdAlloca:
28940	29707	return nullptr;
28941		case IrInstructionIdEndExpr:
28942		return ir_analyze_instruction_end_expr(ira, (IrInstructionEndExpr *)instruction);
28943		case IrInstructionIdBitCastSrc:
28944		return ir_analyze_instruction_bit_cast_src(ira, (IrInstructionBitCastSrc *)instruction);
28945		case IrInstructionIdUnionInitNamedField:
28946		return ir_analyze_instruction_union_init_named_field(ira, (IrInstructionUnionInitNamedField *)instruction);
28947		case IrInstructionIdSuspendBegin:
28948		return ir_analyze_instruction_suspend_begin(ira, (IrInstructionSuspendBegin *)instruction);
28949		case IrInstructionIdSuspendFinish:
28950		return ir_analyze_instruction_suspend_finish(ira, (IrInstructionSuspendFinish *)instruction);
28951		case IrInstructionIdResume:
28952		return ir_analyze_instruction_resume(ira, (IrInstructionResume *)instruction);
28953		case IrInstructionIdAwaitSrc:
28954		return ir_analyze_instruction_await(ira, (IrInstructionAwaitSrc *)instruction);
28955		case IrInstructionIdSpillBegin:
28956		return ir_analyze_instruction_spill_begin(ira, (IrInstructionSpillBegin *)instruction);
28957		case IrInstructionIdSpillEnd:
28958		return ir_analyze_instruction_spill_end(ira, (IrInstructionSpillEnd *)instruction);
	29708	case IrInstSrcIdEndExpr:
	29709	return ir_analyze_instruction_end_expr(ira, (IrInstSrcEndExpr *)instruction);
	29710	case IrInstSrcIdBitCast:
	29711	return ir_analyze_instruction_bit_cast_src(ira, (IrInstSrcBitCast *)instruction);
	29712	case IrInstSrcIdUnionInitNamedField:
	29713	return ir_analyze_instruction_union_init_named_field(ira, (IrInstSrcUnionInitNamedField *)instruction);
	29714	case IrInstSrcIdSuspendBegin:
	29715	return ir_analyze_instruction_suspend_begin(ira, (IrInstSrcSuspendBegin *)instruction);
	29716	case IrInstSrcIdSuspendFinish:
	29717	return ir_analyze_instruction_suspend_finish(ira, (IrInstSrcSuspendFinish *)instruction);
	29718	case IrInstSrcIdResume:
	29719	return ir_analyze_instruction_resume(ira, (IrInstSrcResume *)instruction);
	29720	case IrInstSrcIdAwait:
	29721	return ir_analyze_instruction_await(ira, (IrInstSrcAwait *)instruction);
	29722	case IrInstSrcIdSpillBegin:
	29723	return ir_analyze_instruction_spill_begin(ira, (IrInstSrcSpillBegin *)instruction);
	29724	case IrInstSrcIdSpillEnd:
	29725	return ir_analyze_instruction_spill_end(ira, (IrInstSrcSpillEnd *)instruction);
28959	29726	}
28960	29727	zig_unreachable();
28961	29728	}
28962	29729
28963	29730	// This function attempts to evaluate IR code while doing type checking and other analysis.
28964		// It emits a new IrExecutable which is partially evaluated IR code.
28965		ZigType ir_analyze(CodeGen codegen, IrExecutable old_exec, IrExecutable new_exec,
	29731	// It emits to a new IrExecutableGen which is partially evaluated IR code.
	29732	ZigType ir_analyze(CodeGen codegen, IrExecutableSrc old_exec, IrExecutableGen new_exec,
28966	29733	ZigType expected_type, AstNode expected_type_source_node)
28967	29734	{
28968	29735	assert(old_exec->first_err_trace_msg == nullptr);
...	...	@@ -28988,18 +29755,18 @@ ZigType ir_analyze(CodeGen codegen, IrExecutable old_exec, IrExecutable new_
28988	29755	ira->exec_context.mem_slot_list.items[i] = &vals[i];
28989	29756	}
28990	29757
28991		IrBasicBlock *old_entry_bb = ira->old_irb.exec->basic_block_list.at(0);
28992		IrBasicBlock *new_entry_bb = ir_get_new_bb(ira, old_entry_bb, nullptr);
28993		ir_ref_bb(new_entry_bb);
	29758	IrBasicBlockSrc *old_entry_bb = ira->old_irb.exec->basic_block_list.at(0);
	29759	IrBasicBlockGen *new_entry_bb = ir_get_new_bb(ira, old_entry_bb, nullptr);
	29760	ir_ref_bb_gen(new_entry_bb);
28994	29761	ira->new_irb.current_basic_block = new_entry_bb;
28995	29762	ira->old_bb_index = 0;
28996	29763
28997	29764	ir_start_bb(ira, old_entry_bb, nullptr);
28998	29765
28999	29766	while (ira->old_bb_index < ira->old_irb.exec->basic_block_list.length) {
29000		IrInstruction *old_instruction = ira->old_irb.current_basic_block->instruction_list.at(ira->instruction_index);
	29767	IrInstSrc *old_instruction = ira->old_irb.current_basic_block->instruction_list.at(ira->instruction_index);
29001	29768
29002		if (old_instruction->ref_count == 0 && !ir_has_side_effects(old_instruction)) {
	29769	if (old_instruction->base.ref_count == 0 && !ir_inst_src_has_side_effects(old_instruction)) {
29003	29770	ira->instruction_index += 1;
29004	29771	continue;
29005	29772	}
...	...	@@ -29008,14 +29775,14 @@ ZigType ir_analyze(CodeGen codegen, IrExecutable old_exec, IrExecutable new_
29008	29775	fprintf(stderr, "~ ");
29009	29776	old_instruction->src();
29010	29777	fprintf(stderr, "~ ");
29011		ir_print_instruction(codegen, stderr, old_instruction, 0, IrPassSrc);
	29778	ir_print_inst_src(codegen, stderr, old_instruction, 0);
29012	29779	bool want_break = false;
29013		if (ira->break_debug_id == old_instruction->debug_id) {
	29780	if (ira->break_debug_id == old_instruction->base.debug_id) {
29014	29781	want_break = true;
29015		} else if (old_instruction->source_node != nullptr) {
	29782	} else if (old_instruction->base.source_node != nullptr) {
29016	29783	for (size_t i = 0; i < dbg_ir_breakpoints_count; i += 1) {
29017		if (dbg_ir_breakpoints_buf[i].line == old_instruction->source_node->line + 1 &&
29018		buf_ends_with_str(old_instruction->source_node->owner->data.structure.root_struct->path,
	29784	if (dbg_ir_breakpoints_buf[i].line == old_instruction->base.source_node->line + 1 &&
	29785	buf_ends_with_str(old_instruction->base.source_node->owner->data.structure.root_struct->path,
29019	29786	dbg_ir_breakpoints_buf[i].src_file))
29020	29787	{
29021	29788	want_break = true;
...	...	@@ -29024,9 +29791,9 @@ ZigType ir_analyze(CodeGen codegen, IrExecutable old_exec, IrExecutable new_
29024	29791	}
29025	29792	if (want_break) BREAKPOINT;
29026	29793	}
29027		IrInstruction *new_instruction = ir_analyze_instruction_base(ira, old_instruction);
	29794	IrInstGen *new_instruction = ir_analyze_instruction_base(ira, old_instruction);
29028	29795	if (new_instruction != nullptr) {
29029		ir_assert(new_instruction->value->type != nullptr \|\| new_instruction->value->type != nullptr, old_instruction);
	29796	ir_assert(new_instruction->value->type != nullptr \|\| new_instruction->value->type != nullptr, &old_instruction->base);
29030	29797	old_instruction->child = new_instruction;
29031	29798
29032	29799	if (type_is_invalid(new_instruction->value->type)) {
...	...	@@ -29040,19 +29807,19 @@ ZigType ir_analyze(CodeGen codegen, IrExecutable old_exec, IrExecutable new_
29040	29807	new_exec->first_err_trace_msg = ira->codegen->trace_err;
29041	29808	}
29042	29809	if (new_exec->first_err_trace_msg != nullptr &&
29043		!old_instruction->source_node->already_traced_this_node)
	29810	!old_instruction->base.source_node->already_traced_this_node)
29044	29811	{
29045		old_instruction->source_node->already_traced_this_node = true;
	29812	old_instruction->base.source_node->already_traced_this_node = true;
29046	29813	new_exec->first_err_trace_msg = add_error_note(ira->codegen, new_exec->first_err_trace_msg,
29047		old_instruction->source_node, buf_create_from_str("referenced here"));
	29814	old_instruction->base.source_node, buf_create_from_str("referenced here"));
29048	29815	}
29049	29816	return ira->codegen->builtin_types.entry_invalid;
29050	29817	} else if (ira->codegen->verbose_ir) {
29051	29818	fprintf(stderr, "-> ");
29052		if (instr_is_unreachable(new_instruction)) {
	29819	if (new_instruction->value->type->id == ZigTypeIdUnreachable) {
29053	29820	fprintf(stderr, "(noreturn)\n");
29054	29821	} else {
29055		ir_print_instruction(codegen, stderr, new_instruction, 0, IrPassGen);
	29822	ir_print_inst_gen(codegen, stderr, new_instruction, 0);
29056	29823	}
29057	29824	}
29058	29825
...	...	@@ -29092,204 +29859,279 @@ ZigType ir_analyze(CodeGen codegen, IrExecutable old_exec, IrExecutable new_
29092	29859	return res_type;
29093	29860	}
29094	29861
29095		bool ir_has_side_effects(IrInstruction *instruction) {
	29862	bool ir_inst_gen_has_side_effects(IrInstGen *instruction) {
29096	29863	switch (instruction->id) {
29097		case IrInstructionIdInvalid:
	29864	case IrInstGenIdInvalid:
29098	29865	zig_unreachable();
29099		case IrInstructionIdBr:
29100		case IrInstructionIdCondBr:
29101		case IrInstructionIdSwitchBr:
29102		case IrInstructionIdDeclVarSrc:
29103		case IrInstructionIdDeclVarGen:
29104		case IrInstructionIdStorePtr:
29105		case IrInstructionIdVectorStoreElem:
29106		case IrInstructionIdCallExtra:
29107		case IrInstructionIdCallSrc:
29108		case IrInstructionIdCallSrcArgs:
29109		case IrInstructionIdCallGen:
29110		case IrInstructionIdReturn:
29111		case IrInstructionIdUnreachable:
29112		case IrInstructionIdSetCold:
29113		case IrInstructionIdSetRuntimeSafety:
29114		case IrInstructionIdSetFloatMode:
29115		case IrInstructionIdImport:
29116		case IrInstructionIdCompileErr:
29117		case IrInstructionIdCompileLog:
29118		case IrInstructionIdCImport:
29119		case IrInstructionIdCInclude:
29120		case IrInstructionIdCDefine:
29121		case IrInstructionIdCUndef:
29122		case IrInstructionIdFence:
29123		case IrInstructionIdMemset:
29124		case IrInstructionIdMemcpy:
29125		case IrInstructionIdBreakpoint:
29126		case IrInstructionIdOverflowOp: // TODO when we support multiple returns this can be side effect free
29127		case IrInstructionIdCheckSwitchProngs:
29128		case IrInstructionIdCheckStatementIsVoid:
29129		case IrInstructionIdCheckRuntimeScope:
29130		case IrInstructionIdPanic:
29131		case IrInstructionIdSetEvalBranchQuota:
29132		case IrInstructionIdPtrType:
29133		case IrInstructionIdSetAlignStack:
29134		case IrInstructionIdExport:
29135		case IrInstructionIdSaveErrRetAddr:
29136		case IrInstructionIdAddImplicitReturnType:
29137		case IrInstructionIdAtomicRmw:
29138		case IrInstructionIdAtomicStore:
29139		case IrInstructionIdCmpxchgGen:
29140		case IrInstructionIdCmpxchgSrc:
29141		case IrInstructionIdAssertZero:
29142		case IrInstructionIdAssertNonNull:
29143		case IrInstructionIdResizeSlice:
29144		case IrInstructionIdUndeclaredIdent:
29145		case IrInstructionIdEndExpr:
29146		case IrInstructionIdPtrOfArrayToSlice:
29147		case IrInstructionIdSliceGen:
29148		case IrInstructionIdOptionalWrap:
29149		case IrInstructionIdVectorToArray:
29150		case IrInstructionIdResetResult:
29151		case IrInstructionIdSuspendBegin:
29152		case IrInstructionIdSuspendFinish:
29153		case IrInstructionIdResume:
29154		case IrInstructionIdAwaitSrc:
29155		case IrInstructionIdAwaitGen:
29156		case IrInstructionIdSpillBegin:
	29866	case IrInstGenIdBr:
	29867	case IrInstGenIdCondBr:
	29868	case IrInstGenIdSwitchBr:
	29869	case IrInstGenIdDeclVar:
	29870	case IrInstGenIdStorePtr:
	29871	case IrInstGenIdVectorStoreElem:
	29872	case IrInstGenIdCall:
	29873	case IrInstGenIdReturn:
	29874	case IrInstGenIdUnreachable:
	29875	case IrInstGenIdFence:
	29876	case IrInstGenIdMemset:
	29877	case IrInstGenIdMemcpy:
	29878	case IrInstGenIdBreakpoint:
	29879	case IrInstGenIdOverflowOp: // TODO when we support multiple returns this can be side effect free
	29880	case IrInstGenIdPanic:
	29881	case IrInstGenIdSaveErrRetAddr:
	29882	case IrInstGenIdAtomicRmw:
	29883	case IrInstGenIdAtomicStore:
	29884	case IrInstGenIdCmpxchg:
	29885	case IrInstGenIdAssertZero:
	29886	case IrInstGenIdAssertNonNull:
	29887	case IrInstGenIdResizeSlice:
	29888	case IrInstGenIdPtrOfArrayToSlice:
	29889	case IrInstGenIdSlice:
	29890	case IrInstGenIdOptionalWrap:
	29891	case IrInstGenIdVectorToArray:
	29892	case IrInstGenIdSuspendBegin:
	29893	case IrInstGenIdSuspendFinish:
	29894	case IrInstGenIdResume:
	29895	case IrInstGenIdAwait:
	29896	case IrInstGenIdSpillBegin:
29157	29897	return true;
29158	29898
29159		case IrInstructionIdPhi:
29160		case IrInstructionIdUnOp:
29161		case IrInstructionIdBinOp:
29162		case IrInstructionIdMergeErrSets:
29163		case IrInstructionIdLoadPtr:
29164		case IrInstructionIdConst:
29165		case IrInstructionIdCast:
29166		case IrInstructionIdContainerInitList:
29167		case IrInstructionIdContainerInitFields:
29168		case IrInstructionIdUnionInitNamedField:
29169		case IrInstructionIdFieldPtr:
29170		case IrInstructionIdElemPtr:
29171		case IrInstructionIdVarPtr:
29172		case IrInstructionIdReturnPtr:
29173		case IrInstructionIdTypeOf:
29174		case IrInstructionIdStructFieldPtr:
29175		case IrInstructionIdArrayType:
29176		case IrInstructionIdSliceType:
29177		case IrInstructionIdAnyFrameType:
29178		case IrInstructionIdSizeOf:
29179		case IrInstructionIdTestNonNull:
29180		case IrInstructionIdOptionalUnwrapPtr:
29181		case IrInstructionIdClz:
29182		case IrInstructionIdCtz:
29183		case IrInstructionIdPopCount:
29184		case IrInstructionIdBswap:
29185		case IrInstructionIdBitReverse:
29186		case IrInstructionIdSwitchVar:
29187		case IrInstructionIdSwitchElseVar:
29188		case IrInstructionIdSwitchTarget:
29189		case IrInstructionIdUnionTag:
29190		case IrInstructionIdRef:
29191		case IrInstructionIdEmbedFile:
29192		case IrInstructionIdTruncate:
29193		case IrInstructionIdIntType:
29194		case IrInstructionIdVectorType:
29195		case IrInstructionIdShuffleVector:
29196		case IrInstructionIdSplatSrc:
29197		case IrInstructionIdSplatGen:
29198		case IrInstructionIdBoolNot:
29199		case IrInstructionIdSliceSrc:
29200		case IrInstructionIdMemberCount:
29201		case IrInstructionIdMemberType:
29202		case IrInstructionIdMemberName:
29203		case IrInstructionIdAlignOf:
29204		case IrInstructionIdReturnAddress:
29205		case IrInstructionIdFrameAddress:
29206		case IrInstructionIdFrameHandle:
29207		case IrInstructionIdFrameType:
29208		case IrInstructionIdFrameSizeSrc:
29209		case IrInstructionIdFrameSizeGen:
29210		case IrInstructionIdTestErrSrc:
29211		case IrInstructionIdTestErrGen:
29212		case IrInstructionIdFnProto:
29213		case IrInstructionIdTestComptime:
29214		case IrInstructionIdPtrCastSrc:
29215		case IrInstructionIdPtrCastGen:
29216		case IrInstructionIdBitCastSrc:
29217		case IrInstructionIdBitCastGen:
29218		case IrInstructionIdWidenOrShorten:
29219		case IrInstructionIdPtrToInt:
29220		case IrInstructionIdIntToPtr:
29221		case IrInstructionIdIntToEnum:
29222		case IrInstructionIdIntToErr:
29223		case IrInstructionIdErrToInt:
29224		case IrInstructionIdDeclRef:
29225		case IrInstructionIdErrName:
29226		case IrInstructionIdTypeName:
29227		case IrInstructionIdTagName:
29228		case IrInstructionIdFieldParentPtr:
29229		case IrInstructionIdByteOffsetOf:
29230		case IrInstructionIdBitOffsetOf:
29231		case IrInstructionIdTypeInfo:
29232		case IrInstructionIdType:
29233		case IrInstructionIdHasField:
29234		case IrInstructionIdTypeId:
29235		case IrInstructionIdAlignCast:
29236		case IrInstructionIdImplicitCast:
29237		case IrInstructionIdResolveResult:
29238		case IrInstructionIdOpaqueType:
29239		case IrInstructionIdArgType:
29240		case IrInstructionIdTagType:
29241		case IrInstructionIdErrorReturnTrace:
29242		case IrInstructionIdErrorUnion:
29243		case IrInstructionIdFloatOp:
29244		case IrInstructionIdMulAdd:
29245		case IrInstructionIdAtomicLoad:
29246		case IrInstructionIdIntCast:
29247		case IrInstructionIdFloatCast:
29248		case IrInstructionIdErrSetCast:
29249		case IrInstructionIdIntToFloat:
29250		case IrInstructionIdFloatToInt:
29251		case IrInstructionIdBoolToInt:
29252		case IrInstructionIdFromBytes:
29253		case IrInstructionIdToBytes:
29254		case IrInstructionIdEnumToInt:
29255		case IrInstructionIdArrayToVector:
29256		case IrInstructionIdHasDecl:
29257		case IrInstructionIdAllocaSrc:
29258		case IrInstructionIdAllocaGen:
29259		case IrInstructionIdSpillEnd:
29260		case IrInstructionIdVectorExtractElem:
	29899	case IrInstGenIdPhi:
	29900	case IrInstGenIdBinOp:
	29901	case IrInstGenIdConst:
	29902	case IrInstGenIdCast:
	29903	case IrInstGenIdElemPtr:
	29904	case IrInstGenIdVarPtr:
	29905	case IrInstGenIdReturnPtr:
	29906	case IrInstGenIdStructFieldPtr:
	29907	case IrInstGenIdTestNonNull:
	29908	case IrInstGenIdOptionalUnwrapPtr:
	29909	case IrInstGenIdClz:
	29910	case IrInstGenIdCtz:
	29911	case IrInstGenIdPopCount:
	29912	case IrInstGenIdBswap:
	29913	case IrInstGenIdBitReverse:
	29914	case IrInstGenIdUnionTag:
	29915	case IrInstGenIdTruncate:
	29916	case IrInstGenIdShuffleVector:
	29917	case IrInstGenIdSplat:
	29918	case IrInstGenIdBoolNot:
	29919	case IrInstGenIdReturnAddress:
	29920	case IrInstGenIdFrameAddress:
	29921	case IrInstGenIdFrameHandle:
	29922	case IrInstGenIdFrameSize:
	29923	case IrInstGenIdTestErr:
	29924	case IrInstGenIdPtrCast:
	29925	case IrInstGenIdBitCast:
	29926	case IrInstGenIdWidenOrShorten:
	29927	case IrInstGenIdPtrToInt:
	29928	case IrInstGenIdIntToPtr:
	29929	case IrInstGenIdIntToEnum:
	29930	case IrInstGenIdIntToErr:
	29931	case IrInstGenIdErrToInt:
	29932	case IrInstGenIdErrName:
	29933	case IrInstGenIdTagName:
	29934	case IrInstGenIdFieldParentPtr:
	29935	case IrInstGenIdAlignCast:
	29936	case IrInstGenIdErrorReturnTrace:
	29937	case IrInstGenIdFloatOp:
	29938	case IrInstGenIdMulAdd:
	29939	case IrInstGenIdAtomicLoad:
	29940	case IrInstGenIdArrayToVector:
	29941	case IrInstGenIdAlloca:
	29942	case IrInstGenIdSpillEnd:
	29943	case IrInstGenIdVectorExtractElem:
	29944	case IrInstGenIdBinaryNot:
	29945	case IrInstGenIdNegation:
	29946	case IrInstGenIdNegationWrapping:
29261	29947	return false;
29262	29948
29263		case IrInstructionIdAsmSrc:
	29949	case IrInstGenIdAsm:
29264	29950	{
29265		IrInstructionAsmSrc asm_instruction = (IrInstructionAsmSrc )instruction;
	29951	IrInstGenAsm asm_instruction = (IrInstGenAsm )instruction;
29266	29952	return asm_instruction->has_side_effects;
29267	29953	}
	29954	case IrInstGenIdUnwrapErrPayload:
	29955	{
	29956	IrInstGenUnwrapErrPayload *unwrap_err_payload_instruction =
	29957	(IrInstGenUnwrapErrPayload *)instruction;
	29958	return unwrap_err_payload_instruction->safety_check_on \|\|
	29959	unwrap_err_payload_instruction->initializing;
	29960	}
	29961	case IrInstGenIdUnwrapErrCode:
	29962	return reinterpret_cast<IrInstGenUnwrapErrCode *>(instruction)->initializing;
	29963	case IrInstGenIdUnionFieldPtr:
	29964	return reinterpret_cast<IrInstGenUnionFieldPtr *>(instruction)->initializing;
	29965	case IrInstGenIdErrWrapPayload:
	29966	return reinterpret_cast<IrInstGenErrWrapPayload *>(instruction)->result_loc != nullptr;
	29967	case IrInstGenIdErrWrapCode:
	29968	return reinterpret_cast<IrInstGenErrWrapCode *>(instruction)->result_loc != nullptr;
	29969	case IrInstGenIdLoadPtr:
	29970	return reinterpret_cast<IrInstGenLoadPtr *>(instruction)->result_loc != nullptr;
	29971	case IrInstGenIdRef:
	29972	return reinterpret_cast<IrInstGenRef *>(instruction)->result_loc != nullptr;
	29973	}
	29974	zig_unreachable();
	29975	}
	29976
	29977	bool ir_inst_src_has_side_effects(IrInstSrc *instruction) {
	29978	switch (instruction->id) {
	29979	case IrInstSrcIdInvalid:
	29980	zig_unreachable();
	29981	case IrInstSrcIdBr:
	29982	case IrInstSrcIdCondBr:
	29983	case IrInstSrcIdSwitchBr:
	29984	case IrInstSrcIdDeclVar:
	29985	case IrInstSrcIdStorePtr:
	29986	case IrInstSrcIdCallExtra:
	29987	case IrInstSrcIdCall:
	29988	case IrInstSrcIdCallArgs:
	29989	case IrInstSrcIdReturn:
	29990	case IrInstSrcIdUnreachable:
	29991	case IrInstSrcIdSetCold:
	29992	case IrInstSrcIdSetRuntimeSafety:
	29993	case IrInstSrcIdSetFloatMode:
	29994	case IrInstSrcIdImport:
	29995	case IrInstSrcIdCompileErr:
	29996	case IrInstSrcIdCompileLog:
	29997	case IrInstSrcIdCImport:
	29998	case IrInstSrcIdCInclude:
	29999	case IrInstSrcIdCDefine:
	30000	case IrInstSrcIdCUndef:
	30001	case IrInstSrcIdFence:
	30002	case IrInstSrcIdMemset:
	30003	case IrInstSrcIdMemcpy:
	30004	case IrInstSrcIdBreakpoint:
	30005	case IrInstSrcIdOverflowOp: // TODO when we support multiple returns this can be side effect free
	30006	case IrInstSrcIdCheckSwitchProngs:
	30007	case IrInstSrcIdCheckStatementIsVoid:
	30008	case IrInstSrcIdCheckRuntimeScope:
	30009	case IrInstSrcIdPanic:
	30010	case IrInstSrcIdSetEvalBranchQuota:
	30011	case IrInstSrcIdPtrType:
	30012	case IrInstSrcIdSetAlignStack:
	30013	case IrInstSrcIdExport:
	30014	case IrInstSrcIdSaveErrRetAddr:
	30015	case IrInstSrcIdAddImplicitReturnType:
	30016	case IrInstSrcIdAtomicRmw:
	30017	case IrInstSrcIdAtomicStore:
	30018	case IrInstSrcIdCmpxchg:
	30019	case IrInstSrcIdUndeclaredIdent:
	30020	case IrInstSrcIdEndExpr:
	30021	case IrInstSrcIdResetResult:
	30022	case IrInstSrcIdSuspendBegin:
	30023	case IrInstSrcIdSuspendFinish:
	30024	case IrInstSrcIdResume:
	30025	case IrInstSrcIdAwait:
	30026	case IrInstSrcIdSpillBegin:
	30027	return true;
	30028
	30029	case IrInstSrcIdPhi:
	30030	case IrInstSrcIdUnOp:
	30031	case IrInstSrcIdBinOp:
	30032	case IrInstSrcIdMergeErrSets:
	30033	case IrInstSrcIdLoadPtr:
	30034	case IrInstSrcIdConst:
	30035	case IrInstSrcIdContainerInitList:
	30036	case IrInstSrcIdContainerInitFields:
	30037	case IrInstSrcIdUnionInitNamedField:
	30038	case IrInstSrcIdFieldPtr:
	30039	case IrInstSrcIdElemPtr:
	30040	case IrInstSrcIdVarPtr:
	30041	case IrInstSrcIdTypeOf:
	30042	case IrInstSrcIdArrayType:
	30043	case IrInstSrcIdSliceType:
	30044	case IrInstSrcIdAnyFrameType:
	30045	case IrInstSrcIdSizeOf:
	30046	case IrInstSrcIdTestNonNull:
	30047	case IrInstSrcIdOptionalUnwrapPtr:
	30048	case IrInstSrcIdClz:
	30049	case IrInstSrcIdCtz:
	30050	case IrInstSrcIdPopCount:
	30051	case IrInstSrcIdBswap:
	30052	case IrInstSrcIdBitReverse:
	30053	case IrInstSrcIdSwitchVar:
	30054	case IrInstSrcIdSwitchElseVar:
	30055	case IrInstSrcIdSwitchTarget:
	30056	case IrInstSrcIdRef:
	30057	case IrInstSrcIdEmbedFile:
	30058	case IrInstSrcIdTruncate:
	30059	case IrInstSrcIdIntType:
	30060	case IrInstSrcIdVectorType:
	30061	case IrInstSrcIdShuffleVector:
	30062	case IrInstSrcIdSplat:
	30063	case IrInstSrcIdBoolNot:
	30064	case IrInstSrcIdSlice:
	30065	case IrInstSrcIdMemberCount:
	30066	case IrInstSrcIdMemberType:
	30067	case IrInstSrcIdMemberName:
	30068	case IrInstSrcIdAlignOf:
	30069	case IrInstSrcIdReturnAddress:
	30070	case IrInstSrcIdFrameAddress:
	30071	case IrInstSrcIdFrameHandle:
	30072	case IrInstSrcIdFrameType:
	30073	case IrInstSrcIdFrameSize:
	30074	case IrInstSrcIdTestErr:
	30075	case IrInstSrcIdFnProto:
	30076	case IrInstSrcIdTestComptime:
	30077	case IrInstSrcIdPtrCast:
	30078	case IrInstSrcIdBitCast:
	30079	case IrInstSrcIdPtrToInt:
	30080	case IrInstSrcIdIntToPtr:
	30081	case IrInstSrcIdIntToEnum:
	30082	case IrInstSrcIdIntToErr:
	30083	case IrInstSrcIdErrToInt:
	30084	case IrInstSrcIdDeclRef:
	30085	case IrInstSrcIdErrName:
	30086	case IrInstSrcIdTypeName:
	30087	case IrInstSrcIdTagName:
	30088	case IrInstSrcIdFieldParentPtr:
	30089	case IrInstSrcIdByteOffsetOf:
	30090	case IrInstSrcIdBitOffsetOf:
	30091	case IrInstSrcIdTypeInfo:
	30092	case IrInstSrcIdType:
	30093	case IrInstSrcIdHasField:
	30094	case IrInstSrcIdTypeId:
	30095	case IrInstSrcIdAlignCast:
	30096	case IrInstSrcIdImplicitCast:
	30097	case IrInstSrcIdResolveResult:
	30098	case IrInstSrcIdOpaqueType:
	30099	case IrInstSrcIdArgType:
	30100	case IrInstSrcIdTagType:
	30101	case IrInstSrcIdErrorReturnTrace:
	30102	case IrInstSrcIdErrorUnion:
	30103	case IrInstSrcIdFloatOp:
	30104	case IrInstSrcIdMulAdd:
	30105	case IrInstSrcIdAtomicLoad:
	30106	case IrInstSrcIdIntCast:
	30107	case IrInstSrcIdFloatCast:
	30108	case IrInstSrcIdErrSetCast:
	30109	case IrInstSrcIdIntToFloat:
	30110	case IrInstSrcIdFloatToInt:
	30111	case IrInstSrcIdBoolToInt:
	30112	case IrInstSrcIdFromBytes:
	30113	case IrInstSrcIdToBytes:
	30114	case IrInstSrcIdEnumToInt:
	30115	case IrInstSrcIdHasDecl:
	30116	case IrInstSrcIdAlloca:
	30117	case IrInstSrcIdSpillEnd:
	30118	return false;
29268	30119
29269		case IrInstructionIdAsmGen:
	30120	case IrInstSrcIdAsm:
29270	30121	{
29271		IrInstructionAsmGen asm_instruction = (IrInstructionAsmGen )instruction;
	30122	IrInstSrcAsm asm_instruction = (IrInstSrcAsm )instruction;
29272	30123	return asm_instruction->has_side_effects;
29273	30124	}
29274		case IrInstructionIdUnwrapErrPayload:
	30125
	30126	case IrInstSrcIdUnwrapErrPayload:
29275	30127	{
29276		IrInstructionUnwrapErrPayload *unwrap_err_payload_instruction =
29277		(IrInstructionUnwrapErrPayload *)instruction;
	30128	IrInstSrcUnwrapErrPayload *unwrap_err_payload_instruction =
	30129	(IrInstSrcUnwrapErrPayload *)instruction;
29278	30130	return unwrap_err_payload_instruction->safety_check_on \|\|
29279	30131	unwrap_err_payload_instruction->initializing;
29280	30132	}
29281		case IrInstructionIdUnwrapErrCode:
29282		return reinterpret_cast<IrInstructionUnwrapErrCode *>(instruction)->initializing;
29283		case IrInstructionIdUnionFieldPtr:
29284		return reinterpret_cast<IrInstructionUnionFieldPtr *>(instruction)->initializing;
29285		case IrInstructionIdErrWrapPayload:
29286		return reinterpret_cast<IrInstructionErrWrapPayload *>(instruction)->result_loc != nullptr;
29287		case IrInstructionIdErrWrapCode:
29288		return reinterpret_cast<IrInstructionErrWrapCode *>(instruction)->result_loc != nullptr;
29289		case IrInstructionIdLoadPtrGen:
29290		return reinterpret_cast<IrInstructionLoadPtrGen *>(instruction)->result_loc != nullptr;
29291		case IrInstructionIdRefGen:
29292		return reinterpret_cast<IrInstructionRefGen *>(instruction)->result_loc != nullptr;
	30133	case IrInstSrcIdUnwrapErrCode:
	30134	return reinterpret_cast<IrInstSrcUnwrapErrCode *>(instruction)->initializing;
29293	30135	}
29294	30136	zig_unreachable();
29295	30137	}
...	...	@@ -29323,14 +30165,14 @@ static ZigType ir_resolve_lazy_fn_type(IrAnalyze ira, AstNode *source_node, La
29323	30165	param_info->type = nullptr;
29324	30166	return get_generic_fn_type(ira->codegen, &fn_type_id);
29325	30167	} else {
29326		IrInstruction *param_type_inst = lazy_fn_type->param_types[fn_type_id.next_param_index];
	30168	IrInstGen *param_type_inst = lazy_fn_type->param_types[fn_type_id.next_param_index];
29327	30169	ZigType *param_type = ir_resolve_type(ira, param_type_inst);
29328	30170	if (type_is_invalid(param_type))
29329	30171	return nullptr;
29330	30172	switch (type_requires_comptime(ira->codegen, param_type)) {
29331	30173	case ReqCompTimeYes:
29332	30174	if (!calling_convention_allows_zig_types(fn_type_id.cc)) {
29333		ir_add_error(ira, param_type_inst,
	30175	ir_add_error(ira, &param_type_inst->base,
29334	30176	buf_sprintf("parameter of type '%s' not allowed in function with calling convention '%s'",
29335	30177	buf_ptr(&param_type->name), calling_convention_name(fn_type_id.cc)));
29336	30178	return nullptr;
...	...	@@ -29348,7 +30190,7 @@ static ZigType ir_resolve_lazy_fn_type(IrAnalyze ira, AstNode *source_node, La
29348	30190	if ((err = type_has_bits2(ira->codegen, param_type, &has_bits)))
29349	30191	return nullptr;
29350	30192	if (!has_bits) {
29351		ir_add_error(ira, param_type_inst,
	30193	ir_add_error(ira, &param_type_inst->base,
29352	30194	buf_sprintf("parameter of type '%s' has 0 bits; not allowed in function with calling convention '%s'",
29353	30195	buf_ptr(&param_type->name), calling_convention_name(fn_type_id.cc)));
29354	30196	return nullptr;
...	...	@@ -29367,7 +30209,7 @@ static ZigType ir_resolve_lazy_fn_type(IrAnalyze ira, AstNode *source_node, La
29367	30209	if (type_is_invalid(fn_type_id.return_type))
29368	30210	return nullptr;
29369	30211	if (fn_type_id.return_type->id == ZigTypeIdOpaque) {
29370		ir_add_error(ira, lazy_fn_type->return_type, buf_create_from_str("return type cannot be opaque"));
	30212	ir_add_error(ira, &lazy_fn_type->return_type->base, buf_create_from_str("return type cannot be opaque"));
29371	30213	return nullptr;
29372	30214	}
29373	30215
...	...	@@ -29399,7 +30241,7 @@ static Error ir_resolve_lazy_raw(AstNode source_node, ZigValue val) {
29399	30241	case ZigTypeIdBoundFn:
29400	30242	case ZigTypeIdVoid:
29401	30243	case ZigTypeIdOpaque:
29402		ir_add_error(ira, lazy_align_of->target_type,
	30244	ir_add_error(ira, &lazy_align_of->target_type->base,
29403	30245	buf_sprintf("no align available for type '%s'",
29404	30246	buf_ptr(&lazy_align_of->target_type->value->data.x_type->name)));
29405	30247	return ErrorSemanticAnalyzeFail;
...	...	@@ -29449,7 +30291,7 @@ static Error ir_resolve_lazy_raw(AstNode source_node, ZigValue val) {
29449	30291	case ZigTypeIdNull:
29450	30292	case ZigTypeIdBoundFn:
29451	30293	case ZigTypeIdOpaque:
29452		ir_add_error(ira, lazy_size_of->target_type,
	30294	ir_add_error(ira, &lazy_size_of->target_type->base,
29453	30295	buf_sprintf("no size available for type '%s'",
29454	30296	buf_ptr(&lazy_size_of->target_type->value->data.x_type->name)));
29455	30297	return ErrorSemanticAnalyzeFail;
...	...	@@ -29507,7 +30349,7 @@ static Error ir_resolve_lazy_raw(AstNode source_node, ZigValue val) {
29507	30349	if (lazy_slice_type->sentinel != nullptr) {
29508	30350	if (type_is_invalid(lazy_slice_type->sentinel->value->type))
29509	30351	return ErrorSemanticAnalyzeFail;
29510		IrInstruction *sentinel = ir_implicit_cast(ira, lazy_slice_type->sentinel, elem_type);
	30352	IrInstGen *sentinel = ir_implicit_cast(ira, lazy_slice_type->sentinel, elem_type);
29511	30353	if (type_is_invalid(sentinel->value->type))
29512	30354	return ErrorSemanticAnalyzeFail;
29513	30355	sentinel_val = ir_resolve_const(ira, sentinel, UndefBad);
...	...	@@ -29530,7 +30372,7 @@ static Error ir_resolve_lazy_raw(AstNode source_node, ZigValue val) {
29530	30372	case ZigTypeIdUndefined:
29531	30373	case ZigTypeIdNull:
29532	30374	case ZigTypeIdOpaque:
29533		ir_add_error(ira, lazy_slice_type->elem_type,
	30375	ir_add_error(ira, &lazy_slice_type->elem_type->base,
29534	30376	buf_sprintf("slice of type '%s' not allowed", buf_ptr(&elem_type->name)));
29535	30377	return ErrorSemanticAnalyzeFail;
29536	30378	case ZigTypeIdMetaType:
...	...	@@ -29586,7 +30428,7 @@ static Error ir_resolve_lazy_raw(AstNode source_node, ZigValue val) {
29586	30428	if (lazy_ptr_type->sentinel != nullptr) {
29587	30429	if (type_is_invalid(lazy_ptr_type->sentinel->value->type))
29588	30430	return ErrorSemanticAnalyzeFail;
29589		IrInstruction *sentinel = ir_implicit_cast(ira, lazy_ptr_type->sentinel, elem_type);
	30431	IrInstGen *sentinel = ir_implicit_cast(ira, lazy_ptr_type->sentinel, elem_type);
29590	30432	if (type_is_invalid(sentinel->value->type))
29591	30433	return ErrorSemanticAnalyzeFail;
29592	30434	sentinel_val = ir_resolve_const(ira, sentinel, UndefBad);
...	...	@@ -29603,11 +30445,11 @@ static Error ir_resolve_lazy_raw(AstNode source_node, ZigValue val) {
29603	30445	}
29604	30446
29605	30447	if (elem_type->id == ZigTypeIdUnreachable) {
29606		ir_add_error(ira, lazy_ptr_type->elem_type,
	30448	ir_add_error(ira, &lazy_ptr_type->elem_type->base,
29607	30449	buf_create_from_str("pointer to noreturn not allowed"));
29608	30450	return ErrorSemanticAnalyzeFail;
29609	30451	} else if (elem_type->id == ZigTypeIdOpaque && lazy_ptr_type->ptr_len == PtrLenUnknown) {
29610		ir_add_error(ira, lazy_ptr_type->elem_type,
	30452	ir_add_error(ira, &lazy_ptr_type->elem_type->base,
29611	30453	buf_create_from_str("unknown-length pointer to opaque"));
29612	30454	return ErrorSemanticAnalyzeFail;
29613	30455	} else if (lazy_ptr_type->ptr_len == PtrLenC) {
...	...	@@ -29615,16 +30457,16 @@ static Error ir_resolve_lazy_raw(AstNode source_node, ZigValue val) {
29615	30457	if ((err = type_allowed_in_extern(ira->codegen, elem_type, &ok_type)))
29616	30458	return err;
29617	30459	if (!ok_type) {
29618		ir_add_error(ira, lazy_ptr_type->elem_type,
	30460	ir_add_error(ira, &lazy_ptr_type->elem_type->base,
29619	30461	buf_sprintf("C pointers cannot point to non-C-ABI-compatible type '%s'",
29620	30462	buf_ptr(&elem_type->name)));
29621	30463	return ErrorSemanticAnalyzeFail;
29622	30464	} else if (elem_type->id == ZigTypeIdOpaque) {
29623		ir_add_error(ira, lazy_ptr_type->elem_type,
	30465	ir_add_error(ira, &lazy_ptr_type->elem_type->base,
29624	30466	buf_sprintf("C pointers cannot point opaque types"));
29625	30467	return ErrorSemanticAnalyzeFail;
29626	30468	} else if (lazy_ptr_type->is_allowzero) {
29627		ir_add_error(ira, lazy_ptr_type->elem_type,
	30469	ir_add_error(ira, &lazy_ptr_type->elem_type->base,
29628	30470	buf_sprintf("C pointers always allow address zero"));
29629	30471	return ErrorSemanticAnalyzeFail;
29630	30472	}
...	...	@@ -29662,7 +30504,7 @@ static Error ir_resolve_lazy_raw(AstNode source_node, ZigValue val) {
29662	30504	case ZigTypeIdUndefined:
29663	30505	case ZigTypeIdNull:
29664	30506	case ZigTypeIdOpaque:
29665		ir_add_error(ira, lazy_array_type->elem_type,
	30507	ir_add_error(ira, &lazy_array_type->elem_type->base,
29666	30508	buf_sprintf("array of type '%s' not allowed",
29667	30509	buf_ptr(&elem_type->name)));
29668	30510	return ErrorSemanticAnalyzeFail;
...	...	@@ -29697,7 +30539,7 @@ static Error ir_resolve_lazy_raw(AstNode source_node, ZigValue val) {
29697	30539	if (lazy_array_type->sentinel != nullptr) {
29698	30540	if (type_is_invalid(lazy_array_type->sentinel->value->type))
29699	30541	return ErrorSemanticAnalyzeFail;
29700		IrInstruction *sentinel = ir_implicit_cast(ira, lazy_array_type->sentinel, elem_type);
	30542	IrInstGen *sentinel = ir_implicit_cast(ira, lazy_array_type->sentinel, elem_type);
29701	30543	if (type_is_invalid(sentinel->value->type))
29702	30544	return ErrorSemanticAnalyzeFail;
29703	30545	sentinel_val = ir_resolve_const(ira, sentinel, UndefBad);
...	...	@@ -29721,7 +30563,7 @@ static Error ir_resolve_lazy_raw(AstNode source_node, ZigValue val) {
29721	30563	return ErrorSemanticAnalyzeFail;
29722	30564
29723	30565	if (payload_type->id == ZigTypeIdOpaque \|\| payload_type->id == ZigTypeIdUnreachable) {
29724		ir_add_error(ira, lazy_opt_type->payload_type,
	30566	ir_add_error(ira, &lazy_opt_type->payload_type->base,
29725	30567	buf_sprintf("type '%s' cannot be optional", buf_ptr(&payload_type->name)));
29726	30568	return ErrorSemanticAnalyzeFail;
29727	30569	}
...	...	@@ -29763,7 +30605,7 @@ static Error ir_resolve_lazy_raw(AstNode source_node, ZigValue val) {
29763	30605	return ErrorSemanticAnalyzeFail;
29764	30606
29765	30607	if (err_set_type->id != ZigTypeIdErrorSet) {
29766		ir_add_error(ira, lazy_err_union_type->err_set_type,
	30608	ir_add_error(ira, &lazy_err_union_type->err_set_type->base,
29767	30609	buf_sprintf("expected error set type, found type '%s'",
29768	30610	buf_ptr(&err_set_type->name)));
29769	30611	return ErrorSemanticAnalyzeFail;
...	...	@@ -29799,8 +30641,8 @@ Error ir_resolve_lazy(CodeGen codegen, AstNode source_node, ZigValue *val) {
29799	30641	return ErrorNone;
29800	30642	}
29801	30643
29802		void IrInstruction::src() {
29803		IrInstruction *inst = this;
	30644	void IrInst::src() {
	30645	IrInst *inst = this;
29804	30646	if (inst->source_node != nullptr) {
29805	30647	inst->source_node->src();
29806	30648	} else {
...	...	@@ -29808,26 +30650,45 @@ void IrInstruction::src() {
29808	30650	}
29809	30651	}
29810	30652
29811		void IrInstruction::dump() {
29812		IrInstruction *inst = this;
	30653	void IrInst::dump() {
	30654	this->src();
	30655	fprintf(stderr, "IrInst(#%" PRIu32 ")\n", this->debug_id);
	30656	}
	30657
	30658	void IrInstSrc::src() {
	30659	this->base.src();
	30660	}
	30661
	30662	void IrInstGen::src() {
	30663	this->base.src();
	30664	}
	30665
	30666	void IrInstSrc::dump() {
	30667	IrInstSrc *inst = this;
29813	30668	inst->src();
29814		IrPass pass = (inst->child == nullptr) ? IrPassGen : IrPassSrc;
29815		if (inst->scope == nullptr) {
	30669	if (inst->base.scope == nullptr) {
29816	30670	fprintf(stderr, "(null scope)\n");
29817	30671	} else {
29818		ir_print_instruction(inst->scope->codegen, stderr, inst, 0, pass);
29819		if (pass == IrPassSrc) {
29820		fprintf(stderr, "-> ");
29821		ir_print_instruction(inst->scope->codegen, stderr, inst->child, 0, IrPassGen);
29822		}
	30672	ir_print_inst_src(inst->base.scope->codegen, stderr, inst, 0);
	30673	fprintf(stderr, "-> ");
	30674	ir_print_inst_gen(inst->base.scope->codegen, stderr, inst->child, 0);
	30675	}
	30676	}
	30677	void IrInstGen::dump() {
	30678	IrInstGen *inst = this;
	30679	inst->src();
	30680	if (inst->base.scope == nullptr) {
	30681	fprintf(stderr, "(null scope)\n");
	30682	} else {
	30683	ir_print_inst_gen(inst->base.scope->codegen, stderr, inst, 0);
29823	30684	}
29824	30685	}
29825	30686
29826	30687	void IrAnalyze::dump() {
29827		ir_print(this->codegen, stderr, this->new_irb.exec, 0, IrPassGen);
	30688	ir_print_gen(this->codegen, stderr, this->new_irb.exec, 0);
29828	30689	if (this->new_irb.current_basic_block != nullptr) {
29829	30690	fprintf(stderr, "Current basic block:\n");
29830		ir_print_basic_block(this->codegen, stderr, this->new_irb.current_basic_block, 1, IrPassGen);
	30691	ir_print_basic_block_gen(this->codegen, stderr, this->new_irb.current_basic_block, 1);
29831	30692	}
29832	30693	}
29833	30694

src/ir.hpp+10-10

...	...	@@ -10,33 +10,33 @@
10	10
11	11	#include "all_types.hpp"
12	12
13		enum IrPass {
14		IrPassSrc,
15		IrPassGen,
16		};
17
18		bool ir_gen(CodeGen g, AstNode node, Scope scope, IrExecutable ir_executable);
	13	bool ir_gen(CodeGen g, AstNode node, Scope scope, IrExecutableSrc ir_executable);
19	14	bool ir_gen_fn(CodeGen g, ZigFn fn_entry);
20	15
	16	IrInstGen ir_create_alloca(CodeGen g, Scope scope, AstNode source_node, ZigFn *fn,
	17	ZigType var_type, const char name_hint);
	18
21	19	ZigValue ir_eval_const_value(CodeGen codegen, Scope scope, AstNode node,
22	20	ZigType expected_type, size_t backward_branch_count, size_t *backward_branch_quota,
23	21	ZigFn fn_entry, Buf c_import_buf, AstNode source_node, Buf exec_name,
24		IrExecutable parent_exec, AstNode expected_type_source_node, UndefAllowed undef);
	22	IrExecutableGen parent_exec, AstNode expected_type_source_node, UndefAllowed undef);
25	23
26	24	Error ir_resolve_lazy(CodeGen codegen, AstNode source_node, ZigValue *val);
27	25
28		ZigType ir_analyze(CodeGen g, IrExecutable old_executable, IrExecutable new_executable,
	26	ZigType ir_analyze(CodeGen g, IrExecutableSrc old_executable, IrExecutableGen new_executable,
29	27	ZigType expected_type, AstNode expected_type_source_node);
30	28
31		bool ir_has_side_effects(IrInstruction *instruction);
	29	bool ir_inst_gen_has_side_effects(IrInstGen *inst);
	30	bool ir_inst_src_has_side_effects(IrInstSrc *inst);
32	31
33	32	struct IrAnalyze;
34	33	ZigValue const_ptr_pointee(IrAnalyze ira, CodeGen codegen, ZigValue const_val,
35	34	AstNode *source_node);
36		const char *float_op_to_name(BuiltinFnId op);
37	35
38	36	// for debugging purposes
39	37	void dbg_ir_break(const char *src_file, uint32_t line);
40	38	void dbg_ir_clear(void);
41	39
	40	void destroy_instruction_gen(IrInstGen *inst);
	41
42	42	#endif

src/ir_print.cpp+1998-1281

...	...	@@ -10,19 +10,35 @@
10	10	#include "ir_print.hpp"
11	11	#include "os.hpp"
12	12
13		static uint32_t hash_instruction_ptr(IrInstruction* instruction) {
	13	static uint32_t hash_inst_src_ptr(IrInstSrc* instruction) {
14	14	return (uint32_t)(uintptr_t)instruction;
15	15	}
16	16
17		static bool instruction_ptr_equal(IrInstruction* a, IrInstruction* b) {
	17	static uint32_t hash_inst_gen_ptr(IrInstGen* instruction) {
	18	return (uint32_t)(uintptr_t)instruction;
	19	}
	20
	21	static bool inst_src_ptr_eql(IrInstSrc* a, IrInstSrc* b) {
18	22	return a == b;
19	23	}
20	24
21		using InstructionSet = HashMap<IrInstruction*, uint8_t, hash_instruction_ptr, instruction_ptr_equal>;
22		using InstructionList = ZigList<IrInstruction*>;
	25	static bool inst_gen_ptr_eql(IrInstGen* a, IrInstGen* b) {
	26	return a == b;
	27	}
	28
	29	using InstSetSrc = HashMap<IrInstSrc*, uint8_t, hash_inst_src_ptr, inst_src_ptr_eql>;
	30	using InstSetGen = HashMap<IrInstGen*, uint8_t, hash_inst_gen_ptr, inst_gen_ptr_eql>;
	31	using InstListSrc = ZigList<IrInstSrc*>;
	32	using InstListGen = ZigList<IrInstGen*>;
	33
	34	struct IrPrintSrc {
	35	CodeGen *codegen;
	36	FILE *f;
	37	int indent;
	38	int indent_size;
	39	};
23	40
24		struct IrPrint {
25		IrPass pass;
	41	struct IrPrintGen {
26	42	CodeGen *codegen;
27	43	FILE *f;
28	44	int indent;
...	...	@@ -32,417 +48,590 @@ struct IrPrint {
32	48	// present in the instruction list. Thus we track which instructions
33	49	// are printed (per executable) and after each pass 2 instruction those
34	50	// var instructions are rendered in a trailing fashion.
35		InstructionSet printed;
36		InstructionList pending;
	51	InstSetGen printed;
	52	InstListGen pending;
37	53	};
38	54
39		static void ir_print_other_instruction(IrPrint irp, IrInstruction instruction);
	55	static void ir_print_other_inst_src(IrPrintSrc irp, IrInstSrc inst);
	56	static void ir_print_other_inst_gen(IrPrintGen irp, IrInstGen inst);
40	57
41		const char* ir_instruction_type_str(IrInstructionId id) {
	58	const char* ir_inst_src_type_str(IrInstSrcId id) {
42	59	switch (id) {
43		case IrInstructionIdInvalid:
44		return "Invalid";
45		case IrInstructionIdShuffleVector:
46		return "Shuffle";
47		case IrInstructionIdSplatSrc:
48		return "SplatSrc";
49		case IrInstructionIdSplatGen:
50		return "SplatGen";
51		case IrInstructionIdDeclVarSrc:
52		return "DeclVarSrc";
53		case IrInstructionIdDeclVarGen:
54		return "DeclVarGen";
55		case IrInstructionIdBr:
56		return "Br";
57		case IrInstructionIdCondBr:
58		return "CondBr";
59		case IrInstructionIdSwitchBr:
60		return "SwitchBr";
61		case IrInstructionIdSwitchVar:
62		return "SwitchVar";
63		case IrInstructionIdSwitchElseVar:
64		return "SwitchElseVar";
65		case IrInstructionIdSwitchTarget:
66		return "SwitchTarget";
67		case IrInstructionIdPhi:
68		return "Phi";
69		case IrInstructionIdUnOp:
70		return "UnOp";
71		case IrInstructionIdBinOp:
72		return "BinOp";
73		case IrInstructionIdMergeErrSets:
74		return "MergeErrSets";
75		case IrInstructionIdLoadPtr:
76		return "LoadPtr";
77		case IrInstructionIdLoadPtrGen:
78		return "LoadPtrGen";
79		case IrInstructionIdStorePtr:
80		return "StorePtr";
81		case IrInstructionIdVectorStoreElem:
82		return "VectorStoreElem";
83		case IrInstructionIdFieldPtr:
84		return "FieldPtr";
85		case IrInstructionIdStructFieldPtr:
86		return "StructFieldPtr";
87		case IrInstructionIdUnionFieldPtr:
88		return "UnionFieldPtr";
89		case IrInstructionIdElemPtr:
90		return "ElemPtr";
91		case IrInstructionIdVarPtr:
92		return "VarPtr";
93		case IrInstructionIdReturnPtr:
94		return "ReturnPtr";
95		case IrInstructionIdCallExtra:
96		return "CallExtra";
97		case IrInstructionIdCallSrc:
98		return "CallSrc";
99		case IrInstructionIdCallSrcArgs:
100		return "CallSrcArgs";
101		case IrInstructionIdCallGen:
102		return "CallGen";
103		case IrInstructionIdConst:
104		return "Const";
105		case IrInstructionIdReturn:
106		return "Return";
107		case IrInstructionIdCast:
108		return "Cast";
109		case IrInstructionIdResizeSlice:
110		return "ResizeSlice";
111		case IrInstructionIdContainerInitList:
112		return "ContainerInitList";
113		case IrInstructionIdContainerInitFields:
114		return "ContainerInitFields";
115		case IrInstructionIdUnreachable:
116		return "Unreachable";
117		case IrInstructionIdTypeOf:
118		return "TypeOf";
119		case IrInstructionIdSetCold:
120		return "SetCold";
121		case IrInstructionIdSetRuntimeSafety:
122		return "SetRuntimeSafety";
123		case IrInstructionIdSetFloatMode:
124		return "SetFloatMode";
125		case IrInstructionIdArrayType:
126		return "ArrayType";
127		case IrInstructionIdAnyFrameType:
128		return "AnyFrameType";
129		case IrInstructionIdSliceType:
130		return "SliceType";
131		case IrInstructionIdAsmSrc:
132		return "AsmSrc";
133		case IrInstructionIdAsmGen:
134		return "AsmGen";
135		case IrInstructionIdSizeOf:
136		return "SizeOf";
137		case IrInstructionIdTestNonNull:
138		return "TestNonNull";
139		case IrInstructionIdOptionalUnwrapPtr:
140		return "OptionalUnwrapPtr";
141		case IrInstructionIdOptionalWrap:
142		return "OptionalWrap";
143		case IrInstructionIdUnionTag:
144		return "UnionTag";
145		case IrInstructionIdClz:
146		return "Clz";
147		case IrInstructionIdCtz:
148		return "Ctz";
149		case IrInstructionIdPopCount:
150		return "PopCount";
151		case IrInstructionIdBswap:
152		return "Bswap";
153		case IrInstructionIdBitReverse:
154		return "BitReverse";
155		case IrInstructionIdImport:
156		return "Import";
157		case IrInstructionIdCImport:
158		return "CImport";
159		case IrInstructionIdCInclude:
160		return "CInclude";
161		case IrInstructionIdCDefine:
162		return "CDefine";
163		case IrInstructionIdCUndef:
164		return "CUndef";
165		case IrInstructionIdRef:
166		return "Ref";
167		case IrInstructionIdRefGen:
168		return "RefGen";
169		case IrInstructionIdCompileErr:
170		return "CompileErr";
171		case IrInstructionIdCompileLog:
172		return "CompileLog";
173		case IrInstructionIdErrName:
174		return "ErrName";
175		case IrInstructionIdEmbedFile:
176		return "EmbedFile";
177		case IrInstructionIdCmpxchgSrc:
178		return "CmpxchgSrc";
179		case IrInstructionIdCmpxchgGen:
180		return "CmpxchgGen";
181		case IrInstructionIdFence:
182		return "Fence";
183		case IrInstructionIdTruncate:
184		return "Truncate";
185		case IrInstructionIdIntCast:
186		return "IntCast";
187		case IrInstructionIdFloatCast:
188		return "FloatCast";
189		case IrInstructionIdIntToFloat:
190		return "IntToFloat";
191		case IrInstructionIdFloatToInt:
192		return "FloatToInt";
193		case IrInstructionIdBoolToInt:
194		return "BoolToInt";
195		case IrInstructionIdIntType:
196		return "IntType";
197		case IrInstructionIdVectorType:
198		return "VectorType";
199		case IrInstructionIdBoolNot:
200		return "BoolNot";
201		case IrInstructionIdMemset:
202		return "Memset";
203		case IrInstructionIdMemcpy:
204		return "Memcpy";
205		case IrInstructionIdSliceSrc:
206		return "SliceSrc";
207		case IrInstructionIdSliceGen:
208		return "SliceGen";
209		case IrInstructionIdMemberCount:
210		return "MemberCount";
211		case IrInstructionIdMemberType:
212		return "MemberType";
213		case IrInstructionIdMemberName:
214		return "MemberName";
215		case IrInstructionIdBreakpoint:
216		return "Breakpoint";
217		case IrInstructionIdReturnAddress:
218		return "ReturnAddress";
219		case IrInstructionIdFrameAddress:
220		return "FrameAddress";
221		case IrInstructionIdFrameHandle:
222		return "FrameHandle";
223		case IrInstructionIdFrameType:
224		return "FrameType";
225		case IrInstructionIdFrameSizeSrc:
226		return "FrameSizeSrc";
227		case IrInstructionIdFrameSizeGen:
228		return "FrameSizeGen";
229		case IrInstructionIdAlignOf:
230		return "AlignOf";
231		case IrInstructionIdOverflowOp:
232		return "OverflowOp";
233		case IrInstructionIdTestErrSrc:
234		return "TestErrSrc";
235		case IrInstructionIdTestErrGen:
236		return "TestErrGen";
237		case IrInstructionIdMulAdd:
238		return "MulAdd";
239		case IrInstructionIdFloatOp:
240		return "FloatOp";
241		case IrInstructionIdUnwrapErrCode:
242		return "UnwrapErrCode";
243		case IrInstructionIdUnwrapErrPayload:
244		return "UnwrapErrPayload";
245		case IrInstructionIdErrWrapCode:
246		return "ErrWrapCode";
247		case IrInstructionIdErrWrapPayload:
248		return "ErrWrapPayload";
249		case IrInstructionIdFnProto:
250		return "FnProto";
251		case IrInstructionIdTestComptime:
252		return "TestComptime";
253		case IrInstructionIdPtrCastSrc:
254		return "PtrCastSrc";
255		case IrInstructionIdPtrCastGen:
256		return "PtrCastGen";
257		case IrInstructionIdBitCastSrc:
258		return "BitCastSrc";
259		case IrInstructionIdBitCastGen:
260		return "BitCastGen";
261		case IrInstructionIdWidenOrShorten:
262		return "WidenOrShorten";
263		case IrInstructionIdIntToPtr:
264		return "IntToPtr";
265		case IrInstructionIdPtrToInt:
266		return "PtrToInt";
267		case IrInstructionIdIntToEnum:
268		return "IntToEnum";
269		case IrInstructionIdEnumToInt:
270		return "EnumToInt";
271		case IrInstructionIdIntToErr:
272		return "IntToErr";
273		case IrInstructionIdErrToInt:
274		return "ErrToInt";
275		case IrInstructionIdCheckSwitchProngs:
276		return "CheckSwitchProngs";
277		case IrInstructionIdCheckStatementIsVoid:
278		return "CheckStatementIsVoid";
279		case IrInstructionIdTypeName:
280		return "TypeName";
281		case IrInstructionIdDeclRef:
282		return "DeclRef";
283		case IrInstructionIdPanic:
284		return "Panic";
285		case IrInstructionIdTagName:
286		return "TagName";
287		case IrInstructionIdTagType:
288		return "TagType";
289		case IrInstructionIdFieldParentPtr:
290		return "FieldParentPtr";
291		case IrInstructionIdByteOffsetOf:
292		return "ByteOffsetOf";
293		case IrInstructionIdBitOffsetOf:
294		return "BitOffsetOf";
295		case IrInstructionIdTypeInfo:
296		return "TypeInfo";
297		case IrInstructionIdType:
298		return "Type";
299		case IrInstructionIdHasField:
300		return "HasField";
301		case IrInstructionIdTypeId:
302		return "TypeId";
303		case IrInstructionIdSetEvalBranchQuota:
304		return "SetEvalBranchQuota";
305		case IrInstructionIdPtrType:
306		return "PtrType";
307		case IrInstructionIdAlignCast:
308		return "AlignCast";
309		case IrInstructionIdImplicitCast:
310		return "ImplicitCast";
311		case IrInstructionIdResolveResult:
312		return "ResolveResult";
313		case IrInstructionIdResetResult:
314		return "ResetResult";
315		case IrInstructionIdOpaqueType:
316		return "OpaqueType";
317		case IrInstructionIdSetAlignStack:
318		return "SetAlignStack";
319		case IrInstructionIdArgType:
320		return "ArgType";
321		case IrInstructionIdExport:
322		return "Export";
323		case IrInstructionIdErrorReturnTrace:
324		return "ErrorReturnTrace";
325		case IrInstructionIdErrorUnion:
326		return "ErrorUnion";
327		case IrInstructionIdAtomicRmw:
328		return "AtomicRmw";
329		case IrInstructionIdAtomicLoad:
330		return "AtomicLoad";
331		case IrInstructionIdAtomicStore:
332		return "AtomicStore";
333		case IrInstructionIdSaveErrRetAddr:
334		return "SaveErrRetAddr";
335		case IrInstructionIdAddImplicitReturnType:
336		return "AddImplicitReturnType";
337		case IrInstructionIdErrSetCast:
338		return "ErrSetCast";
339		case IrInstructionIdToBytes:
340		return "ToBytes";
341		case IrInstructionIdFromBytes:
342		return "FromBytes";
343		case IrInstructionIdCheckRuntimeScope:
344		return "CheckRuntimeScope";
345		case IrInstructionIdVectorToArray:
346		return "VectorToArray";
347		case IrInstructionIdArrayToVector:
348		return "ArrayToVector";
349		case IrInstructionIdAssertZero:
350		return "AssertZero";
351		case IrInstructionIdAssertNonNull:
352		return "AssertNonNull";
353		case IrInstructionIdHasDecl:
354		return "HasDecl";
355		case IrInstructionIdUndeclaredIdent:
356		return "UndeclaredIdent";
357		case IrInstructionIdAllocaSrc:
358		return "AllocaSrc";
359		case IrInstructionIdAllocaGen:
360		return "AllocaGen";
361		case IrInstructionIdEndExpr:
362		return "EndExpr";
363		case IrInstructionIdPtrOfArrayToSlice:
364		return "PtrOfArrayToSlice";
365		case IrInstructionIdUnionInitNamedField:
366		return "UnionInitNamedField";
367		case IrInstructionIdSuspendBegin:
368		return "SuspendBegin";
369		case IrInstructionIdSuspendFinish:
370		return "SuspendFinish";
371		case IrInstructionIdAwaitSrc:
372		return "AwaitSrc";
373		case IrInstructionIdAwaitGen:
374		return "AwaitGen";
375		case IrInstructionIdResume:
376		return "Resume";
377		case IrInstructionIdSpillBegin:
378		return "SpillBegin";
379		case IrInstructionIdSpillEnd:
380		return "SpillEnd";
381		case IrInstructionIdVectorExtractElem:
382		return "VectorExtractElem";
	60	case IrInstSrcIdInvalid:
	61	return "SrcInvalid";
	62	case IrInstSrcIdShuffleVector:
	63	return "SrcShuffle";
	64	case IrInstSrcIdSplat:
	65	return "SrcSplat";
	66	case IrInstSrcIdDeclVar:
	67	return "SrcDeclVar";
	68	case IrInstSrcIdBr:
	69	return "SrcBr";
	70	case IrInstSrcIdCondBr:
	71	return "SrcCondBr";
	72	case IrInstSrcIdSwitchBr:
	73	return "SrcSwitchBr";
	74	case IrInstSrcIdSwitchVar:
	75	return "SrcSwitchVar";
	76	case IrInstSrcIdSwitchElseVar:
	77	return "SrcSwitchElseVar";
	78	case IrInstSrcIdSwitchTarget:
	79	return "SrcSwitchTarget";
	80	case IrInstSrcIdPhi:
	81	return "SrcPhi";
	82	case IrInstSrcIdUnOp:
	83	return "SrcUnOp";
	84	case IrInstSrcIdBinOp:
	85	return "SrcBinOp";
	86	case IrInstSrcIdMergeErrSets:
	87	return "SrcMergeErrSets";
	88	case IrInstSrcIdLoadPtr:
	89	return "SrcLoadPtr";
	90	case IrInstSrcIdStorePtr:
	91	return "SrcStorePtr";
	92	case IrInstSrcIdFieldPtr:
	93	return "SrcFieldPtr";
	94	case IrInstSrcIdElemPtr:
	95	return "SrcElemPtr";
	96	case IrInstSrcIdVarPtr:
	97	return "SrcVarPtr";
	98	case IrInstSrcIdCallExtra:
	99	return "SrcCallExtra";
	100	case IrInstSrcIdCall:
	101	return "SrcCall";
	102	case IrInstSrcIdCallArgs:
	103	return "SrcCallArgs";
	104	case IrInstSrcIdConst:
	105	return "SrcConst";
	106	case IrInstSrcIdReturn:
	107	return "SrcReturn";
	108	case IrInstSrcIdContainerInitList:
	109	return "SrcContainerInitList";
	110	case IrInstSrcIdContainerInitFields:
	111	return "SrcContainerInitFields";
	112	case IrInstSrcIdUnreachable:
	113	return "SrcUnreachable";
	114	case IrInstSrcIdTypeOf:
	115	return "SrcTypeOf";
	116	case IrInstSrcIdSetCold:
	117	return "SrcSetCold";
	118	case IrInstSrcIdSetRuntimeSafety:
	119	return "SrcSetRuntimeSafety";
	120	case IrInstSrcIdSetFloatMode:
	121	return "SrcSetFloatMode";
	122	case IrInstSrcIdArrayType:
	123	return "SrcArrayType";
	124	case IrInstSrcIdAnyFrameType:
	125	return "SrcAnyFrameType";
	126	case IrInstSrcIdSliceType:
	127	return "SrcSliceType";
	128	case IrInstSrcIdAsm:
	129	return "SrcAsm";
	130	case IrInstSrcIdSizeOf:
	131	return "SrcSizeOf";
	132	case IrInstSrcIdTestNonNull:
	133	return "SrcTestNonNull";
	134	case IrInstSrcIdOptionalUnwrapPtr:
	135	return "SrcOptionalUnwrapPtr";
	136	case IrInstSrcIdClz:
	137	return "SrcClz";
	138	case IrInstSrcIdCtz:
	139	return "SrcCtz";
	140	case IrInstSrcIdPopCount:
	141	return "SrcPopCount";
	142	case IrInstSrcIdBswap:
	143	return "SrcBswap";
	144	case IrInstSrcIdBitReverse:
	145	return "SrcBitReverse";
	146	case IrInstSrcIdImport:
	147	return "SrcImport";
	148	case IrInstSrcIdCImport:
	149	return "SrcCImport";
	150	case IrInstSrcIdCInclude:
	151	return "SrcCInclude";
	152	case IrInstSrcIdCDefine:
	153	return "SrcCDefine";
	154	case IrInstSrcIdCUndef:
	155	return "SrcCUndef";
	156	case IrInstSrcIdRef:
	157	return "SrcRef";
	158	case IrInstSrcIdCompileErr:
	159	return "SrcCompileErr";
	160	case IrInstSrcIdCompileLog:
	161	return "SrcCompileLog";
	162	case IrInstSrcIdErrName:
	163	return "SrcErrName";
	164	case IrInstSrcIdEmbedFile:
	165	return "SrcEmbedFile";
	166	case IrInstSrcIdCmpxchg:
	167	return "SrcCmpxchg";
	168	case IrInstSrcIdFence:
	169	return "SrcFence";
	170	case IrInstSrcIdTruncate:
	171	return "SrcTruncate";
	172	case IrInstSrcIdIntCast:
	173	return "SrcIntCast";
	174	case IrInstSrcIdFloatCast:
	175	return "SrcFloatCast";
	176	case IrInstSrcIdIntToFloat:
	177	return "SrcIntToFloat";
	178	case IrInstSrcIdFloatToInt:
	179	return "SrcFloatToInt";
	180	case IrInstSrcIdBoolToInt:
	181	return "SrcBoolToInt";
	182	case IrInstSrcIdIntType:
	183	return "SrcIntType";
	184	case IrInstSrcIdVectorType:
	185	return "SrcVectorType";
	186	case IrInstSrcIdBoolNot:
	187	return "SrcBoolNot";
	188	case IrInstSrcIdMemset:
	189	return "SrcMemset";
	190	case IrInstSrcIdMemcpy:
	191	return "SrcMemcpy";
	192	case IrInstSrcIdSlice:
	193	return "SrcSlice";
	194	case IrInstSrcIdMemberCount:
	195	return "SrcMemberCount";
	196	case IrInstSrcIdMemberType:
	197	return "SrcMemberType";
	198	case IrInstSrcIdMemberName:
	199	return "SrcMemberName";
	200	case IrInstSrcIdBreakpoint:
	201	return "SrcBreakpoint";
	202	case IrInstSrcIdReturnAddress:
	203	return "SrcReturnAddress";
	204	case IrInstSrcIdFrameAddress:
	205	return "SrcFrameAddress";
	206	case IrInstSrcIdFrameHandle:
	207	return "SrcFrameHandle";
	208	case IrInstSrcIdFrameType:
	209	return "SrcFrameType";
	210	case IrInstSrcIdFrameSize:
	211	return "SrcFrameSize";
	212	case IrInstSrcIdAlignOf:
	213	return "SrcAlignOf";
	214	case IrInstSrcIdOverflowOp:
	215	return "SrcOverflowOp";
	216	case IrInstSrcIdTestErr:
	217	return "SrcTestErr";
	218	case IrInstSrcIdMulAdd:
	219	return "SrcMulAdd";
	220	case IrInstSrcIdFloatOp:
	221	return "SrcFloatOp";
	222	case IrInstSrcIdUnwrapErrCode:
	223	return "SrcUnwrapErrCode";
	224	case IrInstSrcIdUnwrapErrPayload:
	225	return "SrcUnwrapErrPayload";
	226	case IrInstSrcIdFnProto:
	227	return "SrcFnProto";
	228	case IrInstSrcIdTestComptime:
	229	return "SrcTestComptime";
	230	case IrInstSrcIdPtrCast:
	231	return "SrcPtrCast";
	232	case IrInstSrcIdBitCast:
	233	return "SrcBitCast";
	234	case IrInstSrcIdIntToPtr:
	235	return "SrcIntToPtr";
	236	case IrInstSrcIdPtrToInt:
	237	return "SrcPtrToInt";
	238	case IrInstSrcIdIntToEnum:
	239	return "SrcIntToEnum";
	240	case IrInstSrcIdEnumToInt:
	241	return "SrcEnumToInt";
	242	case IrInstSrcIdIntToErr:
	243	return "SrcIntToErr";
	244	case IrInstSrcIdErrToInt:
	245	return "SrcErrToInt";
	246	case IrInstSrcIdCheckSwitchProngs:
	247	return "SrcCheckSwitchProngs";
	248	case IrInstSrcIdCheckStatementIsVoid:
	249	return "SrcCheckStatementIsVoid";
	250	case IrInstSrcIdTypeName:
	251	return "SrcTypeName";
	252	case IrInstSrcIdDeclRef:
	253	return "SrcDeclRef";
	254	case IrInstSrcIdPanic:
	255	return "SrcPanic";
	256	case IrInstSrcIdTagName:
	257	return "SrcTagName";
	258	case IrInstSrcIdTagType:
	259	return "SrcTagType";
	260	case IrInstSrcIdFieldParentPtr:
	261	return "SrcFieldParentPtr";
	262	case IrInstSrcIdByteOffsetOf:
	263	return "SrcByteOffsetOf";
	264	case IrInstSrcIdBitOffsetOf:
	265	return "SrcBitOffsetOf";
	266	case IrInstSrcIdTypeInfo:
	267	return "SrcTypeInfo";
	268	case IrInstSrcIdType:
	269	return "SrcType";
	270	case IrInstSrcIdHasField:
	271	return "SrcHasField";
	272	case IrInstSrcIdTypeId:
	273	return "SrcTypeId";
	274	case IrInstSrcIdSetEvalBranchQuota:
	275	return "SrcSetEvalBranchQuota";
	276	case IrInstSrcIdPtrType:
	277	return "SrcPtrType";
	278	case IrInstSrcIdAlignCast:
	279	return "SrcAlignCast";
	280	case IrInstSrcIdImplicitCast:
	281	return "SrcImplicitCast";
	282	case IrInstSrcIdResolveResult:
	283	return "SrcResolveResult";
	284	case IrInstSrcIdResetResult:
	285	return "SrcResetResult";
	286	case IrInstSrcIdOpaqueType:
	287	return "SrcOpaqueType";
	288	case IrInstSrcIdSetAlignStack:
	289	return "SrcSetAlignStack";
	290	case IrInstSrcIdArgType:
	291	return "SrcArgType";
	292	case IrInstSrcIdExport:
	293	return "SrcExport";
	294	case IrInstSrcIdErrorReturnTrace:
	295	return "SrcErrorReturnTrace";
	296	case IrInstSrcIdErrorUnion:
	297	return "SrcErrorUnion";
	298	case IrInstSrcIdAtomicRmw:
	299	return "SrcAtomicRmw";
	300	case IrInstSrcIdAtomicLoad:
	301	return "SrcAtomicLoad";
	302	case IrInstSrcIdAtomicStore:
	303	return "SrcAtomicStore";
	304	case IrInstSrcIdSaveErrRetAddr:
	305	return "SrcSaveErrRetAddr";
	306	case IrInstSrcIdAddImplicitReturnType:
	307	return "SrcAddImplicitReturnType";
	308	case IrInstSrcIdErrSetCast:
	309	return "SrcErrSetCast";
	310	case IrInstSrcIdToBytes:
	311	return "SrcToBytes";
	312	case IrInstSrcIdFromBytes:
	313	return "SrcFromBytes";
	314	case IrInstSrcIdCheckRuntimeScope:
	315	return "SrcCheckRuntimeScope";
	316	case IrInstSrcIdHasDecl:
	317	return "SrcHasDecl";
	318	case IrInstSrcIdUndeclaredIdent:
	319	return "SrcUndeclaredIdent";
	320	case IrInstSrcIdAlloca:
	321	return "SrcAlloca";
	322	case IrInstSrcIdEndExpr:
	323	return "SrcEndExpr";
	324	case IrInstSrcIdUnionInitNamedField:
	325	return "SrcUnionInitNamedField";
	326	case IrInstSrcIdSuspendBegin:
	327	return "SrcSuspendBegin";
	328	case IrInstSrcIdSuspendFinish:
	329	return "SrcSuspendFinish";
	330	case IrInstSrcIdAwait:
	331	return "SrcAwaitSr";
	332	case IrInstSrcIdResume:
	333	return "SrcResume";
	334	case IrInstSrcIdSpillBegin:
	335	return "SrcSpillBegin";
	336	case IrInstSrcIdSpillEnd:
	337	return "SrcSpillEnd";
383	338	}
384	339	zig_unreachable();
385	340	}
386	341
387		static void ir_print_indent(IrPrint *irp) {
	342	const char* ir_inst_gen_type_str(IrInstGenId id) {
	343	switch (id) {
	344	case IrInstGenIdInvalid:
	345	return "GenInvalid";
	346	case IrInstGenIdShuffleVector:
	347	return "GenShuffle";
	348	case IrInstGenIdSplat:
	349	return "GenSplat";
	350	case IrInstGenIdDeclVar:
	351	return "GenDeclVar";
	352	case IrInstGenIdBr:
	353	return "GenBr";
	354	case IrInstGenIdCondBr:
	355	return "GenCondBr";
	356	case IrInstGenIdSwitchBr:
	357	return "GenSwitchBr";
	358	case IrInstGenIdPhi:
	359	return "GenPhi";
	360	case IrInstGenIdBinOp:
	361	return "GenBinOp";
	362	case IrInstGenIdLoadPtr:
	363	return "GenLoadPtr";
	364	case IrInstGenIdStorePtr:
	365	return "GenStorePtr";
	366	case IrInstGenIdVectorStoreElem:
	367	return "GenVectorStoreElem";
	368	case IrInstGenIdStructFieldPtr:
	369	return "GenStructFieldPtr";
	370	case IrInstGenIdUnionFieldPtr:
	371	return "GenUnionFieldPtr";
	372	case IrInstGenIdElemPtr:
	373	return "GenElemPtr";
	374	case IrInstGenIdVarPtr:
	375	return "GenVarPtr";
	376	case IrInstGenIdReturnPtr:
	377	return "GenReturnPtr";
	378	case IrInstGenIdCall:
	379	return "GenCall";
	380	case IrInstGenIdConst:
	381	return "GenConst";
	382	case IrInstGenIdReturn:
	383	return "GenReturn";
	384	case IrInstGenIdCast:
	385	return "GenCast";
	386	case IrInstGenIdResizeSlice:
	387	return "GenResizeSlice";
	388	case IrInstGenIdUnreachable:
	389	return "GenUnreachable";
	390	case IrInstGenIdAsm:
	391	return "GenAsm";
	392	case IrInstGenIdTestNonNull:
	393	return "GenTestNonNull";
	394	case IrInstGenIdOptionalUnwrapPtr:
	395	return "GenOptionalUnwrapPtr";
	396	case IrInstGenIdOptionalWrap:
	397	return "GenOptionalWrap";
	398	case IrInstGenIdUnionTag:
	399	return "GenUnionTag";
	400	case IrInstGenIdClz:
	401	return "GenClz";
	402	case IrInstGenIdCtz:
	403	return "GenCtz";
	404	case IrInstGenIdPopCount:
	405	return "GenPopCount";
	406	case IrInstGenIdBswap:
	407	return "GenBswap";
	408	case IrInstGenIdBitReverse:
	409	return "GenBitReverse";
	410	case IrInstGenIdRef:
	411	return "GenRef";
	412	case IrInstGenIdErrName:
	413	return "GenErrName";
	414	case IrInstGenIdCmpxchg:
	415	return "GenCmpxchg";
	416	case IrInstGenIdFence:
	417	return "GenFence";
	418	case IrInstGenIdTruncate:
	419	return "GenTruncate";
	420	case IrInstGenIdBoolNot:
	421	return "GenBoolNot";
	422	case IrInstGenIdMemset:
	423	return "GenMemset";
	424	case IrInstGenIdMemcpy:
	425	return "GenMemcpy";
	426	case IrInstGenIdSlice:
	427	return "GenSlice";
	428	case IrInstGenIdBreakpoint:
	429	return "GenBreakpoint";
	430	case IrInstGenIdReturnAddress:
	431	return "GenReturnAddress";
	432	case IrInstGenIdFrameAddress:
	433	return "GenFrameAddress";
	434	case IrInstGenIdFrameHandle:
	435	return "GenFrameHandle";
	436	case IrInstGenIdFrameSize:
	437	return "GenFrameSize";
	438	case IrInstGenIdOverflowOp:
	439	return "GenOverflowOp";
	440	case IrInstGenIdTestErr:
	441	return "GenTestErr";
	442	case IrInstGenIdMulAdd:
	443	return "GenMulAdd";
	444	case IrInstGenIdFloatOp:
	445	return "GenFloatOp";
	446	case IrInstGenIdUnwrapErrCode:
	447	return "GenUnwrapErrCode";
	448	case IrInstGenIdUnwrapErrPayload:
	449	return "GenUnwrapErrPayload";
	450	case IrInstGenIdErrWrapCode:
	451	return "GenErrWrapCode";
	452	case IrInstGenIdErrWrapPayload:
	453	return "GenErrWrapPayload";
	454	case IrInstGenIdPtrCast:
	455	return "GenPtrCast";
	456	case IrInstGenIdBitCast:
	457	return "GenBitCast";
	458	case IrInstGenIdWidenOrShorten:
	459	return "GenWidenOrShorten";
	460	case IrInstGenIdIntToPtr:
	461	return "GenIntToPtr";
	462	case IrInstGenIdPtrToInt:
	463	return "GenPtrToInt";
	464	case IrInstGenIdIntToEnum:
	465	return "GenIntToEnum";
	466	case IrInstGenIdIntToErr:
	467	return "GenIntToErr";
	468	case IrInstGenIdErrToInt:
	469	return "GenErrToInt";
	470	case IrInstGenIdPanic:
	471	return "GenPanic";
	472	case IrInstGenIdTagName:
	473	return "GenTagName";
	474	case IrInstGenIdFieldParentPtr:
	475	return "GenFieldParentPtr";
	476	case IrInstGenIdAlignCast:
	477	return "GenAlignCast";
	478	case IrInstGenIdErrorReturnTrace:
	479	return "GenErrorReturnTrace";
	480	case IrInstGenIdAtomicRmw:
	481	return "GenAtomicRmw";
	482	case IrInstGenIdAtomicLoad:
	483	return "GenAtomicLoad";
	484	case IrInstGenIdAtomicStore:
	485	return "GenAtomicStore";
	486	case IrInstGenIdSaveErrRetAddr:
	487	return "GenSaveErrRetAddr";
	488	case IrInstGenIdVectorToArray:
	489	return "GenVectorToArray";
	490	case IrInstGenIdArrayToVector:
	491	return "GenArrayToVector";
	492	case IrInstGenIdAssertZero:
	493	return "GenAssertZero";
	494	case IrInstGenIdAssertNonNull:
	495	return "GenAssertNonNull";
	496	case IrInstGenIdAlloca:
	497	return "GenAlloca";
	498	case IrInstGenIdPtrOfArrayToSlice:
	499	return "GenPtrOfArrayToSlice";
	500	case IrInstGenIdSuspendBegin:
	501	return "GenSuspendBegin";
	502	case IrInstGenIdSuspendFinish:
	503	return "GenSuspendFinish";
	504	case IrInstGenIdAwait:
	505	return "GenAwait";
	506	case IrInstGenIdResume:
	507	return "GenResume";
	508	case IrInstGenIdSpillBegin:
	509	return "GenSpillBegin";
	510	case IrInstGenIdSpillEnd:
	511	return "GenSpillEnd";
	512	case IrInstGenIdVectorExtractElem:
	513	return "GenVectorExtractElem";
	514	case IrInstGenIdBinaryNot:
	515	return "GenBinaryNot";
	516	case IrInstGenIdNegation:
	517	return "GenNegation";
	518	case IrInstGenIdNegationWrapping:
	519	return "GenNegationWrapping";
	520	}
	521	zig_unreachable();
	522	}
	523
	524	static void ir_print_indent_src(IrPrintSrc *irp) {
388	525	for (int i = 0; i < irp->indent; i += 1) {
389	526	fprintf(irp->f, " ");
390	527	}
391	528	}
392	529
393		static void ir_print_prefix(IrPrint irp, IrInstruction instruction, bool trailing) {
394		ir_print_indent(irp);
	530	static void ir_print_indent_gen(IrPrintGen *irp) {
	531	for (int i = 0; i < irp->indent; i += 1) {
	532	fprintf(irp->f, " ");
	533	}
	534	}
	535
	536	static void ir_print_prefix_src(IrPrintSrc irp, IrInstSrc instruction, bool trailing) {
	537	ir_print_indent_src(irp);
	538	const char mark = trailing ? ':' : '#';
	539	const char *type_name;
	540	if (instruction->id == IrInstSrcIdConst) {
	541	type_name = buf_ptr(&reinterpret_cast<IrInstSrcConst *>(instruction)->value->type->name);
	542	} else if (instruction->is_noreturn) {
	543	type_name = "noreturn";
	544	} else {
	545	type_name = "(unknown)";
	546	}
	547	const char *ref_count = ir_inst_src_has_side_effects(instruction) ?
	548	"-" : buf_ptr(buf_sprintf("%" PRIu32 "", instruction->base.ref_count));
	549	fprintf(irp->f, "%c%-3" PRIu32 "\| %-22s\| %-12s\| %-2s\| ", mark, instruction->base.debug_id,
	550	ir_inst_src_type_str(instruction->id), type_name, ref_count);
	551	}
	552
	553	static void ir_print_prefix_gen(IrPrintGen irp, IrInstGen instruction, bool trailing) {
	554	ir_print_indent_gen(irp);
395	555	const char mark = trailing ? ':' : '#';
396	556	const char *type_name = instruction->value->type ? buf_ptr(&instruction->value->type->name) : "(unknown)";
397		const char *ref_count = ir_has_side_effects(instruction) ?
398		"-" : buf_ptr(buf_sprintf("%" PRIu32 "", instruction->ref_count));
399		fprintf(irp->f, "%c%-3" PRIu32 "\| %-22s\| %-12s\| %-2s\| ", mark, instruction->debug_id,
400		ir_instruction_type_str(instruction->id), type_name, ref_count);
	557	const char *ref_count = ir_inst_gen_has_side_effects(instruction) ?
	558	"-" : buf_ptr(buf_sprintf("%" PRIu32 "", instruction->base.ref_count));
	559	fprintf(irp->f, "%c%-3" PRIu32 "\| %-22s\| %-12s\| %-2s\| ", mark, instruction->base.debug_id,
	560	ir_inst_gen_type_str(instruction->id), type_name, ref_count);
401	561	}
402	562
403		static void ir_print_const_value(IrPrint irp, ZigValue const_val) {
404		Buf buf = BUF_INIT;
405		buf_resize(&buf, 0);
406		render_const_value(irp->codegen, &buf, const_val);
407		fprintf(irp->f, "%s", buf_ptr(&buf));
	563	static void ir_print_var_src(IrPrintSrc irp, IrInstSrc inst) {
	564	fprintf(irp->f, "#%" PRIu32 "", inst->base.debug_id);
408	565	}
409	566
410		static void ir_print_var_instruction(IrPrint irp, IrInstruction instruction) {
411		fprintf(irp->f, "#%" PRIu32 "", instruction->debug_id);
412		if (irp->pass != IrPassSrc && irp->printed.maybe_get(instruction) == nullptr) {
413		irp->printed.put(instruction, 0);
414		irp->pending.append(instruction);
	567	static void ir_print_var_gen(IrPrintGen irp, IrInstGen inst) {
	568	fprintf(irp->f, "#%" PRIu32 "", inst->base.debug_id);
	569	if (irp->printed.maybe_get(inst) == nullptr) {
	570	irp->printed.put(inst, 0);
	571	irp->pending.append(inst);
415	572	}
416	573	}
417	574
418		static void ir_print_other_instruction(IrPrint irp, IrInstruction instruction) {
419		if (instruction == nullptr) {
	575	static void ir_print_other_inst_src(IrPrintSrc irp, IrInstSrc inst) {
	576	if (inst == nullptr) {
420	577	fprintf(irp->f, "(null)");
421	578	return;
422	579	}
	580	ir_print_var_src(irp, inst);
	581	}
	582
	583	static void ir_print_const_value(CodeGen g, FILE f, ZigValue *const_val) {
	584	Buf buf = BUF_INIT;
	585	buf_resize(&buf, 0);
	586	render_const_value(g, &buf, const_val);
	587	fprintf(f, "%s", buf_ptr(&buf));
	588	}
	589
	590	static void ir_print_other_inst_gen(IrPrintGen irp, IrInstGen inst) {
	591	if (inst == nullptr) {
	592	fprintf(irp->f, "(null)");
	593	return;
	594	}
	595
	596	if (inst->value->special != ConstValSpecialRuntime) {
	597	ir_print_const_value(irp->codegen, irp->f, inst->value);
	598	} else {
	599	ir_print_var_gen(irp, inst);
	600	}
	601	}
423	602
424		if (instruction->value->special != ConstValSpecialRuntime) {
425		ir_print_const_value(irp, instruction->value);
	603	static void ir_print_other_block(IrPrintSrc irp, IrBasicBlockSrc bb) {
	604	if (bb == nullptr) {
	605	fprintf(irp->f, "(null block)");
426	606	} else {
427		ir_print_var_instruction(irp, instruction);
	607	fprintf(irp->f, "$%s_%" PRIu32 "", bb->name_hint, bb->debug_id);
428	608	}
429	609	}
430	610
431		static void ir_print_other_block(IrPrint irp, IrBasicBlock bb) {
	611	static void ir_print_other_block_gen(IrPrintGen irp, IrBasicBlockGen bb) {
432	612	if (bb == nullptr) {
433	613	fprintf(irp->f, "(null block)");
434	614	} else {
435		fprintf(irp->f, "$%s_%" ZIG_PRI_usize "", bb->name_hint, bb->debug_id);
	615	fprintf(irp->f, "$%s_%" PRIu32 "", bb->name_hint, bb->debug_id);
436	616	}
437	617	}
438	618
439		static void ir_print_return(IrPrint irp, IrInstructionReturn instruction) {
	619	static void ir_print_return_src(IrPrintSrc irp, IrInstSrcReturn inst) {
440	620	fprintf(irp->f, "return ");
441		ir_print_other_instruction(irp, instruction->operand);
	621	ir_print_other_inst_src(irp, inst->operand);
442	622	}
443	623
444		static void ir_print_const(IrPrint irp, IrInstructionConst const_instruction) {
445		ir_print_const_value(irp, const_instruction->base.value);
	624	static void ir_print_return_gen(IrPrintGen irp, IrInstGenReturn inst) {
	625	fprintf(irp->f, "return ");
	626	ir_print_other_inst_gen(irp, inst->operand);
	627	}
	628
	629	static void ir_print_const(IrPrintSrc irp, IrInstSrcConst const_instruction) {
	630	ir_print_const_value(irp->codegen, irp->f, const_instruction->value);
	631	}
	632
	633	static void ir_print_const(IrPrintGen irp, IrInstGenConst const_instruction) {
	634	ir_print_const_value(irp->codegen, irp->f, const_instruction->base.value);
446	635	}
447	636
448	637	static const char *ir_bin_op_id_str(IrBinOp op_id) {
...	...	@@ -531,89 +720,111 @@ static const char *ir_un_op_id_str(IrUnOp op_id) {
531	720	zig_unreachable();
532	721	}
533	722
534		static void ir_print_un_op(IrPrint irp, IrInstructionUnOp un_op_instruction) {
535		fprintf(irp->f, "%s ", ir_un_op_id_str(un_op_instruction->op_id));
536		ir_print_other_instruction(irp, un_op_instruction->value);
	723	static void ir_print_un_op(IrPrintSrc irp, IrInstSrcUnOp inst) {
	724	fprintf(irp->f, "%s ", ir_un_op_id_str(inst->op_id));
	725	ir_print_other_inst_src(irp, inst->value);
	726	}
	727
	728	static void ir_print_bin_op(IrPrintSrc irp, IrInstSrcBinOp bin_op_instruction) {
	729	ir_print_other_inst_src(irp, bin_op_instruction->op1);
	730	fprintf(irp->f, " %s ", ir_bin_op_id_str(bin_op_instruction->op_id));
	731	ir_print_other_inst_src(irp, bin_op_instruction->op2);
	732	if (!bin_op_instruction->safety_check_on) {
	733	fprintf(irp->f, " // no safety");
	734	}
537	735	}
538	736
539		static void ir_print_bin_op(IrPrint irp, IrInstructionBinOp bin_op_instruction) {
540		ir_print_other_instruction(irp, bin_op_instruction->op1);
	737	static void ir_print_bin_op(IrPrintGen irp, IrInstGenBinOp bin_op_instruction) {
	738	ir_print_other_inst_gen(irp, bin_op_instruction->op1);
541	739	fprintf(irp->f, " %s ", ir_bin_op_id_str(bin_op_instruction->op_id));
542		ir_print_other_instruction(irp, bin_op_instruction->op2);
	740	ir_print_other_inst_gen(irp, bin_op_instruction->op2);
543	741	if (!bin_op_instruction->safety_check_on) {
544	742	fprintf(irp->f, " // no safety");
545	743	}
546	744	}
547	745
548		static void ir_print_merge_err_sets(IrPrint irp, IrInstructionMergeErrSets instruction) {
549		ir_print_other_instruction(irp, instruction->op1);
	746	static void ir_print_merge_err_sets(IrPrintSrc irp, IrInstSrcMergeErrSets instruction) {
	747	ir_print_other_inst_src(irp, instruction->op1);
550	748	fprintf(irp->f, " \|\| ");
551		ir_print_other_instruction(irp, instruction->op2);
	749	ir_print_other_inst_src(irp, instruction->op2);
552	750	if (instruction->type_name != nullptr) {
553	751	fprintf(irp->f, " // name=%s", buf_ptr(instruction->type_name));
554	752	}
555	753	}
556	754
557		static void ir_print_decl_var_src(IrPrint irp, IrInstructionDeclVarSrc decl_var_instruction) {
	755	static void ir_print_decl_var_src(IrPrintSrc irp, IrInstSrcDeclVar decl_var_instruction) {
558	756	const char *var_or_const = decl_var_instruction->var->gen_is_const ? "const" : "var";
559	757	const char *name = decl_var_instruction->var->name;
560	758	if (decl_var_instruction->var_type) {
561	759	fprintf(irp->f, "%s %s: ", var_or_const, name);
562		ir_print_other_instruction(irp, decl_var_instruction->var_type);
	760	ir_print_other_inst_src(irp, decl_var_instruction->var_type);
563	761	fprintf(irp->f, " ");
564	762	} else {
565	763	fprintf(irp->f, "%s %s ", var_or_const, name);
566	764	}
567	765	if (decl_var_instruction->align_value) {
568	766	fprintf(irp->f, "align ");
569		ir_print_other_instruction(irp, decl_var_instruction->align_value);
	767	ir_print_other_inst_src(irp, decl_var_instruction->align_value);
570	768	fprintf(irp->f, " ");
571	769	}
572	770	fprintf(irp->f, "= ");
573		ir_print_other_instruction(irp, decl_var_instruction->ptr);
	771	ir_print_other_inst_src(irp, decl_var_instruction->ptr);
574	772	if (decl_var_instruction->var->is_comptime != nullptr) {
575	773	fprintf(irp->f, " // comptime = ");
576		ir_print_other_instruction(irp, decl_var_instruction->var->is_comptime);
	774	ir_print_other_inst_src(irp, decl_var_instruction->var->is_comptime);
577	775	}
578	776	}
579	777
580		static void ir_print_cast(IrPrint irp, IrInstructionCast cast_instruction) {
581		fprintf(irp->f, "cast ");
582		ir_print_other_instruction(irp, cast_instruction->value);
583		fprintf(irp->f, " to %s", buf_ptr(&cast_instruction->dest_type->name));
	778	static const char *cast_op_str(CastOp op) {
	779	switch (op) {
	780	case CastOpNoCast: return "NoCast";
	781	case CastOpNoop: return "NoOp";
	782	case CastOpIntToFloat: return "IntToFloat";
	783	case CastOpFloatToInt: return "FloatToInt";
	784	case CastOpBoolToInt: return "BoolToInt";
	785	case CastOpNumLitToConcrete: return "NumLitToConcrate";
	786	case CastOpErrSet: return "ErrSet";
	787	case CastOpBitCast: return "BitCast";
	788	}
	789	zig_unreachable();
	790	}
	791
	792	static void ir_print_cast(IrPrintGen irp, IrInstGenCast cast_instruction) {
	793	fprintf(irp->f, "%s cast ", cast_op_str(cast_instruction->cast_op));
	794	ir_print_other_inst_gen(irp, cast_instruction->value);
584	795	}
585	796
586		static void ir_print_result_loc_var(IrPrint irp, ResultLocVar result_loc_var) {
	797	static void ir_print_result_loc_var(IrPrintSrc irp, ResultLocVar result_loc_var) {
587	798	fprintf(irp->f, "var(");
588		ir_print_other_instruction(irp, result_loc_var->base.source_instruction);
	799	ir_print_other_inst_src(irp, result_loc_var->base.source_instruction);
589	800	fprintf(irp->f, ")");
590	801	}
591	802
592		static void ir_print_result_loc_instruction(IrPrint irp, ResultLocInstruction result_loc_inst) {
	803	static void ir_print_result_loc_instruction(IrPrintSrc irp, ResultLocInstruction result_loc_inst) {
593	804	fprintf(irp->f, "inst(");
594		ir_print_other_instruction(irp, result_loc_inst->base.source_instruction);
	805	ir_print_other_inst_src(irp, result_loc_inst->base.source_instruction);
595	806	fprintf(irp->f, ")");
596	807	}
597	808
598		static void ir_print_result_loc_peer(IrPrint irp, ResultLocPeer result_loc_peer) {
	809	static void ir_print_result_loc_peer(IrPrintSrc irp, ResultLocPeer result_loc_peer) {
599	810	fprintf(irp->f, "peer(next=");
600	811	ir_print_other_block(irp, result_loc_peer->next_bb);
601	812	fprintf(irp->f, ")");
602	813	}
603	814
604		static void ir_print_result_loc_bit_cast(IrPrint irp, ResultLocBitCast result_loc_bit_cast) {
	815	static void ir_print_result_loc_bit_cast(IrPrintSrc irp, ResultLocBitCast result_loc_bit_cast) {
605	816	fprintf(irp->f, "bitcast(ty=");
606		ir_print_other_instruction(irp, result_loc_bit_cast->base.source_instruction);
	817	ir_print_other_inst_src(irp, result_loc_bit_cast->base.source_instruction);
607	818	fprintf(irp->f, ")");
608	819	}
609	820
610		static void ir_print_result_loc_cast(IrPrint irp, ResultLocCast result_loc_cast) {
	821	static void ir_print_result_loc_cast(IrPrintSrc irp, ResultLocCast result_loc_cast) {
611	822	fprintf(irp->f, "cast(ty=");
612		ir_print_other_instruction(irp, result_loc_cast->base.source_instruction);
	823	ir_print_other_inst_src(irp, result_loc_cast->base.source_instruction);
613	824	fprintf(irp->f, ")");
614	825	}
615	826
616		static void ir_print_result_loc(IrPrint irp, ResultLoc result_loc) {
	827	static void ir_print_result_loc(IrPrintSrc irp, ResultLoc result_loc) {
617	828	switch (result_loc->id) {
618	829	case ResultLocIdInvalid:
619	830	zig_unreachable();
...	...	@@ -640,34 +851,34 @@ static void ir_print_result_loc(IrPrint irp, ResultLoc result_loc) {
640	851	zig_unreachable();
641	852	}
642	853
643		static void ir_print_call_extra(IrPrint irp, IrInstructionCallExtra instruction) {
	854	static void ir_print_call_extra(IrPrintSrc irp, IrInstSrcCallExtra instruction) {
644	855	fprintf(irp->f, "opts=");
645		ir_print_other_instruction(irp, instruction->options);
	856	ir_print_other_inst_src(irp, instruction->options);
646	857	fprintf(irp->f, ", fn=");
647		ir_print_other_instruction(irp, instruction->fn_ref);
	858	ir_print_other_inst_src(irp, instruction->fn_ref);
648	859	fprintf(irp->f, ", args=");
649		ir_print_other_instruction(irp, instruction->args);
	860	ir_print_other_inst_src(irp, instruction->args);
650	861	fprintf(irp->f, ", result=");
651	862	ir_print_result_loc(irp, instruction->result_loc);
652	863	}
653	864
654		static void ir_print_call_src_args(IrPrint irp, IrInstructionCallSrcArgs instruction) {
	865	static void ir_print_call_args(IrPrintSrc irp, IrInstSrcCallArgs instruction) {
655	866	fprintf(irp->f, "opts=");
656		ir_print_other_instruction(irp, instruction->options);
	867	ir_print_other_inst_src(irp, instruction->options);
657	868	fprintf(irp->f, ", fn=");
658		ir_print_other_instruction(irp, instruction->fn_ref);
	869	ir_print_other_inst_src(irp, instruction->fn_ref);
659	870	fprintf(irp->f, ", args=(");
660	871	for (size_t i = 0; i < instruction->args_len; i += 1) {
661		IrInstruction *arg = instruction->args_ptr[i];
	872	IrInstSrc *arg = instruction->args_ptr[i];
662	873	if (i != 0)
663	874	fprintf(irp->f, ", ");
664		ir_print_other_instruction(irp, arg);
	875	ir_print_other_inst_src(irp, arg);
665	876	}
666	877	fprintf(irp->f, "), result=");
667	878	ir_print_result_loc(irp, instruction->result_loc);
668	879	}
669	880
670		static void ir_print_call_src(IrPrint irp, IrInstructionCallSrc call_instruction) {
	881	static void ir_print_call_src(IrPrintSrc irp, IrInstSrcCall call_instruction) {
671	882	switch (call_instruction->modifier) {
672	883	case CallModifierNone:
673	884	break;
...	...	@@ -699,20 +910,20 @@ static void ir_print_call_src(IrPrint irp, IrInstructionCallSrc call_instructi
699	910	fprintf(irp->f, "%s", buf_ptr(&call_instruction->fn_entry->symbol_name));
700	911	} else {
701	912	assert(call_instruction->fn_ref);
702		ir_print_other_instruction(irp, call_instruction->fn_ref);
	913	ir_print_other_inst_src(irp, call_instruction->fn_ref);
703	914	}
704	915	fprintf(irp->f, "(");
705	916	for (size_t i = 0; i < call_instruction->arg_count; i += 1) {
706		IrInstruction *arg = call_instruction->args[i];
	917	IrInstSrc *arg = call_instruction->args[i];
707	918	if (i != 0)
708	919	fprintf(irp->f, ", ");
709		ir_print_other_instruction(irp, arg);
	920	ir_print_other_inst_src(irp, arg);
710	921	}
711	922	fprintf(irp->f, ")result=");
712	923	ir_print_result_loc(irp, call_instruction->result_loc);
713	924	}
714	925
715		static void ir_print_call_gen(IrPrint irp, IrInstructionCallGen call_instruction) {
	926	static void ir_print_call_gen(IrPrintGen irp, IrInstGenCall call_instruction) {
716	927	switch (call_instruction->modifier) {
717	928	case CallModifierNone:
718	929	break;
...	...	@@ -744,221 +955,291 @@ static void ir_print_call_gen(IrPrint irp, IrInstructionCallGen call_instructi
744	955	fprintf(irp->f, "%s", buf_ptr(&call_instruction->fn_entry->symbol_name));
745	956	} else {
746	957	assert(call_instruction->fn_ref);
747		ir_print_other_instruction(irp, call_instruction->fn_ref);
	958	ir_print_other_inst_gen(irp, call_instruction->fn_ref);
748	959	}
749	960	fprintf(irp->f, "(");
750	961	for (size_t i = 0; i < call_instruction->arg_count; i += 1) {
751		IrInstruction *arg = call_instruction->args[i];
	962	IrInstGen *arg = call_instruction->args[i];
752	963	if (i != 0)
753	964	fprintf(irp->f, ", ");
754		ir_print_other_instruction(irp, arg);
	965	ir_print_other_inst_gen(irp, arg);
755	966	}
756	967	fprintf(irp->f, ")result=");
757		ir_print_other_instruction(irp, call_instruction->result_loc);
	968	ir_print_other_inst_gen(irp, call_instruction->result_loc);
758	969	}
759	970
760		static void ir_print_cond_br(IrPrint irp, IrInstructionCondBr cond_br_instruction) {
	971	static void ir_print_cond_br(IrPrintSrc irp, IrInstSrcCondBr inst) {
761	972	fprintf(irp->f, "if (");
762		ir_print_other_instruction(irp, cond_br_instruction->condition);
	973	ir_print_other_inst_src(irp, inst->condition);
763	974	fprintf(irp->f, ") ");
764		ir_print_other_block(irp, cond_br_instruction->then_block);
	975	ir_print_other_block(irp, inst->then_block);
765	976	fprintf(irp->f, " else ");
766		ir_print_other_block(irp, cond_br_instruction->else_block);
767		if (cond_br_instruction->is_comptime != nullptr) {
	977	ir_print_other_block(irp, inst->else_block);
	978	if (inst->is_comptime != nullptr) {
768	979	fprintf(irp->f, " // comptime = ");
769		ir_print_other_instruction(irp, cond_br_instruction->is_comptime);
	980	ir_print_other_inst_src(irp, inst->is_comptime);
770	981	}
771	982	}
772	983
773		static void ir_print_br(IrPrint irp, IrInstructionBr br_instruction) {
	984	static void ir_print_cond_br(IrPrintGen irp, IrInstGenCondBr inst) {
	985	fprintf(irp->f, "if (");
	986	ir_print_other_inst_gen(irp, inst->condition);
	987	fprintf(irp->f, ") ");
	988	ir_print_other_block_gen(irp, inst->then_block);
	989	fprintf(irp->f, " else ");
	990	ir_print_other_block_gen(irp, inst->else_block);
	991	}
	992
	993	static void ir_print_br(IrPrintSrc irp, IrInstSrcBr br_instruction) {
774	994	fprintf(irp->f, "goto ");
775	995	ir_print_other_block(irp, br_instruction->dest_block);
776	996	if (br_instruction->is_comptime != nullptr) {
777	997	fprintf(irp->f, " // comptime = ");
778		ir_print_other_instruction(irp, br_instruction->is_comptime);
	998	ir_print_other_inst_src(irp, br_instruction->is_comptime);
779	999	}
780	1000	}
781	1001
782		static void ir_print_phi(IrPrint irp, IrInstructionPhi phi_instruction) {
	1002	static void ir_print_br(IrPrintGen irp, IrInstGenBr inst) {
	1003	fprintf(irp->f, "goto ");
	1004	ir_print_other_block_gen(irp, inst->dest_block);
	1005	}
	1006
	1007	static void ir_print_phi(IrPrintSrc irp, IrInstSrcPhi phi_instruction) {
783	1008	assert(phi_instruction->incoming_count != 0);
784	1009	assert(phi_instruction->incoming_count != SIZE_MAX);
785	1010	for (size_t i = 0; i < phi_instruction->incoming_count; i += 1) {
786		IrBasicBlock *incoming_block = phi_instruction->incoming_blocks[i];
787		IrInstruction *incoming_value = phi_instruction->incoming_values[i];
	1011	IrBasicBlockSrc *incoming_block = phi_instruction->incoming_blocks[i];
	1012	IrInstSrc *incoming_value = phi_instruction->incoming_values[i];
788	1013	if (i != 0)
789	1014	fprintf(irp->f, " ");
790	1015	ir_print_other_block(irp, incoming_block);
791	1016	fprintf(irp->f, ":");
792		ir_print_other_instruction(irp, incoming_value);
	1017	ir_print_other_inst_src(irp, incoming_value);
793	1018	}
794	1019	}
795	1020
796		static void ir_print_container_init_list(IrPrint irp, IrInstructionContainerInitList instruction) {
	1021	static void ir_print_phi(IrPrintGen irp, IrInstGenPhi phi_instruction) {
	1022	assert(phi_instruction->incoming_count != 0);
	1023	assert(phi_instruction->incoming_count != SIZE_MAX);
	1024	for (size_t i = 0; i < phi_instruction->incoming_count; i += 1) {
	1025	IrBasicBlockGen *incoming_block = phi_instruction->incoming_blocks[i];
	1026	IrInstGen *incoming_value = phi_instruction->incoming_values[i];
	1027	if (i != 0)
	1028	fprintf(irp->f, " ");
	1029	ir_print_other_block_gen(irp, incoming_block);
	1030	fprintf(irp->f, ":");
	1031	ir_print_other_inst_gen(irp, incoming_value);
	1032	}
	1033	}
	1034
	1035	static void ir_print_container_init_list(IrPrintSrc irp, IrInstSrcContainerInitList instruction) {
797	1036	fprintf(irp->f, "{");
798	1037	if (instruction->item_count > 50) {
799	1038	fprintf(irp->f, "...(%" ZIG_PRI_usize " items)...", instruction->item_count);
800	1039	} else {
801	1040	for (size_t i = 0; i < instruction->item_count; i += 1) {
802		IrInstruction *result_loc = instruction->elem_result_loc_list[i];
	1041	IrInstSrc *result_loc = instruction->elem_result_loc_list[i];
803	1042	if (i != 0)
804	1043	fprintf(irp->f, ", ");
805		ir_print_other_instruction(irp, result_loc);
	1044	ir_print_other_inst_src(irp, result_loc);
806	1045	}
807	1046	}
808	1047	fprintf(irp->f, "}result=");
809		ir_print_other_instruction(irp, instruction->result_loc);
	1048	ir_print_other_inst_src(irp, instruction->result_loc);
810	1049	}
811	1050
812		static void ir_print_container_init_fields(IrPrint irp, IrInstructionContainerInitFields instruction) {
	1051	static void ir_print_container_init_fields(IrPrintSrc irp, IrInstSrcContainerInitFields instruction) {
813	1052	fprintf(irp->f, "{");
814	1053	for (size_t i = 0; i < instruction->field_count; i += 1) {
815		IrInstructionContainerInitFieldsField *field = &instruction->fields[i];
	1054	IrInstSrcContainerInitFieldsField *field = &instruction->fields[i];
816	1055	const char *comma = (i == 0) ? "" : ", ";
817	1056	fprintf(irp->f, "%s.%s = ", comma, buf_ptr(field->name));
818		ir_print_other_instruction(irp, field->result_loc);
	1057	ir_print_other_inst_src(irp, field->result_loc);
819	1058	}
820	1059	fprintf(irp->f, "}result=");
821		ir_print_other_instruction(irp, instruction->result_loc);
	1060	ir_print_other_inst_src(irp, instruction->result_loc);
	1061	}
	1062
	1063	static void ir_print_unreachable(IrPrintSrc irp, IrInstSrcUnreachable instruction) {
	1064	fprintf(irp->f, "unreachable");
822	1065	}
823	1066
824		static void ir_print_unreachable(IrPrint irp, IrInstructionUnreachable instruction) {
	1067	static void ir_print_unreachable(IrPrintGen irp, IrInstGenUnreachable instruction) {
825	1068	fprintf(irp->f, "unreachable");
826	1069	}
827	1070
828		static void ir_print_elem_ptr(IrPrint irp, IrInstructionElemPtr instruction) {
	1071	static void ir_print_elem_ptr(IrPrintSrc irp, IrInstSrcElemPtr instruction) {
829	1072	fprintf(irp->f, "&");
830		ir_print_other_instruction(irp, instruction->array_ptr);
	1073	ir_print_other_inst_src(irp, instruction->array_ptr);
831	1074	fprintf(irp->f, "[");
832		ir_print_other_instruction(irp, instruction->elem_index);
	1075	ir_print_other_inst_src(irp, instruction->elem_index);
833	1076	fprintf(irp->f, "]");
834	1077	if (!instruction->safety_check_on) {
835	1078	fprintf(irp->f, " // no safety");
836	1079	}
837	1080	}
838	1081
839		static void ir_print_var_ptr(IrPrint irp, IrInstructionVarPtr instruction) {
	1082	static void ir_print_elem_ptr(IrPrintGen irp, IrInstGenElemPtr instruction) {
	1083	fprintf(irp->f, "&");
	1084	ir_print_other_inst_gen(irp, instruction->array_ptr);
	1085	fprintf(irp->f, "[");
	1086	ir_print_other_inst_gen(irp, instruction->elem_index);
	1087	fprintf(irp->f, "]");
	1088	if (!instruction->safety_check_on) {
	1089	fprintf(irp->f, " // no safety");
	1090	}
	1091	}
	1092
	1093	static void ir_print_var_ptr(IrPrintSrc irp, IrInstSrcVarPtr instruction) {
	1094	fprintf(irp->f, "&%s", instruction->var->name);
	1095	}
	1096
	1097	static void ir_print_var_ptr(IrPrintGen irp, IrInstGenVarPtr instruction) {
840	1098	fprintf(irp->f, "&%s", instruction->var->name);
841	1099	}
842	1100
843		static void ir_print_return_ptr(IrPrint irp, IrInstructionReturnPtr instruction) {
	1101	static void ir_print_return_ptr(IrPrintGen irp, IrInstGenReturnPtr instruction) {
844	1102	fprintf(irp->f, "@ReturnPtr");
845	1103	}
846	1104
847		static void ir_print_load_ptr(IrPrint irp, IrInstructionLoadPtr instruction) {
848		ir_print_other_instruction(irp, instruction->ptr);
	1105	static void ir_print_load_ptr(IrPrintSrc irp, IrInstSrcLoadPtr instruction) {
	1106	ir_print_other_inst_src(irp, instruction->ptr);
849	1107	fprintf(irp->f, ".*");
850	1108	}
851	1109
852		static void ir_print_load_ptr_gen(IrPrint irp, IrInstructionLoadPtrGen instruction) {
	1110	static void ir_print_load_ptr_gen(IrPrintGen irp, IrInstGenLoadPtr instruction) {
853	1111	fprintf(irp->f, "loadptr(");
854		ir_print_other_instruction(irp, instruction->ptr);
	1112	ir_print_other_inst_gen(irp, instruction->ptr);
855	1113	fprintf(irp->f, ")result=");
856		ir_print_other_instruction(irp, instruction->result_loc);
	1114	ir_print_other_inst_gen(irp, instruction->result_loc);
	1115	}
	1116
	1117	static void ir_print_store_ptr(IrPrintSrc irp, IrInstSrcStorePtr instruction) {
	1118	fprintf(irp->f, "*");
	1119	ir_print_var_src(irp, instruction->ptr);
	1120	fprintf(irp->f, " = ");
	1121	ir_print_other_inst_src(irp, instruction->value);
857	1122	}
858	1123
859		static void ir_print_store_ptr(IrPrint irp, IrInstructionStorePtr instruction) {
	1124	static void ir_print_store_ptr(IrPrintGen irp, IrInstGenStorePtr instruction) {
860	1125	fprintf(irp->f, "*");
861		ir_print_var_instruction(irp, instruction->ptr);
	1126	ir_print_var_gen(irp, instruction->ptr);
862	1127	fprintf(irp->f, " = ");
863		ir_print_other_instruction(irp, instruction->value);
	1128	ir_print_other_inst_gen(irp, instruction->value);
864	1129	}
865	1130
866		static void ir_print_vector_store_elem(IrPrint irp, IrInstructionVectorStoreElem instruction) {
	1131	static void ir_print_vector_store_elem(IrPrintGen irp, IrInstGenVectorStoreElem instruction) {
867	1132	fprintf(irp->f, "vector_ptr=");
868		ir_print_var_instruction(irp, instruction->vector_ptr);
	1133	ir_print_var_gen(irp, instruction->vector_ptr);
869	1134	fprintf(irp->f, ",index=");
870		ir_print_var_instruction(irp, instruction->index);
	1135	ir_print_var_gen(irp, instruction->index);
871	1136	fprintf(irp->f, ",value=");
872		ir_print_other_instruction(irp, instruction->value);
	1137	ir_print_other_inst_gen(irp, instruction->value);
873	1138	}
874	1139
875		static void ir_print_typeof(IrPrint irp, IrInstructionTypeOf instruction) {
	1140	static void ir_print_typeof(IrPrintSrc irp, IrInstSrcTypeOf instruction) {
876	1141	fprintf(irp->f, "@TypeOf(");
877		ir_print_other_instruction(irp, instruction->value);
	1142	ir_print_other_inst_src(irp, instruction->value);
878	1143	fprintf(irp->f, ")");
879	1144	}
880	1145
881		static void ir_print_field_ptr(IrPrint irp, IrInstructionFieldPtr instruction) {
	1146	static void ir_print_binary_not(IrPrintGen irp, IrInstGenBinaryNot instruction) {
	1147	fprintf(irp->f, "~");
	1148	ir_print_other_inst_gen(irp, instruction->operand);
	1149	}
	1150
	1151	static void ir_print_negation(IrPrintGen irp, IrInstGenNegation instruction) {
	1152	fprintf(irp->f, "-");
	1153	ir_print_other_inst_gen(irp, instruction->operand);
	1154	}
	1155
	1156	static void ir_print_negation_wrapping(IrPrintGen irp, IrInstGenNegationWrapping instruction) {
	1157	fprintf(irp->f, "-%%");
	1158	ir_print_other_inst_gen(irp, instruction->operand);
	1159	}
	1160
	1161
	1162	static void ir_print_field_ptr(IrPrintSrc irp, IrInstSrcFieldPtr instruction) {
882	1163	if (instruction->field_name_buffer) {
883	1164	fprintf(irp->f, "fieldptr ");
884		ir_print_other_instruction(irp, instruction->container_ptr);
	1165	ir_print_other_inst_src(irp, instruction->container_ptr);
885	1166	fprintf(irp->f, ".%s", buf_ptr(instruction->field_name_buffer));
886	1167	} else {
887	1168	assert(instruction->field_name_expr);
888	1169	fprintf(irp->f, "@field(");
889		ir_print_other_instruction(irp, instruction->container_ptr);
	1170	ir_print_other_inst_src(irp, instruction->container_ptr);
890	1171	fprintf(irp->f, ", ");
891		ir_print_other_instruction(irp, instruction->field_name_expr);
	1172	ir_print_other_inst_src(irp, instruction->field_name_expr);
892	1173	fprintf(irp->f, ")");
893	1174	}
894	1175	}
895	1176
896		static void ir_print_struct_field_ptr(IrPrint irp, IrInstructionStructFieldPtr instruction) {
	1177	static void ir_print_struct_field_ptr(IrPrintGen irp, IrInstGenStructFieldPtr instruction) {
897	1178	fprintf(irp->f, "@StructFieldPtr(&");
898		ir_print_other_instruction(irp, instruction->struct_ptr);
	1179	ir_print_other_inst_gen(irp, instruction->struct_ptr);
899	1180	fprintf(irp->f, ".%s", buf_ptr(instruction->field->name));
900	1181	fprintf(irp->f, ")");
901	1182	}
902	1183
903		static void ir_print_union_field_ptr(IrPrint irp, IrInstructionUnionFieldPtr instruction) {
	1184	static void ir_print_union_field_ptr(IrPrintGen irp, IrInstGenUnionFieldPtr instruction) {
904	1185	fprintf(irp->f, "@UnionFieldPtr(&");
905		ir_print_other_instruction(irp, instruction->union_ptr);
	1186	ir_print_other_inst_gen(irp, instruction->union_ptr);
906	1187	fprintf(irp->f, ".%s", buf_ptr(instruction->field->enum_field->name));
907	1188	fprintf(irp->f, ")");
908	1189	}
909	1190
910		static void ir_print_set_cold(IrPrint irp, IrInstructionSetCold instruction) {
	1191	static void ir_print_set_cold(IrPrintSrc irp, IrInstSrcSetCold instruction) {
911	1192	fprintf(irp->f, "@setCold(");
912		ir_print_other_instruction(irp, instruction->is_cold);
	1193	ir_print_other_inst_src(irp, instruction->is_cold);
913	1194	fprintf(irp->f, ")");
914	1195	}
915	1196
916		static void ir_print_set_runtime_safety(IrPrint irp, IrInstructionSetRuntimeSafety instruction) {
	1197	static void ir_print_set_runtime_safety(IrPrintSrc irp, IrInstSrcSetRuntimeSafety instruction) {
917	1198	fprintf(irp->f, "@setRuntimeSafety(");
918		ir_print_other_instruction(irp, instruction->safety_on);
	1199	ir_print_other_inst_src(irp, instruction->safety_on);
919	1200	fprintf(irp->f, ")");
920	1201	}
921	1202
922		static void ir_print_set_float_mode(IrPrint irp, IrInstructionSetFloatMode instruction) {
	1203	static void ir_print_set_float_mode(IrPrintSrc irp, IrInstSrcSetFloatMode instruction) {
923	1204	fprintf(irp->f, "@setFloatMode(");
924		ir_print_other_instruction(irp, instruction->scope_value);
	1205	ir_print_other_inst_src(irp, instruction->scope_value);
925	1206	fprintf(irp->f, ", ");
926		ir_print_other_instruction(irp, instruction->mode_value);
	1207	ir_print_other_inst_src(irp, instruction->mode_value);
927	1208	fprintf(irp->f, ")");
928	1209	}
929	1210
930		static void ir_print_array_type(IrPrint irp, IrInstructionArrayType instruction) {
	1211	static void ir_print_array_type(IrPrintSrc irp, IrInstSrcArrayType instruction) {
931	1212	fprintf(irp->f, "[");
932		ir_print_other_instruction(irp, instruction->size);
	1213	ir_print_other_inst_src(irp, instruction->size);
933	1214	if (instruction->sentinel != nullptr) {
934	1215	fprintf(irp->f, ":");
935		ir_print_other_instruction(irp, instruction->sentinel);
	1216	ir_print_other_inst_src(irp, instruction->sentinel);
936	1217	}
937	1218	fprintf(irp->f, "]");
938		ir_print_other_instruction(irp, instruction->child_type);
	1219	ir_print_other_inst_src(irp, instruction->child_type);
939	1220	}
940	1221
941		static void ir_print_slice_type(IrPrint irp, IrInstructionSliceType instruction) {
	1222	static void ir_print_slice_type(IrPrintSrc irp, IrInstSrcSliceType instruction) {
942	1223	const char *const_kw = instruction->is_const ? "const " : "";
943	1224	fprintf(irp->f, "[]%s", const_kw);
944		ir_print_other_instruction(irp, instruction->child_type);
	1225	ir_print_other_inst_src(irp, instruction->child_type);
945	1226	}
946	1227
947		static void ir_print_any_frame_type(IrPrint irp, IrInstructionAnyFrameType instruction) {
	1228	static void ir_print_any_frame_type(IrPrintSrc irp, IrInstSrcAnyFrameType instruction) {
948	1229	if (instruction->payload_type == nullptr) {
949	1230	fprintf(irp->f, "anyframe");
950	1231	} else {
951	1232	fprintf(irp->f, "anyframe->");
952		ir_print_other_instruction(irp, instruction->payload_type);
	1233	ir_print_other_inst_src(irp, instruction->payload_type);
953	1234	}
954	1235	}
955	1236
956		static void ir_print_asm_src(IrPrint irp, IrInstructionAsmSrc instruction) {
957		assert(instruction->base.source_node->type == NodeTypeAsmExpr);
958		AstNodeAsmExpr *asm_expr = &instruction->base.source_node->data.asm_expr;
	1237	static void ir_print_asm_src(IrPrintSrc irp, IrInstSrcAsm instruction) {
	1238	assert(instruction->base.base.source_node->type == NodeTypeAsmExpr);
	1239	AstNodeAsmExpr *asm_expr = &instruction->base.base.source_node->data.asm_expr;
959	1240	const char *volatile_kw = instruction->has_side_effects ? " volatile" : "";
960	1241	fprintf(irp->f, "asm%s (", volatile_kw);
961		ir_print_other_instruction(irp, instruction->asm_template);
	1242	ir_print_other_inst_src(irp, instruction->asm_template);
962	1243
963	1244	for (size_t i = 0; i < asm_expr->output_list.length; i += 1) {
964	1245	AsmOutput *asm_output = asm_expr->output_list.at(i);
...	...	@@ -969,7 +1250,7 @@ static void ir_print_asm_src(IrPrint irp, IrInstructionAsmSrc instruction) {
969	1250	buf_ptr(asm_output->constraint));
970	1251	if (asm_output->return_type) {
971	1252	fprintf(irp->f, "-> ");
972		ir_print_other_instruction(irp, instruction->output_types[i]);
	1253	ir_print_other_inst_src(irp, instruction->output_types[i]);
973	1254	} else {
974	1255	fprintf(irp->f, "%s", buf_ptr(asm_output->variable_name));
975	1256	}
...	...	@@ -984,7 +1265,7 @@ static void ir_print_asm_src(IrPrint irp, IrInstructionAsmSrc instruction) {
984	1265	fprintf(irp->f, "[%s] \"%s\" (",
985	1266	buf_ptr(asm_input->asm_symbolic_name),
986	1267	buf_ptr(asm_input->constraint));
987		ir_print_other_instruction(irp, instruction->input_list[i]);
	1268	ir_print_other_inst_src(irp, instruction->input_list[i]);
988	1269	fprintf(irp->f, ")");
989	1270	}
990	1271	fprintf(irp->f, " : ");
...	...	@@ -996,9 +1277,9 @@ static void ir_print_asm_src(IrPrint irp, IrInstructionAsmSrc instruction) {
996	1277	fprintf(irp->f, ")");
997	1278	}
998	1279
999		static void ir_print_asm_gen(IrPrint irp, IrInstructionAsmGen instruction) {
1000		assert(instruction->base.source_node->type == NodeTypeAsmExpr);
1001		AstNodeAsmExpr *asm_expr = &instruction->base.source_node->data.asm_expr;
	1280	static void ir_print_asm_gen(IrPrintGen irp, IrInstGenAsm instruction) {
	1281	assert(instruction->base.base.source_node->type == NodeTypeAsmExpr);
	1282	AstNodeAsmExpr *asm_expr = &instruction->base.base.source_node->data.asm_expr;
1002	1283	const char *volatile_kw = instruction->has_side_effects ? " volatile" : "";
1003	1284	fprintf(irp->f, "asm%s (\"%s\") : ", volatile_kw, buf_ptr(instruction->asm_template));
1004	1285
...	...	@@ -1011,7 +1292,7 @@ static void ir_print_asm_gen(IrPrint irp, IrInstructionAsmGen instruction) {
1011	1292	buf_ptr(asm_output->constraint));
1012	1293	if (asm_output->return_type) {
1013	1294	fprintf(irp->f, "-> ");
1014		ir_print_other_instruction(irp, instruction->output_types[i]);
	1295	ir_print_other_inst_gen(irp, instruction->output_types[i]);
1015	1296	} else {
1016	1297	fprintf(irp->f, "%s", buf_ptr(asm_output->variable_name));
1017	1298	}
...	...	@@ -1026,7 +1307,7 @@ static void ir_print_asm_gen(IrPrint irp, IrInstructionAsmGen instruction) {
1026	1307	fprintf(irp->f, "[%s] \"%s\" (",
1027	1308	buf_ptr(asm_input->asm_symbolic_name),
1028	1309	buf_ptr(asm_input->constraint));
1029		ir_print_other_instruction(irp, instruction->input_list[i]);
	1310	ir_print_other_inst_gen(irp, instruction->input_list[i]);
1030	1311	fprintf(irp->f, ")");
1031	1312	}
1032	1313	fprintf(irp->f, " : ");
...	...	@@ -1038,96 +1319,120 @@ static void ir_print_asm_gen(IrPrint irp, IrInstructionAsmGen instruction) {
1038	1319	fprintf(irp->f, ")");
1039	1320	}
1040	1321
1041		static void ir_print_size_of(IrPrint irp, IrInstructionSizeOf instruction) {
	1322	static void ir_print_size_of(IrPrintSrc irp, IrInstSrcSizeOf instruction) {
1042	1323	if (instruction->bit_size)
1043	1324	fprintf(irp->f, "@bitSizeOf(");
1044	1325	else
1045	1326	fprintf(irp->f, "@sizeOf(");
1046		ir_print_other_instruction(irp, instruction->type_value);
	1327	ir_print_other_inst_src(irp, instruction->type_value);
1047	1328	fprintf(irp->f, ")");
1048	1329	}
1049	1330
1050		static void ir_print_test_non_null(IrPrint irp, IrInstructionTestNonNull instruction) {
1051		ir_print_other_instruction(irp, instruction->value);
	1331	static void ir_print_test_non_null(IrPrintSrc irp, IrInstSrcTestNonNull instruction) {
	1332	ir_print_other_inst_src(irp, instruction->value);
	1333	fprintf(irp->f, " != null");
	1334	}
	1335
	1336	static void ir_print_test_non_null(IrPrintGen irp, IrInstGenTestNonNull instruction) {
	1337	ir_print_other_inst_gen(irp, instruction->value);
1052	1338	fprintf(irp->f, " != null");
1053	1339	}
1054	1340
1055		static void ir_print_optional_unwrap_ptr(IrPrint irp, IrInstructionOptionalUnwrapPtr instruction) {
	1341	static void ir_print_optional_unwrap_ptr(IrPrintSrc irp, IrInstSrcOptionalUnwrapPtr instruction) {
1056	1342	fprintf(irp->f, "&");
1057		ir_print_other_instruction(irp, instruction->base_ptr);
	1343	ir_print_other_inst_src(irp, instruction->base_ptr);
1058	1344	fprintf(irp->f, ".*.?");
1059	1345	if (!instruction->safety_check_on) {
1060	1346	fprintf(irp->f, " // no safety");
1061	1347	}
1062	1348	}
1063	1349
1064		static void ir_print_clz(IrPrint irp, IrInstructionClz instruction) {
1065		fprintf(irp->f, "@clz(");
1066		if (instruction->type != nullptr) {
1067		ir_print_other_instruction(irp, instruction->type);
1068		} else {
1069		fprintf(irp->f, "null");
	1350	static void ir_print_optional_unwrap_ptr(IrPrintGen irp, IrInstGenOptionalUnwrapPtr instruction) {
	1351	fprintf(irp->f, "&");
	1352	ir_print_other_inst_gen(irp, instruction->base_ptr);
	1353	fprintf(irp->f, ".*.?");
	1354	if (!instruction->safety_check_on) {
	1355	fprintf(irp->f, " // no safety");
1070	1356	}
	1357	}
	1358
	1359	static void ir_print_clz(IrPrintSrc irp, IrInstSrcClz instruction) {
	1360	fprintf(irp->f, "@clz(");
	1361	ir_print_other_inst_src(irp, instruction->type);
1071	1362	fprintf(irp->f, ",");
1072		ir_print_other_instruction(irp, instruction->op);
	1363	ir_print_other_inst_src(irp, instruction->op);
1073	1364	fprintf(irp->f, ")");
1074	1365	}
1075	1366
1076		static void ir_print_ctz(IrPrint irp, IrInstructionCtz instruction) {
	1367	static void ir_print_clz(IrPrintGen irp, IrInstGenClz instruction) {
	1368	fprintf(irp->f, "@clz(");
	1369	ir_print_other_inst_gen(irp, instruction->op);
	1370	fprintf(irp->f, ")");
	1371	}
	1372
	1373	static void ir_print_ctz(IrPrintSrc irp, IrInstSrcCtz instruction) {
1077	1374	fprintf(irp->f, "@ctz(");
1078		if (instruction->type != nullptr) {
1079		ir_print_other_instruction(irp, instruction->type);
1080		} else {
1081		fprintf(irp->f, "null");
1082		}
	1375	ir_print_other_inst_src(irp, instruction->type);
1083	1376	fprintf(irp->f, ",");
1084		ir_print_other_instruction(irp, instruction->op);
	1377	ir_print_other_inst_src(irp, instruction->op);
1085	1378	fprintf(irp->f, ")");
1086	1379	}
1087	1380
1088		static void ir_print_pop_count(IrPrint irp, IrInstructionPopCount instruction) {
	1381	static void ir_print_ctz(IrPrintGen irp, IrInstGenCtz instruction) {
	1382	fprintf(irp->f, "@ctz(");
	1383	ir_print_other_inst_gen(irp, instruction->op);
	1384	fprintf(irp->f, ")");
	1385	}
	1386
	1387	static void ir_print_pop_count(IrPrintSrc irp, IrInstSrcPopCount instruction) {
1089	1388	fprintf(irp->f, "@popCount(");
1090		if (instruction->type != nullptr) {
1091		ir_print_other_instruction(irp, instruction->type);
1092		} else {
1093		fprintf(irp->f, "null");
1094		}
	1389	ir_print_other_inst_src(irp, instruction->type);
1095	1390	fprintf(irp->f, ",");
1096		ir_print_other_instruction(irp, instruction->op);
	1391	ir_print_other_inst_src(irp, instruction->op);
1097	1392	fprintf(irp->f, ")");
1098	1393	}
1099	1394
1100		static void ir_print_bswap(IrPrint irp, IrInstructionBswap instruction) {
	1395	static void ir_print_pop_count(IrPrintGen irp, IrInstGenPopCount instruction) {
	1396	fprintf(irp->f, "@popCount(");
	1397	ir_print_other_inst_gen(irp, instruction->op);
	1398	fprintf(irp->f, ")");
	1399	}
	1400
	1401	static void ir_print_bswap(IrPrintSrc irp, IrInstSrcBswap instruction) {
1101	1402	fprintf(irp->f, "@byteSwap(");
1102		if (instruction->type != nullptr) {
1103		ir_print_other_instruction(irp, instruction->type);
1104		} else {
1105		fprintf(irp->f, "null");
1106		}
	1403	ir_print_other_inst_src(irp, instruction->type);
1107	1404	fprintf(irp->f, ",");
1108		ir_print_other_instruction(irp, instruction->op);
	1405	ir_print_other_inst_src(irp, instruction->op);
1109	1406	fprintf(irp->f, ")");
1110	1407	}
1111	1408
1112		static void ir_print_bit_reverse(IrPrint irp, IrInstructionBitReverse instruction) {
	1409	static void ir_print_bswap(IrPrintGen irp, IrInstGenBswap instruction) {
	1410	fprintf(irp->f, "@byteSwap(");
	1411	ir_print_other_inst_gen(irp, instruction->op);
	1412	fprintf(irp->f, ")");
	1413	}
	1414
	1415	static void ir_print_bit_reverse(IrPrintSrc irp, IrInstSrcBitReverse instruction) {
1113	1416	fprintf(irp->f, "@bitReverse(");
1114		if (instruction->type != nullptr) {
1115		ir_print_other_instruction(irp, instruction->type);
1116		} else {
1117		fprintf(irp->f, "null");
1118		}
	1417	ir_print_other_inst_src(irp, instruction->type);
1119	1418	fprintf(irp->f, ",");
1120		ir_print_other_instruction(irp, instruction->op);
	1419	ir_print_other_inst_src(irp, instruction->op);
1121	1420	fprintf(irp->f, ")");
1122	1421	}
1123	1422
1124		static void ir_print_switch_br(IrPrint irp, IrInstructionSwitchBr instruction) {
	1423	static void ir_print_bit_reverse(IrPrintGen irp, IrInstGenBitReverse instruction) {
	1424	fprintf(irp->f, "@bitReverse(");
	1425	ir_print_other_inst_gen(irp, instruction->op);
	1426	fprintf(irp->f, ")");
	1427	}
	1428
	1429	static void ir_print_switch_br(IrPrintSrc irp, IrInstSrcSwitchBr instruction) {
1125	1430	fprintf(irp->f, "switch (");
1126		ir_print_other_instruction(irp, instruction->target_value);
	1431	ir_print_other_inst_src(irp, instruction->target_value);
1127	1432	fprintf(irp->f, ") ");
1128	1433	for (size_t i = 0; i < instruction->case_count; i += 1) {
1129		IrInstructionSwitchBrCase *this_case = &instruction->cases[i];
1130		ir_print_other_instruction(irp, this_case->value);
	1434	IrInstSrcSwitchBrCase *this_case = &instruction->cases[i];
	1435	ir_print_other_inst_src(irp, this_case->value);
1131	1436	fprintf(irp->f, " => ");
1132	1437	ir_print_other_block(irp, this_case->block);
1133	1438	fprintf(irp->f, ", ");
...	...	@@ -1136,359 +1441,453 @@ static void ir_print_switch_br(IrPrint irp, IrInstructionSwitchBr instruction)
1136	1441	ir_print_other_block(irp, instruction->else_block);
1137	1442	if (instruction->is_comptime != nullptr) {
1138	1443	fprintf(irp->f, " // comptime = ");
1139		ir_print_other_instruction(irp, instruction->is_comptime);
	1444	ir_print_other_inst_src(irp, instruction->is_comptime);
	1445	}
	1446	}
	1447
	1448	static void ir_print_switch_br(IrPrintGen irp, IrInstGenSwitchBr instruction) {
	1449	fprintf(irp->f, "switch (");
	1450	ir_print_other_inst_gen(irp, instruction->target_value);
	1451	fprintf(irp->f, ") ");
	1452	for (size_t i = 0; i < instruction->case_count; i += 1) {
	1453	IrInstGenSwitchBrCase *this_case = &instruction->cases[i];
	1454	ir_print_other_inst_gen(irp, this_case->value);
	1455	fprintf(irp->f, " => ");
	1456	ir_print_other_block_gen(irp, this_case->block);
	1457	fprintf(irp->f, ", ");
1140	1458	}
	1459	fprintf(irp->f, "else => ");
	1460	ir_print_other_block_gen(irp, instruction->else_block);
1141	1461	}
1142	1462
1143		static void ir_print_switch_var(IrPrint irp, IrInstructionSwitchVar instruction) {
	1463	static void ir_print_switch_var(IrPrintSrc irp, IrInstSrcSwitchVar instruction) {
1144	1464	fprintf(irp->f, "switchvar ");
1145		ir_print_other_instruction(irp, instruction->target_value_ptr);
	1465	ir_print_other_inst_src(irp, instruction->target_value_ptr);
1146	1466	for (size_t i = 0; i < instruction->prongs_len; i += 1) {
1147	1467	fprintf(irp->f, ", ");
1148		ir_print_other_instruction(irp, instruction->prongs_ptr[i]);
	1468	ir_print_other_inst_src(irp, instruction->prongs_ptr[i]);
1149	1469	}
1150	1470	}
1151	1471
1152		static void ir_print_switch_else_var(IrPrint irp, IrInstructionSwitchElseVar instruction) {
	1472	static void ir_print_switch_else_var(IrPrintSrc irp, IrInstSrcSwitchElseVar instruction) {
1153	1473	fprintf(irp->f, "switchelsevar ");
1154		ir_print_other_instruction(irp, &instruction->switch_br->base);
	1474	ir_print_other_inst_src(irp, &instruction->switch_br->base);
1155	1475	}
1156	1476
1157		static void ir_print_switch_target(IrPrint irp, IrInstructionSwitchTarget instruction) {
	1477	static void ir_print_switch_target(IrPrintSrc irp, IrInstSrcSwitchTarget instruction) {
1158	1478	fprintf(irp->f, "switchtarget ");
1159		ir_print_other_instruction(irp, instruction->target_value_ptr);
	1479	ir_print_other_inst_src(irp, instruction->target_value_ptr);
1160	1480	}
1161	1481
1162		static void ir_print_union_tag(IrPrint irp, IrInstructionUnionTag instruction) {
	1482	static void ir_print_union_tag(IrPrintGen irp, IrInstGenUnionTag instruction) {
1163	1483	fprintf(irp->f, "uniontag ");
1164		ir_print_other_instruction(irp, instruction->value);
	1484	ir_print_other_inst_gen(irp, instruction->value);
1165	1485	}
1166	1486
1167		static void ir_print_import(IrPrint irp, IrInstructionImport instruction) {
	1487	static void ir_print_import(IrPrintSrc irp, IrInstSrcImport instruction) {
1168	1488	fprintf(irp->f, "@import(");
1169		ir_print_other_instruction(irp, instruction->name);
	1489	ir_print_other_inst_src(irp, instruction->name);
1170	1490	fprintf(irp->f, ")");
1171	1491	}
1172	1492
1173		static void ir_print_ref(IrPrint irp, IrInstructionRef instruction) {
	1493	static void ir_print_ref(IrPrintSrc irp, IrInstSrcRef instruction) {
1174	1494	const char *const_str = instruction->is_const ? "const " : "";
1175	1495	const char *volatile_str = instruction->is_volatile ? "volatile " : "";
1176	1496	fprintf(irp->f, "%s%sref ", const_str, volatile_str);
1177		ir_print_other_instruction(irp, instruction->value);
	1497	ir_print_other_inst_src(irp, instruction->value);
1178	1498	}
1179	1499
1180		static void ir_print_ref_gen(IrPrint irp, IrInstructionRefGen instruction) {
	1500	static void ir_print_ref_gen(IrPrintGen irp, IrInstGenRef instruction) {
1181	1501	fprintf(irp->f, "@ref(");
1182		ir_print_other_instruction(irp, instruction->operand);
	1502	ir_print_other_inst_gen(irp, instruction->operand);
1183	1503	fprintf(irp->f, ")result=");
1184		ir_print_other_instruction(irp, instruction->result_loc);
	1504	ir_print_other_inst_gen(irp, instruction->result_loc);
1185	1505	}
1186	1506
1187		static void ir_print_compile_err(IrPrint irp, IrInstructionCompileErr instruction) {
	1507	static void ir_print_compile_err(IrPrintSrc irp, IrInstSrcCompileErr instruction) {
1188	1508	fprintf(irp->f, "@compileError(");
1189		ir_print_other_instruction(irp, instruction->msg);
	1509	ir_print_other_inst_src(irp, instruction->msg);
1190	1510	fprintf(irp->f, ")");
1191	1511	}
1192	1512
1193		static void ir_print_compile_log(IrPrint irp, IrInstructionCompileLog instruction) {
	1513	static void ir_print_compile_log(IrPrintSrc irp, IrInstSrcCompileLog instruction) {
1194	1514	fprintf(irp->f, "@compileLog(");
1195	1515	for (size_t i = 0; i < instruction->msg_count; i += 1) {
1196	1516	if (i != 0)
1197	1517	fprintf(irp->f, ",");
1198		IrInstruction *msg = instruction->msg_list[i];
1199		ir_print_other_instruction(irp, msg);
	1518	IrInstSrc *msg = instruction->msg_list[i];
	1519	ir_print_other_inst_src(irp, msg);
1200	1520	}
1201	1521	fprintf(irp->f, ")");
1202	1522	}
1203	1523
1204		static void ir_print_err_name(IrPrint irp, IrInstructionErrName instruction) {
	1524	static void ir_print_err_name(IrPrintSrc irp, IrInstSrcErrName instruction) {
1205	1525	fprintf(irp->f, "@errorName(");
1206		ir_print_other_instruction(irp, instruction->value);
	1526	ir_print_other_inst_src(irp, instruction->value);
1207	1527	fprintf(irp->f, ")");
1208	1528	}
1209	1529
1210		static void ir_print_c_import(IrPrint irp, IrInstructionCImport instruction) {
	1530	static void ir_print_err_name(IrPrintGen irp, IrInstGenErrName instruction) {
	1531	fprintf(irp->f, "@errorName(");
	1532	ir_print_other_inst_gen(irp, instruction->value);
	1533	fprintf(irp->f, ")");
	1534	}
	1535
	1536	static void ir_print_c_import(IrPrintSrc irp, IrInstSrcCImport instruction) {
1211	1537	fprintf(irp->f, "@cImport(...)");
1212	1538	}
1213	1539
1214		static void ir_print_c_include(IrPrint irp, IrInstructionCInclude instruction) {
	1540	static void ir_print_c_include(IrPrintSrc irp, IrInstSrcCInclude instruction) {
1215	1541	fprintf(irp->f, "@cInclude(");
1216		ir_print_other_instruction(irp, instruction->name);
	1542	ir_print_other_inst_src(irp, instruction->name);
1217	1543	fprintf(irp->f, ")");
1218	1544	}
1219	1545
1220		static void ir_print_c_define(IrPrint irp, IrInstructionCDefine instruction) {
	1546	static void ir_print_c_define(IrPrintSrc irp, IrInstSrcCDefine instruction) {
1221	1547	fprintf(irp->f, "@cDefine(");
1222		ir_print_other_instruction(irp, instruction->name);
	1548	ir_print_other_inst_src(irp, instruction->name);
1223	1549	fprintf(irp->f, ", ");
1224		ir_print_other_instruction(irp, instruction->value);
	1550	ir_print_other_inst_src(irp, instruction->value);
1225	1551	fprintf(irp->f, ")");
1226	1552	}
1227	1553
1228		static void ir_print_c_undef(IrPrint irp, IrInstructionCUndef instruction) {
	1554	static void ir_print_c_undef(IrPrintSrc irp, IrInstSrcCUndef instruction) {
1229	1555	fprintf(irp->f, "@cUndef(");
1230		ir_print_other_instruction(irp, instruction->name);
	1556	ir_print_other_inst_src(irp, instruction->name);
1231	1557	fprintf(irp->f, ")");
1232	1558	}
1233	1559
1234		static void ir_print_embed_file(IrPrint irp, IrInstructionEmbedFile instruction) {
	1560	static void ir_print_embed_file(IrPrintSrc irp, IrInstSrcEmbedFile instruction) {
1235	1561	fprintf(irp->f, "@embedFile(");
1236		ir_print_other_instruction(irp, instruction->name);
	1562	ir_print_other_inst_src(irp, instruction->name);
1237	1563	fprintf(irp->f, ")");
1238	1564	}
1239	1565
1240		static void ir_print_cmpxchg_src(IrPrint irp, IrInstructionCmpxchgSrc instruction) {
	1566	static void ir_print_cmpxchg_src(IrPrintSrc irp, IrInstSrcCmpxchg instruction) {
1241	1567	fprintf(irp->f, "@cmpxchg(");
1242		ir_print_other_instruction(irp, instruction->ptr);
	1568	ir_print_other_inst_src(irp, instruction->ptr);
1243	1569	fprintf(irp->f, ", ");
1244		ir_print_other_instruction(irp, instruction->cmp_value);
	1570	ir_print_other_inst_src(irp, instruction->cmp_value);
1245	1571	fprintf(irp->f, ", ");
1246		ir_print_other_instruction(irp, instruction->new_value);
	1572	ir_print_other_inst_src(irp, instruction->new_value);
1247	1573	fprintf(irp->f, ", ");
1248		ir_print_other_instruction(irp, instruction->success_order_value);
	1574	ir_print_other_inst_src(irp, instruction->success_order_value);
1249	1575	fprintf(irp->f, ", ");
1250		ir_print_other_instruction(irp, instruction->failure_order_value);
	1576	ir_print_other_inst_src(irp, instruction->failure_order_value);
1251	1577	fprintf(irp->f, ")result=");
1252	1578	ir_print_result_loc(irp, instruction->result_loc);
1253	1579	}
1254	1580
1255		static void ir_print_cmpxchg_gen(IrPrint irp, IrInstructionCmpxchgGen instruction) {
	1581	static void ir_print_cmpxchg_gen(IrPrintGen irp, IrInstGenCmpxchg instruction) {
1256	1582	fprintf(irp->f, "@cmpxchg(");
1257		ir_print_other_instruction(irp, instruction->ptr);
	1583	ir_print_other_inst_gen(irp, instruction->ptr);
1258	1584	fprintf(irp->f, ", ");
1259		ir_print_other_instruction(irp, instruction->cmp_value);
	1585	ir_print_other_inst_gen(irp, instruction->cmp_value);
1260	1586	fprintf(irp->f, ", ");
1261		ir_print_other_instruction(irp, instruction->new_value);
	1587	ir_print_other_inst_gen(irp, instruction->new_value);
1262	1588	fprintf(irp->f, ", TODO print atomic orders)result=");
1263		ir_print_other_instruction(irp, instruction->result_loc);
	1589	ir_print_other_inst_gen(irp, instruction->result_loc);
1264	1590	}
1265	1591
1266		static void ir_print_fence(IrPrint irp, IrInstructionFence instruction) {
	1592	static void ir_print_fence(IrPrintSrc irp, IrInstSrcFence instruction) {
1267	1593	fprintf(irp->f, "@fence(");
1268		ir_print_other_instruction(irp, instruction->order_value);
	1594	ir_print_other_inst_src(irp, instruction->order);
1269	1595	fprintf(irp->f, ")");
1270	1596	}
1271	1597
1272		static void ir_print_truncate(IrPrint irp, IrInstructionTruncate instruction) {
	1598	static const char *atomic_order_str(AtomicOrder order) {
	1599	switch (order) {
	1600	case AtomicOrderUnordered: return "Unordered";
	1601	case AtomicOrderMonotonic: return "Monotonic";
	1602	case AtomicOrderAcquire: return "Acquire";
	1603	case AtomicOrderRelease: return "Release";
	1604	case AtomicOrderAcqRel: return "AcqRel";
	1605	case AtomicOrderSeqCst: return "SeqCst";
	1606	}
	1607	zig_unreachable();
	1608	}
	1609
	1610	static void ir_print_fence(IrPrintGen irp, IrInstGenFence instruction) {
	1611	fprintf(irp->f, "fence %s", atomic_order_str(instruction->order));
	1612	}
	1613
	1614	static void ir_print_truncate(IrPrintSrc irp, IrInstSrcTruncate instruction) {
1273	1615	fprintf(irp->f, "@truncate(");
1274		ir_print_other_instruction(irp, instruction->dest_type);
	1616	ir_print_other_inst_src(irp, instruction->dest_type);
1275	1617	fprintf(irp->f, ", ");
1276		ir_print_other_instruction(irp, instruction->target);
	1618	ir_print_other_inst_src(irp, instruction->target);
1277	1619	fprintf(irp->f, ")");
1278	1620	}
1279	1621
1280		static void ir_print_int_cast(IrPrint irp, IrInstructionIntCast instruction) {
	1622	static void ir_print_truncate(IrPrintGen irp, IrInstGenTruncate instruction) {
	1623	fprintf(irp->f, "@truncate(");
	1624	ir_print_other_inst_gen(irp, instruction->target);
	1625	fprintf(irp->f, ")");
	1626	}
	1627
	1628	static void ir_print_int_cast(IrPrintSrc irp, IrInstSrcIntCast instruction) {
1281	1629	fprintf(irp->f, "@intCast(");
1282		ir_print_other_instruction(irp, instruction->dest_type);
	1630	ir_print_other_inst_src(irp, instruction->dest_type);
1283	1631	fprintf(irp->f, ", ");
1284		ir_print_other_instruction(irp, instruction->target);
	1632	ir_print_other_inst_src(irp, instruction->target);
1285	1633	fprintf(irp->f, ")");
1286	1634	}
1287	1635
1288		static void ir_print_float_cast(IrPrint irp, IrInstructionFloatCast instruction) {
	1636	static void ir_print_float_cast(IrPrintSrc irp, IrInstSrcFloatCast instruction) {
1289	1637	fprintf(irp->f, "@floatCast(");
1290		ir_print_other_instruction(irp, instruction->dest_type);
	1638	ir_print_other_inst_src(irp, instruction->dest_type);
1291	1639	fprintf(irp->f, ", ");
1292		ir_print_other_instruction(irp, instruction->target);
	1640	ir_print_other_inst_src(irp, instruction->target);
1293	1641	fprintf(irp->f, ")");
1294	1642	}
1295	1643
1296		static void ir_print_err_set_cast(IrPrint irp, IrInstructionErrSetCast instruction) {
	1644	static void ir_print_err_set_cast(IrPrintSrc irp, IrInstSrcErrSetCast instruction) {
1297	1645	fprintf(irp->f, "@errSetCast(");
1298		ir_print_other_instruction(irp, instruction->dest_type);
	1646	ir_print_other_inst_src(irp, instruction->dest_type);
1299	1647	fprintf(irp->f, ", ");
1300		ir_print_other_instruction(irp, instruction->target);
	1648	ir_print_other_inst_src(irp, instruction->target);
1301	1649	fprintf(irp->f, ")");
1302	1650	}
1303	1651
1304		static void ir_print_from_bytes(IrPrint irp, IrInstructionFromBytes instruction) {
	1652	static void ir_print_from_bytes(IrPrintSrc irp, IrInstSrcFromBytes instruction) {
1305	1653	fprintf(irp->f, "@bytesToSlice(");
1306		ir_print_other_instruction(irp, instruction->dest_child_type);
	1654	ir_print_other_inst_src(irp, instruction->dest_child_type);
1307	1655	fprintf(irp->f, ", ");
1308		ir_print_other_instruction(irp, instruction->target);
	1656	ir_print_other_inst_src(irp, instruction->target);
1309	1657	fprintf(irp->f, ")");
1310	1658	}
1311	1659
1312		static void ir_print_to_bytes(IrPrint irp, IrInstructionToBytes instruction) {
	1660	static void ir_print_to_bytes(IrPrintSrc irp, IrInstSrcToBytes instruction) {
1313	1661	fprintf(irp->f, "@sliceToBytes(");
1314		ir_print_other_instruction(irp, instruction->target);
	1662	ir_print_other_inst_src(irp, instruction->target);
1315	1663	fprintf(irp->f, ")");
1316	1664	}
1317	1665
1318		static void ir_print_int_to_float(IrPrint irp, IrInstructionIntToFloat instruction) {
	1666	static void ir_print_int_to_float(IrPrintSrc irp, IrInstSrcIntToFloat instruction) {
1319	1667	fprintf(irp->f, "@intToFloat(");
1320		ir_print_other_instruction(irp, instruction->dest_type);
	1668	ir_print_other_inst_src(irp, instruction->dest_type);
1321	1669	fprintf(irp->f, ", ");
1322		ir_print_other_instruction(irp, instruction->target);
	1670	ir_print_other_inst_src(irp, instruction->target);
1323	1671	fprintf(irp->f, ")");
1324	1672	}
1325	1673
1326		static void ir_print_float_to_int(IrPrint irp, IrInstructionFloatToInt instruction) {
	1674	static void ir_print_float_to_int(IrPrintSrc irp, IrInstSrcFloatToInt instruction) {
1327	1675	fprintf(irp->f, "@floatToInt(");
1328		ir_print_other_instruction(irp, instruction->dest_type);
	1676	ir_print_other_inst_src(irp, instruction->dest_type);
1329	1677	fprintf(irp->f, ", ");
1330		ir_print_other_instruction(irp, instruction->target);
	1678	ir_print_other_inst_src(irp, instruction->target);
1331	1679	fprintf(irp->f, ")");
1332	1680	}
1333	1681
1334		static void ir_print_bool_to_int(IrPrint irp, IrInstructionBoolToInt instruction) {
	1682	static void ir_print_bool_to_int(IrPrintSrc irp, IrInstSrcBoolToInt instruction) {
1335	1683	fprintf(irp->f, "@boolToInt(");
1336		ir_print_other_instruction(irp, instruction->target);
	1684	ir_print_other_inst_src(irp, instruction->target);
1337	1685	fprintf(irp->f, ")");
1338	1686	}
1339	1687
1340		static void ir_print_int_type(IrPrint irp, IrInstructionIntType instruction) {
	1688	static void ir_print_int_type(IrPrintSrc irp, IrInstSrcIntType instruction) {
1341	1689	fprintf(irp->f, "@IntType(");
1342		ir_print_other_instruction(irp, instruction->is_signed);
	1690	ir_print_other_inst_src(irp, instruction->is_signed);
1343	1691	fprintf(irp->f, ", ");
1344		ir_print_other_instruction(irp, instruction->bit_count);
	1692	ir_print_other_inst_src(irp, instruction->bit_count);
1345	1693	fprintf(irp->f, ")");
1346	1694	}
1347	1695
1348		static void ir_print_vector_type(IrPrint irp, IrInstructionVectorType instruction) {
	1696	static void ir_print_vector_type(IrPrintSrc irp, IrInstSrcVectorType instruction) {
1349	1697	fprintf(irp->f, "@Vector(");
1350		ir_print_other_instruction(irp, instruction->len);
	1698	ir_print_other_inst_src(irp, instruction->len);
1351	1699	fprintf(irp->f, ", ");
1352		ir_print_other_instruction(irp, instruction->elem_type);
	1700	ir_print_other_inst_src(irp, instruction->elem_type);
1353	1701	fprintf(irp->f, ")");
1354	1702	}
1355	1703
1356		static void ir_print_shuffle_vector(IrPrint irp, IrInstructionShuffleVector instruction) {
	1704	static void ir_print_shuffle_vector(IrPrintSrc irp, IrInstSrcShuffleVector instruction) {
1357	1705	fprintf(irp->f, "@shuffle(");
1358		ir_print_other_instruction(irp, instruction->scalar_type);
	1706	ir_print_other_inst_src(irp, instruction->scalar_type);
1359	1707	fprintf(irp->f, ", ");
1360		ir_print_other_instruction(irp, instruction->a);
	1708	ir_print_other_inst_src(irp, instruction->a);
1361	1709	fprintf(irp->f, ", ");
1362		ir_print_other_instruction(irp, instruction->b);
	1710	ir_print_other_inst_src(irp, instruction->b);
1363	1711	fprintf(irp->f, ", ");
1364		ir_print_other_instruction(irp, instruction->mask);
	1712	ir_print_other_inst_src(irp, instruction->mask);
1365	1713	fprintf(irp->f, ")");
1366	1714	}
1367	1715
1368		static void ir_print_splat_src(IrPrint irp, IrInstructionSplatSrc instruction) {
	1716	static void ir_print_shuffle_vector(IrPrintGen irp, IrInstGenShuffleVector instruction) {
	1717	fprintf(irp->f, "@shuffle(");
	1718	ir_print_other_inst_gen(irp, instruction->a);
	1719	fprintf(irp->f, ", ");
	1720	ir_print_other_inst_gen(irp, instruction->b);
	1721	fprintf(irp->f, ", ");
	1722	ir_print_other_inst_gen(irp, instruction->mask);
	1723	fprintf(irp->f, ")");
	1724	}
	1725
	1726	static void ir_print_splat_src(IrPrintSrc irp, IrInstSrcSplat instruction) {
1369	1727	fprintf(irp->f, "@splat(");
1370		ir_print_other_instruction(irp, instruction->len);
	1728	ir_print_other_inst_src(irp, instruction->len);
1371	1729	fprintf(irp->f, ", ");
1372		ir_print_other_instruction(irp, instruction->scalar);
	1730	ir_print_other_inst_src(irp, instruction->scalar);
1373	1731	fprintf(irp->f, ")");
1374	1732	}
1375	1733
1376		static void ir_print_splat_gen(IrPrint irp, IrInstructionSplatGen instruction) {
	1734	static void ir_print_splat_gen(IrPrintGen irp, IrInstGenSplat instruction) {
1377	1735	fprintf(irp->f, "@splat(");
1378		ir_print_other_instruction(irp, instruction->scalar);
	1736	ir_print_other_inst_gen(irp, instruction->scalar);
1379	1737	fprintf(irp->f, ")");
1380	1738	}
1381	1739
1382		static void ir_print_bool_not(IrPrint irp, IrInstructionBoolNot instruction) {
	1740	static void ir_print_bool_not(IrPrintSrc irp, IrInstSrcBoolNot instruction) {
	1741	fprintf(irp->f, "! ");
	1742	ir_print_other_inst_src(irp, instruction->value);
	1743	}
	1744
	1745	static void ir_print_bool_not(IrPrintGen irp, IrInstGenBoolNot instruction) {
1383	1746	fprintf(irp->f, "! ");
1384		ir_print_other_instruction(irp, instruction->value);
	1747	ir_print_other_inst_gen(irp, instruction->value);
1385	1748	}
1386	1749
1387		static void ir_print_memset(IrPrint irp, IrInstructionMemset instruction) {
	1750	static void ir_print_memset(IrPrintSrc irp, IrInstSrcMemset instruction) {
1388	1751	fprintf(irp->f, "@memset(");
1389		ir_print_other_instruction(irp, instruction->dest_ptr);
	1752	ir_print_other_inst_src(irp, instruction->dest_ptr);
	1753	fprintf(irp->f, ", ");
	1754	ir_print_other_inst_src(irp, instruction->byte);
	1755	fprintf(irp->f, ", ");
	1756	ir_print_other_inst_src(irp, instruction->count);
	1757	fprintf(irp->f, ")");
	1758	}
	1759
	1760	static void ir_print_memset(IrPrintGen irp, IrInstGenMemset instruction) {
	1761	fprintf(irp->f, "@memset(");
	1762	ir_print_other_inst_gen(irp, instruction->dest_ptr);
	1763	fprintf(irp->f, ", ");
	1764	ir_print_other_inst_gen(irp, instruction->byte);
	1765	fprintf(irp->f, ", ");
	1766	ir_print_other_inst_gen(irp, instruction->count);
	1767	fprintf(irp->f, ")");
	1768	}
	1769
	1770	static void ir_print_memcpy(IrPrintSrc irp, IrInstSrcMemcpy instruction) {
	1771	fprintf(irp->f, "@memcpy(");
	1772	ir_print_other_inst_src(irp, instruction->dest_ptr);
1390	1773	fprintf(irp->f, ", ");
1391		ir_print_other_instruction(irp, instruction->byte);
	1774	ir_print_other_inst_src(irp, instruction->src_ptr);
1392	1775	fprintf(irp->f, ", ");
1393		ir_print_other_instruction(irp, instruction->count);
	1776	ir_print_other_inst_src(irp, instruction->count);
1394	1777	fprintf(irp->f, ")");
1395	1778	}
1396	1779
1397		static void ir_print_memcpy(IrPrint irp, IrInstructionMemcpy instruction) {
	1780	static void ir_print_memcpy(IrPrintGen irp, IrInstGenMemcpy instruction) {
1398	1781	fprintf(irp->f, "@memcpy(");
1399		ir_print_other_instruction(irp, instruction->dest_ptr);
	1782	ir_print_other_inst_gen(irp, instruction->dest_ptr);
1400	1783	fprintf(irp->f, ", ");
1401		ir_print_other_instruction(irp, instruction->src_ptr);
	1784	ir_print_other_inst_gen(irp, instruction->src_ptr);
1402	1785	fprintf(irp->f, ", ");
1403		ir_print_other_instruction(irp, instruction->count);
	1786	ir_print_other_inst_gen(irp, instruction->count);
1404	1787	fprintf(irp->f, ")");
1405	1788	}
1406	1789
1407		static void ir_print_slice_src(IrPrint irp, IrInstructionSliceSrc instruction) {
1408		ir_print_other_instruction(irp, instruction->ptr);
	1790	static void ir_print_slice_src(IrPrintSrc irp, IrInstSrcSlice instruction) {
	1791	ir_print_other_inst_src(irp, instruction->ptr);
1409	1792	fprintf(irp->f, "[");
1410		ir_print_other_instruction(irp, instruction->start);
	1793	ir_print_other_inst_src(irp, instruction->start);
1411	1794	fprintf(irp->f, "..");
1412	1795	if (instruction->end)
1413		ir_print_other_instruction(irp, instruction->end);
	1796	ir_print_other_inst_src(irp, instruction->end);
1414	1797	fprintf(irp->f, "]result=");
1415	1798	ir_print_result_loc(irp, instruction->result_loc);
1416	1799	}
1417	1800
1418		static void ir_print_slice_gen(IrPrint irp, IrInstructionSliceGen instruction) {
1419		ir_print_other_instruction(irp, instruction->ptr);
	1801	static void ir_print_slice_gen(IrPrintGen irp, IrInstGenSlice instruction) {
	1802	ir_print_other_inst_gen(irp, instruction->ptr);
1420	1803	fprintf(irp->f, "[");
1421		ir_print_other_instruction(irp, instruction->start);
	1804	ir_print_other_inst_gen(irp, instruction->start);
1422	1805	fprintf(irp->f, "..");
1423	1806	if (instruction->end)
1424		ir_print_other_instruction(irp, instruction->end);
	1807	ir_print_other_inst_gen(irp, instruction->end);
1425	1808	fprintf(irp->f, "]result=");
1426		ir_print_other_instruction(irp, instruction->result_loc);
	1809	ir_print_other_inst_gen(irp, instruction->result_loc);
1427	1810	}
1428	1811
1429		static void ir_print_member_count(IrPrint irp, IrInstructionMemberCount instruction) {
	1812	static void ir_print_member_count(IrPrintSrc irp, IrInstSrcMemberCount instruction) {
1430	1813	fprintf(irp->f, "@memberCount(");
1431		ir_print_other_instruction(irp, instruction->container);
	1814	ir_print_other_inst_src(irp, instruction->container);
1432	1815	fprintf(irp->f, ")");
1433	1816	}
1434	1817
1435		static void ir_print_member_type(IrPrint irp, IrInstructionMemberType instruction) {
	1818	static void ir_print_member_type(IrPrintSrc irp, IrInstSrcMemberType instruction) {
1436	1819	fprintf(irp->f, "@memberType(");
1437		ir_print_other_instruction(irp, instruction->container_type);
	1820	ir_print_other_inst_src(irp, instruction->container_type);
1438	1821	fprintf(irp->f, ", ");
1439		ir_print_other_instruction(irp, instruction->member_index);
	1822	ir_print_other_inst_src(irp, instruction->member_index);
1440	1823	fprintf(irp->f, ")");
1441	1824	}
1442	1825
1443		static void ir_print_member_name(IrPrint irp, IrInstructionMemberName instruction) {
	1826	static void ir_print_member_name(IrPrintSrc irp, IrInstSrcMemberName instruction) {
1444	1827	fprintf(irp->f, "@memberName(");
1445		ir_print_other_instruction(irp, instruction->container_type);
	1828	ir_print_other_inst_src(irp, instruction->container_type);
1446	1829	fprintf(irp->f, ", ");
1447		ir_print_other_instruction(irp, instruction->member_index);
	1830	ir_print_other_inst_src(irp, instruction->member_index);
1448	1831	fprintf(irp->f, ")");
1449	1832	}
1450	1833
1451		static void ir_print_breakpoint(IrPrint irp, IrInstructionBreakpoint instruction) {
	1834	static void ir_print_breakpoint(IrPrintSrc irp, IrInstSrcBreakpoint instruction) {
	1835	fprintf(irp->f, "@breakpoint()");
	1836	}
	1837
	1838	static void ir_print_breakpoint(IrPrintGen irp, IrInstGenBreakpoint instruction) {
1452	1839	fprintf(irp->f, "@breakpoint()");
1453	1840	}
1454	1841
1455		static void ir_print_frame_address(IrPrint irp, IrInstructionFrameAddress instruction) {
	1842	static void ir_print_frame_address(IrPrintSrc irp, IrInstSrcFrameAddress instruction) {
	1843	fprintf(irp->f, "@frameAddress()");
	1844	}
	1845
	1846	static void ir_print_frame_address(IrPrintGen irp, IrInstGenFrameAddress instruction) {
1456	1847	fprintf(irp->f, "@frameAddress()");
1457	1848	}
1458	1849
1459		static void ir_print_handle(IrPrint irp, IrInstructionFrameHandle instruction) {
	1850	static void ir_print_handle(IrPrintSrc irp, IrInstSrcFrameHandle instruction) {
1460	1851	fprintf(irp->f, "@frame()");
1461	1852	}
1462	1853
1463		static void ir_print_frame_type(IrPrint irp, IrInstructionFrameType instruction) {
	1854	static void ir_print_handle(IrPrintGen irp, IrInstGenFrameHandle instruction) {
	1855	fprintf(irp->f, "@frame()");
	1856	}
	1857
	1858	static void ir_print_frame_type(IrPrintSrc irp, IrInstSrcFrameType instruction) {
1464	1859	fprintf(irp->f, "@Frame(");
1465		ir_print_other_instruction(irp, instruction->fn);
	1860	ir_print_other_inst_src(irp, instruction->fn);
1466	1861	fprintf(irp->f, ")");
1467	1862	}
1468	1863
1469		static void ir_print_frame_size_src(IrPrint irp, IrInstructionFrameSizeSrc instruction) {
	1864	static void ir_print_frame_size_src(IrPrintSrc irp, IrInstSrcFrameSize instruction) {
1470	1865	fprintf(irp->f, "@frameSize(");
1471		ir_print_other_instruction(irp, instruction->fn);
	1866	ir_print_other_inst_src(irp, instruction->fn);
1472	1867	fprintf(irp->f, ")");
1473	1868	}
1474	1869
1475		static void ir_print_frame_size_gen(IrPrint irp, IrInstructionFrameSizeGen instruction) {
	1870	static void ir_print_frame_size_gen(IrPrintGen irp, IrInstGenFrameSize instruction) {
1476	1871	fprintf(irp->f, "@frameSize(");
1477		ir_print_other_instruction(irp, instruction->fn);
	1872	ir_print_other_inst_gen(irp, instruction->fn);
1478	1873	fprintf(irp->f, ")");
1479	1874	}
1480	1875
1481		static void ir_print_return_address(IrPrint irp, IrInstructionReturnAddress instruction) {
	1876	static void ir_print_return_address(IrPrintSrc irp, IrInstSrcReturnAddress instruction) {
	1877	fprintf(irp->f, "@returnAddress()");
	1878	}
	1879
	1880	static void ir_print_return_address(IrPrintGen irp, IrInstGenReturnAddress instruction) {
1482	1881	fprintf(irp->f, "@returnAddress()");
1483	1882	}
1484	1883
1485		static void ir_print_align_of(IrPrint irp, IrInstructionAlignOf instruction) {
	1884	static void ir_print_align_of(IrPrintSrc irp, IrInstSrcAlignOf instruction) {
1486	1885	fprintf(irp->f, "@alignOf(");
1487		ir_print_other_instruction(irp, instruction->type_value);
	1886	ir_print_other_inst_src(irp, instruction->type_value);
1488	1887	fprintf(irp->f, ")");
1489	1888	}
1490	1889
1491		static void ir_print_overflow_op(IrPrint irp, IrInstructionOverflowOp instruction) {
	1890	static void ir_print_overflow_op(IrPrintSrc irp, IrInstSrcOverflowOp instruction) {
1492	1891	switch (instruction->op) {
1493	1892	case IrOverflowOpAdd:
1494	1893	fprintf(irp->f, "@addWithOverflow(");
...	...	@@ -1503,1146 +1902,1457 @@ static void ir_print_overflow_op(IrPrint irp, IrInstructionOverflowOp instruct
1503	1902	fprintf(irp->f, "@shlWithOverflow(");
1504	1903	break;
1505	1904	}
1506		ir_print_other_instruction(irp, instruction->type_value);
	1905	ir_print_other_inst_src(irp, instruction->type_value);
1507	1906	fprintf(irp->f, ", ");
1508		ir_print_other_instruction(irp, instruction->op1);
	1907	ir_print_other_inst_src(irp, instruction->op1);
	1908	fprintf(irp->f, ", ");
	1909	ir_print_other_inst_src(irp, instruction->op2);
	1910	fprintf(irp->f, ", ");
	1911	ir_print_other_inst_src(irp, instruction->result_ptr);
	1912	fprintf(irp->f, ")");
	1913	}
	1914
	1915	static void ir_print_overflow_op(IrPrintGen irp, IrInstGenOverflowOp instruction) {
	1916	switch (instruction->op) {
	1917	case IrOverflowOpAdd:
	1918	fprintf(irp->f, "@addWithOverflow(");
	1919	break;
	1920	case IrOverflowOpSub:
	1921	fprintf(irp->f, "@subWithOverflow(");
	1922	break;
	1923	case IrOverflowOpMul:
	1924	fprintf(irp->f, "@mulWithOverflow(");
	1925	break;
	1926	case IrOverflowOpShl:
	1927	fprintf(irp->f, "@shlWithOverflow(");
	1928	break;
	1929	}
	1930	ir_print_other_inst_gen(irp, instruction->op1);
1509	1931	fprintf(irp->f, ", ");
1510		ir_print_other_instruction(irp, instruction->op2);
	1932	ir_print_other_inst_gen(irp, instruction->op2);
1511	1933	fprintf(irp->f, ", ");
1512		ir_print_other_instruction(irp, instruction->result_ptr);
	1934	ir_print_other_inst_gen(irp, instruction->result_ptr);
1513	1935	fprintf(irp->f, ")");
1514	1936	}
1515	1937
1516		static void ir_print_test_err_src(IrPrint irp, IrInstructionTestErrSrc instruction) {
	1938	static void ir_print_test_err_src(IrPrintSrc irp, IrInstSrcTestErr instruction) {
1517	1939	fprintf(irp->f, "@testError(");
1518		ir_print_other_instruction(irp, instruction->base_ptr);
	1940	ir_print_other_inst_src(irp, instruction->base_ptr);
1519	1941	fprintf(irp->f, ")");
1520	1942	}
1521	1943
1522		static void ir_print_test_err_gen(IrPrint irp, IrInstructionTestErrGen instruction) {
	1944	static void ir_print_test_err_gen(IrPrintGen irp, IrInstGenTestErr instruction) {
1523	1945	fprintf(irp->f, "@testError(");
1524		ir_print_other_instruction(irp, instruction->err_union);
	1946	ir_print_other_inst_gen(irp, instruction->err_union);
	1947	fprintf(irp->f, ")");
	1948	}
	1949
	1950	static void ir_print_unwrap_err_code(IrPrintSrc irp, IrInstSrcUnwrapErrCode instruction) {
	1951	fprintf(irp->f, "UnwrapErrorCode(");
	1952	ir_print_other_inst_src(irp, instruction->err_union_ptr);
1525	1953	fprintf(irp->f, ")");
1526	1954	}
1527	1955
1528		static void ir_print_unwrap_err_code(IrPrint irp, IrInstructionUnwrapErrCode instruction) {
	1956	static void ir_print_unwrap_err_code(IrPrintGen irp, IrInstGenUnwrapErrCode instruction) {
1529	1957	fprintf(irp->f, "UnwrapErrorCode(");
1530		ir_print_other_instruction(irp, instruction->err_union_ptr);
	1958	ir_print_other_inst_gen(irp, instruction->err_union_ptr);
1531	1959	fprintf(irp->f, ")");
1532	1960	}
1533	1961
1534		static void ir_print_unwrap_err_payload(IrPrint irp, IrInstructionUnwrapErrPayload instruction) {
	1962	static void ir_print_unwrap_err_payload(IrPrintSrc irp, IrInstSrcUnwrapErrPayload instruction) {
	1963	fprintf(irp->f, "ErrorUnionFieldPayload(");
	1964	ir_print_other_inst_src(irp, instruction->value);
	1965	fprintf(irp->f, ")safety=%d,init=%d",instruction->safety_check_on, instruction->initializing);
	1966	}
	1967
	1968	static void ir_print_unwrap_err_payload(IrPrintGen irp, IrInstGenUnwrapErrPayload instruction) {
1535	1969	fprintf(irp->f, "ErrorUnionFieldPayload(");
1536		ir_print_other_instruction(irp, instruction->value);
	1970	ir_print_other_inst_gen(irp, instruction->value);
1537	1971	fprintf(irp->f, ")safety=%d,init=%d",instruction->safety_check_on, instruction->initializing);
1538	1972	}
1539	1973
1540		static void ir_print_optional_wrap(IrPrint irp, IrInstructionOptionalWrap instruction) {
	1974	static void ir_print_optional_wrap(IrPrintGen irp, IrInstGenOptionalWrap instruction) {
1541	1975	fprintf(irp->f, "@optionalWrap(");
1542		ir_print_other_instruction(irp, instruction->operand);
	1976	ir_print_other_inst_gen(irp, instruction->operand);
1543	1977	fprintf(irp->f, ")result=");
1544		ir_print_other_instruction(irp, instruction->result_loc);
	1978	ir_print_other_inst_gen(irp, instruction->result_loc);
1545	1979	}
1546	1980
1547		static void ir_print_err_wrap_code(IrPrint irp, IrInstructionErrWrapCode instruction) {
	1981	static void ir_print_err_wrap_code(IrPrintGen irp, IrInstGenErrWrapCode instruction) {
1548	1982	fprintf(irp->f, "@errWrapCode(");
1549		ir_print_other_instruction(irp, instruction->operand);
	1983	ir_print_other_inst_gen(irp, instruction->operand);
1550	1984	fprintf(irp->f, ")result=");
1551		ir_print_other_instruction(irp, instruction->result_loc);
	1985	ir_print_other_inst_gen(irp, instruction->result_loc);
1552	1986	}
1553	1987
1554		static void ir_print_err_wrap_payload(IrPrint irp, IrInstructionErrWrapPayload instruction) {
	1988	static void ir_print_err_wrap_payload(IrPrintGen irp, IrInstGenErrWrapPayload instruction) {
1555	1989	fprintf(irp->f, "@errWrapPayload(");
1556		ir_print_other_instruction(irp, instruction->operand);
	1990	ir_print_other_inst_gen(irp, instruction->operand);
1557	1991	fprintf(irp->f, ")result=");
1558		ir_print_other_instruction(irp, instruction->result_loc);
	1992	ir_print_other_inst_gen(irp, instruction->result_loc);
1559	1993	}
1560	1994
1561		static void ir_print_fn_proto(IrPrint irp, IrInstructionFnProto instruction) {
	1995	static void ir_print_fn_proto(IrPrintSrc irp, IrInstSrcFnProto instruction) {
1562	1996	fprintf(irp->f, "fn(");
1563		for (size_t i = 0; i < instruction->base.source_node->data.fn_proto.params.length; i += 1) {
	1997	for (size_t i = 0; i < instruction->base.base.source_node->data.fn_proto.params.length; i += 1) {
1564	1998	if (i != 0)
1565	1999	fprintf(irp->f, ",");
1566		if (instruction->is_var_args && i == instruction->base.source_node->data.fn_proto.params.length - 1) {
	2000	if (instruction->is_var_args && i == instruction->base.base.source_node->data.fn_proto.params.length - 1) {
1567	2001	fprintf(irp->f, "...");
1568	2002	} else {
1569		ir_print_other_instruction(irp, instruction->param_types[i]);
	2003	ir_print_other_inst_src(irp, instruction->param_types[i]);
1570	2004	}
1571	2005	}
1572	2006	fprintf(irp->f, ")");
1573	2007	if (instruction->align_value != nullptr) {
1574	2008	fprintf(irp->f, " align ");
1575		ir_print_other_instruction(irp, instruction->align_value);
	2009	ir_print_other_inst_src(irp, instruction->align_value);
1576	2010	fprintf(irp->f, " ");
1577	2011	}
1578	2012	fprintf(irp->f, "->");
1579		ir_print_other_instruction(irp, instruction->return_type);
	2013	ir_print_other_inst_src(irp, instruction->return_type);
1580	2014	}
1581	2015
1582		static void ir_print_test_comptime(IrPrint irp, IrInstructionTestComptime instruction) {
	2016	static void ir_print_test_comptime(IrPrintSrc irp, IrInstSrcTestComptime instruction) {
1583	2017	fprintf(irp->f, "@testComptime(");
1584		ir_print_other_instruction(irp, instruction->value);
	2018	ir_print_other_inst_src(irp, instruction->value);
1585	2019	fprintf(irp->f, ")");
1586	2020	}
1587	2021
1588		static void ir_print_ptr_cast_src(IrPrint irp, IrInstructionPtrCastSrc instruction) {
	2022	static void ir_print_ptr_cast_src(IrPrintSrc irp, IrInstSrcPtrCast instruction) {
1589	2023	fprintf(irp->f, "@ptrCast(");
1590	2024	if (instruction->dest_type) {
1591		ir_print_other_instruction(irp, instruction->dest_type);
	2025	ir_print_other_inst_src(irp, instruction->dest_type);
1592	2026	}
1593	2027	fprintf(irp->f, ",");
1594		ir_print_other_instruction(irp, instruction->ptr);
	2028	ir_print_other_inst_src(irp, instruction->ptr);
1595	2029	fprintf(irp->f, ")");
1596	2030	}
1597	2031
1598		static void ir_print_ptr_cast_gen(IrPrint irp, IrInstructionPtrCastGen instruction) {
	2032	static void ir_print_ptr_cast_gen(IrPrintGen irp, IrInstGenPtrCast instruction) {
1599	2033	fprintf(irp->f, "@ptrCast(");
1600		ir_print_other_instruction(irp, instruction->ptr);
	2034	ir_print_other_inst_gen(irp, instruction->ptr);
1601	2035	fprintf(irp->f, ")");
1602	2036	}
1603	2037
1604		static void ir_print_implicit_cast(IrPrint irp, IrInstructionImplicitCast instruction) {
	2038	static void ir_print_implicit_cast(IrPrintSrc irp, IrInstSrcImplicitCast instruction) {
1605	2039	fprintf(irp->f, "@implicitCast(");
1606		ir_print_other_instruction(irp, instruction->operand);
	2040	ir_print_other_inst_src(irp, instruction->operand);
1607	2041	fprintf(irp->f, ")result=");
1608	2042	ir_print_result_loc(irp, &instruction->result_loc_cast->base);
1609	2043	}
1610	2044
1611		static void ir_print_bit_cast_src(IrPrint irp, IrInstructionBitCastSrc instruction) {
	2045	static void ir_print_bit_cast_src(IrPrintSrc irp, IrInstSrcBitCast instruction) {
1612	2046	fprintf(irp->f, "@bitCast(");
1613		ir_print_other_instruction(irp, instruction->operand);
	2047	ir_print_other_inst_src(irp, instruction->operand);
1614	2048	fprintf(irp->f, ")result=");
1615	2049	ir_print_result_loc(irp, &instruction->result_loc_bit_cast->base);
1616	2050	}
1617	2051
1618		static void ir_print_bit_cast_gen(IrPrint irp, IrInstructionBitCastGen instruction) {
	2052	static void ir_print_bit_cast_gen(IrPrintGen irp, IrInstGenBitCast instruction) {
1619	2053	fprintf(irp->f, "@bitCast(");
1620		ir_print_other_instruction(irp, instruction->operand);
	2054	ir_print_other_inst_gen(irp, instruction->operand);
1621	2055	fprintf(irp->f, ")");
1622	2056	}
1623	2057
1624		static void ir_print_widen_or_shorten(IrPrint irp, IrInstructionWidenOrShorten instruction) {
	2058	static void ir_print_widen_or_shorten(IrPrintGen irp, IrInstGenWidenOrShorten instruction) {
1625	2059	fprintf(irp->f, "WidenOrShorten(");
1626		ir_print_other_instruction(irp, instruction->target);
	2060	ir_print_other_inst_gen(irp, instruction->target);
1627	2061	fprintf(irp->f, ")");
1628	2062	}
1629	2063
1630		static void ir_print_ptr_to_int(IrPrint irp, IrInstructionPtrToInt instruction) {
	2064	static void ir_print_ptr_to_int(IrPrintSrc irp, IrInstSrcPtrToInt instruction) {
1631	2065	fprintf(irp->f, "@ptrToInt(");
1632		ir_print_other_instruction(irp, instruction->target);
	2066	ir_print_other_inst_src(irp, instruction->target);
1633	2067	fprintf(irp->f, ")");
1634	2068	}
1635	2069
1636		static void ir_print_int_to_ptr(IrPrint irp, IrInstructionIntToPtr instruction) {
	2070	static void ir_print_ptr_to_int(IrPrintGen irp, IrInstGenPtrToInt instruction) {
	2071	fprintf(irp->f, "@ptrToInt(");
	2072	ir_print_other_inst_gen(irp, instruction->target);
	2073	fprintf(irp->f, ")");
	2074	}
	2075
	2076	static void ir_print_int_to_ptr(IrPrintSrc irp, IrInstSrcIntToPtr instruction) {
1637	2077	fprintf(irp->f, "@intToPtr(");
1638		if (instruction->dest_type == nullptr) {
1639		fprintf(irp->f, "(null)");
1640		} else {
1641		ir_print_other_instruction(irp, instruction->dest_type);
1642		}
	2078	ir_print_other_inst_src(irp, instruction->dest_type);
1643	2079	fprintf(irp->f, ",");
1644		ir_print_other_instruction(irp, instruction->target);
	2080	ir_print_other_inst_src(irp, instruction->target);
1645	2081	fprintf(irp->f, ")");
1646	2082	}
1647	2083
1648		static void ir_print_int_to_enum(IrPrint irp, IrInstructionIntToEnum instruction) {
	2084	static void ir_print_int_to_ptr(IrPrintGen irp, IrInstGenIntToPtr instruction) {
	2085	fprintf(irp->f, "@intToPtr(");
	2086	ir_print_other_inst_gen(irp, instruction->target);
	2087	fprintf(irp->f, ")");
	2088	}
	2089
	2090	static void ir_print_int_to_enum(IrPrintSrc irp, IrInstSrcIntToEnum instruction) {
1649	2091	fprintf(irp->f, "@intToEnum(");
1650		if (instruction->dest_type == nullptr) {
1651		fprintf(irp->f, "(null)");
1652		} else {
1653		ir_print_other_instruction(irp, instruction->dest_type);
1654		}
1655		ir_print_other_instruction(irp, instruction->target);
	2092	ir_print_other_inst_src(irp, instruction->dest_type);
	2093	fprintf(irp->f, ",");
	2094	ir_print_other_inst_src(irp, instruction->target);
1656	2095	fprintf(irp->f, ")");
1657	2096	}
1658	2097
1659		static void ir_print_enum_to_int(IrPrint irp, IrInstructionEnumToInt instruction) {
	2098	static void ir_print_int_to_enum(IrPrintGen irp, IrInstGenIntToEnum instruction) {
	2099	fprintf(irp->f, "@intToEnum(");
	2100	ir_print_other_inst_gen(irp, instruction->target);
	2101	fprintf(irp->f, ")");
	2102	}
	2103
	2104	static void ir_print_enum_to_int(IrPrintSrc irp, IrInstSrcEnumToInt instruction) {
1660	2105	fprintf(irp->f, "@enumToInt(");
1661		ir_print_other_instruction(irp, instruction->target);
	2106	ir_print_other_inst_src(irp, instruction->target);
1662	2107	fprintf(irp->f, ")");
1663	2108	}
1664	2109
1665		static void ir_print_check_runtime_scope(IrPrint irp, IrInstructionCheckRuntimeScope instruction) {
	2110	static void ir_print_check_runtime_scope(IrPrintSrc irp, IrInstSrcCheckRuntimeScope instruction) {
1666	2111	fprintf(irp->f, "@checkRuntimeScope(");
1667		ir_print_other_instruction(irp, instruction->scope_is_comptime);
	2112	ir_print_other_inst_src(irp, instruction->scope_is_comptime);
1668	2113	fprintf(irp->f, ",");
1669		ir_print_other_instruction(irp, instruction->is_comptime);
	2114	ir_print_other_inst_src(irp, instruction->is_comptime);
1670	2115	fprintf(irp->f, ")");
1671	2116	}
1672	2117
1673		static void ir_print_array_to_vector(IrPrint irp, IrInstructionArrayToVector instruction) {
	2118	static void ir_print_array_to_vector(IrPrintGen irp, IrInstGenArrayToVector instruction) {
1674	2119	fprintf(irp->f, "ArrayToVector(");
1675		ir_print_other_instruction(irp, instruction->array);
	2120	ir_print_other_inst_gen(irp, instruction->array);
1676	2121	fprintf(irp->f, ")");
1677	2122	}
1678	2123
1679		static void ir_print_vector_to_array(IrPrint irp, IrInstructionVectorToArray instruction) {
	2124	static void ir_print_vector_to_array(IrPrintGen irp, IrInstGenVectorToArray instruction) {
1680	2125	fprintf(irp->f, "VectorToArray(");
1681		ir_print_other_instruction(irp, instruction->vector);
	2126	ir_print_other_inst_gen(irp, instruction->vector);
1682	2127	fprintf(irp->f, ")result=");
1683		ir_print_other_instruction(irp, instruction->result_loc);
	2128	ir_print_other_inst_gen(irp, instruction->result_loc);
1684	2129	}
1685	2130
1686		static void ir_print_ptr_of_array_to_slice(IrPrint irp, IrInstructionPtrOfArrayToSlice instruction) {
	2131	static void ir_print_ptr_of_array_to_slice(IrPrintGen irp, IrInstGenPtrOfArrayToSlice instruction) {
1687	2132	fprintf(irp->f, "PtrOfArrayToSlice(");
1688		ir_print_other_instruction(irp, instruction->operand);
	2133	ir_print_other_inst_gen(irp, instruction->operand);
1689	2134	fprintf(irp->f, ")result=");
1690		ir_print_other_instruction(irp, instruction->result_loc);
	2135	ir_print_other_inst_gen(irp, instruction->result_loc);
1691	2136	}
1692	2137
1693		static void ir_print_assert_zero(IrPrint irp, IrInstructionAssertZero instruction) {
	2138	static void ir_print_assert_zero(IrPrintGen irp, IrInstGenAssertZero instruction) {
1694	2139	fprintf(irp->f, "AssertZero(");
1695		ir_print_other_instruction(irp, instruction->target);
	2140	ir_print_other_inst_gen(irp, instruction->target);
1696	2141	fprintf(irp->f, ")");
1697	2142	}
1698	2143
1699		static void ir_print_assert_non_null(IrPrint irp, IrInstructionAssertNonNull instruction) {
	2144	static void ir_print_assert_non_null(IrPrintGen irp, IrInstGenAssertNonNull instruction) {
1700	2145	fprintf(irp->f, "AssertNonNull(");
1701		ir_print_other_instruction(irp, instruction->target);
	2146	ir_print_other_inst_gen(irp, instruction->target);
1702	2147	fprintf(irp->f, ")");
1703	2148	}
1704	2149
1705		static void ir_print_resize_slice(IrPrint irp, IrInstructionResizeSlice instruction) {
	2150	static void ir_print_resize_slice(IrPrintGen irp, IrInstGenResizeSlice instruction) {
1706	2151	fprintf(irp->f, "@resizeSlice(");
1707		ir_print_other_instruction(irp, instruction->operand);
	2152	ir_print_other_inst_gen(irp, instruction->operand);
1708	2153	fprintf(irp->f, ")result=");
1709		ir_print_other_instruction(irp, instruction->result_loc);
	2154	ir_print_other_inst_gen(irp, instruction->result_loc);
1710	2155	}
1711	2156
1712		static void ir_print_alloca_src(IrPrint irp, IrInstructionAllocaSrc instruction) {
	2157	static void ir_print_alloca_src(IrPrintSrc irp, IrInstSrcAlloca instruction) {
1713	2158	fprintf(irp->f, "Alloca(align=");
1714		ir_print_other_instruction(irp, instruction->align);
	2159	ir_print_other_inst_src(irp, instruction->align);
1715	2160	fprintf(irp->f, ",name=%s)", instruction->name_hint);
1716	2161	}
1717	2162
1718		static void ir_print_alloca_gen(IrPrint irp, IrInstructionAllocaGen instruction) {
	2163	static void ir_print_alloca_gen(IrPrintGen irp, IrInstGenAlloca instruction) {
1719	2164	fprintf(irp->f, "Alloca(align=%" PRIu32 ",name=%s)", instruction->align, instruction->name_hint);
1720	2165	}
1721	2166
1722		static void ir_print_end_expr(IrPrint irp, IrInstructionEndExpr instruction) {
	2167	static void ir_print_end_expr(IrPrintSrc irp, IrInstSrcEndExpr instruction) {
1723	2168	fprintf(irp->f, "EndExpr(result=");
1724	2169	ir_print_result_loc(irp, instruction->result_loc);
1725	2170	fprintf(irp->f, ",value=");
1726		ir_print_other_instruction(irp, instruction->value);
	2171	ir_print_other_inst_src(irp, instruction->value);
1727	2172	fprintf(irp->f, ")");
1728	2173	}
1729	2174
1730		static void ir_print_int_to_err(IrPrint irp, IrInstructionIntToErr instruction) {
	2175	static void ir_print_int_to_err(IrPrintSrc irp, IrInstSrcIntToErr instruction) {
1731	2176	fprintf(irp->f, "inttoerr ");
1732		ir_print_other_instruction(irp, instruction->target);
	2177	ir_print_other_inst_src(irp, instruction->target);
1733	2178	}
1734	2179
1735		static void ir_print_err_to_int(IrPrint irp, IrInstructionErrToInt instruction) {
	2180	static void ir_print_int_to_err(IrPrintGen irp, IrInstGenIntToErr instruction) {
	2181	fprintf(irp->f, "inttoerr ");
	2182	ir_print_other_inst_gen(irp, instruction->target);
	2183	}
	2184
	2185	static void ir_print_err_to_int(IrPrintSrc irp, IrInstSrcErrToInt instruction) {
	2186	fprintf(irp->f, "errtoint ");
	2187	ir_print_other_inst_src(irp, instruction->target);
	2188	}
	2189
	2190	static void ir_print_err_to_int(IrPrintGen irp, IrInstGenErrToInt instruction) {
1736	2191	fprintf(irp->f, "errtoint ");
1737		ir_print_other_instruction(irp, instruction->target);
	2192	ir_print_other_inst_gen(irp, instruction->target);
1738	2193	}
1739	2194
1740		static void ir_print_check_switch_prongs(IrPrint irp, IrInstructionCheckSwitchProngs instruction) {
	2195	static void ir_print_check_switch_prongs(IrPrintSrc irp, IrInstSrcCheckSwitchProngs instruction) {
1741	2196	fprintf(irp->f, "@checkSwitchProngs(");
1742		ir_print_other_instruction(irp, instruction->target_value);
	2197	ir_print_other_inst_src(irp, instruction->target_value);
1743	2198	fprintf(irp->f, ",");
1744	2199	for (size_t i = 0; i < instruction->range_count; i += 1) {
1745	2200	if (i != 0)
1746	2201	fprintf(irp->f, ",");
1747		ir_print_other_instruction(irp, instruction->ranges[i].start);
	2202	ir_print_other_inst_src(irp, instruction->ranges[i].start);
1748	2203	fprintf(irp->f, "...");
1749		ir_print_other_instruction(irp, instruction->ranges[i].end);
	2204	ir_print_other_inst_src(irp, instruction->ranges[i].end);
1750	2205	}
1751	2206	const char *have_else_str = instruction->have_else_prong ? "yes" : "no";
1752	2207	fprintf(irp->f, ")else:%s", have_else_str);
1753	2208	}
1754	2209
1755		static void ir_print_check_statement_is_void(IrPrint irp, IrInstructionCheckStatementIsVoid instruction) {
	2210	static void ir_print_check_statement_is_void(IrPrintSrc irp, IrInstSrcCheckStatementIsVoid instruction) {
1756	2211	fprintf(irp->f, "@checkStatementIsVoid(");
1757		ir_print_other_instruction(irp, instruction->statement_value);
	2212	ir_print_other_inst_src(irp, instruction->statement_value);
1758	2213	fprintf(irp->f, ")");
1759	2214	}
1760	2215
1761		static void ir_print_type_name(IrPrint irp, IrInstructionTypeName instruction) {
	2216	static void ir_print_type_name(IrPrintSrc irp, IrInstSrcTypeName instruction) {
1762	2217	fprintf(irp->f, "typename ");
1763		ir_print_other_instruction(irp, instruction->type_value);
	2218	ir_print_other_inst_src(irp, instruction->type_value);
	2219	}
	2220
	2221	static void ir_print_tag_name(IrPrintSrc irp, IrInstSrcTagName instruction) {
	2222	fprintf(irp->f, "tagname ");
	2223	ir_print_other_inst_src(irp, instruction->target);
1764	2224	}
1765	2225
1766		static void ir_print_tag_name(IrPrint irp, IrInstructionTagName instruction) {
	2226	static void ir_print_tag_name(IrPrintGen irp, IrInstGenTagName instruction) {
1767	2227	fprintf(irp->f, "tagname ");
1768		ir_print_other_instruction(irp, instruction->target);
	2228	ir_print_other_inst_gen(irp, instruction->target);
1769	2229	}
1770	2230
1771		static void ir_print_ptr_type(IrPrint irp, IrInstructionPtrType instruction) {
	2231	static void ir_print_ptr_type(IrPrintSrc irp, IrInstSrcPtrType instruction) {
1772	2232	fprintf(irp->f, "&");
1773	2233	if (instruction->align_value != nullptr) {
1774	2234	fprintf(irp->f, "align(");
1775		ir_print_other_instruction(irp, instruction->align_value);
	2235	ir_print_other_inst_src(irp, instruction->align_value);
1776	2236	fprintf(irp->f, ")");
1777	2237	}
1778	2238	const char *const_str = instruction->is_const ? "const " : "";
1779	2239	const char *volatile_str = instruction->is_volatile ? "volatile " : "";
1780	2240	fprintf(irp->f, ":%" PRIu32 ":%" PRIu32 " %s%s", instruction->bit_offset_start, instruction->host_int_bytes,
1781	2241	const_str, volatile_str);
1782		ir_print_other_instruction(irp, instruction->child_type);
	2242	ir_print_other_inst_src(irp, instruction->child_type);
1783	2243	}
1784	2244
1785		static void ir_print_decl_ref(IrPrint irp, IrInstructionDeclRef instruction) {
	2245	static void ir_print_decl_ref(IrPrintSrc irp, IrInstSrcDeclRef instruction) {
1786	2246	const char *ptr_str = (instruction->lval == LValPtr) ? "ptr " : "";
1787	2247	fprintf(irp->f, "declref %s%s", ptr_str, buf_ptr(instruction->tld->name));
1788	2248	}
1789	2249
1790		static void ir_print_panic(IrPrint irp, IrInstructionPanic instruction) {
	2250	static void ir_print_panic(IrPrintSrc irp, IrInstSrcPanic instruction) {
1791	2251	fprintf(irp->f, "@panic(");
1792		ir_print_other_instruction(irp, instruction->msg);
	2252	ir_print_other_inst_src(irp, instruction->msg);
1793	2253	fprintf(irp->f, ")");
1794	2254	}
1795	2255
1796		static void ir_print_field_parent_ptr(IrPrint irp, IrInstructionFieldParentPtr instruction) {
	2256	static void ir_print_panic(IrPrintGen irp, IrInstGenPanic instruction) {
	2257	fprintf(irp->f, "@panic(");
	2258	ir_print_other_inst_gen(irp, instruction->msg);
	2259	fprintf(irp->f, ")");
	2260	}
	2261
	2262	static void ir_print_field_parent_ptr(IrPrintSrc irp, IrInstSrcFieldParentPtr instruction) {
1797	2263	fprintf(irp->f, "@fieldParentPtr(");
1798		ir_print_other_instruction(irp, instruction->type_value);
	2264	ir_print_other_inst_src(irp, instruction->type_value);
1799	2265	fprintf(irp->f, ",");
1800		ir_print_other_instruction(irp, instruction->field_name);
	2266	ir_print_other_inst_src(irp, instruction->field_name);
1801	2267	fprintf(irp->f, ",");
1802		ir_print_other_instruction(irp, instruction->field_ptr);
	2268	ir_print_other_inst_src(irp, instruction->field_ptr);
1803	2269	fprintf(irp->f, ")");
1804	2270	}
1805	2271
1806		static void ir_print_byte_offset_of(IrPrint irp, IrInstructionByteOffsetOf instruction) {
	2272	static void ir_print_field_parent_ptr(IrPrintGen irp, IrInstGenFieldParentPtr instruction) {
	2273	fprintf(irp->f, "@fieldParentPtr(%s,", buf_ptr(instruction->field->name));
	2274	ir_print_other_inst_gen(irp, instruction->field_ptr);
	2275	fprintf(irp->f, ")");
	2276	}
	2277
	2278	static void ir_print_byte_offset_of(IrPrintSrc irp, IrInstSrcByteOffsetOf instruction) {
1807	2279	fprintf(irp->f, "@byte_offset_of(");
1808		ir_print_other_instruction(irp, instruction->type_value);
	2280	ir_print_other_inst_src(irp, instruction->type_value);
1809	2281	fprintf(irp->f, ",");
1810		ir_print_other_instruction(irp, instruction->field_name);
	2282	ir_print_other_inst_src(irp, instruction->field_name);
1811	2283	fprintf(irp->f, ")");
1812	2284	}
1813	2285
1814		static void ir_print_bit_offset_of(IrPrint irp, IrInstructionBitOffsetOf instruction) {
	2286	static void ir_print_bit_offset_of(IrPrintSrc irp, IrInstSrcBitOffsetOf instruction) {
1815	2287	fprintf(irp->f, "@bit_offset_of(");
1816		ir_print_other_instruction(irp, instruction->type_value);
	2288	ir_print_other_inst_src(irp, instruction->type_value);
1817	2289	fprintf(irp->f, ",");
1818		ir_print_other_instruction(irp, instruction->field_name);
	2290	ir_print_other_inst_src(irp, instruction->field_name);
1819	2291	fprintf(irp->f, ")");
1820	2292	}
1821	2293
1822		static void ir_print_type_info(IrPrint irp, IrInstructionTypeInfo instruction) {
	2294	static void ir_print_type_info(IrPrintSrc irp, IrInstSrcTypeInfo instruction) {
1823	2295	fprintf(irp->f, "@typeInfo(");
1824		ir_print_other_instruction(irp, instruction->type_value);
	2296	ir_print_other_inst_src(irp, instruction->type_value);
1825	2297	fprintf(irp->f, ")");
1826	2298	}
1827	2299
1828		static void ir_print_type(IrPrint irp, IrInstructionType instruction) {
	2300	static void ir_print_type(IrPrintSrc irp, IrInstSrcType instruction) {
1829	2301	fprintf(irp->f, "@Type(");
1830		ir_print_other_instruction(irp, instruction->type_info);
	2302	ir_print_other_inst_src(irp, instruction->type_info);
1831	2303	fprintf(irp->f, ")");
1832	2304	}
1833	2305
1834		static void ir_print_has_field(IrPrint irp, IrInstructionHasField instruction) {
	2306	static void ir_print_has_field(IrPrintSrc irp, IrInstSrcHasField instruction) {
1835	2307	fprintf(irp->f, "@hasField(");
1836		ir_print_other_instruction(irp, instruction->container_type);
	2308	ir_print_other_inst_src(irp, instruction->container_type);
1837	2309	fprintf(irp->f, ",");
1838		ir_print_other_instruction(irp, instruction->field_name);
	2310	ir_print_other_inst_src(irp, instruction->field_name);
1839	2311	fprintf(irp->f, ")");
1840	2312	}
1841	2313
1842		static void ir_print_type_id(IrPrint irp, IrInstructionTypeId instruction) {
	2314	static void ir_print_type_id(IrPrintSrc irp, IrInstSrcTypeId instruction) {
1843	2315	fprintf(irp->f, "@typeId(");
1844		ir_print_other_instruction(irp, instruction->type_value);
	2316	ir_print_other_inst_src(irp, instruction->type_value);
1845	2317	fprintf(irp->f, ")");
1846	2318	}
1847	2319
1848		static void ir_print_set_eval_branch_quota(IrPrint irp, IrInstructionSetEvalBranchQuota instruction) {
	2320	static void ir_print_set_eval_branch_quota(IrPrintSrc irp, IrInstSrcSetEvalBranchQuota instruction) {
1849	2321	fprintf(irp->f, "@setEvalBranchQuota(");
1850		ir_print_other_instruction(irp, instruction->new_quota);
	2322	ir_print_other_inst_src(irp, instruction->new_quota);
1851	2323	fprintf(irp->f, ")");
1852	2324	}
1853	2325
1854		static void ir_print_align_cast(IrPrint irp, IrInstructionAlignCast instruction) {
	2326	static void ir_print_align_cast(IrPrintSrc irp, IrInstSrcAlignCast instruction) {
1855	2327	fprintf(irp->f, "@alignCast(");
1856		if (instruction->align_bytes == nullptr) {
1857		fprintf(irp->f, "null");
1858		} else {
1859		ir_print_other_instruction(irp, instruction->align_bytes);
1860		}
	2328	ir_print_other_inst_src(irp, instruction->align_bytes);
1861	2329	fprintf(irp->f, ",");
1862		ir_print_other_instruction(irp, instruction->target);
	2330	ir_print_other_inst_src(irp, instruction->target);
	2331	fprintf(irp->f, ")");
	2332	}
	2333
	2334	static void ir_print_align_cast(IrPrintGen irp, IrInstGenAlignCast instruction) {
	2335	fprintf(irp->f, "@alignCast(");
	2336	ir_print_other_inst_gen(irp, instruction->target);
1863	2337	fprintf(irp->f, ")");
1864	2338	}
1865	2339
1866		static void ir_print_resolve_result(IrPrint irp, IrInstructionResolveResult instruction) {
	2340	static void ir_print_resolve_result(IrPrintSrc irp, IrInstSrcResolveResult instruction) {
1867	2341	fprintf(irp->f, "ResolveResult(");
1868	2342	ir_print_result_loc(irp, instruction->result_loc);
1869	2343	fprintf(irp->f, ")");
1870	2344	}
1871	2345
1872		static void ir_print_reset_result(IrPrint irp, IrInstructionResetResult instruction) {
	2346	static void ir_print_reset_result(IrPrintSrc irp, IrInstSrcResetResult instruction) {
1873	2347	fprintf(irp->f, "ResetResult(");
1874	2348	ir_print_result_loc(irp, instruction->result_loc);
1875	2349	fprintf(irp->f, ")");
1876	2350	}
1877	2351
1878		static void ir_print_opaque_type(IrPrint irp, IrInstructionOpaqueType instruction) {
	2352	static void ir_print_opaque_type(IrPrintSrc irp, IrInstSrcOpaqueType instruction) {
1879	2353	fprintf(irp->f, "@OpaqueType()");
1880	2354	}
1881	2355
1882		static void ir_print_set_align_stack(IrPrint irp, IrInstructionSetAlignStack instruction) {
	2356	static void ir_print_set_align_stack(IrPrintSrc irp, IrInstSrcSetAlignStack instruction) {
1883	2357	fprintf(irp->f, "@setAlignStack(");
1884		ir_print_other_instruction(irp, instruction->align_bytes);
	2358	ir_print_other_inst_src(irp, instruction->align_bytes);
1885	2359	fprintf(irp->f, ")");
1886	2360	}
1887	2361
1888		static void ir_print_arg_type(IrPrint irp, IrInstructionArgType instruction) {
	2362	static void ir_print_arg_type(IrPrintSrc irp, IrInstSrcArgType instruction) {
1889	2363	fprintf(irp->f, "@ArgType(");
1890		ir_print_other_instruction(irp, instruction->fn_type);
	2364	ir_print_other_inst_src(irp, instruction->fn_type);
1891	2365	fprintf(irp->f, ",");
1892		ir_print_other_instruction(irp, instruction->arg_index);
	2366	ir_print_other_inst_src(irp, instruction->arg_index);
1893	2367	fprintf(irp->f, ")");
1894	2368	}
1895	2369
1896		static void ir_print_enum_tag_type(IrPrint irp, IrInstructionTagType instruction) {
	2370	static void ir_print_enum_tag_type(IrPrintSrc irp, IrInstSrcTagType instruction) {
1897	2371	fprintf(irp->f, "@TagType(");
1898		ir_print_other_instruction(irp, instruction->target);
	2372	ir_print_other_inst_src(irp, instruction->target);
1899	2373	fprintf(irp->f, ")");
1900	2374	}
1901	2375
1902		static void ir_print_export(IrPrint irp, IrInstructionExport instruction) {
	2376	static void ir_print_export(IrPrintSrc irp, IrInstSrcExport instruction) {
1903	2377	fprintf(irp->f, "@export(");
1904		ir_print_other_instruction(irp, instruction->target);
	2378	ir_print_other_inst_src(irp, instruction->target);
1905	2379	fprintf(irp->f, ",");
1906		ir_print_other_instruction(irp, instruction->options);
	2380	ir_print_other_inst_src(irp, instruction->options);
	2381	fprintf(irp->f, ")");
	2382	}
	2383
	2384	static void ir_print_error_return_trace(IrPrintSrc irp, IrInstSrcErrorReturnTrace instruction) {
	2385	fprintf(irp->f, "@errorReturnTrace(");
	2386	switch (instruction->optional) {
	2387	case IrInstErrorReturnTraceNull:
	2388	fprintf(irp->f, "Null");
	2389	break;
	2390	case IrInstErrorReturnTraceNonNull:
	2391	fprintf(irp->f, "NonNull");
	2392	break;
	2393	}
1907	2394	fprintf(irp->f, ")");
1908	2395	}
1909	2396
1910		static void ir_print_error_return_trace(IrPrint irp, IrInstructionErrorReturnTrace instruction) {
	2397	static void ir_print_error_return_trace(IrPrintGen irp, IrInstGenErrorReturnTrace instruction) {
1911	2398	fprintf(irp->f, "@errorReturnTrace(");
1912	2399	switch (instruction->optional) {
1913		case IrInstructionErrorReturnTrace::Null:
	2400	case IrInstErrorReturnTraceNull:
1914	2401	fprintf(irp->f, "Null");
1915	2402	break;
1916		case IrInstructionErrorReturnTrace::NonNull:
	2403	case IrInstErrorReturnTraceNonNull:
1917	2404	fprintf(irp->f, "NonNull");
1918	2405	break;
1919	2406	}
1920	2407	fprintf(irp->f, ")");
1921	2408	}
1922	2409
1923		static void ir_print_error_union(IrPrint irp, IrInstructionErrorUnion instruction) {
1924		ir_print_other_instruction(irp, instruction->err_set);
	2410	static void ir_print_error_union(IrPrintSrc irp, IrInstSrcErrorUnion instruction) {
	2411	ir_print_other_inst_src(irp, instruction->err_set);
1925	2412	fprintf(irp->f, "!");
1926		ir_print_other_instruction(irp, instruction->payload);
	2413	ir_print_other_inst_src(irp, instruction->payload);
1927	2414	}
1928	2415
1929		static void ir_print_atomic_rmw(IrPrint irp, IrInstructionAtomicRmw instruction) {
	2416	static void ir_print_atomic_rmw(IrPrintSrc irp, IrInstSrcAtomicRmw instruction) {
1930	2417	fprintf(irp->f, "@atomicRmw(");
1931		if (instruction->operand_type != nullptr) {
1932		ir_print_other_instruction(irp, instruction->operand_type);
1933		} else {
1934		fprintf(irp->f, "[TODO print]");
1935		}
	2418	ir_print_other_inst_src(irp, instruction->operand_type);
1936	2419	fprintf(irp->f, ",");
1937		ir_print_other_instruction(irp, instruction->ptr);
	2420	ir_print_other_inst_src(irp, instruction->ptr);
1938	2421	fprintf(irp->f, ",");
1939		if (instruction->op != nullptr) {
1940		ir_print_other_instruction(irp, instruction->op);
1941		} else {
1942		fprintf(irp->f, "[TODO print]");
1943		}
	2422	ir_print_other_inst_src(irp, instruction->op);
1944	2423	fprintf(irp->f, ",");
1945		ir_print_other_instruction(irp, instruction->operand);
	2424	ir_print_other_inst_src(irp, instruction->operand);
1946	2425	fprintf(irp->f, ",");
1947		if (instruction->ordering != nullptr) {
1948		ir_print_other_instruction(irp, instruction->ordering);
1949		} else {
1950		fprintf(irp->f, "[TODO print]");
1951		}
	2426	ir_print_other_inst_src(irp, instruction->ordering);
1952	2427	fprintf(irp->f, ")");
1953	2428	}
1954	2429
1955		static void ir_print_atomic_load(IrPrint irp, IrInstructionAtomicLoad instruction) {
	2430	static void ir_print_atomic_rmw(IrPrintGen irp, IrInstGenAtomicRmw instruction) {
	2431	fprintf(irp->f, "@atomicRmw(");
	2432	ir_print_other_inst_gen(irp, instruction->ptr);
	2433	fprintf(irp->f, ",[TODO print op],");
	2434	ir_print_other_inst_gen(irp, instruction->operand);
	2435	fprintf(irp->f, ",%s)", atomic_order_str(instruction->ordering));
	2436	}
	2437
	2438	static void ir_print_atomic_load(IrPrintSrc irp, IrInstSrcAtomicLoad instruction) {
1956	2439	fprintf(irp->f, "@atomicLoad(");
1957		if (instruction->operand_type != nullptr) {
1958		ir_print_other_instruction(irp, instruction->operand_type);
1959		} else {
1960		fprintf(irp->f, "[TODO print]");
1961		}
	2440	ir_print_other_inst_src(irp, instruction->operand_type);
1962	2441	fprintf(irp->f, ",");
1963		ir_print_other_instruction(irp, instruction->ptr);
	2442	ir_print_other_inst_src(irp, instruction->ptr);
1964	2443	fprintf(irp->f, ",");
1965		if (instruction->ordering != nullptr) {
1966		ir_print_other_instruction(irp, instruction->ordering);
1967		} else {
1968		fprintf(irp->f, "[TODO print]");
1969		}
	2444	ir_print_other_inst_src(irp, instruction->ordering);
1970	2445	fprintf(irp->f, ")");
1971	2446	}
1972	2447
1973		static void ir_print_atomic_store(IrPrint irp, IrInstructionAtomicStore instruction) {
	2448	static void ir_print_atomic_load(IrPrintGen irp, IrInstGenAtomicLoad instruction) {
	2449	fprintf(irp->f, "@atomicLoad(");
	2450	ir_print_other_inst_gen(irp, instruction->ptr);
	2451	fprintf(irp->f, ",%s)", atomic_order_str(instruction->ordering));
	2452	}
	2453
	2454	static void ir_print_atomic_store(IrPrintSrc irp, IrInstSrcAtomicStore instruction) {
1974	2455	fprintf(irp->f, "@atomicStore(");
1975		if (instruction->operand_type != nullptr) {
1976		ir_print_other_instruction(irp, instruction->operand_type);
1977		} else {
1978		fprintf(irp->f, "[TODO print]");
1979		}
	2456	ir_print_other_inst_src(irp, instruction->operand_type);
1980	2457	fprintf(irp->f, ",");
1981		ir_print_other_instruction(irp, instruction->ptr);
	2458	ir_print_other_inst_src(irp, instruction->ptr);
1982	2459	fprintf(irp->f, ",");
1983		ir_print_other_instruction(irp, instruction->value);
	2460	ir_print_other_inst_src(irp, instruction->value);
1984	2461	fprintf(irp->f, ",");
1985		if (instruction->ordering != nullptr) {
1986		ir_print_other_instruction(irp, instruction->ordering);
1987		} else {
1988		fprintf(irp->f, "[TODO print]");
1989		}
	2462	ir_print_other_inst_src(irp, instruction->ordering);
1990	2463	fprintf(irp->f, ")");
1991	2464	}
1992	2465
	2466	static void ir_print_atomic_store(IrPrintGen irp, IrInstGenAtomicStore instruction) {
	2467	fprintf(irp->f, "@atomicStore(");
	2468	ir_print_other_inst_gen(irp, instruction->ptr);
	2469	fprintf(irp->f, ",");
	2470	ir_print_other_inst_gen(irp, instruction->value);
	2471	fprintf(irp->f, ",%s)", atomic_order_str(instruction->ordering));
	2472	}
	2473
	2474
	2475	static void ir_print_save_err_ret_addr(IrPrintSrc irp, IrInstSrcSaveErrRetAddr instruction) {
	2476	fprintf(irp->f, "@saveErrRetAddr()");
	2477	}
1993	2478
1994		static void ir_print_save_err_ret_addr(IrPrint irp, IrInstructionSaveErrRetAddr instruction) {
	2479	static void ir_print_save_err_ret_addr(IrPrintGen irp, IrInstGenSaveErrRetAddr instruction) {
1995	2480	fprintf(irp->f, "@saveErrRetAddr()");
1996	2481	}
1997	2482
1998		static void ir_print_add_implicit_return_type(IrPrint irp, IrInstructionAddImplicitReturnType instruction) {
	2483	static void ir_print_add_implicit_return_type(IrPrintSrc irp, IrInstSrcAddImplicitReturnType instruction) {
1999	2484	fprintf(irp->f, "@addImplicitReturnType(");
2000		ir_print_other_instruction(irp, instruction->value);
	2485	ir_print_other_inst_src(irp, instruction->value);
	2486	fprintf(irp->f, ")");
	2487	}
	2488
	2489	static void ir_print_float_op(IrPrintSrc irp, IrInstSrcFloatOp instruction) {
	2490	fprintf(irp->f, "@%s(", float_op_to_name(instruction->fn_id));
	2491	ir_print_other_inst_src(irp, instruction->operand);
2001	2492	fprintf(irp->f, ")");
2002	2493	}
2003	2494
2004		static void ir_print_float_op(IrPrint irp, IrInstructionFloatOp instruction) {
	2495	static void ir_print_float_op(IrPrintGen irp, IrInstGenFloatOp instruction) {
2005	2496	fprintf(irp->f, "@%s(", float_op_to_name(instruction->fn_id));
2006		ir_print_other_instruction(irp, instruction->operand);
	2497	ir_print_other_inst_gen(irp, instruction->operand);
2007	2498	fprintf(irp->f, ")");
2008	2499	}
2009	2500
2010		static void ir_print_mul_add(IrPrint irp, IrInstructionMulAdd instruction) {
	2501	static void ir_print_mul_add(IrPrintSrc irp, IrInstSrcMulAdd instruction) {
2011	2502	fprintf(irp->f, "@mulAdd(");
2012		if (instruction->type_value != nullptr) {
2013		ir_print_other_instruction(irp, instruction->type_value);
2014		} else {
2015		fprintf(irp->f, "null");
2016		}
	2503	ir_print_other_inst_src(irp, instruction->type_value);
2017	2504	fprintf(irp->f, ",");
2018		ir_print_other_instruction(irp, instruction->op1);
	2505	ir_print_other_inst_src(irp, instruction->op1);
2019	2506	fprintf(irp->f, ",");
2020		ir_print_other_instruction(irp, instruction->op2);
	2507	ir_print_other_inst_src(irp, instruction->op2);
2021	2508	fprintf(irp->f, ",");
2022		ir_print_other_instruction(irp, instruction->op3);
	2509	ir_print_other_inst_src(irp, instruction->op3);
2023	2510	fprintf(irp->f, ")");
2024	2511	}
2025	2512
2026		static void ir_print_decl_var_gen(IrPrint irp, IrInstructionDeclVarGen decl_var_instruction) {
	2513	static void ir_print_mul_add(IrPrintGen irp, IrInstGenMulAdd instruction) {
	2514	fprintf(irp->f, "@mulAdd(");
	2515	ir_print_other_inst_gen(irp, instruction->op1);
	2516	fprintf(irp->f, ",");
	2517	ir_print_other_inst_gen(irp, instruction->op2);
	2518	fprintf(irp->f, ",");
	2519	ir_print_other_inst_gen(irp, instruction->op3);
	2520	fprintf(irp->f, ")");
	2521	}
	2522
	2523	static void ir_print_decl_var_gen(IrPrintGen irp, IrInstGenDeclVar decl_var_instruction) {
2027	2524	ZigVar *var = decl_var_instruction->var;
2028	2525	const char *var_or_const = decl_var_instruction->var->gen_is_const ? "const" : "var";
2029	2526	const char *name = decl_var_instruction->var->name;
2030	2527	fprintf(irp->f, "%s %s: %s align(%u) = ", var_or_const, name, buf_ptr(&var->var_type->name),
2031	2528	var->align_bytes);
2032	2529
2033		ir_print_other_instruction(irp, decl_var_instruction->var_ptr);
2034		if (decl_var_instruction->var->is_comptime != nullptr) {
2035		fprintf(irp->f, " // comptime = ");
2036		ir_print_other_instruction(irp, decl_var_instruction->var->is_comptime);
2037		}
	2530	ir_print_other_inst_gen(irp, decl_var_instruction->var_ptr);
2038	2531	}
2039	2532
2040		static void ir_print_has_decl(IrPrint irp, IrInstructionHasDecl instruction) {
	2533	static void ir_print_has_decl(IrPrintSrc irp, IrInstSrcHasDecl instruction) {
2041	2534	fprintf(irp->f, "@hasDecl(");
2042		ir_print_other_instruction(irp, instruction->container);
	2535	ir_print_other_inst_src(irp, instruction->container);
2043	2536	fprintf(irp->f, ",");
2044		ir_print_other_instruction(irp, instruction->name);
	2537	ir_print_other_inst_src(irp, instruction->name);
2045	2538	fprintf(irp->f, ")");
2046	2539	}
2047	2540
2048		static void ir_print_undeclared_ident(IrPrint irp, IrInstructionUndeclaredIdent instruction) {
	2541	static void ir_print_undeclared_ident(IrPrintSrc irp, IrInstSrcUndeclaredIdent instruction) {
2049	2542	fprintf(irp->f, "@undeclaredIdent(%s)", buf_ptr(instruction->name));
2050	2543	}
2051	2544
2052		static void ir_print_union_init_named_field(IrPrint irp, IrInstructionUnionInitNamedField instruction) {
	2545	static void ir_print_union_init_named_field(IrPrintSrc irp, IrInstSrcUnionInitNamedField instruction) {
2053	2546	fprintf(irp->f, "@unionInit(");
2054		ir_print_other_instruction(irp, instruction->union_type);
	2547	ir_print_other_inst_src(irp, instruction->union_type);
2055	2548	fprintf(irp->f, ", ");
2056		ir_print_other_instruction(irp, instruction->field_name);
	2549	ir_print_other_inst_src(irp, instruction->field_name);
2057	2550	fprintf(irp->f, ", ");
2058		ir_print_other_instruction(irp, instruction->field_result_loc);
	2551	ir_print_other_inst_src(irp, instruction->field_result_loc);
2059	2552	fprintf(irp->f, ", ");
2060		ir_print_other_instruction(irp, instruction->result_loc);
	2553	ir_print_other_inst_src(irp, instruction->result_loc);
2061	2554	fprintf(irp->f, ")");
2062	2555	}
2063	2556
2064		static void ir_print_suspend_begin(IrPrint irp, IrInstructionSuspendBegin instruction) {
	2557	static void ir_print_suspend_begin(IrPrintSrc irp, IrInstSrcSuspendBegin instruction) {
	2558	fprintf(irp->f, "@suspendBegin()");
	2559	}
	2560
	2561	static void ir_print_suspend_begin(IrPrintGen irp, IrInstGenSuspendBegin instruction) {
2065	2562	fprintf(irp->f, "@suspendBegin()");
2066	2563	}
2067	2564
2068		static void ir_print_suspend_finish(IrPrint irp, IrInstructionSuspendFinish instruction) {
	2565	static void ir_print_suspend_finish(IrPrintSrc irp, IrInstSrcSuspendFinish instruction) {
	2566	fprintf(irp->f, "@suspendFinish()");
	2567	}
	2568
	2569	static void ir_print_suspend_finish(IrPrintGen irp, IrInstGenSuspendFinish instruction) {
2069	2570	fprintf(irp->f, "@suspendFinish()");
2070	2571	}
2071	2572
2072		static void ir_print_resume(IrPrint irp, IrInstructionResume instruction) {
	2573	static void ir_print_resume(IrPrintSrc irp, IrInstSrcResume instruction) {
2073	2574	fprintf(irp->f, "resume ");
2074		ir_print_other_instruction(irp, instruction->frame);
	2575	ir_print_other_inst_src(irp, instruction->frame);
2075	2576	}
2076	2577
2077		static void ir_print_await_src(IrPrint irp, IrInstructionAwaitSrc instruction) {
	2578	static void ir_print_resume(IrPrintGen irp, IrInstGenResume instruction) {
	2579	fprintf(irp->f, "resume ");
	2580	ir_print_other_inst_gen(irp, instruction->frame);
	2581	}
	2582
	2583	static void ir_print_await_src(IrPrintSrc irp, IrInstSrcAwait instruction) {
2078	2584	fprintf(irp->f, "@await(");
2079		ir_print_other_instruction(irp, instruction->frame);
	2585	ir_print_other_inst_src(irp, instruction->frame);
2080	2586	fprintf(irp->f, ",");
2081	2587	ir_print_result_loc(irp, instruction->result_loc);
2082	2588	fprintf(irp->f, ")");
2083	2589	}
2084	2590
2085		static void ir_print_await_gen(IrPrint irp, IrInstructionAwaitGen instruction) {
	2591	static void ir_print_await_gen(IrPrintGen irp, IrInstGenAwait instruction) {
2086	2592	fprintf(irp->f, "@await(");
2087		ir_print_other_instruction(irp, instruction->frame);
	2593	ir_print_other_inst_gen(irp, instruction->frame);
2088	2594	fprintf(irp->f, ",");
2089		ir_print_other_instruction(irp, instruction->result_loc);
	2595	ir_print_other_inst_gen(irp, instruction->result_loc);
	2596	fprintf(irp->f, ")");
	2597	}
	2598
	2599	static void ir_print_spill_begin(IrPrintSrc irp, IrInstSrcSpillBegin instruction) {
	2600	fprintf(irp->f, "@spillBegin(");
	2601	ir_print_other_inst_src(irp, instruction->operand);
2090	2602	fprintf(irp->f, ")");
2091	2603	}
2092	2604
2093		static void ir_print_spill_begin(IrPrint irp, IrInstructionSpillBegin instruction) {
	2605	static void ir_print_spill_begin(IrPrintGen irp, IrInstGenSpillBegin instruction) {
2094	2606	fprintf(irp->f, "@spillBegin(");
2095		ir_print_other_instruction(irp, instruction->operand);
	2607	ir_print_other_inst_gen(irp, instruction->operand);
2096	2608	fprintf(irp->f, ")");
2097	2609	}
2098	2610
2099		static void ir_print_spill_end(IrPrint irp, IrInstructionSpillEnd instruction) {
	2611	static void ir_print_spill_end(IrPrintSrc irp, IrInstSrcSpillEnd instruction) {
2100	2612	fprintf(irp->f, "@spillEnd(");
2101		ir_print_other_instruction(irp, &instruction->begin->base);
	2613	ir_print_other_inst_src(irp, &instruction->begin->base);
2102	2614	fprintf(irp->f, ")");
2103	2615	}
2104	2616
2105		static void ir_print_vector_extract_elem(IrPrint irp, IrInstructionVectorExtractElem instruction) {
	2617	static void ir_print_spill_end(IrPrintGen irp, IrInstGenSpillEnd instruction) {
	2618	fprintf(irp->f, "@spillEnd(");
	2619	ir_print_other_inst_gen(irp, &instruction->begin->base);
	2620	fprintf(irp->f, ")");
	2621	}
	2622
	2623	static void ir_print_vector_extract_elem(IrPrintGen irp, IrInstGenVectorExtractElem instruction) {
2106	2624	fprintf(irp->f, "@vectorExtractElem(");
2107		ir_print_other_instruction(irp, instruction->vector);
	2625	ir_print_other_inst_gen(irp, instruction->vector);
2108	2626	fprintf(irp->f, ",");
2109		ir_print_other_instruction(irp, instruction->index);
	2627	ir_print_other_inst_gen(irp, instruction->index);
2110	2628	fprintf(irp->f, ")");
2111	2629	}
2112	2630
2113		static void ir_print_instruction(IrPrint irp, IrInstruction instruction, bool trailing) {
2114		ir_print_prefix(irp, instruction, trailing);
	2631	static void ir_print_inst_src(IrPrintSrc irp, IrInstSrc instruction, bool trailing) {
	2632	ir_print_prefix_src(irp, instruction, trailing);
2115	2633	switch (instruction->id) {
2116		case IrInstructionIdInvalid:
	2634	case IrInstSrcIdInvalid:
2117	2635	zig_unreachable();
2118		case IrInstructionIdReturn:
2119		ir_print_return(irp, (IrInstructionReturn *)instruction);
	2636	case IrInstSrcIdReturn:
	2637	ir_print_return_src(irp, (IrInstSrcReturn *)instruction);
	2638	break;
	2639	case IrInstSrcIdConst:
	2640	ir_print_const(irp, (IrInstSrcConst *)instruction);
	2641	break;
	2642	case IrInstSrcIdBinOp:
	2643	ir_print_bin_op(irp, (IrInstSrcBinOp *)instruction);
	2644	break;
	2645	case IrInstSrcIdMergeErrSets:
	2646	ir_print_merge_err_sets(irp, (IrInstSrcMergeErrSets *)instruction);
	2647	break;
	2648	case IrInstSrcIdDeclVar:
	2649	ir_print_decl_var_src(irp, (IrInstSrcDeclVar *)instruction);
	2650	break;
	2651	case IrInstSrcIdCallExtra:
	2652	ir_print_call_extra(irp, (IrInstSrcCallExtra *)instruction);
	2653	break;
	2654	case IrInstSrcIdCall:
	2655	ir_print_call_src(irp, (IrInstSrcCall *)instruction);
	2656	break;
	2657	case IrInstSrcIdCallArgs:
	2658	ir_print_call_args(irp, (IrInstSrcCallArgs *)instruction);
	2659	break;
	2660	case IrInstSrcIdUnOp:
	2661	ir_print_un_op(irp, (IrInstSrcUnOp *)instruction);
	2662	break;
	2663	case IrInstSrcIdCondBr:
	2664	ir_print_cond_br(irp, (IrInstSrcCondBr *)instruction);
2120	2665	break;
2121		case IrInstructionIdConst:
2122		ir_print_const(irp, (IrInstructionConst *)instruction);
	2666	case IrInstSrcIdBr:
	2667	ir_print_br(irp, (IrInstSrcBr *)instruction);
2123	2668	break;
2124		case IrInstructionIdBinOp:
2125		ir_print_bin_op(irp, (IrInstructionBinOp *)instruction);
	2669	case IrInstSrcIdPhi:
	2670	ir_print_phi(irp, (IrInstSrcPhi *)instruction);
2126	2671	break;
2127		case IrInstructionIdMergeErrSets:
2128		ir_print_merge_err_sets(irp, (IrInstructionMergeErrSets *)instruction);
	2672	case IrInstSrcIdContainerInitList:
	2673	ir_print_container_init_list(irp, (IrInstSrcContainerInitList *)instruction);
2129	2674	break;
2130		case IrInstructionIdDeclVarSrc:
2131		ir_print_decl_var_src(irp, (IrInstructionDeclVarSrc *)instruction);
	2675	case IrInstSrcIdContainerInitFields:
	2676	ir_print_container_init_fields(irp, (IrInstSrcContainerInitFields *)instruction);
2132	2677	break;
2133		case IrInstructionIdCast:
2134		ir_print_cast(irp, (IrInstructionCast *)instruction);
	2678	case IrInstSrcIdUnreachable:
	2679	ir_print_unreachable(irp, (IrInstSrcUnreachable *)instruction);
2135	2680	break;
2136		case IrInstructionIdCallExtra:
2137		ir_print_call_extra(irp, (IrInstructionCallExtra *)instruction);
	2681	case IrInstSrcIdElemPtr:
	2682	ir_print_elem_ptr(irp, (IrInstSrcElemPtr *)instruction);
2138	2683	break;
2139		case IrInstructionIdCallSrc:
2140		ir_print_call_src(irp, (IrInstructionCallSrc *)instruction);
	2684	case IrInstSrcIdVarPtr:
	2685	ir_print_var_ptr(irp, (IrInstSrcVarPtr *)instruction);
2141	2686	break;
2142		case IrInstructionIdCallSrcArgs:
2143		ir_print_call_src_args(irp, (IrInstructionCallSrcArgs *)instruction);
	2687	case IrInstSrcIdLoadPtr:
	2688	ir_print_load_ptr(irp, (IrInstSrcLoadPtr *)instruction);
2144	2689	break;
2145		case IrInstructionIdCallGen:
2146		ir_print_call_gen(irp, (IrInstructionCallGen *)instruction);
	2690	case IrInstSrcIdStorePtr:
	2691	ir_print_store_ptr(irp, (IrInstSrcStorePtr *)instruction);
2147	2692	break;
2148		case IrInstructionIdUnOp:
2149		ir_print_un_op(irp, (IrInstructionUnOp *)instruction);
	2693	case IrInstSrcIdTypeOf:
	2694	ir_print_typeof(irp, (IrInstSrcTypeOf *)instruction);
2150	2695	break;
2151		case IrInstructionIdCondBr:
2152		ir_print_cond_br(irp, (IrInstructionCondBr *)instruction);
	2696	case IrInstSrcIdFieldPtr:
	2697	ir_print_field_ptr(irp, (IrInstSrcFieldPtr *)instruction);
2153	2698	break;
2154		case IrInstructionIdBr:
2155		ir_print_br(irp, (IrInstructionBr *)instruction);
	2699	case IrInstSrcIdSetCold:
	2700	ir_print_set_cold(irp, (IrInstSrcSetCold *)instruction);
2156	2701	break;
2157		case IrInstructionIdPhi:
2158		ir_print_phi(irp, (IrInstructionPhi *)instruction);
	2702	case IrInstSrcIdSetRuntimeSafety:
	2703	ir_print_set_runtime_safety(irp, (IrInstSrcSetRuntimeSafety *)instruction);
2159	2704	break;
2160		case IrInstructionIdContainerInitList:
2161		ir_print_container_init_list(irp, (IrInstructionContainerInitList *)instruction);
	2705	case IrInstSrcIdSetFloatMode:
	2706	ir_print_set_float_mode(irp, (IrInstSrcSetFloatMode *)instruction);
2162	2707	break;
2163		case IrInstructionIdContainerInitFields:
2164		ir_print_container_init_fields(irp, (IrInstructionContainerInitFields *)instruction);
	2708	case IrInstSrcIdArrayType:
	2709	ir_print_array_type(irp, (IrInstSrcArrayType *)instruction);
2165	2710	break;
2166		case IrInstructionIdUnreachable:
2167		ir_print_unreachable(irp, (IrInstructionUnreachable *)instruction);
	2711	case IrInstSrcIdSliceType:
	2712	ir_print_slice_type(irp, (IrInstSrcSliceType *)instruction);
2168	2713	break;
2169		case IrInstructionIdElemPtr:
2170		ir_print_elem_ptr(irp, (IrInstructionElemPtr *)instruction);
	2714	case IrInstSrcIdAnyFrameType:
	2715	ir_print_any_frame_type(irp, (IrInstSrcAnyFrameType *)instruction);
2171	2716	break;
2172		case IrInstructionIdVarPtr:
2173		ir_print_var_ptr(irp, (IrInstructionVarPtr *)instruction);
	2717	case IrInstSrcIdAsm:
	2718	ir_print_asm_src(irp, (IrInstSrcAsm *)instruction);
2174	2719	break;
2175		case IrInstructionIdReturnPtr:
2176		ir_print_return_ptr(irp, (IrInstructionReturnPtr *)instruction);
	2720	case IrInstSrcIdSizeOf:
	2721	ir_print_size_of(irp, (IrInstSrcSizeOf *)instruction);
2177	2722	break;
2178		case IrInstructionIdLoadPtr:
2179		ir_print_load_ptr(irp, (IrInstructionLoadPtr *)instruction);
	2723	case IrInstSrcIdTestNonNull:
	2724	ir_print_test_non_null(irp, (IrInstSrcTestNonNull *)instruction);
2180	2725	break;
2181		case IrInstructionIdLoadPtrGen:
2182		ir_print_load_ptr_gen(irp, (IrInstructionLoadPtrGen *)instruction);
	2726	case IrInstSrcIdOptionalUnwrapPtr:
	2727	ir_print_optional_unwrap_ptr(irp, (IrInstSrcOptionalUnwrapPtr *)instruction);
2183	2728	break;
2184		case IrInstructionIdStorePtr:
2185		ir_print_store_ptr(irp, (IrInstructionStorePtr *)instruction);
	2729	case IrInstSrcIdPopCount:
	2730	ir_print_pop_count(irp, (IrInstSrcPopCount *)instruction);
2186	2731	break;
2187		case IrInstructionIdVectorStoreElem:
2188		ir_print_vector_store_elem(irp, (IrInstructionVectorStoreElem *)instruction);
	2732	case IrInstSrcIdCtz:
	2733	ir_print_ctz(irp, (IrInstSrcCtz *)instruction);
2189	2734	break;
2190		case IrInstructionIdTypeOf:
2191		ir_print_typeof(irp, (IrInstructionTypeOf *)instruction);
	2735	case IrInstSrcIdBswap:
	2736	ir_print_bswap(irp, (IrInstSrcBswap *)instruction);
2192	2737	break;
2193		case IrInstructionIdFieldPtr:
2194		ir_print_field_ptr(irp, (IrInstructionFieldPtr *)instruction);
	2738	case IrInstSrcIdBitReverse:
	2739	ir_print_bit_reverse(irp, (IrInstSrcBitReverse *)instruction);
2195	2740	break;
2196		case IrInstructionIdStructFieldPtr:
2197		ir_print_struct_field_ptr(irp, (IrInstructionStructFieldPtr *)instruction);
	2741	case IrInstSrcIdSwitchBr:
	2742	ir_print_switch_br(irp, (IrInstSrcSwitchBr *)instruction);
2198	2743	break;
2199		case IrInstructionIdUnionFieldPtr:
2200		ir_print_union_field_ptr(irp, (IrInstructionUnionFieldPtr *)instruction);
	2744	case IrInstSrcIdSwitchVar:
	2745	ir_print_switch_var(irp, (IrInstSrcSwitchVar *)instruction);
2201	2746	break;
2202		case IrInstructionIdSetCold:
2203		ir_print_set_cold(irp, (IrInstructionSetCold *)instruction);
	2747	case IrInstSrcIdSwitchElseVar:
	2748	ir_print_switch_else_var(irp, (IrInstSrcSwitchElseVar *)instruction);
2204	2749	break;
2205		case IrInstructionIdSetRuntimeSafety:
2206		ir_print_set_runtime_safety(irp, (IrInstructionSetRuntimeSafety *)instruction);
	2750	case IrInstSrcIdSwitchTarget:
	2751	ir_print_switch_target(irp, (IrInstSrcSwitchTarget *)instruction);
2207	2752	break;
2208		case IrInstructionIdSetFloatMode:
2209		ir_print_set_float_mode(irp, (IrInstructionSetFloatMode *)instruction);
	2753	case IrInstSrcIdImport:
	2754	ir_print_import(irp, (IrInstSrcImport *)instruction);
2210	2755	break;
2211		case IrInstructionIdArrayType:
2212		ir_print_array_type(irp, (IrInstructionArrayType *)instruction);
	2756	case IrInstSrcIdRef:
	2757	ir_print_ref(irp, (IrInstSrcRef *)instruction);
2213	2758	break;
2214		case IrInstructionIdSliceType:
2215		ir_print_slice_type(irp, (IrInstructionSliceType *)instruction);
	2759	case IrInstSrcIdCompileErr:
	2760	ir_print_compile_err(irp, (IrInstSrcCompileErr *)instruction);
2216	2761	break;
2217		case IrInstructionIdAnyFrameType:
2218		ir_print_any_frame_type(irp, (IrInstructionAnyFrameType *)instruction);
	2762	case IrInstSrcIdCompileLog:
	2763	ir_print_compile_log(irp, (IrInstSrcCompileLog *)instruction);
2219	2764	break;
2220		case IrInstructionIdAsmSrc:
2221		ir_print_asm_src(irp, (IrInstructionAsmSrc *)instruction);
	2765	case IrInstSrcIdErrName:
	2766	ir_print_err_name(irp, (IrInstSrcErrName *)instruction);
2222	2767	break;
2223		case IrInstructionIdAsmGen:
2224		ir_print_asm_gen(irp, (IrInstructionAsmGen *)instruction);
	2768	case IrInstSrcIdCImport:
	2769	ir_print_c_import(irp, (IrInstSrcCImport *)instruction);
2225	2770	break;
2226		case IrInstructionIdSizeOf:
2227		ir_print_size_of(irp, (IrInstructionSizeOf *)instruction);
	2771	case IrInstSrcIdCInclude:
	2772	ir_print_c_include(irp, (IrInstSrcCInclude *)instruction);
2228	2773	break;
2229		case IrInstructionIdTestNonNull:
2230		ir_print_test_non_null(irp, (IrInstructionTestNonNull *)instruction);
	2774	case IrInstSrcIdCDefine:
	2775	ir_print_c_define(irp, (IrInstSrcCDefine *)instruction);
2231	2776	break;
2232		case IrInstructionIdOptionalUnwrapPtr:
2233		ir_print_optional_unwrap_ptr(irp, (IrInstructionOptionalUnwrapPtr *)instruction);
	2777	case IrInstSrcIdCUndef:
	2778	ir_print_c_undef(irp, (IrInstSrcCUndef *)instruction);
2234	2779	break;
2235		case IrInstructionIdPopCount:
2236		ir_print_pop_count(irp, (IrInstructionPopCount *)instruction);
	2780	case IrInstSrcIdEmbedFile:
	2781	ir_print_embed_file(irp, (IrInstSrcEmbedFile *)instruction);
2237	2782	break;
2238		case IrInstructionIdClz:
2239		ir_print_clz(irp, (IrInstructionClz *)instruction);
	2783	case IrInstSrcIdCmpxchg:
	2784	ir_print_cmpxchg_src(irp, (IrInstSrcCmpxchg *)instruction);
2240	2785	break;
2241		case IrInstructionIdCtz:
2242		ir_print_ctz(irp, (IrInstructionCtz *)instruction);
	2786	case IrInstSrcIdFence:
	2787	ir_print_fence(irp, (IrInstSrcFence *)instruction);
2243	2788	break;
2244		case IrInstructionIdBswap:
2245		ir_print_bswap(irp, (IrInstructionBswap *)instruction);
	2789	case IrInstSrcIdTruncate:
	2790	ir_print_truncate(irp, (IrInstSrcTruncate *)instruction);
2246	2791	break;
2247		case IrInstructionIdBitReverse:
2248		ir_print_bit_reverse(irp, (IrInstructionBitReverse *)instruction);
	2792	case IrInstSrcIdIntCast:
	2793	ir_print_int_cast(irp, (IrInstSrcIntCast *)instruction);
2249	2794	break;
2250		case IrInstructionIdSwitchBr:
2251		ir_print_switch_br(irp, (IrInstructionSwitchBr *)instruction);
	2795	case IrInstSrcIdFloatCast:
	2796	ir_print_float_cast(irp, (IrInstSrcFloatCast *)instruction);
2252	2797	break;
2253		case IrInstructionIdSwitchVar:
2254		ir_print_switch_var(irp, (IrInstructionSwitchVar *)instruction);
	2798	case IrInstSrcIdErrSetCast:
	2799	ir_print_err_set_cast(irp, (IrInstSrcErrSetCast *)instruction);
2255	2800	break;
2256		case IrInstructionIdSwitchElseVar:
2257		ir_print_switch_else_var(irp, (IrInstructionSwitchElseVar *)instruction);
	2801	case IrInstSrcIdFromBytes:
	2802	ir_print_from_bytes(irp, (IrInstSrcFromBytes *)instruction);
2258	2803	break;
2259		case IrInstructionIdSwitchTarget:
2260		ir_print_switch_target(irp, (IrInstructionSwitchTarget *)instruction);
	2804	case IrInstSrcIdToBytes:
	2805	ir_print_to_bytes(irp, (IrInstSrcToBytes *)instruction);
2261	2806	break;
2262		case IrInstructionIdUnionTag:
2263		ir_print_union_tag(irp, (IrInstructionUnionTag *)instruction);
	2807	case IrInstSrcIdIntToFloat:
	2808	ir_print_int_to_float(irp, (IrInstSrcIntToFloat *)instruction);
2264	2809	break;
2265		case IrInstructionIdImport:
2266		ir_print_import(irp, (IrInstructionImport *)instruction);
	2810	case IrInstSrcIdFloatToInt:
	2811	ir_print_float_to_int(irp, (IrInstSrcFloatToInt *)instruction);
2267	2812	break;
2268		case IrInstructionIdRef:
2269		ir_print_ref(irp, (IrInstructionRef *)instruction);
	2813	case IrInstSrcIdBoolToInt:
	2814	ir_print_bool_to_int(irp, (IrInstSrcBoolToInt *)instruction);
2270	2815	break;
2271		case IrInstructionIdRefGen:
2272		ir_print_ref_gen(irp, (IrInstructionRefGen *)instruction);
	2816	case IrInstSrcIdIntType:
	2817	ir_print_int_type(irp, (IrInstSrcIntType *)instruction);
2273	2818	break;
2274		case IrInstructionIdCompileErr:
2275		ir_print_compile_err(irp, (IrInstructionCompileErr *)instruction);
	2819	case IrInstSrcIdVectorType:
	2820	ir_print_vector_type(irp, (IrInstSrcVectorType *)instruction);
2276	2821	break;
2277		case IrInstructionIdCompileLog:
2278		ir_print_compile_log(irp, (IrInstructionCompileLog *)instruction);
	2822	case IrInstSrcIdShuffleVector:
	2823	ir_print_shuffle_vector(irp, (IrInstSrcShuffleVector *)instruction);
2279	2824	break;
2280		case IrInstructionIdErrName:
2281		ir_print_err_name(irp, (IrInstructionErrName *)instruction);
	2825	case IrInstSrcIdSplat:
	2826	ir_print_splat_src(irp, (IrInstSrcSplat *)instruction);
2282	2827	break;
2283		case IrInstructionIdCImport:
2284		ir_print_c_import(irp, (IrInstructionCImport *)instruction);
	2828	case IrInstSrcIdBoolNot:
	2829	ir_print_bool_not(irp, (IrInstSrcBoolNot *)instruction);
2285	2830	break;
2286		case IrInstructionIdCInclude:
2287		ir_print_c_include(irp, (IrInstructionCInclude *)instruction);
	2831	case IrInstSrcIdMemset:
	2832	ir_print_memset(irp, (IrInstSrcMemset *)instruction);
2288	2833	break;
2289		case IrInstructionIdCDefine:
2290		ir_print_c_define(irp, (IrInstructionCDefine *)instruction);
	2834	case IrInstSrcIdMemcpy:
	2835	ir_print_memcpy(irp, (IrInstSrcMemcpy *)instruction);
2291	2836	break;
2292		case IrInstructionIdCUndef:
2293		ir_print_c_undef(irp, (IrInstructionCUndef *)instruction);
	2837	case IrInstSrcIdSlice:
	2838	ir_print_slice_src(irp, (IrInstSrcSlice *)instruction);
2294	2839	break;
2295		case IrInstructionIdEmbedFile:
2296		ir_print_embed_file(irp, (IrInstructionEmbedFile *)instruction);
	2840	case IrInstSrcIdMemberCount:
	2841	ir_print_member_count(irp, (IrInstSrcMemberCount *)instruction);
2297	2842	break;
2298		case IrInstructionIdCmpxchgSrc:
2299		ir_print_cmpxchg_src(irp, (IrInstructionCmpxchgSrc *)instruction);
	2843	case IrInstSrcIdMemberType:
	2844	ir_print_member_type(irp, (IrInstSrcMemberType *)instruction);
2300	2845	break;
2301		case IrInstructionIdCmpxchgGen:
2302		ir_print_cmpxchg_gen(irp, (IrInstructionCmpxchgGen *)instruction);
	2846	case IrInstSrcIdMemberName:
	2847	ir_print_member_name(irp, (IrInstSrcMemberName *)instruction);
2303	2848	break;
2304		case IrInstructionIdFence:
2305		ir_print_fence(irp, (IrInstructionFence *)instruction);
	2849	case IrInstSrcIdBreakpoint:
	2850	ir_print_breakpoint(irp, (IrInstSrcBreakpoint *)instruction);
2306	2851	break;
2307		case IrInstructionIdTruncate:
2308		ir_print_truncate(irp, (IrInstructionTruncate *)instruction);
	2852	case IrInstSrcIdReturnAddress:
	2853	ir_print_return_address(irp, (IrInstSrcReturnAddress *)instruction);
2309	2854	break;
2310		case IrInstructionIdIntCast:
2311		ir_print_int_cast(irp, (IrInstructionIntCast *)instruction);
	2855	case IrInstSrcIdFrameAddress:
	2856	ir_print_frame_address(irp, (IrInstSrcFrameAddress *)instruction);
2312	2857	break;
2313		case IrInstructionIdFloatCast:
2314		ir_print_float_cast(irp, (IrInstructionFloatCast *)instruction);
	2858	case IrInstSrcIdFrameHandle:
	2859	ir_print_handle(irp, (IrInstSrcFrameHandle *)instruction);
2315	2860	break;
2316		case IrInstructionIdErrSetCast:
2317		ir_print_err_set_cast(irp, (IrInstructionErrSetCast *)instruction);
	2861	case IrInstSrcIdFrameType:
	2862	ir_print_frame_type(irp, (IrInstSrcFrameType *)instruction);
2318	2863	break;
2319		case IrInstructionIdFromBytes:
2320		ir_print_from_bytes(irp, (IrInstructionFromBytes *)instruction);
	2864	case IrInstSrcIdFrameSize:
	2865	ir_print_frame_size_src(irp, (IrInstSrcFrameSize *)instruction);
2321	2866	break;
2322		case IrInstructionIdToBytes:
2323		ir_print_to_bytes(irp, (IrInstructionToBytes *)instruction);
	2867	case IrInstSrcIdAlignOf:
	2868	ir_print_align_of(irp, (IrInstSrcAlignOf *)instruction);
2324	2869	break;
2325		case IrInstructionIdIntToFloat:
2326		ir_print_int_to_float(irp, (IrInstructionIntToFloat *)instruction);
	2870	case IrInstSrcIdOverflowOp:
	2871	ir_print_overflow_op(irp, (IrInstSrcOverflowOp *)instruction);
2327	2872	break;
2328		case IrInstructionIdFloatToInt:
2329		ir_print_float_to_int(irp, (IrInstructionFloatToInt *)instruction);
	2873	case IrInstSrcIdTestErr:
	2874	ir_print_test_err_src(irp, (IrInstSrcTestErr *)instruction);
2330	2875	break;
2331		case IrInstructionIdBoolToInt:
2332		ir_print_bool_to_int(irp, (IrInstructionBoolToInt *)instruction);
	2876	case IrInstSrcIdUnwrapErrCode:
	2877	ir_print_unwrap_err_code(irp, (IrInstSrcUnwrapErrCode *)instruction);
2333	2878	break;
2334		case IrInstructionIdIntType:
2335		ir_print_int_type(irp, (IrInstructionIntType *)instruction);
	2879	case IrInstSrcIdUnwrapErrPayload:
	2880	ir_print_unwrap_err_payload(irp, (IrInstSrcUnwrapErrPayload *)instruction);
2336	2881	break;
2337		case IrInstructionIdVectorType:
2338		ir_print_vector_type(irp, (IrInstructionVectorType *)instruction);
	2882	case IrInstSrcIdFnProto:
	2883	ir_print_fn_proto(irp, (IrInstSrcFnProto *)instruction);
2339	2884	break;
2340		case IrInstructionIdShuffleVector:
2341		ir_print_shuffle_vector(irp, (IrInstructionShuffleVector *)instruction);
	2885	case IrInstSrcIdTestComptime:
	2886	ir_print_test_comptime(irp, (IrInstSrcTestComptime *)instruction);
2342	2887	break;
2343		case IrInstructionIdSplatSrc:
2344		ir_print_splat_src(irp, (IrInstructionSplatSrc *)instruction);
	2888	case IrInstSrcIdPtrCast:
	2889	ir_print_ptr_cast_src(irp, (IrInstSrcPtrCast *)instruction);
2345	2890	break;
2346		case IrInstructionIdSplatGen:
2347		ir_print_splat_gen(irp, (IrInstructionSplatGen *)instruction);
	2891	case IrInstSrcIdBitCast:
	2892	ir_print_bit_cast_src(irp, (IrInstSrcBitCast *)instruction);
2348	2893	break;
2349		case IrInstructionIdBoolNot:
2350		ir_print_bool_not(irp, (IrInstructionBoolNot *)instruction);
	2894	case IrInstSrcIdPtrToInt:
	2895	ir_print_ptr_to_int(irp, (IrInstSrcPtrToInt *)instruction);
2351	2896	break;
2352		case IrInstructionIdMemset:
2353		ir_print_memset(irp, (IrInstructionMemset *)instruction);
	2897	case IrInstSrcIdIntToPtr:
	2898	ir_print_int_to_ptr(irp, (IrInstSrcIntToPtr *)instruction);
2354	2899	break;
2355		case IrInstructionIdMemcpy:
2356		ir_print_memcpy(irp, (IrInstructionMemcpy *)instruction);
	2900	case IrInstSrcIdIntToEnum:
	2901	ir_print_int_to_enum(irp, (IrInstSrcIntToEnum *)instruction);
2357	2902	break;
2358		case IrInstructionIdSliceSrc:
2359		ir_print_slice_src(irp, (IrInstructionSliceSrc *)instruction);
	2903	case IrInstSrcIdIntToErr:
	2904	ir_print_int_to_err(irp, (IrInstSrcIntToErr *)instruction);
2360	2905	break;
2361		case IrInstructionIdSliceGen:
2362		ir_print_slice_gen(irp, (IrInstructionSliceGen *)instruction);
	2906	case IrInstSrcIdErrToInt:
	2907	ir_print_err_to_int(irp, (IrInstSrcErrToInt *)instruction);
2363	2908	break;
2364		case IrInstructionIdMemberCount:
2365		ir_print_member_count(irp, (IrInstructionMemberCount *)instruction);
	2909	case IrInstSrcIdCheckSwitchProngs:
	2910	ir_print_check_switch_prongs(irp, (IrInstSrcCheckSwitchProngs *)instruction);
2366	2911	break;
2367		case IrInstructionIdMemberType:
2368		ir_print_member_type(irp, (IrInstructionMemberType *)instruction);
	2912	case IrInstSrcIdCheckStatementIsVoid:
	2913	ir_print_check_statement_is_void(irp, (IrInstSrcCheckStatementIsVoid *)instruction);
2369	2914	break;
2370		case IrInstructionIdMemberName:
2371		ir_print_member_name(irp, (IrInstructionMemberName *)instruction);
	2915	case IrInstSrcIdTypeName:
	2916	ir_print_type_name(irp, (IrInstSrcTypeName *)instruction);
2372	2917	break;
2373		case IrInstructionIdBreakpoint:
2374		ir_print_breakpoint(irp, (IrInstructionBreakpoint *)instruction);
	2918	case IrInstSrcIdTagName:
	2919	ir_print_tag_name(irp, (IrInstSrcTagName *)instruction);
2375	2920	break;
2376		case IrInstructionIdReturnAddress:
2377		ir_print_return_address(irp, (IrInstructionReturnAddress *)instruction);
	2921	case IrInstSrcIdPtrType:
	2922	ir_print_ptr_type(irp, (IrInstSrcPtrType *)instruction);
2378	2923	break;
2379		case IrInstructionIdFrameAddress:
2380		ir_print_frame_address(irp, (IrInstructionFrameAddress *)instruction);
	2924	case IrInstSrcIdDeclRef:
	2925	ir_print_decl_ref(irp, (IrInstSrcDeclRef *)instruction);
2381	2926	break;
2382		case IrInstructionIdFrameHandle:
2383		ir_print_handle(irp, (IrInstructionFrameHandle *)instruction);
	2927	case IrInstSrcIdPanic:
	2928	ir_print_panic(irp, (IrInstSrcPanic *)instruction);
2384	2929	break;
2385		case IrInstructionIdFrameType:
2386		ir_print_frame_type(irp, (IrInstructionFrameType *)instruction);
	2930	case IrInstSrcIdFieldParentPtr:
	2931	ir_print_field_parent_ptr(irp, (IrInstSrcFieldParentPtr *)instruction);
2387	2932	break;
2388		case IrInstructionIdFrameSizeSrc:
2389		ir_print_frame_size_src(irp, (IrInstructionFrameSizeSrc *)instruction);
	2933	case IrInstSrcIdByteOffsetOf:
	2934	ir_print_byte_offset_of(irp, (IrInstSrcByteOffsetOf *)instruction);
2390	2935	break;
2391		case IrInstructionIdFrameSizeGen:
2392		ir_print_frame_size_gen(irp, (IrInstructionFrameSizeGen *)instruction);
	2936	case IrInstSrcIdBitOffsetOf:
	2937	ir_print_bit_offset_of(irp, (IrInstSrcBitOffsetOf *)instruction);
2393	2938	break;
2394		case IrInstructionIdAlignOf:
2395		ir_print_align_of(irp, (IrInstructionAlignOf *)instruction);
	2939	case IrInstSrcIdTypeInfo:
	2940	ir_print_type_info(irp, (IrInstSrcTypeInfo *)instruction);
2396	2941	break;
2397		case IrInstructionIdOverflowOp:
2398		ir_print_overflow_op(irp, (IrInstructionOverflowOp *)instruction);
	2942	case IrInstSrcIdType:
	2943	ir_print_type(irp, (IrInstSrcType *)instruction);
2399	2944	break;
2400		case IrInstructionIdTestErrSrc:
2401		ir_print_test_err_src(irp, (IrInstructionTestErrSrc *)instruction);
	2945	case IrInstSrcIdHasField:
	2946	ir_print_has_field(irp, (IrInstSrcHasField *)instruction);
2402	2947	break;
2403		case IrInstructionIdTestErrGen:
2404		ir_print_test_err_gen(irp, (IrInstructionTestErrGen *)instruction);
	2948	case IrInstSrcIdTypeId:
	2949	ir_print_type_id(irp, (IrInstSrcTypeId *)instruction);
2405	2950	break;
2406		case IrInstructionIdUnwrapErrCode:
2407		ir_print_unwrap_err_code(irp, (IrInstructionUnwrapErrCode *)instruction);
	2951	case IrInstSrcIdSetEvalBranchQuota:
	2952	ir_print_set_eval_branch_quota(irp, (IrInstSrcSetEvalBranchQuota *)instruction);
2408	2953	break;
2409		case IrInstructionIdUnwrapErrPayload:
2410		ir_print_unwrap_err_payload(irp, (IrInstructionUnwrapErrPayload *)instruction);
	2954	case IrInstSrcIdAlignCast:
	2955	ir_print_align_cast(irp, (IrInstSrcAlignCast *)instruction);
2411	2956	break;
2412		case IrInstructionIdOptionalWrap:
2413		ir_print_optional_wrap(irp, (IrInstructionOptionalWrap *)instruction);
	2957	case IrInstSrcIdImplicitCast:
	2958	ir_print_implicit_cast(irp, (IrInstSrcImplicitCast *)instruction);
2414	2959	break;
2415		case IrInstructionIdErrWrapCode:
2416		ir_print_err_wrap_code(irp, (IrInstructionErrWrapCode *)instruction);
	2960	case IrInstSrcIdResolveResult:
	2961	ir_print_resolve_result(irp, (IrInstSrcResolveResult *)instruction);
2417	2962	break;
2418		case IrInstructionIdErrWrapPayload:
2419		ir_print_err_wrap_payload(irp, (IrInstructionErrWrapPayload *)instruction);
	2963	case IrInstSrcIdResetResult:
	2964	ir_print_reset_result(irp, (IrInstSrcResetResult *)instruction);
2420	2965	break;
2421		case IrInstructionIdFnProto:
2422		ir_print_fn_proto(irp, (IrInstructionFnProto *)instruction);
	2966	case IrInstSrcIdOpaqueType:
	2967	ir_print_opaque_type(irp, (IrInstSrcOpaqueType *)instruction);
2423	2968	break;
2424		case IrInstructionIdTestComptime:
2425		ir_print_test_comptime(irp, (IrInstructionTestComptime *)instruction);
	2969	case IrInstSrcIdSetAlignStack:
	2970	ir_print_set_align_stack(irp, (IrInstSrcSetAlignStack *)instruction);
2426	2971	break;
2427		case IrInstructionIdPtrCastSrc:
2428		ir_print_ptr_cast_src(irp, (IrInstructionPtrCastSrc *)instruction);
	2972	case IrInstSrcIdArgType:
	2973	ir_print_arg_type(irp, (IrInstSrcArgType *)instruction);
2429	2974	break;
2430		case IrInstructionIdPtrCastGen:
2431		ir_print_ptr_cast_gen(irp, (IrInstructionPtrCastGen *)instruction);
	2975	case IrInstSrcIdTagType:
	2976	ir_print_enum_tag_type(irp, (IrInstSrcTagType *)instruction);
2432	2977	break;
2433		case IrInstructionIdBitCastSrc:
2434		ir_print_bit_cast_src(irp, (IrInstructionBitCastSrc *)instruction);
	2978	case IrInstSrcIdExport:
	2979	ir_print_export(irp, (IrInstSrcExport *)instruction);
2435	2980	break;
2436		case IrInstructionIdBitCastGen:
2437		ir_print_bit_cast_gen(irp, (IrInstructionBitCastGen *)instruction);
	2981	case IrInstSrcIdErrorReturnTrace:
	2982	ir_print_error_return_trace(irp, (IrInstSrcErrorReturnTrace *)instruction);
2438	2983	break;
2439		case IrInstructionIdWidenOrShorten:
2440		ir_print_widen_or_shorten(irp, (IrInstructionWidenOrShorten *)instruction);
	2984	case IrInstSrcIdErrorUnion:
	2985	ir_print_error_union(irp, (IrInstSrcErrorUnion *)instruction);
2441	2986	break;
2442		case IrInstructionIdPtrToInt:
2443		ir_print_ptr_to_int(irp, (IrInstructionPtrToInt *)instruction);
	2987	case IrInstSrcIdAtomicRmw:
	2988	ir_print_atomic_rmw(irp, (IrInstSrcAtomicRmw *)instruction);
2444	2989	break;
2445		case IrInstructionIdIntToPtr:
2446		ir_print_int_to_ptr(irp, (IrInstructionIntToPtr *)instruction);
	2990	case IrInstSrcIdSaveErrRetAddr:
	2991	ir_print_save_err_ret_addr(irp, (IrInstSrcSaveErrRetAddr *)instruction);
	2992	break;
	2993	case IrInstSrcIdAddImplicitReturnType:
	2994	ir_print_add_implicit_return_type(irp, (IrInstSrcAddImplicitReturnType *)instruction);
	2995	break;
	2996	case IrInstSrcIdFloatOp:
	2997	ir_print_float_op(irp, (IrInstSrcFloatOp *)instruction);
	2998	break;
	2999	case IrInstSrcIdMulAdd:
	3000	ir_print_mul_add(irp, (IrInstSrcMulAdd *)instruction);
	3001	break;
	3002	case IrInstSrcIdAtomicLoad:
	3003	ir_print_atomic_load(irp, (IrInstSrcAtomicLoad *)instruction);
	3004	break;
	3005	case IrInstSrcIdAtomicStore:
	3006	ir_print_atomic_store(irp, (IrInstSrcAtomicStore *)instruction);
	3007	break;
	3008	case IrInstSrcIdEnumToInt:
	3009	ir_print_enum_to_int(irp, (IrInstSrcEnumToInt *)instruction);
	3010	break;
	3011	case IrInstSrcIdCheckRuntimeScope:
	3012	ir_print_check_runtime_scope(irp, (IrInstSrcCheckRuntimeScope *)instruction);
	3013	break;
	3014	case IrInstSrcIdHasDecl:
	3015	ir_print_has_decl(irp, (IrInstSrcHasDecl *)instruction);
	3016	break;
	3017	case IrInstSrcIdUndeclaredIdent:
	3018	ir_print_undeclared_ident(irp, (IrInstSrcUndeclaredIdent *)instruction);
	3019	break;
	3020	case IrInstSrcIdAlloca:
	3021	ir_print_alloca_src(irp, (IrInstSrcAlloca *)instruction);
	3022	break;
	3023	case IrInstSrcIdEndExpr:
	3024	ir_print_end_expr(irp, (IrInstSrcEndExpr *)instruction);
	3025	break;
	3026	case IrInstSrcIdUnionInitNamedField:
	3027	ir_print_union_init_named_field(irp, (IrInstSrcUnionInitNamedField *)instruction);
	3028	break;
	3029	case IrInstSrcIdSuspendBegin:
	3030	ir_print_suspend_begin(irp, (IrInstSrcSuspendBegin *)instruction);
	3031	break;
	3032	case IrInstSrcIdSuspendFinish:
	3033	ir_print_suspend_finish(irp, (IrInstSrcSuspendFinish *)instruction);
	3034	break;
	3035	case IrInstSrcIdResume:
	3036	ir_print_resume(irp, (IrInstSrcResume *)instruction);
	3037	break;
	3038	case IrInstSrcIdAwait:
	3039	ir_print_await_src(irp, (IrInstSrcAwait *)instruction);
	3040	break;
	3041	case IrInstSrcIdSpillBegin:
	3042	ir_print_spill_begin(irp, (IrInstSrcSpillBegin *)instruction);
	3043	break;
	3044	case IrInstSrcIdSpillEnd:
	3045	ir_print_spill_end(irp, (IrInstSrcSpillEnd *)instruction);
	3046	break;
	3047	case IrInstSrcIdClz:
	3048	ir_print_clz(irp, (IrInstSrcClz *)instruction);
	3049	break;
	3050	}
	3051	fprintf(irp->f, "\n");
	3052	}
	3053
	3054	static void ir_print_inst_gen(IrPrintGen irp, IrInstGen instruction, bool trailing) {
	3055	ir_print_prefix_gen(irp, instruction, trailing);
	3056	switch (instruction->id) {
	3057	case IrInstGenIdInvalid:
	3058	zig_unreachable();
	3059	case IrInstGenIdReturn:
	3060	ir_print_return_gen(irp, (IrInstGenReturn *)instruction);
2447	3061	break;
2448		case IrInstructionIdIntToEnum:
2449		ir_print_int_to_enum(irp, (IrInstructionIntToEnum *)instruction);
	3062	case IrInstGenIdConst:
	3063	ir_print_const(irp, (IrInstGenConst *)instruction);
2450	3064	break;
2451		case IrInstructionIdIntToErr:
2452		ir_print_int_to_err(irp, (IrInstructionIntToErr *)instruction);
	3065	case IrInstGenIdBinOp:
	3066	ir_print_bin_op(irp, (IrInstGenBinOp *)instruction);
2453	3067	break;
2454		case IrInstructionIdErrToInt:
2455		ir_print_err_to_int(irp, (IrInstructionErrToInt *)instruction);
	3068	case IrInstGenIdDeclVar:
	3069	ir_print_decl_var_gen(irp, (IrInstGenDeclVar *)instruction);
2456	3070	break;
2457		case IrInstructionIdCheckSwitchProngs:
2458		ir_print_check_switch_prongs(irp, (IrInstructionCheckSwitchProngs *)instruction);
	3071	case IrInstGenIdCast:
	3072	ir_print_cast(irp, (IrInstGenCast *)instruction);
2459	3073	break;
2460		case IrInstructionIdCheckStatementIsVoid:
2461		ir_print_check_statement_is_void(irp, (IrInstructionCheckStatementIsVoid *)instruction);
	3074	case IrInstGenIdCall:
	3075	ir_print_call_gen(irp, (IrInstGenCall *)instruction);
2462	3076	break;
2463		case IrInstructionIdTypeName:
2464		ir_print_type_name(irp, (IrInstructionTypeName *)instruction);
	3077	case IrInstGenIdCondBr:
	3078	ir_print_cond_br(irp, (IrInstGenCondBr *)instruction);
2465	3079	break;
2466		case IrInstructionIdTagName:
2467		ir_print_tag_name(irp, (IrInstructionTagName *)instruction);
	3080	case IrInstGenIdBr:
	3081	ir_print_br(irp, (IrInstGenBr *)instruction);
2468	3082	break;
2469		case IrInstructionIdPtrType:
2470		ir_print_ptr_type(irp, (IrInstructionPtrType *)instruction);
	3083	case IrInstGenIdPhi:
	3084	ir_print_phi(irp, (IrInstGenPhi *)instruction);
2471	3085	break;
2472		case IrInstructionIdDeclRef:
2473		ir_print_decl_ref(irp, (IrInstructionDeclRef *)instruction);
	3086	case IrInstGenIdUnreachable:
	3087	ir_print_unreachable(irp, (IrInstGenUnreachable *)instruction);
2474	3088	break;
2475		case IrInstructionIdPanic:
2476		ir_print_panic(irp, (IrInstructionPanic *)instruction);
	3089	case IrInstGenIdElemPtr:
	3090	ir_print_elem_ptr(irp, (IrInstGenElemPtr *)instruction);
2477	3091	break;
2478		case IrInstructionIdFieldParentPtr:
2479		ir_print_field_parent_ptr(irp, (IrInstructionFieldParentPtr *)instruction);
	3092	case IrInstGenIdVarPtr:
	3093	ir_print_var_ptr(irp, (IrInstGenVarPtr *)instruction);
2480	3094	break;
2481		case IrInstructionIdByteOffsetOf:
2482		ir_print_byte_offset_of(irp, (IrInstructionByteOffsetOf *)instruction);
	3095	case IrInstGenIdReturnPtr:
	3096	ir_print_return_ptr(irp, (IrInstGenReturnPtr *)instruction);
2483	3097	break;
2484		case IrInstructionIdBitOffsetOf:
2485		ir_print_bit_offset_of(irp, (IrInstructionBitOffsetOf *)instruction);
	3098	case IrInstGenIdLoadPtr:
	3099	ir_print_load_ptr_gen(irp, (IrInstGenLoadPtr *)instruction);
2486	3100	break;
2487		case IrInstructionIdTypeInfo:
2488		ir_print_type_info(irp, (IrInstructionTypeInfo *)instruction);
	3101	case IrInstGenIdStorePtr:
	3102	ir_print_store_ptr(irp, (IrInstGenStorePtr *)instruction);
2489	3103	break;
2490		case IrInstructionIdType:
2491		ir_print_type(irp, (IrInstructionType *)instruction);
	3104	case IrInstGenIdStructFieldPtr:
	3105	ir_print_struct_field_ptr(irp, (IrInstGenStructFieldPtr *)instruction);
2492	3106	break;
2493		case IrInstructionIdHasField:
2494		ir_print_has_field(irp, (IrInstructionHasField *)instruction);
	3107	case IrInstGenIdUnionFieldPtr:
	3108	ir_print_union_field_ptr(irp, (IrInstGenUnionFieldPtr *)instruction);
2495	3109	break;
2496		case IrInstructionIdTypeId:
2497		ir_print_type_id(irp, (IrInstructionTypeId *)instruction);
	3110	case IrInstGenIdAsm:
	3111	ir_print_asm_gen(irp, (IrInstGenAsm *)instruction);
2498	3112	break;
2499		case IrInstructionIdSetEvalBranchQuota:
2500		ir_print_set_eval_branch_quota(irp, (IrInstructionSetEvalBranchQuota *)instruction);
	3113	case IrInstGenIdTestNonNull:
	3114	ir_print_test_non_null(irp, (IrInstGenTestNonNull *)instruction);
2501	3115	break;
2502		case IrInstructionIdAlignCast:
2503		ir_print_align_cast(irp, (IrInstructionAlignCast *)instruction);
	3116	case IrInstGenIdOptionalUnwrapPtr:
	3117	ir_print_optional_unwrap_ptr(irp, (IrInstGenOptionalUnwrapPtr *)instruction);
2504	3118	break;
2505		case IrInstructionIdImplicitCast:
2506		ir_print_implicit_cast(irp, (IrInstructionImplicitCast *)instruction);
	3119	case IrInstGenIdPopCount:
	3120	ir_print_pop_count(irp, (IrInstGenPopCount *)instruction);
2507	3121	break;
2508		case IrInstructionIdResolveResult:
2509		ir_print_resolve_result(irp, (IrInstructionResolveResult *)instruction);
	3122	case IrInstGenIdClz:
	3123	ir_print_clz(irp, (IrInstGenClz *)instruction);
2510	3124	break;
2511		case IrInstructionIdResetResult:
2512		ir_print_reset_result(irp, (IrInstructionResetResult *)instruction);
	3125	case IrInstGenIdCtz:
	3126	ir_print_ctz(irp, (IrInstGenCtz *)instruction);
2513	3127	break;
2514		case IrInstructionIdOpaqueType:
2515		ir_print_opaque_type(irp, (IrInstructionOpaqueType *)instruction);
	3128	case IrInstGenIdBswap:
	3129	ir_print_bswap(irp, (IrInstGenBswap *)instruction);
2516	3130	break;
2517		case IrInstructionIdSetAlignStack:
2518		ir_print_set_align_stack(irp, (IrInstructionSetAlignStack *)instruction);
	3131	case IrInstGenIdBitReverse:
	3132	ir_print_bit_reverse(irp, (IrInstGenBitReverse *)instruction);
2519	3133	break;
2520		case IrInstructionIdArgType:
2521		ir_print_arg_type(irp, (IrInstructionArgType *)instruction);
	3134	case IrInstGenIdSwitchBr:
	3135	ir_print_switch_br(irp, (IrInstGenSwitchBr *)instruction);
2522	3136	break;
2523		case IrInstructionIdTagType:
2524		ir_print_enum_tag_type(irp, (IrInstructionTagType *)instruction);
	3137	case IrInstGenIdUnionTag:
	3138	ir_print_union_tag(irp, (IrInstGenUnionTag *)instruction);
2525	3139	break;
2526		case IrInstructionIdExport:
2527		ir_print_export(irp, (IrInstructionExport *)instruction);
	3140	case IrInstGenIdRef:
	3141	ir_print_ref_gen(irp, (IrInstGenRef *)instruction);
2528	3142	break;
2529		case IrInstructionIdErrorReturnTrace:
2530		ir_print_error_return_trace(irp, (IrInstructionErrorReturnTrace *)instruction);
	3143	case IrInstGenIdErrName:
	3144	ir_print_err_name(irp, (IrInstGenErrName *)instruction);
2531	3145	break;
2532		case IrInstructionIdErrorUnion:
2533		ir_print_error_union(irp, (IrInstructionErrorUnion *)instruction);
	3146	case IrInstGenIdCmpxchg:
	3147	ir_print_cmpxchg_gen(irp, (IrInstGenCmpxchg *)instruction);
2534	3148	break;
2535		case IrInstructionIdAtomicRmw:
2536		ir_print_atomic_rmw(irp, (IrInstructionAtomicRmw *)instruction);
	3149	case IrInstGenIdFence:
	3150	ir_print_fence(irp, (IrInstGenFence *)instruction);
2537	3151	break;
2538		case IrInstructionIdSaveErrRetAddr:
2539		ir_print_save_err_ret_addr(irp, (IrInstructionSaveErrRetAddr *)instruction);
	3152	case IrInstGenIdTruncate:
	3153	ir_print_truncate(irp, (IrInstGenTruncate *)instruction);
2540	3154	break;
2541		case IrInstructionIdAddImplicitReturnType:
2542		ir_print_add_implicit_return_type(irp, (IrInstructionAddImplicitReturnType *)instruction);
	3155	case IrInstGenIdShuffleVector:
	3156	ir_print_shuffle_vector(irp, (IrInstGenShuffleVector *)instruction);
2543	3157	break;
2544		case IrInstructionIdFloatOp:
2545		ir_print_float_op(irp, (IrInstructionFloatOp *)instruction);
	3158	case IrInstGenIdSplat:
	3159	ir_print_splat_gen(irp, (IrInstGenSplat *)instruction);
2546	3160	break;
2547		case IrInstructionIdMulAdd:
2548		ir_print_mul_add(irp, (IrInstructionMulAdd *)instruction);
	3161	case IrInstGenIdBoolNot:
	3162	ir_print_bool_not(irp, (IrInstGenBoolNot *)instruction);
2549	3163	break;
2550		case IrInstructionIdAtomicLoad:
2551		ir_print_atomic_load(irp, (IrInstructionAtomicLoad *)instruction);
	3164	case IrInstGenIdMemset:
	3165	ir_print_memset(irp, (IrInstGenMemset *)instruction);
2552	3166	break;
2553		case IrInstructionIdAtomicStore:
2554		ir_print_atomic_store(irp, (IrInstructionAtomicStore *)instruction);
	3167	case IrInstGenIdMemcpy:
	3168	ir_print_memcpy(irp, (IrInstGenMemcpy *)instruction);
2555	3169	break;
2556		case IrInstructionIdEnumToInt:
2557		ir_print_enum_to_int(irp, (IrInstructionEnumToInt *)instruction);
	3170	case IrInstGenIdSlice:
	3171	ir_print_slice_gen(irp, (IrInstGenSlice *)instruction);
2558	3172	break;
2559		case IrInstructionIdCheckRuntimeScope:
2560		ir_print_check_runtime_scope(irp, (IrInstructionCheckRuntimeScope *)instruction);
	3173	case IrInstGenIdBreakpoint:
	3174	ir_print_breakpoint(irp, (IrInstGenBreakpoint *)instruction);
2561	3175	break;
2562		case IrInstructionIdDeclVarGen:
2563		ir_print_decl_var_gen(irp, (IrInstructionDeclVarGen *)instruction);
	3176	case IrInstGenIdReturnAddress:
	3177	ir_print_return_address(irp, (IrInstGenReturnAddress *)instruction);
2564	3178	break;
2565		case IrInstructionIdArrayToVector:
2566		ir_print_array_to_vector(irp, (IrInstructionArrayToVector *)instruction);
	3179	case IrInstGenIdFrameAddress:
	3180	ir_print_frame_address(irp, (IrInstGenFrameAddress *)instruction);
2567	3181	break;
2568		case IrInstructionIdVectorToArray:
2569		ir_print_vector_to_array(irp, (IrInstructionVectorToArray *)instruction);
	3182	case IrInstGenIdFrameHandle:
	3183	ir_print_handle(irp, (IrInstGenFrameHandle *)instruction);
2570	3184	break;
2571		case IrInstructionIdPtrOfArrayToSlice:
2572		ir_print_ptr_of_array_to_slice(irp, (IrInstructionPtrOfArrayToSlice *)instruction);
	3185	case IrInstGenIdFrameSize:
	3186	ir_print_frame_size_gen(irp, (IrInstGenFrameSize *)instruction);
2573	3187	break;
2574		case IrInstructionIdAssertZero:
2575		ir_print_assert_zero(irp, (IrInstructionAssertZero *)instruction);
	3188	case IrInstGenIdOverflowOp:
	3189	ir_print_overflow_op(irp, (IrInstGenOverflowOp *)instruction);
2576	3190	break;
2577		case IrInstructionIdAssertNonNull:
2578		ir_print_assert_non_null(irp, (IrInstructionAssertNonNull *)instruction);
	3191	case IrInstGenIdTestErr:
	3192	ir_print_test_err_gen(irp, (IrInstGenTestErr *)instruction);
2579	3193	break;
2580		case IrInstructionIdResizeSlice:
2581		ir_print_resize_slice(irp, (IrInstructionResizeSlice *)instruction);
	3194	case IrInstGenIdUnwrapErrCode:
	3195	ir_print_unwrap_err_code(irp, (IrInstGenUnwrapErrCode *)instruction);
2582	3196	break;
2583		case IrInstructionIdHasDecl:
2584		ir_print_has_decl(irp, (IrInstructionHasDecl *)instruction);
	3197	case IrInstGenIdUnwrapErrPayload:
	3198	ir_print_unwrap_err_payload(irp, (IrInstGenUnwrapErrPayload *)instruction);
2585	3199	break;
2586		case IrInstructionIdUndeclaredIdent:
2587		ir_print_undeclared_ident(irp, (IrInstructionUndeclaredIdent *)instruction);
	3200	case IrInstGenIdOptionalWrap:
	3201	ir_print_optional_wrap(irp, (IrInstGenOptionalWrap *)instruction);
2588	3202	break;
2589		case IrInstructionIdAllocaSrc:
2590		ir_print_alloca_src(irp, (IrInstructionAllocaSrc *)instruction);
	3203	case IrInstGenIdErrWrapCode:
	3204	ir_print_err_wrap_code(irp, (IrInstGenErrWrapCode *)instruction);
2591	3205	break;
2592		case IrInstructionIdAllocaGen:
2593		ir_print_alloca_gen(irp, (IrInstructionAllocaGen *)instruction);
	3206	case IrInstGenIdErrWrapPayload:
	3207	ir_print_err_wrap_payload(irp, (IrInstGenErrWrapPayload *)instruction);
2594	3208	break;
2595		case IrInstructionIdEndExpr:
2596		ir_print_end_expr(irp, (IrInstructionEndExpr *)instruction);
	3209	case IrInstGenIdPtrCast:
	3210	ir_print_ptr_cast_gen(irp, (IrInstGenPtrCast *)instruction);
2597	3211	break;
2598		case IrInstructionIdUnionInitNamedField:
2599		ir_print_union_init_named_field(irp, (IrInstructionUnionInitNamedField *)instruction);
	3212	case IrInstGenIdBitCast:
	3213	ir_print_bit_cast_gen(irp, (IrInstGenBitCast *)instruction);
2600	3214	break;
2601		case IrInstructionIdSuspendBegin:
2602		ir_print_suspend_begin(irp, (IrInstructionSuspendBegin *)instruction);
	3215	case IrInstGenIdWidenOrShorten:
	3216	ir_print_widen_or_shorten(irp, (IrInstGenWidenOrShorten *)instruction);
2603	3217	break;
2604		case IrInstructionIdSuspendFinish:
2605		ir_print_suspend_finish(irp, (IrInstructionSuspendFinish *)instruction);
	3218	case IrInstGenIdPtrToInt:
	3219	ir_print_ptr_to_int(irp, (IrInstGenPtrToInt *)instruction);
2606	3220	break;
2607		case IrInstructionIdResume:
2608		ir_print_resume(irp, (IrInstructionResume *)instruction);
	3221	case IrInstGenIdIntToPtr:
	3222	ir_print_int_to_ptr(irp, (IrInstGenIntToPtr *)instruction);
2609	3223	break;
2610		case IrInstructionIdAwaitSrc:
2611		ir_print_await_src(irp, (IrInstructionAwaitSrc *)instruction);
	3224	case IrInstGenIdIntToEnum:
	3225	ir_print_int_to_enum(irp, (IrInstGenIntToEnum *)instruction);
2612	3226	break;
2613		case IrInstructionIdAwaitGen:
2614		ir_print_await_gen(irp, (IrInstructionAwaitGen *)instruction);
	3227	case IrInstGenIdIntToErr:
	3228	ir_print_int_to_err(irp, (IrInstGenIntToErr *)instruction);
2615	3229	break;
2616		case IrInstructionIdSpillBegin:
2617		ir_print_spill_begin(irp, (IrInstructionSpillBegin *)instruction);
	3230	case IrInstGenIdErrToInt:
	3231	ir_print_err_to_int(irp, (IrInstGenErrToInt *)instruction);
2618	3232	break;
2619		case IrInstructionIdSpillEnd:
2620		ir_print_spill_end(irp, (IrInstructionSpillEnd *)instruction);
	3233	case IrInstGenIdTagName:
	3234	ir_print_tag_name(irp, (IrInstGenTagName *)instruction);
2621	3235	break;
2622		case IrInstructionIdVectorExtractElem:
2623		ir_print_vector_extract_elem(irp, (IrInstructionVectorExtractElem *)instruction);
	3236	case IrInstGenIdPanic:
	3237	ir_print_panic(irp, (IrInstGenPanic *)instruction);
	3238	break;
	3239	case IrInstGenIdFieldParentPtr:
	3240	ir_print_field_parent_ptr(irp, (IrInstGenFieldParentPtr *)instruction);
	3241	break;
	3242	case IrInstGenIdAlignCast:
	3243	ir_print_align_cast(irp, (IrInstGenAlignCast *)instruction);
	3244	break;
	3245	case IrInstGenIdErrorReturnTrace:
	3246	ir_print_error_return_trace(irp, (IrInstGenErrorReturnTrace *)instruction);
	3247	break;
	3248	case IrInstGenIdAtomicRmw:
	3249	ir_print_atomic_rmw(irp, (IrInstGenAtomicRmw *)instruction);
	3250	break;
	3251	case IrInstGenIdSaveErrRetAddr:
	3252	ir_print_save_err_ret_addr(irp, (IrInstGenSaveErrRetAddr *)instruction);
	3253	break;
	3254	case IrInstGenIdFloatOp:
	3255	ir_print_float_op(irp, (IrInstGenFloatOp *)instruction);
	3256	break;
	3257	case IrInstGenIdMulAdd:
	3258	ir_print_mul_add(irp, (IrInstGenMulAdd *)instruction);
	3259	break;
	3260	case IrInstGenIdAtomicLoad:
	3261	ir_print_atomic_load(irp, (IrInstGenAtomicLoad *)instruction);
	3262	break;
	3263	case IrInstGenIdAtomicStore:
	3264	ir_print_atomic_store(irp, (IrInstGenAtomicStore *)instruction);
	3265	break;
	3266	case IrInstGenIdArrayToVector:
	3267	ir_print_array_to_vector(irp, (IrInstGenArrayToVector *)instruction);
	3268	break;
	3269	case IrInstGenIdVectorToArray:
	3270	ir_print_vector_to_array(irp, (IrInstGenVectorToArray *)instruction);
	3271	break;
	3272	case IrInstGenIdPtrOfArrayToSlice:
	3273	ir_print_ptr_of_array_to_slice(irp, (IrInstGenPtrOfArrayToSlice *)instruction);
	3274	break;
	3275	case IrInstGenIdAssertZero:
	3276	ir_print_assert_zero(irp, (IrInstGenAssertZero *)instruction);
	3277	break;
	3278	case IrInstGenIdAssertNonNull:
	3279	ir_print_assert_non_null(irp, (IrInstGenAssertNonNull *)instruction);
	3280	break;
	3281	case IrInstGenIdResizeSlice:
	3282	ir_print_resize_slice(irp, (IrInstGenResizeSlice *)instruction);
	3283	break;
	3284	case IrInstGenIdAlloca:
	3285	ir_print_alloca_gen(irp, (IrInstGenAlloca *)instruction);
	3286	break;
	3287	case IrInstGenIdSuspendBegin:
	3288	ir_print_suspend_begin(irp, (IrInstGenSuspendBegin *)instruction);
	3289	break;
	3290	case IrInstGenIdSuspendFinish:
	3291	ir_print_suspend_finish(irp, (IrInstGenSuspendFinish *)instruction);
	3292	break;
	3293	case IrInstGenIdResume:
	3294	ir_print_resume(irp, (IrInstGenResume *)instruction);
	3295	break;
	3296	case IrInstGenIdAwait:
	3297	ir_print_await_gen(irp, (IrInstGenAwait *)instruction);
	3298	break;
	3299	case IrInstGenIdSpillBegin:
	3300	ir_print_spill_begin(irp, (IrInstGenSpillBegin *)instruction);
	3301	break;
	3302	case IrInstGenIdSpillEnd:
	3303	ir_print_spill_end(irp, (IrInstGenSpillEnd *)instruction);
	3304	break;
	3305	case IrInstGenIdVectorExtractElem:
	3306	ir_print_vector_extract_elem(irp, (IrInstGenVectorExtractElem *)instruction);
	3307	break;
	3308	case IrInstGenIdVectorStoreElem:
	3309	ir_print_vector_store_elem(irp, (IrInstGenVectorStoreElem *)instruction);
	3310	break;
	3311	case IrInstGenIdBinaryNot:
	3312	ir_print_binary_not(irp, (IrInstGenBinaryNot *)instruction);
	3313	break;
	3314	case IrInstGenIdNegation:
	3315	ir_print_negation(irp, (IrInstGenNegation *)instruction);
	3316	break;
	3317	case IrInstGenIdNegationWrapping:
	3318	ir_print_negation_wrapping(irp, (IrInstGenNegationWrapping *)instruction);
2624	3319	break;
2625	3320	}
2626	3321	fprintf(irp->f, "\n");
2627	3322	}
2628	3323
2629		static void irp_print_basic_block(IrPrint irp, IrBasicBlock current_block) {
2630		fprintf(irp->f, "%s_%" ZIG_PRI_usize ":\n", current_block->name_hint, current_block->debug_id);
	3324	static void irp_print_basic_block_src(IrPrintSrc irp, IrBasicBlockSrc current_block) {
	3325	fprintf(irp->f, "%s_%" PRIu32 ":\n", current_block->name_hint, current_block->debug_id);
2631	3326	for (size_t instr_i = 0; instr_i < current_block->instruction_list.length; instr_i += 1) {
2632		IrInstruction *instruction = current_block->instruction_list.at(instr_i);
2633		if (irp->pass != IrPassSrc) {
2634		irp->printed.put(instruction, 0);
2635		irp->pending.clear();
2636		}
2637		ir_print_instruction(irp, instruction, false);
	3327	IrInstSrc *instruction = current_block->instruction_list.at(instr_i);
	3328	ir_print_inst_src(irp, instruction, false);
	3329	}
	3330	}
	3331
	3332	static void irp_print_basic_block_gen(IrPrintGen irp, IrBasicBlockGen current_block) {
	3333	fprintf(irp->f, "%s_%" PRIu32 ":\n", current_block->name_hint, current_block->debug_id);
	3334	for (size_t instr_i = 0; instr_i < current_block->instruction_list.length; instr_i += 1) {
	3335	IrInstGen *instruction = current_block->instruction_list.at(instr_i);
	3336	irp->printed.put(instruction, 0);
	3337	irp->pending.clear();
	3338	ir_print_inst_gen(irp, instruction, false);
2638	3339	for (size_t j = 0; j < irp->pending.length; ++j)
2639		ir_print_instruction(irp, irp->pending.at(j), true);
	3340	ir_print_inst_gen(irp, irp->pending.at(j), true);
2640	3341	}
2641	3342	}
2642	3343
2643		void ir_print_basic_block(CodeGen codegen, FILE f, IrBasicBlock *bb, int indent_size, IrPass pass) {
2644		IrPrint ir_print = {};
2645		ir_print.pass = pass;
	3344	void ir_print_basic_block_src(CodeGen codegen, FILE f, IrBasicBlockSrc *bb, int indent_size) {
	3345	IrPrintSrc ir_print = {};
	3346	ir_print.codegen = codegen;
	3347	ir_print.f = f;
	3348	ir_print.indent = indent_size;
	3349	ir_print.indent_size = indent_size;
	3350
	3351	irp_print_basic_block_src(&ir_print, bb);
	3352	}
	3353
	3354	void ir_print_basic_block_gen(CodeGen codegen, FILE f, IrBasicBlockGen *bb, int indent_size) {
	3355	IrPrintGen ir_print = {};
2646	3356	ir_print.codegen = codegen;
2647	3357	ir_print.f = f;
2648	3358	ir_print.indent = indent_size;
...	...	@@ -2651,16 +3361,28 @@ void ir_print_basic_block(CodeGen codegen, FILE f, IrBasicBlock *bb, int inden
2651	3361	ir_print.printed.init(64);
2652	3362	ir_print.pending = {};
2653	3363
2654		irp_print_basic_block(&ir_print, bb);
	3364	irp_print_basic_block_gen(&ir_print, bb);
2655	3365
2656	3366	ir_print.pending.deinit();
2657	3367	ir_print.printed.deinit();
2658	3368	}
2659	3369
2660		void ir_print(CodeGen codegen, FILE f, IrExecutable *executable, int indent_size, IrPass pass) {
2661		IrPrint ir_print = {};
2662		IrPrint *irp = &ir_print;
2663		irp->pass = pass;
	3370	void ir_print_src(CodeGen codegen, FILE f, IrExecutableSrc *executable, int indent_size) {
	3371	IrPrintSrc ir_print = {};
	3372	IrPrintSrc *irp = &ir_print;
	3373	irp->codegen = codegen;
	3374	irp->f = f;
	3375	irp->indent = indent_size;
	3376	irp->indent_size = indent_size;
	3377
	3378	for (size_t bb_i = 0; bb_i < executable->basic_block_list.length; bb_i += 1) {
	3379	irp_print_basic_block_src(irp, executable->basic_block_list.at(bb_i));
	3380	}
	3381	}
	3382
	3383	void ir_print_gen(CodeGen codegen, FILE f, IrExecutableGen *executable, int indent_size) {
	3384	IrPrintGen ir_print = {};
	3385	IrPrintGen *irp = &ir_print;
2664	3386	irp->codegen = codegen;
2665	3387	irp->f = f;
2666	3388	irp->indent = indent_size;
...	...	@@ -2670,32 +3392,27 @@ void ir_print(CodeGen codegen, FILE f, IrExecutable *executable, int indent_si
2670	3392	irp->pending = {};
2671	3393
2672	3394	for (size_t bb_i = 0; bb_i < executable->basic_block_list.length; bb_i += 1) {
2673		irp_print_basic_block(irp, executable->basic_block_list.at(bb_i));
	3395	irp_print_basic_block_gen(irp, executable->basic_block_list.at(bb_i));
2674	3396	}
2675	3397
2676	3398	irp->pending.deinit();
2677	3399	irp->printed.deinit();
2678	3400	}
2679	3401
2680		void ir_print_instruction(CodeGen codegen, FILE f, IrInstruction *instruction, int indent_size, IrPass pass) {
2681		IrPrint ir_print = {};
2682		IrPrint *irp = &ir_print;
2683		irp->pass = pass;
	3402	void ir_print_inst_src(CodeGen codegen, FILE f, IrInstSrc *instruction, int indent_size) {
	3403	IrPrintSrc ir_print = {};
	3404	IrPrintSrc *irp = &ir_print;
2684	3405	irp->codegen = codegen;
2685	3406	irp->f = f;
2686	3407	irp->indent = indent_size;
2687	3408	irp->indent_size = indent_size;
2688		irp->printed = {};
2689		irp->printed.init(4);
2690		irp->pending = {};
2691	3409
2692		ir_print_instruction(irp, instruction, false);
	3410	ir_print_inst_src(irp, instruction, false);
2693	3411	}
2694	3412
2695		void ir_print_const_expr(CodeGen codegen, FILE f, ZigValue *value, int indent_size, IrPass pass) {
2696		IrPrint ir_print = {};
2697		IrPrint *irp = &ir_print;
2698		irp->pass = pass;
	3413	void ir_print_inst_gen(CodeGen codegen, FILE f, IrInstGen *instruction, int indent_size) {
	3414	IrPrintGen ir_print = {};
	3415	IrPrintGen *irp = &ir_print;
2699	3416	irp->codegen = codegen;
2700	3417	irp->f = f;
2701	3418	irp->indent = indent_size;
...	...	@@ -2704,5 +3421,5 @@ void ir_print_const_expr(CodeGen codegen, FILE f, ZigValue *value, int indent_
2704	3421	irp->printed.init(4);
2705	3422	irp->pending = {};
2706	3423
2707		ir_print_const_value(irp, value);
	3424	ir_print_inst_gen(irp, instruction, false);
2708	3425	}

src/ir_print.hpp+8-5

...	...	@@ -12,11 +12,14 @@
12	12
13	13	#include <stdio.h>
14	14
15		void ir_print(CodeGen codegen, FILE f, IrExecutable *executable, int indent_size, IrPass pass);
16		void ir_print_instruction(CodeGen codegen, FILE f, IrInstruction *instruction, int indent_size, IrPass pass);
17		void ir_print_const_expr(CodeGen codegen, FILE f, ZigValue *value, int indent_size, IrPass pass);
18		void ir_print_basic_block(CodeGen codegen, FILE f, IrBasicBlock *bb, int indent_size, IrPass pass);
	15	void ir_print_src(CodeGen codegen, FILE f, IrExecutableSrc *executable, int indent_size);
	16	void ir_print_gen(CodeGen codegen, FILE f, IrExecutableGen *executable, int indent_size);
	17	void ir_print_inst_src(CodeGen codegen, FILE f, IrInstSrc *inst, int indent_size);
	18	void ir_print_inst_gen(CodeGen codegen, FILE f, IrInstGen *inst, int indent_size);
	19	void ir_print_basic_block_src(CodeGen codegen, FILE f, IrBasicBlockSrc *bb, int indent_size);
	20	void ir_print_basic_block_gen(CodeGen codegen, FILE f, IrBasicBlockGen *bb, int indent_size);
19	21
20		const char* ir_instruction_type_str(IrInstructionId id);
	22	const char* ir_inst_src_type_str(IrInstSrcId id);
	23	const char* ir_inst_gen_type_str(IrInstGenId id);
21	24
22	25	#endif

src/parser.cpp+1-1

...	...	@@ -147,7 +147,7 @@ static void ast_invalid_token_error(ParseContext pc, Token token) {
147	147	}
148	148
149	149	static AstNode ast_create_node_no_line_info(ParseContext pc, NodeType type) {
150		AstNode *node = allocate<AstNode>(1);
	150	AstNode *node = allocate<AstNode>(1, "AstNode");
151	151	node->type = type;
152	152	node->owner = pc->owner;
153	153	return node;