authorgravatar for spexguy070@gmail.comMartin Wickham <spexguy070@gmail.com> 2021-07-05 15:28:13-05:00
committergravatar for spexguy070@gmail.comMartin Wickham <spexguy070@gmail.com> 2021-07-05 15:28:13-05:00
log0e5fa87ac9695378683e770fbe0d577521860d35
tree216ae76ac1afd63acb08a27550f3ef22afdbe38d
parent9b0868776646934bdec84888dabebbb2b8d9924e

Better hashing, new asserts failing

7 files changed, 238 insertions(+), 219 deletions(-)

src/stage1/analyze.cpp+209-175
......@@ -5507,34 +5507,48 @@ bool handle_is_ptr(CodeGen *g, ZigType *type_entry) {
55075507 zig_unreachable();
55085508}
55095509
5510static uint32_t hash_ptr(void *ptr) {
5511 return (uint32_t)(((uintptr_t)ptr) % UINT32_MAX);
5510static const uint32_t HASH_INIT = 0x811c9dc5U;
5511
5512template<typename T>
5513static uint32_t hash_combine(uint32_t hash, const T *value, size_t count = 1) {
5514 // Simple FNV32 hash
5515 size_t len = sizeof(T) * count;
5516 const unsigned char *char_bytes = (const unsigned char*)value;
5517 for (size_t c = 0; c < len; ++c) {
5518 hash ^= char_bytes[c];
5519 hash *= 0x01000193U;
5520 }
5521 return hash;
5522}
5523
5524static uint32_t hash_combine_bigint(uint32_t hash, const BigInt *value) {
5525 return hash_combine(hash, bigint_ptr(value), value->digit_count);
55125526}
55135527
5514static uint32_t hash_size(size_t x) {
5515 return (uint32_t)(x % UINT32_MAX);
5528static uint32_t hash_combine_buf(uint32_t hash, const Buf *buf) {
5529 return hash_combine(hash, buf_ptr(buf), buf_len(buf));
55165530}
55175531
55185532uint32_t fn_table_entry_hash(ZigFn* value) {
5519 return ptr_hash(value);
5533 return hash_combine(HASH_INIT, &value);
55205534}
55215535
55225536bool fn_table_entry_eql(ZigFn *a, ZigFn *b) {
5523 return ptr_eq(a, b);
5537 return a == b;
55245538}
55255539
55265540uint32_t fn_type_id_hash(FnTypeId *id) {
5527 uint32_t result = 0;
5528 result += ((uint32_t)(id->cc)) * (uint32_t)3349388391;
5529 result += id->is_var_args ? (uint32_t)1931444534 : 0;
5530 result += hash_ptr(id->return_type);
5531 result += id->alignment * 0xd3b3f3e2;
5541 uint32_t hash = HASH_INIT;
5542 hash = hash_combine(hash, &id->cc);
5543 hash = hash_combine(hash, &id->is_var_args);
5544 hash = hash_combine(hash, &id->return_type);
5545 hash = hash_combine(hash, &id->alignment);
55325546 for (size_t i = 0; i < id->param_count; i += 1) {
55335547 FnTypeParamInfo *info = &id->param_info[i];
5534 result += info->is_noalias ? (uint32_t)892356923 : 0;
5535 result += hash_ptr(info->type);
5548 hash = hash_combine(hash, &info->is_noalias);
5549 hash = hash_combine(hash, &info->type);
55365550 }
5537 return result;
5551 return hash;
55385552}
55395553
55405554bool fn_type_id_eql(FnTypeId *a, FnTypeId *b) {
......@@ -5559,194 +5573,202 @@ bool fn_type_id_eql(FnTypeId *a, FnTypeId *b) {
55595573 return true;
55605574}
55615575
5562static uint32_t hash_const_val_error_set(ZigValue *const_val) {
5576static uint32_t hash_combine_const_val_error_set(uint32_t hash_val, ZigValue *const_val) {
55635577 assert(const_val->data.x_err_set != nullptr);
5564 return const_val->data.x_err_set->value ^ 2630160122;
5578 return hash_combine(hash_val, &const_val->data.x_err_set->value);
55655579}
55665580
5567static uint32_t hash_const_val_ptr(ZigValue *const_val) {
5568 uint32_t hash_val = 0;
5569 switch (const_val->data.x_ptr.mut) {
5570 case ConstPtrMutRuntimeVar:
5571 hash_val += (uint32_t)3500721036;
5572 break;
5573 case ConstPtrMutComptimeConst:
5574 hash_val += (uint32_t)4214318515;
5575 break;
5576 case ConstPtrMutInfer:
5577 case ConstPtrMutComptimeVar:
5578 hash_val += (uint32_t)1103195694;
5579 break;
5580 }
5581static uint32_t hash_combine_const_val_ptr(uint32_t hash_val, ZigValue *const_val) {
5582 hash_val = hash_combine(hash_val, &const_val->data.x_ptr.special);
55815583 switch (const_val->data.x_ptr.special) {
55825584 case ConstPtrSpecialInvalid:
55835585 zig_unreachable();
55845586 case ConstPtrSpecialRef:
5585 hash_val += (uint32_t)2478261866;
5586 hash_val += hash_ptr(const_val->data.x_ptr.data.ref.pointee);
5587 hash_val = hash_combine(hash_val, &const_val->data.x_ptr.data.ref.pointee);
55875588 return hash_val;
55885589 case ConstPtrSpecialBaseArray:
5589 hash_val += (uint32_t)1764906839;
5590 hash_val += hash_ptr(const_val->data.x_ptr.data.base_array.array_val);
5591 hash_val += hash_size(const_val->data.x_ptr.data.base_array.elem_index);
5590 hash_val = hash_combine(hash_val, &const_val->data.x_ptr.data.base_array.array_val);
5591 hash_val = hash_combine(hash_val, &const_val->data.x_ptr.data.base_array.elem_index);
55925592 return hash_val;
55935593 case ConstPtrSpecialSubArray:
5594 hash_val += (uint32_t)2643358777;
5595 hash_val += hash_ptr(const_val->data.x_ptr.data.base_array.array_val);
5596 hash_val += hash_size(const_val->data.x_ptr.data.base_array.elem_index);
5594 hash_val = hash_combine(hash_val, &const_val->data.x_ptr.data.base_array.array_val);
5595 hash_val = hash_combine(hash_val, &const_val->data.x_ptr.data.base_array.elem_index);
55975596 return hash_val;
55985597 case ConstPtrSpecialBaseStruct:
5599 hash_val += (uint32_t)3518317043;
5600 hash_val += hash_ptr(const_val->data.x_ptr.data.base_struct.struct_val);
5601 hash_val += hash_size(const_val->data.x_ptr.data.base_struct.field_index);
5598 hash_val = hash_combine(hash_val, &const_val->data.x_ptr.data.base_struct.struct_val);
5599 hash_val = hash_combine(hash_val, &const_val->data.x_ptr.data.base_struct.field_index);
56025600 return hash_val;
56035601 case ConstPtrSpecialBaseErrorUnionCode:
5604 hash_val += (uint32_t)2994743799;
5605 hash_val += hash_ptr(const_val->data.x_ptr.data.base_err_union_code.err_union_val);
5602 hash_val = hash_combine(hash_val, &const_val->data.x_ptr.data.base_err_union_code.err_union_val);
56065603 return hash_val;
56075604 case ConstPtrSpecialBaseErrorUnionPayload:
5608 hash_val += (uint32_t)3456080131;
5609 hash_val += hash_ptr(const_val->data.x_ptr.data.base_err_union_payload.err_union_val);
5605 hash_val = hash_combine(hash_val, &const_val->data.x_ptr.data.base_err_union_payload.err_union_val);
56105606 return hash_val;
56115607 case ConstPtrSpecialBaseOptionalPayload:
5612 hash_val += (uint32_t)3163140517;
5613 hash_val += hash_ptr(const_val->data.x_ptr.data.base_optional_payload.optional_val);
5608 hash_val = hash_combine(hash_val, &const_val->data.x_ptr.data.base_optional_payload.optional_val);
56145609 return hash_val;
56155610 case ConstPtrSpecialHardCodedAddr:
5616 hash_val += (uint32_t)4048518294;
5617 hash_val += hash_size(const_val->data.x_ptr.data.hard_coded_addr.addr);
5618 return hash_val;
5619 case ConstPtrSpecialDiscard:
5620 hash_val += 2010123162;
5611 hash_val = hash_combine(hash_val, &const_val->data.x_ptr.data.hard_coded_addr.addr);
56215612 return hash_val;
56225613 case ConstPtrSpecialFunction:
5623 hash_val += (uint32_t)2590901619;
5624 hash_val += hash_ptr(const_val->data.x_ptr.data.fn.fn_entry);
5614 hash_val = hash_combine(hash_val, &const_val->data.x_ptr.data.fn.fn_entry);
56255615 return hash_val;
5616 case ConstPtrSpecialDiscard:
56265617 case ConstPtrSpecialNull:
5627 hash_val += (uint32_t)1486246455;
5618 // No fields to hash
56285619 return hash_val;
56295620 }
56305621 zig_unreachable();
56315622}
56325623
5633static uint32_t hash_const_val(ZigValue *const_val) {
5624static uint32_t hash_combine_const_val(uint32_t hash_val, ZigValue *const_val);
5625static uint32_t hash_combine_const_val_array(uint32_t hash_val, ZigValue *array, size_t len) {
5626 if (array->data.x_array.special == ConstArraySpecialUndef) {
5627 char undef_tag = 56;
5628 return hash_combine(hash_val, &undef_tag);
5629 } else if (array->data.x_array.special == ConstArraySpecialBuf) {
5630 // Hash in a way that is compatible with standard byte arrays
5631 // If any of these asserts fails, the if after this needs to be modified
5632 // to handle the new type in SpecialBuf.
5633 assert(array->type->data.array.child_type->id == ZigTypeIdInt);
5634 assert(array->type->data.array.child_type->data.integral.bit_count == 8);
5635 assert(array->type->data.array.child_type->data.integral.is_signed == false);
5636 const char *buf_pos = buf_ptr(array->data.x_array.data.s_buf);
5637 const char *buf_end = buf_pos + buf_len(array->data.x_array.data.s_buf);
5638 while (buf_pos < buf_end) {
5639 hash_val = hash_combine(hash_val, buf_pos);
5640 buf_pos++;
5641 }
5642 return hash_val;
5643 } else if (array->type->data.array.child_type->id == ZigTypeIdInt &&
5644 array->type->data.array.child_type->data.integral.bit_count == 8 &&
5645 array->type->data.array.child_type->data.integral.is_signed == false) {
5646 // If the type is u8, we hash it as if it's a ConstArraySpecialBuf,
5647 // to maintain compatibility.
5648 ZigValue *elems = array->data.x_array.data.s_none.elements;
5649 for (size_t i = 0; i < len; i += 1) {
5650 ZigValue *value = &elems[i];
5651 assert(value->type == array->type->data.array.child_type);
5652 // N.B. Using char here instead of uint8_t to match the const char*
5653 // returned by buf_ptr.
5654 const char byte_value = (char) bigint_as_u8(&value->data.x_bigint);
5655 hash_val = hash_combine(hash_val, &byte_value);
5656 }
5657 return hash_val;
5658 } else {
5659 ZigValue *elems = array->data.x_array.data.s_none.elements;
5660 for (size_t i = 0; i < len; i += 1) {
5661 hash_val = hash_combine_const_val(hash_val, &elems[i]);
5662 }
5663 return hash_val;
5664 }
5665}
5666static uint32_t hash_combine_const_val(uint32_t hash_val, ZigValue *const_val) {
5667 hash_val = hash_combine(hash_val, &const_val->special);
5668 if (const_val->special == ConstValSpecialUndef) {
5669 return hash_val;
5670 }
5671 // if (const_val->special == ConstValSpecialLazy ||
5672 // const_val->special == ConstValSpecialRuntime) {
5673 // // NO_COMMIT verify this is correct
5674 // return hash_combine(hash_val, &const_val);
5675 // }
5676 if (const_val->special != ConstValSpecialStatic) {
5677 printf("\nInvalid special: %d\n", const_val->special);
5678 }
56345679 assert(const_val->special == ConstValSpecialStatic);
5680 hash_val = hash_combine(hash_val, &const_val->type->id);
56355681 switch (const_val->type->id) {
56365682 case ZigTypeIdOpaque:
56375683 zig_unreachable();
56385684 case ZigTypeIdBool:
5639 return const_val->data.x_bool ? (uint32_t)127863866 : (uint32_t)215080464;
5685 return hash_combine(hash_val, &const_val->data.x_bool);
56405686 case ZigTypeIdMetaType:
5641 return hash_ptr(const_val->data.x_type);
5642 case ZigTypeIdVoid:
5643 return (uint32_t)4149439618;
5687 return hash_combine(hash_val, &const_val->data.x_type);
56445688 case ZigTypeIdInt:
56455689 case ZigTypeIdComptimeInt:
5646 {
5647 uint32_t result = 1331471175;
5648 for (size_t i = 0; i < const_val->data.x_bigint.digit_count; i += 1) {
5649 uint64_t digit = bigint_ptr(&const_val->data.x_bigint)[i];
5650 result ^= ((uint32_t)(digit >> 32)) ^ (uint32_t)(result);
5651 }
5652 return result;
5653 }
5690 return hash_combine_bigint(hash_val, &const_val->data.x_bigint);
56545691 case ZigTypeIdEnumLiteral:
5655 return buf_hash(const_val->data.x_enum_literal) * (uint32_t)2691276464;
5692 return hash_combine_buf(hash_val, const_val->data.x_enum_literal);
56565693 case ZigTypeIdEnum:
5657 {
5658 uint32_t result = 31643936;
5659 for (size_t i = 0; i < const_val->data.x_enum_tag.digit_count; i += 1) {
5660 uint64_t digit = bigint_ptr(&const_val->data.x_enum_tag)[i];
5661 result ^= ((uint32_t)(digit >> 32)) ^ (uint32_t)(result);
5662 }
5663 return result;
5664 }
5694 return hash_combine_bigint(hash_val, &const_val->data.x_enum_tag);
56655695 case ZigTypeIdFloat:
5696 hash_val = hash_combine(hash_val, &const_val->type->data.floating.bit_count);
56665697 switch (const_val->type->data.floating.bit_count) {
5667 case 16:
5668 {
5669 uint16_t result;
5670 static_assert(sizeof(result) == sizeof(const_val->data.x_f16), "");
5671 memcpy(&result, &const_val->data.x_f16, sizeof(result));
5672 return result * 65537u;
5673 }
5674 case 32:
5675 {
5676 uint32_t result;
5677 memcpy(&result, &const_val->data.x_f32, 4);
5678 return result ^ 4084870010;
5679 }
5680 case 64:
5681 {
5682 uint32_t ints[2];
5683 memcpy(&ints[0], &const_val->data.x_f64, 8);
5684 return ints[0] ^ ints[1] ^ 0x22ed43c6;
5685 }
5686 case 128:
5687 {
5688 uint32_t ints[4];
5689 memcpy(&ints[0], &const_val->data.x_f128, 16);
5690 return ints[0] ^ ints[1] ^ ints[2] ^ ints[3] ^ 0xb5ffef27;
5691 }
5692 default:
5693 zig_unreachable();
5698 case 16: return hash_combine(hash_val, &const_val->data.x_f16);
5699 case 32: return hash_combine(hash_val, &const_val->data.x_f32);
5700 case 64: return hash_combine(hash_val, &const_val->data.x_f64);
5701 case 128: return hash_combine(hash_val, &const_val->data.x_f128);
5702 default: zig_unreachable();
56945703 }
56955704 case ZigTypeIdComptimeFloat:
5696 {
5697 float128_t f128 = bigfloat_to_f128(&const_val->data.x_bigfloat);
5698 uint32_t ints[4];
5699 memcpy(&ints[0], &f128, 16);
5700 return ints[0] ^ ints[1] ^ ints[2] ^ ints[3] ^ 0xed8b3dfb;
5701 }
5705 return hash_combine(hash_val, &const_val->data.x_bigfloat.value);
57025706 case ZigTypeIdFn:
57035707 assert(const_val->data.x_ptr.mut == ConstPtrMutComptimeConst);
57045708 assert(const_val->data.x_ptr.special == ConstPtrSpecialFunction);
5705 return 3677364617 ^ hash_ptr(const_val->data.x_ptr.data.fn.fn_entry);
5709 return hash_combine(hash_val, &const_val->data.x_ptr.data.fn.fn_entry);
57065710 case ZigTypeIdPointer:
5707 return hash_const_val_ptr(const_val);
5711 return hash_combine_const_val_ptr(hash_val, const_val);
5712 case ZigTypeIdVoid:
57085713 case ZigTypeIdUndefined:
5709 return 162837799;
57105714 case ZigTypeIdNull:
5711 return 844854567;
5715 return hash_val;
57125716 case ZigTypeIdArray:
5713 // TODO better hashing algorithm
5714 return 1166190605;
5715 case ZigTypeIdStruct:
5716 // TODO better hashing algorithm
5717 return 1532530855;
5718 case ZigTypeIdUnion:
5719 // TODO better hashing algorithm
5720 return 2709806591;
5717 return hash_combine_const_val_array(hash_val, const_val, const_val->type->data.array.len);
5718 case ZigTypeIdStruct: {
5719 size_t field_count = const_val->type->data.structure.src_field_count;
5720 for (size_t i = 0; i < field_count; i += 1) {
5721 ZigValue *field = const_val->data.x_struct.fields[i];
5722 hash_val = hash_combine_const_val(hash_val, field);
5723 }
5724 return hash_val;
5725 }
5726 case ZigTypeIdUnion: {
5727 ConstUnionValue *union_value = &const_val->data.x_union;
5728 hash_val = hash_combine_bigint(hash_val, &union_value->tag);
5729 return hash_combine_const_val(hash_val, union_value->payload);
5730 }
57215731 case ZigTypeIdOptional:
57225732 if (get_src_ptr_type(const_val->type) != nullptr) {
5723 return hash_const_val_ptr(const_val) * (uint32_t)1992916303;
5733 char tag = 1;
5734 hash_val = hash_combine(hash_val, &tag);
5735 return hash_combine_const_val_ptr(hash_val, const_val);
57245736 } else if (const_val->type->data.maybe.child_type->id == ZigTypeIdErrorSet) {
5725 return hash_const_val_error_set(const_val) * (uint32_t)3147031929;
5737 char tag = 2;
5738 hash_val = hash_combine(hash_val, &tag);
5739 return hash_combine_const_val_error_set(hash_val, const_val);
5740 } else if (const_val->data.x_optional) {
5741 char tag = 3;
5742 hash_val = hash_combine(hash_val, &tag);
5743 return hash_combine_const_val(hash_val, const_val->data.x_optional);
57265744 } else {
5727 if (const_val->data.x_optional) {
5728 return hash_const_val(const_val->data.x_optional) * (uint32_t)1992916303;
5729 } else {
5730 return 4016830364;
5731 }
5745 char tag = 4;
5746 hash_val = hash_combine(hash_val, &tag);
5747 return hash_val;
57325748 }
5733 case ZigTypeIdErrorUnion:
5734 // TODO better hashing algorithm
5735 return 3415065496;
5749 case ZigTypeIdErrorUnion: {
5750 bool is_err = const_val->data.x_err_union.error_set->data.x_err_set != nullptr;
5751 hash_val = hash_combine(hash_val, &is_err);
5752 if (is_err) {
5753 hash_val = hash_combine_const_val(hash_val, const_val->data.x_err_union.error_set);
5754 } else {
5755 hash_val = hash_combine_const_val(hash_val, const_val->data.x_err_union.payload);
5756 }
5757 return hash_val;
5758 }
57365759 case ZigTypeIdErrorSet:
5737 return hash_const_val_error_set(const_val);
5760 return hash_combine_const_val_error_set(hash_val, const_val);
57385761 case ZigTypeIdVector:
5739 // TODO better hashing algorithm
5740 return 3647867726;
5762 return hash_combine_const_val_array(hash_val, const_val, const_val->type->data.vector.len);
57415763 case ZigTypeIdFnFrame:
57425764 // TODO better hashing algorithm
5743 return 675741936;
5765 return hash_val;
57445766 case ZigTypeIdAnyFrame:
57455767 // TODO better hashing algorithm
5746 return 3747294894;
5768 return hash_val;
57475769 case ZigTypeIdBoundFn: {
57485770 assert(const_val->data.x_bound_fn.fn != nullptr);
5749 return 3677364617 ^ hash_ptr(const_val->data.x_bound_fn.fn);
5771 return hash_combine(hash_val, &const_val->data.x_bound_fn.fn);
57505772 }
57515773 case ZigTypeIdInvalid:
57525774 case ZigTypeIdUnreachable:
......@@ -5754,15 +5776,18 @@ static uint32_t hash_const_val(ZigValue *const_val) {
57545776 }
57555777 zig_unreachable();
57565778}
5779static uint32_t hash_const_val(ZigValue *const_val) {
5780 return hash_combine_const_val(HASH_INIT, const_val);
5781}
57575782
57585783uint32_t generic_fn_type_id_hash(GenericFnTypeId *id) {
5759 uint32_t result = 0;
5760 result += hash_ptr(id->fn_entry);
5784 uint32_t result = HASH_INIT;
5785 result = hash_combine(result, &id->fn_entry);
57615786 for (size_t i = 0; i < id->param_count; i += 1) {
57625787 ZigValue *generic_param = &id->params[i];
57635788 if (generic_param->special != ConstValSpecialRuntime) {
5764 result += hash_const_val(generic_param);
5765 result += hash_ptr(generic_param->type);
5789 result = hash_combine_const_val(result, generic_param);
5790 result = hash_combine(result, &generic_param->type);
57665791 }
57675792 }
57685793 return result;
......@@ -5957,15 +5982,15 @@ bool fn_eval_cacheable(Scope *scope, ZigType *return_type) {
59575982}
59585983
59595984uint32_t fn_eval_hash(Scope* scope) {
5960 uint32_t result = 0;
5985 uint32_t hash = HASH_INIT;
59615986 while (scope) {
59625987 if (scope->id == ScopeIdVarDecl) {
59635988 ScopeVarDecl *var_scope = (ScopeVarDecl *)scope;
5964 result += hash_const_val(var_scope->var->const_value);
5989 hash = hash_combine_const_val(hash, var_scope->var->const_value);
59655990 } else if (scope->id == ScopeIdFnDef) {
59665991 ScopeFnDef *fn_scope = (ScopeFnDef *)scope;
5967 result += hash_ptr(fn_scope->fn_entry);
5968 return result;
5992 hash = hash_combine(hash, &fn_scope->fn_entry);
5993 return hash;
59695994 } else {
59705995 zig_unreachable();
59715996 }
......@@ -7260,6 +7285,8 @@ bool const_values_equal(CodeGen *g, ZigValue *a, ZigValue *b) {
72607285 case ZigTypeIdMetaType:
72617286 return a->data.x_type == b->data.x_type;
72627287 case ZigTypeIdVoid:
7288 case ZigTypeIdUndefined:
7289 case ZigTypeIdNull:
72637290 return true;
72647291 case ZigTypeIdErrorSet:
72657292 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) {
72927319 case ZigTypeIdVector:
72937320 assert(a->type->data.vector.len == b->type->data.vector.len);
72947321 return const_values_equal_array(g, a, b, a->type->data.vector.len);
7295 case ZigTypeIdArray: {
7322 case ZigTypeIdArray:
72967323 assert(a->type->data.array.len == b->type->data.array.len);
72977324 return const_values_equal_array(g, a, b, a->type->data.array.len);
7298 }
72997325 case ZigTypeIdStruct:
73007326 for (size_t i = 0; i < a->type->data.structure.src_field_count; i += 1) {
73017327 ZigValue *field_a = a->data.x_struct.fields[i];
......@@ -7308,10 +7334,6 @@ bool const_values_equal(CodeGen *g, ZigValue *a, ZigValue *b) {
73087334 zig_panic("TODO: const_values_equal ZigTypeIdFnFrame");
73097335 case ZigTypeIdAnyFrame:
73107336 zig_panic("TODO: const_values_equal ZigTypeIdAnyFrame");
7311 case ZigTypeIdUndefined:
7312 zig_panic("TODO: const_values_equal ZigTypeIdUndefined");
7313 case ZigTypeIdNull:
7314 zig_panic("TODO: const_values_equal ZigTypeIdNull");
73157337 case ZigTypeIdOptional:
73167338 if (get_src_ptr_type(a->type) != nullptr)
73177339 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) {
77197741}
77207742
77217743uint32_t type_id_hash(TypeId x) {
7744 uint32_t hash = hash_combine(HASH_INIT, &x.id);
77227745 switch (x.id) {
77237746 case ZigTypeIdInvalid:
77247747 case ZigTypeIdOpaque:
......@@ -7743,27 +7766,38 @@ uint32_t type_id_hash(TypeId x) {
77437766 case ZigTypeIdAnyFrame:
77447767 zig_unreachable();
77457768 case ZigTypeIdErrorUnion:
7746 return hash_ptr(x.data.error_union.err_set_type) ^ hash_ptr(x.data.error_union.payload_type);
7769 hash = hash_combine(hash, &x.data.error_union.err_set_type);
7770 hash = hash_combine(hash, &x.data.error_union.payload_type);
7771 return hash;
77477772 case ZigTypeIdPointer:
7748 return hash_ptr(x.data.pointer.child_type) +
7749 (uint32_t)x.data.pointer.ptr_len * 1120226602u +
7750 (x.data.pointer.is_const ? (uint32_t)2749109194 : (uint32_t)4047371087) +
7751 (x.data.pointer.is_volatile ? (uint32_t)536730450 : (uint32_t)1685612214) +
7752 (x.data.pointer.allow_zero ? (uint32_t)3324284834 : (uint32_t)3584904923) +
7753 (((uint32_t)x.data.pointer.alignment) ^ (uint32_t)0x777fbe0e) +
7754 (((uint32_t)x.data.pointer.bit_offset_in_host) ^ (uint32_t)2639019452) +
7755 (((uint32_t)x.data.pointer.vector_index) ^ (uint32_t)0x19199716) +
7756 (((uint32_t)x.data.pointer.host_int_bytes) ^ (uint32_t)529908881) *
7757 (x.data.pointer.sentinel ? hash_const_val(x.data.pointer.sentinel) : (uint32_t)2955491856);
7773 hash = hash_combine(hash, &x.data.pointer.child_type);
7774 hash = hash_combine(hash, &x.data.pointer.ptr_len);
7775 hash = hash_combine(hash, &x.data.pointer.is_const);
7776 hash = hash_combine(hash, &x.data.pointer.is_volatile);
7777 hash = hash_combine(hash, &x.data.pointer.allow_zero);
7778 hash = hash_combine(hash, &x.data.pointer.alignment);
7779 hash = hash_combine(hash, &x.data.pointer.bit_offset_in_host);
7780 hash = hash_combine(hash, &x.data.pointer.vector_index);
7781 hash = hash_combine(hash, &x.data.pointer.host_int_bytes);
7782 if (x.data.pointer.sentinel != nullptr) {
7783 hash = hash_combine_const_val(hash, x.data.pointer.sentinel);
7784 }
7785 return hash;
77587786 case ZigTypeIdArray:
7759 return hash_ptr(x.data.array.child_type) *
7760 ((uint32_t)x.data.array.size ^ (uint32_t)2122979968) *
7761 (x.data.array.sentinel ? hash_const_val(x.data.array.sentinel) : (uint32_t)1927201585);
7787 hash = hash_combine(hash, &x.data.array.child_type);
7788 hash = hash_combine(hash, &x.data.array.size);
7789 if (x.data.array.sentinel != nullptr) {
7790 hash = hash_combine_const_val(hash, x.data.array.sentinel);
7791 }
7792 return hash;
77627793 case ZigTypeIdInt:
7763 return (x.data.integer.is_signed ? (uint32_t)2652528194 : (uint32_t)163929201) +
7764 (((uint32_t)x.data.integer.bit_count) ^ (uint32_t)2998081557);
7794 hash = hash_combine(hash, &x.data.integer.is_signed);
7795 hash = hash_combine(hash, &x.data.integer.bit_count);
7796 return hash;
77657797 case ZigTypeIdVector:
7766 return hash_ptr(x.data.vector.elem_type) * (x.data.vector.len * 526582681);
7798 hash = hash_combine(hash, &x.data.vector.elem_type);
7799 hash = hash_combine(hash, &x.data.vector.len);
7800 return hash;
77677801 }
77687802 zig_unreachable();
77697803}
......@@ -8155,7 +8189,7 @@ ZigType *get_align_amt_type(CodeGen *g) {
81558189}
81568190
81578191uint32_t type_ptr_hash(const ZigType *ptr) {
8158 return hash_ptr((void*)ptr);
8192 return hash_combine(HASH_INIT, &ptr);
81598193}
81608194
81618195bool type_ptr_eql(const ZigType *a, const ZigType *b) {
......@@ -8163,7 +8197,7 @@ bool type_ptr_eql(const ZigType *a, const ZigType *b) {
81638197}
81648198
81658199uint32_t pkg_ptr_hash(const ZigPackage *ptr) {
8166 return hash_ptr((void*)ptr);
8200 return hash_combine(HASH_INIT, &ptr);
81678201}
81688202
81698203bool pkg_ptr_eql(const ZigPackage *a, const ZigPackage *b) {
......@@ -8171,7 +8205,7 @@ bool pkg_ptr_eql(const ZigPackage *a, const ZigPackage *b) {
81718205}
81728206
81738207uint32_t tld_ptr_hash(const Tld *ptr) {
8174 return hash_ptr((void*)ptr);
8208 return hash_combine(HASH_INIT, &ptr);
81758209}
81768210
81778211bool tld_ptr_eql(const Tld *a, const Tld *b) {
......@@ -8179,7 +8213,7 @@ bool tld_ptr_eql(const Tld *a, const Tld *b) {
81798213}
81808214
81818215uint32_t node_ptr_hash(const AstNode *ptr) {
8182 return hash_ptr((void*)ptr);
8216 return hash_combine(HASH_INIT, &ptr);
81838217}
81848218
81858219bool node_ptr_eql(const AstNode *a, const AstNode *b) {
......@@ -8187,7 +8221,7 @@ bool node_ptr_eql(const AstNode *a, const AstNode *b) {
81878221}
81888222
81898223uint32_t fn_ptr_hash(const ZigFn *ptr) {
8190 return hash_ptr((void*)ptr);
8224 return hash_combine(HASH_INIT, &ptr);
81918225}
81928226
81938227bool fn_ptr_eql(const ZigFn *a, const ZigFn *b) {
......@@ -8195,7 +8229,7 @@ bool fn_ptr_eql(const ZigFn *a, const ZigFn *b) {
81958229}
81968230
81978231uint32_t err_ptr_hash(const ErrorTableEntry *ptr) {
8198 return hash_ptr((void*)ptr);
8232 return hash_combine(HASH_INIT, &ptr);
81998233}
82008234
82018235bool err_ptr_eql(const ErrorTableEntry *a, const ErrorTableEntry *b) {
src/stage1/bigint.cpp+7
......@@ -1691,6 +1691,13 @@ uint32_t bigint_as_u32(const BigInt *bigint) {
16911691 return value32;
16921692}
16931693
1694uint8_t bigint_as_u8(const BigInt *bigint) {
1695 uint64_t value64 = bigint_as_unsigned(bigint);
1696 uint8_t value8 = (uint8_t)value64;
1697 assert (value64 == value8);
1698 return value8;
1699}
1700
16941701size_t bigint_as_usize(const BigInt *bigint) {
16951702 uint64_t value64 = bigint_as_unsigned(bigint);
16961703 size_t valueUsize = (size_t)value64;
src/stage1/bigint.hpp+1
......@@ -39,6 +39,7 @@ void bigint_deinit(BigInt *bi);
3939// panics if number won't fit
4040uint64_t bigint_as_u64(const BigInt *bigint);
4141uint32_t bigint_as_u32(const BigInt *bigint);
42uint8_t bigint_as_u8(const BigInt *bigint);
4243size_t bigint_as_usize(const BigInt *bigint);
4344
4445int64_t bigint_as_signed(const BigInt *bigint);
src/stage1/buffer.hpp+1-1
......@@ -26,7 +26,7 @@ Buf *buf_sprintf(const char *format, ...)
2626 ATTRIBUTE_PRINTF(1, 2);
2727Buf *buf_vprintf(const char *format, va_list ap);
2828
29static inline size_t buf_len(Buf *buf) {
29static inline size_t buf_len(const Buf *buf) {
3030 assert(buf);
3131 assert(buf->list.length);
3232 return buf->list.length - 1;
src/stage1/ir.cpp+20-13
......@@ -272,8 +272,8 @@ static bool value_cmp_numeric_val_all(ZigValue *left, Cmp predicate, ZigValue *r
272272static void memoize_field_init_val(CodeGen *codegen, ZigType *container_type, TypeStructField *field);
273273static void value_to_bigfloat(BigFloat *out, ZigValue *val);
274274
275static Error ir_resolve_lazy_recurse(AstNode *source_node, ZigValue *val);
276static Error ir_resolve_lazy_recurse_array(AstNode *source_node, ZigValue *val, size_t len);
275static Error ir_resolve_lazy_recurse(IrAnalyze *ira, AstNode *source_node, ZigValue *val);
276static Error ir_resolve_lazy_recurse_array(IrAnalyze *ira, AstNode *source_node, ZigValue *val, size_t len);
277277
278278
279279static 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
1294512945 for (size_t i = 0; i < generic_id->param_count; i += 1) {
1294612946 ZigValue *generic_param = &generic_id->params[i];
1294712947 if (generic_param->special != ConstValSpecialRuntime) {
12948 if ((err = ir_resolve_lazy_recurse(source_node, generic_param))) {
12948 if ((err = ir_resolve_lazy_recurse(ira, source_node, generic_param))) {
1294912949 return ira->codegen->invalid_inst_gen;
1295012950 }
1295112951 }
......@@ -25531,7 +25531,7 @@ static Error ir_resolve_lazy_raw(AstNode *source_node, ZigValue *val) {
2553125531 zig_unreachable();
2553225532}
2553325533
25534static Error ir_resolve_lazy_recurse_array(AstNode *source_node, ZigValue *val, size_t len) {
25534static Error ir_resolve_lazy_recurse_array(IrAnalyze *ira, AstNode *source_node, ZigValue *val, size_t len) {
2553525535 Error err;
2553625536 switch (val->data.x_array.special) {
2553725537 case ConstArraySpecialUndef:
......@@ -25543,17 +25543,24 @@ static Error ir_resolve_lazy_recurse_array(AstNode *source_node, ZigValue *val,
2554325543 ZigValue *elems = val->data.x_array.data.s_none.elements;
2554425544
2554525545 for (size_t i = 0; i < len; i += 1) {
25546 if ((err = ir_resolve_lazy_recurse(source_node, &elems[i])))
25546 if ((err = ir_resolve_lazy_recurse(ira, source_node, &elems[i])))
2554725547 return err;
2554825548 }
2554925549
2555025550 return ErrorNone;
2555125551}
2555225552
25553static Error ir_resolve_lazy_recurse(AstNode *source_node, ZigValue *val) {
25553static Error ir_resolve_lazy_recurse(IrAnalyze *ira, AstNode *source_node, ZigValue *val) {
2555425554 Error err;
2555525555 if ((err = ir_resolve_lazy_raw(source_node, val)))
2555625556 return err;
25557 if (val->special == ConstValSpecialRuntime) {
25558 // This shouldn't be possible, it indicates an ICE.
25559 // NO_COMMIT
25560 ir_add_error_node(ira, source_node,
25561 buf_sprintf("This is a bug in the Zig compiler. Runtime value found in comptime known parameter."));
25562 return ErrorSemanticAnalyzeFail;
25563 }
2555725564 if (val->special != ConstValSpecialStatic)
2555825565 return ErrorNone;
2555925566 switch (val->type->id) {
......@@ -25581,16 +25588,16 @@ static Error ir_resolve_lazy_recurse(AstNode *source_node, ZigValue *val) {
2558125588 zig_panic("TODO: ir_resolve_lazy_recurse ZigTypeIdFnFrame");
2558225589 case ZigTypeIdUnion: {
2558325590 ConstUnionValue *union_val = &val->data.x_union;
25584 return ir_resolve_lazy_recurse(source_node, union_val->payload);
25591 return ir_resolve_lazy_recurse(ira, source_node, union_val->payload);
2558525592 }
2558625593 case ZigTypeIdVector:
25587 return ir_resolve_lazy_recurse_array(source_node, val, val->type->data.vector.len);
25594 return ir_resolve_lazy_recurse_array(ira, source_node, val, val->type->data.vector.len);
2558825595 case ZigTypeIdArray:
25589 return ir_resolve_lazy_recurse_array(source_node, val, val->type->data.array.len);
25596 return ir_resolve_lazy_recurse_array(ira, source_node, val, val->type->data.array.len);
2559025597 case ZigTypeIdStruct:
2559125598 for (size_t i = 0; i < val->type->data.structure.src_field_count; i += 1) {
2559225599 ZigValue *field = val->data.x_struct.fields[i];
25593 if ((err = ir_resolve_lazy_recurse(source_node, field)))
25600 if ((err = ir_resolve_lazy_recurse(ira, source_node, field)))
2559425601 return err;
2559525602 }
2559625603 return ErrorNone;
......@@ -25600,13 +25607,13 @@ static Error ir_resolve_lazy_recurse(AstNode *source_node, ZigValue *val) {
2560025607 if (val->data.x_optional == nullptr)
2560125608 return ErrorNone;
2560225609
25603 return ir_resolve_lazy_recurse(source_node, val->data.x_optional);
25610 return ir_resolve_lazy_recurse(ira, source_node, val->data.x_optional);
2560425611 case ZigTypeIdErrorUnion: {
2560525612 bool is_err = val->data.x_err_union.error_set->data.x_err_set != nullptr;
2560625613 if (is_err) {
25607 return ir_resolve_lazy_recurse(source_node, val->data.x_err_union.error_set);
25614 return ir_resolve_lazy_recurse(ira, source_node, val->data.x_err_union.error_set);
2560825615 } else {
25609 return ir_resolve_lazy_recurse(source_node, val->data.x_err_union.payload);
25616 return ir_resolve_lazy_recurse(ira, source_node, val->data.x_err_union.payload);
2561025617 }
2561125618 }
2561225619 }
src/stage1/util.cpp-23
......@@ -21,29 +21,6 @@ void zig_panic(const char *format, ...) {
2121 abort();
2222}
2323
24uint32_t int_hash(int i) {
25 return (uint32_t)(i % UINT32_MAX);
26}
27bool int_eq(int a, int b) {
28 return a == b;
29}
30
31uint32_t uint64_hash(uint64_t i) {
32 return (uint32_t)(i % UINT32_MAX);
33}
34
35bool uint64_eq(uint64_t a, uint64_t b) {
36 return a == b;
37}
38
39uint32_t ptr_hash(const void *ptr) {
40 return (uint32_t)(((uintptr_t)ptr) % UINT32_MAX);
41}
42
43bool ptr_eq(const void *a, const void *b) {
44 return a == b;
45}
46
4724// Ported from std/mem.zig.
4825bool SplitIterator_isSplitByte(SplitIterator *self, uint8_t byte) {
4926 for (size_t i = 0; i < self->split_bytes.len; i += 1) {
src/stage1/util.hpp-7
......@@ -129,13 +129,6 @@ static inline uint64_t round_to_next_power_of_2(uint64_t x) {
129129 return x + 1;
130130}
131131
132uint32_t int_hash(int i);
133bool int_eq(int a, int b);
134uint32_t uint64_hash(uint64_t i);
135bool uint64_eq(uint64_t a, uint64_t b);
136uint32_t ptr_hash(const void *ptr);
137bool ptr_eq(const void *a, const void *b);
138
139132static inline uint8_t log2_u64(uint64_t x) {
140133 return (63 - clzll(x));
141134}