llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-debuginfo Author: Piyou Chen (BeMg) <details> <summary>Changes</summary> This is patch 4 of 4. Together, they adjust `tryAssignCSRFirstTime` and the `getCSRCost` value to improve prologue/epilogue codegen in benchmarks. - https://github.com/llvm/llvm-project/pull/239526 - https://github.com/llvm/llvm-project/pull/239530 - https://github.com/llvm/llvm-project/pull/239532 - https://github.com/llvm/llvm-project/pull/239534 ----- This patch update the getCSRCost value in RISC-V target. It choose 32768 because the (1 << 14) * 2. ----- After increasing CSRCost from 5 to 32768 and giving the greedy register allocator more choices for unused CSRs, SPEC shows an reduction (Geomean -4.63%) in dynamic instruction count. | ICount Redcue % -- | -- 706.stockfish_r | 0.07% 707.ntest_r | 1.92% 708.sqlite_r | -2.71% 710.omnetpp_r | -4.42% 714.cpython_r | -9.71% 721.gcc_r | -6.89% 723.llvm_r | -5.75% 727.cppcheck_r | -23.18% 729.abc_r | -2.26% 734.vpr_r | -2.93% 735.gem5_r | -3.99% 750.sealcrypto_r | -4.38% 753.ns3_r | -2.61% 777.zstd_r | -0.14% Geomean | -4.63% > Note: 707.ntest_r generate the extra spill and could be root cause of regression. --- Patch is 1.29 MiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/239534.diff 90 Files Affected: - (modified) llvm/include/llvm/CodeGen/TargetRegisterInfo.h (+8) - (modified) llvm/lib/CodeGen/RegAllocGreedy.cpp (+178-2) - (modified) llvm/lib/CodeGen/RegAllocGreedy.h (+15) - (modified) llvm/lib/Target/RISCV/RISCVRegisterInfo.cpp (+5) - (modified) llvm/lib/Target/RISCV/RISCVRegisterInfo.h (+4-3) - (modified) llvm/test/CodeGen/RISCV/GlobalISel/double-convert.ll (+60-75) - (modified) llvm/test/CodeGen/RISCV/GlobalISel/fastcc-float.ll (+33-43) - (modified) llvm/test/CodeGen/RISCV/GlobalISel/float-convert.ll (+146-177) - (modified) llvm/test/CodeGen/RISCV/GlobalISel/fp128.ll (+496-460) - (modified) llvm/test/CodeGen/RISCV/GlobalISel/rotl-rotr.ll (+33-18) - (modified) llvm/test/CodeGen/RISCV/GlobalISel/rv64-double-convert.ll (+26-30) - (modified) llvm/test/CodeGen/RISCV/GlobalISel/rv64-float-convert.ll (+26-30) - (modified) llvm/test/CodeGen/RISCV/GlobalISel/rv64zbb.ll (+11-15) - (modified) llvm/test/CodeGen/RISCV/GlobalISel/shifts.ll (+92-87) - (modified) llvm/test/CodeGen/RISCV/GlobalISel/wide-scalar-shift-by-byte-multiple-legalization.ll (+300-300) - (modified) llvm/test/CodeGen/RISCV/atomicrmw-cond-sub-clamp.ll (+4-4) - (modified) llvm/test/CodeGen/RISCV/atomicrmw-uinc-udec-wrap.ll (+4-4) - (modified) llvm/test/CodeGen/RISCV/bfloat-convert.ll (+30-27) - (modified) llvm/test/CodeGen/RISCV/bitint-fp-conv-200.ll (+1170-1030) - (modified) llvm/test/CodeGen/RISCV/calling-conv-half.ll (+10-18) - (modified) llvm/test/CodeGen/RISCV/clmulh.ll (+51-51) - (modified) llvm/test/CodeGen/RISCV/clmulr.ll (+224-222) - (modified) llvm/test/CodeGen/RISCV/condops.ll (+40-45) - (modified) llvm/test/CodeGen/RISCV/csr-first-use-cost.ll (+9-9) - (modified) llvm/test/CodeGen/RISCV/ctlz-cttz-ctpop.ll (+55-58) - (modified) llvm/test/CodeGen/RISCV/ctz_zero_return_test.ll (+42-44) - (modified) llvm/test/CodeGen/RISCV/double-convert.ll (+127-140) - (modified) llvm/test/CodeGen/RISCV/double-round-conv-sat.ll (+73-66) - (modified) llvm/test/CodeGen/RISCV/double-stack-spill-restore.ll (+12-17) - (modified) llvm/test/CodeGen/RISCV/exception-pointer-register.ll (+18-38) - (modified) llvm/test/CodeGen/RISCV/float-convert.ll (+144-165) - (modified) llvm/test/CodeGen/RISCV/float-round-conv-sat.ll (+165-153) - (modified) llvm/test/CodeGen/RISCV/fp128.ll (+182-161) - (modified) llvm/test/CodeGen/RISCV/fpclamptosat.ll (+2529-2377) - (modified) llvm/test/CodeGen/RISCV/fpenv.ll (+20-22) - (modified) llvm/test/CodeGen/RISCV/half-convert.ll (+274-289) - (modified) llvm/test/CodeGen/RISCV/half-round-conv-sat.ll (+240-216) - (modified) llvm/test/CodeGen/RISCV/idiv_large.ll (+804-803) - (modified) llvm/test/CodeGen/RISCV/interrupt-attr-nocall.ll (+44-56) - (modified) llvm/test/CodeGen/RISCV/machine-outliner-and-machine-copy-propagation.ll (+10-6) - (modified) llvm/test/CodeGen/RISCV/machine-sink-load-immediate.ll (+64-64) - (modified) llvm/test/CodeGen/RISCV/miss-sp-restore-eh.ll (+3-6) - (modified) llvm/test/CodeGen/RISCV/overflow-intrinsics.ll (+50-87) - (modified) llvm/test/CodeGen/RISCV/qci-interrupt-attr-fpr.ll (+144-136) - (modified) llvm/test/CodeGen/RISCV/qci-interrupt-attr.ll (+20-20) - (added) llvm/test/CodeGen/RISCV/regalloc-csr-cost-patterns.ll (+1060) - (modified) llvm/test/CodeGen/RISCV/rv32xtheadbb.ll (+34-36) - (modified) llvm/test/CodeGen/RISCV/rv32zbb.ll (+34-36) - (modified) llvm/test/CodeGen/RISCV/rv64-double-convert.ll (+47-46) - (modified) llvm/test/CodeGen/RISCV/rv64-float-convert.ll (+47-46) - (modified) llvm/test/CodeGen/RISCV/rv64-half-convert.ll (+47-46) - (modified) llvm/test/CodeGen/RISCV/rv64-statepoint-call-lowering.ll (+2-2) - (modified) llvm/test/CodeGen/RISCV/rvv/clmulh-sdnode.ll (+84-84) - (modified) llvm/test/CodeGen/RISCV/rvv/fixed-vectors-fp-buildvec.ll (+107-219) - (modified) llvm/test/CodeGen/RISCV/rvv/fixed-vectors-masked-scatter.ll (+659-507) - (modified) llvm/test/CodeGen/RISCV/rvv/fixed-vectors-shuffle-rotate.ll (+32-48) - (modified) llvm/test/CodeGen/RISCV/rvv/fpclamptosat_vec.ll (+91-84) - (modified) llvm/test/CodeGen/RISCV/rvv/interrupt-attr-nocall.ll (+2-4) - (modified) llvm/test/CodeGen/RISCV/rvv/localvar.ll (+24-32) - (modified) llvm/test/CodeGen/RISCV/rvv/nontemporal-vp-scalable.ll (+670-670) - (modified) llvm/test/CodeGen/RISCV/rvv/pr95865.ll (+51-55) - (modified) llvm/test/CodeGen/RISCV/rvv/shrinkwrap.ll (+28-32) - (modified) llvm/test/CodeGen/RISCV/rvv/vsetvli-insert-crossbb.ll (+33-32) - (modified) llvm/test/CodeGen/RISCV/rvv/vxrm-insert-out-of-loop.ll (+30-30) - (modified) llvm/test/CodeGen/RISCV/select-cc.ll (+31-35) - (modified) llvm/test/CodeGen/RISCV/sext-zext-trunc.ll (+12-20) - (modified) llvm/test/CodeGen/RISCV/short-forward-branch-opt-load-atomic-acquire-seq_cst.ll (+34-50) - (modified) llvm/test/CodeGen/RISCV/short-forward-branch-opt-load.ll (+17-25) - (modified) llvm/test/CodeGen/RISCV/short-forward-branch-opt-with-branch-with-immediates_32_eq.ll (+4-8) - (modified) llvm/test/CodeGen/RISCV/short-forward-branch-opt-with-branch-with-immediates_32_ne.ll (+4-8) - (modified) llvm/test/CodeGen/RISCV/short-forward-branch-opt-with-branch-with-immediates_32_sge.ll (+4-8) - (modified) llvm/test/CodeGen/RISCV/short-forward-branch-opt-with-branch-with-immediates_32_slt.ll (+4-8) - (modified) llvm/test/CodeGen/RISCV/short-forward-branch-opt-with-branch-with-immediates_32_uge.ll (+4-8) - (modified) llvm/test/CodeGen/RISCV/short-forward-branch-opt-with-branch-with-immediates_32_ult.ll (+4-8) - (modified) llvm/test/CodeGen/RISCV/short-forward-branch-opt-with-branch-with-immediates_48_eq.ll (+4-8) - (modified) llvm/test/CodeGen/RISCV/short-forward-branch-opt-with-branch-with-immediates_48_ne.ll (+4-8) - (modified) llvm/test/CodeGen/RISCV/short-forward-branch-opt-with-branch-with-immediates_48_sge.ll (+4-8) - (modified) llvm/test/CodeGen/RISCV/short-forward-branch-opt-with-branch-with-immediates_48_slt.ll (+4-8) - (modified) llvm/test/CodeGen/RISCV/short-forward-branch-opt-with-branch-with-immediates_48_uge.ll (+4-8) - (modified) llvm/test/CodeGen/RISCV/short-forward-branch-opt-with-branch-with-immediates_48_ult.ll (+4-8) - (modified) llvm/test/CodeGen/RISCV/shrinkwrap-save-restore-debug.ll (+16-12) - (modified) llvm/test/CodeGen/RISCV/shrinkwrap.ll (+68-82) - (modified) llvm/test/CodeGen/RISCV/simplify-condbr.ll (+4-6) - (modified) llvm/test/CodeGen/RISCV/smulh.ll (+213-211) - (modified) llvm/test/CodeGen/RISCV/umulh.ll (+94-88) - (modified) llvm/test/CodeGen/RISCV/xqcibm-cto-clo-brev.ll (+58-58) - (modified) llvm/test/CodeGen/RISCV/xqcilo-xqcilia-frame-index.ll (+43-53) - (modified) llvm/test/CodeGen/RISCV/zicond-fp-select-zfinx.ll (+4-8) - (modified) llvm/test/DebugInfo/RISCV/dw_op_entry_value_32bit.ll (+1-1) - (modified) llvm/test/DebugInfo/RISCV/dw_op_entry_value_64bit.ll (+1-1) ``````````diff diff --git a/llvm/include/llvm/CodeGen/TargetRegisterInfo.h b/llvm/include/llvm/CodeGen/TargetRegisterInfo.h index fc3b4d6dda844b..3888f141b5370c 100644 --- a/llvm/include/llvm/CodeGen/TargetRegisterInfo.h +++ b/llvm/include/llvm/CodeGen/TargetRegisterInfo.h @@ -899,6 +899,14 @@ class LLVM_ABI TargetRegisterInfo : public MCRegisterInfo { return 30; } + /// Return true if the greedy register allocator should take + /// the lowest-cost choice before using an unused CSR. + /// This uses tryAssignCSRFirstTimeMinCost instead of + /// tryAssignCSRFirstTime. + virtual bool enableCSRFirstTimeMinCost(const MachineFunction &MF) const { + return false; + } + /// Returns true if the target requires (and can make use of) the register /// scavenger. virtual bool requiresRegisterScavenging(const MachineFunction &MF) const { diff --git a/llvm/lib/CodeGen/RegAllocGreedy.cpp b/llvm/lib/CodeGen/RegAllocGreedy.cpp index f7655e97b99427..acce796d5ff651 100644 --- a/llvm/lib/CodeGen/RegAllocGreedy.cpp +++ b/llvm/lib/CodeGen/RegAllocGreedy.cpp @@ -2471,6 +2471,49 @@ BlockFrequency RAGreedy::calcRematCost(const LiveInterval &VirtReg, return HasUse ? RematCost : BlockFrequency::max(); } +/// Return true if the spiller can rematerialize each use of \p LI. +/// And it can rematerialize for only one def. +static bool isRematerializableFromOriginal(const LiveInterval &LI, + const LiveIntervals &LIS, + const VirtRegMap &VRM, + const MachineRegisterInfo &MRI, + const TargetInstrInfo &TII) { + const LiveInterval &OrigLI = LIS.getInterval(VRM.getOriginal(LI.reg())); + const MachineInstr *Def = nullptr; + for (const VNInfo *VNI : OrigLI.valnos) { + if (VNI->isUnused()) + continue; + // Maybe more than one value def for VirtReg + if (VNI->isPHIDef() || Def) + return false; + Def = LIS.getInstructionFromIndex(VNI->def); + if (!Def || !TII.isReMaterializable(*Def)) + return false; + } + if (!Def) + return false; + for (const MachineInstr &MI : MRI.use_nodbg_instructions(LI.reg())) + if (!VirtRegAuxInfo::allUsesAvailableAt(Def, LIS.getInstructionIndex(MI), + LIS, MRI, TII)) + return false; + return true; +} + +/// The cost of rematerializing \p LI before each of its uses. +static BlockFrequency calcRematCostAtUses(const LiveInterval &LI, + const MachineRegisterInfo &MRI, + const SpillPlacement &SpillPlacer) { + uint64_t RematCost = 0; + SmallPtrSet<const MachineInstr *, 8> Seen; + for (const MachineInstr &MI : MRI.use_nodbg_instructions(LI.reg())) { + if (MI.isMetaInstruction() || !Seen.insert(&MI).second) + continue; + RematCost += SpillPlacer.getBlockFrequency(MI.getParent()->getNumber()) + .getFrequency(); + } + return BlockFrequency(RematCost); +} + /// Using a CSR for the first time has a cost because it causes push|pop /// to be added to prologue|epilogue. Splitting a cold section of the live /// range can have lower cost than using the CSR for the first time; @@ -2524,6 +2567,135 @@ MCRegister RAGreedy::tryAssignCSRFirstTime( return PhysReg; } +// Like tryAssignCSRFirstTime before assign the unused CSR to VirtReg, try +// other choices. There are four results: +// 1. Pre-split VirtReg +// 2. Remat/Spill VirtReg +// 3. Evict rematerializable live ranges if that reg is not unused CSR. +// 4. Use the CSR for this VirtReg +// The goal is using the less cost register. +MCRegister RAGreedy::tryAssignCSRFirstTimeMinCost( + const LiveInterval &VirtReg, AllocationOrder &Order, MCRegister PhysReg, + uint8_t &CostPerUseLimit, SmallVectorImpl<Register> &NewVRegs) { + // Compute Remat cost. + std::optional<BlockFrequency> RematCost; + if (VirtReg.isSpillable() && + isRematerializableFromOriginal(VirtReg, *LIS, *VRM, *MRI, *TII)) + RematCost = calcRematCostAtUses(VirtReg, *MRI, *SpillPlacer); + + std::optional<BlockFrequency> SpillRematCost; + if (VirtReg.isSpillable()) { + SpillRematCost = calcSpillCost(VirtReg); + if (RematCost) + SpillRematCost = std::min(*SpillRematCost, *RematCost); + } + + LiveRangeStage Stage = ExtraInfo->getStage(VirtReg); + + if (Stage == RS_Spill && VirtReg.isSpillable()) { + // We choose spill or rematerialize over using the CSR for the first time if + // the spill cost is lower than CSRCost. + if (*SpillRematCost >= CSRCost) + return PhysReg; + + // We are going to spill or rematerialize, set CostPerUseLimit to 1 to make + // sure that we will not use a callee-saved register in tryEvict. + CostPerUseLimit = 1; + return MCRegister(); + } + + if (Stage < RS_Split) { + SA->analyze(&VirtReg); + // A pre-split must cost less than CSRCost. + // CSRCost is the cost for place the CSR save/restore. And it be set by + // target. + BlockFrequency SplitCost = CSRCost; + unsigned NumCands = 0; + unsigned BestCand = calculateRegionSplitCost(VirtReg, Order, SplitCost, + NumCands, true /*IgnoreCSR*/); + + bool SpillRematCostsLess = SpillRematCost && *SpillRematCost < SplitCost; + if (BestCand != NoCand && !SpillRematCostsLess) { + doRegionSplit(VirtReg, BestCand, false /*HasCompact*/, NewVRegs); + return MCRegister(); + } + } + + bool SpillCostsLess = SpillRematCost && *SpillRematCost < CSRCost; + BlockFrequency EvictLimit = SpillCostsLess ? *SpillRematCost : CSRCost; + // Use Evict Reg + if (MCRegister Reg = + tryEvictRematForCSR(VirtReg, Order, NewVRegs, EvictLimit)) + return Reg; + + // Use CSR + if (!SpillCostsLess) + return PhysReg; + + // Use Spill/Remat + // We are going to spill, set CostPerUseLimit to 1 to make sure that + // we will not use a callee-saved register in tryEvict. + ExtraInfo->setStage(VirtReg, RS_Spill); + CostPerUseLimit = 1; + return MCRegister(); +} + +/// Return the cost of evicting and rematerializing all the live ranges that +/// interfere with \p VirtReg in \p PhysReg. +/// Return std::nullopt when +/// 1. has lower Cascade than \p Cascade. +/// 2. can't be spilled. +/// 3. can't be rematerialized. +std::optional<BlockFrequency> +RAGreedy::calcEvictRematCost(const LiveInterval &VirtReg, MCRegister PhysReg, + unsigned Cascade) const { + BlockFrequency Cost(0); + SmallPtrSet<const LiveInterval *, 4> Seen; + for (MCRegUnit Unit : TRI->regunits(PhysReg)) { + for (const LiveInterval *Intf : + Matrix->query(VirtReg, Unit).interferingVRegs()) { + if (!Seen.insert(Intf).second) + continue; + if (ExtraInfo->getCascade(Intf->reg()) >= Cascade || + !Intf->isSpillable() || + !isRematerializableFromOriginal(*Intf, *LIS, *VRM, *MRI, *TII)) + return std::nullopt; + Cost += calcRematCostAtUses(*Intf, *MRI, *SpillPlacer); + } + } + return Cost; +} + +/// Before \p VirtReg uses a CSR for the first time, look for a register that +/// is not an unused CSR and that only rematerializable live ranges occupy. +/// If rematerializing them costs less than \p MaxCost, evict them and +/// return the register. +MCRegister RAGreedy::tryEvictRematForCSR(const LiveInterval &VirtReg, + AllocationOrder &Order, + SmallVectorImpl<Register> &NewVRegs, + BlockFrequency MaxCost) { + unsigned Cascade = ExtraInfo->getCascadeOrCurrentNext(VirtReg.reg()); + MCRegister BestReg; + BlockFrequency BestCost = MaxCost; + for (MCRegister PhysReg : Order.getOrder()) { + if (EvictAdvisor->getUnusedCalleeSavedReg(VirtReg, PhysReg) || + Matrix->checkInterference(VirtReg, PhysReg) != + LiveRegMatrix::IK_VirtReg) + continue; + std::optional<BlockFrequency> Cost = + calcEvictRematCost(VirtReg, PhysReg, Cascade); + if (Cost && *Cost < BestCost) { + BestCost = *Cost; + BestReg = PhysReg; + } + } + if (!BestReg) + return MCRegister(); + + evictInterference(VirtReg, BestReg, NewVRegs); + return BestReg; +} + void RAGreedy::aboutToRemoveInterval(const LiveInterval &LI) { // Do not keep invalid information around. SetOfBrokenHints.remove(&LI); @@ -2791,8 +2963,12 @@ MCRegister RAGreedy::selectOrSplitImpl(const LiveInterval &VirtReg, if (CSRCost.getFrequency() && EvictAdvisor->getUnusedCalleeSavedReg(VirtReg, PhysReg) && NewVRegs.empty()) { - MCRegister CSRReg = tryAssignCSRFirstTime(VirtReg, Order, PhysReg, - CostPerUseLimit, NewVRegs); + MCRegister CSRReg = + TRI->enableCSRFirstTimeMinCost(*MF) + ? tryAssignCSRFirstTimeMinCost(VirtReg, Order, PhysReg, + CostPerUseLimit, NewVRegs) + : tryAssignCSRFirstTime(VirtReg, Order, PhysReg, CostPerUseLimit, + NewVRegs); if (CSRReg || !NewVRegs.empty()) // Return now if we decide to use a CSR or create new vregs due to // pre-splitting. diff --git a/llvm/lib/CodeGen/RegAllocGreedy.h b/llvm/lib/CodeGen/RegAllocGreedy.h index 138da362a1e76f..43353439423206 100644 --- a/llvm/lib/CodeGen/RegAllocGreedy.h +++ b/llvm/lib/CodeGen/RegAllocGreedy.h @@ -365,6 +365,21 @@ class LLVM_LIBRARY_VISIBILITY RAGreedy : public RegAllocBase, /// rematerialization is not possible. BlockFrequency calcRematCost(const LiveInterval &VirtReg, AllocationOrder &Order) const; + /// Like tryAssignCSRFirstTime, but take the choice with the lowest cost of: + /// a pre-split, spilling or rematerializing VirtReg, evicting + /// rematerializable live ranges, and the first use of the CSR. + MCRegister tryAssignCSRFirstTimeMinCost(const LiveInterval &VirtReg, + AllocationOrder &Order, + MCRegister PhysReg, + uint8_t &CostPerUseLimit, + SmallVectorImpl<Register> &NewVRegs); + std::optional<BlockFrequency> calcEvictRematCost(const LiveInterval &VirtReg, + MCRegister PhysReg, + unsigned Cascade) const; + MCRegister tryEvictRematForCSR(const LiveInterval &VirtReg, + AllocationOrder &Order, + SmallVectorImpl<Register> &NewVRegs, + BlockFrequency MaxCost); BlockFrequency calcSpillCost(const LiveInterval &LI); void initializeCSRCost(); MCRegister tryBlockSplit(const LiveInterval &, AllocationOrder &, diff --git a/llvm/lib/Target/RISCV/RISCVRegisterInfo.cpp b/llvm/lib/Target/RISCV/RISCVRegisterInfo.cpp index 00c89367fc3ecb..eb3e597f15f5df 100644 --- a/llvm/lib/Target/RISCV/RISCVRegisterInfo.cpp +++ b/llvm/lib/Target/RISCV/RISCVRegisterInfo.cpp @@ -66,6 +66,11 @@ RISCVRegisterInfo::getIPRACSRegs(const MachineFunction *MF) const { return CSR_IPRA_SaveList; } +bool RISCVRegisterInfo::enableCSRFirstTimeMinCost( + const MachineFunction &MF) const { + return true; +} + const MCPhysReg * RISCVRegisterInfo::getCalleeSavedRegs(const MachineFunction *MF) const { auto &Subtarget = MF->getSubtarget<RISCVSubtarget>(); diff --git a/llvm/lib/Target/RISCV/RISCVRegisterInfo.h b/llvm/lib/Target/RISCV/RISCVRegisterInfo.h index 5d5441c75f5a41..56cc3871399011 100644 --- a/llvm/lib/Target/RISCV/RISCVRegisterInfo.h +++ b/llvm/lib/Target/RISCV/RISCVRegisterInfo.h @@ -73,11 +73,12 @@ struct RISCVRegisterInfo : public RISCVGenRegisterInfo { unsigned getCSRCost() const override { // The cost will be compared against BlockFrequency where entry has the - // value of 1 << 14. A value of 5 will choose to spill or split cold - // path instead of using a callee-saved register. - return 5; + // value of 1 << 14. 32768 mean (1 << 14) * 2 instruction. + return 32768; } + bool enableCSRFirstTimeMinCost(const MachineFunction &MF) const override; + const MCPhysReg *getCalleeSavedRegs(const MachineFunction *MF) const override; const TargetRegisterClass * diff --git a/llvm/test/CodeGen/RISCV/GlobalISel/double-convert.ll b/llvm/test/CodeGen/RISCV/GlobalISel/double-convert.ll index f781a97f8dab54..96fda144dabfa2 100644 --- a/llvm/test/CodeGen/RISCV/GlobalISel/double-convert.ll +++ b/llvm/test/CodeGen/RISCV/GlobalISel/double-convert.ll @@ -1159,71 +1159,62 @@ define i64 @fcvt_l_d_sat(double %a) nounwind { ; ; RV32I-LABEL: fcvt_l_d_sat: ; RV32I: # %bb.0: # %start -; RV32I-NEXT: addi sp, sp, -48 -; RV32I-NEXT: sw ra, 44(sp) # 4-byte Folded Spill -; RV32I-NEXT: sw s0, 40(sp) # 4-byte Folded Spill -; RV32I-NEXT: sw s1, 36(sp) # 4-byte Folded Spill -; RV32I-NEXT: sw s2, 32(sp) # 4-byte Folded Spill -; RV32I-NEXT: sw s3, 28(sp) # 4-byte Folded Spill -; RV32I-NEXT: sw s4, 24(sp) # 4-byte Folded Spill -; RV32I-NEXT: sw s5, 20(sp) # 4-byte Folded Spill -; RV32I-NEXT: sw s6, 16(sp) # 4-byte Folded Spill -; RV32I-NEXT: sw s7, 12(sp) # 4-byte Folded Spill +; RV32I-NEXT: addi sp, sp, -32 +; RV32I-NEXT: sw ra, 28(sp) # 4-byte Folded Spill +; RV32I-NEXT: sw s0, 24(sp) # 4-byte Folded Spill +; RV32I-NEXT: sw s1, 20(sp) # 4-byte Folded Spill +; RV32I-NEXT: sw s2, 16(sp) # 4-byte Folded Spill +; RV32I-NEXT: sw s3, 12(sp) # 4-byte Folded Spill +; RV32I-NEXT: sw s4, 8(sp) # 4-byte Folded Spill ; RV32I-NEXT: mv s1, a0 ; RV32I-NEXT: mv s2, a1 ; RV32I-NEXT: call __fixdfdi -; RV32I-NEXT: mv s3, a0 -; RV32I-NEXT: mv s4, a1 +; RV32I-NEXT: sw a0, 4(sp) # 4-byte Folded Spill +; RV32I-NEXT: sw a1, 0(sp) # 4-byte Folded Spill ; RV32I-NEXT: li s0, 0 ; RV32I-NEXT: lui a3, 802304 ; RV32I-NEXT: mv a0, s1 ; RV32I-NEXT: mv a1, s2 ; RV32I-NEXT: li a2, 0 ; RV32I-NEXT: call __gedf2 -; RV32I-NEXT: lui s6, 524288 -; RV32I-NEXT: li s7, 0 -; RV32I-NEXT: lui s5, 524288 +; RV32I-NEXT: li s4, 0 +; RV32I-NEXT: lui s3, 524288 ; RV32I-NEXT: bltz a0, .LBB27_2 ; RV32I-NEXT: # %bb.1: # %start -; RV32I-NEXT: mv s7, s3 -; RV32I-NEXT: mv s5, s4 +; RV32I-NEXT: lw s4, 4(sp) # 4-byte Folded Reload +; RV32I-NEXT: lw s3, 0(sp) # 4-byte Folded Reload ; RV32I-NEXT: .LBB27_2: # %start ; RV32I-NEXT: lui a3, 278016 -; RV32I-NEXT: li s3, -1 ; RV32I-NEXT: addi a3, a3, -1 ; RV32I-NEXT: li a2, -1 ; RV32I-NEXT: mv a0, s1 ; RV32I-NEXT: mv a1, s2 ; RV32I-NEXT: call __gtdf2 -; RV32I-NEXT: blt s0, a0, .LBB27_4 -; RV32I-NEXT: # %bb.3: # %start -; RV32I-NEXT: mv s3, s7 -; RV32I-NEXT: j .LBB27_5 -; RV32I-NEXT: .LBB27_4: -; RV32I-NEXT: addi s5, s6, -1 -; RV32I-NEXT: .LBB27_5: # %start +; RV32I-NEXT: bge s0, a0, .LBB27_4 +; RV32I-NEXT: # %bb.3: +; RV32I-NEXT: lui s3, 524288 +; RV32I-NEXT: addi s3, s3, -1 +; RV32I-NEXT: li s4, -1 +; RV32I-NEXT: .LBB27_4: # %start ; RV32I-NEXT: mv a0, s1 ; RV32I-NEXT: mv a1, s2 ; RV32I-NEXT: mv a2, s1 ; RV32I-NEXT: mv a3, s2 ; RV32I-NEXT: call __unorddf2 ; RV32I-NEXT: mv a1, s0 -; RV32I-NEXT: bne a0, s0, .LBB27_7 -; RV32I-NEXT: # %bb.6: # %start -; RV32I-NEXT: mv s0, s3 -; RV32I-NEXT: mv a1, s5 -; RV32I-NEXT: .LBB27_7: # %start +; RV32I-NEXT: bne a0, s0, .LBB27_6 +; RV32I-NEXT: # %bb.5: # %start +; RV32I-NEXT: mv s0, s4 +; RV32I-NEXT: mv a1, s3 +; RV32I-NEXT: .LBB27_6: # %start ; RV32I-NEXT: mv a0, s0 -; RV32I-NEXT: lw ra, 44(sp) # 4-byte Folded Reload -; RV32I-NEXT: lw s0, 40(sp) # 4-byte Folded Reload -; RV32I-NEXT: lw s1, 36(sp) # 4-byte Folded Reload -; RV32I-NEXT: lw s2, 32(sp) # 4-byte Folded Reload -; RV32I-NEXT: lw s3, 28(sp) # 4-byte Folded Reload -; RV32I-NEXT: lw s4, 24(sp) # 4-byte Folded Reload -; RV32I-NEXT: lw s5, 20(sp) # 4-byte Folded Reload -; RV32I-NEXT: lw s6, 16(sp) # 4-byte Folded Reload -; RV32I-NEXT: lw s7, 12(sp) # 4-byte Folded Reload -; RV32I-NEXT: addi sp, sp, 48 +; RV32I-NEXT: lw ra, 28(sp) # 4-byte Folded Reload +; RV32I-NEXT: lw s0, 24(sp) # 4-byte Folded Reload +; RV32I-NEXT: lw s1, 20(sp) # 4-byte Folded Reload +; RV32I-NEXT: lw s2, 16(sp) # 4-byte Folded Reload +; RV32I-NEXT: lw s3, 12(sp) # 4-byte Folded Reload +; RV32I-NEXT: lw s4, 8(sp) # 4-byte Folded Reload +; RV32I-NEXT: addi sp, sp, 32 ; RV32I-NEXT: ret ; ; RV64I-LABEL: fcvt_l_d_sat: @@ -1232,7 +1223,6 @@ define i64 @fcvt_l_d_sat(double %a) nounwind { ; RV64I-NEXT: sd ra, 24(sp) # 8-byte Folded Spill ; RV64I-NEXT: sd s0, 16(sp) # 8-byte Folded Spill ; RV64I-NEXT: sd s1, 8(sp) # 8-byte Folded Spill -; RV64I-NEXT: sd s2, 0(sp) # 8-byte Folded Spill ; RV64I-NEXT: mv s1, a0 ; RV64I-NEXT: call __fixdfdi ; RV64I-NEXT: mv s0, a0 @@ -1241,10 +1231,10 @@ define i64 @fcvt_l_d_sat(double %a) nounwind { ; RV64I-NEXT: mv a0, s1 ; RV64I-NEXT: call __gedf2 ; RV64I-NEXT: sext.w a0, a0 -; RV64I-NEXT: li s2, -1 ; RV64I-NEXT: bgez a0, .LBB27_2 ; RV64I-NEXT: # %bb.1: -; RV64I-NEXT: slli s0, s2, 63 +; RV64I-NEXT: li s0, -1 +; RV64I-NEXT: slli s0, s0, 63 ; RV64I-NEXT: .LBB27_2: # %start ; RV64I-NEXT: li a0, 543 ; RV64I-NEXT: slli a0, a0, 53 @@ -1254,7 +1244,8 @@ define i64 @fcvt_l_d_sat(double %a) nounwind { ; RV64I-NEXT: sext.w a0, a0 ; RV64I-NEXT: blez a0, .LBB27_4 ; RV64I-NEXT: # %bb.3: -; RV64I-NEXT: srli s0, s2, 1 +; RV64I-NEXT: li s0, -1 +; RV64I-NEXT: srli s0, s0, 1 ; RV64I-NEXT: .LBB27_4: # %start ; RV64I-NEXT: mv a0, s1 ; RV64I-NEXT: mv a1, s1 @@ -1268,7 +1259,6 @@ define i64 @fcvt_l_d_sat(double %a) nounwind { ; RV64I-NEXT: ld ra, 24(sp) # 8-byte Folded Reload ; RV64I-NEXT: ld s0, 16(sp) # 8-byte Folded Reload ; RV64I-NEXT: ld s1, 8(sp) # 8-byte Folded Reload -; RV64I-NEXT: ld s2, 0(sp) # 8-byte Folded Reload ; RV64I-NEXT: addi sp, sp, 32 ; RV64I-NEXT: ret start: @@ -1335,26 +1325,25 @@ define i64 @fcvt_lu_d_sat(double %a) nounwind { ; RV32I-NEXT: sw s0, 24(sp) # 4-byte Folded Spill ; RV32I-NEXT: sw s1, 20(sp) # 4-byte Folded Spill ; RV32I-NEXT: sw s2, 16(sp) # 4-byte Folded Spill -; RV32I-NEXT: sw s3, 12(sp) # 4-byte Folded Spill -; RV32I-NEXT: sw s4, 8(sp) # 4-byte Folded Spill -; RV32I-NEXT: sw s5, 4(sp) # 4-byte Folded Spill ; RV32I-NEXT: mv s0, a0 ; RV32I-NEXT: mv s1, a1 ; RV32I-NEXT: call __fixunsdfdi ; RV32I-NEXT: mv s2, a0 -; RV32I-NEXT: mv s3, a1 +; RV32I-NEXT: sw a1, 12(sp) # 4-byte Folded Spill ; RV32I-NEXT: mv a0, s0 ; RV32I-NEXT: mv a1, s1 ; RV32I-NEXT: li a2, 0 ; RV32I-NEXT: li a3, 0 ; RV32I-NEXT: call __gedf2 -; RV32I-NEXT: li s4, 0 -; RV32I-NEXT: li s5, 0 +; RV32I-NEXT: li a1, 0 +; RV32I-NEXT: li a2, 0 ; RV32I-NEXT: bltz a0, .LBB28_2 ; RV32I-NEXT: # %bb.1: # %start -; RV32I-NEXT: mv s4, s2 -; RV32I-NEXT: mv s5, s3 +; RV32I-NEXT: mv a1, s2 +; RV32I-NEXT: lw a2, 12(sp) # 4-byte Folded Reload ; RV32I-NEXT: .LBB28_2: # %start +; RV32I-NEXT: sw a1, 8(sp) # 4-byte Folded Spill +; RV32I-NEXT: sw a2, 12(sp) # 4-byte Folded Spill ; RV32I-NEXT: lui a3, 278272 ; RV32I-NEXT: li s2, -1 ; RV32I-NEXT: addi a3, a3, -1 @@ -1365,17 +1354,14 @@ define i64 @fcvt_lu_d_sat(double %a) nounwind { ; RV32I-NEXT: li a1, -1 ; RV32I-NEXT: bgtz a0, .LBB28_4 ; RV32I-NEXT: # %bb.3: # %start -; RV32I-NEXT: mv s2, s4 -; RV32I-NEXT: mv a1, s5 +; RV32I-NEXT: lw s2, 8(sp) # 4-byte Folded Reload +; RV32I-NEXT: lw a1, 12(sp) # 4-byte Folded Reload ; RV32I-NEXT: .LBB28_4: # %start ; RV32I-NEXT: mv a0, s2 ; RV32I-NEXT: lw ra, 28(sp) # 4-byte Folded Reload ; RV32I-NEXT: lw s0, 24(sp) # 4-byte Folded Reload ; RV32I-NEXT: lw s1, 20(sp) # 4-byte Folded Reload ; RV32I-NEXT: lw s2, 16(sp) # 4-byte Folded Reload -; RV32I-NEXT: lw s3, 12(sp) # 4-byte Folded Reload -; RV32I-NEXT: lw s4, 8(sp) # 4-byte Folded Reload -; RV32I-NEXT: lw s5, 4(sp) # 4-byte Folded Reload ; RV32I-NEXT: addi sp, sp, 32 ; RV32I-NEXT: ret ; @@ -1384,35 +1370,34 @@ define i64 @fcvt_lu_d... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/239534 _______________________________________________ llvm-branch-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
