diff --git a/src/codegen/x86_64/CodeGen.zig b/src/codegen/x86_64/CodeGen.zig
index da0ace1f6dd5fe09e00eaf3c7e5b572de2d2e50a..2c7e0e3464fe10803470ac2eae19efaa9f9ffb11 100644
--- a/src/codegen/x86_64/CodeGen.zig
+++ b/src/codegen/x86_64/CodeGen.zig
@@ -181994,7 +181994,7 @@ fn resolveCallingConventionValues(
                 }
 
                 const save_param_gpr_index = param_gpr_index;
-                const save_param_sse_index = param_gpr_index;
+                const save_param_sse_index = param_sse_index;
 
                 var arg_mcv: [4]MCValue = undefined;
                 var arg_mcv_len: u32 = 0;
diff --git a/test/c_abi/cfuncs.c b/test/c_abi/cfuncs.c
index 302503ad4d839449c9aad546e712f3ebb6bdff3d..2013a36f2e379137dc1d61243f6b8222f4677b57 100644
--- a/test/c_abi/cfuncs.c
+++ b/test/c_abi/cfuncs.c
@@ -191,9 +191,6 @@ void zig_struct_i128(struct i128);
 #endif
 void zig_five_integers(int32_t, int32_t, int32_t, int32_t, int32_t);
 
-void zig_f32(float);
-void zig_f64(double);
-void zig_longdouble(long double);
 void zig_five_floats(float, float, float, float, float);
 
 bool zig_ret_bool();
@@ -219,6 +216,198 @@ float complex zig_cmultf(float complex a, float complex b);
 double complex zig_cmultd(double complex a, double complex b);
 #endif
 
+float zig_ret_f32(void);
+void zig_f32(float, size_t);
+void zig_1_f32(size_t, float, size_t);
+void zig_2_f32(size_t, size_t, float, size_t);
+void zig_3_f32(size_t, size_t, size_t, float, size_t);
+void zig_4_f32(size_t, size_t, size_t, size_t, float, size_t);
+void zig_5_f32(size_t, size_t, size_t, size_t, size_t, float, size_t);
+void zig_6_f32(size_t, size_t, size_t, size_t, size_t, size_t, float, size_t);
+void zig_7_f32(size_t, size_t, size_t, size_t, size_t, size_t, size_t, float, size_t);
+void zig_8_f32(size_t, size_t, size_t, size_t, size_t, size_t, size_t, size_t, float, size_t);
+
+float c_ret_f32(void) {
+    return 11;
+}
+void c_f32(float f, size_t i) {
+    assert_or_panic(f == 12);
+    assert_or_panic(i == 1);
+}
+void c_1_f32(size_t a0, float f, size_t i) {
+    assert_or_panic(f == 13);
+    assert_or_panic(i == 2);
+}
+void c_2_f32(size_t a0, size_t a1, float f, size_t i) {
+    assert_or_panic(f == 14);
+    assert_or_panic(i == 3);
+}
+void c_3_f32(size_t a0, size_t a1, size_t a2, float f, size_t i) {
+    assert_or_panic(f == 15);
+    assert_or_panic(i == 4);
+}
+void c_4_f32(size_t a0, size_t a1, size_t a2, size_t a3, float f, size_t i) {
+    assert_or_panic(f == 16);
+    assert_or_panic(i == 5);
+}
+void c_5_f32(size_t a0, size_t a1, size_t a2, size_t a3, size_t a4, float f, size_t i) {
+    assert_or_panic(f == 17);
+    assert_or_panic(i == 6);
+}
+void c_6_f32(size_t a0, size_t a1, size_t a2, size_t a3, size_t a4, size_t a5, float f, size_t i) {
+    assert_or_panic(f == 18);
+    assert_or_panic(i == 7);
+}
+void c_7_f32(size_t a0, size_t a1, size_t a2, size_t a3, size_t a4, size_t a5, size_t a6, float f, size_t i) {
+    assert_or_panic(f == 19);
+    assert_or_panic(i == 8);
+}
+void c_8_f32(size_t a0, size_t a1, size_t a2, size_t a3, size_t a4, size_t a5, size_t a6, size_t a7, float f, size_t i) {
+    assert_or_panic(f == 20);
+    assert_or_panic(i == 9);
+}
+void c_test_f32(void) {
+    float f = zig_ret_f32();
+    assert_or_panic(f == 1);
+    zig_f32(2, 1);
+    zig_1_f32(0, 3, 2);
+    zig_2_f32(0, 1, 4, 3);
+    zig_3_f32(0, 1, 2, 5, 4);
+    zig_4_f32(0, 1, 2, 3, 6, 5);
+    zig_5_f32(0, 1, 2, 3, 4, 7, 6);
+    zig_6_f32(0, 1, 2, 3, 4, 5, 8, 7);
+    zig_7_f32(0, 1, 2, 3, 4, 5, 6, 9, 8);
+    zig_8_f32(0, 1, 2, 3, 4, 5, 6, 7, 10, 9);
+}
+
+double zig_ret_f64(void);
+void zig_f64(double, size_t);
+void zig_1_f64(size_t, double, size_t);
+void zig_2_f64(size_t, size_t, double, size_t);
+void zig_3_f64(size_t, size_t, size_t, double, size_t);
+void zig_4_f64(size_t, size_t, size_t, size_t, double, size_t);
+void zig_5_f64(size_t, size_t, size_t, size_t, size_t, double, size_t);
+void zig_6_f64(size_t, size_t, size_t, size_t, size_t, size_t, double, size_t);
+void zig_7_f64(size_t, size_t, size_t, size_t, size_t, size_t, size_t, double, size_t);
+void zig_8_f64(size_t, size_t, size_t, size_t, size_t, size_t, size_t, size_t, double, size_t);
+
+double c_ret_f64(void) {
+    return 11;
+}
+void c_f64(double f, size_t i) {
+    assert_or_panic(f == 12);
+    assert_or_panic(i == 1);
+}
+void c_1_f64(size_t a0, double f, size_t i) {
+    assert_or_panic(f == 13);
+    assert_or_panic(i == 2);
+}
+void c_2_f64(size_t a0, size_t a1, double f, size_t i) {
+    assert_or_panic(f == 14);
+    assert_or_panic(i == 3);
+}
+void c_3_f64(size_t a0, size_t a1, size_t a2, double f, size_t i) {
+    assert_or_panic(f == 15);
+    assert_or_panic(i == 4);
+}
+void c_4_f64(size_t a0, size_t a1, size_t a2, size_t a3, double f, size_t i) {
+    assert_or_panic(f == 16);
+    assert_or_panic(i == 5);
+}
+void c_5_f64(size_t a0, size_t a1, size_t a2, size_t a3, size_t a4, double f, size_t i) {
+    assert_or_panic(f == 17);
+    assert_or_panic(i == 6);
+}
+void c_6_f64(size_t a0, size_t a1, size_t a2, size_t a3, size_t a4, size_t a5, double f, size_t i) {
+    assert_or_panic(f == 18);
+    assert_or_panic(i == 7);
+}
+void c_7_f64(size_t a0, size_t a1, size_t a2, size_t a3, size_t a4, size_t a5, size_t a6, double f, size_t i) {
+    assert_or_panic(f == 19);
+    assert_or_panic(i == 8);
+}
+void c_8_f64(size_t a0, size_t a1, size_t a2, size_t a3, size_t a4, size_t a5, size_t a6, size_t a7, double f, size_t i) {
+    assert_or_panic(f == 20);
+    assert_or_panic(i == 9);
+}
+void c_test_f64(void) {
+    double f = zig_ret_f64();
+    assert_or_panic(f == 1);
+    zig_f64(2, 1);
+    zig_1_f64(0, 3, 2);
+    zig_2_f64(0, 1, 4, 3);
+    zig_3_f64(0, 1, 2, 5, 4);
+    zig_4_f64(0, 1, 2, 3, 6, 5);
+    zig_5_f64(0, 1, 2, 3, 4, 7, 6);
+    zig_6_f64(0, 1, 2, 3, 4, 5, 8, 7);
+    zig_7_f64(0, 1, 2, 3, 4, 5, 6, 9, 8);
+    zig_8_f64(0, 1, 2, 3, 4, 5, 6, 7, 10, 9);
+}
+
+long double zig_ret_longdouble(void);
+void zig_longdouble(long double, size_t);
+void zig_1_longdouble(size_t, long double, size_t);
+void zig_2_longdouble(size_t, size_t, long double, size_t);
+void zig_3_longdouble(size_t, size_t, size_t, long double, size_t);
+void zig_4_longdouble(size_t, size_t, size_t, size_t, long double, size_t);
+void zig_5_longdouble(size_t, size_t, size_t, size_t, size_t, long double, size_t);
+void zig_6_longdouble(size_t, size_t, size_t, size_t, size_t, size_t, long double, size_t);
+void zig_7_longdouble(size_t, size_t, size_t, size_t, size_t, size_t, size_t, long double, size_t);
+void zig_8_longdouble(size_t, size_t, size_t, size_t, size_t, size_t, size_t, size_t, long double, size_t);
+
+long double c_ret_longdouble(void) {
+    return 11;
+}
+void c_longdouble(long double f, size_t i) {
+    assert_or_panic(f == 12);
+    assert_or_panic(i == 1);
+}
+void c_1_longdouble(size_t a0, long double f, size_t i) {
+    assert_or_panic(f == 13);
+    assert_or_panic(i == 2);
+}
+void c_2_longdouble(size_t a0, size_t a1, long double f, size_t i) {
+    assert_or_panic(f == 14);
+    assert_or_panic(i == 3);
+}
+void c_3_longdouble(size_t a0, size_t a1, size_t a2, long double f, size_t i) {
+    assert_or_panic(f == 15);
+    assert_or_panic(i == 4);
+}
+void c_4_longdouble(size_t a0, size_t a1, size_t a2, size_t a3, long double f, size_t i) {
+    assert_or_panic(f == 16);
+    assert_or_panic(i == 5);
+}
+void c_5_longdouble(size_t a0, size_t a1, size_t a2, size_t a3, size_t a4, long double f, size_t i) {
+    assert_or_panic(f == 17);
+    assert_or_panic(i == 6);
+}
+void c_6_longdouble(size_t a0, size_t a1, size_t a2, size_t a3, size_t a4, size_t a5, long double f, size_t i) {
+    assert_or_panic(f == 18);
+    assert_or_panic(i == 7);
+}
+void c_7_longdouble(size_t a0, size_t a1, size_t a2, size_t a3, size_t a4, size_t a5, size_t a6, long double f, size_t i) {
+    assert_or_panic(f == 19);
+    assert_or_panic(i == 8);
+}
+void c_8_longdouble(size_t a0, size_t a1, size_t a2, size_t a3, size_t a4, size_t a5, size_t a6, size_t a7, long double f, size_t i) {
+    assert_or_panic(f == 20);
+    assert_or_panic(i == 9);
+}
+void c_test_longdouble(void) {
+    long double f = zig_ret_longdouble();
+    assert_or_panic(f == 1);
+    zig_longdouble(2, 1);
+    zig_1_longdouble(0, 3, 2);
+    zig_2_longdouble(0, 1, 4, 3);
+    zig_3_longdouble(0, 1, 2, 5, 4);
+    zig_4_longdouble(0, 1, 2, 3, 6, 5);
+    zig_5_longdouble(0, 1, 2, 3, 4, 7, 6);
+    zig_6_longdouble(0, 1, 2, 3, 4, 5, 8, 7);
+    zig_7_longdouble(0, 1, 2, 3, 4, 5, 6, 9, 8);
+    zig_8_longdouble(0, 1, 2, 3, 4, 5, 6, 7, 10, 9);
+}
+
 #if defined(ZIG_BACKEND_STAGE2_X86_64) || defined(ZIG_PPC32) || defined(__wasm__)
 
 typedef bool Vector_2_bool __attribute__((ext_vector_type(2)));
@@ -15326,9 +15515,6 @@ void run_c_tests(void) {
 
     zig_five_integers(12, 34, 56, 78, 90);
 
-    zig_f32(12.34f);
-    zig_f64(56.78);
-    zig_longdouble(12.34l);
     zig_five_floats(1.0f, 2.0f, 3.0f, 4.0f, 5.0f);
 
     zig_ptr((void *)0xdeadbeefL);
@@ -15550,18 +15736,6 @@ void c_struct_i128(struct i128 x) {
 }
 #endif
 
-void c_f32(float x) {
-    assert_or_panic(x == 12.34f);
-}
-
-void c_f64(double x) {
-    assert_or_panic(x == 56.78);
-}
-
-void c_long_double(long double x) {
-    assert_or_panic(x == 12.34l);
-}
-
 void c_ptr(void *x) {
     assert_or_panic(x == (void *)0xdeadbeefL);
 }
diff --git a/test/c_abi/main.zig b/test/c_abi/main.zig
index f9a48477a714b250696652184e1511ccf86bae28..f494b51818c33466614e24eb0efb398abb157779 100644
--- a/test/c_abi/main.zig
+++ b/test/c_abi/main.zig
@@ -104,10 +104,6 @@ export fn zig_struct_u128(a: U128) void {
     expect(a.value == 0xfffffffffffffffc) catch @panic("test failure: zig_struct_u128");
 }
 
-extern fn c_f32(f32) void;
-extern fn c_f64(f64) void;
-extern fn c_long_double(c_longdouble) void;
-
 // On windows x64, the first 4 are passed via registers, others on the stack.
 extern fn c_five_floats(f32, f32, f32, f32, f32) void;
 
@@ -120,28 +116,9 @@ export fn zig_five_floats(a: f32, b: f32, c: f32, d: f32, e: f32) void {
 }
 
 test "floats" {
-    c_f32(12.34);
-    c_f64(56.78);
     c_five_floats(1.0, 2.0, 3.0, 4.0, 5.0);
 }
 
-test "long double" {
-    if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
-
-    c_long_double(12.34);
-}
-
-export fn zig_f32(x: f32) void {
-    expect(x == 12.34) catch @panic("test failure: zig_f32");
-}
-export fn zig_f64(x: f64) void {
-    expect(x == 56.78) catch @panic("test failure: zig_f64");
-}
-export fn zig_longdouble(x: c_longdouble) void {
-    if (!builtin.target.cpu.arch.isWasm()) return; // waiting for #1481
-    expect(x == 12.34) catch @panic("test failure: zig_longdouble");
-}
-
 extern fn c_ptr(*anyopaque) void;
 
 test "pointer" {
@@ -269,6 +246,209 @@ export fn zig_cmultd_comp(a_r: f64, a_i: f64, b_r: f64, b_i: f64) ComplexDouble
     return .{ .real = 1.5, .imag = 13.5 };
 }
 
+export fn zig_ret_f32() f32 {
+    return 1;
+}
+export fn zig_f32(f: f32, i: usize) void {
+    expect(f == 2) catch @panic("test failure");
+    expect(i == 1) catch @panic("test failure");
+}
+export fn zig_1_f32(_: usize, f: f32, i: usize) void {
+    expect(f == 3) catch @panic("test failure");
+    expect(i == 2) catch @panic("test failure");
+}
+export fn zig_2_f32(_: usize, _: usize, f: f32, i: usize) void {
+    expect(f == 4) catch @panic("test failure");
+    expect(i == 3) catch @panic("test failure");
+}
+export fn zig_3_f32(_: usize, _: usize, _: usize, f: f32, i: usize) void {
+    expect(f == 5) catch @panic("test failure");
+    expect(i == 4) catch @panic("test failure");
+}
+export fn zig_4_f32(_: usize, _: usize, _: usize, _: usize, f: f32, i: usize) void {
+    expect(f == 6) catch @panic("test failure");
+    expect(i == 5) catch @panic("test failure");
+}
+export fn zig_5_f32(_: usize, _: usize, _: usize, _: usize, _: usize, f: f32, i: usize) void {
+    expect(f == 7) catch @panic("test failure");
+    expect(i == 6) catch @panic("test failure");
+}
+export fn zig_6_f32(_: usize, _: usize, _: usize, _: usize, _: usize, _: usize, f: f32, i: usize) void {
+    expect(f == 8) catch @panic("test failure");
+    expect(i == 7) catch @panic("test failure");
+}
+export fn zig_7_f32(_: usize, _: usize, _: usize, _: usize, _: usize, _: usize, _: usize, f: f32, i: usize) void {
+    expect(f == 9) catch @panic("test failure");
+    expect(i == 8) catch @panic("test failure");
+}
+export fn zig_8_f32(_: usize, _: usize, _: usize, _: usize, _: usize, _: usize, _: usize, _: usize, f: f32, i: usize) void {
+    expect(f == 10) catch @panic("test failure");
+    expect(i == 9) catch @panic("test failure");
+}
+
+extern fn c_ret_f32() f32;
+extern fn c_f32(f32, usize) void;
+extern fn c_1_f32(usize, f32, usize) void;
+extern fn c_2_f32(usize, usize, f32, usize) void;
+extern fn c_3_f32(usize, usize, usize, f32, usize) void;
+extern fn c_4_f32(usize, usize, usize, usize, f32, usize) void;
+extern fn c_5_f32(usize, usize, usize, usize, usize, f32, usize) void;
+extern fn c_6_f32(usize, usize, usize, usize, usize, usize, f32, usize) void;
+extern fn c_7_f32(usize, usize, usize, usize, usize, usize, usize, f32, usize) void;
+extern fn c_8_f32(usize, usize, usize, usize, usize, usize, usize, usize, f32, usize) void;
+extern fn c_test_f32() void;
+
+test "f32" {
+    const f = c_ret_f32();
+    try expect(f == 11);
+    c_f32(12, 1);
+    c_1_f32(0, 13, 2);
+    c_2_f32(0, 1, 14, 3);
+    c_3_f32(0, 1, 2, 15, 4);
+    c_4_f32(0, 1, 2, 3, 16, 5);
+    c_5_f32(0, 1, 2, 3, 4, 17, 6);
+    c_6_f32(0, 1, 2, 3, 4, 5, 18, 7);
+    c_7_f32(0, 1, 2, 3, 4, 5, 6, 19, 8);
+    c_8_f32(0, 1, 2, 3, 4, 5, 6, 7, 20, 9);
+    c_test_f32();
+}
+
+export fn zig_ret_f64() f64 {
+    return 1;
+}
+export fn zig_f64(f: f64, i: usize) void {
+    expect(f == 2) catch @panic("test failure");
+    expect(i == 1) catch @panic("test failure");
+}
+export fn zig_1_f64(_: usize, f: f64, i: usize) void {
+    expect(f == 3) catch @panic("test failure");
+    expect(i == 2) catch @panic("test failure");
+}
+export fn zig_2_f64(_: usize, _: usize, f: f64, i: usize) void {
+    expect(f == 4) catch @panic("test failure");
+    expect(i == 3) catch @panic("test failure");
+}
+export fn zig_3_f64(_: usize, _: usize, _: usize, f: f64, i: usize) void {
+    expect(f == 5) catch @panic("test failure");
+    expect(i == 4) catch @panic("test failure");
+}
+export fn zig_4_f64(_: usize, _: usize, _: usize, _: usize, f: f64, i: usize) void {
+    expect(f == 6) catch @panic("test failure");
+    expect(i == 5) catch @panic("test failure");
+}
+export fn zig_5_f64(_: usize, _: usize, _: usize, _: usize, _: usize, f: f64, i: usize) void {
+    expect(f == 7) catch @panic("test failure");
+    expect(i == 6) catch @panic("test failure");
+}
+export fn zig_6_f64(_: usize, _: usize, _: usize, _: usize, _: usize, _: usize, f: f64, i: usize) void {
+    expect(f == 8) catch @panic("test failure");
+    expect(i == 7) catch @panic("test failure");
+}
+export fn zig_7_f64(_: usize, _: usize, _: usize, _: usize, _: usize, _: usize, _: usize, f: f64, i: usize) void {
+    expect(f == 9) catch @panic("test failure");
+    expect(i == 8) catch @panic("test failure");
+}
+export fn zig_8_f64(_: usize, _: usize, _: usize, _: usize, _: usize, _: usize, _: usize, _: usize, f: f64, i: usize) void {
+    expect(f == 10) catch @panic("test failure");
+    expect(i == 9) catch @panic("test failure");
+}
+
+extern fn c_ret_f64() f64;
+extern fn c_f64(f64, usize) void;
+extern fn c_1_f64(usize, f64, usize) void;
+extern fn c_2_f64(usize, usize, f64, usize) void;
+extern fn c_3_f64(usize, usize, usize, f64, usize) void;
+extern fn c_4_f64(usize, usize, usize, usize, f64, usize) void;
+extern fn c_5_f64(usize, usize, usize, usize, usize, f64, usize) void;
+extern fn c_6_f64(usize, usize, usize, usize, usize, usize, f64, usize) void;
+extern fn c_7_f64(usize, usize, usize, usize, usize, usize, usize, f64, usize) void;
+extern fn c_8_f64(usize, usize, usize, usize, usize, usize, usize, usize, f64, usize) void;
+extern fn c_test_f64() void;
+
+test "f64" {
+    const f = c_ret_f64();
+    try expect(f == 11);
+    c_f64(12, 1);
+    c_1_f64(0, 13, 2);
+    c_2_f64(0, 1, 14, 3);
+    c_3_f64(0, 1, 2, 15, 4);
+    c_4_f64(0, 1, 2, 3, 16, 5);
+    c_5_f64(0, 1, 2, 3, 4, 17, 6);
+    c_6_f64(0, 1, 2, 3, 4, 5, 18, 7);
+    c_7_f64(0, 1, 2, 3, 4, 5, 6, 19, 8);
+    c_8_f64(0, 1, 2, 3, 4, 5, 6, 7, 20, 9);
+    c_test_f64();
+}
+
+export fn zig_ret_longdouble() c_longdouble {
+    return 1;
+}
+export fn zig_longdouble(f: c_longdouble, i: usize) void {
+    expect(f == 2) catch @panic("test failure");
+    expect(i == 1) catch @panic("test failure");
+}
+export fn zig_1_longdouble(_: usize, f: c_longdouble, i: usize) void {
+    expect(f == 3) catch @panic("test failure");
+    expect(i == 2) catch @panic("test failure");
+}
+export fn zig_2_longdouble(_: usize, _: usize, f: c_longdouble, i: usize) void {
+    expect(f == 4) catch @panic("test failure");
+    expect(i == 3) catch @panic("test failure");
+}
+export fn zig_3_longdouble(_: usize, _: usize, _: usize, f: c_longdouble, i: usize) void {
+    expect(f == 5) catch @panic("test failure");
+    expect(i == 4) catch @panic("test failure");
+}
+export fn zig_4_longdouble(_: usize, _: usize, _: usize, _: usize, f: c_longdouble, i: usize) void {
+    expect(f == 6) catch @panic("test failure");
+    expect(i == 5) catch @panic("test failure");
+}
+export fn zig_5_longdouble(_: usize, _: usize, _: usize, _: usize, _: usize, f: c_longdouble, i: usize) void {
+    expect(f == 7) catch @panic("test failure");
+    expect(i == 6) catch @panic("test failure");
+}
+export fn zig_6_longdouble(_: usize, _: usize, _: usize, _: usize, _: usize, _: usize, f: c_longdouble, i: usize) void {
+    expect(f == 8) catch @panic("test failure");
+    expect(i == 7) catch @panic("test failure");
+}
+export fn zig_7_longdouble(_: usize, _: usize, _: usize, _: usize, _: usize, _: usize, _: usize, f: c_longdouble, i: usize) void {
+    expect(f == 9) catch @panic("test failure");
+    expect(i == 8) catch @panic("test failure");
+}
+export fn zig_8_longdouble(_: usize, _: usize, _: usize, _: usize, _: usize, _: usize, _: usize, _: usize, f: c_longdouble, i: usize) void {
+    expect(f == 10) catch @panic("test failure");
+    expect(i == 9) catch @panic("test failure");
+}
+
+extern fn c_ret_longdouble() c_longdouble;
+extern fn @"c_longdouble"(c_longdouble, usize) void;
+extern fn c_1_longdouble(usize, c_longdouble, usize) void;
+extern fn c_2_longdouble(usize, usize, c_longdouble, usize) void;
+extern fn c_3_longdouble(usize, usize, usize, c_longdouble, usize) void;
+extern fn c_4_longdouble(usize, usize, usize, usize, c_longdouble, usize) void;
+extern fn c_5_longdouble(usize, usize, usize, usize, usize, c_longdouble, usize) void;
+extern fn c_6_longdouble(usize, usize, usize, usize, usize, usize, c_longdouble, usize) void;
+extern fn c_7_longdouble(usize, usize, usize, usize, usize, usize, usize, c_longdouble, usize) void;
+extern fn c_8_longdouble(usize, usize, usize, usize, usize, usize, usize, usize, c_longdouble, usize) void;
+extern fn c_test_longdouble() void;
+
+test "long double" {
+    if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
+
+    const f = c_ret_longdouble();
+    try expect(f == 11);
+    @"c_longdouble"(12, 1);
+    c_1_longdouble(0, 13, 2);
+    c_2_longdouble(0, 1, 14, 3);
+    c_3_longdouble(0, 1, 2, 15, 4);
+    c_4_longdouble(0, 1, 2, 3, 16, 5);
+    c_5_longdouble(0, 1, 2, 3, 4, 17, 6);
+    c_6_longdouble(0, 1, 2, 3, 4, 5, 18, 7);
+    c_7_longdouble(0, 1, 2, 3, 4, 5, 6, 19, 8);
+    c_8_longdouble(0, 1, 2, 3, 4, 5, 6, 7, 20, 9);
+    c_test_longdouble();
+}
+
 comptime {
     skip: {
         if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64) break :skip;