Merge remote-tracking branch 'origin/master' into llvm7

1 files changed, 89 insertions, 0 deletions

diff --git a/std/os/linux/vdso.zig b/std/os/linux/vdso.zig
new file mode 100644
index 0000000000..f4fb513af9
--- /dev/null
+++ b/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]));
+}