Merge pull request #18 from oven-sh/ali/sanic-gotta-go-fast

shard sema and codegen

Author: dylan-conway

.gitignore

@@ -20,3 +20,5 @@ zig-out/
 # Although this was renamed to .zig-cache, let's leave it here for a few
 # releases to make it less annoying to work with multiple branches.
 zig-cache/
+.claude/
+bun-cache/

build.zig

@@ -123,6 +123,11 @@ pub fn build(b: *std.Build) !void {
         "llvm-has-xtensa",
         "Whether LLVM has the experimental target xtensa enabled",
     ) orelse false;
+    const llvm_has_polly = b.option(
+        bool,
+        "llvm-has-polly",
+        "Whether LLVM was built with Polly and requires linking it",
+    ) orelse false;
     const enable_ios_sdk = b.option(bool, "enable-ios-sdk", "Run tests requiring presence of iOS SDK and frameworks") orelse false;
     const enable_macos_sdk = b.option(bool, "enable-macos-sdk", "Run tests requiring presence of macOS SDK and frameworks") orelse enable_ios_sdk;
     const enable_symlinks_windows = b.option(bool, "enable-symlinks-windows", "Run tests requiring presence of symlinks on Windows") orelse false;
@@ -332,6 +337,7 @@ pub fn build(b: *std.Build) !void {
                 .llvm_has_csky = llvm_has_csky,
                 .llvm_has_arc = llvm_has_arc,
                 .llvm_has_xtensa = llvm_has_xtensa,
+                .llvm_has_polly = llvm_has_polly,
             });
         }
         if (target.result.os.tag == .windows) {
@@ -739,7 +745,7 @@ fn addCompilerMod(b: *std.Build, options: AddCompilerModOptions) *std.Build.Modu
 fn addCompilerStep(b: *std.Build, options: AddCompilerModOptions) *std.Build.Step.Compile {
     const exe = b.addExecutable(.{
         .name = "zig",
-        .max_rss = 10_000_000_000,
+        .max_rss = 11_000_000_000,
         .root_module = addCompilerMod(b, options),
     });
     exe.stack_size = stack_size;
@@ -858,6 +864,7 @@ fn addStaticLlvmOptionsToModule(mod: *std.Build.Module, options: struct {
     llvm_has_csky: bool,
     llvm_has_arc: bool,
     llvm_has_xtensa: bool,
+    llvm_has_polly: bool,
 }) !void {
     // Adds the Zig C++ sources which both stage1 and stage2 need.
     //
@@ -898,6 +905,10 @@ fn addStaticLlvmOptionsToModule(mod: *std.Build.Module, options: struct {
         mod.linkSystemLibrary(lib_name, .{});
     };
 
+    if (options.llvm_has_polly) for (llvm_libs_polly) |lib_name| {
+        mod.linkSystemLibrary(lib_name, .{});
+    };
+
     mod.linkSystemLibrary("z", .{});
     mod.linkSystemLibrary("zstd", .{});
 
@@ -1419,6 +1430,10 @@ const llvm_libs_xtensa = [_][]const u8{
     "LLVMXtensaDesc",
     "LLVMXtensaInfo",
 };
+const llvm_libs_polly = [_][]const u8{
+    "Polly",
+    "PollyISL",
+};
 
 fn generateLangRef(b: *std.Build) std.Build.LazyPath {
     const doctest_exe = b.addExecutable(.{

src/Air.zig

@@ -2154,6 +2154,7 @@ pub fn unwrapShuffleTwo(air: *const Air, zcu: *const Zcu, inst_index: Inst.Index
 }
 
 pub const typesFullyResolved = types_resolved.typesFullyResolved;
+pub const resolveTypesFully = types_resolved.resolveTypesFully;
 pub const typeFullyResolved = types_resolved.checkType;
 pub const valFullyResolved = types_resolved.checkVal;
 pub const legalize = Legalize.legalize;

src/Air/types_resolved.zig

@@ -10,6 +10,21 @@ pub fn typesFullyResolved(air: Air, zcu: *Zcu) bool {
     return checkBody(air, air.getMainBody(), zcu);
 }
 
+/// Under parallel Sema, `resolve_type_fully` and `codegen_func` run
+/// concurrently, so types may be mid-resolution rather than failed. Walk the
+/// same AIR shape as `typesFullyResolved` but force-resolve each struct/union
+/// (blocking on `claimOrWait`-gated resolution). Returns false only if
+/// resolution itself errors.
+pub fn resolveTypesFully(air: Air, pt: Zcu.PerThread) bool {
+    tls_resolve_pt = pt;
+    defer tls_resolve_pt = null;
+    return checkBody(air, air.getMainBody(), pt.zcu);
+}
+
+/// `checkType` is reached via a long instruction walk; thread the optional
+/// PerThread via tls instead of plumbing it through every switch arm.
+threadlocal var tls_resolve_pt: ?Zcu.PerThread = null;
+
 fn checkBody(air: Air, body: []const Air.Inst.Index, zcu: *Zcu) bool {
     const tags = air.instructions.items(.tag);
     const datas = air.instructions.items(.data);
@@ -513,6 +528,10 @@ pub fn checkType(ty: Type, zcu: *Zcu) bool {
         },
         .@"struct" => switch (ip.indexToKey(ty.toIntern())) {
             .struct_type => {
+                if (tls_resolve_pt) |pt| {
+                    ty.resolveFully(pt) catch return false;
+                    return true;
+                }
                 const struct_obj = zcu.typeToStruct(ty).?;
                 return switch (struct_obj.layout) {
                     .@"packed" => struct_obj.backingIntTypeUnordered(ip) != .none,
@@ -530,6 +549,12 @@ pub fn checkType(ty: Type, zcu: *Zcu) bool {
             },
             else => unreachable,
         },
-        .@"union" => return zcu.typeToUnion(ty).?.flagsUnordered(ip).status == .fully_resolved,
+        .@"union" => {
+            if (tls_resolve_pt) |pt| {
+                ty.resolveFully(pt) catch return false;
+                return true;
+            }
+            return zcu.typeToUnion(ty).?.flagsUnordered(ip).status == .fully_resolved;
+        },
     };
 }