From 1456bfa1c619b76a7422ef6be68655d98544d764 Mon Sep 17 00:00:00 2001 From: Techatrix <19954306+Techatrix@users.noreply.github.com> Date: Sat, 14 Jan 2023 19:17:06 +0100 Subject: [PATCH] refactor InternPool KeyAdapter --- src/ComptimeInterpreter.zig | 4 +- src/InternPool.zig | 383 ++++++++++++++++++------------------ 2 files changed, 191 insertions(+), 196 deletions(-) diff --git a/src/ComptimeInterpreter.zig b/src/ComptimeInterpreter.zig index b2a0107..ad56b17 100644 --- a/src/ComptimeInterpreter.zig +++ b/src/ComptimeInterpreter.zig @@ -705,7 +705,7 @@ pub fn interpret( const value_namespace = interpreter.ip.indexToKey(value.val).getNamespace(); if (value_namespace == .none) return error.InvalidBuiltin; - const name = interpreter.ip.indexToKey(field_name.val).bytes.data; // TODO add checks + const name = interpreter.ip.indexToKey(field_name.val).bytes; // TODO add checks const decls = interpreter.namespaces.items(.decls)[@enumToInt(value_namespace)]; const has_decl = decls.contains(name); @@ -764,7 +764,7 @@ pub fn interpret( .interpreter = interpreter, .node_idx = node_idx, .ty = string_literal_type, - .val = try interpreter.ip.get(interpreter.allocator, IPKey{ .bytes = .{ .data = str } }), // TODO + .val = try interpreter.ip.get(interpreter.allocator, IPKey{ .bytes = str }), // TODO }; // TODO: Add type casting, sentinel diff --git a/src/InternPool.zig b/src/InternPool.zig index 33dcd8a..e9b0793 100644 --- a/src/InternPool.zig +++ b/src/InternPool.zig @@ -10,26 +10,12 @@ const builtin = @import("builtin"); const Allocator = std.mem.Allocator; const assert = std.debug.assert; -const KeyAdapter = struct { - intern_pool: *const InternPool, - - pub fn eql(ctx: @This(), a: Key, b_void: void, b_map_index: usize) bool { - _ = b_void; - return ctx.intern_pool.indexToKey(@intToEnum(Index, b_map_index)).eql(a); - } - - pub fn hash(ctx: @This(), a: Key) u32 { - _ = ctx; - return a.hash(); - } -}; - -pub const Int = struct { +pub const Int = packed struct { signedness: std.builtin.Signedness, bits: u16, }; -pub const Pointer = struct { +pub const Pointer = packed struct { elem_type: Index, sentinel: Index = .none, alignment: u16 = 0, @@ -40,7 +26,7 @@ pub const Pointer = struct { address_space: std.builtin.AddressSpace = .generic, }; -pub const Array = struct { +pub const Array = packed struct { // TODO support big int len: u32, child: Index, @@ -62,19 +48,15 @@ pub const Struct = struct { }; }; -pub const Optional = struct { +pub const Optional = packed struct { payload_type: Index, }; -pub const ErrorUnion = struct { +pub const ErrorUnion = packed struct { error_set_type: Index, payload_type: Index, }; -// pub const Error = struct { -// name: []const u8, -// }; - pub const ErrorSet = struct { /// must be sorted names: []const []const u8, @@ -104,11 +86,11 @@ pub const Fn = struct { return_type: Index, args: []const Param, - pub const Param = struct { + pub const Param = packed struct { + arg_type: Index, is_comptime: bool = false, is_generic: bool = false, is_noalias: bool = false, - arg_type: Index, }; }; @@ -127,31 +109,27 @@ pub const Union = struct { pub const Tuple = struct { types: []const Index, - /// unreachable_value elements are used to indicate runtime-known. + /// Index.none elements are used to indicate runtime-known. values: []const Index, }; -pub const Vector = struct { +pub const Vector = packed struct { // TODO support big int len: u32, child: Index, }; -pub const AnyFrame = struct { +pub const AnyFrame = packed struct { child: Index, }; pub const BigInt = std.math.big.int.Const; -pub const Bytes = struct { - data: []const u8, -}; +pub const Bytes = []const u8; -pub const Aggregate = struct { - data: []const Index, -}; +pub const Aggregate = []const Index; -pub const UnionValue = struct { +pub const UnionValue = packed struct { tag: Index, val: Index, }; @@ -165,14 +143,13 @@ pub const Key = union(enum) { struct_type: Struct, optional_type: Optional, error_union_type: ErrorUnion, - // error_type: Error, error_set_type: ErrorSet, enum_type: Enum, function_type: Fn, union_type: Union, tuple_type: Tuple, vector_type: Vector, - anyframe_t_type: AnyFrame, + anyframe_type: AnyFrame, int_u64_value: u64, int_i64_value: i64, @@ -182,10 +159,8 @@ pub const Key = union(enum) { float_64_value: f64, float_80_value: f80, float_128_value: f128, - // type_value: Index, bytes: Bytes, - // one_pointer: Index, aggregate: Aggregate, union_value: UnionValue, @@ -193,98 +168,10 @@ pub const Key = union(enum) { // error // error union - pub fn hash(key: Key) u32 { - var hasher = std.hash.Wyhash.init(0); - std.hash.autoHash(&hasher, std.meta.activeTag(key)); - switch (key) { - .float_16_value => |f| std.hash.autoHash(&hasher, @bitCast(u16, f)), - .float_32_value => |f| std.hash.autoHash(&hasher, @bitCast(u32, f)), - .float_64_value => |f| std.hash.autoHash(&hasher, @bitCast(u64, f)), - .float_80_value => |f| std.hash.autoHash(&hasher, @bitCast(u80, f)), - .float_128_value => |f| std.hash.autoHash(&hasher, @bitCast(u128, f)), - inline else => |info| std.hash.autoHashStrat(&hasher, info, .Deep), // TODO sad stage1 noises :( - } - return @truncate(u32, hasher.final()); - } - - pub fn eql(a: Key, b: Key) bool { - const KeyTag = std.meta.Tag(Key); - const a_tag: KeyTag = a; - const b_tag: KeyTag = b; - if (a_tag != b_tag) return false; - return switch (a) { - .struct_type => |struct_info| { - if (struct_info.layout != b.struct_type.layout) return false; - if (struct_info.fields.len != b.struct_type.fields.len) return false; - for (struct_info.fields) |field, i| { - if (!std.meta.eql(field, b.struct_type.fields[i])) return false; - } - return true; - }, - // .error_type => |error_info| std.mem.eql(u8, error_info.name, b.error_type.name), - .error_set_type => |error_set_info| { - if (error_set_info.names.len != b.error_set_type.names.len) return false; - for (error_set_info.names) |a_name, i| { - const b_name = b.error_set_type.names[i]; - if (!std.mem.eql(u8, a_name, b_name)) return false; - } - return true; - }, - .enum_type => |enum_info| { - if (enum_info.tag_type != b.enum_type.tag_type) return false; - if (enum_info.tag_type_infered != b.enum_type.tag_type_infered) return false; - if (enum_info.fields.len != b.enum_type.fields.len) return false; - @panic("TODO: implement field equality check"); - }, - .function_type => |function_info| { - if (function_info.calling_convention != b.function_type.calling_convention) return false; - if (function_info.alignment != b.function_type.alignment) return false; - if (function_info.is_generic != b.function_type.is_generic) return false; - if (function_info.is_var_args != b.function_type.is_var_args) return false; - if (function_info.return_type != b.function_type.return_type) return false; - if (function_info.args.len != b.function_type.args.len) return false; - - for (function_info.args) |arg, i| { - if (!std.meta.eql(arg, b.function_type.args[i])) return false; - } - return true; - }, - .union_type => |union_info| { - if (union_info.tag_type != b.union_type.tag_type) return false; - if (union_info.layout != b.union_type.layout) return false; - if (union_info.fields.len != b.union_type.fields.len) return false; - for (union_info.fields) |field, i| { - if (!std.meta.eql(field, b.union_type.fields[i])) return false; - } - return true; - }, - .tuple_type => |tuple_info| { - std.debug.assert(tuple_info.types.len == tuple_info.values.len); - std.debug.assert(b.tuple_type.types.len == b.tuple_type.values.len); - if (tuple_info.types.len != b.tuple_type.types.len) return false; - for (tuple_info.types) |ty, i| { - if (ty != b.tuple_type.types[i]) return false; - } - for (tuple_info.values) |val, i| { - if (val != b.tuple_type.values[i]) return false; - } - return true; - }, - .bytes => |bytes| std.mem.eql(u8, bytes.data, b.bytes.data), - .aggregate => |aggregate| { - if (aggregate.data.len != b.aggregate.data.len) return false; - for (aggregate.data) |ty, i| { - if (ty != b.aggregate.data[i]) return false; - } - return true; - }, - else => std.meta.eql(a, b), - }; - } - pub fn tag(key: Key) Tag { return switch (key) { .simple => .simple, + .int_type => |int_info| switch (int_info.signedness) { .signed => .type_int_signed, .unsigned => .type_int_unsigned, @@ -294,14 +181,13 @@ pub const Key = union(enum) { .struct_type => .type_struct, .optional_type => .type_optional, .error_union_type => .type_error_union, - // .error_type => .type_error, .error_set_type => .type_error_set, .enum_type => .type_enum, .function_type => .type_function, .union_type => .type_union, .tuple_type => .type_tuple, .vector_type => .type_vector, - .anyframe_t_type => .type_anyframe_t, + .anyframe_type => .type_anyframe, .int_u64_value => |int| if (int <= std.math.maxInt(u32)) .int_u32 else .int_u64, .int_i64_value => |int| if (std.math.maxInt(i32) <= int and int <= std.math.maxInt(i32)) .int_i32 else .int_i64, @@ -311,10 +197,8 @@ pub const Key = union(enum) { .float_64_value => .float_f64, .float_80_value => .float_f80, .float_128_value => .float_f128, - // .type_value => .type, .bytes => .bytes, - // .one_pointer => .one_pointer, .aggregate => .aggregate, .union_value => .union_value, }; @@ -378,7 +262,7 @@ pub const Key = union(enum) { .union_type => .Union, .tuple_type => .Struct, // TODO this correct? .vector_type => .Vector, - .anyframe_t_type => .AnyFrame, + .anyframe_type => .AnyFrame, .int_u64_value, .int_i64_value, @@ -500,7 +384,7 @@ pub const Key = union(enum) { .array_type => |array_info| array_info.child, .optional_type => |optional_info| optional_info.payload_type, .vector_type => |vector_info| vector_info.child, - .anyframe_t_type => |anyframe_t_info| anyframe_t_info.child, + .anyframe_type => |anyframe_info| anyframe_info.child, else => unreachable, }; } @@ -717,7 +601,7 @@ pub const Key = union(enum) { vector_info.child.fmtType(ip), }); }, - .anyframe_t_type => |anyframe_info| { + .anyframe_type => |anyframe_info| { try writer.writeAll("anyframe->"); try printType(anyframe_info.child, ip, writer); }, @@ -813,7 +697,7 @@ pub const Key = union(enum) { .union_type, .tuple_type, .vector_type, - .anyframe_t_type, + .anyframe_type, => unreachable, .int_u64_value => |int| try std.fmt.formatIntValue(int, "", .{}, writer), @@ -826,19 +710,19 @@ pub const Key = union(enum) { .float_128_value => |float| try writer.print("{d}", .{@floatCast(f64, float)}), // .type_value => |tty| tty.fmtType(ip), - .bytes => |data| try writer.print("\"{}\"", .{std.zig.fmtEscapes(data.data)}), + .bytes => |bytes| try writer.print("\"{}\"", .{std.zig.fmtEscapes(bytes)}), // .one_pointer => unreachable, .aggregate => |aggregate| { const struct_info = ip.indexToKey(ty).struct_type; - std.debug.assert(aggregate.data.len == struct_info.fields.len); + std.debug.assert(aggregate.len == struct_info.fields.len); try writer.writeAll(".{"); var i: u32 = 0; - while (i < aggregate.data.len) : (i += 1) { + while (i < aggregate.len) : (i += 1) { if (i != 0) try writer.writeAll(", "); try writer.print(".{s} = ", .{struct_info.fields[i].name}); - try printValue(aggregate.data[i], struct_info.fields[i].ty, ip, writer); + try printValue(aggregate[i], struct_info.fields[i].ty, ip, writer); } try writer.writeByte('}'); }, @@ -917,9 +801,6 @@ pub const Tag = enum(u8) { /// An error union type. /// data is payload to ErrorUnion. type_error_union, - /// An error type. - /// data is payload to Error. - type_error, /// An error set type. /// data is payload to ErrorSet. type_error_set, @@ -940,7 +821,7 @@ pub const Tag = enum(u8) { type_vector, /// An anyframe->T type. /// data is index to type - type_anyframe_t, + type_anyframe, /// An unsigned integer value that can be represented by u32. /// data is integer value @@ -975,16 +856,10 @@ pub const Tag = enum(u8) { /// A float value that can be represented by f128. /// data is payload to f128. float_f128, - // /// A type value. - // /// data is Index. - // type, /// A byte sequence value. /// data is payload to data begin and length. bytes, - // /// A single pointer value. - // /// data is index to value. - // one_pointer, /// A aggregate (struct) value. /// data is index to Aggregate. aggregate, @@ -1039,12 +914,12 @@ pub fn deinit(ip: *InternPool, gpa: Allocator) void { // TODO deinit fields } - pub fn indexToKey(ip: InternPool, index: Index) Key { const item = ip.items.get(@enumToInt(index)); const data = item.data; return switch (item.tag) { .simple => .{ .simple = @intToEnum(Simple, data) }, + .type_int_signed => .{ .int_type = .{ .signedness = .signed, .bits = @intCast(u16, data), @@ -1057,9 +932,8 @@ pub fn indexToKey(ip: InternPool, index: Index) Key { .type_array => .{ .array_type = ip.extraData(Array, data) }, .type_struct => .{ .struct_type = ip.extraData(Struct, data) }, .type_optional => .{ .optional_type = .{ .payload_type = @intToEnum(Index, data) } }, - .type_anyframe_t => .{ .anyframe_t_type = .{ .child = @intToEnum(Index, data) } }, + .type_anyframe => .{ .anyframe_type = .{ .child = @intToEnum(Index, data) } }, .type_error_union => .{ .error_union_type = ip.extraData(ErrorUnion, data) }, - // .type_error => .{ .error_type = ip.extraData(Error, data) }, .type_error_set => .{ .error_set_type = ip.extraData(ErrorSet, data) }, .type_enum => .{ .enum_type = ip.extraData(Enum, data) }, .type_function => .{ .function_type = ip.extraData(Fn, data) }, @@ -1071,59 +945,51 @@ pub fn indexToKey(ip: InternPool, index: Index) Key { .int_i32 => .{ .int_i64_value = @bitCast(i32, data) }, .int_u64 => .{ .int_u64_value = ip.extraData(u64, data) }, .int_i64 => .{ .int_i64_value = ip.extraData(i64, data) }, - .int_big_positive => unreachable, - .int_big_negative => unreachable, + .int_big_positive => .{ .int_big_value = .{ + .positive = true, + .limbs = ip.extraData([]const std.math.big.Limb, data), + } }, + .int_big_negative => .{ .int_big_value = .{ + .positive = true, + .limbs = ip.extraData([]const std.math.big.Limb, data), + } }, .float_f16 => .{ .float_16_value = @bitCast(f16, @intCast(u16, data)) }, .float_f32 => .{ .float_32_value = @bitCast(f32, data) }, .float_f64 => .{ .float_64_value = ip.extraData(f64, data) }, .float_f80 => .{ .float_80_value = ip.extraData(f80, data) }, .float_f128 => .{ .float_128_value = ip.extraData(f128, data) }, - // .type => .{ .type_value = @intToEnum(Index, data) }, - .bytes => unreachable, // TODO - // .one_pointer => .{ .one_pointer = @intToEnum(Index, data) }, - else => @panic("TODO"), + .bytes => .{ .bytes = ip.extraData([]const u8, data) }, + .aggregate => .{ .aggregate = ip.extraData(Aggregate, data) }, + .union_value => .{ .union_value = ip.extraData(UnionValue, data) }, }; } pub fn get(ip: *InternPool, gpa: Allocator, key: Key) Allocator.Error!Index { - const adapter: KeyAdapter = .{ .intern_pool = ip }; + const adapter: KeyAdapter = .{ .ip = ip }; const gop = try ip.map.getOrPutAdapted(gpa, key, adapter); if (gop.found_existing) return @intToEnum(Index, gop.index); - const item: Item = switch (key) { - .simple => |simple| .{ .tag = .simple, .data = @enumToInt(simple) }, - .int_type => |int_ty| .{ - .tag = switch (int_ty.signedness) { - .signed => .type_int_signed, - .unsigned => .type_int_unsigned, - }, - .data = int_ty.bits, - }, - .optional_type => |optional_ty| .{ .tag = .type_optional, .data = @enumToInt(optional_ty.payload_type) }, - .anyframe_t_type => |anyframe_t| .{ .tag = .type_anyframe_t, .data = @enumToInt(anyframe_t.child) }, - .int_u64_value => |int_val| if (int_val <= std.math.maxInt(u32)) .{ - .tag = .int_u32, - .data = @intCast(u32, int_val), - } else .{ - .tag = .int_u64, - .data = try ip.addExtra(gpa, int_val), - }, - .int_i64_value => |int_val| if (std.math.maxInt(i32) <= int_val and int_val <= std.math.maxInt(i32)) .{ - .tag = .int_i32, - .data = @bitCast(u32, @intCast(u32, int_val)), - } else .{ - .tag = .int_i64, - .data = try ip.addExtra(gpa, int_val), - }, - .float_16_value => |float_val| .{ .tag = .float_f16, .data = @bitCast(u16, float_val) }, - .float_32_value => |float_val| .{ .tag = .float_f32, .data = @bitCast(u32, float_val) }, - // .type_value => |ty| .{ .tag = .type, .data = @enumToInt(ty) }, - .bytes => unreachable, // TODO - // .one_pointer => |val| .{ .tag = .one_pointer, .data = @enumToInt(val) }, - inline else => |data| .{ .tag = key.tag(), .data = try ip.addExtra(gpa, data) }, // TODO sad stage1 noises :( + const tag: Tag = key.tag(); + const data: u32 = switch (key) { + .simple => |simple| @enumToInt(simple), + + .int_type => |int_ty| int_ty.bits, + .optional_type => |optional_ty| @enumToInt(optional_ty.payload_type), + .anyframe_type => |anyframe_ty| @enumToInt(anyframe_ty.child), + + .int_u64_value => |int_val| if (tag == .int_u32) @intCast(u32, int_val) else try ip.addExtra(gpa, int_val), + .int_i64_value => |int_val| if (tag == .int_i32) @bitCast(u32, @intCast(u32, int_val)) else try ip.addExtra(gpa, int_val), + .int_big_value => |big_int_val| try ip.addExtra(gpa, big_int_val.limbs), + .float_16_value => |float_val| @bitCast(u16, float_val), + .float_32_value => |float_val| @bitCast(u32, float_val), + inline else => |data| try ip.addExtra(gpa, data), // TODO sad stage1 noises :( }; - try ip.items.append(gpa, item); + + try ip.items.append(gpa, .{ + .tag = tag, + .data = data, + }); return @intToEnum(Index, ip.items.len - 1); } @@ -1142,6 +1008,135 @@ fn extraData(ip: InternPool, comptime T: type, index: usize) T { return std.mem.bytesToValue(T, bytes); } +const KeyAdapter = struct { + ip: *const InternPool, + + pub fn eql(ctx: @This(), a: Key, b_void: void, b_map_index: usize) bool { + _ = b_void; + + return deepEql(a, ctx.ip.indexToKey(@intToEnum(Index, b_map_index))); + } + + pub fn hash(ctx: @This(), a: Key) u32 { + _ = ctx; + var hasher = std.hash.Wyhash.init(0); + deepHash(&hasher, a); + return @truncate(u32, hasher.final()); + } +}; + +fn deepEql(a: anytype, b: @TypeOf(a)) bool { + const T = @TypeOf(a); + + switch (@typeInfo(T)) { + .Struct => |info| { + if (info.layout == .Packed) { + return std.mem.eql(u8, std.mem.asBytes(&a), std.mem.asBytes(&b)); + } + inline for (info.fields) |field_info| { + if (!deepEql(@field(a, field_info.name), @field(b, field_info.name))) return false; + } + return true; + }, + .Union => |info| { + const UnionTag = info.tag_type.?; + + const tag_a = std.meta.activeTag(a); + const tag_b = std.meta.activeTag(b); + if (tag_a != tag_b) return false; + + inline for (info.fields) |field_info| { + if (@field(UnionTag, field_info.name) == tag_a) { + return deepEql(@field(a, field_info.name), @field(b, field_info.name)); + } + } + return false; + }, + .Pointer => |info| { + if (info.size != .Slice) { + @compileError("cannot compare non slice pointer type " ++ @typeName(T)); + } + + if (@typeInfo(info.child) == .Int) { + return std.mem.eql(info.child, a, b); + } + if (a.len != b.len) return false; + + var i: usize = 0; + while (i < a.len) : (i += 1) { + if (!deepEql(a[i], b[i])) return false; + } + return true; + }, + .Enum, .Int => return a == b, + else => unreachable, + } +} + +fn deepHash(hasher: anytype, key: anytype) void { + const Inner = @TypeOf(key); + + switch (@typeInfo(Inner)) { + .Int => { + if (comptime std.meta.trait.hasUniqueRepresentation(Inner)) { + hasher.update(std.mem.asBytes(&key)); + } else { + const byte_size = comptime std.math.divCeil(comptime_int, @bitSizeOf(Inner), 8) catch unreachable; + hasher.update(std.mem.asBytes(&key)[0..byte_size]); + } + }, + + .Bool => deepHash(hasher, @boolToInt(key)), + .Enum => deepHash(hasher, @enumToInt(key)), + .Float => |info| deepHash(hasher, switch (info.bits) { + 16 => @bitCast(u16, key), + 32 => @bitCast(u32, key), + 64 => @bitCast(u64, key), + 80 => @bitCast(u80, key), + 128 => @bitCast(u128, key), + else => unreachable, + }), + + .Pointer => |info| { + if (info.size != .Slice) { + @compileError(""); + } + + if (comptime std.meta.trait.hasUniqueRepresentation(info.child)) { + hasher.update(std.mem.sliceAsBytes(key)); + } else { + for (key) |item| { + deepHash(hasher, item); + } + } + }, + + .Struct => |info| { + if (info.layout == .Packed) { + hasher.update(std.mem.asBytes(&key)); + } else { + inline for (info.fields) |field| { + deepHash(hasher, @field(key, field.name)); + } + } + }, + + .Union => |info| { + const TagType = info.tag_type.?; + + const tag = std.meta.activeTag(key); + deepHash(hasher, tag); + inline for (info.fields) |field| { + if (@field(TagType, field.name) == tag) { + deepHash(hasher, @field(key, field.name)); + break; + } + } + }, + else => unreachable, + } +} + // --------------------------------------------- // UTILITY // --------------------------------------------- @@ -2601,8 +2596,8 @@ test "anyframe type" { const i32_type = try ip.get(gpa, .{ .int_type = .{ .signedness = .signed, .bits = 32 } }); const bool_type = try ip.get(gpa, .{ .simple = .bool }); - const @"anyframe->i32" = try ip.get(gpa, Key{ .anyframe_t_type = .{ .child = i32_type } }); - const @"anyframe->bool" = try ip.get(gpa, Key{ .anyframe_t_type = .{ .child = bool_type } }); + const @"anyframe->i32" = try ip.get(gpa, Key{ .anyframe_type = .{ .child = i32_type } }); + const @"anyframe->bool" = try ip.get(gpa, Key{ .anyframe_type = .{ .child = bool_type } }); try testExpectFmtType(&ip, @"anyframe->i32", "anyframe->i32"); try testExpectFmtType(&ip, @"anyframe->bool", "anyframe->bool");