srctree

 

/// List of atoms that are either synthetic or map directly to the Zig source program.

atoms: std.ArrayListUnmanaged(Atom) = .{},

thunks: std.ArrayListUnmanaged(Thunk) = .{},

unwind_records: std.ArrayListUnmanaged(UnwindInfo.Record) = .{},

 

try self.files.append(gpa, .null);

// Atom at index 0 is reserved as null atom

try self.atoms.append(gpa, .{});

// Append empty string to string tables

try self.strings.buffer.append(gpa, 0);

try self.strtab.append(gpa, 0);

self.unwind_info.deinit(gpa);

 

self.atoms.deinit(gpa);

for (self.thunks.items) |*thunk| {

thunk.deinit(gpa);

}

return &self.atoms.items[index];

}

 

pub fn addSymbol(self: *MachO) !Symbol.Index {

const index = @as(Symbol.Index, @intCast(self.symbols.items.len));

const symbol = try self.symbols.addOne(self.base.comp.gpa);

 

/// off + size <= parent section size.

off: u64 = 0,

 

/// Index of this atom in the linker's atoms table.

atom_index: Index = 0,

 

flags: Flags = .{},

 

/// Points to the previous and next neighbors, based on the `text_offset`.

prev_index: Index = 0,

next_index: Index = 0,

 

pub fn getName(self: Atom, macho_file: *MachO) [:0]const u8 {

return switch (self.getFile(macho_file)) {

.dylib => unreachable,

pub fn getRelocs(self: Atom, macho_file: *MachO) []const Relocation {

return switch (self.getFile(macho_file)) {

.dylib => unreachable,

};

}

 

}

 

pub fn getUnwindRecords(self: Atom, macho_file: *MachO) []const UnwindInfo.Record.Index {

return switch (self.getFile(macho_file)) {

};

}

 

}

 

pub fn getThunk(self: Atom, macho_file: *MachO) *Thunk {

}

 

pub fn initOutputSection(sect: macho.section_64, macho_file: *MachO) !u8 {

const gpa = macho_file.base.comp.gpa;

const file = self.getFile(macho_file);

assert(file == .zig_object);

try rels.append(gpa, reloc);

}

 

pub fn freeRelocs(self: *Atom, macho_file: *MachO) void {

}

 

pub fn scanRelocs(self: Atom, macho_file: *MachO) !void {

_ = unused_fmt_string;

const atom = ctx.atom;

const macho_file = ctx.macho_file;

atom.atom_index, atom.getName(macho_file), atom.getAddress(macho_file),

atom.out_n_sect, atom.alignment, atom.size,

});

if (!atom.flags.alive) try writer.writeAll(" : [*]");

try writer.writeAll(" : unwind{ ");

const rec = macho_file.getUnwindRecord(index);

try writer.print("{d}", .{index});

if (!rec.alive) try writer.writeAll("([*])");

}

try writer.writeAll(" }");

}

 

/// Specifies if the atom has been visited during garbage collection.

visited: bool = false,

};

 

};

 

pub const Alignment = @import("../../InternPool.zig").Alignment;

 

.has_subtractor = false,

},

});

self.num_rebase_relocs += 1;

 

return atom_index;

@memcpy(buffer, data[off..][0..size]);

}

 

const relocs = self.sections.items(.relocs)[atom.n_sect];

}

 

fn addString(self: *InternalObject, allocator: Allocator, name: [:0]const u8) error{OutOfMemory}!u32 {

 

if (!atom.flags.alive) continue;

if (next_reloc >= relocs.items.len) break;

const end_addr = atom.off + atom.size;

 

while (next_reloc < relocs.items.len and relocs.items[next_reloc].offset < end_addr) : (next_reloc += 1) {}

 

}

}

}

{}

 

const atom = rec.getAtom(macho_file);

}

}

 

if (amt != buffer.len) return error.InputOutput;

}

 

const relocs = self.sections.items(.relocs)[atom.n_sect];

}

 

fn addString(self: *Object, allocator: Allocator, name: [:0]const u8) error{OutOfMemory}!u32 {

 

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

const relocs = try self.relocs.addOne(gpa);

relocs.* = .{};

 

return symbol_index;

}

}

}

 

}

 

}

 

pub fn resolveSymbols(self: *ZigObject, macho_file: *MachO) void {

 

if (isReachable(atom, rel, macho_file)) continue;

try thunk.symbols.put(gpa, rel.target, {});

}

}

 

thunk.value = try advance(header, thunk.size(), .@"4");