Support u128/i128 c-variadic arguments

Author: folkertdev

compiler/rustc_codegen_llvm/src/va_arg.rs

@@ -32,8 +32,8 @@ fn round_pointer_up_to_alignment<'ll>(
     let ptr = bx.inbounds_ptradd(addr, bx.const_i32(align.bytes() as i32 - 1));
     bx.call_intrinsic(
         "llvm.ptrmask",
-        &[ptr_ty, bx.type_i32()],
-        &[ptr, bx.const_int(bx.isize_ty, -(align.bytes() as isize) as i64)],
+        &[ptr_ty, bx.type_isize()],
+        &[ptr, bx.const_usize(align.bytes().wrapping_neg())],
     )
 }
 
@@ -765,9 +765,16 @@ fn x86_64_sysv64_va_arg_from_memory<'ll, 'tcx>(
     // byte boundary if alignment needed by type exceeds 8 byte boundary.
     // It isn't stated explicitly in the standard, but in practice we use
     // alignment greater than 16 where necessary.
-    if layout.layout.align.bytes() > 8 {
-        unreachable!("all instances of VaArgSafe have an alignment <= 8");
-    }
+    let overflow_arg_area_v = if layout.layout.align.bytes() > 8 {
+        round_pointer_up_to_alignment(
+            bx,
+            overflow_arg_area_v,
+            layout.layout.align.abi,
+            bx.type_ptr(),
+        )
+    } else {
+        overflow_arg_area_v
+    };
 
     // AMD64-ABI 3.5.7p5: Step 8. Fetch type from l->overflow_arg_area.
     let mem_addr = overflow_arg_area_v;

library/core/src/ffi/va_list.rs

@@ -268,10 +268,12 @@ mod sealed {
 
     impl Sealed for i32 {}
     impl Sealed for i64 {}
+    impl Sealed for i128 {}
     impl Sealed for isize {}
 
     impl Sealed for u32 {}
     impl Sealed for u64 {}
+    impl Sealed for u128 {}
     impl Sealed for usize {}
 
     impl Sealed for f64 {}
@@ -302,11 +304,13 @@ pub unsafe trait VaArgSafe: sealed::Sealed {}
 // i8 and i16 are implicitly promoted to c_int in C, and cannot implement `VaArgSafe`.
 unsafe impl VaArgSafe for i32 {}
 unsafe impl VaArgSafe for i64 {}
+unsafe impl VaArgSafe for i128 {}
 unsafe impl VaArgSafe for isize {}
 
 // u8 and u16 are implicitly promoted to c_int in C, and cannot implement `VaArgSafe`.
 unsafe impl VaArgSafe for u32 {}
 unsafe impl VaArgSafe for u64 {}
+unsafe impl VaArgSafe for u128 {}
 unsafe impl VaArgSafe for usize {}
 
 // f32 is implicitly promoted to c_double in C, and cannot implement `VaArgSafe`.

tests/run-make/c-link-to-rust-va-list-fn/checkrust.rs

@@ -20,6 +20,7 @@ pub unsafe extern "C" fn check_list_0(mut ap: VaList) -> usize {
     continue_if!(ap.arg::<c_longlong>() == 1);
     continue_if!(ap.arg::<c_int>() == 2);
     continue_if!(ap.arg::<c_longlong>() == 3);
+    continue_if!(ap.arg::<i128>() == 4);
     0
 }
 
@@ -57,6 +58,14 @@ pub unsafe extern "C" fn check_list_copy_0(mut ap: VaList) -> usize {
     if compare_c_str(ap.arg::<*const c_char>(), c"Correct") { 0 } else { 0xff }
 }
 
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn check_list_i128(mut ap: VaList) -> usize {
+    continue_if!(ap.arg::<i128>() == -42);
+    continue_if!(ap.arg::<c_int>() == 0xAAAA_AAAAu32.cast_signed());
+    continue_if!(ap.arg::<u128>() == u128::MAX);
+    0
+}
+
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn check_varargs_0(_: c_int, mut ap: ...) -> usize {
     continue_if!(ap.arg::<c_int>() == 42);

tests/run-make/c-link-to-rust-va-list-fn/test.c

@@ -8,6 +8,7 @@ extern size_t check_list_0(va_list ap);
 extern size_t check_list_1(va_list ap);
 extern size_t check_list_2(va_list ap);
 extern size_t check_list_copy_0(va_list ap);
+extern size_t check_list_i128(va_list ap);
 extern size_t check_varargs_0(int fixed, ...);
 extern size_t check_varargs_1(int fixed, ...);
 extern size_t check_varargs_2(int fixed, ...);
@@ -30,14 +31,16 @@ int test_rust(size_t (*fn)(va_list), ...) {
 }
 
 int main(int argc, char* argv[]) {
-    assert(test_rust(check_list_0, 0x01LL, 0x02, 0x03LL) == 0);
+    assert(test_rust(check_list_0, 0x01LL, 0x02, 0x03LL, (__int128)4) == 0);
 
     assert(test_rust(check_list_1, -1, 'A', '4', ';', 0x32, 0x10000001, "Valid!") == 0);
 
     assert(test_rust(check_list_2, 3.14, 12l, 'a', 6.28, "Hello", 42, "World") == 0);
 
     assert(test_rust(check_list_copy_0, 6.28, 16, 'A', "Skip Me!", "Correct") == 0);
 
+    assert(test_rust(check_list_i128, (__int128)-42, 0xAAAAAAAA, (unsigned __int128)-1) == 0);
+
     assert(check_varargs_0(0, 42, "Hello, World!") == 0);
 
     assert(check_varargs_1(0, 3.14, 12l, 'A', 0x1LL) == 0);