srctree

Andrew Kelley parent 78902db6 6115cf22
migrate from `std.Target.current` to `@import("builtin").target`

closes #9388 closes #9321

doc/docgen.zig added: 771, removed: 743, total 28

@@ -1334,7 +1334,7 @@ fn genHtml(

if (mem.startsWith(u8, triple, "wasm32") or

mem.startsWith(u8, triple, "riscv64-linux") or

(mem.startsWith(u8, triple, "x86_64-linux") and

std.Target.current.os.tag != .linux or std.Target.current.cpu.arch != .x86_64))

builtin.os.tag != .linux or builtin.cpu.arch != .x86_64))

{

// skip execution

break :code_block;

@@ -1602,7 +1602,7 @@ fn genHtml(

Code.Id.Lib => {

const bin_basename = try std.zig.binNameAlloc(allocator, .{

.root_name = code.name,

.target = std.Target.current,

.target = builtin.target,

.output_mode = .Lib,

});

doc/langref.html.in added: 771, removed: 743, total 28

@@ -2681,6 +2681,7 @@ test "pointer child type" {

</p>

{#code_begin|test|variable_alignment#}

const std = @import("std");

const builtin = @import("builtin");

const expect = std.testing.expect;

test "variable alignment" {

@@ -2688,7 +2689,7 @@ test "variable alignment" {

const align_of_i32 = @alignOf(@TypeOf(x));

try expect(@TypeOf(&x) == *i32);

try expect(*i32 == *align(align_of_i32) i32);

if (std.Target.current.cpu.arch == .x86_64) {

if (builtin.target.cpu.arch == .x86_64) {

try expect(@typeInfo(*i32).Pointer.alignment == 4);

}

@@ -3878,6 +3879,7 @@ test "separate scopes" {

{#header_open|switch#}

{#code_begin|test|switch#}

const std = @import("std");

const builtin = @import("builtin");

const expect = std.testing.expect;

test "switch simple" {

@@ -3922,7 +3924,7 @@ test "switch simple" {

}

// Switch expressions can be used outside a function:

const os_msg = switch (std.Target.current.os.tag) {

const os_msg = switch (builtin.target.os.tag) {

.linux => "we found a linux user",

else => "not a linux user",

};

@@ -3930,7 +3932,7 @@ const os_msg = switch (std.Target.current.os.tag) {

// Inside a function, switch statements implicitly are compile-time

// evaluated if the target expression is compile-time known.

test "switch inside function" {

switch (std.Target.current.os.tag) {

switch (builtin.target.os.tag) {

.fuchsia => {

// On an OS other than fuchsia, block is not even analyzed,

// so this compile error is not triggered.

@@ -5690,6 +5692,7 @@ test "cast *[1][*]const u8 to [*]const ?[*]const u8" {

</p>

{#code_begin|test|test_integer_widening#}

const std = @import("std");

const builtin = @import("builtin");

const expect = std.testing.expect;

const mem = std.mem;

@@ -5712,7 +5715,7 @@ test "implicit unsigned integer to signed integer" {

test "float widening" {

// Note: there is an open issue preventing this from working on aarch64:

// https://github.com/ziglang/zig/issues/3282

if (std.Target.current.cpu.arch == .aarch64) return error.SkipZigTest;

if (builtin.target.cpu.arch == .aarch64) return error.SkipZigTest;

var a: f16 = 12.34;

var b: f32 = a;

lib/std/Progress.zig added: 771, removed: 743, total 28

@@ -7,6 +7,7 @@

//! * `initial_delay_ms`

const std = @import("std");

const builtin = @import("builtin");

const windows = std.os.windows;

const testing = std.testing;

const assert = std.debug.assert;

@@ -144,10 +145,10 @@ pub fn start(self: *Progress, name: []const u8, estimated_total_items: usize) !*

if (stderr.supportsAnsiEscapeCodes()) {

self.terminal = stderr;

self.supports_ansi_escape_codes = true;

} else if (std.builtin.os.tag == .windows and stderr.isTty()) {

} else if (builtin.os.tag == .windows and stderr.isTty()) {

self.is_windows_terminal = true;

self.terminal = stderr;

} else if (std.builtin.os.tag != .windows) {

} else if (builtin.os.tag != .windows) {

// we are in a "dumb" terminal like in acme or writing to a file

self.terminal = stderr;

}

@@ -200,7 +201,7 @@ fn refreshWithHeldLock(self: *Progress) void {

if (self.supports_ansi_escape_codes) {

end += (std.fmt.bufPrint(self.output_buffer[end..], "\x1b[{d}D", .{self.columns_written}) catch unreachable).len;

end += (std.fmt.bufPrint(self.output_buffer[end..], "\x1b[0K", .{}) catch unreachable).len;

} else if (std.builtin.os.tag == .windows) winapi: {

} else if (builtin.os.tag == .windows) winapi: {

std.debug.assert(self.is_windows_terminal);

var info: windows.CONSOLE_SCREEN_BUFFER_INFO = undefined;

lib/std/Thread/AutoResetEvent.zig added: 771, removed: 743, total 28

@@ -26,7 +26,7 @@

state: usize = UNSET,

const std = @import("../std.zig");

const builtin = std.builtin;

const builtin = @import("builtin");

const testing = std.testing;

const assert = std.debug.assert;

const StaticResetEvent = std.Thread.StaticResetEvent;

lib/std/Thread/Condition.zig added: 771, removed: 743, total 28

@@ -5,6 +5,7 @@

impl: Impl = .{},

const std = @import("../std.zig");

const builtin = @import("builtin");

const Condition = @This();

const windows = std.os.windows;

const linux = std.os.linux;

@@ -23,9 +24,9 @@ pub fn broadcast(cond: *Condition) void {

cond.impl.broadcast();

}

const Impl = if (std.builtin.single_threaded)

const Impl = if (builtin.single_threaded)

SingleThreadedCondition

else if (std.Target.current.os.tag == .windows)

else if (builtin.os.tag == .windows)

WindowsCondition

else if (std.Thread.use_pthreads)

PthreadCondition

@@ -101,7 +102,7 @@ pub const AtomicCondition = struct {

fn wait(cond: *@This()) void {

while (@atomicLoad(i32, &cond.futex, .Acquire) == 0) {

switch (std.Target.current.os.tag) {

switch (builtin.os.tag) {

.linux => {

switch (linux.getErrno(linux.futex_wait(

&cond.futex,

@@ -123,7 +124,7 @@ pub const AtomicCondition = struct {

fn notify(cond: *@This()) void {

@atomicStore(i32, &cond.futex, 1, .Release);

switch (std.Target.current.os.tag) {

switch (builtin.os.tag) {

.linux => {

switch (linux.getErrno(linux.futex_wake(

&cond.futex,

lib/std/Thread/Futex.zig added: 771, removed: 743, total 28

@@ -4,10 +4,11 @@

//! Using Futex, other Thread synchronization primitives can be built which efficiently wait for cross-thread events or signals.

const std = @import("../std.zig");

const builtin = @import("builtin");

const Futex = @This();

const target = std.Target.current;

const single_threaded = std.builtin.single_threaded;

const target = builtin.target;

const single_threaded = builtin.single_threaded;

const assert = std.debug.assert;

const testing = std.testing;

@@ -70,7 +71,7 @@ else if (target.os.tag == .linux)

LinuxFutex

else if (target.isDarwin())

DarwinFutex

else if (std.builtin.link_libc)

else if (builtin.link_libc)

PosixFutex

else

UnsupportedFutex;

lib/std/Thread/Mutex.zig added: 771, removed: 743, total 28

@@ -24,7 +24,7 @@ impl: Impl = .{},

const Mutex = @This();

const std = @import("../std.zig");

const builtin = std.builtin;

const builtin = @import("builtin");

const os = std.os;

const assert = std.debug.assert;

const windows = os.windows;

@@ -160,7 +160,7 @@ pub const AtomicMutex = struct {

.unlocked => return,

else => {},

}

switch (std.Target.current.os.tag) {

switch (builtin.os.tag) {

.linux => {

switch (linux.getErrno(linux.futex_wait(

@ptrCast(*const i32, &m.state),

@@ -182,7 +182,7 @@ pub const AtomicMutex = struct {

fn unlockSlow(m: *AtomicMutex) void {

@setCold(true);

switch (std.Target.current.os.tag) {

switch (builtin.os.tag) {

.linux => {

switch (linux.getErrno(linux.futex_wake(

@ptrCast(*const i32, &m.state),

lib/std/Thread/ResetEvent.zig added: 771, removed: 743, total 28

@@ -8,7 +8,7 @@

const ResetEvent = @This();

const std = @import("../std.zig");

const builtin = std.builtin;

const builtin = @import("builtin");

const testing = std.testing;

const assert = std.debug.assert;

const c = std.c;

@@ -19,7 +19,7 @@ impl: Impl,

pub const Impl = if (builtin.single_threaded)

std.Thread.StaticResetEvent.DebugEvent

else if (std.Target.current.isDarwin())

else if (builtin.target.isDarwin())

DarwinEvent

else if (std.Thread.use_pthreads)

PosixEvent

lib/std/Thread/StaticResetEvent.zig added: 771, removed: 743, total 28

@@ -8,6 +8,7 @@

//! the logic needs stronger API guarantees.

const std = @import("../std.zig");

const builtin = @import("builtin");

const StaticResetEvent = @This();

const assert = std.debug.assert;

const os = std.os;

@@ -18,7 +19,7 @@ const testing = std.testing;

impl: Impl = .{},

pub const Impl = if (std.builtin.single_threaded)

pub const Impl = if (builtin.single_threaded)

DebugEvent

else

AtomicEvent;

@@ -162,7 +163,7 @@ pub const AtomicEvent = struct {

@atomicStore(u32, &ev.waiters, 0, .Monotonic);

}

pub const Futex = switch (std.Target.current.os.tag) {

pub const Futex = switch (builtin.os.tag) {

.windows => WindowsFutex,

.linux => LinuxFutex,

else => SpinFutex,

@@ -322,7 +323,7 @@ test "basic usage" {

try testing.expectEqual(TimedWaitResult.event_set, event.timedWait(1));

// test cross-thread signaling

if (std.builtin.single_threaded)

if (builtin.single_threaded)

return;

const Context = struct {

lib/std/array_hash_map.zig added: 771, removed: 743, total 28

@@ -9,7 +9,6 @@ const trait = meta.trait;

const autoHash = std.hash.autoHash;

const Wyhash = std.hash.Wyhash;

const Allocator = mem.Allocator;

const builtin = std.builtin;

const hash_map = @This();

/// An ArrayHashMap with default hash and equal functions.

lib/std/atomic.zig added: 771, removed: 743, total 28

@@ -1,5 +1,5 @@

const std = @import("std.zig");

const target = std.Target.current;

const target = @import("builtin").target;

pub const Ordering = std.builtin.AtomicOrder;

lib/std/atomic/Atomic.zig added: 771, removed: 743, total 28

@@ -1,7 +1,7 @@

const std = @import("../std.zig");

const testing = std.testing;

const target = std.Target.current;

const target = @import("builtin").target;

const Ordering = std.atomic.Ordering;

pub fn Atomic(comptime T: type) type {

lib/std/atomic/queue.zig added: 771, removed: 743, total 28

@@ -1,5 +1,5 @@

const std = @import("../std.zig");

const builtin = std.builtin;

const builtin = @import("builtin");

const assert = std.debug.assert;

const expect = std.testing.expect;

lib/std/atomic/stack.zig added: 771, removed: 743, total 28

@@ -1,5 +1,6 @@

const std = @import("../std.zig");

const builtin = @import("builtin");

const assert = std.debug.assert;

const builtin = std.builtin;

const expect = std.testing.expect;

/// Many reader, many writer, non-allocating, thread-safe

@@ -67,7 +68,6 @@ pub fn Stack(comptime T: type) type {

};

}

const std = @import("../std.zig");

const Context = struct {

allocator: *std.mem.Allocator,

stack: *Stack(i32),

lib/std/build.zig added: 771, removed: 743, total 28

@@ -1,5 +1,5 @@

const std = @import("std.zig");

const builtin = std.builtin;

const builtin = @import("builtin");

const io = std.io;

const fs = std.fs;

const mem = std.mem;

@@ -62,7 +62,7 @@ pub const Builder = struct {

build_root: []const u8,

cache_root: []const u8,

global_cache_root: []const u8,

release_mode: ?builtin.Mode,

release_mode: ?std.builtin.Mode,

is_release: bool,

override_lib_dir: ?[]const u8,

vcpkg_root: VcpkgRoot,

@@ -633,18 +633,18 @@ pub const Builder = struct {

}

/// This provides the -Drelease option to the build user and does not give them the choice.

pub fn setPreferredReleaseMode(self: *Builder, mode: builtin.Mode) void {

pub fn setPreferredReleaseMode(self: *Builder, mode: std.builtin.Mode) void {

if (self.release_mode != null) {

@panic("setPreferredReleaseMode must be called before standardReleaseOptions and may not be called twice");

}

const description = self.fmt("Create a release build ({s})", .{@tagName(mode)});

self.is_release = self.option(bool, "release", description) orelse false;

self.release_mode = if (self.is_release) mode else builtin.Mode.Debug;

self.release_mode = if (self.is_release) mode else std.builtin.Mode.Debug;

}

/// If you call this without first calling `setPreferredReleaseMode` then it gives the build user

/// the choice of what kind of release.

pub fn standardReleaseOptions(self: *Builder) builtin.Mode {

pub fn standardReleaseOptions(self: *Builder) std.builtin.Mode {

if (self.release_mode) |mode| return mode;

const release_safe = self.option(bool, "release-safe", "Optimizations on and safety on") orelse false;

@@ -652,17 +652,17 @@ pub const Builder = struct {

const release_small = self.option(bool, "release-small", "Size optimizations on and safety off") orelse false;

const mode = if (release_safe and !release_fast and !release_small)

builtin.Mode.ReleaseSafe

std.builtin.Mode.ReleaseSafe

else if (release_fast and !release_safe and !release_small)

builtin.Mode.ReleaseFast

std.builtin.Mode.ReleaseFast

else if (release_small and !release_fast and !release_safe)

builtin.Mode.ReleaseSmall

std.builtin.Mode.ReleaseSmall

else if (!release_fast and !release_safe and !release_small)

builtin.Mode.Debug

std.builtin.Mode.Debug

else x: {

warn("Multiple release modes (of -Drelease-safe, -Drelease-fast and -Drelease-small)\n\n", .{});

self.markInvalidUserInput();

break :x builtin.Mode.Debug;

break :x std.builtin.Mode.Debug;

};

self.is_release = mode != .Debug;

self.release_mode = mode;

@@ -1290,7 +1290,7 @@ test "builder.findProgram compiles" {

}

/// Deprecated. Use `std.builtin.Version`.

pub const Version = builtin.Version;

pub const Version = std.builtin.Version;

/// Deprecated. Use `std.zig.CrossTarget`.

pub const Target = std.zig.CrossTarget;

@@ -1417,8 +1417,8 @@ pub const LibExeObjStep = struct {

version_script: ?[]const u8 = null,

out_filename: []const u8,

linkage: ?Linkage = null,

version: ?Version,

build_mode: builtin.Mode,

version: ?std.builtin.Version,

build_mode: std.builtin.Mode,

kind: Kind,

major_only_filename: ?[]const u8,

name_only_filename: ?[]const u8,

@@ -1447,8 +1447,8 @@ pub const LibExeObjStep = struct {

filter: ?[]const u8,

single_threaded: bool,

test_evented_io: bool = false,

code_model: builtin.CodeModel = .default,

wasi_exec_model: ?builtin.WasiExecModel = null,

code_model: std.builtin.CodeModel = .default,

wasi_exec_model: ?std.builtin.WasiExecModel = null,

root_src: ?FileSource,

out_h_filename: []const u8,

@@ -1550,7 +1550,7 @@ pub const LibExeObjStep = struct {

};

const SharedLibKind = union(enum) {

versioned: Version,

versioned: std.builtin.Version,

unversioned: void,

};

@@ -1585,7 +1585,7 @@ pub const LibExeObjStep = struct {

root_src_raw: ?FileSource,

kind: Kind,

linkage: ?Linkage,

ver: ?Version,

ver: ?std.builtin.Version,

) *LibExeObjStep {

const name = builder.dupe(name_raw);

const root_src: ?FileSource = if (root_src_raw) |rsrc| rsrc.dupe(builder) else null;

@@ -1599,7 +1599,7 @@ pub const LibExeObjStep = struct {

.builder = builder,

.verbose_link = false,

.verbose_cc = false,

.build_mode = builtin.Mode.Debug,

.build_mode = std.builtin.Mode.Debug,

.linkage = linkage,

.kind = kind,

.root_src = root_src,

@@ -1988,7 +1988,7 @@ pub const LibExeObjStep = struct {

self.verbose_cc = value;

}

pub fn setBuildMode(self: *LibExeObjStep, mode: builtin.Mode) void {

pub fn setBuildMode(self: *LibExeObjStep, mode: std.builtin.Mode) void {

self.build_mode = mode;

}

@@ -2553,7 +2553,7 @@ pub const LibExeObjStep = struct {

const resolved_include_path = self.builder.pathFromRoot(include_path);

const common_include_path = if (std.Target.current.os.tag == .windows and builder.sysroot != null and fs.path.isAbsolute(resolved_include_path)) blk: {

const common_include_path = if (builtin.os.tag == .windows and builder.sysroot != null and fs.path.isAbsolute(resolved_include_path)) blk: {

// We need to check for disk designator and strip it out from dir path so

// that zig/clang can concat resolved_include_path with sysroot.

const disk_designator = fs.path.diskDesignatorWindows(resolved_include_path);

@@ -3237,7 +3237,7 @@ test "LibExeObjStep.addPackage" {

test {

// The only purpose of this test is to get all these untested functions

// to be referenced to avoid regression so it is okay to skip some targets.

if (comptime std.Target.current.cpu.arch.ptrBitWidth() == 64) {

if (comptime builtin.cpu.arch.ptrBitWidth() == 64) {

std.testing.refAllDecls(@This());

std.testing.refAllDecls(Builder);

lib/std/build/OptionsStep.zig added: 771, removed: 743, total 28

@@ -1,4 +1,5 @@

const std = @import("../std.zig");

const builtin = @import("builtin");

const build = std.build;

const fs = std.fs;

const Step = build.Step;

@@ -219,7 +220,7 @@ const OptionFileSourceArg = struct {

};

test "OptionsStep" {

if (std.builtin.os.tag == .wasi) return error.SkipZigTest;

if (builtin.os.tag == .wasi) return error.SkipZigTest;

var arena = std.heap.ArenaAllocator.init(std.testing.allocator);

defer arena.deinit();

lib/std/build/RunStep.zig added: 771, removed: 743, total 28

@@ -1,5 +1,5 @@

const std = @import("../std.zig");

const builtin = std.builtin;

const builtin = @import("builtin");

const build = std.build;

const Step = build.Step;

const Builder = build.Builder;

lib/std/builtin.zig added: 771, removed: 743, total 28

@@ -1,26 +1,27 @@

const builtin = @import("builtin");

// These are all deprecated.

pub const zig_version = builtin.zig_version;

pub const zig_is_stage2 = builtin.zig_is_stage2;

pub const output_mode = builtin.output_mode;

pub const link_mode = builtin.link_mode;

pub const is_test = builtin.is_test;

pub const single_threaded = builtin.single_threaded;

pub const abi = builtin.abi;

pub const cpu = builtin.cpu;

pub const os = builtin.os;

pub const target = builtin.target;

pub const object_format = builtin.object_format;

pub const mode = builtin.mode;

pub const link_libc = builtin.link_libc;

pub const link_libcpp = builtin.link_libcpp;

pub const have_error_return_tracing = builtin.have_error_return_tracing;

pub const valgrind_support = builtin.valgrind_support;

pub const position_independent_code = builtin.position_independent_code;

pub const position_independent_executable = builtin.position_independent_executable;

pub const strip_debug_info = builtin.strip_debug_info;

pub const code_model = builtin.code_model;

// TODO delete these after releasing 0.9.0

pub const zig_version = @compileError("get this from @import(\"builtin\") instead of std.builtin");

pub const zig_is_stage2 = @compileError("get this from @import(\"builtin\") instead of std.builtin");

pub const output_mode = @compileError("get this from @import(\"builtin\") instead of std.builtin");

pub const link_mode = @compileError("get this from @import(\"builtin\") instead of std.builtin");

pub const is_test = @compileError("get this from @import(\"builtin\") instead of std.builtin");

pub const single_threaded = @compileError("get this from @import(\"builtin\") instead of std.builtin");

pub const abi = @compileError("get this from @import(\"builtin\") instead of std.builtin");

pub const cpu = @compileError("get this from @import(\"builtin\") instead of std.builtin");

pub const os = @compileError("get this from @import(\"builtin\") instead of std.builtin");

pub const target = @compileError("get this from @import(\"builtin\") instead of std.builtin");

pub const object_format = @compileError("get this from @import(\"builtin\") instead of std.builtin");

pub const mode = @compileError("get this from @import(\"builtin\") instead of std.builtin");

pub const link_libc = @compileError("get this from @import(\"builtin\") instead of std.builtin");

pub const link_libcpp = @compileError("get this from @import(\"builtin\") instead of std.builtin");

pub const have_error_return_tracing = @compileError("get this from @import(\"builtin\") instead of std.builtin");

pub const valgrind_support = @compileError("get this from @import(\"builtin\") instead of std.builtin");

pub const position_independent_code = @compileError("get this from @import(\"builtin\") instead of std.builtin");

pub const position_independent_executable = @compileError("get this from @import(\"builtin\") instead of std.builtin");

pub const strip_debug_info = @compileError("get this from @import(\"builtin\") instead of std.builtin");

pub const code_model = @compileError("get this from @import(\"builtin\") instead of std.builtin");

/// `explicit_subsystem` is missing when the subsystem is automatically detected,

/// so Zig standard library has the subsystem detection logic here. This should generally be

@@ -694,7 +695,7 @@ pub fn default_panic(msg: []const u8, error_return_trace: ?*StackTrace) noreturn

@breakpoint();

}

switch (os.tag) {

switch (builtin.os.tag) {

.freestanding => {

while (true) {

@breakpoint();

lib/std/c.zig added: 771, removed: 743, total 28

@@ -1,5 +1,5 @@

const std = @import("std");

const builtin = std.builtin;

const builtin = @import("builtin");

const c = @This();

const page_size = std.mem.page_size;

const iovec = std.os.iovec;

@@ -20,7 +20,7 @@ pub const Tokenizer = tokenizer.Tokenizer;

/// If linking gnu libc (glibc), the `ok` value will be true if the target

/// version is greater than or equal to `glibc_version`.

/// If linking a libc other than these, returns `false`.

pub fn versionCheck(glibc_version: builtin.Version) type {

pub fn versionCheck(glibc_version: std.builtin.Version) type {

return struct {

pub const ok = blk: {

if (!builtin.link_libc) break :blk false;

lib/std/c/darwin.zig added: 771, removed: 743, total 28

@@ -1,6 +1,6 @@

const std = @import("../std.zig");

const assert = std.debug.assert;

const builtin = @import("builtin");

const assert = std.debug.assert;

const macho = std.macho;

const native_arch = builtin.target.cpu.arch;

const maxInt = std.math.maxInt;

@@ -72,7 +72,7 @@ const mach_hdr = if (@sizeOf(usize) == 8) mach_header_64 else mach_header;

var dummy_execute_header: mach_hdr = undefined;

pub extern var _mh_execute_header: mach_hdr;

comptime {

if (std.Target.current.isDarwin()) {

if (builtin.target.isDarwin()) {

@export(dummy_execute_header, .{ .name = "_mh_execute_header", .linkage = .Weak });

}

lib/std/child_process.zig added: 771, removed: 743, total 28

@@ -1,4 +1,5 @@

const std = @import("std.zig");

const builtin = @import("builtin");

const cstr = std.cstr;

const unicode = std.unicode;

const io = std.io;

@@ -12,8 +13,7 @@ const mem = std.mem;

const math = std.math;

const debug = std.debug;

const BufMap = std.BufMap;

const builtin = std.builtin;

const Os = builtin.Os;

const Os = std.builtin.Os;

const TailQueue = std.TailQueue;

const maxInt = std.math.maxInt;

const assert = std.debug.assert;

@@ -561,9 +561,9 @@ pub const ChildProcess = struct {

if (self.env_map) |env_map| {

const envp_buf = try createNullDelimitedEnvMap(arena, env_map);

break :m envp_buf.ptr;

} else if (std.builtin.link_libc) {

} else if (builtin.link_libc) {

break :m std.c.environ;

} else if (std.builtin.output_mode == .Exe) {

} else if (builtin.output_mode == .Exe) {

// Then we have Zig start code and this works.

// TODO type-safety for null-termination of `os.environ`.

break :m @ptrCast([*:null]?[*:0]u8, os.environ.ptr);

lib/std/coff.zig added: 771, removed: 743, total 28

@@ -1,4 +1,3 @@

const builtin = std.builtin;

const std = @import("std.zig");

const io = std.io;

const mem = std.mem;

lib/std/crypto.zig added: 771, removed: 743, total 28

@@ -163,7 +163,7 @@ const std = @import("std.zig");

pub const errors = @import("crypto/errors.zig");

test "crypto" {

const please_windows_dont_oom = std.Target.current.os.tag == .windows;

const please_windows_dont_oom = @import("builtin").os.tag == .windows;

if (please_windows_dont_oom) return error.SkipZigTest;

inline for (std.meta.declarations(@This())) |decl| {

lib/std/crypto/aes.zig added: 771, removed: 743, total 28

@@ -1,13 +1,13 @@

const std = @import("../std.zig");

const builtin = @import("builtin");

const testing = std.testing;

const builtin = std.builtin;

const has_aesni = std.Target.x86.featureSetHas(std.Target.current.cpu.features, .aes);

const has_avx = std.Target.x86.featureSetHas(std.Target.current.cpu.features, .avx);

const has_armaes = std.Target.aarch64.featureSetHas(std.Target.current.cpu.features, .aes);

const impl = if (std.Target.current.cpu.arch == .x86_64 and has_aesni and has_avx) impl: {

const has_aesni = std.Target.x86.featureSetHas(builtin.cpu.features, .aes);

const has_avx = std.Target.x86.featureSetHas(builtin.cpu.features, .avx);

const has_armaes = std.Target.aarch64.featureSetHas(builtin.cpu.features, .aes);

const impl = if (builtin.cpu.arch == .x86_64 and has_aesni and has_avx) impl: {

break :impl @import("aes/aesni.zig");

} else if (std.Target.current.cpu.arch == .aarch64 and has_armaes)

} else if (builtin.cpu.arch == .aarch64 and has_armaes)

impl: {

break :impl @import("aes/armcrypto.zig");

} else impl: {

@@ -41,7 +41,7 @@ test "ctr" {

var out: [exp_out.len]u8 = undefined;

var ctx = Aes128.initEnc(key);

ctr(AesEncryptCtx(Aes128), ctx, out[0..], in[0..], iv, builtin.Endian.Big);

ctr(AesEncryptCtx(Aes128), ctx, out[0..], in[0..], iv, std.builtin.Endian.Big);

try testing.expectEqualSlices(u8, exp_out[0..], out[0..]);

}

lib/std/crypto/aes/aesni.zig added: 771, removed: 743, total 28

@@ -1,4 +1,5 @@

const std = @import("../../std.zig");

const builtin = @import("builtin");

const mem = std.mem;

const debug = std.debug;

const Vector = std.meta.Vector;

@@ -97,7 +98,7 @@ pub const Block = struct {

const cpu = std.Target.x86.cpu;

/// The recommended number of AES encryption/decryption to perform in parallel for the chosen implementation.

pub const optimal_parallel_blocks = switch (std.Target.current.cpu.model) {

pub const optimal_parallel_blocks = switch (builtin.cpu.model) {

&cpu.westmere => 6,

&cpu.sandybridge, &cpu.ivybridge => 8,

&cpu.haswell, &cpu.broadwell => 7,

lib/std/crypto/aes_gcm.zig added: 771, removed: 743, total 28

@@ -1,6 +1,5 @@

const std = @import("std");

const assert = std.debug.assert;

const builtin = std.builtin;

const crypto = std.crypto;

const debug = std.debug;

const Ghash = std.crypto.onetimeauth.Ghash;

@@ -40,7 +39,7 @@ fn AesGcm(comptime Aes: anytype) type {

mac.pad();

mem.writeIntBig(u32, j[nonce_length..][0..4], 2);

modes.ctr(@TypeOf(aes), aes, c, m, j, builtin.Endian.Big);

modes.ctr(@TypeOf(aes), aes, c, m, j, std.builtin.Endian.Big);

mac.update(c[0..m.len][0..]);

mac.pad();

@@ -94,7 +93,7 @@ fn AesGcm(comptime Aes: anytype) type {

}

mem.writeIntBig(u32, j[nonce_length..][0..4], 2);

modes.ctr(@TypeOf(aes), aes, m, c, j, builtin.Endian.Big);

modes.ctr(@TypeOf(aes), aes, m, c, j, std.builtin.Endian.Big);

}

};

}

lib/std/crypto/aes_ocb.zig added: 771, removed: 743, total 28

@@ -1,4 +1,5 @@

const std = @import("std");

const builtin = @import("builtin");

const crypto = std.crypto;

const aes = crypto.core.aes;

const assert = std.debug.assert;

@@ -100,9 +101,9 @@ fn AesOcb(comptime Aes: anytype) type {

return offset;

}

const has_aesni = std.Target.x86.featureSetHas(std.Target.current.cpu.features, .aes);

const has_armaes = std.Target.aarch64.featureSetHas(std.Target.current.cpu.features, .aes);

const wb: usize = if ((std.Target.current.cpu.arch == .x86_64 and has_aesni) or (std.Target.current.cpu.arch == .aarch64 and has_armaes)) 4 else 0;

const has_aesni = std.Target.x86.featureSetHas(builtin.cpu.features, .aes);

const has_armaes = std.Target.aarch64.featureSetHas(builtin.cpu.features, .aes);

const wb: usize = if ((builtin.cpu.arch == .x86_64 and has_aesni) or (builtin.cpu.arch == .aarch64 and has_armaes)) 4 else 0;

/// c: ciphertext: output buffer should be of size m.len

/// tag: authentication tag: output MAC

lib/std/crypto/benchmark.zig added: 771, removed: 743, total 28

@@ -1,7 +1,7 @@

// zig run -O ReleaseFast --zig-lib-dir ../.. benchmark.zig

const std = @import("../std.zig");

const builtin = std.builtin;

const builtin = @import("builtin");

const mem = std.mem;

const time = std.time;

const Timer = time.Timer;

lib/std/crypto/blake3.zig added: 771, removed: 743, total 28

@@ -2,6 +2,7 @@

// Source: https://github.com/BLAKE3-team/BLAKE3

const std = @import("../std.zig");

const builtin = @import("builtin");

const fmt = std.fmt;

const math = std.math;

const mem = std.mem;

@@ -200,7 +201,7 @@ const CompressGeneric = struct {

}

};

const compress = if (std.Target.current.cpu.arch == .x86_64) CompressVectorized.compress else CompressGeneric.compress;

const compress = if (builtin.cpu.arch == .x86_64) CompressVectorized.compress else CompressGeneric.compress;

fn first8Words(words: [16]u32) [8]u32 {

return @ptrCast(*const [8]u32, &words).*;

lib/std/crypto/chacha20.zig added: 771, removed: 743, total 28

@@ -1,6 +1,7 @@

// Based on public domain Supercop by Daniel J. Bernstein

const std = @import("../std.zig");

const builtin = @import("builtin");

const math = std.math;

const mem = std.mem;

const assert = std.debug.assert;

@@ -359,7 +360,7 @@ fn ChaChaNonVecImpl(comptime rounds_nb: usize) type {

}

fn ChaChaImpl(comptime rounds_nb: usize) type {

return if (std.Target.current.cpu.arch == .x86_64) ChaChaVecImpl(rounds_nb) else ChaChaNonVecImpl(rounds_nb);

return if (builtin.cpu.arch == .x86_64) ChaChaVecImpl(rounds_nb) else ChaChaNonVecImpl(rounds_nb);

}

fn keyToWords(key: [32]u8) [8]u32 {

lib/std/crypto/ghash.zig added: 771, removed: 743, total 28

@@ -2,6 +2,7 @@

// Adapted from BearSSL's ctmul64 implementation originally written by Thomas Pornin <pornin@bolet.org>

const std = @import("../std.zig");

const builtin = @import("builtin");

const assert = std.debug.assert;

const math = std.math;

const mem = std.mem;

@@ -45,7 +46,7 @@ pub const Ghash = struct {

const h2 = h0 ^ h1;

const h2r = h0r ^ h1r;

if (std.builtin.mode == .ReleaseSmall) {

if (builtin.mode == .ReleaseSmall) {

return Ghash{

.h0 = h0,

.h1 = h1,

@@ -132,12 +133,12 @@ pub const Ghash = struct {

return z0 | z1 | z2 | z3;

}

const has_pclmul = std.Target.x86.featureSetHas(std.Target.current.cpu.features, .pclmul);

const has_avx = std.Target.x86.featureSetHas(std.Target.current.cpu.features, .avx);

const has_armaes = std.Target.aarch64.featureSetHas(std.Target.current.cpu.features, .aes);

const clmul = if (std.Target.current.cpu.arch == .x86_64 and has_pclmul and has_avx) impl: {

const has_pclmul = std.Target.x86.featureSetHas(builtin.cpu.features, .pclmul);

const has_avx = std.Target.x86.featureSetHas(builtin.cpu.features, .avx);

const has_armaes = std.Target.aarch64.featureSetHas(builtin.cpu.features, .aes);

const clmul = if (builtin.cpu.arch == .x86_64 and has_pclmul and has_avx) impl: {

break :impl clmul_pclmul;

} else if (std.Target.current.cpu.arch == .aarch64 and has_armaes) impl: {

} else if (builtin.cpu.arch == .aarch64 and has_armaes) impl: {

break :impl clmul_pmull;

} else impl: {

break :impl clmul_soft;

@@ -151,7 +152,7 @@ pub const Ghash = struct {

var i: usize = 0;

// 2-blocks aggregated reduction

if (std.builtin.mode != .ReleaseSmall) {

if (builtin.mode != .ReleaseSmall) {

while (i + 32 <= msg.len) : (i += 32) {

// B0 * H^2 unreduced

y1 ^= mem.readIntBig(u64, msg[i..][0..8]);

lib/std/crypto/gimli.zig added: 771, removed: 743, total 28

@@ -1,13 +1,14 @@

// Gimli is a 384-bit permutation designed to achieve high security with high

// performance across a broad range of platforms, including 64-bit Intel/AMD

// server CPUs, 64-bit and 32-bit ARM smartphone CPUs, 32-bit ARM

// microcontrollers, 8-bit AVR microcontrollers, FPGAs, ASICs without

// side-channel protection, and ASICs with side-channel protection.

// https://gimli.cr.yp.to/

// https://csrc.nist.gov/CSRC/media/Projects/Lightweight-Cryptography/documents/round-1/spec-doc/gimli-spec.pdf

//! Gimli is a 384-bit permutation designed to achieve high security with high

//! performance across a broad range of platforms, including 64-bit Intel/AMD

//! server CPUs, 64-bit and 32-bit ARM smartphone CPUs, 32-bit ARM

//! microcontrollers, 8-bit AVR microcontrollers, FPGAs, ASICs without

//! side-channel protection, and ASICs with side-channel protection.

//!

//! https://gimli.cr.yp.to/

//! https://csrc.nist.gov/CSRC/media/Projects/Lightweight-Cryptography/documents/round-1/spec-doc/gimli-spec.pdf

const std = @import("../std.zig");

const builtin = @import("builtin");

const mem = std.mem;

const math = std.math;

const debug = std.debug;

@@ -152,9 +153,9 @@ pub const State = struct {

self.endianSwap();

}

pub const permute = if (std.Target.current.cpu.arch == .x86_64) impl: {

pub const permute = if (builtin.cpu.arch == .x86_64) impl: {

break :impl permute_vectorized;

} else if (std.builtin.mode == .ReleaseSmall) impl: {

} else if (builtin.mode == .ReleaseSmall) impl: {

break :impl permute_small;

} else impl: {

break :impl permute_unrolled;

lib/std/crypto/modes.zig added: 771, removed: 743, total 28

@@ -1,7 +1,6 @@

// Based on Go stdlib implementation

const std = @import("../std.zig");

const builtin = std.builtin;

const mem = std.mem;

const debug = std.debug;

@@ -11,7 +10,7 @@ const debug = std.debug;

///

/// Important: the counter mode doesn't provide authenticated encryption: the ciphertext can be trivially modified without this being detected.

/// As a result, applications should generally never use it directly, but only in a construction that includes a MAC.

pub fn ctr(comptime BlockCipher: anytype, block_cipher: BlockCipher, dst: []u8, src: []const u8, iv: [BlockCipher.block_length]u8, endian: builtin.Endian) void {

pub fn ctr(comptime BlockCipher: anytype, block_cipher: BlockCipher, dst: []u8, src: []const u8, iv: [BlockCipher.block_length]u8, endian: std.builtin.Endian) void {

debug.assert(dst.len >= src.len);

const block_length = BlockCipher.block_length;

var counter: [BlockCipher.block_length]u8 = undefined;

lib/std/crypto/pcurves/common.zig added: 771, removed: 743, total 28

@@ -1,5 +1,4 @@

const std = @import("std");

const builtin = std.builtin;

const crypto = std.crypto;

const debug = std.debug;

const mem = std.mem;

@@ -51,7 +50,7 @@ pub fn Field(comptime params: FieldParams) type {

};

/// Reject non-canonical encodings of an element.

pub fn rejectNonCanonical(s_: [encoded_length]u8, endian: builtin.Endian) NonCanonicalError!void {

pub fn rejectNonCanonical(s_: [encoded_length]u8, endian: std.builtin.Endian) NonCanonicalError!void {

var s = if (endian == .Little) s_ else orderSwap(s_);

const field_order_s = comptime fos: {

var fos: [encoded_length]u8 = undefined;

@@ -71,7 +70,7 @@ pub fn Field(comptime params: FieldParams) type {

}

/// Unpack a field element.

pub fn fromBytes(s_: [encoded_length]u8, endian: builtin.Endian) NonCanonicalError!Fe {

pub fn fromBytes(s_: [encoded_length]u8, endian: std.builtin.Endian) NonCanonicalError!Fe {

var s = if (endian == .Little) s_ else orderSwap(s_);

try rejectNonCanonical(s, .Little);

var limbs_z: NonMontgomeryDomainFieldElement = undefined;

@@ -82,7 +81,7 @@ pub fn Field(comptime params: FieldParams) type {

}

/// Pack a field element.

pub fn toBytes(fe: Fe, endian: builtin.Endian) [encoded_length]u8 {

pub fn toBytes(fe: Fe, endian: std.builtin.Endian) [encoded_length]u8 {

var limbs_z: NonMontgomeryDomainFieldElement = undefined;

fiat.fromMontgomery(&limbs_z, fe.limbs);

var s: [encoded_length]u8 = undefined;

lib/std/crypto/pcurves/p256.zig added: 771, removed: 743, total 28

@@ -1,5 +1,4 @@

const std = @import("std");

const builtin = std.builtin;

const crypto = std.crypto;

const mem = std.mem;

const meta = std.meta;

@@ -59,7 +58,7 @@ pub const P256 = struct {

}

/// Create a point from serialized affine coordinates.

pub fn fromSerializedAffineCoordinates(xs: [32]u8, ys: [32]u8, endian: builtin.Endian) (NonCanonicalError || EncodingError)!P256 {

pub fn fromSerializedAffineCoordinates(xs: [32]u8, ys: [32]u8, endian: std.builtin.Endian) (NonCanonicalError || EncodingError)!P256 {

const x = try Fe.fromBytes(xs, endian);

const y = try Fe.fromBytes(ys, endian);

return fromAffineCoordinates(.{ .x = x, .y = y });

@@ -396,7 +395,7 @@ pub const P256 = struct {

/// Multiply an elliptic curve point by a scalar.

/// Return error.IdentityElement if the result is the identity element.

pub fn mul(p: P256, s_: [32]u8, endian: builtin.Endian) IdentityElementError!P256 {

pub fn mul(p: P256, s_: [32]u8, endian: std.builtin.Endian) IdentityElementError!P256 {

const s = if (endian == .Little) s_ else Fe.orderSwap(s_);

if (p.is_base) {

return pcMul16(&basePointPc, s, false);

@@ -408,7 +407,7 @@ pub const P256 = struct {

/// Multiply an elliptic curve point by a *PUBLIC* scalar *IN VARIABLE TIME*

/// This can be used for signature verification.

pub fn mulPublic(p: P256, s_: [32]u8, endian: builtin.Endian) IdentityElementError!P256 {

pub fn mulPublic(p: P256, s_: [32]u8, endian: std.builtin.Endian) IdentityElementError!P256 {

const s = if (endian == .Little) s_ else Fe.orderSwap(s_);

if (p.is_base) {

return pcMul16(&basePointPc, s, true);

@@ -420,7 +419,7 @@ pub const P256 = struct {

/// Double-base multiplication of public parameters - Compute (p1*s1)+(p2*s2) *IN VARIABLE TIME*

/// This can be used for signature verification.

pub fn mulDoubleBasePublic(p1: P256, s1_: [32]u8, p2: P256, s2_: [32]u8, endian: builtin.Endian) IdentityElementError!P256 {

pub fn mulDoubleBasePublic(p1: P256, s1_: [32]u8, p2: P256, s2_: [32]u8, endian: std.builtin.Endian) IdentityElementError!P256 {

const s1 = if (endian == .Little) s1_ else Fe.orderSwap(s1_);

const s2 = if (endian == .Little) s2_ else Fe.orderSwap(s2_);

try p1.rejectIdentity();

lib/std/crypto/pcurves/p256/p256_64.zig added: 771, removed: 743, total 28

@@ -18,7 +18,7 @@

// if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256

const std = @import("std");

const mode = std.builtin.mode; // Checked arithmetic is disabled in non-debug modes to avoid side channels

const mode = @import("builtin").mode; // Checked arithmetic is disabled in non-debug modes to avoid side channels

// The type MontgomeryDomainFieldElement is a field element in the Montgomery domain.

// Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]

lib/std/crypto/pcurves/p256/p256_scalar_64.zig added: 771, removed: 743, total 28

@@ -18,7 +18,7 @@

// if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256

const std = @import("std");

const mode = std.builtin.mode; // Checked arithmetic is disabled in non-debug modes to avoid side channels

const mode = @import("builtin").mode; // Checked arithmetic is disabled in non-debug modes to avoid side channels

// The type MontgomeryDomainFieldElement is a field element in the Montgomery domain.

// Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]

lib/std/crypto/pcurves/p256/scalar.zig added: 771, removed: 743, total 28

@@ -1,5 +1,4 @@

const std = @import("std");

const builtin = std.builtin;

const common = @import("../common.zig");

const crypto = std.crypto;

const debug = std.debug;

@@ -26,47 +25,47 @@ const Fe = Field(.{

});

/// Reject a scalar whose encoding is not canonical.

pub fn rejectNonCanonical(s: CompressedScalar, endian: builtin.Endian) NonCanonicalError!void {

pub fn rejectNonCanonical(s: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!void {

return Fe.rejectNonCanonical(s, endian);

}

/// Reduce a 48-bytes scalar to the field size.

pub fn reduce48(s: [48]u8, endian: builtin.Endian) CompressedScalar {

pub fn reduce48(s: [48]u8, endian: std.builtin.Endian) CompressedScalar {

return Scalar.fromBytes48(s, endian).toBytes(endian);

}

/// Reduce a 64-bytes scalar to the field size.

pub fn reduce64(s: [64]u8, endian: builtin.Endian) CompressedScalar {

pub fn reduce64(s: [64]u8, endian: std.builtin.Endian) CompressedScalar {

return ScalarDouble.fromBytes64(s, endian).toBytes(endian);

}

/// Return a*b (mod L)

pub fn mul(a: CompressedScalar, b: CompressedScalar, endian: builtin.Endian) NonCanonicalError!CompressedScalar {

pub fn mul(a: CompressedScalar, b: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!CompressedScalar {

return (try Scalar.fromBytes(a, endian)).mul(try Scalar.fromBytes(b, endian)).toBytes(endian);

}

/// Return a*b+c (mod L)

pub fn mulAdd(a: CompressedScalar, b: CompressedScalar, c: CompressedScalar, endian: builtin.Endian) NonCanonicalError!CompressedScalar {

pub fn mulAdd(a: CompressedScalar, b: CompressedScalar, c: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!CompressedScalar {

return (try Scalar.fromBytes(a, endian)).mul(try Scalar.fromBytes(b, endian)).add(try Scalar.fromBytes(c, endian)).toBytes(endian);

}

/// Return a+b (mod L)

pub fn add(a: CompressedScalar, b: CompressedScalar, endian: builtin.Endian) NonCanonicalError!CompressedScalar {

pub fn add(a: CompressedScalar, b: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!CompressedScalar {

return (try Scalar.fromBytes(a, endian)).add(try Scalar.fromBytes(b, endian)).toBytes(endian);

}

/// Return -s (mod L)

pub fn neg(s: CompressedScalar, endian: builtin.Endian) NonCanonicalError!CompressedScalar {

pub fn neg(s: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!CompressedScalar {

return (try Scalar.fromBytes(s, endian)).neg().toBytes(endian);

}

/// Return (a-b) (mod L)

pub fn sub(a: CompressedScalar, b: CompressedScalar, endian: builtin.Endian) NonCanonicalError!CompressedScalar {

pub fn sub(a: CompressedScalar, b: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!CompressedScalar {

return (try Scalar.fromBytes(a, endian)).sub(try Scalar.fromBytes(b.endian)).toBytes(endian);

}

/// Return a random scalar

pub fn random(endian: builtin.Endian) CompressedScalar {

pub fn random(endian: std.builtin.Endian) CompressedScalar {

return Scalar.random().toBytes(endian);

}

@@ -81,24 +80,24 @@ pub const Scalar = struct {

pub const one = Scalar{ .fe = Fe.one };

/// Unpack a serialized representation of a scalar.

pub fn fromBytes(s: CompressedScalar, endian: builtin.Endian) NonCanonicalError!Scalar {

pub fn fromBytes(s: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!Scalar {

return Scalar{ .fe = try Fe.fromBytes(s, endian) };

}

/// Reduce a 384 bit input to the field size.

pub fn fromBytes48(s: [48]u8, endian: builtin.Endian) Scalar {

pub fn fromBytes48(s: [48]u8, endian: std.builtin.Endian) Scalar {

const t = ScalarDouble.fromBytes(384, s, endian);

return t.reduce(384);

}

/// Reduce a 512 bit input to the field size.

pub fn fromBytes64(s: [64]u8, endian: builtin.Endian) Scalar {

pub fn fromBytes64(s: [64]u8, endian: std.builtin.Endian) Scalar {

const t = ScalarDouble.fromBytes(512, s, endian);

return t.reduce(512);

}

/// Pack a scalar into bytes.

pub fn toBytes(n: Scalar, endian: builtin.Endian) CompressedScalar {

pub fn toBytes(n: Scalar, endian: std.builtin.Endian) CompressedScalar {

return n.fe.toBytes(endian);

}

@@ -180,7 +179,7 @@ const ScalarDouble = struct {

x2: Fe,

x3: Fe,

fn fromBytes(comptime bits: usize, s_: [bits / 8]u8, endian: builtin.Endian) ScalarDouble {

fn fromBytes(comptime bits: usize, s_: [bits / 8]u8, endian: std.builtin.Endian) ScalarDouble {

debug.assert(bits > 0 and bits <= 512 and bits >= Fe.saturated_bits and bits <= Fe.saturated_bits * 3);

var s = s_;

lib/std/crypto/salsa20.zig added: 771, removed: 743, total 28

@@ -1,4 +1,5 @@

const std = @import("std");

const builtin = @import("builtin");

const crypto = std.crypto;

const debug = std.debug;

const math = std.math;

@@ -304,7 +305,7 @@ const Salsa20NonVecImpl = struct {

}

};

const Salsa20Impl = if (std.Target.current.cpu.arch == .x86_64) Salsa20VecImpl else Salsa20NonVecImpl;

const Salsa20Impl = if (builtin.cpu.arch == .x86_64) Salsa20VecImpl else Salsa20NonVecImpl;

fn keyToWords(key: [32]u8) [8]u32 {

var k: [8]u32 = undefined;

lib/std/crypto/tlcsprng.zig added: 771, removed: 743, total 28

@@ -4,6 +4,7 @@

//! directly to standard library users.

const std = @import("std");

const builtin = @import("builtin");

const root = @import("root");

const mem = std.mem;

const os = std.os;

@@ -12,7 +13,7 @@ const os = std.os;

/// point to thread-local variables.

pub var interface = std.rand.Random{ .fillFn = tlsCsprngFill };

const os_has_fork = switch (std.Target.current.os.tag) {

const os_has_fork = switch (builtin.os.tag) {

.dragonfly,

.freebsd,

.ios,

@@ -29,10 +30,10 @@ const os_has_fork = switch (std.Target.current.os.tag) {

else => false,

};

const os_has_arc4random = std.builtin.link_libc and @hasDecl(std.c, "arc4random_buf");

const os_has_arc4random = builtin.link_libc and @hasDecl(std.c, "arc4random_buf");

const want_fork_safety = os_has_fork and !os_has_arc4random and

(std.meta.globalOption("crypto_fork_safety", bool) orelse true);

const maybe_have_wipe_on_fork = std.Target.current.os.isAtLeast(.linux, .{

const maybe_have_wipe_on_fork = builtin.os.isAtLeast(.linux, .{

.major = 4,

.minor = 14,

}) orelse true;

@@ -55,7 +56,7 @@ var install_atfork_handler = std.once(struct {

threadlocal var wipe_mem: []align(mem.page_size) u8 = &[_]u8{};

fn tlsCsprngFill(_: *const std.rand.Random, buffer: []u8) void {

if (std.builtin.link_libc and @hasDecl(std.c, "arc4random_buf")) {

if (builtin.link_libc and @hasDecl(std.c, "arc4random_buf")) {

// arc4random is already a thread-local CSPRNG.

return std.c.arc4random_buf(buffer.ptr, buffer.len);

}

lib/std/cstr.zig added: 771, removed: 743, total 28

@@ -1,5 +1,5 @@

const std = @import("std.zig");

const builtin = std.builtin;

const builtin = @import("builtin");

const debug = std.debug;

const mem = std.mem;

const testing = std.testing;

lib/std/debug.zig added: 771, removed: 743, total 28

@@ -1,5 +1,5 @@

const std = @import("std.zig");

const builtin = std.builtin;

const builtin = @import("builtin");

const math = std.math;

const mem = std.mem;

const io = std.io;

@@ -16,8 +16,8 @@ const root = @import("root");

const maxInt = std.math.maxInt;

const File = std.fs.File;

const windows = std.os.windows;

const native_arch = std.Target.current.cpu.arch;

const native_os = std.Target.current.os.tag;

const native_arch = builtin.cpu.arch;

const native_os = builtin.os.tag;

const native_endian = native_arch.endian();

pub const runtime_safety = switch (builtin.mode) {

@@ -150,7 +150,7 @@ pub fn dumpStackTraceFromBase(bp: usize, ip: usize) void {

/// capture that many stack frames exactly, and then look for the first address,

/// chopping off the irrelevant frames and shifting so that the returned addresses pointer

/// equals the passed in addresses pointer.

pub fn captureStackTrace(first_address: ?usize, stack_trace: *builtin.StackTrace) void {

pub fn captureStackTrace(first_address: ?usize, stack_trace: *std.builtin.StackTrace) void {

if (native_os == .windows) {

const addrs = stack_trace.instruction_addresses;

const u32_addrs_len = @intCast(u32, addrs.len);

@@ -194,7 +194,7 @@ pub fn captureStackTrace(first_address: ?usize, stack_trace: *builtin.StackTrace

/// Tries to print a stack trace to stderr, unbuffered, and ignores any error returned.

/// TODO multithreaded awareness

pub fn dumpStackTrace(stack_trace: builtin.StackTrace) void {

pub fn dumpStackTrace(stack_trace: std.builtin.StackTrace) void {

nosuspend {

const stderr = io.getStdErr().writer();

if (builtin.strip_debug_info) {

@@ -235,7 +235,7 @@ pub fn panic(comptime format: []const u8, args: anytype) noreturn {

/// `panicExtra` is useful when you want to print out an `@errorReturnTrace`

/// and also print out some values.

pub fn panicExtra(

trace: ?*builtin.StackTrace,

trace: ?*std.builtin.StackTrace,

comptime format: []const u8,

args: anytype,

) noreturn {

@@ -253,7 +253,7 @@ pub fn panicExtra(

break :blk &buf;

};

builtin.panic(msg, trace);

std.builtin.panic(msg, trace);

}

/// Non-zero whenever the program triggered a panic.

@@ -269,7 +269,7 @@ threadlocal var panic_stage: usize = 0;

// `panicImpl` could be useful in implementing a custom panic handler which

// calls the default handler (on supported platforms)

pub fn panicImpl(trace: ?*const builtin.StackTrace, first_trace_addr: ?usize, msg: []const u8) noreturn {

pub fn panicImpl(trace: ?*const std.builtin.StackTrace, first_trace_addr: ?usize, msg: []const u8) noreturn {

@setCold(true);

if (enable_segfault_handler) {

@@ -339,7 +339,7 @@ const DIM = "\x1b[2m";

const RESET = "\x1b[0m";

pub fn writeStackTrace(

stack_trace: builtin.StackTrace,

stack_trace: std.builtin.StackTrace,

out_stream: anytype,

allocator: *mem.Allocator,

debug_info: *DebugInfo,

@@ -764,7 +764,7 @@ pub fn readElfDebugInfo(allocator: *mem.Allocator, elf_file: File) !ModuleDebugI

if (!mem.eql(u8, hdr.e_ident[0..4], "\x7fELF")) return error.InvalidElfMagic;

if (hdr.e_ident[elf.EI_VERSION] != 1) return error.InvalidElfVersion;

const endian: builtin.Endian = switch (hdr.e_ident[elf.EI_DATA]) {

const endian: std.builtin.Endian = switch (hdr.e_ident[elf.EI_DATA]) {

elf.ELFDATA2LSB => .Little,

elf.ELFDATA2MSB => .Big,

else => return error.InvalidElfEndian,

@@ -1002,7 +1002,7 @@ pub const DebugInfo = struct {

}

pub fn getModuleForAddress(self: *DebugInfo, address: usize) !*ModuleDebugInfo {

if (comptime std.Target.current.isDarwin()) {

if (comptime builtin.target.isDarwin()) {

return self.lookupModuleDyld(address);

} else if (native_os == .windows) {

return self.lookupModuleWin32(address);

lib/std/dwarf.zig added: 771, removed: 743, total 28

@@ -1,5 +1,4 @@

const std = @import("std.zig");

const builtin = std.builtin;

const debug = std.debug;

const fs = std.fs;

const io = std.io;

@@ -454,7 +453,7 @@ const LineNumberProgram = struct {

}

};

fn readUnitLength(in_stream: anytype, endian: builtin.Endian, is_64: *bool) !u64 {

fn readUnitLength(in_stream: anytype, endian: std.builtin.Endian, is_64: *bool) !u64 {

const first_32_bits = try in_stream.readInt(u32, endian);

is_64.* = (first_32_bits == 0xffffffff);

if (is_64.*) {

@@ -475,7 +474,7 @@ fn readAllocBytes(allocator: *mem.Allocator, in_stream: anytype, size: usize) ![

}

// TODO the nosuspends here are workarounds

fn readAddress(in_stream: anytype, endian: builtin.Endian, is_64: bool) !u64 {

fn readAddress(in_stream: anytype, endian: std.builtin.Endian, is_64: bool) !u64 {

return nosuspend if (is_64)

try in_stream.readInt(u64, endian)

else

@@ -488,12 +487,12 @@ fn parseFormValueBlockLen(allocator: *mem.Allocator, in_stream: anytype, size: u

}

// TODO the nosuspends here are workarounds

fn parseFormValueBlock(allocator: *mem.Allocator, in_stream: anytype, endian: builtin.Endian, size: usize) !FormValue {

fn parseFormValueBlock(allocator: *mem.Allocator, in_stream: anytype, endian: std.builtin.Endian, size: usize) !FormValue {

const block_len = try nosuspend in_stream.readVarInt(usize, endian, size);

return parseFormValueBlockLen(allocator, in_stream, block_len);

}

fn parseFormValueConstant(allocator: *mem.Allocator, in_stream: anytype, signed: bool, endian: builtin.Endian, comptime size: i32) !FormValue {

fn parseFormValueConstant(allocator: *mem.Allocator, in_stream: anytype, signed: bool, endian: std.builtin.Endian, comptime size: i32) !FormValue {

_ = allocator;

// TODO: Please forgive me, I've worked around zig not properly spilling some intermediate values here.

// `nosuspend` should be removed from all the function calls once it is fixed.

@@ -521,7 +520,7 @@ fn parseFormValueConstant(allocator: *mem.Allocator, in_stream: anytype, signed:

}

// TODO the nosuspends here are workarounds

fn parseFormValueRef(allocator: *mem.Allocator, in_stream: anytype, endian: builtin.Endian, size: i32) !FormValue {

fn parseFormValueRef(allocator: *mem.Allocator, in_stream: anytype, endian: std.builtin.Endian, size: i32) !FormValue {

_ = allocator;

return FormValue{

.Ref = switch (size) {

@@ -536,7 +535,7 @@ fn parseFormValueRef(allocator: *mem.Allocator, in_stream: anytype, endian: buil

}

// TODO the nosuspends here are workarounds

fn parseFormValue(allocator: *mem.Allocator, in_stream: anytype, form_id: u64, endian: builtin.Endian, is_64: bool) anyerror!FormValue {

fn parseFormValue(allocator: *mem.Allocator, in_stream: anytype, form_id: u64, endian: std.builtin.Endian, is_64: bool) anyerror!FormValue {

return switch (form_id) {

FORM.addr => FormValue{ .Address = try readAddress(in_stream, endian, @sizeOf(usize) == 8) },

FORM.block1 => parseFormValueBlock(allocator, in_stream, endian, 1),

@@ -593,7 +592,7 @@ fn getAbbrevTableEntry(abbrev_table: *const AbbrevTable, abbrev_code: u64) ?*con

}

pub const DwarfInfo = struct {

endian: builtin.Endian,

endian: std.builtin.Endian,

// No memory is owned by the DwarfInfo

debug_info: []const u8,

debug_abbrev: []const u8,

lib/std/dynamic_library.zig added: 771, removed: 743, total 28

@@ -1,6 +1,5 @@

const builtin = std.builtin;

const std = @import("std.zig");

const builtin = @import("builtin");

const mem = std.mem;

const os = std.os;

const assert = std.debug.assert;

lib/std/event/channel.zig added: 771, removed: 743, total 28

@@ -1,5 +1,5 @@

const std = @import("../std.zig");

const builtin = std.builtin;

const builtin = @import("builtin");

const assert = std.debug.assert;

const testing = std.testing;

const Loop = std.event.Loop;

lib/std/event/future.zig added: 771, removed: 743, total 28

@@ -1,7 +1,7 @@

const std = @import("../std.zig");

const builtin = @import("builtin");

const assert = std.debug.assert;

const testing = std.testing;

const builtin = std.builtin;

const Lock = std.event.Lock;

/// This is a value that starts out unavailable, until resolve() is called

lib/std/event/group.zig added: 771, removed: 743, total 28

@@ -1,5 +1,5 @@

const std = @import("../std.zig");

const builtin = std.builtin;

const builtin = @import("builtin");

const Lock = std.event.Lock;

const testing = std.testing;

const Allocator = std.mem.Allocator;

lib/std/event/lock.zig added: 771, removed: 743, total 28

@@ -1,5 +1,5 @@

const std = @import("../std.zig");

const builtin = std.builtin;

const builtin = @import("builtin");

const assert = std.debug.assert;

const testing = std.testing;

const mem = std.mem;

lib/std/event/loop.zig added: 771, removed: 743, total 28

@@ -1,5 +1,5 @@

const std = @import("../std.zig");

const builtin = std.builtin;

const builtin = @import("builtin");

const root = @import("root");

const assert = std.debug.assert;

const testing = std.testing;

@@ -9,7 +9,7 @@ const windows = os.windows;

const maxInt = std.math.maxInt;

const Thread = std.Thread;

const is_windows = std.Target.current.os.tag == .windows;

const is_windows = builtin.os.tag == .windows;

pub const Loop = struct {

next_tick_queue: std.atomic.Queue(anyframe),

@@ -191,7 +191,7 @@ pub const Loop = struct {

self.fs_thread.join();

};

if (!std.builtin.single_threaded)

if (!builtin.single_threaded)

try self.delay_queue.init();

}

@@ -825,7 +825,7 @@ pub const Loop = struct {

}

pub fn sleep(self: *Loop, nanoseconds: u64) void {

if (std.builtin.single_threaded)

if (builtin.single_threaded)

@compileError("TODO: integrate timers with epoll/kevent/iocp for single-threaded");

suspend {

lib/std/event/rwlock.zig added: 771, removed: 743, total 28

@@ -1,5 +1,5 @@

const std = @import("../std.zig");

const builtin = std.builtin;

const builtin = @import("builtin");

const assert = std.debug.assert;

const testing = std.testing;

const mem = std.mem;

lib/std/event/wait_group.zig added: 771, removed: 743, total 28

@@ -1,5 +1,5 @@

const std = @import("../std.zig");

const builtin = std.builtin;

const builtin = @import("builtin");

const Loop = std.event.Loop;

/// A WaitGroup keeps track and waits for a group of async tasks to finish.

lib/std/fs.zig added: 771, removed: 743, total 28

@@ -1,6 +1,6 @@

const root = @import("root");

const builtin = std.builtin;

const std = @import("std.zig");

const builtin = @import("builtin");

const root = @import("root");

const os = std.os;

const mem = std.mem;

const base64 = std.base64;

@@ -9,7 +9,7 @@ const Allocator = std.mem.Allocator;

const assert = std.debug.assert;

const math = std.math;

const is_darwin = std.Target.current.os.tag.isDarwin();

const is_darwin = builtin.os.tag.isDarwin();

pub const path = @import("fs/path.zig");

pub const File = @import("fs/file.zig").File;

@@ -2607,7 +2607,7 @@ const CopyFileError = error{SystemResources} || os.CopyFileRangeError || os.Send

// The copy starts at offset 0, the initial offsets are preserved.

// No metadata is transferred over.

fn copy_file(fd_in: os.fd_t, fd_out: os.fd_t) CopyFileError!void {

if (comptime std.Target.current.isDarwin()) {

if (comptime builtin.target.isDarwin()) {

const rc = os.system.fcopyfile(fd_in, fd_out, null, os.system.COPYFILE_DATA);

switch (os.errno(rc)) {

.SUCCESS => return,

@@ -2620,7 +2620,7 @@ fn copy_file(fd_in: os.fd_t, fd_out: os.fd_t) CopyFileError!void {

}

if (std.Target.current.os.tag == .linux) {

if (builtin.os.tag == .linux) {

// Try copy_file_range first as that works at the FS level and is the

// most efficient method (if available).

var offset: u64 = 0;

lib/std/fs/file.zig added: 771, removed: 743, total 28

@@ -1,14 +1,14 @@

const std = @import("../std.zig");

const builtin = std.builtin;

const builtin = @import("builtin");

const os = std.os;

const io = std.io;

const mem = std.mem;

const math = std.math;

const assert = std.debug.assert;

const windows = os.windows;

const Os = builtin.Os;

const Os = std.builtin.Os;

const maxInt = std.math.maxInt;

const is_windows = std.Target.current.os.tag == .windows;

const is_windows = builtin.os.tag == .windows;

pub const File = struct {

/// The OS-specific file descriptor or file handle.

lib/std/fs/get_app_data_dir.zig added: 771, removed: 743, total 28

@@ -1,5 +1,5 @@

const std = @import("../std.zig");

const builtin = std.builtin;

const builtin = @import("builtin");

const unicode = std.unicode;

const mem = std.mem;

const fs = std.fs;

lib/std/fs/test.zig added: 771, removed: 743, total 28

@@ -1,6 +1,6 @@

const std = @import("../std.zig");

const builtin = @import("builtin");

const testing = std.testing;

const builtin = std.builtin;

const fs = std.fs;

const mem = std.mem;

const wasi = std.os.wasi;

lib/std/fs/wasi.zig added: 771, removed: 743, total 28

@@ -1,4 +1,5 @@

const std = @import("std");

const builtin = @import("builtin");

const os = std.os;

const mem = std.mem;

const math = std.math;

@@ -165,7 +166,7 @@ pub const PreopenList = struct {

};

test "extracting WASI preopens" {

if (std.builtin.os.tag != .wasi or std.builtin.link_libc) return error.SkipZigTest;

if (builtin.os.tag != .wasi or builtin.link_libc) return error.SkipZigTest;

var preopens = PreopenList.init(std.testing.allocator);

defer preopens.deinit();

lib/std/fs/watch.zig added: 771, removed: 743, total 28

@@ -1,5 +1,5 @@

const std = @import("std");

const builtin = std.builtin;

const builtin = @import("builtin");

const event = std.event;

const assert = std.debug.assert;

const testing = std.testing;

@@ -250,7 +250,7 @@ pub fn Watch(comptime V: type) type {

};

// @TODO Can I close this fd and get an error from bsdWaitKev?

const flags = if (comptime std.Target.current.isDarwin()) os.O.SYMLINK | os.O.EVTONLY else 0;

const flags = if (comptime builtin.target.isDarwin()) os.O.SYMLINK | os.O.EVTONLY else 0;

const fd = try os.open(realpath, flags, 0);

gop.value_ptr.putter_frame = async self.kqPutEvents(fd, gop.key_ptr.*, gop.value_ptr.*);

return null;

lib/std/hash/auto_hash.zig added: 771, removed: 743, total 28

@@ -2,7 +2,6 @@ const std = @import("std");

const assert = std.debug.assert;

const mem = std.mem;

const meta = std.meta;

const builtin = std.builtin;

/// Describes how pointer types should be hashed.

pub const HashStrategy = enum {

@@ -233,7 +232,7 @@ fn testHashDeepRecursive(key: anytype) u64 {

test "typeContainsSlice" {

comptime {

try testing.expect(!typeContainsSlice(meta.Tag(builtin.TypeInfo)));

try testing.expect(!typeContainsSlice(meta.Tag(std.builtin.TypeInfo)));

try testing.expect(typeContainsSlice([]const u8));

try testing.expect(!typeContainsSlice(u8));

lib/std/hash/benchmark.zig added: 771, removed: 743, total 28

@@ -1,7 +1,7 @@

// zig run -O ReleaseFast --zig-lib-dir ../.. benchmark.zig

const builtin = std.builtin;

const std = @import("std");

const builtin = @import("builtin");

const time = std.time;

const Timer = time.Timer;

const hash = std.hash;

lib/std/hash/cityhash.zig added: 771, removed: 743, total 28

@@ -1,5 +1,4 @@

const std = @import("std");

const builtin = std.builtin;

inline fn offsetPtr(ptr: [*]const u8, offset: usize) [*]const u8 {

// ptr + offset doesn't work at comptime so we need this instead.

lib/std/hash/crc.zig added: 771, removed: 743, total 28

@@ -6,6 +6,7 @@

// still moderately fast just slow relative to the slicing approach.

const std = @import("../std.zig");

const builtin = @import("builtin");

const debug = std.debug;

const testing = std.testing;

@@ -97,7 +98,7 @@ pub fn Crc32WithPoly(comptime poly: Polynomial) type {

};

}

const please_windows_dont_oom = std.Target.current.os.tag == .windows;

const please_windows_dont_oom = builtin.os.tag == .windows;

test "crc32 ieee" {

if (please_windows_dont_oom) return error.SkipZigTest;

lib/std/heap.zig added: 771, removed: 743, total 28

@@ -1,11 +1,11 @@

const std = @import("std.zig");

const builtin = @import("builtin");

const root = @import("root");

const debug = std.debug;

const assert = debug.assert;

const testing = std.testing;

const mem = std.mem;

const os = std.os;

const builtin = std.builtin;

const c = std.c;

const maxInt = std.math.maxInt;

@@ -209,9 +209,9 @@ fn rawCResize(

/// This allocator makes a syscall directly for every allocation and free.

/// Thread-safe and lock-free.

pub const page_allocator = if (std.Target.current.isWasm())

pub const page_allocator = if (builtin.target.isWasm())

&wasm_page_allocator_state

else if (std.Target.current.os.tag == .freestanding)

else if (builtin.target.os.tag == .freestanding)

root.os.heap.page_allocator

else

&page_allocator_state;

@@ -402,7 +402,7 @@ const PageAllocator = struct {

const WasmPageAllocator = struct {

comptime {

if (!std.Target.current.isWasm()) {

if (!builtin.target.isWasm()) {

@compileError("WasmPageAllocator is only available for wasm32 arch");

}

@@ -608,11 +608,11 @@ pub const HeapAllocator = switch (builtin.os.tag) {

const self = @fieldParentPtr(HeapAllocator, "allocator", allocator);

const amt = n + ptr_align - 1 + @sizeOf(usize);

const optional_heap_handle = @atomicLoad(?HeapHandle, &self.heap_handle, builtin.AtomicOrder.SeqCst);

const optional_heap_handle = @atomicLoad(?HeapHandle, &self.heap_handle, .SeqCst);

const heap_handle = optional_heap_handle orelse blk: {

const options = if (builtin.single_threaded) os.windows.HEAP_NO_SERIALIZE else 0;

const hh = os.windows.kernel32.HeapCreate(options, amt, 0) orelse return error.OutOfMemory;

const other_hh = @cmpxchgStrong(?HeapHandle, &self.heap_handle, null, hh, builtin.AtomicOrder.SeqCst, builtin.AtomicOrder.SeqCst) orelse break :blk hh;

const other_hh = @cmpxchgStrong(?HeapHandle, &self.heap_handle, null, hh, .SeqCst, .SeqCst) orelse break :blk hh;

os.windows.HeapDestroy(hh);

break :blk other_hh.?; // can't be null because of the cmpxchg

};

@@ -792,7 +792,7 @@ pub const ThreadSafeFixedBufferAllocator = blk: {

_ = len_align;

_ = ra;

const self = @fieldParentPtr(ThreadSafeFixedBufferAllocator, "allocator", allocator);

var end_index = @atomicLoad(usize, &self.end_index, builtin.AtomicOrder.SeqCst);

var end_index = @atomicLoad(usize, &self.end_index, .SeqCst);

while (true) {

const adjust_off = mem.alignPointerOffset(self.buffer.ptr + end_index, ptr_align) orelse

return error.OutOfMemory;

@@ -801,7 +801,7 @@ pub const ThreadSafeFixedBufferAllocator = blk: {

if (new_end_index > self.buffer.len) {

return error.OutOfMemory;

}

end_index = @cmpxchgWeak(usize, &self.end_index, end_index, new_end_index, builtin.AtomicOrder.SeqCst, builtin.AtomicOrder.SeqCst) orelse return self.buffer[adjusted_index..new_end_index];

end_index = @cmpxchgWeak(usize, &self.end_index, end_index, new_end_index, .SeqCst, .SeqCst) orelse return self.buffer[adjusted_index..new_end_index];

}

@@ -884,7 +884,7 @@ test "raw_c_allocator" {

}

test "WasmPageAllocator internals" {

if (comptime std.Target.current.isWasm()) {

if (comptime builtin.target.isWasm()) {

const conventional_memsize = WasmPageAllocator.conventional.totalPages() * mem.page_size;

const initial = try page_allocator.alloc(u8, mem.page_size);

try testing.expect(@ptrToInt(initial.ptr) < conventional_memsize); // If this isn't conventional, the rest of these tests don't make sense. Also we have a serious memory leak in the test suite.

@@ -924,7 +924,7 @@ test "PageAllocator" {

const allocator = page_allocator;

try testAllocator(allocator);

try testAllocatorAligned(allocator);

if (!std.Target.current.isWasm()) {

if (!builtin.target.isWasm()) {

try testAllocatorLargeAlignment(allocator);

try testAllocatorAlignedShrink(allocator);

}

lib/std/heap/general_purpose_allocator.zig added: 771, removed: 743, total 28

@@ -93,6 +93,7 @@

//! in a `std.HashMap` using the backing allocator.

const std = @import("std");

const builtin = @import("builtin");

const log = std.log.scoped(.gpa);

const math = std.math;

const assert = std.debug.assert;

@@ -104,7 +105,7 @@ const StackTrace = std.builtin.StackTrace;

/// Integer type for pointing to slots in a small allocation

const SlotIndex = std.meta.Int(.unsigned, math.log2(page_size) + 1);

const sys_can_stack_trace = switch (std.Target.current.cpu.arch) {

const sys_can_stack_trace = switch (builtin.cpu.arch) {

// Observed to go into an infinite loop.

// TODO: Make this work.

.mips,

@@ -115,13 +116,13 @@ const sys_can_stack_trace = switch (std.Target.current.cpu.arch) {

// "Non-Emscripten WebAssembly hasn't implemented __builtin_return_address".

.wasm32,

.wasm64,

=> std.Target.current.os.tag == .emscripten,

=> builtin.os.tag == .emscripten,

else => true,

};

const default_test_stack_trace_frames: usize = if (std.builtin.is_test) 8 else 4;

const default_test_stack_trace_frames: usize = if (builtin.is_test) 8 else 4;

const default_sys_stack_trace_frames: usize = if (sys_can_stack_trace) default_test_stack_trace_frames else 0;

const default_stack_trace_frames: usize = switch (std.builtin.mode) {

const default_stack_trace_frames: usize = switch (builtin.mode) {

.Debug => default_sys_stack_trace_frames,

else => 0,

};

@@ -141,7 +142,7 @@ pub const Config = struct {

safety: bool = std.debug.runtime_safety,

/// Whether the allocator may be used simultaneously from multiple threads.

thread_safe: bool = !std.builtin.single_threaded,

thread_safe: bool = !builtin.single_threaded,

/// What type of mutex you'd like to use, for thread safety.

/// when specfied, the mutex type must have the same shape as `std.Thread.Mutex` and

@@ -988,7 +989,7 @@ test "shrink large object to large object with larger alignment" {

var slice = try allocator.alignedAlloc(u8, 16, alloc_size);

defer allocator.free(slice);

const big_alignment: usize = switch (std.Target.current.os.tag) {

const big_alignment: usize = switch (builtin.os.tag) {

.windows => page_size * 32, // Windows aligns to 64K.

else => page_size * 2,

};

@@ -1058,7 +1059,7 @@ test "realloc large object to larger alignment" {

var slice = try allocator.alignedAlloc(u8, 16, page_size * 2 + 50);

defer allocator.free(slice);

const big_alignment: usize = switch (std.Target.current.os.tag) {

const big_alignment: usize = switch (builtin.os.tag) {

.windows => page_size * 32, // Windows aligns to 64K.

else => page_size * 2,

};

lib/std/io.zig added: 771, removed: 743, total 28

@@ -1,5 +1,5 @@

const std = @import("std.zig");

const builtin = std.builtin;

const builtin = @import("builtin");

const root = @import("root");

const c = std.c;

lib/std/io/bit_reader.zig added: 771, removed: 743, total 28

@@ -1,5 +1,4 @@

const std = @import("../std.zig");

const builtin = std.builtin;

const io = std.io;

const assert = std.debug.assert;

const testing = std.testing;

@@ -8,7 +7,7 @@ const meta = std.meta;

const math = std.math;

/// Creates a stream which allows for reading bit fields from another stream

pub fn BitReader(endian: builtin.Endian, comptime ReaderType: type) type {

pub fn BitReader(endian: std.builtin.Endian, comptime ReaderType: type) type {

return struct {

forward_reader: ReaderType,

bit_buffer: u7,

@@ -162,7 +161,7 @@ pub fn BitReader(endian: builtin.Endian, comptime ReaderType: type) type {

}

pub fn bitReader(

comptime endian: builtin.Endian,

comptime endian: std.builtin.Endian,

underlying_stream: anytype,

) BitReader(endian, @TypeOf(underlying_stream)) {

return BitReader(endian, @TypeOf(underlying_stream)).init(underlying_stream);

lib/std/io/bit_writer.zig added: 771, removed: 743, total 28

@@ -1,5 +1,4 @@

const std = @import("../std.zig");

const builtin = std.builtin;

const io = std.io;

const testing = std.testing;

const assert = std.debug.assert;

@@ -8,7 +7,7 @@ const meta = std.meta;

const math = std.math;

/// Creates a stream which allows for writing bit fields to another stream

pub fn BitWriter(endian: builtin.Endian, comptime WriterType: type) type {

pub fn BitWriter(endian: std.builtin.Endian, comptime WriterType: type) type {

return struct {

forward_writer: WriterType,

bit_buffer: u8,

@@ -138,7 +137,7 @@ pub fn BitWriter(endian: builtin.Endian, comptime WriterType: type) type {

}

pub fn bitWriter(

comptime endian: builtin.Endian,

comptime endian: std.builtin.Endian,

underlying_stream: anytype,

) BitWriter(endian, @TypeOf(underlying_stream)) {

return BitWriter(endian, @TypeOf(underlying_stream)).init(underlying_stream);

lib/std/io/c_writer.zig added: 771, removed: 743, total 28

@@ -1,5 +1,5 @@

const std = @import("../std.zig");

const builtin = std.builtin;

const builtin = @import("builtin");

const io = std.io;

const testing = std.testing;

const os = std.os;

lib/std/io/reader.zig added: 771, removed: 743, total 28

@@ -1,5 +1,4 @@

const std = @import("../std.zig");

const builtin = std.builtin;

const math = std.math;

const assert = std.debug.assert;

const mem = std.mem;

@@ -265,12 +264,12 @@ pub fn Reader(

return mem.readIntBig(T, &bytes);

}

pub fn readInt(self: Self, comptime T: type, endian: builtin.Endian) !T {

pub fn readInt(self: Self, comptime T: type, endian: std.builtin.Endian) !T {

const bytes = try self.readBytesNoEof((@typeInfo(T).Int.bits + 7) / 8);

return mem.readInt(T, &bytes, endian);

}

pub fn readVarInt(self: Self, comptime ReturnType: type, endian: builtin.Endian, size: usize) !ReturnType {

pub fn readVarInt(self: Self, comptime ReturnType: type, endian: std.builtin.Endian, size: usize) !ReturnType {

assert(size <= @sizeOf(ReturnType));

var bytes_buf: [@sizeOf(ReturnType)]u8 = undefined;

const bytes = bytes_buf[0..size];

@@ -310,7 +309,7 @@ pub fn Reader(

pub fn readStruct(self: Self, comptime T: type) !T {

// Only extern and packed structs have defined in-memory layout.

comptime assert(@typeInfo(T).Struct.layout != builtin.TypeInfo.ContainerLayout.Auto);

comptime assert(@typeInfo(T).Struct.layout != std.builtin.TypeInfo.ContainerLayout.Auto);

var res: [1]T = undefined;

try self.readNoEof(mem.sliceAsBytes(res[0..]));

return res[0];

@@ -319,7 +318,7 @@ pub fn Reader(

/// Reads an integer with the same size as the given enum's tag type. If the integer matches

/// an enum tag, casts the integer to the enum tag and returns it. Otherwise, returns an error.

/// TODO optimization taking advantage of most fields being in order

pub fn readEnum(self: Self, comptime Enum: type, endian: builtin.Endian) !Enum {

pub fn readEnum(self: Self, comptime Enum: type, endian: std.builtin.Endian) !Enum {

const E = error{

/// An integer was read, but it did not match any of the tags in the supplied enum.

InvalidValue,

lib/std/io/stream_source.zig added: 771, removed: 743, total 28

@@ -1,4 +1,5 @@

const std = @import("../std.zig");

const builtin = @import("builtin");

const io = std.io;

/// Provides `io.Reader`, `io.Writer`, and `io.SeekableStream` for in-memory buffers as

@@ -6,7 +7,7 @@ const io = std.io;

/// For memory sources, if the supplied byte buffer is const, then `io.Writer` is not available.

/// The error set of the stream functions is the error set of the corresponding file functions.

pub const StreamSource = union(enum) {

const has_file = (std.builtin.os.tag != .freestanding);

const has_file = (builtin.os.tag != .freestanding);

/// The stream access is redirected to this buffer.

buffer: io.FixedBufferStream([]u8),

lib/std/io/writer.zig added: 771, removed: 743, total 28

@@ -1,6 +1,5 @@

const std = @import("../std.zig");

const assert = std.debug.assert;

const builtin = std.builtin;

const mem = std.mem;

pub fn Writer(

@@ -77,7 +76,7 @@ pub fn Writer(

}

/// TODO audit non-power-of-two int sizes

pub fn writeInt(self: Self, comptime T: type, value: T, endian: builtin.Endian) Error!void {

pub fn writeInt(self: Self, comptime T: type, value: T, endian: std.builtin.Endian) Error!void {

var bytes: [(@typeInfo(T).Int.bits + 7) / 8]u8 = undefined;

mem.writeInt(T, &bytes, value, endian);

return self.writeAll(&bytes);

@@ -85,7 +84,7 @@ pub fn Writer(

pub fn writeStruct(self: Self, value: anytype) Error!void {

// Only extern and packed structs have defined in-memory layout.

comptime assert(@typeInfo(@TypeOf(value)).Struct.layout != builtin.TypeInfo.ContainerLayout.Auto);

comptime assert(@typeInfo(@TypeOf(value)).Struct.layout != std.builtin.TypeInfo.ContainerLayout.Auto);

return self.writeAll(mem.asBytes(&value));

}

};

lib/std/log.zig added: 771, removed: 743, total 28

@@ -69,7 +69,7 @@

//! ```

const std = @import("std.zig");

const builtin = std.builtin;

const builtin = @import("builtin");

const root = @import("root");

pub const Level = enum {

@@ -170,7 +170,7 @@ pub fn defaultLog(

comptime format: []const u8,

args: anytype,

) void {

if (std.Target.current.os.tag == .freestanding) {

if (builtin.os.tag == .freestanding) {

// On freestanding one must provide a log function; we do not have

// any I/O configured.

return;

lib/std/mem.zig added: 771, removed: 743, total 28

@@ -1,4 +1,5 @@

const std = @import("std.zig");

const builtin = @import("builtin");

const debug = std.debug;

const assert = debug.assert;

const math = std.math;

@@ -7,13 +8,13 @@ const meta = std.meta;

const trait = meta.trait;

const testing = std.testing;

const Endian = std.builtin.Endian;

const native_endian = std.Target.current.cpu.arch.endian();

const native_endian = builtin.cpu.arch.endian();

/// Compile time known minimum page size.

/// https://github.com/ziglang/zig/issues/4082

pub const page_size = switch (std.Target.current.cpu.arch) {

pub const page_size = switch (builtin.cpu.arch) {

.wasm32, .wasm64 => 64 * 1024,

.aarch64 => switch (std.Target.current.os.tag) {

.aarch64 => switch (builtin.os.tag) {

.macos, .ios, .watchos, .tvos => 16 * 1024,

else => 4 * 1024,

lib/std/meta.zig added: 771, removed: 743, total 28

@@ -1,5 +1,4 @@

const std = @import("std.zig");

const builtin = std.builtin;

const debug = std.debug;

const mem = std.mem;

const math = std.math;

@@ -9,7 +8,7 @@ const root = @import("root");

pub const trait = @import("meta/trait.zig");

pub const TrailerFlags = @import("meta/trailer_flags.zig").TrailerFlags;

const TypeInfo = builtin.TypeInfo;

const TypeInfo = std.builtin.TypeInfo;

pub fn tagName(v: anytype) []const u8 {

const T = @TypeOf(v);

@@ -858,7 +857,7 @@ pub fn declList(comptime Namespace: type, comptime Decl: type) []const *const De

pub const IntType = @compileError("replaced by std.meta.Int");

pub fn Int(comptime signedness: builtin.Signedness, comptime bit_count: u16) type {

pub fn Int(comptime signedness: std.builtin.Signedness, comptime bit_count: u16) type {

return @Type(TypeInfo{

.Int = .{

.signedness = signedness,

lib/std/meta/trait.zig added: 771, removed: 743, total 28

@@ -1,5 +1,4 @@

const std = @import("../std.zig");

const builtin = std.builtin;

const mem = std.mem;

const debug = std.debug;

const testing = std.testing;

@@ -98,7 +97,7 @@ test "std.meta.trait.hasField" {

try testing.expect(!hasField("value")(u8));

}

pub fn is(comptime id: builtin.TypeId) TraitFn {

pub fn is(comptime id: std.builtin.TypeId) TraitFn {

const Closure = struct {

pub fn trait(comptime T: type) bool {

return id == @typeInfo(T);

@@ -115,7 +114,7 @@ test "std.meta.trait.is" {

try testing.expect(!is(.Optional)(anyerror));

}

pub fn isPtrTo(comptime id: builtin.TypeId) TraitFn {

pub fn isPtrTo(comptime id: std.builtin.TypeId) TraitFn {

const Closure = struct {

pub fn trait(comptime T: type) bool {

if (!comptime isSingleItemPtr(T)) return false;

@@ -131,7 +130,7 @@ test "std.meta.trait.isPtrTo" {

try testing.expect(!isPtrTo(.Struct)(**struct {}));

}

pub fn isSliceOf(comptime id: builtin.TypeId) TraitFn {

pub fn isSliceOf(comptime id: std.builtin.TypeId) TraitFn {

const Closure = struct {

pub fn trait(comptime T: type) bool {

if (!comptime isSlice(T)) return false;

lib/std/net.zig added: 771, removed: 743, total 28

@@ -12,7 +12,7 @@ const native_endian = builtin.target.cpu.arch.endian();

// first release to support them.

pub const has_unix_sockets = @hasDecl(os.sockaddr, "un") and

(builtin.target.os.tag != .windows or

std.Target.current.os.version_range.windows.isAtLeast(.win10_rs4) orelse false);

builtin.os.version_range.windows.isAtLeast(.win10_rs4) orelse false);

pub const Address = extern union {

any: os.sockaddr,

@@ -1623,7 +1623,7 @@ pub const Stream = struct {

}

pub fn read(self: Stream, buffer: []u8) ReadError!usize {

if (std.Target.current.os.tag == .windows) {

if (builtin.os.tag == .windows) {

return os.windows.ReadFile(self.handle, buffer, null, io.default_mode);

}

@@ -1638,7 +1638,7 @@ pub const Stream = struct {

/// file system thread instead of non-blocking. It needs to be reworked to properly

/// use non-blocking I/O.

pub fn write(self: Stream, buffer: []const u8) WriteError!usize {

if (std.Target.current.os.tag == .windows) {

if (builtin.os.tag == .windows) {

return os.windows.WriteFile(self.handle, buffer, null, io.default_mode);

}

lib/std/net/test.zig added: 771, removed: 743, total 28

@@ -1,5 +1,5 @@

const std = @import("../std.zig");

const builtin = std.builtin;

const builtin = @import("builtin");

const net = std.net;

const mem = std.mem;

const testing = std.testing;

@@ -35,7 +35,7 @@ test "parse and render IPv6 addresses" {

var newIp = std.fmt.bufPrint(buffer[0..], "{}", .{addr}) catch unreachable;

try std.testing.expect(std.mem.eql(u8, printed[i], newIp[1 .. newIp.len - 3]));

if (std.builtin.os.tag == .linux) {

if (builtin.os.tag == .linux) {

var addr_via_resolve = net.Address.resolveIp6(ip, 0) catch unreachable;

var newResolvedIp = std.fmt.bufPrint(buffer[0..], "{}", .{addr_via_resolve}) catch unreachable;

try std.testing.expect(std.mem.eql(u8, printed[i], newResolvedIp[1 .. newResolvedIp.len - 3]));

@@ -49,7 +49,7 @@ test "parse and render IPv6 addresses" {

try testing.expectError(error.Incomplete, net.Address.parseIp6("FF01:", 0));

try testing.expectError(error.InvalidIpv4Mapping, net.Address.parseIp6("::123.123.123.123", 0));

// TODO Make this test pass on other operating systems.

if (std.builtin.os.tag == .linux) {

if (builtin.os.tag == .linux) {

try testing.expectError(error.Incomplete, net.Address.resolveIp6("ff01::fb%", 0));

try testing.expectError(error.Overflow, net.Address.resolveIp6("ff01::fb%wlp3s0s0s0s0s0s0s0s0", 0));

try testing.expectError(error.Overflow, net.Address.resolveIp6("ff01::fb%12345678901234", 0));

@@ -57,7 +57,7 @@ test "parse and render IPv6 addresses" {

}

test "invalid but parseable IPv6 scope ids" {

if (std.builtin.os.tag != .linux) {

if (builtin.os.tag != .linux) {

// Currently, resolveIp6 with alphanumerical scope IDs only works on Linux.

// TODO Make this test pass on other operating systems.

return error.SkipZigTest;

@@ -106,11 +106,11 @@ test "parse and render UNIX addresses" {

test "resolve DNS" {

if (builtin.os.tag == .wasi) return error.SkipZigTest;

if (std.builtin.os.tag == .windows) {

if (builtin.os.tag == .windows) {

_ = try std.os.windows.WSAStartup(2, 2);

}

defer {

if (std.builtin.os.tag == .windows) {

if (builtin.os.tag == .windows) {

std.os.windows.WSACleanup() catch unreachable;

}

@@ -143,11 +143,11 @@ test "listen on a port, send bytes, receive bytes" {

if (builtin.single_threaded) return error.SkipZigTest;

if (builtin.os.tag == .wasi) return error.SkipZigTest;

if (std.builtin.os.tag == .windows) {

if (builtin.os.tag == .windows) {

_ = try std.os.windows.WSAStartup(2, 2);

}

defer {

if (std.builtin.os.tag == .windows) {

if (builtin.os.tag == .windows) {

std.os.windows.WSACleanup() catch unreachable;

}

@@ -185,7 +185,7 @@ test "listen on a port, send bytes, receive bytes" {

test "listen on a port, send bytes, receive bytes" {

if (!std.io.is_async) return error.SkipZigTest;

if (std.builtin.os.tag != .linux and !std.builtin.os.tag.isDarwin()) {

if (builtin.os.tag != .linux and !builtin.os.tag.isDarwin()) {

// TODO build abstractions for other operating systems

return error.SkipZigTest;

}

@@ -207,7 +207,7 @@ test "listen on a port, send bytes, receive bytes" {

test "listen on ipv4 try connect on ipv6 then ipv4" {

if (!std.io.is_async) return error.SkipZigTest;

if (std.builtin.os.tag != .linux and !std.builtin.os.tag.isDarwin()) {

if (builtin.os.tag != .linux and !builtin.os.tag.isDarwin()) {

// TODO build abstractions for other operating systems

return error.SkipZigTest;

}

@@ -267,11 +267,11 @@ test "listen on a unix socket, send bytes, receive bytes" {

if (builtin.single_threaded) return error.SkipZigTest;

if (!net.has_unix_sockets) return error.SkipZigTest;

if (std.builtin.os.tag == .windows) {

if (builtin.os.tag == .windows) {

_ = try std.os.windows.WSAStartup(2, 2);

}

defer {

if (std.builtin.os.tag == .windows) {

if (builtin.os.tag == .windows) {

std.os.windows.WSACleanup() catch unreachable;

}

lib/std/once.zig added: 771, removed: 743, total 28

@@ -1,5 +1,5 @@

const std = @import("std.zig");

const builtin = std.builtin;

const builtin = @import("builtin");

const testing = std.testing;

pub fn once(comptime f: fn () void) Once(f) {

lib/std/os.zig added: 771, removed: 743, total 28

@@ -240,7 +240,7 @@ pub fn close(fd: fd_t) void {

_ = wasi.fd_close(fd);

return;

}

if (comptime std.Target.current.isDarwin()) {

if (comptime builtin.target.isDarwin()) {

// This avoids the EINTR problem.

switch (darwin.getErrno(darwin.@"close$NOCANCEL"(fd))) {

.BADF => unreachable, // Always a race condition.

@@ -487,7 +487,7 @@ pub fn read(fd: fd_t, buf: []u8) ReadError!usize {

}

// Prevents EINVAL.

const max_count = switch (std.Target.current.os.tag) {

const max_count = switch (builtin.os.tag) {

.linux => 0x7ffff000,

.macos, .ios, .watchos, .tvos => math.maxInt(i32),

else => math.maxInt(isize),

@@ -525,7 +525,7 @@ pub fn read(fd: fd_t, buf: []u8) ReadError!usize {

/// * Windows

/// On these systems, the read races with concurrent writes to the same file descriptor.

pub fn readv(fd: fd_t, iov: []const iovec) ReadError!usize {

if (std.Target.current.os.tag == .windows) {

if (builtin.os.tag == .windows) {

// TODO improve this to use ReadFileScatter

if (iov.len == 0) return @as(usize, 0);

const first = iov[0];

@@ -616,7 +616,7 @@ pub fn pread(fd: fd_t, buf: []u8, offset: u64) PReadError!usize {

}

// Prevent EINVAL.

const max_count = switch (std.Target.current.os.tag) {

const max_count = switch (builtin.os.tag) {

.linux => 0x7ffff000,

.macos, .ios, .watchos, .tvos => math.maxInt(i32),

else => math.maxInt(isize),

@@ -662,7 +662,7 @@ pub const TruncateError = error{

} || UnexpectedError;

pub fn ftruncate(fd: fd_t, length: u64) TruncateError!void {

if (std.Target.current.os.tag == .windows) {

if (builtin.os.tag == .windows) {

var io_status_block: windows.IO_STATUS_BLOCK = undefined;

var eof_info = windows.FILE_END_OF_FILE_INFORMATION{

.EndOfFile = @bitCast(windows.LARGE_INTEGER, length),

@@ -683,7 +683,7 @@ pub fn ftruncate(fd: fd_t, length: u64) TruncateError!void {

else => return windows.unexpectedStatus(rc),

}

if (std.Target.current.os.tag == .wasi and !builtin.link_libc) {

if (builtin.os.tag == .wasi and !builtin.link_libc) {

switch (wasi.fd_filestat_set_size(fd, length)) {

.SUCCESS => return,

.INTR => unreachable,

@@ -733,7 +733,7 @@ pub fn ftruncate(fd: fd_t, length: u64) TruncateError!void {

/// * Windows

/// On these systems, the read races with concurrent writes to the same file descriptor.

pub fn preadv(fd: fd_t, iov: []const iovec, offset: u64) PReadError!usize {

const have_pread_but_not_preadv = switch (std.Target.current.os.tag) {

const have_pread_but_not_preadv = switch (builtin.os.tag) {

.windows, .macos, .ios, .watchos, .tvos, .haiku => true,

else => false,

};

@@ -868,7 +868,7 @@ pub fn write(fd: fd_t, bytes: []const u8) WriteError!usize {

}

const max_count = switch (std.Target.current.os.tag) {

const max_count = switch (builtin.os.tag) {

.linux => 0x7ffff000,

.macos, .ios, .watchos, .tvos => math.maxInt(i32),

else => math.maxInt(isize),

@@ -916,7 +916,7 @@ pub fn write(fd: fd_t, bytes: []const u8) WriteError!usize {

///

/// If `iov.len` is larger than `IOV_MAX`, a partial write will occur.

pub fn writev(fd: fd_t, iov: []const iovec_const) WriteError!usize {

if (std.Target.current.os.tag == .windows) {

if (builtin.os.tag == .windows) {

// TODO improve this to use WriteFileScatter

if (iov.len == 0) return @as(usize, 0);

const first = iov[0];

@@ -991,7 +991,7 @@ pub const PWriteError = WriteError || error{Unseekable};

/// The limit on Darwin is `0x7fffffff`, trying to write more than that returns EINVAL.

/// The corresponding POSIX limit is `math.maxInt(isize)`.

pub fn pwrite(fd: fd_t, bytes: []const u8, offset: u64) PWriteError!usize {

if (std.Target.current.os.tag == .windows) {

if (builtin.os.tag == .windows) {

return windows.WriteFile(fd, bytes, offset, std.io.default_mode);

}

if (builtin.os.tag == .wasi and !builtin.link_libc) {

@@ -1024,7 +1024,7 @@ pub fn pwrite(fd: fd_t, bytes: []const u8, offset: u64) PWriteError!usize {

}

// Prevent EINVAL.

const max_count = switch (std.Target.current.os.tag) {

const max_count = switch (builtin.os.tag) {

.linux => 0x7ffff000,

.macos, .ios, .watchos, .tvos => math.maxInt(i32),

else => math.maxInt(isize),

@@ -1083,7 +1083,7 @@ pub fn pwrite(fd: fd_t, bytes: []const u8, offset: u64) PWriteError!usize {

///

/// If `iov.len` is larger than `IOV_MAX`, a partial write will occur.

pub fn pwritev(fd: fd_t, iov: []const iovec_const, offset: u64) PWriteError!usize {

const have_pwrite_but_not_pwritev = switch (std.Target.current.os.tag) {

const have_pwrite_but_not_pwritev = switch (builtin.os.tag) {

.windows, .macos, .ios, .watchos, .tvos, .haiku => true,

else => false,

};

@@ -1199,7 +1199,7 @@ pub const OpenError = error{

/// Open and possibly create a file. Keeps trying if it gets interrupted.

/// See also `openZ`.

pub fn open(file_path: []const u8, flags: u32, perm: mode_t) OpenError!fd_t {

if (std.Target.current.os.tag == .windows) {

if (builtin.os.tag == .windows) {

const file_path_w = try windows.sliceToPrefixedFileW(file_path);

return openW(file_path_w.span(), flags, perm);

}

@@ -1212,7 +1212,7 @@ pub const openC = @compileError("deprecated: renamed to openZ");

/// Open and possibly create a file. Keeps trying if it gets interrupted.

/// See also `open`.

pub fn openZ(file_path: [*:0]const u8, flags: u32, perm: mode_t) OpenError!fd_t {

if (std.Target.current.os.tag == .windows) {

if (builtin.os.tag == .windows) {

const file_path_w = try windows.cStrToPrefixedFileW(file_path);

return openW(file_path_w.span(), flags, perm);

}

@@ -2900,7 +2900,7 @@ pub fn socket(domain: u32, socket_type: u32, protocol: u32) SocketError!socket_t

return rc;

}

const have_sock_flags = comptime !std.Target.current.isDarwin();

const have_sock_flags = comptime !builtin.target.isDarwin();

const filtered_sock_type = if (!have_sock_flags)

socket_type & ~@as(u32, SOCK.NONBLOCK | SOCK.CLOEXEC)

else

@@ -3199,7 +3199,7 @@ pub fn accept(

/// description of the `O.CLOEXEC` flag in `open` for reasons why this may be useful.

flags: u32,

) AcceptError!socket_t {

const have_accept4 = comptime !(std.Target.current.isDarwin() or builtin.os.tag == .windows);

const have_accept4 = comptime !(builtin.target.isDarwin() or builtin.os.tag == .windows);

assert(0 == (flags & ~@as(u32, SOCK.NONBLOCK | SOCK.CLOEXEC))); // Unsupported flag(s)

const accepted_sock = while (true) {

@@ -4807,7 +4807,7 @@ pub const ClockGetTimeError = error{UnsupportedClock} || UnexpectedError;

/// TODO: change this to return the timespec as a return value

/// TODO: look into making clk_id an enum

pub fn clock_gettime(clk_id: i32, tp: *timespec) ClockGetTimeError!void {

if (std.Target.current.os.tag == .wasi and !builtin.link_libc) {

if (builtin.os.tag == .wasi and !builtin.link_libc) {

var ts: timestamp_t = undefined;

switch (system.clock_time_get(@bitCast(u32, clk_id), 1, &ts)) {

.SUCCESS => {

@@ -4821,7 +4821,7 @@ pub fn clock_gettime(clk_id: i32, tp: *timespec) ClockGetTimeError!void {

}

return;

}

if (std.Target.current.os.tag == .windows) {

if (builtin.os.tag == .windows) {

if (clk_id == CLOCK.REALTIME) {

var ft: windows.FILETIME = undefined;

windows.kernel32.GetSystemTimeAsFileTime(&ft);

@@ -4848,7 +4848,7 @@ pub fn clock_gettime(clk_id: i32, tp: *timespec) ClockGetTimeError!void {

}

pub fn clock_getres(clk_id: i32, res: *timespec) ClockGetTimeError!void {

if (std.Target.current.os.tag == .wasi and !builtin.link_libc) {

if (builtin.os.tag == .wasi and !builtin.link_libc) {

var ts: timestamp_t = undefined;

switch (system.clock_res_get(@bitCast(u32, clk_id), &ts)) {

.SUCCESS => res.* = .{

@@ -5416,19 +5416,19 @@ pub fn sendfile(

// Prevents EOVERFLOW.

const size_t = std.meta.Int(.unsigned, @typeInfo(usize).Int.bits - 1);

const max_count = switch (std.Target.current.os.tag) {

const max_count = switch (builtin.os.tag) {

.linux => 0x7ffff000,

.macos, .ios, .watchos, .tvos => math.maxInt(i32),

else => math.maxInt(size_t),

};

switch (std.Target.current.os.tag) {

switch (builtin.os.tag) {

.linux => sf: {

// sendfile() first appeared in Linux 2.2, glibc 2.1.

const call_sf = comptime if (builtin.link_libc)

std.c.versionCheck(.{ .major = 2, .minor = 1 }).ok

else

std.Target.current.os.version_range.linux.range.max.order(.{ .major = 2, .minor = 2 }) != .lt;

builtin.os.version_range.linux.range.max.order(.{ .major = 2, .minor = 2 }) != .lt;

if (!call_sf) break :sf;

if (headers.len != 0) {

@@ -5719,13 +5719,13 @@ var has_copy_file_range_syscall = std.atomic.Atomic(bool).init(true);

///

/// Maximum offsets on Linux are `math.maxInt(i64)`.

pub fn copy_file_range(fd_in: fd_t, off_in: u64, fd_out: fd_t, off_out: u64, len: usize, flags: u32) CopyFileRangeError!usize {

const call_cfr = comptime if (std.Target.current.os.tag == .wasi)

const call_cfr = comptime if (builtin.os.tag == .wasi)

// WASI-libc doesn't have copy_file_range.

false

else if (builtin.link_libc)

std.c.versionCheck(.{ .major = 2, .minor = 27, .patch = 0 }).ok

else

std.Target.current.os.isAtLeast(.linux, .{ .major = 4, .minor = 5 }) orelse true;

builtin.os.isAtLeast(.linux, .{ .major = 4, .minor = 5 }) orelse true;

if (call_cfr and has_copy_file_range_syscall.load(.Monotonic)) {

var off_in_copy = @bitCast(i64, off_in);

@@ -6179,7 +6179,7 @@ pub fn syncfs(fd: fd_t) SyncError!void {

/// Write all pending file contents and metadata modifications for the specified file descriptor to the underlying filesystem.

pub fn fsync(fd: fd_t) SyncError!void {

if (std.Target.current.os.tag == .windows) {

if (builtin.os.tag == .windows) {

if (windows.kernel32.FlushFileBuffers(fd) != 0)

return;

switch (windows.kernel32.GetLastError()) {

@@ -6203,7 +6203,7 @@ pub fn fsync(fd: fd_t) SyncError!void {

/// Write all pending file contents for the specified file descriptor to the underlying filesystem, but not necessarily the metadata.

pub fn fdatasync(fd: fd_t) SyncError!void {

if (std.Target.current.os.tag == .windows) {

if (builtin.os.tag == .windows) {

return fsync(fd) catch |err| switch (err) {

SyncError.AccessDenied => return, // fdatasync doesn't promise that the access time was synced

else => return err,

lib/std/os/linux.zig added: 771, removed: 743, total 28

@@ -6,12 +6,13 @@

//! provide `rename` when only the `renameat` syscall exists.

//! * Does not support POSIX thread cancellation.

const std = @import("../std.zig");

const builtin = @import("builtin");

const assert = std.debug.assert;

const maxInt = std.math.maxInt;

const elf = std.elf;

const vdso = @import("linux/vdso.zig");

const dl = @import("../dynamic_library.zig");

const native_arch = std.Target.current.cpu.arch;

const native_arch = builtin.cpu.arch;

const native_endian = native_arch.endian();

const is_mips = native_arch.isMIPS();

const is_ppc = native_arch.isPPC();

@@ -21,7 +22,7 @@ const iovec = std.os.iovec;

const iovec_const = std.os.iovec_const;

test {

if (std.Target.current.os.tag == .linux) {

if (builtin.os.tag == .linux) {

_ = @import("linux/test.zig");

}

@@ -150,10 +151,10 @@ pub fn getauxval(index: usize) usize {

// Some architectures (and some syscalls) require 64bit parameters to be passed

// in a even-aligned register pair.

const require_aligned_register_pair =

std.Target.current.cpu.arch.isPPC() or

std.Target.current.cpu.arch.isMIPS() or

std.Target.current.cpu.arch.isARM() or

std.Target.current.cpu.arch.isThumb();

builtin.cpu.arch.isPPC() or

builtin.cpu.arch.isMIPS() or

builtin.cpu.arch.isARM() or

builtin.cpu.arch.isThumb();

// Split a 64bit value into a {LSB,MSB} pair.

// The LE/BE variants specify the endianness to assume.

@@ -1579,7 +1580,7 @@ pub fn process_vm_writev(pid: pid_t, local: [*]const iovec, local_count: usize,

}

pub fn fadvise(fd: fd_t, offset: i64, len: i64, advice: usize) usize {

if (comptime std.Target.current.cpu.arch.isMIPS()) {

if (comptime builtin.cpu.arch.isMIPS()) {

// MIPS requires a 7 argument syscall

const offset_halves = splitValue64(offset);

@@ -1595,7 +1596,7 @@ pub fn fadvise(fd: fd_t, offset: i64, len: i64, advice: usize) usize {

length_halves[1],

advice,

);

} else if (comptime std.Target.current.cpu.arch.isARM()) {

} else if (comptime builtin.cpu.arch.isARM()) {

// ARM reorders the arguments

const offset_halves = splitValue64(offset);

lib/std/os/linux/bpf/kern.zig added: 771, removed: 743, total 28

@@ -1,6 +1,7 @@

const std = @import("../../../std.zig");

const builtin = @import("builtin");

const in_bpf_program = switch (std.builtin.cpu.arch) {

const in_bpf_program = switch (builtin.cpu.arch) {

.bpfel, .bpfeb => true,

else => false,

};

lib/std/os/linux/io_uring.zig added: 771, removed: 743, total 28

@@ -1,6 +1,6 @@

const std = @import("../../std.zig");

const builtin = @import("builtin");

const assert = std.debug.assert;

const builtin = std.builtin;

const mem = std.mem;

const net = std.net;

const os = std.os;

lib/std/os/linux/start_pie.zig added: 771, removed: 743, total 28

@@ -1,6 +1,6 @@

const std = @import("std");

const builtin = @import("builtin");

const elf = std.elf;

const builtin = std.builtin;

const assert = std.debug.assert;

const R_AMD64_RELATIVE = 8;

lib/std/os/linux/test.zig added: 771, removed: 743, total 28

@@ -1,5 +1,5 @@

const std = @import("../../std.zig");

const builtin = std.builtin;

const builtin = @import("builtin");

const linux = std.os.linux;

const mem = std.mem;

const elf = std.elf;

lib/std/os/linux/tls.zig added: 771, removed: 743, total 28

@@ -4,7 +4,7 @@ const mem = std.mem;

const elf = std.elf;

const math = std.math;

const assert = std.debug.assert;

const native_arch = std.Target.current.cpu.arch;

const native_arch = @import("builtin").cpu.arch;

// This file implements the two TLS variants [1] used by ELF-based systems.

lib/std/os/windows/user32.zig added: 771, removed: 743, total 28

@@ -1,4 +1,5 @@

const std = @import("../../std.zig");

const builtin = @import("builtin");

const assert = std.debug.assert;

const windows = std.os.windows;

@@ -29,7 +30,7 @@ const HBRUSH = windows.HBRUSH;

fn selectSymbol(comptime function_static: anytype, function_dynamic: @TypeOf(function_static), comptime os: std.Target.Os.WindowsVersion) @TypeOf(function_static) {

comptime {

const sym_ok = std.Target.current.os.isAtLeast(.windows, os);

const sym_ok = builtin.os.isAtLeast(.windows, os);

if (sym_ok == true) return function_static;

if (sym_ok == null) return function_dynamic;

if (sym_ok == false) @compileError("Target OS range does not support function, at least " ++ @tagName(os) ++ " is required");

lib/std/pdb.zig added: 771, removed: 743, total 28

@@ -1,4 +1,3 @@

const builtin = std.builtin;

const std = @import("std.zig");

const io = std.io;

const math = std.math;

lib/std/process.zig added: 771, removed: 743, total 28

@@ -1,5 +1,5 @@

const std = @import("std.zig");

const builtin = std.builtin;

const builtin = @import("builtin");

const os = std.os;

const fs = std.fs;

const BufMap = std.BufMap;

@@ -863,9 +863,9 @@ pub fn execve(

if (env_map) |m| {

const envp_buf = try child_process.createNullDelimitedEnvMap(arena, m);

break :m envp_buf.ptr;

} else if (std.builtin.link_libc) {

} else if (builtin.link_libc) {

break :m std.c.environ;

} else if (std.builtin.output_mode == .Exe) {

} else if (builtin.output_mode == .Exe) {

// Then we have Zig start code and this works.

// TODO type-safety for null-termination of `os.environ`.

break :m @ptrCast([*:null]?[*:0]u8, os.environ.ptr);

lib/std/rand.zig added: 771, removed: 743, total 28

@@ -7,7 +7,6 @@

//! TODO(tiehuis): Benchmark these against other reference implementations.

const std = @import("std.zig");

const builtin = std.builtin;

const assert = std.debug.assert;

const expect = std.testing.expect;

const expectEqual = std.testing.expectEqual;

lib/std/rand/ziggurat.zig added: 771, removed: 743, total 28

@@ -1,14 +1,15 @@

// Implements ZIGNOR [1].

// [1]: Jurgen A. Doornik (2005). [*An Improved Ziggurat Method to Generate Normal Random Samples*]

// (https://www.doornik.com/research/ziggurat.pdf). Nuffield College, Oxford.

// rust/rand used as a reference;

// NOTE: This seems interesting but reference code is a bit hard to grok:

// https://sbarral.github.io/etf.

//! Implements ZIGNOR [1].

//!

//! [1]: Jurgen A. Doornik (2005). [*An Improved Ziggurat Method to Generate Normal Random Samples*]

//! (https://www.doornik.com/research/ziggurat.pdf). Nuffield College, Oxford.

//!

//! rust/rand used as a reference;

//!

//! NOTE: This seems interesting but reference code is a bit hard to grok:

//! https://sbarral.github.io/etf.

const std = @import("../std.zig");

const builtin = @import("builtin");

const math = std.math;

const Random = std.rand.Random;

@@ -126,7 +127,7 @@ fn norm_zero_case(random: *Random, u: f64) f64 {

}

const please_windows_dont_oom = std.Target.current.os.tag == .windows;

const please_windows_dont_oom = builtin.os.tag == .windows;

test "normal dist sanity" {

if (please_windows_dont_oom) return error.SkipZigTest;

lib/std/sort.zig added: 771, removed: 743, total 28

@@ -3,7 +3,6 @@ const assert = std.debug.assert;

const testing = std.testing;

const mem = std.mem;

const math = std.math;

const builtin = std.builtin;

pub fn binarySearch(

comptime T: type,

lib/std/special/compiler_rt.zig added: 771, removed: 743, total 28

@@ -1,9 +1,9 @@

const std = @import("std");

const builtin = @import("builtin");

const is_test = builtin.is_test;

const os_tag = std.Target.current.os.tag;

const os_tag = builtin.os.tag;

const arch = builtin.stage2_arch;

const abi = std.Target.current.abi;

const abi = builtin.abi;

const is_gnu = abi.isGnu();

const is_mingw = os_tag == .windows and is_gnu;

lib/std/special/compiler_rt/atomics.zig added: 771, removed: 743, total 28

@@ -1,8 +1,8 @@

const std = @import("std");

const builtin = std.builtin;

const arch = std.Target.current.cpu.arch;

const builtin = @import("builtin");

const arch = builtin.cpu.arch;

const linkage: builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak;

const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak;

// This parameter is true iff the target architecture supports the bare minimum

// to implement the atomic load/store intrinsics.

@@ -16,7 +16,7 @@ const supports_atomic_ops = switch (arch) {

// operations (unless we're targeting Linux, the kernel provides a way to

// perform CAS operations).

// XXX: The Linux code path is not implemented yet.

!std.Target.arm.featureSetHas(std.Target.current.cpu.features, .has_v6m),

!std.Target.arm.featureSetHas(builtin.cpu.features, .has_v6m),

else => true,

};

@@ -257,7 +257,7 @@ comptime {

}

fn fetchFn(comptime T: type, comptime op: builtin.AtomicRmwOp) fn (*T, T, i32) callconv(.C) T {

fn fetchFn(comptime T: type, comptime op: std.builtin.AtomicRmwOp) fn (*T, T, i32) callconv(.C) T {

return struct {

pub fn fetch_op_N(ptr: *T, val: T, model: i32) callconv(.C) T {

_ = model;

lib/std/special/compiler_rt/clear_cache.zig added: 771, removed: 743, total 28

@@ -1,6 +1,7 @@

const std = @import("std");

const arch = std.builtin.cpu.arch;

const os = std.builtin.os.tag;

const builtin = @import("builtin");

const arch = builtin.cpu.arch;

const os = builtin.os.tag;

// Ported from llvm-project d32170dbd5b0d54436537b6b75beaf44324e0c28

@@ -156,7 +157,7 @@ pub fn clear_cache(start: usize, end: usize) callconv(.C) void {

}

const linkage = if (std.builtin.is_test) std.builtin.GlobalLinkage.Internal else std.builtin.GlobalLinkage.Weak;

const linkage = if (builtin.is_test) std.builtin.GlobalLinkage.Internal else std.builtin.GlobalLinkage.Weak;

fn exportIt() void {

@export(clear_cache, .{ .name = "__clear_cache", .linkage = linkage });

lib/std/special/compiler_rt/count0bits.zig added: 771, removed: 743, total 28

@@ -1,5 +1,5 @@

const std = @import("std");

const builtin = std.builtin;

const builtin = @import("builtin");

// clz - count leading zeroes

// - clzXi2_generic for little endian

@@ -118,18 +118,18 @@ fn __clzsi2_arm32() callconv(.Naked) void {

}

pub const __clzsi2 = impl: {

switch (std.Target.current.cpu.arch) {

switch (builtin.cpu.arch) {

.arm, .armeb, .thumb, .thumbeb => {

const use_thumb1 =

(std.Target.current.cpu.arch.isThumb() or

std.Target.arm.featureSetHas(std.Target.current.cpu.features, .noarm)) and

!std.Target.arm.featureSetHas(std.Target.current.cpu.features, .thumb2);

(builtin.cpu.arch.isThumb() or

std.Target.arm.featureSetHas(builtin.cpu.features, .noarm)) and

!std.Target.arm.featureSetHas(builtin.cpu.features, .thumb2);

if (use_thumb1) {

break :impl __clzsi2_thumb1;

}

// From here on we're either targeting Thumb2 or ARM.

else if (!std.Target.current.cpu.arch.isThumb()) {

else if (!builtin.cpu.arch.isThumb()) {

break :impl __clzsi2_arm32;

}

// Use the generic implementation otherwise.

@@ -140,14 +140,14 @@ pub const __clzsi2 = impl: {

};

pub const __clzdi2 = impl: {

switch (std.Target.current.cpu.arch) {

switch (builtin.cpu.arch) {

// TODO architecture optimised versions

else => break :impl clzXi2_generic(i64),

}

};

pub const __clzti2 = impl: {

switch (std.Target.current.cpu.arch) {

switch (builtin.cpu.arch) {

// TODO architecture optimised versions

else => break :impl clzXi2_generic(i128),

}

lib/std/special/compiler_rt/emutls.zig added: 771, removed: 743, total 28

@@ -5,6 +5,7 @@

const std = @import("std");

const builtin = @import("builtin");

const abort = std.os.abort;

const assert = std.debug.assert;

@@ -15,7 +16,7 @@ const expect = std.testing.expect;

const gcc_word = usize;

comptime {

assert(std.builtin.link_libc);

assert(builtin.link_libc);

}

/// public entrypoint for generated code using EmulatedTLS

lib/std/special/compiler_rt/muldi3.zig added: 771, removed: 743, total 28

@@ -1,6 +1,7 @@

const std = @import("std");

const is_test = std.builtin.is_test;

const native_endian = std.Target.current.cpu.arch.endian();

const builtin = @import("builtin");

const is_test = builtin.is_test;

const native_endian = builtin.cpu.arch.endian();

// Ported from

// https://github.com/llvm/llvm-project/blob/llvmorg-9.0.0/compiler-rt/lib/builtins/muldi3.c

lib/std/special/compiler_rt/multi3.zig added: 771, removed: 743, total 28

@@ -1,7 +1,8 @@

const compiler_rt = @import("../compiler_rt.zig");

const std = @import("std");

const is_test = std.builtin.is_test;

const native_endian = std.Target.current.cpu.arch.endian();

const builtin = @import("builtin");

const is_test = builtin.is_test;

const native_endian = builtin.cpu.arch.endian();

// Ported from git@github.com:llvm-project/llvm-project-20170507.git

// ae684fad6d34858c014c94da69c15e7774a633c3

lib/std/special/compiler_rt/shift.zig added: 771, removed: 743, total 28

@@ -1,6 +1,6 @@

const std = @import("std");

const Log2Int = std.math.Log2Int;

const native_endian = std.Target.current.cpu.arch.endian();

const native_endian = @import("builtin").cpu.arch.endian();

fn Dwords(comptime T: type, comptime signed_half: bool) type {

return extern union {

lib/std/special/compiler_rt/stack_probe.zig added: 771, removed: 743, total 28

@@ -1,4 +1,4 @@

const native_arch = @import("std").Target.current.cpu.arch;

const native_arch = @import("builtin").cpu.arch;

// Zig's own stack-probe routine (available only on x86 and x86_64)

pub fn zig_probe_stack() callconv(.Naked) void {

lib/std/special/compiler_rt/udivmod.zig added: 771, removed: 743, total 28

@@ -1,6 +1,6 @@

const builtin = @import("builtin");

const is_test = builtin.is_test;

const native_endian = @import("std").Target.current.cpu.arch.endian();

const native_endian = builtin.cpu.arch.endian();

const low = switch (native_endian) {

.Big => 1,

lib/std/special/ssp.zig added: 771, removed: 743, total 28

@@ -1,19 +1,18 @@

// Small Zig reimplementation of gcc's libssp.

// This library implements most of the builtins required by the stack smashing

// protection as implemented by gcc&clang.

const std = @import("std");

const builtin = std.builtin;

//!

//! Small Zig reimplementation of gcc's libssp.

//!

//! This library implements most of the builtins required by the stack smashing

//! protection as implemented by gcc&clang.

//! Missing exports:

//! - __gets_chk

//! - __mempcpy_chk

//! - __snprintf_chk

//! - __sprintf_chk

//! - __stpcpy_chk

//! - __vsnprintf_chk

//! - __vsprintf_chk

// Missing exports:

// - __gets_chk

// - __mempcpy_chk

// - __snprintf_chk

// - __sprintf_chk

// - __stpcpy_chk

// - __vsnprintf_chk

// - __vsprintf_chk

const std = @import("std");

extern fn strncpy(dest: [*:0]u8, src: [*:0]const u8, n: usize) callconv(.C) [*:0]u8;

extern fn memset(dest: ?[*]u8, c: u8, n: usize) callconv(.C) ?[*]u8;

@@ -21,7 +20,7 @@ extern fn memcpy(noalias dest: ?[*]u8, noalias src: ?[*]const u8, n: usize) call

extern fn memmove(dest: ?[*]u8, src: ?[*]const u8, n: usize) callconv(.C) ?[*]u8;

// Avoid dragging in the runtime safety mechanisms into this .o file.

pub fn panic(msg: []const u8, error_return_trace: ?*builtin.StackTrace) noreturn {

pub fn panic(msg: []const u8, error_return_trace: ?*std.builtin.StackTrace) noreturn {

_ = msg;

_ = error_return_trace;

@setCold(true);

lib/std/std.zig added: 771, removed: 743, total 28

@@ -95,7 +95,7 @@ comptime {

}

test {

if (builtin.os.tag == .windows) {

if (@import("builtin").os.tag == .windows) {

// We only test the Windows-relevant stuff to save memory because the CI

// server is hitting OOM. TODO revert this after stage2 arrives.

_ = ChildProcess;

lib/std/target.zig added: 771, removed: 743, total 28

@@ -1,6 +1,5 @@

const std = @import("std.zig");

const mem = std.mem;

const builtin = std.builtin;

const Version = std.builtin.Version;

/// TODO Nearly all the functions in this namespace would be

@@ -1017,7 +1016,7 @@ pub const Target = struct {

};

}

pub fn endian(arch: Arch) builtin.Endian {

pub fn endian(arch: Arch) std.builtin.Endian {

return switch (arch) {

.avr,

.arm,

@@ -1302,7 +1301,8 @@ pub const Target = struct {

}

};

pub const current = builtin.target;

/// TODO delete this deprecated declaration after 0.9.0 is released

pub const current = @compileError("instead of std.Target.current, use @import(\"builtin\").target");

pub const stack_align = 16;

lib/std/testing.zig added: 771, removed: 743, total 28

@@ -1,4 +1,5 @@

const std = @import("std.zig");

const builtin = @import("builtin");

const math = std.math;

const print = std.debug.print;

@@ -322,7 +323,7 @@ pub const TmpDir = struct {

};

fn getCwdOrWasiPreopen() std.fs.Dir {

if (std.builtin.os.tag == .wasi and !std.builtin.link_libc) {

if (builtin.os.tag == .wasi and !builtin.link_libc) {

var preopens = std.fs.wasi.PreopenList.init(allocator);

defer preopens.deinit();

preopens.populate() catch

@@ -464,7 +465,7 @@ test {

/// Given a type, reference all the declarations inside, so that the semantic analyzer sees them.

pub fn refAllDecls(comptime T: type) void {

if (!std.builtin.is_test) return;

if (!builtin.is_test) return;

inline for (std.meta.declarations(T)) |decl| {

_ = decl;

}

lib/std/time.zig added: 771, removed: 743, total 28

@@ -1,10 +1,10 @@

const std = @import("std.zig");

const builtin = std.builtin;

const builtin = @import("builtin");

const assert = std.debug.assert;

const testing = std.testing;

const os = std.os;

const math = std.math;

const is_windows = std.Target.current.os.tag == .windows;

const is_windows = builtin.os.tag == .windows;

pub const epoch = @import("time/epoch.zig");

@@ -173,7 +173,7 @@ pub const Timer = struct {

.resolution = @divFloor(ns_per_s, freq),

.start_time = os.windows.QueryPerformanceCounter(),

};

} else if (comptime std.Target.current.isDarwin()) {

} else if (comptime builtin.target.isDarwin()) {

var freq: os.darwin.mach_timebase_info_data = undefined;

os.darwin.mach_timebase_info(&freq);

@@ -225,7 +225,7 @@ pub const Timer = struct {

if (is_windows) {

return os.windows.QueryPerformanceCounter();

}

if (comptime std.Target.current.isDarwin()) {

if (comptime builtin.target.isDarwin()) {

return os.darwin.mach_absolute_time();

}

var ts: os.timespec = undefined;

@@ -237,7 +237,7 @@ pub const Timer = struct {

if (is_windows) {

return safeMulDiv(duration, ns_per_s, self.frequency);

}

if (comptime std.Target.current.isDarwin()) {

if (comptime builtin.target.isDarwin()) {

return safeMulDiv(duration, self.frequency.numer, self.frequency.denom);

}

return duration;

lib/std/unicode.zig added: 771, removed: 743, total 28

@@ -1,5 +1,4 @@

const std = @import("./std.zig");

const builtin = std.builtin;

const assert = std.debug.assert;

const testing = std.testing;

const mem = std.mem;

lib/std/unicode/throughput_test.zig added: 771, removed: 743, total 28

@@ -1,5 +1,4 @@

const std = @import("std");

const builtin = std.builtin;

const time = std.time;

const unicode = std.unicode;

lib/std/x/net/tcp.zig added: 771, removed: 743, total 28

@@ -1,4 +1,5 @@

const std = @import("../../std.zig");

const builtin = @import("builtin");

const io = std.io;

const os = std.os;

@@ -7,7 +8,7 @@ const ip = std.x.net.ip;

const fmt = std.fmt;

const mem = std.mem;

const testing = std.testing;

const native_os = std.Target.current.os;

const native_os = builtin.os;

const IPv4 = std.x.os.IPv4;

const IPv6 = std.x.os.IPv6;

lib/std/x/os/io.zig added: 771, removed: 743, total 28

@@ -1,9 +1,10 @@

const std = @import("../../std.zig");

const builtin = @import("builtin");

const os = std.os;

const mem = std.mem;

const testing = std.testing;

const native_os = std.Target.current.os;

const native_os = builtin.os;

const linux = std.os.linux;

/// POSIX `iovec`, or Windows `WSABUF`. The difference between the two are the ordering

lib/std/x/os/net.zig added: 771, removed: 743, total 28

@@ -1,11 +1,12 @@

const std = @import("../../std.zig");

const builtin = @import("builtin");

const os = std.os;

const fmt = std.fmt;

const mem = std.mem;

const math = std.math;

const testing = std.testing;

const native_os = std.Target.current.os;

const native_os = builtin.os;

const have_ifnamesize = @hasDecl(os.system, "IFNAMESIZE");

/// Resolves a network interface name into a scope/zone ID. It returns

lib/std/x/os/socket.zig added: 771, removed: 743, total 28

@@ -1,4 +1,5 @@

const std = @import("../../std.zig");

const builtin = @import("builtin");

const net = @import("net.zig");

const os = std.os;

@@ -6,8 +7,8 @@ const fmt = std.fmt;

const mem = std.mem;

const time = std.time;

const meta = std.meta;

const native_os = std.Target.current.os;

const native_endian = std.Target.current.cpu.arch.endian();

const native_os = builtin.os;

const native_endian = builtin.cpu.arch.endian();

const Buffer = std.x.os.Buffer;

lib/std/zig/cross_target.zig added: 771, removed: 743, total 28

@@ -1,4 +1,5 @@

const std = @import("../std.zig");

const builtin = @import("builtin");

const assert = std.debug.assert;

const Target = std.Target;

const mem = std.mem;

@@ -329,7 +330,7 @@ pub const CrossTarget = struct {

// This works when doing `zig build` because Zig generates a build executable using

// native CPU model & features. However this will not be accurate otherwise, and

// will need to be integrated with `std.zig.system.NativeTargetInfo.detect`.

return Target.current.cpu;

return builtin.cpu;

.baseline => {

var adjusted_baseline = Target.Cpu.baseline(self.getCpuArch());

@@ -340,7 +341,7 @@ pub const CrossTarget = struct {

// This works when doing `zig build` because Zig generates a build executable using

// native CPU model & features. However this will not be accurate otherwise, and

// will need to be integrated with `std.zig.system.NativeTargetInfo.detect`.

return Target.current.cpu;

return builtin.cpu;

} else {

var adjusted_baseline = Target.Cpu.baseline(self.getCpuArch());

self.updateCpuFeatures(&adjusted_baseline.features);

@@ -355,7 +356,7 @@ pub const CrossTarget = struct {

}

pub fn getCpuArch(self: CrossTarget) Target.Cpu.Arch {

return self.cpu_arch orelse Target.current.cpu.arch;

return self.cpu_arch orelse builtin.cpu.arch;

}

pub fn getCpuModel(self: CrossTarget) *const Target.Cpu.Model {

@@ -371,10 +372,10 @@ pub const CrossTarget = struct {

/// TODO deprecated, use `std.zig.system.NativeTargetInfo.detect`.

pub fn getOs(self: CrossTarget) Target.Os {

// `Target.current.os` works when doing `zig build` because Zig generates a build executable using

// `builtin.os` works when doing `zig build` because Zig generates a build executable using

// native OS version range. However this will not be accurate otherwise, and

// will need to be integrated with `std.zig.system.NativeTargetInfo.detect`.

var adjusted_os = if (self.os_tag) |os_tag| os_tag.defaultVersionRange() else Target.current.os;

var adjusted_os = if (self.os_tag) |os_tag| os_tag.defaultVersionRange() else builtin.os;

if (self.os_version_min) |min| switch (min) {

.none => {},

@@ -403,7 +404,7 @@ pub const CrossTarget = struct {

}

pub fn getOsTag(self: CrossTarget) Target.Os.Tag {

return self.os_tag orelse Target.current.os.tag;

return self.os_tag orelse builtin.os.tag;

}

/// TODO deprecated, use `std.zig.system.NativeTargetInfo.detect`.

@@ -430,7 +431,7 @@ pub const CrossTarget = struct {

// This works when doing `zig build` because Zig generates a build executable using

// native CPU model & features. However this will not be accurate otherwise, and

// will need to be integrated with `std.zig.system.NativeTargetInfo.detect`.

return Target.current.abi;

return builtin.abi;

}

return Target.Abi.default(self.getCpuArch(), self.getOs());

@@ -607,12 +608,12 @@ pub const CrossTarget = struct {

pub fn getExternalExecutor(self: CrossTarget) Executor {

const cpu_arch = self.getCpuArch();

const os_tag = self.getOsTag();

const os_match = os_tag == Target.current.os.tag;

const os_match = os_tag == builtin.os.tag;

// If the OS and CPU arch match, the binary can be considered native.

// TODO additionally match the CPU features. This `getExternalExecutor` function should

// be moved to std.Target and match any chosen target against the native target.

if (os_match and cpu_arch == Target.current.cpu.arch) {

if (os_match and cpu_arch == builtin.cpu.arch) {

// However, we also need to verify that the dynamic linker path is valid.

if (self.os_tag == null) {

return .native;

@@ -664,7 +665,7 @@ pub const CrossTarget = struct {

// TODO loosen this check once upstream adds QEMU-based emulation

// layer for non-host architectures:

// https://github.com/darlinghq/darling/issues/863

if (cpu_arch != Target.current.cpu.arch) {

if (cpu_arch != builtin.cpu.arch) {

return .unavailable;

}

return Executor{ .darling = "darling" };

@@ -789,7 +790,7 @@ pub const CrossTarget = struct {

};

test "CrossTarget.parse" {

if (Target.current.isGnuLibC()) {

if (builtin.target.isGnuLibC()) {

var cross_target = try CrossTarget.parse(.{});

cross_target.setGnuLibCVersion(2, 1, 1);

@@ -800,7 +801,7 @@ test "CrossTarget.parse" {

const triple = std.fmt.bufPrint(

buf[0..],

"native-native-{s}.2.1.1",

.{@tagName(std.Target.current.abi)},

.{@tagName(builtin.abi)},

) catch unreachable;

try std.testing.expectEqualSlices(u8, triple, text);

lib/std/zig/system.zig added: 771, removed: 743, total 28

@@ -1,4 +1,5 @@

const std = @import("../std.zig");

const builtin = @import("builtin");

const elf = std.elf;

const mem = std.mem;

const fs = std.fs;

@@ -8,7 +9,7 @@ const assert = std.debug.assert;

const process = std.process;

const Target = std.Target;

const CrossTarget = std.zig.CrossTarget;

const native_endian = std.Target.current.cpu.arch.endian();

const native_endian = builtin.cpu.arch.endian();

const linux = @import("system/linux.zig");

pub const windows = @import("system/windows.zig");

pub const darwin = @import("system/darwin.zig");

@@ -88,7 +89,7 @@ pub const NativePaths = struct {

return self;

}

if (comptime Target.current.isDarwin()) {

if (comptime builtin.target.isDarwin()) {

try self.addIncludeDir("/usr/include");

try self.addIncludeDir("/usr/local/include");

@@ -239,7 +240,7 @@ pub const NativeTargetInfo = struct {

pub fn detect(allocator: *Allocator, cross_target: CrossTarget) DetectError!NativeTargetInfo {

var os = cross_target.getOsTag().defaultVersionRange();

if (cross_target.os_tag == null) {

switch (Target.current.os.tag) {

switch (builtin.target.os.tag) {

.linux => {

const uts = std.os.uname();

const release = mem.spanZ(&uts.release);

@@ -273,7 +274,7 @@ pub const NativeTargetInfo = struct {

.macos => try darwin.macos.detect(&os),

.freebsd, .netbsd, .dragonfly => {

const key = switch (Target.current.os.tag) {

const key = switch (builtin.target.os.tag) {

.freebsd => "kern.osreldate",

.netbsd, .dragonfly => "kern.osrevision",

else => unreachable,

@@ -289,7 +290,7 @@ pub const NativeTargetInfo = struct {

error.Unexpected => return error.OSVersionDetectionFail,

};

switch (Target.current.os.tag) {

switch (builtin.target.os.tag) {

.freebsd => {

// https://www.freebsd.org/doc/en_US.ISO8859-1/books/porters-handbook/versions.html

// Major * 100,000 has been convention since FreeBSD 2.2 (1997)

@@ -445,8 +446,8 @@ pub const NativeTargetInfo = struct {

os: Target.Os,

cross_target: CrossTarget,

) DetectError!NativeTargetInfo {

const native_target_has_ld = comptime Target.current.hasDynamicLinker();

const is_linux = Target.current.os.tag == .linux;

const native_target_has_ld = comptime builtin.target.hasDynamicLinker();

const is_linux = builtin.target.os.tag == .linux;

const have_all_info = cross_target.dynamic_linker.get() != null and

cross_target.abi != null and (!is_linux or cross_target.abi.?.isGnu());

const os_is_non_native = cross_target.os_tag != null;

@@ -463,7 +464,7 @@ pub const NativeTargetInfo = struct {

// compiler for target riscv64-linux-musl and provide a tarball for users to download.

// A user could then run that zig compiler on riscv64-linux-gnu. This use case is well-defined

// and supported by Zig. But that means that we must detect the system ABI here rather than

// relying on `Target.current`.

// relying on `builtin.target`.

const all_abis = comptime blk: {

assert(@enumToInt(Target.Abi.none) == 0);

const fields = std.meta.fields(Target.Abi)[1..];

@@ -524,7 +525,7 @@ pub const NativeTargetInfo = struct {

// Look for glibc version.

var os_adjusted = os;

if (Target.current.os.tag == .linux and found_ld_info.abi.isGnu() and

if (builtin.target.os.tag == .linux and found_ld_info.abi.isGnu() and

cross_target.glibc_version == null)

{

for (lib_paths) |lib_path| {

@@ -740,7 +741,7 @@ pub const NativeTargetInfo = struct {

}

// We only need this for detecting glibc version.

elf.PT_DYNAMIC => if (Target.current.os.tag == .linux and result.target.isGnuLibC() and

elf.PT_DYNAMIC => if (builtin.target.os.tag == .linux and result.target.isGnuLibC() and

cross_target.glibc_version == null)

{

var dyn_off = elfInt(is_64, need_bswap, ph32.p_offset, ph64.p_offset);

@@ -787,7 +788,7 @@ pub const NativeTargetInfo = struct {

}

if (Target.current.os.tag == .linux and result.target.isGnuLibC() and cross_target.glibc_version == null) {

if (builtin.target.os.tag == .linux and result.target.isGnuLibC() and cross_target.glibc_version == null) {

if (rpath_offset) |rpoff| {

const shstrndx = elfInt(is_64, need_bswap, hdr32.e_shstrndx, hdr64.e_shstrndx);

@@ -979,14 +980,14 @@ pub const NativeTargetInfo = struct {

// Here we switch on a comptime value rather than `cpu_arch`. This is valid because `cpu_arch`,

// although it is a runtime value, is guaranteed to be one of the architectures in the set

// of the respective switch prong.

switch (std.Target.current.cpu.arch) {

switch (builtin.cpu.arch) {

.x86_64, .i386 => {

return @import("system/x86.zig").detectNativeCpuAndFeatures(cpu_arch, os, cross_target);

else => {},

}

switch (std.Target.current.os.tag) {

switch (builtin.os.tag) {

.linux => return linux.detectNativeCpuAndFeatures(),

.macos => return darwin.macos.detectNativeCpuAndFeatures(),

else => {},

lib/std/zig/system/darwin/macos.zig added: 771, removed: 743, total 28

@@ -1,4 +1,5 @@

const std = @import("std");

const builtin = @import("builtin");

const assert = std.debug.assert;

const mem = std.mem;

const testing = std.testing;

@@ -414,7 +415,7 @@ pub fn detectNativeCpuAndFeatures() ?Target.Cpu {

error.Unexpected => unreachable, // EFAULT: stack should be safe, EISDIR/ENOTDIR: constant, known good value

};

const current_arch = Target.current.cpu.arch;

const current_arch = builtin.cpu.arch;

switch (current_arch) {

.aarch64, .aarch64_be, .aarch64_32 => {

const model = switch (cpu_family) {

lib/std/zig/system/linux.zig added: 771, removed: 743, total 28

@@ -1,4 +1,5 @@

const std = @import("std");

const builtin = @import("builtin");

const mem = std.mem;

const io = std.io;

const fs = std.fs;

@@ -450,7 +451,7 @@ pub fn detectNativeCpuAndFeatures() ?Target.Cpu {

};

defer f.close();

const current_arch = std.Target.current.cpu.arch;

const current_arch = builtin.cpu.arch;

switch (current_arch) {

.arm, .armeb, .thumb, .thumbeb, .aarch64, .aarch64_be, .aarch64_32 => {

return ArmCpuinfoParser.parse(current_arch, f.reader()) catch null;

src/Air.zig added: 771, removed: 743, total 28

@@ -4,6 +4,7 @@

//! gets its own `Air` instance.

const std = @import("std");

const builtin = @import("builtin");

const Value = @import("value.zig").Value;

const Type = @import("type.zig").Type;

const Module = @import("Module.zig");

@@ -484,7 +485,7 @@ pub const Inst = struct {

// bigger than expected. Note that in Debug builds, Zig is allowed

// to insert a secret field for safety checks.

comptime {

if (std.builtin.mode != .Debug) {

if (builtin.mode != .Debug) {

assert(@sizeOf(Data) == 8);

}

src/Cache.zig added: 771, removed: 743, total 28

@@ -4,6 +4,7 @@ hash: HashHelper = .{},

const Cache = @This();

const std = @import("std");

const builtin = @import("builtin");

const crypto = std.crypto;

const fs = std.fs;

const assert = std.debug.assert;

@@ -713,7 +714,7 @@ pub const Manifest = struct {

/// uses the file contents. Windows supports symlinks but only with elevated privileges, so

/// it is treated as not supporting symlinks.

pub fn readSmallFile(dir: fs.Dir, sub_path: []const u8, buffer: []u8) ![]u8 {

if (std.Target.current.os.tag == .windows) {

if (builtin.os.tag == .windows) {

return dir.readFile(sub_path, buffer);

} else {

return dir.readLink(sub_path, buffer);

@@ -726,7 +727,7 @@ pub fn readSmallFile(dir: fs.Dir, sub_path: []const u8, buffer: []u8) ![]u8 {

/// `data` must be a valid UTF-8 encoded file path and 255 bytes or fewer.

pub fn writeSmallFile(dir: fs.Dir, sub_path: []const u8, data: []const u8) !void {

assert(data.len <= 255);

if (std.Target.current.os.tag == .windows) {

if (builtin.os.tag == .windows) {

return dir.writeFile(sub_path, data);

} else {

return dir.symLink(data, sub_path, .{});

@@ -778,7 +779,7 @@ fn isProblematicTimestamp(fs_clock: i128) bool {

}

test "cache file and then recall it" {

if (std.Target.current.os.tag == .wasi) {

if (builtin.os.tag == .wasi) {

// https://github.com/ziglang/zig/issues/5437

return error.SkipZigTest;

}

@@ -856,7 +857,7 @@ test "give nonproblematic timestamp" {

}

test "check that changing a file makes cache fail" {

if (std.Target.current.os.tag == .wasi) {

if (builtin.os.tag == .wasi) {

// https://github.com/ziglang/zig/issues/5437

return error.SkipZigTest;

}

@@ -932,7 +933,7 @@ test "check that changing a file makes cache fail" {

}

test "no file inputs" {

if (std.Target.current.os.tag == .wasi) {

if (builtin.os.tag == .wasi) {

// https://github.com/ziglang/zig/issues/5437

return error.SkipZigTest;

}

@@ -977,7 +978,7 @@ test "no file inputs" {

}

test "Manifest with files added after initial hash work" {

if (std.Target.current.os.tag == .wasi) {

if (builtin.os.tag == .wasi) {

// https://github.com/ziglang/zig/issues/5437

return error.SkipZigTest;

}

src/Compilation.zig added: 771, removed: 743, total 28

@@ -937,8 +937,8 @@ pub fn create(gpa: *Allocator, options: InitOptions) !*Compilation {

};

const darwin_can_use_system_sdk = blk: {

if (comptime !std.Target.current.isDarwin()) break :blk false;

break :blk std.builtin.os.tag == .macos and options.target.isDarwin();

if (comptime !builtin.target.isDarwin()) break :blk false;

break :blk builtin.os.tag == .macos and options.target.isDarwin();

};

const sysroot = blk: {

@@ -3582,7 +3582,7 @@ fn detectLibCIncludeDirs(

// native abi, fall back to using the system libc installation.

// On windows, instead of the native (mingw) abi, we want to check

// for the MSVC abi as a fallback.

const use_system_abi = if (std.Target.current.os.tag == .windows)

const use_system_abi = if (builtin.target.os.tag == .windows)

target.abi == .msvc

else

is_native_abi;

src/ThreadPool.zig added: 771, removed: 743, total 28

@@ -4,6 +4,7 @@

// The MIT license requires this copyright notice to be included in all copies

// and substantial portions of the software.

const std = @import("std");

const builtin = @import("builtin");

const ThreadPool = @This();

lock: std.Thread.Mutex = .{},

@@ -57,7 +58,7 @@ pub fn init(self: *ThreadPool, allocator: *std.mem.Allocator) !void {

.allocator = allocator,

.workers = &[_]Worker{},

};

if (std.builtin.single_threaded)

if (builtin.single_threaded)

return;

const worker_count = std.math.max(1, std.Thread.getCpuCount() catch 1);

@@ -100,7 +101,7 @@ pub fn deinit(self: *ThreadPool) void {

}

pub fn spawn(self: *ThreadPool, comptime func: anytype, args: anytype) !void {

if (std.builtin.single_threaded) {

if (builtin.single_threaded) {

@call(.{}, func, args);

return;

}

src/Zir.zig added: 771, removed: 743, total 28

@@ -11,6 +11,7 @@

//! inline assembly is not an exception.

const std = @import("std");

const builtin = @import("builtin");

const mem = std.mem;

const Allocator = std.mem.Allocator;

const assert = std.debug.assert;

@@ -2215,7 +2216,7 @@ pub const Inst = struct {

// bigger than expected. Note that in Debug builds, Zig is allowed

// to insert a secret field for safety checks.

comptime {

if (std.builtin.mode != .Debug) {

if (builtin.mode != .Debug) {

assert(@sizeOf(Data) == 8);

}

src/codegen.zig added: 771, removed: 743, total 28

@@ -1,4 +1,5 @@

const std = @import("std");

const builtin = @import("builtin");

const mem = std.mem;

const math = std.math;

const assert = std.debug.assert;

@@ -522,7 +523,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {

code: *std.ArrayList(u8),

debug_output: DebugInfoOutput,

) GenerateSymbolError!FnResult {

if (build_options.skip_non_native and std.Target.current.cpu.arch != arch) {

if (build_options.skip_non_native and builtin.cpu.arch != arch) {

@panic("Attempted to compile for architecture that was disabled by build configuration");

}

src/codegen/c.zig added: 771, removed: 743, total 28

@@ -1,4 +1,5 @@

const std = @import("std");

const builtin = @import("builtin");

const assert = std.debug.assert;

const mem = std.mem;

const log = std.log.scoped(.c);

@@ -600,7 +601,7 @@ pub const DeclGen = struct {

);

.ErrorSet => {

comptime std.debug.assert(Type.initTag(.anyerror).abiSize(std.Target.current) == 2);

comptime std.debug.assert(Type.initTag(.anyerror).abiSize(builtin.target) == 2);

try w.writeAll("uint16_t");

.ErrorUnion => {

src/introspect.zig added: 771, removed: 743, total 28

@@ -1,4 +1,5 @@

const std = @import("std");

const builtin = @import("builtin");

const mem = std.mem;

const fs = std.fs;

const Compilation = @import("Compilation.zig");

@@ -71,7 +72,7 @@ pub fn resolveGlobalCacheDir(allocator: *mem.Allocator) ![]u8 {

const appname = "zig";

if (std.Target.current.os.tag != .windows) {

if (builtin.os.tag != .windows) {

if (std.os.getenv("XDG_CACHE_HOME")) |cache_root| {

return fs.path.join(allocator, &[_][]const u8{ cache_root, appname });

} else if (std.os.getenv("HOME")) |home| {

src/libc_installation.zig added: 771, removed: 743, total 28

@@ -6,9 +6,9 @@ const Allocator = std.mem.Allocator;

const Batch = std.event.Batch;

const build_options = @import("build_options");

const is_darwin = Target.current.isDarwin();

const is_windows = Target.current.os.tag == .windows;

const is_haiku = Target.current.os.tag == .haiku;

const is_darwin = builtin.target.isDarwin();

const is_windows = builtin.target.os.tag == .windows;

const is_haiku = builtin.target.os.tag == .haiku;

const log = std.log.scoped(.libc_installation);

@@ -219,7 +219,7 @@ pub const LibCInstallation = struct {

var batch = Batch(FindError!void, 2, .auto_async).init();

errdefer batch.wait() catch {};

batch.add(&async self.findNativeIncludeDirPosix(args));

switch (Target.current.os.tag) {

switch (builtin.target.os.tag) {

.freebsd, .netbsd, .openbsd, .dragonfly => self.crt_dir = try std.mem.dupeZ(args.allocator, u8, "/usr/lib"),

.solaris => self.crt_dir = try std.mem.dupeZ(args.allocator, u8, "/usr/lib/64"),

.linux => batch.add(&async self.findNativeCrtDirPosix(args)),

src/link.zig added: 771, removed: 743, total 28

@@ -292,7 +292,7 @@ pub const File = struct {

// make executable, so we don't have to close it.

return;

}

if (comptime std.Target.current.isDarwin() and std.Target.current.cpu.arch == .aarch64) {

if (comptime builtin.target.isDarwin() and builtin.target.cpu.arch == .aarch64) {

if (base.options.target.cpu.arch != .aarch64) return; // If we're not targeting aarch64, nothing to do.

// XNU starting with Big Sur running on arm64 is caching inodes of running binaries.

// Any change to the binary will effectively invalidate the kernel's cache

@@ -711,7 +711,7 @@ pub fn determineMode(options: Options) fs.File.Mode {

// with 0o755 permissions, but it works appropriately if the system is configured

// more leniently. As another data point, C's fopen seems to open files with the

// 666 mode.

const executable_mode = if (std.Target.current.os.tag == .windows) 0 else 0o777;

const executable_mode = if (builtin.target.os.tag == .windows) 0 else 0o777;

switch (options.effectiveOutputMode()) {

.Lib => return switch (options.link_mode) {

.Dynamic => executable_mode,

src/link/Elf.zig added: 771, removed: 743, total 28

@@ -755,7 +755,7 @@ pub fn flushModule(self: *Elf, comp: *Compilation) !void {

const module = self.base.options.module orelse return error.LinkingWithoutZigSourceUnimplemented;

const target_endian = self.base.options.target.cpu.arch.endian();

const foreign_endian = target_endian != std.Target.current.cpu.arch.endian();

const foreign_endian = target_endian != builtin.cpu.arch.endian();

const ptr_width_bytes: u8 = self.ptrWidthBytes();

const init_len_size: usize = switch (self.ptr_width) {

.p32 => 4,

@@ -2827,7 +2827,7 @@ pub fn deleteExport(self: *Elf, exp: Export) void {

}

fn writeProgHeader(self: *Elf, index: usize) !void {

const foreign_endian = self.base.options.target.cpu.arch.endian() != std.Target.current.cpu.arch.endian();

const foreign_endian = self.base.options.target.cpu.arch.endian() != builtin.cpu.arch.endian();

const offset = self.program_headers.items[index].p_offset;

switch (self.ptr_width) {

.p32 => {

@@ -2848,7 +2848,7 @@ fn writeProgHeader(self: *Elf, index: usize) !void {

}

fn writeSectHeader(self: *Elf, index: usize) !void {

const foreign_endian = self.base.options.target.cpu.arch.endian() != std.Target.current.cpu.arch.endian();

const foreign_endian = self.base.options.target.cpu.arch.endian() != builtin.cpu.arch.endian();

switch (self.ptr_width) {

.p32 => {

var shdr: [1]elf.Elf32_Shdr = undefined;

@@ -2946,7 +2946,7 @@ fn writeSymbol(self: *Elf, index: usize) !void {

syms_sect.sh_size = needed_size; // anticipating adding the global symbols later

self.shdr_table_dirty = true; // TODO look into only writing one section

}

const foreign_endian = self.base.options.target.cpu.arch.endian() != std.Target.current.cpu.arch.endian();

const foreign_endian = self.base.options.target.cpu.arch.endian() != builtin.cpu.arch.endian();

switch (self.ptr_width) {

.p32 => {

var sym = [1]elf.Elf32_Sym{

@@ -2982,7 +2982,7 @@ fn writeAllGlobalSymbols(self: *Elf) !void {

.p32 => @sizeOf(elf.Elf32_Sym),

.p64 => @sizeOf(elf.Elf64_Sym),

};

const foreign_endian = self.base.options.target.cpu.arch.endian() != std.Target.current.cpu.arch.endian();

const foreign_endian = self.base.options.target.cpu.arch.endian() != builtin.cpu.arch.endian();

const global_syms_off = syms_sect.sh_offset + self.local_symbols.items.len * sym_size;

switch (self.ptr_width) {

.p32 => {

src/link/MachO.zig added: 771, removed: 743, total 28

@@ -967,7 +967,7 @@ fn resolveSearchDir(

if (fs.path.isAbsolute(dir)) {

if (syslibroot) |root| {

const common_dir = if (std.Target.current.os.tag == .windows) blk: {

const common_dir = if (builtin.os.tag == .windows) blk: {

// We need to check for disk designator and strip it out from dir path so

// that we can concat dir with syslibroot.

// TODO we should backport this mechanism to 'MachO.Dylib.parseDependentLibs()'

src/link/MachO/fat.zig added: 771, removed: 743, total 28

@@ -1,5 +1,5 @@

const std = @import("std");

const builtin = std.builtin;

const builtin = @import("builtin");

const log = std.log.scoped(.archive);

const macho = std.macho;

const mem = std.mem;

@@ -23,7 +23,7 @@ fn readFatStruct(reader: anytype, comptime T: type) !T {

// Fat structures (fat_header & fat_arch) are always written and read to/from

// disk in big endian order.

var res = try reader.readStruct(T);

if (native_endian != builtin.Endian.Big) {

if (native_endian != std.builtin.Endian.Big) {

mem.bswapAllFields(T, &res);

}

return res;

src/main.zig added: 771, removed: 743, total 28

@@ -1,4 +1,5 @@

const std = @import("std");

const builtin = @import("builtin");

const assert = std.debug.assert;

const io = std.io;

const fs = std.fs;

@@ -34,7 +35,7 @@ pub fn fatal(comptime format: []const u8, args: anytype) noreturn {

/// be byte-indexed with a u32 integer.

pub const max_src_size = std.math.maxInt(u32);

pub const debug_extensions_enabled = std.builtin.mode == .Debug;

pub const debug_extensions_enabled = builtin.mode == .Debug;

pub const Color = enum {

auto,

@@ -90,7 +91,7 @@ const debug_usage = normal_usage ++

const usage = if (debug_extensions_enabled) debug_usage else normal_usage;

pub const log_level: std.log.Level = switch (std.builtin.mode) {

pub const log_level: std.log.Level = switch (builtin.mode) {

.Debug => .debug,

.ReleaseSafe, .ReleaseFast => .info,

.ReleaseSmall => .crit,

@@ -142,7 +143,7 @@ pub fn main() anyerror!void {

var gpa_need_deinit = false;

const gpa = gpa: {

if (!std.builtin.link_libc) {

if (!builtin.link_libc) {

gpa_need_deinit = true;

break :gpa &general_purpose_allocator.allocator;

}

@@ -1688,13 +1689,13 @@ fn buildOutputType(

}

if (comptime std.Target.current.isDarwin()) {

if (comptime builtin.target.isDarwin()) {

// If we want to link against frameworks, we need system headers.

if (framework_dirs.items.len > 0 or frameworks.items.len > 0)

want_native_include_dirs = true;

}

const is_darwin_on_darwin = (comptime std.Target.current.isDarwin()) and cross_target.isDarwin();

const is_darwin_on_darwin = (comptime builtin.target.isDarwin()) and cross_target.isDarwin();

if (sysroot == null and (cross_target.isNativeOs() or is_darwin_on_darwin) and

(system_libs.items.len != 0 or want_native_include_dirs))

@@ -1706,7 +1707,7 @@ fn buildOutputType(

warn("{s}", .{warning});

}

const has_sysroot = if (comptime std.Target.current.isDarwin()) outer: {

const has_sysroot = if (comptime builtin.target.isDarwin()) outer: {

const should_get_sdk_path = if (cross_target.isNativeOs() and target_info.target.os.tag == .macos) inner: {

const min = target_info.target.os.getVersionRange().semver.min;

const at_least_mojave = min.major >= 11 or (min.major >= 10 and min.minor >= 14);

@@ -2355,7 +2356,7 @@ fn runOrTest(

defer argv.deinit();

if (test_exec_args.len == 0) {

if (!std.Target.current.canExecBinariesOf(target)) {

if (!builtin.target.canExecBinariesOf(target)) {

switch (arg_mode) {

.zig_test => {

warn("created {s} but skipping execution because it is non-native", .{exe_path});

@@ -3915,7 +3916,7 @@ fn gimmeMoreOfThoseSweetSweetFileDescriptors() void {

const posix = std.os;

var lim = posix.getrlimit(.NOFILE) catch return; // Oh well; we tried.

if (comptime std.Target.current.isDarwin()) {

if (comptime builtin.target.isDarwin()) {

// On Darwin, `NOFILE` is bounded by a hardcoded value `OPEN_MAX`.

// According to the man pages for setrlimit():

// setrlimit() now returns with errno set to EINVAL in places that historically succeeded.

@@ -3959,7 +3960,7 @@ fn detectNativeTargetInfo(gpa: *Allocator, cross_target: std.zig.CrossTarget) !s

/// check for resource leaks can be accurate. In release builds, this

/// calls exit(0), and does not return.

pub fn cleanExit() void {

if (std.builtin.mode == .Debug) {

if (builtin.mode == .Debug) {

return;

} else {

process.exit(0);

src/tracy.zig added: 771, removed: 743, total 28

@@ -1,6 +1,7 @@

pub const std = @import("std");

const std = @import("std");

const builtin = @import("builtin");

pub const enable = if (std.builtin.is_test) false else @import("build_options").enable_tracy;

pub const enable = if (builtin.is_test) false else @import("build_options").enable_tracy;

extern fn ___tracy_emit_zone_begin_callstack(

srcloc: *const ___tracy_source_location_data,

test/assemble_and_link.zig added: 771, removed: 743, total 28

@@ -1,8 +1,9 @@

const std = @import("std");

const builtin = @import("builtin");

const tests = @import("tests.zig");

pub fn addCases(cases: *tests.CompareOutputContext) void {

if (std.Target.current.os.tag == .linux and std.Target.current.cpu.arch == .x86_64) {

if (builtin.os.tag == .linux and builtin.cpu.arch == .x86_64) {

cases.addAsm("hello world linux x86_64",

\\.text

\\.globl _start

test/behavior/asm.zig added: 771, removed: 743, total 28

@@ -1,7 +1,8 @@

const std = @import("std");

const builtin = @import("builtin");

const expect = std.testing.expect;

const is_x86_64_linux = std.Target.current.cpu.arch == .x86_64 and std.Target.current.os.tag == .linux;

const is_x86_64_linux = builtin.cpu.arch == .x86_64 and builtin.os.tag == .linux;

comptime {

if (is_x86_64_linux) {

test/behavior/atomics.zig added: 771, removed: 743, total 28

@@ -1,7 +1,7 @@

const std = @import("std");

const builtin = @import("builtin");

const expect = std.testing.expect;

const expectEqual = std.testing.expectEqual;

const builtin = @import("builtin");

test "cmpxchg" {

try testCmpxchg();

test/behavior/namespace_depends_on_compile_var.zig added: 771, removed: 743, total 28

@@ -1,4 +1,5 @@

const std = @import("std");

const builtin = @import("builtin");

const expect = std.testing.expect;

test "namespace depends on compile var" {

@@ -8,7 +9,7 @@ test "namespace depends on compile var" {

try expect(!some_namespace.a_bool);

}

const some_namespace = switch (std.builtin.os.tag) {

const some_namespace = switch (builtin.os.tag) {

.linux => @import("namespace_depends_on_compile_var/a.zig"),

else => @import("namespace_depends_on_compile_var/b.zig"),

};

test/behavior/sizeof_and_typeof.zig added: 771, removed: 743, total 28

@@ -1,5 +1,4 @@

const std = @import("std");

const builtin = std.builtin;

const expect = std.testing.expect;

const expectEqual = std.testing.expectEqual;

test/behavior/sizeof_and_typeof_stage1.zig added: 771, removed: 743, total 28

@@ -1,5 +1,4 @@

const std = @import("std");

const builtin = std.builtin;

const expect = std.testing.expect;

const expectEqual = std.testing.expectEqual;

test/behavior/vector.zig added: 771, removed: 743, total 28

@@ -674,7 +674,7 @@ test "saturating subtraction" {

test "saturating multiplication" {

// TODO: once #9660 has been solved, remove this line

if (std.builtin.target.cpu.arch == .wasm32) return error.SkipZigTest;

if (builtin.target.cpu.arch == .wasm32) return error.SkipZigTest;

const S = struct {

fn doTheTest() !void {

test/cli.zig added: 771, removed: 743, total 28

@@ -1,4 +1,5 @@

const std = @import("std");

const builtin = @import("builtin");

const testing = std.testing;

const process = std.process;

const fs = std.fs;

@@ -97,7 +98,7 @@ fn testZigInitExe(zig_exe: []const u8, dir_path: []const u8) !void {

}

fn testGodboltApi(zig_exe: []const u8, dir_path: []const u8) anyerror!void {

if (std.Target.current.os.tag != .linux or std.Target.current.cpu.arch != .x86_64) return;

if (builtin.os.tag != .linux or builtin.cpu.arch != .x86_64) return;

const example_zig_path = try fs.path.join(a, &[_][]const u8{ dir_path, "example.zig" });

const example_s_path = try fs.path.join(a, &[_][]const u8{ dir_path, "example.s" });

test/compare_output.zig added: 771, removed: 743, total 28

@@ -28,7 +28,8 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {

cases.addC("number literals",

\\const std = @import("std");

\\const is_windows = std.Target.current.os.tag == .windows;

\\const builtin = @import("builtin");

\\const is_windows = builtin.os.tag == .windows;

\\const c = @cImport({

\\ if (is_windows) {

\\ // See https://github.com/ziglang/zig/issues/515

@@ -207,7 +208,8 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {

cases.addC("casting between float and integer types",

\\const std = @import("std");

\\const is_windows = std.Target.current.os.tag == .windows;

\\const builtin = @import("builtin");

\\const is_windows = builtin.os.tag == .windows;

\\const c = @cImport({

\\ if (is_windows) {

\\ // See https://github.com/ziglang/zig/issues/515

test/compile_errors.zig added: 771, removed: 743, total 28

@@ -1,4 +1,5 @@

const std = @import("std");

const builtin = @import("builtin");

const TestContext = @import("../src/test.zig").TestContext;

pub fn addCases(ctx: *TestContext) !void {

@@ -2898,7 +2899,7 @@ pub fn addCases(ctx: *TestContext) !void {

"tmp.zig:2:18: error: invalid operands to binary expression: 'error{A}' and 'error{B}'",

});

if (std.Target.current.os.tag == .linux) {

if (builtin.os.tag == .linux) {

ctx.testErrStage1("implicit dependency on libc",

\\extern "c" fn exit(u8) void;

\\export fn entry() void {

@@ -8834,9 +8835,10 @@ pub fn addCases(ctx: *TestContext) !void {

ctx.objErrStage1("Issue #9165: windows tcp server compilation error",

\\const std = @import("std");

\\const builtin = @import("builtin");

\\pub const io_mode = .evented;

\\pub fn main() !void {

\\ if (std.builtin.os.tag == .windows) {

\\ if (builtin.os.tag == .windows) {

\\ _ = try (std.net.StreamServer.init(.{})).accept();

\\ } else {

\\ @compileError("Unsupported OS");

test/src/compare_output.zig added: 771, removed: 743, total 28

@@ -1,14 +1,13 @@

// This is the implementation of the test harness.

// For the actual test cases, see test/compare_output.zig.

const std = @import("std");

const builtin = std.builtin;

const build = std.build;

const ArrayList = std.ArrayList;

const fmt = std.fmt;

const mem = std.mem;

const fs = std.fs;

const warn = std.debug.warn;

const Mode = builtin.Mode;

const Mode = std.builtin.Mode;

pub const CompareOutputContext = struct {

b: *build.Builder,

test/standalone.zig added: 771, removed: 743, total 28

@@ -1,4 +1,5 @@

const std = @import("std");

const builtin = @import("builtin");

const tests = @import("tests.zig");

pub fn addCases(cases: *tests.StandaloneContext) void {

@@ -29,19 +30,19 @@ pub fn addCases(cases: *tests.StandaloneContext) void {

cases.addBuildFile("test/standalone/issue_7030/build.zig", .{});

cases.addBuildFile("test/standalone/install_raw_hex/build.zig", .{});

cases.addBuildFile("test/standalone/issue_9812/build.zig", .{});

if (std.Target.current.os.tag != .wasi) {

if (builtin.os.tag != .wasi) {

cases.addBuildFile("test/standalone/load_dynamic_library/build.zig", .{});

}

if (std.Target.current.cpu.arch == .x86_64) { // TODO add C ABI support for other architectures

if (builtin.cpu.arch == .x86_64) { // TODO add C ABI support for other architectures

cases.addBuildFile("test/stage1/c_abi/build.zig", .{});

}

cases.addBuildFile("test/standalone/c_compiler/build.zig", .{ .build_modes = true, .cross_targets = true });

if (std.Target.current.os.tag == .windows) {

if (builtin.os.tag == .windows) {

cases.addC("test/standalone/issue_9402/main.zig");

}

// Try to build and run a PIE executable.

if (std.Target.current.os.tag == .linux) {

if (builtin.os.tag == .linux) {

cases.addBuildFile("test/standalone/pie/build.zig", .{});

}

// Try to build and run an Objective-C executable.

test/standalone/c_compiler/build.zig added: 771, removed: 743, total 28

@@ -1,12 +1,13 @@

const std = @import("std");

const builtin = @import("builtin");

const Builder = std.build.Builder;

const CrossTarget = std.zig.CrossTarget;

fn isRunnableTarget(t: CrossTarget) bool {

if (t.isNative()) return true;

return (t.getOsTag() == std.Target.current.os.tag and

t.getCpuArch() == std.Target.current.cpu.arch);

return (t.getOsTag() == builtin.os.tag and

t.getCpuArch() == builtin.cpu.arch);

}

pub fn build(b: *Builder) void {

test/standalone/install_raw_hex/build.zig added: 771, removed: 743, total 28

@@ -28,14 +28,14 @@ pub fn build(b: *Builder) void {

const expected_hex = &[_][]const u8{

":020000021000EC",

":1000D400D001010001000000D20101000100000074",

":1000E40028020100010000002402010001000000B8",

":1000F4003A02010001000000E202010001000000D8",

":100104000C03010001000000A50202000000000031",

":1000D400A401010001000000A601010001000000CC",

":1000E400FC01010001000000F80101000100000012",

":1000F4000E02010001000000B60201000100000030",

":10010400E00201000100000079020200000000008A",

":1001140000000000000000000000000000000000DB",

":1001240000000000000000000000000000000000CB",

":1001340000000000000000000000000000000000BB",

":10014400AF02020098020100090000004D02010004",

":10014400830202006C020100090000002102010088",

":100154000900000001000000000000000000000091",

":1001640000080002008001010004000010000000EB",

":100174000000000000000000000000001F0000005C",

@@ -44,55 +44,52 @@ pub fn build(b: *Builder) void {

":1001A40000000000000000001F000000000000002C",

":1001B400000000000000000000000000000000003B",

":1001C400000000000000000000000000000000002B",

":1001D400000000000000000000000000000000001B",

":1001E400000000000000000000000000000000000B",

":1001F4000000000000000000000000008702010071",

":1002040010000000200201002C0000006B0201001D",

":100214001B000000570201001300000072656D61AD",

":10022400696E646572206469766973696F6E2062B1",

":1002340079207A65726F206F72206E6567617469C8",

":1002440076652076616C756500636F727465782DD0",

":100254006D3400696E646578206F7574206F662054",

":10026400626F756E647300696E746567657220638E",

":10027400617374207472756E63617465642062695D",

":100284007473006469766973696F6E206279207A89",

":1002940065726F00636F727465785F6D340000007F",

":1002A40081B00091FFE700BEFDE7D0B502AF90B08A",

":1002B4000391029007A800F029F803990020069002",

":1002C40048680490FFE704990698019088420FD289",

":1002D400FFE7019903980068405C07F8310C17F8B0",

":1002E400311C07A800F021F8019801300690EAE7D4",

":1002F400029807A9B1E80C50A0E80C5091E81C50F2",

":1003040080E81C5010B0D0BDFFE7FEE7D0B502AFC7",

":1003140040F2DC11C0F20101B1E80C50A0E80C502D",

":1003240091E81C5080E81C50D0BD80B56F4688B061",

":1003340006906FF35F2127F80A1C37F80A0C049023",

":10034400012038B9FFE740F20020C0F2010000218B",

":10035400FFF7A6FF0498C0F3431027F8020C37F800",

":100364000A0C0390002038B9FFE7039800F01F003F",

":100374000290012038B914E040F20820C0F20100D4",

":100384000021FFF78DFF029800F01F0007F8030C0F",

":100394000698009037F8020C0146019109280ED303",

":1003A40006E040F21020C0F201000021FFF778FFC0",

":1003B40040F21820C0F201000021FFF771FF0099FC",

":1003C400019A51F8220017F803CC012303FA0CF325",

":1003D400184341F8220008B080BD81B000F03F000E",

":1003E4008DF802009DF802000F3000F03F00022853",

":1003F40004D3FFE700208DF8030003E001208DF80B",

":100404000300FFE79DF8030001B070470A000000F5",

":1004140012000000020071001200000066000000DB",

":1004240003007D0C06000000000000000001110123",

":10043400250E1305030E10171B0EB44219110112D9",

":0604440006000002340076",

":1001D4005B02010010000000F40101002C0000008B",

":1001E4003F0201001B0000002B020100130000006D",

":1001F40072656D61696E646572206469766973699C",

":100204006F6E206279207A65726F206F72206E653E",

":100214006761746976652076616C756500636F72D9",

":100224007465782D6D3400696E646578206F75741B",

":10023400206F6620626F756E647300696E74656703",

":1002440065722063617374207472756E6361746582",

":10025400642062697473006469766973696F6E20DF",

":100264006279207A65726F00636F727465785F6D6E",

":100274003400000081B00091FFE700BEFDE7D0B577",

":1002840002AF90B00391029007A800F029F80399F7",

":100294000020069048680490FFE7049906980190AE",

":1002A40088420FD2FFE7019903980068405C07F881",

":1002B400310C17F8311C07A800F021F8019801301F",

":1002C4000690EAE7029807A9B1E80C50A0E80C50A0",

":1002D40091E81C5080E81C5010B0D0BDFFE7FEE749",

":1002E400D0B502AF40F2B011C0F20101B1E80C5038",

":1002F400A0E80C5091E81C5080E81C50D0BD80B59B",

":100304006F4688B006906FF35F2127F80A1C37F810",

":100314000A0C0490012038B9FFE740F2D410C0F26F",

":1003240001000021FFF7A6FF0498C0F3431027F84B",

":10033400020C37F80A0C0390002038B9FFE7039841",

":1003440000F01F000290012038B914E040F2DC10E4",

":10035400C0F201000021FFF78DFF029800F01F009A",

":1003640007F8030C0698009037F8020C0146019137",

":1003740009280ED306E040F2E410C0F20100002187",

":10038400FFF778FF40F2EC10C0F201000021FFF704",

":1003940071FF0099019A51F8220017F803CC012348",

":1003A40003FA0CF3184341F8220008B080BD81B071",

":1003B40000F03F008DF802009DF802000F3000F0BD",

":1003C4003F00022804D3FFE700208DF8030003E078",

":1003D40001208DF80300FFE79DF8030001B070478A",

":1003E4000A00000012000000020071001200000068",

":1003F4006600000003007D0C060000000000000001",

":1004040000011101250E1305030E10171B0EB44233",

":0A0414001911011206000002340065",

":020000021000EC",

":1000D400D001010001000000D20101000100000074",

":1000E40028020100010000002402010001000000B8",

":1000F4003A02010001000000E202010001000000D8",

":100104000C03010001000000A50202000000000031",

":1000D400A401010001000000A601010001000000CC",

":1000E400FC01010001000000F80101000100000012",

":1000F4000E02010001000000B60201000100000030",

":10010400E00201000100000079020200000000008A",

":1001140000000000000000000000000000000000DB",

":1001240000000000000000000000000000000000CB",

":1001340000000000000000000000000000000000BB",

":10014400AF02020098020100090000004D02010004",

":10014400830202006C020100090000002102010088",

":100154000900000001000000000000000000000091",

":1001640000080002008001010004000010000000EB",

":100174000000000000000000000000001F0000005C",

@@ -101,70 +98,67 @@ pub fn build(b: *Builder) void {

":1001A40000000000000000001F000000000000002C",

":1001B400000000000000000000000000000000003B",

":1001C400000000000000000000000000000000002B",

":1001D400000000000000000000000000000000001B",

":1001E400000000000000000000000000000000000B",

":1001F4000000000000000000000000008702010071",

":1002040010000000200201002C0000006B0201001D",

":100214001B000000570201001300000072656D61AD",

":10022400696E646572206469766973696F6E2062B1",

":1002340079207A65726F206F72206E6567617469C8",

":1002440076652076616C756500636F727465782DD0",

":100254006D3400696E646578206F7574206F662054",

":10026400626F756E647300696E746567657220638E",

":10027400617374207472756E63617465642062695D",

":100284007473006469766973696F6E206279207A89",

":1002940065726F00636F727465785F6D340000007F",

":1002A40081B00091FFE700BEFDE7D0B502AF90B08A",

":1002B4000391029007A800F029F803990020069002",

":1002C40048680490FFE704990698019088420FD289",

":1002D400FFE7019903980068405C07F8310C17F8B0",

":1002E400311C07A800F021F8019801300690EAE7D4",

":1002F400029807A9B1E80C50A0E80C5091E81C50F2",

":1003040080E81C5010B0D0BDFFE7FEE7D0B502AFC7",

":1003140040F2DC11C0F20101B1E80C50A0E80C502D",

":1003240091E81C5080E81C50D0BD80B56F4688B061",

":1003340006906FF35F2127F80A1C37F80A0C049023",

":10034400012038B9FFE740F20020C0F2010000218B",

":10035400FFF7A6FF0498C0F3431027F8020C37F800",

":100364000A0C0390002038B9FFE7039800F01F003F",

":100374000290012038B914E040F20820C0F20100D4",

":100384000021FFF78DFF029800F01F0007F8030C0F",

":100394000698009037F8020C0146019109280ED303",

":1003A40006E040F21020C0F201000021FFF778FFC0",

":1003B40040F21820C0F201000021FFF771FF0099FC",

":1003C400019A51F8220017F803CC012303FA0CF325",

":1003D400184341F8220008B080BD81B000F03F000E",

":1003E4008DF802009DF802000F3000F03F00022853",

":1003F40004D3FFE700208DF8030003E001208DF80B",

":100404000300FFE79DF8030001B070470A000000F5",

":1004140012000000020071001200000066000000DB",

":1004240003007D0C06000000000000000001110123",

":10043400250E1305030E10171B0EB44219110112D9",

":0604440006000002340076",

":1001D4005B02010010000000F40101002C0000008B",

":1001E4003F0201001B0000002B020100130000006D",

":1001F40072656D61696E646572206469766973699C",

":100204006F6E206279207A65726F206F72206E653E",

":100214006761746976652076616C756500636F72D9",

":100224007465782D6D3400696E646578206F75741B",

":10023400206F6620626F756E647300696E74656703",

":1002440065722063617374207472756E6361746582",

":10025400642062697473006469766973696F6E20DF",

":100264006279207A65726F00636F727465785F6D6E",

":100274003400000081B00091FFE700BEFDE7D0B577",

":1002840002AF90B00391029007A800F029F80399F7",

":100294000020069048680490FFE7049906980190AE",

":1002A40088420FD2FFE7019903980068405C07F881",

":1002B400310C17F8311C07A800F021F8019801301F",

":1002C4000690EAE7029807A9B1E80C50A0E80C50A0",

":1002D40091E81C5080E81C5010B0D0BDFFE7FEE749",

":1002E400D0B502AF40F2B011C0F20101B1E80C5038",

":1002F400A0E80C5091E81C5080E81C50D0BD80B59B",

":100304006F4688B006906FF35F2127F80A1C37F810",

":100314000A0C0490012038B9FFE740F2D410C0F26F",

":1003240001000021FFF7A6FF0498C0F3431027F84B",

":10033400020C37F80A0C0390002038B9FFE7039841",

":1003440000F01F000290012038B914E040F2DC10E4",

":10035400C0F201000021FFF78DFF029800F01F009A",

":1003640007F8030C0698009037F8020C0146019137",

":1003740009280ED306E040F2E410C0F20100002187",

":10038400FFF778FF40F2EC10C0F201000021FFF704",

":1003940071FF0099019A51F8220017F803CC012348",

":1003A40003FA0CF3184341F8220008B080BD81B071",

":1003B40000F03F008DF802009DF802000F3000F0BD",

":1003C4003F00022804D3FFE700208DF8030003E078",

":1003D40001208DF80300FFE79DF8030001B070478A",

":1003E4000A00000012000000020071001200000068",

":1003F4006600000003007D0C060000000000000001",

":1004040000011101250E1305030E10171B0EB44233",

":0A0414001911011206000002340065",

":020000022000DC",

":1002A40081B00091FFE700BEFDE7D0B502AF90B08A",

":1002B4000391029007A800F029F803990020069002",

":1002C40048680490FFE704990698019088420FD289",

":1002D400FFE7019903980068405C07F8310C17F8B0",

":1002E400311C07A800F021F8019801300690EAE7D4",

":1002F400029807A9B1E80C50A0E80C5091E81C50F2",

":1003040080E81C5010B0D0BDFFE7FEE7D0B502AFC7",

":1003140040F2DC11C0F20101B1E80C50A0E80C502D",

":1003240091E81C5080E81C50D0BD80B56F4688B061",

":1003340006906FF35F2127F80A1C37F80A0C049023",

":10034400012038B9FFE740F20020C0F2010000218B",

":10035400FFF7A6FF0498C0F3431027F8020C37F800",

":100364000A0C0390002038B9FFE7039800F01F003F",

":100374000290012038B914E040F20820C0F20100D4",

":100384000021FFF78DFF029800F01F0007F8030C0F",

":100394000698009037F8020C0146019109280ED303",

":1003A40006E040F21020C0F201000021FFF778FFC0",

":1003B40040F21820C0F201000021FFF771FF0099FC",

":1003C400019A51F8220017F803CC012303FA0CF325",

":1003D400184341F8220008B080BD81B000F03F000E",

":1003E4008DF802009DF802000F3000F03F00022853",

":1003F40004D3FFE700208DF8030003E001208DF80B",

":0C0404000300FFE79DF8030001B0704703",

":1002780081B00091FFE700BEFDE7D0B502AF90B0B6",

":100288000391029007A800F029F80399002006902E",

":1002980048680490FFE704990698019088420FD2B5",

":1002A800FFE7019903980068405C07F8310C17F8DC",

":1002B800311C07A800F021F8019801300690EAE700",

":1002C800029807A9B1E80C50A0E80C5091E81C501E",

":1002D80080E81C5010B0D0BDFFE7FEE7D0B502AFF4",

":1002E80040F2B011C0F20101B1E80C50A0E80C5086",

":1002F80091E81C5080E81C50D0BD80B56F4688B08E",

":1003080006906FF35F2127F80A1C37F80A0C04904F",

":10031800012038B9FFE740F2D410C0F201000021F3",

":10032800FFF7A6FF0498C0F3431027F8020C37F82C",

":100338000A0C0390002038B9FFE7039800F01F006B",

":100348000290012038B914E040F2DC10C0F201003C",

":100358000021FFF78DFF029800F01F0007F8030C3B",

":100368000698009037F8020C0146019109280ED32F",

":1003780006E040F2E410C0F201000021FFF778FF28",

":1003880040F2EC10C0F201000021FFF771FF009964",

":10039800019A51F8220017F803CC012303FA0CF351",

":1003A800184341F8220008B080BD81B000F03F003A",

":1003B8008DF802009DF802000F3000F03F0002287F",

":1003C80004D3FFE700208DF8030003E001208DF837",

":0C03D8000300FFE79DF8030001B0704730",

":00000001FF",

};

test/tests.zig added: 771, removed: 743, total 28

@@ -1,5 +1,5 @@

const std = @import("std");

const builtin = std.builtin;

const builtin = @import("builtin");

const debug = std.debug;

const warn = debug.warn;

const build = std.build;

@@ -9,7 +9,7 @@ const fs = std.fs;

const mem = std.mem;

const fmt = std.fmt;

const ArrayList = std.ArrayList;

const Mode = builtin.Mode;

const Mode = std.builtin.Mode;

const LibExeObjStep = build.LibExeObjStep;

// Cases

@@ -29,7 +29,7 @@ pub const CompareOutputContext = @import("src/compare_output.zig").CompareOutput

const TestTarget = struct {

target: CrossTarget = @as(CrossTarget, .{}),

mode: builtin.Mode = .Debug,

mode: std.builtin.Mode = .Debug,

link_libc: bool = false,

single_threaded: bool = false,

disable_native: bool = false,

@@ -532,8 +532,8 @@ pub fn addPkgTests(

continue;

if (test_target.disable_native and

test_target.target.getOsTag() == std.Target.current.os.tag and

test_target.target.getCpuArch() == std.Target.current.cpu.arch)

test_target.target.getOsTag() == builtin.os.tag and

test_target.target.getCpuArch() == builtin.cpu.arch)

{

continue;

}

@@ -785,7 +785,7 @@ pub const StackTracesContext = struct {

if (line.len == 0) continue;

// offset search past `[drive]:` on windows

var pos: usize = if (std.Target.current.os.tag == .windows) 2 else 0;

var pos: usize = if (builtin.os.tag == .windows) 2 else 0;

// locate delims/anchor

const delims = [_][]const u8{ ":", ":", ":", " in ", "(", ")" };

var marks = [_]usize{0} ** delims.len;

@@ -1055,7 +1055,7 @@ pub const GenHContext = struct {

pub fn addCase(self: *GenHContext, case: *const TestCase) void {

const b = self.b;

const mode = builtin.Mode.Debug;

const mode = std.builtin.Mode.Debug;

const annotated_case_name = fmt.allocPrint(self.b.allocator, "gen-h {s} ({s})", .{ case.name, @tagName(mode) }) catch unreachable;

if (self.test_filter) |filter| {

if (mem.indexOf(u8, annotated_case_name, filter) == null) return;

test/translate_c.zig added: 771, removed: 743, total 28

@@ -1,9 +1,10 @@

const tests = @import("tests.zig");

const std = @import("std");

const builtin = @import("builtin");

const tests = @import("tests.zig");

const CrossTarget = std.zig.CrossTarget;

pub fn addCases(cases: *tests.TranslateCContext) void {

const default_enum_type = if (std.Target.current.abi == .msvc) "c_int" else "c_uint";

const default_enum_type = if (builtin.abi == .msvc) "c_int" else "c_uint";

cases.add("field access is grouped if necessary",

\\unsigned long foo(unsigned long x) {

@@ -1153,7 +1154,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {

\\pub export fn foo() void {}

});

if (std.Target.current.os.tag != .windows) {

if (builtin.os.tag != .windows) {

// Windows treats this as an enum with type c_int

cases.add("big negative enum init values when C ABI supports long long enums",

\\enum EnumWithInits {

@@ -1558,7 +1559,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {

\\}

});

if (std.Target.current.os.tag != .windows) {

if (builtin.os.tag != .windows) {

// sysv_abi not currently supported on windows

cases.add("Macro qualified functions",

\\void __attribute__((sysv_abi)) foo(void);

@@ -2160,7 +2161,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {

\\}

});

if (std.Target.current.os.tag != .windows) {

if (builtin.os.tag != .windows) {

// When clang uses the <arch>-windows-none triple it behaves as MSVC and

// interprets the inner `struct Bar` as an anonymous structure

cases.add("type referenced struct",

@@ -3398,7 +3399,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {

\\pub const FOO = @import("std").zig.c_translation.cast(c_int, @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8000, .hexadecimal));

});

if (std.Target.current.abi == .msvc) {

if (builtin.abi == .msvc) {

cases.add("nameless struct fields",

\\typedef struct NAMED

\\{

tools/update_cpu_features.zig added: 771, removed: 743, total 28

@@ -1,4 +1,5 @@

const std = @import("std");

const builtin = @import("builtin");

const fs = std.fs;

const mem = std.mem;

const json = std.json;

@@ -803,7 +804,7 @@ pub fn main() anyerror!void {

const root_progress = try progress.start("", llvm_targets.len);

defer root_progress.end();

if (std.builtin.single_threaded) {

if (builtin.single_threaded) {

for (llvm_targets) |llvm_target| {

try processOneTarget(Job{

.llvm_tblgen_exe = llvm_tblgen_exe,