authorgravatar for git@vexu.euVeikka Tuominen <git@vexu.eu> 2023-01-14 21:42:29+02:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2023-01-14 21:42:29+02:00
logbb15e4057c9c8bb22084990de475ab10a44592c0
treec1dcacddfc3ff184bd924405db0759ae2625280f
parent18191b80b6381eb41adb4354a243190865801212
parent0013042cbd539cf7eb463483633e9f7aa2fa8067
signaturebadge-question-mark Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #14271 from Vexu/c-abi

float related C ABI fixes

6 files changed, 273 insertions(+), 25 deletions(-)

build.zig+1-1
......@@ -440,7 +440,7 @@ pub fn build(b: *Builder) !void {
440440 b.enable_wine,
441441 enable_symlinks_windows,
442442 ));
443 test_step.dependOn(tests.addCAbiTests(b, skip_non_native));
443 test_step.dependOn(tests.addCAbiTests(b, skip_non_native, skip_release));
444444 test_step.dependOn(tests.addLinkTests(b, test_filter, modes, enable_macos_sdk, skip_stage2_tests, enable_symlinks_windows));
445445 test_step.dependOn(tests.addStackTraceTests(b, test_filter, modes));
446446 test_step.dependOn(tests.addCliTests(b, test_filter, modes));
src/arch/x86_64/abi.zig+36-3
......@@ -5,7 +5,19 @@ const assert = std.debug.assert;
55const Register = @import("bits.zig").Register;
66const RegisterManagerFn = @import("../../register_manager.zig").RegisterManager;
77
8pub const Class = enum { integer, sse, sseup, x87, x87up, complex_x87, memory, none, win_i128 };
8pub const Class = enum {
9 integer,
10 sse,
11 sseup,
12 x87,
13 x87up,
14 complex_x87,
15 memory,
16 none,
17 win_i128,
18 float,
19 float_combine,
20};
921
1022pub fn classifyWindows(ty: Type, target: Target) Class {
1123 // https://docs.microsoft.com/en-gb/cpp/build/x64-calling-convention?view=vs-2017
......@@ -112,7 +124,20 @@ pub fn classifySystemV(ty: Type, target: Target, ctx: Context) [8]Class {
112124 return result;
113125 },
114126 .Float => switch (ty.floatBits(target)) {
115 16, 32, 64 => {
127 16 => {
128 if (ctx == .other) {
129 result[0] = .memory;
130 } else {
131 // TODO clang doesn't allow __fp16 as .ret or .arg
132 result[0] = .sse;
133 }
134 return result;
135 },
136 32 => {
137 result[0] = .float;
138 return result;
139 },
140 64 => {
116141 result[0] = .sse;
117142 return result;
118143 },
......@@ -120,11 +145,15 @@ pub fn classifySystemV(ty: Type, target: Target, ctx: Context) [8]Class {
120145 // "Arguments of types__float128, _Decimal128 and__m128 are
121146 // split into two halves. The least significant ones belong
122147 // to class SSE, the most significant one to class SSEUP."
148 if (ctx == .other) {
149 result[0] = .memory;
150 return result;
151 }
123152 result[0] = .sse;
124153 result[1] = .sseup;
125154 return result;
126155 },
127 else => {
156 80 => {
128157 // "The 64-bit mantissa of arguments of type long double
129158 // belongs to classX87, the 16-bit exponent plus 6 bytes
130159 // of padding belongs to class X87UP."
......@@ -132,6 +161,7 @@ pub fn classifySystemV(ty: Type, target: Target, ctx: Context) [8]Class {
132161 result[1] = .x87up;
133162 return result;
134163 },
164 else => unreachable,
135165 },
136166 .Vector => {
137167 const elem_ty = ty.childType();
......@@ -238,6 +268,9 @@ pub fn classifySystemV(ty: Type, target: Target, ctx: Context) [8]Class {
238268 combine: {
239269 // "If both classes are equal, this is the resulting class."
240270 if (result[result_i] == field_class[0]) {
271 if (result[result_i] == .float) {
272 result[result_i] = .float_combine;
273 }
241274 break :combine;
242275 }
243276
src/codegen/llvm.zig+27-15
......@@ -10395,7 +10395,12 @@ fn firstParamSRet(fn_info: Type.Payload.Function.Data, target: std.Target) bool
1039510395 .mips, .mipsel => return false,
1039610396 .x86_64 => switch (target.os.tag) {
1039710397 .windows => return x86_64_abi.classifyWindows(fn_info.return_type, target) == .memory,
10398 else => return x86_64_abi.classifySystemV(fn_info.return_type, target, .ret)[0] == .memory,
10398 else => {
10399 const class = x86_64_abi.classifySystemV(fn_info.return_type, target, .ret);
10400 if (class[0] == .memory) return true;
10401 if (class[0] == .x87 and class[2] != .none) return true;
10402 return false;
10403 },
1039910404 },
1040010405 .wasm32 => return wasm_c_abi.classifyType(fn_info.return_type, target)[0] == .indirect,
1040110406 .aarch64, .aarch64_be => return aarch64_c_abi.classifyType(fn_info.return_type, target) == .memory,
......@@ -10469,22 +10474,26 @@ fn lowerFnRetTy(dg: *DeclGen, fn_info: Type.Payload.Function.Data) !*llvm.Type {
1046910474 llvm_types_buffer[llvm_types_index] = dg.context.intType(64);
1047010475 llvm_types_index += 1;
1047110476 },
10472 .sse => {
10477 .sse, .sseup => {
1047310478 llvm_types_buffer[llvm_types_index] = dg.context.doubleType();
1047410479 llvm_types_index += 1;
1047510480 },
10476 .sseup => {
10477 llvm_types_buffer[llvm_types_index] = dg.context.doubleType();
10481 .float => {
10482 llvm_types_buffer[llvm_types_index] = dg.context.floatType();
1047810483 llvm_types_index += 1;
1047910484 },
10480 .x87 => {
10481 llvm_types_buffer[llvm_types_index] = dg.context.x86FP80Type();
10485 .float_combine => {
10486 llvm_types_buffer[llvm_types_index] = dg.context.floatType().vectorType(2);
1048210487 llvm_types_index += 1;
1048310488 },
10484 .x87up => {
10489 .x87 => {
10490 if (llvm_types_index != 0 or classes[2] != .none) {
10491 return dg.context.voidType();
10492 }
1048510493 llvm_types_buffer[llvm_types_index] = dg.context.x86FP80Type();
1048610494 llvm_types_index += 1;
1048710495 },
10496 .x87up => continue,
1048810497 .complex_x87 => {
1048910498 @panic("TODO");
1049010499 },
......@@ -10689,22 +10698,25 @@ const ParamTypeIterator = struct {
1068910698 llvm_types_buffer[llvm_types_index] = dg.context.intType(64);
1069010699 llvm_types_index += 1;
1069110700 },
10692 .sse => {
10701 .sse, .sseup => {
1069310702 llvm_types_buffer[llvm_types_index] = dg.context.doubleType();
1069410703 llvm_types_index += 1;
1069510704 },
10696 .sseup => {
10697 llvm_types_buffer[llvm_types_index] = dg.context.doubleType();
10705 .float => {
10706 llvm_types_buffer[llvm_types_index] = dg.context.floatType();
1069810707 llvm_types_index += 1;
1069910708 },
10700 .x87 => {
10701 llvm_types_buffer[llvm_types_index] = dg.context.x86FP80Type();
10709 .float_combine => {
10710 llvm_types_buffer[llvm_types_index] = dg.context.floatType().vectorType(2);
1070210711 llvm_types_index += 1;
1070310712 },
10704 .x87up => {
10705 llvm_types_buffer[llvm_types_index] = dg.context.x86FP80Type();
10706 llvm_types_index += 1;
10713 .x87 => {
10714 it.zig_index += 1;
10715 it.llvm_index += 1;
10716 it.byval_attr = true;
10717 return .byref;
1070710718 },
10719 .x87up => unreachable,
1070810720 .complex_x87 => {
1070910721 @panic("TODO");
1071010722 },
test/c_abi/cfuncs.c+102-1
......@@ -4,7 +4,7 @@
44#include <stdlib.h>
55#include <string.h>
66
7void zig_panic();
7void zig_panic(void);
88
99static void assert_or_panic(bool ok) {
1010 if (!ok) {
......@@ -60,6 +60,54 @@ static void assert_or_panic(bool ok) {
6060# define ZIG_NO_COMPLEX
6161#endif
6262
63#ifdef __x86_64__
64#define ZIG_NO_RAW_F16
65#endif
66
67#ifdef __i386__
68#define ZIG_NO_RAW_F16
69#endif
70
71#ifdef __mips__
72#define ZIG_NO_RAW_F16
73#endif
74
75#ifdef __riscv
76#define ZIG_NO_RAW_F16
77#endif
78
79#ifdef __wasm__
80#define ZIG_NO_RAW_F16
81#endif
82
83#ifdef __powerpc__
84#define ZIG_NO_RAW_F16
85#endif
86
87#ifdef __aarch64__
88#define ZIG_NO_F128
89#endif
90
91#ifdef __arm__
92#define ZIG_NO_F128
93#endif
94
95#ifdef __mips__
96#define ZIG_NO_F128
97#endif
98
99#ifdef __riscv
100#define ZIG_NO_F128
101#endif
102
103#ifdef __powerpc__
104#define ZIG_NO_F128
105#endif
106
107#ifdef __APPLE__
108#define ZIG_NO_F128
109#endif
110
63111#ifndef ZIG_NO_I128
64112struct i128 {
65113 __int128 value;
......@@ -884,3 +932,56 @@ void c_func_ptr_byval(void *a, void *b, struct ByVal in, unsigned long c, void *
884932 assert_or_panic((intptr_t)d == 4);
885933 assert_or_panic(e == 5);
886934}
935
936#ifndef ZIG_NO_RAW_F16
937__fp16 c_f16(__fp16 a) {
938 assert_or_panic(a == 12);
939 return 34;
940}
941#endif
942
943typedef struct {
944 __fp16 a;
945} f16_struct;
946f16_struct c_f16_struct(f16_struct a) {
947 assert_or_panic(a.a == 12);
948 return (f16_struct){34};
949}
950
951#if defined __x86_64__ || defined __i386__
952typedef long double f80;
953f80 c_f80(f80 a) {
954 assert_or_panic((double)a == 12.34);
955 return 56.78;
956}
957typedef struct {
958 f80 a;
959} f80_struct;
960f80_struct c_f80_struct(f80_struct a) {
961 assert_or_panic((double)a.a == 12.34);
962 return (f80_struct){56.78};
963}
964typedef struct {
965 f80 a;
966 int b;
967} f80_extra_struct;
968f80_extra_struct c_f80_extra_struct(f80_extra_struct a) {
969 assert_or_panic((double)a.a == 12.34);
970 assert_or_panic(a.b == 42);
971 return (f80_extra_struct){56.78, 24};
972}
973#endif
974
975#ifndef ZIG_NO_F128
976__float128 c_f128(__float128 a) {
977 assert_or_panic((double)a == 12.34);
978 return 56.78;
979}
980typedef struct {
981 __float128 a;
982} f128_struct;
983f128_struct c_f128_struct(f128_struct a) {
984 assert_or_panic((double)a.a == 12.34);
985 return (f128_struct){56.78};
986}
987#endif
test/c_abi/main.zig+99-1
......@@ -4,7 +4,7 @@
44//! To run all the tests on the tier 1 architecture you can use:
55//! zig build test-c-abi -fqemu
66//! To run the tests on a specific architecture:
7//! zig test -fno-stage1 -lc main.zig cfuncs.c -target mips-linux --test-cmd qemu-mips --test-cmd-bin
7//! zig test -lc main.zig cfuncs.c -target mips-linux --test-cmd qemu-mips --test-cmd-bin
88const std = @import("std");
99const builtin = @import("builtin");
1010const print = std.debug.print;
......@@ -13,6 +13,9 @@ const expectEqual = std.testing.expectEqual;
1313const has_i128 = builtin.cpu.arch != .x86 and !builtin.cpu.arch.isARM() and
1414 !builtin.cpu.arch.isMIPS() and !builtin.cpu.arch.isPPC();
1515
16const has_f128 = builtin.cpu.arch.isX86() and !builtin.os.tag.isDarwin();
17const has_f80 = builtin.cpu.arch.isX86();
18
1619extern fn run_c_tests() void;
1720
1821export fn zig_panic() noreturn {
......@@ -764,6 +767,7 @@ extern fn c_float_array_struct(FloatArrayStruct) void;
764767extern fn c_ret_float_array_struct() FloatArrayStruct;
765768
766769test "Float array like struct" {
770 if (builtin.cpu.arch == .x86 and builtin.mode != .Debug) return error.SkipZigTest;
767771 if (comptime builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
768772 if (comptime builtin.cpu.arch.isPPC()) return error.SkipZigTest;
769773
......@@ -824,7 +828,9 @@ extern fn c_big_vec(BigVec) void;
824828extern fn c_ret_big_vec() BigVec;
825829
826830test "big simd vector" {
831 if (comptime builtin.cpu.arch.isMIPS() and builtin.mode != .Debug) return error.SkipZigTest;
827832 if (comptime builtin.cpu.arch.isPPC64()) return error.SkipZigTest;
833 if (builtin.cpu.arch == .x86_64 and builtin.os.tag == .macos and builtin.mode != .Debug) return error.SkipZigTest;
828834
829835 c_big_vec(.{ 1, 2, 3, 4, 5, 6, 7, 8 });
830836
......@@ -875,6 +881,8 @@ test "DC: Zig passes to C" {
875881 try expectOk(c_assert_DC(.{ .v1 = -0.25, .v2 = 15 }));
876882}
877883test "DC: Zig returns to C" {
884 if (builtin.cpu.arch == .x86 and builtin.mode != .Debug) return error.SkipZigTest;
885 if (comptime builtin.cpu.arch.isMIPS() and builtin.mode != .Debug) return error.SkipZigTest;
878886 if (comptime builtin.cpu.arch.isRISCV()) return error.SkipZigTest;
879887 if (comptime builtin.cpu.arch.isPPC()) return error.SkipZigTest;
880888 if (comptime builtin.cpu.arch.isPPC64()) return error.SkipZigTest;
......@@ -888,6 +896,8 @@ test "DC: C passes to Zig" {
888896 try expectOk(c_send_DC());
889897}
890898test "DC: C returns to Zig" {
899 if (builtin.cpu.arch == .x86 and builtin.mode != .Debug) return error.SkipZigTest;
900 if (comptime builtin.cpu.arch.isMIPS() and builtin.mode != .Debug) return error.SkipZigTest;
891901 if (comptime builtin.cpu.arch.isRISCV()) return error.SkipZigTest;
892902 if (comptime builtin.cpu.arch.isPPC()) return error.SkipZigTest;
893903 if (comptime builtin.cpu.arch.isPPC64()) return error.SkipZigTest;
......@@ -920,6 +930,7 @@ test "CFF: Zig passes to C" {
920930 try expectOk(c_assert_CFF(.{ .v1 = 39, .v2 = 0.875, .v3 = 1.0 }));
921931}
922932test "CFF: Zig returns to C" {
933 if (builtin.cpu.arch == .x86 and builtin.mode != .Debug) return error.SkipZigTest;
923934 if (comptime builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
924935 if (comptime builtin.cpu.arch.isPPC()) return error.SkipZigTest;
925936 if (comptime builtin.cpu.arch.isPPC64()) return error.SkipZigTest;
......@@ -927,6 +938,8 @@ test "CFF: Zig returns to C" {
927938}
928939test "CFF: C passes to Zig" {
929940 if (builtin.target.cpu.arch == .x86) return error.SkipZigTest;
941 if (comptime builtin.cpu.arch.isRISCV() and builtin.mode != .Debug) return error.SkipZigTest;
942 if (builtin.cpu.arch == .aarch64 and builtin.mode != .Debug) return error.SkipZigTest;
930943 if (comptime builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
931944 if (comptime builtin.cpu.arch.isPPC()) return error.SkipZigTest;
932945 if (comptime builtin.cpu.arch.isPPC64()) return error.SkipZigTest;
......@@ -934,6 +947,9 @@ test "CFF: C passes to Zig" {
934947 try expectOk(c_send_CFF());
935948}
936949test "CFF: C returns to Zig" {
950 if (builtin.cpu.arch == .x86 and builtin.mode != .Debug) return error.SkipZigTest;
951 if (builtin.cpu.arch == .aarch64 and builtin.mode != .Debug) return error.SkipZigTest;
952 if (comptime builtin.cpu.arch.isRISCV() and builtin.mode != .Debug) return error.SkipZigTest;
937953 if (comptime builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
938954 if (comptime builtin.cpu.arch.isPPC()) return error.SkipZigTest;
939955 if (comptime builtin.cpu.arch.isPPC64()) return error.SkipZigTest;
......@@ -967,6 +983,7 @@ test "PD: Zig passes to C" {
967983}
968984test "PD: Zig returns to C" {
969985 if (builtin.target.cpu.arch == .x86) return error.SkipZigTest;
986 if (comptime builtin.cpu.arch.isMIPS() and builtin.mode != .Debug) return error.SkipZigTest;
970987 if (comptime builtin.cpu.arch.isPPC()) return error.SkipZigTest;
971988 if (comptime builtin.cpu.arch.isPPC64()) return error.SkipZigTest;
972989 try expectOk(c_assert_ret_PD());
......@@ -980,6 +997,7 @@ test "PD: C passes to Zig" {
980997}
981998test "PD: C returns to Zig" {
982999 if (builtin.target.cpu.arch == .x86) return error.SkipZigTest;
1000 if (comptime builtin.cpu.arch.isMIPS() and builtin.mode != .Debug) return error.SkipZigTest;
9831001 if (comptime builtin.cpu.arch.isPPC()) return error.SkipZigTest;
9841002 if (comptime builtin.cpu.arch.isPPC64()) return error.SkipZigTest;
9851003 try expectEqual(c_ret_PD(), .{ .v1 = null, .v2 = 0.5 });
......@@ -1014,6 +1032,7 @@ extern fn c_modify_by_ref_param(ByRef) ByRef;
10141032
10151033test "C function modifies by ref param" {
10161034 if (comptime builtin.cpu.arch.isPPC()) return error.SkipZigTest;
1035 if (builtin.cpu.arch == .x86_64 and builtin.os.tag == .windows and builtin.mode != .Debug) return error.SkipZigTest;
10171036
10181037 const res = c_modify_by_ref_param(.{ .val = 1, .arr = undefined });
10191038 try expect(res.val == 42);
......@@ -1034,6 +1053,8 @@ const ByVal = extern struct {
10341053
10351054extern fn c_func_ptr_byval(*anyopaque, *anyopaque, ByVal, c_ulong, *anyopaque, c_ulong) void;
10361055test "C function that takes byval struct called via function pointer" {
1056 if (builtin.cpu.arch == .x86 and builtin.mode != .Debug) return error.SkipZigTest;
1057 if (comptime builtin.cpu.arch.isMIPS() and builtin.mode != .Debug) return error.SkipZigTest;
10371058 if (comptime builtin.cpu.arch.isPPC()) return error.SkipZigTest;
10381059
10391060 var fn_ptr = &c_func_ptr_byval;
......@@ -1049,3 +1070,80 @@ test "C function that takes byval struct called via function pointer" {
10491070 @as(c_ulong, 5),
10501071 );
10511072}
1073
1074extern fn c_f16(f16) f16;
1075test "f16 bare" {
1076 if (!comptime builtin.cpu.arch.isAARCH64()) return error.SkipZigTest;
1077
1078 const a = c_f16(12);
1079 try expect(a == 34);
1080}
1081
1082const f16_struct = extern struct {
1083 a: f16,
1084};
1085extern fn c_f16_struct(f16_struct) f16_struct;
1086test "f16 struct" {
1087 if (builtin.target.cpu.arch == .x86) return error.SkipZigTest;
1088 if (comptime builtin.target.cpu.arch.isMIPS()) return error.SkipZigTest;
1089 if (comptime builtin.target.cpu.arch.isPPC()) return error.SkipZigTest;
1090 if (comptime builtin.target.cpu.arch.isPPC()) return error.SkipZigTest;
1091 if (comptime builtin.cpu.arch.isARM() and builtin.mode != .Debug) return error.SkipZigTest;
1092
1093 const a = c_f16_struct(.{ .a = 12 });
1094 try expect(a.a == 34);
1095}
1096
1097extern fn c_f80(f80) f80;
1098test "f80 bare" {
1099 if (!has_f80) return error.SkipZigTest;
1100
1101 const a = c_f80(12.34);
1102 try expect(@floatCast(f64, a) == 56.78);
1103}
1104
1105const f80_struct = extern struct {
1106 a: f80,
1107};
1108extern fn c_f80_struct(f80_struct) f80_struct;
1109test "f80 struct" {
1110 if (!has_f80) return error.SkipZigTest;
1111 if (builtin.target.cpu.arch == .x86) return error.SkipZigTest;
1112 if (builtin.mode != .Debug) return error.SkipZigTest;
1113
1114 const a = c_f80_struct(.{ .a = 12.34 });
1115 try expect(@floatCast(f64, a.a) == 56.78);
1116}
1117
1118const f80_extra_struct = extern struct {
1119 a: f80,
1120 b: c_int,
1121};
1122extern fn c_f80_extra_struct(f80_extra_struct) f80_extra_struct;
1123test "f80 extra struct" {
1124 if (!has_f80) return error.SkipZigTest;
1125 if (builtin.target.cpu.arch == .x86) return error.SkipZigTest;
1126
1127 const a = c_f80_extra_struct(.{ .a = 12.34, .b = 42 });
1128 try expect(@floatCast(f64, a.a) == 56.78);
1129 try expect(a.b == 24);
1130}
1131
1132extern fn c_f128(f128) f128;
1133test "f128 bare" {
1134 if (!has_f128) return error.SkipZigTest;
1135
1136 const a = c_f128(12.34);
1137 try expect(@floatCast(f64, a) == 56.78);
1138}
1139
1140const f128_struct = extern struct {
1141 a: f128,
1142};
1143extern fn c_f128_struct(f128_struct) f128_struct;
1144test "f128 struct" {
1145 if (!has_f128) return error.SkipZigTest;
1146
1147 const a = c_f128_struct(.{ .a = 12.34 });
1148 try expect(@floatCast(f64, a.a) == 56.78);
1149}
test/tests.zig+8-4
......@@ -1323,10 +1323,12 @@ const c_abi_targets = [_]CrossTarget{
13231323 },
13241324};
13251325
1326pub fn addCAbiTests(b: *build.Builder, skip_non_native: bool) *build.Step {
1326pub fn addCAbiTests(b: *build.Builder, skip_non_native: bool, skip_release: bool) *build.Step {
13271327 const step = b.step("test-c-abi", "Run the C ABI tests");
13281328
1329 for (c_abi_targets) |c_abi_target| {
1329 const modes: [2]Mode = .{ .Debug, .ReleaseFast };
1330
1331 for (modes[0 .. @as(u8, 1) + @boolToInt(!skip_release)]) |mode| for (c_abi_targets) |c_abi_target| {
13301332 if (skip_non_native and !c_abi_target.isNative())
13311333 continue;
13321334
......@@ -1339,14 +1341,16 @@ pub fn addCAbiTests(b: *build.Builder, skip_non_native: bool) *build.Step {
13391341 }
13401342 test_step.linkLibC();
13411343 test_step.addCSourceFile("test/c_abi/cfuncs.c", &.{"-std=c99"});
1344 test_step.setBuildMode(mode);
13421345
13431346 const triple_prefix = c_abi_target.zigTriple(b.allocator) catch unreachable;
1344 test_step.setNamePrefix(b.fmt("{s}-{s} ", .{
1347 test_step.setNamePrefix(b.fmt("{s}-{s}-{s} ", .{
13451348 "test-c-abi",
13461349 triple_prefix,
1350 @tagName(mode),
13471351 }));
13481352
13491353 step.dependOn(&test_step.step);
1350 }
1354 };
13511355 return step;
13521356}