stage2 macho: first, rough draft at trampolining
Jakub Konka
parent
80b1041c21
commit
ef5132c508
|
|
@ -2767,24 +2767,51 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
|
|||
// For MachO, the binary, with the exception of object files, has to be a PIE.
|
||||
// Therefore, we cannot load an absolute address.
|
||||
assert(x > math.maxInt(u32)); // 32bit direct addressing is not supported by MachO.
|
||||
// The plan here is to use RIP-relative addressing, but leaving the actual displacement
|
||||
// information empty (0-padded) and fixing it up later in the linker.
|
||||
try self.mod_fn.owner_decl.link.macho.addRipPosition(self.bin_file.allocator, .{
|
||||
.address = x,
|
||||
.start = self.code.items.len,
|
||||
.len = 7,
|
||||
});
|
||||
try self.code.ensureCapacity(self.code.items.len + 9);
|
||||
// leaq %r, [rip + disp]
|
||||
self.code.appendSliceAssumeCapacity(&[_]u8{
|
||||
0x48,
|
||||
0x8d,
|
||||
0x05 | (@as(u8, reg.id() & 0b111) << 3), // R
|
||||
0x0,
|
||||
0x0,
|
||||
0x0,
|
||||
0x0,
|
||||
});
|
||||
// The plan here is to use unconditional relative jump to GOT entry, where we store
|
||||
// pre-calculated and stored effective address to load into the target register.
|
||||
// We leave the actual displacement information empty (0-padded) and fixing it up
|
||||
// later in the linker.
|
||||
if (reg.id() == 0) { // %rax is special-cased
|
||||
try self.code.ensureCapacity(self.code.items.len + 5);
|
||||
try self.mod_fn.owner_decl.link.macho.addRipPosition(self.bin_file.allocator, .{
|
||||
.address = x,
|
||||
.start = self.code.items.len,
|
||||
.len = 5,
|
||||
});
|
||||
// call [label]
|
||||
self.code.appendSliceAssumeCapacity(&[_]u8{
|
||||
0xE8,
|
||||
0x0,
|
||||
0x0,
|
||||
0x0,
|
||||
0x0,
|
||||
});
|
||||
} else {
|
||||
try self.code.ensureCapacity(self.code.items.len + 10);
|
||||
// push %rax
|
||||
self.code.appendSliceAssumeCapacity(&[_]u8{0x50});
|
||||
try self.mod_fn.owner_decl.link.macho.addRipPosition(self.bin_file.allocator, .{
|
||||
.address = x,
|
||||
.start = self.code.items.len,
|
||||
.len = 5,
|
||||
});
|
||||
// call [label]
|
||||
self.code.appendSliceAssumeCapacity(&[_]u8{
|
||||
0xE8,
|
||||
0x0,
|
||||
0x0,
|
||||
0x0,
|
||||
0x0,
|
||||
});
|
||||
// mov %r, %rax
|
||||
self.code.appendSliceAssumeCapacity(&[_]u8{
|
||||
0x48,
|
||||
0x89,
|
||||
0xC0 | @as(u8, reg.id()),
|
||||
});
|
||||
// pop %rax
|
||||
self.code.appendSliceAssumeCapacity(&[_]u8{0x58});
|
||||
}
|
||||
} else if (x <= math.maxInt(u32)) {
|
||||
// Moving from memory to a register is a variant of `8B /r`.
|
||||
// Since we're using 64-bit moves, we require a REX.
|
||||
|
|
|
|||
|
|
@ -1020,8 +1020,8 @@ pub fn updateDecl(self: *MachO, module: *Module, decl: *Module.Decl) !void {
|
|||
const target_addr = rip.address;
|
||||
// const got_addr = got_section.addr + decl.link.macho.offset_table_index * @sizeOf(u64);
|
||||
const this_addr = symbol.n_value + rip.start;
|
||||
std.debug.print("target_addr=0x{x},this_addr=0x{x}\n", .{target_addr, this_addr});
|
||||
const displacement = @intCast(u32, target_addr - this_addr + rip.len);
|
||||
std.debug.print("target_addr=0x{x},this_addr=0x{x}\n", .{ target_addr, this_addr });
|
||||
const displacement = @intCast(u32, target_addr - this_addr - rip.len);
|
||||
std.debug.print("displacement=0x{x}\n", .{displacement});
|
||||
var placeholder = code_buffer.items[rip.start + rip.len - @sizeOf(u32) ..][0..@sizeOf(u32)];
|
||||
mem.writeIntSliceLittle(u32, placeholder, displacement);
|
||||
|
|
@ -1201,7 +1201,7 @@ pub fn populateMissingMetadata(self: *MachO) !void {
|
|||
.addr = text_segment.vmaddr + off,
|
||||
.size = file_size,
|
||||
.offset = off,
|
||||
.@"align" = if (self.base.options.target.cpu.arch == .aarch64) 2 else 1, // 2^2 for aarch64, 2^1 for x86_64
|
||||
.@"align" = if (self.base.options.target.cpu.arch == .aarch64) 2 else 0, // 2^2 for aarch64, 2^0 for x86_64
|
||||
.reloff = 0,
|
||||
.nreloc = 0,
|
||||
.flags = flags,
|
||||
|
|
@ -1214,48 +1214,23 @@ pub fn populateMissingMetadata(self: *MachO) !void {
|
|||
text_segment.filesize = file_size + off;
|
||||
self.cmd_table_dirty = true;
|
||||
}
|
||||
if (self.data_segment_cmd_index == null) {
|
||||
self.data_segment_cmd_index = @intCast(u16, self.load_commands.items.len);
|
||||
const text_segment = &self.load_commands.items[self.text_segment_cmd_index.?].Segment;
|
||||
const maxprot = macho.VM_PROT_READ | macho.VM_PROT_WRITE | macho.VM_PROT_EXECUTE;
|
||||
const initprot = macho.VM_PROT_READ | macho.VM_PROT_WRITE;
|
||||
try self.load_commands.append(self.base.allocator, .{
|
||||
.Segment = .{
|
||||
.cmd = macho.LC_SEGMENT_64,
|
||||
.cmdsize = @sizeOf(macho.segment_command_64),
|
||||
.segname = makeStaticString("__DATA"),
|
||||
.vmaddr = text_segment.vmaddr + text_segment.vmsize,
|
||||
.vmsize = 0,
|
||||
.fileoff = text_segment.fileoff + text_segment.filesize,
|
||||
.filesize = 0,
|
||||
.maxprot = maxprot,
|
||||
.initprot = initprot,
|
||||
.nsects = 0,
|
||||
.flags = 0,
|
||||
},
|
||||
});
|
||||
self.cmd_table_dirty = true;
|
||||
}
|
||||
if (self.got_section_index == null) {
|
||||
const text_section = &self.sections.items[self.text_section_index.?];
|
||||
self.got_section_index = @intCast(u16, self.sections.items.len);
|
||||
const data_segment = &self.load_commands.items[self.data_segment_cmd_index.?].Segment;
|
||||
data_segment.cmdsize += @sizeOf(macho.section_64);
|
||||
data_segment.nsects += 1;
|
||||
|
||||
const file_size = @sizeOf(u64) * self.base.options.symbol_count_hint;
|
||||
// TODO looking for free space should be done *within* a segment it belongs to
|
||||
// const off = @intCast(u32, self.findFreeSpace(file_size, self.page_size));
|
||||
const off = @intCast(u32, data_segment.fileoff);
|
||||
const off = @intCast(u32, text_section.offset + text_section.size);
|
||||
|
||||
log.debug("found __got section free space 0x{x} to 0x{x}\n", .{ off, off + file_size });
|
||||
|
||||
try self.sections.append(self.base.allocator, .{
|
||||
.sectname = makeStaticString("__got"),
|
||||
.segname = makeStaticString("__DATA"),
|
||||
.addr = data_segment.vmaddr,
|
||||
.sectname = makeStaticString("__ziggot"),
|
||||
.segname = makeStaticString("__TEXT"),
|
||||
.addr = text_section.addr + text_section.size,
|
||||
.size = file_size,
|
||||
.offset = off,
|
||||
.@"align" = 3, // 2^3 = 8
|
||||
.@"align" = if (self.base.options.target.cpu.arch == .aarch64) 2 else 0,
|
||||
.reloff = 0,
|
||||
.nreloc = 0,
|
||||
.flags = macho.S_REGULAR,
|
||||
|
|
@ -1264,23 +1239,26 @@ pub fn populateMissingMetadata(self: *MachO) !void {
|
|||
.reserved3 = 0,
|
||||
});
|
||||
|
||||
const segment_size = mem.alignForwardGeneric(u64, file_size, self.page_size);
|
||||
data_segment.vmsize = segment_size;
|
||||
data_segment.filesize = segment_size;
|
||||
const added_size = mem.alignForwardGeneric(u64, file_size, self.page_size);
|
||||
const text_segment = &self.load_commands.items[self.text_segment_cmd_index.?].Segment;
|
||||
text_segment.vmsize += added_size;
|
||||
text_segment.filesize += added_size;
|
||||
text_segment.cmdsize += @sizeOf(macho.section_64);
|
||||
text_segment.nsects += 1;
|
||||
self.cmd_table_dirty = true;
|
||||
}
|
||||
if (self.linkedit_segment_cmd_index == null) {
|
||||
self.linkedit_segment_cmd_index = @intCast(u16, self.load_commands.items.len);
|
||||
const data_segment = &self.load_commands.items[self.data_segment_cmd_index.?].Segment;
|
||||
const text_segment = &self.load_commands.items[self.text_segment_cmd_index.?].Segment;
|
||||
const maxprot = macho.VM_PROT_READ | macho.VM_PROT_WRITE | macho.VM_PROT_EXECUTE;
|
||||
const initprot = macho.VM_PROT_READ;
|
||||
const off = data_segment.fileoff + data_segment.filesize;
|
||||
const off = text_segment.fileoff + text_segment.filesize;
|
||||
try self.load_commands.append(self.base.allocator, .{
|
||||
.Segment = .{
|
||||
.cmd = macho.LC_SEGMENT_64,
|
||||
.cmdsize = @sizeOf(macho.segment_command_64),
|
||||
.segname = makeStaticString("__LINKEDIT"),
|
||||
.vmaddr = data_segment.vmaddr + data_segment.vmsize,
|
||||
.vmaddr = text_segment.vmaddr + text_segment.vmsize,
|
||||
.vmsize = 0,
|
||||
.fileoff = off,
|
||||
.filesize = 0,
|
||||
|
|
@ -1671,11 +1649,24 @@ fn findFreeSpace(self: *MachO, object_size: u64, min_alignment: u16) u64 {
|
|||
fn writeOffsetTableEntry(self: *MachO, index: usize) !void {
|
||||
const sect = &self.sections.items[self.got_section_index.?];
|
||||
const endian = self.base.options.target.cpu.arch.endian();
|
||||
var buf: [@sizeOf(u64)]u8 = undefined;
|
||||
mem.writeInt(u64, &buf, self.offset_table.items[index], endian);
|
||||
|
||||
const off = sect.offset + @sizeOf(u64) * index;
|
||||
const vmaddr = sect.addr + @sizeOf(u64) * index;
|
||||
const pos_symbol_off = @truncate(u31, vmaddr - self.offset_table.items[index] + 7);
|
||||
const symbol_off = @intCast(i32, pos_symbol_off) * -1;
|
||||
std.debug.print("vmaddr=0x{x},item=0x{x}\n", .{vmaddr, self.offset_table.items[index]});
|
||||
std.debug.print("posSymbolOff=0x{x},symbolOff=0x{x}\n", .{pos_symbol_off, @bitCast(u32, symbol_off)});
|
||||
|
||||
var code: [8]u8 = undefined;
|
||||
// lea %rax, [rip - disp]
|
||||
code[0] = 0x48;
|
||||
code[1] = 0x8D;
|
||||
code[2] = 0x5;
|
||||
mem.writeInt(u32, code[3..7], @bitCast(u32, symbol_off), endian);
|
||||
// ret
|
||||
code[7] = 0xC3;
|
||||
log.debug("writing offset table entry 0x{x} at 0x{x}\n", .{ self.offset_table.items[index], off });
|
||||
try self.base.file.?.pwriteAll(&buf, off);
|
||||
try self.base.file.?.pwriteAll(&code, off);
|
||||
}
|
||||
|
||||
fn writeSymbolTable(self: *MachO) !void {
|
||||
|
|
@ -1791,7 +1782,7 @@ fn writeExportTrie(self: *MachO) !void {
|
|||
|
||||
if (export_size > buffer.items.len) {
|
||||
// Pad out to align(8).
|
||||
try self.base.file.?.pwriteAll(&[_]u8{ 0 }, dyld_info.export_off + export_size);
|
||||
try self.base.file.?.pwriteAll(&[_]u8{0}, dyld_info.export_off + export_size);
|
||||
}
|
||||
try self.base.file.?.pwriteAll(buffer.items, dyld_info.export_off);
|
||||
|
||||
|
|
@ -1816,7 +1807,7 @@ fn writeStringTable(self: *MachO) !void {
|
|||
|
||||
if (symtab.strsize > needed_size) {
|
||||
// Pad out to align(8);
|
||||
try self.base.file.?.pwriteAll(&[_]u8{ 0 }, symtab.stroff + symtab.strsize);
|
||||
try self.base.file.?.pwriteAll(&[_]u8{0}, symtab.stroff + symtab.strsize);
|
||||
}
|
||||
try self.base.file.?.pwriteAll(self.string_table.items, symtab.stroff);
|
||||
|
||||
|
|
@ -1843,7 +1834,6 @@ fn writeCmdHeaders(self: *MachO) !void {
|
|||
last_cmd_offset += cmd.cmdsize();
|
||||
}
|
||||
{
|
||||
// write __text section header
|
||||
const off = if (self.text_segment_cmd_index) |text_segment_index| blk: {
|
||||
var i: usize = 0;
|
||||
var cmdsize: usize = @sizeOf(macho.mach_header_64) + @sizeOf(macho.segment_command_64);
|
||||
|
|
@ -1856,27 +1846,14 @@ fn writeCmdHeaders(self: *MachO) !void {
|
|||
// only one, noname segment to append this section header to.
|
||||
return error.TODOImplementWritingObjFiles;
|
||||
};
|
||||
const idx = self.text_section_index.?;
|
||||
// write __text section header
|
||||
const id1 = self.text_section_index.?;
|
||||
log.debug("writing text section header at 0x{x}\n", .{off});
|
||||
try self.base.file.?.pwriteAll(mem.sliceAsBytes(self.sections.items[idx .. idx + 1]), off);
|
||||
}
|
||||
{
|
||||
// write __got section header
|
||||
const off = if (self.data_segment_cmd_index) |data_segment_index| blk: {
|
||||
var i: usize = 0;
|
||||
var cmdsize: usize = @sizeOf(macho.mach_header_64) + @sizeOf(macho.segment_command_64);
|
||||
while (i < data_segment_index) : (i += 1) {
|
||||
cmdsize += self.load_commands.items[i].cmdsize();
|
||||
}
|
||||
break :blk cmdsize;
|
||||
} else {
|
||||
// If we've landed in here, we are building a MachO object file, so we have
|
||||
// only one, noname segment to append this section header to.
|
||||
return error.TODOImplementWritingObjFiles;
|
||||
};
|
||||
const idx = self.got_section_index.?;
|
||||
log.debug("writing got section header at 0x{x}\n", .{off});
|
||||
try self.base.file.?.pwriteAll(mem.sliceAsBytes(self.sections.items[idx .. idx + 1]), off);
|
||||
try self.base.file.?.pwriteAll(mem.sliceAsBytes(self.sections.items[id1 .. id1 + 1]), off);
|
||||
// write __ziggot section header
|
||||
const id2 = self.got_section_index.?;
|
||||
log.debug("writing got section header at 0x{x}\n", .{off + @sizeOf(macho.section_64)});
|
||||
try self.base.file.?.pwriteAll(mem.sliceAsBytes(self.sections.items[id2 .. id2 + 1]), off + @sizeOf(macho.section_64));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -67,8 +67,6 @@ pub fn init(alloc: *Allocator) CodeSignature {
|
|||
|
||||
pub fn calcAdhocSignature(self: *CodeSignature, bin_file: *const MachO) !void {
|
||||
const text_segment = bin_file.load_commands.items[bin_file.text_segment_cmd_index.?].Segment;
|
||||
const data_segment = bin_file.load_commands.items[bin_file.data_segment_cmd_index.?].Segment;
|
||||
const linkedit_segment = bin_file.load_commands.items[bin_file.linkedit_segment_cmd_index.?].Segment;
|
||||
const code_sig_cmd = bin_file.load_commands.items[bin_file.code_signature_cmd_index.?].LinkeditData;
|
||||
|
||||
const execSegBase: u64 = text_segment.fileoff;
|
||||
|
|
|
|||
Loading…
Reference in New Issue