[llvm] 32acf1e - [RISCV] Use XLenVT as LocVT for f16/f32/f164 with Zfinx in CC_RISCV_FastCC.
Craig Topper via llvm-commits
llvm-commits at lists.llvm.org
Mon Aug 26 16:35:49 PDT 2024
Author: Craig Topper
Date: 2024-08-26T16:34:12-07:00
New Revision: 32acf1e95b42614ef76cd98cdbc1b8aec0f0a830
URL: https://github.com/llvm/llvm-project/commit/32acf1e95b42614ef76cd98cdbc1b8aec0f0a830
DIFF: https://github.com/llvm/llvm-project/commit/32acf1e95b42614ef76cd98cdbc1b8aec0f0a830.diff
LOG: [RISCV] Use XLenVT as LocVT for f16/f32/f164 with Zfinx in CC_RISCV_FastCC.
This is need to make sure we create FMV_X_W/FMV_X_H/bitcast nodes
that match up with what return lowering will do.
Added:
Modified:
llvm/lib/Target/RISCV/RISCVISelLowering.cpp
llvm/test/CodeGen/RISCV/fastcc-without-f-reg.ll
Removed:
################################################################################
diff --git a/llvm/lib/Target/RISCV/RISCVISelLowering.cpp b/llvm/lib/Target/RISCV/RISCVISelLowering.cpp
index 4e86bee6a55b54..f59c74f6ab045f 100644
--- a/llvm/lib/Target/RISCV/RISCVISelLowering.cpp
+++ b/llvm/lib/Target/RISCV/RISCVISelLowering.cpp
@@ -19150,6 +19150,8 @@ bool RISCV::CC_RISCV_FastCC(const DataLayout &DL, RISCVABI::ABI ABI,
(LocVT == MVT::f64 && Subtarget.is64Bit() &&
Subtarget.hasStdExtZdinx())) {
if (MCRegister Reg = State.AllocateReg(getFastCCArgGPRs(ABI))) {
+ LocInfo = CCValAssign::BCvt;
+ LocVT = Subtarget.getXLenVT();
State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
return false;
}
diff --git a/llvm/test/CodeGen/RISCV/fastcc-without-f-reg.ll b/llvm/test/CodeGen/RISCV/fastcc-without-f-reg.ll
index 1dbb060fc35faf..2e7ca025314705 100644
--- a/llvm/test/CodeGen/RISCV/fastcc-without-f-reg.ll
+++ b/llvm/test/CodeGen/RISCV/fastcc-without-f-reg.ll
@@ -260,13 +260,13 @@ define half @caller_half_32(<32 x half> %A) nounwind {
; ZHINX32-NEXT: sw s9, 68(sp) # 4-byte Folded Spill
; ZHINX32-NEXT: sw s10, 64(sp) # 4-byte Folded Spill
; ZHINX32-NEXT: sw s11, 60(sp) # 4-byte Folded Spill
-; ZHINX32-NEXT: lh t0, 112(sp)
+; ZHINX32-NEXT: lh t0, 124(sp)
; ZHINX32-NEXT: sw t0, 56(sp) # 4-byte Folded Spill
-; ZHINX32-NEXT: lh t0, 116(sp)
-; ZHINX32-NEXT: sw t0, 52(sp) # 4-byte Folded Spill
; ZHINX32-NEXT: lh t0, 120(sp)
+; ZHINX32-NEXT: sw t0, 52(sp) # 4-byte Folded Spill
+; ZHINX32-NEXT: lh t0, 116(sp)
; ZHINX32-NEXT: sw t0, 48(sp) # 4-byte Folded Spill
-; ZHINX32-NEXT: lh t0, 124(sp)
+; ZHINX32-NEXT: lh t0, 112(sp)
; ZHINX32-NEXT: sw t0, 44(sp) # 4-byte Folded Spill
; ZHINX32-NEXT: lh t6, 128(sp)
; ZHINX32-NEXT: lh t5, 132(sp)
@@ -308,10 +308,10 @@ define half @caller_half_32(<32 x half> %A) nounwind {
; ZHINX32-NEXT: sh t4, 4(sp)
; ZHINX32-NEXT: sh t5, 2(sp)
; ZHINX32-NEXT: sh t6, 0(sp)
-; ZHINX32-NEXT: lw t3, 56(sp) # 4-byte Folded Reload
-; ZHINX32-NEXT: lw t4, 52(sp) # 4-byte Folded Reload
-; ZHINX32-NEXT: lw t5, 48(sp) # 4-byte Folded Reload
-; ZHINX32-NEXT: lw t6, 44(sp) # 4-byte Folded Reload
+; ZHINX32-NEXT: lw t3, 44(sp) # 4-byte Folded Reload
+; ZHINX32-NEXT: lw t4, 48(sp) # 4-byte Folded Reload
+; ZHINX32-NEXT: lw t5, 52(sp) # 4-byte Folded Reload
+; ZHINX32-NEXT: lw t6, 56(sp) # 4-byte Folded Reload
; ZHINX32-NEXT: call callee_half_32
; ZHINX32-NEXT: lw ra, 108(sp) # 4-byte Folded Reload
; ZHINX32-NEXT: lw s0, 104(sp) # 4-byte Folded Reload
@@ -345,13 +345,13 @@ define half @caller_half_32(<32 x half> %A) nounwind {
; ZHINX64-NEXT: sd s9, 88(sp) # 8-byte Folded Spill
; ZHINX64-NEXT: sd s10, 80(sp) # 8-byte Folded Spill
; ZHINX64-NEXT: sd s11, 72(sp) # 8-byte Folded Spill
-; ZHINX64-NEXT: lh t0, 176(sp)
+; ZHINX64-NEXT: lh t0, 200(sp)
; ZHINX64-NEXT: sd t0, 64(sp) # 8-byte Folded Spill
-; ZHINX64-NEXT: lh t0, 184(sp)
-; ZHINX64-NEXT: sd t0, 56(sp) # 8-byte Folded Spill
; ZHINX64-NEXT: lh t0, 192(sp)
+; ZHINX64-NEXT: sd t0, 56(sp) # 8-byte Folded Spill
+; ZHINX64-NEXT: lh t0, 184(sp)
; ZHINX64-NEXT: sd t0, 48(sp) # 8-byte Folded Spill
-; ZHINX64-NEXT: lh t0, 200(sp)
+; ZHINX64-NEXT: lh t0, 176(sp)
; ZHINX64-NEXT: sd t0, 40(sp) # 8-byte Folded Spill
; ZHINX64-NEXT: lh t6, 208(sp)
; ZHINX64-NEXT: lh t5, 216(sp)
@@ -393,10 +393,10 @@ define half @caller_half_32(<32 x half> %A) nounwind {
; ZHINX64-NEXT: sh t4, 4(sp)
; ZHINX64-NEXT: sh t5, 2(sp)
; ZHINX64-NEXT: sh t6, 0(sp)
-; ZHINX64-NEXT: ld t3, 64(sp) # 8-byte Folded Reload
-; ZHINX64-NEXT: ld t4, 56(sp) # 8-byte Folded Reload
-; ZHINX64-NEXT: ld t5, 48(sp) # 8-byte Folded Reload
-; ZHINX64-NEXT: ld t6, 40(sp) # 8-byte Folded Reload
+; ZHINX64-NEXT: ld t3, 40(sp) # 8-byte Folded Reload
+; ZHINX64-NEXT: ld t4, 48(sp) # 8-byte Folded Reload
+; ZHINX64-NEXT: ld t5, 56(sp) # 8-byte Folded Reload
+; ZHINX64-NEXT: ld t6, 64(sp) # 8-byte Folded Reload
; ZHINX64-NEXT: call callee_half_32
; ZHINX64-NEXT: ld ra, 168(sp) # 8-byte Folded Reload
; ZHINX64-NEXT: ld s0, 160(sp) # 8-byte Folded Reload
@@ -832,32 +832,28 @@ define fastcc float @callee_float_32(<32 x float> %A) nounwind {
define float @caller_float_32(<32 x float> %A) nounwind {
; ZHINX32-LABEL: caller_float_32:
; ZHINX32: # %bb.0:
-; ZHINX32-NEXT: addi sp, sp, -160
-; ZHINX32-NEXT: sw ra, 156(sp) # 4-byte Folded Spill
-; ZHINX32-NEXT: sw s0, 152(sp) # 4-byte Folded Spill
-; ZHINX32-NEXT: sw s1, 148(sp) # 4-byte Folded Spill
-; ZHINX32-NEXT: sw s2, 144(sp) # 4-byte Folded Spill
-; ZHINX32-NEXT: sw s3, 140(sp) # 4-byte Folded Spill
-; ZHINX32-NEXT: sw s4, 136(sp) # 4-byte Folded Spill
-; ZHINX32-NEXT: sw s5, 132(sp) # 4-byte Folded Spill
-; ZHINX32-NEXT: sw s6, 128(sp) # 4-byte Folded Spill
-; ZHINX32-NEXT: sw s7, 124(sp) # 4-byte Folded Spill
-; ZHINX32-NEXT: sw s8, 120(sp) # 4-byte Folded Spill
-; ZHINX32-NEXT: sw s9, 116(sp) # 4-byte Folded Spill
-; ZHINX32-NEXT: sw s10, 112(sp) # 4-byte Folded Spill
-; ZHINX32-NEXT: sw s11, 108(sp) # 4-byte Folded Spill
+; ZHINX32-NEXT: addi sp, sp, -144
+; ZHINX32-NEXT: sw ra, 140(sp) # 4-byte Folded Spill
+; ZHINX32-NEXT: sw s0, 136(sp) # 4-byte Folded Spill
+; ZHINX32-NEXT: sw s1, 132(sp) # 4-byte Folded Spill
+; ZHINX32-NEXT: sw s2, 128(sp) # 4-byte Folded Spill
+; ZHINX32-NEXT: sw s3, 124(sp) # 4-byte Folded Spill
+; ZHINX32-NEXT: sw s4, 120(sp) # 4-byte Folded Spill
+; ZHINX32-NEXT: sw s5, 116(sp) # 4-byte Folded Spill
+; ZHINX32-NEXT: sw s6, 112(sp) # 4-byte Folded Spill
+; ZHINX32-NEXT: sw s7, 108(sp) # 4-byte Folded Spill
+; ZHINX32-NEXT: sw s8, 104(sp) # 4-byte Folded Spill
+; ZHINX32-NEXT: sw s9, 100(sp) # 4-byte Folded Spill
+; ZHINX32-NEXT: sw s10, 96(sp) # 4-byte Folded Spill
+; ZHINX32-NEXT: sw s11, 92(sp) # 4-byte Folded Spill
; ZHINX32-NEXT: lw t0, 160(sp)
-; ZHINX32-NEXT: sw t0, 104(sp) # 4-byte Folded Spill
-; ZHINX32-NEXT: lw t0, 164(sp)
-; ZHINX32-NEXT: sw t0, 100(sp) # 4-byte Folded Spill
-; ZHINX32-NEXT: lw t0, 168(sp)
-; ZHINX32-NEXT: sw t0, 96(sp) # 4-byte Folded Spill
-; ZHINX32-NEXT: lw t0, 172(sp)
-; ZHINX32-NEXT: sw t0, 92(sp) # 4-byte Folded Spill
-; ZHINX32-NEXT: lw t6, 176(sp)
-; ZHINX32-NEXT: lw t5, 180(sp)
-; ZHINX32-NEXT: lw t4, 184(sp)
-; ZHINX32-NEXT: lw s0, 188(sp)
+; ZHINX32-NEXT: lw t1, 164(sp)
+; ZHINX32-NEXT: lw t2, 168(sp)
+; ZHINX32-NEXT: lw s0, 172(sp)
+; ZHINX32-NEXT: lw t3, 176(sp)
+; ZHINX32-NEXT: lw t4, 180(sp)
+; ZHINX32-NEXT: lw t5, 184(sp)
+; ZHINX32-NEXT: lw t6, 188(sp)
; ZHINX32-NEXT: lw s1, 192(sp)
; ZHINX32-NEXT: lw s2, 196(sp)
; ZHINX32-NEXT: lw s3, 200(sp)
@@ -870,49 +866,45 @@ define float @caller_float_32(<32 x float> %A) nounwind {
; ZHINX32-NEXT: lw s10, 228(sp)
; ZHINX32-NEXT: lw s11, 232(sp)
; ZHINX32-NEXT: lw ra, 236(sp)
-; ZHINX32-NEXT: lw t3, 240(sp)
-; ZHINX32-NEXT: lw t2, 244(sp)
-; ZHINX32-NEXT: lw t1, 248(sp)
-; ZHINX32-NEXT: lw t0, 252(sp)
-; ZHINX32-NEXT: sw t0, 76(sp)
-; ZHINX32-NEXT: sw t1, 72(sp)
-; ZHINX32-NEXT: sw t2, 68(sp)
-; ZHINX32-NEXT: sw t3, 64(sp)
-; ZHINX32-NEXT: sw ra, 60(sp)
-; ZHINX32-NEXT: sw s11, 56(sp)
-; ZHINX32-NEXT: sw s10, 52(sp)
-; ZHINX32-NEXT: sw s9, 48(sp)
-; ZHINX32-NEXT: sw s8, 44(sp)
-; ZHINX32-NEXT: sw s7, 40(sp)
-; ZHINX32-NEXT: sw s6, 36(sp)
-; ZHINX32-NEXT: sw s5, 32(sp)
-; ZHINX32-NEXT: sw s4, 28(sp)
-; ZHINX32-NEXT: sw s3, 24(sp)
-; ZHINX32-NEXT: sw s2, 20(sp)
-; ZHINX32-NEXT: sw s1, 16(sp)
+; ZHINX32-NEXT: sw ra, 76(sp)
+; ZHINX32-NEXT: sw s11, 72(sp)
+; ZHINX32-NEXT: sw s10, 68(sp)
+; ZHINX32-NEXT: sw s9, 64(sp)
+; ZHINX32-NEXT: sw s8, 60(sp)
+; ZHINX32-NEXT: sw s7, 56(sp)
+; ZHINX32-NEXT: sw s6, 52(sp)
+; ZHINX32-NEXT: sw s5, 48(sp)
+; ZHINX32-NEXT: sw s4, 44(sp)
+; ZHINX32-NEXT: sw s3, 40(sp)
+; ZHINX32-NEXT: sw s2, 36(sp)
+; ZHINX32-NEXT: sw s1, 32(sp)
+; ZHINX32-NEXT: sw t6, 28(sp)
+; ZHINX32-NEXT: sw t5, 24(sp)
+; ZHINX32-NEXT: sw t4, 20(sp)
+; ZHINX32-NEXT: sw t3, 16(sp)
+; ZHINX32-NEXT: lw t3, 144(sp)
+; ZHINX32-NEXT: lw t4, 148(sp)
+; ZHINX32-NEXT: lw t5, 152(sp)
+; ZHINX32-NEXT: lw t6, 156(sp)
; ZHINX32-NEXT: sw s0, 12(sp)
-; ZHINX32-NEXT: sw t4, 8(sp)
-; ZHINX32-NEXT: sw t5, 4(sp)
-; ZHINX32-NEXT: sw t6, 0(sp)
-; ZHINX32-NEXT: lw t3, 104(sp) # 4-byte Folded Reload
-; ZHINX32-NEXT: lw t4, 100(sp) # 4-byte Folded Reload
-; ZHINX32-NEXT: lw t5, 96(sp) # 4-byte Folded Reload
-; ZHINX32-NEXT: lw t6, 92(sp) # 4-byte Folded Reload
+; ZHINX32-NEXT: sw t2, 8(sp)
+; ZHINX32-NEXT: sw t1, 4(sp)
+; ZHINX32-NEXT: sw t0, 0(sp)
; ZHINX32-NEXT: call callee_float_32
-; ZHINX32-NEXT: lw ra, 156(sp) # 4-byte Folded Reload
-; ZHINX32-NEXT: lw s0, 152(sp) # 4-byte Folded Reload
-; ZHINX32-NEXT: lw s1, 148(sp) # 4-byte Folded Reload
-; ZHINX32-NEXT: lw s2, 144(sp) # 4-byte Folded Reload
-; ZHINX32-NEXT: lw s3, 140(sp) # 4-byte Folded Reload
-; ZHINX32-NEXT: lw s4, 136(sp) # 4-byte Folded Reload
-; ZHINX32-NEXT: lw s5, 132(sp) # 4-byte Folded Reload
-; ZHINX32-NEXT: lw s6, 128(sp) # 4-byte Folded Reload
-; ZHINX32-NEXT: lw s7, 124(sp) # 4-byte Folded Reload
-; ZHINX32-NEXT: lw s8, 120(sp) # 4-byte Folded Reload
-; ZHINX32-NEXT: lw s9, 116(sp) # 4-byte Folded Reload
-; ZHINX32-NEXT: lw s10, 112(sp) # 4-byte Folded Reload
-; ZHINX32-NEXT: lw s11, 108(sp) # 4-byte Folded Reload
-; ZHINX32-NEXT: addi sp, sp, 160
+; ZHINX32-NEXT: lw ra, 140(sp) # 4-byte Folded Reload
+; ZHINX32-NEXT: lw s0, 136(sp) # 4-byte Folded Reload
+; ZHINX32-NEXT: lw s1, 132(sp) # 4-byte Folded Reload
+; ZHINX32-NEXT: lw s2, 128(sp) # 4-byte Folded Reload
+; ZHINX32-NEXT: lw s3, 124(sp) # 4-byte Folded Reload
+; ZHINX32-NEXT: lw s4, 120(sp) # 4-byte Folded Reload
+; ZHINX32-NEXT: lw s5, 116(sp) # 4-byte Folded Reload
+; ZHINX32-NEXT: lw s6, 112(sp) # 4-byte Folded Reload
+; ZHINX32-NEXT: lw s7, 108(sp) # 4-byte Folded Reload
+; ZHINX32-NEXT: lw s8, 104(sp) # 4-byte Folded Reload
+; ZHINX32-NEXT: lw s9, 100(sp) # 4-byte Folded Reload
+; ZHINX32-NEXT: lw s10, 96(sp) # 4-byte Folded Reload
+; ZHINX32-NEXT: lw s11, 92(sp) # 4-byte Folded Reload
+; ZHINX32-NEXT: addi sp, sp, 144
; ZHINX32-NEXT: ret
;
; ZHINX64-LABEL: caller_float_32:
@@ -931,13 +923,13 @@ define float @caller_float_32(<32 x float> %A) nounwind {
; ZHINX64-NEXT: sd s9, 136(sp) # 8-byte Folded Spill
; ZHINX64-NEXT: sd s10, 128(sp) # 8-byte Folded Spill
; ZHINX64-NEXT: sd s11, 120(sp) # 8-byte Folded Spill
-; ZHINX64-NEXT: lw t0, 224(sp)
+; ZHINX64-NEXT: lw t0, 248(sp)
; ZHINX64-NEXT: sd t0, 112(sp) # 8-byte Folded Spill
-; ZHINX64-NEXT: lw t0, 232(sp)
-; ZHINX64-NEXT: sd t0, 104(sp) # 8-byte Folded Spill
; ZHINX64-NEXT: lw t0, 240(sp)
+; ZHINX64-NEXT: sd t0, 104(sp) # 8-byte Folded Spill
+; ZHINX64-NEXT: lw t0, 232(sp)
; ZHINX64-NEXT: sd t0, 96(sp) # 8-byte Folded Spill
-; ZHINX64-NEXT: lw t0, 248(sp)
+; ZHINX64-NEXT: lw t0, 224(sp)
; ZHINX64-NEXT: sd t0, 88(sp) # 8-byte Folded Spill
; ZHINX64-NEXT: lw t6, 256(sp)
; ZHINX64-NEXT: lw t5, 264(sp)
@@ -979,10 +971,10 @@ define float @caller_float_32(<32 x float> %A) nounwind {
; ZHINX64-NEXT: sw t4, 8(sp)
; ZHINX64-NEXT: sw t5, 4(sp)
; ZHINX64-NEXT: sw t6, 0(sp)
-; ZHINX64-NEXT: ld t3, 112(sp) # 8-byte Folded Reload
-; ZHINX64-NEXT: ld t4, 104(sp) # 8-byte Folded Reload
-; ZHINX64-NEXT: ld t5, 96(sp) # 8-byte Folded Reload
-; ZHINX64-NEXT: ld t6, 88(sp) # 8-byte Folded Reload
+; ZHINX64-NEXT: ld t3, 88(sp) # 8-byte Folded Reload
+; ZHINX64-NEXT: ld t4, 96(sp) # 8-byte Folded Reload
+; ZHINX64-NEXT: ld t5, 104(sp) # 8-byte Folded Reload
+; ZHINX64-NEXT: ld t6, 112(sp) # 8-byte Folded Reload
; ZHINX64-NEXT: call callee_float_32
; ZHINX64-NEXT: ld ra, 216(sp) # 8-byte Folded Reload
; ZHINX64-NEXT: ld s0, 208(sp) # 8-byte Folded Reload
@@ -1002,32 +994,28 @@ define float @caller_float_32(<32 x float> %A) nounwind {
;
; ZFINX32-LABEL: caller_float_32:
; ZFINX32: # %bb.0:
-; ZFINX32-NEXT: addi sp, sp, -160
-; ZFINX32-NEXT: sw ra, 156(sp) # 4-byte Folded Spill
-; ZFINX32-NEXT: sw s0, 152(sp) # 4-byte Folded Spill
-; ZFINX32-NEXT: sw s1, 148(sp) # 4-byte Folded Spill
-; ZFINX32-NEXT: sw s2, 144(sp) # 4-byte Folded Spill
-; ZFINX32-NEXT: sw s3, 140(sp) # 4-byte Folded Spill
-; ZFINX32-NEXT: sw s4, 136(sp) # 4-byte Folded Spill
-; ZFINX32-NEXT: sw s5, 132(sp) # 4-byte Folded Spill
-; ZFINX32-NEXT: sw s6, 128(sp) # 4-byte Folded Spill
-; ZFINX32-NEXT: sw s7, 124(sp) # 4-byte Folded Spill
-; ZFINX32-NEXT: sw s8, 120(sp) # 4-byte Folded Spill
-; ZFINX32-NEXT: sw s9, 116(sp) # 4-byte Folded Spill
-; ZFINX32-NEXT: sw s10, 112(sp) # 4-byte Folded Spill
-; ZFINX32-NEXT: sw s11, 108(sp) # 4-byte Folded Spill
+; ZFINX32-NEXT: addi sp, sp, -144
+; ZFINX32-NEXT: sw ra, 140(sp) # 4-byte Folded Spill
+; ZFINX32-NEXT: sw s0, 136(sp) # 4-byte Folded Spill
+; ZFINX32-NEXT: sw s1, 132(sp) # 4-byte Folded Spill
+; ZFINX32-NEXT: sw s2, 128(sp) # 4-byte Folded Spill
+; ZFINX32-NEXT: sw s3, 124(sp) # 4-byte Folded Spill
+; ZFINX32-NEXT: sw s4, 120(sp) # 4-byte Folded Spill
+; ZFINX32-NEXT: sw s5, 116(sp) # 4-byte Folded Spill
+; ZFINX32-NEXT: sw s6, 112(sp) # 4-byte Folded Spill
+; ZFINX32-NEXT: sw s7, 108(sp) # 4-byte Folded Spill
+; ZFINX32-NEXT: sw s8, 104(sp) # 4-byte Folded Spill
+; ZFINX32-NEXT: sw s9, 100(sp) # 4-byte Folded Spill
+; ZFINX32-NEXT: sw s10, 96(sp) # 4-byte Folded Spill
+; ZFINX32-NEXT: sw s11, 92(sp) # 4-byte Folded Spill
; ZFINX32-NEXT: lw t0, 160(sp)
-; ZFINX32-NEXT: sw t0, 104(sp) # 4-byte Folded Spill
-; ZFINX32-NEXT: lw t0, 164(sp)
-; ZFINX32-NEXT: sw t0, 100(sp) # 4-byte Folded Spill
-; ZFINX32-NEXT: lw t0, 168(sp)
-; ZFINX32-NEXT: sw t0, 96(sp) # 4-byte Folded Spill
-; ZFINX32-NEXT: lw t0, 172(sp)
-; ZFINX32-NEXT: sw t0, 92(sp) # 4-byte Folded Spill
-; ZFINX32-NEXT: lw t6, 176(sp)
-; ZFINX32-NEXT: lw t5, 180(sp)
-; ZFINX32-NEXT: lw t4, 184(sp)
-; ZFINX32-NEXT: lw s0, 188(sp)
+; ZFINX32-NEXT: lw t1, 164(sp)
+; ZFINX32-NEXT: lw t2, 168(sp)
+; ZFINX32-NEXT: lw s0, 172(sp)
+; ZFINX32-NEXT: lw t3, 176(sp)
+; ZFINX32-NEXT: lw t4, 180(sp)
+; ZFINX32-NEXT: lw t5, 184(sp)
+; ZFINX32-NEXT: lw t6, 188(sp)
; ZFINX32-NEXT: lw s1, 192(sp)
; ZFINX32-NEXT: lw s2, 196(sp)
; ZFINX32-NEXT: lw s3, 200(sp)
@@ -1040,49 +1028,45 @@ define float @caller_float_32(<32 x float> %A) nounwind {
; ZFINX32-NEXT: lw s10, 228(sp)
; ZFINX32-NEXT: lw s11, 232(sp)
; ZFINX32-NEXT: lw ra, 236(sp)
-; ZFINX32-NEXT: lw t3, 240(sp)
-; ZFINX32-NEXT: lw t2, 244(sp)
-; ZFINX32-NEXT: lw t1, 248(sp)
-; ZFINX32-NEXT: lw t0, 252(sp)
-; ZFINX32-NEXT: sw t0, 76(sp)
-; ZFINX32-NEXT: sw t1, 72(sp)
-; ZFINX32-NEXT: sw t2, 68(sp)
-; ZFINX32-NEXT: sw t3, 64(sp)
-; ZFINX32-NEXT: sw ra, 60(sp)
-; ZFINX32-NEXT: sw s11, 56(sp)
-; ZFINX32-NEXT: sw s10, 52(sp)
-; ZFINX32-NEXT: sw s9, 48(sp)
-; ZFINX32-NEXT: sw s8, 44(sp)
-; ZFINX32-NEXT: sw s7, 40(sp)
-; ZFINX32-NEXT: sw s6, 36(sp)
-; ZFINX32-NEXT: sw s5, 32(sp)
-; ZFINX32-NEXT: sw s4, 28(sp)
-; ZFINX32-NEXT: sw s3, 24(sp)
-; ZFINX32-NEXT: sw s2, 20(sp)
-; ZFINX32-NEXT: sw s1, 16(sp)
+; ZFINX32-NEXT: sw ra, 76(sp)
+; ZFINX32-NEXT: sw s11, 72(sp)
+; ZFINX32-NEXT: sw s10, 68(sp)
+; ZFINX32-NEXT: sw s9, 64(sp)
+; ZFINX32-NEXT: sw s8, 60(sp)
+; ZFINX32-NEXT: sw s7, 56(sp)
+; ZFINX32-NEXT: sw s6, 52(sp)
+; ZFINX32-NEXT: sw s5, 48(sp)
+; ZFINX32-NEXT: sw s4, 44(sp)
+; ZFINX32-NEXT: sw s3, 40(sp)
+; ZFINX32-NEXT: sw s2, 36(sp)
+; ZFINX32-NEXT: sw s1, 32(sp)
+; ZFINX32-NEXT: sw t6, 28(sp)
+; ZFINX32-NEXT: sw t5, 24(sp)
+; ZFINX32-NEXT: sw t4, 20(sp)
+; ZFINX32-NEXT: sw t3, 16(sp)
+; ZFINX32-NEXT: lw t3, 144(sp)
+; ZFINX32-NEXT: lw t4, 148(sp)
+; ZFINX32-NEXT: lw t5, 152(sp)
+; ZFINX32-NEXT: lw t6, 156(sp)
; ZFINX32-NEXT: sw s0, 12(sp)
-; ZFINX32-NEXT: sw t4, 8(sp)
-; ZFINX32-NEXT: sw t5, 4(sp)
-; ZFINX32-NEXT: sw t6, 0(sp)
-; ZFINX32-NEXT: lw t3, 104(sp) # 4-byte Folded Reload
-; ZFINX32-NEXT: lw t4, 100(sp) # 4-byte Folded Reload
-; ZFINX32-NEXT: lw t5, 96(sp) # 4-byte Folded Reload
-; ZFINX32-NEXT: lw t6, 92(sp) # 4-byte Folded Reload
+; ZFINX32-NEXT: sw t2, 8(sp)
+; ZFINX32-NEXT: sw t1, 4(sp)
+; ZFINX32-NEXT: sw t0, 0(sp)
; ZFINX32-NEXT: call callee_float_32
-; ZFINX32-NEXT: lw ra, 156(sp) # 4-byte Folded Reload
-; ZFINX32-NEXT: lw s0, 152(sp) # 4-byte Folded Reload
-; ZFINX32-NEXT: lw s1, 148(sp) # 4-byte Folded Reload
-; ZFINX32-NEXT: lw s2, 144(sp) # 4-byte Folded Reload
-; ZFINX32-NEXT: lw s3, 140(sp) # 4-byte Folded Reload
-; ZFINX32-NEXT: lw s4, 136(sp) # 4-byte Folded Reload
-; ZFINX32-NEXT: lw s5, 132(sp) # 4-byte Folded Reload
-; ZFINX32-NEXT: lw s6, 128(sp) # 4-byte Folded Reload
-; ZFINX32-NEXT: lw s7, 124(sp) # 4-byte Folded Reload
-; ZFINX32-NEXT: lw s8, 120(sp) # 4-byte Folded Reload
-; ZFINX32-NEXT: lw s9, 116(sp) # 4-byte Folded Reload
-; ZFINX32-NEXT: lw s10, 112(sp) # 4-byte Folded Reload
-; ZFINX32-NEXT: lw s11, 108(sp) # 4-byte Folded Reload
-; ZFINX32-NEXT: addi sp, sp, 160
+; ZFINX32-NEXT: lw ra, 140(sp) # 4-byte Folded Reload
+; ZFINX32-NEXT: lw s0, 136(sp) # 4-byte Folded Reload
+; ZFINX32-NEXT: lw s1, 132(sp) # 4-byte Folded Reload
+; ZFINX32-NEXT: lw s2, 128(sp) # 4-byte Folded Reload
+; ZFINX32-NEXT: lw s3, 124(sp) # 4-byte Folded Reload
+; ZFINX32-NEXT: lw s4, 120(sp) # 4-byte Folded Reload
+; ZFINX32-NEXT: lw s5, 116(sp) # 4-byte Folded Reload
+; ZFINX32-NEXT: lw s6, 112(sp) # 4-byte Folded Reload
+; ZFINX32-NEXT: lw s7, 108(sp) # 4-byte Folded Reload
+; ZFINX32-NEXT: lw s8, 104(sp) # 4-byte Folded Reload
+; ZFINX32-NEXT: lw s9, 100(sp) # 4-byte Folded Reload
+; ZFINX32-NEXT: lw s10, 96(sp) # 4-byte Folded Reload
+; ZFINX32-NEXT: lw s11, 92(sp) # 4-byte Folded Reload
+; ZFINX32-NEXT: addi sp, sp, 144
; ZFINX32-NEXT: ret
;
; ZFINX64-LABEL: caller_float_32:
@@ -1101,13 +1085,13 @@ define float @caller_float_32(<32 x float> %A) nounwind {
; ZFINX64-NEXT: sd s9, 136(sp) # 8-byte Folded Spill
; ZFINX64-NEXT: sd s10, 128(sp) # 8-byte Folded Spill
; ZFINX64-NEXT: sd s11, 120(sp) # 8-byte Folded Spill
-; ZFINX64-NEXT: lw t0, 224(sp)
+; ZFINX64-NEXT: lw t0, 248(sp)
; ZFINX64-NEXT: sd t0, 112(sp) # 8-byte Folded Spill
-; ZFINX64-NEXT: lw t0, 232(sp)
-; ZFINX64-NEXT: sd t0, 104(sp) # 8-byte Folded Spill
; ZFINX64-NEXT: lw t0, 240(sp)
+; ZFINX64-NEXT: sd t0, 104(sp) # 8-byte Folded Spill
+; ZFINX64-NEXT: lw t0, 232(sp)
; ZFINX64-NEXT: sd t0, 96(sp) # 8-byte Folded Spill
-; ZFINX64-NEXT: lw t0, 248(sp)
+; ZFINX64-NEXT: lw t0, 224(sp)
; ZFINX64-NEXT: sd t0, 88(sp) # 8-byte Folded Spill
; ZFINX64-NEXT: lw t6, 256(sp)
; ZFINX64-NEXT: lw t5, 264(sp)
@@ -1149,10 +1133,10 @@ define float @caller_float_32(<32 x float> %A) nounwind {
; ZFINX64-NEXT: sw t4, 8(sp)
; ZFINX64-NEXT: sw t5, 4(sp)
; ZFINX64-NEXT: sw t6, 0(sp)
-; ZFINX64-NEXT: ld t3, 112(sp) # 8-byte Folded Reload
-; ZFINX64-NEXT: ld t4, 104(sp) # 8-byte Folded Reload
-; ZFINX64-NEXT: ld t5, 96(sp) # 8-byte Folded Reload
-; ZFINX64-NEXT: ld t6, 88(sp) # 8-byte Folded Reload
+; ZFINX64-NEXT: ld t3, 88(sp) # 8-byte Folded Reload
+; ZFINX64-NEXT: ld t4, 96(sp) # 8-byte Folded Reload
+; ZFINX64-NEXT: ld t5, 104(sp) # 8-byte Folded Reload
+; ZFINX64-NEXT: ld t6, 112(sp) # 8-byte Folded Reload
; ZFINX64-NEXT: call callee_float_32
; ZFINX64-NEXT: ld ra, 216(sp) # 8-byte Folded Reload
; ZFINX64-NEXT: ld s0, 208(sp) # 8-byte Folded Reload
@@ -1172,32 +1156,28 @@ define float @caller_float_32(<32 x float> %A) nounwind {
;
; ZDINX32-LABEL: caller_float_32:
; ZDINX32: # %bb.0:
-; ZDINX32-NEXT: addi sp, sp, -160
-; ZDINX32-NEXT: sw ra, 156(sp) # 4-byte Folded Spill
-; ZDINX32-NEXT: sw s0, 152(sp) # 4-byte Folded Spill
-; ZDINX32-NEXT: sw s1, 148(sp) # 4-byte Folded Spill
-; ZDINX32-NEXT: sw s2, 144(sp) # 4-byte Folded Spill
-; ZDINX32-NEXT: sw s3, 140(sp) # 4-byte Folded Spill
-; ZDINX32-NEXT: sw s4, 136(sp) # 4-byte Folded Spill
-; ZDINX32-NEXT: sw s5, 132(sp) # 4-byte Folded Spill
-; ZDINX32-NEXT: sw s6, 128(sp) # 4-byte Folded Spill
-; ZDINX32-NEXT: sw s7, 124(sp) # 4-byte Folded Spill
-; ZDINX32-NEXT: sw s8, 120(sp) # 4-byte Folded Spill
-; ZDINX32-NEXT: sw s9, 116(sp) # 4-byte Folded Spill
-; ZDINX32-NEXT: sw s10, 112(sp) # 4-byte Folded Spill
-; ZDINX32-NEXT: sw s11, 108(sp) # 4-byte Folded Spill
+; ZDINX32-NEXT: addi sp, sp, -144
+; ZDINX32-NEXT: sw ra, 140(sp) # 4-byte Folded Spill
+; ZDINX32-NEXT: sw s0, 136(sp) # 4-byte Folded Spill
+; ZDINX32-NEXT: sw s1, 132(sp) # 4-byte Folded Spill
+; ZDINX32-NEXT: sw s2, 128(sp) # 4-byte Folded Spill
+; ZDINX32-NEXT: sw s3, 124(sp) # 4-byte Folded Spill
+; ZDINX32-NEXT: sw s4, 120(sp) # 4-byte Folded Spill
+; ZDINX32-NEXT: sw s5, 116(sp) # 4-byte Folded Spill
+; ZDINX32-NEXT: sw s6, 112(sp) # 4-byte Folded Spill
+; ZDINX32-NEXT: sw s7, 108(sp) # 4-byte Folded Spill
+; ZDINX32-NEXT: sw s8, 104(sp) # 4-byte Folded Spill
+; ZDINX32-NEXT: sw s9, 100(sp) # 4-byte Folded Spill
+; ZDINX32-NEXT: sw s10, 96(sp) # 4-byte Folded Spill
+; ZDINX32-NEXT: sw s11, 92(sp) # 4-byte Folded Spill
; ZDINX32-NEXT: lw t0, 160(sp)
-; ZDINX32-NEXT: sw t0, 104(sp) # 4-byte Folded Spill
-; ZDINX32-NEXT: lw t0, 164(sp)
-; ZDINX32-NEXT: sw t0, 100(sp) # 4-byte Folded Spill
-; ZDINX32-NEXT: lw t0, 168(sp)
-; ZDINX32-NEXT: sw t0, 96(sp) # 4-byte Folded Spill
-; ZDINX32-NEXT: lw t0, 172(sp)
-; ZDINX32-NEXT: sw t0, 92(sp) # 4-byte Folded Spill
-; ZDINX32-NEXT: lw t6, 176(sp)
-; ZDINX32-NEXT: lw t5, 180(sp)
-; ZDINX32-NEXT: lw t4, 184(sp)
-; ZDINX32-NEXT: lw s0, 188(sp)
+; ZDINX32-NEXT: lw t1, 164(sp)
+; ZDINX32-NEXT: lw t2, 168(sp)
+; ZDINX32-NEXT: lw s0, 172(sp)
+; ZDINX32-NEXT: lw t3, 176(sp)
+; ZDINX32-NEXT: lw t4, 180(sp)
+; ZDINX32-NEXT: lw t5, 184(sp)
+; ZDINX32-NEXT: lw t6, 188(sp)
; ZDINX32-NEXT: lw s1, 192(sp)
; ZDINX32-NEXT: lw s2, 196(sp)
; ZDINX32-NEXT: lw s3, 200(sp)
@@ -1210,49 +1190,45 @@ define float @caller_float_32(<32 x float> %A) nounwind {
; ZDINX32-NEXT: lw s10, 228(sp)
; ZDINX32-NEXT: lw s11, 232(sp)
; ZDINX32-NEXT: lw ra, 236(sp)
-; ZDINX32-NEXT: lw t3, 240(sp)
-; ZDINX32-NEXT: lw t2, 244(sp)
-; ZDINX32-NEXT: lw t1, 248(sp)
-; ZDINX32-NEXT: lw t0, 252(sp)
-; ZDINX32-NEXT: sw t0, 76(sp)
-; ZDINX32-NEXT: sw t1, 72(sp)
-; ZDINX32-NEXT: sw t2, 68(sp)
-; ZDINX32-NEXT: sw t3, 64(sp)
-; ZDINX32-NEXT: sw ra, 60(sp)
-; ZDINX32-NEXT: sw s11, 56(sp)
-; ZDINX32-NEXT: sw s10, 52(sp)
-; ZDINX32-NEXT: sw s9, 48(sp)
-; ZDINX32-NEXT: sw s8, 44(sp)
-; ZDINX32-NEXT: sw s7, 40(sp)
-; ZDINX32-NEXT: sw s6, 36(sp)
-; ZDINX32-NEXT: sw s5, 32(sp)
-; ZDINX32-NEXT: sw s4, 28(sp)
-; ZDINX32-NEXT: sw s3, 24(sp)
-; ZDINX32-NEXT: sw s2, 20(sp)
-; ZDINX32-NEXT: sw s1, 16(sp)
+; ZDINX32-NEXT: sw ra, 76(sp)
+; ZDINX32-NEXT: sw s11, 72(sp)
+; ZDINX32-NEXT: sw s10, 68(sp)
+; ZDINX32-NEXT: sw s9, 64(sp)
+; ZDINX32-NEXT: sw s8, 60(sp)
+; ZDINX32-NEXT: sw s7, 56(sp)
+; ZDINX32-NEXT: sw s6, 52(sp)
+; ZDINX32-NEXT: sw s5, 48(sp)
+; ZDINX32-NEXT: sw s4, 44(sp)
+; ZDINX32-NEXT: sw s3, 40(sp)
+; ZDINX32-NEXT: sw s2, 36(sp)
+; ZDINX32-NEXT: sw s1, 32(sp)
+; ZDINX32-NEXT: sw t6, 28(sp)
+; ZDINX32-NEXT: sw t5, 24(sp)
+; ZDINX32-NEXT: sw t4, 20(sp)
+; ZDINX32-NEXT: sw t3, 16(sp)
+; ZDINX32-NEXT: lw t3, 144(sp)
+; ZDINX32-NEXT: lw t4, 148(sp)
+; ZDINX32-NEXT: lw t5, 152(sp)
+; ZDINX32-NEXT: lw t6, 156(sp)
; ZDINX32-NEXT: sw s0, 12(sp)
-; ZDINX32-NEXT: sw t4, 8(sp)
-; ZDINX32-NEXT: sw t5, 4(sp)
-; ZDINX32-NEXT: sw t6, 0(sp)
-; ZDINX32-NEXT: lw t3, 104(sp) # 4-byte Folded Reload
-; ZDINX32-NEXT: lw t4, 100(sp) # 4-byte Folded Reload
-; ZDINX32-NEXT: lw t5, 96(sp) # 4-byte Folded Reload
-; ZDINX32-NEXT: lw t6, 92(sp) # 4-byte Folded Reload
+; ZDINX32-NEXT: sw t2, 8(sp)
+; ZDINX32-NEXT: sw t1, 4(sp)
+; ZDINX32-NEXT: sw t0, 0(sp)
; ZDINX32-NEXT: call callee_float_32
-; ZDINX32-NEXT: lw ra, 156(sp) # 4-byte Folded Reload
-; ZDINX32-NEXT: lw s0, 152(sp) # 4-byte Folded Reload
-; ZDINX32-NEXT: lw s1, 148(sp) # 4-byte Folded Reload
-; ZDINX32-NEXT: lw s2, 144(sp) # 4-byte Folded Reload
-; ZDINX32-NEXT: lw s3, 140(sp) # 4-byte Folded Reload
-; ZDINX32-NEXT: lw s4, 136(sp) # 4-byte Folded Reload
-; ZDINX32-NEXT: lw s5, 132(sp) # 4-byte Folded Reload
-; ZDINX32-NEXT: lw s6, 128(sp) # 4-byte Folded Reload
-; ZDINX32-NEXT: lw s7, 124(sp) # 4-byte Folded Reload
-; ZDINX32-NEXT: lw s8, 120(sp) # 4-byte Folded Reload
-; ZDINX32-NEXT: lw s9, 116(sp) # 4-byte Folded Reload
-; ZDINX32-NEXT: lw s10, 112(sp) # 4-byte Folded Reload
-; ZDINX32-NEXT: lw s11, 108(sp) # 4-byte Folded Reload
-; ZDINX32-NEXT: addi sp, sp, 160
+; ZDINX32-NEXT: lw ra, 140(sp) # 4-byte Folded Reload
+; ZDINX32-NEXT: lw s0, 136(sp) # 4-byte Folded Reload
+; ZDINX32-NEXT: lw s1, 132(sp) # 4-byte Folded Reload
+; ZDINX32-NEXT: lw s2, 128(sp) # 4-byte Folded Reload
+; ZDINX32-NEXT: lw s3, 124(sp) # 4-byte Folded Reload
+; ZDINX32-NEXT: lw s4, 120(sp) # 4-byte Folded Reload
+; ZDINX32-NEXT: lw s5, 116(sp) # 4-byte Folded Reload
+; ZDINX32-NEXT: lw s6, 112(sp) # 4-byte Folded Reload
+; ZDINX32-NEXT: lw s7, 108(sp) # 4-byte Folded Reload
+; ZDINX32-NEXT: lw s8, 104(sp) # 4-byte Folded Reload
+; ZDINX32-NEXT: lw s9, 100(sp) # 4-byte Folded Reload
+; ZDINX32-NEXT: lw s10, 96(sp) # 4-byte Folded Reload
+; ZDINX32-NEXT: lw s11, 92(sp) # 4-byte Folded Reload
+; ZDINX32-NEXT: addi sp, sp, 144
; ZDINX32-NEXT: ret
;
; ZDINX64-LABEL: caller_float_32:
@@ -1271,13 +1247,13 @@ define float @caller_float_32(<32 x float> %A) nounwind {
; ZDINX64-NEXT: sd s9, 136(sp) # 8-byte Folded Spill
; ZDINX64-NEXT: sd s10, 128(sp) # 8-byte Folded Spill
; ZDINX64-NEXT: sd s11, 120(sp) # 8-byte Folded Spill
-; ZDINX64-NEXT: lw t0, 224(sp)
+; ZDINX64-NEXT: lw t0, 248(sp)
; ZDINX64-NEXT: sd t0, 112(sp) # 8-byte Folded Spill
-; ZDINX64-NEXT: lw t0, 232(sp)
-; ZDINX64-NEXT: sd t0, 104(sp) # 8-byte Folded Spill
; ZDINX64-NEXT: lw t0, 240(sp)
+; ZDINX64-NEXT: sd t0, 104(sp) # 8-byte Folded Spill
+; ZDINX64-NEXT: lw t0, 232(sp)
; ZDINX64-NEXT: sd t0, 96(sp) # 8-byte Folded Spill
-; ZDINX64-NEXT: lw t0, 248(sp)
+; ZDINX64-NEXT: lw t0, 224(sp)
; ZDINX64-NEXT: sd t0, 88(sp) # 8-byte Folded Spill
; ZDINX64-NEXT: lw t6, 256(sp)
; ZDINX64-NEXT: lw t5, 264(sp)
@@ -1319,10 +1295,10 @@ define float @caller_float_32(<32 x float> %A) nounwind {
; ZDINX64-NEXT: sw t4, 8(sp)
; ZDINX64-NEXT: sw t5, 4(sp)
; ZDINX64-NEXT: sw t6, 0(sp)
-; ZDINX64-NEXT: ld t3, 112(sp) # 8-byte Folded Reload
-; ZDINX64-NEXT: ld t4, 104(sp) # 8-byte Folded Reload
-; ZDINX64-NEXT: ld t5, 96(sp) # 8-byte Folded Reload
-; ZDINX64-NEXT: ld t6, 88(sp) # 8-byte Folded Reload
+; ZDINX64-NEXT: ld t3, 88(sp) # 8-byte Folded Reload
+; ZDINX64-NEXT: ld t4, 96(sp) # 8-byte Folded Reload
+; ZDINX64-NEXT: ld t5, 104(sp) # 8-byte Folded Reload
+; ZDINX64-NEXT: ld t6, 112(sp) # 8-byte Folded Reload
; ZDINX64-NEXT: call callee_float_32
; ZDINX64-NEXT: ld ra, 216(sp) # 8-byte Folded Reload
; ZDINX64-NEXT: ld s0, 208(sp) # 8-byte Folded Reload
More information about the llvm-commits
mailing list