From 01ca841f1227cc3e17169c45318c8d4757a5c0d2 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Tue, 23 May 2023 19:10:36 -0700 Subject: [PATCH] Sema: improve the types_to_resolve mechanism Store `InternPool.Index` as the key instead which means that an AIR instruction no longer needs to be burned to store the type, and also that we can use AutoArrayHashMap instead of an ArrayList, which avoids storing duplicates into the set, potentially saving CPU time. --- src/Module.zig | 5 ++--- src/Sema.zig | 16 +++++++++------- 2 files changed, 11 insertions(+), 10 deletions(-) diff --git a/src/Module.zig b/src/Module.zig index f4bf487128..8174778f48 100644 --- a/src/Module.zig +++ b/src/Module.zig @@ -5773,9 +5773,8 @@ pub fn analyzeFnBody(mod: *Module, func: *Fn, arena: Allocator) SemaError!Air { // Similarly, resolve any queued up types that were requested to be resolved for // the backends. - for (sema.types_to_resolve.items) |inst_ref| { - const ty = sema.getTmpAir().getRefType(inst_ref); - sema.resolveTypeFully(ty) catch |err| switch (err) { + for (sema.types_to_resolve.keys()) |ty| { + sema.resolveTypeFully(ty.toType()) catch |err| switch (err) { error.NeededSourceLocation => unreachable, error.GenericPoison => unreachable, error.ComptimeReturn => unreachable, diff --git a/src/Sema.zig b/src/Sema.zig index 13a1c1cb3d..866c242f15 100644 --- a/src/Sema.zig +++ b/src/Sema.zig @@ -66,11 +66,14 @@ comptime_args_fn_inst: Zir.Inst.Index = 0, /// extra hash table lookup in the `monomorphed_funcs` set. /// Sema will set this to null when it takes ownership. preallocated_new_func: ?*Module.Fn = null, -/// The key is `constant` AIR instructions to types that must be fully resolved -/// after the current function body analysis is done. -/// TODO: after upgrading to use InternPool change the key here to be an -/// InternPool value index. -types_to_resolve: std.ArrayListUnmanaged(Air.Inst.Ref) = .{}, +/// The key is types that must be fully resolved prior to machine code +/// generation pass. Types are added to this set when resolving them +/// immediately could cause a dependency loop, but they do need to be resolved +/// before machine code generation passes process the AIR. +/// It would work fine if this were an array list instead of an array hash map. +/// I chose array hash map with the intention to save time by omitting +/// duplicates. +types_to_resolve: std.AutoArrayHashMapUnmanaged(InternPool.Index, void) = .{}, /// These are lazily created runtime blocks from block_inline instructions. /// They are created when an break_inline passes through a runtime condition, because /// Sema must convert comptime control flow to runtime control flow, which means @@ -34085,8 +34088,7 @@ fn anonStructFieldIndex( } fn queueFullTypeResolution(sema: *Sema, ty: Type) !void { - const inst_ref = try sema.addType(ty); - try sema.types_to_resolve.append(sema.gpa, inst_ref); + try sema.types_to_resolve.put(sema.gpa, ty.toIntern(), {}); } fn intAdd(sema: *Sema, lhs: Value, rhs: Value, ty: Type) !Value {