mirror of
https://codeberg.org/ziglang/zig.git
synced 2025-12-06 13:54:21 +00:00
CheckObject: support parsing and dumping archive symtab for ELF
This commit is contained in:
Jakub Konka
parent
6490e2ed82
commit
261db02018
5 changed files with 679 additions and 438 deletions
|
|
@ -405,6 +405,17 @@ pub fn checkInDynamicSection(self: *CheckObject) void {
|
|||
self.checkExact(label);
|
||||
}
|
||||
|
||||
/// Creates a new check checking specifically symbol table parsed and dumped from the archive
|
||||
/// file.
|
||||
pub fn checkInArchiveSymtab(self: *CheckObject) void {
|
||||
const label = switch (self.obj_format) {
|
||||
.elf => ElfDumper.archive_symtab_label,
|
||||
else => @panic("TODO other file formats"),
|
||||
};
|
||||
self.checkStart();
|
||||
self.checkExact(label);
|
||||
}
|
||||
|
||||
/// Creates a new standalone, singular check which allows running simple binary operations
|
||||
/// on the extracted variables. It will then compare the reduced program with the value of
|
||||
/// the expected variable.
|
||||
|
|
@ -884,35 +895,177 @@ const ElfDumper = struct {
|
|||
const symtab_label = "symbol table";
|
||||
const dynamic_symtab_label = "dynamic symbol table";
|
||||
const dynamic_section_label = "dynamic section";
|
||||
|
||||
const Symtab = struct {
|
||||
symbols: []align(1) const elf.Elf64_Sym,
|
||||
strings: []const u8,
|
||||
|
||||
fn get(st: Symtab, index: usize) ?elf.Elf64_Sym {
|
||||
if (index >= st.symbols.len) return null;
|
||||
return st.symbols[index];
|
||||
}
|
||||
|
||||
fn getName(st: Symtab, index: usize) ?[]const u8 {
|
||||
const sym = st.get(index) orelse return null;
|
||||
return getString(st.strings, sym.st_name);
|
||||
}
|
||||
};
|
||||
|
||||
const Context = struct {
|
||||
gpa: Allocator,
|
||||
data: []const u8,
|
||||
hdr: elf.Elf64_Ehdr,
|
||||
shdrs: []align(1) const elf.Elf64_Shdr,
|
||||
phdrs: []align(1) const elf.Elf64_Phdr,
|
||||
shstrtab: []const u8,
|
||||
symtab: ?Symtab = null,
|
||||
dysymtab: ?Symtab = null,
|
||||
};
|
||||
const archive_symtab_label = "archive symbol table";
|
||||
|
||||
fn parseAndDump(step: *Step, bytes: []const u8) ![]const u8 {
|
||||
const gpa = step.owner.allocator;
|
||||
return parseAndDumpArchive(gpa, bytes) catch |err| switch (err) {
|
||||
error.InvalidArchiveMagicNumber => try parseAndDumpObject(gpa, bytes),
|
||||
else => |e| return e,
|
||||
};
|
||||
}
|
||||
|
||||
fn parseAndDumpArchive(gpa: Allocator, bytes: []const u8) ![]const u8 {
|
||||
var stream = std.io.fixedBufferStream(bytes);
|
||||
const reader = stream.reader();
|
||||
|
||||
const magic = try reader.readBytesNoEof(elf.ARMAG.len);
|
||||
if (!mem.eql(u8, &magic, elf.ARMAG)) {
|
||||
return error.InvalidArchiveMagicNumber;
|
||||
}
|
||||
|
||||
var ctx = ArchiveContext{
|
||||
.gpa = gpa,
|
||||
.data = bytes,
|
||||
.strtab = &[0]u8{},
|
||||
};
|
||||
defer {
|
||||
for (ctx.objects.items) |*object| {
|
||||
gpa.free(object.name);
|
||||
}
|
||||
ctx.objects.deinit(gpa);
|
||||
}
|
||||
|
||||
while (true) {
|
||||
if (stream.pos >= ctx.data.len) break;
|
||||
if (!mem.isAligned(stream.pos, 2)) stream.pos += 1;
|
||||
|
||||
const hdr = try reader.readStruct(elf.ar_hdr);
|
||||
|
||||
if (!mem.eql(u8, &hdr.ar_fmag, elf.ARFMAG)) return error.InvalidArchiveHeaderMagicNumber;
|
||||
|
||||
const size = try hdr.size();
|
||||
defer {
|
||||
_ = stream.seekBy(size) catch {};
|
||||
}
|
||||
|
||||
if (hdr.isSymtab()) {
|
||||
try ctx.parseSymtab(ctx.data[stream.pos..][0..size], .p32);
|
||||
continue;
|
||||
}
|
||||
if (hdr.isSymtab64()) {
|
||||
try ctx.parseSymtab(ctx.data[stream.pos..][0..size], .p64);
|
||||
continue;
|
||||
}
|
||||
if (hdr.isStrtab()) {
|
||||
ctx.strtab = ctx.data[stream.pos..][0..size];
|
||||
continue;
|
||||
}
|
||||
if (hdr.isSymdef() or hdr.isSymdefSorted()) continue;
|
||||
|
||||
const name = if (hdr.name()) |name|
|
||||
try gpa.dupe(u8, name)
|
||||
else if (try hdr.nameOffset()) |off|
|
||||
try gpa.dupe(u8, ctx.getString(off))
|
||||
else
|
||||
unreachable;
|
||||
|
||||
try ctx.objects.append(gpa, .{ .name = name, .off = stream.pos, .len = size });
|
||||
}
|
||||
|
||||
var output = std.ArrayList(u8).init(gpa);
|
||||
const writer = output.writer();
|
||||
|
||||
try ctx.dumpSymtab(writer);
|
||||
try ctx.dumpObjects(writer);
|
||||
|
||||
return output.toOwnedSlice();
|
||||
}
|
||||
|
||||
const ArchiveContext = struct {
|
||||
gpa: Allocator,
|
||||
data: []const u8,
|
||||
symtab: std.ArrayListUnmanaged(ArSymtabEntry) = .{},
|
||||
strtab: []const u8,
|
||||
objects: std.ArrayListUnmanaged(struct { name: []const u8, off: usize, len: usize }) = .{},
|
||||
|
||||
fn parseSymtab(ctx: *ArchiveContext, raw: []const u8, ptr_width: enum { p32, p64 }) !void {
|
||||
var stream = std.io.fixedBufferStream(raw);
|
||||
const reader = stream.reader();
|
||||
const num = switch (ptr_width) {
|
||||
.p32 => try reader.readInt(u32, .big),
|
||||
.p64 => try reader.readInt(u64, .big),
|
||||
};
|
||||
const ptr_size: usize = switch (ptr_width) {
|
||||
.p32 => @sizeOf(u32),
|
||||
.p64 => @sizeOf(u64),
|
||||
};
|
||||
const strtab_off = (num + 1) * ptr_size;
|
||||
const strtab_len = raw.len - strtab_off;
|
||||
const strtab = raw[strtab_off..][0..strtab_len];
|
||||
|
||||
try ctx.symtab.ensureTotalCapacityPrecise(ctx.gpa, num);
|
||||
|
||||
var stroff: usize = 0;
|
||||
for (0..num) |_| {
|
||||
const off = switch (ptr_width) {
|
||||
.p32 => try reader.readInt(u32, .big),
|
||||
.p64 => try reader.readInt(u64, .big),
|
||||
};
|
||||
const name = mem.sliceTo(@as([*:0]const u8, @ptrCast(strtab.ptr + stroff)), 0);
|
||||
stroff += name.len + 1;
|
||||
ctx.symtab.appendAssumeCapacity(.{ .off = off, .name = name });
|
||||
}
|
||||
}
|
||||
|
||||
fn dumpSymtab(ctx: ArchiveContext, writer: anytype) !void {
|
||||
if (ctx.symtab.items.len == 0) return;
|
||||
|
||||
var files = std.AutoHashMap(usize, []const u8).init(ctx.gpa);
|
||||
defer files.deinit();
|
||||
try files.ensureUnusedCapacity(@intCast(ctx.objects.items.len));
|
||||
|
||||
for (ctx.objects.items) |object| {
|
||||
files.putAssumeCapacityNoClobber(object.off - @sizeOf(elf.ar_hdr), object.name);
|
||||
}
|
||||
|
||||
var symbols = std.AutoArrayHashMap(usize, std.ArrayList([]const u8)).init(ctx.gpa);
|
||||
defer {
|
||||
for (symbols.values()) |*value| {
|
||||
value.deinit();
|
||||
}
|
||||
symbols.deinit();
|
||||
}
|
||||
|
||||
for (ctx.symtab.items) |entry| {
|
||||
const gop = try symbols.getOrPut(@intCast(entry.off));
|
||||
if (!gop.found_existing) {
|
||||
gop.value_ptr.* = std.ArrayList([]const u8).init(ctx.gpa);
|
||||
}
|
||||
try gop.value_ptr.append(entry.name);
|
||||
}
|
||||
|
||||
try writer.print("{s}\n", .{archive_symtab_label});
|
||||
for (symbols.keys(), symbols.values()) |off, values| {
|
||||
try writer.print("in object {s}\n", .{files.get(off).?});
|
||||
for (values.items) |value| {
|
||||
try writer.print("{s}\n", .{value});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn dumpObjects(ctx: ArchiveContext, writer: anytype) !void {
|
||||
for (ctx.objects.items) |object| {
|
||||
try writer.print("object {s}\n", .{object.name});
|
||||
const output = try parseAndDumpObject(ctx.gpa, ctx.data[object.off..][0..object.len]);
|
||||
defer ctx.gpa.free(output);
|
||||
try writer.print("{s}\n", .{output});
|
||||
}
|
||||
}
|
||||
|
||||
fn getString(ctx: ArchiveContext, off: u32) []const u8 {
|
||||
assert(off < ctx.strtab.len);
|
||||
const name = mem.sliceTo(@as([*:'\n']const u8, @ptrCast(ctx.strtab.ptr + off)), 0);
|
||||
return name[0 .. name.len - 1];
|
||||
}
|
||||
|
||||
const ArSymtabEntry = struct {
|
||||
name: [:0]const u8,
|
||||
off: u64,
|
||||
};
|
||||
};
|
||||
|
||||
fn parseAndDumpObject(gpa: Allocator, bytes: []const u8) ![]const u8 {
|
||||
var stream = std.io.fixedBufferStream(bytes);
|
||||
const reader = stream.reader();
|
||||
|
||||
|
|
@ -924,7 +1077,7 @@ const ElfDumper = struct {
|
|||
const shdrs = @as([*]align(1) const elf.Elf64_Shdr, @ptrCast(bytes.ptr + hdr.e_shoff))[0..hdr.e_shnum];
|
||||
const phdrs = @as([*]align(1) const elf.Elf64_Phdr, @ptrCast(bytes.ptr + hdr.e_phoff))[0..hdr.e_phnum];
|
||||
|
||||
var ctx = Context{
|
||||
var ctx = ObjectContext{
|
||||
.gpa = gpa,
|
||||
.data = bytes,
|
||||
.hdr = hdr,
|
||||
|
|
@ -932,14 +1085,14 @@ const ElfDumper = struct {
|
|||
.phdrs = phdrs,
|
||||
.shstrtab = undefined,
|
||||
};
|
||||
ctx.shstrtab = getSectionContents(ctx, ctx.hdr.e_shstrndx);
|
||||
ctx.shstrtab = ctx.getSectionContents(ctx.hdr.e_shstrndx);
|
||||
|
||||
for (ctx.shdrs, 0..) |shdr, i| switch (shdr.sh_type) {
|
||||
elf.SHT_SYMTAB, elf.SHT_DYNSYM => {
|
||||
const raw = getSectionContents(ctx, i);
|
||||
const raw = ctx.getSectionContents(i);
|
||||
const nsyms = @divExact(raw.len, @sizeOf(elf.Elf64_Sym));
|
||||
const symbols = @as([*]align(1) const elf.Elf64_Sym, @ptrCast(raw.ptr))[0..nsyms];
|
||||
const strings = getSectionContents(ctx, shdr.sh_link);
|
||||
const strings = ctx.getSectionContents(shdr.sh_link);
|
||||
|
||||
switch (shdr.sh_type) {
|
||||
elf.SHT_SYMTAB => {
|
||||
|
|
@ -964,53 +1117,79 @@ const ElfDumper = struct {
|
|||
var output = std.ArrayList(u8).init(gpa);
|
||||
const writer = output.writer();
|
||||
|
||||
try dumpHeader(ctx, writer);
|
||||
try dumpShdrs(ctx, writer);
|
||||
try dumpPhdrs(ctx, writer);
|
||||
try dumpDynamicSection(ctx, writer);
|
||||
try dumpSymtab(ctx, .symtab, writer);
|
||||
try dumpSymtab(ctx, .dysymtab, writer);
|
||||
try ctx.dumpHeader(writer);
|
||||
try ctx.dumpShdrs(writer);
|
||||
try ctx.dumpPhdrs(writer);
|
||||
try ctx.dumpDynamicSection(writer);
|
||||
try ctx.dumpSymtab(.symtab, writer);
|
||||
try ctx.dumpSymtab(.dysymtab, writer);
|
||||
|
||||
return output.toOwnedSlice();
|
||||
}
|
||||
|
||||
inline fn getSectionName(ctx: Context, shndx: usize) []const u8 {
|
||||
const shdr = ctx.shdrs[shndx];
|
||||
return getString(ctx.shstrtab, shdr.sh_name);
|
||||
}
|
||||
const ObjectContext = struct {
|
||||
gpa: Allocator,
|
||||
data: []const u8,
|
||||
hdr: elf.Elf64_Ehdr,
|
||||
shdrs: []align(1) const elf.Elf64_Shdr,
|
||||
phdrs: []align(1) const elf.Elf64_Phdr,
|
||||
shstrtab: []const u8,
|
||||
symtab: ?Symtab = null,
|
||||
dysymtab: ?Symtab = null,
|
||||
|
||||
fn getSectionContents(ctx: Context, shndx: usize) []const u8 {
|
||||
const shdr = ctx.shdrs[shndx];
|
||||
assert(shdr.sh_offset < ctx.data.len);
|
||||
assert(shdr.sh_offset + shdr.sh_size <= ctx.data.len);
|
||||
return ctx.data[shdr.sh_offset..][0..shdr.sh_size];
|
||||
}
|
||||
|
||||
fn getSectionByName(ctx: Context, name: []const u8) ?usize {
|
||||
for (0..ctx.shdrs.len) |shndx| {
|
||||
if (mem.eql(u8, getSectionName(ctx, shndx), name)) return shndx;
|
||||
} else return null;
|
||||
}
|
||||
|
||||
fn getString(strtab: []const u8, off: u32) []const u8 {
|
||||
assert(off < strtab.len);
|
||||
return mem.sliceTo(@as([*:0]const u8, @ptrCast(strtab.ptr + off)), 0);
|
||||
}
|
||||
|
||||
fn dumpHeader(ctx: Context, writer: anytype) !void {
|
||||
fn dumpHeader(ctx: ObjectContext, writer: anytype) !void {
|
||||
try writer.writeAll("header\n");
|
||||
try writer.print("type {s}\n", .{@tagName(ctx.hdr.e_type)});
|
||||
try writer.print("entry {x}\n", .{ctx.hdr.e_entry});
|
||||
}
|
||||
|
||||
fn dumpShdrs(ctx: Context, writer: anytype) !void {
|
||||
fn dumpPhdrs(ctx: ObjectContext, writer: anytype) !void {
|
||||
if (ctx.phdrs.len == 0) return;
|
||||
|
||||
try writer.writeAll("program headers\n");
|
||||
|
||||
for (ctx.phdrs, 0..) |phdr, phndx| {
|
||||
try writer.print("phdr {d}\n", .{phndx});
|
||||
try writer.print("type {s}\n", .{fmtPhType(phdr.p_type)});
|
||||
try writer.print("vaddr {x}\n", .{phdr.p_vaddr});
|
||||
try writer.print("paddr {x}\n", .{phdr.p_paddr});
|
||||
try writer.print("offset {x}\n", .{phdr.p_offset});
|
||||
try writer.print("memsz {x}\n", .{phdr.p_memsz});
|
||||
try writer.print("filesz {x}\n", .{phdr.p_filesz});
|
||||
try writer.print("align {x}\n", .{phdr.p_align});
|
||||
|
||||
{
|
||||
const flags = phdr.p_flags;
|
||||
try writer.writeAll("flags");
|
||||
if (flags > 0) try writer.writeByte(' ');
|
||||
if (flags & elf.PF_R != 0) {
|
||||
try writer.writeByte('R');
|
||||
}
|
||||
if (flags & elf.PF_W != 0) {
|
||||
try writer.writeByte('W');
|
||||
}
|
||||
if (flags & elf.PF_X != 0) {
|
||||
try writer.writeByte('E');
|
||||
}
|
||||
if (flags & elf.PF_MASKOS != 0) {
|
||||
try writer.writeAll("OS");
|
||||
}
|
||||
if (flags & elf.PF_MASKPROC != 0) {
|
||||
try writer.writeAll("PROC");
|
||||
}
|
||||
try writer.writeByte('\n');
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn dumpShdrs(ctx: ObjectContext, writer: anytype) !void {
|
||||
if (ctx.shdrs.len == 0) return;
|
||||
|
||||
try writer.writeAll("section headers\n");
|
||||
|
||||
for (ctx.shdrs, 0..) |shdr, shndx| {
|
||||
try writer.print("shdr {d}\n", .{shndx});
|
||||
try writer.print("name {s}\n", .{getSectionName(ctx, shndx)});
|
||||
try writer.print("name {s}\n", .{ctx.getSectionName(shndx)});
|
||||
try writer.print("type {s}\n", .{fmtShType(shdr.sh_type)});
|
||||
try writer.print("addr {x}\n", .{shdr.sh_addr});
|
||||
try writer.print("offset {x}\n", .{shdr.sh_offset});
|
||||
|
|
@ -1020,11 +1199,11 @@ const ElfDumper = struct {
|
|||
}
|
||||
}
|
||||
|
||||
fn dumpDynamicSection(ctx: Context, writer: anytype) !void {
|
||||
const shndx = getSectionByName(ctx, ".dynamic") orelse return;
|
||||
fn dumpDynamicSection(ctx: ObjectContext, writer: anytype) !void {
|
||||
const shndx = ctx.getSectionByName(".dynamic") orelse return;
|
||||
const shdr = ctx.shdrs[shndx];
|
||||
const strtab = getSectionContents(ctx, shdr.sh_link);
|
||||
const data = getSectionContents(ctx, shndx);
|
||||
const strtab = ctx.getSectionContents(shdr.sh_link);
|
||||
const data = ctx.getSectionContents(shndx);
|
||||
const nentries = @divExact(data.len, @sizeOf(elf.Elf64_Dyn));
|
||||
const entries = @as([*]align(1) const elf.Elf64_Dyn, @ptrCast(data.ptr))[0..nentries];
|
||||
|
||||
|
|
@ -1159,127 +1338,7 @@ const ElfDumper = struct {
|
|||
}
|
||||
}
|
||||
|
||||
fn fmtShType(sh_type: u32) std.fmt.Formatter(formatShType) {
|
||||
return .{ .data = sh_type };
|
||||
}
|
||||
|
||||
fn formatShType(
|
||||
sh_type: u32,
|
||||
comptime unused_fmt_string: []const u8,
|
||||
options: std.fmt.FormatOptions,
|
||||
writer: anytype,
|
||||
) !void {
|
||||
_ = unused_fmt_string;
|
||||
_ = options;
|
||||
const name = switch (sh_type) {
|
||||
elf.SHT_NULL => "NULL",
|
||||
elf.SHT_PROGBITS => "PROGBITS",
|
||||
elf.SHT_SYMTAB => "SYMTAB",
|
||||
elf.SHT_STRTAB => "STRTAB",
|
||||
elf.SHT_RELA => "RELA",
|
||||
elf.SHT_HASH => "HASH",
|
||||
elf.SHT_DYNAMIC => "DYNAMIC",
|
||||
elf.SHT_NOTE => "NOTE",
|
||||
elf.SHT_NOBITS => "NOBITS",
|
||||
elf.SHT_REL => "REL",
|
||||
elf.SHT_SHLIB => "SHLIB",
|
||||
elf.SHT_DYNSYM => "DYNSYM",
|
||||
elf.SHT_INIT_ARRAY => "INIT_ARRAY",
|
||||
elf.SHT_FINI_ARRAY => "FINI_ARRAY",
|
||||
elf.SHT_PREINIT_ARRAY => "PREINIT_ARRAY",
|
||||
elf.SHT_GROUP => "GROUP",
|
||||
elf.SHT_SYMTAB_SHNDX => "SYMTAB_SHNDX",
|
||||
elf.SHT_X86_64_UNWIND => "X86_64_UNWIND",
|
||||
elf.SHT_LLVM_ADDRSIG => "LLVM_ADDRSIG",
|
||||
elf.SHT_GNU_HASH => "GNU_HASH",
|
||||
elf.SHT_GNU_VERDEF => "VERDEF",
|
||||
elf.SHT_GNU_VERNEED => "VERNEED",
|
||||
elf.SHT_GNU_VERSYM => "VERSYM",
|
||||
else => if (elf.SHT_LOOS <= sh_type and sh_type < elf.SHT_HIOS) {
|
||||
return try writer.print("LOOS+0x{x}", .{sh_type - elf.SHT_LOOS});
|
||||
} else if (elf.SHT_LOPROC <= sh_type and sh_type < elf.SHT_HIPROC) {
|
||||
return try writer.print("LOPROC+0x{x}", .{sh_type - elf.SHT_LOPROC});
|
||||
} else if (elf.SHT_LOUSER <= sh_type and sh_type < elf.SHT_HIUSER) {
|
||||
return try writer.print("LOUSER+0x{x}", .{sh_type - elf.SHT_LOUSER});
|
||||
} else "UNKNOWN",
|
||||
};
|
||||
try writer.writeAll(name);
|
||||
}
|
||||
|
||||
fn dumpPhdrs(ctx: Context, writer: anytype) !void {
|
||||
if (ctx.phdrs.len == 0) return;
|
||||
|
||||
try writer.writeAll("program headers\n");
|
||||
|
||||
for (ctx.phdrs, 0..) |phdr, phndx| {
|
||||
try writer.print("phdr {d}\n", .{phndx});
|
||||
try writer.print("type {s}\n", .{fmtPhType(phdr.p_type)});
|
||||
try writer.print("vaddr {x}\n", .{phdr.p_vaddr});
|
||||
try writer.print("paddr {x}\n", .{phdr.p_paddr});
|
||||
try writer.print("offset {x}\n", .{phdr.p_offset});
|
||||
try writer.print("memsz {x}\n", .{phdr.p_memsz});
|
||||
try writer.print("filesz {x}\n", .{phdr.p_filesz});
|
||||
try writer.print("align {x}\n", .{phdr.p_align});
|
||||
|
||||
{
|
||||
const flags = phdr.p_flags;
|
||||
try writer.writeAll("flags");
|
||||
if (flags > 0) try writer.writeByte(' ');
|
||||
if (flags & elf.PF_R != 0) {
|
||||
try writer.writeByte('R');
|
||||
}
|
||||
if (flags & elf.PF_W != 0) {
|
||||
try writer.writeByte('W');
|
||||
}
|
||||
if (flags & elf.PF_X != 0) {
|
||||
try writer.writeByte('E');
|
||||
}
|
||||
if (flags & elf.PF_MASKOS != 0) {
|
||||
try writer.writeAll("OS");
|
||||
}
|
||||
if (flags & elf.PF_MASKPROC != 0) {
|
||||
try writer.writeAll("PROC");
|
||||
}
|
||||
try writer.writeByte('\n');
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn fmtPhType(ph_type: u32) std.fmt.Formatter(formatPhType) {
|
||||
return .{ .data = ph_type };
|
||||
}
|
||||
|
||||
fn formatPhType(
|
||||
ph_type: u32,
|
||||
comptime unused_fmt_string: []const u8,
|
||||
options: std.fmt.FormatOptions,
|
||||
writer: anytype,
|
||||
) !void {
|
||||
_ = unused_fmt_string;
|
||||
_ = options;
|
||||
const p_type = switch (ph_type) {
|
||||
elf.PT_NULL => "NULL",
|
||||
elf.PT_LOAD => "LOAD",
|
||||
elf.PT_DYNAMIC => "DYNAMIC",
|
||||
elf.PT_INTERP => "INTERP",
|
||||
elf.PT_NOTE => "NOTE",
|
||||
elf.PT_SHLIB => "SHLIB",
|
||||
elf.PT_PHDR => "PHDR",
|
||||
elf.PT_TLS => "TLS",
|
||||
elf.PT_NUM => "NUM",
|
||||
elf.PT_GNU_EH_FRAME => "GNU_EH_FRAME",
|
||||
elf.PT_GNU_STACK => "GNU_STACK",
|
||||
elf.PT_GNU_RELRO => "GNU_RELRO",
|
||||
else => if (elf.PT_LOOS <= ph_type and ph_type < elf.PT_HIOS) {
|
||||
return try writer.print("LOOS+0x{x}", .{ph_type - elf.PT_LOOS});
|
||||
} else if (elf.PT_LOPROC <= ph_type and ph_type < elf.PT_HIPROC) {
|
||||
return try writer.print("LOPROC+0x{x}", .{ph_type - elf.PT_LOPROC});
|
||||
} else "UNKNOWN",
|
||||
};
|
||||
try writer.writeAll(p_type);
|
||||
}
|
||||
|
||||
fn dumpSymtab(ctx: Context, comptime @"type": enum { symtab, dysymtab }, writer: anytype) !void {
|
||||
fn dumpSymtab(ctx: ObjectContext, comptime @"type": enum { symtab, dysymtab }, writer: anytype) !void {
|
||||
const symtab = switch (@"type") {
|
||||
.symtab => ctx.symtab,
|
||||
.dysymtab => ctx.dysymtab,
|
||||
|
|
@ -1298,7 +1357,7 @@ const ElfDumper = struct {
|
|||
if (elf.SHN_LOPROC <= sym.st_shndx and sym.st_shndx < elf.SHN_HIPROC) {
|
||||
try writer.print(" LO+{d}", .{sym.st_shndx - elf.SHN_LOPROC});
|
||||
} else {
|
||||
const sym_ndx = &switch (sym.st_shndx) {
|
||||
const sym_ndx = switch (sym.st_shndx) {
|
||||
elf.SHN_ABS => "ABS",
|
||||
elf.SHN_COMMON => "COM",
|
||||
elf.SHN_LIVEPATCH => "LIV",
|
||||
|
|
@ -1354,12 +1413,132 @@ const ElfDumper = struct {
|
|||
try writer.print(" {s}", .{@tagName(sym_vis)});
|
||||
|
||||
const sym_name = switch (sym.st_type()) {
|
||||
elf.STT_SECTION => getSectionName(ctx, sym.st_shndx),
|
||||
elf.STT_SECTION => ctx.getSectionName(sym.st_shndx),
|
||||
else => symtab.getName(index).?,
|
||||
};
|
||||
try writer.print(" {s}\n", .{sym_name});
|
||||
}
|
||||
}
|
||||
|
||||
inline fn getSectionName(ctx: ObjectContext, shndx: usize) []const u8 {
|
||||
const shdr = ctx.shdrs[shndx];
|
||||
return getString(ctx.shstrtab, shdr.sh_name);
|
||||
}
|
||||
|
||||
fn getSectionContents(ctx: ObjectContext, shndx: usize) []const u8 {
|
||||
const shdr = ctx.shdrs[shndx];
|
||||
assert(shdr.sh_offset < ctx.data.len);
|
||||
assert(shdr.sh_offset + shdr.sh_size <= ctx.data.len);
|
||||
return ctx.data[shdr.sh_offset..][0..shdr.sh_size];
|
||||
}
|
||||
|
||||
fn getSectionByName(ctx: ObjectContext, name: []const u8) ?usize {
|
||||
for (0..ctx.shdrs.len) |shndx| {
|
||||
if (mem.eql(u8, ctx.getSectionName(shndx), name)) return shndx;
|
||||
} else return null;
|
||||
}
|
||||
};
|
||||
|
||||
const Symtab = struct {
|
||||
symbols: []align(1) const elf.Elf64_Sym,
|
||||
strings: []const u8,
|
||||
|
||||
fn get(st: Symtab, index: usize) ?elf.Elf64_Sym {
|
||||
if (index >= st.symbols.len) return null;
|
||||
return st.symbols[index];
|
||||
}
|
||||
|
||||
fn getName(st: Symtab, index: usize) ?[]const u8 {
|
||||
const sym = st.get(index) orelse return null;
|
||||
return getString(st.strings, sym.st_name);
|
||||
}
|
||||
};
|
||||
|
||||
fn getString(strtab: []const u8, off: u32) []const u8 {
|
||||
assert(off < strtab.len);
|
||||
return mem.sliceTo(@as([*:0]const u8, @ptrCast(strtab.ptr + off)), 0);
|
||||
}
|
||||
|
||||
fn fmtShType(sh_type: u32) std.fmt.Formatter(formatShType) {
|
||||
return .{ .data = sh_type };
|
||||
}
|
||||
|
||||
fn formatShType(
|
||||
sh_type: u32,
|
||||
comptime unused_fmt_string: []const u8,
|
||||
options: std.fmt.FormatOptions,
|
||||
writer: anytype,
|
||||
) !void {
|
||||
_ = unused_fmt_string;
|
||||
_ = options;
|
||||
const name = switch (sh_type) {
|
||||
elf.SHT_NULL => "NULL",
|
||||
elf.SHT_PROGBITS => "PROGBITS",
|
||||
elf.SHT_SYMTAB => "SYMTAB",
|
||||
elf.SHT_STRTAB => "STRTAB",
|
||||
elf.SHT_RELA => "RELA",
|
||||
elf.SHT_HASH => "HASH",
|
||||
elf.SHT_DYNAMIC => "DYNAMIC",
|
||||
elf.SHT_NOTE => "NOTE",
|
||||
elf.SHT_NOBITS => "NOBITS",
|
||||
elf.SHT_REL => "REL",
|
||||
elf.SHT_SHLIB => "SHLIB",
|
||||
elf.SHT_DYNSYM => "DYNSYM",
|
||||
elf.SHT_INIT_ARRAY => "INIT_ARRAY",
|
||||
elf.SHT_FINI_ARRAY => "FINI_ARRAY",
|
||||
elf.SHT_PREINIT_ARRAY => "PREINIT_ARRAY",
|
||||
elf.SHT_GROUP => "GROUP",
|
||||
elf.SHT_SYMTAB_SHNDX => "SYMTAB_SHNDX",
|
||||
elf.SHT_X86_64_UNWIND => "X86_64_UNWIND",
|
||||
elf.SHT_LLVM_ADDRSIG => "LLVM_ADDRSIG",
|
||||
elf.SHT_GNU_HASH => "GNU_HASH",
|
||||
elf.SHT_GNU_VERDEF => "VERDEF",
|
||||
elf.SHT_GNU_VERNEED => "VERNEED",
|
||||
elf.SHT_GNU_VERSYM => "VERSYM",
|
||||
else => if (elf.SHT_LOOS <= sh_type and sh_type < elf.SHT_HIOS) {
|
||||
return try writer.print("LOOS+0x{x}", .{sh_type - elf.SHT_LOOS});
|
||||
} else if (elf.SHT_LOPROC <= sh_type and sh_type < elf.SHT_HIPROC) {
|
||||
return try writer.print("LOPROC+0x{x}", .{sh_type - elf.SHT_LOPROC});
|
||||
} else if (elf.SHT_LOUSER <= sh_type and sh_type < elf.SHT_HIUSER) {
|
||||
return try writer.print("LOUSER+0x{x}", .{sh_type - elf.SHT_LOUSER});
|
||||
} else "UNKNOWN",
|
||||
};
|
||||
try writer.writeAll(name);
|
||||
}
|
||||
|
||||
fn fmtPhType(ph_type: u32) std.fmt.Formatter(formatPhType) {
|
||||
return .{ .data = ph_type };
|
||||
}
|
||||
|
||||
fn formatPhType(
|
||||
ph_type: u32,
|
||||
comptime unused_fmt_string: []const u8,
|
||||
options: std.fmt.FormatOptions,
|
||||
writer: anytype,
|
||||
) !void {
|
||||
_ = unused_fmt_string;
|
||||
_ = options;
|
||||
const p_type = switch (ph_type) {
|
||||
elf.PT_NULL => "NULL",
|
||||
elf.PT_LOAD => "LOAD",
|
||||
elf.PT_DYNAMIC => "DYNAMIC",
|
||||
elf.PT_INTERP => "INTERP",
|
||||
elf.PT_NOTE => "NOTE",
|
||||
elf.PT_SHLIB => "SHLIB",
|
||||
elf.PT_PHDR => "PHDR",
|
||||
elf.PT_TLS => "TLS",
|
||||
elf.PT_NUM => "NUM",
|
||||
elf.PT_GNU_EH_FRAME => "GNU_EH_FRAME",
|
||||
elf.PT_GNU_STACK => "GNU_STACK",
|
||||
elf.PT_GNU_RELRO => "GNU_RELRO",
|
||||
else => if (elf.PT_LOOS <= ph_type and ph_type < elf.PT_HIOS) {
|
||||
return try writer.print("LOOS+0x{x}", .{ph_type - elf.PT_LOOS});
|
||||
} else if (elf.PT_LOPROC <= ph_type and ph_type < elf.PT_HIPROC) {
|
||||
return try writer.print("LOPROC+0x{x}", .{ph_type - elf.PT_LOPROC});
|
||||
} else "UNKNOWN",
|
||||
};
|
||||
try writer.writeAll(p_type);
|
||||
}
|
||||
};
|
||||
|
||||
const WasmDumper = struct {
|
||||
|
|
|
|||
|
|
@ -1896,3 +1896,92 @@ pub const STV = enum(u2) {
|
|||
HIDDEN = 2,
|
||||
PROTECTED = 3,
|
||||
};
|
||||
|
||||
pub const ar_hdr = extern struct {
|
||||
/// Member file name, sometimes / terminated.
|
||||
ar_name: [16]u8,
|
||||
|
||||
/// File date, decimal seconds since Epoch.
|
||||
ar_date: [12]u8,
|
||||
|
||||
/// User ID, in ASCII format.
|
||||
ar_uid: [6]u8,
|
||||
|
||||
/// Group ID, in ASCII format.
|
||||
ar_gid: [6]u8,
|
||||
|
||||
/// File mode, in ASCII octal.
|
||||
ar_mode: [8]u8,
|
||||
|
||||
/// File size, in ASCII decimal.
|
||||
ar_size: [10]u8,
|
||||
|
||||
/// Always contains ARFMAG.
|
||||
ar_fmag: [2]u8,
|
||||
|
||||
pub fn date(self: ar_hdr) std.fmt.ParseIntError!u64 {
|
||||
const value = mem.trimRight(u8, &self.ar_date, &[_]u8{0x20});
|
||||
return std.fmt.parseInt(u64, value, 10);
|
||||
}
|
||||
|
||||
pub fn size(self: ar_hdr) std.fmt.ParseIntError!u32 {
|
||||
const value = mem.trimRight(u8, &self.ar_size, &[_]u8{0x20});
|
||||
return std.fmt.parseInt(u32, value, 10);
|
||||
}
|
||||
|
||||
pub fn isStrtab(self: ar_hdr) bool {
|
||||
return mem.eql(u8, &self.ar_name, STRNAME);
|
||||
}
|
||||
|
||||
pub fn isSymtab(self: ar_hdr) bool {
|
||||
return mem.eql(u8, &self.ar_name, SYMNAME);
|
||||
}
|
||||
|
||||
pub fn isSymtab64(self: ar_hdr) bool {
|
||||
return mem.eql(u8, &self.ar_name, SYM64NAME);
|
||||
}
|
||||
|
||||
pub fn isSymdef(self: ar_hdr) bool {
|
||||
return mem.eql(u8, &self.ar_name, SYMDEFNAME);
|
||||
}
|
||||
|
||||
pub fn isSymdefSorted(self: ar_hdr) bool {
|
||||
return mem.eql(u8, &self.ar_name, SYMDEFSORTEDNAME);
|
||||
}
|
||||
|
||||
pub fn name(self: *const ar_hdr) ?[]const u8 {
|
||||
const value = &self.ar_name;
|
||||
if (value[0] == '/') return null;
|
||||
const sentinel = mem.indexOfScalar(u8, value, '/') orelse value.len;
|
||||
return value[0..sentinel];
|
||||
}
|
||||
|
||||
pub fn nameOffset(self: ar_hdr) std.fmt.ParseIntError!?u32 {
|
||||
const value = &self.ar_name;
|
||||
if (value[0] != '/') return null;
|
||||
const trimmed = mem.trimRight(u8, value, &[_]u8{0x20});
|
||||
return try std.fmt.parseInt(u32, trimmed[1..], 10);
|
||||
}
|
||||
};
|
||||
|
||||
fn genSpecialMemberName(comptime name: []const u8) *const [16]u8 {
|
||||
assert(name.len <= 16);
|
||||
const padding = 16 - name.len;
|
||||
return name ++ &[_]u8{0x20} ** padding;
|
||||
}
|
||||
|
||||
// Archive files start with the ARMAG identifying string. Then follows a
|
||||
// `struct ar_hdr', and as many bytes of member file data as its `ar_size'
|
||||
// member indicates, for each member file.
|
||||
/// String that begins an archive file.
|
||||
pub const ARMAG = "!<arch>\n";
|
||||
/// String in ar_fmag at the end of each header.
|
||||
pub const ARFMAG = "`\n";
|
||||
/// 32-bit symtab identifier
|
||||
pub const SYMNAME = genSpecialMemberName("/");
|
||||
/// Strtab identifier
|
||||
pub const STRNAME = genSpecialMemberName("//");
|
||||
/// 64-bit symtab identifier
|
||||
pub const SYM64NAME = genSpecialMemberName("/SYM64/");
|
||||
pub const SYMDEFNAME = genSpecialMemberName("__.SYMDEF");
|
||||
pub const SYMDEFSORTEDNAME = genSpecialMemberName("__.SYMDEF SORTED");
|
||||
|
|
|
|||
|
|
@ -1582,12 +1582,12 @@ pub fn flushStaticLib(self: *Elf, comp: *Compilation) link.File.FlushError!void
|
|||
|
||||
// Update file offsets of contributing objects.
|
||||
const total_size: usize = blk: {
|
||||
var pos: usize = Archive.ARMAG.len;
|
||||
pos += @sizeOf(Archive.ar_hdr) + ar_symtab.size(.p64);
|
||||
var pos: usize = elf.ARMAG.len;
|
||||
pos += @sizeOf(elf.ar_hdr) + ar_symtab.size(.p64);
|
||||
|
||||
if (ar_strtab.size() > 0) {
|
||||
pos = mem.alignForward(usize, pos, 2);
|
||||
pos += @sizeOf(Archive.ar_hdr) + ar_strtab.size();
|
||||
pos += @sizeOf(elf.ar_hdr) + ar_strtab.size();
|
||||
}
|
||||
|
||||
for (files.items) |index| {
|
||||
|
|
@ -1599,7 +1599,7 @@ pub fn flushStaticLib(self: *Elf, comp: *Compilation) link.File.FlushError!void
|
|||
};
|
||||
pos = mem.alignForward(usize, pos, 2);
|
||||
state.file_off = pos;
|
||||
pos += @sizeOf(Archive.ar_hdr) + (math.cast(usize, state.size) orelse return error.Overflow);
|
||||
pos += @sizeOf(elf.ar_hdr) + (math.cast(usize, state.size) orelse return error.Overflow);
|
||||
}
|
||||
|
||||
break :blk pos;
|
||||
|
|
@ -1615,7 +1615,7 @@ pub fn flushStaticLib(self: *Elf, comp: *Compilation) link.File.FlushError!void
|
|||
try buffer.ensureTotalCapacityPrecise(total_size);
|
||||
|
||||
// Write magic
|
||||
try buffer.writer().writeAll(Archive.ARMAG);
|
||||
try buffer.writer().writeAll(elf.ARMAG);
|
||||
|
||||
// Write symtab
|
||||
try ar_symtab.write(.p64, self, buffer.writer());
|
||||
|
|
|
|||
|
|
@ -8,8 +8,8 @@ pub fn isArchive(path: []const u8) !bool {
|
|||
const file = try std.fs.cwd().openFile(path, .{});
|
||||
defer file.close();
|
||||
const reader = file.reader();
|
||||
const magic = reader.readBytesNoEof(ARMAG.len) catch return false;
|
||||
if (!mem.eql(u8, &magic, ARMAG)) return false;
|
||||
const magic = reader.readBytesNoEof(elf.ARMAG.len) catch return false;
|
||||
if (!mem.eql(u8, &magic, elf.ARMAG)) return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -24,19 +24,19 @@ pub fn parse(self: *Archive, elf_file: *Elf) !void {
|
|||
|
||||
var stream = std.io.fixedBufferStream(self.data);
|
||||
const reader = stream.reader();
|
||||
_ = try reader.readBytesNoEof(ARMAG.len);
|
||||
_ = try reader.readBytesNoEof(elf.ARMAG.len);
|
||||
|
||||
while (true) {
|
||||
if (stream.pos >= self.data.len) break;
|
||||
if (!mem.isAligned(stream.pos, 2)) stream.pos += 1;
|
||||
|
||||
const hdr = try reader.readStruct(ar_hdr);
|
||||
const hdr = try reader.readStruct(elf.ar_hdr);
|
||||
|
||||
if (!mem.eql(u8, &hdr.ar_fmag, ARFMAG)) {
|
||||
if (!mem.eql(u8, &hdr.ar_fmag, elf.ARFMAG)) {
|
||||
// TODO convert into an error
|
||||
log.debug(
|
||||
"{s}: invalid header delimiter: expected '{s}', found '{s}'",
|
||||
.{ self.path, std.fmt.fmtSliceEscapeLower(ARFMAG), std.fmt.fmtSliceEscapeLower(&hdr.ar_fmag) },
|
||||
.{ self.path, std.fmt.fmtSliceEscapeLower(elf.ARFMAG), std.fmt.fmtSliceEscapeLower(&hdr.ar_fmag) },
|
||||
);
|
||||
return;
|
||||
}
|
||||
|
|
@ -88,8 +88,8 @@ pub fn setArHdr(opts: struct {
|
|||
name_off: u32,
|
||||
},
|
||||
size: u32,
|
||||
}) ar_hdr {
|
||||
var hdr: ar_hdr = .{
|
||||
}) elf.ar_hdr {
|
||||
var hdr: elf.ar_hdr = .{
|
||||
.ar_name = undefined,
|
||||
.ar_date = undefined,
|
||||
.ar_uid = undefined,
|
||||
|
|
@ -99,13 +99,13 @@ pub fn setArHdr(opts: struct {
|
|||
.ar_fmag = undefined,
|
||||
};
|
||||
@memset(mem.asBytes(&hdr), 0x20);
|
||||
@memcpy(&hdr.ar_fmag, Archive.ARFMAG);
|
||||
@memcpy(&hdr.ar_fmag, elf.ARFMAG);
|
||||
|
||||
{
|
||||
var stream = std.io.fixedBufferStream(&hdr.ar_name);
|
||||
const writer = stream.writer();
|
||||
switch (opts.name) {
|
||||
.symtab => writer.print("{s}", .{Archive.SYM64NAME}) catch unreachable,
|
||||
.symtab => writer.print("{s}", .{elf.SYM64NAME}) catch unreachable,
|
||||
.strtab => writer.print("//", .{}) catch unreachable,
|
||||
.name => |x| writer.print("{s}/", .{x}) catch unreachable,
|
||||
.name_off => |x| writer.print("/{d}", .{x}) catch unreachable,
|
||||
|
|
@ -119,98 +119,9 @@ pub fn setArHdr(opts: struct {
|
|||
return hdr;
|
||||
}
|
||||
|
||||
fn genSpecialMemberName(comptime name: []const u8) *const [16]u8 {
|
||||
assert(name.len <= 16);
|
||||
const padding = 16 - name.len;
|
||||
return name ++ &[_]u8{0x20} ** padding;
|
||||
}
|
||||
|
||||
// Archive files start with the ARMAG identifying string. Then follows a
|
||||
// `struct ar_hdr', and as many bytes of member file data as its `ar_size'
|
||||
// member indicates, for each member file.
|
||||
/// String that begins an archive file.
|
||||
pub const ARMAG = "!<arch>\n";
|
||||
/// String in ar_fmag at the end of each header.
|
||||
const ARFMAG = "`\n";
|
||||
/// 32-bit symtab identifier
|
||||
const SYMNAME = genSpecialMemberName("/");
|
||||
/// Strtab identifier
|
||||
const STRNAME = genSpecialMemberName("//");
|
||||
/// 64-bit symtab identifier
|
||||
const SYM64NAME = genSpecialMemberName("/SYM64/");
|
||||
const SYMDEFNAME = genSpecialMemberName("__.SYMDEF");
|
||||
const SYMDEFSORTEDNAME = genSpecialMemberName("__.SYMDEF SORTED");
|
||||
|
||||
const strtab_delimiter = '\n';
|
||||
pub const max_member_name_len = 15;
|
||||
|
||||
pub const ar_hdr = extern struct {
|
||||
/// Member file name, sometimes / terminated.
|
||||
ar_name: [16]u8,
|
||||
|
||||
/// File date, decimal seconds since Epoch.
|
||||
ar_date: [12]u8,
|
||||
|
||||
/// User ID, in ASCII format.
|
||||
ar_uid: [6]u8,
|
||||
|
||||
/// Group ID, in ASCII format.
|
||||
ar_gid: [6]u8,
|
||||
|
||||
/// File mode, in ASCII octal.
|
||||
ar_mode: [8]u8,
|
||||
|
||||
/// File size, in ASCII decimal.
|
||||
ar_size: [10]u8,
|
||||
|
||||
/// Always contains ARFMAG.
|
||||
ar_fmag: [2]u8,
|
||||
|
||||
fn date(self: ar_hdr) !u64 {
|
||||
const value = mem.trimRight(u8, &self.ar_date, &[_]u8{0x20});
|
||||
return std.fmt.parseInt(u64, value, 10);
|
||||
}
|
||||
|
||||
fn size(self: ar_hdr) !u32 {
|
||||
const value = mem.trimRight(u8, &self.ar_size, &[_]u8{0x20});
|
||||
return std.fmt.parseInt(u32, value, 10);
|
||||
}
|
||||
|
||||
fn isStrtab(self: ar_hdr) bool {
|
||||
return mem.eql(u8, &self.ar_name, STRNAME);
|
||||
}
|
||||
|
||||
fn isSymtab(self: ar_hdr) bool {
|
||||
return mem.eql(u8, &self.ar_name, SYMNAME);
|
||||
}
|
||||
|
||||
fn isSymtab64(self: ar_hdr) bool {
|
||||
return mem.eql(u8, &self.ar_name, SYM64NAME);
|
||||
}
|
||||
|
||||
fn isSymdef(self: ar_hdr) bool {
|
||||
return mem.eql(u8, &self.ar_name, SYMDEFNAME);
|
||||
}
|
||||
|
||||
fn isSymdefSorted(self: ar_hdr) bool {
|
||||
return mem.eql(u8, &self.ar_name, SYMDEFSORTEDNAME);
|
||||
}
|
||||
|
||||
fn name(self: *const ar_hdr) ?[]const u8 {
|
||||
const value = &self.ar_name;
|
||||
if (value[0] == '/') return null;
|
||||
const sentinel = mem.indexOfScalar(u8, value, '/') orelse value.len;
|
||||
return value[0..sentinel];
|
||||
}
|
||||
|
||||
fn nameOffset(self: ar_hdr) !?u32 {
|
||||
const value = &self.ar_name;
|
||||
if (value[0] != '/') return null;
|
||||
const trimmed = mem.trimRight(u8, value, &[_]u8{0x20});
|
||||
return try std.fmt.parseInt(u32, trimmed[1..], 10);
|
||||
}
|
||||
};
|
||||
|
||||
pub const ArSymtab = struct {
|
||||
symtab: std.ArrayListUnmanaged(Entry) = .{},
|
||||
strtab: StringTable = .{},
|
||||
|
|
|
|||
|
|
@ -21,6 +21,9 @@ pub fn build(b: *Build) void {
|
|||
.abi = .gnu,
|
||||
};
|
||||
|
||||
// Exercise linker in ar mode
|
||||
elf_step.dependOn(testEmitStaticLib(b, .{ .target = musl_target }));
|
||||
|
||||
// Exercise linker with self-hosted backend (no LLVM)
|
||||
elf_step.dependOn(testGcSectionsZig(b, .{ .use_llvm = false, .target = default_target }));
|
||||
elf_step.dependOn(testLinkingObj(b, .{ .use_llvm = false, .target = default_target }));
|
||||
|
|
@ -626,6 +629,65 @@ fn testDsoUndef(b: *Build, opts: Options) *Step {
|
|||
return test_step;
|
||||
}
|
||||
|
||||
fn testEmitStaticLib(b: *Build, opts: Options) *Step {
|
||||
const test_step = addTestStep(b, "emit-static-lib", opts);
|
||||
|
||||
const obj1 = addObject(b, "obj1", opts);
|
||||
addCSourceBytes(obj1,
|
||||
\\int foo = 0;
|
||||
\\int bar = 2;
|
||||
\\int fooBar() {
|
||||
\\ return foo + bar;
|
||||
\\}
|
||||
, &.{});
|
||||
|
||||
const obj2 = addObject(b, "obj2", opts);
|
||||
addCSourceBytes(obj2, "int tentative;", &.{"-fcommon"});
|
||||
|
||||
const obj3 = addObject(b, "a_very_long_file_name_so_that_it_ends_up_in_strtab", opts);
|
||||
addZigSourceBytes(obj3,
|
||||
\\fn weakFoo() callconv(.C) usize {
|
||||
\\ return 42;
|
||||
\\}
|
||||
\\export var strongBar: usize = 100;
|
||||
\\comptime {
|
||||
\\ @export(weakFoo, .{ .name = "weakFoo", .linkage = .Weak });
|
||||
\\ @export(strongBar, .{ .name = "strongBarAlias", .linkage = .Strong });
|
||||
\\}
|
||||
);
|
||||
|
||||
const lib = addStaticLibrary(b, "lib", opts);
|
||||
lib.addObject(obj1);
|
||||
lib.addObject(obj2);
|
||||
lib.addObject(obj3);
|
||||
|
||||
const check = lib.checkObject();
|
||||
check.checkInArchiveSymtab();
|
||||
check.checkExactPath("in object", obj1.getEmittedBin());
|
||||
check.checkExact("foo");
|
||||
check.checkInArchiveSymtab();
|
||||
check.checkExactPath("in object", obj1.getEmittedBin());
|
||||
check.checkExact("bar");
|
||||
check.checkInArchiveSymtab();
|
||||
check.checkExactPath("in object", obj1.getEmittedBin());
|
||||
check.checkExact("fooBar");
|
||||
check.checkInArchiveSymtab();
|
||||
check.checkExactPath("in object", obj2.getEmittedBin());
|
||||
check.checkExact("tentative");
|
||||
check.checkInArchiveSymtab();
|
||||
check.checkExactPath("in object", obj3.getEmittedBin());
|
||||
check.checkExact("weakFoo");
|
||||
check.checkInArchiveSymtab();
|
||||
check.checkExactPath("in object", obj3.getEmittedBin());
|
||||
check.checkExact("strongBar");
|
||||
check.checkInArchiveSymtab();
|
||||
check.checkExactPath("in object", obj3.getEmittedBin());
|
||||
check.checkExact("strongBarAlias");
|
||||
test_step.dependOn(&check.step);
|
||||
|
||||
return test_step;
|
||||
}
|
||||
|
||||
fn testEmptyObject(b: *Build, opts: Options) *Step {
|
||||
const test_step = addTestStep(b, "empty-object", opts);
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue