srctree

try self.base.file.?.pwriteAll(buffer, sh_offset);

}

 

try self.reportUndefinedSymbols(&undefs);

 

if (has_reloc_errors) return error.FlushFailure;

nlocals += 1;

}

 

th.output_symtab_ctx.ilocal = nlocals + 1;

th.calcSymtabSize(self);

nlocals += th.output_symtab_ctx.nlocals;

strsize += th.output_symtab_ctx.strsize;

 

for (files.items) |index| {

const file_ptr = self.file(index).?;

 

self.writeSectionSymbols();

 

th.writeSymtab(self);

 

if (self.zigObjectPtr()) |zig_object| {

zig_object.asFile().writeSymtab(self);

try writer.print("linker_defined({d}) : (linker defined)\n", .{index});

try writer.print("{}\n", .{linker_defined.fmtSymtab(self)});

}

}

try writer.print("{}\n", .{self.zig_got.fmt(self)});

try writer.print("{}\n", .{self.got.fmt(self)});

try writer.print("{}\n", .{self.plt.fmt(self)});

 

pub fn createThunks(shndx: u32, elf_file: *Elf) !void {

const gpa = elf_file.base.comp.gpa;

const cpu_arch = elf_file.getTarget().cpu.arch;

const shdr = &elf_file.shdrs.items[shndx];

const atoms = elf_file.output_sections.get(shndx).?.items;

assert(atoms.len > 0);

start_atom.value = try advance(shdr, start_atom.size, start_atom.alignment);

i += 1;

 

const atom_index = atoms[i];

const atom = elf_file.atom(atom_index).?;

assert(atom.flags.alive);

atom.value = try advance(shdr, atom.size, atom.alignment);

}

 

}

 

pub fn write(thunk: Thunk, elf_file: *Elf, writer: anytype) !void {

.aarch64 => try aarch64.write(thunk, elf_file, writer),

.x86_64, .riscv64 => unreachable,

else => @panic("unhandled arch"),

 

.os_tag = .linux,

.abi = .gnu,

});

const riscv64_musl = b.resolveTargetQuery(.{

.cpu_arch = .riscv64,

.os_tag = .linux,

elf_step.dependOn(testMismatchedCpuArchitectureError(b, .{ .target = x86_64_musl }));

elf_step.dependOn(testZText(b, .{ .target = x86_64_gnu }));

 

// x86_64 self-hosted backend

elf_step.dependOn(testEmitRelocatable(b, .{ .use_llvm = false, .target = x86_64_musl }));

elf_step.dependOn(testEmitStaticLibZig(b, .{ .use_llvm = false, .target = x86_64_musl }));

return test_step;

}

 

fn testTlsDfStaticTls(b: *Build, opts: Options) *Step {

const test_step = addTestStep(b, "tls-df-static-tls", opts);

 

 

}

 

fn testDeadStrip(b: *Build, opts: Options) *Step {

 

const obj = addObject(b, opts, .{ .name = "a", .cpp_source_bytes =

\\#include <stdio.h>

}

 

fn testDeadStripDylibs(b: *Build, opts: Options) *Step {

 

const main_o = addObject(b, opts, .{ .name = "main", .c_source_bytes =

\\#include <objc/runtime.h>

}

 

fn testDylib(b: *Build, opts: Options) *Step {

 

const dylib = addSharedLibrary(b, opts, .{ .name = "a", .c_source_bytes =

\\#include<stdio.h>

}

 

fn testDylibVersionTbd(b: *Build, opts: Options) *Step {

 

const tbd = tbd: {

const wf = WriteFile.create(b);

}

 

fn testEmptyObject(b: *Build, opts: Options) *Step {

 

const empty = addObject(b, opts, .{ .name = "empty", .c_source_bytes = "" });

 

}

 

fn testEmptyZig(b: *Build, opts: Options) *Step {

 

const exe = addExecutable(b, opts, .{ .name = "empty", .zig_source_bytes = "pub fn main() void {}" });

 

}

 

fn testEntryPoint(b: *Build, opts: Options) *Step {

 

const exe = addExecutable(b, opts, .{ .name = "main", .c_source_bytes =

\\#include<stdio.h>

}

 

fn testEntryPointArchive(b: *Build, opts: Options) *Step {

 

const lib = addStaticLibrary(b, opts, .{ .name = "main", .c_source_bytes = "int main() { return 0; }" });

 

}

 

fn testEntryPointDylib(b: *Build, opts: Options) *Step {

 

const dylib = addSharedLibrary(b, opts, .{ .name = "a" });

addCSourceBytes(dylib,

}

 

fn testHeaderpad(b: *Build, opts: Options) *Step {

 

const addExe = struct {

fn addExe(bb: *Build, o: Options, name: []const u8) *Compile {

 

// Adapted from https://github.com/llvm/llvm-project/blob/main/lld/test/MachO/weak-header-flags.s

fn testHeaderWeakFlags(b: *Build, opts: Options) *Step {

 

const obj1 = addObject(b, opts, .{ .name = "a", .asm_source_bytes =

\\.globl _x

}

 

fn testHelloC(b: *Build, opts: Options) *Step {

 

const exe = addExecutable(b, opts, .{ .name = "main", .c_source_bytes =

\\#include <stdio.h>

}

 

fn testHelloZig(b: *Build, opts: Options) *Step {

 

const exe = addExecutable(b, opts, .{ .name = "main", .zig_source_bytes =

\\const std = @import("std");

}

 

fn testLargeBss(b: *Build, opts: Options) *Step {

 

// TODO this test used use a 4GB zerofill section but this actually fails and causes every

// linker I tried misbehave in different ways. This only happened on arm64. I thought that

}

 

fn testLayout(b: *Build, opts: Options) *Step {

 

const exe = addExecutable(b, opts, .{ .name = "main", .c_source_bytes =

\\#include <stdio.h>

}

 

fn testLinkDirectlyCppTbd(b: *Build, opts: Options) *Step {

 

const sdk = std.zig.system.darwin.getSdk(b.allocator, opts.target.result) orelse

@panic("macOS SDK is required to run the test");

}

 

fn testLinksection(b: *Build, opts: Options) *Step {

 

const obj = addObject(b, opts, .{ .name = "main", .zig_source_bytes =

\\export var test_global: u32 linksection("__DATA,__TestGlobal") = undefined;

}

 

fn testMhExecuteHeader(b: *Build, opts: Options) *Step {

 

const exe = addExecutable(b, opts, .{ .name = "main", .c_source_bytes = "int main() { return 0; }" });

 

}

 

fn testNoDeadStrip(b: *Build, opts: Options) *Step {

 

const exe = addExecutable(b, opts, .{ .name = "name", .c_source_bytes =

\\__attribute__((used)) int bogus1 = 0;

}

 

fn testNoExportsDylib(b: *Build, opts: Options) *Step {

 

const dylib = addSharedLibrary(b, opts, .{ .name = "a", .c_source_bytes = "static void abc() {}" });

 

}

 

fn testNeededFramework(b: *Build, opts: Options) *Step {

 

const exe = addExecutable(b, opts, .{ .name = "main", .c_source_bytes = "int main() { return 0; }" });

exe.root_module.linkFramework("Cocoa", .{ .needed = true });

}

 

fn testNeededLibrary(b: *Build, opts: Options) *Step {

 

const dylib = addSharedLibrary(b, opts, .{ .name = "a", .c_source_bytes = "int a = 42;" });

 

}

 

fn testObjc(b: *Build, opts: Options) *Step {

 

const lib = addStaticLibrary(b, opts, .{ .name = "a", .objc_source_bytes =

\\#import <Foundation/Foundation.h>

}

 

fn testObjcpp(b: *Build, opts: Options) *Step {

 

const foo_h = foo_h: {

const wf = WriteFile.create(b);

}

 

fn testPagezeroSize(b: *Build, opts: Options) *Step {

 

{

const exe = addExecutable(b, opts, .{ .name = "main", .c_source_bytes = "int main () { return 0; }" });

}

 

fn testReexportsZig(b: *Build, opts: Options) *Step {

 

const lib = addStaticLibrary(b, opts, .{ .name = "a", .zig_source_bytes =

\\const x: i32 = 42;

}

 

fn testRelocatable(b: *Build, opts: Options) *Step {

 

const a_o = addObject(b, opts, .{ .name = "a", .cpp_source_bytes =

\\#include <stdexcept>

}

 

fn testRelocatableZig(b: *Build, opts: Options) *Step {

 

const a_o = addObject(b, opts, .{ .name = "a", .zig_source_bytes =

\\const std = @import("std");

}

 

fn testSearchStrategy(b: *Build, opts: Options) *Step {

 

const obj = addObject(b, opts, .{ .name = "a", .c_source_bytes =

\\#include<stdio.h>

}

 

fn testSectionBoundarySymbols(b: *Build, opts: Options) *Step {

 

const obj1 = addObject(b, opts, .{

.name = "obj1",

}

 

fn testSegmentBoundarySymbols(b: *Build, opts: Options) *Step {

 

const obj1 = addObject(b, opts, .{ .name = "a", .cpp_source_bytes =

\\constexpr const char* MESSAGE __attribute__((used, section("__DATA_CONST_1,__message_ptr"))) = "codebase";

}

 

fn testStackSize(b: *Build, opts: Options) *Step {

 

const exe = addExecutable(b, opts, .{ .name = "main", .c_source_bytes = "int main() { return 0; }" });

exe.stack_size = 0x100000000;

}

 

fn testTbdv3(b: *Build, opts: Options) *Step {

 

const dylib = addSharedLibrary(b, opts, .{ .name = "a", .c_source_bytes = "int getFoo() { return 42; }" });

 

}

 

fn testTentative(b: *Build, opts: Options) *Step {

 

const exe = addExecutable(b, opts, .{ .name = "main" });

addCSourceBytes(exe,

}

 

fn testThunks(b: *Build, opts: Options) *Step {

 

const exe = addExecutable(b, opts, .{ .name = "main", .c_source_bytes =

\\#include <stdio.h>

}

 

fn testTls(b: *Build, opts: Options) *Step {

 

const dylib = addSharedLibrary(b, opts, .{ .name = "a", .c_source_bytes =

\\_Thread_local int a;

}

 

fn testTlsLargeTbss(b: *Build, opts: Options) *Step {

 

const exe = addExecutable(b, opts, .{ .name = "main", .c_source_bytes =

\\#include <stdio.h>

}

 

fn testTwoLevelNamespace(b: *Build, opts: Options) *Step {

 

const liba = addSharedLibrary(b, opts, .{ .name = "a", .c_source_bytes =

\\#include <stdio.h>

}

 

fn testUndefinedFlag(b: *Build, opts: Options) *Step {

 

const obj = addObject(b, opts, .{ .name = "a", .c_source_bytes = "int foo = 42;" });

 

}

 

fn testUnwindInfo(b: *Build, opts: Options) *Step {

 

const all_h = all_h: {

const wf = WriteFile.create(b);

}

 

fn testUnwindInfoNoSubsectionsArm64(b: *Build, opts: Options) *Step {

 

const a_o = addObject(b, opts, .{ .name = "a", .asm_source_bytes =

\\.globl _foo

}

 

fn testUnwindInfoNoSubsectionsX64(b: *Build, opts: Options) *Step {

 

const a_o = addObject(b, opts, .{ .name = "a", .asm_source_bytes =

\\.globl _foo

 

// Adapted from https://github.com/llvm/llvm-project/blob/main/lld/test/MachO/weak-binding.s

fn testWeakBind(b: *Build, opts: Options) *Step {

 

const lib = addSharedLibrary(b, opts, .{ .name = "foo", .asm_source_bytes =

\\.globl _weak_dysym

}

 

fn testWeakFramework(b: *Build, opts: Options) *Step {

 

const exe = addExecutable(b, opts, .{ .name = "main", .c_source_bytes = "int main() { return 0; }" });

exe.root_module.linkFramework("Cocoa", .{ .weak = true });

}

 

fn testWeakLibrary(b: *Build, opts: Options) *Step {

 

const dylib = addSharedLibrary(b, opts, .{ .name = "a", .c_source_bytes =

\\#include<stdio.h>

}

 

fn testWeakRef(b: *Build, opts: Options) *Step {

 

const exe = addExecutable(b, opts, .{ .name = "main", .c_source_bytes =

\\#include <stdio.h>

}

 

fn addTestStep(b: *Build, comptime prefix: []const u8, opts: Options) *Step {

}

 

const builtin = @import("builtin");