Merge branch 'master' into loongarch64

Author: xtexx

lib/init/build.zig

@@ -29,7 +29,7 @@ pub fn build(b: *std.Build) void {
     // to our consumers. We must give it a name because a Zig package can expose
     // multiple modules and consumers will need to be able to specify which
     // module they want to access.
-    const mod = b.addModule(".NAME", .{
+    const mod = b.addModule("_NAME", .{
         // The root source file is the "entry point" of this module. Users of
         // this module will only be able to access public declarations contained
         // in this file, which means that if you have declarations that you
@@ -59,7 +59,7 @@ pub fn build(b: *std.Build) void {
     // If neither case applies to you, feel free to delete the declaration you
     // don't need and to put everything under a single module.
     const exe = b.addExecutable(.{
-        .name = ".NAME",
+        .name = "_NAME",
         .root_module = b.createModule(.{
             // b.createModule defines a new module just like b.addModule but,
             // unlike b.addModule, it does not expose the module to consumers of
@@ -74,12 +74,12 @@ pub fn build(b: *std.Build) void {
             // List of modules available for import in source files part of the
             // root module.
             .imports = &.{
-                // Here ".NAME" is the name you will use in your source code to
-                // import this module (e.g. `@import(".NAME")`). The name is
+                // Here "_NAME" is the name you will use in your source code to
+                // import this module (e.g. `@import("_NAME")`). The name is
                 // repeated because you are allowed to rename your imports, which
                 // can be extremely useful in case of collisions (which can happen
                 // importing modules from different packages).
-                .{ .name = ".NAME", .module = mod },
+                .{ .name = "_NAME", .module = mod },
             },
         }),
     });

lib/init/build.zig.zon

@@ -6,7 +6,7 @@
     //
     // It is redundant to include "zig" in this name because it is already
     // within the Zig package namespace.
-    .name = .LITNAME,
+    .name = ._NAME,
     // This is a [Semantic Version](https://semver.org/).
     // In a future version of Zig it will be used for package deduplication.
     .version = "0.0.0",
@@ -25,7 +25,7 @@
     .fingerprint = .FINGERPRINT, // Changing this has security and trust implications.
     // Tracks the earliest Zig version that the package considers to be a
     // supported use case.
-    .minimum_zig_version = ".ZIGVER",
+    .minimum_zig_version = "_ZIGVER",
     // This field is optional.
     // Each dependency must either provide a `url` and `hash`, or a `path`.
     // `zig build --fetch` can be used to fetch all dependencies of a package, recursively.

lib/init/src/main.zig

@@ -1,10 +1,10 @@
 const std = @import("std");
-const _LITNAME = @import(".NAME");
+const _NAME = @import(".NAME");
 
 pub fn main() !void {
     // Prints to stderr, ignoring potential errors.
     std.debug.print("All your {s} are belong to us.\n", .{"codebase"});
-    try .NAME.advancedPrint();
+    try _NAME.bufferedPrint();
 }
 
 test "simple test" {

lib/init/src/root.zig

@@ -1,11 +1,12 @@
 //! By convention, root.zig is the root source file when making a library.
 const std = @import("std");
 
-pub fn advancedPrint() !void {
+pub fn bufferedPrint() !void {
     // Stdout is for the actual output of your application, for example if you
     // are implementing gzip, then only the compressed bytes should be sent to
     // stdout, not any debugging messages.
     const stdout_file = std.io.getStdOut().writer();
+    // Buffering can improve performance significantly in print-heavy programs.
     var bw = std.io.bufferedWriter(stdout_file);
     const stdout = bw.writer();
 

lib/std/zig/Parse.zig

@@ -2774,9 +2774,9 @@ fn parsePrimaryTypeExpr(p: *Parse) !?Node.Index {
             else => {
                 const main_token = p.nextToken();
                 const period = p.eatToken(.period);
-                if (period == null) try p.warnExpected(.period);
+                if (period == null) return p.failExpected(.period);
                 const identifier = p.eatToken(.identifier);
-                if (identifier == null) try p.warnExpected(.identifier);
+                if (identifier == null) return p.failExpected(.identifier);
                 return try p.addNode(.{
                     .tag = .error_value,
                     .main_token = main_token,

lib/std/zig/llvm/ir.zig

@@ -1064,7 +1064,7 @@ pub const MetadataBlock = struct {
     pub const Subrange = struct {
         pub const ops = [_]AbbrevOp{
             .{ .literal = @intFromEnum(MetadataCode.SUBRANGE) },
-            .{ .literal = 0b10 }, // is distinct | version
+            .{ .literal = 0 | (2 << 1) }, // is distinct | version
             MetadataAbbrev, // count
             MetadataAbbrev, // lower bound
             .{ .literal = 0 }, // upper bound

lib/std/zig/parser_test.zig

@@ -6280,7 +6280,6 @@ test "recovery: invalid global error set access" {
         \\}
     , &[_]Error{
         .expected_token,
-        .expected_token,
     });
 }
 

src/Zcu/PerThread.zig

@@ -4373,34 +4373,29 @@ pub fn addDependency(pt: Zcu.PerThread, unit: AnalUnit, dependee: InternPool.Dep
 /// codegen thread, depending on whether the backend supports `Zcu.Feature.separate_thread`.
 pub fn runCodegen(pt: Zcu.PerThread, func_index: InternPool.Index, air: *Air, out: *@import("../link.zig").ZcuTask.LinkFunc.SharedMir) void {
     const zcu = pt.zcu;
-    if (runCodegenInner(pt, func_index, air)) |mir| {
+    const success: bool = if (runCodegenInner(pt, func_index, air)) |mir| success: {
         out.value = mir;
-        out.status.store(.ready, .release);
-    } else |err| switch (err) {
-        error.OutOfMemory => {
-            zcu.comp.setAllocFailure();
-            out.status.store(.failed, .monotonic);
-        },
-        error.CodegenFail => {
-            zcu.assertCodegenFailed(zcu.funcInfo(func_index).owner_nav);
-            out.status.store(.failed, .monotonic);
-        },
-        error.NoLinkFile => {
-            assert(zcu.comp.bin_file == null);
-            out.status.store(.failed, .monotonic);
-        },
-        error.BackendDoesNotProduceMir => {
-            const backend = target_util.zigBackend(zcu.root_mod.resolved_target.result, zcu.comp.config.use_llvm);
-            switch (backend) {
+        break :success true;
+    } else |err| success: {
+        switch (err) {
+            error.OutOfMemory => zcu.comp.setAllocFailure(),
+            error.CodegenFail => zcu.assertCodegenFailed(zcu.funcInfo(func_index).owner_nav),
+            error.NoLinkFile => assert(zcu.comp.bin_file == null),
+            error.BackendDoesNotProduceMir => switch (target_util.zigBackend(
+                zcu.root_mod.resolved_target.result,
+                zcu.comp.config.use_llvm,
+            )) {
                 else => unreachable, // assertion failure
                 .stage2_spirv64,
                 .stage2_llvm,
                 => {},
-            }
-            out.status.store(.failed, .monotonic);
-        },
-    }
-    zcu.comp.link_task_queue.mirReady(zcu.comp, out);
+            },
+        }
+        break :success false;
+    };
+    // release `out.value` with this store; synchronizes with acquire loads in `link`
+    out.status.store(if (success) .ready else .failed, .release);
+    zcu.comp.link_task_queue.mirReady(zcu.comp, func_index, out);
     if (zcu.pending_codegen_jobs.rmw(.Sub, 1, .monotonic) == 1) {
         // Decremented to 0, so all done.
         zcu.codegen_prog_node.end();

src/link.zig

@@ -1249,7 +1249,7 @@ pub const ZcuTask = union(enum) {
             .update_line_number,
             => {},
             .link_func => |link_func| {
-                switch (link_func.mir.status.load(.monotonic)) {
+                switch (link_func.mir.status.load(.acquire)) {
                     .pending => unreachable, // cannot deinit until MIR done
                     .failed => {}, // MIR not populated so doesn't need freeing
                     .ready => link_func.mir.value.deinit(zcu),
@@ -1453,7 +1453,7 @@ pub fn doZcuTask(comp: *Compilation, tid: usize, task: ZcuTask) void {
             const fqn_slice = ip.getNav(nav).fqn.toSlice(ip);
             const nav_prog_node = comp.link_prog_node.start(fqn_slice, 0);
             defer nav_prog_node.end();
-            switch (func.mir.status.load(.monotonic)) {
+            switch (func.mir.status.load(.acquire)) {
                 .pending => unreachable,
                 .ready => {},
                 .failed => return,

src/link/Queue.zig

@@ -64,7 +64,7 @@ state: union(enum) {
     finished,
     /// The link thread is not running or queued, because it is waiting for this MIR to be populated.
     /// Once codegen completes, it must call `mirReady` which will restart the link thread.
-    wait_for_mir: *ZcuTask.LinkFunc.SharedMir,
+    wait_for_mir: InternPool.Index,
 },
 
 /// In the worst observed case, MIR is around 50 times as large as AIR. More typically, the ratio is
@@ -113,20 +113,20 @@ pub fn start(q: *Queue, comp: *Compilation) void {
 
 /// Called by codegen workers after they have populated a `ZcuTask.LinkFunc.SharedMir`. If the link
 /// thread was waiting for this MIR, it can resume.
-pub fn mirReady(q: *Queue, comp: *Compilation, mir: *ZcuTask.LinkFunc.SharedMir) void {
+pub fn mirReady(q: *Queue, comp: *Compilation, func_index: InternPool.Index, mir: *ZcuTask.LinkFunc.SharedMir) void {
     // We would like to assert that `mir` is not pending, but that would race with a worker thread
     // potentially freeing it.
     {
         q.mutex.lock();
         defer q.mutex.unlock();
         switch (q.state) {
             .finished, .running => return,
-            .wait_for_mir => |wait_for| if (wait_for != mir) return,
+            .wait_for_mir => |wait_for| if (wait_for != func_index) return,
         }
         // We were waiting for `mir`, so we will restart the linker thread.
         q.state = .running;
     }
-    assert(mir.status.load(.monotonic) != .pending);
+    assert(mir.status.load(.acquire) != .pending);
     comp.thread_pool.spawnWgId(&comp.link_task_wait_group, flushTaskQueue, .{ q, comp });
 }
 
@@ -170,8 +170,8 @@ pub fn enqueueZcu(q: *Queue, comp: *Compilation, task: ZcuTask) Allocator.Error!
             .finished => if (q.pending_prelink_tasks != 0) return,
         }
         // Restart the linker thread, unless it would immediately be blocked
-        if (task == .link_func and task.link_func.mir.status.load(.monotonic) == .pending) {
-            q.state = .{ .wait_for_mir = task.link_func.mir };
+        if (task == .link_func and task.link_func.mir.status.load(.acquire) == .pending) {
+            q.state = .{ .wait_for_mir = task.link_func.func };
             return;
         }
         q.state = .running;
@@ -243,12 +243,12 @@ fn flushTaskQueue(tid: usize, q: *Queue, comp: *Compilation) void {
             if (task != .link_func) break :pending;
             const status_ptr = &task.link_func.mir.status;
             // First check without the mutex to optimize for the common case where MIR is ready.
-            if (status_ptr.load(.monotonic) != .pending) break :pending;
+            if (status_ptr.load(.acquire) != .pending) break :pending;
             q.mutex.lock();
             defer q.mutex.unlock();
-            if (status_ptr.load(.monotonic) != .pending) break :pending;
+            if (status_ptr.load(.acquire) != .pending) break :pending;
             // We will stop for now, and get restarted once this MIR is ready.
-            q.state = .{ .wait_for_mir = task.link_func.mir };
+            q.state = .{ .wait_for_mir = task.link_func.func };
             q.flush_safety.unlock();
             return;
         }
@@ -273,6 +273,7 @@ const std = @import("std");
 const assert = std.debug.assert;
 const Allocator = std.mem.Allocator;
 const Compilation = @import("../Compilation.zig");
+const InternPool = @import("../InternPool.zig");
 const link = @import("../link.zig");
 const PrelinkTask = link.PrelinkTask;
 const ZcuTask = link.ZcuTask;

src/main.zig

@@ -7290,34 +7290,27 @@ const Templates = struct {
                     new_line = false;
                 }
             }
+
             if (templates.strip and contents[i] == '\n') {
                 new_line = true;
-            } else if (contents[i] == '_') {
-                if (std.mem.startsWith(u8, contents[i..], "_LITNAME")) {
-                    try templates.buffer.appendSlice(root_name);
-                    i += "_LITNAME".len;
-                    continue;
-                }
-            } else if (contents[i] == '.') {
-                if (std.mem.startsWith(u8, contents[i..], ".LITNAME")) {
-                    try templates.buffer.append('.');
+            } else if (contents[i] == '_' or contents[i] == '.') {
+                // Both '_' and '.' are allowed because depending on the context
+                // one prefix will be valid, while the other might not.
+                if (std.mem.startsWith(u8, contents[i + 1 ..], "NAME")) {
                     try templates.buffer.appendSlice(root_name);
-                    i += ".LITNAME".len;
+                    i += "_NAME".len;
                     continue;
-                } else if (std.mem.startsWith(u8, contents[i..], ".NAME")) {
-                    try templates.buffer.appendSlice(root_name);
-                    i += ".NAME".len;
-                    continue;
-                } else if (std.mem.startsWith(u8, contents[i..], ".FINGERPRINT")) {
+                } else if (std.mem.startsWith(u8, contents[i + 1 ..], "FINGERPRINT")) {
                     try templates.buffer.writer().print("0x{x}", .{fingerprint.int()});
-                    i += ".FINGERPRINT".len;
+                    i += "_FINGERPRINT".len;
                     continue;
-                } else if (std.mem.startsWith(u8, contents[i..], ".ZIGVER")) {
+                } else if (std.mem.startsWith(u8, contents[i + 1 ..], "ZIGVER")) {
                     try templates.buffer.appendSlice(build_options.version);
-                    i += ".ZIGVER".len;
+                    i += "_ZIGVER".len;
                     continue;
                 }
             }
+
             try templates.buffer.append(contents[i]);
             i += 1;
         }