llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-backend-risc-v @llvm/pr-subscribers-backend-aarch64 Author: Matt Arsenault (arsenm) <details> <summary>Changes</summary> Avoid getting this from the MachineFunction --- Patch is 20.14 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/99688.diff 11 Files Affected: - (modified) llvm/include/llvm/CodeGen/TargetInstrInfo.h (+6-3) - (modified) llvm/lib/CodeGen/MachineOutliner.cpp (+21-22) - (modified) llvm/lib/CodeGen/TargetInstrInfo.cpp (+6-4) - (modified) llvm/lib/Target/AArch64/AArch64InstrInfo.cpp (+5-3) - (modified) llvm/lib/Target/AArch64/AArch64InstrInfo.h (+4-2) - (modified) llvm/lib/Target/ARM/ARMBaseInstrInfo.cpp (+4-2) - (modified) llvm/lib/Target/ARM/ARMBaseInstrInfo.h (+4-2) - (modified) llvm/lib/Target/RISCV/RISCVInstrInfo.cpp (+4-2) - (modified) llvm/lib/Target/RISCV/RISCVInstrInfo.h (+3-1) - (modified) llvm/lib/Target/X86/X86InstrInfo.cpp (+3-1) - (modified) llvm/lib/Target/X86/X86InstrInfo.h (+4-2) ``````````diff diff --git a/llvm/include/llvm/CodeGen/TargetInstrInfo.h b/llvm/include/llvm/CodeGen/TargetInstrInfo.h index 5c7f6ddc94840..4ae9e470616bb 100644 --- a/llvm/include/llvm/CodeGen/TargetInstrInfo.h +++ b/llvm/include/llvm/CodeGen/TargetInstrInfo.h @@ -2089,6 +2089,7 @@ class TargetInstrInfo : public MCInstrInfo { /// information for a set of outlining candidates. Returns std::nullopt if the /// candidates are not suitable for outlining. virtual std::optional<outliner::OutlinedFunction> getOutliningCandidateInfo( + const MachineModuleInfo &MMI, std::vector<outliner::Candidate> &RepeatedSequenceLocs) const { llvm_unreachable( "Target didn't implement TargetInstrInfo::getOutliningCandidateInfo!"); @@ -2103,7 +2104,8 @@ class TargetInstrInfo : public MCInstrInfo { protected: /// Target-dependent implementation for getOutliningTypeImpl. virtual outliner::InstrType - getOutliningTypeImpl(MachineBasicBlock::iterator &MIT, unsigned Flags) const { + getOutliningTypeImpl(const MachineModuleInfo &MMI, + MachineBasicBlock::iterator &MIT, unsigned Flags) const { llvm_unreachable( "Target didn't implement TargetInstrInfo::getOutliningTypeImpl!"); } @@ -2111,8 +2113,9 @@ class TargetInstrInfo : public MCInstrInfo { public: /// Returns how or if \p MIT should be outlined. \p Flags is the /// target-specific information returned by isMBBSafeToOutlineFrom. - outliner::InstrType - getOutliningType(MachineBasicBlock::iterator &MIT, unsigned Flags) const; + outliner::InstrType getOutliningType(const MachineModuleInfo &MMI, + MachineBasicBlock::iterator &MIT, + unsigned Flags) const; /// Optional target hook that returns true if \p MBB is safe to outline from, /// and returns any target-specific information in \p Flags. diff --git a/llvm/lib/CodeGen/MachineOutliner.cpp b/llvm/lib/CodeGen/MachineOutliner.cpp index c7ccf10e12b12..4b56a467b8d07 100644 --- a/llvm/lib/CodeGen/MachineOutliner.cpp +++ b/llvm/lib/CodeGen/MachineOutliner.cpp @@ -132,6 +132,7 @@ namespace { /// Maps \p MachineInstrs to unsigned integers and stores the mappings. struct InstructionMapper { + const MachineModuleInfo &MMI; /// The next available integer to assign to a \p MachineInstr that /// cannot be outlined. @@ -333,7 +334,7 @@ struct InstructionMapper { // which may be outlinable. Check if each instruction is known to be safe. for (; It != OutlinableRangeEnd; ++It) { // Keep track of where this instruction is in the module. - switch (TII.getOutliningType(It, Flags)) { + switch (TII.getOutliningType(MMI, It, Flags)) { case InstrType::Illegal: mapToIllegalUnsigned(It, CanOutlineWithPrevInstr, UnsignedVecForMBB, InstrListForMBB); @@ -382,7 +383,7 @@ struct InstructionMapper { } } - InstructionMapper() { + InstructionMapper(const MachineModuleInfo &MMI_) : MMI(MMI_) { // Make sure that the implementation of DenseMapInfo<unsigned> hasn't // changed. assert(DenseMapInfo<unsigned>::getEmptyKey() == (unsigned)-1 && @@ -405,6 +406,8 @@ struct MachineOutliner : public ModulePass { static char ID; + MachineModuleInfo *MMI = nullptr; + /// Set to true if the outliner should consider functions with /// linkonceodr linkage. bool OutlineFromLinkOnceODRs = false; @@ -489,20 +492,19 @@ struct MachineOutliner : public ModulePass { /// Populate and \p InstructionMapper with instruction-to-integer mappings. /// These are used to construct a suffix tree. - void populateMapper(InstructionMapper &Mapper, Module &M, - MachineModuleInfo &MMI); + void populateMapper(InstructionMapper &Mapper, Module &M); /// Initialize information necessary to output a size remark. /// FIXME: This should be handled by the pass manager, not the outliner. /// FIXME: This is nearly identical to the initSizeRemarkInfo in the legacy /// pass manager. - void initSizeRemarkInfo(const Module &M, const MachineModuleInfo &MMI, + void initSizeRemarkInfo(const Module &M, StringMap<unsigned> &FunctionToInstrCount); /// Emit the remark. // FIXME: This should be handled by the pass manager, not the outliner. void - emitInstrCountChangedRemark(const Module &M, const MachineModuleInfo &MMI, + emitInstrCountChangedRemark(const Module &M, const StringMap<unsigned> &FunctionToInstrCount); }; } // Anonymous namespace. @@ -669,7 +671,7 @@ void MachineOutliner::findCandidates( CandidatesForRepeatedSeq[0].getMF()->getSubtarget().getInstrInfo(); std::optional<OutlinedFunction> OF = - TII->getOutliningCandidateInfo(CandidatesForRepeatedSeq); + TII->getOutliningCandidateInfo(*MMI, CandidatesForRepeatedSeq); // If we deleted too many candidates, then there's nothing worth outlining. // FIXME: This should take target-specified instruction sizes into account. @@ -988,8 +990,7 @@ bool MachineOutliner::outline(Module &M, return OutlinedSomething; } -void MachineOutliner::populateMapper(InstructionMapper &Mapper, Module &M, - MachineModuleInfo &MMI) { +void MachineOutliner::populateMapper(InstructionMapper &Mapper, Module &M) { // Build instruction mappings for each function in the module. Start by // iterating over each Function in M. LLVM_DEBUG(dbgs() << "*** Populating mapper ***\n"); @@ -1003,7 +1004,7 @@ void MachineOutliner::populateMapper(InstructionMapper &Mapper, Module &M, // There's something in F. Check if it has a MachineFunction associated with // it. - MachineFunction *MF = MMI.getMachineFunction(F); + MachineFunction *MF = MMI->getMachineFunction(F); // If it doesn't, then there's nothing to outline from. Move to the next // Function. @@ -1062,12 +1063,11 @@ void MachineOutliner::populateMapper(InstructionMapper &Mapper, Module &M, } void MachineOutliner::initSizeRemarkInfo( - const Module &M, const MachineModuleInfo &MMI, - StringMap<unsigned> &FunctionToInstrCount) { + const Module &M, StringMap<unsigned> &FunctionToInstrCount) { // Collect instruction counts for every function. We'll use this to emit // per-function size remarks later. for (const Function &F : M) { - MachineFunction *MF = MMI.getMachineFunction(F); + MachineFunction *MF = MMI->getMachineFunction(F); // We only care about MI counts here. If there's no MachineFunction at this // point, then there won't be after the outliner runs, so let's move on. @@ -1078,13 +1078,12 @@ void MachineOutliner::initSizeRemarkInfo( } void MachineOutliner::emitInstrCountChangedRemark( - const Module &M, const MachineModuleInfo &MMI, - const StringMap<unsigned> &FunctionToInstrCount) { + const Module &M, const StringMap<unsigned> &FunctionToInstrCount) { // Iterate over each function in the module and emit remarks. // Note that we won't miss anything by doing this, because the outliner never // deletes functions. for (const Function &F : M) { - MachineFunction *MF = MMI.getMachineFunction(F); + MachineFunction *MF = MMI->getMachineFunction(F); // The outliner never deletes functions. If we don't have a MF here, then we // didn't have one prior to outlining either. @@ -1135,6 +1134,8 @@ bool MachineOutliner::runOnModule(Module &M) { if (M.empty()) return false; + MMI = &getAnalysis<MachineModuleInfoWrapperPass>().getMMI(); + // Number to append to the current outlined function. unsigned OutlinedFunctionNum = 0; @@ -1158,8 +1159,6 @@ bool MachineOutliner::runOnModule(Module &M) { } bool MachineOutliner::doOutline(Module &M, unsigned &OutlinedFunctionNum) { - MachineModuleInfo &MMI = getAnalysis<MachineModuleInfoWrapperPass>().getMMI(); - // If the user passed -enable-machine-outliner=always or // -enable-machine-outliner, the pass will run on all functions in the module. // Otherwise, if the target supports default outlining, it will run on all @@ -1177,10 +1176,10 @@ bool MachineOutliner::doOutline(Module &M, unsigned &OutlinedFunctionNum) { // If the user specifies that they want to outline from linkonceodrs, set // it here. OutlineFromLinkOnceODRs = EnableLinkOnceODROutlining; - InstructionMapper Mapper; + InstructionMapper Mapper(*MMI); // Prepare instruction mappings for the suffix tree. - populateMapper(Mapper, M, MMI); + populateMapper(Mapper, M); std::vector<OutlinedFunction> FunctionList; // Find all of the outlining candidates. @@ -1198,7 +1197,7 @@ bool MachineOutliner::doOutline(Module &M, unsigned &OutlinedFunctionNum) { bool ShouldEmitSizeRemarks = M.shouldEmitInstrCountChangedRemark(); StringMap<unsigned> FunctionToInstrCount; if (ShouldEmitSizeRemarks) - initSizeRemarkInfo(M, MMI, FunctionToInstrCount); + initSizeRemarkInfo(M, FunctionToInstrCount); // Outline each of the candidates and return true if something was outlined. bool OutlinedSomething = @@ -1208,7 +1207,7 @@ bool MachineOutliner::doOutline(Module &M, unsigned &OutlinedFunctionNum) { // module. If we've asked for size remarks, then output them. // FIXME: This should be in the pass manager. if (ShouldEmitSizeRemarks && OutlinedSomething) - emitInstrCountChangedRemark(M, MMI, FunctionToInstrCount); + emitInstrCountChangedRemark(M, FunctionToInstrCount); LLVM_DEBUG({ if (!OutlinedSomething) diff --git a/llvm/lib/CodeGen/TargetInstrInfo.cpp b/llvm/lib/CodeGen/TargetInstrInfo.cpp index 3cd1bb296d288..c2b8c39662bb6 100644 --- a/llvm/lib/CodeGen/TargetInstrInfo.cpp +++ b/llvm/lib/CodeGen/TargetInstrInfo.cpp @@ -1809,15 +1809,17 @@ void TargetInstrInfo::mergeOutliningCandidateAttributes( F.addFnAttr(Attribute::NoUnwind); } -outliner::InstrType TargetInstrInfo::getOutliningType( - MachineBasicBlock::iterator &MIT, unsigned Flags) const { +outliner::InstrType +TargetInstrInfo::getOutliningType(const MachineModuleInfo &MMI, + MachineBasicBlock::iterator &MIT, + unsigned Flags) const { MachineInstr &MI = *MIT; // NOTE: MI.isMetaInstruction() will match CFI_INSTRUCTION, but some targets // have support for outlining those. Special-case that here. if (MI.isCFIInstruction()) // Just go right to the target implementation. - return getOutliningTypeImpl(MIT, Flags); + return getOutliningTypeImpl(MMI, MIT, Flags); // Be conservative about inline assembly. if (MI.isInlineAsm()) @@ -1883,7 +1885,7 @@ outliner::InstrType TargetInstrInfo::getOutliningType( } // If we don't know, delegate to the target-specific hook. - return getOutliningTypeImpl(MIT, Flags); + return getOutliningTypeImpl(MMI, MIT, Flags); } bool TargetInstrInfo::isMBBSafeToOutlineFrom(MachineBasicBlock &MBB, diff --git a/llvm/lib/Target/AArch64/AArch64InstrInfo.cpp b/llvm/lib/Target/AArch64/AArch64InstrInfo.cpp index 1b301a4a05fc5..702c2831e013f 100644 --- a/llvm/lib/Target/AArch64/AArch64InstrInfo.cpp +++ b/llvm/lib/Target/AArch64/AArch64InstrInfo.cpp @@ -8286,6 +8286,7 @@ static bool outliningCandidatesV8_3OpsConsensus(const outliner::Candidate &a, std::optional<outliner::OutlinedFunction> AArch64InstrInfo::getOutliningCandidateInfo( + const MachineModuleInfo &MMI, std::vector<outliner::Candidate> &RepeatedSequenceLocs) const { unsigned SequenceSize = 0; for (auto &MI : RepeatedSequenceLocs[0]) @@ -8861,8 +8862,9 @@ AArch64InstrInfo::getOutlinableRanges(MachineBasicBlock &MBB, } outliner::InstrType -AArch64InstrInfo::getOutliningTypeImpl(MachineBasicBlock::iterator &MIT, - unsigned Flags) const { +AArch64InstrInfo::getOutliningTypeImpl(const MachineModuleInfo &MMI, + MachineBasicBlock::iterator &MIT, + unsigned Flags) const { MachineInstr &MI = *MIT; MachineBasicBlock *MBB = MI.getParent(); MachineFunction *MF = MBB->getParent(); @@ -8974,7 +8976,7 @@ AArch64InstrInfo::getOutliningTypeImpl(MachineBasicBlock::iterator &MIT, // We have a function we have information about. Check it if it's something // can safely outline. - MachineFunction *CalleeMF = MF->getMMI().getMachineFunction(*Callee); + MachineFunction *CalleeMF = MMI.getMachineFunction(*Callee); // We don't know what's going on with the callee at all. Don't touch it. if (!CalleeMF) diff --git a/llvm/lib/Target/AArch64/AArch64InstrInfo.h b/llvm/lib/Target/AArch64/AArch64InstrInfo.h index 69ee0a70765e1..7e5ac423f09ce 100644 --- a/llvm/lib/Target/AArch64/AArch64InstrInfo.h +++ b/llvm/lib/Target/AArch64/AArch64InstrInfo.h @@ -466,11 +466,13 @@ class AArch64InstrInfo final : public AArch64GenInstrInfo { bool isFunctionSafeToOutlineFrom(MachineFunction &MF, bool OutlineFromLinkOnceODRs) const override; std::optional<outliner::OutlinedFunction> getOutliningCandidateInfo( + const MachineModuleInfo &MMI, std::vector<outliner::Candidate> &RepeatedSequenceLocs) const override; void mergeOutliningCandidateAttributes( Function &F, std::vector<outliner::Candidate> &Candidates) const override; - outliner::InstrType - getOutliningTypeImpl(MachineBasicBlock::iterator &MIT, unsigned Flags) const override; + outliner::InstrType getOutliningTypeImpl(const MachineModuleInfo &MMI, + MachineBasicBlock::iterator &MIT, + unsigned Flags) const override; SmallVector< std::pair<MachineBasicBlock::iterator, MachineBasicBlock::iterator>> getOutlinableRanges(MachineBasicBlock &MBB, unsigned &Flags) const override; diff --git a/llvm/lib/Target/ARM/ARMBaseInstrInfo.cpp b/llvm/lib/Target/ARM/ARMBaseInstrInfo.cpp index bf6bb8c295efe..df7970feecbbc 100644 --- a/llvm/lib/Target/ARM/ARMBaseInstrInfo.cpp +++ b/llvm/lib/Target/ARM/ARMBaseInstrInfo.cpp @@ -5873,6 +5873,7 @@ static bool isLRAvailable(const TargetRegisterInfo &TRI, std::optional<outliner::OutlinedFunction> ARMBaseInstrInfo::getOutliningCandidateInfo( + const MachineModuleInfo &MMI, std::vector<outliner::Candidate> &RepeatedSequenceLocs) const { unsigned SequenceSize = 0; for (auto &MI : RepeatedSequenceLocs[0]) @@ -6278,8 +6279,9 @@ bool ARMBaseInstrInfo::isMBBSafeToOutlineFrom(MachineBasicBlock &MBB, } outliner::InstrType -ARMBaseInstrInfo::getOutliningTypeImpl(MachineBasicBlock::iterator &MIT, - unsigned Flags) const { +ARMBaseInstrInfo::getOutliningTypeImpl(const MachineModuleInfo &MMI, + MachineBasicBlock::iterator &MIT, + unsigned Flags) const { MachineInstr &MI = *MIT; const TargetRegisterInfo *TRI = &getRegisterInfo(); diff --git a/llvm/lib/Target/ARM/ARMBaseInstrInfo.h b/llvm/lib/Target/ARM/ARMBaseInstrInfo.h index a3c2684ac1fb9..8521e3ef91399 100644 --- a/llvm/lib/Target/ARM/ARMBaseInstrInfo.h +++ b/llvm/lib/Target/ARM/ARMBaseInstrInfo.h @@ -356,11 +356,13 @@ class ARMBaseInstrInfo : public ARMGenInstrInfo { bool isFunctionSafeToOutlineFrom(MachineFunction &MF, bool OutlineFromLinkOnceODRs) const override; std::optional<outliner::OutlinedFunction> getOutliningCandidateInfo( + const MachineModuleInfo &MMI, std::vector<outliner::Candidate> &RepeatedSequenceLocs) const override; void mergeOutliningCandidateAttributes( Function &F, std::vector<outliner::Candidate> &Candidates) const override; - outliner::InstrType getOutliningTypeImpl(MachineBasicBlock::iterator &MIT, - unsigned Flags) const override; + outliner::InstrType getOutliningTypeImpl(const MachineModuleInfo &MMI, + MachineBasicBlock::iterator &MIT, + unsigned Flags) const override; bool isMBBSafeToOutlineFrom(MachineBasicBlock &MBB, unsigned &Flags) const override; void buildOutlinedFrame(MachineBasicBlock &MBB, MachineFunction &MF, diff --git a/llvm/lib/Target/RISCV/RISCVInstrInfo.cpp b/llvm/lib/Target/RISCV/RISCVInstrInfo.cpp index ba3b4bd701d63..1df51c1595b8d 100644 --- a/llvm/lib/Target/RISCV/RISCVInstrInfo.cpp +++ b/llvm/lib/Target/RISCV/RISCVInstrInfo.cpp @@ -2830,6 +2830,7 @@ bool RISCVInstrInfo::shouldOutlineFromFunctionByDefault( std::optional<outliner::OutlinedFunction> RISCVInstrInfo::getOutliningCandidateInfo( + const MachineModuleInfo &MMI, std::vector<outliner::Candidate> &RepeatedSequenceLocs) const { // First we need to filter out candidates where the X5 register (IE t0) can't @@ -2868,8 +2869,9 @@ RISCVInstrInfo::getOutliningCandidateInfo( } outliner::InstrType -RISCVInstrInfo::getOutliningTypeImpl(MachineBasicBlock::iterator &MBBI, - unsigned Flags) const { +RISCVInstrInfo::getOutliningTypeImpl(const MachineModuleInfo &MMI, + MachineBasicBlock::iterator &MBBI, + unsigned Flags) const { MachineInstr &MI = *MBBI; MachineBasicBlock *MBB = MI.getParent(); const TargetRegisterInfo *TRI = diff --git a/llvm/lib/Target/RISCV/RISCVInstrInfo.h b/llvm/lib/Target/RISCV/RISCVInstrInfo.h index 025cc36d19eb7..025e12d81e60d 100644 --- a/llvm/lib/Target/RISCV/RISCVInstrInfo.h +++ b/llvm/lib/Target/RISCV/RISCVInstrInfo.h @@ -206,11 +206,13 @@ class RISCVInstrInfo : public RISCVGenInstrInfo { // Calculate target-specific information for a set of outlining candidates. std::optional<outliner::OutlinedFunction> getOutliningCandidateInfo( + const MachineModuleInfo &MMI, std::vector<outliner::Candidate> &RepeatedSequenceLocs) const override; // Return if/how a given MachineInstr should be outlined. virtual outliner::InstrType - getOutliningTypeImpl(MachineBasicBlock::iterator &MBBI, + getOutliningTypeImpl(const MachineModuleInfo &MMI, + MachineBasicBlock::iterator &MBBI, unsigned Flags) const override; // Insert a custom frame for outlined functions. diff --git a/llvm/lib/Target/X86/X86InstrInfo.cpp b/llvm/lib/Target/X86/X86InstrInfo.cpp index fab7c167e385f..f3e6aaf35ca82 100644 --- a/llvm/lib/Target/X86/X86InstrInfo.cpp +++ b/llvm/lib/Target/X86/X86InstrInfo.cpp @@ -10468,6 +10468,7 @@ enum MachineOutlinerClass { MachineOutlinerDefault, MachineOutlinerTailCall }; std::optional<outliner::OutlinedFunction> X86InstrInfo::getOutliningCandidateInfo( + const MachineModuleInfo &MMI, std::vector<outliner::Candidate> &RepeatedSequenceLocs) const { unsigned SequenceSize = 0; for (auto &MI : RepeatedSequenceLocs[0]) { @@ -10544,7 +10545,8 @@ bool X86InstrInfo::isFunctionSafeToOutlineFrom( } outliner::InstrType -X86InstrInfo::getOutliningTypeImpl(MachineBasicBlock::iterator &MIT, +X86InstrInfo::getOutliningTypeImpl(const MachineModuleInfo &MMI, + MachineBasicBlock::iterator &MIT, unsigned Flags) const { MachineInstr &MI = *MIT; diff --git a/llvm/lib/Target/X86/X86InstrInfo.h b/llvm/lib/Target/X86/X86InstrInfo.h index eaa3dd0893948..3100a9e5699f0 100644 --- a/llvm/lib/Target/X86/X86InstrInfo.h +++ b/llvm/lib/Target/X86/X86InstrInfo.h @@ -585,13 +585,15 @@ class X86InstrInfo final : public X86GenInstrInfo { getSerializableDirectMachineOperandTargetFlags() const override; std::optional<outliner::OutlinedFunction> getOutliningCandidateInfo( + const MachineModuleInfo &MMI, std::vector<outliner::Candidate> &RepeatedSequenceLocs) const override; bool isFunctionSafeToOutlineFrom(MachineFunction &MF, bool OutlineFromLinkOnceODRs) const override; - outliner::InstrType - getOutliningTypeImpl(MachineBasicBlock::iterator &MIT, unsigned Flags) const override; + outliner::InstrType getOutliningTypeImpl(const MachineModuleInfo &MMI, + MachineBasicBlock::iterator &MIT, + unsigned Flags) const override; vo... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/99688 _______________________________________________ llvm-branch-commits mailing list llvm-branch-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
