Commit 771e88951a9af48335abe14e4c44b5c4f5b252de | zig

author	Andrew Kelley <andrew@ziglang.org> 2019-06-08 18:51:31-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2019-06-08 18:51:31-04:00
log	771e88951a9af48335abe14e4c44b5c4f5b252de
tree	c6b4831bd61ba18dc819e6ebce1f50b841b4ad80
parent	52eb34718862928b5d83c58990d5d7a6b07e20e2
signature	Commit is signed but in an unrecognized format.

result location mechanism for struct initialization

```zig
export fn entry() void {
    const static = Foo{
        .x = 9,
        .bar = Bar{ .y = 10 },
    };
    const runtime = foo(true);
}

fn foo(c: bool) Foo {
    return Foo{
        .x = 12,
        .bar = if (c) bar1() else bar2(),
    };
}

fn bar1() Bar {
    return Bar{ .y = 34 };
}

fn bar2() Bar {
    return Bar{ .y = 56 };
}
```

```llvm
@0 = internal unnamed_addr constant %Foo { i32 9, %Bar { i32 10 } }, align 4
@1 = internal unnamed_addr constant %Bar { i32 34 }, align 4
@2 = internal unnamed_addr constant %Bar { i32 56 }, align 4

define void @entry() #2 !dbg !35 {
Entry:
  %runtime = alloca %Foo, align 4
  call void @llvm.dbg.declare(metadata %Foo* @0, metadata !39, metadata !DIExpression()), !dbg !50
  call fastcc void @foo(%Foo* sret %runtime, i1 true), !dbg !51
  call void @llvm.dbg.declare(metadata %Foo* %runtime, metadata !49, metadata !DIExpression()), !dbg !52
  ret void, !dbg !53
}

define internal fastcc void @foo(%Foo* nonnull sret, i1) unnamed_addr #2 !dbg !54 {
Entry:
  %c = alloca i1, align 1
  store i1 %1, i1* %c, align 1
  call void @llvm.dbg.declare(metadata i1* %c, metadata !60, metadata !DIExpression()), !dbg !61
  %2 = getelementptr inbounds %Foo, %Foo* %0, i32 0, i32 0, !dbg !62
  store i32 12, i32* %2, align 4, !dbg !62
  %3 = getelementptr inbounds %Foo, %Foo* %0, i32 0, i32 1, !dbg !64
  %4 = load i1, i1* %c, align 1, !dbg !65
  br i1 %4, label %Then, label %Else, !dbg !65

Then:                                             ; preds = %Entry
  call fastcc void @bar1(%Bar* sret %3), !dbg !66
  br label %EndIf, !dbg !64

Else:                                             ; preds = %Entry
  call fastcc void @bar2(%Bar* sret %3), !dbg !67
  br label %EndIf, !dbg !64

EndIf:                                            ; preds = %Else, %Then
  ret void, !dbg !68
}

define internal fastcc void @bar1(%Bar* nonnull sret) unnamed_addr #2 !dbg !69 {
Entry:
  %1 = bitcast %Bar* %0 to i8*, !dbg !73
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %1, i8* align 4 bitcast (%Bar* @1 to i8*), i64 4, i1 false), !dbg !73
  ret void, !dbg !73
}

define internal fastcc void @bar2(%Bar* nonnull sret) unnamed_addr #2 !dbg !75 {
Entry:
  %1 = bitcast %Bar* %0 to i8*, !dbg !76
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %1, i8* align 4 bitcast (%Bar* @2 to i8*), i64 4, i1 false), !dbg !76
  ret void, !dbg !76
}

!39 = !DILocalVariable(name: "static", scope: !40, file: !5, line: 2, type: !41)
!49 = !DILocalVariable(name: "runtime", scope: !40, file: !5, line: 6, type: !41)
```

7 files changed, 270 insertions(+), 143 deletions(-)

BRANCH_TODO
src

BRANCH_TODO+2-6

...	...	@@ -1,8 +1,8 @@
1	1	Scratch pad for stuff to do before merging master
2	2	=================================================
3	3
4		* struct initializations
5		* function call parameters
	4	* array initializations
	5	* union initializations
6	6	* bitCast
7	7
8	8	look at all the ir_gen_node ir_gen_node_extra calls and make sure result locations are properly propagated
...	...	@@ -25,7 +25,3 @@ inferred comptime
25	25	return ir_build_ref(irb, scope, value->source_node, value, false, false);
26	26
27	27	handle if with no else
28
29
30
31

src/all_types.hpp+34-15

...	...	@@ -1957,6 +1957,7 @@ enum ScopeId {
1957	1957	ScopeIdCompTime,
1958	1958	ScopeIdCoroPrelude,
1959	1959	ScopeIdRuntime,
	1960	ScopeIdElide,
1960	1961	};
1961	1962
1962	1963	struct Scope {
...	...	@@ -1970,6 +1971,14 @@ struct Scope {
1970	1971	ScopeId id;
1971	1972	};
1972	1973
	1974	// This scope, when activated, causes all the instructions in the scope to be omitted
	1975	// from the generated code.
	1976	struct ScopeElide {
	1977	Scope base;
	1978
	1979	bool activated;
	1980	};
	1981
1973	1982	// This scope comes from global declarations or from
1974	1983	// declarations in a container declaration
1975	1984	// NodeTypeContainerDecl
...	...	@@ -2189,7 +2198,6 @@ enum IrInstructionId {
2189	2198	IrInstructionIdResizeSlice,
2190	2199	IrInstructionIdContainerInitList,
2191	2200	IrInstructionIdContainerInitFields,
2192		IrInstructionIdStructInit,
2193	2201	IrInstructionIdUnionInit,
2194	2202	IrInstructionIdUnreachable,
2195	2203	IrInstructionIdTypeOf,
...	...	@@ -2279,6 +2287,7 @@ enum IrInstructionId {
2279	2287	IrInstructionIdPtrType,
2280	2288	IrInstructionIdAlignCast,
2281	2289	IrInstructionIdImplicitCast,
	2290	IrInstructionIdResolveResult,
2282	2291	IrInstructionIdOpaqueType,
2283	2292	IrInstructionIdSetAlignStack,
2284	2293	IrInstructionIdArgType,
...	...	@@ -2366,6 +2375,7 @@ struct IrInstructionCondBr {
2366	2375	IrBasicBlock *then_block;
2367	2376	IrBasicBlock *else_block;
2368	2377	IrInstruction *is_comptime;
	2378	ResultLoc *result_loc;
2369	2379	};
2370	2380
2371	2381	struct IrInstructionBr {
...	...	@@ -2646,20 +2656,6 @@ struct IrInstructionContainerInitFields {
2646	2656	IrInstructionContainerInitFieldsField *fields;
2647	2657	};
2648	2658
2649		struct IrInstructionStructInitField {
2650		IrInstruction *value;
2651		TypeStructField *type_struct_field;
2652		};
2653
2654		struct IrInstructionStructInit {
2655		IrInstruction base;
2656
2657		ZigType *struct_type;
2658		size_t field_count;
2659		IrInstructionStructInitField *fields;
2660		LLVMValueRef tmp_ptr;
2661		};
2662
2663	2659	struct IrInstructionUnionInit {
2664	2660	IrInstruction base;
2665	2661
...	...	@@ -3581,13 +3577,22 @@ struct IrInstructionImplicitCast {
3581	3577	IrInstruction *target;
3582	3578	};
3583	3579
	3580	struct IrInstructionResolveResult {
	3581	IrInstruction base;
	3582
	3583	ResultLoc *result_loc;
	3584	IrInstruction *ty;
	3585	};
	3586
3584	3587	enum ResultLocId {
3585	3588	ResultLocIdInvalid,
3586	3589	ResultLocIdNone,
3587	3590	ResultLocIdVar,
	3591	ResultLocIdField,
3588	3592	ResultLocIdReturn,
3589	3593	ResultLocIdPeer,
3590	3594	ResultLocIdPeerParent,
	3595	ResultLocIdInstruction,
3591	3596	};
3592	3597
3593	3598	struct ResultLoc {
...	...	@@ -3597,6 +3602,7 @@ struct ResultLoc {
3597	3602	IrInstruction *source_instruction;
3598	3603	IrInstruction *gen_instruction; // value to store to the result loc
3599	3604	ZigType *implicit_elem_type;
	3605	ScopeElide *scope_elide;
3600	3606	};
3601	3607
3602	3608	struct ResultLocNone {
...	...	@@ -3609,6 +3615,14 @@ struct ResultLocVar {
3609	3615	ZigVar *var;
3610	3616	};
3611	3617
	3618	struct ResultLocField {
	3619	ResultLoc base;
	3620
	3621	ResultLoc *parent;
	3622	Buf *name;
	3623	IrInstruction *container_type;
	3624	};
	3625
3612	3626	struct ResultLocReturn {
3613	3627	ResultLoc base;
3614	3628	};
...	...	@@ -3636,6 +3650,11 @@ struct ResultLocPeer {
3636	3650	IrSuspendPosition suspend_pos;
3637	3651	};
3638	3652
	3653	// The result location is the source instruction
	3654	struct ResultLocInstruction {
	3655	ResultLoc base;
	3656	};
	3657
3639	3658	static const size_t slice_ptr_index = 0;
3640	3659	static const size_t slice_len_index = 1;
3641	3660

src/analyze.cpp+6

...	...	@@ -166,6 +166,12 @@ Scope create_runtime_scope(CodeGen g, AstNode node, Scope parent, IrInstruct
166	166	return &scope->base;
167	167	}
168	168
	169	ScopeElide create_elide_scope(CodeGen g, AstNode node, Scope parent) {
	170	ScopeElide *scope = allocate<ScopeElide>(1);
	171	init_scope(g, &scope->base, ScopeIdElide, node, parent);
	172	return scope;
	173	}
	174
169	175	ScopeSuspend create_suspend_scope(CodeGen g, AstNode node, Scope parent) {
170	176	assert(node->type == NodeTypeSuspend);
171	177	ScopeSuspend *scope = allocate<ScopeSuspend>(1);

src/analyze.hpp+1

...	...	@@ -121,6 +121,7 @@ ScopeFnDef create_fndef_scope(CodeGen g, AstNode node, Scope parent, ZigFn *
121	121	Scope create_comptime_scope(CodeGen g, AstNode node, Scope parent);
122	122	Scope create_coro_prelude_scope(CodeGen g, AstNode node, Scope parent);
123	123	Scope create_runtime_scope(CodeGen g, AstNode node, Scope parent, IrInstruction *is_comptime);
	124	ScopeElide create_elide_scope(CodeGen g, AstNode node, Scope parent);
124	125
125	126	void init_const_str_lit(CodeGen g, ConstExprValue const_val, Buf *str);
126	127	ConstExprValue create_const_str_lit(CodeGen g, Buf *str);

src/codegen.cpp+39-34

...	...	@@ -715,6 +715,7 @@ static ZigLLVMDIScope get_di_scope(CodeGen g, Scope *scope) {
715	715	case ScopeIdCompTime:
716	716	case ScopeIdCoroPrelude:
717	717	case ScopeIdRuntime:
	718	case ScopeIdElide:
718	719	return get_di_scope(g, scope->parent);
719	720	}
720	721	zig_unreachable();
...	...	@@ -2383,7 +2384,6 @@ static LLVMValueRef ir_render_save_err_ret_addr(CodeGen g, IrExecutable execut
2383	2384	}
2384	2385
2385	2386	static LLVMValueRef ir_render_return(CodeGen g, IrExecutable executable, IrInstructionReturn *return_instruction) {
2386		LLVMValueRef value = ir_llvm_value(g, return_instruction->value);
2387	2387	ZigType *return_type = return_instruction->value->value.type;
2388	2388
2389	2389	if (want_first_arg_sret(g, &g->cur_fn->type_entry->data.fn.fn_type_id)) {
...	...	@@ -2391,13 +2391,16 @@ static LLVMValueRef ir_render_return(CodeGen g, IrExecutable executable, IrIns
2391	2391	if (return_instruction->value->value.special != ConstValSpecialRuntime) {
2392	2392	// if it's comptime we have to do this but if it's runtime trust that
2393	2393	// result location mechanism took care of it.
	2394	LLVMValueRef value = ir_llvm_value(g, return_instruction->value);
2394	2395	gen_assign_raw(g, g->cur_ret_ptr, get_pointer_to_type(g, return_type, false), value);
2395	2396	}
2396	2397	LLVMBuildRetVoid(g->builder);
2397	2398	} else if (handle_is_ptr(return_type)) {
	2399	LLVMValueRef value = ir_llvm_value(g, return_instruction->value);
2398	2400	LLVMValueRef by_val_value = gen_load_untyped(g, value, 0, false, "");
2399	2401	LLVMBuildRet(g->builder, by_val_value);
2400	2402	} else {
	2403	LLVMValueRef value = ir_llvm_value(g, return_instruction->value);
2401	2404	LLVMBuildRet(g->builder, value);
2402	2405	}
2403	2406	return nullptr;
...	...	@@ -5032,29 +5035,6 @@ static LLVMValueRef ir_render_union_tag(CodeGen g, IrExecutable executable, Ir
5032	5035	return get_handle_value(g, tag_field_ptr, tag_type, ptr_type);
5033	5036	}
5034	5037
5035		static LLVMValueRef ir_render_struct_init(CodeGen g, IrExecutable executable, IrInstructionStructInit *instruction) {
5036		for (size_t i = 0; i < instruction->field_count; i += 1) {
5037		IrInstructionStructInitField *field = &instruction->fields[i];
5038		TypeStructField *type_struct_field = field->type_struct_field;
5039		if (!type_has_bits(type_struct_field->type_entry))
5040		continue;
5041
5042		LLVMValueRef field_ptr = LLVMBuildStructGEP(g->builder, instruction->tmp_ptr,
5043		(unsigned)type_struct_field->gen_index, "");
5044		LLVMValueRef value = ir_llvm_value(g, field->value);
5045
5046		uint32_t field_align_bytes = get_abi_alignment(g, type_struct_field->type_entry);
5047		uint32_t host_int_bytes = get_host_int_bytes(g, instruction->struct_type, type_struct_field);
5048
5049		ZigType *ptr_type = get_pointer_to_type_extra(g, type_struct_field->type_entry,
5050		false, false, PtrLenSingle, field_align_bytes,
5051		(uint32_t)type_struct_field->bit_offset_in_host, host_int_bytes, false);
5052
5053		gen_assign_raw(g, field_ptr, ptr_type, value);
5054		}
5055		return instruction->tmp_ptr;
5056		}
5057
5058	5038	static LLVMValueRef ir_render_union_init(CodeGen g, IrExecutable executable, IrInstructionUnionInit *instruction) {
5059	5039	TypeUnionField *type_union_field = instruction->field;
5060	5040
...	...	@@ -5531,10 +5511,6 @@ static void set_debug_location(CodeGen g, IrInstruction instruction) {
5531	5511	}
5532	5512
5533	5513	static LLVMValueRef ir_render_instruction(CodeGen g, IrExecutable executable, IrInstruction *instruction) {
5534		if (!g->strip_debug_symbols) {
5535		set_debug_location(g, instruction);
5536		}
5537
5538	5514	switch (instruction->id) {
5539	5515	case IrInstructionIdInvalid:
5540	5516	case IrInstructionIdConst:
...	...	@@ -5609,6 +5585,7 @@ static LLVMValueRef ir_render_instruction(CodeGen g, IrExecutable executable,
5609	5585	case IrInstructionIdEndExpr:
5610	5586	case IrInstructionIdAllocaGen:
5611	5587	case IrInstructionIdImplicitCast:
	5588	case IrInstructionIdResolveResult:
5612	5589	zig_unreachable();
5613	5590
5614	5591	case IrInstructionIdDeclVarGen:
...	...	@@ -5705,8 +5682,6 @@ static LLVMValueRef ir_render_instruction(CodeGen g, IrExecutable executable,
5705	5682	return ir_render_err_wrap_payload(g, executable, (IrInstructionErrWrapPayload *)instruction);
5706	5683	case IrInstructionIdUnionTag:
5707	5684	return ir_render_union_tag(g, executable, (IrInstructionUnionTag *)instruction);
5708		case IrInstructionIdStructInit:
5709		return ir_render_struct_init(g, executable, (IrInstructionStructInit *)instruction);
5710	5685	case IrInstructionIdUnionInit:
5711	5686	return ir_render_union_init(g, executable, (IrInstructionUnionInit *)instruction);
5712	5687	case IrInstructionIdPtrCastGen:
...	...	@@ -5791,6 +5766,34 @@ static LLVMValueRef ir_render_instruction(CodeGen g, IrExecutable executable,
5791	5766	zig_unreachable();
5792	5767	}
5793	5768
	5769	static bool scope_is_elided(Scope *scope) {
	5770	for (;;) {
	5771	switch (scope->id) {
	5772	case ScopeIdDecls:
	5773	case ScopeIdCompTime:
	5774	case ScopeIdCImport:
	5775	zig_unreachable();
	5776	case ScopeIdElide:
	5777	if (reinterpret_cast<ScopeElide *>(scope)->activated)
	5778	return true;
	5779	// fallthrough
	5780	case ScopeIdBlock:
	5781	case ScopeIdDefer:
	5782	case ScopeIdDeferExpr:
	5783	case ScopeIdVarDecl:
	5784	case ScopeIdLoop:
	5785	case ScopeIdSuspend:
	5786	case ScopeIdCoroPrelude:
	5787	case ScopeIdRuntime:
	5788	scope = scope->parent;
	5789	continue;
	5790	case ScopeIdFnDef:
	5791	return false;
	5792	}
	5793	zig_unreachable();
	5794	}
	5795	}
	5796
5794	5797	static void ir_render(CodeGen g, ZigFn fn_entry) {
5795	5798	assert(fn_entry);
5796	5799
...	...	@@ -5806,7 +5809,12 @@ static void ir_render(CodeGen g, ZigFn fn_entry) {
5806	5809	if (instruction->ref_count == 0 && !ir_has_side_effects(instruction))
5807	5810	continue;
5808	5811
5809		instruction->llvm_value = ir_render_instruction(g, executable, instruction);
	5812	if (!scope_is_elided(instruction->scope)) {
	5813	if (!g->strip_debug_symbols) {
	5814	set_debug_location(g, instruction);
	5815	}
	5816	instruction->llvm_value = ir_render_instruction(g, executable, instruction);
	5817	}
5810	5818	}
5811	5819	current_block->llvm_exit_block = LLVMGetInsertBlock(g->builder);
5812	5820	}
...	...	@@ -6891,9 +6899,6 @@ static void do_code_gen(CodeGen *g) {
6891	6899	} else if (instruction->id == IrInstructionIdContainerInitList) {
6892	6900	IrInstructionContainerInitList container_init_list_instruction = (IrInstructionContainerInitList )instruction;
6893	6901	slot = &container_init_list_instruction->tmp_ptr;
6894		} else if (instruction->id == IrInstructionIdStructInit) {
6895		IrInstructionStructInit struct_init_instruction = (IrInstructionStructInit )instruction;
6896		slot = &struct_init_instruction->tmp_ptr;
6897	6902	} else if (instruction->id == IrInstructionIdUnionInit) {
6898	6903	IrInstructionUnionInit union_init_instruction = (IrInstructionUnionInit )instruction;
6899	6904	slot = &union_init_instruction->tmp_ptr;

src/ir.cpp+163-73

...	...	@@ -616,10 +616,6 @@ static constexpr IrInstructionId ir_instruction_id(IrInstructionRef *) {
616	616	return IrInstructionIdRef;
617	617	}
618	618
619		static constexpr IrInstructionId ir_instruction_id(IrInstructionStructInit *) {
620		return IrInstructionIdStructInit;
621		}
622
623	619	static constexpr IrInstructionId ir_instruction_id(IrInstructionUnionInit *) {
624	620	return IrInstructionIdUnionInit;
625	621	}
...	...	@@ -888,6 +884,10 @@ static constexpr IrInstructionId ir_instruction_id(IrInstructionImplicitCast *)
888	884	return IrInstructionIdImplicitCast;
889	885	}
890	886
	887	static constexpr IrInstructionId ir_instruction_id(IrInstructionResolveResult *) {
	888	return IrInstructionIdResolveResult;
	889	}
	890
891	891	static constexpr IrInstructionId ir_instruction_id(IrInstructionOpaqueType *) {
892	892	return IrInstructionIdOpaqueType;
893	893	}
...	...	@@ -1517,20 +1517,6 @@ static IrInstruction ir_build_container_init_fields(IrBuilder irb, Scope *scop
1517	1517	return &container_init_fields_instruction->base;
1518	1518	}
1519	1519
1520		static IrInstruction ir_build_struct_init(IrBuilder irb, Scope scope, AstNode source_node,
1521		ZigType struct_type, size_t field_count, IrInstructionStructInitField fields)
1522		{
1523		IrInstructionStructInit *struct_init_instruction = ir_build_instruction<IrInstructionStructInit>(irb, scope, source_node);
1524		struct_init_instruction->struct_type = struct_type;
1525		struct_init_instruction->field_count = field_count;
1526		struct_init_instruction->fields = fields;
1527
1528		for (size_t i = 0; i < field_count; i += 1)
1529		ir_ref_instruction(fields[i].value, irb->current_basic_block);
1530
1531		return &struct_init_instruction->base;
1532		}
1533
1534	1520	static IrInstruction ir_build_union_init(IrBuilder irb, Scope scope, AstNode source_node,
1535	1521	ZigType union_type, TypeUnionField field, IrInstruction *init_value)
1536	1522	{
...	...	@@ -2764,6 +2750,18 @@ static IrInstruction ir_build_implicit_cast(IrBuilder irb, Scope *scope, AstNo
2764	2750	return &instruction->base;
2765	2751	}
2766	2752
	2753	static IrInstruction ir_build_resolve_result(IrBuilder irb, Scope scope, AstNode source_node,
	2754	ResultLoc result_loc, IrInstruction ty)
	2755	{
	2756	IrInstructionResolveResult *instruction = ir_build_instruction<IrInstructionResolveResult>(irb, scope, source_node);
	2757	instruction->result_loc = result_loc;
	2758	instruction->ty = ty;
	2759
	2760	ir_ref_instruction(ty, irb->current_basic_block);
	2761
	2762	return &instruction->base;
	2763	}
	2764
2767	2765	static IrInstruction ir_build_opaque_type(IrBuilder irb, Scope scope, AstNode source_node) {
2768	2766	IrInstructionOpaqueType *instruction = ir_build_instruction<IrInstructionOpaqueType>(irb, scope, source_node);
2769	2767
...	...	@@ -3220,6 +3218,7 @@ static void ir_count_defers(IrBuilder irb, Scope inner_scope, Scope *outer_sco
3220	3218	case ScopeIdSuspend:
3221	3219	case ScopeIdCompTime:
3222	3220	case ScopeIdRuntime:
	3221	case ScopeIdElide:
3223	3222	scope = scope->parent;
3224	3223	continue;
3225	3224	case ScopeIdDeferExpr:
...	...	@@ -3276,6 +3275,7 @@ static bool ir_gen_defers_for_block(IrBuilder irb, Scope inner_scope, Scope *o
3276	3275	case ScopeIdSuspend:
3277	3276	case ScopeIdCompTime:
3278	3277	case ScopeIdRuntime:
	3278	case ScopeIdElide:
3279	3279	scope = scope->parent;
3280	3280	continue;
3281	3281	case ScopeIdDeferExpr:
...	...	@@ -5549,7 +5549,9 @@ static IrInstruction ir_gen_prefix_op_expr(IrBuilder irb, Scope *scope, AstNod
5549	5549	zig_unreachable();
5550	5550	}
5551	5551
5552		static IrInstruction ir_gen_container_init_expr(IrBuilder irb, Scope scope, AstNode node) {
	5552	static IrInstruction ir_gen_container_init_expr(IrBuilder irb, Scope scope, AstNode node, LVal lval,
	5553	ResultLoc *result_loc)
	5554	{
5553	5555	assert(node->type == NodeTypeContainerInitExpr);
5554	5556
5555	5557	AstNodeContainerInitExpr *container_init_expr = &node->data.container_init_expr;
...	...	@@ -5559,39 +5561,61 @@ static IrInstruction ir_gen_container_init_expr(IrBuilder irb, Scope *scope, A
5559	5561	if (container_type == irb->codegen->invalid_instruction)
5560	5562	return container_type;
5561	5563
5562		if (kind == ContainerInitKindStruct) {
5563		size_t field_count = container_init_expr->entries.length;
5564		IrInstructionContainerInitFieldsField *fields = allocate<IrInstructionContainerInitFieldsField>(field_count);
5565		for (size_t i = 0; i < field_count; i += 1) {
5566		AstNode *entry_node = container_init_expr->entries.at(i);
5567		assert(entry_node->type == NodeTypeStructValueField);
5568
5569		Buf *name = entry_node->data.struct_val_field.name;
5570		AstNode *expr_node = entry_node->data.struct_val_field.expr;
5571		IrInstruction *expr_value = ir_gen_node(irb, expr_node, scope);
5572		if (expr_value == irb->codegen->invalid_instruction)
5573		return expr_value;
5574
5575		fields[i].name = name;
5576		fields[i].value = expr_value;
5577		fields[i].source_node = entry_node;
5578		}
5579		return ir_build_container_init_fields(irb, scope, node, container_type, field_count, fields);
5580		} else if (kind == ContainerInitKindArray) {
5581		size_t item_count = container_init_expr->entries.length;
5582		IrInstruction *values = allocate<IrInstruction >(item_count);
5583		for (size_t i = 0; i < item_count; i += 1) {
5584		AstNode *expr_node = container_init_expr->entries.at(i);
5585		IrInstruction *expr_value = ir_gen_node(irb, expr_node, scope);
5586		if (expr_value == irb->codegen->invalid_instruction)
5587		return expr_value;
5588
5589		values[i] = expr_value;
5590		}
5591		return ir_build_container_init_list(irb, scope, node, container_type, item_count, values);
5592		} else {
5593		zig_unreachable();
	5564	switch (kind) {
	5565	case ContainerInitKindStruct: {
	5566	src_assert(result_loc->scope_elide == nullptr, node);
	5567	result_loc->scope_elide = create_elide_scope(irb->codegen, node, scope);
	5568	size_t field_count = container_init_expr->entries.length;
	5569	IrInstructionContainerInitFieldsField *fields = allocate<IrInstructionContainerInitFieldsField>(field_count);
	5570	for (size_t i = 0; i < field_count; i += 1) {
	5571	AstNode *entry_node = container_init_expr->entries.at(i);
	5572	assert(entry_node->type == NodeTypeStructValueField);
	5573
	5574	Buf *name = entry_node->data.struct_val_field.name;
	5575	AstNode *expr_node = entry_node->data.struct_val_field.expr;
	5576
	5577	ResultLoc *child_result_loc = nullptr;
	5578	if (result_loc != nullptr) {
	5579	IrInstruction *container_ptr = ir_build_resolve_result(irb, &result_loc->scope_elide->base,
	5580	expr_node, result_loc, container_type);
	5581	IrInstruction *field_ptr = ir_build_field_ptr(irb, &result_loc->scope_elide->base, expr_node,
	5582	container_ptr, name);
	5583	ResultLocInstruction *result_loc_inst = allocate<ResultLocInstruction>(1);
	5584	result_loc_inst->base.id = ResultLocIdInstruction;
	5585	result_loc_inst->base.source_instruction = field_ptr;
	5586	ir_ref_instruction(field_ptr, irb->current_basic_block);
	5587	child_result_loc = &result_loc_inst->base;
	5588	}
	5589
	5590	IrInstruction *expr_value = ir_gen_node_extra(irb, expr_node, &result_loc->scope_elide->base,
	5591	LValNone, child_result_loc);
	5592	if (expr_value == irb->codegen->invalid_instruction)
	5593	return expr_value;
	5594
	5595	fields[i].name = name;
	5596	fields[i].value = expr_value;
	5597	fields[i].source_node = entry_node;
	5598	}
	5599	IrInstruction *init_fields = ir_build_container_init_fields(irb, scope, node, container_type, field_count, fields);
	5600
	5601	return ir_lval_wrap(irb, scope, init_fields, lval, result_loc);
	5602	}
	5603	case ContainerInitKindArray: {
	5604	size_t item_count = container_init_expr->entries.length;
	5605	IrInstruction *values = allocate<IrInstruction >(item_count);
	5606	for (size_t i = 0; i < item_count; i += 1) {
	5607	AstNode *expr_node = container_init_expr->entries.at(i);
	5608	IrInstruction *expr_value = ir_gen_node(irb, expr_node, scope);
	5609	if (expr_value == irb->codegen->invalid_instruction)
	5610	return expr_value;
	5611
	5612	values[i] = expr_value;
	5613	}
	5614	IrInstruction *init_list = ir_build_container_init_list(irb, scope, node, container_type, item_count, values);
	5615	return ir_lval_wrap(irb, scope, init_list, lval, result_loc);
	5616	}
5594	5617	}
	5618	zig_unreachable();
5595	5619	}
5596	5620
5597	5621	static ResultLocVar create_var_result_loc(IrInstruction alloca, ZigVar *var) {
...	...	@@ -7885,7 +7909,7 @@ static IrInstruction ir_gen_node_raw(IrBuilder irb, AstNode node, Scope scop
7885	7909	case NodeTypePrefixOpExpr:
7886	7910	return ir_gen_prefix_op_expr(irb, scope, node, lval, result_loc);
7887	7911	case NodeTypeContainerInitExpr:
7888		return ir_lval_wrap(irb, scope, ir_gen_container_init_expr(irb, scope, node), lval, result_loc);
	7912	return ir_gen_container_init_expr(irb, scope, node, lval, result_loc);
7889	7913	case NodeTypeVariableDeclaration:
7890	7914	return ir_lval_wrap(irb, scope, ir_gen_var_decl(irb, scope, node), lval, result_loc);
7891	7915	case NodeTypeWhileExpr:
...	...	@@ -14468,7 +14492,9 @@ static IrInstruction ir_analyze_alloca(IrAnalyze ira, IrInstruction *source_in
14468	14492	return &result->base;
14469	14493	}
14470	14494
14471		static ZigType ir_result_loc_expected_type(IrAnalyze ira, ResultLoc *result_loc) {
	14495	static ZigType ir_result_loc_expected_type(IrAnalyze ira, IrInstruction *suspend_source_instr,
	14496	ResultLoc *result_loc)
	14497	{
14472	14498	switch (result_loc->id) {
14473	14499	case ResultLocIdInvalid:
14474	14500	case ResultLocIdPeerParent:
...	...	@@ -14476,6 +14502,30 @@ static ZigType ir_result_loc_expected_type(IrAnalyze ira, ResultLoc *result_lo
14476	14502	case ResultLocIdNone:
14477	14503	case ResultLocIdVar:
14478	14504	return nullptr;
	14505	case ResultLocIdInstruction:
	14506	return result_loc->source_instruction->child->value.type;
	14507	case ResultLocIdField: {
	14508	if (result_loc->resolved_loc != nullptr) {
	14509	ZigType *ptr_type = result_loc->resolved_loc->value.type;
	14510	assert(ptr_type->id == ZigTypeIdPointer);
	14511	return ptr_type->data.pointer.child_type;
	14512	}
	14513	ResultLocField result_loc_field = reinterpret_cast<ResultLocField >(result_loc);
	14514	ZigType *container_type = ir_resolve_type(ira, result_loc_field->container_type->child);
	14515	if (type_is_invalid(container_type))
	14516	return ira->codegen->builtin_types.entry_invalid;
	14517	if (container_type->id == ZigTypeIdStruct) {
	14518	TypeStructField *field = find_struct_type_field(container_type, result_loc_field->name);
	14519	if (field == nullptr) {
	14520	return ira->codegen->builtin_types.entry_invalid;
	14521	}
	14522	return field->type_entry;
	14523	} else if (container_type->id == ZigTypeIdUnion) {
	14524	zig_panic("TODO");
	14525	} else {
	14526	zig_unreachable();
	14527	}
	14528	}
14479	14529	case ResultLocIdReturn:
14480	14530	return ira->explicit_return_type;
14481	14531	case ResultLocIdPeer:
...	...	@@ -14491,7 +14541,10 @@ static IrInstruction ir_resolve_result(IrAnalyze ira, IrInstruction *suspend_s
14491	14541	ResultLoc result_loc, ZigType value_type, IrInstruction *value)
14492	14542	{
14493	14543	if (result_loc->resolved_loc != nullptr) {
14494		return result_loc->resolved_loc;
	14544	// allow to redo the result location if the value is known and comptime and the previous one isn't
	14545	if (value == nullptr \|\| !instr_is_comptime(value) \|\| instr_is_comptime(result_loc->resolved_loc)) {
	14546	return result_loc->resolved_loc;
	14547	}
14495	14548	}
14496	14549	result_loc->gen_instruction = value;
14497	14550	result_loc->implicit_elem_type = value_type;
...	...	@@ -14524,7 +14577,7 @@ static IrInstruction ir_resolve_result(IrAnalyze ira, IrInstruction *suspend_s
14524	14577	return ira->codegen->invalid_instruction;
14525	14578	bool is_comptime = force_comptime \|\| (value != nullptr &&
14526	14579	value->value.special != ConstValSpecialRuntime && result_loc_var->var->gen_is_const);
14527		if (alloca_src->base.child == nullptr) {
	14580	if (alloca_src->base.child == nullptr \|\| is_comptime) {
14528	14581	uint32_t align = 0;
14529	14582	if (alloca_src->align != nullptr && !ir_resolve_align(ira, alloca_src->align->child, &align)) {
14530	14583	return ira->codegen->invalid_instruction;
...	...	@@ -14539,12 +14592,40 @@ static IrInstruction ir_resolve_result(IrAnalyze ira, IrInstruction *suspend_s
14539	14592	alloca_gen = ir_analyze_alloca(ira, result_loc->source_instruction, value_type, align,
14540	14593	alloca_src->name_hint, force_comptime);
14541	14594	}
	14595	if (alloca_src->base.child != nullptr) {
	14596	alloca_src->base.child->ref_count = 0;
	14597	}
14542	14598	alloca_src->base.child = alloca_gen;
14543	14599	}
14544	14600	result_loc->written = true;
14545	14601	result_loc->resolved_loc = is_comptime ? nullptr : alloca_src->base.child;
14546	14602	return result_loc->resolved_loc;
14547	14603	}
	14604	case ResultLocIdInstruction: {
	14605	result_loc->written = true;
	14606	result_loc->resolved_loc = result_loc->source_instruction->child;
	14607	return result_loc->resolved_loc;
	14608	}
	14609	case ResultLocIdField: {
	14610	ResultLocField result_loc_field = reinterpret_cast<ResultLocField >(result_loc);
	14611
	14612	ZigType *container_type = ir_resolve_type(ira, result_loc_field->container_type->child);
	14613	if (type_is_invalid(container_type))
	14614	return ira->codegen->invalid_instruction;
	14615
	14616	IrInstruction *parent_result_loc = ir_resolve_result(ira, suspend_source_instr,
	14617	result_loc_field->parent, container_type, nullptr);
	14618	if (parent_result_loc == nullptr \|\| type_is_invalid(parent_result_loc->value.type) \|\|
	14619	parent_result_loc->value.type->id == ZigTypeIdUnreachable)
	14620	{
	14621	return parent_result_loc;
	14622	}
	14623
	14624	result_loc->written = true;
	14625	result_loc->resolved_loc = ir_analyze_container_field_ptr(ira, result_loc_field->name,
	14626	suspend_source_instr, parent_result_loc, container_type);
	14627	return result_loc->resolved_loc;
	14628	}
14548	14629	case ResultLocIdReturn: {
14549	14630	bool is_comptime = value != nullptr && value->value.special != ConstValSpecialRuntime;
14550	14631	if (is_comptime) return nullptr;
...	...	@@ -14593,7 +14674,7 @@ static IrInstruction ir_resolve_result(IrAnalyze ira, IrInstruction *suspend_s
14593	14674	ira->resume_stack.append(opposite_peer->suspend_pos);
14594	14675	}
14595	14676	}
14596		ZigType *expected_type = ir_result_loc_expected_type(ira, peer_parent->parent);
	14677	ZigType *expected_type = ir_result_loc_expected_type(ira, suspend_source_instr, peer_parent->parent);
14597	14678	peer_parent->resolved_type = ir_resolve_peer_types(ira,
14598	14679	peer_parent->base.source_instruction->source_node, expected_type, instructions,
14599	14680	peer_parent->peer_count);
...	...	@@ -14626,6 +14707,12 @@ static IrInstruction ir_analyze_instruction_implicit_cast(IrAnalyze ira, IrIns
14626	14707	return ir_implicit_cast(ira, target, dest_type);
14627	14708	}
14628	14709
	14710	static IrInstruction ir_analyze_instruction_resolve_result(IrAnalyze ira, IrInstructionResolveResult *instruction) {
	14711	ZigType *ty = ir_resolve_type(ira, instruction->ty->child);
	14712	if (type_is_invalid(ty))
	14713	return ira->codegen->invalid_instruction;
	14714	return ir_resolve_result(ira, &instruction->base, instruction->result_loc, ty, nullptr);
	14715	}
14629	14716
14630	14717	static IrInstruction ir_analyze_async_call(IrAnalyze ira, IrInstructionCallSrc call_instruction, ZigFn fn_entry,
14631	14718	ZigType fn_type, IrInstruction fn_ref, IrInstruction **casted_args, size_t arg_count,
...	...	@@ -18330,8 +18417,6 @@ static IrInstruction ir_analyze_container_init_fields(IrAnalyze ira, IrInstruc
18330	18417
18331	18418	AstNode *field_assign_nodes = allocate<AstNode >(actual_field_count);
18332	18419
18333		IrInstructionStructInitField *new_fields = allocate<IrInstructionStructInitField>(actual_field_count);
18334
18335	18420	bool is_comptime = ir_should_inline(ira->new_irb.exec, instruction->scope)
18336	18421	\|\| type_requires_comptime(ira->codegen, container_type) == ReqCompTimeYes;
18337	18422
...	...	@@ -18371,9 +18456,6 @@ static IrInstruction ir_analyze_container_init_fields(IrAnalyze ira, IrInstruc
18371	18456	}
18372	18457	field_assign_nodes[field_index] = field->source_node;
18373	18458
18374		new_fields[field_index].value = casted_field_value;
18375		new_fields[field_index].type_struct_field = type_field;
18376
18377	18459	if (const_val.special == ConstValSpecialStatic) {
18378	18460	if (is_comptime \|\| casted_field_value->value.special != ConstValSpecialRuntime) {
18379	18461	ConstExprValue *field_val = ir_resolve_const(ira, casted_field_value, UndefOk);
...	...	@@ -18416,9 +18498,6 @@ static IrInstruction ir_analyze_container_init_fields(IrAnalyze ira, IrInstruc
18416	18498	IrInstruction *runtime_inst = ir_const(ira, instruction, field->init_val->type);
18417	18499	copy_const_val(&runtime_inst->value, field->init_val, true);
18418	18500
18419		new_fields[i].value = runtime_inst;
18420		new_fields[i].type_struct_field = field;
18421
18422	18501	if (const_val.special == ConstValSpecialStatic) {
18423	18502	copy_const_val(&const_val.data.x_struct.fields[i], field->init_val, true);
18424	18503	}
...	...	@@ -18451,12 +18530,11 @@ static IrInstruction ir_analyze_container_init_fields(IrAnalyze ira, IrInstruc
18451	18530	return ira->codegen->invalid_instruction;
18452	18531	}
18453	18532
18454		IrInstruction *new_instruction = ir_build_struct_init(&ira->new_irb,
18455		instruction->scope, instruction->source_node,
18456		container_type, actual_field_count, new_fields);
18457		new_instruction->value.type = container_type;
18458		ir_add_alloca(ira, new_instruction, container_type);
18459		return new_instruction;
	18533	// this instruction should not get to codegen
	18534	IrInstruction *result = ir_const(ira, instruction, container_type);
	18535	// this is how we signal to EndExpr the value is not comptime known
	18536	result->value.special = ConstValSpecialRuntime;
	18537	return result;
18460	18538	}
18461	18539
18462	18540	static IrInstruction ir_analyze_instruction_container_init_list(IrAnalyze ira,
...	...	@@ -23794,7 +23872,18 @@ static IrInstruction ir_analyze_instruction_end_expr(IrAnalyze ira, IrInstruct
23794	23872	if (type_is_invalid(value->value.type))
23795	23873	return ira->codegen->invalid_instruction;
23796	23874
23797		if (!instruction->result_loc->written) {
	23875	bool want_resolve_result = instruction->result_loc->written;
	23876	if (instruction->result_loc->written) {
	23877	if (instruction->result_loc->scope_elide != nullptr && instr_is_comptime(value)) {
	23878	want_resolve_result = true;
	23879	instruction->result_loc->scope_elide->activated = true;
	23880	} else {
	23881	want_resolve_result = false;
	23882	}
	23883	} else {
	23884	want_resolve_result = true;
	23885	}
	23886	if (want_resolve_result) {
23798	23887	IrInstruction *result_loc = ir_resolve_result(ira, &instruction->base, instruction->result_loc,
23799	23888	value->value.type, value);
23800	23889	if (result_loc != nullptr) {
...	...	@@ -23815,7 +23904,6 @@ static IrInstruction ir_analyze_instruction_base(IrAnalyze ira, IrInstruction
23815	23904	switch (instruction->id) {
23816	23905	case IrInstructionIdInvalid:
23817	23906	case IrInstructionIdWidenOrShorten:
23818		case IrInstructionIdStructInit:
23819	23907	case IrInstructionIdUnionInit:
23820	23908	case IrInstructionIdStructFieldPtr:
23821	23909	case IrInstructionIdUnionFieldPtr:
...	...	@@ -24036,6 +24124,8 @@ static IrInstruction ir_analyze_instruction_base(IrAnalyze ira, IrInstruction
24036	24124	return ir_analyze_instruction_align_cast(ira, (IrInstructionAlignCast *)instruction);
24037	24125	case IrInstructionIdImplicitCast:
24038	24126	return ir_analyze_instruction_implicit_cast(ira, (IrInstructionImplicitCast *)instruction);
	24127	case IrInstructionIdResolveResult:
	24128	return ir_analyze_instruction_resolve_result(ira, (IrInstructionResolveResult *)instruction);
24039	24129	case IrInstructionIdOpaqueType:
24040	24130	return ir_analyze_instruction_opaque_type(ira, (IrInstructionOpaqueType *)instruction);
24041	24131	case IrInstructionIdSetAlignStack:
...	...	@@ -24260,7 +24350,6 @@ bool ir_has_side_effects(IrInstruction *instruction) {
24260	24350	case IrInstructionIdCast:
24261	24351	case IrInstructionIdContainerInitList:
24262	24352	case IrInstructionIdContainerInitFields:
24263		case IrInstructionIdStructInit:
24264	24353	case IrInstructionIdUnionInit:
24265	24354	case IrInstructionIdFieldPtr:
24266	24355	case IrInstructionIdElemPtr:
...	...	@@ -24326,6 +24415,7 @@ bool ir_has_side_effects(IrInstruction *instruction) {
24326	24415	case IrInstructionIdTypeId:
24327	24416	case IrInstructionIdAlignCast:
24328	24417	case IrInstructionIdImplicitCast:
	24418	case IrInstructionIdResolveResult:
24329	24419	case IrInstructionIdOpaqueType:
24330	24420	case IrInstructionIdArgType:
24331	24421	case IrInstructionIdTagType:

src/ir_print.cpp+25-15

...	...	@@ -207,6 +207,18 @@ static void ir_print_result_loc_var(IrPrint irp, ResultLocVar result_loc_var)
207	207	fprintf(irp->f, ")");
208	208	}
209	209
	210	static void ir_print_result_loc_instruction(IrPrint irp, ResultLocInstruction result_loc_inst) {
	211	fprintf(irp->f, "inst(");
	212	ir_print_other_instruction(irp, result_loc_inst->base.source_instruction);
	213	fprintf(irp->f, ")");
	214	}
	215
	216	static void ir_print_result_loc_field(IrPrint irp, ResultLocField result_loc_field) {
	217	fprintf(irp->f, "field(name=%s,type=", buf_ptr(result_loc_field->name));
	218	ir_print_other_instruction(irp, result_loc_field->container_type);
	219	fprintf(irp->f, ")");
	220	}
	221
210	222	static void ir_print_result_loc_peer(IrPrint irp, ResultLocPeer result_loc_peer) {
211	223	fprintf(irp->f, "peer(next=");
212	224	ir_print_other_block(irp, result_loc_peer->next_bb);
...	...	@@ -225,6 +237,10 @@ static void ir_print_result_loc(IrPrint irp, ResultLoc result_loc) {
225	237	return;
226	238	case ResultLocIdVar:
227	239	return ir_print_result_loc_var(irp, (ResultLocVar *)result_loc);
	240	case ResultLocIdInstruction:
	241	return ir_print_result_loc_instruction(irp, (ResultLocInstruction *)result_loc);
	242	case ResultLocIdField:
	243	return ir_print_result_loc_field(irp, (ResultLocField *)result_loc);
228	244	case ResultLocIdPeer:
229	245	return ir_print_result_loc_peer(irp, (ResultLocPeer *)result_loc);
230	246	case ResultLocIdPeerParent:
...	...	@@ -352,18 +368,6 @@ static void ir_print_container_init_fields(IrPrint *irp, IrInstructionContainerI
352	368	fprintf(irp->f, "} // container init");
353	369	}
354	370
355		static void ir_print_struct_init(IrPrint irp, IrInstructionStructInit instruction) {
356		fprintf(irp->f, "%s {", buf_ptr(&instruction->struct_type->name));
357		for (size_t i = 0; i < instruction->field_count; i += 1) {
358		IrInstructionStructInitField *field = &instruction->fields[i];
359		Buf *field_name = field->type_struct_field->name;
360		const char *comma = (i == 0) ? "" : ", ";
361		fprintf(irp->f, "%s.%s = ", comma, buf_ptr(field_name));
362		ir_print_other_instruction(irp, field->value);
363		}
364		fprintf(irp->f, "} // struct init");
365		}
366
367	371	static void ir_print_union_init(IrPrint irp, IrInstructionUnionInit instruction) {
368	372	Buf *field_name = instruction->field->enum_field->name;
369	373
...	...	@@ -1265,6 +1269,12 @@ static void ir_print_implicit_cast(IrPrint irp, IrInstructionImplicitCast inst
1265	1269	fprintf(irp->f, ")");
1266	1270	}
1267	1271
	1272	static void ir_print_resolve_result(IrPrint irp, IrInstructionResolveResult instruction) {
	1273	fprintf(irp->f, "ResolveResult(");
	1274	ir_print_result_loc(irp, instruction->result_loc);
	1275	fprintf(irp->f, ")");
	1276	}
	1277
1268	1278	static void ir_print_opaque_type(IrPrint irp, IrInstructionOpaqueType instruction) {
1269	1279	fprintf(irp->f, "@OpaqueType()");
1270	1280	}
...	...	@@ -1588,9 +1598,6 @@ static void ir_print_instruction(IrPrint irp, IrInstruction instruction) {
1588	1598	case IrInstructionIdContainerInitFields:
1589	1599	ir_print_container_init_fields(irp, (IrInstructionContainerInitFields *)instruction);
1590	1600	break;
1591		case IrInstructionIdStructInit:
1592		ir_print_struct_init(irp, (IrInstructionStructInit *)instruction);
1593		break;
1594	1601	case IrInstructionIdUnionInit:
1595	1602	ir_print_union_init(irp, (IrInstructionUnionInit *)instruction);
1596	1603	break;
...	...	@@ -1900,6 +1907,9 @@ static void ir_print_instruction(IrPrint irp, IrInstruction instruction) {
1900	1907	case IrInstructionIdImplicitCast:
1901	1908	ir_print_implicit_cast(irp, (IrInstructionImplicitCast *)instruction);
1902	1909	break;
	1910	case IrInstructionIdResolveResult:
	1911	ir_print_resolve_result(irp, (IrInstructionResolveResult *)instruction);
	1912	break;
1903	1913	case IrInstructionIdOpaqueType:
1904	1914	ir_print_opaque_type(irp, (IrInstructionOpaqueType *)instruction);
1905	1915	break;