diff --git a/src/stage1/analyze.cpp b/src/stage1/analyze.cpp index a4cc39e7b4..a3ad584eaf 100644 --- a/src/stage1/analyze.cpp +++ b/src/stage1/analyze.cpp @@ -5507,34 +5507,48 @@ bool handle_is_ptr(CodeGen *g, ZigType *type_entry) { zig_unreachable(); } -static uint32_t hash_ptr(void *ptr) { - return (uint32_t)(((uintptr_t)ptr) % UINT32_MAX); +static const uint32_t HASH_INIT = 0x811c9dc5U; + +template +static uint32_t hash_combine(uint32_t hash, const T *value, size_t count = 1) { + // Simple FNV32 hash + size_t len = sizeof(T) * count; + const unsigned char *char_bytes = (const unsigned char*)value; + for (size_t c = 0; c < len; ++c) { + hash ^= char_bytes[c]; + hash *= 0x01000193U; + } + return hash; } -static uint32_t hash_size(size_t x) { - return (uint32_t)(x % UINT32_MAX); +static uint32_t hash_combine_bigint(uint32_t hash, const BigInt *value) { + return hash_combine(hash, bigint_ptr(value), value->digit_count); +} + +static uint32_t hash_combine_buf(uint32_t hash, const Buf *buf) { + return hash_combine(hash, buf_ptr(buf), buf_len(buf)); } uint32_t fn_table_entry_hash(ZigFn* value) { - return ptr_hash(value); + return hash_combine(HASH_INIT, &value); } bool fn_table_entry_eql(ZigFn *a, ZigFn *b) { - return ptr_eq(a, b); + return a == b; } uint32_t fn_type_id_hash(FnTypeId *id) { - uint32_t result = 0; - result += ((uint32_t)(id->cc)) * (uint32_t)3349388391; - result += id->is_var_args ? (uint32_t)1931444534 : 0; - result += hash_ptr(id->return_type); - result += id->alignment * 0xd3b3f3e2; + uint32_t hash = HASH_INIT; + hash = hash_combine(hash, &id->cc); + hash = hash_combine(hash, &id->is_var_args); + hash = hash_combine(hash, &id->return_type); + hash = hash_combine(hash, &id->alignment); for (size_t i = 0; i < id->param_count; i += 1) { FnTypeParamInfo *info = &id->param_info[i]; - result += info->is_noalias ? (uint32_t)892356923 : 0; - result += hash_ptr(info->type); + hash = hash_combine(hash, &info->is_noalias); + hash = hash_combine(hash, &info->type); } - return result; + return hash; } bool fn_type_id_eql(FnTypeId *a, FnTypeId *b) { @@ -5559,194 +5573,202 @@ bool fn_type_id_eql(FnTypeId *a, FnTypeId *b) { return true; } -static uint32_t hash_const_val_error_set(ZigValue *const_val) { +static uint32_t hash_combine_const_val_error_set(uint32_t hash_val, ZigValue *const_val) { assert(const_val->data.x_err_set != nullptr); - return const_val->data.x_err_set->value ^ 2630160122; + return hash_combine(hash_val, &const_val->data.x_err_set->value); } -static uint32_t hash_const_val_ptr(ZigValue *const_val) { - uint32_t hash_val = 0; - switch (const_val->data.x_ptr.mut) { - case ConstPtrMutRuntimeVar: - hash_val += (uint32_t)3500721036; - break; - case ConstPtrMutComptimeConst: - hash_val += (uint32_t)4214318515; - break; - case ConstPtrMutInfer: - case ConstPtrMutComptimeVar: - hash_val += (uint32_t)1103195694; - break; - } +static uint32_t hash_combine_const_val_ptr(uint32_t hash_val, ZigValue *const_val) { + hash_val = hash_combine(hash_val, &const_val->data.x_ptr.special); switch (const_val->data.x_ptr.special) { case ConstPtrSpecialInvalid: zig_unreachable(); case ConstPtrSpecialRef: - hash_val += (uint32_t)2478261866; - hash_val += hash_ptr(const_val->data.x_ptr.data.ref.pointee); + hash_val = hash_combine(hash_val, &const_val->data.x_ptr.data.ref.pointee); return hash_val; case ConstPtrSpecialBaseArray: - hash_val += (uint32_t)1764906839; - hash_val += hash_ptr(const_val->data.x_ptr.data.base_array.array_val); - hash_val += hash_size(const_val->data.x_ptr.data.base_array.elem_index); + hash_val = hash_combine(hash_val, &const_val->data.x_ptr.data.base_array.array_val); + hash_val = hash_combine(hash_val, &const_val->data.x_ptr.data.base_array.elem_index); return hash_val; case ConstPtrSpecialSubArray: - hash_val += (uint32_t)2643358777; - hash_val += hash_ptr(const_val->data.x_ptr.data.base_array.array_val); - hash_val += hash_size(const_val->data.x_ptr.data.base_array.elem_index); + hash_val = hash_combine(hash_val, &const_val->data.x_ptr.data.base_array.array_val); + hash_val = hash_combine(hash_val, &const_val->data.x_ptr.data.base_array.elem_index); return hash_val; case ConstPtrSpecialBaseStruct: - hash_val += (uint32_t)3518317043; - hash_val += hash_ptr(const_val->data.x_ptr.data.base_struct.struct_val); - hash_val += hash_size(const_val->data.x_ptr.data.base_struct.field_index); + hash_val = hash_combine(hash_val, &const_val->data.x_ptr.data.base_struct.struct_val); + hash_val = hash_combine(hash_val, &const_val->data.x_ptr.data.base_struct.field_index); return hash_val; case ConstPtrSpecialBaseErrorUnionCode: - hash_val += (uint32_t)2994743799; - hash_val += hash_ptr(const_val->data.x_ptr.data.base_err_union_code.err_union_val); + hash_val = hash_combine(hash_val, &const_val->data.x_ptr.data.base_err_union_code.err_union_val); return hash_val; case ConstPtrSpecialBaseErrorUnionPayload: - hash_val += (uint32_t)3456080131; - hash_val += hash_ptr(const_val->data.x_ptr.data.base_err_union_payload.err_union_val); + hash_val = hash_combine(hash_val, &const_val->data.x_ptr.data.base_err_union_payload.err_union_val); return hash_val; case ConstPtrSpecialBaseOptionalPayload: - hash_val += (uint32_t)3163140517; - hash_val += hash_ptr(const_val->data.x_ptr.data.base_optional_payload.optional_val); + hash_val = hash_combine(hash_val, &const_val->data.x_ptr.data.base_optional_payload.optional_val); return hash_val; case ConstPtrSpecialHardCodedAddr: - hash_val += (uint32_t)4048518294; - hash_val += hash_size(const_val->data.x_ptr.data.hard_coded_addr.addr); - return hash_val; - case ConstPtrSpecialDiscard: - hash_val += 2010123162; + hash_val = hash_combine(hash_val, &const_val->data.x_ptr.data.hard_coded_addr.addr); return hash_val; case ConstPtrSpecialFunction: - hash_val += (uint32_t)2590901619; - hash_val += hash_ptr(const_val->data.x_ptr.data.fn.fn_entry); + hash_val = hash_combine(hash_val, &const_val->data.x_ptr.data.fn.fn_entry); return hash_val; + case ConstPtrSpecialDiscard: case ConstPtrSpecialNull: - hash_val += (uint32_t)1486246455; + // No fields to hash return hash_val; } zig_unreachable(); } -static uint32_t hash_const_val(ZigValue *const_val) { +static uint32_t hash_combine_const_val(uint32_t hash_val, ZigValue *const_val); +static uint32_t hash_combine_const_val_array(uint32_t hash_val, ZigValue *array, size_t len) { + if (array->data.x_array.special == ConstArraySpecialUndef) { + char undef_tag = 56; + return hash_combine(hash_val, &undef_tag); + } else if (array->data.x_array.special == ConstArraySpecialBuf) { + // Hash in a way that is compatible with standard byte arrays + // If any of these asserts fails, the if after this needs to be modified + // to handle the new type in SpecialBuf. + assert(array->type->data.array.child_type->id == ZigTypeIdInt); + assert(array->type->data.array.child_type->data.integral.bit_count == 8); + assert(array->type->data.array.child_type->data.integral.is_signed == false); + const char *buf_pos = buf_ptr(array->data.x_array.data.s_buf); + const char *buf_end = buf_pos + buf_len(array->data.x_array.data.s_buf); + while (buf_pos < buf_end) { + hash_val = hash_combine(hash_val, buf_pos); + buf_pos++; + } + return hash_val; + } else if (array->type->data.array.child_type->id == ZigTypeIdInt && + array->type->data.array.child_type->data.integral.bit_count == 8 && + array->type->data.array.child_type->data.integral.is_signed == false) { + // If the type is u8, we hash it as if it's a ConstArraySpecialBuf, + // to maintain compatibility. + ZigValue *elems = array->data.x_array.data.s_none.elements; + for (size_t i = 0; i < len; i += 1) { + ZigValue *value = &elems[i]; + assert(value->type == array->type->data.array.child_type); + // N.B. Using char here instead of uint8_t to match the const char* + // returned by buf_ptr. + const char byte_value = (char) bigint_as_u8(&value->data.x_bigint); + hash_val = hash_combine(hash_val, &byte_value); + } + return hash_val; + } else { + ZigValue *elems = array->data.x_array.data.s_none.elements; + for (size_t i = 0; i < len; i += 1) { + hash_val = hash_combine_const_val(hash_val, &elems[i]); + } + return hash_val; + } +} +static uint32_t hash_combine_const_val(uint32_t hash_val, ZigValue *const_val) { + hash_val = hash_combine(hash_val, &const_val->special); + if (const_val->special == ConstValSpecialUndef) { + return hash_val; + } + // if (const_val->special == ConstValSpecialLazy || + // const_val->special == ConstValSpecialRuntime) { + // // NO_COMMIT verify this is correct + // return hash_combine(hash_val, &const_val); + // } + if (const_val->special != ConstValSpecialStatic) { + printf("\nInvalid special: %d\n", const_val->special); + } assert(const_val->special == ConstValSpecialStatic); + hash_val = hash_combine(hash_val, &const_val->type->id); switch (const_val->type->id) { case ZigTypeIdOpaque: zig_unreachable(); case ZigTypeIdBool: - return const_val->data.x_bool ? (uint32_t)127863866 : (uint32_t)215080464; + return hash_combine(hash_val, &const_val->data.x_bool); case ZigTypeIdMetaType: - return hash_ptr(const_val->data.x_type); - case ZigTypeIdVoid: - return (uint32_t)4149439618; + return hash_combine(hash_val, &const_val->data.x_type); case ZigTypeIdInt: case ZigTypeIdComptimeInt: - { - uint32_t result = 1331471175; - for (size_t i = 0; i < const_val->data.x_bigint.digit_count; i += 1) { - uint64_t digit = bigint_ptr(&const_val->data.x_bigint)[i]; - result ^= ((uint32_t)(digit >> 32)) ^ (uint32_t)(result); - } - return result; - } + return hash_combine_bigint(hash_val, &const_val->data.x_bigint); case ZigTypeIdEnumLiteral: - return buf_hash(const_val->data.x_enum_literal) * (uint32_t)2691276464; + return hash_combine_buf(hash_val, const_val->data.x_enum_literal); case ZigTypeIdEnum: - { - uint32_t result = 31643936; - for (size_t i = 0; i < const_val->data.x_enum_tag.digit_count; i += 1) { - uint64_t digit = bigint_ptr(&const_val->data.x_enum_tag)[i]; - result ^= ((uint32_t)(digit >> 32)) ^ (uint32_t)(result); - } - return result; - } + return hash_combine_bigint(hash_val, &const_val->data.x_enum_tag); case ZigTypeIdFloat: + hash_val = hash_combine(hash_val, &const_val->type->data.floating.bit_count); switch (const_val->type->data.floating.bit_count) { - case 16: - { - uint16_t result; - static_assert(sizeof(result) == sizeof(const_val->data.x_f16), ""); - memcpy(&result, &const_val->data.x_f16, sizeof(result)); - return result * 65537u; - } - case 32: - { - uint32_t result; - memcpy(&result, &const_val->data.x_f32, 4); - return result ^ 4084870010; - } - case 64: - { - uint32_t ints[2]; - memcpy(&ints[0], &const_val->data.x_f64, 8); - return ints[0] ^ ints[1] ^ 0x22ed43c6; - } - case 128: - { - uint32_t ints[4]; - memcpy(&ints[0], &const_val->data.x_f128, 16); - return ints[0] ^ ints[1] ^ ints[2] ^ ints[3] ^ 0xb5ffef27; - } - default: - zig_unreachable(); + case 16: return hash_combine(hash_val, &const_val->data.x_f16); + case 32: return hash_combine(hash_val, &const_val->data.x_f32); + case 64: return hash_combine(hash_val, &const_val->data.x_f64); + case 128: return hash_combine(hash_val, &const_val->data.x_f128); + default: zig_unreachable(); } case ZigTypeIdComptimeFloat: - { - float128_t f128 = bigfloat_to_f128(&const_val->data.x_bigfloat); - uint32_t ints[4]; - memcpy(&ints[0], &f128, 16); - return ints[0] ^ ints[1] ^ ints[2] ^ ints[3] ^ 0xed8b3dfb; - } + return hash_combine(hash_val, &const_val->data.x_bigfloat.value); case ZigTypeIdFn: assert(const_val->data.x_ptr.mut == ConstPtrMutComptimeConst); assert(const_val->data.x_ptr.special == ConstPtrSpecialFunction); - return 3677364617 ^ hash_ptr(const_val->data.x_ptr.data.fn.fn_entry); + return hash_combine(hash_val, &const_val->data.x_ptr.data.fn.fn_entry); case ZigTypeIdPointer: - return hash_const_val_ptr(const_val); + return hash_combine_const_val_ptr(hash_val, const_val); + case ZigTypeIdVoid: case ZigTypeIdUndefined: - return 162837799; case ZigTypeIdNull: - return 844854567; + return hash_val; case ZigTypeIdArray: - // TODO better hashing algorithm - return 1166190605; - case ZigTypeIdStruct: - // TODO better hashing algorithm - return 1532530855; - case ZigTypeIdUnion: - // TODO better hashing algorithm - return 2709806591; + return hash_combine_const_val_array(hash_val, const_val, const_val->type->data.array.len); + case ZigTypeIdStruct: { + size_t field_count = const_val->type->data.structure.src_field_count; + for (size_t i = 0; i < field_count; i += 1) { + ZigValue *field = const_val->data.x_struct.fields[i]; + hash_val = hash_combine_const_val(hash_val, field); + } + return hash_val; + } + case ZigTypeIdUnion: { + ConstUnionValue *union_value = &const_val->data.x_union; + hash_val = hash_combine_bigint(hash_val, &union_value->tag); + return hash_combine_const_val(hash_val, union_value->payload); + } case ZigTypeIdOptional: if (get_src_ptr_type(const_val->type) != nullptr) { - return hash_const_val_ptr(const_val) * (uint32_t)1992916303; + char tag = 1; + hash_val = hash_combine(hash_val, &tag); + return hash_combine_const_val_ptr(hash_val, const_val); } else if (const_val->type->data.maybe.child_type->id == ZigTypeIdErrorSet) { - return hash_const_val_error_set(const_val) * (uint32_t)3147031929; + char tag = 2; + hash_val = hash_combine(hash_val, &tag); + return hash_combine_const_val_error_set(hash_val, const_val); + } else if (const_val->data.x_optional) { + char tag = 3; + hash_val = hash_combine(hash_val, &tag); + return hash_combine_const_val(hash_val, const_val->data.x_optional); } else { - if (const_val->data.x_optional) { - return hash_const_val(const_val->data.x_optional) * (uint32_t)1992916303; - } else { - return 4016830364; - } + char tag = 4; + hash_val = hash_combine(hash_val, &tag); + return hash_val; } - case ZigTypeIdErrorUnion: - // TODO better hashing algorithm - return 3415065496; + case ZigTypeIdErrorUnion: { + bool is_err = const_val->data.x_err_union.error_set->data.x_err_set != nullptr; + hash_val = hash_combine(hash_val, &is_err); + if (is_err) { + hash_val = hash_combine_const_val(hash_val, const_val->data.x_err_union.error_set); + } else { + hash_val = hash_combine_const_val(hash_val, const_val->data.x_err_union.payload); + } + return hash_val; + } case ZigTypeIdErrorSet: - return hash_const_val_error_set(const_val); + return hash_combine_const_val_error_set(hash_val, const_val); case ZigTypeIdVector: - // TODO better hashing algorithm - return 3647867726; + return hash_combine_const_val_array(hash_val, const_val, const_val->type->data.vector.len); case ZigTypeIdFnFrame: // TODO better hashing algorithm - return 675741936; + return hash_val; case ZigTypeIdAnyFrame: // TODO better hashing algorithm - return 3747294894; + return hash_val; case ZigTypeIdBoundFn: { assert(const_val->data.x_bound_fn.fn != nullptr); - return 3677364617 ^ hash_ptr(const_val->data.x_bound_fn.fn); + return hash_combine(hash_val, &const_val->data.x_bound_fn.fn); } case ZigTypeIdInvalid: case ZigTypeIdUnreachable: @@ -5754,15 +5776,18 @@ static uint32_t hash_const_val(ZigValue *const_val) { } zig_unreachable(); } +static uint32_t hash_const_val(ZigValue *const_val) { + return hash_combine_const_val(HASH_INIT, const_val); +} uint32_t generic_fn_type_id_hash(GenericFnTypeId *id) { - uint32_t result = 0; - result += hash_ptr(id->fn_entry); + uint32_t result = HASH_INIT; + result = hash_combine(result, &id->fn_entry); for (size_t i = 0; i < id->param_count; i += 1) { ZigValue *generic_param = &id->params[i]; if (generic_param->special != ConstValSpecialRuntime) { - result += hash_const_val(generic_param); - result += hash_ptr(generic_param->type); + result = hash_combine_const_val(result, generic_param); + result = hash_combine(result, &generic_param->type); } } return result; @@ -5957,15 +5982,15 @@ bool fn_eval_cacheable(Scope *scope, ZigType *return_type) { } uint32_t fn_eval_hash(Scope* scope) { - uint32_t result = 0; + uint32_t hash = HASH_INIT; while (scope) { if (scope->id == ScopeIdVarDecl) { ScopeVarDecl *var_scope = (ScopeVarDecl *)scope; - result += hash_const_val(var_scope->var->const_value); + hash = hash_combine_const_val(hash, var_scope->var->const_value); } else if (scope->id == ScopeIdFnDef) { ScopeFnDef *fn_scope = (ScopeFnDef *)scope; - result += hash_ptr(fn_scope->fn_entry); - return result; + hash = hash_combine(hash, &fn_scope->fn_entry); + return hash; } else { zig_unreachable(); } @@ -7260,6 +7285,8 @@ bool const_values_equal(CodeGen *g, ZigValue *a, ZigValue *b) { case ZigTypeIdMetaType: return a->data.x_type == b->data.x_type; case ZigTypeIdVoid: + case ZigTypeIdUndefined: + case ZigTypeIdNull: return true; case ZigTypeIdErrorSet: return a->data.x_err_set->value == b->data.x_err_set->value; @@ -7292,10 +7319,9 @@ bool const_values_equal(CodeGen *g, ZigValue *a, ZigValue *b) { case ZigTypeIdVector: assert(a->type->data.vector.len == b->type->data.vector.len); return const_values_equal_array(g, a, b, a->type->data.vector.len); - case ZigTypeIdArray: { + case ZigTypeIdArray: assert(a->type->data.array.len == b->type->data.array.len); return const_values_equal_array(g, a, b, a->type->data.array.len); - } case ZigTypeIdStruct: for (size_t i = 0; i < a->type->data.structure.src_field_count; i += 1) { ZigValue *field_a = a->data.x_struct.fields[i]; @@ -7308,10 +7334,6 @@ bool const_values_equal(CodeGen *g, ZigValue *a, ZigValue *b) { zig_panic("TODO: const_values_equal ZigTypeIdFnFrame"); case ZigTypeIdAnyFrame: zig_panic("TODO: const_values_equal ZigTypeIdAnyFrame"); - case ZigTypeIdUndefined: - zig_panic("TODO: const_values_equal ZigTypeIdUndefined"); - case ZigTypeIdNull: - zig_panic("TODO: const_values_equal ZigTypeIdNull"); case ZigTypeIdOptional: if (get_src_ptr_type(a->type) != nullptr) return const_values_equal_ptr(a, b); @@ -7719,6 +7741,7 @@ ZigType *make_int_type(CodeGen *g, bool is_signed, uint32_t size_in_bits) { } uint32_t type_id_hash(TypeId x) { + uint32_t hash = hash_combine(HASH_INIT, &x.id); switch (x.id) { case ZigTypeIdInvalid: case ZigTypeIdOpaque: @@ -7743,27 +7766,38 @@ uint32_t type_id_hash(TypeId x) { case ZigTypeIdAnyFrame: zig_unreachable(); case ZigTypeIdErrorUnion: - return hash_ptr(x.data.error_union.err_set_type) ^ hash_ptr(x.data.error_union.payload_type); + hash = hash_combine(hash, &x.data.error_union.err_set_type); + hash = hash_combine(hash, &x.data.error_union.payload_type); + return hash; case ZigTypeIdPointer: - return hash_ptr(x.data.pointer.child_type) + - (uint32_t)x.data.pointer.ptr_len * 1120226602u + - (x.data.pointer.is_const ? (uint32_t)2749109194 : (uint32_t)4047371087) + - (x.data.pointer.is_volatile ? (uint32_t)536730450 : (uint32_t)1685612214) + - (x.data.pointer.allow_zero ? (uint32_t)3324284834 : (uint32_t)3584904923) + - (((uint32_t)x.data.pointer.alignment) ^ (uint32_t)0x777fbe0e) + - (((uint32_t)x.data.pointer.bit_offset_in_host) ^ (uint32_t)2639019452) + - (((uint32_t)x.data.pointer.vector_index) ^ (uint32_t)0x19199716) + - (((uint32_t)x.data.pointer.host_int_bytes) ^ (uint32_t)529908881) * - (x.data.pointer.sentinel ? hash_const_val(x.data.pointer.sentinel) : (uint32_t)2955491856); + hash = hash_combine(hash, &x.data.pointer.child_type); + hash = hash_combine(hash, &x.data.pointer.ptr_len); + hash = hash_combine(hash, &x.data.pointer.is_const); + hash = hash_combine(hash, &x.data.pointer.is_volatile); + hash = hash_combine(hash, &x.data.pointer.allow_zero); + hash = hash_combine(hash, &x.data.pointer.alignment); + hash = hash_combine(hash, &x.data.pointer.bit_offset_in_host); + hash = hash_combine(hash, &x.data.pointer.vector_index); + hash = hash_combine(hash, &x.data.pointer.host_int_bytes); + if (x.data.pointer.sentinel != nullptr) { + hash = hash_combine_const_val(hash, x.data.pointer.sentinel); + } + return hash; case ZigTypeIdArray: - return hash_ptr(x.data.array.child_type) * - ((uint32_t)x.data.array.size ^ (uint32_t)2122979968) * - (x.data.array.sentinel ? hash_const_val(x.data.array.sentinel) : (uint32_t)1927201585); + hash = hash_combine(hash, &x.data.array.child_type); + hash = hash_combine(hash, &x.data.array.size); + if (x.data.array.sentinel != nullptr) { + hash = hash_combine_const_val(hash, x.data.array.sentinel); + } + return hash; case ZigTypeIdInt: - return (x.data.integer.is_signed ? (uint32_t)2652528194 : (uint32_t)163929201) + - (((uint32_t)x.data.integer.bit_count) ^ (uint32_t)2998081557); + hash = hash_combine(hash, &x.data.integer.is_signed); + hash = hash_combine(hash, &x.data.integer.bit_count); + return hash; case ZigTypeIdVector: - return hash_ptr(x.data.vector.elem_type) * (x.data.vector.len * 526582681); + hash = hash_combine(hash, &x.data.vector.elem_type); + hash = hash_combine(hash, &x.data.vector.len); + return hash; } zig_unreachable(); } @@ -8155,7 +8189,7 @@ ZigType *get_align_amt_type(CodeGen *g) { } uint32_t type_ptr_hash(const ZigType *ptr) { - return hash_ptr((void*)ptr); + return hash_combine(HASH_INIT, &ptr); } bool type_ptr_eql(const ZigType *a, const ZigType *b) { @@ -8163,7 +8197,7 @@ bool type_ptr_eql(const ZigType *a, const ZigType *b) { } uint32_t pkg_ptr_hash(const ZigPackage *ptr) { - return hash_ptr((void*)ptr); + return hash_combine(HASH_INIT, &ptr); } bool pkg_ptr_eql(const ZigPackage *a, const ZigPackage *b) { @@ -8171,7 +8205,7 @@ bool pkg_ptr_eql(const ZigPackage *a, const ZigPackage *b) { } uint32_t tld_ptr_hash(const Tld *ptr) { - return hash_ptr((void*)ptr); + return hash_combine(HASH_INIT, &ptr); } bool tld_ptr_eql(const Tld *a, const Tld *b) { @@ -8179,7 +8213,7 @@ bool tld_ptr_eql(const Tld *a, const Tld *b) { } uint32_t node_ptr_hash(const AstNode *ptr) { - return hash_ptr((void*)ptr); + return hash_combine(HASH_INIT, &ptr); } bool node_ptr_eql(const AstNode *a, const AstNode *b) { @@ -8187,7 +8221,7 @@ bool node_ptr_eql(const AstNode *a, const AstNode *b) { } uint32_t fn_ptr_hash(const ZigFn *ptr) { - return hash_ptr((void*)ptr); + return hash_combine(HASH_INIT, &ptr); } bool fn_ptr_eql(const ZigFn *a, const ZigFn *b) { @@ -8195,7 +8229,7 @@ bool fn_ptr_eql(const ZigFn *a, const ZigFn *b) { } uint32_t err_ptr_hash(const ErrorTableEntry *ptr) { - return hash_ptr((void*)ptr); + return hash_combine(HASH_INIT, &ptr); } bool err_ptr_eql(const ErrorTableEntry *a, const ErrorTableEntry *b) { diff --git a/src/stage1/bigint.cpp b/src/stage1/bigint.cpp index acb3e18e41..97181b6ad2 100644 --- a/src/stage1/bigint.cpp +++ b/src/stage1/bigint.cpp @@ -1691,6 +1691,13 @@ uint32_t bigint_as_u32(const BigInt *bigint) { return value32; } +uint8_t bigint_as_u8(const BigInt *bigint) { + uint64_t value64 = bigint_as_unsigned(bigint); + uint8_t value8 = (uint8_t)value64; + assert (value64 == value8); + return value8; +} + size_t bigint_as_usize(const BigInt *bigint) { uint64_t value64 = bigint_as_unsigned(bigint); size_t valueUsize = (size_t)value64; diff --git a/src/stage1/bigint.hpp b/src/stage1/bigint.hpp index aa37b9302a..521de25b1c 100644 --- a/src/stage1/bigint.hpp +++ b/src/stage1/bigint.hpp @@ -39,6 +39,7 @@ void bigint_deinit(BigInt *bi); // panics if number won't fit uint64_t bigint_as_u64(const BigInt *bigint); uint32_t bigint_as_u32(const BigInt *bigint); +uint8_t bigint_as_u8(const BigInt *bigint); size_t bigint_as_usize(const BigInt *bigint); int64_t bigint_as_signed(const BigInt *bigint); diff --git a/src/stage1/buffer.hpp b/src/stage1/buffer.hpp index 8876316589..d8a31b1bf4 100644 --- a/src/stage1/buffer.hpp +++ b/src/stage1/buffer.hpp @@ -26,7 +26,7 @@ Buf *buf_sprintf(const char *format, ...) ATTRIBUTE_PRINTF(1, 2); Buf *buf_vprintf(const char *format, va_list ap); -static inline size_t buf_len(Buf *buf) { +static inline size_t buf_len(const Buf *buf) { assert(buf); assert(buf->list.length); return buf->list.length - 1; diff --git a/src/stage1/ir.cpp b/src/stage1/ir.cpp index d4daa547c7..b5dbdd3c21 100644 --- a/src/stage1/ir.cpp +++ b/src/stage1/ir.cpp @@ -272,8 +272,8 @@ static bool value_cmp_numeric_val_all(ZigValue *left, Cmp predicate, ZigValue *r static void memoize_field_init_val(CodeGen *codegen, ZigType *container_type, TypeStructField *field); static void value_to_bigfloat(BigFloat *out, ZigValue *val); -static Error ir_resolve_lazy_recurse(AstNode *source_node, ZigValue *val); -static Error ir_resolve_lazy_recurse_array(AstNode *source_node, ZigValue *val, size_t len); +static Error ir_resolve_lazy_recurse(IrAnalyze *ira, AstNode *source_node, ZigValue *val); +static Error ir_resolve_lazy_recurse_array(IrAnalyze *ira, AstNode *source_node, ZigValue *val, size_t len); static void ir_assert_impl(bool ok, IrInstGen *source_instruction, char const *file, unsigned int line) { @@ -12945,7 +12945,7 @@ static IrInstGen *ir_analyze_fn_call(IrAnalyze *ira, Scope *scope, AstNode *sour for (size_t i = 0; i < generic_id->param_count; i += 1) { ZigValue *generic_param = &generic_id->params[i]; if (generic_param->special != ConstValSpecialRuntime) { - if ((err = ir_resolve_lazy_recurse(source_node, generic_param))) { + if ((err = ir_resolve_lazy_recurse(ira, source_node, generic_param))) { return ira->codegen->invalid_inst_gen; } } @@ -25531,7 +25531,7 @@ static Error ir_resolve_lazy_raw(AstNode *source_node, ZigValue *val) { zig_unreachable(); } -static Error ir_resolve_lazy_recurse_array(AstNode *source_node, ZigValue *val, size_t len) { +static Error ir_resolve_lazy_recurse_array(IrAnalyze *ira, AstNode *source_node, ZigValue *val, size_t len) { Error err; switch (val->data.x_array.special) { case ConstArraySpecialUndef: @@ -25543,17 +25543,24 @@ static Error ir_resolve_lazy_recurse_array(AstNode *source_node, ZigValue *val, ZigValue *elems = val->data.x_array.data.s_none.elements; for (size_t i = 0; i < len; i += 1) { - if ((err = ir_resolve_lazy_recurse(source_node, &elems[i]))) + if ((err = ir_resolve_lazy_recurse(ira, source_node, &elems[i]))) return err; } return ErrorNone; } -static Error ir_resolve_lazy_recurse(AstNode *source_node, ZigValue *val) { +static Error ir_resolve_lazy_recurse(IrAnalyze *ira, AstNode *source_node, ZigValue *val) { Error err; if ((err = ir_resolve_lazy_raw(source_node, val))) return err; + if (val->special == ConstValSpecialRuntime) { + // This shouldn't be possible, it indicates an ICE. + // NO_COMMIT + ir_add_error_node(ira, source_node, + buf_sprintf("This is a bug in the Zig compiler. Runtime value found in comptime known parameter.")); + return ErrorSemanticAnalyzeFail; + } if (val->special != ConstValSpecialStatic) return ErrorNone; switch (val->type->id) { @@ -25581,16 +25588,16 @@ static Error ir_resolve_lazy_recurse(AstNode *source_node, ZigValue *val) { zig_panic("TODO: ir_resolve_lazy_recurse ZigTypeIdFnFrame"); case ZigTypeIdUnion: { ConstUnionValue *union_val = &val->data.x_union; - return ir_resolve_lazy_recurse(source_node, union_val->payload); + return ir_resolve_lazy_recurse(ira, source_node, union_val->payload); } case ZigTypeIdVector: - return ir_resolve_lazy_recurse_array(source_node, val, val->type->data.vector.len); + return ir_resolve_lazy_recurse_array(ira, source_node, val, val->type->data.vector.len); case ZigTypeIdArray: - return ir_resolve_lazy_recurse_array(source_node, val, val->type->data.array.len); + return ir_resolve_lazy_recurse_array(ira, source_node, val, val->type->data.array.len); case ZigTypeIdStruct: for (size_t i = 0; i < val->type->data.structure.src_field_count; i += 1) { ZigValue *field = val->data.x_struct.fields[i]; - if ((err = ir_resolve_lazy_recurse(source_node, field))) + if ((err = ir_resolve_lazy_recurse(ira, source_node, field))) return err; } return ErrorNone; @@ -25600,13 +25607,13 @@ static Error ir_resolve_lazy_recurse(AstNode *source_node, ZigValue *val) { if (val->data.x_optional == nullptr) return ErrorNone; - return ir_resolve_lazy_recurse(source_node, val->data.x_optional); + return ir_resolve_lazy_recurse(ira, source_node, val->data.x_optional); case ZigTypeIdErrorUnion: { bool is_err = val->data.x_err_union.error_set->data.x_err_set != nullptr; if (is_err) { - return ir_resolve_lazy_recurse(source_node, val->data.x_err_union.error_set); + return ir_resolve_lazy_recurse(ira, source_node, val->data.x_err_union.error_set); } else { - return ir_resolve_lazy_recurse(source_node, val->data.x_err_union.payload); + return ir_resolve_lazy_recurse(ira, source_node, val->data.x_err_union.payload); } } } diff --git a/src/stage1/util.cpp b/src/stage1/util.cpp index 2de09df808..e1e167adf9 100644 --- a/src/stage1/util.cpp +++ b/src/stage1/util.cpp @@ -21,29 +21,6 @@ void zig_panic(const char *format, ...) { abort(); } -uint32_t int_hash(int i) { - return (uint32_t)(i % UINT32_MAX); -} -bool int_eq(int a, int b) { - return a == b; -} - -uint32_t uint64_hash(uint64_t i) { - return (uint32_t)(i % UINT32_MAX); -} - -bool uint64_eq(uint64_t a, uint64_t b) { - return a == b; -} - -uint32_t ptr_hash(const void *ptr) { - return (uint32_t)(((uintptr_t)ptr) % UINT32_MAX); -} - -bool ptr_eq(const void *a, const void *b) { - return a == b; -} - // Ported from std/mem.zig. bool SplitIterator_isSplitByte(SplitIterator *self, uint8_t byte) { for (size_t i = 0; i < self->split_bytes.len; i += 1) { diff --git a/src/stage1/util.hpp b/src/stage1/util.hpp index bb4ff00f7a..35fa49acce 100644 --- a/src/stage1/util.hpp +++ b/src/stage1/util.hpp @@ -129,13 +129,6 @@ static inline uint64_t round_to_next_power_of_2(uint64_t x) { return x + 1; } -uint32_t int_hash(int i); -bool int_eq(int a, int b); -uint32_t uint64_hash(uint64_t i); -bool uint64_eq(uint64_t a, uint64_t b); -uint32_t ptr_hash(const void *ptr); -bool ptr_eq(const void *a, const void *b); - static inline uint8_t log2_u64(uint64_t x) { return (63 - clzll(x)); }