update zig sources to 0.8.0-dev.1416+584cb2e4f

Author: andrewrk

build

@@ -7,7 +7,7 @@ TARGET="$2" # Example: riscv64-linux-gnu
 MCPU="$3" # Examples: `baseline`, `native`, `generic+v7a`, or `arm1176jzf_s`
 
 ROOTDIR="$(pwd)"
-ZIG_VERSION="0.8.0-dev.1400+85eb05e9a"
+ZIG_VERSION="0.8.0-dev.1416+584cb2e4f"
 
 TARGET_OS_AND_ABI=${TARGET#*-} # Example: linux-gnu
 

zig/doc/langref.html.in

@@ -933,8 +933,8 @@ const assert = std.debug.assert;
 threadlocal var x: i32 = 1234;
 
 test "thread local storage" {
-    const thread1 = try std.Thread.spawn({}, testTls);
-    const thread2 = try std.Thread.spawn({}, testTls);
+    const thread1 = try std.Thread.spawn(testTls, {});
+    const thread2 = try std.Thread.spawn(testTls, {});
     testTls({});
     thread1.wait();
     thread2.wait();

zig/lib/std/Thread.zig

@@ -165,18 +165,32 @@ pub const SpawnError = error{
     Unexpected,
 };
 
-/// caller must call wait on the returned thread
-/// fn startFn(@TypeOf(context)) T
-/// where T is u8, noreturn, void, or !void
-/// caller must call wait on the returned thread
-pub fn spawn(context: anytype, comptime startFn: anytype) SpawnError!*Thread {
+// Given `T`, the type of the thread startFn, extract the expected type for the
+// context parameter.
+fn SpawnContextType(comptime T: type) type {
+    const TI = @typeInfo(T);
+    if (TI != .Fn)
+        @compileError("expected function type, found " ++ @typeName(T));
+
+    if (TI.Fn.args.len != 1)
+        @compileError("expected function with single argument, found " ++ @typeName(T));
+
+    return TI.Fn.args[0].arg_type orelse
+        @compileError("cannot use a generic function as thread startFn");
+}
+
+/// Spawns a new thread executing startFn, returning an handle for it.
+/// Caller must call wait on the returned thread.
+/// The `startFn` function must take a single argument of type T and return a
+/// value of type u8, noreturn, void or !void.
+/// The `context` parameter is of type T and is passed to the spawned thread.
+pub fn spawn(comptime startFn: anytype, context: SpawnContextType(@TypeOf(startFn))) SpawnError!*Thread {
     if (builtin.single_threaded) @compileError("cannot spawn thread when building in single-threaded mode");
     // TODO compile-time call graph analysis to determine stack upper bound
     // https://github.com/ziglang/zig/issues/157
     const default_stack_size = 16 * 1024 * 1024;
 
     const Context = @TypeOf(context);
-    comptime assert(@typeInfo(@TypeOf(startFn)).Fn.args[0].arg_type.? == Context);
 
     if (std.Target.current.os.tag == .windows) {
         const WinThread = struct {

zig/lib/std/Thread/AutoResetEvent.zig

@@ -220,8 +220,8 @@ test "basic usage" {
     };
 
     var context = Context{};
-    const send_thread = try std.Thread.spawn(&context, Context.sender);
-    const recv_thread = try std.Thread.spawn(&context, Context.receiver);
+    const send_thread = try std.Thread.spawn(Context.sender, &context);
+    const recv_thread = try std.Thread.spawn(Context.receiver, &context);
 
     send_thread.wait();
     recv_thread.wait();

zig/lib/std/Thread/Mutex.zig

@@ -299,7 +299,7 @@ test "basic usage" {
         const thread_count = 10;
         var threads: [thread_count]*std.Thread = undefined;
         for (threads) |*t| {
-            t.* = try std.Thread.spawn(&context, worker);
+            t.* = try std.Thread.spawn(worker, &context);
         }
         for (threads) |t|
             t.wait();

zig/lib/std/Thread/ResetEvent.zig

@@ -281,7 +281,7 @@ test "basic usage" {
     var context: Context = undefined;
     try context.init();
     defer context.deinit();
-    const receiver = try std.Thread.spawn(&context, Context.receiver);
+    const receiver = try std.Thread.spawn(Context.receiver, &context);
     defer receiver.wait();
     context.sender();
 
@@ -290,7 +290,7 @@ test "basic usage" {
         // https://github.com/ziglang/zig/issues/7009
         var timed = Context.init();
         defer timed.deinit();
-        const sleeper = try std.Thread.spawn(&timed, Context.sleeper);
+        const sleeper = try std.Thread.spawn(Context.sleeper, &timed);
         defer sleeper.wait();
         try timed.timedWaiter();
     }

zig/lib/std/Thread/StaticResetEvent.zig

@@ -379,7 +379,7 @@ test "basic usage" {
     };
 
     var context = Context{};
-    const receiver = try std.Thread.spawn(&context, Context.receiver);
+    const receiver = try std.Thread.spawn(Context.receiver, &context);
     defer receiver.wait();
     context.sender();
 
@@ -388,7 +388,7 @@ test "basic usage" {
         // https://github.com/ziglang/zig/issues/7009
         var timed = Context.init();
         defer timed.deinit();
-        const sleeper = try std.Thread.spawn(&timed, Context.sleeper);
+        const sleeper = try std.Thread.spawn(Context.sleeper, &timed);
         defer sleeper.wait();
         try timed.timedWaiter();
     }

zig/lib/std/atomic/queue.zig

@@ -216,11 +216,11 @@ test "std.atomic.Queue" {
 
         var putters: [put_thread_count]*std.Thread = undefined;
         for (putters) |*t| {
-            t.* = try std.Thread.spawn(&context, startPuts);
+            t.* = try std.Thread.spawn(startPuts, &context);
         }
         var getters: [put_thread_count]*std.Thread = undefined;
         for (getters) |*t| {
-            t.* = try std.Thread.spawn(&context, startGets);
+            t.* = try std.Thread.spawn(startGets, &context);
         }
 
         for (putters) |t|

zig/lib/std/atomic/stack.zig

@@ -123,11 +123,11 @@ test "std.atomic.stack" {
     } else {
         var putters: [put_thread_count]*std.Thread = undefined;
         for (putters) |*t| {
-            t.* = try std.Thread.spawn(&context, startPuts);
+            t.* = try std.Thread.spawn(startPuts, &context);
         }
         var getters: [put_thread_count]*std.Thread = undefined;
         for (getters) |*t| {
-            t.* = try std.Thread.spawn(&context, startGets);
+            t.* = try std.Thread.spawn(startGets, &context);
         }
 
         for (putters) |t|

zig/lib/std/buf_set.zig

@@ -32,7 +32,7 @@ pub const BufSet = struct {
         if (self.hash_map.get(key) == null) {
             const key_copy = try self.copy(key);
             errdefer self.free(key_copy);
-            _ = try self.hash_map.put(key_copy, {});
+            try self.hash_map.put(key_copy, {});
         }
     }
 

zig/lib/std/build.zig

@@ -790,7 +790,7 @@ pub const Builder = struct {
                 var list = ArrayList([]const u8).init(self.allocator);
                 list.append(s) catch unreachable;
                 list.append(value) catch unreachable;
-                _ = self.user_input_options.put(name, UserInputOption{
+                self.user_input_options.put(name, UserInputOption{
                     .name = name,
                     .value = UserValue{ .List = list },
                     .used = false,
@@ -799,7 +799,7 @@ pub const Builder = struct {
             UserValue.List => |*list| {
                 // append to the list
                 list.append(value) catch unreachable;
-                _ = self.user_input_options.put(name, UserInputOption{
+                self.user_input_options.put(name, UserInputOption{
                     .name = name,
                     .value = UserValue{ .List = list.* },
                     .used = false,

zig/lib/std/c/builtins.zig

@@ -182,3 +182,9 @@ pub fn __builtin_memcpy(
     @memcpy(dst_cast, src_cast, len);
     return dst;
 }
+
+/// The return value of __builtin_expect is `expr`. `c` is the expected value
+/// of `expr` and is used as a hint to the compiler in C. Here it is unused.
+pub fn __builtin_expect(expr: c_long, c: c_long) callconv(.Inline) c_long {
+    return expr;
+}

zig/lib/std/crypto.zig

@@ -16,6 +16,11 @@ pub const aead = struct {
         pub const Aes256Gcm = @import("crypto/aes_gcm.zig").Aes256Gcm;
     };
 
+    pub const aes_ocb = struct {
+        pub const Aes128Ocb = @import("crypto/aes_ocb.zig").Aes128Ocb;
+        pub const Aes256Ocb = @import("crypto/aes_ocb.zig").Aes256Ocb;
+    };
+
     pub const Gimli = @import("crypto/gimli.zig").Aead;
 
     pub const chacha_poly = struct {
@@ -157,30 +162,11 @@ test "crypto" {
         }
     }
 
-    _ = @import("crypto/aes.zig");
-    _ = @import("crypto/bcrypt.zig");
+    _ = @import("crypto/aegis.zig");
+    _ = @import("crypto/aes_gcm.zig");
+    _ = @import("crypto/aes_ocb.zig");
     _ = @import("crypto/blake2.zig");
-    _ = @import("crypto/blake3.zig");
     _ = @import("crypto/chacha20.zig");
-    _ = @import("crypto/gimli.zig");
-    _ = @import("crypto/hmac.zig");
-    _ = @import("crypto/isap.zig");
-    _ = @import("crypto/md5.zig");
-    _ = @import("crypto/modes.zig");
-    _ = @import("crypto/pbkdf2.zig");
-    _ = @import("crypto/poly1305.zig");
-    _ = @import("crypto/sha1.zig");
-    _ = @import("crypto/sha2.zig");
-    _ = @import("crypto/sha3.zig");
-    _ = @import("crypto/salsa20.zig");
-    _ = @import("crypto/siphash.zig");
-    _ = @import("crypto/25519/curve25519.zig");
-    _ = @import("crypto/25519/ed25519.zig");
-    _ = @import("crypto/25519/edwards25519.zig");
-    _ = @import("crypto/25519/field.zig");
-    _ = @import("crypto/25519/scalar.zig");
-    _ = @import("crypto/25519/x25519.zig");
-    _ = @import("crypto/25519/ristretto255.zig");
 }
 
 test "CSPRNG" {

zig/lib/std/crypto/aes/aesni.zig

@@ -313,10 +313,7 @@ pub fn AesEncryptCtx(comptime Aes: type) type {
             inline while (i < rounds) : (i += 1) {
                 ts = Block.parallel.encryptWide(count, ts, round_keys[i]);
             }
-            i = 1;
-            inline while (i < count) : (i += 1) {
-                ts = Block.parallel.encryptLastWide(count, ts, round_keys[i]);
-            }
+            ts = Block.parallel.encryptLastWide(count, ts, round_keys[i]);
             j = 0;
             inline while (j < count) : (j += 1) {
                 dst[16 * j .. 16 * j + 16].* = ts[j].toBytes();
@@ -392,10 +389,7 @@ pub fn AesDecryptCtx(comptime Aes: type) type {
             inline while (i < rounds) : (i += 1) {
                 ts = Block.parallel.decryptWide(count, ts, inv_round_keys[i]);
             }
-            i = 1;
-            inline while (i < count) : (i += 1) {
-                ts = Block.parallel.decryptLastWide(count, ts, inv_round_keys[i]);
-            }
+            ts = Block.parallel.decryptLastWide(count, ts, inv_round_keys[i]);
             j = 0;
             inline while (j < count) : (j += 1) {
                 dst[16 * j .. 16 * j + 16].* = ts[j].toBytes();

zig/lib/std/crypto/aes/armcrypto.zig

@@ -364,10 +364,7 @@ pub fn AesEncryptCtx(comptime Aes: type) type {
             inline while (i < rounds) : (i += 1) {
                 ts = Block.parallel.encryptWide(count, ts, round_keys[i]);
             }
-            i = 1;
-            inline while (i < count) : (i += 1) {
-                ts = Block.parallel.encryptLastWide(count, ts, round_keys[i]);
-            }
+            ts = Block.parallel.encryptLastWide(count, ts, round_keys[i]);
             j = 0;
             inline while (j < count) : (j += 1) {
                 dst[16 * j .. 16 * j + 16].* = ts[j].toBytes();
@@ -443,10 +440,7 @@ pub fn AesDecryptCtx(comptime Aes: type) type {
             inline while (i < rounds) : (i += 1) {
                 ts = Block.parallel.decryptWide(count, ts, inv_round_keys[i]);
             }
-            i = 1;
-            inline while (i < count) : (i += 1) {
-                ts = Block.parallel.decryptLastWide(count, ts, inv_round_keys[i]);
-            }
+            ts = Block.parallel.decryptLastWide(count, ts, inv_round_keys[i]);
             j = 0;
             inline while (j < count) : (j += 1) {
                 dst[16 * j .. 16 * j + 16].* = ts[j].toBytes();