Support `u128`/`i128` c-variadic arguments by folkertdev · Pull Request #155429 · rust-lang/rust

folkertdev · 2026-04-17T10:39:17Z

The restriction on u128 is kind of arbitrary, so let's see what it would take to support it.

folkertdev · 2026-04-17T10:40:44Z

@bors try jobs=dist-various-1,dist-various-2,aarch64-apple,x86_64-mingw-1

Support `u128`/`i128` c-variadic arguments try-job: dist-various-1 try-job: dist-various-2 try-job: aarch64-apple try-job: x86_64-mingw-1

folkertdev · 2026-04-17T13:28:53Z

@bors try jobs=dist-various-1,dist-various-2,aarch64-apple,x86_64-mingw-1

Support `u128`/`i128` c-variadic arguments try-job: dist-various-1 try-job: dist-various-2 try-job: aarch64-apple try-job: x86_64-mingw-1

rust-bors · 2026-04-17T16:19:42Z

💔 Test for d3bd26f failed: CI. Failed job:

try - aarch64-apple (web logs, enhanced plaintext logs)

folkertdev · 2026-04-17T20:45:36Z

@bors try jobs=dist-various-1,dist-various-2,aarch64-apple,x86_64-mingw-1

Support `u128`/`i128` c-variadic arguments try-job: dist-various-1 try-job: dist-various-2 try-job: aarch64-apple try-job: x86_64-mingw-1

rust-bors · 2026-04-18T00:04:36Z

☀️ Try build successful (CI)
Build commit: d505291 (d50529125c96155f22b48fab34b00ab49c79dcad, parent: f29256dd1420dc681bf4956e3012ffe9eccdc7e7)

folkertdev · 2026-04-21T17:23:11Z

+crate::cfg_select! {
+    target_pointer_width = "32" => {
+        // GCC says <https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/_005f_005fint128.html>
+        //
+        // > There is no support in GCC for expressing an integer constant of type __int128 for targets
+        // > with long long integer less than 128 bits wide.
+    }
+    target_env = "msvc" => {
+        // Per https://learn.microsoft.com/en-us/cpp/cpp/data-type-ranges?view=msvc-170, __int128 is
+        // not recognized by msvc.
+    }
+    any(
+        target_arch = "x86_64",
+        target_arch = "aarch64",
+        target_arch = "riscv64",
+        target_arch = "loongarch64",
+        target_arch = "s390x",
+        target_arch = "powerpc64"
+    ) => {
+        unsafe impl VaArgSafe for i128 {}
+        unsafe impl VaArgSafe for u128 {}
+    }
+    _ => {
+    }
+}


cc @Amanieu @joshtriplett @workingjubilee thoughts on this as an initial set of targets to support i128 varargs on?

View changes since the review

folkertdev · 2026-04-21T17:43:28Z

+            Primitive::Int(integer, _) => match integer {
+                Integer::I8 | Integer::I16 => unreachable!(),
+                Integer::I32 | Integer::I64 => { /* fall through */ }
+                Integer::I128 => return Align::EIGHT,


It has custom behavior, the va_arg implementation for powerpc64 is here

https://github.com/llvm/llvm-project/blob/c7eea85b8046660f0a1fd4a1c5c41b44475f8caf/clang/lib/CodeGen/Targets/PPC.cpp#L998

and it uses the implementation here

https://github.com/llvm/llvm-project/blob/c7eea85b8046660f0a1fd4a1c5c41b44475f8caf/clang/lib/CodeGen/Targets/PPC.cpp#L765

The logic falls through to the last line for i128, returning 8. For f128 it curiously does use an alignment of 16, so I've just added that already because it would be easy to miss down the line.

View changes since the review

folkertdev

This looks big but only really because I added a lot more assembly tests to check that the 128-bit implementation is correct. Due to its alignment it sometimes requires some additonal logic, so I thought it best to lock the behavior in via assembly tests.

r? tgross35

View changes since this review

folkertdev · 2026-04-25T13:20:28Z

+    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)
+    } else {
+        overflow_arg_area_v
+    };


https://github.com/llvm/llvm-project/blob/f2436980771e8d5a203a6092160550f8c15664e1/clang/lib/CodeGen/Targets/X86.cpp#L3057-L3065

folkertdev · 2026-04-25T13:22:22Z

+//@ revisions: WINDOWS_GNU WINDOWS_MSVC
+//@ [WINDOWS_GNU] compile-flags: -Copt-level=3 -Cllvm-args=-x86-asm-syntax=intel
+//@ [WINDOWS_GNU] compile-flags: --target x86_64-pc-windows-gnu
+//@ [WINDOWS_GNU] needs-llvm-components: x86
+//@ [WINDOWS_MSVC] compile-flags: -Copt-level=3 -Cllvm-args=-x86-asm-syntax=intel
+//@ [WINDOWS_MSVC] compile-flags: --target x86_64-pc-windows-msvc
+//@ [WINDOWS_MSVC] needs-llvm-components: x86


Calling this out explicitly: we do implement the trait even on -msvc targets, because clang provides __int128 there. If MSVC itself ever did support the type (which, from my understanding, is unlikely), clang would kind of have to follow whatever it does, and we would too. Until then we're compatible with clang.

folkertdev · 2026-04-25T13:23:55Z

+// Clang and Rustc use a different ABI for i128 on wasm32, and LLVM optimizes differently if we use
+// a mutable reference instead of just a pointer. With this setup we match the equivalent Clang
+// input exactly.
+#[unsafe(no_mangle)]
+unsafe extern "C" fn read_i128(out: *mut i128, ap: *mut VaList<'_>) {


just calling attention to this difference. Based on #135532 we actually follow the spec here.

folkertdev · 2026-04-25T13:24:55Z

+//@ revisions: POWERPC POWERPC64 POWERPC64LE AIX
+//@ [POWERPC] compile-flags: -Copt-level=3 --target powerpc-unknown-linux-gnu
+//@ [POWERPC] needs-llvm-components: powerpc
+//@ [POWERPC64] compile-flags: -Copt-level=3 --target powerpc64-unknown-linux-gnu
+//@ [POWERPC64] needs-llvm-components: powerpc
+//@ [POWERPC64LE] compile-flags: -Copt-level=3 --target powerpc64le-unknown-linux-gnu
+//@ [POWERPC64LE] needs-llvm-components: powerpc
+//@ [AIX] compile-flags: -Copt-level=3 --target powerpc64-ibm-aix
+//@ [AIX] needs-llvm-components: powerpc


included because powerpc has some special behavior for i128, which is only aligned to 8 bytes in c-variadic arguments.

folkertdev · 2026-04-25T13:26:12Z

+// assembly.
+//
+// For aarch64-apple-darwin LLVM is able to optimize our output better, because we effectively
+// desugar va_arg early, hence we don't actually match Clang there.


I played around with our codegen for a while, but LLVM is too clever. But, these are both tier-1 targets so we test the implementation versus C in CI, and the generated IR does look reasonable.

folkertdev · 2026-04-25T13:27:48Z

+// Implement `VaArgSafe` for 128-bit integers on targets where clang provides `__int128`.
+//
+// GCC does not implement `__int128` for any 16-bit/32-bit target:
+//
+// https://gcc.gnu.org/onlinedocs/gcc-15.2.0/gcc/_005f_005fint128.html
+//
+// > There is no support in GCC for expressing an integer constant of type __int128 for targets
+// > with long long integer less than 128 bits wide.
+//
+// Per https://learn.microsoft.com/en-us/cpp/cpp/data-type-ranges?view=msvc-170, MSVC does not
+// define `__int128`.
+//
+// Clang is slightly more permissive: it defines `__int128` on wasm32 (a 32-bit target) and also
+// does provide `__int128` on 64-bit `*-pc-windows-msvc`, and we follow suit.


calling this out: the implementation now follows clang: if it defines __int128, we impl the trait.

cc @Amanieu @joshtriplett if you have objections to that.

rustbot · 2026-04-25T13:29:29Z

tgross35 is currently at their maximum review capacity.
They may take a while to respond.

folkertdev · 2026-04-25T13:57:06Z

may as well

@bors try jobs=dist-various-1,dist-various-2,aarch64-apple,x86_64-mingw-1

Support `u128`/`i128` c-variadic arguments try-job: dist-various-1 try-job: dist-various-2 try-job: aarch64-apple try-job: x86_64-mingw-1

folkertdev · 2026-04-25T16:50:59Z

 ) -> &'ll Value {
    if layout.layout.align.abi > src_align {
-        let tmp = bx.alloca(layout.layout.size(), layout.layout.align().abi);
+        let tmp = bx.alloca_with_ty(layout);


Using a typed alloca solves an issue with the memcpy not being optimized out, see llvm/llvm-project#194158. Normally rust type erases allocas (e.g. [16 x i8]) and that confuses LLVM apparently.

View changes since the review

rust-bors · 2026-04-25T16:56:36Z

💔 Test for 9d4c015 failed: CI. Failed job:

try - dist-various-2 (web logs, enhanced plaintext logs)

folkertdev · 2026-04-25T19:54:18Z

@bors try jobs=dist-various-1,dist-various-2,aarch64-apple,x86_64-mingw-1

Support `u128`/`i128` c-variadic arguments try-job: dist-various-1 try-job: dist-various-2 try-job: aarch64-apple try-job: x86_64-mingw-1

rust-bors · 2026-04-25T23:00:13Z

☀️ Try build successful (CI)
Build commit: aee82fa (aee82fa5d127ed3da73b856690b5b55cbfd0efd3, parent: 9838411cb723b60dc62b1625751075c4d933b992)

On platforms where `clang` defines `__int128`.

rustbot · 2026-04-26T11:38:06Z

This PR was rebased onto a different main commit. Here's a range-diff highlighting what actually changed.

Rebasing is a normal part of keeping PRs up to date, so no action is needed—this note is just to help reviewers.