mirror/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2025-12-06 14:23:09 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'mparadinha-test-1486'

Browse Source
This commit is contained in:
Jakub Konka 2022-02-03 14:31:36 +01:00
commit cfceec15e1
2 changed files with 96 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

100
src/arch/x86_64/CodeGen.zig
View File

@ -1685,6 +1685,7 @@ fn airLoad(self: *Self, inst: Air.Inst.Index) !void {
fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type) InnerError!void {
_ = ptr_ty;
const abi_size = value_ty.abiSize(self.target.*);
switch (ptr) {
.none => unreachable,
.undef => unreachable,
@ -1705,6 +1706,9 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type
return self.fail("TODO implement storing to MCValue.embedded_in_code", .{});
},
.register => |reg| {
self.register_manager.freezeRegs(&.{reg});
defer self.register_manager.unfreezeRegs(&.{reg});
switch (value) {
.none => unreachable,
.undef => unreachable,
@ -1713,7 +1717,6 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type
.compare_flags_unsigned => unreachable,
.compare_flags_signed => unreachable,
.immediate => |imm| {
const abi_size = value_ty.abiSize(self.target.*);
switch (abi_size) {
1, 2, 4 => {
// TODO this is wasteful!
@ -1736,13 +1739,30 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type
.data = .{ .payload = payload },
});
},
8 => {
// TODO: optimization: if the imm is only using the lower
// 4 bytes and can be sign extended we can use a normal mov
// with indirect addressing (mov [reg64], imm32).
// movabs does not support indirect register addressing
// so we need an extra register and an extra mov.
const tmp_reg = try self.copyToTmpRegister(value_ty, value);
_ = try self.addInst(.{
.tag = .mov,
.ops = (Mir.Ops{
.reg1 = reg.to64(),
.reg2 = tmp_reg.to64(),
.flags = 0b10,
}).encode(),
.data = .{ .imm = 0 },
});
},
else => {
return self.fail("TODO implement set pointee with immediate of ABI size {d}", .{abi_size});
},
}
},
.register => |src_reg| {
const abi_size = value_ty.abiSize(self.target.*);
_ = try self.addInst(.{
.tag = .mov,
.ops = (Mir.Ops{
@ -1758,8 +1778,80 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type
},
}
},
.memory => {
return self.fail("TODO implement storing to MCValue.memory", .{});
.memory => |addr| {
if (self.bin_file.options.pie) {
return self.fail("TODO implement storing to memory when targeting PIE", .{});
}
// TODO: in case the address fits in an imm32 we can use [ds:imm32]
// instead of wasting an instruction copying the address to a register
if (value.isRegister()) self.register_manager.freezeRegs(&.{value.register});
defer if (value.isRegister()) self.register_manager.unfreezeRegs(&.{value.register});
const addr_reg = try self.copyToTmpRegister(ptr_ty, .{ .immediate = addr });
// to get the actual address of the value we want to modify we have to go through the GOT
// mov reg, [reg]
_ = try self.addInst(.{
.tag = .mov,
.ops = (Mir.Ops{
.reg1 = addr_reg.to64(),
.reg2 = addr_reg.to64(),
.flags = 0b01,
}).encode(),
.data = .{ .imm = 0 },
});
switch (value) {
.immediate => |imm| {
if (abi_size > 8) {
return self.fail("TODO saving imm to memory for abi_size {}", .{abi_size});
}
const payload = try self.addExtra(Mir.ImmPair{
.dest_off = 0,
.operand = @intCast(u32, imm),
});
const flags: u2 = switch (abi_size) {
1 => 0b00,
2 => 0b01,
4 => 0b10,
8 => 0b11,
else => unreachable,
};
if (flags == 0b11) {
const top_bits: u32 = @intCast(u32, imm >> 32);
const can_extend = if (value_ty.isUnsignedInt())
(top_bits == 0) and (imm & 0x8000_0000) == 0
else
top_bits == 0xffff_ffff;
if (!can_extend) {
return self.fail("TODO imm64 would get incorrectly sign extended", .{});
}
}
_ = try self.addInst(.{
.tag = .mov_mem_imm,
.ops = (Mir.Ops{
.reg1 = addr_reg.to64(),
.flags = flags,
}).encode(),
.data = .{ .payload = payload },
});
},
.register => |reg| {
_ = try self.addInst(.{
.tag = .mov,
.ops = (Mir.Ops{
.reg1 = addr_reg.to64(),
.reg2 = reg,
.flags = 0b10,
}).encode(),
.data = .{ .imm = 0 },
});
},
else => return self.fail("TODO implement storing {} to MCValue.memory", .{value}),
}
},
.stack_offset => {
return self.fail("TODO implement storing to MCValue.stack_offset", .{});

3
test/behavior/bugs/1486.zig
View File

@ -1,13 +1,10 @@
const std = @import("std");
const builtin = @import("builtin");
const expect = std.testing.expect;
const ptr = &global;
var global: usize = 123;
test "constant pointer to global variable causes runtime load" {
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
global = 1234;
try expect(&global == ptr);
try expect(ptr.* == 1234);