authorgravatar for kubkon@jakubkonka.comJakub Konka <kubkon@jakubkonka.com> 2023-01-25 23:17:13+01:00
committergravatar for kubkon@jakubkonka.comJakub Konka <kubkon@jakubkonka.com> 2023-01-26 14:29:14+01:00
log041bc71bc8ff45dc2d4df11d48023e457b8b021e
treedd89ac48c1159c11612bbc70867da377cd53a9b1
parent4d804c1b239e45a0a28f4caf1f9748dac44ddce2

self-hosted: clean up calling logic for x86_64 and aarch64 across linkers

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

src/arch/aarch64/CodeGen.zig+41-82
...@@ -4302,32 +4302,19 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier...@@ -4302,32 +4302,19 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier
4302 // on linking.4302 // on linking.
4303 const mod = self.bin_file.options.module.?;4303 const mod = self.bin_file.options.module.?;
4304 if (self.air.value(callee)) |func_value| {4304 if (self.air.value(callee)) |func_value| {
4305 if (self.bin_file.cast(link.File.Elf)) |elf_file| {4305 if (func_value.castTag(.function)) |func_payload| {
4306 if (func_value.castTag(.function)) |func_payload| {4306 const func = func_payload.data;
4307 const func = func_payload.data;4307 const fn_owner_decl = mod.declPtr(func.owner_decl);
4308
4309 if (self.bin_file.cast(link.File.Elf)) |elf_file| {
4308 const ptr_bits = self.target.cpu.arch.ptrBitWidth();4310 const ptr_bits = self.target.cpu.arch.ptrBitWidth();
4309 const ptr_bytes: u64 = @divExact(ptr_bits, 8);4311 const ptr_bytes: u64 = @divExact(ptr_bits, 8);
4310 const fn_owner_decl = mod.declPtr(func.owner_decl);
4311 const got_addr = blk: {4312 const got_addr = blk: {
4312 const got = &elf_file.program_headers.items[elf_file.phdr_got_index.?];4313 const got = &elf_file.program_headers.items[elf_file.phdr_got_index.?];
4313 break :blk @intCast(u32, got.p_vaddr + fn_owner_decl.link.elf.offset_table_index * ptr_bytes);4314 break :blk @intCast(u32, got.p_vaddr + fn_owner_decl.link.elf.offset_table_index * ptr_bytes);
4314 };4315 };
4315
4316 try self.genSetReg(Type.initTag(.usize), .x30, .{ .memory = got_addr });4316 try self.genSetReg(Type.initTag(.usize), .x30, .{ .memory = got_addr });
43174317 } else if (self.bin_file.cast(link.File.MachO)) |macho_file| {
4318 _ = try self.addInst(.{
4319 .tag = .blr,
4320 .data = .{ .reg = .x30 },
4321 });
4322 } else if (func_value.castTag(.extern_fn)) |_| {
4323 return self.fail("TODO implement calling extern functions", .{});
4324 } else {
4325 return self.fail("TODO implement calling bitcasted functions", .{});
4326 }
4327 } else if (self.bin_file.cast(link.File.MachO)) |macho_file| {
4328 if (func_value.castTag(.function)) |func_payload| {
4329 const func = func_payload.data;
4330 const fn_owner_decl = mod.declPtr(func.owner_decl);
4331 try fn_owner_decl.link.macho.ensureInitialized(macho_file);4318 try fn_owner_decl.link.macho.ensureInitialized(macho_file);
4332 try self.genSetReg(Type.initTag(.u64), .x30, .{4319 try self.genSetReg(Type.initTag(.u64), .x30, .{
4333 .linker_load = .{4320 .linker_load = .{
...@@ -4335,22 +4322,39 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier...@@ -4335,22 +4322,39 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier
4335 .sym_index = fn_owner_decl.link.macho.getSymbolIndex().?,4322 .sym_index = fn_owner_decl.link.macho.getSymbolIndex().?,
4336 },4323 },
4337 });4324 });
4338 // blr x304325 } else if (self.bin_file.cast(link.File.Coff)) |_| {
4339 _ = try self.addInst(.{4326 try self.genSetReg(Type.initTag(.u64), .x30, .{
4340 .tag = .blr,4327 .linker_load = .{
4341 .data = .{ .reg = .x30 },4328 .type = .got,
4329 .sym_index = fn_owner_decl.link.coff.sym_index,
4330 },
4342 });4331 });
4343 } else if (func_value.castTag(.extern_fn)) |func_payload| {4332 } else if (self.bin_file.cast(link.File.Plan9)) |p9| {
4344 const extern_fn = func_payload.data;4333 try p9.seeDecl(func.owner_decl);
4345 const decl_name = mod.declPtr(extern_fn.owner_decl).name;4334 const ptr_bits = self.target.cpu.arch.ptrBitWidth();
4346 if (extern_fn.lib_name) |lib_name| {4335 const ptr_bytes: u64 = @divExact(ptr_bits, 8);
4347 log.debug("TODO enforce that '{s}' is expected in '{s}' library", .{4336 const got_addr = p9.bases.data;
4348 decl_name,4337 const got_index = fn_owner_decl.link.plan9.got_index.?;
4349 lib_name,4338 const fn_got_addr = got_addr + got_index * ptr_bytes;
4350 });4339 try self.genSetReg(Type.initTag(.usize), .x30, .{ .memory = fn_got_addr });
4351 }4340 } else unreachable;
4352 const sym_index = try macho_file.getGlobalSymbol(mem.sliceTo(decl_name, 0));4341
4342 _ = try self.addInst(.{
4343 .tag = .blr,
4344 .data = .{ .reg = .x30 },
4345 });
4346 } else if (func_value.castTag(.extern_fn)) |func_payload| {
4347 const extern_fn = func_payload.data;
4348 const decl_name = mod.declPtr(extern_fn.owner_decl).name;
4349 if (extern_fn.lib_name) |lib_name| {
4350 log.debug("TODO enforce that '{s}' is expected in '{s}' library", .{
4351 decl_name,
4352 lib_name,
4353 });
4354 }
43534355
4356 if (self.bin_file.cast(link.File.MachO)) |macho_file| {
4357 const sym_index = try macho_file.getGlobalSymbol(mem.sliceTo(decl_name, 0));
4354 _ = try self.addInst(.{4358 _ = try self.addInst(.{
4355 .tag = .call_extern,4359 .tag = .call_extern,
4356 .data = .{4360 .data = .{
...@@ -4360,33 +4364,7 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier...@@ -4360,33 +4364,7 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier
4360 },4364 },
4361 },4365 },
4362 });4366 });
4363 } else {4367 } else if (self.bin_file.cast(link.File.Coff)) |coff_file| {
4364 return self.fail("TODO implement calling bitcasted functions", .{});
4365 }
4366 } else if (self.bin_file.cast(link.File.Coff)) |coff_file| {
4367 if (func_value.castTag(.function)) |func_payload| {
4368 const func = func_payload.data;
4369 const fn_owner_decl = mod.declPtr(func.owner_decl);
4370 try self.genSetReg(Type.initTag(.u64), .x30, .{
4371 .linker_load = .{
4372 .type = .got,
4373 .sym_index = fn_owner_decl.link.coff.sym_index,
4374 },
4375 });
4376 // blr x30
4377 _ = try self.addInst(.{
4378 .tag = .blr,
4379 .data = .{ .reg = .x30 },
4380 });
4381 } else if (func_value.castTag(.extern_fn)) |func_payload| {
4382 const extern_fn = func_payload.data;
4383 const decl_name = mod.declPtr(extern_fn.owner_decl).name;
4384 if (extern_fn.lib_name) |lib_name| {
4385 log.debug("TODO enforce that '{s}' is expected in '{s}' library", .{
4386 decl_name,
4387 lib_name,
4388 });
4389 }
4390 const sym_index = try coff_file.getGlobalSymbol(mem.sliceTo(decl_name, 0));4368 const sym_index = try coff_file.getGlobalSymbol(mem.sliceTo(decl_name, 0));
4391 try self.genSetReg(Type.initTag(.u64), .x30, .{4369 try self.genSetReg(Type.initTag(.u64), .x30, .{
4392 .linker_load = .{4370 .linker_load = .{
...@@ -4394,35 +4372,16 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier...@@ -4394,35 +4372,16 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier
4394 .sym_index = sym_index,4372 .sym_index = sym_index,
4395 },4373 },
4396 });4374 });
4397 // blr x30
4398 _ = try self.addInst(.{4375 _ = try self.addInst(.{
4399 .tag = .blr,4376 .tag = .blr,
4400 .data = .{ .reg = .x30 },4377 .data = .{ .reg = .x30 },
4401 });4378 });
4402 } else {4379 } else {
4403 return self.fail("TODO implement calling bitcasted functions", .{});
4404 }
4405 } else if (self.bin_file.cast(link.File.Plan9)) |p9| {
4406 if (func_value.castTag(.function)) |func_payload| {
4407 try p9.seeDecl(func_payload.data.owner_decl);
4408 const ptr_bits = self.target.cpu.arch.ptrBitWidth();
4409 const ptr_bytes: u64 = @divExact(ptr_bits, 8);
4410 const got_addr = p9.bases.data;
4411 const got_index = mod.declPtr(func_payload.data.owner_decl).link.plan9.got_index.?;
4412 const fn_got_addr = got_addr + got_index * ptr_bytes;
4413
4414 try self.genSetReg(Type.initTag(.usize), .x30, .{ .memory = fn_got_addr });
4415
4416 _ = try self.addInst(.{
4417 .tag = .blr,
4418 .data = .{ .reg = .x30 },
4419 });
4420 } else if (func_value.castTag(.extern_fn)) |_| {
4421 return self.fail("TODO implement calling extern functions", .{});4380 return self.fail("TODO implement calling extern functions", .{});
4422 } else {
4423 return self.fail("TODO implement calling bitcasted functions", .{});
4424 }4381 }
4425 } else unreachable;4382 } else {
4383 return self.fail("TODO implement calling bitcasted functions", .{});
4384 }
4426 } else {4385 } else {
4427 assert(ty.zigTypeTag() == .Pointer);4386 assert(ty.zigTypeTag() == .Pointer);
4428 const mcv = try self.resolveInst(callee);4387 const mcv = try self.resolveInst(callee);
src/arch/x86_64/CodeGen.zig+52-113
...@@ -3992,13 +3992,14 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier...@@ -3992,13 +3992,14 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier
3992 // Due to incremental compilation, how function calls are generated depends3992 // Due to incremental compilation, how function calls are generated depends
3993 // on linking.3993 // on linking.
3994 const mod = self.bin_file.options.module.?;3994 const mod = self.bin_file.options.module.?;
3995 if (self.bin_file.cast(link.File.Elf)) |elf_file| {3995 if (self.air.value(callee)) |func_value| {
3996 if (self.air.value(callee)) |func_value| {3996 if (func_value.castTag(.function)) |func_payload| {
3997 if (func_value.castTag(.function)) |func_payload| {3997 const func = func_payload.data;
3998 const func = func_payload.data;3998 const fn_owner_decl = mod.declPtr(func.owner_decl);
3999
4000 if (self.bin_file.cast(link.File.Elf)) |elf_file| {
3999 const ptr_bits = self.target.cpu.arch.ptrBitWidth();4001 const ptr_bits = self.target.cpu.arch.ptrBitWidth();
4000 const ptr_bytes: u64 = @divExact(ptr_bits, 8);4002 const ptr_bytes: u64 = @divExact(ptr_bits, 8);
4001 const fn_owner_decl = mod.declPtr(func.owner_decl);
4002 const got_addr = blk: {4003 const got_addr = blk: {
4003 const got = &elf_file.program_headers.items[elf_file.phdr_got_index.?];4004 const got = &elf_file.program_headers.items[elf_file.phdr_got_index.?];
4004 break :blk @intCast(u32, got.p_vaddr + fn_owner_decl.link.elf.offset_table_index * ptr_bytes);4005 break :blk @intCast(u32, got.p_vaddr + fn_owner_decl.link.elf.offset_table_index * ptr_bytes);
...@@ -4008,29 +4009,7 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier...@@ -4008,29 +4009,7 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier
4008 .ops = Mir.Inst.Ops.encode(.{ .flags = 0b01 }),4009 .ops = Mir.Inst.Ops.encode(.{ .flags = 0b01 }),
4009 .data = .{ .imm = @truncate(u32, got_addr) },4010 .data = .{ .imm = @truncate(u32, got_addr) },
4010 });4011 });
4011 } else if (func_value.castTag(.extern_fn)) |_| {4012 } else if (self.bin_file.cast(link.File.Coff)) |_| {
4012 return self.fail("TODO implement calling extern functions", .{});
4013 } else {
4014 return self.fail("TODO implement calling bitcasted functions", .{});
4015 }
4016 } else {
4017 assert(ty.zigTypeTag() == .Pointer);
4018 const mcv = try self.resolveInst(callee);
4019 try self.genSetReg(Type.initTag(.usize), .rax, mcv);
4020 _ = try self.addInst(.{
4021 .tag = .call,
4022 .ops = Mir.Inst.Ops.encode(.{
4023 .reg1 = .rax,
4024 .flags = 0b01,
4025 }),
4026 .data = undefined,
4027 });
4028 }
4029 } else if (self.bin_file.cast(link.File.Coff)) |coff_file| {
4030 if (self.air.value(callee)) |func_value| {
4031 if (func_value.castTag(.function)) |func_payload| {
4032 const func = func_payload.data;
4033 const fn_owner_decl = mod.declPtr(func.owner_decl);
4034 try self.genSetReg(Type.initTag(.usize), .rax, .{4013 try self.genSetReg(Type.initTag(.usize), .rax, .{
4035 .linker_load = .{4014 .linker_load = .{
4036 .type = .got,4015 .type = .got,
...@@ -4045,19 +4024,12 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier...@@ -4045,19 +4024,12 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier
4045 }),4024 }),
4046 .data = undefined,4025 .data = undefined,
4047 });4026 });
4048 } else if (func_value.castTag(.extern_fn)) |func_payload| {4027 } else if (self.bin_file.cast(link.File.MachO)) |macho_file| {
4049 const extern_fn = func_payload.data;4028 try fn_owner_decl.link.macho.ensureInitialized(macho_file);
4050 const decl_name = mod.declPtr(extern_fn.owner_decl).name;4029 const sym_index = fn_owner_decl.link.macho.getSymbolIndex().?;
4051 if (extern_fn.lib_name) |lib_name| {
4052 log.debug("TODO enforce that '{s}' is expected in '{s}' library", .{
4053 decl_name,
4054 lib_name,
4055 });
4056 }
4057 const sym_index = try coff_file.getGlobalSymbol(mem.sliceTo(decl_name, 0));
4058 try self.genSetReg(Type.initTag(.usize), .rax, .{4030 try self.genSetReg(Type.initTag(.usize), .rax, .{
4059 .linker_load = .{4031 .linker_load = .{
4060 .type = .import,4032 .type = .got,
4061 .sym_index = sym_index,4033 .sym_index = sym_index,
4062 },4034 },
4063 });4035 });
...@@ -4069,36 +4041,37 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier...@@ -4069,36 +4041,37 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier
4069 }),4041 }),
4070 .data = undefined,4042 .data = undefined,
4071 });4043 });
4072 } else {4044 } else if (self.bin_file.cast(link.File.Plan9)) |p9| {
4073 return self.fail("TODO implement calling bitcasted functions", .{});4045 try p9.seeDecl(func.owner_decl);
4046 const ptr_bits = self.target.cpu.arch.ptrBitWidth();
4047 const ptr_bytes: u64 = @divExact(ptr_bits, 8);
4048 const got_addr = p9.bases.data;
4049 const got_index = fn_owner_decl.link.plan9.got_index.?;
4050 const fn_got_addr = got_addr + got_index * ptr_bytes;
4051 _ = try self.addInst(.{
4052 .tag = .call,
4053 .ops = Mir.Inst.Ops.encode(.{ .flags = 0b01 }),
4054 .data = .{ .imm = @intCast(u32, fn_got_addr) },
4055 });
4056 } else unreachable;
4057 } else if (func_value.castTag(.extern_fn)) |func_payload| {
4058 const extern_fn = func_payload.data;
4059 const decl_name = mod.declPtr(extern_fn.owner_decl).name;
4060 if (extern_fn.lib_name) |lib_name| {
4061 log.debug("TODO enforce that '{s}' is expected in '{s}' library", .{
4062 decl_name,
4063 lib_name,
4064 });
4074 }4065 }
4075 } else {4066
4076 assert(ty.zigTypeTag() == .Pointer);4067 if (self.bin_file.cast(link.File.Coff)) |coff_file| {
4077 const mcv = try self.resolveInst(callee);4068 const sym_index = try coff_file.getGlobalSymbol(mem.sliceTo(decl_name, 0));
4078 try self.genSetReg(Type.initTag(.usize), .rax, mcv);
4079 _ = try self.addInst(.{
4080 .tag = .call,
4081 .ops = Mir.Inst.Ops.encode(.{
4082 .reg1 = .rax,
4083 .flags = 0b01,
4084 }),
4085 .data = undefined,
4086 });
4087 }
4088 } else if (self.bin_file.cast(link.File.MachO)) |macho_file| {
4089 if (self.air.value(callee)) |func_value| {
4090 if (func_value.castTag(.function)) |func_payload| {
4091 const func = func_payload.data;
4092 const fn_owner_decl = mod.declPtr(func.owner_decl);
4093 try fn_owner_decl.link.macho.ensureInitialized(macho_file);
4094 const sym_index = fn_owner_decl.link.macho.getSymbolIndex().?;
4095 try self.genSetReg(Type.initTag(.usize), .rax, .{4069 try self.genSetReg(Type.initTag(.usize), .rax, .{
4096 .linker_load = .{4070 .linker_load = .{
4097 .type = .got,4071 .type = .import,
4098 .sym_index = sym_index,4072 .sym_index = sym_index,
4099 },4073 },
4100 });4074 });
4101 // callq *%rax
4102 _ = try self.addInst(.{4075 _ = try self.addInst(.{
4103 .tag = .call,4076 .tag = .call,
4104 .ops = Mir.Inst.Ops.encode(.{4077 .ops = Mir.Inst.Ops.encode(.{
...@@ -4107,15 +4080,7 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier...@@ -4107,15 +4080,7 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier
4107 }),4080 }),
4108 .data = undefined,4081 .data = undefined,
4109 });4082 });
4110 } else if (func_value.castTag(.extern_fn)) |func_payload| {4083 } else if (self.bin_file.cast(link.File.MachO)) |macho_file| {
4111 const extern_fn = func_payload.data;
4112 const decl_name = mod.declPtr(extern_fn.owner_decl).name;
4113 if (extern_fn.lib_name) |lib_name| {
4114 log.debug("TODO enforce that '{s}' is expected in '{s}' library", .{
4115 decl_name,
4116 lib_name,
4117 });
4118 }
4119 const sym_index = try macho_file.getGlobalSymbol(mem.sliceTo(decl_name, 0));4084 const sym_index = try macho_file.getGlobalSymbol(mem.sliceTo(decl_name, 0));
4120 _ = try self.addInst(.{4085 _ = try self.addInst(.{
4121 .tag = .call_extern,4086 .tag = .call_extern,
...@@ -4128,50 +4093,24 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier...@@ -4128,50 +4093,24 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier
4128 },4093 },
4129 });4094 });
4130 } else {4095 } else {
4131 return self.fail("TODO implement calling bitcasted functions", .{});4096 return self.fail("TODO implement calling extern functions", .{});
4132 }4097 }
4133 } else {4098 } else {
4134 assert(ty.zigTypeTag() == .Pointer);4099 return self.fail("TODO implement calling bitcasted functions", .{});
4135 const mcv = try self.resolveInst(callee);
4136 try self.genSetReg(Type.initTag(.usize), .rax, mcv);
4137 _ = try self.addInst(.{
4138 .tag = .call,
4139 .ops = Mir.Inst.Ops.encode(.{
4140 .reg1 = .rax,
4141 .flags = 0b01,
4142 }),
4143 .data = undefined,
4144 });
4145 }
4146 } else if (self.bin_file.cast(link.File.Plan9)) |p9| {
4147 if (self.air.value(callee)) |func_value| {
4148 if (func_value.castTag(.function)) |func_payload| {
4149 try p9.seeDecl(func_payload.data.owner_decl);
4150 const ptr_bits = self.target.cpu.arch.ptrBitWidth();
4151 const ptr_bytes: u64 = @divExact(ptr_bits, 8);
4152 const got_addr = p9.bases.data;
4153 const got_index = mod.declPtr(func_payload.data.owner_decl).link.plan9.got_index.?;
4154 const fn_got_addr = got_addr + got_index * ptr_bytes;
4155 _ = try self.addInst(.{
4156 .tag = .call,
4157 .ops = Mir.Inst.Ops.encode(.{ .flags = 0b01 }),
4158 .data = .{ .imm = @intCast(u32, fn_got_addr) },
4159 });
4160 } else return self.fail("TODO implement calling extern fn on plan9", .{});
4161 } else {
4162 assert(ty.zigTypeTag() == .Pointer);
4163 const mcv = try self.resolveInst(callee);
4164 try self.genSetReg(Type.initTag(.usize), .rax, mcv);
4165 _ = try self.addInst(.{
4166 .tag = .call,
4167 .ops = Mir.Inst.Ops.encode(.{
4168 .reg1 = .rax,
4169 .flags = 0b01,
4170 }),
4171 .data = undefined,
4172 });
4173 }4100 }
4174 } else unreachable;4101 } else {
4102 assert(ty.zigTypeTag() == .Pointer);
4103 const mcv = try self.resolveInst(callee);
4104 try self.genSetReg(Type.initTag(.usize), .rax, mcv);
4105 _ = try self.addInst(.{
4106 .tag = .call,
4107 .ops = Mir.Inst.Ops.encode(.{
4108 .reg1 = .rax,
4109 .flags = 0b01,
4110 }),
4111 .data = undefined,
4112 });
4113 }
41754114
4176 if (info.stack_byte_count > 0) {4115 if (info.stack_byte_count > 0) {
4177 // Readjust the stack4116 // Readjust the stack