Nixyri/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2024-11-15 08:33:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

std: change @import("builtin") to std.builtin

Browse Source
This commit is contained in:
Andrew Kelley 2021-04-12 16:43:50 -07:00
parent a4bb7c8bb1
commit 429cd2b5dd
86 changed files with 263 additions and 268 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lib/std/Thread/AutoResetEvent.zig
View File

@ -32,7 +32,7 @@
state: usize = UNSET,
const std = @import("../std.zig");
const builtin = @import("builtin");
const builtin = std.builtin;
const testing = std.testing;
const assert = std.debug.assert;
const StaticResetEvent = std.Thread.StaticResetEvent;

2
lib/std/array_hash_map.zig
View File

@ -14,7 +14,7 @@ const trait = meta.trait;
const autoHash = std.hash.autoHash;
const Wyhash = std.hash.Wyhash;
const Allocator = mem.Allocator;
const builtin = @import("builtin");
const builtin = std.builtin;
const hash_map = @This();
pub fn AutoArrayHashMap(comptime K: type, comptime V: type) type {

2
lib/std/atomic/queue.zig
View File

@ -4,7 +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.zig");
const builtin = @import("builtin");
const builtin = std.builtin;
const assert = std.debug.assert;
const expect = std.testing.expect;

2
lib/std/atomic/stack.zig
View File

@ -4,7 +4,7 @@
// The MIT license requires this copyright notice to be included in all copies
// and substantial portions of the software.
const assert = std.debug.assert;
const builtin = @import("builtin");
const builtin = std.builtin;
const expect = std.testing.expect;
/// Many reader, many writer, non-allocating, thread-safe

4
lib/std/build.zig
View File

@ -1409,7 +1409,7 @@ pub const LibExeObjStep = struct {
red_zone: ?bool = null,
subsystem: ?builtin.SubSystem = null,
subsystem: ?std.Target.SubSystem = null,
/// Overrides the default stack size
stack_size: ?u64 = null,
@ -1961,7 +1961,7 @@ pub const LibExeObjStep = struct {
},
std.builtin.Version => {
out.print(
\\pub const {}: @import("builtin").Version = .{{
\\pub const {}: @import("std").builtin.Version = .{{
\\ .major = {d},
\\ .minor = {d},
\\ .patch = {d},

53
lib/std/builtin.zig
View File

@ -3,39 +3,40 @@
// This file is part of [zig](https://ziglang.org/), which is MIT licensed.
// The MIT license requires this copyright notice to be included in all copies
// and substantial portions of the software.
pub usingnamespace @import("builtin");
const builtin = @import("builtin");
/// Deprecated: use `std.Target`.
pub const Target = std.Target;
/// Deprecated: use `std.Target.Os`.
pub const Os = std.Target.Os;
/// Deprecated: use `std.Target.Cpu.Arch`.
pub const Arch = std.Target.Cpu.Arch;
/// Deprecated: use `std.Target.Abi`.
pub const Abi = std.Target.Abi;
/// Deprecated: use `std.Target.ObjectFormat`.
pub const ObjectFormat = std.Target.ObjectFormat;
/// Deprecated: use `std.Target.SubSystem`.
pub const SubSystem = std.Target.SubSystem;
/// Deprecated: use `std.Target.Cpu`.
pub const Cpu = std.Target.Cpu;
// 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;
/// `explicit_subsystem` is missing when the subsystem is automatically detected,
/// so Zig standard library has the subsystem detection logic here. This should generally be
/// used rather than `explicit_subsystem`.
/// On non-Windows targets, this is `null`.
pub const subsystem: ?SubSystem = blk: {
if (@hasDecl(@This(), "explicit_subsystem")) break :blk explicit_subsystem;
pub const subsystem: ?std.Target.SubSystem = blk: {
if (@hasDecl(builtin, "explicit_subsystem")) break :blk explicit_subsystem;
switch (os.tag) {
.windows => {
if (is_test) {
break :blk SubSystem.Console;
break :blk std.Target.SubSystem.Console;
}
if (@hasDecl(root, "main") or
@hasDecl(root, "WinMain") or
@ -43,9 +44,9 @@ pub const subsystem: ?SubSystem = blk: {
@hasDecl(root, "WinMainCRTStartup") or
@hasDecl(root, "wWinMainCRTStartup"))
{
break :blk SubSystem.Windows;
break :blk std.Target.SubSystem.Windows;
} else {
break :blk SubSystem.Console;
break :blk std.Target.SubSystem.Console;
}
},
else => break :blk null,

14
lib/std/c/linux.zig
View File

@ -3,12 +3,14 @@
// This file is part of [zig](https://ziglang.org/), which is MIT licensed.
// The MIT license requires this copyright notice to be included in all copies
// and substantial portions of the software.
const builtin = @import("builtin");
const std = @import("../std.zig");
const maxInt = std.math.maxInt;
const abi = std.Target.current.abi;
const arch = std.Target.current.cpu.arch;
const os_tag = std.Target.current.os.tag;
usingnamespace std.c;
pub const _errno = switch (builtin.abi) {
pub const _errno = switch (abi) {
.android => struct {
extern "c" var __errno: c_int;
fn getErrno() *c_int {
@ -124,7 +126,7 @@ pub const pthread_mutex_t = extern struct {
pub const pthread_cond_t = extern struct {
size: [__SIZEOF_PTHREAD_COND_T]u8 align(@alignOf(usize)) = [_]u8{0} ** __SIZEOF_PTHREAD_COND_T,
};
pub const pthread_rwlock_t = switch (std.builtin.abi) {
pub const pthread_rwlock_t = switch (abi) {
.android => switch (@sizeOf(usize)) {
4 => extern struct {
lock: std.c.pthread_mutex_t = std.c.PTHREAD_MUTEX_INITIALIZER,
@ -155,11 +157,11 @@ pub const sem_t = extern struct {
};
const __SIZEOF_PTHREAD_COND_T = 48;
const __SIZEOF_PTHREAD_MUTEX_T = if (builtin.os.tag == .fuchsia) 40 else switch (builtin.abi) {
const __SIZEOF_PTHREAD_MUTEX_T = if (os_tag == .fuchsia) 40 else switch (abi) {
.musl, .musleabi, .musleabihf => if (@sizeOf(usize) == 8) 40 else 24,
.gnu, .gnuabin32, .gnuabi64, .gnueabi, .gnueabihf, .gnux32 => switch (builtin.arch) {
.gnu, .gnuabin32, .gnuabi64, .gnueabi, .gnueabihf, .gnux32 => switch (arch) {
.aarch64 => 48,
.x86_64 => if (builtin.abi == .gnux32) 40 else 32,
.x86_64 => if (abi == .gnux32) 40 else 32,
.mips64, .powerpc64, .powerpc64le, .sparcv9 => 40,
else => if (@sizeOf(usize) == 8) 40 else 24,
},

2
lib/std/child_process.zig
View File

@ -15,7 +15,7 @@ const windows = os.windows;
const mem = std.mem;
const debug = std.debug;
const BufMap = std.BufMap;
const builtin = @import("builtin");
const builtin = std.builtin;
const Os = builtin.Os;
const TailQueue = std.TailQueue;
const maxInt = std.math.maxInt;

2
lib/std/coff.zig
View File

@ -3,7 +3,7 @@
// This file is part of [zig](https://ziglang.org/), which is MIT licensed.
// The MIT license requires this copyright notice to be included in all copies
// and substantial portions of the software.
const builtin = @import("builtin");
const builtin = std.builtin;
const std = @import("std.zig");
const io = std.io;
const mem = std.mem;

2
lib/std/cstr.zig
View File

@ -4,7 +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.zig");
const builtin = @import("builtin");
const builtin = std.builtin;
const debug = std.debug;
const mem = std.mem;
const testing = std.testing;

47
lib/std/debug.zig
View File

@ -21,6 +21,9 @@ 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_endian = native_arch.endian();
pub const runtime_safety = switch (builtin.mode) {
.Debug, .ReleaseSafe => true,
@ -90,7 +93,7 @@ pub fn detectTTYConfig() TTY.Config {
const stderr_file = io.getStdErr();
if (stderr_file.supportsAnsiEscapeCodes()) {
return .escape_codes;
} else if (builtin.os.tag == .windows and stderr_file.isTty()) {
} else if (native_os == .windows and stderr_file.isTty()) {
return .windows_api;
} else {
return .no_color;
@ -148,7 +151,7 @@ pub fn dumpStackTraceFromBase(bp: usize, ip: usize) void {
/// 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 {
if (builtin.os.tag == .windows) {
if (native_os == .windows) {
const addrs = stack_trace.instruction_addresses;
const u32_addrs_len = @intCast(u32, addrs.len);
const first_addr = first_address orelse {
@ -226,7 +229,7 @@ pub fn assert(ok: bool) void {
pub fn panic(comptime format: []const u8, args: anytype) noreturn {
@setCold(true);
// TODO: remove conditional once wasi / LLVM defines __builtin_return_address
const first_trace_addr = if (builtin.os.tag == .wasi) null else @returnAddress();
const first_trace_addr = if (native_os == .wasi) null else @returnAddress();
panicExtra(null, first_trace_addr, format, args);
}
@ -343,25 +346,25 @@ pub const StackIterator = struct {
}
// Offset of the saved BP wrt the frame pointer.
const fp_offset = if (builtin.arch.isRISCV())
const fp_offset = if (native_arch.isRISCV())
// On RISC-V the frame pointer points to the top of the saved register
// area, on pretty much every other architecture it points to the stack
// slot where the previous frame pointer is saved.
2 * @sizeOf(usize)
else if (builtin.arch.isSPARC())
else if (native_arch.isSPARC())
// On SPARC the previous frame pointer is stored at 14 slots past %fp+BIAS.
14 * @sizeOf(usize)
else
0;
const fp_bias = if (builtin.arch.isSPARC())
const fp_bias = if (native_arch.isSPARC())
// On SPARC frame pointers are biased by a constant.
2047
else
0;
// Positive offset of the saved PC wrt the frame pointer.
const pc_offset = if (builtin.arch == .powerpc64le)
const pc_offset = if (native_arch == .powerpc64le)
2 * @sizeOf(usize)
else
@sizeOf(usize);
@ -380,7 +383,7 @@ pub const StackIterator = struct {
}
fn next_internal(self: *StackIterator) ?usize {
const fp = if (builtin.arch.isSPARC())
const fp = if (native_arch.isSPARC())
// On SPARC the offset is positive. (!)
math.add(usize, self.fp, fp_offset) catch return null
else
@ -416,7 +419,7 @@ pub fn writeCurrentStackTrace(
tty_config: TTY.Config,
start_addr: ?usize,
) !void {
if (builtin.os.tag == .windows) {
if (native_os == .windows) {
return writeCurrentStackTraceWindows(out_stream, debug_info, tty_config, start_addr);
}
var it = StackIterator.init(start_addr, null);
@ -473,7 +476,7 @@ pub const TTY = struct {
.Dim => out_stream.writeAll(DIM) catch return,
.Reset => out_stream.writeAll(RESET) catch return,
},
.windows_api => if (builtin.os.tag == .windows) {
.windows_api => if (native_os == .windows) {
const stderr_file = io.getStdErr();
const S = struct {
var attrs: windows.WORD = undefined;
@ -675,7 +678,7 @@ pub fn openSelfDebugInfo(allocator: *mem.Allocator) anyerror!DebugInfo {
if (@hasDecl(root, "os") and @hasDecl(root.os, "debug") and @hasDecl(root.os.debug, "openSelfDebugInfo")) {
return root.os.debug.openSelfDebugInfo(allocator);
}
switch (builtin.os.tag) {
switch (native_os) {
.linux,
.freebsd,
.netbsd,
@ -888,7 +891,7 @@ pub fn readElfDebugInfo(allocator: *mem.Allocator, elf_file: File) !ModuleDebugI
elf.ELFDATA2MSB => .Big,
else => return error.InvalidElfEndian,
};
assert(endian == std.builtin.endian); // this is our own debug info
assert(endian == native_endian); // this is our own debug info
const shoff = hdr.e_shoff;
const str_section_off = shoff + @as(u64, hdr.e_shentsize) * @as(u64, hdr.e_shstrndx);
@ -1123,9 +1126,9 @@ pub const DebugInfo = struct {
pub fn getModuleForAddress(self: *DebugInfo, address: usize) !*ModuleDebugInfo {
if (comptime std.Target.current.isDarwin()) {
return self.lookupModuleDyld(address);
} else if (builtin.os.tag == .windows) {
} else if (native_os == .windows) {
return self.lookupModuleWin32(address);
} else if (builtin.os.tag == .haiku) {
} else if (native_os == .haiku) {
return self.lookupModuleHaiku(address);
} else {
return self.lookupModuleDl(address);
@ -1353,7 +1356,7 @@ const SymbolInfo = struct {
}
};
pub const ModuleDebugInfo = switch (builtin.os.tag) {
pub const ModuleDebugInfo = switch (native_os) {
.macos, .ios, .watchos, .tvos => struct {
base_address: usize,
mapped_memory: []const u8,
@ -1720,7 +1723,7 @@ fn getDebugInfoAllocator() *mem.Allocator {
}
/// Whether or not the current target can print useful debug information when a segfault occurs.
pub const have_segfault_handling_support = switch (builtin.os.tag) {
pub const have_segfault_handling_support = switch (native_os) {
.linux, .netbsd => true,
.windows => true,
.freebsd, .openbsd => @hasDecl(os, "ucontext_t"),
@ -1744,7 +1747,7 @@ pub fn attachSegfaultHandler() void {
if (!have_segfault_handling_support) {
@compileError("segfault handler not supported for this target");
}
if (builtin.os.tag == .windows) {
if (native_os == .windows) {
windows_segfault_handle = windows.kernel32.AddVectoredExceptionHandler(0, handleSegfaultWindows);
return;
}
@ -1760,7 +1763,7 @@ pub fn attachSegfaultHandler() void {
}
fn resetSegfaultHandler() void {
if (builtin.os.tag == .windows) {
if (native_os == .windows) {
if (windows_segfault_handle) |handle| {
assert(windows.kernel32.RemoveVectoredExceptionHandler(handle) != 0);
windows_segfault_handle = null;
@ -1783,7 +1786,7 @@ fn handleSegfaultLinux(sig: i32, info: *const os.siginfo_t, ctx_ptr: ?*const c_v
// and the resulting segfault will crash the process rather than continually dump stack traces.
resetSegfaultHandler();
const addr = switch (builtin.os.tag) {
const addr = switch (native_os) {
.linux => @ptrToInt(info.fields.sigfault.addr),
.freebsd => @ptrToInt(info.addr),
.netbsd => @ptrToInt(info.info.reason.fault.addr),
@ -1802,7 +1805,7 @@ fn handleSegfaultLinux(sig: i32, info: *const os.siginfo_t, ctx_ptr: ?*const c_v
} catch os.abort();
}
switch (builtin.arch) {
switch (native_arch) {
.i386 => {
const ctx = @ptrCast(*const os.ucontext_t, @alignCast(@alignOf(os.ucontext_t), ctx_ptr));
const ip = @intCast(usize, ctx.mcontext.gregs[os.REG_EIP]);
@ -1811,13 +1814,13 @@ fn handleSegfaultLinux(sig: i32, info: *const os.siginfo_t, ctx_ptr: ?*const c_v
},
.x86_64 => {
const ctx = @ptrCast(*const os.ucontext_t, @alignCast(@alignOf(os.ucontext_t), ctx_ptr));
const ip = switch (builtin.os.tag) {
const ip = switch (native_os) {
.linux, .netbsd => @intCast(usize, ctx.mcontext.gregs[os.REG_RIP]),
.freebsd => @intCast(usize, ctx.mcontext.rip),
.openbsd => @intCast(usize, ctx.sc_rip),
else => unreachable,
};
const bp = switch (builtin.os.tag) {
const bp = switch (native_os) {
.linux, .netbsd => @intCast(usize, ctx.mcontext.gregs[os.REG_RBP]),
.openbsd => @intCast(usize, ctx.sc_rbp),
.freebsd => @intCast(usize, ctx.mcontext.rbp),

2
lib/std/dwarf.zig
View File

@ -4,7 +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.zig");
const builtin = @import("builtin");
const builtin = std.builtin;
const debug = std.debug;
const fs = std.fs;
const io = std.io;

2
lib/std/dynamic_library.zig
View File

@ -3,7 +3,7 @@
// This file is part of [zig](https://ziglang.org/), which is MIT licensed.
// The MIT license requires this copyright notice to be included in all copies
// and substantial portions of the software.
const builtin = @import("builtin");
const builtin = std.builtin;
const std = @import("std.zig");
const mem = std.mem;

2
lib/std/event/channel.zig
View File

@ -4,7 +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.zig");
const builtin = @import("builtin");
const builtin = std.builtin;
const assert = std.debug.assert;
const testing = std.testing;
const Loop = std.event.Loop;

2
lib/std/event/future.zig
View File

@ -6,7 +6,7 @@
const std = @import("../std.zig");
const assert = std.debug.assert;
const testing = std.testing;
const builtin = @import("builtin");
const builtin = std.builtin;
const Lock = std.event.Lock;
/// This is a value that starts out unavailable, until resolve() is called

2
lib/std/event/group.zig
View File

@ -4,7 +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.zig");
const builtin = @import("builtin");
const builtin = std.builtin;
const Lock = std.event.Lock;
const testing = std.testing;
const Allocator = std.mem.Allocator;

2
lib/std/event/lock.zig
View File

@ -4,7 +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.zig");
const builtin = @import("builtin");
const builtin = std.builtin;
const assert = std.debug.assert;
const testing = std.testing;
const mem = std.mem;

2
lib/std/event/loop.zig
View File

@ -4,7 +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.zig");
const builtin = @import("builtin");
const builtin = std.builtin;
const root = @import("root");
const assert = std.debug.assert;
const testing = std.testing;

2
lib/std/event/rwlock.zig
View File

@ -4,7 +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.zig");
const builtin = @import("builtin");
const builtin = std.builtin;
const assert = std.debug.assert;
const testing = std.testing;
const mem = std.mem;

2
lib/std/event/wait_group.zig
View File

@ -4,7 +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.zig");
const builtin = @import("builtin");
const builtin = std.builtin;
const Loop = std.event.Loop;
/// A WaitGroup keeps track and waits for a group of async tasks to finish.

2
lib/std/fmt.zig
View File

@ -9,7 +9,7 @@ const assert = std.debug.assert;
const mem = std.mem;
const unicode = std.unicode;
const meta = std.meta;
const builtin = @import("builtin");
const builtin = std.builtin;
const errol = @import("fmt/errol.zig");
const lossyCast = std.math.lossyCast;
const expectFmt = std.testing.expectFmt;

2
lib/std/fs.zig
View File

@ -3,7 +3,7 @@
// This file is part of [zig](https://ziglang.org/), which is MIT licensed.
// The MIT license requires this copyright notice to be included in all copies
// and substantial portions of the software.
const builtin = @import("builtin");
const builtin = std.builtin;
const std = @import("std.zig");
const os = std.os;
const mem = std.mem;

2
lib/std/fs/file.zig
View File

@ -4,7 +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.zig");
const builtin = @import("builtin");
const builtin = std.builtin;
const os = std.os;
const io = std.io;
const mem = std.mem;

2
lib/std/fs/get_app_data_dir.zig
View File

@ -4,7 +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.zig");
const builtin = @import("builtin");
const builtin = std.builtin;
const unicode = std.unicode;
const mem = std.mem;
const fs = std.fs;

2
lib/std/fs/path.zig
View File

@ -3,7 +3,7 @@
// This file is part of [zig](https://ziglang.org/), which is MIT licensed.
// The MIT license requires this copyright notice to be included in all copies
// and substantial portions of the software.
const builtin = @import("builtin");
const builtin = std.builtin;
const std = @import("../std.zig");
const debug = std.debug;
const assert = debug.assert;

2
lib/std/fs/wasi.zig
View File

@ -167,7 +167,7 @@ pub const PreopenList = struct {
};
test "extracting WASI preopens" {
if (@import("builtin").os.tag != .wasi) return error.SkipZigTest;
if (std.builtin.os.tag != .wasi) return error.SkipZigTest;
var preopens = PreopenList.init(std.testing.allocator);
defer preopens.deinit();

2
lib/std/fs/watch.zig
View File

@ -4,7 +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 builtin = std.builtin;
const event = std.event;
const assert = std.debug.assert;
const testing = std.testing;

6
lib/std/hash/auto_hash.zig
View File

@ -4,10 +4,10 @@
// 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 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 {
@ -239,7 +239,7 @@ fn testHashDeepRecursive(key: anytype) u64 {
test "typeContainsSlice" {
comptime {
testing.expect(!typeContainsSlice(meta.Tag(std.builtin.TypeInfo)));
testing.expect(!typeContainsSlice(meta.Tag(builtin.TypeInfo)));
testing.expect(typeContainsSlice([]const u8));
testing.expect(!typeContainsSlice(u8));
@ -400,7 +400,7 @@ test "testHash union" {
test "testHash vector" {
// Disabled because of #3317
if (@import("builtin").arch == .mipsel or @import("builtin").arch == .mips) return error.SkipZigTest;
if (builtin.target.cpu.arch == .mipsel or builtin.target.cpu.arch == .mips) return error.SkipZigTest;
const a: meta.Vector(4, u32) = [_]u32{ 1, 2, 3, 4 };
const b: meta.Vector(4, u32) = [_]u32{ 1, 2, 3, 5 };

2
lib/std/hash/benchmark.zig
View File

@ -5,7 +5,7 @@
// and substantial portions of the software.
// zig run benchmark.zig --release-fast --override-lib-dir ..
const builtin = @import("builtin");
const builtin = std.builtin;
const std = @import("std");
const time = std.time;
const Timer = time.Timer;

2
lib/std/hash/cityhash.zig
View File

@ -4,7 +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 builtin = std.builtin;
fn offsetPtr(ptr: [*]const u8, offset: usize) callconv(.Inline) [*]const u8 {
// ptr + offset doesn't work at comptime so we need this instead.

2
lib/std/hash/murmur.zig
View File

@ -4,7 +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 builtin = std.builtin;
const testing = std.testing;
const default_seed: u32 = 0xc70f6907;

1
lib/std/hash_map.zig
View File

@ -4,7 +4,6 @@
// The MIT license requires this copyright notice to be included in all copies
// and substantial portions of the software.
const std = @import("std.zig");
const builtin = @import("builtin");
const assert = debug.assert;
const autoHash = std.hash.autoHash;
const debug = std.debug;

2
lib/std/heap.zig
View File

@ -10,7 +10,7 @@ const assert = debug.assert;
const testing = std.testing;
const mem = std.mem;
const os = std.os;
const builtin = @import("builtin");
const builtin = std.builtin;
const c = std.c;
const maxInt = std.math.maxInt;

2
lib/std/io.zig
View File

@ -4,7 +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.zig");
const builtin = @import("builtin");
const builtin = std.builtin;
const root = @import("root");
const c = std.c;

1
lib/std/math/acosh.zig
View File

@ -9,7 +9,6 @@
// https://git.musl-libc.org/cgit/musl/tree/src/math/acoshf.c
// https://git.musl-libc.org/cgit/musl/tree/src/math/acosh.c
const builtin = @import("builtin");
const std = @import("../std.zig");
const math = std.math;
const expect = std.testing.expect;

1
lib/std/math/ceil.zig
View File

@ -9,7 +9,6 @@
// https://git.musl-libc.org/cgit/musl/tree/src/math/ceilf.c
// https://git.musl-libc.org/cgit/musl/tree/src/math/ceil.c
const builtin = @import("builtin");
const std = @import("../std.zig");
const math = std.math;
const expect = std.testing.expect;

1
lib/std/math/complex/atan.zig
View File

@ -10,7 +10,6 @@
// https://git.musl-libc.org/cgit/musl/tree/src/complex/catan.c
const std = @import("../../std.zig");
const builtin = @import("builtin");
const testing = std.testing;
const math = std.math;
const cmath = math.complex;

1
lib/std/math/complex/cosh.zig
View File

@ -9,7 +9,6 @@
// https://git.musl-libc.org/cgit/musl/tree/src/complex/ccoshf.c
// https://git.musl-libc.org/cgit/musl/tree/src/complex/ccosh.c
const builtin = @import("builtin");
const std = @import("../../std.zig");
const testing = std.testing;
const math = std.math;

1
lib/std/math/complex/exp.zig
View File

@ -9,7 +9,6 @@
// https://git.musl-libc.org/cgit/musl/tree/src/complex/cexpf.c
// https://git.musl-libc.org/cgit/musl/tree/src/complex/cexp.c
const builtin = @import("builtin");
const std = @import("../../std.zig");
const testing = std.testing;
const math = std.math;

1
lib/std/math/complex/sinh.zig
View File

@ -9,7 +9,6 @@
// https://git.musl-libc.org/cgit/musl/tree/src/complex/csinhf.c
// https://git.musl-libc.org/cgit/musl/tree/src/complex/csinh.c
const builtin = @import("builtin");
const std = @import("../../std.zig");
const testing = std.testing;
const math = std.math;

1
lib/std/math/complex/tanh.zig
View File

@ -9,7 +9,6 @@
// https://git.musl-libc.org/cgit/musl/tree/src/complex/ctanhf.c
// https://git.musl-libc.org/cgit/musl/tree/src/complex/ctanh.c
const builtin = @import("builtin");
const std = @import("../../std.zig");
const testing = std.testing;
const math = std.math;

1
lib/std/math/cos.zig
View File

@ -8,7 +8,6 @@
//
// https://golang.org/src/math/sin.go
const builtin = @import("builtin");
const std = @import("../std.zig");
const math = std.math;
const expect = std.testing.expect;

1
lib/std/math/cosh.zig
View File

@ -9,7 +9,6 @@
// https://git.musl-libc.org/cgit/musl/tree/src/math/coshf.c
// https://git.musl-libc.org/cgit/musl/tree/src/math/cosh.c
const builtin = @import("builtin");
const std = @import("../std.zig");
const math = std.math;
const expo2 = @import("expo2.zig").expo2;

1
lib/std/math/expm1.zig
View File

@ -11,7 +11,6 @@
// TODO: Updated recently.
const builtin = @import("builtin");
const std = @import("../std.zig");
const math = std.math;
const expect = std.testing.expect;

1
lib/std/math/floor.zig
View File

@ -9,7 +9,6 @@
// https://git.musl-libc.org/cgit/musl/tree/src/math/floorf.c
// https://git.musl-libc.org/cgit/musl/tree/src/math/floor.c
const builtin = @import("builtin");
const expect = std.testing.expect;
const std = @import("../std.zig");
const math = std.math;

1
lib/std/math/log1p.zig
View File

@ -9,7 +9,6 @@
// https://git.musl-libc.org/cgit/musl/tree/src/math/log1pf.c
// https://git.musl-libc.org/cgit/musl/tree/src/math/log1p.c
const builtin = @import("builtin");
const std = @import("../std.zig");
const math = std.math;
const expect = std.testing.expect;

1
lib/std/math/pow.zig
View File

@ -8,7 +8,6 @@
//
// https://golang.org/src/math/pow.go
const builtin = @import("builtin");
const std = @import("../std.zig");
const math = std.math;
const expect = std.testing.expect;

1
lib/std/math/powi.zig
View File

@ -8,7 +8,6 @@
//
// https://github.com/rust-lang/rust/blob/360432f1e8794de58cd94f34c9c17ad65871e5b5/src/libcore/num/mod.rs#L3423
const builtin = @import("builtin");
const std = @import("../std.zig");
const math = std.math;
const assert = std.debug.assert;

1
lib/std/math/round.zig
View File

@ -9,7 +9,6 @@
// https://git.musl-libc.org/cgit/musl/tree/src/math/roundf.c
// https://git.musl-libc.org/cgit/musl/tree/src/math/round.c
const builtin = @import("builtin");
const expect = std.testing.expect;
const std = @import("../std.zig");
const math = std.math;

1
lib/std/math/sin.zig
View File

@ -8,7 +8,6 @@
//
// https://golang.org/src/math/sin.go
const builtin = @import("builtin");
const std = @import("../std.zig");
const math = std.math;
const expect = std.testing.expect;

1
lib/std/math/sinh.zig
View File

@ -9,7 +9,6 @@
// https://git.musl-libc.org/cgit/musl/tree/src/math/sinhf.c
// https://git.musl-libc.org/cgit/musl/tree/src/math/sinh.c
const builtin = @import("builtin");
const std = @import("../std.zig");
const math = std.math;
const expect = std.testing.expect;

3
lib/std/math/sqrt.zig
View File

@ -6,8 +6,7 @@
const std = @import("../std.zig");
const math = std.math;
const expect = std.testing.expect;
const builtin = @import("builtin");
const TypeId = builtin.TypeId;
const TypeId = std.builtin.TypeId;
const maxInt = std.math.maxInt;
/// Returns the square root of x.

1
lib/std/math/tan.zig
View File

@ -8,7 +8,6 @@
//
// https://golang.org/src/math/tan.go
const builtin = @import("builtin");
const std = @import("../std.zig");
const math = std.math;
const expect = std.testing.expect;

1
lib/std/math/tanh.zig
View File

@ -9,7 +9,6 @@
// https://git.musl-libc.org/cgit/musl/tree/src/math/tanhf.c
// https://git.musl-libc.org/cgit/musl/tree/src/math/tanh.c
const builtin = @import("builtin");
const std = @import("../std.zig");
const math = std.math;
const expect = std.testing.expect;

91
lib/std/mem.zig
View File

@ -7,17 +7,18 @@ const std = @import("std.zig");
const debug = std.debug;
const assert = debug.assert;
const math = std.math;
const builtin = std.builtin;
const mem = @This();
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();
/// Compile time known minimum page size.
/// https://github.com/ziglang/zig/issues/4082
pub const page_size = switch (builtin.arch) {
pub const page_size = switch (std.Target.current.cpu.arch) {
.wasm32, .wasm64 => 64 * 1024,
.aarch64 => switch (builtin.os.tag) {
.aarch64 => switch (std.Target.current.os.tag) {
.macos, .ios, .watchos, .tvos => 16 * 1024,
else => 4 * 1024,
},
@ -1042,7 +1043,7 @@ test "mem.containsAtLeast" {
/// Reads an integer from memory with size equal to bytes.len.
/// T specifies the return type, which must be large enough to store
/// the result.
pub fn readVarInt(comptime ReturnType: type, bytes: []const u8, endian: builtin.Endian) ReturnType {
pub fn readVarInt(comptime ReturnType: type, bytes: []const u8, endian: Endian) ReturnType {
var result: ReturnType = 0;
switch (endian) {
.Big => {
@ -1077,12 +1078,12 @@ pub fn readIntForeign(comptime T: type, bytes: *const [@divExact(@typeInfo(T).In
return @byteSwap(T, readIntNative(T, bytes));
}
pub const readIntLittle = switch (builtin.endian) {
pub const readIntLittle = switch (native_endian) {
.Little => readIntNative,
.Big => readIntForeign,
};
pub const readIntBig = switch (builtin.endian) {
pub const readIntBig = switch (native_endian) {
.Little => readIntForeign,
.Big => readIntNative,
};
@ -1106,12 +1107,12 @@ pub fn readIntSliceForeign(comptime T: type, bytes: []const u8) T {
return @byteSwap(T, readIntSliceNative(T, bytes));
}
pub const readIntSliceLittle = switch (builtin.endian) {
pub const readIntSliceLittle = switch (native_endian) {
.Little => readIntSliceNative,
.Big => readIntSliceForeign,
};
pub const readIntSliceBig = switch (builtin.endian) {
pub const readIntSliceBig = switch (native_endian) {
.Little => readIntSliceForeign,
.Big => readIntSliceNative,
};
@ -1119,8 +1120,8 @@ pub const readIntSliceBig = switch (builtin.endian) {
/// Reads an integer from memory with bit count specified by T.
/// The bit count of T must be evenly divisible by 8.
/// This function cannot fail and cannot cause undefined behavior.
pub fn readInt(comptime T: type, bytes: *const [@divExact(@typeInfo(T).Int.bits, 8)]u8, endian: builtin.Endian) T {
if (endian == builtin.endian) {
pub fn readInt(comptime T: type, bytes: *const [@divExact(@typeInfo(T).Int.bits, 8)]u8, endian: Endian) T {
if (endian == native_endian) {
return readIntNative(T, bytes);
} else {
return readIntForeign(T, bytes);
@ -1130,7 +1131,7 @@ pub fn readInt(comptime T: type, bytes: *const [@divExact(@typeInfo(T).Int.bits,
/// Asserts that bytes.len >= @typeInfo(T).Int.bits / 8. Reads the integer starting from index 0
/// and ignores extra bytes.
/// The bit count of T must be evenly divisible by 8.
pub fn readIntSlice(comptime T: type, bytes: []const u8, endian: builtin.Endian) T {
pub fn readIntSlice(comptime T: type, bytes: []const u8, endian: Endian) T {
const n = @divExact(@typeInfo(T).Int.bits, 8);
assert(bytes.len >= n);
return readInt(T, bytes[0..n], endian);
@ -1188,12 +1189,12 @@ pub fn writeIntForeign(comptime T: type, buf: *[@divExact(@typeInfo(T).Int.bits,
writeIntNative(T, buf, @byteSwap(T, value));
}
pub const writeIntLittle = switch (builtin.endian) {
pub const writeIntLittle = switch (native_endian) {
.Little => writeIntNative,
.Big => writeIntForeign,
};
pub const writeIntBig = switch (builtin.endian) {
pub const writeIntBig = switch (native_endian) {
.Little => writeIntForeign,
.Big => writeIntNative,
};
@ -1201,8 +1202,8 @@ pub const writeIntBig = switch (builtin.endian) {
/// Writes an integer to memory, storing it in twos-complement.
/// This function always succeeds, has defined behavior for all inputs, but
/// the integer bit width must be divisible by 8.
pub fn writeInt(comptime T: type, buffer: *[@divExact(@typeInfo(T).Int.bits, 8)]u8, value: T, endian: builtin.Endian) void {
if (endian == builtin.endian) {
pub fn writeInt(comptime T: type, buffer: *[@divExact(@typeInfo(T).Int.bits, 8)]u8, value: T, endian: Endian) void {
if (endian == native_endian) {
return writeIntNative(T, buffer, value);
} else {
return writeIntForeign(T, buffer, value);
@ -1252,12 +1253,12 @@ pub fn writeIntSliceBig(comptime T: type, buffer: []u8, value: T) void {
}
}
pub const writeIntSliceNative = switch (builtin.endian) {
pub const writeIntSliceNative = switch (native_endian) {
.Little => writeIntSliceLittle,
.Big => writeIntSliceBig,
};
pub const writeIntSliceForeign = switch (builtin.endian) {
pub const writeIntSliceForeign = switch (native_endian) {
.Little => writeIntSliceBig,
.Big => writeIntSliceLittle,
};
@ -1268,7 +1269,7 @@ pub const writeIntSliceForeign = switch (builtin.endian) {
/// Any extra bytes in buffer not part of the integer are set to zero, with
/// respect to endianness. To avoid the branch to check for extra buffer bytes,
/// use writeInt instead.
pub fn writeIntSlice(comptime T: type, buffer: []u8, value: T, endian: builtin.Endian) void {
pub fn writeIntSlice(comptime T: type, buffer: []u8, value: T, endian: Endian) void {
comptime assert(@typeInfo(T).Int.bits % 8 == 0);
return switch (endian) {
.Little => writeIntSliceLittle(T, buffer, value),
@ -1678,10 +1679,10 @@ fn testReadIntImpl() void {
0x56,
0x78,
};
testing.expect(readInt(u32, &bytes, builtin.Endian.Big) == 0x12345678);
testing.expect(readInt(u32, &bytes, Endian.Big) == 0x12345678);
testing.expect(readIntBig(u32, &bytes) == 0x12345678);
testing.expect(readIntBig(i32, &bytes) == 0x12345678);
testing.expect(readInt(u32, &bytes, builtin.Endian.Little) == 0x78563412);
testing.expect(readInt(u32, &bytes, Endian.Little) == 0x78563412);
testing.expect(readIntLittle(u32, &bytes) == 0x78563412);
testing.expect(readIntLittle(i32, &bytes) == 0x78563412);
}
@ -1692,7 +1693,7 @@ fn testReadIntImpl() void {
0x12,
0x34,
};
const answer = readInt(u32, &buf, builtin.Endian.Big);
const answer = readInt(u32, &buf, Endian.Big);
testing.expect(answer == 0x00001234);
}
{
@ -1702,7 +1703,7 @@ fn testReadIntImpl() void {
0x00,
0x00,
};
const answer = readInt(u32, &buf, builtin.Endian.Little);
const answer = readInt(u32, &buf, Endian.Little);
testing.expect(answer == 0x00003412);
}
{
@ -1724,19 +1725,19 @@ test "writeIntSlice" {
fn testWriteIntImpl() void {
var bytes: [8]u8 = undefined;
writeIntSlice(u0, bytes[0..], 0, builtin.Endian.Big);
writeIntSlice(u0, bytes[0..], 0, Endian.Big);
testing.expect(eql(u8, &bytes, &[_]u8{
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
}));
writeIntSlice(u0, bytes[0..], 0, builtin.Endian.Little);
writeIntSlice(u0, bytes[0..], 0, Endian.Little);
testing.expect(eql(u8, &bytes, &[_]u8{
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
}));
writeIntSlice(u64, bytes[0..], 0x12345678CAFEBABE, builtin.Endian.Big);
writeIntSlice(u64, bytes[0..], 0x12345678CAFEBABE, Endian.Big);
testing.expect(eql(u8, &bytes, &[_]u8{
0x12,
0x34,
@ -1748,7 +1749,7 @@ fn testWriteIntImpl() void {
0xBE,
}));
writeIntSlice(u64, bytes[0..], 0xBEBAFECA78563412, builtin.Endian.Little);
writeIntSlice(u64, bytes[0..], 0xBEBAFECA78563412, Endian.Little);
testing.expect(eql(u8, &bytes, &[_]u8{
0x12,
0x34,
@ -1760,7 +1761,7 @@ fn testWriteIntImpl() void {
0xBE,
}));
writeIntSlice(u32, bytes[0..], 0x12345678, builtin.Endian.Big);
writeIntSlice(u32, bytes[0..], 0x12345678, Endian.Big);
testing.expect(eql(u8, &bytes, &[_]u8{
0x00,
0x00,
@ -1772,7 +1773,7 @@ fn testWriteIntImpl() void {
0x78,
}));
writeIntSlice(u32, bytes[0..], 0x78563412, builtin.Endian.Little);
writeIntSlice(u32, bytes[0..], 0x78563412, Endian.Little);
testing.expect(eql(u8, &bytes, &[_]u8{
0x12,
0x34,
@ -1784,7 +1785,7 @@ fn testWriteIntImpl() void {
0x00,
}));
writeIntSlice(u16, bytes[0..], 0x1234, builtin.Endian.Big);
writeIntSlice(u16, bytes[0..], 0x1234, Endian.Big);
testing.expect(eql(u8, &bytes, &[_]u8{
0x00,
0x00,
@ -1796,7 +1797,7 @@ fn testWriteIntImpl() void {
0x34,
}));
writeIntSlice(u16, bytes[0..], 0x1234, builtin.Endian.Little);
writeIntSlice(u16, bytes[0..], 0x1234, Endian.Little);
testing.expect(eql(u8, &bytes, &[_]u8{
0x34,
0x12,
@ -1949,7 +1950,7 @@ test "replaceOwned" {
/// Converts a little-endian integer to host endianness.
pub fn littleToNative(comptime T: type, x: T) T {
return switch (builtin.endian) {
return switch (native_endian) {
.Little => x,
.Big => @byteSwap(T, x),
};
@ -1957,14 +1958,14 @@ pub fn littleToNative(comptime T: type, x: T) T {
/// Converts a big-endian integer to host endianness.
pub fn bigToNative(comptime T: type, x: T) T {
return switch (builtin.endian) {
return switch (native_endian) {
.Little => @byteSwap(T, x),
.Big => x,
};
}
/// Converts an integer from specified endianness to host endianness.
pub fn toNative(comptime T: type, x: T, endianness_of_x: builtin.Endian) T {
pub fn toNative(comptime T: type, x: T, endianness_of_x: Endian) T {
return switch (endianness_of_x) {
.Little => littleToNative(T, x),
.Big => bigToNative(T, x),
@ -1972,7 +1973,7 @@ pub fn toNative(comptime T: type, x: T, endianness_of_x: builtin.Endian) T {
}
/// Converts an integer which has host endianness to the desired endianness.
pub fn nativeTo(comptime T: type, x: T, desired_endianness: builtin.Endian) T {
pub fn nativeTo(comptime T: type, x: T, desired_endianness: Endian) T {
return switch (desired_endianness) {
.Little => nativeToLittle(T, x),
.Big => nativeToBig(T, x),
@ -1981,7 +1982,7 @@ pub fn nativeTo(comptime T: type, x: T, desired_endianness: builtin.Endian) T {
/// Converts an integer which has host endianness to little endian.
pub fn nativeToLittle(comptime T: type, x: T) T {
return switch (builtin.endian) {
return switch (native_endian) {
.Little => x,
.Big => @byteSwap(T, x),
};
@ -1989,13 +1990,13 @@ pub fn nativeToLittle(comptime T: type, x: T) T {
/// Converts an integer which has host endianness to big endian.
pub fn nativeToBig(comptime T: type, x: T) T {
return switch (builtin.endian) {
return switch (native_endian) {
.Little => @byteSwap(T, x),
.Big => x,
};
}
fn CopyPtrAttrs(comptime source: type, comptime size: builtin.TypeInfo.Pointer.Size, comptime child: type) type {
fn CopyPtrAttrs(comptime source: type, comptime size: std.builtin.TypeInfo.Pointer.Size, comptime child: type) type {
const info = @typeInfo(source).Pointer;
return @Type(.{
.Pointer = .{
@ -2027,7 +2028,7 @@ pub fn asBytes(ptr: anytype) AsBytesReturnType(@TypeOf(ptr)) {
test "asBytes" {
const deadbeef = @as(u32, 0xDEADBEEF);
const deadbeef_bytes = switch (builtin.endian) {
const deadbeef_bytes = switch (native_endian) {
.Big => "\xDE\xAD\xBE\xEF",
.Little => "\xEF\xBE\xAD\xDE",
};
@ -2080,13 +2081,13 @@ pub fn toBytes(value: anytype) [@sizeOf(@TypeOf(value))]u8 {
test "toBytes" {
var my_bytes = toBytes(@as(u32, 0x12345678));
switch (builtin.endian) {
switch (native_endian) {
.Big => testing.expect(eql(u8, &my_bytes, "\x12\x34\x56\x78")),
.Little => testing.expect(eql(u8, &my_bytes, "\x78\x56\x34\x12")),
}
my_bytes[0] = '\x99';
switch (builtin.endian) {
switch (native_endian) {
.Big => testing.expect(eql(u8, &my_bytes, "\x99\x34\x56\x78")),
.Little => testing.expect(eql(u8, &my_bytes, "\x99\x56\x34\x12")),
}
@ -2113,14 +2114,14 @@ pub fn bytesAsValue(comptime T: type, bytes: anytype) BytesAsValueReturnType(T,
test "bytesAsValue" {
const deadbeef = @as(u32, 0xDEADBEEF);
const deadbeef_bytes = switch (builtin.endian) {
const deadbeef_bytes = switch (native_endian) {
.Big => "\xDE\xAD\xBE\xEF",
.Little => "\xEF\xBE\xAD\xDE",
};
testing.expect(deadbeef == bytesAsValue(u32, deadbeef_bytes).*);
var codeface_bytes: [4]u8 = switch (builtin.endian) {
var codeface_bytes: [4]u8 = switch (native_endian) {
.Big => "\xC0\xDE\xFA\xCE",
.Little => "\xCE\xFA\xDE\xC0",
}.*;
@ -2168,7 +2169,7 @@ pub fn bytesToValue(comptime T: type, bytes: anytype) T {
return bytesAsValue(T, bytes).*;
}
test "bytesToValue" {
const deadbeef_bytes = switch (builtin.endian) {
const deadbeef_bytes = switch (native_endian) {
.Big => "\xDE\xAD\xBE\xEF",
.Little => "\xEF\xBE\xAD\xDE",
};
@ -2297,7 +2298,7 @@ test "sliceAsBytes" {
const bytes = [_]u16{ 0xDEAD, 0xBEEF };
const slice = sliceAsBytes(bytes[0..]);
testing.expect(slice.len == 4);
testing.expect(eql(u8, slice, switch (builtin.endian) {
testing.expect(eql(u8, slice, switch (native_endian) {
.Big => "\xDE\xAD\xBE\xEF",
.Little => "\xAD\xDE\xEF\xBE",
}));
@ -2319,7 +2320,7 @@ test "sliceAsBytes packed struct at runtime and comptime" {
var foo: Foo = undefined;
var slice = sliceAsBytes(@as(*[1]Foo, &foo)[0..1]);
slice[0] = 0x13;
switch (builtin.endian) {
switch (native_endian) {
.Big => {
testing.expect(foo.a == 0x1);
testing.expect(foo.b == 0x3);

2
lib/std/meta.zig
View File

@ -4,7 +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.zig");
const builtin = @import("builtin");
const builtin = std.builtin;
const debug = std.debug;
const mem = std.mem;
const math = std.math;

2
lib/std/net.zig
View File

@ -4,7 +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.zig");
const builtin = @import("builtin");
const builtin = std.builtin;
const assert = std.debug.assert;
const net = @This();
const mem = std.mem;

2
lib/std/os.zig
View File

@ -21,7 +21,7 @@
const root = @import("root");
const std = @import("std.zig");
const builtin = @import("builtin");
const builtin = std.builtin;
const assert = std.debug.assert;
const math = std.math;
const mem = std.mem;

24
lib/std/os/bits/linux.zig
View File

@ -3,17 +3,17 @@
// This file is part of [zig](https://ziglang.org/), which is MIT licensed.
// The MIT license requires this copyright notice to be included in all copies
// and substantial portions of the software.
const builtin = @import("builtin");
const std = @import("../../std.zig");
const maxInt = std.math.maxInt;
const arch = std.Target.current.cpu.arch;
usingnamespace @import("../bits.zig");
pub usingnamespace switch (builtin.arch) {
pub usingnamespace switch (arch) {
.mips, .mipsel => @import("linux/errno-mips.zig"),
else => @import("linux/errno-generic.zig"),
};
pub usingnamespace switch (builtin.arch) {
pub usingnamespace switch (arch) {
.i386 => @import("linux/i386.zig"),
.x86_64 => @import("linux/x86_64.zig"),
.aarch64 => @import("linux/arm64.zig"),
@ -30,9 +30,9 @@ pub usingnamespace @import("linux/netlink.zig");
pub usingnamespace @import("linux/prctl.zig");
pub usingnamespace @import("linux/securebits.zig");
const is_mips = builtin.arch.isMIPS();
const is_ppc64 = builtin.arch.isPPC64();
const is_sparc = builtin.arch.isSPARC();
const is_mips = arch.isMIPS();
const is_ppc64 = arch.isPPC64();
const is_sparc = arch.isSPARC();
pub const pid_t = i32;
pub const fd_t = i32;
@ -134,7 +134,7 @@ pub const PROT_WRITE = 0x2;
pub const PROT_EXEC = 0x4;
/// page may be used for atomic ops
pub const PROT_SEM = switch (builtin.arch) {
pub const PROT_SEM = switch (arch) {
// TODO: also xtensa
.mips, .mipsel, .mips64, .mips64el => 0x10,
else => 0x8,
@ -1004,7 +1004,7 @@ pub const sigset_t = [1024 / 32]u32;
pub const all_mask: sigset_t = [_]u32{0xffffffff} ** sigset_t.len;
pub const app_mask: sigset_t = [2]u32{ 0xfffffffc, 0x7fffffff } ++ [_]u32{0xffffffff} ** 30;
pub const k_sigaction = switch (builtin.arch) {
pub const k_sigaction = switch (arch) {
.mips, .mipsel => extern struct {
flags: c_uint,
handler: ?fn (c_int) callconv(.C) void,
@ -1121,7 +1121,7 @@ pub const epoll_data = extern union {
// On x86_64 the structure is packed so that it matches the definition of its
// 32bit counterpart
pub const epoll_event = switch (builtin.arch) {
pub const epoll_event = switch (arch) {
.x86_64 => packed struct {
events: u32,
data: epoll_data,
@ -1288,12 +1288,12 @@ pub fn CPU_COUNT(set: cpu_set_t) cpu_count_t {
//#define CPU_ZERO(set) CPU_ZERO_S(sizeof(cpu_set_t),set)
//#define CPU_EQUAL(s1,s2) CPU_EQUAL_S(sizeof(cpu_set_t),s1,s2)
pub const MINSIGSTKSZ = switch (builtin.arch) {
pub const MINSIGSTKSZ = switch (arch) {
.i386, .x86_64, .arm, .mipsel => 2048,
.aarch64 => 5120,
else => @compileError("MINSIGSTKSZ not defined for this architecture"),
};
pub const SIGSTKSZ = switch (builtin.arch) {
pub const SIGSTKSZ = switch (arch) {
.i386, .x86_64, .arm, .mipsel => 8192,
.aarch64 => 16384,
else => @compileError("SIGSTKSZ not defined for this architecture"),
@ -2053,7 +2053,7 @@ pub const B3000000 = 0o0010015;
pub const B3500000 = 0o0010016;
pub const B4000000 = 0o0010017;
pub usingnamespace switch (builtin.arch) {
pub usingnamespace switch (arch) {
.powerpc, .powerpc64, .powerpc64le => struct {
pub const VINTR = 0;
pub const VQUIT = 1;

1
lib/std/os/darwin.zig
View File

@ -3,7 +3,6 @@
// This file is part of [zig](https://ziglang.org/), which is MIT licensed.
// The MIT license requires this copyright notice to be included in all copies
// and substantial portions of the software.
const builtin = @import("builtin");
const std = @import("../std.zig");
pub usingnamespace std.c;
pub usingnamespace @import("bits.zig");

47
lib/std/os/linux.zig
View File

@ -11,14 +11,15 @@
// provide `rename` when only the `renameat` syscall exists.
// * Does not support POSIX thread cancellation.
const std = @import("../std.zig");
const builtin = std.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_endian = native_arch.endian();
pub usingnamespace switch (builtin.arch) {
pub usingnamespace switch (native_arch) {
.i386 => @import("linux/i386.zig"),
.x86_64 => @import("linux/x86_64.zig"),
.aarch64 => @import("linux/arm64.zig"),
@ -58,7 +59,7 @@ const require_aligned_register_pair =
// Split a 64bit value into a {LSB,MSB} pair.
fn splitValue64(val: u64) [2]u32 {
switch (builtin.endian) {
switch (native_endian) {
.Little => return [2]u32{
@truncate(u32, val),
@truncate(u32, val >> 32),
@ -113,7 +114,7 @@ pub fn execve(path: [*:0]const u8, argv: [*:null]const ?[*:0]const u8, envp: [*:
}
pub fn fork() usize {
if (comptime builtin.arch.isSPARC()) {
if (comptime native_arch.isSPARC()) {
return syscall_fork();
} else if (@hasField(SYS, "fork")) {
return syscall0(.fork);
@ -431,7 +432,7 @@ pub fn faccessat(dirfd: i32, path: [*:0]const u8, mode: u32, flags: u32) usize {
}
pub fn pipe(fd: *[2]i32) usize {
if (comptime (builtin.arch.isMIPS() or builtin.arch.isSPARC())) {
if (comptime (native_arch.isMIPS() or native_arch.isSPARC())) {
return syscall_pipe(fd);
} else if (@hasField(SYS, "pipe")) {
return syscall1(.pipe, @ptrToInt(fd));
@ -912,7 +913,7 @@ pub fn sigaction(sig: u6, noalias act: ?*const Sigaction, noalias oact: ?*Sigact
const ksa_arg = if (act != null) @ptrToInt(&ksa) else 0;
const oldksa_arg = if (oact != null) @ptrToInt(&oldksa) else 0;
const result = switch (builtin.arch) {
const result = switch (native_arch) {
// The sparc version of rt_sigaction needs the restorer function to be passed as an argument too.
.sparc, .sparcv9 => syscall5(.rt_sigaction, sig, ksa_arg, oldksa_arg, @ptrToInt(ksa.restorer), mask_size),
else => syscall4(.rt_sigaction, sig, ksa_arg, oldksa_arg, mask_size),
@ -944,42 +945,42 @@ pub fn sigismember(set: *const sigset_t, sig: u6) bool {
}
pub fn getsockname(fd: i32, noalias addr: *sockaddr, noalias len: *socklen_t) usize {
if (builtin.arch == .i386) {
if (native_arch == .i386) {
return socketcall(SC_getsockname, &[3]usize{ @bitCast(usize, @as(isize, fd)), @ptrToInt(addr), @ptrToInt(len) });
}
return syscall3(.getsockname, @bitCast(usize, @as(isize, fd)), @ptrToInt(addr), @ptrToInt(len));
}
pub fn getpeername(fd: i32, noalias addr: *sockaddr, noalias len: *socklen_t) usize {
if (builtin.arch == .i386) {
if (native_arch == .i386) {
return socketcall(SC_getpeername, &[3]usize{ @bitCast(usize, @as(isize, fd)), @ptrToInt(addr), @ptrToInt(len) });
}
return syscall3(.getpeername, @bitCast(usize, @as(isize, fd)), @ptrToInt(addr), @ptrToInt(len));
}
pub fn socket(domain: u32, socket_type: u32, protocol: u32) usize {
if (builtin.arch == .i386) {
if (native_arch == .i386) {
return socketcall(SC_socket, &[3]usize{ domain, socket_type, protocol });
}
return syscall3(.socket, domain, socket_type, protocol);
}
pub fn setsockopt(fd: i32, level: u32, optname: u32, optval: [*]const u8, optlen: socklen_t) usize {
if (builtin.arch == .i386) {
if (native_arch == .i386) {
return socketcall(SC_setsockopt, &[5]usize{ @bitCast(usize, @as(isize, fd)), level, optname, @ptrToInt(optval), @intCast(usize, optlen) });
}
return syscall5(.setsockopt, @bitCast(usize, @as(isize, fd)), level, optname, @ptrToInt(optval), @intCast(usize, optlen));
}
pub fn getsockopt(fd: i32, level: u32, optname: u32, noalias optval: [*]u8, noalias optlen: *socklen_t) usize {
if (builtin.arch == .i386) {
if (native_arch == .i386) {
return socketcall(SC_getsockopt, &[5]usize{ @bitCast(usize, @as(isize, fd)), level, optname, @ptrToInt(optval), @ptrToInt(optlen) });
}
return syscall5(.getsockopt, @bitCast(usize, @as(isize, fd)), level, optname, @ptrToInt(optval), @ptrToInt(optlen));
}
pub fn sendmsg(fd: i32, msg: *const msghdr_const, flags: u32) usize {
if (builtin.arch == .i386) {
if (native_arch == .i386) {
return socketcall(SC_sendmsg, &[3]usize{ @bitCast(usize, @as(isize, fd)), @ptrToInt(msg), flags });
}
return syscall3(.sendmsg, @bitCast(usize, @as(isize, fd)), @ptrToInt(msg), flags);
@ -1026,49 +1027,49 @@ pub fn sendmmsg(fd: i32, msgvec: [*]mmsghdr_const, vlen: u32, flags: u32) usize
}
pub fn connect(fd: i32, addr: *const c_void, len: socklen_t) usize {
if (builtin.arch == .i386) {
if (native_arch == .i386) {
return socketcall(SC_connect, &[3]usize{ @bitCast(usize, @as(isize, fd)), @ptrToInt(addr), len });
}
return syscall3(.connect, @bitCast(usize, @as(isize, fd)), @ptrToInt(addr), len);
}
pub fn recvmsg(fd: i32, msg: *msghdr, flags: u32) usize {
if (builtin.arch == .i386) {
if (native_arch == .i386) {
return socketcall(SC_recvmsg, &[3]usize{ @bitCast(usize, @as(isize, fd)), @ptrToInt(msg), flags });
}
return syscall3(.recvmsg, @bitCast(usize, @as(isize, fd)), @ptrToInt(msg), flags);
}
pub fn recvfrom(fd: i32, noalias buf: [*]u8, len: usize, flags: u32, noalias addr: ?*sockaddr, noalias alen: ?*socklen_t) usize {
if (builtin.arch == .i386) {
if (native_arch == .i386) {
return socketcall(SC_recvfrom, &[6]usize{ @bitCast(usize, @as(isize, fd)), @ptrToInt(buf), len, flags, @ptrToInt(addr), @ptrToInt(alen) });
}
return syscall6(.recvfrom, @bitCast(usize, @as(isize, fd)), @ptrToInt(buf), len, flags, @ptrToInt(addr), @ptrToInt(alen));
}
pub fn shutdown(fd: i32, how: i32) usize {
if (builtin.arch == .i386) {
if (native_arch == .i386) {
return socketcall(SC_shutdown, &[2]usize{ @bitCast(usize, @as(isize, fd)), @bitCast(usize, @as(isize, how)) });
}
return syscall2(.shutdown, @bitCast(usize, @as(isize, fd)), @bitCast(usize, @as(isize, how)));
}
pub fn bind(fd: i32, addr: *const sockaddr, len: socklen_t) usize {
if (builtin.arch == .i386) {
if (native_arch == .i386) {
return socketcall(SC_bind, &[3]usize{ @bitCast(usize, @as(isize, fd)), @ptrToInt(addr), @intCast(usize, len) });
}
return syscall3(.bind, @bitCast(usize, @as(isize, fd)), @ptrToInt(addr), @intCast(usize, len));
}
pub fn listen(fd: i32, backlog: u32) usize {
if (builtin.arch == .i386) {
if (native_arch == .i386) {
return socketcall(SC_listen, &[2]usize{ @bitCast(usize, @as(isize, fd)), backlog });
}
return syscall2(.listen, @bitCast(usize, @as(isize, fd)), backlog);
}
pub fn sendto(fd: i32, buf: [*]const u8, len: usize, flags: u32, addr: ?*const sockaddr, alen: socklen_t) usize {
if (builtin.arch == .i386) {
if (native_arch == .i386) {
return socketcall(SC_sendto, &[6]usize{ @bitCast(usize, @as(isize, fd)), @ptrToInt(buf), len, flags, @ptrToInt(addr), @intCast(usize, alen) });
}
return syscall6(.sendto, @bitCast(usize, @as(isize, fd)), @ptrToInt(buf), len, flags, @ptrToInt(addr), @intCast(usize, alen));
@ -1095,21 +1096,21 @@ pub fn sendfile(outfd: i32, infd: i32, offset: ?*i64, count: usize) usize {
}
pub fn socketpair(domain: i32, socket_type: i32, protocol: i32, fd: [2]i32) usize {
if (builtin.arch == .i386) {
if (native_arch == .i386) {
return socketcall(SC_socketpair, &[4]usize{ @intCast(usize, domain), @intCast(usize, socket_type), @intCast(usize, protocol), @ptrToInt(&fd[0]) });
}
return syscall4(.socketpair, @intCast(usize, domain), @intCast(usize, socket_type), @intCast(usize, protocol), @ptrToInt(&fd[0]));
}
pub fn accept(fd: i32, noalias addr: ?*sockaddr, noalias len: ?*socklen_t) usize {
if (builtin.arch == .i386) {
if (native_arch == .i386) {
return socketcall(SC_accept, &[4]usize{ fd, addr, len, 0 });
}
return accept4(fd, addr, len, 0);
}
pub fn accept4(fd: i32, noalias addr: ?*sockaddr, noalias len: ?*socklen_t, flags: u32) usize {
if (builtin.arch == .i386) {
if (native_arch == .i386) {
return socketcall(SC_accept4, &[4]usize{ @bitCast(usize, @as(isize, fd)), @ptrToInt(addr), @ptrToInt(len), flags });
}
return syscall4(.accept4, @bitCast(usize, @as(isize, fd)), @ptrToInt(addr), @ptrToInt(len), flags);
@ -1388,7 +1389,7 @@ pub fn madvise(address: [*]u8, len: usize, advice: u32) usize {
}
test {
if (builtin.os.tag == .linux) {
if (std.Target.current.os.tag == .linux) {
_ = @import("linux/test.zig");
}
}

2
lib/std/os/linux/start_pie.zig
View File

@ -1,6 +1,6 @@
const std = @import("std");
const elf = std.elf;
const builtin = @import("builtin");
const builtin = std.builtin;
const assert = std.debug.assert;
const R_AMD64_RELATIVE = 8;

2
lib/std/os/linux/test.zig
View File

@ -4,7 +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.zig");
const builtin = @import("builtin");
const builtin = std.builtin;
const linux = std.os.linux;
const mem = std.mem;
const elf = std.elf;

16
lib/std/os/linux/tls.zig
View File

@ -4,12 +4,12 @@
// 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 = std.builtin;
const os = std.os;
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;
// This file implements the two TLS variants [1] used by ELF-based systems.
//
@ -52,14 +52,14 @@ const TLSVariant = enum {
VariantII,
};
const tls_variant = switch (builtin.arch) {
const tls_variant = switch (native_arch) {
.arm, .armeb, .aarch64, .aarch64_be, .riscv32, .riscv64, .mips, .mipsel, .powerpc, .powerpc64, .powerpc64le => TLSVariant.VariantI,
.x86_64, .i386, .sparcv9 => TLSVariant.VariantII,
else => @compileError("undefined tls_variant for this architecture"),
};
// Controls how many bytes are reserved for the Thread Control Block
const tls_tcb_size = switch (builtin.arch) {
const tls_tcb_size = switch (native_arch) {
// ARM EABI mandates enough space for two pointers: the first one points to
// the DTV while the second one is unspecified but reserved
.arm, .armeb, .aarch64, .aarch64_be => 2 * @sizeOf(usize),
@ -68,7 +68,7 @@ const tls_tcb_size = switch (builtin.arch) {
};
// Controls if the TP points to the end of the TCB instead of its beginning
const tls_tp_points_past_tcb = switch (builtin.arch) {
const tls_tp_points_past_tcb = switch (native_arch) {
.riscv32, .riscv64, .mips, .mipsel, .powerpc, .powerpc64, .powerpc64le => true,
else => false,
};
@ -76,12 +76,12 @@ const tls_tp_points_past_tcb = switch (builtin.arch) {
// Some architectures add some offset to the tp and dtv addresses in order to
// make the generated code more efficient
const tls_tp_offset = switch (builtin.arch) {
const tls_tp_offset = switch (native_arch) {
.mips, .mipsel, .powerpc, .powerpc64, .powerpc64le => 0x7000,
else => 0,
};
const tls_dtv_offset = switch (builtin.arch) {
const tls_dtv_offset = switch (native_arch) {
.mips, .mipsel, .powerpc, .powerpc64, .powerpc64le => 0x8000,
.riscv32, .riscv64 => 0x800,
else => 0,
@ -114,7 +114,7 @@ const TLSImage = struct {
pub var tls_image: TLSImage = undefined;
pub fn setThreadPointer(addr: usize) void {
switch (builtin.arch) {
switch (native_arch) {
.i386 => {
var user_desc = std.os.linux.user_desc{
.entry_number = tls_image.gdt_entry_number,
@ -228,7 +228,7 @@ fn initTLS() void {
// ARMv6 targets (and earlier) have no support for TLS in hardware
// FIXME: Elide the check for targets >= ARMv7 when the target feature API
// becomes less verbose (and more usable).
if (comptime builtin.arch.isARM()) {
if (comptime native_arch.isARM()) {
if (at_hwcap & std.os.linux.HWCAP_TLS == 0) {
// FIXME: Make __aeabi_read_tp call the kernel helper kuser_get_tls
// For the time being use a simple abort instead of a @panic call to

2
lib/std/os/test.zig
View File

@ -18,7 +18,7 @@ const Thread = std.Thread;
const a = std.testing.allocator;
const builtin = @import("builtin");
const builtin = std.builtin;
const AtomicRmwOp = builtin.AtomicRmwOp;
const AtomicOrder = builtin.AtomicOrder;
const tmpDir = std.testing.tmpDir;

2
lib/std/os/windows.zig
View File

@ -9,7 +9,7 @@
// * When null-terminated or UTF16LE byte buffers are required, provide APIs which accept
// slices as well as APIs which accept null-terminated UTF16LE byte buffers.
const builtin = @import("builtin");
const builtin = std.builtin;
const std = @import("../std.zig");
const mem = std.mem;
const assert = std.debug.assert;

6
lib/std/os/windows/bits.zig
View File

@ -5,10 +5,10 @@
// and substantial portions of the software.
// Platform-dependent types and values that are used along with OS-specific APIs.
const builtin = @import("builtin");
const std = @import("../../std.zig");
const assert = std.debug.assert;
const maxInt = std.math.maxInt;
const arch = std.Target.current.cpu.arch;
pub usingnamespace @import("win32error.zig");
pub usingnamespace @import("ntstatus.zig");
@ -24,7 +24,7 @@ pub const STD_OUTPUT_HANDLE = maxInt(DWORD) - 11 + 1;
/// The standard error device. Initially, this is the active console screen buffer, CONOUT$.
pub const STD_ERROR_HANDLE = maxInt(DWORD) - 12 + 1;
pub const WINAPI: builtin.CallingConvention = if (builtin.arch == .i386)
pub const WINAPI: std.builtin.CallingConvention = if (arch == .i386)
.Stdcall
else
.C;
@ -937,7 +937,7 @@ pub const EXCEPTION_RECORD = extern struct {
ExceptionInformation: [15]usize,
};
pub usingnamespace switch (builtin.arch) {
pub usingnamespace switch (arch) {
.i386 => struct {
pub const FLOATING_SAVE_AREA = extern struct {
ControlWord: DWORD,

2
lib/std/os/windows/user32.zig
View File

@ -5,7 +5,7 @@
// and substantial portions of the software.
usingnamespace @import("bits.zig");
const std = @import("std");
const builtin = @import("builtin");
const builtin = std.builtin;
const assert = std.debug.assert;
const windows = @import("../windows.zig");
const unexpectedError = windows.unexpectedError;

2
lib/std/packed_int_array.zig
View File

@ -4,7 +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 builtin = std.builtin;
const debug = std.debug;
const testing = std.testing;

2
lib/std/pdb.zig
View File

@ -3,7 +3,7 @@
// This file is part of [zig](https://ziglang.org/), which is MIT licensed.
// The MIT license requires this copyright notice to be included in all copies
// and substantial portions of the software.
const builtin = @import("builtin");
const builtin = std.builtin;
const std = @import("std.zig");
const io = std.io;
const math = std.math;

2
lib/std/rand.zig
View File

@ -13,7 +13,7 @@
//! TODO(tiehuis): Benchmark these against other reference implementations.
const std = @import("std.zig");
const builtin = @import("builtin");
const builtin = std.builtin;
const assert = std.debug.assert;
const expect = std.testing.expect;
const expectEqual = std.testing.expectEqual;

2
lib/std/sort.zig
View File

@ -8,7 +8,7 @@ const assert = std.debug.assert;
const testing = std.testing;
const mem = std.mem;
const math = std.math;
const builtin = @import("builtin");
const builtin = std.builtin;
pub fn binarySearch(
comptime T: type,

17
lib/std/special/c.zig
View File

@ -10,19 +10,22 @@
// such as memcpy, memset, and some math functions.
const std = @import("std");
const builtin = @import("builtin");
const builtin = std.builtin;
const maxInt = std.math.maxInt;
const isNan = std.math.isNan;
const native_arch = std.Target.current.cpu.arch;
const native_abi = std.Target.current.abi;
const native_os = std.Target.current.os.tag;
const is_wasm = switch (builtin.arch) {
const is_wasm = switch (native_arch) {
.wasm32, .wasm64 => true,
else => false,
};
const is_msvc = switch (builtin.abi) {
const is_msvc = switch (native_abi) {
.msvc => true,
else => false,
};
const is_freestanding = switch (builtin.os.tag) {
const is_freestanding = switch (native_os) {
.freestanding => true,
else => false,
};
@ -174,7 +177,7 @@ pub fn panic(msg: []const u8, error_return_trace: ?*builtin.StackTrace) noreturn
@setCold(true);
std.debug.panic("{s}", .{msg});
}
if (builtin.os.tag != .freestanding and builtin.os.tag != .other) {
if (native_os != .freestanding and native_os != .other) {
std.os.abort();
}
while (true) {}
@ -275,7 +278,7 @@ test "test_bcmp" {
}
comptime {
if (builtin.os.tag == .linux) {
if (native_os == .linux) {
@export(clone, .{ .name = "clone" });
}
}
@ -284,7 +287,7 @@ comptime {
// it causes a segfault in release mode. this is a workaround of calling it
// across .o file boundaries. fix comptime @ptrCast of nakedcc functions.
fn clone() callconv(.Naked) void {
switch (builtin.arch) {
switch (native_arch) {
.i386 => {
// __clone(func, stack, flags, arg, ptid, tls, ctid)
// +8, +12, +16, +20, +24, +28, +32

21
lib/std/special/compiler_rt.zig
View File

@ -6,15 +6,18 @@
const std = @import("std");
const builtin = std.builtin;
const is_test = builtin.is_test;
const os_tag = std.Target.current.os.tag;
const arch = std.Target.current.cpu.arch;
const abi = std.Target.current.abi;
const is_gnu = std.Target.current.abi.isGnu();
const is_mingw = builtin.os.tag == .windows and is_gnu;
const is_gnu = abi.isGnu();
const is_mingw = os_tag == .windows and is_gnu;
comptime {
const linkage = if (is_test) builtin.GlobalLinkage.Internal else builtin.GlobalLinkage.Weak;
const strong_linkage = if (is_test) builtin.GlobalLinkage.Internal else builtin.GlobalLinkage.Strong;
switch (builtin.arch) {
switch (arch) {
.i386,
.x86_64,
=> @export(@import("compiler_rt/stack_probe.zig").zig_probe_stack, .{
@ -167,11 +170,11 @@ comptime {
@export(@import("compiler_rt/clzsi2.zig").__clzsi2, .{ .name = "__clzsi2", .linkage = linkage });
if (builtin.link_libc and builtin.os.tag == .openbsd) {
if (builtin.link_libc and os_tag == .openbsd) {
@export(@import("compiler_rt/emutls.zig").__emutls_get_address, .{ .name = "__emutls_get_address", .linkage = linkage });
}
if ((builtin.arch.isARM() or builtin.arch.isThumb()) and !is_test) {
if ((arch.isARM() or arch.isThumb()) and !is_test) {
@export(@import("compiler_rt/arm.zig").__aeabi_unwind_cpp_pr0, .{ .name = "__aeabi_unwind_cpp_pr0", .linkage = linkage });
@export(@import("compiler_rt/arm.zig").__aeabi_unwind_cpp_pr1, .{ .name = "__aeabi_unwind_cpp_pr1", .linkage = linkage });
@export(@import("compiler_rt/arm.zig").__aeabi_unwind_cpp_pr2, .{ .name = "__aeabi_unwind_cpp_pr2", .linkage = linkage });
@ -202,7 +205,7 @@ comptime {
@export(@import("compiler_rt/arm.zig").__aeabi_memclr, .{ .name = "__aeabi_memclr4", .linkage = linkage });
@export(@import("compiler_rt/arm.zig").__aeabi_memclr, .{ .name = "__aeabi_memclr8", .linkage = linkage });
if (builtin.os.tag == .linux) {
if (os_tag == .linux) {
@export(@import("compiler_rt/arm.zig").__aeabi_read_tp, .{ .name = "__aeabi_read_tp", .linkage = linkage });
}
@ -269,7 +272,7 @@ comptime {
@export(@import("compiler_rt/compareXf2.zig").__aeabi_dcmpun, .{ .name = "__aeabi_dcmpun", .linkage = linkage });
}
if (builtin.arch == .i386 and builtin.abi == .msvc) {
if (arch == .i386 and abi == .msvc) {
// Don't let LLVM apply the stdcall name mangling on those MSVC builtins
@export(@import("compiler_rt/aulldiv.zig")._alldiv, .{ .name = "\x01__alldiv", .linkage = strong_linkage });
@export(@import("compiler_rt/aulldiv.zig")._aulldiv, .{ .name = "\x01__aulldiv", .linkage = strong_linkage });
@ -277,7 +280,7 @@ comptime {
@export(@import("compiler_rt/aullrem.zig")._aullrem, .{ .name = "\x01__aullrem", .linkage = strong_linkage });
}
if (builtin.arch.isSPARC()) {
if (arch.isSPARC()) {
// SPARC systems use a different naming scheme
@export(@import("compiler_rt/sparc.zig")._Qp_add, .{ .name = "_Qp_add", .linkage = linkage });
@export(@import("compiler_rt/sparc.zig")._Qp_div, .{ .name = "_Qp_div", .linkage = linkage });
@ -334,7 +337,7 @@ comptime {
@export(@import("compiler_rt/stack_probe.zig").__chkstk, .{ .name = "__chkstk", .linkage = strong_linkage });
}
switch (builtin.arch) {
switch (arch) {
.i386 => {
@export(@import("compiler_rt/divti3.zig").__divti3, .{ .name = "__divti3", .linkage = linkage });
@export(@import("compiler_rt/modti3.zig").__modti3, .{ .name = "__modti3", .linkage = linkage });

5
lib/std/special/compiler_rt/atomics.zig
View File

@ -5,6 +5,7 @@
// and substantial portions of the software.
const std = @import("std");
const builtin = std.builtin;
const arch = std.Target.current.cpu.arch;
const linkage: builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak;
@ -13,7 +14,7 @@ const linkage: builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak
// Some architectures support atomic load/stores but no CAS, but we ignore this
// detail to keep the export logic clean and because we need some kind of CAS to
// implement the spinlocks.
const supports_atomic_ops = switch (builtin.arch) {
const supports_atomic_ops = switch (arch) {
.msp430, .avr => false,
.arm, .armeb, .thumb, .thumbeb =>
// The ARM v6m ISA has no ldrex/strex and so it's impossible to do CAS
@ -27,7 +28,7 @@ const supports_atomic_ops = switch (builtin.arch) {
// The size (in bytes) of the biggest object that the architecture can
// load/store atomically.
// Objects bigger than this threshold require the use of a lock.
const largest_atomic_size = switch (builtin.arch) {
const largest_atomic_size = switch (arch) {
// XXX: On x86/x86_64 we could check the presence of cmpxchg8b/cmpxchg16b
// and set this parameter accordingly.
else => @sizeOf(usize),

10
lib/std/special/compiler_rt/muldi3.zig
View File

@ -3,14 +3,16 @@
// This file is part of [zig](https://ziglang.org/), which is MIT licensed.
// The MIT license requires this copyright notice to be included in all copies
// and substantial portions of the software.
const builtin = @import("builtin");
const std = @import("std");
const is_test = std.builtin.is_test;
const native_endian = std.Target.current.cpu.arch.endian();
// Ported from
// https://github.com/llvm/llvm-project/blob/llvmorg-9.0.0/compiler-rt/lib/builtins/muldi3.c
const dwords = extern union {
all: i64,
s: switch (builtin.endian) {
s: switch (native_endian) {
.Little => extern struct {
low: u32,
high: u32,
@ -23,7 +25,7 @@ const dwords = extern union {
};
fn __muldsi3(a: u32, b: u32) i64 {
@setRuntimeSafety(builtin.is_test);
@setRuntimeSafety(is_test);
const bits_in_word_2 = @sizeOf(i32) * 8 / 2;
const lower_mask = (~@as(u32, 0)) >> bits_in_word_2;
@ -45,7 +47,7 @@ fn __muldsi3(a: u32, b: u32) i64 {
}
pub fn __muldi3(a: i64, b: i64) callconv(.C) i64 {
@setRuntimeSafety(builtin.is_test);
@setRuntimeSafety(is_test);
const x = dwords{ .all = a };
const y = dwords{ .all = b };

8
lib/std/special/compiler_rt/multi3.zig
View File

@ -3,15 +3,17 @@
// This file is part of [zig](https://ziglang.org/), which is MIT licensed.
// The MIT license requires this copyright notice to be included in all copies
// and substantial portions of the software.
const builtin = @import("builtin");
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();
// Ported from git@github.com:llvm-project/llvm-project-20170507.git
// ae684fad6d34858c014c94da69c15e7774a633c3
// 2018-08-13
pub fn __multi3(a: i128, b: i128) callconv(.C) i128 {
@setRuntimeSafety(builtin.is_test);
@setRuntimeSafety(is_test);
const x = twords{ .all = a };
const y = twords{ .all = b };
var r = twords{ .all = __mulddi3(x.s.low, y.s.low) };
@ -50,7 +52,7 @@ const twords = extern union {
all: i128,
s: S,
const S = if (builtin.endian == .Little)
const S = if (native_endian == .Little)
struct {
low: u64,
high: u64,

4
lib/std/special/compiler_rt/shift.zig
View File

@ -4,8 +4,8 @@
// 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 = std.builtin;
const Log2Int = std.math.Log2Int;
const native_endian = std.Target.current.cpu.arch.endian();
fn Dwords(comptime T: type, comptime signed_half: bool) type {
return extern union {
@ -15,7 +15,7 @@ fn Dwords(comptime T: type, comptime signed_half: bool) type {
pub const HalfT = if (signed_half) HalfTS else HalfTU;
all: T,
s: if (builtin.endian == .Little)
s: if (native_endian == .Little)
struct { low: HalfT, high: HalfT }
else
struct { high: HalfT, low: HalfT },

10
lib/std/special/compiler_rt/stack_probe.zig
View File

@ -3,7 +3,7 @@
// This file is part of [zig](https://ziglang.org/), which is MIT licensed.
// The MIT license requires this copyright notice to be included in all copies
// and substantial portions of the software.
const builtin = @import("builtin");
const native_arch = @import("std").Target.current.cpu.arch;
// Zig's own stack-probe routine (available only on x86 and x86_64)
pub fn zig_probe_stack() callconv(.Naked) void {
@ -13,7 +13,7 @@ pub fn zig_probe_stack() callconv(.Naked) void {
// invalid so let's update it on the go, otherwise we'll get a segfault
// instead of triggering the stack growth.
switch (builtin.arch) {
switch (native_arch) {
.x86_64 => {
// %rax = probe length, %rsp = stack pointer
asm volatile (
@ -65,7 +65,7 @@ pub fn zig_probe_stack() callconv(.Naked) void {
fn win_probe_stack_only() void {
@setRuntimeSafety(false);
switch (builtin.arch) {
switch (native_arch) {
.x86_64 => {
asm volatile (
\\ push %%rcx
@ -117,7 +117,7 @@ fn win_probe_stack_only() void {
fn win_probe_stack_adjust_sp() void {
@setRuntimeSafety(false);
switch (builtin.arch) {
switch (native_arch) {
.x86_64 => {
asm volatile (
\\ push %%rcx
@ -191,7 +191,7 @@ pub fn _chkstk() callconv(.Naked) void {
}
pub fn __chkstk() callconv(.Naked) void {
@setRuntimeSafety(false);
switch (builtin.arch) {
switch (native_arch) {
.i386 => @call(.{ .modifier = .always_inline }, win_probe_stack_adjust_sp, .{}),
.x86_64 => @call(.{ .modifier = .always_inline }, win_probe_stack_only, .{}),
else => unreachable,

3
lib/std/special/compiler_rt/udivmod.zig
View File

@ -5,8 +5,9 @@
// and substantial portions of the software.
const builtin = @import("builtin");
const is_test = builtin.is_test;
const native_endian = @import("std").Target.current.cpu.arch.endian();
const low = switch (builtin.endian) {
const low = switch (native_endian) {
.Big => 1,
.Little => 0,
};

26
lib/std/start.zig
View File

@ -11,10 +11,12 @@ const builtin = @import("builtin");
const assert = std.debug.assert;
const uefi = std.os.uefi;
const tlcsprng = @import("crypto/tlcsprng.zig");
const native_arch = std.Target.current.cpu.arch;
const native_os = std.Target.current.os.tag;
var argc_argv_ptr: [*]usize = undefined;
const start_sym_name = if (builtin.arch.isMIPS()) "__start" else "_start";
const start_sym_name = if (native_arch.isMIPS()) "__start" else "_start";
comptime {
// The self-hosted compiler is not fully capable of handling all of this start.zig file.
@ -23,9 +25,7 @@ comptime {
if (builtin.zig_is_stage2) {
if (builtin.output_mode == .Exe) {
if (builtin.link_libc or builtin.object_format == .c) {
if (!@hasDecl(root, "main")) {
@export(main2, "main");
}
@export(main2, "main");
} else {
if (!@hasDecl(root, "_start")) {
@export(_start2, "_start");
@ -34,7 +34,7 @@ comptime {
}
} else {
if (builtin.output_mode == .Lib and builtin.link_mode == .Dynamic) {
if (builtin.os.tag == .windows and !@hasDecl(root, "_DllMainCRTStartup")) {
if (native_os == .windows and !@hasDecl(root, "_DllMainCRTStartup")) {
@export(_DllMainCRTStartup, .{ .name = "_DllMainCRTStartup" });
}
} else if (builtin.output_mode == .Exe or @hasDecl(root, "main")) {
@ -42,7 +42,7 @@ comptime {
if (@typeInfo(@TypeOf(root.main)).Fn.calling_convention != .C) {
@export(main, .{ .name = "main", .linkage = .Weak });
}
} else if (builtin.os.tag == .windows) {
} else if (native_os == .windows) {
if (!@hasDecl(root, "WinMain") and !@hasDecl(root, "WinMainCRTStartup") and
!@hasDecl(root, "wWinMain") and !@hasDecl(root, "wWinMainCRTStartup"))
{
@ -56,11 +56,11 @@ comptime {
{
@export(wWinMainCRTStartup, .{ .name = "wWinMainCRTStartup" });
}
} else if (builtin.os.tag == .uefi) {
} else if (native_os == .uefi) {
if (!@hasDecl(root, "EfiMain")) @export(EfiMain, .{ .name = "EfiMain" });
} else if (builtin.arch.isWasm() and builtin.os.tag == .freestanding) {
} else if (native_arch.isWasm() and native_os == .freestanding) {
if (!@hasDecl(root, start_sym_name)) @export(wasm_freestanding_start, .{ .name = start_sym_name });
} else if (builtin.os.tag != .other and builtin.os.tag != .freestanding) {
} else if (native_os != .other and native_os != .freestanding) {
if (!@hasDecl(root, start_sym_name)) @export(_start, .{ .name = start_sym_name });
}
}
@ -80,7 +80,7 @@ fn _start2() callconv(.Naked) noreturn {
}
fn exit2(code: u8) noreturn {
switch (builtin.arch) {
switch (native_arch) {
.x86_64 => {
asm volatile ("syscall"
:
@ -157,13 +157,13 @@ fn EfiMain(handle: uefi.Handle, system_table: *uefi.tables.SystemTable) callconv
}
fn _start() callconv(.Naked) noreturn {
if (builtin.os.tag == .wasi) {
if (native_os == .wasi) {
// This is marked inline because for some reason LLVM in release mode fails to inline it,
// and we want fewer call frames in stack traces.
std.os.wasi.proc_exit(@call(.{ .modifier = .always_inline }, callMain, .{}));
}
switch (builtin.arch) {
switch (native_arch) {
.x86_64 => {
argc_argv_ptr = asm volatile (
\\ xor %%rbp, %%rbp
@ -273,7 +273,7 @@ fn posixCallMainAndExit() noreturn {
while (envp_optional[envp_count]) |_| : (envp_count += 1) {}
const envp = @ptrCast([*][*:0]u8, envp_optional)[0..envp_count];
if (builtin.os.tag == .linux) {
if (native_os == .linux) {
// Find the beginning of the auxiliary vector
const auxv = @ptrCast([*]std.elf.Auxv, @alignCast(@alignOf(usize), envp.ptr + envp_count + 1));
std.os.linux.elf_aux_maybe = auxv;

6
lib/std/target.zig
View File

@ -1225,11 +1225,7 @@ pub const Target = struct {
}
};
pub const current = Target{
.cpu = builtin.cpu,
.os = builtin.os,
.abi = builtin.abi,
};
pub const current = builtin.target;
pub const stack_align = 16;

2
lib/std/testing.zig
View File

@ -309,7 +309,7 @@ pub const TmpDir = struct {
};
fn getCwdOrWasiPreopen() std.fs.Dir {
if (@import("builtin").os.tag == .wasi) {
if (std.builtin.os.tag == .wasi) {
var preopens = std.fs.wasi.PreopenList.init(allocator);
defer preopens.deinit();
preopens.populate() catch

2
lib/std/unicode.zig
View File

@ -4,7 +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.zig");
const builtin = @import("builtin");
const builtin = std.builtin;
const assert = std.debug.assert;
const testing = std.testing;
const mem = std.mem;

2
lib/std/valgrind.zig
View File

@ -3,7 +3,7 @@
// This file is part of [zig](https://ziglang.org/), which is MIT licensed.
// The MIT license requires this copyright notice to be included in all copies
// and substantial portions of the software.
const builtin = @import("builtin");
const builtin = std.builtin;
const std = @import("std.zig");
const math = std.math;

3
lib/std/zig/system.zig
View File

@ -14,6 +14,7 @@ const process = std.process;
const Target = std.Target;
const CrossTarget = std.zig.CrossTarget;
const macos = @import("system/macos.zig");
const native_endian = std.Target.current.cpu.arch.endian();
pub const windows = @import("system/windows.zig");
pub const getSDKPath = macos.getSDKPath;
@ -603,7 +604,7 @@ pub const NativeTargetInfo = struct {
elf.ELFDATA2MSB => .Big,
else => return error.InvalidElfEndian,
};
const need_bswap = elf_endian != std.builtin.endian;
const need_bswap = elf_endian != native_endian;
if (hdr32.e_ident[elf.EI_VERSION] != 1) return error.InvalidElfVersion;
const is_64 = switch (hdr32.e_ident[elf.EI_CLASS]) {