mirror/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2026-02-13 21:08:36 +00:00
Code Issues Packages Projects Releases Wiki Activity

x86_64: implement loop_switch_br and switch_dispatch

Browse Source
This commit is contained in:
Jacob Young 2024-08-31 22:18:30 -04:00 committed by mlugg
parent 2b9af9e825
commit d5b01df3c8
No known key found for this signature in database
GPG Key ID: 3F5B7DCCBF4AF02E
2 changed files with 157 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -105,7 +105,7 @@ frame_allocs: std.MultiArrayList(FrameAlloc) = .{},
free_frame_indices: std.AutoArrayHashMapUnmanaged(FrameIndex, void) = .{},
frame_locs: std.MultiArrayList(Mir.FrameLoc) = .{},
loop_repeat_info: std.AutoHashMapUnmanaged(Air.Inst.Index, struct {
loops: std.AutoHashMapUnmanaged(Air.Inst.Index, struct {
/// The state to restore before branching.
state: State,
/// The branch target.
@ -219,6 +219,38 @@ pub const MCValue = union(enum) {
reserved_frame: FrameIndex,
air_ref: Air.Inst.Ref,
fn isModifiable(mcv: MCValue) bool {
return switch (mcv) {
.none,
.unreach,
.dead,
.undef,
.immediate,
.register_offset,
.eflags,
.register_overflow,
.lea_symbol,
.lea_direct,
.lea_got,
.lea_tlv,
.lea_frame,
.elementwise_regs_then_frame,
.reserved_frame,
.air_ref,
=> false,
.register,
.register_pair,
.memory,
.load_symbol,
.load_got,
.load_direct,
.load_tlv,
.indirect,
=> true,
.load_frame => |frame_addr| !frame_addr.index.isNamed(),
};
}
fn isMemory(mcv: MCValue) bool {
return switch (mcv) {
.memory, .indirect, .load_frame => true,
@ -822,7 +854,7 @@ pub fn generate(
function.frame_allocs.deinit(gpa);
function.free_frame_indices.deinit(gpa);
function.frame_locs.deinit(gpa);
function.loop_repeat_info.deinit(gpa);
function.loops.deinit(gpa);
var block_it = function.blocks.valueIterator();
while (block_it.next()) |block| block.deinit(gpa);
function.blocks.deinit(gpa);
@ -2156,18 +2188,20 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
const air_tags = self.air.instructions.items(.tag);
self.arg_index = 0;
for (body) |inst| {
wip_mir_log.debug("{}", .{self.fmtAir(inst)});
verbose_tracking_log.debug("{}", .{self.fmtTracking()});
for (body) |inst| switch (air_tags[@intFromEnum(inst)]) {
.arg => {
wip_mir_log.debug("{}", .{self.fmtAir(inst)});
verbose_tracking_log.debug("{}", .{self.fmtTracking()});
const old_air_bookkeeping = self.air_bookkeeping;
try self.inst_tracking.ensureUnusedCapacity(self.gpa, 1);
switch (air_tags[@intFromEnum(inst)]) {
.arg => try self.airArg(inst),
else => break,
}
self.checkInvariantsAfterAirInst(inst, old_air_bookkeeping);
}
const old_air_bookkeeping = self.air_bookkeeping;
try self.inst_tracking.ensureUnusedCapacity(self.gpa, 1);
try self.airArg(inst);
self.checkInvariantsAfterAirInst(inst, old_air_bookkeeping);
},
else => break,
};
if (self.arg_index == 0) try self.airDbgVarArgs();
self.arg_index = 0;
@ -2256,7 +2290,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
.block => try self.airBlock(inst),
.br => try self.airBr(inst),
.repeat => try self.airRepeat(inst),
.switch_dispatch => return self.fail("TODO implement `switch_dispatch`", .{}),
.switch_dispatch => try self.airSwitchDispatch(inst),
.trap => try self.airTrap(),
.breakpoint => try self.airBreakpoint(),
.ret_addr => try self.airRetAddr(inst),
@ -2345,7 +2379,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
.field_parent_ptr => try self.airFieldParentPtr(inst),
.switch_br => try self.airSwitchBr(inst),
.loop_switch_br => return self.fail("TODO implement `loop_switch_br`", .{}),
.loop_switch_br => try self.airLoopSwitchBr(inst),
.slice_ptr => try self.airSlicePtr(inst),
.slice_len => try self.airSliceLen(inst),
@ -13637,14 +13671,13 @@ fn airLoop(self: *Self, inst: Air.Inst.Index) !void {
self.scope_generation += 1;
const state = try self.saveState();
try self.loop_repeat_info.putNoClobber(self.gpa, inst, .{
try self.loops.putNoClobber(self.gpa, inst, .{
.state = state,
.jmp_target = @intCast(self.mir_instructions.len),
});
defer assert(self.loop_repeat_info.remove(inst));
defer assert(self.loops.remove(inst));
try self.genBody(body);
self.finishAirBookkeeping();
}
@ -13685,10 +13718,8 @@ fn lowerBlock(self: *Self, inst: Air.Inst.Index, body: []const Air.Inst.Index) !
self.finishAirBookkeeping();
}
fn airSwitchBr(self: *Self, inst: Air.Inst.Index) !void {
fn lowerSwitchBr(self: *Self, inst: Air.Inst.Index, switch_br: Air.UnwrappedSwitch, condition: MCValue) !void {
const zcu = self.pt.zcu;
const switch_br = self.air.unwrapSwitch(inst);
const condition = try self.resolveInst(switch_br.operand);
const condition_ty = self.typeOf(switch_br.operand);
const liveness = try self.liveness.getSwitchBr(self.gpa, inst, switch_br.cases_len + 1);
defer self.gpa.free(liveness.deaths);
@ -13699,13 +13730,6 @@ fn airSwitchBr(self: *Self, inst: Air.Inst.Index) !void {
else => unreachable,
};
// If the condition dies here in this switch instruction, process
// that death now instead of later as this has an effect on
// whether it needs to be spilled in the branches
if (self.liveness.operandDies(inst, 0)) {
if (switch_br.operand.toIndex()) |op_inst| try self.processDeath(op_inst);
}
self.scope_generation += 1;
const state = try self.saveState();
@ -13810,11 +13834,111 @@ fn airSwitchBr(self: *Self, inst: Air.Inst.Index) !void {
.close_scope = true,
});
}
}
fn airSwitchBr(self: *Self, inst: Air.Inst.Index) !void {
const switch_br = self.air.unwrapSwitch(inst);
const condition = try self.resolveInst(switch_br.operand);
// If the condition dies here in this switch instruction, process
// that death now instead of later as this has an effect on
// whether it needs to be spilled in the branches
if (self.liveness.operandDies(inst, 0)) {
if (switch_br.operand.toIndex()) |op_inst| try self.processDeath(op_inst);
}
try self.lowerSwitchBr(inst, switch_br, condition);
// We already took care of pl_op.operand earlier, so there's nothing left to do
self.finishAirBookkeeping();
}
fn airLoopSwitchBr(self: *Self, inst: Air.Inst.Index) !void {
const switch_br = self.air.unwrapSwitch(inst);
const condition = try self.resolveInst(switch_br.operand);
const mat_cond = if (condition.isModifiable() and
self.reuseOperand(inst, switch_br.operand, 0, condition))
condition
else mat_cond: {
const mat_cond = try self.allocRegOrMem(inst, true);
try self.genCopy(self.typeOf(switch_br.operand), mat_cond, condition, .{});
break :mat_cond mat_cond;
};
self.inst_tracking.putAssumeCapacityNoClobber(inst, InstTracking.init(mat_cond));
// If the condition dies here in this switch instruction, process
// that death now instead of later as this has an effect on
// whether it needs to be spilled in the branches
if (self.liveness.operandDies(inst, 0)) {
if (switch_br.operand.toIndex()) |op_inst| try self.processDeath(op_inst);
}
self.scope_generation += 1;
const state = try self.saveState();
try self.loops.putNoClobber(self.gpa, inst, .{
.state = state,
.jmp_target = @intCast(self.mir_instructions.len),
});
defer assert(self.loops.remove(inst));
// Stop tracking block result without forgetting tracking info
try self.freeValue(mat_cond);
try self.lowerSwitchBr(inst, switch_br, mat_cond);
try self.processDeath(inst);
self.finishAirBookkeeping();
}
fn airSwitchDispatch(self: *Self, inst: Air.Inst.Index) !void {
const br = self.air.instructions.items(.data)[@intFromEnum(inst)].br;
const block_ty = self.typeOfIndex(br.block_inst);
const block_tracking = self.inst_tracking.getPtr(br.block_inst).?;
const loop_data = self.loops.getPtr(br.block_inst).?;
done: {
try self.getValue(block_tracking.short, null);
const src_mcv = try self.resolveInst(br.operand);
if (self.reuseOperandAdvanced(inst, br.operand, 0, src_mcv, br.block_inst)) {
try self.getValue(block_tracking.short, br.block_inst);
// .long = .none to avoid merging operand and block result stack frames.
const current_tracking: InstTracking = .{ .long = .none, .short = src_mcv };
try current_tracking.materializeUnsafe(self, br.block_inst, block_tracking.*);
for (current_tracking.getRegs()) |src_reg| self.register_manager.freeReg(src_reg);
break :done;
}
try self.getValue(block_tracking.short, br.block_inst);
const dst_mcv = block_tracking.short;
try self.genCopy(block_ty, dst_mcv, try self.resolveInst(br.operand), .{});
break :done;
}
// Process operand death so that it is properly accounted for in the State below.
if (self.liveness.operandDies(inst, 0)) {
if (br.operand.toIndex()) |op_inst| try self.processDeath(op_inst);
}
try self.restoreState(loop_data.state, &.{}, .{
.emit_instructions = true,
.update_tracking = false,
.resurrect = false,
.close_scope = false,
});
// Emit a jump with a relocation. It will be patched up after the block ends.
// Leave the jump offset undefined
_ = try self.asmJmpReloc(loop_data.jmp_target);
// Stop tracking block result without forgetting tracking info
try self.freeValue(block_tracking.short);
self.finishAirBookkeeping();
}
fn performReloc(self: *Self, reloc: Mir.Inst.Index) void {
const next_inst: u32 = @intCast(self.mir_instructions.len);
switch (self.mir_instructions.items(.tag)[reloc]) {
@ -13891,7 +14015,7 @@ fn airBr(self: *Self, inst: Air.Inst.Index) !void {
fn airRepeat(self: *Self, inst: Air.Inst.Index) !void {
const loop_inst = self.air.instructions.items(.data)[@intFromEnum(inst)].repeat.loop_inst;
const repeat_info = self.loop_repeat_info.get(loop_inst).?;
const repeat_info = self.loops.get(loop_inst).?;
try self.restoreState(repeat_info.state, &.{}, .{
.emit_instructions = true,
.update_tracking = false,
@ -19578,7 +19702,10 @@ fn typeOf(self: *Self, inst: Air.Inst.Ref) Type {
fn typeOfIndex(self: *Self, inst: Air.Inst.Index) Type {
const pt = self.pt;
const zcu = pt.zcu;
return self.air.typeOfIndex(inst, &zcu.intern_pool);
return switch (self.air.instructions.items(.tag)[@intFromEnum(inst)]) {
.loop_switch_br => self.typeOf(self.air.unwrapSwitch(inst).operand),
else => self.air.typeOfIndex(inst, &zcu.intern_pool),
};
}
fn intCompilerRtAbiName(int_bits: u32) u8 {

6
test/behavior/switch_loop.zig
View File

@ -4,7 +4,6 @@ const expect = std.testing.expect;
test "simple switch loop" {
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@ -30,7 +29,6 @@ test "simple switch loop" {
test "switch loop with ranges" {
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@ -53,7 +51,6 @@ test "switch loop with ranges" {
test "switch loop on enum" {
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@ -79,7 +76,6 @@ test "switch loop on enum" {
test "switch loop on tagged union" {
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@ -113,7 +109,6 @@ test "switch loop on tagged union" {
test "switch loop dispatching instructions" {
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
@ -165,7 +160,6 @@ test "switch loop dispatching instructions" {
test "switch loop with pointer capture" {
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO