authorgravatar for kubkon@jakubkonka.comJakub Konka <kubkon@jakubkonka.com> 2023-04-15 14:57:38+02:00
committergravatar for kubkon@jakubkonka.comJakub Konka <kubkon@jakubkonka.com> 2023-04-15 20:59:51+02:00
logecc52d859f7f1e400c8bfc08aea971f4596649cf
treed476d85eb2c7085656e20c266910d3ca3f33abf9
parentb82130709d121222f793c082dbbe6c29e7f2ec41

x86_64: fix loading/storing pointers from linker deferred memory locations

1 files changed, 69 insertions(+), 47 deletions(-)

src/arch/x86_64/CodeGen.zig+69-47
......@@ -3619,11 +3619,15 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo
36193619 else => return self.fail("TODO implement loading from register into {}", .{dst_mcv}),
36203620 }
36213621 },
3622 .load_direct, .load_tlv => |sym_index| try self.load(dst_mcv, switch (ptr) {
3623 .load_direct => .{ .lea_direct = sym_index },
3624 .load_tlv => .{ .lea_tlv = sym_index },
3625 else => unreachable,
3626 }, ptr_ty),
3622 .load_direct => |sym_index| {
3623 const addr_reg = try self.copyToTmpRegister(Type.usize, .{ .lea_direct = sym_index });
3624 const addr_reg_lock = self.register_manager.lockRegAssumeUnused(addr_reg);
3625 defer self.register_manager.unlockReg(addr_reg_lock);
3626 // Load the pointer, which is stored in memory
3627 try self.asmRegisterMemory(.mov, addr_reg, Memory.sib(.qword, .{ .base = addr_reg }));
3628 try self.load(dst_mcv, .{ .register = addr_reg }, ptr_ty);
3629 },
3630 .load_tlv => |sym_index| try self.load(dst_mcv, .{ .lea_tlv = sym_index }, ptr_ty),
36273631 .memory, .load_got, .lea_direct, .lea_tlv => {
36283632 const reg = try self.copyToTmpRegister(ptr_ty, ptr);
36293633 try self.load(dst_mcv, .{ .register = reg }, ptr_ty);
......@@ -3817,15 +3821,15 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type
38173821 defer self.register_manager.unlockReg(addr_reg_lock);
38183822
38193823 switch (ptr) {
3820 .memory => |addr| {
3821 try self.genSetReg(ptr_ty, addr_reg, .{ .immediate = addr });
3822 // Load the pointer, which is stored in memory
3823 try self.asmRegisterMemory(.mov, addr_reg, Memory.sib(.qword, .{ .base = addr_reg }));
3824 },
3824 .memory => |addr| try self.genSetReg(ptr_ty, addr_reg, .{ .immediate = addr }),
38253825 .load_direct => |sym_index| try self.genSetReg(ptr_ty, addr_reg, .{ .lea_direct = sym_index }),
38263826 .load_tlv => |sym_index| try self.genSetReg(ptr_ty, addr_reg, .{ .lea_tlv = sym_index }),
38273827 else => unreachable,
38283828 }
3829 if (ptr != .load_tlv) {
3830 // Load the pointer, which is stored in memory
3831 try self.asmRegisterMemory(.mov, addr_reg, Memory.sib(.qword, .{ .base = addr_reg }));
3832 }
38293833
38303834 const new_ptr = MCValue{ .register = addr_reg };
38313835 try self.store(new_ptr, value, ptr_ty, value_ty);
......@@ -7223,6 +7227,8 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: i32, mcv: MCValue, opts: Inl
72237227 .memory,
72247228 .load_direct,
72257229 .load_tlv,
7230 .lea_direct,
7231 .lea_tlv,
72267232 => if (abi_size <= 8) {
72277233 const reg = try self.copyToTmpRegister(ty, mcv);
72287234 return self.genSetStack(ty, stack_offset, MCValue{ .register = reg }, opts);
......@@ -7235,7 +7241,7 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: i32, mcv: MCValue, opts: Inl
72357241 .memory => |addr| .{ .immediate = addr },
72367242 .load_direct => |sym_index| .{ .lea_direct = sym_index },
72377243 .load_tlv => |sym_index| .{ .lea_tlv = sym_index },
7238 else => unreachable,
7244 else => mcv,
72397245 });
72407246 try self.genInlineMemcpy(
72417247 .{ .ptr_stack_offset = stack_offset },
......@@ -7258,8 +7264,6 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: i32, mcv: MCValue, opts: Inl
72587264 ),
72597265 .ptr_stack_offset,
72607266 .load_got,
7261 .lea_direct,
7262 .lea_tlv,
72637267 => {
72647268 const tmp_reg = try self.copyToTmpRegister(ty, mcv);
72657269 const tmp_lock = self.register_manager.lockRegAssumeUnused(tmp_reg);
......@@ -7350,21 +7354,27 @@ fn genInlineMemcpy(
73507354 try self.spillRegisters(&.{ .rdi, .rsi, .rcx });
73517355
73527356 switch (dst_ptr) {
7353 .memory => |addr| {
7354 try self.genSetReg(Type.usize, .rdi, .{ .immediate = addr });
7355 // Load the pointer, which is stored in memory
7356 try self.asmRegisterMemory(.mov, .rdi, Memory.sib(.qword, .{ .base = .rdi }));
7357 .lea_tlv,
7358 .load_tlv,
7359 => {
7360 try self.genSetReg(Type.usize, .rdi, switch (dst_ptr) {
7361 .load_tlv => |sym_index| .{ .lea_tlv = sym_index },
7362 else => dst_ptr,
7363 });
73577364 },
7365 .memory,
73587366 .load_got,
73597367 .lea_direct,
73607368 .load_direct,
7361 .lea_tlv,
7362 .load_tlv,
7363 => try self.genSetReg(Type.usize, .rdi, switch (dst_ptr) {
7364 .load_direct => |sym_index| .{ .lea_direct = sym_index },
7365 .load_tlv => |sym_index| .{ .lea_tlv = sym_index },
7366 else => dst_ptr,
7367 }),
7369 => {
7370 try self.genSetReg(Type.usize, .rdi, switch (dst_ptr) {
7371 .memory => |addr| .{ .immediate = addr },
7372 .load_direct => |sym_index| .{ .lea_direct = sym_index },
7373 else => dst_ptr,
7374 });
7375 // Load the pointer, which is stored in memory
7376 try self.asmRegisterMemory(.mov, .rdi, Memory.sib(.qword, .{ .base = .rdi }));
7377 },
73687378 .stack_offset, .ptr_stack_offset => |off| {
73697379 try self.asmRegisterMemory(switch (dst_ptr) {
73707380 .stack_offset => .mov,
......@@ -7388,21 +7398,27 @@ fn genInlineMemcpy(
73887398 }
73897399
73907400 switch (src_ptr) {
7391 .memory => |addr| {
7392 try self.genSetReg(Type.usize, .rsi, .{ .immediate = addr });
7393 // Load the pointer, which is stored in memory
7394 try self.asmRegisterMemory(.mov, .rsi, Memory.sib(.qword, .{ .base = .rsi }));
7401 .lea_tlv,
7402 .load_tlv,
7403 => {
7404 try self.genSetReg(Type.usize, .rsi, switch (src_ptr) {
7405 .load_tlv => |sym_index| .{ .lea_tlv = sym_index },
7406 else => dst_ptr,
7407 });
73957408 },
7409 .memory,
73967410 .load_got,
73977411 .lea_direct,
73987412 .load_direct,
7399 .lea_tlv,
7400 .load_tlv,
7401 => try self.genSetReg(Type.usize, .rsi, switch (src_ptr) {
7402 .load_direct => |sym_index| .{ .lea_direct = sym_index },
7403 .load_tlv => |sym_index| .{ .lea_tlv = sym_index },
7404 else => src_ptr,
7405 }),
7413 => {
7414 try self.genSetReg(Type.usize, .rsi, switch (src_ptr) {
7415 .memory => |addr| .{ .immediate = addr },
7416 .load_direct => |sym_index| .{ .lea_direct = sym_index },
7417 else => src_ptr,
7418 });
7419 // Load the pointer, which is stored in memory
7420 try self.asmRegisterMemory(.mov, .rsi, Memory.sib(.qword, .{ .base = .rsi }));
7421 },
74067422 .stack_offset, .ptr_stack_offset => |off| {
74077423 try self.asmRegisterMemory(switch (src_ptr) {
74087424 .stack_offset => .mov,
......@@ -7449,21 +7465,27 @@ fn genInlineMemset(
74497465 try self.spillRegisters(&.{ .rdi, .al, .rcx });
74507466
74517467 switch (dst_ptr) {
7452 .memory => |addr| {
7453 try self.genSetReg(Type.usize, .rdi, .{ .immediate = addr });
7454 // Load the pointer, which is stored in memory
7455 try self.asmRegisterMemory(.mov, .rdi, Memory.sib(.qword, .{ .base = .rdi }));
7468 .lea_tlv,
7469 .load_tlv,
7470 => {
7471 try self.genSetReg(Type.usize, .rdi, switch (dst_ptr) {
7472 .load_tlv => |sym_index| .{ .lea_tlv = sym_index },
7473 else => dst_ptr,
7474 });
74567475 },
7457 .load_got,
7476 .load_got => try self.genSetReg(Type.usize, .rdi, dst_ptr),
7477 .memory,
74587478 .lea_direct,
74597479 .load_direct,
7460 .lea_tlv,
7461 .load_tlv,
7462 => try self.genSetReg(Type.usize, .rdi, switch (dst_ptr) {
7463 .load_direct => |sym_index| .{ .lea_direct = sym_index },
7464 .load_tlv => |sym_index| .{ .lea_tlv = sym_index },
7465 else => dst_ptr,
7466 }),
7480 => {
7481 try self.genSetReg(Type.usize, .rdi, switch (dst_ptr) {
7482 .memory => |addr| .{ .immediate = addr },
7483 .load_direct => |sym_index| .{ .lea_direct = sym_index },
7484 else => dst_ptr,
7485 });
7486 // Load the pointer, which is stored in memory
7487 try self.asmRegisterMemory(.mov, .rdi, Memory.sib(.qword, .{ .base = .rdi }));
7488 },
74677489 .stack_offset, .ptr_stack_offset => |off| {
74687490 try self.asmRegisterMemory(switch (dst_ptr) {
74697491 .stack_offset => .mov,