authorgravatar for jacobly@ziglang.orgJacob Young <jacobly@ziglang.org> 2023-10-04 19:24:31-04:00
committergravatar for jacobly@ziglang.orgJacob Young <jacobly@ziglang.org> 2023-10-05 00:19:25-04:00
logc2ec518fe2704422017b09c0808ec1a40c0ec0ed
tree6c9603b9b2a4b53783906b6bed81a12eb09725e1
parentb4427bc300cd768721891e6747e59102c8cb06fc

x86_64: refactor calling convention checks

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

src/arch/x86_64/CodeGen.zig+33-25
......@@ -807,7 +807,7 @@ pub fn generate(
807807 .lower = .{
808808 .allocator = bin_file.allocator,
809809 .mir = mir,
810 .target = &bin_file.options.target,
810 .cc = abi.resolveCallingConvention(fn_info.cc, function.target.*),
811811 .src_loc = src_loc,
812812 },
813813 .bin_file = bin_file,
......@@ -893,7 +893,7 @@ pub fn generateLazy(
893893 .lower = .{
894894 .allocator = bin_file.allocator,
895895 .mir = mir,
896 .target = &bin_file.options.target,
896 .cc = abi.resolveCallingConvention(.Unspecified, function.target.*),
897897 .src_loc = src_loc,
898898 },
899899 .bin_file = bin_file,
......@@ -980,6 +980,7 @@ fn formatWipMir(
980980 _: std.fmt.FormatOptions,
981981 writer: anytype,
982982) @TypeOf(writer).Error!void {
983 const mod = data.self.bin_file.options.module.?;
983984 var lower = Lower{
984985 .allocator = data.self.gpa,
985986 .mir = .{
......@@ -987,7 +988,7 @@ fn formatWipMir(
987988 .extra = data.self.mir_extra.items,
988989 .frame_locs = (std.MultiArrayList(Mir.FrameLoc){}).slice(),
989990 },
990 .target = data.self.target,
991 .cc = mod.typeToFunc(data.self.fn_type).?.cc,
991992 .src_loc = data.self.src_loc,
992993 };
993994 for ((lower.lowerMir(data.inst) catch |err| switch (err) {
......@@ -1680,7 +1681,7 @@ fn gen(self: *Self) InnerError!void {
16801681 try self.asmRegister(.{ ._, .pop }, .rbp);
16811682 try self.asmOpOnly(.{ ._, .ret });
16821683
1683 const frame_layout = try self.computeFrameLayout();
1684 const frame_layout = try self.computeFrameLayout(cc);
16841685 const need_frame_align = frame_layout.stack_mask != math.maxInt(u32);
16851686 const need_stack_adjust = frame_layout.stack_adjust > 0;
16861687 const need_save_reg = frame_layout.save_reg_list.count() > 0;
......@@ -2075,7 +2076,8 @@ fn genLazy(self: *Self, lazy_sym: link.File.LazySymbol) InnerError!void {
20752076 const enum_ty = lazy_sym.ty;
20762077 wip_mir_log.debug("{}.@tagName:", .{enum_ty.fmt(self.bin_file.options.module.?)});
20772078
2078 const param_regs = abi.getCAbiIntParamRegs(self.target.*);
2079 const resolved_cc = abi.resolveCallingConvention(.Unspecified, self.target.*);
2080 const param_regs = abi.getCAbiIntParamRegs(resolved_cc);
20792081 const param_locks = self.register_manager.lockRegsAssumeUnused(2, param_regs[0..2].*);
20802082 defer for (param_locks) |lock| self.register_manager.unlockReg(lock);
20812083
......@@ -2208,7 +2210,7 @@ fn setFrameLoc(
22082210 offset.* += self.frame_allocs.items(.abi_size)[frame_i];
22092211}
22102212
2211fn computeFrameLayout(self: *Self) !FrameLayout {
2213fn computeFrameLayout(self: *Self, cc: std.builtin.CallingConvention) !FrameLayout {
22122214 const frame_allocs_len = self.frame_allocs.len;
22132215 try self.frame_locs.resize(self.gpa, frame_allocs_len);
22142216 const stack_frame_order = try self.gpa.alloc(FrameIndex, frame_allocs_len - FrameIndex.named_count);
......@@ -2240,7 +2242,8 @@ fn computeFrameLayout(self: *Self) !FrameLayout {
22402242 // Create list of registers to save in the prologue.
22412243 // TODO handle register classes
22422244 var save_reg_list = Mir.RegisterList{};
2243 const callee_preserved_regs = abi.getCalleePreservedRegs(self.target.*);
2245 const callee_preserved_regs =
2246 abi.getCalleePreservedRegs(abi.resolveCallingConvention(cc, self.target.*));
22442247 for (callee_preserved_regs) |reg| {
22452248 if (self.register_manager.isRegAllocated(reg)) {
22462249 save_reg_list.push(callee_preserved_regs, reg);
......@@ -8477,8 +8480,7 @@ fn genCall(self: *Self, info: union(enum) {
84778480 try arg_locks.ensureTotalCapacity(16);
84788481 defer for (arg_locks.items) |arg_lock| if (arg_lock) |lock| self.register_manager.unlockReg(lock);
84798482
8480 var call_info =
8481 try self.resolveCallingConventionValues(fn_info, var_args, .call_frame);
8483 var call_info = try self.resolveCallingConventionValues(fn_info, var_args, .call_frame);
84828484 defer call_info.deinit(self);
84838485
84848486 // We need a properly aligned and sized call frame to be able to call this function.
......@@ -8497,7 +8499,9 @@ fn genCall(self: *Self, info: union(enum) {
84978499 }
84988500
84998501 try self.spillEflagsIfOccupied();
8500 try self.spillRegisters(abi.getCallerPreservedRegs(self.target.*));
8502 try self.spillRegisters(abi.getCallerPreservedRegs(
8503 abi.resolveCallingConvention(fn_info.cc, self.target.*),
8504 ));
85018505
85028506 // set stack arguments first because this can clobber registers
85038507 // also clobber spill arguments as we go
......@@ -11727,6 +11731,7 @@ fn airTagName(self: *Self, inst: Air.Inst.Index) !void {
1172711731 const un_op = self.air.instructions.items(.data)[inst].un_op;
1172811732 const inst_ty = self.typeOfIndex(inst);
1172911733 const enum_ty = self.typeOf(un_op);
11734 const resolved_cc = abi.resolveCallingConvention(.Unspecified, self.target.*);
1173011735
1173111736 // We need a properly aligned and sized call frame to be able to call this function.
1173211737 {
......@@ -11744,9 +11749,9 @@ fn airTagName(self: *Self, inst: Air.Inst.Index) !void {
1174411749 }
1174511750
1174611751 try self.spillEflagsIfOccupied();
11747 try self.spillRegisters(abi.getCallerPreservedRegs(self.target.*));
11752 try self.spillRegisters(abi.getCallerPreservedRegs(resolved_cc));
1174811753
11749 const param_regs = abi.getCAbiIntParamRegs(self.target.*);
11754 const param_regs = abi.getCAbiIntParamRegs(resolved_cc);
1175011755
1175111756 const dst_mcv = try self.allocRegOrMem(inst, false);
1175211757 try self.genSetReg(param_regs[0], Type.usize, dst_mcv.address());
......@@ -12523,23 +12528,25 @@ fn resolveCallingConventionValues(
1252312528
1252412529 const ret_ty = fn_info.return_type.toType();
1252512530
12531 const resolved_cc = abi.resolveCallingConvention(cc, self.target.*);
1252612532 switch (cc) {
1252712533 .Naked => {
1252812534 assert(result.args.len == 0);
1252912535 result.return_value = InstTracking.init(.unreach);
1253012536 result.stack_align = .@"8";
1253112537 },
12532 .C => {
12538 .C, .SysV, .Win64 => {
1253312539 var param_reg_i: usize = 0;
1253412540 var param_sse_reg_i: usize = 0;
1253512541 result.stack_align = .@"16";
1253612542
12537 switch (self.target.os.tag) {
12538 .windows => {
12543 switch (resolved_cc) {
12544 .SysV => {},
12545 .Win64 => {
1253912546 // Align the stack to 16bytes before allocating shadow stack space (if any).
1254012547 result.stack_byte_count += @intCast(4 * Type.usize.abiSize(mod));
1254112548 },
12542 else => {},
12549 else => unreachable,
1254312550 }
1254412551
1254512552 // Return values
......@@ -12549,13 +12556,14 @@ fn resolveCallingConventionValues(
1254912556 // TODO: is this even possible for C calling convention?
1255012557 result.return_value = InstTracking.init(.none);
1255112558 } else {
12552 const classes = switch (self.target.os.tag) {
12553 .windows => &[1]abi.Class{abi.classifyWindows(ret_ty, mod)},
12554 else => mem.sliceTo(&abi.classifySystemV(ret_ty, mod, .ret), .none),
12559 const classes = switch (resolved_cc) {
12560 .SysV => mem.sliceTo(&abi.classifySystemV(ret_ty, mod, .ret), .none),
12561 .Win64 => &[1]abi.Class{abi.classifyWindows(ret_ty, mod)},
12562 else => unreachable,
1255512563 };
1255612564 for (
1255712565 classes,
12558 abi.getCAbiIntReturnRegs(self.target.*)[0..classes.len],
12566 abi.getCAbiIntReturnRegs(resolved_cc)[0..classes.len],
1255912567 0..,
1256012568 ) |class, ret_reg, ret_reg_i| {
1256112569 result.return_value = switch (classes[0]) {
......@@ -12577,7 +12585,7 @@ fn resolveCallingConventionValues(
1257712585 .memory => switch (ret_reg_i) {
1257812586 0 => ret: {
1257912587 const ret_indirect_reg =
12580 abi.getCAbiIntParamRegs(self.target.*)[param_reg_i];
12588 abi.getCAbiIntParamRegs(resolved_cc)[param_reg_i];
1258112589 param_reg_i += 1;
1258212590 break :ret .{
1258312591 .short = .{ .indirect = .{ .reg = ret_reg } },
......@@ -12603,8 +12611,8 @@ fn resolveCallingConventionValues(
1260312611 };
1260412612 for (classes, 0..) |class, class_i| {
1260512613 switch (class) {
12606 .integer => if (param_reg_i < abi.getCAbiIntParamRegs(self.target.*).len) {
12607 const param_reg = abi.getCAbiIntParamRegs(self.target.*)[param_reg_i];
12614 .integer => if (param_reg_i < abi.getCAbiIntParamRegs(resolved_cc).len) {
12615 const param_reg = abi.getCAbiIntParamRegs(resolved_cc)[param_reg_i];
1260812616 param_reg_i += 1;
1260912617
1261012618 arg.* = switch (class_i) {
......@@ -12661,13 +12669,13 @@ fn resolveCallingConventionValues(
1266112669 } else if (!ret_ty.hasRuntimeBitsIgnoreComptime(mod)) {
1266212670 result.return_value = InstTracking.init(.none);
1266312671 } else {
12664 const ret_reg = abi.getCAbiIntReturnRegs(self.target.*)[0];
12672 const ret_reg = abi.getCAbiIntReturnRegs(resolved_cc)[0];
1266512673 const ret_ty_size: u31 = @intCast(ret_ty.abiSize(mod));
1266612674 if (ret_ty_size <= 8 and !ret_ty.isRuntimeFloat()) {
1266712675 const aliased_reg = registerAlias(ret_reg, ret_ty_size);
1266812676 result.return_value = .{ .short = .{ .register = aliased_reg }, .long = .none };
1266912677 } else {
12670 const ret_indirect_reg = abi.getCAbiIntParamRegs(self.target.*)[0];
12678 const ret_indirect_reg = abi.getCAbiIntParamRegs(resolved_cc)[0];
1267112679 result.return_value = .{
1267212680 .short = .{ .indirect = .{ .reg = ret_reg } },
1267312681 .long = .{ .indirect = .{ .reg = ret_indirect_reg } },
src/arch/x86_64/Lower.zig+3-5
......@@ -2,7 +2,7 @@
22
33allocator: Allocator,
44mir: Mir,
5target: *const std.Target,
5cc: std.builtin.CallingConvention,
66err_msg: ?*ErrorMsg = null,
77src_loc: Module.SrcLoc,
88result_insts_len: u8 = undefined,
......@@ -552,15 +552,13 @@ fn generic(lower: *Lower, inst: Mir.Inst) Error!void {
552552}
553553
554554fn pushPopRegList(lower: *Lower, comptime mnemonic: Mnemonic, inst: Mir.Inst) Error!void {
555 const callee_preserved_regs = abi.getCalleePreservedRegs(lower.target.*);
555 const callee_preserved_regs = abi.getCalleePreservedRegs(lower.cc);
556556 var it = inst.data.reg_list.iterator(.{ .direction = switch (mnemonic) {
557557 .push => .reverse,
558558 .pop => .forward,
559559 else => unreachable,
560560 } });
561 while (it.next()) |i| try lower.emit(.none, mnemonic, &.{.{
562 .reg = callee_preserved_regs[i],
563 }});
561 while (it.next()) |i| try lower.emit(.none, mnemonic, &.{.{ .reg = callee_preserved_regs[i] }});
564562}
565563
566564const page_size: i32 = 1 << 12;
src/arch/x86_64/abi.zig+33-17
......@@ -463,31 +463,48 @@ pub const Win64 = struct {
463463 pub const c_abi_int_return_regs = [_]Register{.rax};
464464};
465465
466pub fn getCalleePreservedRegs(target: Target) []const Register {
467 return switch (target.os.tag) {
468 .windows => &Win64.callee_preserved_regs,
469 else => &SysV.callee_preserved_regs,
466pub fn resolveCallingConvention(
467 cc: std.builtin.CallingConvention,
468 target: std.Target,
469) std.builtin.CallingConvention {
470 return switch (cc) {
471 .Unspecified, .C => switch (target.os.tag) {
472 else => .SysV,
473 .windows => .Win64,
474 },
475 else => cc,
476 };
477}
478
479pub fn getCalleePreservedRegs(cc: std.builtin.CallingConvention) []const Register {
480 return switch (cc) {
481 .SysV => &SysV.callee_preserved_regs,
482 .Win64 => &Win64.callee_preserved_regs,
483 else => unreachable,
470484 };
471485}
472486
473pub fn getCallerPreservedRegs(target: Target) []const Register {
474 return switch (target.os.tag) {
475 .windows => &Win64.caller_preserved_regs,
476 else => &SysV.caller_preserved_regs,
487pub fn getCallerPreservedRegs(cc: std.builtin.CallingConvention) []const Register {
488 return switch (cc) {
489 .SysV => &SysV.caller_preserved_regs,
490 .Win64 => &Win64.caller_preserved_regs,
491 else => unreachable,
477492 };
478493}
479494
480pub fn getCAbiIntParamRegs(target: Target) []const Register {
481 return switch (target.os.tag) {
482 .windows => &Win64.c_abi_int_param_regs,
483 else => &SysV.c_abi_int_param_regs,
495pub fn getCAbiIntParamRegs(cc: std.builtin.CallingConvention) []const Register {
496 return switch (cc) {
497 .SysV => &SysV.c_abi_int_param_regs,
498 .Win64 => &Win64.c_abi_int_param_regs,
499 else => unreachable,
484500 };
485501}
486502
487pub fn getCAbiIntReturnRegs(target: Target) []const Register {
488 return switch (target.os.tag) {
489 .windows => &Win64.c_abi_int_return_regs,
490 else => &SysV.c_abi_int_return_regs,
503pub fn getCAbiIntReturnRegs(cc: std.builtin.CallingConvention) []const Register {
504 return switch (cc) {
505 .SysV => &SysV.c_abi_int_return_regs,
506 .Win64 => &Win64.c_abi_int_return_regs,
507 else => unreachable,
491508 };
492509}
493510
......@@ -524,7 +541,6 @@ pub const RegisterClass = struct {
524541
525542const builtin = @import("builtin");
526543const std = @import("std");
527const Target = std.Target;
528544const assert = std.debug.assert;
529545const testing = std.testing;
530546