Merge pull request #17319 from ziglang/elf-tls

elf: add basic TLS segment handling

Author: kubkon

src/link/Elf.zig

@@ -59,38 +59,6 @@ pub fn outputShndx(self: Atom) ?u16 {
     return self.output_section_index;
 }
 
-pub fn codeInObject(self: Atom, elf_file: *Elf) error{Overflow}![]const u8 {
-    const object = self.file(elf_file).?.object;
-    return object.shdrContents(self.input_section_index);
-}
-
-/// Returns atom's code and optionally uncompresses data if required (for compressed sections).
-/// Caller owns the memory.
-pub fn codeInObjectUncompressAlloc(self: Atom, elf_file: *Elf) ![]u8 {
-    const gpa = elf_file.base.allocator;
-    const data = try self.codeInObject(elf_file);
-    const shdr = self.inputShdr(elf_file);
-    if (shdr.sh_flags & elf.SHF_COMPRESSED != 0) {
-        const chdr = @as(*align(1) const elf.Elf64_Chdr, @ptrCast(data.ptr)).*;
-        switch (chdr.ch_type) {
-            .ZLIB => {
-                var stream = std.io.fixedBufferStream(data[@sizeOf(elf.Elf64_Chdr)..]);
-                var zlib_stream = std.compress.zlib.decompressStream(gpa, stream.reader()) catch
-                    return error.InputOutput;
-                defer zlib_stream.deinit();
-                const size = std.math.cast(usize, chdr.ch_size) orelse return error.Overflow;
-                const decomp = try gpa.alloc(u8, size);
-                const nread = zlib_stream.reader().readAll(decomp) catch return error.InputOutput;
-                if (nread != decomp.len) {
-                    return error.InputOutput;
-                }
-                return decomp;
-            },
-            else => @panic("TODO unhandled compression scheme"),
-        }
-    } else return gpa.dupe(u8, data);
-}
-
 pub fn priority(self: Atom, elf_file: *Elf) u64 {
     const index = self.file(elf_file).?.index();
     return (@as(u64, @intCast(index)) << 32) | @as(u64, @intCast(self.input_section_index));
@@ -327,7 +295,15 @@ pub fn freeRelocs(self: Atom, elf_file: *Elf) void {
     zig_module.relocs.items[self.relocs_section_index].clearRetainingCapacity();
 }
 
-pub fn scanRelocs(self: Atom, elf_file: *Elf, undefs: anytype) !void {
+pub fn scanRelocsRequiresCode(self: Atom, elf_file: *Elf) error{Overflow}!bool {
+    for (try self.relocs(elf_file)) |rel| {
+        if (rel.r_type() == elf.R_X86_64_GOTTPOFF) return true;
+    }
+    return false;
+}
+
+pub fn scanRelocs(self: Atom, elf_file: *Elf, code: ?[]const u8, undefs: anytype) !void {
+    const is_dyn_lib = elf_file.isDynLib();
     const file_ptr = self.file(elf_file).?;
     const rels = try self.relocs(elf_file);
     var i: usize = 0;
@@ -336,6 +312,8 @@ pub fn scanRelocs(self: Atom, elf_file: *Elf, undefs: anytype) !void {
 
         if (rel.r_type() == elf.R_X86_64_NONE) continue;
 
+        const r_offset = std.math.cast(usize, rel.r_offset) orelse return error.Overflow;
+
         const symbol_index = switch (file_ptr) {
             .zig_module => |x| x.symbol(rel.r_sym()),
             .object => |x| x.symbols.items[rel.r_sym()],
@@ -388,7 +366,54 @@ pub fn scanRelocs(self: Atom, elf_file: *Elf, undefs: anytype) !void {
 
             elf.R_X86_64_PC32 => {},
 
-            else => @panic("TODO"),
+            elf.R_X86_64_TPOFF32,
+            elf.R_X86_64_TPOFF64,
+            => {
+                if (is_dyn_lib) {
+                    // TODO
+                    // self.picError(symbol, rel, elf_file);
+                }
+            },
+
+            elf.R_X86_64_TLSGD => {
+                // TODO verify followed by appropriate relocation such as PLT32 __tls_get_addr
+
+                if (elf_file.isStatic() or
+                    (!symbol.flags.import and !is_dyn_lib))
+                {
+                    // Relax if building with -static flag as __tls_get_addr() will not be present in libc.a
+                    // We skip the next relocation.
+                    i += 1;
+                } else if (!symbol.flags.import and is_dyn_lib) {
+                    symbol.flags.needs_gottp = true;
+                    i += 1;
+                } else {
+                    symbol.flags.needs_tlsgd = true;
+                }
+            },
+
+            elf.R_X86_64_GOTTPOFF => {
+                const should_relax = blk: {
+                    // if (!elf_file.options.relax or is_shared or symbol.flags.import) break :blk false;
+                    if (!x86_64.canRelaxGotTpOff(code.?[r_offset - 3 ..])) break :blk false;
+                    break :blk true;
+                };
+                if (!should_relax) {
+                    symbol.flags.needs_gottp = true;
+                }
+            },
+
+            else => {
+                var err = try elf_file.addErrorWithNotes(1);
+                try err.addMsg(elf_file, "fatal linker error: unhandled relocation type {}", .{
+                    fmtRelocType(rel.r_type()),
+                });
+                try err.addNote(elf_file, "in {}:{s} at offset 0x{x}", .{
+                    self.file(elf_file).?.fmtPath(),
+                    self.name(elf_file),
+                    r_offset,
+                });
+            },
         }
     }
 }
@@ -430,7 +455,10 @@ pub fn resolveRelocs(self: Atom, elf_file: *Elf, code: []u8) !void {
     var stream = std.io.fixedBufferStream(code);
     const cwriter = stream.writer();
 
-    for (try self.relocs(elf_file)) |rel| {
+    const rels = try self.relocs(elf_file);
+    var i: usize = 0;
+    while (i < rels.len) : (i += 1) {
+        const rel = rels[i];
         const r_type = rel.r_type();
         if (r_type == elf.R_X86_64_NONE) continue;
 
@@ -463,9 +491,9 @@ pub fn resolveRelocs(self: Atom, elf_file: *Elf, code: []u8) !void {
         // Relative offset to the start of the global offset table.
         const G = @as(i64, @intCast(target.gotAddress(elf_file))) - GOT;
         // // Address of the thread pointer.
-        // const TP = @as(i64, @intCast(elf_file.getTpAddress()));
+        const TP = @as(i64, @intCast(elf_file.tpAddress()));
         // // Address of the dynamic thread pointer.
-        // const DTP = @as(i64, @intCast(elf_file.getDtpAddress()));
+        // const DTP = @as(i64, @intCast(elf_file.dtpAddress()));
 
         relocs_log.debug("  {s}: {x}: [{x} => {x}] G({x}) ({s})", .{
             fmtRelocType(r_type),
@@ -512,10 +540,43 @@ pub fn resolveRelocs(self: Atom, elf_file: *Elf, code: []u8) !void {
                 try cwriter.writeIntLittle(i32, @as(i32, @intCast(G + GOT + A - P)));
             },
 
-            else => {
-                log.err("TODO: unhandled relocation type {}", .{fmtRelocType(rel.r_type())});
-                @panic("TODO unhandled relocation type");
+            elf.R_X86_64_TPOFF32 => try cwriter.writeIntLittle(i32, @as(i32, @truncate(S + A - TP))),
+            elf.R_X86_64_TPOFF64 => try cwriter.writeIntLittle(i64, S + A - TP),
+
+            elf.R_X86_64_TLSGD => {
+                if (target.flags.has_tlsgd) {
+                    // TODO
+                    // const S_ = @as(i64, @intCast(target.tlsGdAddress(elf_file)));
+                    // try cwriter.writeIntLittle(i32, @as(i32, @intCast(S_ + A - P)));
+                } else if (target.flags.has_gottp) {
+                    // TODO
+                    // const S_ = @as(i64, @intCast(target.getGotTpAddress(elf_file)));
+                    // try relaxTlsGdToIe(relocs[i .. i + 2], @intCast(S_ - P), elf_file, &stream);
+                    i += 1;
+                } else {
+                    try x86_64.relaxTlsGdToLe(
+                        self,
+                        rels[i .. i + 2],
+                        @as(i32, @intCast(S - TP)),
+                        elf_file,
+                        &stream,
+                    );
+                    i += 1;
+                }
+            },
+
+            elf.R_X86_64_GOTTPOFF => {
+                if (target.flags.has_gottp) {
+                    // TODO
+                    // const S_ = @as(i64, @intCast(target.gotTpAddress(elf_file)));
+                    // try cwriter.writeIntLittle(i32, @as(i32, @intCast(S_ + A - P)));
+                } else {
+                    x86_64.relaxGotTpOff(code[r_offset - 3 ..]) catch unreachable;
+                    try cwriter.writeIntLittle(i32, @as(i32, @intCast(S - TP)));
+                }
             },
+
+            else => {},
         }
     }
 }
@@ -681,6 +742,80 @@ const x86_64 = struct {
         }
     }
 
+    pub fn canRelaxGotTpOff(code: []const u8) bool {
+        const old_inst = disassemble(code) orelse return false;
+        switch (old_inst.encoding.mnemonic) {
+            .mov => if (Instruction.new(old_inst.prefix, .mov, &.{
+                old_inst.ops[0],
+                // TODO: hack to force imm32s in the assembler
+                .{ .imm = Immediate.s(-129) },
+            })) |inst| {
+                inst.encode(std.io.null_writer, .{}) catch return false;
+                return true;
+            } else |_| return false,
+            else => return false,
+        }
+    }
+
+    pub fn relaxGotTpOff(code: []u8) !void {
+        const old_inst = disassemble(code) orelse return error.RelaxFail;
+        switch (old_inst.encoding.mnemonic) {
+            .mov => {
+                const inst = try Instruction.new(old_inst.prefix, .mov, &.{
+                    old_inst.ops[0],
+                    // TODO: hack to force imm32s in the assembler
+                    .{ .imm = Immediate.s(-129) },
+                });
+                relocs_log.debug("    relaxing {} => {}", .{ old_inst.encoding, inst.encoding });
+                encode(&.{inst}, code) catch return error.RelaxFail;
+            },
+            else => return error.RelaxFail,
+        }
+    }
+
+    pub fn relaxTlsGdToLe(
+        self: Atom,
+        rels: []align(1) const elf.Elf64_Rela,
+        value: i32,
+        elf_file: *Elf,
+        stream: anytype,
+    ) !void {
+        assert(rels.len == 2);
+        const writer = stream.writer();
+        switch (rels[1].r_type()) {
+            elf.R_X86_64_PC32,
+            elf.R_X86_64_PLT32,
+            elf.R_X86_64_GOTPCREL,
+            elf.R_X86_64_GOTPCRELX,
+            => {
+                var insts = [_]u8{
+                    0x64, 0x48, 0x8b, 0x04, 0x25, 0, 0, 0, 0, // movq %fs:0,%rax
+                    0x48, 0x81, 0xc0, 0, 0, 0, 0, // add $tp_offset, %rax
+                };
+                std.mem.writeIntLittle(i32, insts[12..][0..4], value);
+                try stream.seekBy(-4);
+                try writer.writeAll(&insts);
+                relocs_log.debug("    relaxing {} and {}", .{
+                    fmtRelocType(rels[0].r_type()),
+                    fmtRelocType(rels[1].r_type()),
+                });
+            },
+
+            else => {
+                var err = try elf_file.addErrorWithNotes(1);
+                try err.addMsg(elf_file, "fatal linker error: rewrite {} when followed by {}", .{
+                    fmtRelocType(rels[0].r_type()),
+                    fmtRelocType(rels[1].r_type()),
+                });
+                try err.addNote(elf_file, "in {}:{s} at offset 0x{x}", .{
+                    self.file(elf_file).?.fmtPath(),
+                    self.name(elf_file),
+                    rels[0].r_offset,
+                });
+            },
+        }
+    }
+
     fn disassemble(code: []const u8) ?Instruction {
         var disas = Disassembler.init(code);
         const inst = disas.next() catch return null;

src/link/Elf/Atom.zig

@@ -208,6 +208,8 @@ fn getOutputSectionIndex(self: *Object, elf_file: *Elf, shdr: elf.Elf64_Shdr) er
                 break :blk prefix;
             }
         }
+        if (std.mem.eql(u8, name, ".tcommon")) break :blk ".tbss";
+        if (std.mem.eql(u8, name, ".common")) break :blk ".bss";
         break :blk name;
     };
     const @"type" = switch (shdr.sh_type) {
@@ -233,8 +235,7 @@ fn getOutputSectionIndex(self: *Object, elf_file: *Elf, shdr: elf.Elf64_Shdr) er
         const is_alloc = flags & elf.SHF_ALLOC != 0;
         const is_write = flags & elf.SHF_WRITE != 0;
         const is_exec = flags & elf.SHF_EXECINSTR != 0;
-        const is_tls = flags & elf.SHF_TLS != 0;
-        if (!is_alloc or is_tls) {
+        if (!is_alloc) {
             log.err("{}: output section {s} not found", .{ self.fmtPath(), name });
             @panic("TODO: missing output section!");
         }
@@ -243,7 +244,7 @@ fn getOutputSectionIndex(self: *Object, elf_file: *Elf, shdr: elf.Elf64_Shdr) er
         if (is_exec) phdr_flags |= elf.PF_X;
         const phdr_index = try elf_file.allocateSegment(.{
             .size = Elf.padToIdeal(shdr.sh_size),
-            .alignment = if (is_tls) shdr.sh_addralign else elf_file.page_size,
+            .alignment = elf_file.page_size,
             .flags = phdr_flags,
         });
         const shndx = try elf_file.allocateAllocSection(.{
@@ -428,7 +429,13 @@ pub fn scanRelocs(self: *Object, elf_file: *Elf, undefs: anytype) !void {
         const shdr = atom.inputShdr(elf_file);
         if (shdr.sh_flags & elf.SHF_ALLOC == 0) continue;
         if (shdr.sh_type == elf.SHT_NOBITS) continue;
-        try atom.scanRelocs(elf_file, undefs);
+        if (try atom.scanRelocsRequiresCode(elf_file)) {
+            // TODO ideally, we don't have to decompress at this stage (should already be done)
+            // and we just fetch the code slice.
+            const code = try self.codeDecompressAlloc(elf_file, atom_index);
+            defer elf_file.base.allocator.free(code);
+            try atom.scanRelocs(elf_file, code, undefs);
+        } else try atom.scanRelocs(elf_file, null, undefs);
     }
 
     for (self.cies.items) |cie| {
@@ -591,7 +598,7 @@ pub fn convertCommonSymbols(self: *Object, elf_file: *Elf) !void {
         try self.atoms.append(gpa, atom_index);
 
         const is_tls = global.getType(elf_file) == elf.STT_TLS;
-        const name = if (is_tls) ".tls_common" else ".common";
+        const name = if (is_tls) ".tbss" else ".bss";
 
         const atom = elf_file.atom(atom_index).?;
         atom.atom_index = atom_index;
@@ -685,14 +692,43 @@ pub fn globals(self: *Object) []const Symbol.Index {
     return self.symbols.items[start..];
 }
 
-pub fn shdrContents(self: *Object, index: u32) error{Overflow}![]const u8 {
+fn shdrContents(self: Object, index: u32) error{Overflow}![]const u8 {
     assert(index < self.shdrs.items.len);
     const shdr = self.shdrs.items[index];
     const offset = math.cast(usize, shdr.sh_offset) orelse return error.Overflow;
     const size = math.cast(usize, shdr.sh_size) orelse return error.Overflow;
     return self.data[offset..][0..size];
 }
 
+/// Returns atom's code and optionally uncompresses data if required (for compressed sections).
+/// Caller owns the memory.
+pub fn codeDecompressAlloc(self: Object, elf_file: *Elf, atom_index: Atom.Index) ![]u8 {
+    const gpa = elf_file.base.allocator;
+    const atom_ptr = elf_file.atom(atom_index).?;
+    assert(atom_ptr.file_index == self.index);
+    const data = try self.shdrContents(atom_ptr.input_section_index);
+    const shdr = atom_ptr.inputShdr(elf_file);
+    if (shdr.sh_flags & elf.SHF_COMPRESSED != 0) {
+        const chdr = @as(*align(1) const elf.Elf64_Chdr, @ptrCast(data.ptr)).*;
+        switch (chdr.ch_type) {
+            .ZLIB => {
+                var stream = std.io.fixedBufferStream(data[@sizeOf(elf.Elf64_Chdr)..]);
+                var zlib_stream = std.compress.zlib.decompressStream(gpa, stream.reader()) catch
+                    return error.InputOutput;
+                defer zlib_stream.deinit();
+                const size = std.math.cast(usize, chdr.ch_size) orelse return error.Overflow;
+                const decomp = try gpa.alloc(u8, size);
+                const nread = zlib_stream.reader().readAll(decomp) catch return error.InputOutput;
+                if (nread != decomp.len) {
+                    return error.InputOutput;
+                }
+                return decomp;
+            },
+            else => @panic("TODO unhandled compression scheme"),
+        }
+    } else return gpa.dupe(u8, data);
+}
+
 fn getString(self: *Object, off: u32) [:0]const u8 {
     assert(off < self.strtab.len);
     return mem.sliceTo(@as([*:0]const u8, @ptrCast(self.strtab.ptr + off)), 0);

src/link/Elf/Object.zig

@@ -196,9 +196,10 @@ pub fn setOutputSym(symbol: Symbol, elf_file: *Elf, out: *elf.Elf64_Sym) void {
         //     if (symbol.flags.is_canonical) break :blk symbol.address(.{}, elf_file);
         //     break :blk 0;
         // }
-        // if (st_shndx == elf.SHN_ABS) break :blk symbol.value;
-        // const shdr = &elf_file.sections.items(.shdr)[st_shndx];
-        // if (Elf.shdrIsTls(shdr)) break :blk symbol.value - elf_file.getTlsAddress();
+        if (st_shndx == elf.SHN_ABS) break :blk symbol.value;
+        const shdr = &elf_file.shdrs.items[st_shndx];
+        if (shdr.sh_flags & elf.SHF_TLS != 0 and file_ptr != .linker_defined)
+            break :blk symbol.value - elf_file.tlsAddress();
         break :blk symbol.value;
     };
     out.* = .{
@@ -327,10 +328,12 @@ pub const Flags = packed struct {
     has_dynamic: bool = false,
 
     /// Whether the symbol contains TLSGD indirection.
-    tlsgd: bool = false,
+    needs_tlsgd: bool = false,
+    has_tlsgd: bool = false,
 
     /// Whether the symbol contains GOTTP indirection.
-    gottp: bool = false,
+    needs_gottp: bool = false,
+    has_gottp: bool = false,
 
     /// Whether the symbol contains TLSDESC indirection.
     tlsdesc: bool = false,