1 files changed, 25 insertions, 16 deletions

diff --git a/llvm/lib/Target/X86/X86InstrInfo.cpp b/llvm/lib/Target/X86/X86InstrInfo.cpp
index 8eb1536790d..ac1c0c9357d 100644
--- a/llvm/lib/Target/X86/X86InstrInfo.cpp
+++ b/llvm/lib/Target/X86/X86InstrInfo.cpp
@@ -10537,22 +10537,31 @@ char LDTLSCleanup::ID = 0;
 FunctionPass*
 llvm::createCleanupLocalDynamicTLSPass() { return new LDTLSCleanup(); }
 
-size_t X86InstrInfo::getOutliningCallOverhead(
-MachineBasicBlock::iterator &StartIt,
-MachineBasicBlock::iterator &EndIt) const {
-  // We just have to emit a call, so return 1.
-  return 1;
+// Constants defining how certain sequences should be outlined.
+const unsigned MachineOutlinerDefaultFn = 0;
+const unsigned MachineOutlinerTailCallFn = 1;
+
+std::pair<size_t, unsigned> X86InstrInfo::getOutliningCallOverhead(
+    MachineBasicBlock::iterator &StartIt,
+    MachineBasicBlock::iterator &EndIt) const {
+
+  // Is this a tail call? If it is, make note of it.
+  if (EndIt->isTerminator())
+    return std::make_pair(1, MachineOutlinerTailCallFn);
+
+  return std::make_pair(1, MachineOutlinerDefaultFn);
 }
 
-size_t X86InstrInfo::getOutliningFrameOverhead(
-MachineBasicBlock::iterator &StartIt,
-MachineBasicBlock::iterator &EndIt) const {
+std::pair<size_t, unsigned> X86InstrInfo::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 X86InstrInfo::isFunctionSafeToOutlineFrom(MachineFunction &MF) const {
@@ -10616,10 +10625,10 @@ X86InstrInfo::getOutliningType(MachineInstr &MI) const {
 
 void X86InstrInfo::insertOutlinerEpilogue(MachineBasicBlock &MBB,
                                           MachineFunction &MF,
-                                          bool IsTailCall) const {
+                                          unsigned FrameClass) const {
 
   // If we're a tail call, we already have a return, so don't do anything.
-  if (IsTailCall)
+  if (FrameClass == MachineOutlinerTailCallFn)
     return;
 
   // We're a normal call, so our sequence doesn't have a return instruction.
@@ -10630,15 +10639,15 @@ void X86InstrInfo::insertOutlinerEpilogue(MachineBasicBlock &MBB,
 
 void X86InstrInfo::insertOutlinerPrologue(MachineBasicBlock &MBB,
                                           MachineFunction &MF,
-                                          bool IsTailCall) const {}
+                                          unsigned FrameClass) const {}
 
 MachineBasicBlock::iterator
 X86InstrInfo::insertOutlinedCall(Module &M, MachineBasicBlock &MBB,
                                  MachineBasicBlock::iterator &It,
                                  MachineFunction &MF,
-                                 bool IsTailCall) const {
+                                 unsigned CallClass) const {
   // Is it a tail call?
-  if (IsTailCall) {
+  if (CallClass == MachineOutlinerTailCallFn) {
     // Yes, just insert a JMP.
     It = MBB.insert(It,
                   BuildMI(MF, DebugLoc(), get(X86::JMP_1))