srctree

/// Long-lived list of all file descriptors.

/// We store them globally rather than per actual File so that we can re-use

/// one file handle per every object file within an archive.

file_handles: std.ArrayListUnmanaged(File.Handle) = .{},

for (self.file_handles.items) |fh| {

fh.close();

}

self.file_handles.deinit(gpa);

 

try file_ptr.updateArSize(self);

try self.file(index).?.writeAr(self, buffer.writer());

const handle = try std.fs.cwd().openFile(path, .{});

const fh = try self.addFileHandle(handle);

 

.file_handle = fh,

const handle = try std.fs.cwd().openFile(path, .{});

const fh = try self.addFileHandle(handle);

 

var archive = Archive{};

try archive.parse(self, path, fh);

const handle = try std.fs.cwd().openFile(lib.path, .{});

defer handle.close();

 

try shared_object.parse(self, handle);

for (cg.comdatGroupMembers(self)) |shndx| {

pub fn addFileHandle(self: *Elf, handle: std.fs.File) !File.HandleIndex {

const gpa = self.base.comp.gpa;

const index: File.HandleIndex = @intCast(self.file_handles.items.len);

const fh = try self.file_handles.addOne(gpa);

fh.* = handle;

return index;

}

 

pub fn fileHandle(self: Elf, index: File.HandleIndex) File.Handle {

assert(index < self.file_handles.items.len);

return self.file_handles.items[index];

}

 

/// Caller owns the memory.

pub fn preadAllAlloc(allocator: Allocator, handle: std.fs.File, offset: usize, size: usize) ![]u8 {

const buffer = try allocator.alloc(u8, size);

errdefer allocator.free(buffer);

const amt = try handle.preadAll(buffer, offset);

if (amt != size) return error.InputOutput;

return buffer;

}

 

 

file: File.Index,

shndx: u32,

members_start: u32,

members_len: u32,

 

pub fn comdatGroupMembers(cg: ComdatGroup, elf_file: *Elf) []const u32 {

const object = elf_file.file(cg.file).?.object;

return object.comdat_group_data.items[cg.members_start..][0..cg.members_len];

}

 

strtab: std.ArrayListUnmanaged(u8) = .{},

self.strtab.deinit(allocator);

pub fn parse(self: *Archive, elf_file: *Elf, path: []const u8, handle_index: File.HandleIndex) !void {

const handle = elf_file.fileHandle(handle_index);

const size = (try handle.stat()).size;

const reader = handle.reader();

var pos: usize = elf.ARMAG.len;

if (pos >= size) break;

if (!mem.isAligned(pos, 2)) {

try handle.seekBy(1);

pos += 1;

}

pos += @sizeOf(elf.ar_hdr);

try elf_file.reportParseError(path, "invalid archive header delimiter: {s}", .{

const obj_size = try hdr.size();

_ = handle.seekBy(obj_size) catch {};

pos += obj_size;

try self.strtab.resize(gpa, obj_size);

const amt = try handle.preadAll(self.strtab.items, pos);

if (amt != obj_size) return error.InputOutput;

name

self.getString(off)

.archive = .{

.path = try gpa.dupe(u8, path),

.offset = pos,

},

.path = try gpa.dupe(u8, name),

.file_handle = handle_index,

log.debug("extracting object '{s}' from archive '{s}'", .{ object.path, path });

assert(off < self.strtab.items.len);

const name = mem.sliceTo(@as([*:'\n']const u8, @ptrCast(self.strtab.items.ptr + off)), 0);

size: usize,

/// Start index of the relocations belonging to this atom.

rel_index: u32 = 0,

 

/// Number of relocations belonging to this atom.

rel_num: u32 = 0,

 

pub fn inputShdr(self: Atom, elf_file: *Elf) elf.Elf64_Shdr {

.object => |x| x.relocs.items[self.rel_index..][0..self.rel_num],

archive: ?InArchive = null,

file_handle: File.HandleIndex,

shdrs: std.ArrayListUnmanaged(elf.Elf64_Shdr) = .{},

comdat_group_data: std.ArrayListUnmanaged(u32) = .{},

relocs: std.ArrayListUnmanaged(elf.Elf64_Rela) = .{},

eh_frame_data: std.ArrayListUnmanaged(u8) = .{},

if (self.archive) |*ar| allocator.free(ar.path);

self.comdat_group_data.deinit(allocator);

self.relocs.deinit(allocator);

self.eh_frame_data.deinit(allocator);

const gpa = elf_file.base.comp.gpa;

const offset = if (self.archive) |ar| ar.offset else 0;

const handle = elf_file.fileHandle(self.file_handle);

const file_size = (try handle.stat()).size;

const header_buffer = try Elf.preadAllAlloc(gpa, handle, offset, @sizeOf(elf.Elf64_Ehdr));

defer gpa.free(header_buffer);

self.header = @as(*align(1) const elf.Elf64_Ehdr, @ptrCast(header_buffer)).*;

const shoff = math.cast(usize, self.header.?.e_shoff) orelse return error.Overflow;

const shnum = math.cast(usize, self.header.?.e_shnum) orelse return error.Overflow;

const shsize = shnum * @sizeOf(elf.Elf64_Shdr);

if (file_size < offset + shoff or file_size < offset + shoff + shsize) {

const shdrs_buffer = try Elf.preadAllAlloc(gpa, handle, offset + shoff, shsize);

defer gpa.free(shdrs_buffer);

const shdrs = @as([*]align(1) const elf.Elf64_Shdr, @ptrCast(shdrs_buffer.ptr))[0..shnum];

try self.shdrs.appendUnalignedSlice(gpa, shdrs);

for (self.shdrs.items) |shdr| {

if (file_size < offset + shdr.sh_offset or file_size < offset + shdr.sh_offset + shdr.sh_size) {

const shstrtab = try self.preadShdrContentsAlloc(gpa, handle, self.header.?.e_shstrndx);

defer gpa.free(shstrtab);

for (self.shdrs.items) |shdr| {

const shdr = self.shdrs.items[index];

const raw_symtab = try self.preadShdrContentsAlloc(gpa, handle, index);

defer gpa.free(raw_symtab);

const strtab = try self.preadShdrContentsAlloc(gpa, handle, shdr.sh_link);

defer gpa.free(strtab);

try self.strtab.appendSlice(gpa, strtab);

const gpa = elf_file.base.comp.gpa;

const handle = elf_file.fileHandle(self.file_handle);

 

try self.initAtoms(gpa, handle, elf_file);

try self.initSymtab(gpa, elf_file);

try self.parseEhFrame(gpa, handle, @as(u32, @intCast(i)), elf_file);

fn initAtoms(self: *Object, allocator: Allocator, handle: std.fs.File, elf_file: *Elf) !void {

try self.atoms.resize(allocator, shdrs.len);

const shndx = @as(u32, @intCast(i));

const group_raw_data = try self.preadShdrContentsAlloc(allocator, handle, shndx);

defer allocator.free(group_raw_data);

const group_start = @as(u32, @intCast(self.comdat_group_data.items.len));

try self.comdat_group_data.appendUnalignedSlice(allocator, group_members[1..]);

 

.file = self.index,

.members_start = group_start,

.members_len = @intCast(group_nmembers - 1),

try self.comdat_groups.append(allocator, comdat_group_index);

try self.addAtom(allocator, handle, shdr, shndx, elf_file);

const relocs = try self.preadRelocsAlloc(allocator, handle, @intCast(i));

defer allocator.free(relocs);

atom.relocs_section_index = @intCast(i);

atom.rel_index = @intCast(self.relocs.items.len);

atom.rel_num = @intCast(relocs.len);

try self.relocs.appendUnalignedSlice(allocator, relocs);

fn addAtom(self: *Object, allocator: Allocator, handle: std.fs.File, shdr: elf.Elf64_Shdr, shndx: u32, elf_file: *Elf) !void {

const data = try self.preadShdrContentsAlloc(allocator, handle, shndx);

defer allocator.free(data);

fn initOutputSection(self: Object, elf_file: *Elf, shdr: elf.Elf64_Shdr) error{OutOfMemory}!u16 {

fn initSymtab(self: *Object, allocator: Allocator, elf_file: *Elf) !void {

try self.symbols.ensureTotalCapacityPrecise(allocator, self.symtab.items.len);

fn parseEhFrame(self: *Object, allocator: Allocator, handle: std.fs.File, shndx: u32, elf_file: *Elf) !void {

elf.SHT_RELA => if (shdr.sh_info == shndx) break @as(u32, @intCast(i)),

// TODO: convert into an error

const raw = try self.preadShdrContentsAlloc(allocator, handle, shndx);

defer allocator.free(raw);

const data_start = @as(u32, @intCast(self.eh_frame_data.items.len));

try self.eh_frame_data.appendSlice(allocator, raw);

const relocs = try self.preadRelocsAlloc(allocator, handle, relocs_shndx);

defer allocator.free(relocs);

const rel_start = @as(u32, @intCast(self.relocs.items.len));

try self.relocs.appendUnalignedSlice(allocator, relocs);

.cie => try self.cies.append(allocator, .{

.offset = data_start + rec.offset,

.rel_index = rel_start + @as(u32, @intCast(rel_range.start)),

.fde => try self.fdes.append(allocator, .{

.offset = data_start + rec.offset,

.rel_index = rel_start + @as(u32, @intCast(rel_range.start)),

pub fn updateArSize(self: *Object, elf_file: *Elf) !void {

const handle = elf_file.fileHandle(self.file_handle);

const size = (try handle.stat()).size;

self.output_ar_state.size = size;

pub fn writeAr(self: Object, elf_file: *Elf, writer: anytype) !void {

const size = std.math.cast(usize, self.output_ar_state.size) orelse return error.Overflow;

.size = size,

const handle = elf_file.fileHandle(self.file_handle);

const gpa = elf_file.base.comp.gpa;

const data = try gpa.alloc(u8, size);

defer gpa.free(data);

const amt = try handle.preadAll(data, 0);

if (amt != size) return error.InputOutput;

try writer.writeAll(data);

const handle = elf_file.fileHandle(self.file_handle);

const data = try self.preadShdrContentsAlloc(gpa, handle, atom_ptr.input_section_index);

defer if (shdr.sh_flags & elf.SHF_COMPRESSED != 0) gpa.free(data);

 

}

return data;

/// Caller owns the memory.

fn preadShdrContentsAlloc(self: Object, allocator: Allocator, handle: std.fs.File, index: u32) ![]u8 {

assert(index < self.shdrs.items.len);

const offset = if (self.archive) |ar| ar.offset else 0;

const shdr = self.shdrs.items[index];

return Elf.preadAllAlloc(allocator, handle, offset + shdr.sh_offset, shdr.sh_size);

}

 

/// Caller owns the memory.

fn preadRelocsAlloc(self: Object, allocator: Allocator, handle: std.fs.File, shndx: u32) ![]align(1) const elf.Elf64_Rela {

const raw = try self.preadShdrContentsAlloc(allocator, handle, shndx);

const num = @divExact(raw.len, @sizeOf(elf.Elf64_Rela));

return @as([*]align(1) const elf.Elf64_Rela, @ptrCast(raw.ptr))[0..num];

}

 

const cg_members = cg.comdatGroupMembers(elf_file);

if (object.archive) |ar| {

try writer.writeAll(ar.path);

const InArchive = struct {

path: []const u8,

offset: u64,

shdrs: std.ArrayListUnmanaged(elf.Elf64_Shdr) = .{},

 

dynamic_table: std.ArrayListUnmanaged(elf.Elf64_Dyn) = .{},

self.shdrs.deinit(allocator);

self.dynamic_table.deinit(allocator);

pub fn parse(self: *SharedObject, elf_file: *Elf, handle: std.fs.File) !void {

const file_size = (try handle.stat()).size;

const header_buffer = try Elf.preadAllAlloc(gpa, handle, 0, @sizeOf(elf.Elf64_Ehdr));

defer gpa.free(header_buffer);

self.header = @as(*align(1) const elf.Elf64_Ehdr, @ptrCast(header_buffer)).*;

const shoff = std.math.cast(usize, self.header.?.e_shoff) orelse return error.Overflow;

const shnum = std.math.cast(usize, self.header.?.e_shnum) orelse return error.Overflow;

const shsize = shnum * @sizeOf(elf.Elf64_Shdr);

if (file_size < shoff or file_size < shoff + shsize) {

const shdrs_buffer = try Elf.preadAllAlloc(gpa, handle, shoff, shsize);

defer gpa.free(shdrs_buffer);

const shdrs = @as([*]align(1) const elf.Elf64_Shdr, @ptrCast(shdrs_buffer.ptr))[0..shnum];

try self.shdrs.appendUnalignedSlice(gpa, shdrs);

var dynsym_sect_index: ?u32 = null;

var dynamic_sect_index: ?u32 = null;

var versym_sect_index: ?u32 = null;

var verdef_sect_index: ?u32 = null;

for (self.shdrs.items, 0..) |shdr, i| {

if (file_size < shdr.sh_offset or file_size < shdr.sh_offset + shdr.sh_size) {

elf.SHT_DYNSYM => dynsym_sect_index = @intCast(i),

elf.SHT_DYNAMIC => dynamic_sect_index = @intCast(i),

elf.SHT_GNU_VERSYM => versym_sect_index = @intCast(i),

elf.SHT_GNU_VERDEF => verdef_sect_index = @intCast(i),

if (dynamic_sect_index) |index| {

const shdr = self.shdrs.items[index];

const raw = try Elf.preadAllAlloc(gpa, handle, shdr.sh_offset, shdr.sh_size);

defer gpa.free(raw);

const num = @divExact(raw.len, @sizeOf(elf.Elf64_Dyn));

const dyntab = @as([*]align(1) const elf.Elf64_Dyn, @ptrCast(raw.ptr))[0..num];

try self.dynamic_table.appendUnalignedSlice(gpa, dyntab);

}

 

const symtab = if (dynsym_sect_index) |index| blk: {

const shdr = self.shdrs.items[index];

const buffer = try Elf.preadAllAlloc(gpa, handle, shdr.sh_offset, shdr.sh_size);

const nsyms = @divExact(buffer.len, @sizeOf(elf.Elf64_Sym));

break :blk @as([*]align(1) const elf.Elf64_Sym, @ptrCast(buffer.ptr))[0..nsyms];

} else &[0]elf.Elf64_Sym{};

defer gpa.free(symtab);

 

const strtab = if (dynsym_sect_index) |index| blk: {

const symtab_shdr = self.shdrs.items[index];

const shdr = self.shdrs.items[symtab_shdr.sh_link];

const buffer = try Elf.preadAllAlloc(gpa, handle, shdr.sh_offset, shdr.sh_size);

break :blk buffer;

} else &[0]u8{};

defer gpa.free(strtab);

 

try self.parseVersions(elf_file, handle, .{

.symtab = symtab,

.verdef_sect_index = verdef_sect_index,

.versym_sect_index = versym_sect_index,

});

 

try self.initSymtab(elf_file, .{

.symtab = symtab,

.strtab = strtab,

});

fn parseVersions(self: *SharedObject, elf_file: *Elf, handle: std.fs.File, opts: struct {

symtab: []align(1) const elf.Elf64_Sym,

verdef_sect_index: ?u32,

versym_sect_index: ?u32,

}) !void {

if (opts.verdef_sect_index) |shndx| {

const shdr = self.shdrs.items[shndx];

const verdefs = try Elf.preadAllAlloc(gpa, handle, shdr.sh_offset, shdr.sh_size);

defer gpa.free(verdefs);

try self.versyms.ensureTotalCapacityPrecise(gpa, opts.symtab.len);

if (opts.versym_sect_index) |shndx| {

const shdr = self.shdrs.items[shndx];

const versyms_raw = try Elf.preadAllAlloc(gpa, handle, shdr.sh_offset, shdr.sh_size);

defer gpa.free(versyms_raw);

} else for (0..opts.symtab.len) |_| {

fn initSymtab(self: *SharedObject, elf_file: *Elf, opts: struct {

symtab: []align(1) const elf.Elf64_Sym,

strtab: []const u8,

}) !void {

try self.strtab.appendSlice(gpa, opts.strtab);

try self.symtab.ensureTotalCapacityPrecise(gpa, opts.symtab.len);

try self.symbols.ensureTotalCapacityPrecise(gpa, opts.symtab.len);

for (opts.symtab, 0..) |sym, i| {

for (self.dynamic_table.items) |entry| switch (entry.d_tag) {

for (self.dynamic_table.items) |entry| switch (entry.d_tag) {

pub fn inputShdr(self: ZigObject, atom_index: Atom.Index, elf_file: *Elf) elf.Elf64_Shdr {

const atom = elf_file.atom(atom_index) orelse return Elf.null_shdr;

const shndx = atom.outputShndx() orelse return Elf.null_shdr;

var shdr = elf_file.shdrs.items[shndx];

shdr.sh_addr = 0;

shdr.sh_offset = 0;

shdr.sh_size = atom.size;

shdr.sh_addralign = atom.alignment.toByteUnits(1);

return shdr;

.size = self.data.items.len,

pub fn data(fde: Fde, elf_file: *Elf) []u8 {

return object.eh_frame_data.items[fde.offset..][0..fde.calcSize()];

return object.relocs.items[fde.rel_index..][0..fde.rel_num];

pub fn data(cie: Cie, elf_file: *Elf) []u8 {

return object.eh_frame_data.items[cie.offset..][0..cie.calcSize()];

return object.relocs.items[cie.rel_index..][0..cie.rel_num];

const contents = cie.data(elf_file);

const contents = fde.data(elf_file);

const contents = fde.data(elf_file);

pub fn updateArSize(file: File, elf_file: *Elf) !void {

.object => |x| x.updateArSize(elf_file),

pub fn writeAr(file: File, elf_file: *Elf, writer: anytype) !void {

.object => |x| x.writeAr(elf_file, writer),

 

pub const Handle = std.fs.File;

pub const HandleIndex = Index;

const members = cg.comdatGroupMembers(elf_file);

const members = cg.comdatGroupMembers(elf_file);