authorgravatar for kubkon@jakubkonka.comJakub Konka <kubkon@jakubkonka.com> 2022-03-18 20:02:33+01:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2022-03-18 20:02:33+01:00
log338bf55e84abcb4f5fb595266135d6fc074ecf3c
tree1c8d9f805821816ae6cd08efce0cead6fc85dd63
parent3865a61a99de85f864f98dc75f9a3ef4aa2b43ee
parentc32e2c4d3cc66e8984f83a1d26265c64ec9a0f19
signaturebadge-question-mark Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #11216 from joachimschmidt557/stage2-arm

stage2 ARM: remove MCValue.embedded_in_code

6 files changed, 62 insertions(+), 62 deletions(-)

src/arch/arm/CodeGen.zig+62-57
......@@ -118,11 +118,6 @@ const MCValue = union(enum) {
118118 /// A pointer-sized integer that fits in a register.
119119 /// If the type is a pointer, this is the pointer address in virtual address space.
120120 immediate: u32,
121 /// The constant was emitted into the code, at this offset.
122 /// If the type is a pointer, it means the pointer address is embedded in the code.
123 embedded_in_code: usize,
124 /// The value is a pointer to a constant which was emitted into the code, at this offset.
125 ptr_embedded_in_code: usize,
126121 /// The value is in a target-specific register.
127122 register: Register,
128123 /// The value is in memory at a hard-coded address.
......@@ -144,7 +139,7 @@ const MCValue = union(enum) {
144139
145140 fn isMemory(mcv: MCValue) bool {
146141 return switch (mcv) {
147 .embedded_in_code, .memory, .stack_offset, .stack_argument_offset => true,
142 .memory, .stack_offset, .stack_argument_offset => true,
148143 else => false,
149144 };
150145 }
......@@ -163,12 +158,10 @@ const MCValue = union(enum) {
163158 .dead => unreachable,
164159
165160 .immediate,
166 .embedded_in_code,
167161 .memory,
168162 .compare_flags_unsigned,
169163 .compare_flags_signed,
170164 .ptr_stack_offset,
171 .ptr_embedded_in_code,
172165 .undef,
173166 .stack_argument_offset,
174167 => false,
......@@ -1358,24 +1351,28 @@ fn airWrapErrUnionErr(self: *Self, inst: Air.Inst.Index) !void {
13581351 return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
13591352}
13601353
1354fn slicePtr(self: *Self, mcv: MCValue) !MCValue {
1355 switch (mcv) {
1356 .dead, .unreach => unreachable,
1357 .register => unreachable, // a slice doesn't fit in one register
1358 .stack_argument_offset => |off| {
1359 return MCValue{ .stack_argument_offset = off + 4 };
1360 },
1361 .stack_offset => |off| {
1362 return MCValue{ .stack_offset = off + 4 };
1363 },
1364 .memory => |addr| {
1365 return MCValue{ .memory = addr };
1366 },
1367 else => return self.fail("TODO implement slice_ptr for {}", .{mcv}),
1368 }
1369}
1370
13611371fn airSlicePtr(self: *Self, inst: Air.Inst.Index) !void {
13621372 const ty_op = self.air.instructions.items(.data)[inst].ty_op;
13631373 const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
13641374 const mcv = try self.resolveInst(ty_op.operand);
1365 switch (mcv) {
1366 .dead, .unreach => unreachable,
1367 .register => unreachable, // a slice doesn't fit in one register
1368 .stack_argument_offset => |off| {
1369 break :result MCValue{ .stack_argument_offset = off + 4 };
1370 },
1371 .stack_offset => |off| {
1372 break :result MCValue{ .stack_offset = off + 4 };
1373 },
1374 .memory => |addr| {
1375 break :result MCValue{ .memory = addr };
1376 },
1377 else => return self.fail("TODO implement slice_ptr for {}", .{mcv}),
1378 }
1375 break :result try self.slicePtr(mcv);
13791376 };
13801377 return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
13811378}
......@@ -1409,7 +1406,7 @@ fn airPtrSliceLenPtr(self: *Self, inst: Air.Inst.Index) !void {
14091406 switch (mcv) {
14101407 .dead, .unreach => unreachable,
14111408 .ptr_stack_offset => |off| {
1412 break :result MCValue{ .ptr_stack_offset = off + 4 };
1409 break :result MCValue{ .ptr_stack_offset = off };
14131410 },
14141411 else => return self.fail("TODO implement ptr_slice_len_ptr for {}", .{mcv}),
14151412 }
......@@ -1424,7 +1421,7 @@ fn airPtrSlicePtrPtr(self: *Self, inst: Air.Inst.Index) !void {
14241421 switch (mcv) {
14251422 .dead, .unreach => unreachable,
14261423 .ptr_stack_offset => |off| {
1427 break :result MCValue{ .ptr_stack_offset = off };
1424 break :result MCValue{ .ptr_stack_offset = off + 4 };
14281425 },
14291426 else => return self.fail("TODO implement ptr_slice_ptr_ptr for {}", .{mcv}),
14301427 }
......@@ -1455,15 +1452,17 @@ fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {
14551452 if (index_is_register) self.register_manager.freezeRegs(&.{index_mcv.register});
14561453 defer if (index_is_register) self.register_manager.unfreezeRegs(&.{index_mcv.register});
14571454
1458 const base_mcv: MCValue = switch (slice_mcv) {
1459 .stack_offset => |off| .{ .register = try self.copyToTmpRegister(slice_ptr_field_type, .{ .stack_offset = off + 4 }) },
1460 .stack_argument_offset => |off| .{ .register = try self.copyToTmpRegister(slice_ptr_field_type, .{ .stack_argument_offset = off + 4 }) },
1461 else => return self.fail("TODO slice_elem_val when slice is {}", .{slice_mcv}),
1462 };
1463 self.register_manager.freezeRegs(&.{base_mcv.register});
1455 const base_mcv = try self.slicePtr(slice_mcv);
14641456
14651457 switch (elem_size) {
14661458 1, 4 => {
1459 const base_reg = switch (base_mcv) {
1460 .register => |r| r,
1461 else => try self.copyToTmpRegister(slice_ptr_field_type, base_mcv),
1462 };
1463 self.register_manager.freezeRegs(&.{base_reg});
1464 defer self.register_manager.unfreezeRegs(&.{base_reg});
1465
14671466 const dst_reg = try self.register_manager.allocReg(inst);
14681467 const dst_mcv = MCValue{ .register = dst_reg };
14691468 self.register_manager.freezeRegs(&.{dst_reg});
......@@ -1491,13 +1490,11 @@ fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {
14911490 .tag = tag,
14921491 .data = .{ .rr_offset = .{
14931492 .rt = dst_reg,
1494 .rn = base_mcv.register,
1493 .rn = base_reg,
14951494 .offset = .{ .offset = Instruction.Offset.reg(index_reg, .{ .lsl = shift }) },
14961495 } },
14971496 });
14981497
1499 self.register_manager.unfreezeRegs(&.{base_mcv.register});
1500
15011498 break :result dst_mcv;
15021499 },
15031500 else => {
......@@ -1515,7 +1512,16 @@ fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {
15151512fn airSliceElemPtr(self: *Self, inst: Air.Inst.Index) !void {
15161513 const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
15171514 const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
1518 const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement slice_elem_ptr for {}", .{self.target.cpu.arch});
1515 const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
1516 const slice_mcv = try self.resolveInst(extra.lhs);
1517 const index_mcv = try self.resolveInst(extra.rhs);
1518 const base_mcv = try self.slicePtr(slice_mcv);
1519
1520 const slice_ty = self.air.typeOf(extra.lhs);
1521
1522 const addr = try self.binOp(.ptr_add, null, base_mcv, index_mcv, slice_ty, Type.usize);
1523 break :result addr;
1524 };
15191525 return self.finishAir(inst, result, .{ extra.lhs, extra.rhs, .none });
15201526}
15211527
......@@ -1535,7 +1541,15 @@ fn airPtrElemVal(self: *Self, inst: Air.Inst.Index) !void {
15351541fn airPtrElemPtr(self: *Self, inst: Air.Inst.Index) !void {
15361542 const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
15371543 const extra = self.air.extraData(Air.Bin, ty_pl.payload).data;
1538 const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement ptr_elem_ptr for {}", .{self.target.cpu.arch});
1544 const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
1545 const ptr_mcv = try self.resolveInst(extra.lhs);
1546 const index_mcv = try self.resolveInst(extra.rhs);
1547
1548 const ptr_ty = self.air.typeOf(extra.lhs);
1549
1550 const addr = try self.binOp(.ptr_add, null, ptr_mcv, index_mcv, ptr_ty, Type.usize);
1551 break :result addr;
1552 };
15391553 return self.finishAir(inst, result, .{ extra.lhs, extra.rhs, .none });
15401554}
15411555
......@@ -1641,9 +1655,6 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo
16411655 .compare_flags_signed => unreachable,
16421656 .immediate => |imm| try self.setRegOrMem(elem_ty, dst_mcv, .{ .memory = imm }),
16431657 .ptr_stack_offset => |off| try self.setRegOrMem(elem_ty, dst_mcv, .{ .stack_offset = off }),
1644 .ptr_embedded_in_code => |off| {
1645 try self.setRegOrMem(elem_ty, dst_mcv, .{ .embedded_in_code = off });
1646 },
16471658 .register => |reg| {
16481659 self.register_manager.freezeRegs(&.{reg});
16491660 defer self.register_manager.unfreezeRegs(&.{reg});
......@@ -1652,7 +1663,6 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo
16521663 .dead => unreachable,
16531664 .undef => unreachable,
16541665 .compare_flags_signed, .compare_flags_unsigned => unreachable,
1655 .embedded_in_code => unreachable,
16561666 .register => |dst_reg| {
16571667 try self.genLdrRegister(dst_reg, reg, elem_ty);
16581668 },
......@@ -1690,7 +1700,6 @@ fn load(self: *Self, dst_mcv: MCValue, ptr: MCValue, ptr_ty: Type) InnerError!vo
16901700 }
16911701 },
16921702 .memory,
1693 .embedded_in_code,
16941703 .stack_offset,
16951704 .stack_argument_offset,
16961705 => {
......@@ -1746,9 +1755,6 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type
17461755 .ptr_stack_offset => |off| {
17471756 try self.genSetStack(value_ty, off, value);
17481757 },
1749 .ptr_embedded_in_code => |off| {
1750 try self.setRegOrMem(value_ty, .{ .embedded_in_code = off }, value);
1751 },
17521758 .register => |addr_reg| {
17531759 self.register_manager.freezeRegs(&.{addr_reg});
17541760 defer self.register_manager.unfreezeRegs(&.{addr_reg});
......@@ -1760,7 +1766,7 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type
17601766 try self.genStrRegister(value_reg, addr_reg, value_ty);
17611767 },
17621768 else => {
1763 if (value_ty.abiSize(self.target.*) <= 4) {
1769 if (elem_size <= 4) {
17641770 const tmp_reg = try self.register_manager.allocReg(null);
17651771 self.register_manager.freezeRegs(&.{tmp_reg});
17661772 defer self.register_manager.unfreezeRegs(&.{tmp_reg});
......@@ -1784,6 +1790,17 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type
17841790 try self.genSetReg(ptr_ty, src_reg, .{ .ptr_stack_offset = off });
17851791 },
17861792 .memory => |addr| try self.genSetReg(Type.usize, src_reg, .{ .immediate = @intCast(u32, addr) }),
1793 .stack_argument_offset => |unadjusted_off| {
1794 const adj_off = unadjusted_off + elem_size;
1795
1796 _ = try self.addInst(.{
1797 .tag = .ldr_ptr_stack_argument,
1798 .data = .{ .r_stack_offset = .{
1799 .rt = src_reg,
1800 .stack_offset = adj_off,
1801 } },
1802 });
1803 },
17871804 else => return self.fail("TODO store {} to register", .{value}),
17881805 }
17891806
......@@ -1797,7 +1814,6 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type
17971814 }
17981815 },
17991816 .memory,
1800 .embedded_in_code,
18011817 .stack_offset,
18021818 .stack_argument_offset,
18031819 => {
......@@ -2680,12 +2696,10 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallOptions.
26802696 .immediate => unreachable,
26812697 .unreach => unreachable,
26822698 .dead => unreachable,
2683 .embedded_in_code => unreachable,
26842699 .memory => unreachable,
26852700 .compare_flags_signed => unreachable,
26862701 .compare_flags_unsigned => unreachable,
26872702 .ptr_stack_offset => unreachable,
2688 .ptr_embedded_in_code => unreachable,
26892703 .register => |reg| {
26902704 try self.register_manager.getReg(reg, null);
26912705 try self.genSetReg(arg_ty, reg, arg_mcv);
......@@ -3584,7 +3598,6 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerErro
35843598 .compare_flags_signed,
35853599 .immediate,
35863600 .ptr_stack_offset,
3587 .ptr_embedded_in_code,
35883601 => {
35893602 const reg = try self.copyToTmpRegister(ty, mcv);
35903603 return self.genSetStack(ty, stack_offset, MCValue{ .register = reg });
......@@ -3637,7 +3650,6 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerErro
36373650 }
36383651 },
36393652 .memory,
3640 .embedded_in_code,
36413653 .stack_argument_offset,
36423654 .stack_offset,
36433655 => {
......@@ -3684,7 +3696,6 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerErro
36843696 } },
36853697 });
36863698 },
3687 .embedded_in_code => return self.fail("TODO genSetStack with src={}", .{mcv}),
36883699 else => unreachable,
36893700 }
36903701
......@@ -3704,7 +3715,6 @@ fn genSetStack(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) InnerErro
37043715fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void {
37053716 switch (mcv) {
37063717 .dead => unreachable,
3707 .ptr_embedded_in_code => unreachable,
37083718 .unreach, .none => return, // Nothing to do.
37093719 .undef => {
37103720 if (!self.wantSafety())
......@@ -3964,7 +3974,6 @@ fn genSetReg(self: *Self, ty: Type, reg: Register, mcv: MCValue) InnerError!void
39643974 } },
39653975 });
39663976 },
3967 else => return self.fail("TODO implement getSetReg for arm {}", .{mcv}),
39683977 }
39693978}
39703979
......@@ -4028,7 +4037,6 @@ fn genSetStackArgument(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) I
40284037 .stack_offset,
40294038 .memory,
40304039 .stack_argument_offset,
4031 .embedded_in_code,
40324040 => {
40334041 if (abi_size <= 4) {
40344042 const reg = try self.copyToTmpRegister(ty, mcv);
......@@ -4054,9 +4062,7 @@ fn genSetStackArgument(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) I
40544062 try self.genSetReg(ptr_ty, src_reg, .{ .ptr_stack_offset = off });
40554063 },
40564064 .memory => |addr| try self.genSetReg(ptr_ty, src_reg, .{ .immediate = @intCast(u32, addr) }),
4057 .stack_argument_offset,
4058 .embedded_in_code,
4059 => return self.fail("TODO genSetStackArgument src={}", .{mcv}),
4065 .stack_argument_offset => return self.fail("TODO genSetStackArgument src={}", .{mcv}),
40604066 else => unreachable,
40614067 }
40624068
......@@ -4085,7 +4091,6 @@ fn genSetStackArgument(self: *Self, ty: Type, stack_offset: u32, mcv: MCValue) I
40854091 .compare_flags_signed,
40864092 .immediate,
40874093 .ptr_stack_offset,
4088 .ptr_embedded_in_code,
40894094 => {
40904095 const reg = try self.copyToTmpRegister(ty, mcv);
40914096 return self.genSetStackArgument(ty, stack_offset, MCValue{ .register = reg });
test/behavior/align.zig-1
......@@ -115,7 +115,6 @@ fn addUnalignedSlice(a: []align(1) const u32, b: []align(1) const u32) u32 {
115115test "specifying alignment allows pointer cast" {
116116 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
117117 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
118 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
119118
120119 try testBytesAlign(0x33);
121120}
test/behavior/array.zig-1
......@@ -272,7 +272,6 @@ test "read/write through global variable array of struct fields initialized via
272272
273273test "implicit cast single-item pointer" {
274274 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
275 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
276275
277276 try testImplicitCastSingleItemPtr();
278277 comptime try testImplicitCastSingleItemPtr();
test/behavior/basic.zig-1
......@@ -636,7 +636,6 @@ var global_ptr = &gdt[0];
636636
637637test "global constant is loaded with a runtime-known index" {
638638 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
639 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
640639
641640 const S = struct {
642641 fn doTheTest() !void {
test/behavior/optional.zig-1
......@@ -275,7 +275,6 @@ test "0-bit child type coerced to optional" {
275275 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
276276 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
277277 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
278 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
279278
280279 const S = struct {
281280 fn doTheTest() !void {
test/behavior/struct.zig-1
......@@ -1289,7 +1289,6 @@ test "initialize struct with empty literal" {
12891289
12901290test "loading a struct pointer perfoms a copy" {
12911291 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1292 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
12931292
12941293 const S = struct {
12951294 a: i32,