From ca4b78291286dc38801cdcad219185f4ad8f6983 Mon Sep 17 00:00:00 2001 From: Christoffer Lerno Date: Fri, 12 Jul 2024 18:27:05 +0200 Subject: [PATCH] MemberIndex -> ArrayIndex --- src/compiler/abi/c_abi_x64.c | 2 +- src/compiler/compiler_internal.h | 22 ++++++------ src/compiler/llvm_codegen.c | 10 +++--- src/compiler/llvm_codegen_expr.c | 46 ++++++++++++------------- src/compiler/llvm_codegen_type.c | 4 +-- src/compiler/parse_global.c | 2 +- src/compiler/sema_casts.c | 4 +-- src/compiler/sema_decls.c | 8 ++--- src/compiler/sema_expr.c | 18 +++++----- src/compiler/sema_initializers.c | 58 ++++++++++++++++---------------- src/compiler/sema_internal.h | 2 +- src/compiler/sema_liveness.c | 4 +-- src/compiler/sema_stmts.c | 2 +- src/compiler/types.c | 4 +-- 14 files changed, 93 insertions(+), 93 deletions(-) diff --git a/src/compiler/abi/c_abi_x64.c b/src/compiler/abi/c_abi_x64.c index c5d8df89e..70f84edb9 100644 --- a/src/compiler/abi/c_abi_x64.c +++ b/src/compiler/abi/c_abi_x64.c @@ -362,7 +362,7 @@ static Decl *x64_get_member_at_offset(Decl *decl, unsigned offset) Decl *last_match = NULL; FOREACH(Decl *, member, members) { - if (member->offset > (MemberIndex)offset) break; + if (member->offset > (ArrayIndex)offset) break; last_match = member; } assert(last_match); diff --git a/src/compiler/compiler_internal.h b/src/compiler/compiler_internal.h index 9366c28cb..e3b587821 100644 --- a/src/compiler/compiler_internal.h +++ b/src/compiler/compiler_internal.h @@ -17,7 +17,7 @@ typedef double Real; typedef uint64_t ByteSize; typedef uint32_t TypeSize; typedef int32_t IndexDiff; -typedef int32_t MemberIndex; +typedef int32_t ArrayIndex; typedef uint32_t AlignSize; typedef int32_t ScopeId; typedef uint32_t ArraySize; @@ -36,8 +36,8 @@ typedef uint16_t SectionId; #define MAX_MACRO_ITERATIONS 0xFFFFFF #define MAX_PARAMS 127 #define MAX_BITSTRUCT 0x1000 -#define MAX_MEMBERS ((MemberIndex)(((uint64_t)2) << 28)) -#define MAX_ALIGNMENT ((MemberIndex)(((uint64_t)2) << 28)) +#define MAX_MEMBERS ((ArrayIndex)(((uint64_t)2) << 28)) +#define MAX_ALIGNMENT ((ArrayIndex)(((uint64_t)2) << 28)) #define MAX_PRIORITY 0xFFFF #define MAX_TYPE_SIZE UINT32_MAX #define MAX_GLOBAL_DECL_STACK (65536) @@ -121,7 +121,7 @@ struct ConstInitializer_ struct { ConstInitializer *element; - MemberIndex index; + ArrayIndex index; } init_union; struct { @@ -131,7 +131,7 @@ struct ConstInitializer_ struct { ConstInitializer *element; - MemberIndex index; + ArrayIndex index; } init_array_value; }; }; @@ -427,7 +427,7 @@ typedef struct typedef struct { TypeSize size; - MemberIndex union_rep; + ArrayIndex union_rep; Decl **members; Decl *padded_decl; AlignSize padding : 16; @@ -882,8 +882,8 @@ typedef struct DesignatorElement_ Expr *index_end_expr; }; }; - MemberIndex index; - MemberIndex index_end; + ArrayIndex index; + ArrayIndex index_end; } DesignatorElement; typedef struct @@ -1816,8 +1816,8 @@ typedef struct typedef struct ABIArgInfo_ { - MemberIndex param_index_start : 16; - MemberIndex param_index_end : 16; + ArrayIndex param_index_start : 16; + ArrayIndex param_index_end : 16; ABIKind kind : 6; struct { @@ -2337,7 +2337,7 @@ void sema_erase_unwrapped(SemaContext *context, Decl *decl); bool sema_analyse_cond_expr(SemaContext *context, Expr *expr, CondResult *result); bool sema_analyse_expr_rhs(SemaContext *context, Type *to, Expr *expr, bool allow_optional, bool *no_match_ref); -MemberIndex sema_get_initializer_const_array_size(SemaContext *context, Expr *initializer, bool *may_be_array, bool *is_const_size); +ArrayIndex sema_get_initializer_const_array_size(SemaContext *context, Expr *initializer, bool *may_be_array, bool *is_const_size); bool sema_analyse_expr(SemaContext *context, Expr *expr); bool sema_expr_check_discard(SemaContext *context, Expr *expr); diff --git a/src/compiler/llvm_codegen.c b/src/compiler/llvm_codegen.c index 255d72298..291dc5d88 100644 --- a/src/compiler/llvm_codegen.c +++ b/src/compiler/llvm_codegen.c @@ -246,7 +246,7 @@ LLVMValueRef llvm_emit_const_initializer(GenContext *c, ConstInitializer *const_ ArraySize size = array_type->array.len; assert(size > 0); LLVMValueRef *parts = VECNEW(LLVMValueRef, size); - for (MemberIndex i = 0; i < (MemberIndex)size; i++) + for (ArrayIndex i = 0; i < (ArrayIndex)size; i++) { LLVMValueRef element = llvm_emit_const_initializer(c, elements[i]); if (element_type_llvm != LLVMTypeOf(element)) was_modified = true; @@ -273,14 +273,14 @@ LLVMValueRef llvm_emit_const_initializer(GenContext *c, ConstInitializer *const_ ConstInitializer **elements = const_init->init_array.elements; unsigned element_count = vec_size(elements); assert(element_count > 0 && "Array should always have gotten at least one element."); - MemberIndex current_index = 0; + ArrayIndex current_index = 0; unsigned alignment = 0; LLVMValueRef *parts = NULL; bool pack = false; FOREACH(ConstInitializer *, element, elements) { assert(element->kind == CONST_INIT_ARRAY_VALUE); - MemberIndex element_index = element->init_array_value.index; + ArrayIndex element_index = element->init_array_value.index; IndexDiff diff = element_index - current_index; if (alignment && expected_align != alignment) { @@ -298,7 +298,7 @@ LLVMValueRef llvm_emit_const_initializer(GenContext *c, ConstInitializer *const_ current_index = element_index + 1; } - IndexDiff end_diff = (MemberIndex)array_type->array.len - current_index; + IndexDiff end_diff = (ArrayIndex)array_type->array.len - current_index; if (end_diff > 0) { vec_add(parts, llvm_emit_const_array_padding(element_type_llvm, end_diff, &was_modified)); @@ -365,7 +365,7 @@ LLVMValueRef llvm_emit_const_initializer(GenContext *c, ConstInitializer *const_ LLVMValueRef *entries = NULL; bool was_modified = false; ByteSize prev_size = 0; - for (MemberIndex i = 0; i < count; i++) + for (ArrayIndex i = 0; i < count; i++) { if (members[i]->padding) { diff --git a/src/compiler/llvm_codegen_expr.c b/src/compiler/llvm_codegen_expr.c index 50a73e081..3a9103eaf 100644 --- a/src/compiler/llvm_codegen_expr.c +++ b/src/compiler/llvm_codegen_expr.c @@ -9,7 +9,7 @@ static LLVMValueRef llvm_emit_coerce_alignment(GenContext *c, BEValue *be_value, static bool bitstruct_requires_bitswap(Decl *decl); static inline LLVMValueRef llvm_const_high_bitmask(GenContext *c, LLVMTypeRef type, int type_bits, int high_bits); static inline LLVMValueRef llvm_const_low_bitmask(GenContext *c, LLVMTypeRef type, int type_bits, int low_bits); -static inline LLVMValueRef llvm_update_vector(GenContext *c, LLVMValueRef vector, LLVMValueRef value, MemberIndex index); +static inline LLVMValueRef llvm_update_vector(GenContext *c, LLVMValueRef vector, LLVMValueRef value, ArrayIndex index); static inline void llvm_emit_expression_list_expr(GenContext *c, BEValue *be_value, Expr *expr); static LLVMValueRef llvm_emit_dynamic_search(GenContext *c, LLVMValueRef type_id_ptr, LLVMValueRef selector); static inline void llvm_emit_bitassign_array(GenContext *c, LLVMValueRef result, BEValue parent, Decl *parent_decl, Decl *member); @@ -761,7 +761,7 @@ static inline void llvm_emit_pointer_offset(GenContext *c, BEValue *value, Expr } -static MemberIndex find_member_index(Decl *parent, Decl *member) +static ArrayIndex find_member_index(Decl *parent, Decl *member) { FOREACH_IDX(i, Decl *, maybe_member, parent->strukt.members) { @@ -783,7 +783,7 @@ static void llvm_emit_member_addr(GenContext *c, BEValue *value, Decl *parent, D Decl *found = NULL; do { - MemberIndex index = find_member_index(parent, member); + ArrayIndex index = find_member_index(parent, member); assert(index > -1); found = parent->strukt.members[index]; switch (parent->type->canonical->type_kind) @@ -809,7 +809,7 @@ static void llvm_emit_bitstruct_member(GenContext *c, BEValue *value, Decl *pare Decl *found = NULL; do { - MemberIndex index = find_member_index(parent, member); + ArrayIndex index = find_member_index(parent, member); assert(index > -1); found = parent->strukt.members[index]; switch (parent->type->canonical->type_kind) @@ -1640,7 +1640,7 @@ static LLVMValueRef llvm_recursive_set_value(GenContext *c, DesignatorElement ** case DESIGNATOR_ARRAY: return llvm_emit_insert_value(c, parent, val, index); case DESIGNATOR_RANGE: - for (MemberIndex i = current_element->index; i <= current_element->index_end; i++) + for (ArrayIndex i = current_element->index; i <= current_element->index_end; i++) { parent = llvm_emit_insert_value(c, parent, val, i); } @@ -1663,7 +1663,7 @@ static LLVMValueRef llvm_recursive_set_value(GenContext *c, DesignatorElement ** current_val = llvm_recursive_set_value(c, current_element_ptr + 1, current_val, last_element_ptr, value); return llvm_emit_insert_value(c, parent, current_val, current_element->index); case DESIGNATOR_RANGE: - for (MemberIndex i = current_element->index; i <= current_element->index_end; i++) + for (ArrayIndex i = current_element->index; i <= current_element->index_end; i++) { current_val = llvm_emit_extract_value(c, parent, i); current_val = llvm_recursive_set_value(c, current_element_ptr + 1, current_val, last_element_ptr, value); @@ -1758,10 +1758,10 @@ static void llvm_emit_const_init_ref(GenContext *c, BEValue *ref, ConstInitializ LLVMValueRef array_ref = ref->value; Type *array_type = const_init->type; Type *element_type = array_type->array.base; - MemberIndex size = (MemberIndex)array_type->array.len; + ArrayIndex size = (ArrayIndex)array_type->array.len; LLVMTypeRef array_type_llvm = llvm_get_type(c, array_type); assert(size <= UINT32_MAX); - for (MemberIndex i = 0; i < size; i++) + for (ArrayIndex i = 0; i < size; i++) { AlignSize alignment; LLVMValueRef array_pointer = llvm_emit_array_gep_raw(c, array_ref, array_type_llvm, (unsigned)i, ref->alignment, &alignment); @@ -1779,12 +1779,12 @@ static void llvm_emit_const_init_ref(GenContext *c, BEValue *ref, ConstInitializ Type *element_type = array_type->array.base; LLVMTypeRef array_type_llvm = llvm_get_type(c, array_type); ConstInitializer **elements = const_init->init_array.elements; - MemberIndex current_index = 0; + ArrayIndex current_index = 0; LLVMValueRef *parts = NULL; FOREACH(ConstInitializer *, element, elements) { assert(element->kind == CONST_INIT_ARRAY_VALUE); - MemberIndex element_index = element->init_array_value.index; + ArrayIndex element_index = element->init_array_value.index; AlignSize alignment; LLVMValueRef array_pointer = llvm_emit_array_gep_raw(c, array_ref, array_type_llvm, (unsigned)element_index, ref->alignment, &alignment); BEValue value; @@ -1796,7 +1796,7 @@ static void llvm_emit_const_init_ref(GenContext *c, BEValue *ref, ConstInitializ case CONST_INIT_UNION: { Decl *decl = const_init->type->decl; - MemberIndex index = const_init->init_union.index; + ArrayIndex index = const_init->init_union.index; Type *type = decl->strukt.members[index]->type->canonical; // Bitcast. BEValue value = *ref; @@ -1810,8 +1810,8 @@ static void llvm_emit_const_init_ref(GenContext *c, BEValue *ref, ConstInitializ { Decl *decl = const_init->type->decl; Decl **members = decl->strukt.members; - MemberIndex count = (MemberIndex)vec_size(members); - for (MemberIndex i = 0; i < count; i++) + ArrayIndex count = (ArrayIndex)vec_size(members); + for (ArrayIndex i = 0; i < count; i++) { BEValue value; llvm_value_struct_gep(c, &value, ref, (unsigned)i); @@ -1969,7 +1969,7 @@ static void llvm_emit_initialize_designated_const_range(GenContext *c, BEValue * emitted_value = &emitted_local; } LLVMTypeRef ref_type = llvm_get_type(c, ref->type); - for (MemberIndex i = curr->index; i <= curr->index_end; i++) + for (ArrayIndex i = curr->index; i <= curr->index_end; i++) { BEValue new_ref; AlignSize alignment; @@ -2167,8 +2167,8 @@ LLVMValueRef llvm_emit_const_bitstruct_array(GenContext *c, ConstInitializer *in slots[i] = llvm_get_zero_raw(c->byte_type); } Decl **members = decl->strukt.members; - MemberIndex count = (MemberIndex)vec_size(members); - for (MemberIndex i = 0; i < count; i++) + ArrayIndex count = (ArrayIndex)vec_size(members); + for (ArrayIndex i = 0; i < count; i++) { Decl *member = members[i]; unsigned start_bit = member->var.start_bit; @@ -2245,10 +2245,10 @@ LLVMValueRef llvm_emit_const_bitstruct(GenContext *c, ConstInitializer *initiali LLVMTypeRef llvm_base_type = llvm_get_type(c, base_type); LLVMValueRef result = llvm_get_zero_raw(llvm_base_type); Decl **members = decl->strukt.members; - MemberIndex count = (MemberIndex)vec_size(members); + ArrayIndex count = (ArrayIndex)vec_size(members); TypeSize base_type_size = type_size(base_type); TypeSize base_type_bitsize = base_type_size * 8; - for (MemberIndex i = 0; i < count; i++) + for (ArrayIndex i = 0; i < count; i++) { ConstInitializer *val = initializer->init_struct[i]; Decl *member = members[i]; @@ -5109,9 +5109,9 @@ static void llvm_emit_any_pointer(GenContext *c, BEValue *value, BEValue *pointe void llvm_value_struct_gep(GenContext *c, BEValue *element, BEValue *struct_pointer, unsigned index) { llvm_value_fold_optional(c, struct_pointer); - MemberIndex actual_index = -1; + ArrayIndex actual_index = -1; Decl *member; - for (MemberIndex i = 0; i <= index; i++) + for (ArrayIndex i = 0; i <= index; i++) { member = struct_pointer->type->decl->strukt.members[i]; if (member->padding) @@ -6281,7 +6281,7 @@ static inline void llvm_emit_optional(GenContext *c, BEValue *be_value, Expr *ex llvm_value_set(be_value, llvm_get_undef(c, type), type); } -static inline LLVMValueRef llvm_update_vector(GenContext *c, LLVMValueRef vector, LLVMValueRef value, MemberIndex index) +static inline LLVMValueRef llvm_update_vector(GenContext *c, LLVMValueRef vector, LLVMValueRef value, ArrayIndex index) { LLVMValueRef index_value = llvm_const_int(c, type_usz, (uint64_t)index); return LLVMBuildInsertElement(c->builder, vector, value, index_value, ""); @@ -6306,7 +6306,7 @@ static inline void llvm_emit_vector_initializer_list(GenContext *c, BEValue *val { llvm_emit_expr(c, &val, element); llvm_value_rvalue(c, &val); - vec_value = llvm_update_vector(c, vec_value, val.value, (MemberIndex)i); + vec_value = llvm_update_vector(c, vec_value, val.value, (ArrayIndex)i); } } else @@ -6328,7 +6328,7 @@ static inline void llvm_emit_vector_initializer_list(GenContext *c, BEValue *val break; } case DESIGNATOR_RANGE: - for (MemberIndex idx = element->index; idx <= element->index_end; idx++) + for (ArrayIndex idx = element->index; idx <= element->index_end; idx++) { vec_value = llvm_update_vector(c, vec_value, val.value, idx); } diff --git a/src/compiler/llvm_codegen_type.c b/src/compiler/llvm_codegen_type.c index 5c17335d4..a9184d3d3 100644 --- a/src/compiler/llvm_codegen_type.c +++ b/src/compiler/llvm_codegen_type.c @@ -150,7 +150,7 @@ static void param_expand(GenContext *context, LLVMTypeRef** params_ref, Type *ty static inline void add_func_type_param(GenContext *c, Type *param_type, ABIArgInfo *arg_info, LLVMTypeRef **params) { - arg_info->param_index_start = (MemberIndex)vec_size(*params); + arg_info->param_index_start = (ArrayIndex)vec_size(*params); switch (arg_info->kind) { case ABI_ARG_IGNORE: @@ -197,7 +197,7 @@ static inline void add_func_type_param(GenContext *c, Type *param_type, ABIArgIn vec_add(*params, llvm_abi_type(c, arg_info->direct_pair.hi)); break; } - arg_info->param_index_end = (MemberIndex)vec_size(*params); + arg_info->param_index_end = (ArrayIndex)vec_size(*params); } LLVMTypeRef llvm_update_prototype_abi(GenContext *c, FunctionPrototype *prototype, LLVMTypeRef **params) diff --git a/src/compiler/parse_global.c b/src/compiler/parse_global.c index d86cce79f..aa9d36b5a 100644 --- a/src/compiler/parse_global.c +++ b/src/compiler/parse_global.c @@ -1443,7 +1443,7 @@ bool parse_struct_body(ParseContext *c, Decl *parent) CONSUME_OR_RET(TOKEN_LBRACE, false); assert(decl_is_struct_type(parent)); - MemberIndex index = 0; + ArrayIndex index = 0; while (!tok_is(c, TOKEN_RBRACE)) { TokenType token_type = c->tok; diff --git a/src/compiler/sema_casts.c b/src/compiler/sema_casts.c index 2ef0616f1..c7b64ac62 100644 --- a/src/compiler/sema_casts.c +++ b/src/compiler/sema_casts.c @@ -958,7 +958,7 @@ static bool rule_vec_to_arr(CastContext *cc, bool is_explicit, bool is_silent) static bool rule_slice_to_vecarr(CastContext *cc, bool is_explicit, bool is_silent) { Expr *expr = cc->expr; - MemberIndex size = sema_len_from_const(expr); + ArrayIndex size = sema_len_from_const(expr); if (size < 0) { if (is_silent) return false; @@ -995,7 +995,7 @@ static bool rule_slice_to_infer(CastContext *cc, bool is_explicit, bool is_silen return cast_is_allowed(cc, is_explicit, is_silent); } // 2. Otherwise there is a vector matching. - MemberIndex size = sema_len_from_const(expr); + ArrayIndex size = sema_len_from_const(expr); if (size < 0) { if (is_silent) return false; diff --git a/src/compiler/sema_decls.c b/src/compiler/sema_decls.c index d7cad96bf..966ac2b00 100644 --- a/src/compiler/sema_decls.c +++ b/src/compiler/sema_decls.c @@ -297,7 +297,7 @@ static inline bool sema_check_struct_holes(SemaContext *context, Decl *decl, Dec static bool sema_analyse_union_members(SemaContext *context, Decl *decl) { AlignSize max_size = 0; - MemberIndex max_alignment_element = 0; + ArrayIndex max_alignment_element = 0; AlignSize max_alignment = 0; bool has_named_parameter = false; @@ -349,7 +349,7 @@ static bool sema_analyse_union_members(SemaContext *context, Decl *decl) if (member_alignment > max_alignment) { max_alignment = member_alignment; - max_alignment_element = (MemberIndex)i; + max_alignment_element = (ArrayIndex)i; } // Update max size if (member_size > max_size) @@ -358,9 +358,9 @@ static bool sema_analyse_union_members(SemaContext *context, Decl *decl) max_size = (AlignSize)member_size; // If this is bigger than the previous with max // alignment, pick this as the maximum size field. - if (max_alignment_element != (MemberIndex)i && max_alignment == member_alignment) + if (max_alignment_element != (ArrayIndex)i && max_alignment == member_alignment) { - max_alignment_element = (MemberIndex)i; + max_alignment_element = (ArrayIndex)i; } } // Offset is always 0 diff --git a/src/compiler/sema_expr.c b/src/compiler/sema_expr.c index 84d2b9bae..11d386f62 100644 --- a/src/compiler/sema_expr.c +++ b/src/compiler/sema_expr.c @@ -280,8 +280,8 @@ static inline ArraySize sema_get_const_len(SemaContext *context, Expr *expr) { bool may_be_array; bool is_const_size; - MemberIndex len = (ArraySize) sema_get_initializer_const_array_size(context, expr, &may_be_array, - &is_const_size); + ArrayIndex len = (ArraySize) sema_get_initializer_const_array_size(context, expr, &may_be_array, + &is_const_size); assert(is_const_size); return (ArraySize) len; } @@ -2555,7 +2555,7 @@ static bool sema_slice_len_is_in_range(SemaContext *context, Type *type, Expr *l SEMA_ERROR(len_expr, "The length may not be negative."); return false; } - MemberIndex len_val = (MemberIndex)const_len.i.low; + ArrayIndex len_val = (ArrayIndex)const_len.i.low; switch (type->type_kind) { case TYPE_POINTER: @@ -2567,7 +2567,7 @@ static bool sema_slice_len_is_in_range(SemaContext *context, Type *type, Expr *l case TYPE_ARRAY: case TYPE_VECTOR: { - MemberIndex len = (MemberIndex)type->array.len; + ArrayIndex len = (ArrayIndex)type->array.len; bool is_vector = type->type_kind == TYPE_VECTOR; if (from_end) { @@ -2613,7 +2613,7 @@ static bool sema_slice_index_is_in_range(SemaContext *context, Type *type, Expr SEMA_ERROR(index_expr, "Negative numbers are not allowed when indexing from the end."); return false; } - MemberIndex idx = (MemberIndex)index.i.low; + ArrayIndex idx = (ArrayIndex)index.i.low; switch (type->type_kind) { case TYPE_POINTER: @@ -2626,7 +2626,7 @@ static bool sema_slice_index_is_in_range(SemaContext *context, Type *type, Expr case TYPE_ARRAY: case TYPE_VECTOR: { - MemberIndex len = (MemberIndex)type->array.len; + ArrayIndex len = (ArrayIndex)type->array.len; if (from_end) { idx = len - idx; @@ -9015,7 +9015,7 @@ NO_MATCH_REF: return false; } -static MemberIndex len_from_const_initializer(ConstInitializer *init) +static ArrayIndex len_from_const_initializer(ConstInitializer *init) { switch (init->kind) { @@ -9028,7 +9028,7 @@ static MemberIndex len_from_const_initializer(ConstInitializer *init) return -1; case CONST_INIT_ARRAY: { - MemberIndex max = 0; + ArrayIndex max = 0; FOREACH(ConstInitializer *, element, init->init_array.elements) { assert(element->kind == CONST_INIT_ARRAY_VALUE); @@ -9041,7 +9041,7 @@ static MemberIndex len_from_const_initializer(ConstInitializer *init) } UNREACHABLE } -MemberIndex sema_len_from_const(Expr *expr) +ArrayIndex sema_len_from_const(Expr *expr) { // We also handle the case where we have a cast from a const array. if (!expr_is_const(expr)) diff --git a/src/compiler/sema_initializers.c b/src/compiler/sema_initializers.c index 1fe5bec1b..e283dd38b 100644 --- a/src/compiler/sema_initializers.c +++ b/src/compiler/sema_initializers.c @@ -15,11 +15,11 @@ static inline bool sema_expr_analyse_initializer(SemaContext *context, Type *ass static void sema_create_const_initializer_value(ConstInitializer *const_init, Expr *value); static void sema_create_const_initializer_from_designated_init(ConstInitializer *const_init, Expr *initializer); static Decl *sema_resolve_element_for_name(SemaContext *context, Decl **decls, DesignatorElement ***elements_ref, unsigned *index); -static Type *sema_expr_analyse_designator(SemaContext *context, Type *current, Expr *expr, MemberIndex *max_index, Decl **member_ptr); +static Type *sema_expr_analyse_designator(SemaContext *context, Type *current, Expr *expr, ArrayIndex *max_index, Decl **member_ptr); INLINE bool sema_initializer_list_is_empty(Expr *value); -static Type *sema_find_type_of_element(SemaContext *context, Type *type, DesignatorElement ***elements_ref, unsigned *curr_index, bool *is_constant, bool *did_report_error, MemberIndex *max_index, Decl **member_ptr); -MemberIndex sema_get_initializer_const_array_size(SemaContext *context, Expr *initializer, bool *may_be_array, bool *is_const_size); -static MemberIndex sema_analyse_designator_index(SemaContext *context, Expr *index); +static Type *sema_find_type_of_element(SemaContext *context, Type *type, DesignatorElement ***elements_ref, unsigned *curr_index, bool *is_constant, bool *did_report_error, ArrayIndex *max_index, Decl **member_ptr); +ArrayIndex sema_get_initializer_const_array_size(SemaContext *context, Expr *initializer, bool *may_be_array, bool *is_const_size); +static ArrayIndex sema_analyse_designator_index(SemaContext *context, Expr *index); static void sema_update_const_initializer_with_designator(ConstInitializer *const_init, DesignatorElement **curr, DesignatorElement **end, @@ -69,7 +69,7 @@ static inline bool sema_expr_analyse_struct_plain_initializer(SemaContext *conte assert(assigned->resolve_status == RESOLVE_DONE); Expr **elements = initializer->initializer_list; Decl **members = assigned->strukt.members; - MemberIndex size = (MemberIndex)vec_size(elements); + ArrayIndex size = (ArrayIndex)vec_size(elements); unsigned elements_needed = decl_count_elements(assigned); // 1. For struct number of members must be the same as the size of the struct. @@ -98,8 +98,8 @@ static inline bool sema_expr_analyse_struct_plain_initializer(SemaContext *conte } // 3. Loop through all elements. - MemberIndex max_loop = size > elements_needed ? size : elements_needed; - for (MemberIndex i = 0; i < max_loop; i++) + ArrayIndex max_loop = size > elements_needed ? size : elements_needed; + for (ArrayIndex i = 0; i < max_loop; i++) { // 4. Check if we exceeded the list of elements in the struct/union. // This way we can check the other elements which might help the @@ -403,7 +403,7 @@ static bool sema_expr_analyse_designated_initializer(SemaContext *context, Type Type *original = flattened->canonical; bool is_bitstruct = original->type_kind == TYPE_BITSTRUCT; bool is_structlike = type_is_union_or_strukt(original) || is_bitstruct; - MemberIndex max_index = -1; + ArrayIndex max_index = -1; bool optional = false; Type *inner_type = NULL; bool is_inferred = type_is_inferred(flattened); @@ -902,8 +902,8 @@ static inline void sema_update_const_initializer_with_designator_array(ConstInit Expr *value) { DesignatorElement *element = curr[0]; - MemberIndex low_index = element->index; - MemberIndex high_index = element->kind == DESIGNATOR_RANGE ? element->index_end : element->index; + ArrayIndex low_index = element->index; + ArrayIndex high_index = element->kind == DESIGNATOR_RANGE ? element->index_end : element->index; assert(element->kind == DESIGNATOR_ARRAY || element->kind == DESIGNATOR_RANGE); // Expand zero into array. @@ -921,9 +921,9 @@ static inline void sema_update_const_initializer_with_designator_array(ConstInit ConstInitializer **array_elements = const_init->init_array.elements; unsigned array_count = vec_size(array_elements); - MemberIndex insert_index = 0; + ArrayIndex insert_index = 0; - for (MemberIndex index = low_index; index <= high_index; index++) + for (ArrayIndex index = low_index; index <= high_index; index++) { assert(insert_index >= array_count || array_elements); // Walk to the insert point or until we reached the end of the array. @@ -1017,7 +1017,7 @@ static inline void sema_update_const_initializer_with_designator( } } -static Type *sema_expr_analyse_designator(SemaContext *context, Type *current, Expr *expr, MemberIndex *max_index, Decl **member_ptr) +static Type *sema_expr_analyse_designator(SemaContext *context, Type *current, Expr *expr, ArrayIndex *max_index, Decl **member_ptr) { DesignatorElement **path = expr->designator_expr.path; @@ -1045,7 +1045,7 @@ INLINE bool sema_initializer_list_is_empty(Expr *value) return expr_is_const_initializer(value) && value->const_expr.initializer->kind == CONST_INIT_ZERO; } -static Type *sema_find_type_of_element(SemaContext *context, Type *type, DesignatorElement ***elements_ref, unsigned *curr_index, bool *is_constant, bool *did_report_error, MemberIndex *max_index, Decl **member_ptr) +static Type *sema_find_type_of_element(SemaContext *context, Type *type, DesignatorElement ***elements_ref, unsigned *curr_index, bool *is_constant, bool *did_report_error, ArrayIndex *max_index, Decl **member_ptr) { Type *type_flattened = type_flatten(type); DesignatorElement *element = (*elements_ref)[*curr_index]; @@ -1069,13 +1069,13 @@ static Type *sema_find_type_of_element(SemaContext *context, Type *type, Designa default: return NULL; } - MemberIndex index = sema_analyse_designator_index(context, element->index_expr); + ArrayIndex index = sema_analyse_designator_index(context, element->index_expr); if (index < 0) { *did_report_error = true; return NULL; } - if (index >= (MemberIndex)len) + if (index >= (ArrayIndex)len) { SEMA_ERROR(element->index_expr, "The index may must be less than the array length (which was %llu).", (unsigned long long)len); *did_report_error = true; @@ -1086,7 +1086,7 @@ static Type *sema_find_type_of_element(SemaContext *context, Type *type, Designa if (max_index && *max_index < index) *max_index = index; if (element->kind == DESIGNATOR_RANGE) { - MemberIndex end_index = sema_analyse_designator_index(context, element->index_end_expr); + ArrayIndex end_index = sema_analyse_designator_index(context, element->index_end_expr); if (end_index < 0) { *did_report_error = true; @@ -1098,7 +1098,7 @@ static Type *sema_find_type_of_element(SemaContext *context, Type *type, Designa *did_report_error = true; return NULL; } - if (end_index > (MemberIndex)len) + if (end_index > (ArrayIndex)len) { *did_report_error = true; SEMA_ERROR(element->index_expr, "The index may must be less than the array length (which was %llu).", (unsigned long long)len); @@ -1123,7 +1123,7 @@ static Type *sema_find_type_of_element(SemaContext *context, Type *type, Designa return member->type; } -MemberIndex sema_get_initializer_const_array_size(SemaContext *context, Expr *initializer, bool *may_be_array, bool *is_const_size) +ArrayIndex sema_get_initializer_const_array_size(SemaContext *context, Expr *initializer, bool *may_be_array, bool *is_const_size) { if (expr_is_const(initializer)) { @@ -1137,7 +1137,7 @@ MemberIndex sema_get_initializer_const_array_size(SemaContext *context, Expr *in if (type->type_kind == TYPE_ARRAY) { *may_be_array = true; - return (MemberIndex)type->array.len; + return (ArrayIndex)type->array.len; } if (type->type_kind == TYPE_SLICE) { @@ -1151,7 +1151,7 @@ MemberIndex sema_get_initializer_const_array_size(SemaContext *context, Expr *in return vectail(init->init_array.elements)->init_array_value.index + 1; case CONST_INIT_ARRAY_FULL: *may_be_array = true; - return (MemberIndex)vec_size(init->init_array_full); + return (ArrayIndex)vec_size(init->init_array_full); case CONST_INIT_ARRAY_VALUE: UNREACHABLE; case CONST_INIT_STRUCT: @@ -1167,14 +1167,14 @@ MemberIndex sema_get_initializer_const_array_size(SemaContext *context, Expr *in case EXPR_INITIALIZER_LIST: *may_be_array = true; *is_const_size = true; - return (MemberIndex)vec_size(initializer->initializer_list); + return (ArrayIndex)vec_size(initializer->initializer_list); case EXPR_DESIGNATED_INITIALIZER_LIST: break; default: UNREACHABLE } Expr **initializers = initializer->designated_init_list; - MemberIndex size = 0; + ArrayIndex size = 0; // Otherwise we assume everything's a designator. FOREACH(Expr *, sub_initializer, initializers) { @@ -1189,7 +1189,7 @@ MemberIndex sema_get_initializer_const_array_size(SemaContext *context, Expr *in return -1; case DESIGNATOR_ARRAY: { - MemberIndex index = sema_analyse_designator_index(context, element->index_expr); + ArrayIndex index = sema_analyse_designator_index(context, element->index_expr); if (index < 0 || element->index_expr->expr_kind != EXPR_CONST) { *is_const_size = false; @@ -1200,7 +1200,7 @@ MemberIndex sema_get_initializer_const_array_size(SemaContext *context, Expr *in } case DESIGNATOR_RANGE: { - MemberIndex index = sema_analyse_designator_index(context, element->index_end_expr); + ArrayIndex index = sema_analyse_designator_index(context, element->index_end_expr); if (index < 0 || element->index_end_expr->expr_kind != EXPR_CONST) { *is_const_size = false; @@ -1216,7 +1216,7 @@ MemberIndex sema_get_initializer_const_array_size(SemaContext *context, Expr *in return size; } -static MemberIndex sema_analyse_designator_index(SemaContext *context, Expr *index) +static ArrayIndex sema_analyse_designator_index(SemaContext *context, Expr *index) { if (!sema_analyse_expr(context, index)) { @@ -1244,7 +1244,7 @@ static MemberIndex sema_analyse_designator_index(SemaContext *context, Expr *ind SEMA_ERROR(index, "Negative index values is not allowed."); return -1; } - return (MemberIndex)index_val; + return (ArrayIndex)index_val; } @@ -1267,7 +1267,7 @@ static Decl *sema_resolve_element_for_name(SemaContext *context, Decl **decls, D // The simple case, we have a match. if (decl->name == name) { - element->index = (MemberIndex)i; + element->index = (ArrayIndex)i; return decl; } if (!decl->name) @@ -1281,7 +1281,7 @@ static Decl *sema_resolve_element_for_name(SemaContext *context, Decl **decls, D // Create our anon field. DesignatorElement *anon_element = CALLOCS(DesignatorElement); anon_element->kind = DESIGNATOR_FIELD; - anon_element->index = (MemberIndex)i; + anon_element->index = (ArrayIndex)i; vec_insert_at(*elements_ref, old_index, anon_element); // Advance (*index)++; diff --git a/src/compiler/sema_internal.h b/src/compiler/sema_internal.h index b366917bd..1c0f466cb 100644 --- a/src/compiler/sema_internal.h +++ b/src/compiler/sema_internal.h @@ -90,7 +90,7 @@ bool sema_expr_check_assign(SemaContext *context, Expr *expr); bool sema_analyse_function_signature(SemaContext *context, Decl *func_decl, CallABI abi, Signature *signature); ConstInitializer *sema_merge_bitstruct_const_initializers(ConstInitializer *lhs, ConstInitializer *rhs, BinaryOp op); void sema_invert_bitstruct_const_initializer(ConstInitializer *initializer); -MemberIndex sema_len_from_const(Expr *expr); +ArrayIndex sema_len_from_const(Expr *expr); void cast_promote_vararg(SemaContext *context, Expr *arg); Type *cast_numeric_arithmetic_promotion(Type *type); void cast_to_int_to_max_bit_size(SemaContext *context, Expr *lhs, Expr *rhs, Type *left_type, Type *right_type); diff --git a/src/compiler/sema_liveness.c b/src/compiler/sema_liveness.c index d5da08f73..eb87dc8eb 100644 --- a/src/compiler/sema_liveness.c +++ b/src/compiler/sema_liveness.c @@ -213,7 +213,7 @@ static void sema_trace_const_initializer_liveness(ConstInitializer *const_init) Type *array_type = const_init->type; ConstInitializer **elements = const_init->init_array_full; ArraySize size = array_type->array.len; - for (MemberIndex i = 0; i < (MemberIndex)size; i++) + for (ArrayIndex i = 0; i < (ArrayIndex)size; i++) { sema_trace_const_initializer_liveness(elements[i]); } @@ -233,7 +233,7 @@ static void sema_trace_const_initializer_liveness(ConstInitializer *const_init) Decl **members = decl->strukt.members; uint32_t count = vec_size(members); if (decl->decl_kind == DECL_UNION && count) count = 1; - for (MemberIndex i = 0; i < count; i++) + for (ArrayIndex i = 0; i < count; i++) { sema_trace_const_initializer_liveness(const_init->init_struct[i]); } diff --git a/src/compiler/sema_stmts.c b/src/compiler/sema_stmts.c index 498d3127a..510624a68 100644 --- a/src/compiler/sema_stmts.c +++ b/src/compiler/sema_stmts.c @@ -1443,7 +1443,7 @@ static inline bool sema_analyse_foreach_stmt(SemaContext *context, Ast *statemen { bool may_be_array; bool is_const_size; - MemberIndex size = sema_get_initializer_const_array_size(context, enumerator, &may_be_array, &is_const_size); + ArrayIndex size = sema_get_initializer_const_array_size(context, enumerator, &may_be_array, &is_const_size); if (!may_be_array) { SEMA_ERROR(enumerator, diff --git a/src/compiler/types.c b/src/compiler/types.c index a4bdbf83a..06107836c 100644 --- a/src/compiler/types.c +++ b/src/compiler/types.c @@ -998,7 +998,7 @@ static inline bool array_structurally_equivalent_to_struct(Type *array, Type *ty { assert(array->type_kind == TYPE_ARRAY); - MemberIndex len = (MemberIndex)array->array.len; + ArrayIndex len = (ArrayIndex)array->array.len; if (!len) return type_size(type) == 0; Type *base = array->array.base; @@ -1012,7 +1012,7 @@ static inline bool array_structurally_equivalent_to_struct(Type *array, Type *ty Decl **members = type->decl->strukt.members; // For structs / errors, all members must match. - MemberIndex offset = 0; + ArrayIndex offset = 0; AlignSize align_size = type_abi_alignment(array); Type *array_base = array->array.base; FOREACH(Decl *, member, members)