Commit 21767144fc
Changed files (10)
src
std
test
cases
src/codegen.cpp
@@ -3561,6 +3561,16 @@ static LLVMValueRef ir_render_cmpxchg(CodeGen *g, IrExecutable *executable, IrIn
LLVMValueRef result_val = ZigLLVMBuildCmpXchg(g->builder, ptr_val, cmp_val, new_val,
success_order, failure_order, instruction->is_weak);
+ TypeTableEntry *maybe_type = instruction->base.value.type;
+ assert(maybe_type->id == TypeTableEntryIdMaybe);
+ TypeTableEntry *child_type = maybe_type->data.maybe.child_type;
+
+ if (type_is_codegen_pointer(child_type)) {
+ LLVMValueRef payload_val = LLVMBuildExtractValue(g->builder, result_val, 0, "");
+ LLVMValueRef success_bit = LLVMBuildExtractValue(g->builder, result_val, 1, "");
+ return LLVMBuildSelect(g->builder, success_bit, LLVMConstNull(child_type->type_ref), payload_val, "");
+ }
+
assert(instruction->tmp_ptr != nullptr);
assert(type_has_bits(instruction->type));
std/os/linux/index.zig
@@ -1,6 +1,7 @@
const std = @import("../../index.zig");
const assert = std.debug.assert;
const builtin = @import("builtin");
+const vdso = @import("vdso.zig");
pub use switch (builtin.arch) {
builtin.Arch.x86_64 => @import("x86_64.zig"),
builtin.Arch.i386 => @import("i386.zig"),
@@ -806,8 +807,27 @@ pub fn waitpid(pid: i32, status: &i32, options: i32) usize {
}
pub fn clock_gettime(clk_id: i32, tp: ×pec) usize {
+ if (VDSO_CGT_SYM.len != 0) {
+ const f = @atomicLoad(@typeOf(init_vdso_clock_gettime), &vdso_clock_gettime, builtin.AtomicOrder.Unordered);
+ if (@ptrToInt(f) != 0) {
+ const rc = f(clk_id, tp);
+ switch (rc) {
+ 0, @bitCast(usize, isize(-EINVAL)) => return rc,
+ else => {},
+ }
+ }
+ }
return syscall2(SYS_clock_gettime, @bitCast(usize, isize(clk_id)), @ptrToInt(tp));
}
+var vdso_clock_gettime = init_vdso_clock_gettime;
+extern fn init_vdso_clock_gettime(clk: i32, ts: ×pec) usize {
+ const addr = vdso.lookup(VDSO_CGT_VER, VDSO_CGT_SYM);
+ var f = @intToPtr(@typeOf(init_vdso_clock_gettime), addr);
+ _ = @cmpxchgStrong(@typeOf(init_vdso_clock_gettime), &vdso_clock_gettime, init_vdso_clock_gettime, f,
+ builtin.AtomicOrder.Monotonic, builtin.AtomicOrder.Monotonic);
+ if (@ptrToInt(f) == 0) return @bitCast(usize, isize(-ENOSYS));
+ return f(clk, ts);
+}
pub fn clock_getres(clk_id: i32, tp: ×pec) usize {
return syscall2(SYS_clock_getres, @bitCast(usize, isize(clk_id)), @ptrToInt(tp));
std/os/linux/vdso.zig
@@ -0,0 +1,89 @@
+const std = @import("../../index.zig");
+const elf = std.elf;
+const linux = std.os.linux;
+const cstr = std.cstr;
+const mem = std.mem;
+
+pub fn lookup(vername: []const u8, name: []const u8) usize {
+ const vdso_addr = std.os.linux_aux_raw[std.elf.AT_SYSINFO_EHDR];
+ if (vdso_addr == 0) return 0;
+
+ const eh = @intToPtr(&elf.Ehdr, vdso_addr);
+ var ph_addr: usize = vdso_addr + eh.e_phoff;
+ const ph = @intToPtr(&elf.Phdr, ph_addr);
+
+ var maybe_dynv: ?&usize = null;
+ var base: usize = @maxValue(usize);
+ {
+ var i: usize = 0;
+ while (i < eh.e_phnum) : ({i += 1; ph_addr += eh.e_phentsize;}) {
+ const this_ph = @intToPtr(&elf.Phdr, ph_addr);
+ switch (this_ph.p_type) {
+ elf.PT_LOAD => base = vdso_addr + this_ph.p_offset - this_ph.p_vaddr,
+ elf.PT_DYNAMIC => maybe_dynv = @intToPtr(&usize, vdso_addr + this_ph.p_offset),
+ else => {},
+ }
+ }
+ }
+ const dynv = maybe_dynv ?? return 0;
+ if (base == @maxValue(usize)) return 0;
+
+ var maybe_strings: ?&u8 = null;
+ var maybe_syms: ?&elf.Sym = null;
+ var maybe_hashtab: ?&linux.Elf_Symndx = null;
+ var maybe_versym: ?&u16 = null;
+ var maybe_verdef: ?&elf.Verdef = null;
+
+ {
+ var i: usize = 0;
+ while (dynv[i] != 0) : (i += 2) {
+ const p = base + dynv[i + 1];
+ switch (dynv[i]) {
+ elf.DT_STRTAB => maybe_strings = @intToPtr(&u8, p),
+ elf.DT_SYMTAB => maybe_syms = @intToPtr(&elf.Sym, p),
+ elf.DT_HASH => maybe_hashtab = @intToPtr(&linux.Elf_Symndx, p),
+ elf.DT_VERSYM => maybe_versym = @intToPtr(&u16, p),
+ elf.DT_VERDEF => maybe_verdef = @intToPtr(&elf.Verdef, p),
+ else => {},
+ }
+ }
+ }
+
+ const strings = maybe_strings ?? return 0;
+ const syms = maybe_syms ?? return 0;
+ const hashtab = maybe_hashtab ?? return 0;
+ if (maybe_verdef == null) maybe_versym = null;
+
+
+ const OK_TYPES = (1<<elf.STT_NOTYPE | 1<<elf.STT_OBJECT | 1<<elf.STT_FUNC | 1<<elf.STT_COMMON);
+ const OK_BINDS = (1<<elf.STB_GLOBAL | 1<<elf.STB_WEAK | 1<<elf.STB_GNU_UNIQUE);
+
+ var i: usize = 0;
+ while (i < hashtab[1]) : (i += 1) {
+ if (0==(u32(1)<<u5(syms[i].st_info&0xf) & OK_TYPES)) continue;
+ if (0==(u32(1)<<u5(syms[i].st_info>>4) & OK_BINDS)) continue;
+ if (0==syms[i].st_shndx) continue;
+ if (!mem.eql(u8, name, cstr.toSliceConst(&strings[syms[i].st_name]))) continue;
+ if (maybe_versym) |versym| {
+ if (!checkver(??maybe_verdef, versym[i], vername, strings))
+ continue;
+ }
+ return base + syms[i].st_value;
+ }
+
+ return 0;
+}
+
+fn checkver(def_arg: &elf.Verdef, vsym_arg: i32, vername: []const u8, strings: &u8) bool {
+ var def = def_arg;
+ const vsym = @bitCast(u32, vsym_arg) & 0x7fff;
+ while (true) {
+ if (0==(def.vd_flags & elf.VER_FLG_BASE) and (def.vd_ndx & 0x7fff) == vsym)
+ break;
+ if (def.vd_next == 0)
+ return false;
+ def = @intToPtr(&elf.Verdef, @ptrToInt(def) + def.vd_next);
+ }
+ const aux = @intToPtr(&elf.Verdaux, @ptrToInt(def ) + def.vd_aux);
+ return mem.eql(u8, vername, cstr.toSliceConst(&strings[aux.vda_name]));
+}
std/os/linux/x86_64.zig
@@ -371,6 +371,13 @@ pub const F_GETOWN_EX = 16;
pub const F_GETOWNER_UIDS = 17;
+
+pub const VDSO_USEFUL = true;
+pub const VDSO_CGT_SYM = "__vdso_clock_gettime";
+pub const VDSO_CGT_VER = "LINUX_2.6";
+pub const VDSO_GETCPU_SYM = "__vdso_getcpu";
+pub const VDSO_GETCPU_VER = "LINUX_2.6";
+
pub fn syscall0(number: usize) usize {
return asm volatile ("syscall"
: [ret] "={rax}" (-> usize)
@@ -509,3 +516,4 @@ pub const dirent = extern struct {
d_name: u8, // field address is the address of first byte of name
};
+pub const Elf_Symndx = u32;
std/os/index.zig
@@ -478,6 +478,7 @@ fn posixExecveErrnoToErr(err: usize) PosixExecveError {
};
}
+pub var linux_aux_raw = []usize{0} ** 38;
pub var posix_environ_raw: []&u8 = undefined;
/// Caller must free result when done.
std/os/time.zig
@@ -160,13 +160,13 @@ pub const Timer = struct {
Os.windows => {
var freq: i64 = undefined;
var err = windows.QueryPerformanceFrequency(&freq);
- if (err == 0) return error.TimerUnsupported;
+ if (err == windows.FALSE) return error.TimerUnsupported;
self.frequency = u64(freq);
self.resolution = @divFloor(ns_per_s, self.frequency);
var start_time: i64 = undefined;
err = windows.QueryPerformanceCounter(&start_time);
- debug.assert(err != 0);
+ debug.assert(err != windows.FALSE);
self.start_time = u64(start_time);
},
Os.linux => {
@@ -236,7 +236,7 @@ pub const Timer = struct {
fn clockWindows() u64 {
var result: i64 = undefined;
var err = windows.QueryPerformanceCounter(&result);
- debug.assert(err != 0);
+ debug.assert(err != windows.FALSE);
return u64(result);
}
@@ -285,4 +285,4 @@ test "os.time.Timer" {
timer.reset();
debug.assert(timer.read() < time_1);
-}
\ No newline at end of file
+}
std/special/bootstrap.zig
@@ -48,22 +48,33 @@ extern fn WinMainCRTStartup() noreturn {
fn posixCallMainAndExit() noreturn {
const argc = *argc_ptr;
const argv = @ptrCast(&&u8, &argc_ptr[1]);
- const envp = @ptrCast(&?&u8, &argv[argc + 1]);
+ const envp_nullable = @ptrCast(&?&u8, &argv[argc + 1]);
+ var envp_count: usize = 0;
+ while (envp_nullable[envp_count]) |_| : (envp_count += 1) {}
+ const envp = @ptrCast(&&u8, envp_nullable)[0..envp_count];
+ if (builtin.os == builtin.Os.linux) {
+ const auxv = &@ptrCast(&usize, envp.ptr)[envp_count + 1];
+ var i: usize = 0;
+ while (auxv[i] != 0) : (i += 2) {
+ if (auxv[i] < std.os.linux_aux_raw.len) std.os.linux_aux_raw[auxv[i]] = auxv[i+1];
+ }
+ std.debug.assert(std.os.linux_aux_raw[std.elf.AT_PAGESZ] == std.os.page_size);
+ }
+
std.os.posix.exit(callMainWithArgs(argc, argv, envp));
}
-fn callMainWithArgs(argc: usize, argv: &&u8, envp: &?&u8) u8 {
+fn callMainWithArgs(argc: usize, argv: &&u8, envp: []&u8) u8 {
std.os.ArgIteratorPosix.raw = argv[0..argc];
-
- var env_count: usize = 0;
- while (envp[env_count] != null) : (env_count += 1) {}
- std.os.posix_environ_raw = @ptrCast(&&u8, envp)[0..env_count];
-
+ std.os.posix_environ_raw = envp;
return callMain();
}
extern fn main(c_argc: i32, c_argv: &&u8, c_envp: &?&u8) i32 {
- return callMainWithArgs(usize(c_argc), c_argv, c_envp);
+ var env_count: usize = 0;
+ while (c_envp[env_count] != null) : (env_count += 1) {}
+ const envp = @ptrCast(&&u8, c_envp)[0..env_count];
+ return callMainWithArgs(usize(c_argc), c_argv, envp);
}
fn callMain() u8 {
std/elf.zig
@@ -7,6 +7,246 @@ const mem = std.mem;
const debug = std.debug;
const InStream = std.stream.InStream;
+pub const AT_NULL = 0;
+pub const AT_IGNORE = 1;
+pub const AT_EXECFD = 2;
+pub const AT_PHDR = 3;
+pub const AT_PHENT = 4;
+pub const AT_PHNUM = 5;
+pub const AT_PAGESZ = 6;
+pub const AT_BASE = 7;
+pub const AT_FLAGS = 8;
+pub const AT_ENTRY = 9;
+pub const AT_NOTELF = 10;
+pub const AT_UID = 11;
+pub const AT_EUID = 12;
+pub const AT_GID = 13;
+pub const AT_EGID = 14;
+pub const AT_CLKTCK = 17;
+pub const AT_PLATFORM = 15;
+pub const AT_HWCAP = 16;
+pub const AT_FPUCW = 18;
+pub const AT_DCACHEBSIZE = 19;
+pub const AT_ICACHEBSIZE = 20;
+pub const AT_UCACHEBSIZE = 21;
+pub const AT_IGNOREPPC = 22;
+pub const AT_SECURE = 23;
+pub const AT_BASE_PLATFORM = 24;
+pub const AT_RANDOM = 25;
+pub const AT_HWCAP2 = 26;
+pub const AT_EXECFN = 31;
+pub const AT_SYSINFO = 32;
+pub const AT_SYSINFO_EHDR = 33;
+pub const AT_L1I_CACHESHAPE = 34;
+pub const AT_L1D_CACHESHAPE = 35;
+pub const AT_L2_CACHESHAPE = 36;
+pub const AT_L3_CACHESHAPE = 37;
+pub const AT_L1I_CACHESIZE = 40;
+pub const AT_L1I_CACHEGEOMETRY = 41;
+pub const AT_L1D_CACHESIZE = 42;
+pub const AT_L1D_CACHEGEOMETRY = 43;
+pub const AT_L2_CACHESIZE = 44;
+pub const AT_L2_CACHEGEOMETRY = 45;
+pub const AT_L3_CACHESIZE = 46;
+pub const AT_L3_CACHEGEOMETRY = 47;
+
+pub const DT_NULL = 0;
+pub const DT_NEEDED = 1;
+pub const DT_PLTRELSZ = 2;
+pub const DT_PLTGOT = 3;
+pub const DT_HASH = 4;
+pub const DT_STRTAB = 5;
+pub const DT_SYMTAB = 6;
+pub const DT_RELA = 7;
+pub const DT_RELASZ = 8;
+pub const DT_RELAENT = 9;
+pub const DT_STRSZ = 10;
+pub const DT_SYMENT = 11;
+pub const DT_INIT = 12;
+pub const DT_FINI = 13;
+pub const DT_SONAME = 14;
+pub const DT_RPATH = 15;
+pub const DT_SYMBOLIC = 16;
+pub const DT_REL = 17;
+pub const DT_RELSZ = 18;
+pub const DT_RELENT = 19;
+pub const DT_PLTREL = 20;
+pub const DT_DEBUG = 21;
+pub const DT_TEXTREL = 22;
+pub const DT_JMPREL = 23;
+pub const DT_BIND_NOW = 24;
+pub const DT_INIT_ARRAY = 25;
+pub const DT_FINI_ARRAY = 26;
+pub const DT_INIT_ARRAYSZ = 27;
+pub const DT_FINI_ARRAYSZ = 28;
+pub const DT_RUNPATH = 29;
+pub const DT_FLAGS = 30;
+pub const DT_ENCODING = 32;
+pub const DT_PREINIT_ARRAY = 32;
+pub const DT_PREINIT_ARRAYSZ = 33;
+pub const DT_SYMTAB_SHNDX = 34;
+pub const DT_NUM = 35;
+pub const DT_LOOS = 0x6000000d;
+pub const DT_HIOS = 0x6ffff000;
+pub const DT_LOPROC = 0x70000000;
+pub const DT_HIPROC = 0x7fffffff;
+pub const DT_PROCNUM = DT_MIPS_NUM;
+
+pub const DT_VALRNGLO = 0x6ffffd00;
+pub const DT_GNU_PRELINKED = 0x6ffffdf5;
+pub const DT_GNU_CONFLICTSZ = 0x6ffffdf6;
+pub const DT_GNU_LIBLISTSZ = 0x6ffffdf7;
+pub const DT_CHECKSUM = 0x6ffffdf8;
+pub const DT_PLTPADSZ = 0x6ffffdf9;
+pub const DT_MOVEENT = 0x6ffffdfa;
+pub const DT_MOVESZ = 0x6ffffdfb;
+pub const DT_FEATURE_1 = 0x6ffffdfc;
+pub const DT_POSFLAG_1 = 0x6ffffdfd;
+
+pub const DT_SYMINSZ = 0x6ffffdfe;
+pub const DT_SYMINENT = 0x6ffffdff;
+pub const DT_VALRNGHI = 0x6ffffdff;
+pub const DT_VALNUM = 12;
+
+pub const DT_ADDRRNGLO = 0x6ffffe00;
+pub const DT_GNU_HASH = 0x6ffffef5;
+pub const DT_TLSDESC_PLT = 0x6ffffef6;
+pub const DT_TLSDESC_GOT = 0x6ffffef7;
+pub const DT_GNU_CONFLICT = 0x6ffffef8;
+pub const DT_GNU_LIBLIST = 0x6ffffef9;
+pub const DT_CONFIG = 0x6ffffefa;
+pub const DT_DEPAUDIT = 0x6ffffefb;
+pub const DT_AUDIT = 0x6ffffefc;
+pub const DT_PLTPAD = 0x6ffffefd;
+pub const DT_MOVETAB = 0x6ffffefe;
+pub const DT_SYMINFO = 0x6ffffeff;
+pub const DT_ADDRRNGHI = 0x6ffffeff;
+pub const DT_ADDRNUM = 11;
+
+
+pub const DT_VERSYM = 0x6ffffff0;
+
+pub const DT_RELACOUNT = 0x6ffffff9;
+pub const DT_RELCOUNT = 0x6ffffffa;
+
+
+pub const DT_FLAGS_1 = 0x6ffffffb;
+pub const DT_VERDEF = 0x6ffffffc;
+
+pub const DT_VERDEFNUM = 0x6ffffffd;
+pub const DT_VERNEED = 0x6ffffffe;
+
+pub const DT_VERNEEDNUM = 0x6fffffff;
+pub const DT_VERSIONTAGNUM = 16;
+
+
+
+pub const DT_AUXILIARY = 0x7ffffffd;
+pub const DT_FILTER = 0x7fffffff;
+pub const DT_EXTRANUM = 3;
+
+
+pub const DT_SPARC_REGISTER = 0x70000001;
+pub const DT_SPARC_NUM = 2;
+
+pub const DT_MIPS_RLD_VERSION = 0x70000001;
+pub const DT_MIPS_TIME_STAMP = 0x70000002;
+pub const DT_MIPS_ICHECKSUM = 0x70000003;
+pub const DT_MIPS_IVERSION = 0x70000004;
+pub const DT_MIPS_FLAGS = 0x70000005;
+pub const DT_MIPS_BASE_ADDRESS = 0x70000006;
+pub const DT_MIPS_MSYM = 0x70000007;
+pub const DT_MIPS_CONFLICT = 0x70000008;
+pub const DT_MIPS_LIBLIST = 0x70000009;
+pub const DT_MIPS_LOCAL_GOTNO = 0x7000000a;
+pub const DT_MIPS_CONFLICTNO = 0x7000000b;
+pub const DT_MIPS_LIBLISTNO = 0x70000010;
+pub const DT_MIPS_SYMTABNO = 0x70000011;
+pub const DT_MIPS_UNREFEXTNO = 0x70000012;
+pub const DT_MIPS_GOTSYM = 0x70000013;
+pub const DT_MIPS_HIPAGENO = 0x70000014;
+pub const DT_MIPS_RLD_MAP = 0x70000016;
+pub const DT_MIPS_DELTA_CLASS = 0x70000017;
+pub const DT_MIPS_DELTA_CLASS_NO = 0x70000018;
+
+pub const DT_MIPS_DELTA_INSTANCE = 0x70000019;
+pub const DT_MIPS_DELTA_INSTANCE_NO = 0x7000001a;
+
+pub const DT_MIPS_DELTA_RELOC = 0x7000001b;
+pub const DT_MIPS_DELTA_RELOC_NO = 0x7000001c;
+
+pub const DT_MIPS_DELTA_SYM = 0x7000001d;
+
+pub const DT_MIPS_DELTA_SYM_NO = 0x7000001e;
+
+pub const DT_MIPS_DELTA_CLASSSYM = 0x70000020;
+
+pub const DT_MIPS_DELTA_CLASSSYM_NO = 0x70000021;
+
+pub const DT_MIPS_CXX_FLAGS = 0x70000022;
+pub const DT_MIPS_PIXIE_INIT = 0x70000023;
+pub const DT_MIPS_SYMBOL_LIB = 0x70000024;
+pub const DT_MIPS_LOCALPAGE_GOTIDX = 0x70000025;
+pub const DT_MIPS_LOCAL_GOTIDX = 0x70000026;
+pub const DT_MIPS_HIDDEN_GOTIDX = 0x70000027;
+pub const DT_MIPS_PROTECTED_GOTIDX = 0x70000028;
+pub const DT_MIPS_OPTIONS = 0x70000029;
+pub const DT_MIPS_INTERFACE = 0x7000002a;
+pub const DT_MIPS_DYNSTR_ALIGN = 0x7000002b;
+pub const DT_MIPS_INTERFACE_SIZE = 0x7000002c;
+pub const DT_MIPS_RLD_TEXT_RESOLVE_ADDR = 0x7000002d;
+
+pub const DT_MIPS_PERF_SUFFIX = 0x7000002e;
+
+pub const DT_MIPS_COMPACT_SIZE = 0x7000002f;
+pub const DT_MIPS_GP_VALUE = 0x70000030;
+pub const DT_MIPS_AUX_DYNAMIC = 0x70000031;
+
+pub const DT_MIPS_PLTGOT = 0x70000032;
+
+pub const DT_MIPS_RWPLT = 0x70000034;
+pub const DT_MIPS_RLD_MAP_REL = 0x70000035;
+pub const DT_MIPS_NUM = 0x36;
+
+pub const DT_ALPHA_PLTRO = (DT_LOPROC + 0);
+pub const DT_ALPHA_NUM = 1;
+
+pub const DT_PPC_GOT = (DT_LOPROC + 0);
+pub const DT_PPC_OPT = (DT_LOPROC + 1);
+pub const DT_PPC_NUM = 2;
+
+pub const DT_PPC64_GLINK = (DT_LOPROC + 0);
+pub const DT_PPC64_OPD = (DT_LOPROC + 1);
+pub const DT_PPC64_OPDSZ = (DT_LOPROC + 2);
+pub const DT_PPC64_OPT = (DT_LOPROC + 3);
+pub const DT_PPC64_NUM = 4;
+
+pub const DT_IA_64_PLT_RESERVE = (DT_LOPROC + 0);
+pub const DT_IA_64_NUM = 1;
+
+pub const DT_NIOS2_GP = 0x70000002;
+
+pub const PT_NULL = 0;
+pub const PT_LOAD = 1;
+pub const PT_DYNAMIC = 2;
+pub const PT_INTERP = 3;
+pub const PT_NOTE = 4;
+pub const PT_SHLIB = 5;
+pub const PT_PHDR = 6;
+pub const PT_TLS = 7;
+pub const PT_NUM = 8;
+pub const PT_LOOS = 0x60000000;
+pub const PT_GNU_EH_FRAME = 0x6474e550;
+pub const PT_GNU_STACK = 0x6474e551;
+pub const PT_GNU_RELRO = 0x6474e552;
+pub const PT_LOSUNW = 0x6ffffffa;
+pub const PT_SUNWBSS = 0x6ffffffa;
+pub const PT_SUNWSTACK = 0x6ffffffb;
+pub const PT_HISUNW = 0x6fffffff;
+pub const PT_HIOS = 0x6fffffff;
+pub const PT_LOPROC = 0x70000000;
+pub const PT_HIPROC = 0x7fffffff;
+
pub const SHT_NULL = 0;
pub const SHT_PROGBITS = 1;
pub const SHT_SYMTAB = 2;
@@ -31,6 +271,45 @@ pub const SHT_HIPROC = 0x7fffffff;
pub const SHT_LOUSER = 0x80000000;
pub const SHT_HIUSER = 0xffffffff;
+pub const STB_LOCAL = 0;
+pub const STB_GLOBAL = 1;
+pub const STB_WEAK = 2;
+pub const STB_NUM = 3;
+pub const STB_LOOS = 10;
+pub const STB_GNU_UNIQUE = 10;
+pub const STB_HIOS = 12;
+pub const STB_LOPROC = 13;
+pub const STB_HIPROC = 15;
+
+pub const STB_MIPS_SPLIT_COMMON = 13;
+
+pub const STT_NOTYPE = 0;
+pub const STT_OBJECT = 1;
+pub const STT_FUNC = 2;
+pub const STT_SECTION = 3;
+pub const STT_FILE = 4;
+pub const STT_COMMON = 5;
+pub const STT_TLS = 6;
+pub const STT_NUM = 7;
+pub const STT_LOOS = 10;
+pub const STT_GNU_IFUNC = 10;
+pub const STT_HIOS = 12;
+pub const STT_LOPROC = 13;
+pub const STT_HIPROC = 15;
+
+pub const STT_SPARC_REGISTER = 13;
+
+pub const STT_PARISC_MILLICODE = 13;
+
+pub const STT_HP_OPAQUE = (STT_LOOS + 0x1);
+pub const STT_HP_STUB = (STT_LOOS + 0x2);
+
+pub const STT_ARM_TFUNC = STT_LOPROC;
+pub const STT_ARM_16BIT = STT_HIPROC;
+
+pub const VER_FLG_BASE = 0x1;
+pub const VER_FLG_WEAK = 0x2;
+
pub const FileType = enum {
Relocatable,
Executable,
@@ -266,3 +545,335 @@ pub const Elf = struct {
try elf.in_file.seekTo(elf_section.offset);
}
};
+
+pub const EI_NIDENT = 16;
+pub const Elf32_Half = u16;
+pub const Elf64_Half = u16;
+pub const Elf32_Word = u32;
+pub const Elf32_Sword = i32;
+pub const Elf64_Word = u32;
+pub const Elf64_Sword = i32;
+pub const Elf32_Xword = u64;
+pub const Elf32_Sxword = i64;
+pub const Elf64_Xword = u64;
+pub const Elf64_Sxword = i64;
+pub const Elf32_Addr = u32;
+pub const Elf64_Addr = u64;
+pub const Elf32_Off = u32;
+pub const Elf64_Off = u64;
+pub const Elf32_Section = u16;
+pub const Elf64_Section = u16;
+pub const Elf32_Versym = Elf32_Half;
+pub const Elf64_Versym = Elf64_Half;
+pub const Elf32_Ehdr = extern struct {
+ e_ident: [EI_NIDENT]u8,
+ e_type: Elf32_Half,
+ e_machine: Elf32_Half,
+ e_version: Elf32_Word,
+ e_entry: Elf32_Addr,
+ e_phoff: Elf32_Off,
+ e_shoff: Elf32_Off,
+ e_flags: Elf32_Word,
+ e_ehsize: Elf32_Half,
+ e_phentsize: Elf32_Half,
+ e_phnum: Elf32_Half,
+ e_shentsize: Elf32_Half,
+ e_shnum: Elf32_Half,
+ e_shstrndx: Elf32_Half,
+};
+pub const Elf64_Ehdr = extern struct {
+ e_ident: [EI_NIDENT]u8,
+ e_type: Elf64_Half,
+ e_machine: Elf64_Half,
+ e_version: Elf64_Word,
+ e_entry: Elf64_Addr,
+ e_phoff: Elf64_Off,
+ e_shoff: Elf64_Off,
+ e_flags: Elf64_Word,
+ e_ehsize: Elf64_Half,
+ e_phentsize: Elf64_Half,
+ e_phnum: Elf64_Half,
+ e_shentsize: Elf64_Half,
+ e_shnum: Elf64_Half,
+ e_shstrndx: Elf64_Half,
+};
+pub const Elf32_Shdr = extern struct {
+ sh_name: Elf32_Word,
+ sh_type: Elf32_Word,
+ sh_flags: Elf32_Word,
+ sh_addr: Elf32_Addr,
+ sh_offset: Elf32_Off,
+ sh_size: Elf32_Word,
+ sh_link: Elf32_Word,
+ sh_info: Elf32_Word,
+ sh_addralign: Elf32_Word,
+ sh_entsize: Elf32_Word,
+};
+pub const Elf64_Shdr = extern struct {
+ sh_name: Elf64_Word,
+ sh_type: Elf64_Word,
+ sh_flags: Elf64_Xword,
+ sh_addr: Elf64_Addr,
+ sh_offset: Elf64_Off,
+ sh_size: Elf64_Xword,
+ sh_link: Elf64_Word,
+ sh_info: Elf64_Word,
+ sh_addralign: Elf64_Xword,
+ sh_entsize: Elf64_Xword,
+};
+pub const Elf32_Chdr = extern struct {
+ ch_type: Elf32_Word,
+ ch_size: Elf32_Word,
+ ch_addralign: Elf32_Word,
+};
+pub const Elf64_Chdr = extern struct {
+ ch_type: Elf64_Word,
+ ch_reserved: Elf64_Word,
+ ch_size: Elf64_Xword,
+ ch_addralign: Elf64_Xword,
+};
+pub const Elf32_Sym = extern struct {
+ st_name: Elf32_Word,
+ st_value: Elf32_Addr,
+ st_size: Elf32_Word,
+ st_info: u8,
+ st_other: u8,
+ st_shndx: Elf32_Section,
+};
+pub const Elf64_Sym = extern struct {
+ st_name: Elf64_Word,
+ st_info: u8,
+ st_other: u8,
+ st_shndx: Elf64_Section,
+ st_value: Elf64_Addr,
+ st_size: Elf64_Xword,
+};
+pub const Elf32_Syminfo = extern struct {
+ si_boundto: Elf32_Half,
+ si_flags: Elf32_Half,
+};
+pub const Elf64_Syminfo = extern struct {
+ si_boundto: Elf64_Half,
+ si_flags: Elf64_Half,
+};
+pub const Elf32_Rel = extern struct {
+ r_offset: Elf32_Addr,
+ r_info: Elf32_Word,
+};
+pub const Elf64_Rel = extern struct {
+ r_offset: Elf64_Addr,
+ r_info: Elf64_Xword,
+};
+pub const Elf32_Rela = extern struct {
+ r_offset: Elf32_Addr,
+ r_info: Elf32_Word,
+ r_addend: Elf32_Sword,
+};
+pub const Elf64_Rela = extern struct {
+ r_offset: Elf64_Addr,
+ r_info: Elf64_Xword,
+ r_addend: Elf64_Sxword,
+};
+pub const Elf32_Phdr = extern struct {
+ p_type: Elf32_Word,
+ p_offset: Elf32_Off,
+ p_vaddr: Elf32_Addr,
+ p_paddr: Elf32_Addr,
+ p_filesz: Elf32_Word,
+ p_memsz: Elf32_Word,
+ p_flags: Elf32_Word,
+ p_align: Elf32_Word,
+};
+pub const Elf64_Phdr = extern struct {
+ p_type: Elf64_Word,
+ p_flags: Elf64_Word,
+ p_offset: Elf64_Off,
+ p_vaddr: Elf64_Addr,
+ p_paddr: Elf64_Addr,
+ p_filesz: Elf64_Xword,
+ p_memsz: Elf64_Xword,
+ p_align: Elf64_Xword,
+};
+pub const Elf32_Dyn = extern struct {
+ d_tag: Elf32_Sword,
+ d_un: extern union {
+ d_val: Elf32_Word,
+ d_ptr: Elf32_Addr,
+ },
+};
+pub const Elf64_Dyn = extern struct {
+ d_tag: Elf64_Sxword,
+ d_un: extern union {
+ d_val: Elf64_Xword,
+ d_ptr: Elf64_Addr,
+ },
+};
+pub const Elf32_Verdef = extern struct {
+ vd_version: Elf32_Half,
+ vd_flags: Elf32_Half,
+ vd_ndx: Elf32_Half,
+ vd_cnt: Elf32_Half,
+ vd_hash: Elf32_Word,
+ vd_aux: Elf32_Word,
+ vd_next: Elf32_Word,
+};
+pub const Elf64_Verdef = extern struct {
+ vd_version: Elf64_Half,
+ vd_flags: Elf64_Half,
+ vd_ndx: Elf64_Half,
+ vd_cnt: Elf64_Half,
+ vd_hash: Elf64_Word,
+ vd_aux: Elf64_Word,
+ vd_next: Elf64_Word,
+};
+pub const Elf32_Verdaux = extern struct {
+ vda_name: Elf32_Word,
+ vda_next: Elf32_Word,
+};
+pub const Elf64_Verdaux = extern struct {
+ vda_name: Elf64_Word,
+ vda_next: Elf64_Word,
+};
+pub const Elf32_Verneed = extern struct {
+ vn_version: Elf32_Half,
+ vn_cnt: Elf32_Half,
+ vn_file: Elf32_Word,
+ vn_aux: Elf32_Word,
+ vn_next: Elf32_Word,
+};
+pub const Elf64_Verneed = extern struct {
+ vn_version: Elf64_Half,
+ vn_cnt: Elf64_Half,
+ vn_file: Elf64_Word,
+ vn_aux: Elf64_Word,
+ vn_next: Elf64_Word,
+};
+pub const Elf32_Vernaux = extern struct {
+ vna_hash: Elf32_Word,
+ vna_flags: Elf32_Half,
+ vna_other: Elf32_Half,
+ vna_name: Elf32_Word,
+ vna_next: Elf32_Word,
+};
+pub const Elf64_Vernaux = extern struct {
+ vna_hash: Elf64_Word,
+ vna_flags: Elf64_Half,
+ vna_other: Elf64_Half,
+ vna_name: Elf64_Word,
+ vna_next: Elf64_Word,
+};
+pub const Elf32_auxv_t = extern struct {
+ a_type: u32,
+ a_un: extern union {
+ a_val: u32,
+ },
+};
+pub const Elf64_auxv_t = extern struct {
+ a_type: u64,
+ a_un: extern union {
+ a_val: u64,
+ },
+};
+pub const Elf32_Nhdr = extern struct {
+ n_namesz: Elf32_Word,
+ n_descsz: Elf32_Word,
+ n_type: Elf32_Word,
+};
+pub const Elf64_Nhdr = extern struct {
+ n_namesz: Elf64_Word,
+ n_descsz: Elf64_Word,
+ n_type: Elf64_Word,
+};
+pub const Elf32_Move = extern struct {
+ m_value: Elf32_Xword,
+ m_info: Elf32_Word,
+ m_poffset: Elf32_Word,
+ m_repeat: Elf32_Half,
+ m_stride: Elf32_Half,
+};
+pub const Elf64_Move = extern struct {
+ m_value: Elf64_Xword,
+ m_info: Elf64_Xword,
+ m_poffset: Elf64_Xword,
+ m_repeat: Elf64_Half,
+ m_stride: Elf64_Half,
+};
+pub const Elf32_gptab = extern union {
+ gt_header: extern struct {
+ gt_current_g_value: Elf32_Word,
+ gt_unused: Elf32_Word,
+ },
+ gt_entry: extern struct {
+ gt_g_value: Elf32_Word,
+ gt_bytes: Elf32_Word,
+ },
+};
+pub const Elf32_RegInfo = extern struct {
+ ri_gprmask: Elf32_Word,
+ ri_cprmask: [4]Elf32_Word,
+ ri_gp_value: Elf32_Sword,
+};
+pub const Elf_Options = extern struct {
+ kind: u8,
+ size: u8,
+ @"section": Elf32_Section,
+ info: Elf32_Word,
+};
+pub const Elf_Options_Hw = extern struct {
+ hwp_flags1: Elf32_Word,
+ hwp_flags2: Elf32_Word,
+};
+pub const Elf32_Lib = extern struct {
+ l_name: Elf32_Word,
+ l_time_stamp: Elf32_Word,
+ l_checksum: Elf32_Word,
+ l_version: Elf32_Word,
+ l_flags: Elf32_Word,
+};
+pub const Elf64_Lib = extern struct {
+ l_name: Elf64_Word,
+ l_time_stamp: Elf64_Word,
+ l_checksum: Elf64_Word,
+ l_version: Elf64_Word,
+ l_flags: Elf64_Word,
+};
+pub const Elf32_Conflict = Elf32_Addr;
+pub const Elf_MIPS_ABIFlags_v0 = extern struct {
+ version: Elf32_Half,
+ isa_level: u8,
+ isa_rev: u8,
+ gpr_size: u8,
+ cpr1_size: u8,
+ cpr2_size: u8,
+ fp_abi: u8,
+ isa_ext: Elf32_Word,
+ ases: Elf32_Word,
+ flags1: Elf32_Word,
+ flags2: Elf32_Word,
+};
+
+pub const Ehdr = switch(@sizeOf(usize)) {
+ 4 => Elf32_Ehdr,
+ 8 => Elf64_Ehdr,
+ else => @compileError("expected pointer size of 32 or 64"),
+};
+pub const Phdr = switch(@sizeOf(usize)) {
+ 4 => Elf32_Phdr,
+ 8 => Elf64_Phdr,
+ else => @compileError("expected pointer size of 32 or 64"),
+};
+pub const Sym = switch(@sizeOf(usize)) {
+ 4 => Elf32_Sym,
+ 8 => Elf64_Sym,
+ else => @compileError("expected pointer size of 32 or 64"),
+};
+pub const Verdef = switch(@sizeOf(usize)) {
+ 4 => Elf32_Verdef,
+ 8 => Elf64_Verdef,
+ else => @compileError("expected pointer size of 32 or 64"),
+};
+pub const Verdaux = switch(@sizeOf(usize)) {
+ 4 => Elf32_Verdaux,
+ 8 => Elf64_Verdaux,
+ else => @compileError("expected pointer size of 32 or 64"),
+};
test/cases/atomics.zig
@@ -49,3 +49,23 @@ fn testAtomicLoad(ptr: &u8) void {
const x = @atomicLoad(u8, ptr, AtomicOrder.SeqCst);
assert(x == 42);
}
+
+test "cmpxchg with ptr" {
+ var data1: i32 = 1234;
+ var data2: i32 = 5678;
+ var data3: i32 = 9101;
+ var x: &i32 = &data1;
+ if (@cmpxchgWeak(&i32, &x, &data2, &data3, AtomicOrder.SeqCst, AtomicOrder.SeqCst)) |x1| {
+ assert(x1 == &data1);
+ } else {
+ @panic("cmpxchg should have failed");
+ }
+
+ while (@cmpxchgWeak(&i32, &x, &data1, &data3, AtomicOrder.SeqCst, AtomicOrder.SeqCst)) |x1| {
+ assert(x1 == &data1);
+ }
+ assert(x == &data3);
+
+ assert(@cmpxchgStrong(&i32, &x, &data3, &data2, AtomicOrder.SeqCst, AtomicOrder.SeqCst) == null);
+ assert(x == &data2);
+}
CMakeLists.txt
@@ -508,6 +508,7 @@ set(ZIG_STD_FILES
"os/index.zig"
"os/linux/errno.zig"
"os/linux/index.zig"
+ "os/linux/vdso.zig"
"os/linux/x86_64.zig"
"os/path.zig"
"os/time.zig"