authorgravatar for jacoblevgw@gmail.comJacob G-W <jacoblevgw@gmail.com> 2021-06-08 20:12:18-04:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2021-07-08 14:10:49-07:00
log3e59c1502556493b29171c2d22447dd70670ca02
treeda6e6ed293d124312623b931ef050de8829d7c30
parentc114474190fd6fe48b8c74becfb39ed82287d059

plan9 linker: do relocations

2 files changed, 93 insertions(+), 24 deletions(-)

src/codegen.zig+50-10
......@@ -2557,16 +2557,56 @@ fn Function(comptime arch: std.Target.Cpu.Arch) type {
25572557 return self.fail(inst.base.src, "TODO implement calling runtime known function pointer", .{});
25582558 }
25592559 } else if (self.bin_file.cast(link.File.Plan9)) |p9| {
2560 if (inst.func.value()) |func_value| {
2561 if (func_value.castTag(.function)) |func_payload| {
2562 try p9.addCallReloc(self.code, .{
2563 .caller = p9.cur_decl,
2564 .callee = func_payload.data.owner_decl,
2565 .offset_in_caller = self.code.items.len,
2566 });
2567 } else return self.fail(inst.base.src, "TODO implement calling extern fn on plan9", .{});
2568 } else {
2569 return self.fail(inst.base.src, "TODO implement calling runtime known function pointer", .{});
2560 switch (arch) {
2561 .x86_64 => {
2562 for (info.args) |mc_arg, arg_i| {
2563 const arg = inst.args[arg_i];
2564 const arg_mcv = try self.resolveInst(inst.args[arg_i]);
2565 // Here we do not use setRegOrMem even though the logic is similar, because
2566 // the function call will move the stack pointer, so the offsets are different.
2567 switch (mc_arg) {
2568 .none => continue,
2569 .register => |reg| {
2570 try self.register_manager.getReg(reg, null);
2571 try self.genSetReg(arg.src, arg.ty, reg, arg_mcv);
2572 },
2573 .stack_offset => {
2574 // Here we need to emit instructions like this:
2575 // mov qword ptr [rsp + stack_offset], x
2576 return self.fail(inst.base.src, "TODO implement calling with parameters in memory", .{});
2577 },
2578 .ptr_stack_offset => {
2579 return self.fail(inst.base.src, "TODO implement calling with MCValue.ptr_stack_offset arg", .{});
2580 },
2581 .ptr_embedded_in_code => {
2582 return self.fail(inst.base.src, "TODO implement calling with MCValue.ptr_embedded_in_code arg", .{});
2583 },
2584 .undef => unreachable,
2585 .immediate => unreachable,
2586 .unreach => unreachable,
2587 .dead => unreachable,
2588 .embedded_in_code => unreachable,
2589 .memory => unreachable,
2590 .compare_flags_signed => unreachable,
2591 .compare_flags_unsigned => unreachable,
2592 }
2593 }
2594 if (inst.func.value()) |func_value| {
2595 if (func_value.castTag(.function)) |func_payload| {
2596 try self.genSetReg(inst.base.src, Type.initTag(.u64), .rax, .{ .immediate = 0xdeadbeefdeadbeef });
2597 try p9.addCallReloc(self.code, .{
2598 .caller = p9.cur_decl,
2599 .callee = func_payload.data.owner_decl,
2600 .offset_in_caller = self.code.items.len,
2601 });
2602 // call rax
2603 try self.code.appendSlice(&.{ 0xff, 0xd0 });
2604 } else return self.fail(inst.base.src, "TODO implement calling extern fn on plan9", .{});
2605 } else {
2606 return self.fail(inst.base.src, "TODO implement calling runtime known function pointer", .{});
2607 }
2608 },
2609 else => return self.fail(inst.base.src, "TODO implement call on plan9 for {}", .{self.target.cpu.arch}),
25702610 }
25712611 } else unreachable;
25722612
src/link/Plan9.zig+43-14
......@@ -39,11 +39,12 @@ pub const DeclBlock = struct {
3939 type: enum { text, data },
4040 // offset in the text or data sects
4141 offset: u32,
42 sym_index: usize,
42 // offset into syms
43 sym_index: ?usize,
4344 pub const empty = DeclBlock{
4445 .type = .text,
4546 .offset = 0,
46 .sym_index = 0,
47 .sym_index = null,
4748 };
4849};
4950
......@@ -98,6 +99,8 @@ pub fn flushModule(self: *Plan9, comp: *Compilation) !void {
9899 const tracy = trace(@src());
99100 defer tracy.end();
100101
102 defer assert(self.hdr.entry != 0x0);
103
101104 const module = self.base.options.module orelse return error.LinkingWithoutZigSourceUnimplemented;
102105
103106 self.text_buf.items.len = 0;
......@@ -120,7 +123,7 @@ pub fn flushModule(self: *Plan9, comp: *Compilation) !void {
120123 .type = .data,
121124 .sym_index = decl.link.plan9.sym_index,
122125 };
123 if (decl.link.plan9.sym_index == 0) {
126 if (decl.link.plan9.sym_index == null) {
124127 try self.syms.append(self.base.allocator, .{
125128 .value = decl.link.plan9.offset,
126129 .type = switch (decl.link.plan9.type) {
......@@ -131,7 +134,7 @@ pub fn flushModule(self: *Plan9, comp: *Compilation) !void {
131134 });
132135 decl.link.plan9.sym_index = self.syms.items.len - 1;
133136 } else {
134 self.syms.items[decl.link.plan9.sym_index] = .{
137 self.syms.items[decl.link.plan9.sym_index.?] = .{
135138 .value = decl.link.plan9.offset,
136139 .type = switch (decl.link.plan9.type) {
137140 .text => .t,
......@@ -162,18 +165,40 @@ pub fn flushModule(self: *Plan9, comp: *Compilation) !void {
162165 }
163166 }
164167
168 // Do relocations.
169 {
170 for (self.call_relocs.items) |reloc| {
171 const l: DeclBlock = reloc.caller.link.plan9;
172 assert(l.sym_index != null); // we didn't process it already
173 const endian = self.base.options.target.cpu.arch.endian();
174 if (self.ptr_width == .p32) {
175 const callee_offset = @truncate(u32, reloc.callee.link.plan9.offset + default_base_addr); // TODO this is different if its data
176 const off = reloc.offset_in_caller + l.offset;
177 std.mem.writeInt(u32, self.text_buf.items[off - 4 ..][0..4], callee_offset, endian);
178 } else {
179 // what we are writing
180 const callee_offset = reloc.callee.link.plan9.offset + default_base_addr; // TODO this is different if its data
181 const off = reloc.offset_in_caller + l.offset;
182 std.mem.writeInt(u64, self.text_buf.items[off - 8 ..][0..8], callee_offset, endian);
183 }
184 }
185 }
186
165187 var sym_buf = std.ArrayList(u8).init(self.base.allocator);
166188 defer sym_buf.deinit();
167189 try self.writeSyms(&sym_buf);
168190
169191 // generate the header
170 self.hdr.magic = try aout.magicFromArch(self.base.options.target.cpu.arch);
171 self.hdr.text = @intCast(u32, self.text_buf.items.len);
172 self.hdr.data = @intCast(u32, self.data_buf.items.len);
173 self.hdr.syms = @intCast(u32, sym_buf.items.len);
174 self.hdr.bss = 0;
175 self.hdr.pcsz = 0;
176 self.hdr.spsz = 0;
192 self.hdr = .{
193 .magic = try aout.magicFromArch(self.base.options.target.cpu.arch),
194 .text = @intCast(u32, self.text_buf.items.len),
195 .data = @intCast(u32, self.data_buf.items.len),
196 .syms = @intCast(u32, sym_buf.items.len),
197 .bss = 0,
198 .pcsz = 0,
199 .spsz = 0,
200 .entry = self.hdr.entry,
201 };
177202
178203 const file = self.base.file.?;
179204
......@@ -262,22 +287,26 @@ pub fn openPath(allocator: *Allocator, sub_path: []const u8, options: link.Optio
262287 const self = try createEmpty(allocator, options);
263288 errdefer self.base.destroy();
264289
290 if (std.builtin.mode == .Debug or std.builtin.mode == .ReleaseSafe)
291 self.hdr.entry = 0x0;
292
265293 self.base.file = file;
266294 return self;
267295}
268296
297// tells its future self to write the addr of the callee decl into offset_in_caller.
298// writes it to the {4, 8} bytes before offset_in_caller
269299pub fn addCallReloc(self: *Plan9, code: *std.ArrayList(u8), reloc: CallReloc) !void {
270300 try self.call_relocs.append(self.base.allocator, reloc);
271 try code.writer().writeIntBig(u64, 0xdeadbeef);
272301}
273302
274303pub fn writeSyms(self: *Plan9, buf: *std.ArrayList(u8)) !void {
275304 const writer = buf.writer();
276305 for (self.syms.items) |sym| {
277306 if (self.ptr_width == .p32) {
278 try writer.writeIntBig(u32, @intCast(u32, sym.value));
307 try writer.writeIntBig(u32, @intCast(u32, sym.value) + default_base_addr);
279308 } else {
280 try writer.writeIntBig(u64, sym.value);
309 try writer.writeIntBig(u64, sym.value + default_base_addr);
281310 }
282311 try writer.writeByte(@enumToInt(sym.type));
283312 try writer.writeAll(std.mem.span(sym.name));