Compile Variables

Compile Variables

Compile variables are accessible by importing the "builtin" package, which the compiler makes available to every Zig source file. It contains compile-time constants such as the current target, endianness, and release mode.

const builtin = @import("builtin");
const separator = if (builtin.os == builtin.Os.windows) '\\' else '/';

Example of what is imported with @import("builtin"):

pub const StackTrace = struct {
    index: usize,
    instruction_addresses: []usize,
};

pub const PanicFn = fn([]const u8, ?*StackTrace) noreturn;

pub const Os = enum {
    freestanding,
    ananas,
    cloudabi,
    dragonfly,
    freebsd,
    fuchsia,
    ios,
    kfreebsd,
    linux,
    lv2,
    macosx,
    netbsd,
    openbsd,
    solaris,
    windows,
    haiku,
    minix,
    rtems,
    nacl,
    cnk,
    aix,
    cuda,
    nvcl,
    amdhsa,
    ps4,
    elfiamcu,
    tvos,
    watchos,
    mesa3d,
    contiki,
    amdpal,
    hermit,
    hurd,
    wasi,
    zen,
    uefi,
};

pub const Arch = union(enum) {
    arm: Arm32,
    armeb: Arm32,
    aarch64: Arm64,
    aarch64_be: Arm64,
    arc,
    avr,
    bpfel,
    bpfeb,
    hexagon,
    mips,
    mipsel,
    mips64,
    mips64el,
    msp430,
    powerpc,
    powerpc64,
    powerpc64le,
    r600,
    amdgcn,
    riscv32,
    riscv64,
    sparc,
    sparcv9,
    sparcel,
    s390x,
    tce,
    tcele,
    thumb: Arm32,
    thumbeb: Arm32,
    i386,
    x86_64,
    xcore,
    nvptx,
    nvptx64,
    le32,
    le64,
    amdil,
    amdil64,
    hsail,
    hsail64,
    spir,
    spir64,
    kalimba: Kalimba,
    shave,
    lanai,
    wasm32,
    wasm64,
    renderscript32,
    renderscript64,
    pub const Arm32 = enum {
        v8_5a,
        v8_4a,
        v8_3a,
        v8_2a,
        v8_1a,
        v8,
        v8r,
        v8m_baseline,
        v8m_mainline,
        v7,
        v7em,
        v7m,
        v7s,
        v7k,
        v7ve,
        v6,
        v6m,
        v6k,
        v6t2,
        v5,
        v5te,
        v4t,
    };
    pub const Arm64 = enum {
        v8_5a,
        v8_4a,
        v8_3a,
        v8_2a,
        v8_1a,
        v8,
        v8r,
        v8m_baseline,
        v8m_mainline,
    };
    pub const Kalimba = enum {
        v5,
        v4,
        v3,
    };
    pub const Mips = enum {
        r6,
    };
};

pub const Abi = enum {
    none,
    gnu,
    gnuabin32,
    gnuabi64,
    gnueabi,
    gnueabihf,
    gnux32,
    code16,
    eabi,
    eabihf,
    android,
    musl,
    musleabi,
    musleabihf,
    msvc,
    itanium,
    cygnus,
    coreclr,
    simulator,
};

pub const ObjectFormat = enum {
    unknown,
    coff,
    elf,
    macho,
    wasm,
};

pub const GlobalLinkage = enum {
    Internal,
    Strong,
    Weak,
    LinkOnce,
};

pub const AtomicOrder = enum {
    Unordered,
    Monotonic,
    Acquire,
    Release,
    AcqRel,
    SeqCst,
};

pub const AtomicRmwOp = enum {
    Xchg,
    Add,
    Sub,
    And,
    Nand,
    Or,
    Xor,
    Max,
    Min,
};

pub const Mode = enum {
    Debug,
    ReleaseSafe,
    ReleaseFast,
    ReleaseSmall,
};

pub const TypeId = enum {
    Type,
    Void,
    Bool,
    NoReturn,
    Int,
    Float,
    Pointer,
    Array,
    Struct,
    ComptimeFloat,
    ComptimeInt,
    Undefined,
    Null,
    Optional,
    ErrorUnion,
    ErrorSet,
    Enum,
    Union,
    Fn,
    BoundFn,
    ArgTuple,
    Opaque,
    Promise,
    Vector,
    EnumLiteral,
};

pub const TypeInfo = union(TypeId) {
    Type: void,
    Void: void,
    Bool: void,
    NoReturn: void,
    Int: Int,
    Float: Float,
    Pointer: Pointer,
    Array: Array,
    Struct: Struct,
    ComptimeFloat: void,
    ComptimeInt: void,
    Undefined: void,
    Null: void,
    Optional: Optional,
    ErrorUnion: ErrorUnion,
    ErrorSet: ErrorSet,
    Enum: Enum,
    Union: Union,
    Fn: Fn,
    BoundFn: Fn,
    ArgTuple: void,
    Opaque: void,
    Promise: Promise,
    Vector: Vector,
    EnumLiteral: void,

    pub const Int = struct {
        is_signed: bool,
        bits: comptime_int,
    };

    pub const Float = struct {
        bits: comptime_int,
    };

    pub const Pointer = struct {
        size: Size,
        is_const: bool,
        is_volatile: bool,
        alignment: comptime_int,
        child: type,
        is_allowzero: bool,

        pub const Size = enum {
            One,
            Many,
            Slice,
            C,
        };
    };

    pub const Array = struct {
        len: comptime_int,
        child: type,
    };

    pub const ContainerLayout = enum {
        Auto,
        Extern,
        Packed,
    };

    pub const StructField = struct {
        name: []const u8,
        offset: ?comptime_int,
        field_type: type,
    };

    pub const Struct = struct {
        layout: ContainerLayout,
        fields: []StructField,
        defs: []Definition,
    };

    pub const Optional = struct {
        child: type,
    };

    pub const ErrorUnion = struct {
        error_set: type,
        payload: type,
    };

    pub const Error = struct {
        name: []const u8,
        value: comptime_int,
    };

    pub const ErrorSet = ?[]Error;

    pub const EnumField = struct {
        name: []const u8,
        value: comptime_int,
    };

    pub const Enum = struct {
        layout: ContainerLayout,
        tag_type: type,
        fields: []EnumField,
        defs: []Definition,
    };

    pub const UnionField = struct {
        name: []const u8,
        enum_field: ?EnumField,
        field_type: type,
    };

    pub const Union = struct {
        layout: ContainerLayout,
        tag_type: ?type,
        fields: []UnionField,
        defs: []Definition,
    };

    pub const CallingConvention = enum {
        Unspecified,
        C,
        Cold,
        Naked,
        Stdcall,
        Async,
    };

    pub const FnArg = struct {
        is_generic: bool,
        is_noalias: bool,
        arg_type: ?type,
    };

    pub const Fn = struct {
        calling_convention: CallingConvention,
        is_generic: bool,
        is_var_args: bool,
        return_type: ?type,
        async_allocator_type: ?type,
        args: []FnArg,
    };

    pub const Promise = struct {
        child: ?type,
    };

    pub const Vector = struct {
        len: comptime_int,
        child: type,
    };

    pub const Definition = struct {
        name: []const u8,
        is_pub: bool,
        data: Data,

        pub const Data = union(enum) {
            Type: type,
            Var: type,
            Fn: FnDef,

            pub const FnDef = struct {
                fn_type: type,
                inline_type: Inline,
                calling_convention: CallingConvention,
                is_var_args: bool,
                is_extern: bool,
                is_export: bool,
                lib_name: ?[]const u8,
                return_type: type,
                arg_names: [][] const u8,

                pub const Inline = enum {
                    Auto,
                    Always,
                    Never,
                };
            };
        };
    };
};

pub const FloatMode = enum {
    Strict,
    Optimized,
};

pub const Endian = enum {
    Big,
    Little,
};

pub const endian = Endian.Little;
pub const is_test = false;
pub const single_threaded = false;
pub const os = Os.linux;
pub const arch = Arch.x86_64;
pub const abi = Abi.gnu;
pub const object_format = ObjectFormat.elf;
pub const mode = Mode.Debug;
pub const link_libc = false;
pub const have_error_return_tracing = false;
pub const valgrind_support = true;
pub const position_independent_code = false;

See also:

• Build Mode