[MachineOutliner] NFC: Change IsTailCall to a call class + frame class

This commit

- Removes IsTailCall and replaces it with a target-defined unsigned
- Refactors getOutliningCallOverhead and getOutliningFrameOverhead so that they don't use IsTailCall
- Adds a call class + frame class classification to OutlinedFunction and Candidate respectively

This accomplishes a couple things.

Firstly, we don't need the notion of *tail call* in the general outlining algorithm.

Secondly, we now can have different "outlining classes" for each candidate within a set of candidates.
This will make it easy to add new ways to outline sequences for certain targets and dynamically choose
an appropriate cost model for a sequence depending on the context that that sequence lives in.

Ultimately, this should get us closer to being able to do something like, say avoid saving the link
register when outlining AArch64 instructions.



git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@309475 91177308-0d34-0410-b5e6-96231b3b80d8

Author: Jessica Paquette

include/llvm/Target/TargetInstrInfo.h

@@ -1556,7 +1556,11 @@ class TargetInstrInfo : public MCInstrInfo {
   /// \brief Returns the number of instructions that will be taken to call a
   /// function defined by the sequence on the closed interval [ \p StartIt, \p
   /// EndIt].
-  virtual size_t
+  ///
+  /// \returns The number of instructions for the call in the first member,
+  /// and a target-defined unsigned describing what type of call to emit in the
+  /// second member.
+  virtual std::pair<size_t, unsigned>
   getOutliningCallOverhead(MachineBasicBlock::iterator &StartIt,
                            MachineBasicBlock::iterator &EndIt) const {
     llvm_unreachable(
@@ -1566,11 +1570,16 @@ class TargetInstrInfo : public MCInstrInfo {
   /// \brief Returns the number of instructions that will be taken to construct
   /// an outlined function frame for a function defined on the closed interval
   /// [ \p StartIt, \p EndIt].
-  virtual size_t
-  getOutliningFrameOverhead(MachineBasicBlock::iterator &StartIt,
-                            MachineBasicBlock::iterator &EndIt) const {
+  ///
+  /// \returns The number of instructions for the frame in the first member
+  /// and a target-defined unsigned describing what type of frame to construct
+  /// in the second member.
+  virtual std::pair<size_t, unsigned> getOutliningFrameOverhead(
+      std::vector<
+          std::pair<MachineBasicBlock::iterator, MachineBasicBlock::iterator>>
+          &CandidateClass) const {
     llvm_unreachable(
-        "Target didn't implement TargetInstrInfo::getOutliningCallOverhead!");
+        "Target didn't implement TargetInstrInfo::getOutliningFrameOverhead!");
   }
 
   /// Represents how an instruction should be mapped by the outliner.
@@ -1591,7 +1600,7 @@ class TargetInstrInfo : public MCInstrInfo {
   /// emitted.
   virtual void insertOutlinerEpilogue(MachineBasicBlock &MBB,
                                       MachineFunction &MF,
-                                      bool IsTailCall) const {
+                                      unsigned FrameClass) const {
     llvm_unreachable(
         "Target didn't implement TargetInstrInfo::insertOutlinerEpilogue!");
   }
@@ -1602,7 +1611,7 @@ class TargetInstrInfo : public MCInstrInfo {
   virtual MachineBasicBlock::iterator
   insertOutlinedCall(Module &M, MachineBasicBlock &MBB,
                      MachineBasicBlock::iterator &It, MachineFunction &MF,
-                     bool IsTailCall) const {
+                     unsigned CallClass) const {
     llvm_unreachable(
         "Target didn't implement TargetInstrInfo::insertOutlinedCall!");
   }
@@ -1611,7 +1620,7 @@ class TargetInstrInfo : public MCInstrInfo {
   /// This may be empty, in which case no prologue will be emitted.
   virtual void insertOutlinerPrologue(MachineBasicBlock &MBB,
                                       MachineFunction &MF,
-                                      bool IsTailCall) const {
+                                      unsigned FrameClass) const {
     llvm_unreachable(
         "Target didn't implement TargetInstrInfo::insertOutlinerPrologue!");
   }

lib/CodeGen/MachineOutliner.cpp

@@ -87,6 +87,9 @@ struct Candidate {
   /// \p OutlinedFunctions.
   size_t FunctionIdx;
 
+  /// Target-defined unsigned defining how to emit a call for this candidate.
+  unsigned CallClass = 0;
+
   /// \brief The number of instructions that would be saved by outlining every
   /// candidate of this type.
   ///
@@ -96,8 +99,9 @@ struct Candidate {
   /// for some given candidate.
   unsigned Benefit = 0;
 
-  Candidate(size_t StartIdx, size_t Len, size_t FunctionIdx)
-      : StartIdx(StartIdx), Len(Len), FunctionIdx(FunctionIdx) {}
+  Candidate(size_t StartIdx, size_t Len, size_t FunctionIdx, unsigned CallClass)
+      : StartIdx(StartIdx), Len(Len), FunctionIdx(FunctionIdx),
+        CallClass(CallClass) {}
 
   Candidate() {}
 
@@ -127,15 +131,14 @@ struct OutlinedFunction {
   /// The number of instructions this function would save.
   unsigned Benefit = 0;
 
-  /// \brief Set to true if candidates for this outlined function should be
-  /// replaced with tail calls to this OutlinedFunction.
-  bool IsTailCall = false;
+  /// Target-defined unsigned defining how to emit the frame for this function.
+  unsigned FrameClass = 0;
 
   OutlinedFunction(size_t Name, size_t OccurrenceCount,
                    const std::vector<unsigned> &Sequence, unsigned Benefit,
-                   bool IsTailCall)
+                   unsigned FrameClass)
       : Name(Name), OccurrenceCount(OccurrenceCount), Sequence(Sequence),
-        Benefit(Benefit), IsTailCall(IsTailCall) {}
+        Benefit(Benefit), FrameClass(FrameClass) {}
 };
 
 /// Represents an undefined index in the suffix tree.
@@ -842,9 +845,18 @@ MachineOutliner::findCandidates(SuffixTree &ST, const TargetInstrInfo &TII,
     // Figure out if this candidate is beneficial.
     size_t StringLen = Leaf->ConcatLen - Leaf->size();
     size_t CallOverhead = 0;
-    size_t FrameOverhead = 0;
     size_t SequenceOverhead = StringLen;
 
+    // If this is a beneficial class of candidate, then every one is stored in
+    // this vector.
+    std::vector<Candidate> CandidatesForRepeatedSeq;
+
+    // Used for getOutliningFrameOverhead.
+    // FIXME: CandidatesForRepeatedSeq and this should be combined.
+    std::vector<
+        std::pair<MachineBasicBlock::iterator, MachineBasicBlock::iterator>>
+        CandidateClass;
+
     // Figure out the call overhead for each instance of the sequence.
     for (auto &ChildPair : Parent.Children) {
       SuffixTreeNode *M = ChildPair.second;
@@ -854,16 +866,24 @@ MachineOutliner::findCandidates(SuffixTree &ST, const TargetInstrInfo &TII,
         MachineBasicBlock::iterator StartIt = Mapper.InstrList[M->SuffixIdx];
         MachineBasicBlock::iterator EndIt =
             Mapper.InstrList[M->SuffixIdx + StringLen - 1];
-        CallOverhead += TII.getOutliningCallOverhead(StartIt, EndIt);
+
+        // Get the overhead for calling a function for this sequence and any
+        // target-specified data for how to construct the call.
+        std::pair<size_t, unsigned> CallOverheadPair =
+            TII.getOutliningCallOverhead(StartIt, EndIt);
+        CallOverhead += CallOverheadPair.first;
+        CandidatesForRepeatedSeq.emplace_back(M->SuffixIdx, StringLen, FnIdx,
+                                              CallOverheadPair.second);
+        CandidateClass.emplace_back(std::make_pair(StartIt, EndIt));
+
+        // Never visit this leaf again.
+        M->IsInTree = false;
       }
     }
 
-    // Figure out how many instructions it'll take to construct an outlined
-    // function frame for this sequence.
-    MachineBasicBlock::iterator StartIt = Mapper.InstrList[Leaf->SuffixIdx];
-    MachineBasicBlock::iterator EndIt =
-        Mapper.InstrList[Leaf->SuffixIdx + StringLen - 1];
-    FrameOverhead = TII.getOutliningFrameOverhead(StartIt, EndIt);
+    std::pair<size_t, unsigned> FrameOverheadPair =
+        TII.getOutliningFrameOverhead(CandidateClass);
+    size_t FrameOverhead = FrameOverheadPair.first;
 
     size_t OutliningCost = CallOverhead + FrameOverhead + SequenceOverhead;
     size_t NotOutliningCost = SequenceOverhead * Parent.OccurrenceCount;
@@ -876,26 +896,21 @@ MachineOutliner::findCandidates(SuffixTree &ST, const TargetInstrInfo &TII,
     if (StringLen > MaxLen)
       MaxLen = StringLen;
 
-    unsigned OccurrenceCount = 0;
-    for (auto &ChildPair : Parent.Children) {
-      SuffixTreeNode *M = ChildPair.second;
-
-      // Is it a leaf? If so, we have an occurrence of this candidate.
-      if (M && M->IsInTree && M->isLeaf()) {
-        OccurrenceCount++;
-        CandidateList.emplace_back(M->SuffixIdx, StringLen, FnIdx);
-        CandidateList.back().Benefit = Benefit;
-        M->IsInTree = false;
-      }
+    // At this point, the candidate class is seen as beneficial. Set their
+    // benefit values and save them in the candidate list.
+    for (Candidate &C : CandidatesForRepeatedSeq) {
+      C.Benefit = Benefit;
+      CandidateList.push_back(C);
     }
 
     // Save the function for the new candidate sequence.
     std::vector<unsigned> CandidateSequence;
     for (unsigned i = Leaf->SuffixIdx; i < Leaf->SuffixIdx + StringLen; i++)
       CandidateSequence.push_back(ST.Str[i]);
 
-    FunctionList.emplace_back(FnIdx, OccurrenceCount, CandidateSequence,
-                              Benefit, false);
+    FunctionList.emplace_back(FnIdx, CandidatesForRepeatedSeq.size(),
+                              CandidateSequence, Benefit,
+                              FrameOverheadPair.second);
 
     // Move to the next function.
     FnIdx++;
@@ -996,7 +1011,8 @@ void MachineOutliner::pruneOverlaps(std::vector<Candidate> &CandidateList,
         MachineBasicBlock::iterator StartIt = Mapper.InstrList[C2.StartIdx];
         MachineBasicBlock::iterator EndIt =
             Mapper.InstrList[C2.StartIdx + C2.Len - 1];
-        F2.Benefit += TII.getOutliningCallOverhead(StartIt, EndIt);
+
+        F2.Benefit += TII.getOutliningCallOverhead(StartIt, EndIt).first;
         // Add back one instance of the sequence.
 
         if (F2.Sequence.size() > F2.Benefit)
@@ -1022,7 +1038,8 @@ void MachineOutliner::pruneOverlaps(std::vector<Candidate> &CandidateList,
         MachineBasicBlock::iterator StartIt = Mapper.InstrList[C1.StartIdx];
         MachineBasicBlock::iterator EndIt =
             Mapper.InstrList[C1.StartIdx + C1.Len - 1];
-        F2.Benefit += TII.getOutliningCallOverhead(StartIt, EndIt);
+
+        F1.Benefit += TII.getOutliningCallOverhead(StartIt, EndIt).first;
 
         // Add back one instance of the sequence.
         if (F1.Sequence.size() > F1.Benefit)
@@ -1056,10 +1073,6 @@ MachineOutliner::buildCandidateList(std::vector<Candidate> &CandidateList,
   MaxCandidateLen =
       findCandidates(ST, TII, Mapper, CandidateList, FunctionList);
 
-  for (auto &OF : FunctionList)
-    OF.IsTailCall =
-        Mapper.IntegerInstructionMap[OF.Sequence.back()]->isTerminator();
-
   // Sort the candidates in decending order. This will simplify the outlining
   // process when we have to remove the candidates from the mapping by
   // allowing us to cut them out without keeping track of an offset.
@@ -1102,7 +1115,7 @@ MachineOutliner::createOutlinedFunction(Module &M, const OutlinedFunction &OF,
   // Insert the new function into the module.
   MF.insert(MF.begin(), &MBB);
 
-  TII.insertOutlinerPrologue(MBB, MF, OF.IsTailCall);
+  TII.insertOutlinerPrologue(MBB, MF, OF.FrameClass);
 
   // Copy over the instructions for the function using the integer mappings in
   // its sequence.
@@ -1117,7 +1130,7 @@ MachineOutliner::createOutlinedFunction(Module &M, const OutlinedFunction &OF,
     MBB.insert(MBB.end(), NewMI);
   }
 
-  TII.insertOutlinerEpilogue(MBB, MF, OF.IsTailCall);
+  TII.insertOutlinerEpilogue(MBB, MF, OF.FrameClass);
 
   return &MF;
 }
@@ -1166,7 +1179,7 @@ bool MachineOutliner::outline(Module &M,
     const TargetInstrInfo &TII = *STI.getInstrInfo();
 
     // Insert a call to the new function and erase the old sequence.
-    TII.insertOutlinedCall(M, *MBB, StartIt, *MF, OF.IsTailCall);
+    TII.insertOutlinedCall(M, *MBB, StartIt, *MF, C.CallClass);
     StartIt = Mapper.InstrList[C.StartIdx];
     MBB->erase(StartIt, EndIt);
 

lib/Target/AArch64/AArch64InstrInfo.cpp

@@ -4432,27 +4432,34 @@ AArch64InstrInfo::getSerializableMachineMemOperandTargetFlags() const {
   return makeArrayRef(TargetFlags);
 }
 
-size_t AArch64InstrInfo::getOutliningCallOverhead(
+// Constants defining how certain sequences should be outlined.
+const unsigned MachineOutlinerDefaultFn = 0;
+const unsigned MachineOutlinerTailCallFn = 1;
+
+std::pair<size_t, unsigned> AArch64InstrInfo::getOutliningCallOverhead(
     MachineBasicBlock::iterator &StartIt,
     MachineBasicBlock::iterator &EndIt) const {
   // Is this a tail-call?
-  if (EndIt->isTerminator())
-    return 1; // Yes, so we don't need to save/restore LR.
+  if (EndIt->isTerminator()) {
+    // Yes, so we only have to emit a call. Return a cost of 1 + signify that
+    // this candidate should be tail-called.
+    return std::make_pair(1, MachineOutlinerTailCallFn);
+  }
 
   // No, so save + restore LR.
-  return 3;
+  return std::make_pair(3, MachineOutlinerDefaultFn);
 }
 
-size_t AArch64InstrInfo::getOutliningFrameOverhead(
-    MachineBasicBlock::iterator &StartIt,
-    MachineBasicBlock::iterator &EndIt) const {
+std::pair<size_t, unsigned> AArch64InstrInfo::getOutliningFrameOverhead(
+    std::vector<std::pair<MachineBasicBlock::iterator,
+                          MachineBasicBlock::iterator>> &CandidateClass) const {
 
-  // Is this a tail-call?
-  if (EndIt->isTerminator())
-    return 0; // Yes, so we already have a return.
+  // Is the last instruction in this class a terminator?
+  if (CandidateClass[0].second->isTerminator())
+    return std::make_pair(0, MachineOutlinerTailCallFn);
 
   // No, so we have to add a return to the end.
-  return 1;
+  return std::make_pair(1, MachineOutlinerDefaultFn);
 }
 
 bool AArch64InstrInfo::isFunctionSafeToOutlineFrom(MachineFunction &MF) const {
@@ -4568,10 +4575,10 @@ void AArch64InstrInfo::fixupPostOutline(MachineBasicBlock &MBB) const {
 
 void AArch64InstrInfo::insertOutlinerEpilogue(MachineBasicBlock &MBB,
                                               MachineFunction &MF,
-                                              bool IsTailCall) const {
+                                              unsigned FrameClass) const {
 
   // If this is a tail call outlined function, then there's already a return.
-  if (IsTailCall)
+  if (FrameClass == MachineOutlinerTailCallFn)
     return;
 
   // It's not a tail call, so we have to insert the return ourselves.
@@ -4585,18 +4592,17 @@ void AArch64InstrInfo::insertOutlinerEpilogue(MachineBasicBlock &MBB,
 
 void AArch64InstrInfo::insertOutlinerPrologue(MachineBasicBlock &MBB,
                                               MachineFunction &MF,
-                                              bool IsTailCall) const {}
+                                              unsigned FrameClass) const {}
 
 MachineBasicBlock::iterator AArch64InstrInfo::insertOutlinedCall(
     Module &M, MachineBasicBlock &MBB, MachineBasicBlock::iterator &It,
-    MachineFunction &MF, bool IsTailCall) const {
+    MachineFunction &MF, unsigned CallClass) const {
 
   // Are we tail calling?
-  if (IsTailCall) {
+  if (CallClass == MachineOutlinerTailCallFn) {
     // If yes, then we can just branch to the label.
-    It = MBB.insert(It,
-                    BuildMI(MF, DebugLoc(), get(AArch64::B))
-                        .addGlobalAddress(M.getNamedValue(MF.getName())));
+    It = MBB.insert(It, BuildMI(MF, DebugLoc(), get(AArch64::B))
+                            .addGlobalAddress(M.getNamedValue(MF.getName())));
     return It;
   }
 
@@ -4611,9 +4617,8 @@ MachineBasicBlock::iterator AArch64InstrInfo::insertOutlinedCall(
   It++;
 
   // Insert the call.
-  It = MBB.insert(It,
-                  BuildMI(MF, DebugLoc(), get(AArch64::BL))
-                      .addGlobalAddress(M.getNamedValue(MF.getName())));
+  It = MBB.insert(It, BuildMI(MF, DebugLoc(), get(AArch64::BL))
+                          .addGlobalAddress(M.getNamedValue(MF.getName())));
 
   It++;