authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2019-11-13 20:43:32-05:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2019-11-14 03:52:39-05:00
logd89f39d71949c85b26f2ccd4071c9445aa8b6d7c
treeb770509b52976a23e483eb58f6edadc70da1ca95
parentf2f698a888afdc8709142912f8394376d28e16ea
signaturelock-open Commit is signed but in an unrecognized format.

rework layout of struct type fields

This removes the remaining hack in the implementation of anonymous struct literals, and they can now therefore now have greater than 16 fields/elements.

6 files changed, 144 insertions(+), 134 deletions(-)

src/all_types.hpp+1-1
......@@ -1279,7 +1279,7 @@ struct RootStruct {
12791279
12801280struct ZigTypeStruct {
12811281 AstNode *decl_node;
1282 TypeStructField *fields;
1282 TypeStructField **fields;
12831283 ScopeDecls *decls_scope;
12841284 HashMap<Buf *, TypeStructField *, buf_hash, buf_eql_buf> fields_by_name;
12851285 RootStruct *root_struct;
src/analyze.cpp+55-40
......@@ -803,19 +803,19 @@ ZigType *get_slice_type(CodeGen *g, ZigType *ptr_type) {
803803 entry->data.structure.is_slice = true;
804804 entry->data.structure.src_field_count = element_count;
805805 entry->data.structure.gen_field_count = element_count;
806 entry->data.structure.fields = allocate<TypeStructField>(element_count);
806 entry->data.structure.fields = alloc_type_struct_fields(element_count);
807807 entry->data.structure.fields_by_name.init(element_count);
808 entry->data.structure.fields[slice_ptr_index].name = ptr_field_name;
809 entry->data.structure.fields[slice_ptr_index].type_entry = ptr_type;
810 entry->data.structure.fields[slice_ptr_index].src_index = slice_ptr_index;
811 entry->data.structure.fields[slice_ptr_index].gen_index = 0;
812 entry->data.structure.fields[slice_len_index].name = len_field_name;
813 entry->data.structure.fields[slice_len_index].type_entry = g->builtin_types.entry_usize;
814 entry->data.structure.fields[slice_len_index].src_index = slice_len_index;
815 entry->data.structure.fields[slice_len_index].gen_index = 1;
816
817 entry->data.structure.fields_by_name.put(ptr_field_name, &entry->data.structure.fields[slice_ptr_index]);
818 entry->data.structure.fields_by_name.put(len_field_name, &entry->data.structure.fields[slice_len_index]);
808 entry->data.structure.fields[slice_ptr_index]->name = ptr_field_name;
809 entry->data.structure.fields[slice_ptr_index]->type_entry = ptr_type;
810 entry->data.structure.fields[slice_ptr_index]->src_index = slice_ptr_index;
811 entry->data.structure.fields[slice_ptr_index]->gen_index = 0;
812 entry->data.structure.fields[slice_len_index]->name = len_field_name;
813 entry->data.structure.fields[slice_len_index]->type_entry = g->builtin_types.entry_usize;
814 entry->data.structure.fields[slice_len_index]->src_index = slice_len_index;
815 entry->data.structure.fields[slice_len_index]->gen_index = 1;
816
817 entry->data.structure.fields_by_name.put(ptr_field_name, entry->data.structure.fields[slice_ptr_index]);
818 entry->data.structure.fields_by_name.put(len_field_name, entry->data.structure.fields[slice_len_index]);
819819
820820 switch (type_requires_comptime(g, ptr_type)) {
821821 case ReqCompTimeInvalid:
......@@ -828,8 +828,8 @@ ZigType *get_slice_type(CodeGen *g, ZigType *ptr_type) {
828828
829829 if (!type_has_bits(ptr_type)) {
830830 entry->data.structure.gen_field_count = 1;
831 entry->data.structure.fields[slice_ptr_index].gen_index = SIZE_MAX;
832 entry->data.structure.fields[slice_len_index].gen_index = 0;
831 entry->data.structure.fields[slice_ptr_index]->gen_index = SIZE_MAX;
832 entry->data.structure.fields[slice_len_index]->gen_index = 0;
833833 }
834834
835835 ZigType *child_type = ptr_type->data.pointer.child_type;
......@@ -1984,12 +1984,12 @@ static ZigType *get_struct_type(CodeGen *g, const char *type_name, SrcField fiel
19841984 struct_type->data.structure.src_field_count = field_count;
19851985 struct_type->data.structure.gen_field_count = 0;
19861986 struct_type->data.structure.resolve_status = ResolveStatusSizeKnown;
1987 struct_type->data.structure.fields = allocate<TypeStructField>(field_count);
1987 struct_type->data.structure.fields = alloc_type_struct_fields(field_count);
19881988 struct_type->data.structure.fields_by_name.init(field_count);
19891989
19901990 size_t abi_align = min_abi_align;
19911991 for (size_t i = 0; i < field_count; i += 1) {
1992 TypeStructField *field = &struct_type->data.structure.fields[i];
1992 TypeStructField *field = struct_type->data.structure.fields[i];
19931993 field->name = buf_create_from_str(fields[i].name);
19941994 field->type_entry = fields[i].ty;
19951995 field->src_index = i;
......@@ -2009,7 +2009,7 @@ static ZigType *get_struct_type(CodeGen *g, const char *type_name, SrcField fiel
20092009
20102010 size_t next_offset = 0;
20112011 for (size_t i = 0; i < field_count; i += 1) {
2012 TypeStructField *field = &struct_type->data.structure.fields[i];
2012 TypeStructField *field = struct_type->data.structure.fields[i];
20132013 if (!type_has_bits(field->type_entry))
20142014 continue;
20152015
......@@ -2018,7 +2018,7 @@ static ZigType *get_struct_type(CodeGen *g, const char *type_name, SrcField fiel
20182018 // find the next non-zero-byte field for offset calculations
20192019 size_t next_src_field_index = i + 1;
20202020 for (; next_src_field_index < field_count; next_src_field_index += 1) {
2021 if (type_has_bits(struct_type->data.structure.fields[next_src_field_index].type_entry))
2021 if (type_has_bits(struct_type->data.structure.fields[next_src_field_index]->type_entry))
20222022 break;
20232023 }
20242024 size_t next_abi_align;
......@@ -2026,7 +2026,7 @@ static ZigType *get_struct_type(CodeGen *g, const char *type_name, SrcField fiel
20262026 next_abi_align = abi_align;
20272027 } else {
20282028 next_abi_align = max(fields[next_src_field_index].align,
2029 struct_type->data.structure.fields[next_src_field_index].type_entry->abi_align);
2029 struct_type->data.structure.fields[next_src_field_index]->type_entry->abi_align);
20302030 }
20312031 next_offset = next_field_offset(next_offset, abi_align, field->type_entry->abi_size, next_abi_align);
20322032 }
......@@ -2109,7 +2109,7 @@ static Error resolve_struct_type(CodeGen *g, ZigType *struct_type) {
21092109
21102110 // Calculate offsets
21112111 for (size_t i = 0; i < field_count; i += 1) {
2112 TypeStructField *field = &struct_type->data.structure.fields[i];
2112 TypeStructField *field = struct_type->data.structure.fields[i];
21132113 if (field->gen_index == SIZE_MAX)
21142114 continue;
21152115
......@@ -2178,12 +2178,12 @@ static Error resolve_struct_type(CodeGen *g, ZigType *struct_type) {
21782178 gen_field_index += 1;
21792179 size_t next_src_field_index = i + 1;
21802180 for (; next_src_field_index < field_count; next_src_field_index += 1) {
2181 if (struct_type->data.structure.fields[next_src_field_index].gen_index != SIZE_MAX) {
2181 if (struct_type->data.structure.fields[next_src_field_index]->gen_index != SIZE_MAX) {
21822182 break;
21832183 }
21842184 }
21852185 size_t next_align = (next_src_field_index == field_count) ?
2186 abi_align : struct_type->data.structure.fields[next_src_field_index].align;
2186 abi_align : struct_type->data.structure.fields[next_src_field_index]->align;
21872187 next_offset = next_field_offset(next_offset, abi_align, field_abi_size, next_align);
21882188 size_in_bits = next_offset * 8;
21892189 }
......@@ -2206,7 +2206,7 @@ static Error resolve_struct_type(CodeGen *g, ZigType *struct_type) {
22062206
22072207 // Resolve types for fields
22082208 for (size_t i = 0; i < field_count; i += 1) {
2209 TypeStructField *field = &struct_type->data.structure.fields[i];
2209 TypeStructField *field = struct_type->data.structure.fields[i];
22102210 ZigType *field_type = resolve_struct_field_type(g, field);
22112211 if (field_type == nullptr) {
22122212 struct_type->data.structure.resolve_status = ResolveStatusInvalid;
......@@ -2697,7 +2697,7 @@ static Error resolve_struct_zero_bits(CodeGen *g, ZigType *struct_type) {
26972697 struct_type->data.structure.src_field_count = (uint32_t)field_count;
26982698
26992699 src_assert(struct_type->data.structure.fields == nullptr, decl_node);
2700 struct_type->data.structure.fields = allocate<TypeStructField>(field_count);
2700 struct_type->data.structure.fields = alloc_type_struct_fields(field_count);
27012701 } else if (decl_node->type == NodeTypeContainerInitExpr) {
27022702 src_assert(struct_type->data.structure.is_inferred, decl_node);
27032703 src_assert(struct_type->data.structure.fields != nullptr, decl_node);
......@@ -2711,7 +2711,7 @@ static Error resolve_struct_zero_bits(CodeGen *g, ZigType *struct_type) {
27112711
27122712 size_t gen_field_index = 0;
27132713 for (size_t i = 0; i < field_count; i += 1) {
2714 TypeStructField *type_struct_field = &struct_type->data.structure.fields[i];
2714 TypeStructField *type_struct_field = struct_type->data.structure.fields[i];
27152715
27162716 AstNode *field_node;
27172717 if (decl_node->type == NodeTypeContainerDecl) {
......@@ -2843,7 +2843,7 @@ static Error resolve_struct_alignment(CodeGen *g, ZigType *struct_type) {
28432843 bool packed = struct_type->data.structure.layout == ContainerLayoutPacked;
28442844
28452845 for (size_t i = 0; i < field_count; i += 1) {
2846 TypeStructField *field = &struct_type->data.structure.fields[i];
2846 TypeStructField *field = struct_type->data.structure.fields[i];
28472847 if (field->gen_index == SIZE_MAX)
28482848 continue;
28492849
......@@ -5506,7 +5506,7 @@ OnePossibleValue type_has_one_possible_value(CodeGen *g, ZigType *type_entry) {
55065506 return type_has_one_possible_value(g, type_entry->data.array.child_type);
55075507 case ZigTypeIdStruct:
55085508 for (size_t i = 0; i < type_entry->data.structure.src_field_count; i += 1) {
5509 TypeStructField *field = &type_entry->data.structure.fields[i];
5509 TypeStructField *field = type_entry->data.structure.fields[i];
55105510 OnePossibleValue opv = (field->type_entry != nullptr) ?
55115511 type_has_one_possible_value(g, field->type_entry) :
55125512 type_val_resolve_has_one_possible_value(g, field->type_val);
......@@ -5902,6 +5902,21 @@ ConstExprValue **realloc_const_vals_ptrs(ConstExprValue **ptr, size_t old_count,
59025902 return result;
59035903}
59045904
5905TypeStructField **alloc_type_struct_fields(size_t count) {
5906 return realloc_type_struct_fields(nullptr, 0, count);
5907}
5908
5909TypeStructField **realloc_type_struct_fields(TypeStructField **ptr, size_t old_count, size_t new_count) {
5910 assert(new_count >= old_count);
5911
5912 size_t new_item_count = new_count - old_count;
5913 TypeStructField **result = reallocate(ptr, old_count, new_count, "TypeStructField*");
5914 TypeStructField *vals = allocate<TypeStructField>(new_item_count, "TypeStructField");
5915 for (size_t i = old_count; i < new_count; i += 1) {
5916 result[i] = &vals[i - old_count];
5917 }
5918 return result;
5919}
59055920
59065921static ZigType *get_async_fn_type(CodeGen *g, ZigType *orig_fn_type) {
59075922 if (orig_fn_type->data.fn.fn_type_id.cc == CallingConventionAsync)
......@@ -7176,7 +7191,7 @@ static void init_const_undefined(CodeGen *g, ConstExprValue *const_val) {
71767191 const_val->data.x_struct.fields = alloc_const_vals_ptrs(field_count);
71777192 for (size_t i = 0; i < field_count; i += 1) {
71787193 ConstExprValue *field_val = const_val->data.x_struct.fields[i];
7179 field_val->type = resolve_struct_field_type(g, &wanted_type->data.structure.fields[i]);
7194 field_val->type = resolve_struct_field_type(g, wanted_type->data.structure.fields[i]);
71807195 assert(field_val->type);
71817196 init_const_undefined(g, field_val);
71827197 field_val->parent.id = ConstParentIdStruct;
......@@ -7608,7 +7623,7 @@ static X64CABIClass type_system_V_abi_x86_64_class(CodeGen *g, ZigType *ty, size
76087623 }
76097624 X64CABIClass working_class = X64CABIClass_Unknown;
76107625 for (uint32_t i = 0; i < ty->data.structure.src_field_count; i += 1) {
7611 X64CABIClass field_class = type_c_abi_x86_64_class(g, ty->data.structure.fields->type_entry);
7626 X64CABIClass field_class = type_c_abi_x86_64_class(g, ty->data.structure.fields[0]->type_entry);
76127627 if (field_class == X64CABIClass_Unknown)
76137628 return X64CABIClass_Unknown;
76147629 if (i == 0 || field_class == X64CABIClass_MEMORY || working_class == X64CABIClass_SSE) {
......@@ -7740,7 +7755,7 @@ Buf *type_h_name(ZigType *t) {
77407755static void resolve_llvm_types_slice(CodeGen *g, ZigType *type, ResolveStatus wanted_resolve_status) {
77417756 if (type->data.structure.resolve_status >= wanted_resolve_status) return;
77427757
7743 ZigType *ptr_type = type->data.structure.fields[slice_ptr_index].type_entry;
7758 ZigType *ptr_type = type->data.structure.fields[slice_ptr_index]->type_entry;
77447759 ZigType *child_type = ptr_type->data.pointer.child_type;
77457760 ZigType *usize_type = g->builtin_types.entry_usize;
77467761
......@@ -7762,7 +7777,7 @@ static void resolve_llvm_types_slice(CodeGen *g, ZigType *type, ResolveStatus wa
77627777 // If the child type is []const T then we need to make sure the type ref
77637778 // and debug info is the same as if the child type were []T.
77647779 if (is_slice(child_type)) {
7765 ZigType *child_ptr_type = child_type->data.structure.fields[slice_ptr_index].type_entry;
7780 ZigType *child_ptr_type = child_type->data.structure.fields[slice_ptr_index]->type_entry;
77667781 assert(child_ptr_type->id == ZigTypeIdPointer);
77677782 if (child_ptr_type->data.pointer.is_const || child_ptr_type->data.pointer.is_volatile ||
77687783 child_ptr_type->data.pointer.explicit_alignment != 0 || child_ptr_type->data.pointer.allow_zero)
......@@ -7939,7 +7954,7 @@ static void resolve_llvm_types_struct(CodeGen *g, ZigType *struct_type, ResolveS
79397954
79407955 // trigger all the recursive get_llvm_type calls
79417956 for (size_t i = 0; i < field_count; i += 1) {
7942 TypeStructField *field = &struct_type->data.structure.fields[i];
7957 TypeStructField *field = struct_type->data.structure.fields[i];
79437958 ZigType *field_type = field->type_entry;
79447959 if (!type_has_bits(field_type))
79457960 continue;
......@@ -7953,7 +7968,7 @@ static void resolve_llvm_types_struct(CodeGen *g, ZigType *struct_type, ResolveS
79537968 // inserting padding bytes where LLVM would do it automatically.
79547969 size_t llvm_struct_abi_align = 0;
79557970 for (size_t i = 0; i < field_count; i += 1) {
7956 ZigType *field_type = struct_type->data.structure.fields[i].type_entry;
7971 ZigType *field_type = struct_type->data.structure.fields[i]->type_entry;
79577972 if (!type_has_bits(field_type))
79587973 continue;
79597974 LLVMTypeRef field_llvm_type = get_llvm_type(g, field_type);
......@@ -7962,7 +7977,7 @@ static void resolve_llvm_types_struct(CodeGen *g, ZigType *struct_type, ResolveS
79627977 }
79637978
79647979 for (size_t i = 0; i < field_count; i += 1) {
7965 TypeStructField *field = &struct_type->data.structure.fields[i];
7980 TypeStructField *field = struct_type->data.structure.fields[i];
79667981 ZigType *field_type = field->type_entry;
79677982
79687983 if (!type_has_bits(field_type)) {
......@@ -8012,23 +8027,23 @@ static void resolve_llvm_types_struct(CodeGen *g, ZigType *struct_type, ResolveS
80128027 // find the next non-zero-byte field for offset calculations
80138028 size_t next_src_field_index = i + 1;
80148029 for (; next_src_field_index < field_count; next_src_field_index += 1) {
8015 if (type_has_bits(struct_type->data.structure.fields[next_src_field_index].type_entry))
8030 if (type_has_bits(struct_type->data.structure.fields[next_src_field_index]->type_entry))
80168031 break;
80178032 }
80188033 size_t next_abi_align;
80198034 if (next_src_field_index == field_count) {
80208035 next_abi_align = struct_type->abi_align;
80218036 } else {
8022 if (struct_type->data.structure.fields[next_src_field_index].align == 0) {
8023 next_abi_align = struct_type->data.structure.fields[next_src_field_index].type_entry->abi_align;
8037 if (struct_type->data.structure.fields[next_src_field_index]->align == 0) {
8038 next_abi_align = struct_type->data.structure.fields[next_src_field_index]->type_entry->abi_align;
80248039 } else {
8025 next_abi_align = struct_type->data.structure.fields[next_src_field_index].align;
8040 next_abi_align = struct_type->data.structure.fields[next_src_field_index]->align;
80268041 }
80278042 }
80288043 size_t llvm_next_abi_align = (next_src_field_index == field_count) ?
80298044 llvm_struct_abi_align :
80308045 LLVMABIAlignmentOfType(g->target_data_ref,
8031 get_llvm_type(g, struct_type->data.structure.fields[next_src_field_index].type_entry));
8046 get_llvm_type(g, struct_type->data.structure.fields[next_src_field_index]->type_entry));
80328047
80338048 size_t next_offset = next_field_offset(field->offset, struct_type->abi_align,
80348049 field_type->abi_size, next_abi_align);
......@@ -8067,7 +8082,7 @@ static void resolve_llvm_types_struct(CodeGen *g, ZigType *struct_type, ResolveS
80678082 ZigLLVMDIType **di_element_types = allocate<ZigLLVMDIType*>(debug_field_count);
80688083 size_t debug_field_index = 0;
80698084 for (size_t i = 0; i < field_count; i += 1) {
8070 TypeStructField *field = &struct_type->data.structure.fields[i];
8085 TypeStructField *field = struct_type->data.structure.fields[i];
80718086 size_t gen_field_index = field->gen_index;
80728087 if (gen_field_index == SIZE_MAX) {
80738088 continue;
src/analyze.hpp+3
......@@ -180,6 +180,9 @@ ConstExprValue *create_const_vals(size_t count);
180180ConstExprValue **alloc_const_vals_ptrs(size_t count);
181181ConstExprValue **realloc_const_vals_ptrs(ConstExprValue **ptr, size_t old_count, size_t new_count);
182182
183TypeStructField **alloc_type_struct_fields(size_t count);
184TypeStructField **realloc_type_struct_fields(TypeStructField **ptr, size_t old_count, size_t new_count);
185
183186ZigType *make_int_type(CodeGen *g, bool is_signed, uint32_t size_in_bits);
184187void expand_undef_array(CodeGen *g, ConstExprValue *const_val);
185188void expand_undef_struct(CodeGen *g, ConstExprValue *const_val);
src/codegen.cpp+44-44
......@@ -1108,15 +1108,15 @@ static LLVMValueRef get_add_error_return_trace_addr_fn(CodeGen *g) {
11081108 LLVMValueRef err_ret_trace_ptr = LLVMGetParam(fn_val, 0);
11091109 LLVMValueRef address_value = LLVMGetParam(fn_val, 1);
11101110
1111 size_t index_field_index = g->stack_trace_type->data.structure.fields[0].gen_index;
1111 size_t index_field_index = g->stack_trace_type->data.structure.fields[0]->gen_index;
11121112 LLVMValueRef index_field_ptr = LLVMBuildStructGEP(g->builder, err_ret_trace_ptr, (unsigned)index_field_index, "");
1113 size_t addresses_field_index = g->stack_trace_type->data.structure.fields[1].gen_index;
1113 size_t addresses_field_index = g->stack_trace_type->data.structure.fields[1]->gen_index;
11141114 LLVMValueRef addresses_field_ptr = LLVMBuildStructGEP(g->builder, err_ret_trace_ptr, (unsigned)addresses_field_index, "");
11151115
1116 ZigType *slice_type = g->stack_trace_type->data.structure.fields[1].type_entry;
1117 size_t ptr_field_index = slice_type->data.structure.fields[slice_ptr_index].gen_index;
1116 ZigType *slice_type = g->stack_trace_type->data.structure.fields[1]->type_entry;
1117 size_t ptr_field_index = slice_type->data.structure.fields[slice_ptr_index]->gen_index;
11181118 LLVMValueRef ptr_field_ptr = LLVMBuildStructGEP(g->builder, addresses_field_ptr, (unsigned)ptr_field_index, "");
1119 size_t len_field_index = slice_type->data.structure.fields[slice_len_index].gen_index;
1119 size_t len_field_index = slice_type->data.structure.fields[slice_len_index]->gen_index;
11201120 LLVMValueRef len_field_ptr = LLVMBuildStructGEP(g->builder, addresses_field_ptr, (unsigned)len_field_index, "");
11211121
11221122 LLVMValueRef len_value = gen_load_untyped(g, len_field_ptr, 0, false, "");
......@@ -2176,16 +2176,16 @@ static LLVMValueRef get_merge_err_ret_traces_fn_val(CodeGen *g) {
21762176 LLVMBuildCondBr(g->builder, null_bit, return_block, non_null_block);
21772177
21782178 LLVMPositionBuilderAtEnd(g->builder, non_null_block);
2179 size_t src_index_field_index = g->stack_trace_type->data.structure.fields[0].gen_index;
2180 size_t src_addresses_field_index = g->stack_trace_type->data.structure.fields[1].gen_index;
2179 size_t src_index_field_index = g->stack_trace_type->data.structure.fields[0]->gen_index;
2180 size_t src_addresses_field_index = g->stack_trace_type->data.structure.fields[1]->gen_index;
21812181 LLVMValueRef src_index_field_ptr = LLVMBuildStructGEP(g->builder, src_stack_trace_ptr,
21822182 (unsigned)src_index_field_index, "");
21832183 LLVMValueRef src_addresses_field_ptr = LLVMBuildStructGEP(g->builder, src_stack_trace_ptr,
21842184 (unsigned)src_addresses_field_index, "");
2185 ZigType *slice_type = g->stack_trace_type->data.structure.fields[1].type_entry;
2186 size_t ptr_field_index = slice_type->data.structure.fields[slice_ptr_index].gen_index;
2185 ZigType *slice_type = g->stack_trace_type->data.structure.fields[1]->type_entry;
2186 size_t ptr_field_index = slice_type->data.structure.fields[slice_ptr_index]->gen_index;
21872187 LLVMValueRef src_ptr_field_ptr = LLVMBuildStructGEP(g->builder, src_addresses_field_ptr, (unsigned)ptr_field_index, "");
2188 size_t len_field_index = slice_type->data.structure.fields[slice_len_index].gen_index;
2188 size_t len_field_index = slice_type->data.structure.fields[slice_len_index]->gen_index;
21892189 LLVMValueRef src_len_field_ptr = LLVMBuildStructGEP(g->builder, src_addresses_field_ptr, (unsigned)len_field_index, "");
21902190 LLVMValueRef src_index_val = LLVMBuildLoad(g->builder, src_index_field_ptr, "");
21912191 LLVMValueRef src_ptr_val = LLVMBuildLoad(g->builder, src_ptr_field_ptr, "");
......@@ -3010,21 +3010,21 @@ static LLVMValueRef ir_render_resize_slice(CodeGen *g, IrExecutable *executable,
30103010 assert(actual_type->id == ZigTypeIdStruct);
30113011 assert(actual_type->data.structure.is_slice);
30123012
3013 ZigType *actual_pointer_type = actual_type->data.structure.fields[0].type_entry;
3013 ZigType *actual_pointer_type = actual_type->data.structure.fields[0]->type_entry;
30143014 ZigType *actual_child_type = actual_pointer_type->data.pointer.child_type;
3015 ZigType *wanted_pointer_type = wanted_type->data.structure.fields[0].type_entry;
3015 ZigType *wanted_pointer_type = wanted_type->data.structure.fields[0]->type_entry;
30163016 ZigType *wanted_child_type = wanted_pointer_type->data.pointer.child_type;
30173017
30183018
3019 size_t actual_ptr_index = actual_type->data.structure.fields[slice_ptr_index].gen_index;
3020 size_t actual_len_index = actual_type->data.structure.fields[slice_len_index].gen_index;
3021 size_t wanted_ptr_index = wanted_type->data.structure.fields[slice_ptr_index].gen_index;
3022 size_t wanted_len_index = wanted_type->data.structure.fields[slice_len_index].gen_index;
3019 size_t actual_ptr_index = actual_type->data.structure.fields[slice_ptr_index]->gen_index;
3020 size_t actual_len_index = actual_type->data.structure.fields[slice_len_index]->gen_index;
3021 size_t wanted_ptr_index = wanted_type->data.structure.fields[slice_ptr_index]->gen_index;
3022 size_t wanted_len_index = wanted_type->data.structure.fields[slice_len_index]->gen_index;
30233023
30243024 LLVMValueRef src_ptr_ptr = LLVMBuildStructGEP(g->builder, expr_val, (unsigned)actual_ptr_index, "");
30253025 LLVMValueRef src_ptr = gen_load_untyped(g, src_ptr_ptr, 0, false, "");
30263026 LLVMValueRef src_ptr_casted = LLVMBuildBitCast(g->builder, src_ptr,
3027 get_llvm_type(g, wanted_type->data.structure.fields[0].type_entry), "");
3027 get_llvm_type(g, wanted_type->data.structure.fields[0]->type_entry), "");
30283028 LLVMValueRef dest_ptr_ptr = LLVMBuildStructGEP(g->builder, result_loc,
30293029 (unsigned)wanted_ptr_index, "");
30303030 gen_store_untyped(g, src_ptr_casted, dest_ptr_ptr, 0, false);
......@@ -3140,9 +3140,9 @@ static LLVMValueRef ir_render_ptr_of_array_to_slice(CodeGen *g, IrExecutable *ex
31403140{
31413141 ZigType *actual_type = instruction->operand->value.type;
31423142 ZigType *slice_type = instruction->base.value.type;
3143 ZigType *slice_ptr_type = slice_type->data.structure.fields[slice_ptr_index].type_entry;
3144 size_t ptr_index = slice_type->data.structure.fields[slice_ptr_index].gen_index;
3145 size_t len_index = slice_type->data.structure.fields[slice_len_index].gen_index;
3143 ZigType *slice_ptr_type = slice_type->data.structure.fields[slice_ptr_index]->type_entry;
3144 size_t ptr_index = slice_type->data.structure.fields[slice_ptr_index]->gen_index;
3145 size_t len_index = slice_type->data.structure.fields[slice_len_index]->gen_index;
31463146
31473147 LLVMValueRef result_loc = ir_llvm_value(g, instruction->result_loc);
31483148
......@@ -3766,14 +3766,14 @@ static LLVMValueRef ir_render_elem_ptr(CodeGen *g, IrExecutable *executable, IrI
37663766 assert(LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(array_ptr))) == LLVMStructTypeKind);
37673767
37683768 if (safety_check_on) {
3769 size_t len_index = array_type->data.structure.fields[slice_len_index].gen_index;
3769 size_t len_index = array_type->data.structure.fields[slice_len_index]->gen_index;
37703770 assert(len_index != SIZE_MAX);
37713771 LLVMValueRef len_ptr = LLVMBuildStructGEP(g->builder, array_ptr, (unsigned)len_index, "");
37723772 LLVMValueRef len = gen_load_untyped(g, len_ptr, 0, false, "");
37733773 add_bounds_check(g, subscript_value, LLVMIntEQ, nullptr, LLVMIntULT, len);
37743774 }
37753775
3776 size_t ptr_index = array_type->data.structure.fields[slice_ptr_index].gen_index;
3776 size_t ptr_index = array_type->data.structure.fields[slice_ptr_index]->gen_index;
37773777 assert(ptr_index != SIZE_MAX);
37783778 LLVMValueRef ptr_ptr = LLVMBuildStructGEP(g->builder, array_ptr, (unsigned)ptr_index, "");
37793779 LLVMValueRef ptr = gen_load_untyped(g, ptr_ptr, 0, false, "");
......@@ -3865,7 +3865,7 @@ static void render_async_spills(CodeGen *g) {
38653865 if (instruction->field_index == SIZE_MAX)
38663866 continue;
38673867
3868 size_t gen_index = frame_type->data.structure.fields[instruction->field_index].gen_index;
3868 size_t gen_index = frame_type->data.structure.fields[instruction->field_index]->gen_index;
38693869 instruction->base.llvm_value = LLVMBuildStructGEP(g->builder, g->cur_frame_ptr, gen_index,
38703870 instruction->name_hint);
38713871 }
......@@ -4992,10 +4992,10 @@ static LLVMValueRef ir_render_align_cast(CodeGen *g, IrExecutable *executable, I
49924992 align_bytes = target_type->data.maybe.child_type->data.fn.fn_type_id.alignment;
49934993 ptr_val = target_val;
49944994 } else if (target_type->id == ZigTypeIdStruct && target_type->data.structure.is_slice) {
4995 ZigType *slice_ptr_type = target_type->data.structure.fields[slice_ptr_index].type_entry;
4995 ZigType *slice_ptr_type = target_type->data.structure.fields[slice_ptr_index]->type_entry;
49964996 align_bytes = get_ptr_align(g, slice_ptr_type);
49974997
4998 size_t ptr_index = target_type->data.structure.fields[slice_ptr_index].gen_index;
4998 size_t ptr_index = target_type->data.structure.fields[slice_ptr_index]->gen_index;
49994999 LLVMValueRef ptr_val_ptr = LLVMBuildStructGEP(g->builder, target_val, (unsigned)ptr_index, "");
50005000 ptr_val = gen_load_untyped(g, ptr_val_ptr, 0, false, "");
50015001 } else {
......@@ -5240,13 +5240,13 @@ static LLVMValueRef ir_render_slice(CodeGen *g, IrExecutable *executable, IrInst
52405240 }
52415241
52425242 if (type_has_bits(array_type)) {
5243 size_t gen_ptr_index = instruction->base.value.type->data.structure.fields[slice_ptr_index].gen_index;
5243 size_t gen_ptr_index = instruction->base.value.type->data.structure.fields[slice_ptr_index]->gen_index;
52445244 LLVMValueRef ptr_field_ptr = LLVMBuildStructGEP(g->builder, tmp_struct_ptr, gen_ptr_index, "");
52455245 LLVMValueRef slice_start_ptr = LLVMBuildInBoundsGEP(g->builder, array_ptr, &start_val, 1, "");
52465246 gen_store_untyped(g, slice_start_ptr, ptr_field_ptr, 0, false);
52475247 }
52485248
5249 size_t gen_len_index = instruction->base.value.type->data.structure.fields[slice_len_index].gen_index;
5249 size_t gen_len_index = instruction->base.value.type->data.structure.fields[slice_len_index]->gen_index;
52505250 LLVMValueRef len_field_ptr = LLVMBuildStructGEP(g->builder, tmp_struct_ptr, gen_len_index, "");
52515251 LLVMValueRef len_value = LLVMBuildNSWSub(g->builder, end_val, start_val, "");
52525252 gen_store_untyped(g, len_value, len_field_ptr, 0, false);
......@@ -5258,9 +5258,9 @@ static LLVMValueRef ir_render_slice(CodeGen *g, IrExecutable *executable, IrInst
52585258 assert(LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(array_ptr))) == LLVMStructTypeKind);
52595259 assert(LLVMGetTypeKind(LLVMGetElementType(LLVMTypeOf(tmp_struct_ptr))) == LLVMStructTypeKind);
52605260
5261 size_t ptr_index = array_type->data.structure.fields[slice_ptr_index].gen_index;
5261 size_t ptr_index = array_type->data.structure.fields[slice_ptr_index]->gen_index;
52625262 assert(ptr_index != SIZE_MAX);
5263 size_t len_index = array_type->data.structure.fields[slice_len_index].gen_index;
5263 size_t len_index = array_type->data.structure.fields[slice_len_index]->gen_index;
52645264 assert(len_index != SIZE_MAX);
52655265
52665266 LLVMValueRef prev_end = nullptr;
......@@ -6568,7 +6568,7 @@ static LLVMValueRef pack_const_int(CodeGen *g, LLVMTypeRef big_int_type_ref, Con
65686568 LLVMValueRef val = LLVMConstInt(big_int_type_ref, 0, false);
65696569 size_t used_bits = 0;
65706570 for (size_t i = 0; i < type_entry->data.structure.src_field_count; i += 1) {
6571 TypeStructField *field = &type_entry->data.structure.fields[i];
6571 TypeStructField *field = type_entry->data.structure.fields[i];
65726572 if (field->gen_index == SIZE_MAX) {
65736573 continue;
65746574 }
......@@ -6647,7 +6647,7 @@ static LLVMValueRef gen_const_val_ptr(CodeGen *g, ConstExprValue *const_val, con
66476647 return const_val->global_refs->llvm_value;
66486648 }
66496649 size_t src_field_index = const_val->data.x_ptr.data.base_struct.field_index;
6650 size_t gen_field_index = struct_const_val->type->data.structure.fields[src_field_index].gen_index;
6650 size_t gen_field_index = struct_const_val->type->data.structure.fields[src_field_index]->gen_index;
66516651 LLVMValueRef uncasted_ptr_val = gen_const_ptr_struct_recursive(g, struct_const_val,
66526652 gen_field_index);
66536653 LLVMValueRef ptr_val = LLVMConstBitCast(uncasted_ptr_val, get_llvm_type(g, const_val->type));
......@@ -6826,7 +6826,7 @@ check: switch (const_val->special) {
68266826 if (type_entry->data.structure.layout == ContainerLayoutPacked) {
68276827 size_t src_field_index = 0;
68286828 while (src_field_index < src_field_count) {
6829 TypeStructField *type_struct_field = &type_entry->data.structure.fields[src_field_index];
6829 TypeStructField *type_struct_field = type_entry->data.structure.fields[src_field_index];
68306830 if (type_struct_field->gen_index == SIZE_MAX) {
68316831 src_field_index += 1;
68326832 continue;
......@@ -6834,7 +6834,7 @@ check: switch (const_val->special) {
68346834
68356835 size_t src_field_index_end = src_field_index + 1;
68366836 for (; src_field_index_end < src_field_count; src_field_index_end += 1) {
6837 TypeStructField *it_field = &type_entry->data.structure.fields[src_field_index_end];
6837 TypeStructField *it_field = type_entry->data.structure.fields[src_field_index_end];
68386838 if (it_field->gen_index != type_struct_field->gen_index)
68396839 break;
68406840 }
......@@ -6853,7 +6853,7 @@ check: switch (const_val->special) {
68536853 LLVMValueRef val = LLVMConstInt(big_int_type_ref, 0, false);
68546854 size_t used_bits = 0;
68556855 for (size_t i = src_field_index; i < src_field_index_end; i += 1) {
6856 TypeStructField *it_field = &type_entry->data.structure.fields[i];
6856 TypeStructField *it_field = type_entry->data.structure.fields[i];
68576857 if (it_field->gen_index == SIZE_MAX) {
68586858 continue;
68596859 }
......@@ -6893,7 +6893,7 @@ check: switch (const_val->special) {
68936893 }
68946894 } else {
68956895 for (uint32_t i = 0; i < src_field_count; i += 1) {
6896 TypeStructField *type_struct_field = &type_entry->data.structure.fields[i];
6896 TypeStructField *type_struct_field = type_entry->data.structure.fields[i];
68976897 if (type_struct_field->gen_index == SIZE_MAX) {
68986898 continue;
68996899 }
......@@ -6910,10 +6910,10 @@ check: switch (const_val->special) {
69106910 make_unnamed_struct = make_unnamed_struct || is_llvm_value_unnamed_type(g, field_val->type, val);
69116911
69126912 size_t end_pad_gen_index = (i + 1 < src_field_count) ?
6913 type_entry->data.structure.fields[i + 1].gen_index :
6913 type_entry->data.structure.fields[i + 1]->gen_index :
69146914 type_entry->data.structure.gen_field_count;
69156915 size_t next_offset = (i + 1 < src_field_count) ?
6916 type_entry->data.structure.fields[i + 1].offset : type_entry->abi_size;
6916 type_entry->data.structure.fields[i + 1]->offset : type_entry->abi_size;
69176917 if (end_pad_gen_index != SIZE_MAX) {
69186918 for (size_t gen_i = type_struct_field->gen_index + 1; gen_i < end_pad_gen_index;
69196919 gen_i += 1)
......@@ -7576,15 +7576,15 @@ static void do_code_gen(CodeGen *g) {
75767576 // finishing error return trace setup. we have to do this after all the allocas.
75777577 if (have_err_ret_trace_stack) {
75787578 ZigType *usize = g->builtin_types.entry_usize;
7579 size_t index_field_index = g->stack_trace_type->data.structure.fields[0].gen_index;
7579 size_t index_field_index = g->stack_trace_type->data.structure.fields[0]->gen_index;
75807580 LLVMValueRef index_field_ptr = LLVMBuildStructGEP(g->builder, g->cur_err_ret_trace_val_stack, (unsigned)index_field_index, "");
75817581 gen_store_untyped(g, LLVMConstNull(usize->llvm_type), index_field_ptr, 0, false);
75827582
7583 size_t addresses_field_index = g->stack_trace_type->data.structure.fields[1].gen_index;
7583 size_t addresses_field_index = g->stack_trace_type->data.structure.fields[1]->gen_index;
75847584 LLVMValueRef addresses_field_ptr = LLVMBuildStructGEP(g->builder, g->cur_err_ret_trace_val_stack, (unsigned)addresses_field_index, "");
75857585
7586 ZigType *slice_type = g->stack_trace_type->data.structure.fields[1].type_entry;
7587 size_t ptr_field_index = slice_type->data.structure.fields[slice_ptr_index].gen_index;
7586 ZigType *slice_type = g->stack_trace_type->data.structure.fields[1]->type_entry;
7587 size_t ptr_field_index = slice_type->data.structure.fields[slice_ptr_index]->gen_index;
75887588 LLVMValueRef ptr_field_ptr = LLVMBuildStructGEP(g->builder, addresses_field_ptr, (unsigned)ptr_field_index, "");
75897589 LLVMValueRef zero = LLVMConstNull(usize->llvm_type);
75907590 LLVMValueRef indices[] = {zero, zero};
......@@ -7593,7 +7593,7 @@ static void do_code_gen(CodeGen *g) {
75937593 ZigType *ptr_ptr_usize_type = get_pointer_to_type(g, get_pointer_to_type(g, usize, false), false);
75947594 gen_store(g, err_ret_array_val_elem0_ptr, ptr_field_ptr, ptr_ptr_usize_type);
75957595
7596 size_t len_field_index = slice_type->data.structure.fields[slice_len_index].gen_index;
7596 size_t len_field_index = slice_type->data.structure.fields[slice_len_index]->gen_index;
75977597 LLVMValueRef len_field_ptr = LLVMBuildStructGEP(g->builder, addresses_field_ptr, (unsigned)len_field_index, "");
75987598 gen_store(g, LLVMConstInt(usize->llvm_type, stack_trace_ptr_count, false), len_field_ptr, get_pointer_to_type(g, usize, false));
75997599 }
......@@ -9508,7 +9508,7 @@ static void prepend_c_type_to_decl_list(CodeGen *g, GenH *gen_h, ZigType *type_e
95089508 return;
95099509 case ZigTypeIdStruct:
95109510 for (uint32_t i = 0; i < type_entry->data.structure.src_field_count; i += 1) {
9511 TypeStructField *field = &type_entry->data.structure.fields[i];
9511 TypeStructField *field = type_entry->data.structure.fields[i];
95129512 prepend_c_type_to_decl_list(g, gen_h, field->type_entry);
95139513 }
95149514 gen_h->types_to_declare.append(type_entry);
......@@ -9874,7 +9874,7 @@ static void gen_h_file(CodeGen *g) {
98749874 if (type_entry->data.structure.layout == ContainerLayoutExtern) {
98759875 fprintf(out_h, "struct %s {\n", buf_ptr(type_h_name(type_entry)));
98769876 for (uint32_t field_i = 0; field_i < type_entry->data.structure.src_field_count; field_i += 1) {
9877 TypeStructField *struct_field = &type_entry->data.structure.fields[field_i];
9877 TypeStructField *struct_field = type_entry->data.structure.fields[field_i];
98789878
98799879 Buf *type_name_buf = buf_alloc();
98809880 get_c_type(g, gen_h, struct_field->type_entry, type_name_buf);
src/dump_analysis.cpp+3-3
......@@ -268,7 +268,7 @@ static void tree_print_struct(FILE *f, ZigType *struct_type, size_t indent) {
268268 ZigList<ZigType *> children = {};
269269 uint64_t sum_from_fields = 0;
270270 for (size_t i = 0; i < struct_type->data.structure.src_field_count; i += 1) {
271 TypeStructField *field = &struct_type->data.structure.fields[i];
271 TypeStructField *field = struct_type->data.structure.fields[i];
272272 children.append(field->type_entry);
273273 sum_from_fields += field->type_entry->abi_size;
274274 }
......@@ -747,7 +747,7 @@ static void anal_dump_type(AnalDumpCtx *ctx, ZigType *ty) {
747747 if (ty->data.structure.is_slice) {
748748 jw_object_field(jw, "len");
749749 jw_int(jw, 2);
750 anal_dump_pointer_attrs(ctx, ty->data.structure.fields[slice_ptr_index].type_entry);
750 anal_dump_pointer_attrs(ctx, ty->data.structure.fields[slice_ptr_index]->type_entry);
751751 break;
752752 }
753753
......@@ -803,7 +803,7 @@ static void anal_dump_type(AnalDumpCtx *ctx, ZigType *ty) {
803803
804804 for(size_t i = 0; i < ty->data.structure.src_field_count; i += 1) {
805805 jw_array_elem(jw);
806 anal_dump_type_ref(ctx, ty->data.structure.fields[i].type_entry);
806 anal_dump_type_ref(ctx, ty->data.structure.fields[i]->type_entry);
807807 }
808808 jw_end_array(jw);
809809 }
src/ir.cpp+38-46
......@@ -277,7 +277,7 @@ static bool is_slice(ZigType *type) {
277277
278278static bool slice_is_const(ZigType *type) {
279279 assert(is_slice(type));
280 return type->data.structure.fields[slice_ptr_index].type_entry->data.pointer.is_const;
280 return type->data.structure.fields[slice_ptr_index]->type_entry->data.pointer.is_const;
281281}
282282
283283// This function returns true when you can change the type of a ConstExprValue and the
......@@ -9858,8 +9858,8 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze *ira, ZigType *wanted
98589858
98599859 // slice const
98609860 if (is_slice(wanted_type) && is_slice(actual_type)) {
9861 ZigType *actual_ptr_type = actual_type->data.structure.fields[slice_ptr_index].type_entry;
9862 ZigType *wanted_ptr_type = wanted_type->data.structure.fields[slice_ptr_index].type_entry;
9861 ZigType *actual_ptr_type = actual_type->data.structure.fields[slice_ptr_index]->type_entry;
9862 ZigType *wanted_ptr_type = wanted_type->data.structure.fields[slice_ptr_index]->type_entry;
98639863 if ((err = type_resolve(g, actual_ptr_type->data.pointer.child_type, ResolveStatusAlignmentKnown))) {
98649864 result.id = ConstCastResultIdInvalid;
98659865 return result;
......@@ -10623,7 +10623,7 @@ static ZigType *ir_resolve_peer_types(IrAnalyze *ira, AstNode *source_node, ZigT
1062310623 ZigType *array_type = cur_type->data.pointer.child_type;
1062410624 ZigType *slice_type = (prev_type->id == ZigTypeIdErrorUnion) ?
1062510625 prev_type->data.error_union.payload_type : prev_type;
10626 ZigType *slice_ptr_type = slice_type->data.structure.fields[slice_ptr_index].type_entry;
10626 ZigType *slice_ptr_type = slice_type->data.structure.fields[slice_ptr_index]->type_entry;
1062710627 if ((slice_ptr_type->data.pointer.is_const || array_type->data.array.len == 0) &&
1062810628 types_match_const_cast_only(ira,
1062910629 slice_ptr_type->data.pointer.child_type,
......@@ -10644,7 +10644,7 @@ static ZigType *ir_resolve_peer_types(IrAnalyze *ira, AstNode *source_node, ZigT
1064410644 ZigType *array_type = prev_type->data.pointer.child_type;
1064510645 ZigType *slice_type = (cur_type->id == ZigTypeIdErrorUnion) ?
1064610646 cur_type->data.error_union.payload_type : cur_type;
10647 ZigType *slice_ptr_type = slice_type->data.structure.fields[slice_ptr_index].type_entry;
10647 ZigType *slice_ptr_type = slice_type->data.structure.fields[slice_ptr_index]->type_entry;
1064810648 if ((slice_ptr_type->data.pointer.is_const || array_type->data.array.len == 0) &&
1064910649 types_match_const_cast_only(ira,
1065010650 slice_ptr_type->data.pointer.child_type,
......@@ -10658,10 +10658,10 @@ static ZigType *ir_resolve_peer_types(IrAnalyze *ira, AstNode *source_node, ZigT
1065810658
1065910659 // [N]T to []T
1066010660 if (cur_type->id == ZigTypeIdArray && is_slice(prev_type) &&
10661 (prev_type->data.structure.fields[slice_ptr_index].type_entry->data.pointer.is_const ||
10661 (prev_type->data.structure.fields[slice_ptr_index]->type_entry->data.pointer.is_const ||
1066210662 cur_type->data.array.len == 0) &&
1066310663 types_match_const_cast_only(ira,
10664 prev_type->data.structure.fields[slice_ptr_index].type_entry->data.pointer.child_type,
10664 prev_type->data.structure.fields[slice_ptr_index]->type_entry->data.pointer.child_type,
1066510665 cur_type->data.array.child_type, source_node, false).id == ConstCastResultIdOk)
1066610666 {
1066710667 convert_to_const_slice = false;
......@@ -10670,10 +10670,10 @@ static ZigType *ir_resolve_peer_types(IrAnalyze *ira, AstNode *source_node, ZigT
1067010670
1067110671 // [N]T to []T
1067210672 if (prev_type->id == ZigTypeIdArray && is_slice(cur_type) &&
10673 (cur_type->data.structure.fields[slice_ptr_index].type_entry->data.pointer.is_const ||
10673 (cur_type->data.structure.fields[slice_ptr_index]->type_entry->data.pointer.is_const ||
1067410674 prev_type->data.array.len == 0) &&
1067510675 types_match_const_cast_only(ira,
10676 cur_type->data.structure.fields[slice_ptr_index].type_entry->data.pointer.child_type,
10676 cur_type->data.structure.fields[slice_ptr_index]->type_entry->data.pointer.child_type,
1067710677 prev_type->data.array.child_type, source_node, false).id == ConstCastResultIdOk)
1067810678 {
1067910679 prev_inst = cur_inst;
......@@ -10978,7 +10978,7 @@ static IrInstruction *ir_resolve_ptr_of_array_to_slice(IrAnalyze *ira, IrInstruc
1097810978 assert(value->value.type->id == ZigTypeIdPointer);
1097910979 ZigType *array_type = value->value.type->data.pointer.child_type;
1098010980 assert(is_slice(wanted_type));
10981 bool is_const = wanted_type->data.structure.fields[slice_ptr_index].type_entry->data.pointer.is_const;
10981 bool is_const = wanted_type->data.structure.fields[slice_ptr_index]->type_entry->data.pointer.is_const;
1098210982
1098310983 IrInstruction *result = ir_const(ira, source_instr, wanted_type);
1098410984 init_const_slice(ira->codegen, &result->value, pointee, 0, array_type->data.array.len, is_const);
......@@ -12775,7 +12775,7 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
1277512775 // cast from [N]T to []const T
1277612776 // TODO: once https://github.com/ziglang/zig/issues/265 lands, remove this
1277712777 if (is_slice(wanted_type) && actual_type->id == ZigTypeIdArray) {
12778 ZigType *ptr_type = wanted_type->data.structure.fields[slice_ptr_index].type_entry;
12778 ZigType *ptr_type = wanted_type->data.structure.fields[slice_ptr_index]->type_entry;
1277912779 assert(ptr_type->id == ZigTypeIdPointer);
1278012780 if ((ptr_type->data.pointer.is_const || actual_type->data.array.len == 0) &&
1278112781 types_match_const_cast_only(ira, ptr_type->data.pointer.child_type, actual_type->data.array.child_type,
......@@ -12792,7 +12792,7 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
1279212792 actual_type->id == ZigTypeIdArray)
1279312793 {
1279412794 ZigType *ptr_type =
12795 wanted_type->data.maybe.child_type->data.structure.fields[slice_ptr_index].type_entry;
12795 wanted_type->data.maybe.child_type->data.structure.fields[slice_ptr_index]->type_entry;
1279612796 assert(ptr_type->id == ZigTypeIdPointer);
1279712797 if ((ptr_type->data.pointer.is_const || actual_type->data.array.len == 0) &&
1279812798 types_match_const_cast_only(ira, ptr_type->data.pointer.child_type, actual_type->data.array.child_type,
......@@ -12841,7 +12841,7 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
1284112841 {
1284212842 ZigType *slice_type = (wanted_type->id == ZigTypeIdErrorUnion) ?
1284312843 wanted_type->data.error_union.payload_type : wanted_type;
12844 ZigType *slice_ptr_type = slice_type->data.structure.fields[slice_ptr_index].type_entry;
12844 ZigType *slice_ptr_type = slice_type->data.structure.fields[slice_ptr_index]->type_entry;
1284512845 assert(slice_ptr_type->id == ZigTypeIdPointer);
1284612846 ZigType *array_type = actual_type->data.pointer.child_type;
1284712847 bool const_ok = (slice_ptr_type->data.pointer.is_const || array_type->data.array.len == 0
......@@ -12895,7 +12895,7 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
1289512895 actual_type->data.pointer.child_type->id == ZigTypeIdArray)
1289612896 {
1289712897 ZigType *slice_type = wanted_type->data.error_union.payload_type;
12898 ZigType *slice_ptr_type = slice_type->data.structure.fields[slice_ptr_index].type_entry;
12898 ZigType *slice_ptr_type = slice_type->data.structure.fields[slice_ptr_index]->type_entry;
1289912899 assert(slice_ptr_type->id == ZigTypeIdPointer);
1290012900 ZigType *array_type = actual_type->data.pointer.child_type;
1290112901 bool const_ok = (slice_ptr_type->data.pointer.is_const || array_type->data.array.len == 0
......@@ -12972,7 +12972,7 @@ static IrInstruction *ir_analyze_cast(IrAnalyze *ira, IrInstruction *source_inst
1297212972 actual_type->id == ZigTypeIdArray)
1297312973 {
1297412974 ZigType *ptr_type =
12975 wanted_type->data.error_union.payload_type->data.structure.fields[slice_ptr_index].type_entry;
12975 wanted_type->data.error_union.payload_type->data.structure.fields[slice_ptr_index]->type_entry;
1297612976 assert(ptr_type->id == ZigTypeIdPointer);
1297712977 if ((ptr_type->data.pointer.is_const || actual_type->data.array.len == 0) &&
1297812978 types_match_const_cast_only(ira, ptr_type->data.pointer.child_type, actual_type->data.array.child_type,
......@@ -14817,7 +14817,7 @@ static IrInstruction *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *i
1481714817 op1_array_index = op1_val->data.x_ptr.data.base_array.elem_index;
1481814818 op1_array_end = op1_array_val->type->data.array.len - 1;
1481914819 } else if (is_slice(op1_type)) {
14820 ZigType *ptr_type = op1_type->data.structure.fields[slice_ptr_index].type_entry;
14820 ZigType *ptr_type = op1_type->data.structure.fields[slice_ptr_index]->type_entry;
1482114821 child_type = ptr_type->data.pointer.child_type;
1482214822 ConstExprValue *ptr_val = op1_val->data.x_struct.fields[slice_ptr_index];
1482314823 assert(ptr_val->data.x_ptr.special == ConstPtrSpecialBaseArray);
......@@ -14850,7 +14850,7 @@ static IrInstruction *ir_analyze_array_cat(IrAnalyze *ira, IrInstructionBinOp *i
1485014850 op2_array_index = op2_val->data.x_ptr.data.base_array.elem_index;
1485114851 op2_array_end = op2_array_val->type->data.array.len - 1;
1485214852 } else if (is_slice(op2_type)) {
14853 ZigType *ptr_type = op2_type->data.structure.fields[slice_ptr_index].type_entry;
14853 ZigType *ptr_type = op2_type->data.structure.fields[slice_ptr_index]->type_entry;
1485414854 op2_type_valid = ptr_type->data.pointer.child_type == child_type;
1485514855 ConstExprValue *ptr_val = op2_val->data.x_struct.fields[slice_ptr_index];
1485614856 assert(ptr_val->data.x_ptr.special == ConstPtrSpecialBaseArray);
......@@ -16458,18 +16458,10 @@ static IrInstruction *ir_analyze_store_ptr(IrAnalyze *ira, IrInstruction *source
1645816458 uint32_t old_field_count = isf->inferred_struct_type->data.structure.src_field_count;
1645916459 uint32_t new_field_count = old_field_count + 1;
1646016460 isf->inferred_struct_type->data.structure.src_field_count = new_field_count;
16461 if (new_field_count > 16) {
16462 // This thing with 16 is a hack to allow this functionality to work without
16463 // modifying the ConstExprValue layout of structs. That reworking needs to be
16464 // done, but this hack lets us do it separately, in the future.
16465 zig_panic("TODO need to rework the layout of ZigTypeStruct. This realloc would have caused invalid pointer references");
16466 }
16467 if (isf->inferred_struct_type->data.structure.fields == nullptr) {
16468 isf->inferred_struct_type->data.structure.fields = allocate<TypeStructField>(16);
16469 }
16461 isf->inferred_struct_type->data.structure.fields = realloc_type_struct_fields(
16462 isf->inferred_struct_type->data.structure.fields, old_field_count, new_field_count);
1647016463
16471 // This reference can't live long, don't keep it around outside this block.
16472 TypeStructField *field = &isf->inferred_struct_type->data.structure.fields[old_field_count];
16464 TypeStructField *field = isf->inferred_struct_type->data.structure.fields[old_field_count];
1647316465 field->name = isf->field_name;
1647416466 field->type_entry = uncasted_value->value.type;
1647516467 field->type_val = create_const_type(ira->codegen, field->type_entry);
......@@ -17900,7 +17892,7 @@ static ZigType *adjust_ptr_align(CodeGen *g, ZigType *ptr_type, uint32_t new_ali
1790017892
1790117893static ZigType *adjust_slice_align(CodeGen *g, ZigType *slice_type, uint32_t new_align) {
1790217894 assert(is_slice(slice_type));
17903 ZigType *ptr_type = adjust_ptr_align(g, slice_type->data.structure.fields[slice_ptr_index].type_entry,
17895 ZigType *ptr_type = adjust_ptr_align(g, slice_type->data.structure.fields[slice_ptr_index]->type_entry,
1790417896 new_align);
1790517897 return get_slice_type(g, ptr_type);
1790617898}
......@@ -17986,7 +17978,7 @@ static IrInstruction *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstruct
1798617978 }
1798717979 return_type = adjust_ptr_len(ira->codegen, array_type, elem_ptr_instruction->ptr_len);
1798817980 } else if (is_slice(array_type)) {
17989 return_type = adjust_ptr_len(ira->codegen, array_type->data.structure.fields[slice_ptr_index].type_entry,
17981 return_type = adjust_ptr_len(ira->codegen, array_type->data.structure.fields[slice_ptr_index]->type_entry,
1799017982 elem_ptr_instruction->ptr_len);
1799117983 } else if (array_type->id == ZigTypeIdArgTuple) {
1799217984 ConstExprValue *ptr_val = ir_resolve_const(ira, array_ptr, UndefBad);
......@@ -18464,7 +18456,7 @@ static IrInstruction *ir_analyze_struct_field_ptr(IrAnalyze *ira, IrInstruction
1846418456 ConstExprValue *field_val = struct_val->data.x_struct.fields[i];
1846518457 field_val->special = ConstValSpecialUndef;
1846618458 field_val->type = resolve_struct_field_type(ira->codegen,
18467 &struct_type->data.structure.fields[i]);
18459 struct_type->data.structure.fields[i]);
1846818460 field_val->parent.id = ConstParentIdStruct;
1846918461 field_val->parent.data.p_struct.struct_val = struct_val;
1847018462 field_val->parent.data.p_struct.field_index = i;
......@@ -20385,7 +20377,7 @@ static IrInstruction *ir_analyze_container_init_fields(IrAnalyze *ira, IrInstruc
2038520377 if (field_assign_nodes[i] != nullptr) continue;
2038620378
2038720379 // look for a default field value
20388 TypeStructField *field = &container_type->data.structure.fields[i];
20380 TypeStructField *field = container_type->data.structure.fields[i];
2038920381 if (field->init_val == nullptr) {
2039020382 // it's not memoized. time to go analyze it
2039120383 AstNode *init_node;
......@@ -20396,7 +20388,7 @@ static IrInstruction *ir_analyze_container_init_fields(IrAnalyze *ira, IrInstruc
2039620388 }
2039720389 if (init_node == nullptr) {
2039820390 ir_add_error_node(ira, instruction->source_node,
20399 buf_sprintf("missing field: '%s'", buf_ptr(container_type->data.structure.fields[i].name)));
20391 buf_sprintf("missing field: '%s'", buf_ptr(container_type->data.structure.fields[i]->name)));
2040020392 any_missing = true;
2040120393 continue;
2040220394 }
......@@ -21198,7 +21190,7 @@ static ConstExprValue *create_ptr_like_type_info(IrAnalyze *ira, ZigType *ptr_ty
2119821190 ZigType *attrs_type;
2119921191 BuiltinPtrSize size_enum_index;
2120021192 if (is_slice(ptr_type_entry)) {
21201 attrs_type = ptr_type_entry->data.structure.fields[slice_ptr_index].type_entry;
21193 attrs_type = ptr_type_entry->data.structure.fields[slice_ptr_index]->type_entry;
2120221194 size_enum_index = BuiltinPtrSizeSlice;
2120321195 } else if (ptr_type_entry->id == ZigTypeIdPointer) {
2120421196 attrs_type = ptr_type_entry;
......@@ -21691,7 +21683,7 @@ static Error ir_make_type_info_value(IrAnalyze *ira, IrInstruction *source_instr
2169121683 init_const_slice(ira->codegen, fields[1], struct_field_array, 0, struct_field_count, false);
2169221684
2169321685 for (uint32_t struct_field_index = 0; struct_field_index < struct_field_count; struct_field_index++) {
21694 TypeStructField *struct_field = &type_entry->data.structure.fields[struct_field_index];
21686 TypeStructField *struct_field = type_entry->data.structure.fields[struct_field_index];
2169521687 ConstExprValue *struct_field_val = &struct_field_array->data.x_array.data.s_none.elements[struct_field_index];
2169621688
2169721689 struct_field_val->special = ConstValSpecialStatic;
......@@ -22647,7 +22639,7 @@ static IrInstruction *ir_analyze_instruction_from_bytes(IrAnalyze *ira, IrInstru
2264722639 if ((err = resolve_ptr_align(ira, target->value.type, &src_ptr_align)))
2264822640 return ira->codegen->invalid_instruction;
2264922641 } else if (is_slice(target->value.type)) {
22650 ZigType *src_ptr_type = target->value.type->data.structure.fields[slice_ptr_index].type_entry;
22642 ZigType *src_ptr_type = target->value.type->data.structure.fields[slice_ptr_index]->type_entry;
2265122643 src_ptr_const = src_ptr_type->data.pointer.is_const;
2265222644 src_ptr_volatile = src_ptr_type->data.pointer.is_volatile;
2265322645
......@@ -22740,7 +22732,7 @@ static IrInstruction *ir_analyze_instruction_to_bytes(IrAnalyze *ira, IrInstruct
2274022732 return ira->codegen->invalid_instruction;
2274122733 }
2274222734
22743 ZigType *src_ptr_type = target->value.type->data.structure.fields[slice_ptr_index].type_entry;
22735 ZigType *src_ptr_type = target->value.type->data.structure.fields[slice_ptr_index]->type_entry;
2274422736
2274522737 uint32_t alignment;
2274622738 if ((err = resolve_ptr_align(ira, src_ptr_type, &alignment)))
......@@ -23548,7 +23540,7 @@ static IrInstruction *ir_analyze_instruction_slice(IrAnalyze *ira, IrInstruction
2354823540 }
2354923541 }
2355023542 } else if (is_slice(array_type)) {
23551 ZigType *ptr_type = array_type->data.structure.fields[slice_ptr_index].type_entry;
23543 ZigType *ptr_type = array_type->data.structure.fields[slice_ptr_index]->type_entry;
2355223544 return_type = get_slice_type(ira->codegen, ptr_type);
2355323545 } else {
2355423546 ir_add_error(ira, &instruction->base,
......@@ -23857,7 +23849,7 @@ static IrInstruction *ir_analyze_instruction_member_type(IrAnalyze *ira, IrInstr
2385723849 member_index, buf_ptr(&container_type->name), container_type->data.structure.src_field_count));
2385823850 return ira->codegen->invalid_instruction;
2385923851 }
23860 TypeStructField *field = &container_type->data.structure.fields[member_index];
23852 TypeStructField *field = container_type->data.structure.fields[member_index];
2386123853
2386223854 return ir_const_type(ira, &instruction->base, field->type_entry);
2386323855 } else if (container_type->id == ZigTypeIdUnion) {
......@@ -23899,7 +23891,7 @@ static IrInstruction *ir_analyze_instruction_member_name(IrAnalyze *ira, IrInstr
2389923891 member_index, buf_ptr(&container_type->name), container_type->data.structure.src_field_count));
2390023892 return ira->codegen->invalid_instruction;
2390123893 }
23902 TypeStructField *field = &container_type->data.structure.fields[member_index];
23894 TypeStructField *field = container_type->data.structure.fields[member_index];
2390323895
2390423896 IrInstruction *result = ir_const(ira, &instruction->base, nullptr);
2390523897 init_const_str_lit(ira->codegen, &result->value, field->name);
......@@ -24885,7 +24877,7 @@ static IrInstruction *ir_align_cast(IrAnalyze *ira, IrInstruction *target, uint3
2488524877 ZigType *fn_type = get_fn_type(ira->codegen, &fn_type_id);
2488624878 result_type = get_optional_type(ira->codegen, fn_type);
2488724879 } else if (is_slice(target_type)) {
24888 ZigType *slice_ptr_type = target_type->data.structure.fields[slice_ptr_index].type_entry;
24880 ZigType *slice_ptr_type = target_type->data.structure.fields[slice_ptr_index]->type_entry;
2488924881 if ((err = resolve_ptr_align(ira, slice_ptr_type, &old_align_bytes)))
2489024882 return ira->codegen->invalid_instruction;
2489124883 ZigType *result_ptr_type = adjust_ptr_align(ira->codegen, slice_ptr_type, align_bytes);
......@@ -25130,7 +25122,7 @@ static void buf_write_value_bytes(CodeGen *codegen, uint8_t *buf, ConstExprValue
2513025122 case ContainerLayoutExtern: {
2513125123 size_t src_field_count = val->type->data.structure.src_field_count;
2513225124 for (size_t field_i = 0; field_i < src_field_count; field_i += 1) {
25133 TypeStructField *struct_field = &val->type->data.structure.fields[field_i];
25125 TypeStructField *struct_field = val->type->data.structure.fields[field_i];
2513425126 if (struct_field->gen_index == SIZE_MAX)
2513525127 continue;
2513625128 ConstExprValue *field_val = val->data.x_struct.fields[field_i];
......@@ -25159,7 +25151,7 @@ static void buf_write_value_bytes(CodeGen *codegen, uint8_t *buf, ConstExprValue
2515925151 bigint_init_unsigned(&big_int, 0);
2516025152 size_t used_bits = 0;
2516125153 while (src_i < src_field_count) {
25162 TypeStructField *field = &val->type->data.structure.fields[src_i];
25154 TypeStructField *field = val->type->data.structure.fields[src_i];
2516325155 assert(field->gen_index != SIZE_MAX);
2516425156 if (field->gen_index != gen_i)
2516525157 break;
......@@ -25306,7 +25298,7 @@ static Error buf_read_value_bytes(IrAnalyze *ira, CodeGen *codegen, AstNode *sou
2530625298 for (size_t field_i = 0; field_i < src_field_count; field_i += 1) {
2530725299 ConstExprValue *field_val = val->data.x_struct.fields[field_i];
2530825300 field_val->special = ConstValSpecialStatic;
25309 TypeStructField *struct_field = &val->type->data.structure.fields[field_i];
25301 TypeStructField *struct_field = val->type->data.structure.fields[field_i];
2531025302 field_val->type = struct_field->type_entry;
2531125303 if (struct_field->gen_index == SIZE_MAX)
2531225304 continue;
......@@ -25337,7 +25329,7 @@ static Error buf_read_value_bytes(IrAnalyze *ira, CodeGen *codegen, AstNode *sou
2533725329 BigInt big_int;
2533825330 bigint_read_twos_complement(&big_int, buf + offset, big_int_byte_count * 8, is_big_endian, false);
2533925331 while (src_i < src_field_count) {
25340 TypeStructField *field = &val->type->data.structure.fields[src_i];
25332 TypeStructField *field = val->type->data.structure.fields[src_i];
2534125333 src_assert(field->gen_index != SIZE_MAX, source_node);
2534225334 if (field->gen_index != gen_i)
2534325335 break;
......@@ -25600,7 +25592,7 @@ static IrInstruction *ir_analyze_instruction_align_cast(IrAnalyze *ira, IrInstru
2560025592
2560125593 ZigType *elem_type = nullptr;
2560225594 if (is_slice(target->value.type)) {
25603 ZigType *slice_ptr_type = target->value.type->data.structure.fields[slice_ptr_index].type_entry;
25595 ZigType *slice_ptr_type = target->value.type->data.structure.fields[slice_ptr_index]->type_entry;
2560425596 elem_type = slice_ptr_type->data.pointer.child_type;
2560525597 } else if (target->value.type->id == ZigTypeIdPointer) {
2560625598 elem_type = target->value.type->data.pointer.child_type;