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

via cfe-commits cfe-commits at lists.llvm.org
Fri Nov 6 19:03:25 PST 2026


llvmorg-github-actions[bot] wrote:


<!--LLVM PR SUMMARY COMMENT-->

@llvm/pr-subscribers-backend-risc-v

Author: Craig Topper (topperc)

<details>
<summary>Changes</summary>

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

---

Patch is 39.11 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/239884.diff


7 Files Affected:

- (modified) clang/docs/ReleaseNotes.md (+2) 
- (modified) clang/lib/CodeGen/Targets/RISCV.cpp (+6-5) 
- (modified) clang/test/CodeGen/RISCV/riscv64-vararg.c (+105-56) 
- (modified) llvm/docs/ReleaseNotes.md (+1) 
- (modified) llvm/lib/Target/RISCV/RISCVCallingConv.cpp (+13-13) 
- (modified) llvm/test/CodeGen/RISCV/calling-conv-lp64e.ll (+218-31) 
- (added) llvm/test/CodeGen/RISCV/vararg-lp64e.ll (+233) 


``````````diff
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 7abdd2175c41cb..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
 ;
 ;...
[truncated]

``````````

</details>


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


More information about the cfe-commits mailing list