Skip to content

Commit fdc7ccf

Browse files
topperctopperc
committed
[RISCV][GISel] Allow fp128 function arguments.
Add more testing for large arguments.
1 parent 867a1d6 commit fdc7ccf

File tree

3 files changed

+579
-1
lines changed

3 files changed

+579
-1
lines changed

‎llvm/lib/Target/RISCV/GISel/RISCVCallLowering.cpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -350,7 +350,7 @@ static bool isSupportedArgumentType(Type *T, const RISCVSubtarget &Subtarget,
350350
bool IsLowerArgs = false) {
351351
if (T->isIntegerTy())
352352
return true;
353-
if (T->isHalfTy() || T->isFloatTy() || T->isDoubleTy())
353+
if (T->isHalfTy() || T->isFloatTy() || T->isDoubleTy() || T->isFP128Ty())
354354
return true;
355355
if (T->isPointerTy())
356356
return true;

‎llvm/test/CodeGen/RISCV/GlobalISel/irtranslator/calling-conv-ilp32-ilp32f-ilp32d-common.ll‎

Lines changed: 230 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -825,6 +825,236 @@ define i32 @caller_many_scalars() nounwind {
825825
ret i32 %1
826826
}
827827

828+
829+
; Check that i128 and fp128 are passed indirectly
830+
831+
define i32 @callee_large_scalars(i128 %a, fp128 %b) nounwind {
832+
; RV32I-LABEL: name: callee_large_scalars
833+
; RV32I: bb.1 (%ir-block.0):
834+
; RV32I-NEXT: liveins: $x10, $x11
835+
; RV32I-NEXT: {{ $}}
836+
; RV32I-NEXT: [[COPY:%[0-9]+]]:_(p0) = COPY $x10
837+
; RV32I-NEXT: [[LOAD:%[0-9]+]]:_(s128) = G_LOAD [[COPY]](p0) :: (load (s128), align 8)
838+
; RV32I-NEXT: [[COPY1:%[0-9]+]]:_(p0) = COPY $x11
839+
; RV32I-NEXT: [[LOAD1:%[0-9]+]]:_(s128) = G_LOAD [[COPY1]](p0) :: (load (s128))
840+
; RV32I-NEXT: [[ICMP:%[0-9]+]]:_(s1) = G_ICMP intpred(eq), [[LOAD]](s128), [[LOAD1]]
841+
; RV32I-NEXT: [[ZEXT:%[0-9]+]]:_(s32) = G_ZEXT [[ICMP]](s1)
842+
; RV32I-NEXT: $x10 = COPY [[ZEXT]](s32)
843+
; RV32I-NEXT: PseudoRET implicit $x10
844+
%b_bitcast = bitcast fp128 %b to i128
845+
%1 = icmp eq i128 %a, %b_bitcast
846+
%2 = zext i1 %1 to i32
847+
ret i32 %2
848+
}
849+
850+
define i32 @caller_large_scalars() nounwind {
851+
; ILP32-LABEL: name: caller_large_scalars
852+
; ILP32: bb.1 (%ir-block.0):
853+
; ILP32-NEXT: [[C:%[0-9]+]]:_(s128) = G_CONSTANT i128 1
854+
; ILP32-NEXT: [[C1:%[0-9]+]]:_(s128) = G_FCONSTANT fp128 0xL00000000000000007FFF000000000000
855+
; ILP32-NEXT: ADJCALLSTACKDOWN 0, 0, implicit-def $x2, implicit $x2
856+
; ILP32-NEXT: [[FRAME_INDEX:%[0-9]+]]:_(p0) = G_FRAME_INDEX %stack.0
857+
; ILP32-NEXT: G_STORE [[C]](s128), [[FRAME_INDEX]](p0) :: (store (s128) into %stack.0, align 8)
858+
; ILP32-NEXT: [[FRAME_INDEX1:%[0-9]+]]:_(p0) = G_FRAME_INDEX %stack.1
859+
; ILP32-NEXT: G_STORE [[C1]](s128), [[FRAME_INDEX1]](p0) :: (store (s128) into %stack.1)
860+
; ILP32-NEXT: $x10 = COPY [[FRAME_INDEX]](p0)
861+
; ILP32-NEXT: $x11 = COPY [[FRAME_INDEX1]](p0)
862+
; ILP32-NEXT: PseudoCALL target-flags(riscv-call) @callee_large_scalars, csr_ilp32_lp64, implicit-def $x1, implicit $x10, implicit $x11, implicit-def $x10
863+
; ILP32-NEXT: ADJCALLSTACKUP 0, 0, implicit-def $x2, implicit $x2
864+
; ILP32-NEXT: [[COPY:%[0-9]+]]:_(s32) = COPY $x10
865+
; ILP32-NEXT: $x10 = COPY [[COPY]](s32)
866+
; ILP32-NEXT: PseudoRET implicit $x10
867+
;
868+
; ILP32F-LABEL: name: caller_large_scalars
869+
; ILP32F: bb.1 (%ir-block.0):
870+
; ILP32F-NEXT: [[C:%[0-9]+]]:_(s128) = G_CONSTANT i128 1
871+
; ILP32F-NEXT: [[C1:%[0-9]+]]:_(s128) = G_FCONSTANT fp128 0xL00000000000000007FFF000000000000
872+
; ILP32F-NEXT: ADJCALLSTACKDOWN 0, 0, implicit-def $x2, implicit $x2
873+
; ILP32F-NEXT: [[FRAME_INDEX:%[0-9]+]]:_(p0) = G_FRAME_INDEX %stack.0
874+
; ILP32F-NEXT: G_STORE [[C]](s128), [[FRAME_INDEX]](p0) :: (store (s128) into %stack.0, align 8)
875+
; ILP32F-NEXT: [[FRAME_INDEX1:%[0-9]+]]:_(p0) = G_FRAME_INDEX %stack.1
876+
; ILP32F-NEXT: G_STORE [[C1]](s128), [[FRAME_INDEX1]](p0) :: (store (s128) into %stack.1)
877+
; ILP32F-NEXT: $x10 = COPY [[FRAME_INDEX]](p0)
878+
; ILP32F-NEXT: $x11 = COPY [[FRAME_INDEX1]](p0)
879+
; ILP32F-NEXT: PseudoCALL target-flags(riscv-call) @callee_large_scalars, csr_ilp32f_lp64f, implicit-def $x1, implicit $x10, implicit $x11, implicit-def $x10
880+
; ILP32F-NEXT: ADJCALLSTACKUP 0, 0, implicit-def $x2, implicit $x2
881+
; ILP32F-NEXT: [[COPY:%[0-9]+]]:_(s32) = COPY $x10
882+
; ILP32F-NEXT: $x10 = COPY [[COPY]](s32)
883+
; ILP32F-NEXT: PseudoRET implicit $x10
884+
;
885+
; ILP32D-LABEL: name: caller_large_scalars
886+
; ILP32D: bb.1 (%ir-block.0):
887+
; ILP32D-NEXT: [[C:%[0-9]+]]:_(s128) = G_CONSTANT i128 1
888+
; ILP32D-NEXT: [[C1:%[0-9]+]]:_(s128) = G_FCONSTANT fp128 0xL00000000000000007FFF000000000000
889+
; ILP32D-NEXT: ADJCALLSTACKDOWN 0, 0, implicit-def $x2, implicit $x2
890+
; ILP32D-NEXT: [[FRAME_INDEX:%[0-9]+]]:_(p0) = G_FRAME_INDEX %stack.0
891+
; ILP32D-NEXT: G_STORE [[C]](s128), [[FRAME_INDEX]](p0) :: (store (s128) into %stack.0, align 8)
892+
; ILP32D-NEXT: [[FRAME_INDEX1:%[0-9]+]]:_(p0) = G_FRAME_INDEX %stack.1
893+
; ILP32D-NEXT: G_STORE [[C1]](s128), [[FRAME_INDEX1]](p0) :: (store (s128) into %stack.1)
894+
; ILP32D-NEXT: $x10 = COPY [[FRAME_INDEX]](p0)
895+
; ILP32D-NEXT: $x11 = COPY [[FRAME_INDEX1]](p0)
896+
; ILP32D-NEXT: PseudoCALL target-flags(riscv-call) @callee_large_scalars, csr_ilp32d_lp64d, implicit-def $x1, implicit $x10, implicit $x11, implicit-def $x10
897+
; ILP32D-NEXT: ADJCALLSTACKUP 0, 0, implicit-def $x2, implicit $x2
898+
; ILP32D-NEXT: [[COPY:%[0-9]+]]:_(s32) = COPY $x10
899+
; ILP32D-NEXT: $x10 = COPY [[COPY]](s32)
900+
; ILP32D-NEXT: PseudoRET implicit $x10
901+
%1 = call i32 @callee_large_scalars(i128 1, fp128 0xL00000000000000007FFF000000000000)
902+
ret i32 %1
903+
}
904+
905+
; Check that arguments larger than 2*xlen are handled correctly when their
906+
; address is passed on the stack rather than in memory
907+
908+
; Must keep define on a single line due to an update_llc_test_checks.py limitation
909+
define i32 @callee_large_scalars_exhausted_regs(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e, i32 %f, i32 %g, i128 %h, i32 %i, fp128 %j) nounwind {
910+
; RV32I-LABEL: name: callee_large_scalars_exhausted_regs
911+
; RV32I: bb.1 (%ir-block.0):
912+
; RV32I-NEXT: liveins: $x10, $x11, $x12, $x13, $x14, $x15, $x16, $x17
913+
; RV32I-NEXT: {{ $}}
914+
; RV32I-NEXT: [[COPY:%[0-9]+]]:_(s32) = COPY $x10
915+
; RV32I-NEXT: [[COPY1:%[0-9]+]]:_(s32) = COPY $x11
916+
; RV32I-NEXT: [[COPY2:%[0-9]+]]:_(s32) = COPY $x12
917+
; RV32I-NEXT: [[COPY3:%[0-9]+]]:_(s32) = COPY $x13
918+
; RV32I-NEXT: [[COPY4:%[0-9]+]]:_(s32) = COPY $x14
919+
; RV32I-NEXT: [[COPY5:%[0-9]+]]:_(s32) = COPY $x15
920+
; RV32I-NEXT: [[COPY6:%[0-9]+]]:_(s32) = COPY $x16
921+
; RV32I-NEXT: [[COPY7:%[0-9]+]]:_(p0) = COPY $x17
922+
; RV32I-NEXT: [[LOAD:%[0-9]+]]:_(s128) = G_LOAD [[COPY7]](p0) :: (load (s128), align 8)
923+
; RV32I-NEXT: [[FRAME_INDEX:%[0-9]+]]:_(p0) = G_FRAME_INDEX %fixed-stack.1
924+
; RV32I-NEXT: [[LOAD1:%[0-9]+]]:_(s32) = G_LOAD [[FRAME_INDEX]](p0) :: (load (s32) from %fixed-stack.1, align 16)
925+
; RV32I-NEXT: [[FRAME_INDEX1:%[0-9]+]]:_(p0) = G_FRAME_INDEX %fixed-stack.0
926+
; RV32I-NEXT: [[LOAD2:%[0-9]+]]:_(p0) = G_LOAD [[FRAME_INDEX1]](p0) :: (load (p0) from %fixed-stack.0)
927+
; RV32I-NEXT: [[LOAD3:%[0-9]+]]:_(s128) = G_LOAD [[LOAD2]](p0) :: (load (s128))
928+
; RV32I-NEXT: [[ICMP:%[0-9]+]]:_(s1) = G_ICMP intpred(eq), [[LOAD]](s128), [[LOAD3]]
929+
; RV32I-NEXT: [[ZEXT:%[0-9]+]]:_(s32) = G_ZEXT [[ICMP]](s1)
930+
; RV32I-NEXT: $x10 = COPY [[ZEXT]](s32)
931+
; RV32I-NEXT: PseudoRET implicit $x10
932+
%j_bitcast = bitcast fp128 %j to i128
933+
%1 = icmp eq i128 %h, %j_bitcast
934+
%2 = zext i1 %1 to i32
935+
ret i32 %2
936+
}
937+
938+
define i32 @caller_large_scalars_exhausted_regs() nounwind {
939+
; ILP32-LABEL: name: caller_large_scalars_exhausted_regs
940+
; ILP32: bb.1 (%ir-block.0):
941+
; ILP32-NEXT: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 1
942+
; ILP32-NEXT: [[C1:%[0-9]+]]:_(s32) = G_CONSTANT i32 2
943+
; ILP32-NEXT: [[C2:%[0-9]+]]:_(s32) = G_CONSTANT i32 3
944+
; ILP32-NEXT: [[C3:%[0-9]+]]:_(s32) = G_CONSTANT i32 4
945+
; ILP32-NEXT: [[C4:%[0-9]+]]:_(s32) = G_CONSTANT i32 5
946+
; ILP32-NEXT: [[C5:%[0-9]+]]:_(s32) = G_CONSTANT i32 6
947+
; ILP32-NEXT: [[C6:%[0-9]+]]:_(s32) = G_CONSTANT i32 7
948+
; ILP32-NEXT: [[C7:%[0-9]+]]:_(s128) = G_CONSTANT i128 8
949+
; ILP32-NEXT: [[C8:%[0-9]+]]:_(s32) = G_CONSTANT i32 9
950+
; ILP32-NEXT: [[C9:%[0-9]+]]:_(s128) = G_FCONSTANT fp128 0xL00000000000000007FFF000000000000
951+
; ILP32-NEXT: ADJCALLSTACKDOWN 8, 0, implicit-def $x2, implicit $x2
952+
; ILP32-NEXT: [[FRAME_INDEX:%[0-9]+]]:_(p0) = G_FRAME_INDEX %stack.0
953+
; ILP32-NEXT: G_STORE [[C7]](s128), [[FRAME_INDEX]](p0) :: (store (s128) into %stack.0, align 8)
954+
; ILP32-NEXT: [[COPY:%[0-9]+]]:_(p0) = COPY $x2
955+
; ILP32-NEXT: [[C10:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
956+
; ILP32-NEXT: [[PTR_ADD:%[0-9]+]]:_(p0) = G_PTR_ADD [[COPY]], [[C10]](s32)
957+
; ILP32-NEXT: G_STORE [[C8]](s32), [[PTR_ADD]](p0) :: (store (s32) into stack, align 16)
958+
; ILP32-NEXT: [[FRAME_INDEX1:%[0-9]+]]:_(p0) = G_FRAME_INDEX %stack.1
959+
; ILP32-NEXT: G_STORE [[C9]](s128), [[FRAME_INDEX1]](p0) :: (store (s128) into %stack.1)
960+
; ILP32-NEXT: [[C11:%[0-9]+]]:_(s32) = G_CONSTANT i32 4
961+
; ILP32-NEXT: [[PTR_ADD1:%[0-9]+]]:_(p0) = G_PTR_ADD [[COPY]], [[C11]](s32)
962+
; ILP32-NEXT: G_STORE [[FRAME_INDEX1]](p0), [[PTR_ADD1]](p0) :: (store (p0) into stack + 4)
963+
; ILP32-NEXT: $x10 = COPY [[C]](s32)
964+
; ILP32-NEXT: $x11 = COPY [[C1]](s32)
965+
; ILP32-NEXT: $x12 = COPY [[C2]](s32)
966+
; ILP32-NEXT: $x13 = COPY [[C3]](s32)
967+
; ILP32-NEXT: $x14 = COPY [[C4]](s32)
968+
; ILP32-NEXT: $x15 = COPY [[C5]](s32)
969+
; ILP32-NEXT: $x16 = COPY [[C6]](s32)
970+
; ILP32-NEXT: $x17 = COPY [[FRAME_INDEX]](p0)
971+
; ILP32-NEXT: PseudoCALL target-flags(riscv-call) @callee_large_scalars_exhausted_regs, csr_ilp32_lp64, implicit-def $x1, implicit $x10, implicit $x11, implicit $x12, implicit $x13, implicit $x14, implicit $x15, implicit $x16, implicit $x17, implicit-def $x10
972+
; ILP32-NEXT: ADJCALLSTACKUP 8, 0, implicit-def $x2, implicit $x2
973+
; ILP32-NEXT: [[COPY1:%[0-9]+]]:_(s32) = COPY $x10
974+
; ILP32-NEXT: $x10 = COPY [[COPY1]](s32)
975+
; ILP32-NEXT: PseudoRET implicit $x10
976+
;
977+
; ILP32F-LABEL: name: caller_large_scalars_exhausted_regs
978+
; ILP32F: bb.1 (%ir-block.0):
979+
; ILP32F-NEXT: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 1
980+
; ILP32F-NEXT: [[C1:%[0-9]+]]:_(s32) = G_CONSTANT i32 2
981+
; ILP32F-NEXT: [[C2:%[0-9]+]]:_(s32) = G_CONSTANT i32 3
982+
; ILP32F-NEXT: [[C3:%[0-9]+]]:_(s32) = G_CONSTANT i32 4
983+
; ILP32F-NEXT: [[C4:%[0-9]+]]:_(s32) = G_CONSTANT i32 5
984+
; ILP32F-NEXT: [[C5:%[0-9]+]]:_(s32) = G_CONSTANT i32 6
985+
; ILP32F-NEXT: [[C6:%[0-9]+]]:_(s32) = G_CONSTANT i32 7
986+
; ILP32F-NEXT: [[C7:%[0-9]+]]:_(s128) = G_CONSTANT i128 8
987+
; ILP32F-NEXT: [[C8:%[0-9]+]]:_(s32) = G_CONSTANT i32 9
988+
; ILP32F-NEXT: [[C9:%[0-9]+]]:_(s128) = G_FCONSTANT fp128 0xL00000000000000007FFF000000000000
989+
; ILP32F-NEXT: ADJCALLSTACKDOWN 8, 0, implicit-def $x2, implicit $x2
990+
; ILP32F-NEXT: [[FRAME_INDEX:%[0-9]+]]:_(p0) = G_FRAME_INDEX %stack.0
991+
; ILP32F-NEXT: G_STORE [[C7]](s128), [[FRAME_INDEX]](p0) :: (store (s128) into %stack.0, align 8)
992+
; ILP32F-NEXT: [[COPY:%[0-9]+]]:_(p0) = COPY $x2
993+
; ILP32F-NEXT: [[C10:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
994+
; ILP32F-NEXT: [[PTR_ADD:%[0-9]+]]:_(p0) = G_PTR_ADD [[COPY]], [[C10]](s32)
995+
; ILP32F-NEXT: G_STORE [[C8]](s32), [[PTR_ADD]](p0) :: (store (s32) into stack, align 16)
996+
; ILP32F-NEXT: [[FRAME_INDEX1:%[0-9]+]]:_(p0) = G_FRAME_INDEX %stack.1
997+
; ILP32F-NEXT: G_STORE [[C9]](s128), [[FRAME_INDEX1]](p0) :: (store (s128) into %stack.1)
998+
; ILP32F-NEXT: [[C11:%[0-9]+]]:_(s32) = G_CONSTANT i32 4
999+
; ILP32F-NEXT: [[PTR_ADD1:%[0-9]+]]:_(p0) = G_PTR_ADD [[COPY]], [[C11]](s32)
1000+
; ILP32F-NEXT: G_STORE [[FRAME_INDEX1]](p0), [[PTR_ADD1]](p0) :: (store (p0) into stack + 4)
1001+
; ILP32F-NEXT: $x10 = COPY [[C]](s32)
1002+
; ILP32F-NEXT: $x11 = COPY [[C1]](s32)
1003+
; ILP32F-NEXT: $x12 = COPY [[C2]](s32)
1004+
; ILP32F-NEXT: $x13 = COPY [[C3]](s32)
1005+
; ILP32F-NEXT: $x14 = COPY [[C4]](s32)
1006+
; ILP32F-NEXT: $x15 = COPY [[C5]](s32)
1007+
; ILP32F-NEXT: $x16 = COPY [[C6]](s32)
1008+
; ILP32F-NEXT: $x17 = COPY [[FRAME_INDEX]](p0)
1009+
; ILP32F-NEXT: PseudoCALL target-flags(riscv-call) @callee_large_scalars_exhausted_regs, csr_ilp32f_lp64f, implicit-def $x1, implicit $x10, implicit $x11, implicit $x12, implicit $x13, implicit $x14, implicit $x15, implicit $x16, implicit $x17, implicit-def $x10
1010+
; ILP32F-NEXT: ADJCALLSTACKUP 8, 0, implicit-def $x2, implicit $x2
1011+
; ILP32F-NEXT: [[COPY1:%[0-9]+]]:_(s32) = COPY $x10
1012+
; ILP32F-NEXT: $x10 = COPY [[COPY1]](s32)
1013+
; ILP32F-NEXT: PseudoRET implicit $x10
1014+
;
1015+
; ILP32D-LABEL: name: caller_large_scalars_exhausted_regs
1016+
; ILP32D: bb.1 (%ir-block.0):
1017+
; ILP32D-NEXT: [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 1
1018+
; ILP32D-NEXT: [[C1:%[0-9]+]]:_(s32) = G_CONSTANT i32 2
1019+
; ILP32D-NEXT: [[C2:%[0-9]+]]:_(s32) = G_CONSTANT i32 3
1020+
; ILP32D-NEXT: [[C3:%[0-9]+]]:_(s32) = G_CONSTANT i32 4
1021+
; ILP32D-NEXT: [[C4:%[0-9]+]]:_(s32) = G_CONSTANT i32 5
1022+
; ILP32D-NEXT: [[C5:%[0-9]+]]:_(s32) = G_CONSTANT i32 6
1023+
; ILP32D-NEXT: [[C6:%[0-9]+]]:_(s32) = G_CONSTANT i32 7
1024+
; ILP32D-NEXT: [[C7:%[0-9]+]]:_(s128) = G_CONSTANT i128 8
1025+
; ILP32D-NEXT: [[C8:%[0-9]+]]:_(s32) = G_CONSTANT i32 9
1026+
; ILP32D-NEXT: [[C9:%[0-9]+]]:_(s128) = G_FCONSTANT fp128 0xL00000000000000007FFF000000000000
1027+
; ILP32D-NEXT: ADJCALLSTACKDOWN 8, 0, implicit-def $x2, implicit $x2
1028+
; ILP32D-NEXT: [[FRAME_INDEX:%[0-9]+]]:_(p0) = G_FRAME_INDEX %stack.0
1029+
; ILP32D-NEXT: G_STORE [[C7]](s128), [[FRAME_INDEX]](p0) :: (store (s128) into %stack.0, align 8)
1030+
; ILP32D-NEXT: [[COPY:%[0-9]+]]:_(p0) = COPY $x2
1031+
; ILP32D-NEXT: [[C10:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
1032+
; ILP32D-NEXT: [[PTR_ADD:%[0-9]+]]:_(p0) = G_PTR_ADD [[COPY]], [[C10]](s32)
1033+
; ILP32D-NEXT: G_STORE [[C8]](s32), [[PTR_ADD]](p0) :: (store (s32) into stack, align 16)
1034+
; ILP32D-NEXT: [[FRAME_INDEX1:%[0-9]+]]:_(p0) = G_FRAME_INDEX %stack.1
1035+
; ILP32D-NEXT: G_STORE [[C9]](s128), [[FRAME_INDEX1]](p0) :: (store (s128) into %stack.1)
1036+
; ILP32D-NEXT: [[C11:%[0-9]+]]:_(s32) = G_CONSTANT i32 4
1037+
; ILP32D-NEXT: [[PTR_ADD1:%[0-9]+]]:_(p0) = G_PTR_ADD [[COPY]], [[C11]](s32)
1038+
; ILP32D-NEXT: G_STORE [[FRAME_INDEX1]](p0), [[PTR_ADD1]](p0) :: (store (p0) into stack + 4)
1039+
; ILP32D-NEXT: $x10 = COPY [[C]](s32)
1040+
; ILP32D-NEXT: $x11 = COPY [[C1]](s32)
1041+
; ILP32D-NEXT: $x12 = COPY [[C2]](s32)
1042+
; ILP32D-NEXT: $x13 = COPY [[C3]](s32)
1043+
; ILP32D-NEXT: $x14 = COPY [[C4]](s32)
1044+
; ILP32D-NEXT: $x15 = COPY [[C5]](s32)
1045+
; ILP32D-NEXT: $x16 = COPY [[C6]](s32)
1046+
; ILP32D-NEXT: $x17 = COPY [[FRAME_INDEX]](p0)
1047+
; ILP32D-NEXT: PseudoCALL target-flags(riscv-call) @callee_large_scalars_exhausted_regs, csr_ilp32d_lp64d, implicit-def $x1, implicit $x10, implicit $x11, implicit $x12, implicit $x13, implicit $x14, implicit $x15, implicit $x16, implicit $x17, implicit-def $x10
1048+
; ILP32D-NEXT: ADJCALLSTACKUP 8, 0, implicit-def $x2, implicit $x2
1049+
; ILP32D-NEXT: [[COPY1:%[0-9]+]]:_(s32) = COPY $x10
1050+
; ILP32D-NEXT: $x10 = COPY [[COPY1]](s32)
1051+
; ILP32D-NEXT: PseudoRET implicit $x10
1052+
%1 = call i32 @callee_large_scalars_exhausted_regs(
1053+
i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i128 8, i32 9,
1054+
fp128 0xL00000000000000007FFF000000000000)
1055+
ret i32 %1
1056+
}
1057+
8281058
; Check return of 2x xlen scalars
8291059

8301060
define i64 @callee_small_scalar_ret() nounwind {

0 commit comments

Comments
 (0)