Commit `01ca841f12`

Andrew Kelley <andrew@ziglang.org>

2023-05-24 04:10:36

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.

master

1 parent 1b64eed

Changed files (2)

src

Module.zig

Sema.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,

@@ -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 {

Commit 01ca841f12

Commit `01ca841f12`