Commit 429cd2b5dd

Andrew Kelley <andrew@ziglang.org>
2021-04-13 01:43:50
std: change `@import("builtin")` to `std.builtin`
master
1 parent a4bb7c8
Changed files (86)
lib
std
atomic
queue.zig
stack.zig
c
linux.zig
event
channel.zig
future.zig
group.zig
lock.zig
loop.zig
rwlock.zig
wait_group.zig
fs
file.zig
get_app_data_dir.zig
path.zig
wasi.zig
watch.zig
hash
auto_hash.zig
benchmark.zig
cityhash.zig
murmur.zig
math
complex
atan.zig
cosh.zig
exp.zig
sinh.zig
tanh.zig
acosh.zig
ceil.zig
cos.zig
cosh.zig
expm1.zig
floor.zig
log1p.zig
pow.zig
powi.zig
round.zig
sin.zig
sinh.zig
sqrt.zig
tan.zig
tanh.zig
os
bits
linux.zig
linux
start_pie.zig
test.zig
tls.zig
windows
bits.zig
user32.zig
darwin.zig
linux.zig
test.zig
windows.zig
special
compiler_rt
atomics.zig
muldi3.zig
multi3.zig
shift.zig
stack_probe.zig
udivmod.zig
c.zig
compiler_rt.zig
Thread
AutoResetEvent.zig
zig
system.zig
array_hash_map.zig
build.zig
builtin.zig
child_process.zig
coff.zig
cstr.zig
debug.zig
dwarf.zig
dynamic_library.zig
fmt.zig
fs.zig
hash_map.zig
heap.zig
io.zig
mem.zig
meta.zig
net.zig
os.zig
packed_int_array.zig
pdb.zig
rand.zig
sort.zig
start.zig
target.zig
testing.zig
unicode.zig
valgrind.zig
lib/std/atomic/queue.zig
@@ -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;
lib/std/atomic/stack.zig
@@ -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
lib/std/c/linux.zig
@@ -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,
     },
lib/std/event/channel.zig
@@ -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;
lib/std/event/future.zig
@@ -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
lib/std/event/group.zig
@@ -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;
lib/std/event/lock.zig
@@ -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;
lib/std/event/loop.zig
@@ -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;
lib/std/event/rwlock.zig
@@ -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;
lib/std/event/wait_group.zig
@@ -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.
lib/std/fs/file.zig
@@ -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;
lib/std/fs/get_app_data_dir.zig
@@ -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;
lib/std/fs/path.zig
@@ -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;
lib/std/fs/wasi.zig
@@ -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();
lib/std/fs/watch.zig
@@ -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;
lib/std/hash/auto_hash.zig
@@ -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 };
lib/std/hash/benchmark.zig
@@ -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;
lib/std/hash/cityhash.zig
@@ -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.
lib/std/hash/murmur.zig
@@ -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;
lib/std/math/complex/atan.zig
@@ -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;
lib/std/math/complex/cosh.zig
@@ -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;
lib/std/math/complex/exp.zig
@@ -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;
lib/std/math/complex/sinh.zig
@@ -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;
lib/std/math/complex/tanh.zig
@@ -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;
lib/std/math/acosh.zig
@@ -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;
lib/std/math/ceil.zig
@@ -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;
lib/std/math/cos.zig
@@ -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;
lib/std/math/cosh.zig
@@ -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;
lib/std/math/expm1.zig
@@ -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;
lib/std/math/floor.zig
@@ -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;
lib/std/math/log1p.zig
@@ -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;
lib/std/math/pow.zig
@@ -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;
lib/std/math/powi.zig
@@ -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;
lib/std/math/round.zig
@@ -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;
lib/std/math/sin.zig
@@ -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;
lib/std/math/sinh.zig
@@ -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;
lib/std/math/sqrt.zig
@@ -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.
lib/std/math/tan.zig
@@ -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;
lib/std/math/tanh.zig
@@ -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;
lib/std/os/bits/linux.zig
@@ -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;
lib/std/os/linux/start_pie.zig
@@ -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;
lib/std/os/linux/test.zig
@@ -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;
lib/std/os/linux/tls.zig
@@ -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
lib/std/os/windows/bits.zig
@@ -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,
lib/std/os/windows/user32.zig
@@ -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;
lib/std/os/darwin.zig
@@ -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");
lib/std/os/linux.zig
@@ -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");
     }
 }
lib/std/os/test.zig
@@ -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;
lib/std/os/windows.zig
@@ -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;
lib/std/special/compiler_rt/atomics.zig
@@ -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),
lib/std/special/compiler_rt/muldi3.zig
@@ -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 };
lib/std/special/compiler_rt/multi3.zig
@@ -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,
lib/std/special/compiler_rt/shift.zig
@@ -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 },
lib/std/special/compiler_rt/stack_probe.zig
@@ -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,
lib/std/special/compiler_rt/udivmod.zig
@@ -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,
 };
lib/std/special/c.zig
@@ -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
lib/std/special/compiler_rt.zig
@@ -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 });
lib/std/Thread/AutoResetEvent.zig
@@ -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;
lib/std/zig/system.zig
@@ -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]) {
lib/std/array_hash_map.zig
@@ -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 {
lib/std/build.zig
@@ -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},
lib/std/builtin.zig
@@ -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");
-
-/// 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;
+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;
 
 /// `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,
lib/std/child_process.zig
@@ -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;
lib/std/coff.zig
@@ -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;
lib/std/cstr.zig
@@ -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;
lib/std/debug.zig
@@ -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),
lib/std/dwarf.zig
@@ -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;
lib/std/dynamic_library.zig
@@ -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;
lib/std/fmt.zig
@@ -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;
lib/std/fs.zig
@@ -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;
lib/std/hash_map.zig
@@ -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;
lib/std/heap.zig
@@ -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;
lib/std/io.zig
@@ -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;
lib/std/mem.zig
@@ -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);
lib/std/meta.zig
@@ -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;
lib/std/net.zig
@@ -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;
lib/std/os.zig
@@ -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;
lib/std/packed_int_array.zig
@@ -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;
lib/std/pdb.zig
@@ -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;
lib/std/rand.zig
@@ -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;
lib/std/sort.zig
@@ -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,
lib/std/start.zig
@@ -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;
lib/std/target.zig
@@ -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;
lib/std/testing.zig
@@ -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
lib/std/unicode.zig
@@ -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;
lib/std/valgrind.zig
@@ -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;