Commit c36289511629e01bbd32bc5f1133f5ed5997d1e0 | zig

author	Andrew Kelley <andrew@ziglang.org> 2019-06-10 15:49:45-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2019-06-10 15:49:45-04:00
log	c36289511629e01bbd32bc5f1133f5ed5997d1e0
tree	c527aacbe9af5abc3c400bc0b5d412e94f08027f
parent	17b1ac5d03cd32e047d917a88e029c143cb5d119
signature	Commit is signed but in an unrecognized format.

result location semantics for slices

```zig
export fn entry() void {
    var buf: [10]u8 = undefined;
    const slice1: []const u8 = &buf;
    const slice2 = buf[0..];
}
```

```llvm
define void @entry() #2 !dbg !35 {
Entry:
  %buf = alloca [10 x i8], align 1
  %slice1 = alloca %"[]u8", align 8
  %slice2 = alloca %"[]u8", align 8
  %0 = bitcast [10 x i8]* %buf to i8*, !dbg !46
  call void @llvm.memset.p0i8.i64(i8* align 1 %0, i8 -86, i64 10, i1 false), !dbg !46
  call void @llvm.dbg.declare(metadata [10 x i8]* %buf, metadata !39, metadata !DIExpression()), !dbg !46
  %1 = getelementptr inbounds %"[]u8", %"[]u8"* %slice1, i32 0, i32 0, !dbg !47
  %2 = getelementptr inbounds [10 x i8], [10 x i8]* %buf, i64 0, i64 0, !dbg !47
  store i8* %2, i8** %1, align 8, !dbg !47
  %3 = getelementptr inbounds %"[]u8", %"[]u8"* %slice1, i32 0, i32 1, !dbg !47
  store i64 10, i64* %3, align 8, !dbg !47
  call void @llvm.dbg.declare(metadata %"[]u8"* %slice1, metadata !44, metadata !DIExpression()), !dbg !48
  %4 = getelementptr inbounds %"[]u8", %"[]u8"* %slice2, i32 0, i32 0, !dbg !49
  %5 = getelementptr inbounds [10 x i8], [10 x i8]* %buf, i64 0, i64 0, !dbg !49
  store i8* %5, i8** %4, align 8, !dbg !49
  %6 = getelementptr inbounds %"[]u8", %"[]u8"* %slice2, i32 0, i32 1, !dbg !49
  store i64 10, i64* %6, align 8, !dbg !49
  call void @llvm.dbg.declare(metadata %"[]u8"* %slice2, metadata !45, metadata !DIExpression()), !dbg !50
  ret void, !dbg !51
}
```

5 files changed, 210 insertions(+), 97 deletions(-)

BRANCH_TODO
src

BRANCH_TODO-3

...	...	@@ -20,6 +20,3 @@ inferred comptime
20	20	// an instruction which just makes a pointer of it.
21	21	return ir_build_ref(irb, scope, value->source_node, value, false, false);
22	22
23		handle if with no else
24
25

src/all_types.hpp+23-4

...	...	@@ -2248,7 +2248,8 @@ enum IrInstructionId {
2248	2248	IrInstructionIdBoolNot,
2249	2249	IrInstructionIdMemset,
2250	2250	IrInstructionIdMemcpy,
2251		IrInstructionIdSlice,
	2251	IrInstructionIdSliceSrc,
	2252	IrInstructionIdSliceGen,
2252	2253	IrInstructionIdMemberCount,
2253	2254	IrInstructionIdMemberType,
2254	2255	IrInstructionIdMemberName,
...	...	@@ -2334,6 +2335,7 @@ enum IrInstructionId {
2334	2335	IrInstructionIdAllocaSrc,
2335	2336	IrInstructionIdAllocaGen,
2336	2337	IrInstructionIdEndExpr,
	2338	IrInstructionIdPtrOfArrayToSlice,
2337	2339	};
2338	2340
2339	2341	struct IrInstruction {
...	...	@@ -2617,7 +2619,6 @@ enum CastOp {
2617	2619	CastOpNumLitToConcrete,
2618	2620	CastOpErrSet,
2619	2621	CastOpBitCast,
2620		CastOpPtrOfArrayToSlice,
2621	2622	};
2622	2623
2623	2624	// TODO get rid of this instruction, replace with instructions for each op code
...	...	@@ -2989,14 +2990,24 @@ struct IrInstructionMemcpy {
2989	2990	IrInstruction *count;
2990	2991	};
2991	2992
2992		struct IrInstructionSlice {
	2993	struct IrInstructionSliceSrc {
2993	2994	IrInstruction base;
2994	2995
	2996	bool safety_check_on;
2995	2997	IrInstruction *ptr;
2996	2998	IrInstruction *start;
2997	2999	IrInstruction *end;
	3000	ResultLoc *result_loc;
	3001	};
	3002
	3003	struct IrInstructionSliceGen {
	3004	IrInstruction base;
	3005
2998	3006	bool safety_check_on;
2999		LLVMValueRef tmp_ptr;
	3007	IrInstruction *ptr;
	3008	IrInstruction *start;
	3009	IrInstruction *end;
	3010	IrInstruction *result_loc;
3000	3011	};
3001	3012
3002	3013	struct IrInstructionMemberCount {
...	...	@@ -3563,6 +3574,7 @@ struct IrInstructionImplicitCast {
3563	3574
3564	3575	IrInstruction *dest_type;
3565	3576	IrInstruction *target;
	3577	ResultLoc *result_loc;
3566	3578	};
3567	3579
3568	3580	struct IrInstructionResolveResult {
...	...	@@ -3572,6 +3584,13 @@ struct IrInstructionResolveResult {
3572	3584	IrInstruction *ty;
3573	3585	};
3574	3586
	3587	struct IrInstructionPtrOfArrayToSlice {
	3588	IrInstruction base;
	3589
	3590	IrInstruction *operand;
	3591	IrInstruction *result_loc;
	3592	};
	3593
3575	3594	enum ResultLocId {
3576	3595	ResultLocIdInvalid,
3577	3596	ResultLocIdNone,

src/codegen.cpp+39-33

...	...	@@ -3072,33 +3072,39 @@ static LLVMValueRef ir_render_cast(CodeGen g, IrExecutable executable,
3072	3072	return expr_val;
3073	3073	case CastOpBitCast:
3074	3074	return LLVMBuildBitCast(g->builder, expr_val, get_llvm_type(g, wanted_type), "");
3075		case CastOpPtrOfArrayToSlice: {
3076		assert(cast_instruction->tmp_ptr);
3077		assert(actual_type->id == ZigTypeIdPointer);
3078		ZigType *array_type = actual_type->data.pointer.child_type;
3079		assert(array_type->id == ZigTypeIdArray);
3080
3081		LLVMValueRef ptr_field_ptr = LLVMBuildStructGEP(g->builder, cast_instruction->tmp_ptr,
3082		slice_ptr_index, "");
3083		LLVMValueRef indices[] = {
3084		LLVMConstNull(g->builtin_types.entry_usize->llvm_type),
3085		LLVMConstInt(g->builtin_types.entry_usize->llvm_type, 0, false),
3086		};
3087		LLVMValueRef slice_start_ptr = LLVMBuildInBoundsGEP(g->builder, expr_val, indices, 2, "");
3088		gen_store_untyped(g, slice_start_ptr, ptr_field_ptr, 0, false);
3089
3090		LLVMValueRef len_field_ptr = LLVMBuildStructGEP(g->builder, cast_instruction->tmp_ptr,
3091		slice_len_index, "");
3092		LLVMValueRef len_value = LLVMConstInt(g->builtin_types.entry_usize->llvm_type,
3093		array_type->data.array.len, false);
3094		gen_store_untyped(g, len_value, len_field_ptr, 0, false);
3095
3096		return cast_instruction->tmp_ptr;
3097		}
3098	3075	}
3099	3076	zig_unreachable();
3100	3077	}
3101	3078
	3079	static LLVMValueRef ir_render_ptr_of_array_to_slice(CodeGen g, IrExecutable executable,
	3080	IrInstructionPtrOfArrayToSlice *instruction)
	3081	{
	3082	ZigType *actual_type = instruction->operand->value.type;
	3083	LLVMValueRef expr_val = ir_llvm_value(g, instruction->operand);
	3084	assert(expr_val);
	3085
	3086	LLVMValueRef result_loc = ir_llvm_value(g, instruction->result_loc);
	3087
	3088	assert(actual_type->id == ZigTypeIdPointer);
	3089	ZigType *array_type = actual_type->data.pointer.child_type;
	3090	assert(array_type->id == ZigTypeIdArray);
	3091
	3092	LLVMValueRef ptr_field_ptr = LLVMBuildStructGEP(g->builder, result_loc, slice_ptr_index, "");
	3093	LLVMValueRef indices[] = {
	3094	LLVMConstNull(g->builtin_types.entry_usize->llvm_type),
	3095	LLVMConstInt(g->builtin_types.entry_usize->llvm_type, 0, false),
	3096	};
	3097	LLVMValueRef slice_start_ptr = LLVMBuildInBoundsGEP(g->builder, expr_val, indices, 2, "");
	3098	gen_store_untyped(g, slice_start_ptr, ptr_field_ptr, 0, false);
	3099
	3100	LLVMValueRef len_field_ptr = LLVMBuildStructGEP(g->builder, result_loc, slice_len_index, "");
	3101	LLVMValueRef len_value = LLVMConstInt(g->builtin_types.entry_usize->llvm_type,
	3102	array_type->data.array.len, false);
	3103	gen_store_untyped(g, len_value, len_field_ptr, 0, false);
	3104
	3105	return result_loc;
	3106	}
	3107
3102	3108	static LLVMValueRef ir_render_ptr_cast(CodeGen g, IrExecutable executable,
3103	3109	IrInstructionPtrCastGen *instruction)
3104	3110	{
...	...	@@ -4603,16 +4609,14 @@ static LLVMValueRef ir_render_memcpy(CodeGen g, IrExecutable executable, IrIns
4603	4609	return nullptr;
4604	4610	}
4605	4611
4606		static LLVMValueRef ir_render_slice(CodeGen g, IrExecutable executable, IrInstructionSlice *instruction) {
4607		assert(instruction->tmp_ptr);
4608
	4612	static LLVMValueRef ir_render_slice(CodeGen g, IrExecutable executable, IrInstructionSliceGen *instruction) {
4609	4613	LLVMValueRef array_ptr_ptr = ir_llvm_value(g, instruction->ptr);
4610	4614	ZigType *array_ptr_type = instruction->ptr->value.type;
4611	4615	assert(array_ptr_type->id == ZigTypeIdPointer);
4612	4616	ZigType *array_type = array_ptr_type->data.pointer.child_type;
4613	4617	LLVMValueRef array_ptr = get_handle_value(g, array_ptr_ptr, array_type, array_ptr_type);
4614	4618
4615		LLVMValueRef tmp_struct_ptr = instruction->tmp_ptr;
	4619	LLVMValueRef tmp_struct_ptr = ir_llvm_value(g, instruction->result_loc);
4616	4620
4617	4621	bool want_runtime_safety = instruction->safety_check_on && ir_want_runtime_safety(g, &instruction->base);
4618	4622
...	...	@@ -4630,7 +4634,9 @@ static LLVMValueRef ir_render_slice(CodeGen g, IrExecutable executable, IrInst
4630	4634	end_val = LLVMConstInt(g->builtin_types.entry_usize->llvm_type, array_type->data.array.len, false);
4631	4635	}
4632	4636	if (want_runtime_safety) {
4633		add_bounds_check(g, start_val, LLVMIntEQ, nullptr, LLVMIntULE, end_val);
	4637	if (instruction->start->value.special == ConstValSpecialRuntime \|\| instruction->end) {
	4638	add_bounds_check(g, start_val, LLVMIntEQ, nullptr, LLVMIntULE, end_val);
	4639	}
4634	4640	if (instruction->end) {
4635	4641	LLVMValueRef array_end = LLVMConstInt(g->builtin_types.entry_usize->llvm_type,
4636	4642	array_type->data.array.len, false);
...	...	@@ -5525,6 +5531,7 @@ static LLVMValueRef ir_render_instruction(CodeGen g, IrExecutable executable,
5525	5531	case IrInstructionIdImplicitCast:
5526	5532	case IrInstructionIdResolveResult:
5527	5533	case IrInstructionIdContainerInitList:
	5534	case IrInstructionIdSliceSrc:
5528	5535	zig_unreachable();
5529	5536
5530	5537	case IrInstructionIdDeclVarGen:
...	...	@@ -5595,8 +5602,8 @@ static LLVMValueRef ir_render_instruction(CodeGen g, IrExecutable executable,
5595	5602	return ir_render_memset(g, executable, (IrInstructionMemset *)instruction);
5596	5603	case IrInstructionIdMemcpy:
5597	5604	return ir_render_memcpy(g, executable, (IrInstructionMemcpy *)instruction);
5598		case IrInstructionIdSlice:
5599		return ir_render_slice(g, executable, (IrInstructionSlice *)instruction);
	5605	case IrInstructionIdSliceGen:
	5606	return ir_render_slice(g, executable, (IrInstructionSliceGen *)instruction);
5600	5607	case IrInstructionIdBreakpoint:
5601	5608	return ir_render_breakpoint(g, executable, (IrInstructionBreakpoint *)instruction);
5602	5609	case IrInstructionIdReturnAddress:
...	...	@@ -5697,6 +5704,8 @@ static LLVMValueRef ir_render_instruction(CodeGen g, IrExecutable executable,
5697	5704	return ir_render_assert_non_null(g, executable, (IrInstructionAssertNonNull *)instruction);
5698	5705	case IrInstructionIdResizeSlice:
5699	5706	return ir_render_resize_slice(g, executable, (IrInstructionResizeSlice *)instruction);
	5707	case IrInstructionIdPtrOfArrayToSlice:
	5708	return ir_render_ptr_of_array_to_slice(g, executable, (IrInstructionPtrOfArrayToSlice *)instruction);
5700	5709	}
5701	5710	zig_unreachable();
5702	5711	}
...	...	@@ -6831,9 +6840,6 @@ static void do_code_gen(CodeGen *g) {
6831	6840	slot = &ref_instruction->tmp_ptr;
6832	6841	assert(instruction->value.type->id == ZigTypeIdPointer);
6833	6842	slot_type = instruction->value.type->data.pointer.child_type;
6834		} else if (instruction->id == IrInstructionIdSlice) {
6835		IrInstructionSlice slice_instruction = (IrInstructionSlice )instruction;
6836		slot = &slice_instruction->tmp_ptr;
6837	6843	} else if (instruction->id == IrInstructionIdOptionalWrap) {
6838	6844	IrInstructionOptionalWrap maybe_wrap_instruction = (IrInstructionOptionalWrap )instruction;
6839	6845	slot = &maybe_wrap_instruction->tmp_ptr;

src/ir.cpp+119-53

...	...	@@ -700,8 +700,12 @@ static constexpr IrInstructionId ir_instruction_id(IrInstructionMemcpy *) {
700	700	return IrInstructionIdMemcpy;
701	701	}
702	702
703		static constexpr IrInstructionId ir_instruction_id(IrInstructionSlice *) {
704		return IrInstructionIdSlice;
	703	static constexpr IrInstructionId ir_instruction_id(IrInstructionSliceSrc *) {
	704	return IrInstructionIdSliceSrc;
	705	}
	706
	707	static constexpr IrInstructionId ir_instruction_id(IrInstructionSliceGen *) {
	708	return IrInstructionIdSliceGen;
705	709	}
706	710
707	711	static constexpr IrInstructionId ir_instruction_id(IrInstructionMemberCount *) {
...	...	@@ -880,6 +884,10 @@ static constexpr IrInstructionId ir_instruction_id(IrInstructionResolveResult *)
880	884	return IrInstructionIdResolveResult;
881	885	}
882	886
	887	static constexpr IrInstructionId ir_instruction_id(IrInstructionPtrOfArrayToSlice *) {
	888	return IrInstructionIdPtrOfArrayToSlice;
	889	}
	890
883	891	static constexpr IrInstructionId ir_instruction_id(IrInstructionOpaqueType *) {
884	892	return IrInstructionIdOpaqueType;
885	893	}
...	...	@@ -2216,14 +2224,15 @@ static IrInstruction ir_build_memcpy(IrBuilder irb, Scope scope, AstNode sou
2216	2224	return &instruction->base;
2217	2225	}
2218	2226
2219		static IrInstruction ir_build_slice(IrBuilder irb, Scope scope, AstNode source_node,
2220		IrInstruction ptr, IrInstruction start, IrInstruction *end, bool safety_check_on)
	2227	static IrInstruction ir_build_slice_src(IrBuilder irb, Scope scope, AstNode source_node,
	2228	IrInstruction ptr, IrInstruction start, IrInstruction end, bool safety_check_on, ResultLoc result_loc)
2221	2229	{
2222		IrInstructionSlice *instruction = ir_build_instruction<IrInstructionSlice>(irb, scope, source_node);
	2230	IrInstructionSliceSrc *instruction = ir_build_instruction<IrInstructionSliceSrc>(irb, scope, source_node);
2223	2231	instruction->ptr = ptr;
2224	2232	instruction->start = start;
2225	2233	instruction->end = end;
2226	2234	instruction->safety_check_on = safety_check_on;
	2235	instruction->result_loc = result_loc;
2227	2236
2228	2237	ir_ref_instruction(ptr, irb->current_basic_block);
2229	2238	ir_ref_instruction(start, irb->current_basic_block);
...	...	@@ -2232,6 +2241,26 @@ static IrInstruction ir_build_slice(IrBuilder irb, Scope scope, AstNode sour
2232	2241	return &instruction->base;
2233	2242	}
2234	2243
	2244	static IrInstruction ir_build_slice_gen(IrAnalyze ira, IrInstruction source_instruction, ZigType slice_type,
	2245	IrInstruction ptr, IrInstruction start, IrInstruction end, bool safety_check_on, IrInstruction result_loc)
	2246	{
	2247	IrInstructionSliceGen *instruction = ir_build_instruction<IrInstructionSliceGen>(
	2248	&ira->new_irb, source_instruction->scope, source_instruction->source_node);
	2249	instruction->base.value.type = slice_type;
	2250	instruction->ptr = ptr;
	2251	instruction->start = start;
	2252	instruction->end = end;
	2253	instruction->safety_check_on = safety_check_on;
	2254	instruction->result_loc = result_loc;
	2255
	2256	ir_ref_instruction(ptr, ira->new_irb.current_basic_block);
	2257	ir_ref_instruction(start, ira->new_irb.current_basic_block);
	2258	if (end) ir_ref_instruction(end, ira->new_irb.current_basic_block);
	2259	ir_ref_instruction(result_loc, ira->new_irb.current_basic_block);
	2260
	2261	return &instruction->base;
	2262	}
	2263
2235	2264	static IrInstruction ir_build_member_count(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *container) {
2236	2265	IrInstructionMemberCount *instruction = ir_build_instruction<IrInstructionMemberCount>(irb, scope, source_node);
2237	2266	instruction->container = container;
...	...	@@ -2705,11 +2734,12 @@ static IrInstruction ir_build_align_cast(IrBuilder irb, Scope *scope, AstNode
2705	2734	}
2706	2735
2707	2736	static IrInstruction ir_build_implicit_cast(IrBuilder irb, Scope scope, AstNode source_node,
2708		IrInstruction dest_type, IrInstruction target)
	2737	IrInstruction dest_type, IrInstruction target, ResultLoc *result_loc)
2709	2738	{
2710	2739	IrInstructionImplicitCast *instruction = ir_build_instruction<IrInstructionImplicitCast>(irb, scope, source_node);
2711	2740	instruction->dest_type = dest_type;
2712	2741	instruction->target = target;
	2742	instruction->result_loc = result_loc;
2713	2743
2714	2744	ir_ref_instruction(dest_type, irb->current_basic_block);
2715	2745	ir_ref_instruction(target, irb->current_basic_block);
...	...	@@ -3082,6 +3112,21 @@ static IrInstruction ir_build_vector_to_array(IrAnalyze ira, IrInstruction *so
3082	3112	return &instruction->base;
3083	3113	}
3084	3114
	3115	static IrInstruction ir_build_ptr_of_array_to_slice(IrAnalyze ira, IrInstruction *source_instruction,
	3116	ZigType result_type, IrInstruction operand, IrInstruction *result_loc)
	3117	{
	3118	IrInstructionPtrOfArrayToSlice *instruction = ir_build_instruction<IrInstructionPtrOfArrayToSlice>(&ira->new_irb,
	3119	source_instruction->scope, source_instruction->source_node);
	3120	instruction->base.value.type = result_type;
	3121	instruction->operand = operand;
	3122	instruction->result_loc = result_loc;
	3123
	3124	ir_ref_instruction(operand, ira->new_irb.current_basic_block);
	3125	ir_ref_instruction(result_loc, ira->new_irb.current_basic_block);
	3126
	3127	return &instruction->base;
	3128	}
	3129
3085	3130	static IrInstruction ir_build_array_to_vector(IrAnalyze ira, IrInstruction *source_instruction,
3086	3131	IrInstruction array, ZigType result_type)
3087	3132	{
...	...	@@ -5717,7 +5762,8 @@ static IrInstruction ir_gen_var_decl(IrBuilder irb, Scope scope, AstNode nod
5717	5762	return irb->codegen->invalid_instruction;
5718	5763
5719	5764	if (type_instruction != nullptr) {
5720		IrInstruction *implicit_cast = ir_build_implicit_cast(irb, scope, node, type_instruction, init_value);
	5765	IrInstruction *implicit_cast = ir_build_implicit_cast(irb, scope, node, type_instruction, init_value,
	5766	&result_loc_var->base);
5721	5767	ir_build_end_expr(irb, scope, node, implicit_cast, &result_loc_var->base);
5722	5768	}
5723	5769
...	...	@@ -7086,7 +7132,7 @@ static IrInstruction ir_gen_defer(IrBuilder irb, Scope *parent_scope, AstNode
7086	7132	return ir_build_const_void(irb, parent_scope, node);
7087	7133	}
7088	7134
7089		static IrInstruction ir_gen_slice(IrBuilder irb, Scope scope, AstNode node) {
	7135	static IrInstruction ir_gen_slice(IrBuilder irb, Scope scope, AstNode node, LVal lval, ResultLoc *result_loc) {
7090	7136	assert(node->type == NodeTypeSliceExpr);
7091	7137
7092	7138	AstNodeSliceExpr *slice_expr = &node->data.slice_expr;
...	...	@@ -7111,7 +7157,8 @@ static IrInstruction ir_gen_slice(IrBuilder irb, Scope scope, AstNode node)
7111	7157	end_value = nullptr;
7112	7158	}
7113	7159
7114		return ir_build_slice(irb, scope, node, ptr_value, start_value, end_value, true);
	7160	IrInstruction *slice = ir_build_slice_src(irb, scope, node, ptr_value, start_value, end_value, true, result_loc);
	7161	return ir_lval_wrap(irb, scope, slice, lval, result_loc);
7115	7162	}
7116	7163
7117	7164	static IrInstruction ir_gen_catch(IrBuilder irb, Scope parent_scope, AstNode node, LVal lval,
...	...	@@ -7659,7 +7706,7 @@ static IrInstruction ir_gen_await_expr(IrBuilder irb, Scope scope, AstNode n
7659	7706	IrInstruction *target_promise_type = ir_build_typeof(irb, scope, node, target_inst);
7660	7707	IrInstruction *promise_result_type = ir_build_promise_result_type(irb, scope, node, target_promise_type);
7661	7708	ir_build_await_bookkeeping(irb, scope, node, promise_result_type);
7662		IrInstruction *undef_promise_result = ir_build_implicit_cast(irb, scope, node, promise_result_type, undef);
	7709	IrInstruction *undef_promise_result = ir_build_implicit_cast(irb, scope, node, promise_result_type, undef, nullptr);
7663	7710	build_decl_var_and_init(irb, scope, node, result_var, undef_promise_result, "result", const_bool_false);
7664	7711	IrInstruction *my_result_var_ptr = ir_build_var_ptr(irb, scope, node, result_var);
7665	7712	ir_build_store_ptr(irb, scope, node, result_ptr_field_ptr, my_result_var_ptr);
...	...	@@ -8001,7 +8048,7 @@ static IrInstruction ir_gen_node_raw(IrBuilder irb, AstNode node, Scope scop
8001	8048	case NodeTypeDefer:
8002	8049	return ir_lval_wrap(irb, scope, ir_gen_defer(irb, scope, node), lval, result_loc);
8003	8050	case NodeTypeSliceExpr:
8004		return ir_lval_wrap(irb, scope, ir_gen_slice(irb, scope, node), lval, result_loc);
	8051	return ir_gen_slice(irb, scope, node, lval, result_loc);
8005	8052	case NodeTypeCatchExpr:
8006	8053	return ir_gen_catch(irb, scope, node, lval, result_loc);
8007	8054	case NodeTypeContainerDecl:
...	...	@@ -8028,15 +8075,19 @@ static IrInstruction ir_gen_node_raw(IrBuilder irb, AstNode node, Scope scop
8028	8075	zig_unreachable();
8029	8076	}
8030	8077
	8078	static ResultLoc *no_result_loc(void) {
	8079	ResultLocNone *result_loc_none = allocate<ResultLocNone>(1);
	8080	result_loc_none->base.id = ResultLocIdNone;
	8081	return &result_loc_none->base;
	8082	}
	8083
8031	8084	static IrInstruction ir_gen_node_extra(IrBuilder irb, AstNode node, Scope scope, LVal lval,
8032	8085	ResultLoc *result_loc)
8033	8086	{
8034	8087	if (result_loc == nullptr) {
8035	8088	// Create a result location indicating there is none - but if one gets created
8036	8089	// it will be properly distributed.
8037		ResultLocNone *result_loc_none = allocate<ResultLocNone>(1);
8038		result_loc_none->base.id = ResultLocIdNone;
8039		result_loc = &result_loc_none->base;
	8090	result_loc = no_result_loc();
8040	8091	}
8041	8092	IrInstruction *result = ir_gen_node_raw(irb, node, scope, lval, result_loc);
8042	8093	irb->exec->invalid = irb->exec->invalid \|\| (result == irb->codegen->invalid_instruction);
...	...	@@ -8098,7 +8149,7 @@ bool ir_gen(CodeGen codegen, AstNode node, Scope scope, IrExecutable ir_exec
8098	8149	// TODO mark this var decl as "no safety" e.g. disable initializing the undef value to 0xaa
8099	8150	ZigType *coro_frame_type = get_promise_frame_type(irb->codegen, return_type);
8100	8151	IrInstruction *coro_frame_type_value = ir_build_const_type(irb, coro_scope, node, coro_frame_type);
8101		IrInstruction *undef_coro_frame = ir_build_implicit_cast(irb, coro_scope, node, coro_frame_type_value, undef);
	8152	IrInstruction *undef_coro_frame = ir_build_implicit_cast(irb, coro_scope, node, coro_frame_type_value, undef, nullptr);
8102	8153	build_decl_var_and_init(irb, coro_scope, node, promise_var, undef_coro_frame, "promise", const_bool_false);
8103	8154	coro_promise_ptr = ir_build_var_ptr(irb, coro_scope, node, promise_var);
8104	8155
...	...	@@ -8106,7 +8157,7 @@ bool ir_gen(CodeGen codegen, AstNode node, Scope scope, IrExecutable ir_exec
8106	8157	IrInstruction *null_value = ir_build_const_null(irb, coro_scope, node);
8107	8158	IrInstruction *await_handle_type_val = ir_build_const_type(irb, coro_scope, node,
8108	8159	get_optional_type(irb->codegen, irb->codegen->builtin_types.entry_promise));
8109		IrInstruction *null_await_handle = ir_build_implicit_cast(irb, coro_scope, node, await_handle_type_val, null_value);
	8160	IrInstruction *null_await_handle = ir_build_implicit_cast(irb, coro_scope, node, await_handle_type_val, null_value, nullptr);
8110	8161	build_decl_var_and_init(irb, coro_scope, node, await_handle_var, null_await_handle, "await_handle", const_bool_false);
8111	8162	irb->exec->await_handle_var_ptr = ir_build_var_ptr(irb, coro_scope, node, await_handle_var);
8112	8163
...	...	@@ -8169,7 +8220,7 @@ bool ir_gen(CodeGen codegen, AstNode node, Scope scope, IrExecutable ir_exec
8169	8220	Buf *instruction_addresses_name = buf_create_from_str("instruction_addresses");
8170	8221	IrInstruction *addrs_slice_ptr = ir_build_field_ptr(irb, scope, node, err_ret_trace_ptr, instruction_addresses_name, false);
8171	8222
8172		IrInstruction *slice_value = ir_build_slice(irb, scope, node, return_addresses_ptr, zero, nullptr, false);
	8223	IrInstruction *slice_value = ir_build_slice_src(irb, scope, node, return_addresses_ptr, zero, nullptr, false, no_result_loc());
8173	8224	ir_build_store_ptr(irb, scope, node, addrs_slice_ptr, slice_value);
8174	8225	}
8175	8226
...	...	@@ -8275,7 +8326,8 @@ bool ir_gen(CodeGen codegen, AstNode node, Scope scope, IrExecutable ir_exec
8275	8326	IrInstruction *coro_mem_ptr_ref = ir_build_ref(irb, scope, node, coro_mem_ptr, true, false);
8276	8327	IrInstruction *coro_size_ptr = ir_build_var_ptr(irb, scope, node, coro_size_var);
8277	8328	IrInstruction *coro_size = ir_build_load_ptr(irb, scope, node, coro_size_ptr);
8278		IrInstruction *mem_slice = ir_build_slice(irb, scope, node, coro_mem_ptr_ref, zero, coro_size, false);
	8329	IrInstruction *mem_slice = ir_build_slice_src(irb, scope, node, coro_mem_ptr_ref, zero, coro_size, false,
	8330	no_result_loc());
8279	8331	size_t arg_count = 5;
8280	8332	IrInstruction *args = allocate<IrInstruction >(arg_count);
8281	8333	args[0] = implicit_allocator_ptr; // self
...	...	@@ -10417,7 +10469,6 @@ static bool eval_const_expr_implicit_cast(IrAnalyze ira, IrInstruction source_
10417	10469	zig_unreachable();
10418	10470	case CastOpErrSet:
10419	10471	case CastOpBitCast:
10420		case CastOpPtrOfArrayToSlice:
10421	10472	zig_panic("TODO");
10422	10473	case CastOpNoop:
10423	10474	{
...	...	@@ -10574,7 +10625,7 @@ static IrInstruction ir_resolve_ptr_of_array_to_unknown_len_ptr(IrAnalyze ira,
10574	10625	}
10575	10626
10576	10627	static IrInstruction ir_resolve_ptr_of_array_to_slice(IrAnalyze ira, IrInstruction *source_instr,
10577		IrInstruction value, ZigType wanted_type)
	10628	IrInstruction value, ZigType wanted_type, ResultLoc *result_loc)
10578	10629	{
10579	10630	Error err;
10580	10631
...	...	@@ -10605,11 +10656,12 @@ static IrInstruction ir_resolve_ptr_of_array_to_slice(IrAnalyze ira, IrInstruc
10605	10656	}
10606	10657	}
10607	10658
10608		IrInstruction *result = ir_build_cast(&ira->new_irb, source_instr->scope, source_instr->source_node,
10609		wanted_type, value, CastOpPtrOfArrayToSlice);
10610		result->value.type = wanted_type;
10611		ir_add_alloca(ira, result, wanted_type);
10612		return result;
	10659	if (result_loc == nullptr) result_loc = no_result_loc();
	10660	IrInstruction *result_loc_inst = ir_resolve_result(ira, source_instr, result_loc, wanted_type, nullptr);
	10661	if (type_is_invalid(result_loc_inst->value.type) \|\| instr_is_unreachable(result_loc_inst)) {
	10662	return result_loc_inst;
	10663	}
	10664	return ir_build_ptr_of_array_to_slice(ira, source_instr, wanted_type, value, result_loc_inst);
10613	10665	}
10614	10666
10615	10667	static IrBasicBlock ir_get_new_bb(IrAnalyze ira, IrBasicBlock old_bb, IrInstruction ref_old_instruction) {
...	...	@@ -11195,7 +11247,7 @@ static IrInstruction ir_get_ref(IrAnalyze ira, IrInstruction *source_instructi
11195	11247	}
11196	11248
11197	11249	static IrInstruction ir_analyze_array_to_slice(IrAnalyze ira, IrInstruction *source_instr,
11198		IrInstruction array_arg, ZigType wanted_type)
	11250	IrInstruction array_arg, ZigType wanted_type, ResultLoc *result_loc)
11199	11251	{
11200	11252	assert(is_slice(wanted_type));
11201	11253	// In this function we honor the const-ness of wanted_type, because
...	...	@@ -11227,12 +11279,14 @@ static IrInstruction ir_analyze_array_to_slice(IrAnalyze ira, IrInstruction *s
11227	11279
11228	11280	if (!array_ptr) array_ptr = ir_get_ref(ira, source_instr, array, true, false);
11229	11281
11230		IrInstruction *result = ir_build_slice(&ira->new_irb, source_instr->scope,
11231		source_instr->source_node, array_ptr, start, end, false);
11232		result->value.type = wanted_type;
	11282	if (result_loc == nullptr) result_loc = no_result_loc();
	11283	IrInstruction *result_loc_inst = ir_resolve_result(ira, source_instr, result_loc, wanted_type, nullptr);
	11284	if (type_is_invalid(result_loc_inst->value.type) \|\| instr_is_unreachable(result_loc_inst)) {
	11285	return result_loc_inst;
	11286	}
	11287	IrInstruction *result = ir_build_slice_gen(ira, source_instr, wanted_type, array_ptr, start, end, false, result_loc_inst);
11233	11288	result->value.data.rh_slice.id = RuntimeHintSliceIdLen;
11234	11289	result->value.data.rh_slice.len = array_type->data.array.len;
11235		ir_add_alloca(ira, result, result->value.type);
11236	11290
11237	11291	return result;
11238	11292	}
...	...	@@ -11929,7 +11983,7 @@ static bool is_pointery_and_elem_is_not_pointery(ZigType *ty) {
11929	11983	}
11930	11984
11931	11985	static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_instr,
11932		ZigType wanted_type, IrInstruction value)
	11986	ZigType wanted_type, IrInstruction value, ResultLoc *result_loc)
11933	11987	{
11934	11988	Error err;
11935	11989	ZigType *actual_type = value->value.type;
...	...	@@ -12017,11 +12071,11 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
12017	12071	actual_type->id == ZigTypeIdComptimeInt \|\|
12018	12072	actual_type->id == ZigTypeIdComptimeFloat)
12019	12073	{
12020		IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, wanted_type->data.error_union.payload_type, value);
	12074	IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, wanted_type->data.error_union.payload_type, value, nullptr);
12021	12075	if (type_is_invalid(cast1->value.type))
12022	12076	return ira->codegen->invalid_instruction;
12023	12077
12024		IrInstruction *cast2 = ir_analyze_cast(ira, source_instr, wanted_type, cast1);
	12078	IrInstruction *cast2 = ir_analyze_cast(ira, source_instr, wanted_type, cast1, result_loc);
12025	12079	if (type_is_invalid(cast2->value.type))
12026	12080	return ira->codegen->invalid_instruction;
12027	12081
...	...	@@ -12103,7 +12157,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
12103	12157	types_match_const_cast_only(ira, ptr_type->data.pointer.child_type, actual_type->data.array.child_type,
12104	12158	source_node, false).id == ConstCastResultIdOk)
12105	12159	{
12106		return ir_analyze_array_to_slice(ira, source_instr, value, wanted_type);
	12160	return ir_analyze_array_to_slice(ira, source_instr, value, wanted_type, result_loc);
12107	12161	}
12108	12162	}
12109	12163
...	...	@@ -12120,11 +12174,11 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
12120	12174	types_match_const_cast_only(ira, ptr_type->data.pointer.child_type, actual_type->data.array.child_type,
12121	12175	source_node, false).id == ConstCastResultIdOk)
12122	12176	{
12123		IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, wanted_type->data.maybe.child_type, value);
	12177	IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, wanted_type->data.maybe.child_type, value, nullptr);
12124	12178	if (type_is_invalid(cast1->value.type))
12125	12179	return ira->codegen->invalid_instruction;
12126	12180
12127		IrInstruction *cast2 = ir_analyze_cast(ira, source_instr, wanted_type, cast1);
	12181	IrInstruction *cast2 = ir_analyze_cast(ira, source_instr, wanted_type, cast1, result_loc);
12128	12182	if (type_is_invalid(cast2->value.type))
12129	12183	return ira->codegen->invalid_instruction;
12130	12184
...	...	@@ -12167,7 +12221,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
12167	12221	array_type->data.array.child_type, source_node,
12168	12222	!slice_ptr_type->data.pointer.is_const).id == ConstCastResultIdOk)
12169	12223	{
12170		return ir_resolve_ptr_of_array_to_slice(ira, source_instr, value, wanted_type);
	12224	return ir_resolve_ptr_of_array_to_slice(ira, source_instr, value, wanted_type, result_loc);
12171	12225	}
12172	12226	}
12173	12227
...	...	@@ -12198,11 +12252,11 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
12198	12252	types_match_const_cast_only(ira, ptr_type->data.pointer.child_type, actual_type->data.array.child_type,
12199	12253	source_node, false).id == ConstCastResultIdOk)
12200	12254	{
12201		IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, wanted_type->data.error_union.payload_type, value);
	12255	IrInstruction *cast1 = ir_analyze_cast(ira, source_instr, wanted_type->data.error_union.payload_type, value, nullptr);
12202	12256	if (type_is_invalid(cast1->value.type))
12203	12257	return ira->codegen->invalid_instruction;
12204	12258
12205		IrInstruction *cast2 = ir_analyze_cast(ira, source_instr, wanted_type, cast1);
	12259	IrInstruction *cast2 = ir_analyze_cast(ira, source_instr, wanted_type, cast1, result_loc);
12206	12260	if (type_is_invalid(cast2->value.type))
12207	12261	return ira->codegen->invalid_instruction;
12208	12262
...	...	@@ -12380,7 +12434,9 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
12380	12434	return ira->codegen->invalid_instruction;
12381	12435	}
12382	12436
12383		static IrInstruction ir_implicit_cast(IrAnalyze ira, IrInstruction value, ZigType expected_type) {
	12437	static IrInstruction ir_implicit_cast_with_result(IrAnalyze ira, IrInstruction value, ZigType expected_type,
	12438	ResultLoc *result_loc)
	12439	{
12384	12440	assert(value);
12385	12441	assert(value != ira->codegen->invalid_instruction);
12386	12442	assert(!expected_type \|\| !type_is_invalid(expected_type));
...	...	@@ -12393,7 +12449,11 @@ static IrInstruction ir_implicit_cast(IrAnalyze ira, IrInstruction *value, Zig
12393	12449	if (value->value.type->id == ZigTypeIdUnreachable)
12394	12450	return value;
12395	12451
12396		return ir_analyze_cast(ira, value, expected_type, value);
	12452	return ir_analyze_cast(ira, value, expected_type, value, result_loc);
	12453	}
	12454
	12455	static IrInstruction ir_implicit_cast(IrAnalyze ira, IrInstruction value, ZigType expected_type) {
	12456	return ir_implicit_cast_with_result(ira, value, expected_type, nullptr);
12397	12457	}
12398	12458
12399	12459	static IrInstruction ir_get_deref(IrAnalyze ira, IrInstruction source_instruction, IrInstruction ptr) {
...	...	@@ -14744,7 +14804,7 @@ static IrInstruction ir_analyze_instruction_implicit_cast(IrAnalyze ira, IrIns
14744	14804	if (type_is_invalid(target->value.type))
14745	14805	return ira->codegen->invalid_instruction;
14746	14806
14747		return ir_implicit_cast(ira, target, dest_type);
	14807	return ir_implicit_cast_with_result(ira, target, dest_type, instruction->result_loc);
14748	14808	}
14749	14809
14750	14810	static IrInstruction ir_analyze_instruction_resolve_result(IrAnalyze ira, IrInstructionResolveResult *instruction) {
...	...	@@ -15687,7 +15747,8 @@ static IrInstruction ir_analyze_instruction_call(IrAnalyze ira, IrInstructionC
15687	15747
15688	15748	IrInstruction *arg = call_instruction->args[0]->child;
15689	15749
15690		IrInstruction *cast_instruction = ir_analyze_cast(ira, &call_instruction->base, dest_type, arg);
	15750	IrInstruction *cast_instruction = ir_analyze_cast(ira, &call_instruction->base, dest_type, arg,
	15751	call_instruction->result_loc);
15691	15752	if (type_is_invalid(cast_instruction->value.type))
15692	15753	return ira->codegen->invalid_instruction;
15693	15754	return ir_finish_anal(ira, cast_instruction);
...	...	@@ -21165,7 +21226,7 @@ static IrInstruction ir_analyze_instruction_memcpy(IrAnalyze ira, IrInstructio
21165	21226	return result;
21166	21227	}
21167	21228
21168		static IrInstruction ir_analyze_instruction_slice(IrAnalyze ira, IrInstructionSlice *instruction) {
	21229	static IrInstruction ir_analyze_instruction_slice(IrAnalyze ira, IrInstructionSliceSrc *instruction) {
21169	21230	IrInstruction *ptr_ptr = instruction->ptr->child;
21170	21231	if (type_is_invalid(ptr_ptr->value.type))
21171	21232	return ira->codegen->invalid_instruction;
...	...	@@ -21454,12 +21515,13 @@ static IrInstruction ir_analyze_instruction_slice(IrAnalyze ira, IrInstruction
21454	21515	return result;
21455	21516	}
21456	21517
21457		IrInstruction *new_instruction = ir_build_slice(&ira->new_irb,
21458		instruction->base.scope, instruction->base.source_node,
21459		ptr_ptr, casted_start, end, instruction->safety_check_on);
21460		new_instruction->value.type = return_type;
21461		ir_add_alloca(ira, new_instruction, return_type);
21462		return new_instruction;
	21518	IrInstruction *result_loc = ir_resolve_result(ira, &instruction->base, instruction->result_loc,
	21519	return_type, nullptr);
	21520	if (type_is_invalid(result_loc->value.type) \|\| instr_is_unreachable(result_loc)) {
	21521	return result_loc;
	21522	}
	21523	return ir_build_slice_gen(ira, &instruction->base, return_type,
	21524	ptr_ptr, casted_start, end, instruction->safety_check_on, result_loc);
21463	21525	}
21464	21526
21465	21527	static IrInstruction ir_analyze_instruction_member_count(IrAnalyze ira, IrInstructionMemberCount *instruction) {
...	...	@@ -23900,6 +23962,7 @@ static IrInstruction ir_analyze_instruction_base(IrAnalyze ira, IrInstruction
23900	23962	case IrInstructionIdCmpxchgGen:
23901	23963	case IrInstructionIdArrayToVector:
23902	23964	case IrInstructionIdVectorToArray:
	23965	case IrInstructionIdPtrOfArrayToSlice:
23903	23966	case IrInstructionIdAssertZero:
23904	23967	case IrInstructionIdAssertNonNull:
23905	23968	case IrInstructionIdResizeSlice:
...	...	@@ -23908,6 +23971,7 @@ static IrInstruction ir_analyze_instruction_base(IrAnalyze ira, IrInstruction
23908	23971	case IrInstructionIdCallGen:
23909	23972	case IrInstructionIdReturnPtr:
23910	23973	case IrInstructionIdAllocaGen:
	23974	case IrInstructionIdSliceGen:
23911	23975	zig_unreachable();
23912	23976
23913	23977	case IrInstructionIdReturn:
...	...	@@ -24042,8 +24106,8 @@ static IrInstruction ir_analyze_instruction_base(IrAnalyze ira, IrInstruction
24042	24106	return ir_analyze_instruction_memset(ira, (IrInstructionMemset *)instruction);
24043	24107	case IrInstructionIdMemcpy:
24044	24108	return ir_analyze_instruction_memcpy(ira, (IrInstructionMemcpy *)instruction);
24045		case IrInstructionIdSlice:
24046		return ir_analyze_instruction_slice(ira, (IrInstructionSlice *)instruction);
	24109	case IrInstructionIdSliceSrc:
	24110	return ir_analyze_instruction_slice(ira, (IrInstructionSliceSrc *)instruction);
24047	24111	case IrInstructionIdMemberCount:
24048	24112	return ir_analyze_instruction_member_count(ira, (IrInstructionMemberCount *)instruction);
24049	24113	case IrInstructionIdMemberType:
...	...	@@ -24321,6 +24385,8 @@ bool ir_has_side_effects(IrInstruction *instruction) {
24321	24385	case IrInstructionIdGlobalAsm:
24322	24386	case IrInstructionIdUndeclaredIdent:
24323	24387	case IrInstructionIdEndExpr:
	24388	case IrInstructionIdPtrOfArrayToSlice:
	24389	case IrInstructionIdSliceGen:
24324	24390	return true;
24325	24391
24326	24392	case IrInstructionIdPhi:
...	...	@@ -24360,7 +24426,7 @@ bool ir_has_side_effects(IrInstruction *instruction) {
24360	24426	case IrInstructionIdIntType:
24361	24427	case IrInstructionIdVectorType:
24362	24428	case IrInstructionIdBoolNot:
24363		case IrInstructionIdSlice:
	24429	case IrInstructionIdSliceSrc:
24364	24430	case IrInstructionIdMemberCount:
24365	24431	case IrInstructionIdMemberType:
24366	24432	case IrInstructionIdMemberName:

src/ir_print.cpp+29-4

...	...	@@ -858,14 +858,26 @@ static void ir_print_memcpy(IrPrint irp, IrInstructionMemcpy instruction) {
858	858	fprintf(irp->f, ")");
859	859	}
860	860
861		static void ir_print_slice(IrPrint irp, IrInstructionSlice instruction) {
	861	static void ir_print_slice_src(IrPrint irp, IrInstructionSliceSrc instruction) {
862	862	ir_print_other_instruction(irp, instruction->ptr);
863	863	fprintf(irp->f, "[");
864	864	ir_print_other_instruction(irp, instruction->start);
865	865	fprintf(irp->f, "..");
866	866	if (instruction->end)
867	867	ir_print_other_instruction(irp, instruction->end);
868		fprintf(irp->f, "]");
	868	fprintf(irp->f, "]result=");
	869	ir_print_result_loc(irp, instruction->result_loc);
	870	}
	871
	872	static void ir_print_slice_gen(IrPrint irp, IrInstructionSliceGen instruction) {
	873	ir_print_other_instruction(irp, instruction->ptr);
	874	fprintf(irp->f, "[");
	875	ir_print_other_instruction(irp, instruction->start);
	876	fprintf(irp->f, "..");
	877	if (instruction->end)
	878	ir_print_other_instruction(irp, instruction->end);
	879	fprintf(irp->f, "]result=");
	880	ir_print_other_instruction(irp, instruction->result_loc);
869	881	}
870	882
871	883	static void ir_print_member_count(IrPrint irp, IrInstructionMemberCount instruction) {
...	...	@@ -1086,6 +1098,13 @@ static void ir_print_vector_to_array(IrPrint irp, IrInstructionVectorToArray i
1086	1098	fprintf(irp->f, ")");
1087	1099	}
1088	1100
	1101	static void ir_print_ptr_of_array_to_slice(IrPrint irp, IrInstructionPtrOfArrayToSlice instruction) {
	1102	fprintf(irp->f, "PtrOfArrayToSlice(");
	1103	ir_print_other_instruction(irp, instruction->operand);
	1104	fprintf(irp->f, ")result=");
	1105	ir_print_other_instruction(irp, instruction->result_loc);
	1106	}
	1107
1089	1108	static void ir_print_assert_zero(IrPrint irp, IrInstructionAssertZero instruction) {
1090	1109	fprintf(irp->f, "AssertZero(");
1091	1110	ir_print_other_instruction(irp, instruction->target);
...	...	@@ -1758,8 +1777,11 @@ static void ir_print_instruction(IrPrint irp, IrInstruction instruction) {
1758	1777	case IrInstructionIdMemcpy:
1759	1778	ir_print_memcpy(irp, (IrInstructionMemcpy *)instruction);
1760	1779	break;
1761		case IrInstructionIdSlice:
1762		ir_print_slice(irp, (IrInstructionSlice *)instruction);
	1780	case IrInstructionIdSliceSrc:
	1781	ir_print_slice_src(irp, (IrInstructionSliceSrc *)instruction);
	1782	break;
	1783	case IrInstructionIdSliceGen:
	1784	ir_print_slice_gen(irp, (IrInstructionSliceGen *)instruction);
1763	1785	break;
1764	1786	case IrInstructionIdMemberCount:
1765	1787	ir_print_member_count(irp, (IrInstructionMemberCount *)instruction);
...	...	@@ -1992,6 +2014,9 @@ static void ir_print_instruction(IrPrint irp, IrInstruction instruction) {
1992	2014	case IrInstructionIdVectorToArray:
1993	2015	ir_print_vector_to_array(irp, (IrInstructionVectorToArray *)instruction);
1994	2016	break;
	2017	case IrInstructionIdPtrOfArrayToSlice:
	2018	ir_print_ptr_of_array_to_slice(irp, (IrInstructionPtrOfArrayToSlice *)instruction);
	2019	break;
1995	2020	case IrInstructionIdAssertZero:
1996	2021	ir_print_assert_zero(irp, (IrInstructionAssertZero *)instruction);
1997	2022	break;