Commit 62d0d88b56b909cf9f9f7a78a8222acd0f37b6cb | zig

author	Andrew Kelley <andrew@ziglang.org> 2016-11-17 04:00:02-05:00
committer	Andrew Kelley <andrew@ziglang.org> 2016-11-17 04:00:02-05:00
log	62d0d88b56b909cf9f9f7a78a8222acd0f37b6cb
tree	c61b610a3c43bad96f28cc46385f2843c2dd2633
parent	a55555c99e9bcc1424c8650ab44570caf593bcdc

IR: pointers to constants don't copy data

8 files changed, 263 insertions(+), 313 deletions(-)

src/all_types.hpp+21-14

...	...	@@ -51,17 +51,24 @@ struct ConstEnumValue {
51	51	};
52	52
53	53	struct ConstStructValue {
54		ConstExprValue **fields;
	54	ConstExprValue *fields;
55	55	};
56	56
57	57	struct ConstArrayValue {
58		ConstExprValue **fields;
	58	ConstExprValue *elements;
	59	// This will be the same as `len` from the type, but we duplicate the information
	60	// in the constant value so that pointers pointing to arrays can see this size.
	61	size_t size;
59	62	};
60	63
61	64	struct ConstPtrValue {
62		ConstExprValue **ptr;
63		// len should almost always be 1. exceptions include C strings
64		uint64_t len;
	65	ConstExprValue *base_ptr;
	66	// If index is SIZE_MAX, then base_ptr points directly to child type.
	67	// Otherwise base_ptr points to an array const val and index is offset
	68	// in object units from base_ptr into the block of memory pointed to
	69	size_t index;
	70	// This flag helps us preserve the null byte when performing compile-time
	71	// concatenation on C strings.
65	72	bool is_c_str;
66	73	};
67	74
...	...	@@ -71,15 +78,17 @@ struct ConstErrValue {
71	78	};
72	79
73	80	enum ConstValSpecial {
74		ConstValSpecialOther,
	81	ConstValSpecialRuntime,
	82	ConstValSpecialStatic,
75	83	ConstValSpecialUndef,
76	84	ConstValSpecialZeroes,
77	85	};
78	86
79	87	struct ConstExprValue {
80		bool ok;
81		bool depends_on_compile_var;
82	88	ConstValSpecial special;
	89	bool depends_on_compile_var;
	90	LLVMValueRef llvm_value;
	91	LLVMValueRef llvm_global;
83	92
84	93	// populated if val_type == ConstValTypeOk
85	94	union {
...	...	@@ -108,13 +117,9 @@ enum ReturnKnowledge {
108	117	};
109	118
110	119	struct Expr {
111		TypeTableEntry *type_entry;
	120	IrInstruction *instruction;
112	121	ReturnKnowledge return_knowledge;
113	122	VariableTableEntry *variable;
114
115		LLVMValueRef const_llvm_val;
116		ConstExprValue const_val;
117		bool has_global_const;
118	123	};
119	124
120	125	struct StructValExprCodeGen {
...	...	@@ -1289,7 +1294,6 @@ struct CodeGen {
1289	1294	// there will not be a corresponding fn_defs entry.
1290	1295	ZigList<FnTableEntry *> fn_protos;
1291	1296	ZigList<VariableTableEntry *> global_vars;
1292		ZigList<AstNode *> global_const_list;
1293	1297
1294	1298	OutType out_type;
1295	1299	FnTableEntry *cur_fn;
...	...	@@ -1733,4 +1737,7 @@ enum LValPurpose {
1733	1737	LValPurposeConstAddressOf,
1734	1738	};
1735	1739
	1740	static const size_t slice_ptr_index = 0;
	1741	static const size_t slice_len_index = 1;
	1742
1736	1743	#endif

src/analyze.cpp+21-20

...	...	@@ -882,7 +882,7 @@ static TypeTableEntry analyze_type_expr_pointer_only(CodeGen g, ImportTableEnt
882	882	if (result->type_entry->id == TypeTableEntryIdInvalid)
883	883	return g->builtin_types.entry_invalid;
884	884
885		assert(result->static_value.ok);
	885	assert(result->static_value.special != ConstValSpecialRuntime);
886	886	return result->static_value.data.x_type;
887	887	}
888	888
...	...	@@ -1963,9 +1963,8 @@ static void resolve_var_decl(CodeGen g, ImportTableEntry import, AstNode *node
1963	1963	}
1964	1964	if (implicit_type->id != TypeTableEntryIdInvalid) {
1965	1965	Expr *expr = get_resolved_expr(var_decl->expr);
1966		assert(result->static_value.ok);
1967		expr->const_val = result->static_value;
1968		expr->type_entry = result->type_entry;
	1966	assert(result->static_value.special != ConstValSpecialRuntime);
	1967	expr->instruction = result;
1969	1968	}
1970	1969	} else if (!is_extern) {
1971	1970	add_node_error(g, node, buf_sprintf("variables must be initialized"));
...	...	@@ -2132,8 +2131,8 @@ static bool num_lit_fits_in_other_type(CodeGen g, AstNode literal_node, TypeTa
2132	2131	}
2133	2132
2134	2133	Expr *expr = get_resolved_expr(literal_node);
2135		ConstExprValue *const_val = &expr->const_val;
2136		assert(const_val->ok);
	2134	ConstExprValue *const_val = &expr->instruction->static_value;
	2135	assert(const_val->special != ConstValSpecialRuntime);
2137	2136	if (other_type_underlying->id == TypeTableEntryIdFloat) {
2138	2137	return true;
2139	2138	} else if (other_type_underlying->id == TypeTableEntryIdInt &&
...	...	@@ -2600,15 +2599,15 @@ static void add_symbols_from_import(CodeGen g, AstNode src_use_node, AstNode *
2600	2599	AstNode *use_target_node = src_use_node->data.use.expr;
2601	2600	Expr *expr = get_resolved_expr(use_target_node);
2602	2601
2603		if (expr->type_entry->id == TypeTableEntryIdInvalid) {
	2602	if (expr->instruction->type_entry->id == TypeTableEntryIdInvalid) {
2604	2603	tld->import->any_imports_failed = true;
2605	2604	return;
2606	2605	}
2607	2606
2608	2607	tld->resolution = TldResolutionOk;
2609	2608
2610		ConstExprValue *const_val = &expr->const_val;
2611		assert(const_val->ok);
	2609	ConstExprValue *const_val = &expr->instruction->static_value;
	2610	assert(const_val->special != ConstValSpecialRuntime);
2612	2611
2613	2612	ImportTableEntry *target_import = const_val->data.x_import;
2614	2613	assert(target_import);
...	...	@@ -3031,10 +3030,11 @@ void find_libc_lib_path(CodeGen *g) {
3031	3030	}
3032	3031
3033	3032	static uint32_t hash_ptr(void *ptr) {
3034		uint64_t x = (uint64_t)(uintptr_t)(ptr);
3035		uint32_t a = x >> 32;
3036		uint32_t b = x & 0xffffffff;
3037		return a ^ b;
	3033	return ((uintptr_t)ptr) % UINT32_MAX;
	3034	}
	3035
	3036	static uint32_t hash_size(size_t x) {
	3037	return x % UINT32_MAX;
3038	3038	}
3039	3039
3040	3040	uint32_t fn_type_id_hash(FnTypeId *id) {
...	...	@@ -3090,7 +3090,7 @@ static uint32_t hash_const_val(TypeTableEntry type, ConstExprValue const_val)
3090	3090	case TypeTableEntryIdNumLitFloat:
3091	3091	return const_val->data.x_bignum.data.x_float * UINT32_MAX;
3092	3092	case TypeTableEntryIdPointer:
3093		return hash_ptr(const_val->data.x_ptr.ptr);
	3093	return hash_ptr(const_val->data.x_ptr.base_ptr) + hash_size(const_val->data.x_ptr.index);
3094	3094	case TypeTableEntryIdUndefLit:
3095	3095	return 162837799;
3096	3096	case TypeTableEntryIdNullLit:
...	...	@@ -3143,8 +3143,8 @@ uint32_t generic_fn_type_id_hash(GenericFnTypeId *id) {
3143	3143	for (size_t i = 0; i < id->generic_param_count; i += 1) {
3144	3144	GenericParamValue *generic_param = &id->generic_params[i];
3145	3145	if (generic_param->node) {
3146		ConstExprValue *const_val = &get_resolved_expr(generic_param->node)->const_val;
3147		assert(const_val->ok);
	3146	ConstExprValue *const_val = &get_resolved_expr(generic_param->node)->instruction->static_value;
	3147	assert(const_val->special != ConstValSpecialRuntime);
3148	3148	result += hash_const_val(generic_param->type, const_val);
3149	3149	}
3150	3150	result += hash_ptr(generic_param->type);
...	...	@@ -3160,10 +3160,10 @@ bool generic_fn_type_id_eql(GenericFnTypeId a, GenericFnTypeId b) {
3160	3160	GenericParamValue *b_val = &b->generic_params[i];
3161	3161	if (a_val->type != b_val->type) return false;
3162	3162	if (a_val->node && b_val->node) {
3163		ConstExprValue *a_const_val = &get_resolved_expr(a_val->node)->const_val;
3164		ConstExprValue *b_const_val = &get_resolved_expr(b_val->node)->const_val;
3165		assert(a_const_val->ok);
3166		assert(b_const_val->ok);
	3163	ConstExprValue *a_const_val = &get_resolved_expr(a_val->node)->instruction->static_value;
	3164	ConstExprValue *b_const_val = &get_resolved_expr(b_val->node)->instruction->static_value;
	3165	assert(a_const_val->special != ConstValSpecialRuntime);
	3166	assert(b_const_val->special != ConstValSpecialRuntime);
3167	3167	if (!const_values_equal(a_const_val, b_const_val, a_val->type)) {
3168	3168	return false;
3169	3169	}
...	...	@@ -3237,3 +3237,4 @@ uint64_t get_memcpy_align(CodeGen g, TypeTableEntry type_entry) {
3237	3237	return LLVMABISizeOfType(g->target_data_ref, first_type_in_mem->type_ref);
3238	3238	}
3239	3239
	3240

src/codegen.cpp+69-81

...	...	@@ -226,7 +226,8 @@ void codegen_set_rdynamic(CodeGen *g, bool rdynamic) {
226	226	g->linker_rdynamic = rdynamic;
227	227	}
228	228
229		static LLVMValueRef gen_const_val(CodeGen g, TypeTableEntry type_entry, ConstExprValue *const_val);
	229	static void render_const_val(CodeGen g, TypeTableEntry type_entry, ConstExprValue *const_val);
	230	static void render_const_val_global(CodeGen g, TypeTableEntry type_entry, ConstExprValue *const_val);
230	231
231	232	static void set_debug_source_node(CodeGen g, AstNode node) {
232	233	assert(node->block_context);
...	...	@@ -862,11 +863,17 @@ static LLVMValueRef ir_llvm_value(CodeGen g, IrInstruction instruction) {
862	863	if (!type_has_bits(instruction->type_entry))
863	864	return nullptr;
864	865	if (!instruction->llvm_value) {
865		assert(instruction->static_value.ok);
	866	assert(instruction->static_value.special != ConstValSpecialRuntime);
866	867	assert(instruction->type_entry);
867		instruction->llvm_value = gen_const_val(g, instruction->type_entry, &instruction->static_value);
	868	render_const_val(g, instruction->type_entry, &instruction->static_value);
	869	instruction->llvm_value = instruction->static_value.llvm_value;
868	870	assert(instruction->llvm_value);
869	871	}
	872	if (instruction->static_value.special != ConstValSpecialRuntime) {
	873	if (instruction->type_entry->id == TypeTableEntryIdPointer) {
	874	return LLVMBuildLoad(g->builder, instruction->static_value.llvm_global, "");
	875	}
	876	}
870	877	return instruction->llvm_value;
871	878	}
872	879
...	...	@@ -1401,9 +1408,9 @@ static LLVMValueRef ir_render_decl_var(CodeGen g, IrExecutable executable,
1401	1408	bool want_zeroes = false;
1402	1409
1403	1410	ConstExprValue *const_val = &init_value->static_value;
1404		if (!const_val->ok \|\| const_val->special == ConstValSpecialOther)
	1411	if (const_val->special == ConstValSpecialRuntime \|\| const_val->special == ConstValSpecialStatic)
1405	1412	have_init_expr = true;
1406		if (const_val->ok && const_val->special == ConstValSpecialZeroes)
	1413	if (const_val->special == ConstValSpecialZeroes)
1407	1414	want_zeroes = true;
1408	1415
1409	1416	if (have_init_expr) {
...	...	@@ -1740,14 +1747,14 @@ static void ir_render(CodeGen g, FnTableEntry fn_entry) {
1740	1747	}
1741	1748
1742	1749	static LLVMValueRef gen_const_val(CodeGen g, TypeTableEntry type_entry, ConstExprValue *const_val) {
1743		assert(const_val->ok);
1744
1745	1750	switch (const_val->special) {
	1751	case ConstValSpecialRuntime:
	1752	zig_unreachable();
1746	1753	case ConstValSpecialUndef:
1747	1754	return LLVMGetUndef(type_entry->type_ref);
1748	1755	case ConstValSpecialZeroes:
1749	1756	return LLVMConstNull(type_entry->type_ref);
1750		case ConstValSpecialOther:
	1757	case ConstValSpecialStatic:
1751	1758	break;
1752	1759
1753	1760	}
...	...	@@ -1814,7 +1821,7 @@ static LLVMValueRef gen_const_val(CodeGen g, TypeTableEntry type_entry, ConstE
1814	1821	continue;
1815	1822	}
1816	1823	fields[type_struct_field->gen_index] = gen_const_val(g, type_struct_field->type_entry,
1817		const_val->data.x_struct.fields[i]);
	1824	&const_val->data.x_struct.fields[i]);
1818	1825	}
1819	1826	return LLVMConstNamedStruct(type_entry->type_ref, fields,
1820	1827	type_entry->data.structure.gen_field_count);
...	...	@@ -1829,8 +1836,8 @@ static LLVMValueRef gen_const_val(CodeGen g, TypeTableEntry type_entry, ConstE
1829	1836	uint64_t len = type_entry->data.array.len;
1830	1837	LLVMValueRef *values = allocate<LLVMValueRef>(len);
1831	1838	for (uint64_t i = 0; i < len; i += 1) {
1832		ConstExprValue *field_value = const_val->data.x_array.fields[i];
1833		values[i] = gen_const_val(g, child_type, field_value);
	1839	ConstExprValue *elem_value = &const_val->data.x_array.elements[i];
	1840	values[i] = gen_const_val(g, child_type, elem_value);
1834	1841	}
1835	1842	return LLVMConstArray(child_type->type_ref, values, len);
1836	1843	}
...	...	@@ -1878,29 +1885,26 @@ static LLVMValueRef gen_const_val(CodeGen g, TypeTableEntry type_entry, ConstE
1878	1885	case TypeTableEntryIdPointer:
1879	1886	{
1880	1887	TypeTableEntry *child_type = type_entry->data.pointer.child_type;
1881		size_t len = const_val->data.x_ptr.len;
1882		LLVMValueRef target_val;
1883		if (len == 1) {
1884		target_val = gen_const_val(g, child_type, const_val->data.x_ptr.ptr[0]);
1885		} else if (len > 1) {
1886		LLVMValueRef *values = allocate<LLVMValueRef>(len);
1887		for (size_t i = 0; i < len; i += 1) {
1888		values[i] = gen_const_val(g, child_type, const_val->data.x_ptr.ptr[i]);
1889		}
1890		target_val = LLVMConstArray(child_type->type_ref, values, len);
1891		} else {
1892		return LLVMGetUndef(type_entry->type_ref);
1893		}
1894		LLVMValueRef global_value = LLVMAddGlobal(g->module, LLVMTypeOf(target_val), "");
1895		LLVMSetInitializer(global_value, target_val);
1896		LLVMSetLinkage(global_value, LLVMPrivateLinkage);
1897		LLVMSetGlobalConstant(global_value, type_entry->data.pointer.is_const);
1898		LLVMSetUnnamedAddr(global_value, true);
1899
1900		if (len > 1) {
1901		return LLVMConstBitCast(global_value, type_entry->type_ref);
	1888
	1889	render_const_val_global(g, type_entry, const_val);
	1890	size_t index = const_val->data.x_ptr.index;
	1891	if (index == SIZE_MAX) {
	1892	render_const_val(g, child_type, const_val->data.x_ptr.base_ptr);
	1893	render_const_val_global(g, child_type, const_val->data.x_ptr.base_ptr);
	1894	return const_val->data.x_ptr.base_ptr->llvm_global;
1902	1895	} else {
1903		return global_value;
	1896	ConstExprValue *array_const_val = const_val->data.x_ptr.base_ptr;
	1897	TypeTableEntry *array_type = get_array_type(g, child_type,
	1898	array_const_val->data.x_array.size);
	1899	render_const_val(g, array_type, array_const_val);
	1900	render_const_val_global(g, array_type, array_const_val);
	1901	TypeTableEntry *usize = g->builtin_types.entry_usize;
	1902	LLVMValueRef indices[] = {
	1903	LLVMConstNull(usize->type_ref),
	1904	LLVMConstInt(usize->type_ref, index, false),
	1905	};
	1906	LLVMValueRef ptr_val = LLVMConstInBoundsGEP(array_const_val->llvm_global, indices, 2);
	1907	return ptr_val;
1904	1908	}
1905	1909	}
1906	1910	case TypeTableEntryIdErrorUnion:
...	...	@@ -1945,27 +1949,26 @@ static LLVMValueRef gen_const_val(CodeGen g, TypeTableEntry type_entry, ConstE
1945	1949	zig_unreachable();
1946	1950	}
1947	1951
1948		static void gen_const_globals(CodeGen *g) {
1949		for (size_t i = 0; i < g->global_const_list.length; i += 1) {
1950		AstNode *expr_node = g->global_const_list.at(i);
1951		Expr *expr = get_resolved_expr(expr_node);
1952		ConstExprValue *const_val = &expr->const_val;
1953		assert(const_val->ok);
1954		TypeTableEntry *type_entry = expr->type_entry;
1955
1956		if (handle_is_ptr(type_entry)) {
1957		LLVMValueRef init_val = gen_const_val(g, type_entry, const_val);
1958		LLVMValueRef global_value = LLVMAddGlobal(g->module, LLVMTypeOf(init_val), "");
1959		LLVMSetInitializer(global_value, init_val);
1960		LLVMSetLinkage(global_value, LLVMPrivateLinkage);
1961		LLVMSetGlobalConstant(global_value, true);
1962		LLVMSetUnnamedAddr(global_value, true);
1963		expr->const_llvm_val = global_value;
1964		} else {
1965		expr->const_llvm_val = gen_const_val(g, type_entry, const_val);
1966		}
1967		assert(expr->const_llvm_val);
	1952	static void render_const_val(CodeGen g, TypeTableEntry type_entry, ConstExprValue *const_val) {
	1953	if (!const_val->llvm_value)
	1954	const_val->llvm_value = gen_const_val(g, type_entry, const_val);
	1955
	1956	if (const_val->llvm_global)
	1957	LLVMSetInitializer(const_val->llvm_global, const_val->llvm_value);
	1958	}
	1959
	1960	static void render_const_val_global(CodeGen g, TypeTableEntry type_entry, ConstExprValue *const_val) {
	1961	if (!const_val->llvm_global) {
	1962	LLVMValueRef global_value = LLVMAddGlobal(g->module, type_entry->type_ref, "");
	1963	LLVMSetLinkage(global_value, LLVMInternalLinkage);
	1964	LLVMSetGlobalConstant(global_value, true);
	1965	LLVMSetUnnamedAddr(global_value, true);
	1966
	1967	const_val->llvm_global = global_value;
1968	1968	}
	1969
	1970	if (const_val->llvm_value)
	1971	LLVMSetInitializer(const_val->llvm_global, const_val->llvm_value);
1969	1972	}
1970	1973
1971	1974	static void delete_unused_builtin_fns(CodeGen *g) {
...	...	@@ -2096,9 +2099,6 @@ static void do_code_gen(CodeGen *g) {
2096	2099	assert(!g->errors.length);
2097	2100
2098	2101	delete_unused_builtin_fns(g);
2099
2100
2101		gen_const_globals(g);
2102	2102	generate_error_name_table(g);
2103	2103
2104	2104	// Generate module level variables
...	...	@@ -2107,8 +2107,8 @@ static void do_code_gen(CodeGen *g) {
2107	2107
2108	2108	if (var->type->id == TypeTableEntryIdNumLitFloat) {
2109	2109	// Generate debug info for it but that's it.
2110		ConstExprValue *const_val = &get_resolved_expr(var->val_node)->const_val;
2111		assert(const_val->ok);
	2110	ConstExprValue *const_val = &get_resolved_expr(var->val_node)->instruction->static_value;
	2111	assert(const_val->special != ConstValSpecialRuntime);
2112	2112	TypeTableEntry *var_type = g->builtin_types.entry_f64;
2113	2113	LLVMValueRef init_val = LLVMConstReal(var_type->type_ref, const_val->data.x_bignum.data.x_float);
2114	2114	gen_global_var(g, var, init_val, var_type);
...	...	@@ -2117,8 +2117,8 @@ static void do_code_gen(CodeGen *g) {
2117	2117
2118	2118	if (var->type->id == TypeTableEntryIdNumLitInt) {
2119	2119	// Generate debug info for it but that's it.
2120		ConstExprValue *const_val = &get_resolved_expr(var->val_node)->const_val;
2121		assert(const_val->ok);
	2120	ConstExprValue *const_val = &get_resolved_expr(var->val_node)->instruction->static_value;
	2121	assert(const_val->special != ConstValSpecialRuntime);
2122	2122	TypeTableEntry *var_type = const_val->data.x_bignum.is_negative ?
2123	2123	g->builtin_types.entry_isize : g->builtin_types.entry_usize;
2124	2124	LLVMValueRef init_val = LLVMConstInt(var_type->type_ref,
...	...	@@ -2143,25 +2143,13 @@ static void do_code_gen(CodeGen *g) {
2143	2143	LLVMSetLinkage(global_value, LLVMExternalLinkage);
2144	2144	} else {
2145	2145	AstNode *expr_node = var->decl_node->data.variable_declaration.expr;
2146		LLVMValueRef init_val;
2147		if (expr_node) {
2148		Expr *expr = get_resolved_expr(expr_node);
2149		ConstExprValue *const_val = &expr->const_val;
2150		assert(const_val->ok);
2151		TypeTableEntry *type_entry = expr->type_entry;
2152		init_val = gen_const_val(g, type_entry, const_val);
2153		} else {
2154		init_val = LLVMConstNull(var->type->type_ref);
2155		}
2156
2157		global_value = LLVMAddGlobal(g->module, LLVMTypeOf(init_val), buf_ptr(&var->name));
2158		LLVMSetInitializer(global_value, init_val);
2159		LLVMSetLinkage(global_value, LLVMInternalLinkage);
2160		LLVMSetUnnamedAddr(global_value, true);
2161
	2146	IrInstruction *instruction = get_resolved_expr(expr_node)->instruction;
	2147	render_const_val(g, instruction->type_entry, &instruction->static_value);
	2148	render_const_val_global(g, instruction->type_entry, &instruction->static_value);
	2149	global_value = instruction->static_value.llvm_global;
2162	2150	// TODO debug info for function pointers
2163	2151	if (var->gen_is_const && var->type->id != TypeTableEntryIdFn) {
2164		gen_global_var(g, var, init_val, var->type);
	2152	gen_global_var(g, var, instruction->static_value.llvm_value, var->type);
2165	2153	}
2166	2154	}
2167	2155
...	...	@@ -3282,11 +3270,11 @@ static void get_c_type(CodeGen g, TypeTableEntry type_entry, Buf *out_buf) {
3282	3270
3283	3271	static void get_c_type_node(CodeGen g, AstNode type_node, Buf *out_buf) {
3284	3272	Expr *expr = get_resolved_expr(type_node);
3285		assert(expr->type_entry);
3286		assert(expr->type_entry->id == TypeTableEntryIdMetaType);
	3273	assert(expr->instruction->type_entry);
	3274	assert(expr->instruction->type_entry->id == TypeTableEntryIdMetaType);
3287	3275
3288		ConstExprValue *const_val = &expr->const_val;
3289		assert(const_val->ok);
	3276	ConstExprValue *const_val = &expr->instruction->static_value;
	3277	assert(const_val->special != ConstValSpecialRuntime);
3290	3278
3291	3279	TypeTableEntry *type_entry = const_val->data.x_type;
3292	3280

src/eval.cpp+20-99

...	...	@@ -147,7 +147,7 @@ static int eval_const_expr_bin_op_bignum(ConstExprValue *op1_val, ConstExprValue
147	147	}
148	148	}
149	149
150		out_val->ok = true;
	150	out_val->special = ConstValSpecialStatic;
151	151	out_val->depends_on_compile_var = op1_val->depends_on_compile_var \|\| op2_val->depends_on_compile_var;
152	152	return 0;
153	153	}
...	...	@@ -155,8 +155,8 @@ static int eval_const_expr_bin_op_bignum(ConstExprValue *op1_val, ConstExprValue
155	155	int eval_const_expr_bin_op(ConstExprValue op1_val, TypeTableEntry op1_type,
156	156	BinOpType bin_op, ConstExprValue op2_val, TypeTableEntry op2_type, ConstExprValue *out_val)
157	157	{
158		assert(op1_val->ok);
159		assert(op2_val->ok);
	158	assert(op1_val->special != ConstValSpecialRuntime);
	159	assert(op2_val->special != ConstValSpecialRuntime);
160	160	assert(op1_type->id != TypeTableEntryIdInvalid);
161	161	assert(op2_type->id != TypeTableEntryIdInvalid);
162	162
...	...	@@ -171,7 +171,7 @@ int eval_const_expr_bin_op(ConstExprValue op1_val, TypeTableEntry op1_type,
171	171	assert(op1_type->id == TypeTableEntryIdBool);
172	172	assert(op2_type->id == TypeTableEntryIdBool);
173	173	out_val->data.x_bool = eval_bool_bin_op_bool(op1_val->data.x_bool, bin_op, op2_val->data.x_bool);
174		out_val->ok = true;
	174	out_val->special = ConstValSpecialStatic;
175	175	out_val->depends_on_compile_var = op1_val->depends_on_compile_var \|\| op2_val->depends_on_compile_var;
176	176	return 0;
177	177	case BinOpTypeCmpEq:
...	...	@@ -219,7 +219,7 @@ int eval_const_expr_bin_op(ConstExprValue op1_val, TypeTableEntry op1_type,
219	219	out_val->depends_on_compile_var =
220	220	op1_val->depends_on_compile_var \|\| op2_val->depends_on_compile_var;
221	221	out_val->data.x_bool = answer;
222		out_val->ok = true;
	222	out_val->special = ConstValSpecialStatic;
223	223	return 0;
224	224	}
225	225	case BinOpTypeAdd:
...	...	@@ -309,67 +309,7 @@ void eval_const_expr_implicit_cast(CastOp cast_op,
309	309	const_val = other_val;
310	310	break;
311	311	case CastOpPointerReinterpret:
312		if (other_type->id == TypeTableEntryIdPointer &&
313		new_type->id == TypeTableEntryIdPointer)
314		{
315		TypeTableEntry *other_child_type = other_type->data.pointer.child_type;
316		TypeTableEntry *new_child_type = new_type->data.pointer.child_type;
317
318		if ((other_child_type->id == TypeTableEntryIdInt \|\|
319		other_child_type->id == TypeTableEntryIdFloat) &&
320		(new_child_type->id == TypeTableEntryIdInt \|\|
321		new_child_type->id == TypeTableEntryIdFloat))
322		{
323		ConstExprValue *ptr_val = allocate<ConstExprValue>(1);
324		*ptr_val = other_val->data.x_ptr.ptr[0];
325		const_val->data.x_ptr.ptr = ptr_val;
326		const_val->data.x_ptr.len = 1;
327		const_val->ok = true;
328		const_val->special = other_val->special;
329		const_val->depends_on_compile_var = other_val->depends_on_compile_var;
330		} else {
331		zig_panic("TODO");
332		}
333		} else if (other_type->id == TypeTableEntryIdMaybe &&
334		new_type->id == TypeTableEntryIdMaybe)
335		{
336		if (!other_val->data.x_maybe) {
337		const_val = other_val;
338		break;
339		}
340
341		TypeTableEntry *other_ptr_type = other_type->data.maybe.child_type;
342		TypeTableEntry *new_ptr_type = new_type->data.maybe.child_type;
343
344		if (other_ptr_type->id == TypeTableEntryIdPointer &&
345		new_ptr_type->id == TypeTableEntryIdPointer)
346		{
347		TypeTableEntry *other_child_type = other_ptr_type->data.pointer.child_type;
348		TypeTableEntry *new_child_type = new_ptr_type->data.pointer.child_type;
349
350		if ((other_child_type->id == TypeTableEntryIdInt \|\|
351		other_child_type->id == TypeTableEntryIdFloat) &&
352		(new_child_type->id == TypeTableEntryIdInt \|\|
353		new_child_type->id == TypeTableEntryIdFloat))
354		{
355		ConstExprValue *ptr_parent = allocate<ConstExprValue>(1);
356		ConstExprValue *ptr_val = allocate<ConstExprValue>(1);
357		*ptr_val = other_val->data.x_maybe->data.x_ptr.ptr[0];
358		ptr_parent->data.x_ptr.ptr = ptr_val;
359		ptr_parent->data.x_ptr.len = 1;
360		ptr_parent->ok = true;
361
362		const_val->data.x_maybe = ptr_parent;
363		const_val->ok = true;
364		const_val->special = other_val->special;
365		const_val->depends_on_compile_var = other_val->depends_on_compile_var;
366		} else {
367		zig_panic("TODO");
368		}
369		} else {
370		zig_panic("TODO");
371		}
372		}
	312	zig_panic("TODO compile time pointer reinterpret");
373	313	break;
374	314	case CastOpPtrToInt:
375	315	case CastOpIntToPtr:
...	...	@@ -378,62 +318,43 @@ void eval_const_expr_implicit_cast(CastOp cast_op,
378	318	// can't do it
379	319	break;
380	320	case CastOpToUnknownSizeArray:
381		{
382		assert(other_type->id == TypeTableEntryIdArray);
383
384		ConstExprValue *all_fields = allocate<ConstExprValue>(2);
385		ConstExprValue *ptr_field = &all_fields[0];
386		ConstExprValue *len_field = &all_fields[1];
387
388		const_val->data.x_struct.fields = allocate<ConstExprValue*>(2);
389		const_val->data.x_struct.fields[0] = ptr_field;
390		const_val->data.x_struct.fields[1] = len_field;
391
392		ptr_field->ok = true;
393		ptr_field->data.x_ptr.ptr = other_val->data.x_array.fields;
394		ptr_field->data.x_ptr.len = other_type->data.array.len;
395
396		len_field->ok = true;
397		bignum_init_unsigned(&len_field->data.x_bignum, other_type->data.array.len);
398
399		const_val->ok = true;
400		break;
401		}
	321	zig_panic("TODO compile time implicit to unknown size array");
	322	break;
402	323	case CastOpMaybeWrap:
403	324	const_val->data.x_maybe = other_val;
404		const_val->ok = true;
	325	const_val->special = ConstValSpecialStatic;
405	326	break;
406	327	case CastOpNullToMaybe:
407	328	const_val->data.x_maybe = nullptr;
408		const_val->ok = true;
	329	const_val->special = ConstValSpecialStatic;
409	330	break;
410	331	case CastOpErrorWrap:
411	332	const_val->data.x_err.err = nullptr;
412	333	const_val->data.x_err.payload = other_val;
413		const_val->ok = true;
	334	const_val->special = ConstValSpecialStatic;
414	335	break;
415	336	case CastOpPureErrorWrap:
416	337	const_val->data.x_err.err = other_val->data.x_err.err;
417		const_val->ok = true;
	338	const_val->special = ConstValSpecialStatic;
418	339	break;
419	340	case CastOpErrToInt:
420	341	{
421	342	uint64_t value = other_val->data.x_err.err ? other_val->data.x_err.err->value : 0;
422	343	bignum_init_unsigned(&const_val->data.x_bignum, value);
423		const_val->ok = true;
	344	const_val->special = ConstValSpecialStatic;
424	345	break;
425	346	}
426	347	case CastOpIntToFloat:
427	348	bignum_cast_to_float(&const_val->data.x_bignum, &other_val->data.x_bignum);
428		const_val->ok = true;
	349	const_val->special = ConstValSpecialStatic;
429	350	break;
430	351	case CastOpFloatToInt:
431	352	bignum_cast_to_int(&const_val->data.x_bignum, &other_val->data.x_bignum);
432		const_val->ok = true;
	353	const_val->special = ConstValSpecialStatic;
433	354	break;
434	355	case CastOpBoolToInt:
435	356	bignum_init_unsigned(&const_val->data.x_bignum, other_val->data.x_bool ? 1 : 0);
436		const_val->ok = true;
	357	const_val->special = ConstValSpecialStatic;
437	358	break;
438	359	case CastOpIntToEnum:
439	360	{
...	...	@@ -442,12 +363,12 @@ void eval_const_expr_implicit_cast(CastOp cast_op,
442	363	assert(value < new_type->data.enumeration.src_field_count);
443	364	const_val->data.x_enum.tag = value;
444	365	const_val->data.x_enum.payload = NULL;
445		const_val->ok = true;
	366	const_val->special = ConstValSpecialStatic;
446	367	break;
447	368	}
448	369	case CastOpEnumToInt:
449	370	bignum_init_unsigned(&const_val->data.x_bignum, other_val->data.x_enum.tag);
450		const_val->ok = true;
	371	const_val->special = ConstValSpecialStatic;
451	372	break;
452	373	}
453	374	}
...	...	@@ -465,7 +386,7 @@ static bool int_type_depends_on_compile_var(CodeGen g, TypeTableEntry int_type
465	386
466	387	void eval_min_max_value(CodeGen g, TypeTableEntry type_entry, ConstExprValue *const_val, bool is_max) {
467	388	if (type_entry->id == TypeTableEntryIdInt) {
468		const_val->ok = true;
	389	const_val->special = ConstValSpecialStatic;
469	390	const_val->depends_on_compile_var = int_type_depends_on_compile_var(g, type_entry);
470	391	if (is_max) {
471	392	if (type_entry->data.integral.is_signed) {
...	...	@@ -486,7 +407,7 @@ void eval_min_max_value(CodeGen g, TypeTableEntry type_entry, ConstExprValue *
486	407	} else if (type_entry->id == TypeTableEntryIdFloat) {
487	408	zig_panic("TODO analyze_min_max_value float");
488	409	} else if (type_entry->id == TypeTableEntryIdBool) {
489		const_val->ok = true;
	410	const_val->special = ConstValSpecialStatic;
490	411	const_val->data.x_bool = is_max;
491	412	} else {
492	413	zig_unreachable();

src/ir.cpp+125-94

...	...	@@ -35,6 +35,18 @@ static IrInstruction ir_gen_node_extra(IrBuilder irb, AstNode *node, BlockCont
35	35	LValPurpose lval);
36	36	static TypeTableEntry ir_analyze_instruction(IrAnalyze ira, IrInstruction *instruction);
37	37
	38	ConstExprValue const_ptr_pointee(ConstExprValue const_val) {
	39	ConstExprValue *base_ptr = const_val->data.x_ptr.base_ptr;
	40	size_t index = const_val->data.x_ptr.index;
	41
	42	if (index == SIZE_MAX) {
	43	return base_ptr;
	44	} else {
	45	assert(index < base_ptr->data.x_array.size);
	46	return &base_ptr->data.x_array.elements[index];
	47	}
	48	}
	49
38	50	static void ir_instruction_append(IrBasicBlock basic_block, IrInstruction instruction) {
39	51	assert(basic_block);
40	52	assert(instruction);
...	...	@@ -237,7 +249,7 @@ static IrInstruction ir_build_cond_br(IrBuilder irb, AstNode *source_node, IrI
237	249	{
238	250	IrInstructionCondBr *cond_br_instruction = ir_build_instruction<IrInstructionCondBr>(irb, source_node);
239	251	cond_br_instruction->base.type_entry = irb->codegen->builtin_types.entry_unreachable;
240		cond_br_instruction->base.static_value.ok = true;
	252	cond_br_instruction->base.static_value.special = ConstValSpecialStatic;
241	253	cond_br_instruction->condition = condition;
242	254	cond_br_instruction->then_block = then_block;
243	255	cond_br_instruction->else_block = else_block;
...	...	@@ -262,7 +274,7 @@ static IrInstruction ir_build_cond_br_from(IrBuilder irb, IrInstruction *old_i
262	274	static IrInstruction ir_build_return(IrBuilder irb, AstNode source_node, IrInstruction return_value) {
263	275	IrInstructionReturn *return_instruction = ir_build_instruction<IrInstructionReturn>(irb, source_node);
264	276	return_instruction->base.type_entry = irb->codegen->builtin_types.entry_unreachable;
265		return_instruction->base.static_value.ok = true;
	277	return_instruction->base.static_value.special = ConstValSpecialStatic;
266	278	return_instruction->value = return_value;
267	279
268	280	ir_ref_instruction(return_value);
...	...	@@ -281,20 +293,19 @@ static IrInstruction ir_build_return_from(IrBuilder irb, IrInstruction *old_in
281	293	static IrInstruction ir_create_const(IrBuilder irb, AstNode source_node, TypeTableEntry type_entry) {
282	294	IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(irb->exec, source_node);
283	295	const_instruction->base.type_entry = type_entry;
284		const_instruction->base.static_value.ok = true;
	296	const_instruction->base.static_value.special = ConstValSpecialStatic;
285	297	return &const_instruction->base;
286	298	}
287	299
288	300	static IrInstruction ir_build_const_void(IrBuilder irb, AstNode *source_node) {
289	301	IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, source_node);
290	302	const_instruction->base.type_entry = irb->codegen->builtin_types.entry_void;
291		const_instruction->base.static_value.ok = true;
	303	const_instruction->base.static_value.special = ConstValSpecialStatic;
292	304	return &const_instruction->base;
293	305	}
294	306
295	307	static IrInstruction ir_build_const_undefined(IrBuilder irb, AstNode *source_node) {
296	308	IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, source_node);
297		const_instruction->base.static_value.ok = true;
298	309	const_instruction->base.static_value.special = ConstValSpecialUndef;
299	310	const_instruction->base.type_entry = irb->codegen->builtin_types.entry_undef;
300	311	return &const_instruction->base;
...	...	@@ -304,7 +315,7 @@ static IrInstruction ir_build_const_bignum(IrBuilder irb, AstNode *source_node
304	315	IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, source_node);
305	316	const_instruction->base.type_entry = (bignum->kind == BigNumKindInt) ?
306	317	irb->codegen->builtin_types.entry_num_lit_int : irb->codegen->builtin_types.entry_num_lit_float;
307		const_instruction->base.static_value.ok = true;
	318	const_instruction->base.static_value.special = ConstValSpecialStatic;
308	319	const_instruction->base.static_value.data.x_bignum = *bignum;
309	320	return &const_instruction->base;
310	321	}
...	...	@@ -312,7 +323,7 @@ static IrInstruction ir_build_const_bignum(IrBuilder irb, AstNode *source_node
312	323	static IrInstruction ir_build_const_usize(IrBuilder irb, AstNode *source_node, uint64_t value) {
313	324	IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, source_node);
314	325	const_instruction->base.type_entry = irb->codegen->builtin_types.entry_usize;
315		const_instruction->base.static_value.ok = true;
	326	const_instruction->base.static_value.special = ConstValSpecialStatic;
316	327	bignum_init_unsigned(&const_instruction->base.static_value.data.x_bignum, value);
317	328	return &const_instruction->base;
318	329	}
...	...	@@ -320,7 +331,7 @@ static IrInstruction ir_build_const_usize(IrBuilder irb, AstNode *source_node,
320	331	static IrInstruction ir_create_const_type(IrBuilder irb, AstNode source_node, TypeTableEntry type_entry) {
321	332	IrInstructionConst *const_instruction = ir_create_instruction<IrInstructionConst>(irb->exec, source_node);
322	333	const_instruction->base.type_entry = irb->codegen->builtin_types.entry_type;
323		const_instruction->base.static_value.ok = true;
	334	const_instruction->base.static_value.special = ConstValSpecialStatic;
324	335	const_instruction->base.static_value.data.x_type = type_entry;
325	336	return &const_instruction->base;
326	337	}
...	...	@@ -334,7 +345,7 @@ static IrInstruction ir_build_const_type(IrBuilder irb, AstNode *source_node,
334	345	static IrInstruction ir_build_const_fn(IrBuilder irb, AstNode source_node, FnTableEntry fn_entry) {
335	346	IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, source_node);
336	347	const_instruction->base.type_entry = fn_entry->type_entry;
337		const_instruction->base.static_value.ok = true;
	348	const_instruction->base.static_value.special = ConstValSpecialStatic;
338	349	const_instruction->base.static_value.data.x_fn = fn_entry;
339	350	return &const_instruction->base;
340	351	}
...	...	@@ -342,7 +353,7 @@ static IrInstruction ir_build_const_fn(IrBuilder irb, AstNode *source_node, Fn
342	353	static IrInstruction ir_build_const_generic_fn(IrBuilder irb, AstNode source_node, TypeTableEntry fn_type) {
343	354	IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, source_node);
344	355	const_instruction->base.type_entry = fn_type;
345		const_instruction->base.static_value.ok = true;
	356	const_instruction->base.static_value.special = ConstValSpecialStatic;
346	357	const_instruction->base.static_value.data.x_type = fn_type;
347	358	return &const_instruction->base;
348	359	}
...	...	@@ -350,7 +361,7 @@ static IrInstruction ir_build_const_generic_fn(IrBuilder irb, AstNode *source_
350	361	static IrInstruction ir_build_const_import(IrBuilder irb, AstNode source_node, ImportTableEntry import) {
351	362	IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, source_node);
352	363	const_instruction->base.type_entry = irb->codegen->builtin_types.entry_namespace;
353		const_instruction->base.static_value.ok = true;
	364	const_instruction->base.static_value.special = ConstValSpecialStatic;
354	365	const_instruction->base.static_value.data.x_import = import;
355	366	return &const_instruction->base;
356	367	}
...	...	@@ -358,7 +369,7 @@ static IrInstruction ir_build_const_import(IrBuilder irb, AstNode *source_node
358	369	static IrInstruction ir_build_const_scope(IrBuilder irb, AstNode source_node, BlockContext scope) {
359	370	IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, source_node);
360	371	const_instruction->base.type_entry = irb->codegen->builtin_types.entry_block;
361		const_instruction->base.static_value.ok = true;
	372	const_instruction->base.static_value.special = ConstValSpecialStatic;
362	373	const_instruction->base.static_value.data.x_block = scope;
363	374	return &const_instruction->base;
364	375	}
...	...	@@ -366,7 +377,7 @@ static IrInstruction ir_build_const_scope(IrBuilder irb, AstNode *source_node,
366	377	static IrInstruction ir_build_const_bool(IrBuilder irb, AstNode *source_node, bool value) {
367	378	IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, source_node);
368	379	const_instruction->base.type_entry = irb->codegen->builtin_types.entry_bool;
369		const_instruction->base.static_value.ok = true;
	380	const_instruction->base.static_value.special = ConstValSpecialStatic;
370	381	const_instruction->base.static_value.data.x_bool = value;
371	382	return &const_instruction->base;
372	383	}
...	...	@@ -377,45 +388,45 @@ static IrInstruction ir_build_const_str_lit(IrBuilder irb, AstNode *source_nod
377	388	TypeTableEntry *type_entry = get_array_type(irb->codegen, u8_type, buf_len(str));
378	389	const_instruction->base.type_entry = type_entry;
379	390	ConstExprValue *const_val = &const_instruction->base.static_value;
380		const_val->ok = true;
381		const_val->data.x_array.fields = allocate<ConstExprValue*>(buf_len(str));
	391	const_val->special = ConstValSpecialStatic;
	392	const_val->data.x_array.elements = allocate<ConstExprValue>(buf_len(str));
	393	const_val->data.x_array.size = buf_len(str);
382	394
383		ConstExprValue *all_chars = allocate<ConstExprValue>(buf_len(str));
384	395	for (size_t i = 0; i < buf_len(str); i += 1) {
385		ConstExprValue *this_char = &all_chars[i];
386		this_char->ok = true;
	396	ConstExprValue *this_char = &const_val->data.x_array.elements[i];
	397	this_char->special = ConstValSpecialStatic;
387	398	bignum_init_unsigned(&this_char->data.x_bignum, buf_ptr(str)[i]);
388		const_val->data.x_array.fields[i] = this_char;
389	399	}
390	400
391	401	return &const_instruction->base;
392	402	}
393	403
394	404	static IrInstruction ir_build_const_c_str_lit(IrBuilder irb, AstNode source_node, Buf str) {
395		IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, source_node);
396		TypeTableEntry *u8_type = irb->codegen->builtin_types.entry_u8;
397		TypeTableEntry *type_entry = get_pointer_to_type(irb->codegen, u8_type, true);
398		const_instruction->base.type_entry = type_entry;
399		ConstExprValue *const_val = &const_instruction->base.static_value;
400		const_val->ok = true;
401
	405	// first we build the underlying array
402	406	size_t len_with_null = buf_len(str) + 1;
403		const_val->data.x_ptr.ptr = allocate<ConstExprValue*>(len_with_null);
404		const_val->data.x_ptr.len = len_with_null;
405		const_val->data.x_ptr.is_c_str = true;
406
407		ConstExprValue *all_chars = allocate<ConstExprValue>(len_with_null);
	407	ConstExprValue *array_val = allocate<ConstExprValue>(1);
	408	array_val->special = ConstValSpecialStatic;
	409	array_val->data.x_array.elements = allocate<ConstExprValue>(len_with_null);
	410	array_val->data.x_array.size = len_with_null;
408	411	for (size_t i = 0; i < buf_len(str); i += 1) {
409		ConstExprValue *this_char = &all_chars[i];
410		this_char->ok = true;
	412	ConstExprValue *this_char = &array_val->data.x_array.elements[i];
	413	this_char->special = ConstValSpecialStatic;
411	414	bignum_init_unsigned(&this_char->data.x_bignum, buf_ptr(str)[i]);
412		const_val->data.x_ptr.ptr[i] = this_char;
413	415	}
414
415		ConstExprValue *null_char = &all_chars[len_with_null - 1];
416		null_char->ok = true;
	416	ConstExprValue *null_char = &array_val->data.x_array.elements[len_with_null - 1];
	417	null_char->special = ConstValSpecialStatic;
417	418	bignum_init_unsigned(&null_char->data.x_bignum, 0);
418		const_val->data.x_ptr.ptr[len_with_null - 1] = null_char;
	419
	420	// then make the pointer point to it
	421	IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, source_node);
	422	TypeTableEntry *u8_type = irb->codegen->builtin_types.entry_u8;
	423	TypeTableEntry *type_entry = get_pointer_to_type(irb->codegen, u8_type, true);
	424	const_instruction->base.type_entry = type_entry;
	425	ConstExprValue *ptr_val = &const_instruction->base.static_value;
	426	ptr_val->special = ConstValSpecialStatic;
	427	ptr_val->data.x_ptr.base_ptr = array_val;
	428	ptr_val->data.x_ptr.index = 0;
	429	ptr_val->data.x_ptr.is_c_str = true;
419	430
420	431	return &const_instruction->base;
421	432	}
...	...	@@ -591,7 +602,7 @@ static IrInstruction ir_build_phi_from(IrBuilder irb, IrInstruction *old_instr
591	602	static IrInstruction ir_build_br(IrBuilder irb, AstNode source_node, IrBasicBlock dest_block, bool is_inline) {
592	603	IrInstructionBr *br_instruction = ir_build_instruction<IrInstructionBr>(irb, source_node);
593	604	br_instruction->base.type_entry = irb->codegen->builtin_types.entry_unreachable;
594		br_instruction->base.static_value.ok = true;
	605	br_instruction->base.static_value.special = ConstValSpecialStatic;
595	606	br_instruction->dest_block = dest_block;
596	607	br_instruction->is_inline = is_inline;
597	608
...	...	@@ -662,7 +673,7 @@ static IrInstruction ir_build_container_init_fields(IrBuilder irb, AstNode *so
662	673	static IrInstruction ir_build_unreachable(IrBuilder irb, AstNode *source_node) {
663	674	IrInstructionUnreachable *unreachable_instruction =
664	675	ir_build_instruction<IrInstructionUnreachable>(irb, source_node);
665		unreachable_instruction->base.static_value.ok = true;
	676	unreachable_instruction->base.static_value.special = ConstValSpecialStatic;
666	677	unreachable_instruction->base.type_entry = irb->codegen->builtin_types.entry_unreachable;
667	678	return &unreachable_instruction->base;
668	679	}
...	...	@@ -677,7 +688,7 @@ static IrInstruction ir_build_store_ptr(IrBuilder irb, AstNode *source_node,
677	688	IrInstruction ptr, IrInstruction value)
678	689	{
679	690	IrInstructionStorePtr *instruction = ir_build_instruction<IrInstructionStorePtr>(irb, source_node);
680		instruction->base.static_value.ok = true;
	691	instruction->base.static_value.special = ConstValSpecialStatic;
681	692	instruction->base.type_entry = irb->codegen->builtin_types.entry_void;
682	693	instruction->ptr = ptr;
683	694	instruction->value = value;
...	...	@@ -700,7 +711,7 @@ static IrInstruction ir_build_var_decl(IrBuilder irb, AstNode *source_node,
700	711	VariableTableEntry var, IrInstruction var_type, IrInstruction *init_value)
701	712	{
702	713	IrInstructionDeclVar *decl_var_instruction = ir_build_instruction<IrInstructionDeclVar>(irb, source_node);
703		decl_var_instruction->base.static_value.ok = true;
	714	decl_var_instruction->base.static_value.special = ConstValSpecialStatic;
704	715	decl_var_instruction->base.type_entry = irb->codegen->builtin_types.entry_void;
705	716	decl_var_instruction->var = var;
706	717	decl_var_instruction->var_type = var_type;
...	...	@@ -1900,7 +1911,7 @@ static bool ir_num_lit_fits_in_other_type(IrAnalyze ira, IrInstruction instruc
1900	1911	}
1901	1912
1902	1913	ConstExprValue *const_val = &instruction->static_value;
1903		assert(const_val->ok);
	1914	assert(const_val->special != ConstValSpecialRuntime);
1904	1915	if (other_type_underlying->id == TypeTableEntryIdFloat) {
1905	1916	return true;
1906	1917	} else if (other_type_underlying->id == TypeTableEntryIdInt &&
...	...	@@ -2110,10 +2121,10 @@ static IrInstruction ir_resolve_cast(IrAnalyze ira, IrInstruction *source_inst
2110	2121	IrInstruction *dest_type, CastOp cast_op, bool need_alloca)
2111	2122	{
2112	2123	assert(dest_type->type_entry->id == TypeTableEntryIdMetaType);
2113		assert(dest_type->static_value.ok);
	2124	assert(dest_type->static_value.special != ConstValSpecialRuntime);
2114	2125	TypeTableEntry *wanted_type = dest_type->static_value.data.x_type;
2115	2126
2116		if (value->static_value.ok) {
	2127	if (value->static_value.special != ConstValSpecialRuntime) {
2117	2128	IrInstruction *result = ir_create_const(&ira->new_irb, source_instr->source_node, wanted_type);
2118	2129	eval_const_expr_implicit_cast(cast_op, &value->static_value, value->type_entry,
2119	2130	&result->static_value, wanted_type);
...	...	@@ -2194,7 +2205,7 @@ static ConstExprValue ir_build_const_from(IrAnalyze ira, IrInstruction *old_in
2194	2205	}
2195	2206	ir_link_new_instruction(new_instruction, old_instruction);
2196	2207	ConstExprValue *const_val = &new_instruction->static_value;
2197		const_val->ok = true;
	2208	const_val->special = ConstValSpecialStatic;
2198	2209	const_val->depends_on_compile_var = depends_on_compile_var;
2199	2210	return const_val;
2200	2211	}
...	...	@@ -2226,7 +2237,7 @@ static TypeTableEntry ir_resolve_type(IrAnalyze ira, IrInstruction *type_value
2226	2237	}
2227	2238
2228	2239	ConstExprValue *const_val = &type_value->static_value;
2229		if (!const_val->ok) {
	2240	if (const_val->special == ConstValSpecialRuntime) {
2230	2241	add_node_error(ira->codegen, type_value->source_node,
2231	2242	buf_sprintf("unable to evaluate constant expression"));
2232	2243	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -2249,7 +2260,7 @@ static bool ir_resolve_bool(IrAnalyze ira, IrInstruction bool_value, bool *out
2249	2260	}
2250	2261
2251	2262	ConstExprValue *const_val = &bool_value->static_value;
2252		if (!const_val->ok) {
	2263	if (const_val->special == ConstValSpecialRuntime) {
2253	2264	add_node_error(ira->codegen, bool_value->source_node,
2254	2265	buf_sprintf("unable to evaluate constant expression"));
2255	2266	return false;
...	...	@@ -2273,7 +2284,7 @@ static FnTableEntry ir_resolve_fn(IrAnalyze ira, IrInstruction *fn_value) {
2273	2284	}
2274	2285
2275	2286	ConstExprValue *const_val = &fn_value->static_value;
2276		if (!const_val->ok) {
	2287	if (const_val->special == ConstValSpecialRuntime) {
2277	2288	add_node_error(ira->codegen, fn_value->source_node,
2278	2289	buf_sprintf("unable to evaluate constant expression"));
2279	2290	return nullptr;
...	...	@@ -2286,7 +2297,7 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
2286	2297	IrInstruction dest_type, IrInstruction value)
2287	2298	{
2288	2299	assert(dest_type->type_entry->id == TypeTableEntryIdMetaType);
2289		assert(dest_type->static_value.ok);
	2300	assert(dest_type->static_value.special != ConstValSpecialRuntime);
2290	2301
2291	2302	TypeTableEntry *wanted_type = dest_type->static_value.data.x_type;
2292	2303	TypeTableEntry *actual_type = value->type_entry;
...	...	@@ -2618,7 +2629,7 @@ static TypeTableEntry ir_analyze_bin_op_bool(IrAnalyze ira, IrInstructionBinOp
2618	2629
2619	2630	ConstExprValue *op1_val = &casted_op1->static_value;
2620	2631	ConstExprValue *op2_val = &casted_op2->static_value;
2621		if (op1_val->ok && op2_val->ok) {
	2632	if (op1_val->special != ConstValSpecialRuntime && op2_val->special != ConstValSpecialRuntime) {
2622	2633	bool depends_on_compile_var = op1_val->depends_on_compile_var \|\| op2_val->depends_on_compile_var;
2623	2634	ConstExprValue *out_val = ir_build_const_from(ira, &bin_op_instruction->base, depends_on_compile_var);
2624	2635
...	...	@@ -2710,7 +2721,7 @@ static TypeTableEntry ir_analyze_bin_op_cmp(IrAnalyze ira, IrInstructionBinOp
2710	2721
2711	2722	ConstExprValue *op1_val = &casted_op1->static_value;
2712	2723	ConstExprValue *op2_val = &casted_op2->static_value;
2713		if (op1_val->ok && op2_val->ok) {
	2724	if (op1_val->special != ConstValSpecialRuntime && op2_val->special != ConstValSpecialRuntime) {
2714	2725	bool type_can_gt_lt_cmp = (resolved_type->id == TypeTableEntryIdNumLitFloat \|\|
2715	2726	resolved_type->id == TypeTableEntryIdNumLitInt \|\|
2716	2727	resolved_type->id == TypeTableEntryIdFloat \|\|
...	...	@@ -2799,7 +2810,7 @@ static int ir_eval_bignum(ConstExprValue op1_val, ConstExprValue op2_val,
2799	2810	}
2800	2811	}
2801	2812
2802		out_val->ok = true;
	2813	out_val->special = ConstValSpecialStatic;
2803	2814	out_val->depends_on_compile_var = op1_val->depends_on_compile_var \|\| op2_val->depends_on_compile_var;
2804	2815	return 0;
2805	2816	}
...	...	@@ -2892,7 +2903,7 @@ static TypeTableEntry ir_analyze_bin_op_math(IrAnalyze ira, IrInstructionBinOp
2892	2903	return ira->codegen->builtin_types.entry_invalid;
2893	2904
2894	2905
2895		if (casted_op1->static_value.ok && casted_op2->static_value.ok) {
	2906	if (casted_op1->static_value.special != ConstValSpecialRuntime && casted_op2->static_value.special != ConstValSpecialRuntime) {
2896	2907	ConstExprValue *op1_val = &casted_op1->static_value;
2897	2908	ConstExprValue *op2_val = &casted_op2->static_value;
2898	2909	ConstExprValue *out_val = &bin_op_instruction->base.static_value;
...	...	@@ -2992,7 +3003,7 @@ static TypeTableEntry ir_analyze_instruction_decl_var(IrAnalyze ira, IrInstruc
2992	3003	break;
2993	3004	case TypeTableEntryIdNumLitFloat:
2994	3005	case TypeTableEntryIdNumLitInt:
2995		if (is_export \|\| is_extern \|\| !casted_init_value->static_value.ok) {
	3006	if (is_export \|\| is_extern \|\| casted_init_value->static_value.special == ConstValSpecialRuntime) {
2996	3007	add_node_error(ira->codegen, var_type->source_node, buf_sprintf("unable to infer variable type"));
2997	3008	result_type = ira->codegen->builtin_types.entry_invalid;
2998	3009	}
...	...	@@ -3006,7 +3017,7 @@ static TypeTableEntry ir_analyze_instruction_decl_var(IrAnalyze ira, IrInstruc
3006	3017	break;
3007	3018	case TypeTableEntryIdMetaType:
3008	3019	case TypeTableEntryIdNamespace:
3009		if (!casted_init_value->static_value.ok) {
	3020	if (casted_init_value->static_value.special == ConstValSpecialRuntime) {
3010	3021	add_node_error(ira->codegen, var_type->source_node,
3011	3022	buf_sprintf("variable of type '%s' must be constant", buf_ptr(&result_type->name)));
3012	3023	result_type = ira->codegen->builtin_types.entry_invalid;
...	...	@@ -3052,7 +3063,7 @@ static TypeTableEntry ir_analyze_instruction_call(IrAnalyze ira, IrInstruction
3052	3063	if (fn_ref->type_entry->id == TypeTableEntryIdInvalid)
3053	3064	return ira->codegen->builtin_types.entry_invalid;
3054	3065
3055		if (fn_ref->static_value.ok) {
	3066	if (fn_ref->static_value.special != ConstValSpecialRuntime) {
3056	3067	if (fn_ref->type_entry->id == TypeTableEntryIdMetaType) {
3057	3068	size_t actual_param_count = call_instruction->arg_count;
3058	3069
...	...	@@ -3106,9 +3117,9 @@ static TypeTableEntry ir_analyze_unary_bool_not(IrAnalyze ira, IrInstructionUn
3106	3117	return ira->codegen->builtin_types.entry_invalid;
3107	3118
3108	3119	ConstExprValue *operand_val = &casted_value->static_value;
3109		if (operand_val->ok) {
	3120	if (operand_val->special != ConstValSpecialRuntime) {
3110	3121	ConstExprValue *result_val = &un_op_instruction->base.static_value;
3111		result_val->ok = true;
	3122	result_val->special = ConstValSpecialStatic;
3112	3123	result_val->depends_on_compile_var = operand_val->depends_on_compile_var;
3113	3124	result_val->data.x_bool = !operand_val->data.x_bool;
3114	3125	return bool_type;
...	...	@@ -3204,7 +3215,7 @@ static TypeTableEntry ir_analyze_unary_address_of(IrAnalyze ira, IrInstruction
3204	3215	{
3205	3216	ConstExprValue *out_val = ir_build_const_from(ira, &un_op_instruction->base,
3206	3217	value->static_value.depends_on_compile_var);
3207		assert(value->static_value.ok);
	3218	assert(value->static_value.special != ConstValSpecialRuntime);
3208	3219	TypeTableEntry *child_type = value->static_value.data.x_type;
3209	3220	out_val->data.x_type = get_pointer_to_type(ira->codegen, child_type, is_const);
3210	3221	return ira->codegen->builtin_types.entry_type;
...	...	@@ -3252,9 +3263,10 @@ static TypeTableEntry ir_analyze_dereference(IrAnalyze ira, IrInstructionUnOp
3252	3263	// this dereference is always an rvalue because in the IR gen we identify lvalue and emit
3253	3264	// one of the ptr instructions
3254	3265
3255		if (value->static_value.ok) {
	3266	if (value->static_value.special != ConstValSpecialRuntime) {
3256	3267	ConstExprValue *out_val = ir_build_const_from(ira, &un_op_instruction->base, false);
3257		out_val = value->static_value.data.x_ptr.ptr[0];
	3268	ConstExprValue *pointee = const_ptr_pointee(&value->static_value);
	3269	out_val = pointee;
3258	3270	return child_type;
3259	3271	}
3260	3272
...	...	@@ -3428,7 +3440,7 @@ static TypeTableEntry ir_analyze_instruction_cond_br(IrAnalyze ira, IrInstruct
3428	3440	return ir_finish_anal(ira, ira->codegen->builtin_types.entry_unreachable);
3429	3441
3430	3442	// TODO detect backward jumps
3431		if (condition->static_value.ok) {
	3443	if (condition->static_value.special != ConstValSpecialRuntime) {
3432	3444	IrBasicBlock *old_dest_block = condition->static_value.data.x_bool ?
3433	3445	cond_br_instruction->then_block : cond_br_instruction->else_block;
3434	3446
...	...	@@ -3463,7 +3475,7 @@ static TypeTableEntry ir_analyze_instruction_phi(IrAnalyze ira, IrInstructionP
3463	3475	continue;
3464	3476	IrInstruction *value = phi_instruction->incoming_values[i]->other;
3465	3477	assert(value->type_entry);
3466		if (value->static_value.ok) {
	3478	if (value->static_value.special != ConstValSpecialRuntime) {
3467	3479	ConstExprValue *out_val = ir_build_const_from(ira, &phi_instruction->base,
3468	3480	value->static_value.depends_on_compile_var);
3469	3481	*out_val = value->static_value;
...	...	@@ -3523,17 +3535,16 @@ static TypeTableEntry ir_analyze_instruction_var_ptr(IrAnalyze ira, IrInstruct
3523	3535	} else if (var->src_is_const) {
3524	3536	AstNode *var_decl_node = var->decl_node;
3525	3537	assert(var_decl_node->type == NodeTypeVariableDeclaration);
3526		mem_slot = &get_resolved_expr(var_decl_node->data.variable_declaration.expr)->const_val;
3527		assert(mem_slot->ok);
	3538	mem_slot = &get_resolved_expr(var_decl_node->data.variable_declaration.expr)->instruction->static_value;
	3539	assert(mem_slot->special != ConstValSpecialRuntime);
3528	3540	}
3529	3541
3530		if (mem_slot && mem_slot->ok) {
	3542	if (mem_slot && mem_slot->special != ConstValSpecialRuntime) {
3531	3543	ConstExprValue *out_val = ir_build_const_from(ira, &var_ptr_instruction->base,
3532	3544	mem_slot->depends_on_compile_var);
3533	3545
3534		out_val->data.x_ptr.len = 1;
3535		out_val->data.x_ptr.ptr = allocate<ConstExprValue *>(1);
3536		out_val->data.x_ptr.ptr[0] = mem_slot;
	3546	out_val->data.x_ptr.base_ptr = mem_slot;
	3547	out_val->data.x_ptr.index = SIZE_MAX;
3537	3548	return ptr_type;
3538	3549	} else {
3539	3550	ir_build_var_ptr_from(&ira->new_irb, &var_ptr_instruction->base, var);
...	...	@@ -3577,7 +3588,7 @@ static TypeTableEntry ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstruc
3577	3588	if (casted_elem_index == ira->codegen->invalid_instruction)
3578	3589	return ira->codegen->builtin_types.entry_invalid;
3579	3590
3580		if (casted_elem_index->static_value.ok) {
	3591	if (casted_elem_index->static_value.special != ConstValSpecialRuntime) {
3581	3592	uint64_t index = casted_elem_index->static_value.data.x_bignum.data.x_uint;
3582	3593	if (array_type->id == TypeTableEntryIdArray) {
3583	3594	uint64_t array_len = array_type->data.array.len;
...	...	@@ -3589,24 +3600,34 @@ static TypeTableEntry ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstruc
3589	3600	}
3590	3601	}
3591	3602
3592		if (array_ptr->static_value.ok) {
	3603	if (array_ptr->static_value.special != ConstValSpecialRuntime) {
3593	3604	bool depends_on_compile_var = array_ptr->static_value.depends_on_compile_var \|\|
3594	3605	casted_elem_index->static_value.depends_on_compile_var;
3595	3606	ConstExprValue *out_val = ir_build_const_from(ira, &elem_ptr_instruction->base, depends_on_compile_var);
3596		out_val->data.x_ptr.len = 1;
3597		out_val->data.x_ptr.ptr = allocate<ConstExprValue *>(1);
3598	3607	if (array_type->id == TypeTableEntryIdPointer) {
3599		uint64_t pointer_len = array_ptr->static_value.data.x_ptr.len;
3600		if (index >= pointer_len) {
	3608	size_t offset = array_ptr->static_value.data.x_ptr.index;
	3609	size_t new_index;
	3610	size_t mem_size;
	3611	size_t old_size;
	3612	if (offset == SIZE_MAX) {
	3613	new_index = SIZE_MAX;
	3614	mem_size = 1;
	3615	old_size = 1;
	3616	} else {
	3617	new_index = offset + index;
	3618	mem_size = array_ptr->static_value.data.x_ptr.base_ptr->data.x_array.size;
	3619	old_size = mem_size - offset;
	3620	}
	3621	if (new_index >= mem_size) {
3601	3622	add_node_error(ira->codegen, elem_ptr_instruction->base.source_node,
3602		buf_sprintf("index %" PRIu64 " outside pointer of size %" PRIu64,
3603		index, pointer_len));
	3623	buf_sprintf("index %" PRIu64 " outside pointer of size %" PRIu64, index, old_size));
3604	3624	return ira->codegen->builtin_types.entry_invalid;
3605	3625	}
3606		out_val->data.x_ptr.ptr[0] = array_ptr->static_value.data.x_ptr.ptr[index];
	3626	out_val->data.x_ptr.base_ptr = array_ptr->static_value.data.x_ptr.base_ptr;
	3627	out_val->data.x_ptr.index = new_index;
3607	3628	} else if (is_slice(array_type)) {
3608		ConstExprValue *ptr_field = array_ptr->static_value.data.x_struct.fields[0];
3609		ConstExprValue *len_field = array_ptr->static_value.data.x_struct.fields[1];
	3629	ConstExprValue *ptr_field = &array_ptr->static_value.data.x_struct.fields[slice_ptr_index];
	3630	ConstExprValue *len_field = &array_ptr->static_value.data.x_struct.fields[slice_len_index];
3610	3631	uint64_t slice_len = len_field->data.x_bignum.data.x_uint;
3611	3632	if (index >= slice_len) {
3612	3633	add_node_error(ira->codegen, elem_ptr_instruction->base.source_node,
...	...	@@ -3614,10 +3635,18 @@ static TypeTableEntry ir_analyze_instruction_elem_ptr(IrAnalyze ira, IrInstruc
3614	3635	index, slice_len));
3615	3636	return ira->codegen->builtin_types.entry_invalid;
3616	3637	}
3617		assert(index < ptr_field->data.x_ptr.len);
3618		out_val->data.x_ptr.ptr[0] = ptr_field->data.x_ptr.ptr[index];
	3638	out_val->data.x_ptr.base_ptr = ptr_field->data.x_ptr.base_ptr;
	3639	size_t offset = ptr_field->data.x_ptr.index;
	3640	if (offset == SIZE_MAX) {
	3641	out_val->data.x_ptr.index = SIZE_MAX;
	3642	} else {
	3643	uint64_t new_index = offset + index;
	3644	assert(new_index < ptr_field->data.x_ptr.base_ptr->data.x_array.size);
	3645	out_val->data.x_ptr.index = new_index;
	3646	}
3619	3647	} else if (array_type->id == TypeTableEntryIdArray) {
3620		out_val->data.x_ptr.ptr[0] = array_ptr->static_value.data.x_array.fields[index];
	3648	out_val->data.x_ptr.base_ptr = &array_ptr->static_value;
	3649	out_val->data.x_ptr.index = index;
3621	3650	} else {
3622	3651	zig_unreachable();
3623	3652	}
...	...	@@ -3790,9 +3819,9 @@ static TypeTableEntry ir_analyze_instruction_load_ptr(IrAnalyze ira, IrInstruc
3790	3819	return type_entry;
3791	3820	} else if (type_entry->id == TypeTableEntryIdPointer) {
3792	3821	TypeTableEntry *child_type = type_entry->data.pointer.child_type;
3793		if (ptr->static_value.ok) {
3794		ConstExprValue *pointee = ptr->static_value.data.x_ptr.ptr[0];
3795		if (pointee->ok) {
	3822	if (ptr->static_value.special != ConstValSpecialRuntime) {
	3823	ConstExprValue *pointee = const_ptr_pointee(&ptr->static_value);
	3824	if (pointee->special != ConstValSpecialRuntime) {
3796	3825	ConstExprValue *out_val = ir_build_const_from(ira, &load_ptr_instruction->base,
3797	3826	pointee->depends_on_compile_var);
3798	3827	out_val = pointee;
...	...	@@ -3823,18 +3852,20 @@ static TypeTableEntry ir_analyze_instruction_store_ptr(IrAnalyze ira, IrInstru
3823	3852	if (casted_value == ira->codegen->invalid_instruction)
3824	3853	return ira->codegen->builtin_types.entry_invalid;
3825	3854
3826		if (ptr->static_value.ok && casted_value->static_value.ok) {
3827		ConstExprValue *dest_val = ptr->static_value.data.x_ptr.ptr[0];
3828		if (dest_val->ok) {
	3855	if (ptr->static_value.special != ConstValSpecialRuntime &&
	3856	casted_value->static_value.special != ConstValSpecialRuntime)
	3857	{
	3858	ConstExprValue *dest_val = const_ptr_pointee(&ptr->static_value);
	3859	if (dest_val->special != ConstValSpecialRuntime) {
3829	3860	*dest_val = casted_value->static_value;
3830	3861	return ir_analyze_void(ira, &store_ptr_instruction->base);
3831	3862	}
3832	3863	}
3833	3864
3834		if (ptr->static_value.ok) {
	3865	if (ptr->static_value.special != ConstValSpecialRuntime) {
3835	3866	// This memory location is transforming from known at compile time to known at runtime.
3836	3867	// We must emit our own var ptr instruction.
3837		ptr->static_value.ok = false;
	3868	ptr->static_value.special = ConstValSpecialRuntime;
3838	3869	IrInstruction *new_ptr_inst;
3839	3870	if (ptr->id == IrInstructionIdVarPtr) {
3840	3871	IrInstructionVarPtr var_ptr_inst = (IrInstructionVarPtr )ptr;
...	...	@@ -3842,7 +3873,7 @@ static TypeTableEntry ir_analyze_instruction_store_ptr(IrAnalyze ira, IrInstru
3842	3873	new_ptr_inst = ir_build_var_ptr(&ira->new_irb, store_ptr_instruction->base.source_node, var);
3843	3874	assert(var->mem_slot_index != SIZE_MAX);
3844	3875	ConstExprValue *mem_slot = &ira->exec_context.mem_slot_list[var->mem_slot_index];
3845		mem_slot->ok = false;
	3876	mem_slot->special = ConstValSpecialRuntime;
3846	3877	} else if (ptr->id == IrInstructionIdFieldPtr) {
3847	3878	zig_panic("TODO");
3848	3879	} else if (ptr->id == IrInstructionIdElemPtr) {
...	...	@@ -4236,7 +4267,7 @@ IrInstruction ir_exec_const_result(IrExecutable exec) {
4236	4267
4237	4268	IrInstructionReturn ret_inst = (IrInstructionReturn )only_inst;
4238	4269	IrInstruction *value = ret_inst->value;
4239		assert(value->static_value.ok);
	4270	assert(value->static_value.special != ConstValSpecialRuntime);
4240	4271	return value;
4241	4272	}
4242	4273

src/ir.hpp+1

...	...	@@ -19,5 +19,6 @@ TypeTableEntry ir_analyze(CodeGen g, IrExecutable *old_executable, IrExecutabl
19	19	IrInstruction ir_exec_const_result(IrExecutable exec);
20	20
21	21	bool ir_has_side_effects(IrInstruction *instruction);
	22	ConstExprValue const_ptr_pointee(ConstExprValue const_val);
22	23
23	24	#endif

src/ir_print.cpp+6-4

...	...	@@ -23,13 +23,15 @@ static void ir_print_prefix(IrPrint irp, IrInstruction instruction) {
23	23
24	24	static void ir_print_const_value(IrPrint irp, TypeTableEntry type_entry, ConstExprValue *const_val) {
25	25	switch (const_val->special) {
	26	case ConstValSpecialRuntime:
	27	zig_unreachable();
26	28	case ConstValSpecialUndef:
27	29	fprintf(irp->f, "undefined");
28	30	return;
29	31	case ConstValSpecialZeroes:
30	32	fprintf(irp->f, "zeroes");
31	33	return;
32		case ConstValSpecialOther:
	34	case ConstValSpecialStatic:
33	35	break;
34	36	}
35	37	switch (type_entry->id) {
...	...	@@ -70,7 +72,7 @@ static void ir_print_const_value(IrPrint irp, TypeTableEntry type_entry, Const
70	72	}
71	73	case TypeTableEntryIdPointer:
72	74	fprintf(irp->f, "&");
73		ir_print_const_value(irp, type_entry->data.pointer.child_type, const_val->data.x_ptr.ptr[0]);
	75	ir_print_const_value(irp, type_entry->data.pointer.child_type, const_ptr_pointee(const_val));
74	76	break;
75	77	case TypeTableEntryIdFn:
76	78	{
...	...	@@ -91,7 +93,7 @@ static void ir_print_const_value(IrPrint irp, TypeTableEntry type_entry, Const
91	93	for (uint64_t i = 0; i < len; i += 1) {
92	94	if (i != 0)
93	95	fprintf(irp->f, ",");
94		ConstExprValue *child_value = const_val->data.x_array.fields[i];
	96	ConstExprValue *child_value = &const_val->data.x_array.elements[i];
95	97	TypeTableEntry *child_type = type_entry->data.array.child_type;
96	98	ir_print_const_value(irp, child_type, child_value);
97	99	}
...	...	@@ -126,7 +128,7 @@ static void ir_print_var_instruction(IrPrint irp, IrInstruction instruction) {
126	128	}
127	129
128	130	static void ir_print_other_instruction(IrPrint irp, IrInstruction instruction) {
129		if (instruction->static_value.ok) {
	131	if (instruction->static_value.special != ConstValSpecialRuntime) {
130	132	ir_print_const_instruction(irp, instruction);
131	133	} else {
132	134	ir_print_var_instruction(irp, instruction);

src/parser.cpp-1

...	...	@@ -2763,7 +2763,6 @@ AstNode ast_clone_subtree_special(AstNode old_node, uint32_t *next_node_index,
2763	2763	old_node->data.prefix_op_expr.primary_expr, next_node_index);
2764	2764	break;
2765	2765	case NodeTypeFnCallExpr:
2766		assert(!old_node->data.fn_call_expr.resolved_expr.has_global_const);
2767	2766	clone_subtree_field(&new_node->data.fn_call_expr.fn_ref_expr,
2768	2767	old_node->data.fn_call_expr.fn_ref_expr, next_node_index);
2769	2768	clone_subtree_list(&new_node->data.fn_call_expr.params,