[llvm] a8ef679 - Revert "[RISCV][GISel] Allow >2*XLen integers in isSupportedReturnType."

Craig Topper via llvm-commits llvm-commits at lists.llvm.org
Tue Aug 20 16:34:34 PDT 2024


Author: Craig Topper
Date: 2024-08-20T16:34:15-07:00
New Revision: a8ef679507743a05c1fdfa677a4599eefa04fc37

URL: https://github.com/llvm/llvm-project/commit/a8ef679507743a05c1fdfa677a4599eefa04fc37
DIFF: https://github.com/llvm/llvm-project/commit/a8ef679507743a05c1fdfa677a4599eefa04fc37.diff

LOG: Revert "[RISCV][GISel] Allow >2*XLen integers in isSupportedReturnType."

It didn't crash so I thought this worked now, but upon further review
it miscalculates the stack address for the return.

Added: 
    

Modified: 
    llvm/lib/Target/RISCV/GISel/RISCVCallLowering.cpp
    llvm/test/CodeGen/RISCV/GlobalISel/irtranslator/calling-conv-ilp32-ilp32f-ilp32d-common.ll
    llvm/test/CodeGen/RISCV/GlobalISel/irtranslator/calling-conv-lp64-lp64f-lp64d-common.ll

Removed: 
    


################################################################################
diff  --git a/llvm/lib/Target/RISCV/GISel/RISCVCallLowering.cpp b/llvm/lib/Target/RISCV/GISel/RISCVCallLowering.cpp
index f46264a2c9213d..f7fa0e170fd297 100644
--- a/llvm/lib/Target/RISCV/GISel/RISCVCallLowering.cpp
+++ b/llvm/lib/Target/RISCV/GISel/RISCVCallLowering.cpp
@@ -363,7 +363,7 @@ static bool isSupportedReturnType(Type *T, const RISCVSubtarget &Subtarget,
   // TODO: Integers larger than 2*XLen are passed indirectly which is not
   // supported yet.
   if (T->isIntegerTy())
-    return true;
+    return T->getIntegerBitWidth() <= Subtarget.getXLen() * 2;
   if (T->isHalfTy() || T->isFloatTy() || T->isDoubleTy())
     return true;
   if (T->isPointerTy())

diff  --git a/llvm/test/CodeGen/RISCV/GlobalISel/irtranslator/calling-conv-ilp32-ilp32f-ilp32d-common.ll b/llvm/test/CodeGen/RISCV/GlobalISel/irtranslator/calling-conv-ilp32-ilp32f-ilp32d-common.ll
index 57ff26a6585154..5ca1bf7467858e 100644
--- a/llvm/test/CodeGen/RISCV/GlobalISel/irtranslator/calling-conv-ilp32-ilp32f-ilp32d-common.ll
+++ b/llvm/test/CodeGen/RISCV/GlobalISel/irtranslator/calling-conv-ilp32-ilp32f-ilp32d-common.ll
@@ -886,64 +886,6 @@ define i32 @caller_small_scalar_ret() nounwind {
   ret i32 %3
 }
 
-; Check return of >2x xlen scalars
-
-define i128 @callee_large_scalar_ret() nounwind {
-  ; RV32I-LABEL: name: callee_large_scalar_ret
-  ; RV32I: bb.1 (%ir-block.0):
-  ; RV32I-NEXT:   [[C:%[0-9]+]]:_(s128) = G_CONSTANT i128 1234567898765432123456789
-  ; RV32I-NEXT:   [[FRAME_INDEX:%[0-9]+]]:_(p0) = G_FRAME_INDEX %stack.0
-  ; RV32I-NEXT:   G_STORE [[C]](s128), [[FRAME_INDEX]](p0) :: (store (s128) into %stack.0, align 8)
-  ; RV32I-NEXT:   $x10 = COPY [[FRAME_INDEX]](p0)
-  ; RV32I-NEXT:   PseudoRET implicit $x10
-  ret i128 1234567898765432123456789
-}
-
-define i32 @caller_large_scalar_ret() nounwind {
-  ; ILP32-LABEL: name: caller_large_scalar_ret
-  ; ILP32: bb.1 (%ir-block.0):
-  ; ILP32-NEXT:   [[C:%[0-9]+]]:_(s128) = G_CONSTANT i128 9876543212345678987654321
-  ; ILP32-NEXT:   ADJCALLSTACKDOWN 0, 0, implicit-def $x2, implicit $x2
-  ; ILP32-NEXT:   PseudoCALL target-flags(riscv-call) @callee_large_scalar_ret, csr_ilp32_lp64, implicit-def $x1, implicit-def $x10
-  ; ILP32-NEXT:   ADJCALLSTACKUP 0, 0, implicit-def $x2, implicit $x2
-  ; ILP32-NEXT:   [[COPY:%[0-9]+]]:_(p0) = COPY $x10
-  ; ILP32-NEXT:   [[LOAD:%[0-9]+]]:_(s128) = G_LOAD [[COPY]](p0) :: (load (s128), align 8)
-  ; ILP32-NEXT:   [[ICMP:%[0-9]+]]:_(s1) = G_ICMP intpred(eq), [[C]](s128), [[LOAD]]
-  ; ILP32-NEXT:   [[ZEXT:%[0-9]+]]:_(s32) = G_ZEXT [[ICMP]](s1)
-  ; ILP32-NEXT:   $x10 = COPY [[ZEXT]](s32)
-  ; ILP32-NEXT:   PseudoRET implicit $x10
-  ;
-  ; ILP32F-LABEL: name: caller_large_scalar_ret
-  ; ILP32F: bb.1 (%ir-block.0):
-  ; ILP32F-NEXT:   [[C:%[0-9]+]]:_(s128) = G_CONSTANT i128 9876543212345678987654321
-  ; ILP32F-NEXT:   ADJCALLSTACKDOWN 0, 0, implicit-def $x2, implicit $x2
-  ; ILP32F-NEXT:   PseudoCALL target-flags(riscv-call) @callee_large_scalar_ret, csr_ilp32f_lp64f, implicit-def $x1, implicit-def $x10
-  ; ILP32F-NEXT:   ADJCALLSTACKUP 0, 0, implicit-def $x2, implicit $x2
-  ; ILP32F-NEXT:   [[COPY:%[0-9]+]]:_(p0) = COPY $x10
-  ; ILP32F-NEXT:   [[LOAD:%[0-9]+]]:_(s128) = G_LOAD [[COPY]](p0) :: (load (s128), align 8)
-  ; ILP32F-NEXT:   [[ICMP:%[0-9]+]]:_(s1) = G_ICMP intpred(eq), [[C]](s128), [[LOAD]]
-  ; ILP32F-NEXT:   [[ZEXT:%[0-9]+]]:_(s32) = G_ZEXT [[ICMP]](s1)
-  ; ILP32F-NEXT:   $x10 = COPY [[ZEXT]](s32)
-  ; ILP32F-NEXT:   PseudoRET implicit $x10
-  ;
-  ; ILP32D-LABEL: name: caller_large_scalar_ret
-  ; ILP32D: bb.1 (%ir-block.0):
-  ; ILP32D-NEXT:   [[C:%[0-9]+]]:_(s128) = G_CONSTANT i128 9876543212345678987654321
-  ; ILP32D-NEXT:   ADJCALLSTACKDOWN 0, 0, implicit-def $x2, implicit $x2
-  ; ILP32D-NEXT:   PseudoCALL target-flags(riscv-call) @callee_large_scalar_ret, csr_ilp32d_lp64d, implicit-def $x1, implicit-def $x10
-  ; ILP32D-NEXT:   ADJCALLSTACKUP 0, 0, implicit-def $x2, implicit $x2
-  ; ILP32D-NEXT:   [[COPY:%[0-9]+]]:_(p0) = COPY $x10
-  ; ILP32D-NEXT:   [[LOAD:%[0-9]+]]:_(s128) = G_LOAD [[COPY]](p0) :: (load (s128), align 8)
-  ; ILP32D-NEXT:   [[ICMP:%[0-9]+]]:_(s1) = G_ICMP intpred(eq), [[C]](s128), [[LOAD]]
-  ; ILP32D-NEXT:   [[ZEXT:%[0-9]+]]:_(s32) = G_ZEXT [[ICMP]](s1)
-  ; ILP32D-NEXT:   $x10 = COPY [[ZEXT]](s32)
-  ; ILP32D-NEXT:   PseudoRET implicit $x10
-  %1 = call i128 @callee_large_scalar_ret()
-  %2 = icmp eq i128 9876543212345678987654321, %1
-  %3 = zext i1 %2 to i32
-  ret i32 %3
-}
-
 ; Check return of 2x xlen structs
 
 %struct.small = type { i32, ptr }

diff  --git a/llvm/test/CodeGen/RISCV/GlobalISel/irtranslator/calling-conv-lp64-lp64f-lp64d-common.ll b/llvm/test/CodeGen/RISCV/GlobalISel/irtranslator/calling-conv-lp64-lp64f-lp64d-common.ll
index 088cac9bd2930f..2499f8caf02bcf 100644
--- a/llvm/test/CodeGen/RISCV/GlobalISel/irtranslator/calling-conv-lp64-lp64f-lp64d-common.ll
+++ b/llvm/test/CodeGen/RISCV/GlobalISel/irtranslator/calling-conv-lp64-lp64f-lp64d-common.ll
@@ -541,64 +541,6 @@ define i64 @caller_small_scalar_ret() nounwind {
   ret i64 %3
 }
 
-; Check return of >2x xlen scalars
-
-define i256 @callee_large_scalar_ret() nounwind {
-  ; RV64I-LABEL: name: callee_large_scalar_ret
-  ; RV64I: bb.1 (%ir-block.0):
-  ; RV64I-NEXT:   [[C:%[0-9]+]]:_(s256) = G_CONSTANT i256 -1
-  ; RV64I-NEXT:   [[FRAME_INDEX:%[0-9]+]]:_(p0) = G_FRAME_INDEX %stack.0
-  ; RV64I-NEXT:   G_STORE [[C]](s256), [[FRAME_INDEX]](p0) :: (store (s256) into %stack.0, align 16)
-  ; RV64I-NEXT:   $x10 = COPY [[FRAME_INDEX]](p0)
-  ; RV64I-NEXT:   PseudoRET implicit $x10
-  ret i256 -1
-}
-
-define i64 @caller_large_scalar_ret() nounwind {
-  ; LP64-LABEL: name: caller_large_scalar_ret
-  ; LP64: bb.1 (%ir-block.0):
-  ; LP64-NEXT:   [[C:%[0-9]+]]:_(s256) = G_CONSTANT i256 -2
-  ; LP64-NEXT:   ADJCALLSTACKDOWN 0, 0, implicit-def $x2, implicit $x2
-  ; LP64-NEXT:   PseudoCALL target-flags(riscv-call) @callee_small_scalar_ret, csr_ilp32_lp64, implicit-def $x1, implicit-def $x10
-  ; LP64-NEXT:   ADJCALLSTACKUP 0, 0, implicit-def $x2, implicit $x2
-  ; LP64-NEXT:   [[COPY:%[0-9]+]]:_(p0) = COPY $x10
-  ; LP64-NEXT:   [[LOAD:%[0-9]+]]:_(s256) = G_LOAD [[COPY]](p0) :: (load (s256), align 16)
-  ; LP64-NEXT:   [[ICMP:%[0-9]+]]:_(s1) = G_ICMP intpred(eq), [[C]](s256), [[LOAD]]
-  ; LP64-NEXT:   [[ZEXT:%[0-9]+]]:_(s64) = G_ZEXT [[ICMP]](s1)
-  ; LP64-NEXT:   $x10 = COPY [[ZEXT]](s64)
-  ; LP64-NEXT:   PseudoRET implicit $x10
-  ;
-  ; LP64F-LABEL: name: caller_large_scalar_ret
-  ; LP64F: bb.1 (%ir-block.0):
-  ; LP64F-NEXT:   [[C:%[0-9]+]]:_(s256) = G_CONSTANT i256 -2
-  ; LP64F-NEXT:   ADJCALLSTACKDOWN 0, 0, implicit-def $x2, implicit $x2
-  ; LP64F-NEXT:   PseudoCALL target-flags(riscv-call) @callee_small_scalar_ret, csr_ilp32f_lp64f, implicit-def $x1, implicit-def $x10
-  ; LP64F-NEXT:   ADJCALLSTACKUP 0, 0, implicit-def $x2, implicit $x2
-  ; LP64F-NEXT:   [[COPY:%[0-9]+]]:_(p0) = COPY $x10
-  ; LP64F-NEXT:   [[LOAD:%[0-9]+]]:_(s256) = G_LOAD [[COPY]](p0) :: (load (s256), align 16)
-  ; LP64F-NEXT:   [[ICMP:%[0-9]+]]:_(s1) = G_ICMP intpred(eq), [[C]](s256), [[LOAD]]
-  ; LP64F-NEXT:   [[ZEXT:%[0-9]+]]:_(s64) = G_ZEXT [[ICMP]](s1)
-  ; LP64F-NEXT:   $x10 = COPY [[ZEXT]](s64)
-  ; LP64F-NEXT:   PseudoRET implicit $x10
-  ;
-  ; LP64D-LABEL: name: caller_large_scalar_ret
-  ; LP64D: bb.1 (%ir-block.0):
-  ; LP64D-NEXT:   [[C:%[0-9]+]]:_(s256) = G_CONSTANT i256 -2
-  ; LP64D-NEXT:   ADJCALLSTACKDOWN 0, 0, implicit-def $x2, implicit $x2
-  ; LP64D-NEXT:   PseudoCALL target-flags(riscv-call) @callee_small_scalar_ret, csr_ilp32d_lp64d, implicit-def $x1, implicit-def $x10
-  ; LP64D-NEXT:   ADJCALLSTACKUP 0, 0, implicit-def $x2, implicit $x2
-  ; LP64D-NEXT:   [[COPY:%[0-9]+]]:_(p0) = COPY $x10
-  ; LP64D-NEXT:   [[LOAD:%[0-9]+]]:_(s256) = G_LOAD [[COPY]](p0) :: (load (s256), align 16)
-  ; LP64D-NEXT:   [[ICMP:%[0-9]+]]:_(s1) = G_ICMP intpred(eq), [[C]](s256), [[LOAD]]
-  ; LP64D-NEXT:   [[ZEXT:%[0-9]+]]:_(s64) = G_ZEXT [[ICMP]](s1)
-  ; LP64D-NEXT:   $x10 = COPY [[ZEXT]](s64)
-  ; LP64D-NEXT:   PseudoRET implicit $x10
-  %1 = call i256 @callee_small_scalar_ret()
-  %2 = icmp eq i256 -2, %1
-  %3 = zext i1 %2 to i64
-  ret i64 %3
-}
-
 ; Check return of 2x xlen structs
 
 %struct.small = type { i64, ptr }


        


More information about the llvm-commits mailing list