[clang] [llvm] [RISCV] Sync the LP64E i128 vararg and stack argument behavior with gcc. (PR #239884)

Craig Topper via cfe-commits cfe-commits at lists.llvm.org
Fri Nov 6 19:02:50 PST 2026


https://github.com/topperc created https://github.com/llvm/llvm-project/pull/239884

i128 arguments to variadic functions are not passed in aligned pairs for LP64E.
The stack locations for i128 arguments are not 16 byte aligned.

In the backend, rather than checking for RVE directly, use the ABI stack
alignment to clamp the type alignment which is where gcc's behavior comes from.

Assisted-by: Claude

>From 074d04e5e80ffa5c99309fb4622f9517569e0557 Mon Sep 17 00:00:00 2001
From: Craig Topper <craig.topper at sifive.com>
Date: Fri, 6 Nov 2026 18:02:19 -0800
Subject: [PATCH 1/2] Pre-commit tests

---
 llvm/test/CodeGen/RISCV/calling-conv-lp64e.ll | 223 +++++++++++++++
 llvm/test/CodeGen/RISCV/vararg-lp64e.ll       | 257 ++++++++++++++++++
 2 files changed, 480 insertions(+)
 create mode 100644 llvm/test/CodeGen/RISCV/vararg-lp64e.ll

diff --git a/llvm/test/CodeGen/RISCV/calling-conv-lp64e.ll b/llvm/test/CodeGen/RISCV/calling-conv-lp64e.ll
index 7abdd2175c41cb..da26a98499045b 100644
--- a/llvm/test/CodeGen/RISCV/calling-conv-lp64e.ll
+++ b/llvm/test/CodeGen/RISCV/calling-conv-lp64e.ll
@@ -211,3 +211,226 @@ define i64 @caller_tiny_scalar_ret() nounwind {
   %3 = sext i32 %2 to i64
   ret i64 %3
 }
+
+; Check that on RV64, i128 is passed in a pair of registers. Unlike
+; the convention for varargs, this need not be an aligned pair.
+
+define i64 @callee_i128_in_regs(i32 %a, i128 %b) nounwind {
+; RV64I-LP64E-FPELIM-LABEL: callee_i128_in_regs:
+; RV64I-LP64E-FPELIM:       # %bb.0:
+; RV64I-LP64E-FPELIM-NEXT:    slli a0, a0, 32
+; RV64I-LP64E-FPELIM-NEXT:    srli a0, a0, 32
+; RV64I-LP64E-FPELIM-NEXT:    add a0, a0, a1
+; RV64I-LP64E-FPELIM-NEXT:    ret
+;
+; RV64I-LP64E-WITHFP-LABEL: callee_i128_in_regs:
+; RV64I-LP64E-WITHFP:       # %bb.0:
+; RV64I-LP64E-WITHFP-NEXT:    addi sp, sp, -16
+; RV64I-LP64E-WITHFP-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
+; RV64I-LP64E-WITHFP-NEXT:    sd s0, 0(sp) # 8-byte Folded Spill
+; RV64I-LP64E-WITHFP-NEXT:    addi s0, sp, 16
+; RV64I-LP64E-WITHFP-NEXT:    slli a0, a0, 32
+; RV64I-LP64E-WITHFP-NEXT:    srli a0, a0, 32
+; RV64I-LP64E-WITHFP-NEXT:    add a0, a0, a1
+; RV64I-LP64E-WITHFP-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
+; RV64I-LP64E-WITHFP-NEXT:    ld s0, 0(sp) # 8-byte Folded Reload
+; RV64I-LP64E-WITHFP-NEXT:    addi sp, sp, 16
+; RV64I-LP64E-WITHFP-NEXT:    ret
+  %b_trunc = trunc i128 %b to i64
+  %a_ext = zext i32 %a to i64
+  %1 = add i64 %a_ext, %b_trunc
+  ret i64 %1
+}
+
+define i64 @caller_i128_in_regs() nounwind {
+; RV64I-LP64E-FPELIM-LABEL: caller_i128_in_regs:
+; RV64I-LP64E-FPELIM:       # %bb.0:
+; RV64I-LP64E-FPELIM-NEXT:    addi sp, sp, -8
+; RV64I-LP64E-FPELIM-NEXT:    sd ra, 0(sp) # 8-byte Folded Spill
+; RV64I-LP64E-FPELIM-NEXT:    li a0, 1
+; RV64I-LP64E-FPELIM-NEXT:    li a1, 2
+; RV64I-LP64E-FPELIM-NEXT:    li a2, 0
+; RV64I-LP64E-FPELIM-NEXT:    call callee_i128_in_regs
+; RV64I-LP64E-FPELIM-NEXT:    ld ra, 0(sp) # 8-byte Folded Reload
+; RV64I-LP64E-FPELIM-NEXT:    addi sp, sp, 8
+; RV64I-LP64E-FPELIM-NEXT:    ret
+;
+; RV64I-LP64E-WITHFP-LABEL: caller_i128_in_regs:
+; RV64I-LP64E-WITHFP:       # %bb.0:
+; RV64I-LP64E-WITHFP-NEXT:    addi sp, sp, -16
+; RV64I-LP64E-WITHFP-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
+; RV64I-LP64E-WITHFP-NEXT:    sd s0, 0(sp) # 8-byte Folded Spill
+; RV64I-LP64E-WITHFP-NEXT:    addi s0, sp, 16
+; RV64I-LP64E-WITHFP-NEXT:    li a0, 1
+; RV64I-LP64E-WITHFP-NEXT:    li a1, 2
+; RV64I-LP64E-WITHFP-NEXT:    li a2, 0
+; RV64I-LP64E-WITHFP-NEXT:    call callee_i128_in_regs
+; RV64I-LP64E-WITHFP-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
+; RV64I-LP64E-WITHFP-NEXT:    ld s0, 0(sp) # 8-byte Folded Reload
+; RV64I-LP64E-WITHFP-NEXT:    addi sp, sp, 16
+; RV64I-LP64E-WITHFP-NEXT:    ret
+  %1 = call i64 @callee_i128_in_regs(i32 1, i128 2)
+  ret i64 %1
+}
+
+; The i128 is split between a5 and the stack. The stack half is 8-byte aligned.
+define i64 @callee_i128_split(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e, i128 %f, i32 %g) nounwind {
+; RV64I-LP64E-FPELIM-LABEL: callee_i128_split:
+; RV64I-LP64E-FPELIM:       # %bb.0:
+; RV64I-LP64E-FPELIM-NEXT:    lwu a0, 8(sp)
+; RV64I-LP64E-FPELIM-NEXT:    add a0, a5, a0
+; RV64I-LP64E-FPELIM-NEXT:    ret
+;
+; RV64I-LP64E-WITHFP-LABEL: callee_i128_split:
+; RV64I-LP64E-WITHFP:       # %bb.0:
+; RV64I-LP64E-WITHFP-NEXT:    addi sp, sp, -16
+; RV64I-LP64E-WITHFP-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
+; RV64I-LP64E-WITHFP-NEXT:    sd s0, 0(sp) # 8-byte Folded Spill
+; RV64I-LP64E-WITHFP-NEXT:    addi s0, sp, 16
+; RV64I-LP64E-WITHFP-NEXT:    lwu a0, 24(sp)
+; RV64I-LP64E-WITHFP-NEXT:    add a0, a5, a0
+; RV64I-LP64E-WITHFP-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
+; RV64I-LP64E-WITHFP-NEXT:    ld s0, 0(sp) # 8-byte Folded Reload
+; RV64I-LP64E-WITHFP-NEXT:    addi sp, sp, 16
+; RV64I-LP64E-WITHFP-NEXT:    ret
+  %f_trunc = trunc i128 %f to i64
+  %g_ext = zext i32 %g to i64
+  %1 = add i64 %f_trunc, %g_ext
+  ret i64 %1
+}
+
+define i64 @caller_i128_split() nounwind {
+; RV64I-LP64E-FPELIM-LABEL: caller_i128_split:
+; RV64I-LP64E-FPELIM:       # %bb.0:
+; RV64I-LP64E-FPELIM-NEXT:    addi sp, sp, -24
+; RV64I-LP64E-FPELIM-NEXT:    sd ra, 16(sp) # 8-byte Folded Spill
+; RV64I-LP64E-FPELIM-NEXT:    li a6, 7
+; RV64I-LP64E-FPELIM-NEXT:    li a0, 1
+; RV64I-LP64E-FPELIM-NEXT:    li a1, 2
+; RV64I-LP64E-FPELIM-NEXT:    li a2, 3
+; RV64I-LP64E-FPELIM-NEXT:    li a3, 4
+; RV64I-LP64E-FPELIM-NEXT:    li a4, 5
+; RV64I-LP64E-FPELIM-NEXT:    li a5, 6
+; RV64I-LP64E-FPELIM-NEXT:    sd zero, 0(sp)
+; RV64I-LP64E-FPELIM-NEXT:    sd a6, 8(sp)
+; RV64I-LP64E-FPELIM-NEXT:    call callee_i128_split
+; RV64I-LP64E-FPELIM-NEXT:    ld ra, 16(sp) # 8-byte Folded Reload
+; RV64I-LP64E-FPELIM-NEXT:    addi sp, sp, 24
+; RV64I-LP64E-FPELIM-NEXT:    ret
+;
+; RV64I-LP64E-WITHFP-LABEL: caller_i128_split:
+; RV64I-LP64E-WITHFP:       # %bb.0:
+; RV64I-LP64E-WITHFP-NEXT:    addi sp, sp, -32
+; RV64I-LP64E-WITHFP-NEXT:    sd ra, 24(sp) # 8-byte Folded Spill
+; RV64I-LP64E-WITHFP-NEXT:    sd s0, 16(sp) # 8-byte Folded Spill
+; RV64I-LP64E-WITHFP-NEXT:    addi s0, sp, 32
+; RV64I-LP64E-WITHFP-NEXT:    li a6, 7
+; RV64I-LP64E-WITHFP-NEXT:    li a0, 1
+; RV64I-LP64E-WITHFP-NEXT:    li a1, 2
+; RV64I-LP64E-WITHFP-NEXT:    li a2, 3
+; RV64I-LP64E-WITHFP-NEXT:    li a3, 4
+; RV64I-LP64E-WITHFP-NEXT:    li a4, 5
+; RV64I-LP64E-WITHFP-NEXT:    li a5, 6
+; RV64I-LP64E-WITHFP-NEXT:    sd zero, 0(sp)
+; RV64I-LP64E-WITHFP-NEXT:    sd a6, 8(sp)
+; RV64I-LP64E-WITHFP-NEXT:    call callee_i128_split
+; RV64I-LP64E-WITHFP-NEXT:    ld ra, 24(sp) # 8-byte Folded Reload
+; RV64I-LP64E-WITHFP-NEXT:    ld s0, 16(sp) # 8-byte Folded Reload
+; RV64I-LP64E-WITHFP-NEXT:    addi sp, sp, 32
+; RV64I-LP64E-WITHFP-NEXT:    ret
+  %1 = call i64 @callee_i128_split(i32 1, i32 2, i32 3, i32 4, i32 5, i128 6, i32 7)
+  ret i64 %1
+}
+
+; The i128 is passed on the stack with only 8-byte alignment.
+define i64 @callee_i128_on_stack(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e, i32 %f, i32 %g, i128 %h) nounwind {
+; RV64I-LP64E-FPELIM-LABEL: callee_i128_on_stack:
+; RV64I-LP64E-FPELIM:       # %bb.0:
+; RV64I-LP64E-FPELIM-NEXT:    addi sp, sp, -16
+; RV64I-LP64E-FPELIM-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
+; RV64I-LP64E-FPELIM-NEXT:    sd s0, 0(sp) # 8-byte Folded Spill
+; RV64I-LP64E-FPELIM-NEXT:    addi s0, sp, 16
+; RV64I-LP64E-FPELIM-NEXT:    andi sp, sp, -16
+; RV64I-LP64E-FPELIM-NEXT:    lwu a0, 0(s0)
+; RV64I-LP64E-FPELIM-NEXT:    ld a1, 16(s0)
+; RV64I-LP64E-FPELIM-NEXT:    add a0, a1, a0
+; RV64I-LP64E-FPELIM-NEXT:    addi sp, s0, -16
+; RV64I-LP64E-FPELIM-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
+; RV64I-LP64E-FPELIM-NEXT:    ld s0, 0(sp) # 8-byte Folded Reload
+; RV64I-LP64E-FPELIM-NEXT:    addi sp, sp, 16
+; RV64I-LP64E-FPELIM-NEXT:    ret
+;
+; RV64I-LP64E-WITHFP-LABEL: callee_i128_on_stack:
+; RV64I-LP64E-WITHFP:       # %bb.0:
+; RV64I-LP64E-WITHFP-NEXT:    addi sp, sp, -16
+; RV64I-LP64E-WITHFP-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
+; RV64I-LP64E-WITHFP-NEXT:    sd s0, 0(sp) # 8-byte Folded Spill
+; RV64I-LP64E-WITHFP-NEXT:    addi s0, sp, 16
+; RV64I-LP64E-WITHFP-NEXT:    andi sp, sp, -16
+; RV64I-LP64E-WITHFP-NEXT:    lwu a0, 0(s0)
+; RV64I-LP64E-WITHFP-NEXT:    ld a1, 16(s0)
+; RV64I-LP64E-WITHFP-NEXT:    add a0, a1, a0
+; RV64I-LP64E-WITHFP-NEXT:    addi sp, s0, -16
+; RV64I-LP64E-WITHFP-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
+; RV64I-LP64E-WITHFP-NEXT:    ld s0, 0(sp) # 8-byte Folded Reload
+; RV64I-LP64E-WITHFP-NEXT:    addi sp, sp, 16
+; RV64I-LP64E-WITHFP-NEXT:    ret
+  %h_trunc = trunc i128 %h to i64
+  %g_ext = zext i32 %g to i64
+  %1 = add i64 %h_trunc, %g_ext
+  ret i64 %1
+}
+
+define i64 @caller_i128_on_stack() nounwind {
+; RV64I-LP64E-FPELIM-LABEL: caller_i128_on_stack:
+; RV64I-LP64E-FPELIM:       # %bb.0:
+; RV64I-LP64E-FPELIM-NEXT:    addi sp, sp, -48
+; RV64I-LP64E-FPELIM-NEXT:    sd ra, 40(sp) # 8-byte Folded Spill
+; RV64I-LP64E-FPELIM-NEXT:    sd s0, 32(sp) # 8-byte Folded Spill
+; RV64I-LP64E-FPELIM-NEXT:    addi s0, sp, 48
+; RV64I-LP64E-FPELIM-NEXT:    andi sp, sp, -16
+; RV64I-LP64E-FPELIM-NEXT:    li a6, 8
+; RV64I-LP64E-FPELIM-NEXT:    li a7, 7
+; RV64I-LP64E-FPELIM-NEXT:    li a0, 1
+; RV64I-LP64E-FPELIM-NEXT:    li a1, 2
+; RV64I-LP64E-FPELIM-NEXT:    li a2, 3
+; RV64I-LP64E-FPELIM-NEXT:    li a3, 4
+; RV64I-LP64E-FPELIM-NEXT:    li a4, 5
+; RV64I-LP64E-FPELIM-NEXT:    li a5, 6
+; RV64I-LP64E-FPELIM-NEXT:    sd a7, 0(sp)
+; RV64I-LP64E-FPELIM-NEXT:    sd a6, 16(sp)
+; RV64I-LP64E-FPELIM-NEXT:    sd zero, 24(sp)
+; RV64I-LP64E-FPELIM-NEXT:    call callee_i128_on_stack
+; RV64I-LP64E-FPELIM-NEXT:    addi sp, s0, -48
+; RV64I-LP64E-FPELIM-NEXT:    ld ra, 40(sp) # 8-byte Folded Reload
+; RV64I-LP64E-FPELIM-NEXT:    ld s0, 32(sp) # 8-byte Folded Reload
+; RV64I-LP64E-FPELIM-NEXT:    addi sp, sp, 48
+; RV64I-LP64E-FPELIM-NEXT:    ret
+;
+; RV64I-LP64E-WITHFP-LABEL: caller_i128_on_stack:
+; RV64I-LP64E-WITHFP:       # %bb.0:
+; RV64I-LP64E-WITHFP-NEXT:    addi sp, sp, -48
+; RV64I-LP64E-WITHFP-NEXT:    sd ra, 40(sp) # 8-byte Folded Spill
+; RV64I-LP64E-WITHFP-NEXT:    sd s0, 32(sp) # 8-byte Folded Spill
+; RV64I-LP64E-WITHFP-NEXT:    addi s0, sp, 48
+; RV64I-LP64E-WITHFP-NEXT:    andi sp, sp, -16
+; RV64I-LP64E-WITHFP-NEXT:    li a6, 8
+; RV64I-LP64E-WITHFP-NEXT:    li a7, 7
+; RV64I-LP64E-WITHFP-NEXT:    li a0, 1
+; RV64I-LP64E-WITHFP-NEXT:    li a1, 2
+; RV64I-LP64E-WITHFP-NEXT:    li a2, 3
+; RV64I-LP64E-WITHFP-NEXT:    li a3, 4
+; RV64I-LP64E-WITHFP-NEXT:    li a4, 5
+; RV64I-LP64E-WITHFP-NEXT:    li a5, 6
+; RV64I-LP64E-WITHFP-NEXT:    sd a7, 0(sp)
+; RV64I-LP64E-WITHFP-NEXT:    sd a6, 16(sp)
+; RV64I-LP64E-WITHFP-NEXT:    sd zero, 24(sp)
+; RV64I-LP64E-WITHFP-NEXT:    call callee_i128_on_stack
+; RV64I-LP64E-WITHFP-NEXT:    addi sp, s0, -48
+; RV64I-LP64E-WITHFP-NEXT:    ld ra, 40(sp) # 8-byte Folded Reload
+; RV64I-LP64E-WITHFP-NEXT:    ld s0, 32(sp) # 8-byte Folded Reload
+; RV64I-LP64E-WITHFP-NEXT:    addi sp, sp, 48
+; RV64I-LP64E-WITHFP-NEXT:    ret
+  %1 = call i64 @callee_i128_on_stack(i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i128 8)
+  ret i64 %1
+}
diff --git a/llvm/test/CodeGen/RISCV/vararg-lp64e.ll b/llvm/test/CodeGen/RISCV/vararg-lp64e.ll
new file mode 100644
index 00000000000000..acce5ef35332d8
--- /dev/null
+++ b/llvm/test/CodeGen/RISCV/vararg-lp64e.ll
@@ -0,0 +1,257 @@
+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py UTC_ARGS: --version 6
+; RUN: llc -mtriple=riscv64 -target-abi lp64e -verify-machineinstrs < %s \
+; RUN:   | FileCheck -check-prefix=LP64E %s
+; RUN: llc -mtriple=riscv64 -target-abi lp64e -frame-pointer=all -verify-machineinstrs < %s \
+; RUN:   | FileCheck -check-prefix=LP64E-WITHFP %s
+
+; Variadic i128 arguments are not given 16-byte alignment for LP64E, matching
+; GCC. They are not passed in aligned register pairs and are only 8-byte
+; aligned on the stack.
+
+declare void @llvm.va_start(ptr)
+declare void @llvm.va_end(ptr)
+
+; The i128 is passed in a1 and a2 rather than an aligned register pair.
+define void @caller_i128_in_regs() {
+; LP64E-LABEL: caller_i128_in_regs:
+; LP64E:       # %bb.0: # %entry
+; LP64E-NEXT:    addi sp, sp, -8
+; LP64E-NEXT:    .cfi_def_cfa_offset 8
+; LP64E-NEXT:    sd ra, 0(sp) # 8-byte Folded Spill
+; LP64E-NEXT:    .cfi_offset ra, -8
+; LP64E-NEXT:    li a0, 1
+; LP64E-NEXT:    li a2, 2
+; LP64E-NEXT:    li a4, 3
+; LP64E-NEXT:    li a3, 0
+; LP64E-NEXT:    call va_i128
+; LP64E-NEXT:    ld ra, 0(sp) # 8-byte Folded Reload
+; LP64E-NEXT:    .cfi_restore ra
+; LP64E-NEXT:    addi sp, sp, 8
+; LP64E-NEXT:    .cfi_def_cfa_offset 0
+; LP64E-NEXT:    ret
+;
+; LP64E-WITHFP-LABEL: caller_i128_in_regs:
+; LP64E-WITHFP:       # %bb.0: # %entry
+; LP64E-WITHFP-NEXT:    addi sp, sp, -16
+; LP64E-WITHFP-NEXT:    .cfi_def_cfa_offset 16
+; LP64E-WITHFP-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
+; LP64E-WITHFP-NEXT:    sd s0, 0(sp) # 8-byte Folded Spill
+; LP64E-WITHFP-NEXT:    .cfi_offset ra, -8
+; LP64E-WITHFP-NEXT:    .cfi_offset s0, -16
+; LP64E-WITHFP-NEXT:    addi s0, sp, 16
+; LP64E-WITHFP-NEXT:    .cfi_def_cfa s0, 0
+; LP64E-WITHFP-NEXT:    li a0, 1
+; LP64E-WITHFP-NEXT:    li a2, 2
+; LP64E-WITHFP-NEXT:    li a4, 3
+; LP64E-WITHFP-NEXT:    li a3, 0
+; LP64E-WITHFP-NEXT:    call va_i128
+; LP64E-WITHFP-NEXT:    .cfi_def_cfa sp, 16
+; LP64E-WITHFP-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
+; LP64E-WITHFP-NEXT:    ld s0, 0(sp) # 8-byte Folded Reload
+; LP64E-WITHFP-NEXT:    .cfi_restore ra
+; LP64E-WITHFP-NEXT:    .cfi_restore s0
+; LP64E-WITHFP-NEXT:    addi sp, sp, 16
+; LP64E-WITHFP-NEXT:    .cfi_def_cfa_offset 0
+; LP64E-WITHFP-NEXT:    ret
+entry:
+  call void (i32, ...) @va_i128(i32 1, i128 2, i32 3)
+  ret void
+}
+
+; The i128 is split between a5 and the stack.
+define void @caller_i128_split_stack() {
+; LP64E-LABEL: caller_i128_split_stack:
+; LP64E:       # %bb.0: # %entry
+; LP64E-NEXT:    addi sp, sp, -48
+; LP64E-NEXT:    .cfi_def_cfa_offset 48
+; LP64E-NEXT:    sd ra, 40(sp) # 8-byte Folded Spill
+; LP64E-NEXT:    sd s0, 32(sp) # 8-byte Folded Spill
+; LP64E-NEXT:    .cfi_offset ra, -8
+; LP64E-NEXT:    .cfi_offset s0, -16
+; LP64E-NEXT:    addi s0, sp, 48
+; LP64E-NEXT:    .cfi_def_cfa s0, 0
+; LP64E-NEXT:    andi sp, sp, -16
+; LP64E-NEXT:    li a5, 7
+; LP64E-NEXT:    li a6, 6
+; LP64E-NEXT:    li a0, 1
+; LP64E-NEXT:    li a1, 2
+; LP64E-NEXT:    li a2, 3
+; LP64E-NEXT:    li a3, 4
+; LP64E-NEXT:    li a4, 5
+; LP64E-NEXT:    sd a6, 0(sp)
+; LP64E-NEXT:    sd zero, 8(sp)
+; LP64E-NEXT:    sd a5, 16(sp)
+; LP64E-NEXT:    call va_i128
+; LP64E-NEXT:    addi sp, s0, -48
+; LP64E-NEXT:    .cfi_def_cfa sp, 48
+; LP64E-NEXT:    ld ra, 40(sp) # 8-byte Folded Reload
+; LP64E-NEXT:    ld s0, 32(sp) # 8-byte Folded Reload
+; LP64E-NEXT:    .cfi_restore ra
+; LP64E-NEXT:    .cfi_restore s0
+; LP64E-NEXT:    addi sp, sp, 48
+; LP64E-NEXT:    .cfi_def_cfa_offset 0
+; LP64E-NEXT:    ret
+;
+; LP64E-WITHFP-LABEL: caller_i128_split_stack:
+; LP64E-WITHFP:       # %bb.0: # %entry
+; LP64E-WITHFP-NEXT:    addi sp, sp, -48
+; LP64E-WITHFP-NEXT:    .cfi_def_cfa_offset 48
+; LP64E-WITHFP-NEXT:    sd ra, 40(sp) # 8-byte Folded Spill
+; LP64E-WITHFP-NEXT:    sd s0, 32(sp) # 8-byte Folded Spill
+; LP64E-WITHFP-NEXT:    .cfi_offset ra, -8
+; LP64E-WITHFP-NEXT:    .cfi_offset s0, -16
+; LP64E-WITHFP-NEXT:    addi s0, sp, 48
+; LP64E-WITHFP-NEXT:    .cfi_def_cfa s0, 0
+; LP64E-WITHFP-NEXT:    andi sp, sp, -16
+; LP64E-WITHFP-NEXT:    li a5, 7
+; LP64E-WITHFP-NEXT:    li a6, 6
+; LP64E-WITHFP-NEXT:    li a0, 1
+; LP64E-WITHFP-NEXT:    li a1, 2
+; LP64E-WITHFP-NEXT:    li a2, 3
+; LP64E-WITHFP-NEXT:    li a3, 4
+; LP64E-WITHFP-NEXT:    li a4, 5
+; LP64E-WITHFP-NEXT:    sd a6, 0(sp)
+; LP64E-WITHFP-NEXT:    sd zero, 8(sp)
+; LP64E-WITHFP-NEXT:    sd a5, 16(sp)
+; LP64E-WITHFP-NEXT:    call va_i128
+; LP64E-WITHFP-NEXT:    addi sp, s0, -48
+; LP64E-WITHFP-NEXT:    .cfi_def_cfa sp, 48
+; LP64E-WITHFP-NEXT:    ld ra, 40(sp) # 8-byte Folded Reload
+; LP64E-WITHFP-NEXT:    ld s0, 32(sp) # 8-byte Folded Reload
+; LP64E-WITHFP-NEXT:    .cfi_restore ra
+; LP64E-WITHFP-NEXT:    .cfi_restore s0
+; LP64E-WITHFP-NEXT:    addi sp, sp, 48
+; LP64E-WITHFP-NEXT:    .cfi_def_cfa_offset 0
+; LP64E-WITHFP-NEXT:    ret
+entry:
+  call void (i32, ...) @va_i128(i32 1, i32 2, i32 3, i32 4, i32 5, i128 6, i32 7)
+  ret void
+}
+
+; The i128 is passed on the stack at an 8-byte aligned offset.
+define void @caller_i128_on_stack() {
+; LP64E-LABEL: caller_i128_on_stack:
+; LP64E:       # %bb.0: # %entry
+; LP64E-NEXT:    addi sp, sp, -48
+; LP64E-NEXT:    .cfi_def_cfa_offset 48
+; LP64E-NEXT:    sd ra, 40(sp) # 8-byte Folded Spill
+; LP64E-NEXT:    sd s0, 32(sp) # 8-byte Folded Spill
+; LP64E-NEXT:    .cfi_offset ra, -8
+; LP64E-NEXT:    .cfi_offset s0, -16
+; LP64E-NEXT:    addi s0, sp, 48
+; LP64E-NEXT:    .cfi_def_cfa s0, 0
+; LP64E-NEXT:    andi sp, sp, -16
+; LP64E-NEXT:    li a6, 8
+; LP64E-NEXT:    li a7, 7
+; LP64E-NEXT:    li a0, 1
+; LP64E-NEXT:    li a1, 2
+; LP64E-NEXT:    li a2, 3
+; LP64E-NEXT:    li a3, 4
+; LP64E-NEXT:    li a4, 5
+; LP64E-NEXT:    li a5, 6
+; LP64E-NEXT:    sd a7, 0(sp)
+; LP64E-NEXT:    sd a6, 16(sp)
+; LP64E-NEXT:    sd zero, 24(sp)
+; LP64E-NEXT:    call va_i128
+; LP64E-NEXT:    addi sp, s0, -48
+; LP64E-NEXT:    .cfi_def_cfa sp, 48
+; LP64E-NEXT:    ld ra, 40(sp) # 8-byte Folded Reload
+; LP64E-NEXT:    ld s0, 32(sp) # 8-byte Folded Reload
+; LP64E-NEXT:    .cfi_restore ra
+; LP64E-NEXT:    .cfi_restore s0
+; LP64E-NEXT:    addi sp, sp, 48
+; LP64E-NEXT:    .cfi_def_cfa_offset 0
+; LP64E-NEXT:    ret
+;
+; LP64E-WITHFP-LABEL: caller_i128_on_stack:
+; LP64E-WITHFP:       # %bb.0: # %entry
+; LP64E-WITHFP-NEXT:    addi sp, sp, -48
+; LP64E-WITHFP-NEXT:    .cfi_def_cfa_offset 48
+; LP64E-WITHFP-NEXT:    sd ra, 40(sp) # 8-byte Folded Spill
+; LP64E-WITHFP-NEXT:    sd s0, 32(sp) # 8-byte Folded Spill
+; LP64E-WITHFP-NEXT:    .cfi_offset ra, -8
+; LP64E-WITHFP-NEXT:    .cfi_offset s0, -16
+; LP64E-WITHFP-NEXT:    addi s0, sp, 48
+; LP64E-WITHFP-NEXT:    .cfi_def_cfa s0, 0
+; LP64E-WITHFP-NEXT:    andi sp, sp, -16
+; LP64E-WITHFP-NEXT:    li a6, 8
+; LP64E-WITHFP-NEXT:    li a7, 7
+; LP64E-WITHFP-NEXT:    li a0, 1
+; LP64E-WITHFP-NEXT:    li a1, 2
+; LP64E-WITHFP-NEXT:    li a2, 3
+; LP64E-WITHFP-NEXT:    li a3, 4
+; LP64E-WITHFP-NEXT:    li a4, 5
+; LP64E-WITHFP-NEXT:    li a5, 6
+; LP64E-WITHFP-NEXT:    sd a7, 0(sp)
+; LP64E-WITHFP-NEXT:    sd a6, 16(sp)
+; LP64E-WITHFP-NEXT:    sd zero, 24(sp)
+; LP64E-WITHFP-NEXT:    call va_i128
+; LP64E-WITHFP-NEXT:    addi sp, s0, -48
+; LP64E-WITHFP-NEXT:    .cfi_def_cfa sp, 48
+; LP64E-WITHFP-NEXT:    ld ra, 40(sp) # 8-byte Folded Reload
+; LP64E-WITHFP-NEXT:    ld s0, 32(sp) # 8-byte Folded Reload
+; LP64E-WITHFP-NEXT:    .cfi_restore ra
+; LP64E-WITHFP-NEXT:    .cfi_restore s0
+; LP64E-WITHFP-NEXT:    addi sp, sp, 48
+; LP64E-WITHFP-NEXT:    .cfi_def_cfa_offset 0
+; LP64E-WITHFP-NEXT:    ret
+entry:
+  call void (i32, ...) @va_i128(i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i128 8)
+  ret void
+}
+
+; The callee reads the i128 from a slot that is only 8-byte aligned.
+define i64 @va_i128(i32 %n, ...) {
+; LP64E-LABEL: va_i128:
+; LP64E:       # %bb.0: # %entry
+; LP64E-NEXT:    addi sp, sp, -56
+; LP64E-NEXT:    .cfi_def_cfa_offset 56
+; LP64E-NEXT:    mv a0, a1
+; LP64E-NEXT:    sd a5, 48(sp)
+; LP64E-NEXT:    sd a1, 16(sp)
+; LP64E-NEXT:    sd a2, 24(sp)
+; LP64E-NEXT:    sd a3, 32(sp)
+; LP64E-NEXT:    addi a1, sp, 32
+; LP64E-NEXT:    sd a4, 40(sp)
+; LP64E-NEXT:    sd a1, 0(sp)
+; LP64E-NEXT:    addi sp, sp, 56
+; LP64E-NEXT:    .cfi_def_cfa_offset 0
+; LP64E-NEXT:    ret
+;
+; LP64E-WITHFP-LABEL: va_i128:
+; LP64E-WITHFP:       # %bb.0: # %entry
+; LP64E-WITHFP-NEXT:    addi sp, sp, -72
+; LP64E-WITHFP-NEXT:    .cfi_def_cfa_offset 72
+; LP64E-WITHFP-NEXT:    sd ra, 16(sp) # 8-byte Folded Spill
+; LP64E-WITHFP-NEXT:    sd s0, 8(sp) # 8-byte Folded Spill
+; LP64E-WITHFP-NEXT:    .cfi_offset ra, -56
+; LP64E-WITHFP-NEXT:    .cfi_offset s0, -64
+; LP64E-WITHFP-NEXT:    addi s0, sp, 24
+; LP64E-WITHFP-NEXT:    .cfi_def_cfa s0, 48
+; LP64E-WITHFP-NEXT:    mv a0, a1
+; LP64E-WITHFP-NEXT:    sd a5, 64(sp)
+; LP64E-WITHFP-NEXT:    sd a1, 32(sp)
+; LP64E-WITHFP-NEXT:    sd a2, 40(sp)
+; LP64E-WITHFP-NEXT:    sd a3, 48(sp)
+; LP64E-WITHFP-NEXT:    addi a1, sp, 48
+; LP64E-WITHFP-NEXT:    sd a4, 56(sp)
+; LP64E-WITHFP-NEXT:    sd a1, 0(sp)
+; LP64E-WITHFP-NEXT:    .cfi_def_cfa sp, 72
+; LP64E-WITHFP-NEXT:    ld ra, 16(sp) # 8-byte Folded Reload
+; LP64E-WITHFP-NEXT:    ld s0, 8(sp) # 8-byte Folded Reload
+; LP64E-WITHFP-NEXT:    .cfi_restore ra
+; LP64E-WITHFP-NEXT:    .cfi_restore s0
+; LP64E-WITHFP-NEXT:    addi sp, sp, 72
+; LP64E-WITHFP-NEXT:    .cfi_def_cfa_offset 0
+; LP64E-WITHFP-NEXT:    ret
+entry:
+  %args = alloca ptr, align 8
+  call void @llvm.va_start(ptr %args)
+  %argp.cur = load ptr, ptr %args, align 8
+  %argp.next = getelementptr inbounds i8, ptr %argp.cur, i64 16
+  store ptr %argp.next, ptr %args, align 8
+  %v = load i128, ptr %argp.cur, align 8
+  call void @llvm.va_end(ptr %args)
+  %t = trunc i128 %v to i64
+  ret i64 %t
+}

>From 2e5c6226481b8bb5d36ee078a79b7ad808ee3839 Mon Sep 17 00:00:00 2001
From: Craig Topper <craig.topper at sifive.com>
Date: Fri, 6 Nov 2026 18:05:46 -0800
Subject: [PATCH 2/2] [RISCV] Sync the LP64E i128 vararg and stack argument
 behavior with gcc.

i128 arguments to variadic functions are not passed in aligned pairs for LP64E.
The stack locations for i128 arguments are not 16 byte aligned.

In the backend, rather than checking for RVE directly, use the ABI stack
alignment to clamp the type alignment which is where gcc's behavior comes from.

Assisted-by: Claude
---
 clang/docs/ReleaseNotes.md                    |   2 +
 clang/lib/CodeGen/Targets/RISCV.cpp           |  11 +-
 clang/test/CodeGen/RISCV/riscv64-vararg.c     | 161 ++++++++++++------
 llvm/docs/ReleaseNotes.md                     |   1 +
 llvm/lib/Target/RISCV/RISCVCallingConv.cpp    |  26 +--
 llvm/test/CodeGen/RISCV/calling-conv-lp64e.ll | 100 ++++-------
 llvm/test/CodeGen/RISCV/vararg-lp64e.ll       | 116 +++++--------
 7 files changed, 205 insertions(+), 212 deletions(-)

diff --git a/clang/docs/ReleaseNotes.md b/clang/docs/ReleaseNotes.md
index e6e84323ca73f1..284b37965dc576 100644
--- a/clang/docs/ReleaseNotes.md
+++ b/clang/docs/ReleaseNotes.md
@@ -1379,6 +1379,8 @@ documentation](CIR/index.md) for more information regarding ClangIR's status and
   `-mcpu` is present, the ISA will be selected from the host CPU and the tune
   CPU will be selected from `-mcpu`.
 
+- The handling of __int128 arguments with the LP64E ABI now matches gcc.
+
 #### CUDA/HIP Language Changes
 
 - HIP compilations now add the `include/libhipcxx` directory from the selected
diff --git a/clang/lib/CodeGen/Targets/RISCV.cpp b/clang/lib/CodeGen/Targets/RISCV.cpp
index 4a2e268d2bcb05..96dad3d044c05f 100644
--- a/clang/lib/CodeGen/Targets/RISCV.cpp
+++ b/clang/lib/CodeGen/Targets/RISCV.cpp
@@ -813,7 +813,7 @@ ABIArgInfo RISCVABIInfo::classifyArgumentType(QualType Ty, bool IsFixed,
   // changed when RV32E/ILP32E is ratified.
   int NeededArgGPRs = 1;
   if (!IsFixed && NeededAlign == 2 * XLen)
-    NeededArgGPRs = 2 + (EABI && XLen == 32 ? 0 : (ArgGPRsLeft % 2));
+    NeededArgGPRs = 2 + (EABI ? 0 : (ArgGPRsLeft % 2));
   else if (Size > XLen && Size <= 2 * XLen)
     NeededArgGPRs = 2;
 
@@ -909,10 +909,11 @@ RValue RISCVABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
 
   // TODO: To be compatible with GCC's behaviors, we force arguments with
   // 2×XLEN-bit alignment and size at most 2×XLEN bits like `long long`,
-  // `unsigned long long` and `double` to have 4-byte alignment. This
-  // behavior may be changed when RV32E/ILP32E is ratified.
-  if (EABI && XLen == 32)
-    TInfo.Align = std::min(TInfo.Align, CharUnits::fromQuantity(4));
+  // `unsigned long long`, `double` and `__int128` to have XLEN-byte alignment
+  // for ILP32E and LP64E. This behavior may be changed when RV32E/ILP32E is
+  // ratified.
+  if (EABI)
+    TInfo.Align = std::min(TInfo.Align, SlotSize);
 
   // Arguments bigger than 2*Xlen bytes are passed indirectly.
   bool IsIndirect = TInfo.Width > 2 * SlotSize;
diff --git a/clang/test/CodeGen/RISCV/riscv64-vararg.c b/clang/test/CodeGen/RISCV/riscv64-vararg.c
index e042ce7cafbba2..f11ee97072535d 100644
--- a/clang/test/CodeGen/RISCV/riscv64-vararg.c
+++ b/clang/test/CodeGen/RISCV/riscv64-vararg.c
@@ -1,11 +1,12 @@
 // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 2
-// RUN: %clang_cc1 -triple riscv64 -emit-llvm %s -o - | FileCheck %s
+// RUN: %clang_cc1 -triple riscv64 -emit-llvm %s -o - \
+// RUN:     | FileCheck %s -check-prefixes=CHECK,CHECK-LP64
 // RUN: %clang_cc1 -triple riscv64 -target-feature +f -target-abi lp64f -emit-llvm %s -o - \
-// RUN:     | FileCheck %s
+// RUN:     | FileCheck %s -check-prefixes=CHECK,CHECK-LP64
 // RUN: %clang_cc1 -triple riscv64 -target-feature +d -target-feature +f -target-abi lp64d -emit-llvm %s -o - \
-// RUN:     | FileCheck %s
+// RUN:     | FileCheck %s -check-prefixes=CHECK,CHECK-LP64
 // RUN: %clang_cc1 -triple riscv64 -target-abi lp64e -emit-llvm %s -o - \
-// RUN:     | FileCheck %s
+// RUN:     | FileCheck %s -check-prefixes=CHECK,CHECK-LP64E
 
 #include <stddef.h>
 #include <stdint.h>
@@ -159,24 +160,41 @@ int f_va_1(char *fmt, ...) {
 // used to pass varargs with 2x xlen alignment and 2x xlen size. Ensure the
 // correct offsets are used.
 
-// CHECK-LABEL: define dso_local fp128 @f_va_2
-// CHECK-SAME: (ptr noundef [[FMT:%.*]], ...) #[[ATTR0]] {
-// CHECK-NEXT:  entry:
-// CHECK-NEXT:    [[FMT_ADDR:%.*]] = alloca ptr, align 8
-// CHECK-NEXT:    [[VA:%.*]] = alloca ptr, align 8
-// CHECK-NEXT:    [[V:%.*]] = alloca fp128, align 16
-// CHECK-NEXT:    store ptr [[FMT]], ptr [[FMT_ADDR]], align 8
-// CHECK-NEXT:    call void @llvm.va_start.p0(ptr [[VA]])
-// CHECK-NEXT:    [[ARGP_CUR:%.*]] = load ptr, ptr [[VA]], align 8
-// CHECK-NEXT:    [[TMP0:%.*]] = getelementptr inbounds i8, ptr [[ARGP_CUR]], i32 15
-// CHECK-NEXT:    [[ARGP_CUR_ALIGNED:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr [[TMP0]], i64 -16)
-// CHECK-NEXT:    [[ARGP_NEXT:%.*]] = getelementptr inbounds i8, ptr [[ARGP_CUR_ALIGNED]], i64 16
-// CHECK-NEXT:    store ptr [[ARGP_NEXT]], ptr [[VA]], align 8
-// CHECK-NEXT:    [[TMP1:%.*]] = load fp128, ptr [[ARGP_CUR_ALIGNED]], align 16
-// CHECK-NEXT:    store fp128 [[TMP1]], ptr [[V]], align 16
-// CHECK-NEXT:    call void @llvm.va_end.p0(ptr [[VA]])
-// CHECK-NEXT:    [[TMP2:%.*]] = load fp128, ptr [[V]], align 16
-// CHECK-NEXT:    ret fp128 [[TMP2]]
+// CHECK-LP64-LABEL: define dso_local fp128 @f_va_2
+// CHECK-LP64-SAME: (ptr noundef [[FMT:%.*]], ...) #[[ATTR0]] {
+// CHECK-LP64-NEXT:  entry:
+// CHECK-LP64-NEXT:    [[FMT_ADDR:%.*]] = alloca ptr, align 8
+// CHECK-LP64-NEXT:    [[VA:%.*]] = alloca ptr, align 8
+// CHECK-LP64-NEXT:    [[V:%.*]] = alloca fp128, align 16
+// CHECK-LP64-NEXT:    store ptr [[FMT]], ptr [[FMT_ADDR]], align 8
+// CHECK-LP64-NEXT:    call void @llvm.va_start.p0(ptr [[VA]])
+// CHECK-LP64-NEXT:    [[ARGP_CUR:%.*]] = load ptr, ptr [[VA]], align 8
+// CHECK-LP64-NEXT:    [[TMP0:%.*]] = getelementptr inbounds i8, ptr [[ARGP_CUR]], i32 15
+// CHECK-LP64-NEXT:    [[ARGP_CUR_ALIGNED:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr [[TMP0]], i64 -16)
+// CHECK-LP64-NEXT:    [[ARGP_NEXT:%.*]] = getelementptr inbounds i8, ptr [[ARGP_CUR_ALIGNED]], i64 16
+// CHECK-LP64-NEXT:    store ptr [[ARGP_NEXT]], ptr [[VA]], align 8
+// CHECK-LP64-NEXT:    [[TMP1:%.*]] = load fp128, ptr [[ARGP_CUR_ALIGNED]], align 16
+// CHECK-LP64-NEXT:    store fp128 [[TMP1]], ptr [[V]], align 16
+// CHECK-LP64-NEXT:    call void @llvm.va_end.p0(ptr [[VA]])
+// CHECK-LP64-NEXT:    [[TMP2:%.*]] = load fp128, ptr [[V]], align 16
+// CHECK-LP64-NEXT:    ret fp128 [[TMP2]]
+//
+// CHECK-LP64E-LABEL: define dso_local fp128 @f_va_2
+// CHECK-LP64E-SAME: (ptr noundef [[FMT:%.*]], ...) #[[ATTR0]] {
+// CHECK-LP64E-NEXT:  entry:
+// CHECK-LP64E-NEXT:    [[FMT_ADDR:%.*]] = alloca ptr, align 8
+// CHECK-LP64E-NEXT:    [[VA:%.*]] = alloca ptr, align 8
+// CHECK-LP64E-NEXT:    [[V:%.*]] = alloca fp128, align 16
+// CHECK-LP64E-NEXT:    store ptr [[FMT]], ptr [[FMT_ADDR]], align 8
+// CHECK-LP64E-NEXT:    call void @llvm.va_start.p0(ptr [[VA]])
+// CHECK-LP64E-NEXT:    [[ARGP_CUR:%.*]] = load ptr, ptr [[VA]], align 8
+// CHECK-LP64E-NEXT:    [[ARGP_NEXT:%.*]] = getelementptr inbounds i8, ptr [[ARGP_CUR]], i64 16
+// CHECK-LP64E-NEXT:    store ptr [[ARGP_NEXT]], ptr [[VA]], align 8
+// CHECK-LP64E-NEXT:    [[TMP0:%.*]] = load fp128, ptr [[ARGP_CUR]], align 8
+// CHECK-LP64E-NEXT:    store fp128 [[TMP0]], ptr [[V]], align 16
+// CHECK-LP64E-NEXT:    call void @llvm.va_end.p0(ptr [[VA]])
+// CHECK-LP64E-NEXT:    [[TMP1:%.*]] = load fp128, ptr [[V]], align 16
+// CHECK-LP64E-NEXT:    ret fp128 [[TMP1]]
 //
 long double f_va_2(char *fmt, ...) {
   __builtin_va_list va;
@@ -190,40 +208,71 @@ long double f_va_2(char *fmt, ...) {
 
 // Two "aligned" register pairs.
 
-// CHECK-LABEL: define dso_local fp128 @f_va_3
-// CHECK-SAME: (ptr noundef [[FMT:%.*]], ...) #[[ATTR0]] {
-// CHECK-NEXT:  entry:
-// CHECK-NEXT:    [[FMT_ADDR:%.*]] = alloca ptr, align 8
-// CHECK-NEXT:    [[VA:%.*]] = alloca ptr, align 8
-// CHECK-NEXT:    [[V:%.*]] = alloca fp128, align 16
-// CHECK-NEXT:    [[W:%.*]] = alloca i32, align 4
-// CHECK-NEXT:    [[X:%.*]] = alloca fp128, align 16
-// CHECK-NEXT:    store ptr [[FMT]], ptr [[FMT_ADDR]], align 8
-// CHECK-NEXT:    call void @llvm.va_start.p0(ptr [[VA]])
-// CHECK-NEXT:    [[ARGP_CUR:%.*]] = load ptr, ptr [[VA]], align 8
-// CHECK-NEXT:    [[TMP0:%.*]] = getelementptr inbounds i8, ptr [[ARGP_CUR]], i32 15
-// CHECK-NEXT:    [[ARGP_CUR_ALIGNED:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr [[TMP0]], i64 -16)
-// CHECK-NEXT:    [[ARGP_NEXT:%.*]] = getelementptr inbounds i8, ptr [[ARGP_CUR_ALIGNED]], i64 16
-// CHECK-NEXT:    store ptr [[ARGP_NEXT]], ptr [[VA]], align 8
-// CHECK-NEXT:    [[TMP1:%.*]] = load fp128, ptr [[ARGP_CUR_ALIGNED]], align 16
-// CHECK-NEXT:    store fp128 [[TMP1]], ptr [[V]], align 16
-// CHECK-NEXT:    [[ARGP_CUR1:%.*]] = load ptr, ptr [[VA]], align 8
-// CHECK-NEXT:    [[ARGP_NEXT2:%.*]] = getelementptr inbounds i8, ptr [[ARGP_CUR1]], i64 8
-// CHECK-NEXT:    store ptr [[ARGP_NEXT2]], ptr [[VA]], align 8
-// CHECK-NEXT:    [[TMP2:%.*]] = load i32, ptr [[ARGP_CUR1]], align 8
-// CHECK-NEXT:    store i32 [[TMP2]], ptr [[W]], align 4
-// CHECK-NEXT:    [[ARGP_CUR3:%.*]] = load ptr, ptr [[VA]], align 8
-// CHECK-NEXT:    [[TMP3:%.*]] = getelementptr inbounds i8, ptr [[ARGP_CUR3]], i32 15
-// CHECK-NEXT:    [[ARGP_CUR3_ALIGNED:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr [[TMP3]], i64 -16)
-// CHECK-NEXT:    [[ARGP_NEXT4:%.*]] = getelementptr inbounds i8, ptr [[ARGP_CUR3_ALIGNED]], i64 16
-// CHECK-NEXT:    store ptr [[ARGP_NEXT4]], ptr [[VA]], align 8
-// CHECK-NEXT:    [[TMP4:%.*]] = load fp128, ptr [[ARGP_CUR3_ALIGNED]], align 16
-// CHECK-NEXT:    store fp128 [[TMP4]], ptr [[X]], align 16
-// CHECK-NEXT:    call void @llvm.va_end.p0(ptr [[VA]])
-// CHECK-NEXT:    [[TMP5:%.*]] = load fp128, ptr [[V]], align 16
-// CHECK-NEXT:    [[TMP6:%.*]] = load fp128, ptr [[X]], align 16
-// CHECK-NEXT:    [[ADD:%.*]] = fadd fp128 [[TMP5]], [[TMP6]]
-// CHECK-NEXT:    ret fp128 [[ADD]]
+// CHECK-LP64-LABEL: define dso_local fp128 @f_va_3
+// CHECK-LP64-SAME: (ptr noundef [[FMT:%.*]], ...) #[[ATTR0]] {
+// CHECK-LP64-NEXT:  entry:
+// CHECK-LP64-NEXT:    [[FMT_ADDR:%.*]] = alloca ptr, align 8
+// CHECK-LP64-NEXT:    [[VA:%.*]] = alloca ptr, align 8
+// CHECK-LP64-NEXT:    [[V:%.*]] = alloca fp128, align 16
+// CHECK-LP64-NEXT:    [[W:%.*]] = alloca i32, align 4
+// CHECK-LP64-NEXT:    [[X:%.*]] = alloca fp128, align 16
+// CHECK-LP64-NEXT:    store ptr [[FMT]], ptr [[FMT_ADDR]], align 8
+// CHECK-LP64-NEXT:    call void @llvm.va_start.p0(ptr [[VA]])
+// CHECK-LP64-NEXT:    [[ARGP_CUR:%.*]] = load ptr, ptr [[VA]], align 8
+// CHECK-LP64-NEXT:    [[TMP0:%.*]] = getelementptr inbounds i8, ptr [[ARGP_CUR]], i32 15
+// CHECK-LP64-NEXT:    [[ARGP_CUR_ALIGNED:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr [[TMP0]], i64 -16)
+// CHECK-LP64-NEXT:    [[ARGP_NEXT:%.*]] = getelementptr inbounds i8, ptr [[ARGP_CUR_ALIGNED]], i64 16
+// CHECK-LP64-NEXT:    store ptr [[ARGP_NEXT]], ptr [[VA]], align 8
+// CHECK-LP64-NEXT:    [[TMP1:%.*]] = load fp128, ptr [[ARGP_CUR_ALIGNED]], align 16
+// CHECK-LP64-NEXT:    store fp128 [[TMP1]], ptr [[V]], align 16
+// CHECK-LP64-NEXT:    [[ARGP_CUR1:%.*]] = load ptr, ptr [[VA]], align 8
+// CHECK-LP64-NEXT:    [[ARGP_NEXT2:%.*]] = getelementptr inbounds i8, ptr [[ARGP_CUR1]], i64 8
+// CHECK-LP64-NEXT:    store ptr [[ARGP_NEXT2]], ptr [[VA]], align 8
+// CHECK-LP64-NEXT:    [[TMP2:%.*]] = load i32, ptr [[ARGP_CUR1]], align 8
+// CHECK-LP64-NEXT:    store i32 [[TMP2]], ptr [[W]], align 4
+// CHECK-LP64-NEXT:    [[ARGP_CUR3:%.*]] = load ptr, ptr [[VA]], align 8
+// CHECK-LP64-NEXT:    [[TMP3:%.*]] = getelementptr inbounds i8, ptr [[ARGP_CUR3]], i32 15
+// CHECK-LP64-NEXT:    [[ARGP_CUR3_ALIGNED:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr [[TMP3]], i64 -16)
+// CHECK-LP64-NEXT:    [[ARGP_NEXT4:%.*]] = getelementptr inbounds i8, ptr [[ARGP_CUR3_ALIGNED]], i64 16
+// CHECK-LP64-NEXT:    store ptr [[ARGP_NEXT4]], ptr [[VA]], align 8
+// CHECK-LP64-NEXT:    [[TMP4:%.*]] = load fp128, ptr [[ARGP_CUR3_ALIGNED]], align 16
+// CHECK-LP64-NEXT:    store fp128 [[TMP4]], ptr [[X]], align 16
+// CHECK-LP64-NEXT:    call void @llvm.va_end.p0(ptr [[VA]])
+// CHECK-LP64-NEXT:    [[TMP5:%.*]] = load fp128, ptr [[V]], align 16
+// CHECK-LP64-NEXT:    [[TMP6:%.*]] = load fp128, ptr [[X]], align 16
+// CHECK-LP64-NEXT:    [[ADD:%.*]] = fadd fp128 [[TMP5]], [[TMP6]]
+// CHECK-LP64-NEXT:    ret fp128 [[ADD]]
+//
+// CHECK-LP64E-LABEL: define dso_local fp128 @f_va_3
+// CHECK-LP64E-SAME: (ptr noundef [[FMT:%.*]], ...) #[[ATTR0]] {
+// CHECK-LP64E-NEXT:  entry:
+// CHECK-LP64E-NEXT:    [[FMT_ADDR:%.*]] = alloca ptr, align 8
+// CHECK-LP64E-NEXT:    [[VA:%.*]] = alloca ptr, align 8
+// CHECK-LP64E-NEXT:    [[V:%.*]] = alloca fp128, align 16
+// CHECK-LP64E-NEXT:    [[W:%.*]] = alloca i32, align 4
+// CHECK-LP64E-NEXT:    [[X:%.*]] = alloca fp128, align 16
+// CHECK-LP64E-NEXT:    store ptr [[FMT]], ptr [[FMT_ADDR]], align 8
+// CHECK-LP64E-NEXT:    call void @llvm.va_start.p0(ptr [[VA]])
+// CHECK-LP64E-NEXT:    [[ARGP_CUR:%.*]] = load ptr, ptr [[VA]], align 8
+// CHECK-LP64E-NEXT:    [[ARGP_NEXT:%.*]] = getelementptr inbounds i8, ptr [[ARGP_CUR]], i64 16
+// CHECK-LP64E-NEXT:    store ptr [[ARGP_NEXT]], ptr [[VA]], align 8
+// CHECK-LP64E-NEXT:    [[TMP0:%.*]] = load fp128, ptr [[ARGP_CUR]], align 8
+// CHECK-LP64E-NEXT:    store fp128 [[TMP0]], ptr [[V]], align 16
+// CHECK-LP64E-NEXT:    [[ARGP_CUR1:%.*]] = load ptr, ptr [[VA]], align 8
+// CHECK-LP64E-NEXT:    [[ARGP_NEXT2:%.*]] = getelementptr inbounds i8, ptr [[ARGP_CUR1]], i64 8
+// CHECK-LP64E-NEXT:    store ptr [[ARGP_NEXT2]], ptr [[VA]], align 8
+// CHECK-LP64E-NEXT:    [[TMP1:%.*]] = load i32, ptr [[ARGP_CUR1]], align 8
+// CHECK-LP64E-NEXT:    store i32 [[TMP1]], ptr [[W]], align 4
+// CHECK-LP64E-NEXT:    [[ARGP_CUR3:%.*]] = load ptr, ptr [[VA]], align 8
+// CHECK-LP64E-NEXT:    [[ARGP_NEXT4:%.*]] = getelementptr inbounds i8, ptr [[ARGP_CUR3]], i64 16
+// CHECK-LP64E-NEXT:    store ptr [[ARGP_NEXT4]], ptr [[VA]], align 8
+// CHECK-LP64E-NEXT:    [[TMP2:%.*]] = load fp128, ptr [[ARGP_CUR3]], align 8
+// CHECK-LP64E-NEXT:    store fp128 [[TMP2]], ptr [[X]], align 16
+// CHECK-LP64E-NEXT:    call void @llvm.va_end.p0(ptr [[VA]])
+// CHECK-LP64E-NEXT:    [[TMP3:%.*]] = load fp128, ptr [[V]], align 16
+// CHECK-LP64E-NEXT:    [[TMP4:%.*]] = load fp128, ptr [[X]], align 16
+// CHECK-LP64E-NEXT:    [[ADD:%.*]] = fadd fp128 [[TMP3]], [[TMP4]]
+// CHECK-LP64E-NEXT:    ret fp128 [[ADD]]
 //
 long double f_va_3(char *fmt, ...) {
   __builtin_va_list va;
diff --git a/llvm/docs/ReleaseNotes.md b/llvm/docs/ReleaseNotes.md
index 089483134ec231..c626720b05e526 100644
--- a/llvm/docs/ReleaseNotes.md
+++ b/llvm/docs/ReleaseNotes.md
@@ -399,6 +399,7 @@ Makes programs 10x faster by doing Special New Thing.
   global variant of Ascalon X without `Zvkng` and with reduced vector FP64
   throughput.
 * Removed X5 from the preserve_most register list.
+* The behavior of i128 arguments with the LP64E ABI now matches gcc.
 
 ### Changes to the WebAssembly Backend
 
diff --git a/llvm/lib/Target/RISCV/RISCVCallingConv.cpp b/llvm/lib/Target/RISCV/RISCVCallingConv.cpp
index 25572376ead0dc..9a4bf8e3a64235 100644
--- a/llvm/lib/Target/RISCV/RISCVCallingConv.cpp
+++ b/llvm/lib/Target/RISCV/RISCVCallingConv.cpp
@@ -303,8 +303,6 @@ static bool CC_RISCVAssign2XLen(CCState &State, CCValAssign VA1,
                                 const RISCVSubtarget &Subtarget) {
   unsigned XLen = Subtarget.getXLen();
   unsigned XLenInBytes = XLen / 8;
-  RISCVABI::ABI ABI = Subtarget.getTargetABI();
-  bool EABI = RISCVABI::isRVE(ABI);
 
   ArrayRef<MCPhysReg> ArgGPRs = RISCV::getArgGPRs(Subtarget);
 
@@ -314,11 +312,12 @@ static bool CC_RISCVAssign2XLen(CCState &State, CCValAssign VA1,
                                      VA1.getLocVT(), CCValAssign::Full));
   } else {
     // Both halves must be passed on the stack, with proper alignment.
-    // TODO: To be compatible with GCC's behaviors, we force them to have 4-byte
-    // alignment. This behavior may be changed when RV32E/ILP32E is ratified.
-    Align StackAlign(XLenInBytes);
-    if (!EABI || XLen != 32)
-      StackAlign = std::max(StackAlign, ArgFlags1.getNonZeroOrigAlign());
+    // TODO: To be compatible with GCC's behaviors, we clamp the alignment by
+    // the ABI stack alignment. This behavior may be changed when RV32E/ILP32E
+    // is ratified.
+    Align StackAlign =
+        std::min(RISCVABI::getStackAlignment(Subtarget.getTargetABI()),
+                 std::max(Align(XLenInBytes), ArgFlags1.getNonZeroOrigAlign()));
     State.addLoc(
         CCValAssign::getMem(VA1.getValNo(), VA1.getValVT(),
                             State.AllocateStack(XLenInBytes, StackAlign),
@@ -521,13 +520,14 @@ static bool CC_RISCV_Impl(unsigned ValNo, MVT ValVT, MVT LocVT,
   // legalisation or not. The argument will not be passed by registers if the
   // original type is larger than 2*XLEN, so the register alignment rule does
   // not apply.
-  // TODO: To be compatible with GCC's behaviors, we don't align registers
-  // currently if we are using ILP32E calling convention. This behavior may be
-  // changed when RV32E/ILP32E is ratified.
+  // TODO: To be compatible with GCC's behaviors, we clamp the alignment by the
+  // ABI stack alignment, so registers are never aligned for ILP32E/LP64E. This
+  // behavior may be changed when RV32E/ILP32E is ratified.
   unsigned TwoXLenInBytes = (2 * XLen) / 8;
-  if (ArgFlags.isVarArg() && ArgFlags.getNonZeroOrigAlign() == TwoXLenInBytes &&
-      DL.getTypeAllocSize(OrigTy) == TwoXLenInBytes &&
-      ABI != RISCVABI::ABI::ILP32E) {
+  Align ArgAlign = std::min(ArgFlags.getNonZeroOrigAlign(),
+                            RISCVABI::getStackAlignment(ABI));
+  if (ArgFlags.isVarArg() && ArgAlign == TwoXLenInBytes &&
+      DL.getTypeAllocSize(OrigTy) == TwoXLenInBytes) {
     unsigned RegIdx = State.getFirstUnallocated(ArgGPRs);
     // Skip 'odd' register if necessary.
     if (RegIdx != std::size(ArgGPRs) && RegIdx % 2 == 1)
diff --git a/llvm/test/CodeGen/RISCV/calling-conv-lp64e.ll b/llvm/test/CodeGen/RISCV/calling-conv-lp64e.ll
index da26a98499045b..32a9ecebc4ea63 100644
--- a/llvm/test/CodeGen/RISCV/calling-conv-lp64e.ll
+++ b/llvm/test/CodeGen/RISCV/calling-conv-lp64e.ll
@@ -74,16 +74,7 @@ define i64 @caller_float_in_regs() nounwind {
 define i64 @callee_float_on_stack(i128 %a, i128 %b, i128 %c, i128 %d, float %e) nounwind {
 ; RV64I-LP64E-FPELIM-LABEL: callee_float_on_stack:
 ; RV64I-LP64E-FPELIM:       # %bb.0:
-; RV64I-LP64E-FPELIM-NEXT:    addi sp, sp, -16
-; RV64I-LP64E-FPELIM-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
-; RV64I-LP64E-FPELIM-NEXT:    sd s0, 0(sp) # 8-byte Folded Spill
-; RV64I-LP64E-FPELIM-NEXT:    addi s0, sp, 16
-; RV64I-LP64E-FPELIM-NEXT:    andi sp, sp, -16
-; RV64I-LP64E-FPELIM-NEXT:    lw a0, 16(s0)
-; RV64I-LP64E-FPELIM-NEXT:    addi sp, s0, -16
-; RV64I-LP64E-FPELIM-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
-; RV64I-LP64E-FPELIM-NEXT:    ld s0, 0(sp) # 8-byte Folded Reload
-; RV64I-LP64E-FPELIM-NEXT:    addi sp, sp, 16
+; RV64I-LP64E-FPELIM-NEXT:    lw a0, 16(sp)
 ; RV64I-LP64E-FPELIM-NEXT:    ret
 ;
 ; RV64I-LP64E-WITHFP-LABEL: callee_float_on_stack:
@@ -92,9 +83,7 @@ define i64 @callee_float_on_stack(i128 %a, i128 %b, i128 %c, i128 %d, float %e)
 ; RV64I-LP64E-WITHFP-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 ; RV64I-LP64E-WITHFP-NEXT:    sd s0, 0(sp) # 8-byte Folded Spill
 ; RV64I-LP64E-WITHFP-NEXT:    addi s0, sp, 16
-; RV64I-LP64E-WITHFP-NEXT:    andi sp, sp, -16
-; RV64I-LP64E-WITHFP-NEXT:    lw a0, 16(s0)
-; RV64I-LP64E-WITHFP-NEXT:    addi sp, s0, -16
+; RV64I-LP64E-WITHFP-NEXT:    lw a0, 32(sp)
 ; RV64I-LP64E-WITHFP-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 ; RV64I-LP64E-WITHFP-NEXT:    ld s0, 0(sp) # 8-byte Folded Reload
 ; RV64I-LP64E-WITHFP-NEXT:    addi sp, sp, 16
@@ -109,11 +98,8 @@ define i64 @callee_float_on_stack(i128 %a, i128 %b, i128 %c, i128 %d, float %e)
 define i64 @caller_float_on_stack() nounwind {
 ; RV64I-LP64E-FPELIM-LABEL: caller_float_on_stack:
 ; RV64I-LP64E-FPELIM:       # %bb.0:
-; RV64I-LP64E-FPELIM-NEXT:    addi sp, sp, -48
-; RV64I-LP64E-FPELIM-NEXT:    sd ra, 40(sp) # 8-byte Folded Spill
-; RV64I-LP64E-FPELIM-NEXT:    sd s0, 32(sp) # 8-byte Folded Spill
-; RV64I-LP64E-FPELIM-NEXT:    addi s0, sp, 48
-; RV64I-LP64E-FPELIM-NEXT:    andi sp, sp, -16
+; RV64I-LP64E-FPELIM-NEXT:    addi sp, sp, -32
+; RV64I-LP64E-FPELIM-NEXT:    sd ra, 24(sp) # 8-byte Folded Spill
 ; RV64I-LP64E-FPELIM-NEXT:    li a1, 0
 ; RV64I-LP64E-FPELIM-NEXT:    li a3, 0
 ; RV64I-LP64E-FPELIM-NEXT:    li a5, 0
@@ -126,19 +112,16 @@ define i64 @caller_float_on_stack() nounwind {
 ; RV64I-LP64E-FPELIM-NEXT:    sd zero, 8(sp)
 ; RV64I-LP64E-FPELIM-NEXT:    sd a6, 16(sp)
 ; RV64I-LP64E-FPELIM-NEXT:    call callee_float_on_stack
-; RV64I-LP64E-FPELIM-NEXT:    addi sp, s0, -48
-; RV64I-LP64E-FPELIM-NEXT:    ld ra, 40(sp) # 8-byte Folded Reload
-; RV64I-LP64E-FPELIM-NEXT:    ld s0, 32(sp) # 8-byte Folded Reload
-; RV64I-LP64E-FPELIM-NEXT:    addi sp, sp, 48
+; RV64I-LP64E-FPELIM-NEXT:    ld ra, 24(sp) # 8-byte Folded Reload
+; RV64I-LP64E-FPELIM-NEXT:    addi sp, sp, 32
 ; RV64I-LP64E-FPELIM-NEXT:    ret
 ;
 ; RV64I-LP64E-WITHFP-LABEL: caller_float_on_stack:
 ; RV64I-LP64E-WITHFP:       # %bb.0:
-; RV64I-LP64E-WITHFP-NEXT:    addi sp, sp, -48
-; RV64I-LP64E-WITHFP-NEXT:    sd ra, 40(sp) # 8-byte Folded Spill
-; RV64I-LP64E-WITHFP-NEXT:    sd s0, 32(sp) # 8-byte Folded Spill
-; RV64I-LP64E-WITHFP-NEXT:    addi s0, sp, 48
-; RV64I-LP64E-WITHFP-NEXT:    andi sp, sp, -16
+; RV64I-LP64E-WITHFP-NEXT:    addi sp, sp, -40
+; RV64I-LP64E-WITHFP-NEXT:    sd ra, 32(sp) # 8-byte Folded Spill
+; RV64I-LP64E-WITHFP-NEXT:    sd s0, 24(sp) # 8-byte Folded Spill
+; RV64I-LP64E-WITHFP-NEXT:    addi s0, sp, 40
 ; RV64I-LP64E-WITHFP-NEXT:    li a1, 0
 ; RV64I-LP64E-WITHFP-NEXT:    li a3, 0
 ; RV64I-LP64E-WITHFP-NEXT:    li a5, 0
@@ -151,10 +134,9 @@ define i64 @caller_float_on_stack() nounwind {
 ; RV64I-LP64E-WITHFP-NEXT:    sd zero, 8(sp)
 ; RV64I-LP64E-WITHFP-NEXT:    sd a6, 16(sp)
 ; RV64I-LP64E-WITHFP-NEXT:    call callee_float_on_stack
-; RV64I-LP64E-WITHFP-NEXT:    addi sp, s0, -48
-; RV64I-LP64E-WITHFP-NEXT:    ld ra, 40(sp) # 8-byte Folded Reload
-; RV64I-LP64E-WITHFP-NEXT:    ld s0, 32(sp) # 8-byte Folded Reload
-; RV64I-LP64E-WITHFP-NEXT:    addi sp, sp, 48
+; RV64I-LP64E-WITHFP-NEXT:    ld ra, 32(sp) # 8-byte Folded Reload
+; RV64I-LP64E-WITHFP-NEXT:    ld s0, 24(sp) # 8-byte Folded Reload
+; RV64I-LP64E-WITHFP-NEXT:    addi sp, sp, 40
 ; RV64I-LP64E-WITHFP-NEXT:    ret
   %1 = call i64 @callee_float_on_stack(i128 1, i128 2, i128 3, i128 4, float 5.0)
   ret i64 %1
@@ -346,18 +328,9 @@ define i64 @caller_i128_split() nounwind {
 define i64 @callee_i128_on_stack(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e, i32 %f, i32 %g, i128 %h) nounwind {
 ; RV64I-LP64E-FPELIM-LABEL: callee_i128_on_stack:
 ; RV64I-LP64E-FPELIM:       # %bb.0:
-; RV64I-LP64E-FPELIM-NEXT:    addi sp, sp, -16
-; RV64I-LP64E-FPELIM-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
-; RV64I-LP64E-FPELIM-NEXT:    sd s0, 0(sp) # 8-byte Folded Spill
-; RV64I-LP64E-FPELIM-NEXT:    addi s0, sp, 16
-; RV64I-LP64E-FPELIM-NEXT:    andi sp, sp, -16
-; RV64I-LP64E-FPELIM-NEXT:    lwu a0, 0(s0)
-; RV64I-LP64E-FPELIM-NEXT:    ld a1, 16(s0)
+; RV64I-LP64E-FPELIM-NEXT:    lwu a0, 0(sp)
+; RV64I-LP64E-FPELIM-NEXT:    ld a1, 8(sp)
 ; RV64I-LP64E-FPELIM-NEXT:    add a0, a1, a0
-; RV64I-LP64E-FPELIM-NEXT:    addi sp, s0, -16
-; RV64I-LP64E-FPELIM-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
-; RV64I-LP64E-FPELIM-NEXT:    ld s0, 0(sp) # 8-byte Folded Reload
-; RV64I-LP64E-FPELIM-NEXT:    addi sp, sp, 16
 ; RV64I-LP64E-FPELIM-NEXT:    ret
 ;
 ; RV64I-LP64E-WITHFP-LABEL: callee_i128_on_stack:
@@ -366,11 +339,9 @@ define i64 @callee_i128_on_stack(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e, i32 %f,
 ; RV64I-LP64E-WITHFP-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 ; RV64I-LP64E-WITHFP-NEXT:    sd s0, 0(sp) # 8-byte Folded Spill
 ; RV64I-LP64E-WITHFP-NEXT:    addi s0, sp, 16
-; RV64I-LP64E-WITHFP-NEXT:    andi sp, sp, -16
-; RV64I-LP64E-WITHFP-NEXT:    lwu a0, 0(s0)
-; RV64I-LP64E-WITHFP-NEXT:    ld a1, 16(s0)
+; RV64I-LP64E-WITHFP-NEXT:    lwu a0, 16(sp)
+; RV64I-LP64E-WITHFP-NEXT:    ld a1, 24(sp)
 ; RV64I-LP64E-WITHFP-NEXT:    add a0, a1, a0
-; RV64I-LP64E-WITHFP-NEXT:    addi sp, s0, -16
 ; RV64I-LP64E-WITHFP-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 ; RV64I-LP64E-WITHFP-NEXT:    ld s0, 0(sp) # 8-byte Folded Reload
 ; RV64I-LP64E-WITHFP-NEXT:    addi sp, sp, 16
@@ -384,11 +355,8 @@ define i64 @callee_i128_on_stack(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e, i32 %f,
 define i64 @caller_i128_on_stack() nounwind {
 ; RV64I-LP64E-FPELIM-LABEL: caller_i128_on_stack:
 ; RV64I-LP64E-FPELIM:       # %bb.0:
-; RV64I-LP64E-FPELIM-NEXT:    addi sp, sp, -48
-; RV64I-LP64E-FPELIM-NEXT:    sd ra, 40(sp) # 8-byte Folded Spill
-; RV64I-LP64E-FPELIM-NEXT:    sd s0, 32(sp) # 8-byte Folded Spill
-; RV64I-LP64E-FPELIM-NEXT:    addi s0, sp, 48
-; RV64I-LP64E-FPELIM-NEXT:    andi sp, sp, -16
+; RV64I-LP64E-FPELIM-NEXT:    addi sp, sp, -32
+; RV64I-LP64E-FPELIM-NEXT:    sd ra, 24(sp) # 8-byte Folded Spill
 ; RV64I-LP64E-FPELIM-NEXT:    li a6, 8
 ; RV64I-LP64E-FPELIM-NEXT:    li a7, 7
 ; RV64I-LP64E-FPELIM-NEXT:    li a0, 1
@@ -398,22 +366,19 @@ define i64 @caller_i128_on_stack() nounwind {
 ; RV64I-LP64E-FPELIM-NEXT:    li a4, 5
 ; RV64I-LP64E-FPELIM-NEXT:    li a5, 6
 ; RV64I-LP64E-FPELIM-NEXT:    sd a7, 0(sp)
-; RV64I-LP64E-FPELIM-NEXT:    sd a6, 16(sp)
-; RV64I-LP64E-FPELIM-NEXT:    sd zero, 24(sp)
+; RV64I-LP64E-FPELIM-NEXT:    sd a6, 8(sp)
+; RV64I-LP64E-FPELIM-NEXT:    sd zero, 16(sp)
 ; RV64I-LP64E-FPELIM-NEXT:    call callee_i128_on_stack
-; RV64I-LP64E-FPELIM-NEXT:    addi sp, s0, -48
-; RV64I-LP64E-FPELIM-NEXT:    ld ra, 40(sp) # 8-byte Folded Reload
-; RV64I-LP64E-FPELIM-NEXT:    ld s0, 32(sp) # 8-byte Folded Reload
-; RV64I-LP64E-FPELIM-NEXT:    addi sp, sp, 48
+; RV64I-LP64E-FPELIM-NEXT:    ld ra, 24(sp) # 8-byte Folded Reload
+; RV64I-LP64E-FPELIM-NEXT:    addi sp, sp, 32
 ; RV64I-LP64E-FPELIM-NEXT:    ret
 ;
 ; RV64I-LP64E-WITHFP-LABEL: caller_i128_on_stack:
 ; RV64I-LP64E-WITHFP:       # %bb.0:
-; RV64I-LP64E-WITHFP-NEXT:    addi sp, sp, -48
-; RV64I-LP64E-WITHFP-NEXT:    sd ra, 40(sp) # 8-byte Folded Spill
-; RV64I-LP64E-WITHFP-NEXT:    sd s0, 32(sp) # 8-byte Folded Spill
-; RV64I-LP64E-WITHFP-NEXT:    addi s0, sp, 48
-; RV64I-LP64E-WITHFP-NEXT:    andi sp, sp, -16
+; RV64I-LP64E-WITHFP-NEXT:    addi sp, sp, -40
+; RV64I-LP64E-WITHFP-NEXT:    sd ra, 32(sp) # 8-byte Folded Spill
+; RV64I-LP64E-WITHFP-NEXT:    sd s0, 24(sp) # 8-byte Folded Spill
+; RV64I-LP64E-WITHFP-NEXT:    addi s0, sp, 40
 ; RV64I-LP64E-WITHFP-NEXT:    li a6, 8
 ; RV64I-LP64E-WITHFP-NEXT:    li a7, 7
 ; RV64I-LP64E-WITHFP-NEXT:    li a0, 1
@@ -423,13 +388,12 @@ define i64 @caller_i128_on_stack() nounwind {
 ; RV64I-LP64E-WITHFP-NEXT:    li a4, 5
 ; RV64I-LP64E-WITHFP-NEXT:    li a5, 6
 ; RV64I-LP64E-WITHFP-NEXT:    sd a7, 0(sp)
-; RV64I-LP64E-WITHFP-NEXT:    sd a6, 16(sp)
-; RV64I-LP64E-WITHFP-NEXT:    sd zero, 24(sp)
+; RV64I-LP64E-WITHFP-NEXT:    sd a6, 8(sp)
+; RV64I-LP64E-WITHFP-NEXT:    sd zero, 16(sp)
 ; RV64I-LP64E-WITHFP-NEXT:    call callee_i128_on_stack
-; RV64I-LP64E-WITHFP-NEXT:    addi sp, s0, -48
-; RV64I-LP64E-WITHFP-NEXT:    ld ra, 40(sp) # 8-byte Folded Reload
-; RV64I-LP64E-WITHFP-NEXT:    ld s0, 32(sp) # 8-byte Folded Reload
-; RV64I-LP64E-WITHFP-NEXT:    addi sp, sp, 48
+; RV64I-LP64E-WITHFP-NEXT:    ld ra, 32(sp) # 8-byte Folded Reload
+; RV64I-LP64E-WITHFP-NEXT:    ld s0, 24(sp) # 8-byte Folded Reload
+; RV64I-LP64E-WITHFP-NEXT:    addi sp, sp, 40
 ; RV64I-LP64E-WITHFP-NEXT:    ret
   %1 = call i64 @callee_i128_on_stack(i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i128 8)
   ret i64 %1
diff --git a/llvm/test/CodeGen/RISCV/vararg-lp64e.ll b/llvm/test/CodeGen/RISCV/vararg-lp64e.ll
index acce5ef35332d8..d88eb3fb84b14c 100644
--- a/llvm/test/CodeGen/RISCV/vararg-lp64e.ll
+++ b/llvm/test/CodeGen/RISCV/vararg-lp64e.ll
@@ -20,9 +20,9 @@ define void @caller_i128_in_regs() {
 ; LP64E-NEXT:    sd ra, 0(sp) # 8-byte Folded Spill
 ; LP64E-NEXT:    .cfi_offset ra, -8
 ; LP64E-NEXT:    li a0, 1
-; LP64E-NEXT:    li a2, 2
-; LP64E-NEXT:    li a4, 3
-; LP64E-NEXT:    li a3, 0
+; LP64E-NEXT:    li a1, 2
+; LP64E-NEXT:    li a3, 3
+; LP64E-NEXT:    li a2, 0
 ; LP64E-NEXT:    call va_i128
 ; LP64E-NEXT:    ld ra, 0(sp) # 8-byte Folded Reload
 ; LP64E-NEXT:    .cfi_restore ra
@@ -41,9 +41,9 @@ define void @caller_i128_in_regs() {
 ; LP64E-WITHFP-NEXT:    addi s0, sp, 16
 ; LP64E-WITHFP-NEXT:    .cfi_def_cfa s0, 0
 ; LP64E-WITHFP-NEXT:    li a0, 1
-; LP64E-WITHFP-NEXT:    li a2, 2
-; LP64E-WITHFP-NEXT:    li a4, 3
-; LP64E-WITHFP-NEXT:    li a3, 0
+; LP64E-WITHFP-NEXT:    li a1, 2
+; LP64E-WITHFP-NEXT:    li a3, 3
+; LP64E-WITHFP-NEXT:    li a2, 0
 ; LP64E-WITHFP-NEXT:    call va_i128
 ; LP64E-WITHFP-NEXT:    .cfi_def_cfa sp, 16
 ; LP64E-WITHFP-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
@@ -62,65 +62,52 @@ entry:
 define void @caller_i128_split_stack() {
 ; LP64E-LABEL: caller_i128_split_stack:
 ; LP64E:       # %bb.0: # %entry
-; LP64E-NEXT:    addi sp, sp, -48
-; LP64E-NEXT:    .cfi_def_cfa_offset 48
-; LP64E-NEXT:    sd ra, 40(sp) # 8-byte Folded Spill
-; LP64E-NEXT:    sd s0, 32(sp) # 8-byte Folded Spill
+; LP64E-NEXT:    addi sp, sp, -24
+; LP64E-NEXT:    .cfi_def_cfa_offset 24
+; LP64E-NEXT:    sd ra, 16(sp) # 8-byte Folded Spill
 ; LP64E-NEXT:    .cfi_offset ra, -8
-; LP64E-NEXT:    .cfi_offset s0, -16
-; LP64E-NEXT:    addi s0, sp, 48
-; LP64E-NEXT:    .cfi_def_cfa s0, 0
-; LP64E-NEXT:    andi sp, sp, -16
-; LP64E-NEXT:    li a5, 7
-; LP64E-NEXT:    li a6, 6
+; LP64E-NEXT:    li a6, 7
 ; LP64E-NEXT:    li a0, 1
 ; LP64E-NEXT:    li a1, 2
 ; LP64E-NEXT:    li a2, 3
 ; LP64E-NEXT:    li a3, 4
 ; LP64E-NEXT:    li a4, 5
-; LP64E-NEXT:    sd a6, 0(sp)
-; LP64E-NEXT:    sd zero, 8(sp)
-; LP64E-NEXT:    sd a5, 16(sp)
+; LP64E-NEXT:    li a5, 6
+; LP64E-NEXT:    sd zero, 0(sp)
+; LP64E-NEXT:    sd a6, 8(sp)
 ; LP64E-NEXT:    call va_i128
-; LP64E-NEXT:    addi sp, s0, -48
-; LP64E-NEXT:    .cfi_def_cfa sp, 48
-; LP64E-NEXT:    ld ra, 40(sp) # 8-byte Folded Reload
-; LP64E-NEXT:    ld s0, 32(sp) # 8-byte Folded Reload
+; LP64E-NEXT:    ld ra, 16(sp) # 8-byte Folded Reload
 ; LP64E-NEXT:    .cfi_restore ra
-; LP64E-NEXT:    .cfi_restore s0
-; LP64E-NEXT:    addi sp, sp, 48
+; LP64E-NEXT:    addi sp, sp, 24
 ; LP64E-NEXT:    .cfi_def_cfa_offset 0
 ; LP64E-NEXT:    ret
 ;
 ; LP64E-WITHFP-LABEL: caller_i128_split_stack:
 ; LP64E-WITHFP:       # %bb.0: # %entry
-; LP64E-WITHFP-NEXT:    addi sp, sp, -48
-; LP64E-WITHFP-NEXT:    .cfi_def_cfa_offset 48
-; LP64E-WITHFP-NEXT:    sd ra, 40(sp) # 8-byte Folded Spill
-; LP64E-WITHFP-NEXT:    sd s0, 32(sp) # 8-byte Folded Spill
+; LP64E-WITHFP-NEXT:    addi sp, sp, -32
+; LP64E-WITHFP-NEXT:    .cfi_def_cfa_offset 32
+; LP64E-WITHFP-NEXT:    sd ra, 24(sp) # 8-byte Folded Spill
+; LP64E-WITHFP-NEXT:    sd s0, 16(sp) # 8-byte Folded Spill
 ; LP64E-WITHFP-NEXT:    .cfi_offset ra, -8
 ; LP64E-WITHFP-NEXT:    .cfi_offset s0, -16
-; LP64E-WITHFP-NEXT:    addi s0, sp, 48
+; LP64E-WITHFP-NEXT:    addi s0, sp, 32
 ; LP64E-WITHFP-NEXT:    .cfi_def_cfa s0, 0
-; LP64E-WITHFP-NEXT:    andi sp, sp, -16
-; LP64E-WITHFP-NEXT:    li a5, 7
-; LP64E-WITHFP-NEXT:    li a6, 6
+; LP64E-WITHFP-NEXT:    li a6, 7
 ; LP64E-WITHFP-NEXT:    li a0, 1
 ; LP64E-WITHFP-NEXT:    li a1, 2
 ; LP64E-WITHFP-NEXT:    li a2, 3
 ; LP64E-WITHFP-NEXT:    li a3, 4
 ; LP64E-WITHFP-NEXT:    li a4, 5
-; LP64E-WITHFP-NEXT:    sd a6, 0(sp)
-; LP64E-WITHFP-NEXT:    sd zero, 8(sp)
-; LP64E-WITHFP-NEXT:    sd a5, 16(sp)
+; LP64E-WITHFP-NEXT:    li a5, 6
+; LP64E-WITHFP-NEXT:    sd zero, 0(sp)
+; LP64E-WITHFP-NEXT:    sd a6, 8(sp)
 ; LP64E-WITHFP-NEXT:    call va_i128
-; LP64E-WITHFP-NEXT:    addi sp, s0, -48
-; LP64E-WITHFP-NEXT:    .cfi_def_cfa sp, 48
-; LP64E-WITHFP-NEXT:    ld ra, 40(sp) # 8-byte Folded Reload
-; LP64E-WITHFP-NEXT:    ld s0, 32(sp) # 8-byte Folded Reload
+; LP64E-WITHFP-NEXT:    .cfi_def_cfa sp, 32
+; LP64E-WITHFP-NEXT:    ld ra, 24(sp) # 8-byte Folded Reload
+; LP64E-WITHFP-NEXT:    ld s0, 16(sp) # 8-byte Folded Reload
 ; LP64E-WITHFP-NEXT:    .cfi_restore ra
 ; LP64E-WITHFP-NEXT:    .cfi_restore s0
-; LP64E-WITHFP-NEXT:    addi sp, sp, 48
+; LP64E-WITHFP-NEXT:    addi sp, sp, 32
 ; LP64E-WITHFP-NEXT:    .cfi_def_cfa_offset 0
 ; LP64E-WITHFP-NEXT:    ret
 entry:
@@ -132,15 +119,10 @@ entry:
 define void @caller_i128_on_stack() {
 ; LP64E-LABEL: caller_i128_on_stack:
 ; LP64E:       # %bb.0: # %entry
-; LP64E-NEXT:    addi sp, sp, -48
-; LP64E-NEXT:    .cfi_def_cfa_offset 48
-; LP64E-NEXT:    sd ra, 40(sp) # 8-byte Folded Spill
-; LP64E-NEXT:    sd s0, 32(sp) # 8-byte Folded Spill
+; LP64E-NEXT:    addi sp, sp, -32
+; LP64E-NEXT:    .cfi_def_cfa_offset 32
+; LP64E-NEXT:    sd ra, 24(sp) # 8-byte Folded Spill
 ; LP64E-NEXT:    .cfi_offset ra, -8
-; LP64E-NEXT:    .cfi_offset s0, -16
-; LP64E-NEXT:    addi s0, sp, 48
-; LP64E-NEXT:    .cfi_def_cfa s0, 0
-; LP64E-NEXT:    andi sp, sp, -16
 ; LP64E-NEXT:    li a6, 8
 ; LP64E-NEXT:    li a7, 7
 ; LP64E-NEXT:    li a0, 1
@@ -150,30 +132,25 @@ define void @caller_i128_on_stack() {
 ; LP64E-NEXT:    li a4, 5
 ; LP64E-NEXT:    li a5, 6
 ; LP64E-NEXT:    sd a7, 0(sp)
-; LP64E-NEXT:    sd a6, 16(sp)
-; LP64E-NEXT:    sd zero, 24(sp)
+; LP64E-NEXT:    sd a6, 8(sp)
+; LP64E-NEXT:    sd zero, 16(sp)
 ; LP64E-NEXT:    call va_i128
-; LP64E-NEXT:    addi sp, s0, -48
-; LP64E-NEXT:    .cfi_def_cfa sp, 48
-; LP64E-NEXT:    ld ra, 40(sp) # 8-byte Folded Reload
-; LP64E-NEXT:    ld s0, 32(sp) # 8-byte Folded Reload
+; LP64E-NEXT:    ld ra, 24(sp) # 8-byte Folded Reload
 ; LP64E-NEXT:    .cfi_restore ra
-; LP64E-NEXT:    .cfi_restore s0
-; LP64E-NEXT:    addi sp, sp, 48
+; LP64E-NEXT:    addi sp, sp, 32
 ; LP64E-NEXT:    .cfi_def_cfa_offset 0
 ; LP64E-NEXT:    ret
 ;
 ; LP64E-WITHFP-LABEL: caller_i128_on_stack:
 ; LP64E-WITHFP:       # %bb.0: # %entry
-; LP64E-WITHFP-NEXT:    addi sp, sp, -48
-; LP64E-WITHFP-NEXT:    .cfi_def_cfa_offset 48
-; LP64E-WITHFP-NEXT:    sd ra, 40(sp) # 8-byte Folded Spill
-; LP64E-WITHFP-NEXT:    sd s0, 32(sp) # 8-byte Folded Spill
+; LP64E-WITHFP-NEXT:    addi sp, sp, -40
+; LP64E-WITHFP-NEXT:    .cfi_def_cfa_offset 40
+; LP64E-WITHFP-NEXT:    sd ra, 32(sp) # 8-byte Folded Spill
+; LP64E-WITHFP-NEXT:    sd s0, 24(sp) # 8-byte Folded Spill
 ; LP64E-WITHFP-NEXT:    .cfi_offset ra, -8
 ; LP64E-WITHFP-NEXT:    .cfi_offset s0, -16
-; LP64E-WITHFP-NEXT:    addi s0, sp, 48
+; LP64E-WITHFP-NEXT:    addi s0, sp, 40
 ; LP64E-WITHFP-NEXT:    .cfi_def_cfa s0, 0
-; LP64E-WITHFP-NEXT:    andi sp, sp, -16
 ; LP64E-WITHFP-NEXT:    li a6, 8
 ; LP64E-WITHFP-NEXT:    li a7, 7
 ; LP64E-WITHFP-NEXT:    li a0, 1
@@ -183,16 +160,15 @@ define void @caller_i128_on_stack() {
 ; LP64E-WITHFP-NEXT:    li a4, 5
 ; LP64E-WITHFP-NEXT:    li a5, 6
 ; LP64E-WITHFP-NEXT:    sd a7, 0(sp)
-; LP64E-WITHFP-NEXT:    sd a6, 16(sp)
-; LP64E-WITHFP-NEXT:    sd zero, 24(sp)
+; LP64E-WITHFP-NEXT:    sd a6, 8(sp)
+; LP64E-WITHFP-NEXT:    sd zero, 16(sp)
 ; LP64E-WITHFP-NEXT:    call va_i128
-; LP64E-WITHFP-NEXT:    addi sp, s0, -48
-; LP64E-WITHFP-NEXT:    .cfi_def_cfa sp, 48
-; LP64E-WITHFP-NEXT:    ld ra, 40(sp) # 8-byte Folded Reload
-; LP64E-WITHFP-NEXT:    ld s0, 32(sp) # 8-byte Folded Reload
+; LP64E-WITHFP-NEXT:    .cfi_def_cfa sp, 40
+; LP64E-WITHFP-NEXT:    ld ra, 32(sp) # 8-byte Folded Reload
+; LP64E-WITHFP-NEXT:    ld s0, 24(sp) # 8-byte Folded Reload
 ; LP64E-WITHFP-NEXT:    .cfi_restore ra
 ; LP64E-WITHFP-NEXT:    .cfi_restore s0
-; LP64E-WITHFP-NEXT:    addi sp, sp, 48
+; LP64E-WITHFP-NEXT:    addi sp, sp, 40
 ; LP64E-WITHFP-NEXT:    .cfi_def_cfa_offset 0
 ; LP64E-WITHFP-NEXT:    ret
 entry:



More information about the cfe-commits mailing list