Commit 6115cf2240
Changed files (147)
lib
std
crypto
meta
net
os
rand
special
unicode
x
zig
src
test
behavior
doc/docgen.zig
@@ -1334,7 +1334,7 @@ fn genHtml(
if (mem.startsWith(u8, triple, "wasm32") or
mem.startsWith(u8, triple, "riscv64-linux") or
(mem.startsWith(u8, triple, "x86_64-linux") and
- std.Target.current.os.tag != .linux or std.Target.current.cpu.arch != .x86_64))
+ builtin.os.tag != .linux or builtin.cpu.arch != .x86_64))
{
// skip execution
break :code_block;
@@ -1602,7 +1602,7 @@ fn genHtml(
Code.Id.Lib => {
const bin_basename = try std.zig.binNameAlloc(allocator, .{
.root_name = code.name,
- .target = std.Target.current,
+ .target = builtin.target,
.output_mode = .Lib,
});
doc/langref.html.in
@@ -2681,6 +2681,7 @@ test "pointer child type" {
</p>
{#code_begin|test|variable_alignment#}
const std = @import("std");
+const builtin = @import("builtin");
const expect = std.testing.expect;
test "variable alignment" {
@@ -2688,7 +2689,7 @@ test "variable alignment" {
const align_of_i32 = @alignOf(@TypeOf(x));
try expect(@TypeOf(&x) == *i32);
try expect(*i32 == *align(align_of_i32) i32);
- if (std.Target.current.cpu.arch == .x86_64) {
+ if (builtin.target.cpu.arch == .x86_64) {
try expect(@typeInfo(*i32).Pointer.alignment == 4);
}
}
@@ -3878,6 +3879,7 @@ test "separate scopes" {
{#header_open|switch#}
{#code_begin|test|switch#}
const std = @import("std");
+const builtin = @import("builtin");
const expect = std.testing.expect;
test "switch simple" {
@@ -3922,7 +3924,7 @@ test "switch simple" {
}
// Switch expressions can be used outside a function:
-const os_msg = switch (std.Target.current.os.tag) {
+const os_msg = switch (builtin.target.os.tag) {
.linux => "we found a linux user",
else => "not a linux user",
};
@@ -3930,7 +3932,7 @@ const os_msg = switch (std.Target.current.os.tag) {
// Inside a function, switch statements implicitly are compile-time
// evaluated if the target expression is compile-time known.
test "switch inside function" {
- switch (std.Target.current.os.tag) {
+ switch (builtin.target.os.tag) {
.fuchsia => {
// On an OS other than fuchsia, block is not even analyzed,
// so this compile error is not triggered.
@@ -5690,6 +5692,7 @@ test "cast *[1][*]const u8 to [*]const ?[*]const u8" {
</p>
{#code_begin|test|test_integer_widening#}
const std = @import("std");
+const builtin = @import("builtin");
const expect = std.testing.expect;
const mem = std.mem;
@@ -5712,7 +5715,7 @@ test "implicit unsigned integer to signed integer" {
test "float widening" {
// Note: there is an open issue preventing this from working on aarch64:
// https://github.com/ziglang/zig/issues/3282
- if (std.Target.current.cpu.arch == .aarch64) return error.SkipZigTest;
+ if (builtin.target.cpu.arch == .aarch64) return error.SkipZigTest;
var a: f16 = 12.34;
var b: f32 = a;
lib/std/atomic/Atomic.zig
@@ -1,7 +1,7 @@
const std = @import("../std.zig");
const testing = std.testing;
-const target = std.Target.current;
+const target = @import("builtin").target;
const Ordering = std.atomic.Ordering;
pub fn Atomic(comptime T: type) type {
lib/std/atomic/queue.zig
@@ -1,5 +1,5 @@
const std = @import("../std.zig");
-const builtin = std.builtin;
+const builtin = @import("builtin");
const assert = std.debug.assert;
const expect = std.testing.expect;
lib/std/atomic/stack.zig
@@ -1,5 +1,6 @@
+const std = @import("../std.zig");
+const builtin = @import("builtin");
const assert = std.debug.assert;
-const builtin = std.builtin;
const expect = std.testing.expect;
/// Many reader, many writer, non-allocating, thread-safe
@@ -67,7 +68,6 @@ pub fn Stack(comptime T: type) type {
};
}
-const std = @import("../std.zig");
const Context = struct {
allocator: *std.mem.Allocator,
stack: *Stack(i32),
lib/std/build/OptionsStep.zig
@@ -1,4 +1,5 @@
const std = @import("../std.zig");
+const builtin = @import("builtin");
const build = std.build;
const fs = std.fs;
const Step = build.Step;
@@ -219,7 +220,7 @@ const OptionFileSourceArg = struct {
};
test "OptionsStep" {
- if (std.builtin.os.tag == .wasi) return error.SkipZigTest;
+ if (builtin.os.tag == .wasi) return error.SkipZigTest;
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
lib/std/build/RunStep.zig
@@ -1,5 +1,5 @@
const std = @import("../std.zig");
-const builtin = std.builtin;
+const builtin = @import("builtin");
const build = std.build;
const Step = build.Step;
const Builder = build.Builder;
lib/std/c/darwin.zig
@@ -1,6 +1,6 @@
const std = @import("../std.zig");
-const assert = std.debug.assert;
const builtin = @import("builtin");
+const assert = std.debug.assert;
const macho = std.macho;
const native_arch = builtin.target.cpu.arch;
const maxInt = std.math.maxInt;
@@ -72,7 +72,7 @@ const mach_hdr = if (@sizeOf(usize) == 8) mach_header_64 else mach_header;
var dummy_execute_header: mach_hdr = undefined;
pub extern var _mh_execute_header: mach_hdr;
comptime {
- if (std.Target.current.isDarwin()) {
+ if (builtin.target.isDarwin()) {
@export(dummy_execute_header, .{ .name = "_mh_execute_header", .linkage = .Weak });
}
}
lib/std/crypto/aes/aesni.zig
@@ -1,4 +1,5 @@
const std = @import("../../std.zig");
+const builtin = @import("builtin");
const mem = std.mem;
const debug = std.debug;
const Vector = std.meta.Vector;
@@ -97,7 +98,7 @@ pub const Block = struct {
const cpu = std.Target.x86.cpu;
/// The recommended number of AES encryption/decryption to perform in parallel for the chosen implementation.
- pub const optimal_parallel_blocks = switch (std.Target.current.cpu.model) {
+ pub const optimal_parallel_blocks = switch (builtin.cpu.model) {
&cpu.westmere => 6,
&cpu.sandybridge, &cpu.ivybridge => 8,
&cpu.haswell, &cpu.broadwell => 7,
lib/std/crypto/pcurves/p256/p256_64.zig
@@ -18,7 +18,7 @@
// if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256
const std = @import("std");
-const mode = std.builtin.mode; // Checked arithmetic is disabled in non-debug modes to avoid side channels
+const mode = @import("builtin").mode; // Checked arithmetic is disabled in non-debug modes to avoid side channels
// The type MontgomeryDomainFieldElement is a field element in the Montgomery domain.
// Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
lib/std/crypto/pcurves/p256/p256_scalar_64.zig
@@ -18,7 +18,7 @@
// if x1 & (2^256-1) < 2^255 then x1 & (2^256-1) else (x1 & (2^256-1)) - 2^256
const std = @import("std");
-const mode = std.builtin.mode; // Checked arithmetic is disabled in non-debug modes to avoid side channels
+const mode = @import("builtin").mode; // Checked arithmetic is disabled in non-debug modes to avoid side channels
// The type MontgomeryDomainFieldElement is a field element in the Montgomery domain.
// Bounds: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
lib/std/crypto/pcurves/p256/scalar.zig
@@ -1,5 +1,4 @@
const std = @import("std");
-const builtin = std.builtin;
const common = @import("../common.zig");
const crypto = std.crypto;
const debug = std.debug;
@@ -26,47 +25,47 @@ const Fe = Field(.{
});
/// Reject a scalar whose encoding is not canonical.
-pub fn rejectNonCanonical(s: CompressedScalar, endian: builtin.Endian) NonCanonicalError!void {
+pub fn rejectNonCanonical(s: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!void {
return Fe.rejectNonCanonical(s, endian);
}
/// Reduce a 48-bytes scalar to the field size.
-pub fn reduce48(s: [48]u8, endian: builtin.Endian) CompressedScalar {
+pub fn reduce48(s: [48]u8, endian: std.builtin.Endian) CompressedScalar {
return Scalar.fromBytes48(s, endian).toBytes(endian);
}
/// Reduce a 64-bytes scalar to the field size.
-pub fn reduce64(s: [64]u8, endian: builtin.Endian) CompressedScalar {
+pub fn reduce64(s: [64]u8, endian: std.builtin.Endian) CompressedScalar {
return ScalarDouble.fromBytes64(s, endian).toBytes(endian);
}
/// Return a*b (mod L)
-pub fn mul(a: CompressedScalar, b: CompressedScalar, endian: builtin.Endian) NonCanonicalError!CompressedScalar {
+pub fn mul(a: CompressedScalar, b: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!CompressedScalar {
return (try Scalar.fromBytes(a, endian)).mul(try Scalar.fromBytes(b, endian)).toBytes(endian);
}
/// Return a*b+c (mod L)
-pub fn mulAdd(a: CompressedScalar, b: CompressedScalar, c: CompressedScalar, endian: builtin.Endian) NonCanonicalError!CompressedScalar {
+pub fn mulAdd(a: CompressedScalar, b: CompressedScalar, c: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!CompressedScalar {
return (try Scalar.fromBytes(a, endian)).mul(try Scalar.fromBytes(b, endian)).add(try Scalar.fromBytes(c, endian)).toBytes(endian);
}
/// Return a+b (mod L)
-pub fn add(a: CompressedScalar, b: CompressedScalar, endian: builtin.Endian) NonCanonicalError!CompressedScalar {
+pub fn add(a: CompressedScalar, b: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!CompressedScalar {
return (try Scalar.fromBytes(a, endian)).add(try Scalar.fromBytes(b, endian)).toBytes(endian);
}
/// Return -s (mod L)
-pub fn neg(s: CompressedScalar, endian: builtin.Endian) NonCanonicalError!CompressedScalar {
+pub fn neg(s: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!CompressedScalar {
return (try Scalar.fromBytes(s, endian)).neg().toBytes(endian);
}
/// Return (a-b) (mod L)
-pub fn sub(a: CompressedScalar, b: CompressedScalar, endian: builtin.Endian) NonCanonicalError!CompressedScalar {
+pub fn sub(a: CompressedScalar, b: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!CompressedScalar {
return (try Scalar.fromBytes(a, endian)).sub(try Scalar.fromBytes(b.endian)).toBytes(endian);
}
/// Return a random scalar
-pub fn random(endian: builtin.Endian) CompressedScalar {
+pub fn random(endian: std.builtin.Endian) CompressedScalar {
return Scalar.random().toBytes(endian);
}
@@ -81,24 +80,24 @@ pub const Scalar = struct {
pub const one = Scalar{ .fe = Fe.one };
/// Unpack a serialized representation of a scalar.
- pub fn fromBytes(s: CompressedScalar, endian: builtin.Endian) NonCanonicalError!Scalar {
+ pub fn fromBytes(s: CompressedScalar, endian: std.builtin.Endian) NonCanonicalError!Scalar {
return Scalar{ .fe = try Fe.fromBytes(s, endian) };
}
/// Reduce a 384 bit input to the field size.
- pub fn fromBytes48(s: [48]u8, endian: builtin.Endian) Scalar {
+ pub fn fromBytes48(s: [48]u8, endian: std.builtin.Endian) Scalar {
const t = ScalarDouble.fromBytes(384, s, endian);
return t.reduce(384);
}
/// Reduce a 512 bit input to the field size.
- pub fn fromBytes64(s: [64]u8, endian: builtin.Endian) Scalar {
+ pub fn fromBytes64(s: [64]u8, endian: std.builtin.Endian) Scalar {
const t = ScalarDouble.fromBytes(512, s, endian);
return t.reduce(512);
}
/// Pack a scalar into bytes.
- pub fn toBytes(n: Scalar, endian: builtin.Endian) CompressedScalar {
+ pub fn toBytes(n: Scalar, endian: std.builtin.Endian) CompressedScalar {
return n.fe.toBytes(endian);
}
@@ -180,7 +179,7 @@ const ScalarDouble = struct {
x2: Fe,
x3: Fe,
- fn fromBytes(comptime bits: usize, s_: [bits / 8]u8, endian: builtin.Endian) ScalarDouble {
+ fn fromBytes(comptime bits: usize, s_: [bits / 8]u8, endian: std.builtin.Endian) ScalarDouble {
debug.assert(bits > 0 and bits <= 512 and bits >= Fe.saturated_bits and bits <= Fe.saturated_bits * 3);
var s = s_;
lib/std/crypto/pcurves/common.zig
@@ -1,5 +1,4 @@
const std = @import("std");
-const builtin = std.builtin;
const crypto = std.crypto;
const debug = std.debug;
const mem = std.mem;
@@ -51,7 +50,7 @@ pub fn Field(comptime params: FieldParams) type {
};
/// Reject non-canonical encodings of an element.
- pub fn rejectNonCanonical(s_: [encoded_length]u8, endian: builtin.Endian) NonCanonicalError!void {
+ pub fn rejectNonCanonical(s_: [encoded_length]u8, endian: std.builtin.Endian) NonCanonicalError!void {
var s = if (endian == .Little) s_ else orderSwap(s_);
const field_order_s = comptime fos: {
var fos: [encoded_length]u8 = undefined;
@@ -71,7 +70,7 @@ pub fn Field(comptime params: FieldParams) type {
}
/// Unpack a field element.
- pub fn fromBytes(s_: [encoded_length]u8, endian: builtin.Endian) NonCanonicalError!Fe {
+ pub fn fromBytes(s_: [encoded_length]u8, endian: std.builtin.Endian) NonCanonicalError!Fe {
var s = if (endian == .Little) s_ else orderSwap(s_);
try rejectNonCanonical(s, .Little);
var limbs_z: NonMontgomeryDomainFieldElement = undefined;
@@ -82,7 +81,7 @@ pub fn Field(comptime params: FieldParams) type {
}
/// Pack a field element.
- pub fn toBytes(fe: Fe, endian: builtin.Endian) [encoded_length]u8 {
+ pub fn toBytes(fe: Fe, endian: std.builtin.Endian) [encoded_length]u8 {
var limbs_z: NonMontgomeryDomainFieldElement = undefined;
fiat.fromMontgomery(&limbs_z, fe.limbs);
var s: [encoded_length]u8 = undefined;
lib/std/crypto/pcurves/p256.zig
@@ -1,5 +1,4 @@
const std = @import("std");
-const builtin = std.builtin;
const crypto = std.crypto;
const mem = std.mem;
const meta = std.meta;
@@ -59,7 +58,7 @@ pub const P256 = struct {
}
/// Create a point from serialized affine coordinates.
- pub fn fromSerializedAffineCoordinates(xs: [32]u8, ys: [32]u8, endian: builtin.Endian) (NonCanonicalError || EncodingError)!P256 {
+ pub fn fromSerializedAffineCoordinates(xs: [32]u8, ys: [32]u8, endian: std.builtin.Endian) (NonCanonicalError || EncodingError)!P256 {
const x = try Fe.fromBytes(xs, endian);
const y = try Fe.fromBytes(ys, endian);
return fromAffineCoordinates(.{ .x = x, .y = y });
@@ -396,7 +395,7 @@ pub const P256 = struct {
/// Multiply an elliptic curve point by a scalar.
/// Return error.IdentityElement if the result is the identity element.
- pub fn mul(p: P256, s_: [32]u8, endian: builtin.Endian) IdentityElementError!P256 {
+ pub fn mul(p: P256, s_: [32]u8, endian: std.builtin.Endian) IdentityElementError!P256 {
const s = if (endian == .Little) s_ else Fe.orderSwap(s_);
if (p.is_base) {
return pcMul16(&basePointPc, s, false);
@@ -408,7 +407,7 @@ pub const P256 = struct {
/// Multiply an elliptic curve point by a *PUBLIC* scalar *IN VARIABLE TIME*
/// This can be used for signature verification.
- pub fn mulPublic(p: P256, s_: [32]u8, endian: builtin.Endian) IdentityElementError!P256 {
+ pub fn mulPublic(p: P256, s_: [32]u8, endian: std.builtin.Endian) IdentityElementError!P256 {
const s = if (endian == .Little) s_ else Fe.orderSwap(s_);
if (p.is_base) {
return pcMul16(&basePointPc, s, true);
@@ -420,7 +419,7 @@ pub const P256 = struct {
/// Double-base multiplication of public parameters - Compute (p1*s1)+(p2*s2) *IN VARIABLE TIME*
/// This can be used for signature verification.
- pub fn mulDoubleBasePublic(p1: P256, s1_: [32]u8, p2: P256, s2_: [32]u8, endian: builtin.Endian) IdentityElementError!P256 {
+ pub fn mulDoubleBasePublic(p1: P256, s1_: [32]u8, p2: P256, s2_: [32]u8, endian: std.builtin.Endian) IdentityElementError!P256 {
const s1 = if (endian == .Little) s1_ else Fe.orderSwap(s1_);
const s2 = if (endian == .Little) s2_ else Fe.orderSwap(s2_);
try p1.rejectIdentity();
lib/std/crypto/aes.zig
@@ -1,13 +1,13 @@
const std = @import("../std.zig");
+const builtin = @import("builtin");
const testing = std.testing;
-const builtin = std.builtin;
-const has_aesni = std.Target.x86.featureSetHas(std.Target.current.cpu.features, .aes);
-const has_avx = std.Target.x86.featureSetHas(std.Target.current.cpu.features, .avx);
-const has_armaes = std.Target.aarch64.featureSetHas(std.Target.current.cpu.features, .aes);
-const impl = if (std.Target.current.cpu.arch == .x86_64 and has_aesni and has_avx) impl: {
+const has_aesni = std.Target.x86.featureSetHas(builtin.cpu.features, .aes);
+const has_avx = std.Target.x86.featureSetHas(builtin.cpu.features, .avx);
+const has_armaes = std.Target.aarch64.featureSetHas(builtin.cpu.features, .aes);
+const impl = if (builtin.cpu.arch == .x86_64 and has_aesni and has_avx) impl: {
break :impl @import("aes/aesni.zig");
-} else if (std.Target.current.cpu.arch == .aarch64 and has_armaes)
+} else if (builtin.cpu.arch == .aarch64 and has_armaes)
impl: {
break :impl @import("aes/armcrypto.zig");
} else impl: {
@@ -41,7 +41,7 @@ test "ctr" {
var out: [exp_out.len]u8 = undefined;
var ctx = Aes128.initEnc(key);
- ctr(AesEncryptCtx(Aes128), ctx, out[0..], in[0..], iv, builtin.Endian.Big);
+ ctr(AesEncryptCtx(Aes128), ctx, out[0..], in[0..], iv, std.builtin.Endian.Big);
try testing.expectEqualSlices(u8, exp_out[0..], out[0..]);
}
lib/std/crypto/aes_gcm.zig
@@ -1,6 +1,5 @@
const std = @import("std");
const assert = std.debug.assert;
-const builtin = std.builtin;
const crypto = std.crypto;
const debug = std.debug;
const Ghash = std.crypto.onetimeauth.Ghash;
@@ -40,7 +39,7 @@ fn AesGcm(comptime Aes: anytype) type {
mac.pad();
mem.writeIntBig(u32, j[nonce_length..][0..4], 2);
- modes.ctr(@TypeOf(aes), aes, c, m, j, builtin.Endian.Big);
+ modes.ctr(@TypeOf(aes), aes, c, m, j, std.builtin.Endian.Big);
mac.update(c[0..m.len][0..]);
mac.pad();
@@ -94,7 +93,7 @@ fn AesGcm(comptime Aes: anytype) type {
}
mem.writeIntBig(u32, j[nonce_length..][0..4], 2);
- modes.ctr(@TypeOf(aes), aes, m, c, j, builtin.Endian.Big);
+ modes.ctr(@TypeOf(aes), aes, m, c, j, std.builtin.Endian.Big);
}
};
}
lib/std/crypto/aes_ocb.zig
@@ -1,4 +1,5 @@
const std = @import("std");
+const builtin = @import("builtin");
const crypto = std.crypto;
const aes = crypto.core.aes;
const assert = std.debug.assert;
@@ -100,9 +101,9 @@ fn AesOcb(comptime Aes: anytype) type {
return offset;
}
- const has_aesni = std.Target.x86.featureSetHas(std.Target.current.cpu.features, .aes);
- const has_armaes = std.Target.aarch64.featureSetHas(std.Target.current.cpu.features, .aes);
- const wb: usize = if ((std.Target.current.cpu.arch == .x86_64 and has_aesni) or (std.Target.current.cpu.arch == .aarch64 and has_armaes)) 4 else 0;
+ const has_aesni = std.Target.x86.featureSetHas(builtin.cpu.features, .aes);
+ const has_armaes = std.Target.aarch64.featureSetHas(builtin.cpu.features, .aes);
+ const wb: usize = if ((builtin.cpu.arch == .x86_64 and has_aesni) or (builtin.cpu.arch == .aarch64 and has_armaes)) 4 else 0;
/// c: ciphertext: output buffer should be of size m.len
/// tag: authentication tag: output MAC
lib/std/crypto/benchmark.zig
@@ -1,7 +1,7 @@
// zig run -O ReleaseFast --zig-lib-dir ../.. benchmark.zig
const std = @import("../std.zig");
-const builtin = std.builtin;
+const builtin = @import("builtin");
const mem = std.mem;
const time = std.time;
const Timer = time.Timer;
lib/std/crypto/blake3.zig
@@ -2,6 +2,7 @@
// Source: https://github.com/BLAKE3-team/BLAKE3
const std = @import("../std.zig");
+const builtin = @import("builtin");
const fmt = std.fmt;
const math = std.math;
const mem = std.mem;
@@ -200,7 +201,7 @@ const CompressGeneric = struct {
}
};
-const compress = if (std.Target.current.cpu.arch == .x86_64) CompressVectorized.compress else CompressGeneric.compress;
+const compress = if (builtin.cpu.arch == .x86_64) CompressVectorized.compress else CompressGeneric.compress;
fn first8Words(words: [16]u32) [8]u32 {
return @ptrCast(*const [8]u32, &words).*;
lib/std/crypto/chacha20.zig
@@ -1,6 +1,7 @@
// Based on public domain Supercop by Daniel J. Bernstein
const std = @import("../std.zig");
+const builtin = @import("builtin");
const math = std.math;
const mem = std.mem;
const assert = std.debug.assert;
@@ -359,7 +360,7 @@ fn ChaChaNonVecImpl(comptime rounds_nb: usize) type {
}
fn ChaChaImpl(comptime rounds_nb: usize) type {
- return if (std.Target.current.cpu.arch == .x86_64) ChaChaVecImpl(rounds_nb) else ChaChaNonVecImpl(rounds_nb);
+ return if (builtin.cpu.arch == .x86_64) ChaChaVecImpl(rounds_nb) else ChaChaNonVecImpl(rounds_nb);
}
fn keyToWords(key: [32]u8) [8]u32 {
lib/std/crypto/ghash.zig
@@ -2,6 +2,7 @@
// Adapted from BearSSL's ctmul64 implementation originally written by Thomas Pornin <pornin@bolet.org>
const std = @import("../std.zig");
+const builtin = @import("builtin");
const assert = std.debug.assert;
const math = std.math;
const mem = std.mem;
@@ -45,7 +46,7 @@ pub const Ghash = struct {
const h2 = h0 ^ h1;
const h2r = h0r ^ h1r;
- if (std.builtin.mode == .ReleaseSmall) {
+ if (builtin.mode == .ReleaseSmall) {
return Ghash{
.h0 = h0,
.h1 = h1,
@@ -132,12 +133,12 @@ pub const Ghash = struct {
return z0 | z1 | z2 | z3;
}
- const has_pclmul = std.Target.x86.featureSetHas(std.Target.current.cpu.features, .pclmul);
- const has_avx = std.Target.x86.featureSetHas(std.Target.current.cpu.features, .avx);
- const has_armaes = std.Target.aarch64.featureSetHas(std.Target.current.cpu.features, .aes);
- const clmul = if (std.Target.current.cpu.arch == .x86_64 and has_pclmul and has_avx) impl: {
+ const has_pclmul = std.Target.x86.featureSetHas(builtin.cpu.features, .pclmul);
+ const has_avx = std.Target.x86.featureSetHas(builtin.cpu.features, .avx);
+ const has_armaes = std.Target.aarch64.featureSetHas(builtin.cpu.features, .aes);
+ const clmul = if (builtin.cpu.arch == .x86_64 and has_pclmul and has_avx) impl: {
break :impl clmul_pclmul;
- } else if (std.Target.current.cpu.arch == .aarch64 and has_armaes) impl: {
+ } else if (builtin.cpu.arch == .aarch64 and has_armaes) impl: {
break :impl clmul_pmull;
} else impl: {
break :impl clmul_soft;
@@ -151,7 +152,7 @@ pub const Ghash = struct {
var i: usize = 0;
// 2-blocks aggregated reduction
- if (std.builtin.mode != .ReleaseSmall) {
+ if (builtin.mode != .ReleaseSmall) {
while (i + 32 <= msg.len) : (i += 32) {
// B0 * H^2 unreduced
y1 ^= mem.readIntBig(u64, msg[i..][0..8]);
lib/std/crypto/gimli.zig
@@ -1,13 +1,14 @@
-// Gimli is a 384-bit permutation designed to achieve high security with high
-// performance across a broad range of platforms, including 64-bit Intel/AMD
-// server CPUs, 64-bit and 32-bit ARM smartphone CPUs, 32-bit ARM
-// microcontrollers, 8-bit AVR microcontrollers, FPGAs, ASICs without
-// side-channel protection, and ASICs with side-channel protection.
-//
-// https://gimli.cr.yp.to/
-// https://csrc.nist.gov/CSRC/media/Projects/Lightweight-Cryptography/documents/round-1/spec-doc/gimli-spec.pdf
+//! Gimli is a 384-bit permutation designed to achieve high security with high
+//! performance across a broad range of platforms, including 64-bit Intel/AMD
+//! server CPUs, 64-bit and 32-bit ARM smartphone CPUs, 32-bit ARM
+//! microcontrollers, 8-bit AVR microcontrollers, FPGAs, ASICs without
+//! side-channel protection, and ASICs with side-channel protection.
+//!
+//! https://gimli.cr.yp.to/
+//! https://csrc.nist.gov/CSRC/media/Projects/Lightweight-Cryptography/documents/round-1/spec-doc/gimli-spec.pdf
const std = @import("../std.zig");
+const builtin = @import("builtin");
const mem = std.mem;
const math = std.math;
const debug = std.debug;
@@ -152,9 +153,9 @@ pub const State = struct {
self.endianSwap();
}
- pub const permute = if (std.Target.current.cpu.arch == .x86_64) impl: {
+ pub const permute = if (builtin.cpu.arch == .x86_64) impl: {
break :impl permute_vectorized;
- } else if (std.builtin.mode == .ReleaseSmall) impl: {
+ } else if (builtin.mode == .ReleaseSmall) impl: {
break :impl permute_small;
} else impl: {
break :impl permute_unrolled;
lib/std/crypto/modes.zig
@@ -1,7 +1,6 @@
// Based on Go stdlib implementation
const std = @import("../std.zig");
-const builtin = std.builtin;
const mem = std.mem;
const debug = std.debug;
@@ -11,7 +10,7 @@ const debug = std.debug;
///
/// Important: the counter mode doesn't provide authenticated encryption: the ciphertext can be trivially modified without this being detected.
/// As a result, applications should generally never use it directly, but only in a construction that includes a MAC.
-pub fn ctr(comptime BlockCipher: anytype, block_cipher: BlockCipher, dst: []u8, src: []const u8, iv: [BlockCipher.block_length]u8, endian: builtin.Endian) void {
+pub fn ctr(comptime BlockCipher: anytype, block_cipher: BlockCipher, dst: []u8, src: []const u8, iv: [BlockCipher.block_length]u8, endian: std.builtin.Endian) void {
debug.assert(dst.len >= src.len);
const block_length = BlockCipher.block_length;
var counter: [BlockCipher.block_length]u8 = undefined;
lib/std/crypto/salsa20.zig
@@ -1,4 +1,5 @@
const std = @import("std");
+const builtin = @import("builtin");
const crypto = std.crypto;
const debug = std.debug;
const math = std.math;
@@ -304,7 +305,7 @@ const Salsa20NonVecImpl = struct {
}
};
-const Salsa20Impl = if (std.Target.current.cpu.arch == .x86_64) Salsa20VecImpl else Salsa20NonVecImpl;
+const Salsa20Impl = if (builtin.cpu.arch == .x86_64) Salsa20VecImpl else Salsa20NonVecImpl;
fn keyToWords(key: [32]u8) [8]u32 {
var k: [8]u32 = undefined;
lib/std/crypto/tlcsprng.zig
@@ -4,6 +4,7 @@
//! directly to standard library users.
const std = @import("std");
+const builtin = @import("builtin");
const root = @import("root");
const mem = std.mem;
const os = std.os;
@@ -12,7 +13,7 @@ const os = std.os;
/// point to thread-local variables.
pub var interface = std.rand.Random{ .fillFn = tlsCsprngFill };
-const os_has_fork = switch (std.Target.current.os.tag) {
+const os_has_fork = switch (builtin.os.tag) {
.dragonfly,
.freebsd,
.ios,
@@ -29,10 +30,10 @@ const os_has_fork = switch (std.Target.current.os.tag) {
else => false,
};
-const os_has_arc4random = std.builtin.link_libc and @hasDecl(std.c, "arc4random_buf");
+const os_has_arc4random = builtin.link_libc and @hasDecl(std.c, "arc4random_buf");
const want_fork_safety = os_has_fork and !os_has_arc4random and
(std.meta.globalOption("crypto_fork_safety", bool) orelse true);
-const maybe_have_wipe_on_fork = std.Target.current.os.isAtLeast(.linux, .{
+const maybe_have_wipe_on_fork = builtin.os.isAtLeast(.linux, .{
.major = 4,
.minor = 14,
}) orelse true;
@@ -55,7 +56,7 @@ var install_atfork_handler = std.once(struct {
threadlocal var wipe_mem: []align(mem.page_size) u8 = &[_]u8{};
fn tlsCsprngFill(_: *const std.rand.Random, buffer: []u8) void {
- if (std.builtin.link_libc and @hasDecl(std.c, "arc4random_buf")) {
+ if (builtin.link_libc and @hasDecl(std.c, "arc4random_buf")) {
// arc4random is already a thread-local CSPRNG.
return std.c.arc4random_buf(buffer.ptr, buffer.len);
}
lib/std/event/channel.zig
@@ -1,5 +1,5 @@
const std = @import("../std.zig");
-const builtin = std.builtin;
+const builtin = @import("builtin");
const assert = std.debug.assert;
const testing = std.testing;
const Loop = std.event.Loop;
lib/std/event/future.zig
@@ -1,7 +1,7 @@
const std = @import("../std.zig");
+const builtin = @import("builtin");
const assert = std.debug.assert;
const testing = std.testing;
-const builtin = std.builtin;
const Lock = std.event.Lock;
/// This is a value that starts out unavailable, until resolve() is called
lib/std/event/group.zig
@@ -1,5 +1,5 @@
const std = @import("../std.zig");
-const builtin = std.builtin;
+const builtin = @import("builtin");
const Lock = std.event.Lock;
const testing = std.testing;
const Allocator = std.mem.Allocator;
lib/std/event/lock.zig
@@ -1,5 +1,5 @@
const std = @import("../std.zig");
-const builtin = std.builtin;
+const builtin = @import("builtin");
const assert = std.debug.assert;
const testing = std.testing;
const mem = std.mem;
lib/std/event/loop.zig
@@ -1,5 +1,5 @@
const std = @import("../std.zig");
-const builtin = std.builtin;
+const builtin = @import("builtin");
const root = @import("root");
const assert = std.debug.assert;
const testing = std.testing;
@@ -9,7 +9,7 @@ const windows = os.windows;
const maxInt = std.math.maxInt;
const Thread = std.Thread;
-const is_windows = std.Target.current.os.tag == .windows;
+const is_windows = builtin.os.tag == .windows;
pub const Loop = struct {
next_tick_queue: std.atomic.Queue(anyframe),
@@ -191,7 +191,7 @@ pub const Loop = struct {
self.fs_thread.join();
};
- if (!std.builtin.single_threaded)
+ if (!builtin.single_threaded)
try self.delay_queue.init();
}
@@ -825,7 +825,7 @@ pub const Loop = struct {
}
pub fn sleep(self: *Loop, nanoseconds: u64) void {
- if (std.builtin.single_threaded)
+ if (builtin.single_threaded)
@compileError("TODO: integrate timers with epoll/kevent/iocp for single-threaded");
suspend {
lib/std/event/rwlock.zig
@@ -1,5 +1,5 @@
const std = @import("../std.zig");
-const builtin = std.builtin;
+const builtin = @import("builtin");
const assert = std.debug.assert;
const testing = std.testing;
const mem = std.mem;
lib/std/event/wait_group.zig
@@ -1,5 +1,5 @@
const std = @import("../std.zig");
-const builtin = std.builtin;
+const builtin = @import("builtin");
const Loop = std.event.Loop;
/// A WaitGroup keeps track and waits for a group of async tasks to finish.
lib/std/fs/file.zig
@@ -1,14 +1,14 @@
const std = @import("../std.zig");
-const builtin = std.builtin;
+const builtin = @import("builtin");
const os = std.os;
const io = std.io;
const mem = std.mem;
const math = std.math;
const assert = std.debug.assert;
const windows = os.windows;
-const Os = builtin.Os;
+const Os = std.builtin.Os;
const maxInt = std.math.maxInt;
-const is_windows = std.Target.current.os.tag == .windows;
+const is_windows = builtin.os.tag == .windows;
pub const File = struct {
/// The OS-specific file descriptor or file handle.
lib/std/fs/get_app_data_dir.zig
@@ -1,5 +1,5 @@
const std = @import("../std.zig");
-const builtin = std.builtin;
+const builtin = @import("builtin");
const unicode = std.unicode;
const mem = std.mem;
const fs = std.fs;
lib/std/fs/test.zig
@@ -1,6 +1,6 @@
const std = @import("../std.zig");
+const builtin = @import("builtin");
const testing = std.testing;
-const builtin = std.builtin;
const fs = std.fs;
const mem = std.mem;
const wasi = std.os.wasi;
lib/std/fs/wasi.zig
@@ -1,4 +1,5 @@
const std = @import("std");
+const builtin = @import("builtin");
const os = std.os;
const mem = std.mem;
const math = std.math;
@@ -165,7 +166,7 @@ pub const PreopenList = struct {
};
test "extracting WASI preopens" {
- if (std.builtin.os.tag != .wasi or std.builtin.link_libc) return error.SkipZigTest;
+ if (builtin.os.tag != .wasi or builtin.link_libc) return error.SkipZigTest;
var preopens = PreopenList.init(std.testing.allocator);
defer preopens.deinit();
lib/std/fs/watch.zig
@@ -1,5 +1,5 @@
const std = @import("std");
-const builtin = std.builtin;
+const builtin = @import("builtin");
const event = std.event;
const assert = std.debug.assert;
const testing = std.testing;
@@ -250,7 +250,7 @@ pub fn Watch(comptime V: type) type {
};
// @TODO Can I close this fd and get an error from bsdWaitKev?
- const flags = if (comptime std.Target.current.isDarwin()) os.O.SYMLINK | os.O.EVTONLY else 0;
+ const flags = if (comptime builtin.target.isDarwin()) os.O.SYMLINK | os.O.EVTONLY else 0;
const fd = try os.open(realpath, flags, 0);
gop.value_ptr.putter_frame = async self.kqPutEvents(fd, gop.key_ptr.*, gop.value_ptr.*);
return null;
lib/std/hash/auto_hash.zig
@@ -2,7 +2,6 @@ const std = @import("std");
const assert = std.debug.assert;
const mem = std.mem;
const meta = std.meta;
-const builtin = std.builtin;
/// Describes how pointer types should be hashed.
pub const HashStrategy = enum {
@@ -233,7 +232,7 @@ fn testHashDeepRecursive(key: anytype) u64 {
test "typeContainsSlice" {
comptime {
- try testing.expect(!typeContainsSlice(meta.Tag(builtin.TypeInfo)));
+ try testing.expect(!typeContainsSlice(meta.Tag(std.builtin.TypeInfo)));
try testing.expect(typeContainsSlice([]const u8));
try testing.expect(!typeContainsSlice(u8));
lib/std/hash/benchmark.zig
@@ -1,7 +1,7 @@
// zig run -O ReleaseFast --zig-lib-dir ../.. benchmark.zig
-const builtin = std.builtin;
const std = @import("std");
+const builtin = @import("builtin");
const time = std.time;
const Timer = time.Timer;
const hash = std.hash;
lib/std/hash/cityhash.zig
@@ -1,5 +1,4 @@
const std = @import("std");
-const builtin = std.builtin;
inline fn offsetPtr(ptr: [*]const u8, offset: usize) [*]const u8 {
// ptr + offset doesn't work at comptime so we need this instead.
lib/std/hash/crc.zig
@@ -6,6 +6,7 @@
// still moderately fast just slow relative to the slicing approach.
const std = @import("../std.zig");
+const builtin = @import("builtin");
const debug = std.debug;
const testing = std.testing;
@@ -97,7 +98,7 @@ pub fn Crc32WithPoly(comptime poly: Polynomial) type {
};
}
-const please_windows_dont_oom = std.Target.current.os.tag == .windows;
+const please_windows_dont_oom = builtin.os.tag == .windows;
test "crc32 ieee" {
if (please_windows_dont_oom) return error.SkipZigTest;
lib/std/heap/general_purpose_allocator.zig
@@ -93,6 +93,7 @@
//! in a `std.HashMap` using the backing allocator.
const std = @import("std");
+const builtin = @import("builtin");
const log = std.log.scoped(.gpa);
const math = std.math;
const assert = std.debug.assert;
@@ -104,7 +105,7 @@ const StackTrace = std.builtin.StackTrace;
/// Integer type for pointing to slots in a small allocation
const SlotIndex = std.meta.Int(.unsigned, math.log2(page_size) + 1);
-const sys_can_stack_trace = switch (std.Target.current.cpu.arch) {
+const sys_can_stack_trace = switch (builtin.cpu.arch) {
// Observed to go into an infinite loop.
// TODO: Make this work.
.mips,
@@ -115,13 +116,13 @@ const sys_can_stack_trace = switch (std.Target.current.cpu.arch) {
// "Non-Emscripten WebAssembly hasn't implemented __builtin_return_address".
.wasm32,
.wasm64,
- => std.Target.current.os.tag == .emscripten,
+ => builtin.os.tag == .emscripten,
else => true,
};
-const default_test_stack_trace_frames: usize = if (std.builtin.is_test) 8 else 4;
+const default_test_stack_trace_frames: usize = if (builtin.is_test) 8 else 4;
const default_sys_stack_trace_frames: usize = if (sys_can_stack_trace) default_test_stack_trace_frames else 0;
-const default_stack_trace_frames: usize = switch (std.builtin.mode) {
+const default_stack_trace_frames: usize = switch (builtin.mode) {
.Debug => default_sys_stack_trace_frames,
else => 0,
};
@@ -141,7 +142,7 @@ pub const Config = struct {
safety: bool = std.debug.runtime_safety,
/// Whether the allocator may be used simultaneously from multiple threads.
- thread_safe: bool = !std.builtin.single_threaded,
+ thread_safe: bool = !builtin.single_threaded,
/// What type of mutex you'd like to use, for thread safety.
/// when specfied, the mutex type must have the same shape as `std.Thread.Mutex` and
@@ -988,7 +989,7 @@ test "shrink large object to large object with larger alignment" {
var slice = try allocator.alignedAlloc(u8, 16, alloc_size);
defer allocator.free(slice);
- const big_alignment: usize = switch (std.Target.current.os.tag) {
+ const big_alignment: usize = switch (builtin.os.tag) {
.windows => page_size * 32, // Windows aligns to 64K.
else => page_size * 2,
};
@@ -1058,7 +1059,7 @@ test "realloc large object to larger alignment" {
var slice = try allocator.alignedAlloc(u8, 16, page_size * 2 + 50);
defer allocator.free(slice);
- const big_alignment: usize = switch (std.Target.current.os.tag) {
+ const big_alignment: usize = switch (builtin.os.tag) {
.windows => page_size * 32, // Windows aligns to 64K.
else => page_size * 2,
};
lib/std/io/bit_reader.zig
@@ -1,5 +1,4 @@
const std = @import("../std.zig");
-const builtin = std.builtin;
const io = std.io;
const assert = std.debug.assert;
const testing = std.testing;
@@ -8,7 +7,7 @@ const meta = std.meta;
const math = std.math;
/// Creates a stream which allows for reading bit fields from another stream
-pub fn BitReader(endian: builtin.Endian, comptime ReaderType: type) type {
+pub fn BitReader(endian: std.builtin.Endian, comptime ReaderType: type) type {
return struct {
forward_reader: ReaderType,
bit_buffer: u7,
@@ -162,7 +161,7 @@ pub fn BitReader(endian: builtin.Endian, comptime ReaderType: type) type {
}
pub fn bitReader(
- comptime endian: builtin.Endian,
+ comptime endian: std.builtin.Endian,
underlying_stream: anytype,
) BitReader(endian, @TypeOf(underlying_stream)) {
return BitReader(endian, @TypeOf(underlying_stream)).init(underlying_stream);
lib/std/io/bit_writer.zig
@@ -1,5 +1,4 @@
const std = @import("../std.zig");
-const builtin = std.builtin;
const io = std.io;
const testing = std.testing;
const assert = std.debug.assert;
@@ -8,7 +7,7 @@ const meta = std.meta;
const math = std.math;
/// Creates a stream which allows for writing bit fields to another stream
-pub fn BitWriter(endian: builtin.Endian, comptime WriterType: type) type {
+pub fn BitWriter(endian: std.builtin.Endian, comptime WriterType: type) type {
return struct {
forward_writer: WriterType,
bit_buffer: u8,
@@ -138,7 +137,7 @@ pub fn BitWriter(endian: builtin.Endian, comptime WriterType: type) type {
}
pub fn bitWriter(
- comptime endian: builtin.Endian,
+ comptime endian: std.builtin.Endian,
underlying_stream: anytype,
) BitWriter(endian, @TypeOf(underlying_stream)) {
return BitWriter(endian, @TypeOf(underlying_stream)).init(underlying_stream);
lib/std/io/c_writer.zig
@@ -1,5 +1,5 @@
const std = @import("../std.zig");
-const builtin = std.builtin;
+const builtin = @import("builtin");
const io = std.io;
const testing = std.testing;
const os = std.os;
lib/std/io/reader.zig
@@ -1,5 +1,4 @@
const std = @import("../std.zig");
-const builtin = std.builtin;
const math = std.math;
const assert = std.debug.assert;
const mem = std.mem;
@@ -265,12 +264,12 @@ pub fn Reader(
return mem.readIntBig(T, &bytes);
}
- pub fn readInt(self: Self, comptime T: type, endian: builtin.Endian) !T {
+ pub fn readInt(self: Self, comptime T: type, endian: std.builtin.Endian) !T {
const bytes = try self.readBytesNoEof((@typeInfo(T).Int.bits + 7) / 8);
return mem.readInt(T, &bytes, endian);
}
- pub fn readVarInt(self: Self, comptime ReturnType: type, endian: builtin.Endian, size: usize) !ReturnType {
+ pub fn readVarInt(self: Self, comptime ReturnType: type, endian: std.builtin.Endian, size: usize) !ReturnType {
assert(size <= @sizeOf(ReturnType));
var bytes_buf: [@sizeOf(ReturnType)]u8 = undefined;
const bytes = bytes_buf[0..size];
@@ -310,7 +309,7 @@ pub fn Reader(
pub fn readStruct(self: Self, comptime T: type) !T {
// Only extern and packed structs have defined in-memory layout.
- comptime assert(@typeInfo(T).Struct.layout != builtin.TypeInfo.ContainerLayout.Auto);
+ comptime assert(@typeInfo(T).Struct.layout != std.builtin.TypeInfo.ContainerLayout.Auto);
var res: [1]T = undefined;
try self.readNoEof(mem.sliceAsBytes(res[0..]));
return res[0];
@@ -319,7 +318,7 @@ pub fn Reader(
/// Reads an integer with the same size as the given enum's tag type. If the integer matches
/// an enum tag, casts the integer to the enum tag and returns it. Otherwise, returns an error.
/// TODO optimization taking advantage of most fields being in order
- pub fn readEnum(self: Self, comptime Enum: type, endian: builtin.Endian) !Enum {
+ pub fn readEnum(self: Self, comptime Enum: type, endian: std.builtin.Endian) !Enum {
const E = error{
/// An integer was read, but it did not match any of the tags in the supplied enum.
InvalidValue,
lib/std/io/stream_source.zig
@@ -1,4 +1,5 @@
const std = @import("../std.zig");
+const builtin = @import("builtin");
const io = std.io;
/// Provides `io.Reader`, `io.Writer`, and `io.SeekableStream` for in-memory buffers as
@@ -6,7 +7,7 @@ const io = std.io;
/// For memory sources, if the supplied byte buffer is const, then `io.Writer` is not available.
/// The error set of the stream functions is the error set of the corresponding file functions.
pub const StreamSource = union(enum) {
- const has_file = (std.builtin.os.tag != .freestanding);
+ const has_file = (builtin.os.tag != .freestanding);
/// The stream access is redirected to this buffer.
buffer: io.FixedBufferStream([]u8),
lib/std/io/writer.zig
@@ -1,6 +1,5 @@
const std = @import("../std.zig");
const assert = std.debug.assert;
-const builtin = std.builtin;
const mem = std.mem;
pub fn Writer(
@@ -77,7 +76,7 @@ pub fn Writer(
}
/// TODO audit non-power-of-two int sizes
- pub fn writeInt(self: Self, comptime T: type, value: T, endian: builtin.Endian) Error!void {
+ pub fn writeInt(self: Self, comptime T: type, value: T, endian: std.builtin.Endian) Error!void {
var bytes: [(@typeInfo(T).Int.bits + 7) / 8]u8 = undefined;
mem.writeInt(T, &bytes, value, endian);
return self.writeAll(&bytes);
@@ -85,7 +84,7 @@ pub fn Writer(
pub fn writeStruct(self: Self, value: anytype) Error!void {
// Only extern and packed structs have defined in-memory layout.
- comptime assert(@typeInfo(@TypeOf(value)).Struct.layout != builtin.TypeInfo.ContainerLayout.Auto);
+ comptime assert(@typeInfo(@TypeOf(value)).Struct.layout != std.builtin.TypeInfo.ContainerLayout.Auto);
return self.writeAll(mem.asBytes(&value));
}
};
lib/std/meta/trait.zig
@@ -1,5 +1,4 @@
const std = @import("../std.zig");
-const builtin = std.builtin;
const mem = std.mem;
const debug = std.debug;
const testing = std.testing;
@@ -98,7 +97,7 @@ test "std.meta.trait.hasField" {
try testing.expect(!hasField("value")(u8));
}
-pub fn is(comptime id: builtin.TypeId) TraitFn {
+pub fn is(comptime id: std.builtin.TypeId) TraitFn {
const Closure = struct {
pub fn trait(comptime T: type) bool {
return id == @typeInfo(T);
@@ -115,7 +114,7 @@ test "std.meta.trait.is" {
try testing.expect(!is(.Optional)(anyerror));
}
-pub fn isPtrTo(comptime id: builtin.TypeId) TraitFn {
+pub fn isPtrTo(comptime id: std.builtin.TypeId) TraitFn {
const Closure = struct {
pub fn trait(comptime T: type) bool {
if (!comptime isSingleItemPtr(T)) return false;
@@ -131,7 +130,7 @@ test "std.meta.trait.isPtrTo" {
try testing.expect(!isPtrTo(.Struct)(**struct {}));
}
-pub fn isSliceOf(comptime id: builtin.TypeId) TraitFn {
+pub fn isSliceOf(comptime id: std.builtin.TypeId) TraitFn {
const Closure = struct {
pub fn trait(comptime T: type) bool {
if (!comptime isSlice(T)) return false;
lib/std/net/test.zig
@@ -1,5 +1,5 @@
const std = @import("../std.zig");
-const builtin = std.builtin;
+const builtin = @import("builtin");
const net = std.net;
const mem = std.mem;
const testing = std.testing;
@@ -35,7 +35,7 @@ test "parse and render IPv6 addresses" {
var newIp = std.fmt.bufPrint(buffer[0..], "{}", .{addr}) catch unreachable;
try std.testing.expect(std.mem.eql(u8, printed[i], newIp[1 .. newIp.len - 3]));
- if (std.builtin.os.tag == .linux) {
+ if (builtin.os.tag == .linux) {
var addr_via_resolve = net.Address.resolveIp6(ip, 0) catch unreachable;
var newResolvedIp = std.fmt.bufPrint(buffer[0..], "{}", .{addr_via_resolve}) catch unreachable;
try std.testing.expect(std.mem.eql(u8, printed[i], newResolvedIp[1 .. newResolvedIp.len - 3]));
@@ -49,7 +49,7 @@ test "parse and render IPv6 addresses" {
try testing.expectError(error.Incomplete, net.Address.parseIp6("FF01:", 0));
try testing.expectError(error.InvalidIpv4Mapping, net.Address.parseIp6("::123.123.123.123", 0));
// TODO Make this test pass on other operating systems.
- if (std.builtin.os.tag == .linux) {
+ if (builtin.os.tag == .linux) {
try testing.expectError(error.Incomplete, net.Address.resolveIp6("ff01::fb%", 0));
try testing.expectError(error.Overflow, net.Address.resolveIp6("ff01::fb%wlp3s0s0s0s0s0s0s0s0", 0));
try testing.expectError(error.Overflow, net.Address.resolveIp6("ff01::fb%12345678901234", 0));
@@ -57,7 +57,7 @@ test "parse and render IPv6 addresses" {
}
test "invalid but parseable IPv6 scope ids" {
- if (std.builtin.os.tag != .linux) {
+ if (builtin.os.tag != .linux) {
// Currently, resolveIp6 with alphanumerical scope IDs only works on Linux.
// TODO Make this test pass on other operating systems.
return error.SkipZigTest;
@@ -106,11 +106,11 @@ test "parse and render UNIX addresses" {
test "resolve DNS" {
if (builtin.os.tag == .wasi) return error.SkipZigTest;
- if (std.builtin.os.tag == .windows) {
+ if (builtin.os.tag == .windows) {
_ = try std.os.windows.WSAStartup(2, 2);
}
defer {
- if (std.builtin.os.tag == .windows) {
+ if (builtin.os.tag == .windows) {
std.os.windows.WSACleanup() catch unreachable;
}
}
@@ -143,11 +143,11 @@ test "listen on a port, send bytes, receive bytes" {
if (builtin.single_threaded) return error.SkipZigTest;
if (builtin.os.tag == .wasi) return error.SkipZigTest;
- if (std.builtin.os.tag == .windows) {
+ if (builtin.os.tag == .windows) {
_ = try std.os.windows.WSAStartup(2, 2);
}
defer {
- if (std.builtin.os.tag == .windows) {
+ if (builtin.os.tag == .windows) {
std.os.windows.WSACleanup() catch unreachable;
}
}
@@ -185,7 +185,7 @@ test "listen on a port, send bytes, receive bytes" {
test "listen on a port, send bytes, receive bytes" {
if (!std.io.is_async) return error.SkipZigTest;
- if (std.builtin.os.tag != .linux and !std.builtin.os.tag.isDarwin()) {
+ if (builtin.os.tag != .linux and !builtin.os.tag.isDarwin()) {
// TODO build abstractions for other operating systems
return error.SkipZigTest;
}
@@ -207,7 +207,7 @@ test "listen on a port, send bytes, receive bytes" {
test "listen on ipv4 try connect on ipv6 then ipv4" {
if (!std.io.is_async) return error.SkipZigTest;
- if (std.builtin.os.tag != .linux and !std.builtin.os.tag.isDarwin()) {
+ if (builtin.os.tag != .linux and !builtin.os.tag.isDarwin()) {
// TODO build abstractions for other operating systems
return error.SkipZigTest;
}
@@ -267,11 +267,11 @@ test "listen on a unix socket, send bytes, receive bytes" {
if (builtin.single_threaded) return error.SkipZigTest;
if (!net.has_unix_sockets) return error.SkipZigTest;
- if (std.builtin.os.tag == .windows) {
+ if (builtin.os.tag == .windows) {
_ = try std.os.windows.WSAStartup(2, 2);
}
defer {
- if (std.builtin.os.tag == .windows) {
+ if (builtin.os.tag == .windows) {
std.os.windows.WSACleanup() catch unreachable;
}
}
lib/std/os/linux/bpf/kern.zig
@@ -1,6 +1,7 @@
const std = @import("../../../std.zig");
+const builtin = @import("builtin");
-const in_bpf_program = switch (std.builtin.cpu.arch) {
+const in_bpf_program = switch (builtin.cpu.arch) {
.bpfel, .bpfeb => true,
else => false,
};
lib/std/os/linux/io_uring.zig
@@ -1,6 +1,6 @@
const std = @import("../../std.zig");
+const builtin = @import("builtin");
const assert = std.debug.assert;
-const builtin = std.builtin;
const mem = std.mem;
const net = std.net;
const os = std.os;
lib/std/os/linux/start_pie.zig
@@ -1,6 +1,6 @@
const std = @import("std");
+const builtin = @import("builtin");
const elf = std.elf;
-const builtin = std.builtin;
const assert = std.debug.assert;
const R_AMD64_RELATIVE = 8;
lib/std/os/linux/test.zig
@@ -1,5 +1,5 @@
const std = @import("../../std.zig");
-const builtin = std.builtin;
+const builtin = @import("builtin");
const linux = std.os.linux;
const mem = std.mem;
const elf = std.elf;
lib/std/os/linux/tls.zig
@@ -4,7 +4,7 @@ const mem = std.mem;
const elf = std.elf;
const math = std.math;
const assert = std.debug.assert;
-const native_arch = std.Target.current.cpu.arch;
+const native_arch = @import("builtin").cpu.arch;
// This file implements the two TLS variants [1] used by ELF-based systems.
//
lib/std/os/windows/user32.zig
@@ -1,4 +1,5 @@
const std = @import("../../std.zig");
+const builtin = @import("builtin");
const assert = std.debug.assert;
const windows = std.os.windows;
@@ -29,7 +30,7 @@ const HBRUSH = windows.HBRUSH;
fn selectSymbol(comptime function_static: anytype, function_dynamic: @TypeOf(function_static), comptime os: std.Target.Os.WindowsVersion) @TypeOf(function_static) {
comptime {
- const sym_ok = std.Target.current.os.isAtLeast(.windows, os);
+ const sym_ok = builtin.os.isAtLeast(.windows, os);
if (sym_ok == true) return function_static;
if (sym_ok == null) return function_dynamic;
if (sym_ok == false) @compileError("Target OS range does not support function, at least " ++ @tagName(os) ++ " is required");
lib/std/os/linux.zig
@@ -6,12 +6,13 @@
//! provide `rename` when only the `renameat` syscall exists.
//! * Does not support POSIX thread cancellation.
const std = @import("../std.zig");
+const builtin = @import("builtin");
const assert = std.debug.assert;
const maxInt = std.math.maxInt;
const elf = std.elf;
const vdso = @import("linux/vdso.zig");
const dl = @import("../dynamic_library.zig");
-const native_arch = std.Target.current.cpu.arch;
+const native_arch = builtin.cpu.arch;
const native_endian = native_arch.endian();
const is_mips = native_arch.isMIPS();
const is_ppc = native_arch.isPPC();
@@ -21,7 +22,7 @@ const iovec = std.os.iovec;
const iovec_const = std.os.iovec_const;
test {
- if (std.Target.current.os.tag == .linux) {
+ if (builtin.os.tag == .linux) {
_ = @import("linux/test.zig");
}
}
@@ -150,10 +151,10 @@ pub fn getauxval(index: usize) usize {
// Some architectures (and some syscalls) require 64bit parameters to be passed
// in a even-aligned register pair.
const require_aligned_register_pair =
- std.Target.current.cpu.arch.isPPC() or
- std.Target.current.cpu.arch.isMIPS() or
- std.Target.current.cpu.arch.isARM() or
- std.Target.current.cpu.arch.isThumb();
+ builtin.cpu.arch.isPPC() or
+ builtin.cpu.arch.isMIPS() or
+ builtin.cpu.arch.isARM() or
+ builtin.cpu.arch.isThumb();
// Split a 64bit value into a {LSB,MSB} pair.
// The LE/BE variants specify the endianness to assume.
@@ -1579,7 +1580,7 @@ pub fn process_vm_writev(pid: pid_t, local: [*]const iovec, local_count: usize,
}
pub fn fadvise(fd: fd_t, offset: i64, len: i64, advice: usize) usize {
- if (comptime std.Target.current.cpu.arch.isMIPS()) {
+ if (comptime builtin.cpu.arch.isMIPS()) {
// MIPS requires a 7 argument syscall
const offset_halves = splitValue64(offset);
@@ -1595,7 +1596,7 @@ pub fn fadvise(fd: fd_t, offset: i64, len: i64, advice: usize) usize {
length_halves[1],
advice,
);
- } else if (comptime std.Target.current.cpu.arch.isARM()) {
+ } else if (comptime builtin.cpu.arch.isARM()) {
// ARM reorders the arguments
const offset_halves = splitValue64(offset);
lib/std/rand/ziggurat.zig
@@ -1,14 +1,15 @@
-// Implements ZIGNOR [1].
-//
-// [1]: Jurgen A. Doornik (2005). [*An Improved Ziggurat Method to Generate Normal Random Samples*]
-// (https://www.doornik.com/research/ziggurat.pdf). Nuffield College, Oxford.
-//
-// rust/rand used as a reference;
-//
-// NOTE: This seems interesting but reference code is a bit hard to grok:
-// https://sbarral.github.io/etf.
+//! Implements ZIGNOR [1].
+//!
+//! [1]: Jurgen A. Doornik (2005). [*An Improved Ziggurat Method to Generate Normal Random Samples*]
+//! (https://www.doornik.com/research/ziggurat.pdf). Nuffield College, Oxford.
+//!
+//! rust/rand used as a reference;
+//!
+//! NOTE: This seems interesting but reference code is a bit hard to grok:
+//! https://sbarral.github.io/etf.
const std = @import("../std.zig");
+const builtin = @import("builtin");
const math = std.math;
const Random = std.rand.Random;
@@ -126,7 +127,7 @@ fn norm_zero_case(random: *Random, u: f64) f64 {
}
}
-const please_windows_dont_oom = std.Target.current.os.tag == .windows;
+const please_windows_dont_oom = builtin.os.tag == .windows;
test "normal dist sanity" {
if (please_windows_dont_oom) return error.SkipZigTest;
lib/std/special/compiler_rt/atomics.zig
@@ -1,8 +1,8 @@
const std = @import("std");
-const builtin = std.builtin;
-const arch = std.Target.current.cpu.arch;
+const builtin = @import("builtin");
+const arch = builtin.cpu.arch;
-const linkage: builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak;
+const linkage: std.builtin.GlobalLinkage = if (builtin.is_test) .Internal else .Weak;
// This parameter is true iff the target architecture supports the bare minimum
// to implement the atomic load/store intrinsics.
@@ -16,7 +16,7 @@ const supports_atomic_ops = switch (arch) {
// operations (unless we're targeting Linux, the kernel provides a way to
// perform CAS operations).
// XXX: The Linux code path is not implemented yet.
- !std.Target.arm.featureSetHas(std.Target.current.cpu.features, .has_v6m),
+ !std.Target.arm.featureSetHas(builtin.cpu.features, .has_v6m),
else => true,
};
@@ -257,7 +257,7 @@ comptime {
}
}
-fn fetchFn(comptime T: type, comptime op: builtin.AtomicRmwOp) fn (*T, T, i32) callconv(.C) T {
+fn fetchFn(comptime T: type, comptime op: std.builtin.AtomicRmwOp) fn (*T, T, i32) callconv(.C) T {
return struct {
pub fn fetch_op_N(ptr: *T, val: T, model: i32) callconv(.C) T {
_ = model;
lib/std/special/compiler_rt/clear_cache.zig
@@ -1,6 +1,7 @@
const std = @import("std");
-const arch = std.builtin.cpu.arch;
-const os = std.builtin.os.tag;
+const builtin = @import("builtin");
+const arch = builtin.cpu.arch;
+const os = builtin.os.tag;
// Ported from llvm-project d32170dbd5b0d54436537b6b75beaf44324e0c28
@@ -156,7 +157,7 @@ pub fn clear_cache(start: usize, end: usize) callconv(.C) void {
}
}
-const linkage = if (std.builtin.is_test) std.builtin.GlobalLinkage.Internal else std.builtin.GlobalLinkage.Weak;
+const linkage = if (builtin.is_test) std.builtin.GlobalLinkage.Internal else std.builtin.GlobalLinkage.Weak;
fn exportIt() void {
@export(clear_cache, .{ .name = "__clear_cache", .linkage = linkage });
lib/std/special/compiler_rt/count0bits.zig
@@ -1,5 +1,5 @@
const std = @import("std");
-const builtin = std.builtin;
+const builtin = @import("builtin");
// clz - count leading zeroes
// - clzXi2_generic for little endian
@@ -118,18 +118,18 @@ fn __clzsi2_arm32() callconv(.Naked) void {
}
pub const __clzsi2 = impl: {
- switch (std.Target.current.cpu.arch) {
+ switch (builtin.cpu.arch) {
.arm, .armeb, .thumb, .thumbeb => {
const use_thumb1 =
- (std.Target.current.cpu.arch.isThumb() or
- std.Target.arm.featureSetHas(std.Target.current.cpu.features, .noarm)) and
- !std.Target.arm.featureSetHas(std.Target.current.cpu.features, .thumb2);
+ (builtin.cpu.arch.isThumb() or
+ std.Target.arm.featureSetHas(builtin.cpu.features, .noarm)) and
+ !std.Target.arm.featureSetHas(builtin.cpu.features, .thumb2);
if (use_thumb1) {
break :impl __clzsi2_thumb1;
}
// From here on we're either targeting Thumb2 or ARM.
- else if (!std.Target.current.cpu.arch.isThumb()) {
+ else if (!builtin.cpu.arch.isThumb()) {
break :impl __clzsi2_arm32;
}
// Use the generic implementation otherwise.
@@ -140,14 +140,14 @@ pub const __clzsi2 = impl: {
};
pub const __clzdi2 = impl: {
- switch (std.Target.current.cpu.arch) {
+ switch (builtin.cpu.arch) {
// TODO architecture optimised versions
else => break :impl clzXi2_generic(i64),
}
};
pub const __clzti2 = impl: {
- switch (std.Target.current.cpu.arch) {
+ switch (builtin.cpu.arch) {
// TODO architecture optimised versions
else => break :impl clzXi2_generic(i128),
}
lib/std/special/compiler_rt/emutls.zig
@@ -5,6 +5,7 @@
//
const std = @import("std");
+const builtin = @import("builtin");
const abort = std.os.abort;
const assert = std.debug.assert;
@@ -15,7 +16,7 @@ const expect = std.testing.expect;
const gcc_word = usize;
comptime {
- assert(std.builtin.link_libc);
+ assert(builtin.link_libc);
}
/// public entrypoint for generated code using EmulatedTLS
lib/std/special/compiler_rt/muldi3.zig
@@ -1,6 +1,7 @@
const std = @import("std");
-const is_test = std.builtin.is_test;
-const native_endian = std.Target.current.cpu.arch.endian();
+const builtin = @import("builtin");
+const is_test = builtin.is_test;
+const native_endian = builtin.cpu.arch.endian();
// Ported from
// https://github.com/llvm/llvm-project/blob/llvmorg-9.0.0/compiler-rt/lib/builtins/muldi3.c
lib/std/special/compiler_rt/multi3.zig
@@ -1,7 +1,8 @@
const compiler_rt = @import("../compiler_rt.zig");
const std = @import("std");
-const is_test = std.builtin.is_test;
-const native_endian = std.Target.current.cpu.arch.endian();
+const builtin = @import("builtin");
+const is_test = builtin.is_test;
+const native_endian = builtin.cpu.arch.endian();
// Ported from git@github.com:llvm-project/llvm-project-20170507.git
// ae684fad6d34858c014c94da69c15e7774a633c3
lib/std/special/compiler_rt/shift.zig
@@ -1,6 +1,6 @@
const std = @import("std");
const Log2Int = std.math.Log2Int;
-const native_endian = std.Target.current.cpu.arch.endian();
+const native_endian = @import("builtin").cpu.arch.endian();
fn Dwords(comptime T: type, comptime signed_half: bool) type {
return extern union {
lib/std/special/compiler_rt/stack_probe.zig
@@ -1,4 +1,4 @@
-const native_arch = @import("std").Target.current.cpu.arch;
+const native_arch = @import("builtin").cpu.arch;
// Zig's own stack-probe routine (available only on x86 and x86_64)
pub fn zig_probe_stack() callconv(.Naked) void {
lib/std/special/compiler_rt/udivmod.zig
@@ -1,6 +1,6 @@
const builtin = @import("builtin");
const is_test = builtin.is_test;
-const native_endian = @import("std").Target.current.cpu.arch.endian();
+const native_endian = builtin.cpu.arch.endian();
const low = switch (native_endian) {
.Big => 1,
lib/std/special/compiler_rt.zig
@@ -1,9 +1,9 @@
const std = @import("std");
const builtin = @import("builtin");
const is_test = builtin.is_test;
-const os_tag = std.Target.current.os.tag;
+const os_tag = builtin.os.tag;
const arch = builtin.stage2_arch;
-const abi = std.Target.current.abi;
+const abi = builtin.abi;
const is_gnu = abi.isGnu();
const is_mingw = os_tag == .windows and is_gnu;
lib/std/special/ssp.zig
@@ -1,19 +1,18 @@
-//
-// Small Zig reimplementation of gcc's libssp.
-//
-// This library implements most of the builtins required by the stack smashing
-// protection as implemented by gcc&clang.
-const std = @import("std");
-const builtin = std.builtin;
+//!
+//! Small Zig reimplementation of gcc's libssp.
+//!
+//! This library implements most of the builtins required by the stack smashing
+//! protection as implemented by gcc&clang.
+//! Missing exports:
+//! - __gets_chk
+//! - __mempcpy_chk
+//! - __snprintf_chk
+//! - __sprintf_chk
+//! - __stpcpy_chk
+//! - __vsnprintf_chk
+//! - __vsprintf_chk
-// Missing exports:
-// - __gets_chk
-// - __mempcpy_chk
-// - __snprintf_chk
-// - __sprintf_chk
-// - __stpcpy_chk
-// - __vsnprintf_chk
-// - __vsprintf_chk
+const std = @import("std");
extern fn strncpy(dest: [*:0]u8, src: [*:0]const u8, n: usize) callconv(.C) [*:0]u8;
extern fn memset(dest: ?[*]u8, c: u8, n: usize) callconv(.C) ?[*]u8;
@@ -21,7 +20,7 @@ extern fn memcpy(noalias dest: ?[*]u8, noalias src: ?[*]const u8, n: usize) call
extern fn memmove(dest: ?[*]u8, src: ?[*]const u8, n: usize) callconv(.C) ?[*]u8;
// Avoid dragging in the runtime safety mechanisms into this .o file.
-pub fn panic(msg: []const u8, error_return_trace: ?*builtin.StackTrace) noreturn {
+pub fn panic(msg: []const u8, error_return_trace: ?*std.builtin.StackTrace) noreturn {
_ = msg;
_ = error_return_trace;
@setCold(true);
lib/std/Thread/AutoResetEvent.zig
@@ -26,7 +26,7 @@
state: usize = UNSET,
const std = @import("../std.zig");
-const builtin = std.builtin;
+const builtin = @import("builtin");
const testing = std.testing;
const assert = std.debug.assert;
const StaticResetEvent = std.Thread.StaticResetEvent;
lib/std/Thread/Condition.zig
@@ -5,6 +5,7 @@
impl: Impl = .{},
const std = @import("../std.zig");
+const builtin = @import("builtin");
const Condition = @This();
const windows = std.os.windows;
const linux = std.os.linux;
@@ -23,9 +24,9 @@ pub fn broadcast(cond: *Condition) void {
cond.impl.broadcast();
}
-const Impl = if (std.builtin.single_threaded)
+const Impl = if (builtin.single_threaded)
SingleThreadedCondition
-else if (std.Target.current.os.tag == .windows)
+else if (builtin.os.tag == .windows)
WindowsCondition
else if (std.Thread.use_pthreads)
PthreadCondition
@@ -101,7 +102,7 @@ pub const AtomicCondition = struct {
fn wait(cond: *@This()) void {
while (@atomicLoad(i32, &cond.futex, .Acquire) == 0) {
- switch (std.Target.current.os.tag) {
+ switch (builtin.os.tag) {
.linux => {
switch (linux.getErrno(linux.futex_wait(
&cond.futex,
@@ -123,7 +124,7 @@ pub const AtomicCondition = struct {
fn notify(cond: *@This()) void {
@atomicStore(i32, &cond.futex, 1, .Release);
- switch (std.Target.current.os.tag) {
+ switch (builtin.os.tag) {
.linux => {
switch (linux.getErrno(linux.futex_wake(
&cond.futex,
lib/std/Thread/Futex.zig
@@ -4,10 +4,11 @@
//! Using Futex, other Thread synchronization primitives can be built which efficiently wait for cross-thread events or signals.
const std = @import("../std.zig");
+const builtin = @import("builtin");
const Futex = @This();
-const target = std.Target.current;
-const single_threaded = std.builtin.single_threaded;
+const target = builtin.target;
+const single_threaded = builtin.single_threaded;
const assert = std.debug.assert;
const testing = std.testing;
@@ -70,7 +71,7 @@ else if (target.os.tag == .linux)
LinuxFutex
else if (target.isDarwin())
DarwinFutex
-else if (std.builtin.link_libc)
+else if (builtin.link_libc)
PosixFutex
else
UnsupportedFutex;
lib/std/Thread/Mutex.zig
@@ -24,7 +24,7 @@ impl: Impl = .{},
const Mutex = @This();
const std = @import("../std.zig");
-const builtin = std.builtin;
+const builtin = @import("builtin");
const os = std.os;
const assert = std.debug.assert;
const windows = os.windows;
@@ -160,7 +160,7 @@ pub const AtomicMutex = struct {
.unlocked => return,
else => {},
}
- switch (std.Target.current.os.tag) {
+ switch (builtin.os.tag) {
.linux => {
switch (linux.getErrno(linux.futex_wait(
@ptrCast(*const i32, &m.state),
@@ -182,7 +182,7 @@ pub const AtomicMutex = struct {
fn unlockSlow(m: *AtomicMutex) void {
@setCold(true);
- switch (std.Target.current.os.tag) {
+ switch (builtin.os.tag) {
.linux => {
switch (linux.getErrno(linux.futex_wake(
@ptrCast(*const i32, &m.state),
lib/std/Thread/ResetEvent.zig
@@ -8,7 +8,7 @@
const ResetEvent = @This();
const std = @import("../std.zig");
-const builtin = std.builtin;
+const builtin = @import("builtin");
const testing = std.testing;
const assert = std.debug.assert;
const c = std.c;
@@ -19,7 +19,7 @@ impl: Impl,
pub const Impl = if (builtin.single_threaded)
std.Thread.StaticResetEvent.DebugEvent
-else if (std.Target.current.isDarwin())
+else if (builtin.target.isDarwin())
DarwinEvent
else if (std.Thread.use_pthreads)
PosixEvent
lib/std/Thread/StaticResetEvent.zig
@@ -8,6 +8,7 @@
//! the logic needs stronger API guarantees.
const std = @import("../std.zig");
+const builtin = @import("builtin");
const StaticResetEvent = @This();
const assert = std.debug.assert;
const os = std.os;
@@ -18,7 +19,7 @@ const testing = std.testing;
impl: Impl = .{},
-pub const Impl = if (std.builtin.single_threaded)
+pub const Impl = if (builtin.single_threaded)
DebugEvent
else
AtomicEvent;
@@ -162,7 +163,7 @@ pub const AtomicEvent = struct {
@atomicStore(u32, &ev.waiters, 0, .Monotonic);
}
- pub const Futex = switch (std.Target.current.os.tag) {
+ pub const Futex = switch (builtin.os.tag) {
.windows => WindowsFutex,
.linux => LinuxFutex,
else => SpinFutex,
@@ -322,7 +323,7 @@ test "basic usage" {
try testing.expectEqual(TimedWaitResult.event_set, event.timedWait(1));
// test cross-thread signaling
- if (std.builtin.single_threaded)
+ if (builtin.single_threaded)
return;
const Context = struct {
lib/std/unicode/throughput_test.zig
@@ -1,5 +1,4 @@
const std = @import("std");
-const builtin = std.builtin;
const time = std.time;
const unicode = std.unicode;
lib/std/x/net/tcp.zig
@@ -1,4 +1,5 @@
const std = @import("../../std.zig");
+const builtin = @import("builtin");
const io = std.io;
const os = std.os;
@@ -7,7 +8,7 @@ const ip = std.x.net.ip;
const fmt = std.fmt;
const mem = std.mem;
const testing = std.testing;
-const native_os = std.Target.current.os;
+const native_os = builtin.os;
const IPv4 = std.x.os.IPv4;
const IPv6 = std.x.os.IPv6;
lib/std/x/os/io.zig
@@ -1,9 +1,10 @@
const std = @import("../../std.zig");
+const builtin = @import("builtin");
const os = std.os;
const mem = std.mem;
const testing = std.testing;
-const native_os = std.Target.current.os;
+const native_os = builtin.os;
const linux = std.os.linux;
/// POSIX `iovec`, or Windows `WSABUF`. The difference between the two are the ordering
lib/std/x/os/net.zig
@@ -1,11 +1,12 @@
const std = @import("../../std.zig");
+const builtin = @import("builtin");
const os = std.os;
const fmt = std.fmt;
const mem = std.mem;
const math = std.math;
const testing = std.testing;
-const native_os = std.Target.current.os;
+const native_os = builtin.os;
const have_ifnamesize = @hasDecl(os.system, "IFNAMESIZE");
/// Resolves a network interface name into a scope/zone ID. It returns
lib/std/x/os/socket.zig
@@ -1,4 +1,5 @@
const std = @import("../../std.zig");
+const builtin = @import("builtin");
const net = @import("net.zig");
const os = std.os;
@@ -6,8 +7,8 @@ const fmt = std.fmt;
const mem = std.mem;
const time = std.time;
const meta = std.meta;
-const native_os = std.Target.current.os;
-const native_endian = std.Target.current.cpu.arch.endian();
+const native_os = builtin.os;
+const native_endian = builtin.cpu.arch.endian();
const Buffer = std.x.os.Buffer;
lib/std/zig/system/darwin/macos.zig
@@ -1,4 +1,5 @@
const std = @import("std");
+const builtin = @import("builtin");
const assert = std.debug.assert;
const mem = std.mem;
const testing = std.testing;
@@ -414,7 +415,7 @@ pub fn detectNativeCpuAndFeatures() ?Target.Cpu {
error.Unexpected => unreachable, // EFAULT: stack should be safe, EISDIR/ENOTDIR: constant, known good value
};
- const current_arch = Target.current.cpu.arch;
+ const current_arch = builtin.cpu.arch;
switch (current_arch) {
.aarch64, .aarch64_be, .aarch64_32 => {
const model = switch (cpu_family) {
lib/std/zig/system/linux.zig
@@ -1,4 +1,5 @@
const std = @import("std");
+const builtin = @import("builtin");
const mem = std.mem;
const io = std.io;
const fs = std.fs;
@@ -450,7 +451,7 @@ pub fn detectNativeCpuAndFeatures() ?Target.Cpu {
};
defer f.close();
- const current_arch = std.Target.current.cpu.arch;
+ const current_arch = builtin.cpu.arch;
switch (current_arch) {
.arm, .armeb, .thumb, .thumbeb, .aarch64, .aarch64_be, .aarch64_32 => {
return ArmCpuinfoParser.parse(current_arch, f.reader()) catch null;
lib/std/zig/cross_target.zig
@@ -1,4 +1,5 @@
const std = @import("../std.zig");
+const builtin = @import("builtin");
const assert = std.debug.assert;
const Target = std.Target;
const mem = std.mem;
@@ -329,7 +330,7 @@ pub const CrossTarget = struct {
// This works when doing `zig build` because Zig generates a build executable using
// native CPU model & features. However this will not be accurate otherwise, and
// will need to be integrated with `std.zig.system.NativeTargetInfo.detect`.
- return Target.current.cpu;
+ return builtin.cpu;
},
.baseline => {
var adjusted_baseline = Target.Cpu.baseline(self.getCpuArch());
@@ -340,7 +341,7 @@ pub const CrossTarget = struct {
// This works when doing `zig build` because Zig generates a build executable using
// native CPU model & features. However this will not be accurate otherwise, and
// will need to be integrated with `std.zig.system.NativeTargetInfo.detect`.
- return Target.current.cpu;
+ return builtin.cpu;
} else {
var adjusted_baseline = Target.Cpu.baseline(self.getCpuArch());
self.updateCpuFeatures(&adjusted_baseline.features);
@@ -355,7 +356,7 @@ pub const CrossTarget = struct {
}
pub fn getCpuArch(self: CrossTarget) Target.Cpu.Arch {
- return self.cpu_arch orelse Target.current.cpu.arch;
+ return self.cpu_arch orelse builtin.cpu.arch;
}
pub fn getCpuModel(self: CrossTarget) *const Target.Cpu.Model {
@@ -371,10 +372,10 @@ pub const CrossTarget = struct {
/// TODO deprecated, use `std.zig.system.NativeTargetInfo.detect`.
pub fn getOs(self: CrossTarget) Target.Os {
- // `Target.current.os` works when doing `zig build` because Zig generates a build executable using
+ // `builtin.os` works when doing `zig build` because Zig generates a build executable using
// native OS version range. However this will not be accurate otherwise, and
// will need to be integrated with `std.zig.system.NativeTargetInfo.detect`.
- var adjusted_os = if (self.os_tag) |os_tag| os_tag.defaultVersionRange() else Target.current.os;
+ var adjusted_os = if (self.os_tag) |os_tag| os_tag.defaultVersionRange() else builtin.os;
if (self.os_version_min) |min| switch (min) {
.none => {},
@@ -403,7 +404,7 @@ pub const CrossTarget = struct {
}
pub fn getOsTag(self: CrossTarget) Target.Os.Tag {
- return self.os_tag orelse Target.current.os.tag;
+ return self.os_tag orelse builtin.os.tag;
}
/// TODO deprecated, use `std.zig.system.NativeTargetInfo.detect`.
@@ -430,7 +431,7 @@ pub const CrossTarget = struct {
// This works when doing `zig build` because Zig generates a build executable using
// native CPU model & features. However this will not be accurate otherwise, and
// will need to be integrated with `std.zig.system.NativeTargetInfo.detect`.
- return Target.current.abi;
+ return builtin.abi;
}
return Target.Abi.default(self.getCpuArch(), self.getOs());
@@ -607,12 +608,12 @@ pub const CrossTarget = struct {
pub fn getExternalExecutor(self: CrossTarget) Executor {
const cpu_arch = self.getCpuArch();
const os_tag = self.getOsTag();
- const os_match = os_tag == Target.current.os.tag;
+ const os_match = os_tag == builtin.os.tag;
// If the OS and CPU arch match, the binary can be considered native.
// TODO additionally match the CPU features. This `getExternalExecutor` function should
// be moved to std.Target and match any chosen target against the native target.
- if (os_match and cpu_arch == Target.current.cpu.arch) {
+ if (os_match and cpu_arch == builtin.cpu.arch) {
// However, we also need to verify that the dynamic linker path is valid.
if (self.os_tag == null) {
return .native;
@@ -664,7 +665,7 @@ pub const CrossTarget = struct {
// TODO loosen this check once upstream adds QEMU-based emulation
// layer for non-host architectures:
// https://github.com/darlinghq/darling/issues/863
- if (cpu_arch != Target.current.cpu.arch) {
+ if (cpu_arch != builtin.cpu.arch) {
return .unavailable;
}
return Executor{ .darling = "darling" };
@@ -789,7 +790,7 @@ pub const CrossTarget = struct {
};
test "CrossTarget.parse" {
- if (Target.current.isGnuLibC()) {
+ if (builtin.target.isGnuLibC()) {
var cross_target = try CrossTarget.parse(.{});
cross_target.setGnuLibCVersion(2, 1, 1);
@@ -800,7 +801,7 @@ test "CrossTarget.parse" {
const triple = std.fmt.bufPrint(
buf[0..],
"native-native-{s}.2.1.1",
- .{@tagName(std.Target.current.abi)},
+ .{@tagName(builtin.abi)},
) catch unreachable;
try std.testing.expectEqualSlices(u8, triple, text);
lib/std/zig/system.zig
@@ -1,4 +1,5 @@
const std = @import("../std.zig");
+const builtin = @import("builtin");
const elf = std.elf;
const mem = std.mem;
const fs = std.fs;
@@ -8,7 +9,7 @@ const assert = std.debug.assert;
const process = std.process;
const Target = std.Target;
const CrossTarget = std.zig.CrossTarget;
-const native_endian = std.Target.current.cpu.arch.endian();
+const native_endian = builtin.cpu.arch.endian();
const linux = @import("system/linux.zig");
pub const windows = @import("system/windows.zig");
pub const darwin = @import("system/darwin.zig");
@@ -88,7 +89,7 @@ pub const NativePaths = struct {
return self;
}
- if (comptime Target.current.isDarwin()) {
+ if (comptime builtin.target.isDarwin()) {
try self.addIncludeDir("/usr/include");
try self.addIncludeDir("/usr/local/include");
@@ -239,7 +240,7 @@ pub const NativeTargetInfo = struct {
pub fn detect(allocator: *Allocator, cross_target: CrossTarget) DetectError!NativeTargetInfo {
var os = cross_target.getOsTag().defaultVersionRange();
if (cross_target.os_tag == null) {
- switch (Target.current.os.tag) {
+ switch (builtin.target.os.tag) {
.linux => {
const uts = std.os.uname();
const release = mem.spanZ(&uts.release);
@@ -273,7 +274,7 @@ pub const NativeTargetInfo = struct {
},
.macos => try darwin.macos.detect(&os),
.freebsd, .netbsd, .dragonfly => {
- const key = switch (Target.current.os.tag) {
+ const key = switch (builtin.target.os.tag) {
.freebsd => "kern.osreldate",
.netbsd, .dragonfly => "kern.osrevision",
else => unreachable,
@@ -289,7 +290,7 @@ pub const NativeTargetInfo = struct {
error.Unexpected => return error.OSVersionDetectionFail,
};
- switch (Target.current.os.tag) {
+ switch (builtin.target.os.tag) {
.freebsd => {
// https://www.freebsd.org/doc/en_US.ISO8859-1/books/porters-handbook/versions.html
// Major * 100,000 has been convention since FreeBSD 2.2 (1997)
@@ -445,8 +446,8 @@ pub const NativeTargetInfo = struct {
os: Target.Os,
cross_target: CrossTarget,
) DetectError!NativeTargetInfo {
- const native_target_has_ld = comptime Target.current.hasDynamicLinker();
- const is_linux = Target.current.os.tag == .linux;
+ const native_target_has_ld = comptime builtin.target.hasDynamicLinker();
+ const is_linux = builtin.target.os.tag == .linux;
const have_all_info = cross_target.dynamic_linker.get() != null and
cross_target.abi != null and (!is_linux or cross_target.abi.?.isGnu());
const os_is_non_native = cross_target.os_tag != null;
@@ -463,7 +464,7 @@ pub const NativeTargetInfo = struct {
// compiler for target riscv64-linux-musl and provide a tarball for users to download.
// A user could then run that zig compiler on riscv64-linux-gnu. This use case is well-defined
// and supported by Zig. But that means that we must detect the system ABI here rather than
- // relying on `Target.current`.
+ // relying on `builtin.target`.
const all_abis = comptime blk: {
assert(@enumToInt(Target.Abi.none) == 0);
const fields = std.meta.fields(Target.Abi)[1..];
@@ -524,7 +525,7 @@ pub const NativeTargetInfo = struct {
// Look for glibc version.
var os_adjusted = os;
- if (Target.current.os.tag == .linux and found_ld_info.abi.isGnu() and
+ if (builtin.target.os.tag == .linux and found_ld_info.abi.isGnu() and
cross_target.glibc_version == null)
{
for (lib_paths) |lib_path| {
@@ -740,7 +741,7 @@ pub const NativeTargetInfo = struct {
}
},
// We only need this for detecting glibc version.
- elf.PT_DYNAMIC => if (Target.current.os.tag == .linux and result.target.isGnuLibC() and
+ elf.PT_DYNAMIC => if (builtin.target.os.tag == .linux and result.target.isGnuLibC() and
cross_target.glibc_version == null)
{
var dyn_off = elfInt(is_64, need_bswap, ph32.p_offset, ph64.p_offset);
@@ -787,7 +788,7 @@ pub const NativeTargetInfo = struct {
}
}
- if (Target.current.os.tag == .linux and result.target.isGnuLibC() and cross_target.glibc_version == null) {
+ if (builtin.target.os.tag == .linux and result.target.isGnuLibC() and cross_target.glibc_version == null) {
if (rpath_offset) |rpoff| {
const shstrndx = elfInt(is_64, need_bswap, hdr32.e_shstrndx, hdr64.e_shstrndx);
@@ -979,14 +980,14 @@ pub const NativeTargetInfo = struct {
// Here we switch on a comptime value rather than `cpu_arch`. This is valid because `cpu_arch`,
// although it is a runtime value, is guaranteed to be one of the architectures in the set
// of the respective switch prong.
- switch (std.Target.current.cpu.arch) {
+ switch (builtin.cpu.arch) {
.x86_64, .i386 => {
return @import("system/x86.zig").detectNativeCpuAndFeatures(cpu_arch, os, cross_target);
},
else => {},
}
- switch (std.Target.current.os.tag) {
+ switch (builtin.os.tag) {
.linux => return linux.detectNativeCpuAndFeatures(),
.macos => return darwin.macos.detectNativeCpuAndFeatures(),
else => {},
lib/std/array_hash_map.zig
@@ -9,7 +9,6 @@ const trait = meta.trait;
const autoHash = std.hash.autoHash;
const Wyhash = std.hash.Wyhash;
const Allocator = mem.Allocator;
-const builtin = std.builtin;
const hash_map = @This();
/// An ArrayHashMap with default hash and equal functions.
lib/std/atomic.zig
@@ -1,5 +1,5 @@
const std = @import("std.zig");
-const target = std.Target.current;
+const target = @import("builtin").target;
pub const Ordering = std.builtin.AtomicOrder;
lib/std/build.zig
@@ -1,5 +1,5 @@
const std = @import("std.zig");
-const builtin = std.builtin;
+const builtin = @import("builtin");
const io = std.io;
const fs = std.fs;
const mem = std.mem;
@@ -62,7 +62,7 @@ pub const Builder = struct {
build_root: []const u8,
cache_root: []const u8,
global_cache_root: []const u8,
- release_mode: ?builtin.Mode,
+ release_mode: ?std.builtin.Mode,
is_release: bool,
override_lib_dir: ?[]const u8,
vcpkg_root: VcpkgRoot,
@@ -633,18 +633,18 @@ pub const Builder = struct {
}
/// This provides the -Drelease option to the build user and does not give them the choice.
- pub fn setPreferredReleaseMode(self: *Builder, mode: builtin.Mode) void {
+ pub fn setPreferredReleaseMode(self: *Builder, mode: std.builtin.Mode) void {
if (self.release_mode != null) {
@panic("setPreferredReleaseMode must be called before standardReleaseOptions and may not be called twice");
}
const description = self.fmt("Create a release build ({s})", .{@tagName(mode)});
self.is_release = self.option(bool, "release", description) orelse false;
- self.release_mode = if (self.is_release) mode else builtin.Mode.Debug;
+ self.release_mode = if (self.is_release) mode else std.builtin.Mode.Debug;
}
/// If you call this without first calling `setPreferredReleaseMode` then it gives the build user
/// the choice of what kind of release.
- pub fn standardReleaseOptions(self: *Builder) builtin.Mode {
+ pub fn standardReleaseOptions(self: *Builder) std.builtin.Mode {
if (self.release_mode) |mode| return mode;
const release_safe = self.option(bool, "release-safe", "Optimizations on and safety on") orelse false;
@@ -652,17 +652,17 @@ pub const Builder = struct {
const release_small = self.option(bool, "release-small", "Size optimizations on and safety off") orelse false;
const mode = if (release_safe and !release_fast and !release_small)
- builtin.Mode.ReleaseSafe
+ std.builtin.Mode.ReleaseSafe
else if (release_fast and !release_safe and !release_small)
- builtin.Mode.ReleaseFast
+ std.builtin.Mode.ReleaseFast
else if (release_small and !release_fast and !release_safe)
- builtin.Mode.ReleaseSmall
+ std.builtin.Mode.ReleaseSmall
else if (!release_fast and !release_safe and !release_small)
- builtin.Mode.Debug
+ std.builtin.Mode.Debug
else x: {
warn("Multiple release modes (of -Drelease-safe, -Drelease-fast and -Drelease-small)\n\n", .{});
self.markInvalidUserInput();
- break :x builtin.Mode.Debug;
+ break :x std.builtin.Mode.Debug;
};
self.is_release = mode != .Debug;
self.release_mode = mode;
@@ -1290,7 +1290,7 @@ test "builder.findProgram compiles" {
}
/// Deprecated. Use `std.builtin.Version`.
-pub const Version = builtin.Version;
+pub const Version = std.builtin.Version;
/// Deprecated. Use `std.zig.CrossTarget`.
pub const Target = std.zig.CrossTarget;
@@ -1417,8 +1417,8 @@ pub const LibExeObjStep = struct {
version_script: ?[]const u8 = null,
out_filename: []const u8,
linkage: ?Linkage = null,
- version: ?Version,
- build_mode: builtin.Mode,
+ version: ?std.builtin.Version,
+ build_mode: std.builtin.Mode,
kind: Kind,
major_only_filename: ?[]const u8,
name_only_filename: ?[]const u8,
@@ -1447,8 +1447,8 @@ pub const LibExeObjStep = struct {
filter: ?[]const u8,
single_threaded: bool,
test_evented_io: bool = false,
- code_model: builtin.CodeModel = .default,
- wasi_exec_model: ?builtin.WasiExecModel = null,
+ code_model: std.builtin.CodeModel = .default,
+ wasi_exec_model: ?std.builtin.WasiExecModel = null,
root_src: ?FileSource,
out_h_filename: []const u8,
@@ -1550,7 +1550,7 @@ pub const LibExeObjStep = struct {
};
const SharedLibKind = union(enum) {
- versioned: Version,
+ versioned: std.builtin.Version,
unversioned: void,
};
@@ -1585,7 +1585,7 @@ pub const LibExeObjStep = struct {
root_src_raw: ?FileSource,
kind: Kind,
linkage: ?Linkage,
- ver: ?Version,
+ ver: ?std.builtin.Version,
) *LibExeObjStep {
const name = builder.dupe(name_raw);
const root_src: ?FileSource = if (root_src_raw) |rsrc| rsrc.dupe(builder) else null;
@@ -1599,7 +1599,7 @@ pub const LibExeObjStep = struct {
.builder = builder,
.verbose_link = false,
.verbose_cc = false,
- .build_mode = builtin.Mode.Debug,
+ .build_mode = std.builtin.Mode.Debug,
.linkage = linkage,
.kind = kind,
.root_src = root_src,
@@ -1988,7 +1988,7 @@ pub const LibExeObjStep = struct {
self.verbose_cc = value;
}
- pub fn setBuildMode(self: *LibExeObjStep, mode: builtin.Mode) void {
+ pub fn setBuildMode(self: *LibExeObjStep, mode: std.builtin.Mode) void {
self.build_mode = mode;
}
@@ -2553,7 +2553,7 @@ pub const LibExeObjStep = struct {
const resolved_include_path = self.builder.pathFromRoot(include_path);
- const common_include_path = if (std.Target.current.os.tag == .windows and builder.sysroot != null and fs.path.isAbsolute(resolved_include_path)) blk: {
+ const common_include_path = if (builtin.os.tag == .windows and builder.sysroot != null and fs.path.isAbsolute(resolved_include_path)) blk: {
// We need to check for disk designator and strip it out from dir path so
// that zig/clang can concat resolved_include_path with sysroot.
const disk_designator = fs.path.diskDesignatorWindows(resolved_include_path);
@@ -3237,7 +3237,7 @@ test "LibExeObjStep.addPackage" {
test {
// The only purpose of this test is to get all these untested functions
// to be referenced to avoid regression so it is okay to skip some targets.
- if (comptime std.Target.current.cpu.arch.ptrBitWidth() == 64) {
+ if (comptime builtin.cpu.arch.ptrBitWidth() == 64) {
std.testing.refAllDecls(@This());
std.testing.refAllDecls(Builder);
lib/std/builtin.zig
@@ -1,26 +1,27 @@
const builtin = @import("builtin");
-// These are all deprecated.
-pub const zig_version = builtin.zig_version;
-pub const zig_is_stage2 = builtin.zig_is_stage2;
-pub const output_mode = builtin.output_mode;
-pub const link_mode = builtin.link_mode;
-pub const is_test = builtin.is_test;
-pub const single_threaded = builtin.single_threaded;
-pub const abi = builtin.abi;
-pub const cpu = builtin.cpu;
-pub const os = builtin.os;
-pub const target = builtin.target;
-pub const object_format = builtin.object_format;
-pub const mode = builtin.mode;
-pub const link_libc = builtin.link_libc;
-pub const link_libcpp = builtin.link_libcpp;
-pub const have_error_return_tracing = builtin.have_error_return_tracing;
-pub const valgrind_support = builtin.valgrind_support;
-pub const position_independent_code = builtin.position_independent_code;
-pub const position_independent_executable = builtin.position_independent_executable;
-pub const strip_debug_info = builtin.strip_debug_info;
-pub const code_model = builtin.code_model;
+// TODO delete these after releasing 0.9.0
+
+pub const zig_version = @compileError("get this from @import(\"builtin\") instead of std.builtin");
+pub const zig_is_stage2 = @compileError("get this from @import(\"builtin\") instead of std.builtin");
+pub const output_mode = @compileError("get this from @import(\"builtin\") instead of std.builtin");
+pub const link_mode = @compileError("get this from @import(\"builtin\") instead of std.builtin");
+pub const is_test = @compileError("get this from @import(\"builtin\") instead of std.builtin");
+pub const single_threaded = @compileError("get this from @import(\"builtin\") instead of std.builtin");
+pub const abi = @compileError("get this from @import(\"builtin\") instead of std.builtin");
+pub const cpu = @compileError("get this from @import(\"builtin\") instead of std.builtin");
+pub const os = @compileError("get this from @import(\"builtin\") instead of std.builtin");
+pub const target = @compileError("get this from @import(\"builtin\") instead of std.builtin");
+pub const object_format = @compileError("get this from @import(\"builtin\") instead of std.builtin");
+pub const mode = @compileError("get this from @import(\"builtin\") instead of std.builtin");
+pub const link_libc = @compileError("get this from @import(\"builtin\") instead of std.builtin");
+pub const link_libcpp = @compileError("get this from @import(\"builtin\") instead of std.builtin");
+pub const have_error_return_tracing = @compileError("get this from @import(\"builtin\") instead of std.builtin");
+pub const valgrind_support = @compileError("get this from @import(\"builtin\") instead of std.builtin");
+pub const position_independent_code = @compileError("get this from @import(\"builtin\") instead of std.builtin");
+pub const position_independent_executable = @compileError("get this from @import(\"builtin\") instead of std.builtin");
+pub const strip_debug_info = @compileError("get this from @import(\"builtin\") instead of std.builtin");
+pub const code_model = @compileError("get this from @import(\"builtin\") instead of std.builtin");
/// `explicit_subsystem` is missing when the subsystem is automatically detected,
/// so Zig standard library has the subsystem detection logic here. This should generally be
@@ -694,7 +695,7 @@ pub fn default_panic(msg: []const u8, error_return_trace: ?*StackTrace) noreturn
@breakpoint();
}
}
- switch (os.tag) {
+ switch (builtin.os.tag) {
.freestanding => {
while (true) {
@breakpoint();
lib/std/c.zig
@@ -1,5 +1,5 @@
const std = @import("std");
-const builtin = std.builtin;
+const builtin = @import("builtin");
const c = @This();
const page_size = std.mem.page_size;
const iovec = std.os.iovec;
@@ -20,7 +20,7 @@ pub const Tokenizer = tokenizer.Tokenizer;
/// If linking gnu libc (glibc), the `ok` value will be true if the target
/// version is greater than or equal to `glibc_version`.
/// If linking a libc other than these, returns `false`.
-pub fn versionCheck(glibc_version: builtin.Version) type {
+pub fn versionCheck(glibc_version: std.builtin.Version) type {
return struct {
pub const ok = blk: {
if (!builtin.link_libc) break :blk false;
lib/std/child_process.zig
@@ -1,4 +1,5 @@
const std = @import("std.zig");
+const builtin = @import("builtin");
const cstr = std.cstr;
const unicode = std.unicode;
const io = std.io;
@@ -12,8 +13,7 @@ const mem = std.mem;
const math = std.math;
const debug = std.debug;
const BufMap = std.BufMap;
-const builtin = std.builtin;
-const Os = builtin.Os;
+const Os = std.builtin.Os;
const TailQueue = std.TailQueue;
const maxInt = std.math.maxInt;
const assert = std.debug.assert;
@@ -561,9 +561,9 @@ pub const ChildProcess = struct {
if (self.env_map) |env_map| {
const envp_buf = try createNullDelimitedEnvMap(arena, env_map);
break :m envp_buf.ptr;
- } else if (std.builtin.link_libc) {
+ } else if (builtin.link_libc) {
break :m std.c.environ;
- } else if (std.builtin.output_mode == .Exe) {
+ } else if (builtin.output_mode == .Exe) {
// Then we have Zig start code and this works.
// TODO type-safety for null-termination of `os.environ`.
break :m @ptrCast([*:null]?[*:0]u8, os.environ.ptr);
lib/std/coff.zig
@@ -1,4 +1,3 @@
-const builtin = std.builtin;
const std = @import("std.zig");
const io = std.io;
const mem = std.mem;
lib/std/crypto.zig
@@ -163,7 +163,7 @@ const std = @import("std.zig");
pub const errors = @import("crypto/errors.zig");
test "crypto" {
- const please_windows_dont_oom = std.Target.current.os.tag == .windows;
+ const please_windows_dont_oom = @import("builtin").os.tag == .windows;
if (please_windows_dont_oom) return error.SkipZigTest;
inline for (std.meta.declarations(@This())) |decl| {
lib/std/cstr.zig
@@ -1,5 +1,5 @@
const std = @import("std.zig");
-const builtin = std.builtin;
+const builtin = @import("builtin");
const debug = std.debug;
const mem = std.mem;
const testing = std.testing;
lib/std/debug.zig
@@ -1,5 +1,5 @@
const std = @import("std.zig");
-const builtin = std.builtin;
+const builtin = @import("builtin");
const math = std.math;
const mem = std.mem;
const io = std.io;
@@ -16,8 +16,8 @@ const root = @import("root");
const maxInt = std.math.maxInt;
const File = std.fs.File;
const windows = std.os.windows;
-const native_arch = std.Target.current.cpu.arch;
-const native_os = std.Target.current.os.tag;
+const native_arch = builtin.cpu.arch;
+const native_os = builtin.os.tag;
const native_endian = native_arch.endian();
pub const runtime_safety = switch (builtin.mode) {
@@ -150,7 +150,7 @@ pub fn dumpStackTraceFromBase(bp: usize, ip: usize) void {
/// capture that many stack frames exactly, and then look for the first address,
/// chopping off the irrelevant frames and shifting so that the returned addresses pointer
/// equals the passed in addresses pointer.
-pub fn captureStackTrace(first_address: ?usize, stack_trace: *builtin.StackTrace) void {
+pub fn captureStackTrace(first_address: ?usize, stack_trace: *std.builtin.StackTrace) void {
if (native_os == .windows) {
const addrs = stack_trace.instruction_addresses;
const u32_addrs_len = @intCast(u32, addrs.len);
@@ -194,7 +194,7 @@ pub fn captureStackTrace(first_address: ?usize, stack_trace: *builtin.StackTrace
/// Tries to print a stack trace to stderr, unbuffered, and ignores any error returned.
/// TODO multithreaded awareness
-pub fn dumpStackTrace(stack_trace: builtin.StackTrace) void {
+pub fn dumpStackTrace(stack_trace: std.builtin.StackTrace) void {
nosuspend {
const stderr = io.getStdErr().writer();
if (builtin.strip_debug_info) {
@@ -235,7 +235,7 @@ pub fn panic(comptime format: []const u8, args: anytype) noreturn {
/// `panicExtra` is useful when you want to print out an `@errorReturnTrace`
/// and also print out some values.
pub fn panicExtra(
- trace: ?*builtin.StackTrace,
+ trace: ?*std.builtin.StackTrace,
comptime format: []const u8,
args: anytype,
) noreturn {
@@ -253,7 +253,7 @@ pub fn panicExtra(
break :blk &buf;
},
};
- builtin.panic(msg, trace);
+ std.builtin.panic(msg, trace);
}
/// Non-zero whenever the program triggered a panic.
@@ -269,7 +269,7 @@ threadlocal var panic_stage: usize = 0;
// `panicImpl` could be useful in implementing a custom panic handler which
// calls the default handler (on supported platforms)
-pub fn panicImpl(trace: ?*const builtin.StackTrace, first_trace_addr: ?usize, msg: []const u8) noreturn {
+pub fn panicImpl(trace: ?*const std.builtin.StackTrace, first_trace_addr: ?usize, msg: []const u8) noreturn {
@setCold(true);
if (enable_segfault_handler) {
@@ -339,7 +339,7 @@ const DIM = "\x1b[2m";
const RESET = "\x1b[0m";
pub fn writeStackTrace(
- stack_trace: builtin.StackTrace,
+ stack_trace: std.builtin.StackTrace,
out_stream: anytype,
allocator: *mem.Allocator,
debug_info: *DebugInfo,
@@ -764,7 +764,7 @@ pub fn readElfDebugInfo(allocator: *mem.Allocator, elf_file: File) !ModuleDebugI
if (!mem.eql(u8, hdr.e_ident[0..4], "\x7fELF")) return error.InvalidElfMagic;
if (hdr.e_ident[elf.EI_VERSION] != 1) return error.InvalidElfVersion;
- const endian: builtin.Endian = switch (hdr.e_ident[elf.EI_DATA]) {
+ const endian: std.builtin.Endian = switch (hdr.e_ident[elf.EI_DATA]) {
elf.ELFDATA2LSB => .Little,
elf.ELFDATA2MSB => .Big,
else => return error.InvalidElfEndian,
@@ -1002,7 +1002,7 @@ pub const DebugInfo = struct {
}
pub fn getModuleForAddress(self: *DebugInfo, address: usize) !*ModuleDebugInfo {
- if (comptime std.Target.current.isDarwin()) {
+ if (comptime builtin.target.isDarwin()) {
return self.lookupModuleDyld(address);
} else if (native_os == .windows) {
return self.lookupModuleWin32(address);
lib/std/dwarf.zig
@@ -1,5 +1,4 @@
const std = @import("std.zig");
-const builtin = std.builtin;
const debug = std.debug;
const fs = std.fs;
const io = std.io;
@@ -454,7 +453,7 @@ const LineNumberProgram = struct {
}
};
-fn readUnitLength(in_stream: anytype, endian: builtin.Endian, is_64: *bool) !u64 {
+fn readUnitLength(in_stream: anytype, endian: std.builtin.Endian, is_64: *bool) !u64 {
const first_32_bits = try in_stream.readInt(u32, endian);
is_64.* = (first_32_bits == 0xffffffff);
if (is_64.*) {
@@ -475,7 +474,7 @@ fn readAllocBytes(allocator: *mem.Allocator, in_stream: anytype, size: usize) ![
}
// TODO the nosuspends here are workarounds
-fn readAddress(in_stream: anytype, endian: builtin.Endian, is_64: bool) !u64 {
+fn readAddress(in_stream: anytype, endian: std.builtin.Endian, is_64: bool) !u64 {
return nosuspend if (is_64)
try in_stream.readInt(u64, endian)
else
@@ -488,12 +487,12 @@ fn parseFormValueBlockLen(allocator: *mem.Allocator, in_stream: anytype, size: u
}
// TODO the nosuspends here are workarounds
-fn parseFormValueBlock(allocator: *mem.Allocator, in_stream: anytype, endian: builtin.Endian, size: usize) !FormValue {
+fn parseFormValueBlock(allocator: *mem.Allocator, in_stream: anytype, endian: std.builtin.Endian, size: usize) !FormValue {
const block_len = try nosuspend in_stream.readVarInt(usize, endian, size);
return parseFormValueBlockLen(allocator, in_stream, block_len);
}
-fn parseFormValueConstant(allocator: *mem.Allocator, in_stream: anytype, signed: bool, endian: builtin.Endian, comptime size: i32) !FormValue {
+fn parseFormValueConstant(allocator: *mem.Allocator, in_stream: anytype, signed: bool, endian: std.builtin.Endian, comptime size: i32) !FormValue {
_ = allocator;
// TODO: Please forgive me, I've worked around zig not properly spilling some intermediate values here.
// `nosuspend` should be removed from all the function calls once it is fixed.
@@ -521,7 +520,7 @@ fn parseFormValueConstant(allocator: *mem.Allocator, in_stream: anytype, signed:
}
// TODO the nosuspends here are workarounds
-fn parseFormValueRef(allocator: *mem.Allocator, in_stream: anytype, endian: builtin.Endian, size: i32) !FormValue {
+fn parseFormValueRef(allocator: *mem.Allocator, in_stream: anytype, endian: std.builtin.Endian, size: i32) !FormValue {
_ = allocator;
return FormValue{
.Ref = switch (size) {
@@ -536,7 +535,7 @@ fn parseFormValueRef(allocator: *mem.Allocator, in_stream: anytype, endian: buil
}
// TODO the nosuspends here are workarounds
-fn parseFormValue(allocator: *mem.Allocator, in_stream: anytype, form_id: u64, endian: builtin.Endian, is_64: bool) anyerror!FormValue {
+fn parseFormValue(allocator: *mem.Allocator, in_stream: anytype, form_id: u64, endian: std.builtin.Endian, is_64: bool) anyerror!FormValue {
return switch (form_id) {
FORM.addr => FormValue{ .Address = try readAddress(in_stream, endian, @sizeOf(usize) == 8) },
FORM.block1 => parseFormValueBlock(allocator, in_stream, endian, 1),
@@ -593,7 +592,7 @@ fn getAbbrevTableEntry(abbrev_table: *const AbbrevTable, abbrev_code: u64) ?*con
}
pub const DwarfInfo = struct {
- endian: builtin.Endian,
+ endian: std.builtin.Endian,
// No memory is owned by the DwarfInfo
debug_info: []const u8,
debug_abbrev: []const u8,
lib/std/dynamic_library.zig
@@ -1,6 +1,5 @@
-const builtin = std.builtin;
-
const std = @import("std.zig");
+const builtin = @import("builtin");
const mem = std.mem;
const os = std.os;
const assert = std.debug.assert;
lib/std/fs.zig
@@ -1,6 +1,6 @@
-const root = @import("root");
-const builtin = std.builtin;
const std = @import("std.zig");
+const builtin = @import("builtin");
+const root = @import("root");
const os = std.os;
const mem = std.mem;
const base64 = std.base64;
@@ -9,7 +9,7 @@ const Allocator = std.mem.Allocator;
const assert = std.debug.assert;
const math = std.math;
-const is_darwin = std.Target.current.os.tag.isDarwin();
+const is_darwin = builtin.os.tag.isDarwin();
pub const path = @import("fs/path.zig");
pub const File = @import("fs/file.zig").File;
@@ -2607,7 +2607,7 @@ const CopyFileError = error{SystemResources} || os.CopyFileRangeError || os.Send
// The copy starts at offset 0, the initial offsets are preserved.
// No metadata is transferred over.
fn copy_file(fd_in: os.fd_t, fd_out: os.fd_t) CopyFileError!void {
- if (comptime std.Target.current.isDarwin()) {
+ if (comptime builtin.target.isDarwin()) {
const rc = os.system.fcopyfile(fd_in, fd_out, null, os.system.COPYFILE_DATA);
switch (os.errno(rc)) {
.SUCCESS => return,
@@ -2620,7 +2620,7 @@ fn copy_file(fd_in: os.fd_t, fd_out: os.fd_t) CopyFileError!void {
}
}
- if (std.Target.current.os.tag == .linux) {
+ if (builtin.os.tag == .linux) {
// Try copy_file_range first as that works at the FS level and is the
// most efficient method (if available).
var offset: u64 = 0;
lib/std/heap.zig
@@ -1,11 +1,11 @@
const std = @import("std.zig");
+const builtin = @import("builtin");
const root = @import("root");
const debug = std.debug;
const assert = debug.assert;
const testing = std.testing;
const mem = std.mem;
const os = std.os;
-const builtin = std.builtin;
const c = std.c;
const maxInt = std.math.maxInt;
@@ -209,9 +209,9 @@ fn rawCResize(
/// This allocator makes a syscall directly for every allocation and free.
/// Thread-safe and lock-free.
-pub const page_allocator = if (std.Target.current.isWasm())
+pub const page_allocator = if (builtin.target.isWasm())
&wasm_page_allocator_state
-else if (std.Target.current.os.tag == .freestanding)
+else if (builtin.target.os.tag == .freestanding)
root.os.heap.page_allocator
else
&page_allocator_state;
@@ -402,7 +402,7 @@ const PageAllocator = struct {
const WasmPageAllocator = struct {
comptime {
- if (!std.Target.current.isWasm()) {
+ if (!builtin.target.isWasm()) {
@compileError("WasmPageAllocator is only available for wasm32 arch");
}
}
@@ -608,11 +608,11 @@ pub const HeapAllocator = switch (builtin.os.tag) {
const self = @fieldParentPtr(HeapAllocator, "allocator", allocator);
const amt = n + ptr_align - 1 + @sizeOf(usize);
- const optional_heap_handle = @atomicLoad(?HeapHandle, &self.heap_handle, builtin.AtomicOrder.SeqCst);
+ const optional_heap_handle = @atomicLoad(?HeapHandle, &self.heap_handle, .SeqCst);
const heap_handle = optional_heap_handle orelse blk: {
const options = if (builtin.single_threaded) os.windows.HEAP_NO_SERIALIZE else 0;
const hh = os.windows.kernel32.HeapCreate(options, amt, 0) orelse return error.OutOfMemory;
- const other_hh = @cmpxchgStrong(?HeapHandle, &self.heap_handle, null, hh, builtin.AtomicOrder.SeqCst, builtin.AtomicOrder.SeqCst) orelse break :blk hh;
+ const other_hh = @cmpxchgStrong(?HeapHandle, &self.heap_handle, null, hh, .SeqCst, .SeqCst) orelse break :blk hh;
os.windows.HeapDestroy(hh);
break :blk other_hh.?; // can't be null because of the cmpxchg
};
@@ -792,7 +792,7 @@ pub const ThreadSafeFixedBufferAllocator = blk: {
_ = len_align;
_ = ra;
const self = @fieldParentPtr(ThreadSafeFixedBufferAllocator, "allocator", allocator);
- var end_index = @atomicLoad(usize, &self.end_index, builtin.AtomicOrder.SeqCst);
+ var end_index = @atomicLoad(usize, &self.end_index, .SeqCst);
while (true) {
const adjust_off = mem.alignPointerOffset(self.buffer.ptr + end_index, ptr_align) orelse
return error.OutOfMemory;
@@ -801,7 +801,7 @@ pub const ThreadSafeFixedBufferAllocator = blk: {
if (new_end_index > self.buffer.len) {
return error.OutOfMemory;
}
- end_index = @cmpxchgWeak(usize, &self.end_index, end_index, new_end_index, builtin.AtomicOrder.SeqCst, builtin.AtomicOrder.SeqCst) orelse return self.buffer[adjusted_index..new_end_index];
+ end_index = @cmpxchgWeak(usize, &self.end_index, end_index, new_end_index, .SeqCst, .SeqCst) orelse return self.buffer[adjusted_index..new_end_index];
}
}
@@ -884,7 +884,7 @@ test "raw_c_allocator" {
}
test "WasmPageAllocator internals" {
- if (comptime std.Target.current.isWasm()) {
+ if (comptime builtin.target.isWasm()) {
const conventional_memsize = WasmPageAllocator.conventional.totalPages() * mem.page_size;
const initial = try page_allocator.alloc(u8, mem.page_size);
try testing.expect(@ptrToInt(initial.ptr) < conventional_memsize); // If this isn't conventional, the rest of these tests don't make sense. Also we have a serious memory leak in the test suite.
@@ -924,7 +924,7 @@ test "PageAllocator" {
const allocator = page_allocator;
try testAllocator(allocator);
try testAllocatorAligned(allocator);
- if (!std.Target.current.isWasm()) {
+ if (!builtin.target.isWasm()) {
try testAllocatorLargeAlignment(allocator);
try testAllocatorAlignedShrink(allocator);
}
lib/std/io.zig
@@ -1,5 +1,5 @@
const std = @import("std.zig");
-const builtin = std.builtin;
+const builtin = @import("builtin");
const root = @import("root");
const c = std.c;
lib/std/log.zig
@@ -69,7 +69,7 @@
//! ```
const std = @import("std.zig");
-const builtin = std.builtin;
+const builtin = @import("builtin");
const root = @import("root");
pub const Level = enum {
@@ -170,7 +170,7 @@ pub fn defaultLog(
comptime format: []const u8,
args: anytype,
) void {
- if (std.Target.current.os.tag == .freestanding) {
+ if (builtin.os.tag == .freestanding) {
// On freestanding one must provide a log function; we do not have
// any I/O configured.
return;
lib/std/mem.zig
@@ -1,4 +1,5 @@
const std = @import("std.zig");
+const builtin = @import("builtin");
const debug = std.debug;
const assert = debug.assert;
const math = std.math;
@@ -7,13 +8,13 @@ const meta = std.meta;
const trait = meta.trait;
const testing = std.testing;
const Endian = std.builtin.Endian;
-const native_endian = std.Target.current.cpu.arch.endian();
+const native_endian = builtin.cpu.arch.endian();
/// Compile time known minimum page size.
/// https://github.com/ziglang/zig/issues/4082
-pub const page_size = switch (std.Target.current.cpu.arch) {
+pub const page_size = switch (builtin.cpu.arch) {
.wasm32, .wasm64 => 64 * 1024,
- .aarch64 => switch (std.Target.current.os.tag) {
+ .aarch64 => switch (builtin.os.tag) {
.macos, .ios, .watchos, .tvos => 16 * 1024,
else => 4 * 1024,
},
lib/std/meta.zig
@@ -1,5 +1,4 @@
const std = @import("std.zig");
-const builtin = std.builtin;
const debug = std.debug;
const mem = std.mem;
const math = std.math;
@@ -9,7 +8,7 @@ const root = @import("root");
pub const trait = @import("meta/trait.zig");
pub const TrailerFlags = @import("meta/trailer_flags.zig").TrailerFlags;
-const TypeInfo = builtin.TypeInfo;
+const TypeInfo = std.builtin.TypeInfo;
pub fn tagName(v: anytype) []const u8 {
const T = @TypeOf(v);
@@ -858,7 +857,7 @@ pub fn declList(comptime Namespace: type, comptime Decl: type) []const *const De
pub const IntType = @compileError("replaced by std.meta.Int");
-pub fn Int(comptime signedness: builtin.Signedness, comptime bit_count: u16) type {
+pub fn Int(comptime signedness: std.builtin.Signedness, comptime bit_count: u16) type {
return @Type(TypeInfo{
.Int = .{
.signedness = signedness,
lib/std/net.zig
@@ -12,7 +12,7 @@ const native_endian = builtin.target.cpu.arch.endian();
// first release to support them.
pub const has_unix_sockets = @hasDecl(os.sockaddr, "un") and
(builtin.target.os.tag != .windows or
- std.Target.current.os.version_range.windows.isAtLeast(.win10_rs4) orelse false);
+ builtin.os.version_range.windows.isAtLeast(.win10_rs4) orelse false);
pub const Address = extern union {
any: os.sockaddr,
@@ -1623,7 +1623,7 @@ pub const Stream = struct {
}
pub fn read(self: Stream, buffer: []u8) ReadError!usize {
- if (std.Target.current.os.tag == .windows) {
+ if (builtin.os.tag == .windows) {
return os.windows.ReadFile(self.handle, buffer, null, io.default_mode);
}
@@ -1638,7 +1638,7 @@ pub const Stream = struct {
/// file system thread instead of non-blocking. It needs to be reworked to properly
/// use non-blocking I/O.
pub fn write(self: Stream, buffer: []const u8) WriteError!usize {
- if (std.Target.current.os.tag == .windows) {
+ if (builtin.os.tag == .windows) {
return os.windows.WriteFile(self.handle, buffer, null, io.default_mode);
}
lib/std/once.zig
@@ -1,5 +1,5 @@
const std = @import("std.zig");
-const builtin = std.builtin;
+const builtin = @import("builtin");
const testing = std.testing;
pub fn once(comptime f: fn () void) Once(f) {
lib/std/os.zig
@@ -240,7 +240,7 @@ pub fn close(fd: fd_t) void {
_ = wasi.fd_close(fd);
return;
}
- if (comptime std.Target.current.isDarwin()) {
+ if (comptime builtin.target.isDarwin()) {
// This avoids the EINTR problem.
switch (darwin.getErrno(darwin.@"close$NOCANCEL"(fd))) {
.BADF => unreachable, // Always a race condition.
@@ -487,7 +487,7 @@ pub fn read(fd: fd_t, buf: []u8) ReadError!usize {
}
// Prevents EINVAL.
- const max_count = switch (std.Target.current.os.tag) {
+ const max_count = switch (builtin.os.tag) {
.linux => 0x7ffff000,
.macos, .ios, .watchos, .tvos => math.maxInt(i32),
else => math.maxInt(isize),
@@ -525,7 +525,7 @@ pub fn read(fd: fd_t, buf: []u8) ReadError!usize {
/// * Windows
/// On these systems, the read races with concurrent writes to the same file descriptor.
pub fn readv(fd: fd_t, iov: []const iovec) ReadError!usize {
- if (std.Target.current.os.tag == .windows) {
+ if (builtin.os.tag == .windows) {
// TODO improve this to use ReadFileScatter
if (iov.len == 0) return @as(usize, 0);
const first = iov[0];
@@ -616,7 +616,7 @@ pub fn pread(fd: fd_t, buf: []u8, offset: u64) PReadError!usize {
}
// Prevent EINVAL.
- const max_count = switch (std.Target.current.os.tag) {
+ const max_count = switch (builtin.os.tag) {
.linux => 0x7ffff000,
.macos, .ios, .watchos, .tvos => math.maxInt(i32),
else => math.maxInt(isize),
@@ -662,7 +662,7 @@ pub const TruncateError = error{
} || UnexpectedError;
pub fn ftruncate(fd: fd_t, length: u64) TruncateError!void {
- if (std.Target.current.os.tag == .windows) {
+ if (builtin.os.tag == .windows) {
var io_status_block: windows.IO_STATUS_BLOCK = undefined;
var eof_info = windows.FILE_END_OF_FILE_INFORMATION{
.EndOfFile = @bitCast(windows.LARGE_INTEGER, length),
@@ -683,7 +683,7 @@ pub fn ftruncate(fd: fd_t, length: u64) TruncateError!void {
else => return windows.unexpectedStatus(rc),
}
}
- if (std.Target.current.os.tag == .wasi and !builtin.link_libc) {
+ if (builtin.os.tag == .wasi and !builtin.link_libc) {
switch (wasi.fd_filestat_set_size(fd, length)) {
.SUCCESS => return,
.INTR => unreachable,
@@ -733,7 +733,7 @@ pub fn ftruncate(fd: fd_t, length: u64) TruncateError!void {
/// * Windows
/// On these systems, the read races with concurrent writes to the same file descriptor.
pub fn preadv(fd: fd_t, iov: []const iovec, offset: u64) PReadError!usize {
- const have_pread_but_not_preadv = switch (std.Target.current.os.tag) {
+ const have_pread_but_not_preadv = switch (builtin.os.tag) {
.windows, .macos, .ios, .watchos, .tvos, .haiku => true,
else => false,
};
@@ -868,7 +868,7 @@ pub fn write(fd: fd_t, bytes: []const u8) WriteError!usize {
}
}
- const max_count = switch (std.Target.current.os.tag) {
+ const max_count = switch (builtin.os.tag) {
.linux => 0x7ffff000,
.macos, .ios, .watchos, .tvos => math.maxInt(i32),
else => math.maxInt(isize),
@@ -916,7 +916,7 @@ pub fn write(fd: fd_t, bytes: []const u8) WriteError!usize {
///
/// If `iov.len` is larger than `IOV_MAX`, a partial write will occur.
pub fn writev(fd: fd_t, iov: []const iovec_const) WriteError!usize {
- if (std.Target.current.os.tag == .windows) {
+ if (builtin.os.tag == .windows) {
// TODO improve this to use WriteFileScatter
if (iov.len == 0) return @as(usize, 0);
const first = iov[0];
@@ -991,7 +991,7 @@ pub const PWriteError = WriteError || error{Unseekable};
/// The limit on Darwin is `0x7fffffff`, trying to write more than that returns EINVAL.
/// The corresponding POSIX limit is `math.maxInt(isize)`.
pub fn pwrite(fd: fd_t, bytes: []const u8, offset: u64) PWriteError!usize {
- if (std.Target.current.os.tag == .windows) {
+ if (builtin.os.tag == .windows) {
return windows.WriteFile(fd, bytes, offset, std.io.default_mode);
}
if (builtin.os.tag == .wasi and !builtin.link_libc) {
@@ -1024,7 +1024,7 @@ pub fn pwrite(fd: fd_t, bytes: []const u8, offset: u64) PWriteError!usize {
}
// Prevent EINVAL.
- const max_count = switch (std.Target.current.os.tag) {
+ const max_count = switch (builtin.os.tag) {
.linux => 0x7ffff000,
.macos, .ios, .watchos, .tvos => math.maxInt(i32),
else => math.maxInt(isize),
@@ -1083,7 +1083,7 @@ pub fn pwrite(fd: fd_t, bytes: []const u8, offset: u64) PWriteError!usize {
///
/// If `iov.len` is larger than `IOV_MAX`, a partial write will occur.
pub fn pwritev(fd: fd_t, iov: []const iovec_const, offset: u64) PWriteError!usize {
- const have_pwrite_but_not_pwritev = switch (std.Target.current.os.tag) {
+ const have_pwrite_but_not_pwritev = switch (builtin.os.tag) {
.windows, .macos, .ios, .watchos, .tvos, .haiku => true,
else => false,
};
@@ -1199,7 +1199,7 @@ pub const OpenError = error{
/// Open and possibly create a file. Keeps trying if it gets interrupted.
/// See also `openZ`.
pub fn open(file_path: []const u8, flags: u32, perm: mode_t) OpenError!fd_t {
- if (std.Target.current.os.tag == .windows) {
+ if (builtin.os.tag == .windows) {
const file_path_w = try windows.sliceToPrefixedFileW(file_path);
return openW(file_path_w.span(), flags, perm);
}
@@ -1212,7 +1212,7 @@ pub const openC = @compileError("deprecated: renamed to openZ");
/// Open and possibly create a file. Keeps trying if it gets interrupted.
/// See also `open`.
pub fn openZ(file_path: [*:0]const u8, flags: u32, perm: mode_t) OpenError!fd_t {
- if (std.Target.current.os.tag == .windows) {
+ if (builtin.os.tag == .windows) {
const file_path_w = try windows.cStrToPrefixedFileW(file_path);
return openW(file_path_w.span(), flags, perm);
}
@@ -2900,7 +2900,7 @@ pub fn socket(domain: u32, socket_type: u32, protocol: u32) SocketError!socket_t
return rc;
}
- const have_sock_flags = comptime !std.Target.current.isDarwin();
+ const have_sock_flags = comptime !builtin.target.isDarwin();
const filtered_sock_type = if (!have_sock_flags)
socket_type & ~@as(u32, SOCK.NONBLOCK | SOCK.CLOEXEC)
else
@@ -3199,7 +3199,7 @@ pub fn accept(
/// description of the `O.CLOEXEC` flag in `open` for reasons why this may be useful.
flags: u32,
) AcceptError!socket_t {
- const have_accept4 = comptime !(std.Target.current.isDarwin() or builtin.os.tag == .windows);
+ const have_accept4 = comptime !(builtin.target.isDarwin() or builtin.os.tag == .windows);
assert(0 == (flags & ~@as(u32, SOCK.NONBLOCK | SOCK.CLOEXEC))); // Unsupported flag(s)
const accepted_sock = while (true) {
@@ -4807,7 +4807,7 @@ pub const ClockGetTimeError = error{UnsupportedClock} || UnexpectedError;
/// TODO: change this to return the timespec as a return value
/// TODO: look into making clk_id an enum
pub fn clock_gettime(clk_id: i32, tp: *timespec) ClockGetTimeError!void {
- if (std.Target.current.os.tag == .wasi and !builtin.link_libc) {
+ if (builtin.os.tag == .wasi and !builtin.link_libc) {
var ts: timestamp_t = undefined;
switch (system.clock_time_get(@bitCast(u32, clk_id), 1, &ts)) {
.SUCCESS => {
@@ -4821,7 +4821,7 @@ pub fn clock_gettime(clk_id: i32, tp: *timespec) ClockGetTimeError!void {
}
return;
}
- if (std.Target.current.os.tag == .windows) {
+ if (builtin.os.tag == .windows) {
if (clk_id == CLOCK.REALTIME) {
var ft: windows.FILETIME = undefined;
windows.kernel32.GetSystemTimeAsFileTime(&ft);
@@ -4848,7 +4848,7 @@ pub fn clock_gettime(clk_id: i32, tp: *timespec) ClockGetTimeError!void {
}
pub fn clock_getres(clk_id: i32, res: *timespec) ClockGetTimeError!void {
- if (std.Target.current.os.tag == .wasi and !builtin.link_libc) {
+ if (builtin.os.tag == .wasi and !builtin.link_libc) {
var ts: timestamp_t = undefined;
switch (system.clock_res_get(@bitCast(u32, clk_id), &ts)) {
.SUCCESS => res.* = .{
@@ -5416,19 +5416,19 @@ pub fn sendfile(
// Prevents EOVERFLOW.
const size_t = std.meta.Int(.unsigned, @typeInfo(usize).Int.bits - 1);
- const max_count = switch (std.Target.current.os.tag) {
+ const max_count = switch (builtin.os.tag) {
.linux => 0x7ffff000,
.macos, .ios, .watchos, .tvos => math.maxInt(i32),
else => math.maxInt(size_t),
};
- switch (std.Target.current.os.tag) {
+ switch (builtin.os.tag) {
.linux => sf: {
// sendfile() first appeared in Linux 2.2, glibc 2.1.
const call_sf = comptime if (builtin.link_libc)
std.c.versionCheck(.{ .major = 2, .minor = 1 }).ok
else
- std.Target.current.os.version_range.linux.range.max.order(.{ .major = 2, .minor = 2 }) != .lt;
+ builtin.os.version_range.linux.range.max.order(.{ .major = 2, .minor = 2 }) != .lt;
if (!call_sf) break :sf;
if (headers.len != 0) {
@@ -5719,13 +5719,13 @@ var has_copy_file_range_syscall = std.atomic.Atomic(bool).init(true);
///
/// Maximum offsets on Linux are `math.maxInt(i64)`.
pub fn copy_file_range(fd_in: fd_t, off_in: u64, fd_out: fd_t, off_out: u64, len: usize, flags: u32) CopyFileRangeError!usize {
- const call_cfr = comptime if (std.Target.current.os.tag == .wasi)
+ const call_cfr = comptime if (builtin.os.tag == .wasi)
// WASI-libc doesn't have copy_file_range.
false
else if (builtin.link_libc)
std.c.versionCheck(.{ .major = 2, .minor = 27, .patch = 0 }).ok
else
- std.Target.current.os.isAtLeast(.linux, .{ .major = 4, .minor = 5 }) orelse true;
+ builtin.os.isAtLeast(.linux, .{ .major = 4, .minor = 5 }) orelse true;
if (call_cfr and has_copy_file_range_syscall.load(.Monotonic)) {
var off_in_copy = @bitCast(i64, off_in);
@@ -6179,7 +6179,7 @@ pub fn syncfs(fd: fd_t) SyncError!void {
/// Write all pending file contents and metadata modifications for the specified file descriptor to the underlying filesystem.
pub fn fsync(fd: fd_t) SyncError!void {
- if (std.Target.current.os.tag == .windows) {
+ if (builtin.os.tag == .windows) {
if (windows.kernel32.FlushFileBuffers(fd) != 0)
return;
switch (windows.kernel32.GetLastError()) {
@@ -6203,7 +6203,7 @@ pub fn fsync(fd: fd_t) SyncError!void {
/// Write all pending file contents for the specified file descriptor to the underlying filesystem, but not necessarily the metadata.
pub fn fdatasync(fd: fd_t) SyncError!void {
- if (std.Target.current.os.tag == .windows) {
+ if (builtin.os.tag == .windows) {
return fsync(fd) catch |err| switch (err) {
SyncError.AccessDenied => return, // fdatasync doesn't promise that the access time was synced
else => return err,
lib/std/pdb.zig
@@ -1,4 +1,3 @@
-const builtin = std.builtin;
const std = @import("std.zig");
const io = std.io;
const math = std.math;
lib/std/process.zig
@@ -1,5 +1,5 @@
const std = @import("std.zig");
-const builtin = std.builtin;
+const builtin = @import("builtin");
const os = std.os;
const fs = std.fs;
const BufMap = std.BufMap;
@@ -863,9 +863,9 @@ pub fn execve(
if (env_map) |m| {
const envp_buf = try child_process.createNullDelimitedEnvMap(arena, m);
break :m envp_buf.ptr;
- } else if (std.builtin.link_libc) {
+ } else if (builtin.link_libc) {
break :m std.c.environ;
- } else if (std.builtin.output_mode == .Exe) {
+ } else if (builtin.output_mode == .Exe) {
// Then we have Zig start code and this works.
// TODO type-safety for null-termination of `os.environ`.
break :m @ptrCast([*:null]?[*:0]u8, os.environ.ptr);
lib/std/Progress.zig
@@ -7,6 +7,7 @@
//! * `initial_delay_ms`
const std = @import("std");
+const builtin = @import("builtin");
const windows = std.os.windows;
const testing = std.testing;
const assert = std.debug.assert;
@@ -144,10 +145,10 @@ pub fn start(self: *Progress, name: []const u8, estimated_total_items: usize) !*
if (stderr.supportsAnsiEscapeCodes()) {
self.terminal = stderr;
self.supports_ansi_escape_codes = true;
- } else if (std.builtin.os.tag == .windows and stderr.isTty()) {
+ } else if (builtin.os.tag == .windows and stderr.isTty()) {
self.is_windows_terminal = true;
self.terminal = stderr;
- } else if (std.builtin.os.tag != .windows) {
+ } else if (builtin.os.tag != .windows) {
// we are in a "dumb" terminal like in acme or writing to a file
self.terminal = stderr;
}
@@ -200,7 +201,7 @@ fn refreshWithHeldLock(self: *Progress) void {
if (self.supports_ansi_escape_codes) {
end += (std.fmt.bufPrint(self.output_buffer[end..], "\x1b[{d}D", .{self.columns_written}) catch unreachable).len;
end += (std.fmt.bufPrint(self.output_buffer[end..], "\x1b[0K", .{}) catch unreachable).len;
- } else if (std.builtin.os.tag == .windows) winapi: {
+ } else if (builtin.os.tag == .windows) winapi: {
std.debug.assert(self.is_windows_terminal);
var info: windows.CONSOLE_SCREEN_BUFFER_INFO = undefined;
lib/std/rand.zig
@@ -7,7 +7,6 @@
//! TODO(tiehuis): Benchmark these against other reference implementations.
const std = @import("std.zig");
-const builtin = std.builtin;
const assert = std.debug.assert;
const expect = std.testing.expect;
const expectEqual = std.testing.expectEqual;
lib/std/sort.zig
@@ -3,7 +3,6 @@ const assert = std.debug.assert;
const testing = std.testing;
const mem = std.mem;
const math = std.math;
-const builtin = std.builtin;
pub fn binarySearch(
comptime T: type,
lib/std/std.zig
@@ -95,7 +95,7 @@ comptime {
}
test {
- if (builtin.os.tag == .windows) {
+ if (@import("builtin").os.tag == .windows) {
// We only test the Windows-relevant stuff to save memory because the CI
// server is hitting OOM. TODO revert this after stage2 arrives.
_ = ChildProcess;
lib/std/target.zig
@@ -1,6 +1,5 @@
const std = @import("std.zig");
const mem = std.mem;
-const builtin = std.builtin;
const Version = std.builtin.Version;
/// TODO Nearly all the functions in this namespace would be
@@ -1017,7 +1016,7 @@ pub const Target = struct {
};
}
- pub fn endian(arch: Arch) builtin.Endian {
+ pub fn endian(arch: Arch) std.builtin.Endian {
return switch (arch) {
.avr,
.arm,
@@ -1302,7 +1301,8 @@ pub const Target = struct {
}
};
- pub const current = builtin.target;
+ /// TODO delete this deprecated declaration after 0.9.0 is released
+ pub const current = @compileError("instead of std.Target.current, use @import(\"builtin\").target");
pub const stack_align = 16;
lib/std/testing.zig
@@ -1,4 +1,5 @@
const std = @import("std.zig");
+const builtin = @import("builtin");
const math = std.math;
const print = std.debug.print;
@@ -322,7 +323,7 @@ pub const TmpDir = struct {
};
fn getCwdOrWasiPreopen() std.fs.Dir {
- if (std.builtin.os.tag == .wasi and !std.builtin.link_libc) {
+ if (builtin.os.tag == .wasi and !builtin.link_libc) {
var preopens = std.fs.wasi.PreopenList.init(allocator);
defer preopens.deinit();
preopens.populate() catch
@@ -464,7 +465,7 @@ test {
/// Given a type, reference all the declarations inside, so that the semantic analyzer sees them.
pub fn refAllDecls(comptime T: type) void {
- if (!std.builtin.is_test) return;
+ if (!builtin.is_test) return;
inline for (std.meta.declarations(T)) |decl| {
_ = decl;
}
lib/std/time.zig
@@ -1,10 +1,10 @@
const std = @import("std.zig");
-const builtin = std.builtin;
+const builtin = @import("builtin");
const assert = std.debug.assert;
const testing = std.testing;
const os = std.os;
const math = std.math;
-const is_windows = std.Target.current.os.tag == .windows;
+const is_windows = builtin.os.tag == .windows;
pub const epoch = @import("time/epoch.zig");
@@ -173,7 +173,7 @@ pub const Timer = struct {
.resolution = @divFloor(ns_per_s, freq),
.start_time = os.windows.QueryPerformanceCounter(),
};
- } else if (comptime std.Target.current.isDarwin()) {
+ } else if (comptime builtin.target.isDarwin()) {
var freq: os.darwin.mach_timebase_info_data = undefined;
os.darwin.mach_timebase_info(&freq);
@@ -225,7 +225,7 @@ pub const Timer = struct {
if (is_windows) {
return os.windows.QueryPerformanceCounter();
}
- if (comptime std.Target.current.isDarwin()) {
+ if (comptime builtin.target.isDarwin()) {
return os.darwin.mach_absolute_time();
}
var ts: os.timespec = undefined;
@@ -237,7 +237,7 @@ pub const Timer = struct {
if (is_windows) {
return safeMulDiv(duration, ns_per_s, self.frequency);
}
- if (comptime std.Target.current.isDarwin()) {
+ if (comptime builtin.target.isDarwin()) {
return safeMulDiv(duration, self.frequency.numer, self.frequency.denom);
}
return duration;
lib/std/unicode.zig
@@ -1,5 +1,4 @@
const std = @import("./std.zig");
-const builtin = std.builtin;
const assert = std.debug.assert;
const testing = std.testing;
const mem = std.mem;
src/codegen/c.zig
@@ -1,4 +1,5 @@
const std = @import("std");
+const builtin = @import("builtin");
const assert = std.debug.assert;
const mem = std.mem;
const log = std.log.scoped(.c);
@@ -600,7 +601,7 @@ pub const DeclGen = struct {
);
},
.ErrorSet => {
- comptime std.debug.assert(Type.initTag(.anyerror).abiSize(std.Target.current) == 2);
+ comptime std.debug.assert(Type.initTag(.anyerror).abiSize(builtin.target) == 2);
try w.writeAll("uint16_t");
},
.ErrorUnion => {
src/link/MachO/fat.zig
@@ -1,5 +1,5 @@
const std = @import("std");
-const builtin = std.builtin;
+const builtin = @import("builtin");
const log = std.log.scoped(.archive);
const macho = std.macho;
const mem = std.mem;
@@ -23,7 +23,7 @@ fn readFatStruct(reader: anytype, comptime T: type) !T {
// Fat structures (fat_header & fat_arch) are always written and read to/from
// disk in big endian order.
var res = try reader.readStruct(T);
- if (native_endian != builtin.Endian.Big) {
+ if (native_endian != std.builtin.Endian.Big) {
mem.bswapAllFields(T, &res);
}
return res;
src/link/Elf.zig
@@ -755,7 +755,7 @@ pub fn flushModule(self: *Elf, comp: *Compilation) !void {
const module = self.base.options.module orelse return error.LinkingWithoutZigSourceUnimplemented;
const target_endian = self.base.options.target.cpu.arch.endian();
- const foreign_endian = target_endian != std.Target.current.cpu.arch.endian();
+ const foreign_endian = target_endian != builtin.cpu.arch.endian();
const ptr_width_bytes: u8 = self.ptrWidthBytes();
const init_len_size: usize = switch (self.ptr_width) {
.p32 => 4,
@@ -2827,7 +2827,7 @@ pub fn deleteExport(self: *Elf, exp: Export) void {
}
fn writeProgHeader(self: *Elf, index: usize) !void {
- const foreign_endian = self.base.options.target.cpu.arch.endian() != std.Target.current.cpu.arch.endian();
+ const foreign_endian = self.base.options.target.cpu.arch.endian() != builtin.cpu.arch.endian();
const offset = self.program_headers.items[index].p_offset;
switch (self.ptr_width) {
.p32 => {
@@ -2848,7 +2848,7 @@ fn writeProgHeader(self: *Elf, index: usize) !void {
}
fn writeSectHeader(self: *Elf, index: usize) !void {
- const foreign_endian = self.base.options.target.cpu.arch.endian() != std.Target.current.cpu.arch.endian();
+ const foreign_endian = self.base.options.target.cpu.arch.endian() != builtin.cpu.arch.endian();
switch (self.ptr_width) {
.p32 => {
var shdr: [1]elf.Elf32_Shdr = undefined;
@@ -2946,7 +2946,7 @@ fn writeSymbol(self: *Elf, index: usize) !void {
syms_sect.sh_size = needed_size; // anticipating adding the global symbols later
self.shdr_table_dirty = true; // TODO look into only writing one section
}
- const foreign_endian = self.base.options.target.cpu.arch.endian() != std.Target.current.cpu.arch.endian();
+ const foreign_endian = self.base.options.target.cpu.arch.endian() != builtin.cpu.arch.endian();
switch (self.ptr_width) {
.p32 => {
var sym = [1]elf.Elf32_Sym{
@@ -2982,7 +2982,7 @@ fn writeAllGlobalSymbols(self: *Elf) !void {
.p32 => @sizeOf(elf.Elf32_Sym),
.p64 => @sizeOf(elf.Elf64_Sym),
};
- const foreign_endian = self.base.options.target.cpu.arch.endian() != std.Target.current.cpu.arch.endian();
+ const foreign_endian = self.base.options.target.cpu.arch.endian() != builtin.cpu.arch.endian();
const global_syms_off = syms_sect.sh_offset + self.local_symbols.items.len * sym_size;
switch (self.ptr_width) {
.p32 => {
src/link/MachO.zig
@@ -967,7 +967,7 @@ fn resolveSearchDir(
if (fs.path.isAbsolute(dir)) {
if (syslibroot) |root| {
- const common_dir = if (std.Target.current.os.tag == .windows) blk: {
+ const common_dir = if (builtin.os.tag == .windows) blk: {
// We need to check for disk designator and strip it out from dir path so
// that we can concat dir with syslibroot.
// TODO we should backport this mechanism to 'MachO.Dylib.parseDependentLibs()'
src/Air.zig
@@ -4,6 +4,7 @@
//! gets its own `Air` instance.
const std = @import("std");
+const builtin = @import("builtin");
const Value = @import("value.zig").Value;
const Type = @import("type.zig").Type;
const Module = @import("Module.zig");
@@ -484,7 +485,7 @@ pub const Inst = struct {
// bigger than expected. Note that in Debug builds, Zig is allowed
// to insert a secret field for safety checks.
comptime {
- if (std.builtin.mode != .Debug) {
+ if (builtin.mode != .Debug) {
assert(@sizeOf(Data) == 8);
}
}
src/Cache.zig
@@ -4,6 +4,7 @@ hash: HashHelper = .{},
const Cache = @This();
const std = @import("std");
+const builtin = @import("builtin");
const crypto = std.crypto;
const fs = std.fs;
const assert = std.debug.assert;
@@ -713,7 +714,7 @@ pub const Manifest = struct {
/// uses the file contents. Windows supports symlinks but only with elevated privileges, so
/// it is treated as not supporting symlinks.
pub fn readSmallFile(dir: fs.Dir, sub_path: []const u8, buffer: []u8) ![]u8 {
- if (std.Target.current.os.tag == .windows) {
+ if (builtin.os.tag == .windows) {
return dir.readFile(sub_path, buffer);
} else {
return dir.readLink(sub_path, buffer);
@@ -726,7 +727,7 @@ pub fn readSmallFile(dir: fs.Dir, sub_path: []const u8, buffer: []u8) ![]u8 {
/// `data` must be a valid UTF-8 encoded file path and 255 bytes or fewer.
pub fn writeSmallFile(dir: fs.Dir, sub_path: []const u8, data: []const u8) !void {
assert(data.len <= 255);
- if (std.Target.current.os.tag == .windows) {
+ if (builtin.os.tag == .windows) {
return dir.writeFile(sub_path, data);
} else {
return dir.symLink(data, sub_path, .{});
@@ -778,7 +779,7 @@ fn isProblematicTimestamp(fs_clock: i128) bool {
}
test "cache file and then recall it" {
- if (std.Target.current.os.tag == .wasi) {
+ if (builtin.os.tag == .wasi) {
// https://github.com/ziglang/zig/issues/5437
return error.SkipZigTest;
}
@@ -856,7 +857,7 @@ test "give nonproblematic timestamp" {
}
test "check that changing a file makes cache fail" {
- if (std.Target.current.os.tag == .wasi) {
+ if (builtin.os.tag == .wasi) {
// https://github.com/ziglang/zig/issues/5437
return error.SkipZigTest;
}
@@ -932,7 +933,7 @@ test "check that changing a file makes cache fail" {
}
test "no file inputs" {
- if (std.Target.current.os.tag == .wasi) {
+ if (builtin.os.tag == .wasi) {
// https://github.com/ziglang/zig/issues/5437
return error.SkipZigTest;
}
@@ -977,7 +978,7 @@ test "no file inputs" {
}
test "Manifest with files added after initial hash work" {
- if (std.Target.current.os.tag == .wasi) {
+ if (builtin.os.tag == .wasi) {
// https://github.com/ziglang/zig/issues/5437
return error.SkipZigTest;
}
src/codegen.zig
@@ -1,4 +1,5 @@
const std = @import("std");
+const builtin = @import("builtin");
const mem = std.mem;
const math = std.math;
const assert = std.debug.assert;
@@ -522,7 +523,7 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
code: *std.ArrayList(u8),
debug_output: DebugInfoOutput,
) GenerateSymbolError!FnResult {
- if (build_options.skip_non_native and std.Target.current.cpu.arch != arch) {
+ if (build_options.skip_non_native and builtin.cpu.arch != arch) {
@panic("Attempted to compile for architecture that was disabled by build configuration");
}
src/Compilation.zig
@@ -937,8 +937,8 @@ pub fn create(gpa: *Allocator, options: InitOptions) !*Compilation {
};
const darwin_can_use_system_sdk = blk: {
- if (comptime !std.Target.current.isDarwin()) break :blk false;
- break :blk std.builtin.os.tag == .macos and options.target.isDarwin();
+ if (comptime !builtin.target.isDarwin()) break :blk false;
+ break :blk builtin.os.tag == .macos and options.target.isDarwin();
};
const sysroot = blk: {
@@ -3582,7 +3582,7 @@ fn detectLibCIncludeDirs(
// native abi, fall back to using the system libc installation.
// On windows, instead of the native (mingw) abi, we want to check
// for the MSVC abi as a fallback.
- const use_system_abi = if (std.Target.current.os.tag == .windows)
+ const use_system_abi = if (builtin.target.os.tag == .windows)
target.abi == .msvc
else
is_native_abi;
src/introspect.zig
@@ -1,4 +1,5 @@
const std = @import("std");
+const builtin = @import("builtin");
const mem = std.mem;
const fs = std.fs;
const Compilation = @import("Compilation.zig");
@@ -71,7 +72,7 @@ pub fn resolveGlobalCacheDir(allocator: *mem.Allocator) ![]u8 {
const appname = "zig";
- if (std.Target.current.os.tag != .windows) {
+ if (builtin.os.tag != .windows) {
if (std.os.getenv("XDG_CACHE_HOME")) |cache_root| {
return fs.path.join(allocator, &[_][]const u8{ cache_root, appname });
} else if (std.os.getenv("HOME")) |home| {
src/libc_installation.zig
@@ -6,9 +6,9 @@ const Allocator = std.mem.Allocator;
const Batch = std.event.Batch;
const build_options = @import("build_options");
-const is_darwin = Target.current.isDarwin();
-const is_windows = Target.current.os.tag == .windows;
-const is_haiku = Target.current.os.tag == .haiku;
+const is_darwin = builtin.target.isDarwin();
+const is_windows = builtin.target.os.tag == .windows;
+const is_haiku = builtin.target.os.tag == .haiku;
const log = std.log.scoped(.libc_installation);
@@ -219,7 +219,7 @@ pub const LibCInstallation = struct {
var batch = Batch(FindError!void, 2, .auto_async).init();
errdefer batch.wait() catch {};
batch.add(&async self.findNativeIncludeDirPosix(args));
- switch (Target.current.os.tag) {
+ switch (builtin.target.os.tag) {
.freebsd, .netbsd, .openbsd, .dragonfly => self.crt_dir = try std.mem.dupeZ(args.allocator, u8, "/usr/lib"),
.solaris => self.crt_dir = try std.mem.dupeZ(args.allocator, u8, "/usr/lib/64"),
.linux => batch.add(&async self.findNativeCrtDirPosix(args)),
src/link.zig
@@ -292,7 +292,7 @@ pub const File = struct {
// make executable, so we don't have to close it.
return;
}
- if (comptime std.Target.current.isDarwin() and std.Target.current.cpu.arch == .aarch64) {
+ if (comptime builtin.target.isDarwin() and builtin.target.cpu.arch == .aarch64) {
if (base.options.target.cpu.arch != .aarch64) return; // If we're not targeting aarch64, nothing to do.
// XNU starting with Big Sur running on arm64 is caching inodes of running binaries.
// Any change to the binary will effectively invalidate the kernel's cache
@@ -711,7 +711,7 @@ pub fn determineMode(options: Options) fs.File.Mode {
// with 0o755 permissions, but it works appropriately if the system is configured
// more leniently. As another data point, C's fopen seems to open files with the
// 666 mode.
- const executable_mode = if (std.Target.current.os.tag == .windows) 0 else 0o777;
+ const executable_mode = if (builtin.target.os.tag == .windows) 0 else 0o777;
switch (options.effectiveOutputMode()) {
.Lib => return switch (options.link_mode) {
.Dynamic => executable_mode,
src/main.zig
@@ -1,4 +1,5 @@
const std = @import("std");
+const builtin = @import("builtin");
const assert = std.debug.assert;
const io = std.io;
const fs = std.fs;
@@ -34,7 +35,7 @@ pub fn fatal(comptime format: []const u8, args: anytype) noreturn {
/// be byte-indexed with a u32 integer.
pub const max_src_size = std.math.maxInt(u32);
-pub const debug_extensions_enabled = std.builtin.mode == .Debug;
+pub const debug_extensions_enabled = builtin.mode == .Debug;
pub const Color = enum {
auto,
@@ -90,7 +91,7 @@ const debug_usage = normal_usage ++
const usage = if (debug_extensions_enabled) debug_usage else normal_usage;
-pub const log_level: std.log.Level = switch (std.builtin.mode) {
+pub const log_level: std.log.Level = switch (builtin.mode) {
.Debug => .debug,
.ReleaseSafe, .ReleaseFast => .info,
.ReleaseSmall => .crit,
@@ -142,7 +143,7 @@ pub fn main() anyerror!void {
var gpa_need_deinit = false;
const gpa = gpa: {
- if (!std.builtin.link_libc) {
+ if (!builtin.link_libc) {
gpa_need_deinit = true;
break :gpa &general_purpose_allocator.allocator;
}
@@ -1688,13 +1689,13 @@ fn buildOutputType(
}
}
- if (comptime std.Target.current.isDarwin()) {
+ if (comptime builtin.target.isDarwin()) {
// If we want to link against frameworks, we need system headers.
if (framework_dirs.items.len > 0 or frameworks.items.len > 0)
want_native_include_dirs = true;
}
- const is_darwin_on_darwin = (comptime std.Target.current.isDarwin()) and cross_target.isDarwin();
+ const is_darwin_on_darwin = (comptime builtin.target.isDarwin()) and cross_target.isDarwin();
if (sysroot == null and (cross_target.isNativeOs() or is_darwin_on_darwin) and
(system_libs.items.len != 0 or want_native_include_dirs))
@@ -1706,7 +1707,7 @@ fn buildOutputType(
warn("{s}", .{warning});
}
- const has_sysroot = if (comptime std.Target.current.isDarwin()) outer: {
+ const has_sysroot = if (comptime builtin.target.isDarwin()) outer: {
const should_get_sdk_path = if (cross_target.isNativeOs() and target_info.target.os.tag == .macos) inner: {
const min = target_info.target.os.getVersionRange().semver.min;
const at_least_mojave = min.major >= 11 or (min.major >= 10 and min.minor >= 14);
@@ -2355,7 +2356,7 @@ fn runOrTest(
defer argv.deinit();
if (test_exec_args.len == 0) {
- if (!std.Target.current.canExecBinariesOf(target)) {
+ if (!builtin.target.canExecBinariesOf(target)) {
switch (arg_mode) {
.zig_test => {
warn("created {s} but skipping execution because it is non-native", .{exe_path});
@@ -3915,7 +3916,7 @@ fn gimmeMoreOfThoseSweetSweetFileDescriptors() void {
const posix = std.os;
var lim = posix.getrlimit(.NOFILE) catch return; // Oh well; we tried.
- if (comptime std.Target.current.isDarwin()) {
+ if (comptime builtin.target.isDarwin()) {
// On Darwin, `NOFILE` is bounded by a hardcoded value `OPEN_MAX`.
// According to the man pages for setrlimit():
// setrlimit() now returns with errno set to EINVAL in places that historically succeeded.
@@ -3959,7 +3960,7 @@ fn detectNativeTargetInfo(gpa: *Allocator, cross_target: std.zig.CrossTarget) !s
/// check for resource leaks can be accurate. In release builds, this
/// calls exit(0), and does not return.
pub fn cleanExit() void {
- if (std.builtin.mode == .Debug) {
+ if (builtin.mode == .Debug) {
return;
} else {
process.exit(0);
src/ThreadPool.zig
@@ -4,6 +4,7 @@
// The MIT license requires this copyright notice to be included in all copies
// and substantial portions of the software.
const std = @import("std");
+const builtin = @import("builtin");
const ThreadPool = @This();
lock: std.Thread.Mutex = .{},
@@ -57,7 +58,7 @@ pub fn init(self: *ThreadPool, allocator: *std.mem.Allocator) !void {
.allocator = allocator,
.workers = &[_]Worker{},
};
- if (std.builtin.single_threaded)
+ if (builtin.single_threaded)
return;
const worker_count = std.math.max(1, std.Thread.getCpuCount() catch 1);
@@ -100,7 +101,7 @@ pub fn deinit(self: *ThreadPool) void {
}
pub fn spawn(self: *ThreadPool, comptime func: anytype, args: anytype) !void {
- if (std.builtin.single_threaded) {
+ if (builtin.single_threaded) {
@call(.{}, func, args);
return;
}
src/tracy.zig
@@ -1,6 +1,7 @@
-pub const std = @import("std");
+const std = @import("std");
+const builtin = @import("builtin");
-pub const enable = if (std.builtin.is_test) false else @import("build_options").enable_tracy;
+pub const enable = if (builtin.is_test) false else @import("build_options").enable_tracy;
extern fn ___tracy_emit_zone_begin_callstack(
srcloc: *const ___tracy_source_location_data,
src/Zir.zig
@@ -11,6 +11,7 @@
//! inline assembly is not an exception.
const std = @import("std");
+const builtin = @import("builtin");
const mem = std.mem;
const Allocator = std.mem.Allocator;
const assert = std.debug.assert;
@@ -2215,7 +2216,7 @@ pub const Inst = struct {
// bigger than expected. Note that in Debug builds, Zig is allowed
// to insert a secret field for safety checks.
comptime {
- if (std.builtin.mode != .Debug) {
+ if (builtin.mode != .Debug) {
assert(@sizeOf(Data) == 8);
}
}
test/behavior/asm.zig
@@ -1,7 +1,8 @@
const std = @import("std");
+const builtin = @import("builtin");
const expect = std.testing.expect;
-const is_x86_64_linux = std.Target.current.cpu.arch == .x86_64 and std.Target.current.os.tag == .linux;
+const is_x86_64_linux = builtin.cpu.arch == .x86_64 and builtin.os.tag == .linux;
comptime {
if (is_x86_64_linux) {
test/behavior/atomics.zig
@@ -1,7 +1,7 @@
const std = @import("std");
+const builtin = @import("builtin");
const expect = std.testing.expect;
const expectEqual = std.testing.expectEqual;
-const builtin = @import("builtin");
test "cmpxchg" {
try testCmpxchg();
test/behavior/namespace_depends_on_compile_var.zig
@@ -1,4 +1,5 @@
const std = @import("std");
+const builtin = @import("builtin");
const expect = std.testing.expect;
test "namespace depends on compile var" {
@@ -8,7 +9,7 @@ test "namespace depends on compile var" {
try expect(!some_namespace.a_bool);
}
}
-const some_namespace = switch (std.builtin.os.tag) {
+const some_namespace = switch (builtin.os.tag) {
.linux => @import("namespace_depends_on_compile_var/a.zig"),
else => @import("namespace_depends_on_compile_var/b.zig"),
};
test/behavior/sizeof_and_typeof.zig
@@ -1,5 +1,4 @@
const std = @import("std");
-const builtin = std.builtin;
const expect = std.testing.expect;
const expectEqual = std.testing.expectEqual;
test/behavior/sizeof_and_typeof_stage1.zig
@@ -1,5 +1,4 @@
const std = @import("std");
-const builtin = std.builtin;
const expect = std.testing.expect;
const expectEqual = std.testing.expectEqual;
test/behavior/vector.zig
@@ -674,7 +674,7 @@ test "saturating subtraction" {
test "saturating multiplication" {
// TODO: once #9660 has been solved, remove this line
- if (std.builtin.target.cpu.arch == .wasm32) return error.SkipZigTest;
+ if (builtin.target.cpu.arch == .wasm32) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
test/src/compare_output.zig
@@ -1,14 +1,13 @@
// This is the implementation of the test harness.
// For the actual test cases, see test/compare_output.zig.
const std = @import("std");
-const builtin = std.builtin;
const build = std.build;
const ArrayList = std.ArrayList;
const fmt = std.fmt;
const mem = std.mem;
const fs = std.fs;
const warn = std.debug.warn;
-const Mode = builtin.Mode;
+const Mode = std.builtin.Mode;
pub const CompareOutputContext = struct {
b: *build.Builder,
test/standalone/c_compiler/build.zig
@@ -1,12 +1,13 @@
const std = @import("std");
+const builtin = @import("builtin");
const Builder = std.build.Builder;
const CrossTarget = std.zig.CrossTarget;
fn isRunnableTarget(t: CrossTarget) bool {
if (t.isNative()) return true;
- return (t.getOsTag() == std.Target.current.os.tag and
- t.getCpuArch() == std.Target.current.cpu.arch);
+ return (t.getOsTag() == builtin.os.tag and
+ t.getCpuArch() == builtin.cpu.arch);
}
pub fn build(b: *Builder) void {
test/standalone/install_raw_hex/build.zig
@@ -28,14 +28,14 @@ pub fn build(b: *Builder) void {
const expected_hex = &[_][]const u8{
":020000021000EC",
- ":1000D400D001010001000000D20101000100000074",
- ":1000E40028020100010000002402010001000000B8",
- ":1000F4003A02010001000000E202010001000000D8",
- ":100104000C03010001000000A50202000000000031",
+ ":1000D400A401010001000000A601010001000000CC",
+ ":1000E400FC01010001000000F80101000100000012",
+ ":1000F4000E02010001000000B60201000100000030",
+ ":10010400E00201000100000079020200000000008A",
":1001140000000000000000000000000000000000DB",
":1001240000000000000000000000000000000000CB",
":1001340000000000000000000000000000000000BB",
- ":10014400AF02020098020100090000004D02010004",
+ ":10014400830202006C020100090000002102010088",
":100154000900000001000000000000000000000091",
":1001640000080002008001010004000010000000EB",
":100174000000000000000000000000001F0000005C",
@@ -44,55 +44,52 @@ pub fn build(b: *Builder) void {
":1001A40000000000000000001F000000000000002C",
":1001B400000000000000000000000000000000003B",
":1001C400000000000000000000000000000000002B",
- ":1001D400000000000000000000000000000000001B",
- ":1001E400000000000000000000000000000000000B",
- ":1001F4000000000000000000000000008702010071",
- ":1002040010000000200201002C0000006B0201001D",
- ":100214001B000000570201001300000072656D61AD",
- ":10022400696E646572206469766973696F6E2062B1",
- ":1002340079207A65726F206F72206E6567617469C8",
- ":1002440076652076616C756500636F727465782DD0",
- ":100254006D3400696E646578206F7574206F662054",
- ":10026400626F756E647300696E746567657220638E",
- ":10027400617374207472756E63617465642062695D",
- ":100284007473006469766973696F6E206279207A89",
- ":1002940065726F00636F727465785F6D340000007F",
- ":1002A40081B00091FFE700BEFDE7D0B502AF90B08A",
- ":1002B4000391029007A800F029F803990020069002",
- ":1002C40048680490FFE704990698019088420FD289",
- ":1002D400FFE7019903980068405C07F8310C17F8B0",
- ":1002E400311C07A800F021F8019801300690EAE7D4",
- ":1002F400029807A9B1E80C50A0E80C5091E81C50F2",
- ":1003040080E81C5010B0D0BDFFE7FEE7D0B502AFC7",
- ":1003140040F2DC11C0F20101B1E80C50A0E80C502D",
- ":1003240091E81C5080E81C50D0BD80B56F4688B061",
- ":1003340006906FF35F2127F80A1C37F80A0C049023",
- ":10034400012038B9FFE740F20020C0F2010000218B",
- ":10035400FFF7A6FF0498C0F3431027F8020C37F800",
- ":100364000A0C0390002038B9FFE7039800F01F003F",
- ":100374000290012038B914E040F20820C0F20100D4",
- ":100384000021FFF78DFF029800F01F0007F8030C0F",
- ":100394000698009037F8020C0146019109280ED303",
- ":1003A40006E040F21020C0F201000021FFF778FFC0",
- ":1003B40040F21820C0F201000021FFF771FF0099FC",
- ":1003C400019A51F8220017F803CC012303FA0CF325",
- ":1003D400184341F8220008B080BD81B000F03F000E",
- ":1003E4008DF802009DF802000F3000F03F00022853",
- ":1003F40004D3FFE700208DF8030003E001208DF80B",
- ":100404000300FFE79DF8030001B070470A000000F5",
- ":1004140012000000020071001200000066000000DB",
- ":1004240003007D0C06000000000000000001110123",
- ":10043400250E1305030E10171B0EB44219110112D9",
- ":0604440006000002340076",
+ ":1001D4005B02010010000000F40101002C0000008B",
+ ":1001E4003F0201001B0000002B020100130000006D",
+ ":1001F40072656D61696E646572206469766973699C",
+ ":100204006F6E206279207A65726F206F72206E653E",
+ ":100214006761746976652076616C756500636F72D9",
+ ":100224007465782D6D3400696E646578206F75741B",
+ ":10023400206F6620626F756E647300696E74656703",
+ ":1002440065722063617374207472756E6361746582",
+ ":10025400642062697473006469766973696F6E20DF",
+ ":100264006279207A65726F00636F727465785F6D6E",
+ ":100274003400000081B00091FFE700BEFDE7D0B577",
+ ":1002840002AF90B00391029007A800F029F80399F7",
+ ":100294000020069048680490FFE7049906980190AE",
+ ":1002A40088420FD2FFE7019903980068405C07F881",
+ ":1002B400310C17F8311C07A800F021F8019801301F",
+ ":1002C4000690EAE7029807A9B1E80C50A0E80C50A0",
+ ":1002D40091E81C5080E81C5010B0D0BDFFE7FEE749",
+ ":1002E400D0B502AF40F2B011C0F20101B1E80C5038",
+ ":1002F400A0E80C5091E81C5080E81C50D0BD80B59B",
+ ":100304006F4688B006906FF35F2127F80A1C37F810",
+ ":100314000A0C0490012038B9FFE740F2D410C0F26F",
+ ":1003240001000021FFF7A6FF0498C0F3431027F84B",
+ ":10033400020C37F80A0C0390002038B9FFE7039841",
+ ":1003440000F01F000290012038B914E040F2DC10E4",
+ ":10035400C0F201000021FFF78DFF029800F01F009A",
+ ":1003640007F8030C0698009037F8020C0146019137",
+ ":1003740009280ED306E040F2E410C0F20100002187",
+ ":10038400FFF778FF40F2EC10C0F201000021FFF704",
+ ":1003940071FF0099019A51F8220017F803CC012348",
+ ":1003A40003FA0CF3184341F8220008B080BD81B071",
+ ":1003B40000F03F008DF802009DF802000F3000F0BD",
+ ":1003C4003F00022804D3FFE700208DF8030003E078",
+ ":1003D40001208DF80300FFE79DF8030001B070478A",
+ ":1003E4000A00000012000000020071001200000068",
+ ":1003F4006600000003007D0C060000000000000001",
+ ":1004040000011101250E1305030E10171B0EB44233",
+ ":0A0414001911011206000002340065",
":020000021000EC",
- ":1000D400D001010001000000D20101000100000074",
- ":1000E40028020100010000002402010001000000B8",
- ":1000F4003A02010001000000E202010001000000D8",
- ":100104000C03010001000000A50202000000000031",
+ ":1000D400A401010001000000A601010001000000CC",
+ ":1000E400FC01010001000000F80101000100000012",
+ ":1000F4000E02010001000000B60201000100000030",
+ ":10010400E00201000100000079020200000000008A",
":1001140000000000000000000000000000000000DB",
":1001240000000000000000000000000000000000CB",
":1001340000000000000000000000000000000000BB",
- ":10014400AF02020098020100090000004D02010004",
+ ":10014400830202006C020100090000002102010088",
":100154000900000001000000000000000000000091",
":1001640000080002008001010004000010000000EB",
":100174000000000000000000000000001F0000005C",
@@ -101,70 +98,67 @@ pub fn build(b: *Builder) void {
":1001A40000000000000000001F000000000000002C",
":1001B400000000000000000000000000000000003B",
":1001C400000000000000000000000000000000002B",
- ":1001D400000000000000000000000000000000001B",
- ":1001E400000000000000000000000000000000000B",
- ":1001F4000000000000000000000000008702010071",
- ":1002040010000000200201002C0000006B0201001D",
- ":100214001B000000570201001300000072656D61AD",
- ":10022400696E646572206469766973696F6E2062B1",
- ":1002340079207A65726F206F72206E6567617469C8",
- ":1002440076652076616C756500636F727465782DD0",
- ":100254006D3400696E646578206F7574206F662054",
- ":10026400626F756E647300696E746567657220638E",
- ":10027400617374207472756E63617465642062695D",
- ":100284007473006469766973696F6E206279207A89",
- ":1002940065726F00636F727465785F6D340000007F",
- ":1002A40081B00091FFE700BEFDE7D0B502AF90B08A",
- ":1002B4000391029007A800F029F803990020069002",
- ":1002C40048680490FFE704990698019088420FD289",
- ":1002D400FFE7019903980068405C07F8310C17F8B0",
- ":1002E400311C07A800F021F8019801300690EAE7D4",
- ":1002F400029807A9B1E80C50A0E80C5091E81C50F2",
- ":1003040080E81C5010B0D0BDFFE7FEE7D0B502AFC7",
- ":1003140040F2DC11C0F20101B1E80C50A0E80C502D",
- ":1003240091E81C5080E81C50D0BD80B56F4688B061",
- ":1003340006906FF35F2127F80A1C37F80A0C049023",
- ":10034400012038B9FFE740F20020C0F2010000218B",
- ":10035400FFF7A6FF0498C0F3431027F8020C37F800",
- ":100364000A0C0390002038B9FFE7039800F01F003F",
- ":100374000290012038B914E040F20820C0F20100D4",
- ":100384000021FFF78DFF029800F01F0007F8030C0F",
- ":100394000698009037F8020C0146019109280ED303",
- ":1003A40006E040F21020C0F201000021FFF778FFC0",
- ":1003B40040F21820C0F201000021FFF771FF0099FC",
- ":1003C400019A51F8220017F803CC012303FA0CF325",
- ":1003D400184341F8220008B080BD81B000F03F000E",
- ":1003E4008DF802009DF802000F3000F03F00022853",
- ":1003F40004D3FFE700208DF8030003E001208DF80B",
- ":100404000300FFE79DF8030001B070470A000000F5",
- ":1004140012000000020071001200000066000000DB",
- ":1004240003007D0C06000000000000000001110123",
- ":10043400250E1305030E10171B0EB44219110112D9",
- ":0604440006000002340076",
+ ":1001D4005B02010010000000F40101002C0000008B",
+ ":1001E4003F0201001B0000002B020100130000006D",
+ ":1001F40072656D61696E646572206469766973699C",
+ ":100204006F6E206279207A65726F206F72206E653E",
+ ":100214006761746976652076616C756500636F72D9",
+ ":100224007465782D6D3400696E646578206F75741B",
+ ":10023400206F6620626F756E647300696E74656703",
+ ":1002440065722063617374207472756E6361746582",
+ ":10025400642062697473006469766973696F6E20DF",
+ ":100264006279207A65726F00636F727465785F6D6E",
+ ":100274003400000081B00091FFE700BEFDE7D0B577",
+ ":1002840002AF90B00391029007A800F029F80399F7",
+ ":100294000020069048680490FFE7049906980190AE",
+ ":1002A40088420FD2FFE7019903980068405C07F881",
+ ":1002B400310C17F8311C07A800F021F8019801301F",
+ ":1002C4000690EAE7029807A9B1E80C50A0E80C50A0",
+ ":1002D40091E81C5080E81C5010B0D0BDFFE7FEE749",
+ ":1002E400D0B502AF40F2B011C0F20101B1E80C5038",
+ ":1002F400A0E80C5091E81C5080E81C50D0BD80B59B",
+ ":100304006F4688B006906FF35F2127F80A1C37F810",
+ ":100314000A0C0490012038B9FFE740F2D410C0F26F",
+ ":1003240001000021FFF7A6FF0498C0F3431027F84B",
+ ":10033400020C37F80A0C0390002038B9FFE7039841",
+ ":1003440000F01F000290012038B914E040F2DC10E4",
+ ":10035400C0F201000021FFF78DFF029800F01F009A",
+ ":1003640007F8030C0698009037F8020C0146019137",
+ ":1003740009280ED306E040F2E410C0F20100002187",
+ ":10038400FFF778FF40F2EC10C0F201000021FFF704",
+ ":1003940071FF0099019A51F8220017F803CC012348",
+ ":1003A40003FA0CF3184341F8220008B080BD81B071",
+ ":1003B40000F03F008DF802009DF802000F3000F0BD",
+ ":1003C4003F00022804D3FFE700208DF8030003E078",
+ ":1003D40001208DF80300FFE79DF8030001B070478A",
+ ":1003E4000A00000012000000020071001200000068",
+ ":1003F4006600000003007D0C060000000000000001",
+ ":1004040000011101250E1305030E10171B0EB44233",
+ ":0A0414001911011206000002340065",
":020000022000DC",
- ":1002A40081B00091FFE700BEFDE7D0B502AF90B08A",
- ":1002B4000391029007A800F029F803990020069002",
- ":1002C40048680490FFE704990698019088420FD289",
- ":1002D400FFE7019903980068405C07F8310C17F8B0",
- ":1002E400311C07A800F021F8019801300690EAE7D4",
- ":1002F400029807A9B1E80C50A0E80C5091E81C50F2",
- ":1003040080E81C5010B0D0BDFFE7FEE7D0B502AFC7",
- ":1003140040F2DC11C0F20101B1E80C50A0E80C502D",
- ":1003240091E81C5080E81C50D0BD80B56F4688B061",
- ":1003340006906FF35F2127F80A1C37F80A0C049023",
- ":10034400012038B9FFE740F20020C0F2010000218B",
- ":10035400FFF7A6FF0498C0F3431027F8020C37F800",
- ":100364000A0C0390002038B9FFE7039800F01F003F",
- ":100374000290012038B914E040F20820C0F20100D4",
- ":100384000021FFF78DFF029800F01F0007F8030C0F",
- ":100394000698009037F8020C0146019109280ED303",
- ":1003A40006E040F21020C0F201000021FFF778FFC0",
- ":1003B40040F21820C0F201000021FFF771FF0099FC",
- ":1003C400019A51F8220017F803CC012303FA0CF325",
- ":1003D400184341F8220008B080BD81B000F03F000E",
- ":1003E4008DF802009DF802000F3000F03F00022853",
- ":1003F40004D3FFE700208DF8030003E001208DF80B",
- ":0C0404000300FFE79DF8030001B0704703",
+ ":1002780081B00091FFE700BEFDE7D0B502AF90B0B6",
+ ":100288000391029007A800F029F80399002006902E",
+ ":1002980048680490FFE704990698019088420FD2B5",
+ ":1002A800FFE7019903980068405C07F8310C17F8DC",
+ ":1002B800311C07A800F021F8019801300690EAE700",
+ ":1002C800029807A9B1E80C50A0E80C5091E81C501E",
+ ":1002D80080E81C5010B0D0BDFFE7FEE7D0B502AFF4",
+ ":1002E80040F2B011C0F20101B1E80C50A0E80C5086",
+ ":1002F80091E81C5080E81C50D0BD80B56F4688B08E",
+ ":1003080006906FF35F2127F80A1C37F80A0C04904F",
+ ":10031800012038B9FFE740F2D410C0F201000021F3",
+ ":10032800FFF7A6FF0498C0F3431027F8020C37F82C",
+ ":100338000A0C0390002038B9FFE7039800F01F006B",
+ ":100348000290012038B914E040F2DC10C0F201003C",
+ ":100358000021FFF78DFF029800F01F0007F8030C3B",
+ ":100368000698009037F8020C0146019109280ED32F",
+ ":1003780006E040F2E410C0F201000021FFF778FF28",
+ ":1003880040F2EC10C0F201000021FFF771FF009964",
+ ":10039800019A51F8220017F803CC012303FA0CF351",
+ ":1003A800184341F8220008B080BD81B000F03F003A",
+ ":1003B8008DF802009DF802000F3000F03F0002287F",
+ ":1003C80004D3FFE700208DF8030003E001208DF837",
+ ":0C03D8000300FFE79DF8030001B0704730",
":00000001FF",
};
test/assemble_and_link.zig
@@ -1,8 +1,9 @@
const std = @import("std");
+const builtin = @import("builtin");
const tests = @import("tests.zig");
pub fn addCases(cases: *tests.CompareOutputContext) void {
- if (std.Target.current.os.tag == .linux and std.Target.current.cpu.arch == .x86_64) {
+ if (builtin.os.tag == .linux and builtin.cpu.arch == .x86_64) {
cases.addAsm("hello world linux x86_64",
\\.text
\\.globl _start
test/cli.zig
@@ -1,4 +1,5 @@
const std = @import("std");
+const builtin = @import("builtin");
const testing = std.testing;
const process = std.process;
const fs = std.fs;
@@ -97,7 +98,7 @@ fn testZigInitExe(zig_exe: []const u8, dir_path: []const u8) !void {
}
fn testGodboltApi(zig_exe: []const u8, dir_path: []const u8) anyerror!void {
- if (std.Target.current.os.tag != .linux or std.Target.current.cpu.arch != .x86_64) return;
+ if (builtin.os.tag != .linux or builtin.cpu.arch != .x86_64) return;
const example_zig_path = try fs.path.join(a, &[_][]const u8{ dir_path, "example.zig" });
const example_s_path = try fs.path.join(a, &[_][]const u8{ dir_path, "example.s" });
test/compare_output.zig
@@ -28,7 +28,8 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
cases.addC("number literals",
\\const std = @import("std");
- \\const is_windows = std.Target.current.os.tag == .windows;
+ \\const builtin = @import("builtin");
+ \\const is_windows = builtin.os.tag == .windows;
\\const c = @cImport({
\\ if (is_windows) {
\\ // See https://github.com/ziglang/zig/issues/515
@@ -207,7 +208,8 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
cases.addC("casting between float and integer types",
\\const std = @import("std");
- \\const is_windows = std.Target.current.os.tag == .windows;
+ \\const builtin = @import("builtin");
+ \\const is_windows = builtin.os.tag == .windows;
\\const c = @cImport({
\\ if (is_windows) {
\\ // See https://github.com/ziglang/zig/issues/515
test/compile_errors.zig
@@ -1,4 +1,5 @@
const std = @import("std");
+const builtin = @import("builtin");
const TestContext = @import("../src/test.zig").TestContext;
pub fn addCases(ctx: *TestContext) !void {
@@ -2898,7 +2899,7 @@ pub fn addCases(ctx: *TestContext) !void {
"tmp.zig:2:18: error: invalid operands to binary expression: 'error{A}' and 'error{B}'",
});
- if (std.Target.current.os.tag == .linux) {
+ if (builtin.os.tag == .linux) {
ctx.testErrStage1("implicit dependency on libc",
\\extern "c" fn exit(u8) void;
\\export fn entry() void {
@@ -8834,9 +8835,10 @@ pub fn addCases(ctx: *TestContext) !void {
ctx.objErrStage1("Issue #9165: windows tcp server compilation error",
\\const std = @import("std");
+ \\const builtin = @import("builtin");
\\pub const io_mode = .evented;
\\pub fn main() !void {
- \\ if (std.builtin.os.tag == .windows) {
+ \\ if (builtin.os.tag == .windows) {
\\ _ = try (std.net.StreamServer.init(.{})).accept();
\\ } else {
\\ @compileError("Unsupported OS");
test/standalone.zig
@@ -1,4 +1,5 @@
const std = @import("std");
+const builtin = @import("builtin");
const tests = @import("tests.zig");
pub fn addCases(cases: *tests.StandaloneContext) void {
@@ -29,19 +30,19 @@ pub fn addCases(cases: *tests.StandaloneContext) void {
cases.addBuildFile("test/standalone/issue_7030/build.zig", .{});
cases.addBuildFile("test/standalone/install_raw_hex/build.zig", .{});
cases.addBuildFile("test/standalone/issue_9812/build.zig", .{});
- if (std.Target.current.os.tag != .wasi) {
+ if (builtin.os.tag != .wasi) {
cases.addBuildFile("test/standalone/load_dynamic_library/build.zig", .{});
}
- if (std.Target.current.cpu.arch == .x86_64) { // TODO add C ABI support for other architectures
+ if (builtin.cpu.arch == .x86_64) { // TODO add C ABI support for other architectures
cases.addBuildFile("test/stage1/c_abi/build.zig", .{});
}
cases.addBuildFile("test/standalone/c_compiler/build.zig", .{ .build_modes = true, .cross_targets = true });
- if (std.Target.current.os.tag == .windows) {
+ if (builtin.os.tag == .windows) {
cases.addC("test/standalone/issue_9402/main.zig");
}
// Try to build and run a PIE executable.
- if (std.Target.current.os.tag == .linux) {
+ if (builtin.os.tag == .linux) {
cases.addBuildFile("test/standalone/pie/build.zig", .{});
}
// Try to build and run an Objective-C executable.
test/tests.zig
@@ -1,5 +1,5 @@
const std = @import("std");
-const builtin = std.builtin;
+const builtin = @import("builtin");
const debug = std.debug;
const warn = debug.warn;
const build = std.build;
@@ -9,7 +9,7 @@ const fs = std.fs;
const mem = std.mem;
const fmt = std.fmt;
const ArrayList = std.ArrayList;
-const Mode = builtin.Mode;
+const Mode = std.builtin.Mode;
const LibExeObjStep = build.LibExeObjStep;
// Cases
@@ -29,7 +29,7 @@ pub const CompareOutputContext = @import("src/compare_output.zig").CompareOutput
const TestTarget = struct {
target: CrossTarget = @as(CrossTarget, .{}),
- mode: builtin.Mode = .Debug,
+ mode: std.builtin.Mode = .Debug,
link_libc: bool = false,
single_threaded: bool = false,
disable_native: bool = false,
@@ -532,8 +532,8 @@ pub fn addPkgTests(
continue;
if (test_target.disable_native and
- test_target.target.getOsTag() == std.Target.current.os.tag and
- test_target.target.getCpuArch() == std.Target.current.cpu.arch)
+ test_target.target.getOsTag() == builtin.os.tag and
+ test_target.target.getCpuArch() == builtin.cpu.arch)
{
continue;
}
@@ -785,7 +785,7 @@ pub const StackTracesContext = struct {
if (line.len == 0) continue;
// offset search past `[drive]:` on windows
- var pos: usize = if (std.Target.current.os.tag == .windows) 2 else 0;
+ var pos: usize = if (builtin.os.tag == .windows) 2 else 0;
// locate delims/anchor
const delims = [_][]const u8{ ":", ":", ":", " in ", "(", ")" };
var marks = [_]usize{0} ** delims.len;
@@ -1055,7 +1055,7 @@ pub const GenHContext = struct {
pub fn addCase(self: *GenHContext, case: *const TestCase) void {
const b = self.b;
- const mode = builtin.Mode.Debug;
+ const mode = std.builtin.Mode.Debug;
const annotated_case_name = fmt.allocPrint(self.b.allocator, "gen-h {s} ({s})", .{ case.name, @tagName(mode) }) catch unreachable;
if (self.test_filter) |filter| {
if (mem.indexOf(u8, annotated_case_name, filter) == null) return;
test/translate_c.zig
@@ -1,9 +1,10 @@
-const tests = @import("tests.zig");
const std = @import("std");
+const builtin = @import("builtin");
+const tests = @import("tests.zig");
const CrossTarget = std.zig.CrossTarget;
pub fn addCases(cases: *tests.TranslateCContext) void {
- const default_enum_type = if (std.Target.current.abi == .msvc) "c_int" else "c_uint";
+ const default_enum_type = if (builtin.abi == .msvc) "c_int" else "c_uint";
cases.add("field access is grouped if necessary",
\\unsigned long foo(unsigned long x) {
@@ -1153,7 +1154,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
\\pub export fn foo() void {}
});
- if (std.Target.current.os.tag != .windows) {
+ if (builtin.os.tag != .windows) {
// Windows treats this as an enum with type c_int
cases.add("big negative enum init values when C ABI supports long long enums",
\\enum EnumWithInits {
@@ -1558,7 +1559,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
\\}
});
- if (std.Target.current.os.tag != .windows) {
+ if (builtin.os.tag != .windows) {
// sysv_abi not currently supported on windows
cases.add("Macro qualified functions",
\\void __attribute__((sysv_abi)) foo(void);
@@ -2160,7 +2161,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
\\}
});
- if (std.Target.current.os.tag != .windows) {
+ if (builtin.os.tag != .windows) {
// When clang uses the <arch>-windows-none triple it behaves as MSVC and
// interprets the inner `struct Bar` as an anonymous structure
cases.add("type referenced struct",
@@ -3398,7 +3399,7 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
\\pub const FOO = @import("std").zig.c_translation.cast(c_int, @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8000, .hexadecimal));
});
- if (std.Target.current.abi == .msvc) {
+ if (builtin.abi == .msvc) {
cases.add("nameless struct fields",
\\typedef struct NAMED
\\{
tools/update_cpu_features.zig
@@ -1,4 +1,5 @@
const std = @import("std");
+const builtin = @import("builtin");
const fs = std.fs;
const mem = std.mem;
const json = std.json;
@@ -803,7 +804,7 @@ pub fn main() anyerror!void {
const root_progress = try progress.start("", llvm_targets.len);
defer root_progress.end();
- if (std.builtin.single_threaded) {
+ if (builtin.single_threaded) {
for (llvm_targets) |llvm_target| {
try processOneTarget(Job{
.llvm_tblgen_exe = llvm_tblgen_exe,