Use TargetMachine

Author: ellishg

llvm/include/llvm/CodeGen/TargetInstrInfo.h

@@ -2184,15 +2184,6 @@ class LLVM_ABI TargetInstrInfo : public MCInstrInfo {
                                        MachineBasicBlock::iterator &MIT,
                                        unsigned Flags) const;
 
-  /// Remove all Linker Optimization Hints (LOH) associated with instructions in
-  /// \p MIs and \return the number of hints removed. This is useful in
-  /// transformations that cause these hints to be illegal, like in the machine
-  /// outliner.
-  virtual size_t clearLinkerOptimizationHints(
-      const SmallPtrSetImpl<MachineInstr *> &MIs) const {
-    return 0;
-  }
-
   /// Optional target hook that returns true if \p MBB is safe to outline from,
   /// and returns any target-specific information in \p Flags.
   virtual bool isMBBSafeToOutlineFrom(MachineBasicBlock &MBB,

llvm/include/llvm/Target/TargetMachine.h

@@ -37,6 +37,7 @@ using ModulePassManager = PassManager<Module>;
 
 class Function;
 class GlobalValue;
+class MachineInstr;
 class MachineModuleInfoWrapperPass;
 struct MachineSchedContext;
 class Mangler;
@@ -518,6 +519,15 @@ class TargetMachine {
 
   // MachineRegisterInfo callback function
   virtual void registerMachineRegisterInfoCallback(MachineFunction &MF) const {}
+
+  /// Remove all Linker Optimization Hints (LOH) associated with instructions in
+  /// \p MIs and \return the number of hints removed. This is useful in
+  /// transformations that cause these hints to be illegal, like in the machine
+  /// outliner.
+  virtual size_t clearLinkerOptimizationHints(
+      const SmallPtrSetImpl<MachineInstr *> &MIs) const {
+    return 0;
+  }
 };
 
 } // end namespace llvm

llvm/lib/CodeGen/MachineOutliner.cpp

@@ -67,6 +67,7 @@
 #include "llvm/CodeGen/MachineOptimizationRemarkEmitter.h"
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/CodeGen/TargetInstrInfo.h"
+#include "llvm/CodeGen/TargetPassConfig.h"
 #include "llvm/CodeGen/TargetSubtargetInfo.h"
 #include "llvm/IR/DIBuilder.h"
 #include "llvm/IR/IRBuilder.h"
@@ -77,6 +78,7 @@
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/SuffixTree.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/Target/TargetMachine.h"
 #include "llvm/Transforms/Utils/ModuleUtils.h"
 #include <tuple>
 #include <vector>
@@ -427,6 +429,7 @@ struct MachineOutliner : public ModulePass {
   static char ID;
 
   MachineModuleInfo *MMI = nullptr;
+  const TargetMachine *TM = nullptr;
 
   /// Set to true if the outliner should consider functions with
   /// linkonceodr linkage.
@@ -462,6 +465,7 @@ struct MachineOutliner : public ModulePass {
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequired<MachineModuleInfoWrapperPass>();
+    AU.addRequired<TargetPassConfig>();
     AU.addPreserved<MachineModuleInfoWrapperPass>();
     AU.addUsedIfAvailable<ImmutableModuleSummaryIndexWrapperPass>();
     AU.setPreservesAll();
@@ -1081,10 +1085,9 @@ bool MachineOutliner::outline(
     // the outlined function.
     SmallPtrSet<MachineInstr *, 2> MIs;
     for (Candidate &C : OF->Candidates) {
-      const TargetInstrInfo &TII = *C.getMF()->getSubtarget().getInstrInfo();
       for (MachineInstr &MI : C)
         MIs.insert(&MI);
-      NumRemovedLOHs += TII.clearLinkerOptimizationHints(MIs);
+      NumRemovedLOHs += TM->clearLinkerOptimizationHints(MIs);
       MIs.clear();
     }
 
@@ -1399,6 +1402,7 @@ bool MachineOutliner::runOnModule(Module &M) {
   initializeOutlinerMode(M);
 
   MMI = &getAnalysis<MachineModuleInfoWrapperPass>().getMMI();
+  TM = &getAnalysis<TargetPassConfig>().getTM<TargetMachine>();
 
   // Number to append to the current outlined function.
   unsigned OutlinedFunctionNum = 0;

llvm/lib/Target/AArch64/AArch64InstrInfo.cpp

@@ -9641,15 +9641,6 @@ AArch64InstrInfo::getOutlinableRanges(MachineBasicBlock &MBB,
   return Ranges;
 }
 
-size_t AArch64InstrInfo::clearLinkerOptimizationHints(
-    const SmallPtrSetImpl<MachineInstr *> &MIs) const {
-  if (MIs.empty())
-    return 0;
-  auto *MI = *MIs.begin();
-  auto *FuncInfo = MI->getMF()->getInfo<AArch64FunctionInfo>();
-  return FuncInfo->clearLinkerOptimizationHints(MIs);
-}
-
 outliner::InstrType
 AArch64InstrInfo::getOutliningTypeImpl(const MachineModuleInfo &MMI,
                                        MachineBasicBlock::iterator &MIT,

llvm/lib/Target/AArch64/AArch64InstrInfo.h

@@ -493,8 +493,6 @@ class AArch64InstrInfo final : public AArch64GenInstrInfo {
   outliner::InstrType getOutliningTypeImpl(const MachineModuleInfo &MMI,
                                            MachineBasicBlock::iterator &MIT,
                                            unsigned Flags) const override;
-  size_t clearLinkerOptimizationHints(
-      const SmallPtrSetImpl<MachineInstr *> &MIs) const override;
   SmallVector<
       std::pair<MachineBasicBlock::iterator, MachineBasicBlock::iterator>>
   getOutlinableRanges(MachineBasicBlock &MBB, unsigned &Flags) const override;

llvm/lib/Target/AArch64/AArch64TargetMachine.cpp

@@ -509,6 +509,15 @@ AArch64TargetMachine::createPostMachineScheduler(MachineSchedContext *C) const {
   return DAG;
 }
 
+size_t AArch64TargetMachine::clearLinkerOptimizationHints(
+    const SmallPtrSetImpl<MachineInstr *> &MIs) const {
+  if (MIs.empty())
+    return 0;
+  auto *MI = *MIs.begin();
+  auto *FuncInfo = MI->getMF()->getInfo<AArch64FunctionInfo>();
+  return FuncInfo->clearLinkerOptimizationHints(MIs);
+}
+
 void AArch64leTargetMachine::anchor() { }
 
 AArch64leTargetMachine::AArch64leTargetMachine(

llvm/lib/Target/AArch64/AArch64TargetMachine.h

@@ -76,6 +76,9 @@ class AArch64TargetMachine : public CodeGenTargetMachineImpl {
   ScheduleDAGInstrs *
   createPostMachineScheduler(MachineSchedContext *C) const override;
 
+  size_t clearLinkerOptimizationHints(
+      const SmallPtrSetImpl<MachineInstr *> &MIs) const override;
+
 private:
   bool isLittle;
 };