Have MachineBlockPlacement select the start of the cold fragment

[deadalnix]

Summary

This will provide a solid point for cold splitting. See D17555 for details.

[davidxl]

lib/CodeGen/MachineBlockPlacement.cpp

601

The split for non EH code can not yet be safely implemented as is -- so it is better to be removed:

1. The cold block outlining currently is only turned on with real profile data;
2. There is on guarantee that the outlining threshold is greater than the split threshold here.

[reames]

lib/CodeGen/MachineBlockPlacement.cpp

595

This seems like very strange placement. Why would we update our notion of cold blocks for every hot block we find? I think you want to move this elsewhere and use the last block under the assumption that is coldest? Also, comments to explain your reasoning will be required.

include/llvm/CodeGen/MachineFunction.h

class MachineFunction {
 
   /// Current high-level properties of the IR of the function (e.g. is in SSA
   /// form or whether registers have been allocated)
   MachineFunctionProperties Properties;
 
   // Allocation management for pseudo source values.
   std::unique_ptr<PseudoSourceValueManager> PSVManager;
 
+  /// Mark a basic block after which the function is cold.
+  /// This is null if no such fragment exists or has been computed.
+  const MachineBasicBlock *ColdFragmentStart;
+
   MachineFunction(const MachineFunction &) = delete;
   void operator=(const MachineFunction&) = delete;
 public:
   MachineFunction(const Function *Fn, const TargetMachine &TM,
                   unsigned FunctionNum, MachineModuleInfo &MMI);
   ~MachineFunction();
 
   MachineModuleInfo &getMMI() const { return MMI; }
public:
   void setHasInlineAsm(bool B) {
     HasInlineAsm = B;
   }
 
   /// Get the function properties
   const MachineFunctionProperties &getProperties() const { return Properties; }
   MachineFunctionProperties &getProperties() { return Properties; }
 
+  /// Get the start of the cold fragment. null if none exists or was conputed.
+  const MachineBasicBlock *getColdFragmentStart() const {
+    return ColdFragmentStart;
+  }
+
+  /// Set the start of the cold fragment.
+  void setColdFragmentStart(const MachineBasicBlock *CFS) {
+    assert(!CFS || CFS->getParent() == this);
+    ColdFragmentStart = CFS;
+  }
+
   /// getInfo - Keep track of various per-function pieces of information for
   /// backends that would like to do so.
   ///
   template<typename Ty>
   Ty *getInfo() {
     if (!MFInfo)
       MFInfo = Ty::template create<Ty>(Allocator, *this);
     return static_cast<Ty*>(MFInfo);

lib/CodeGen/MachineBlockPlacement.cpp

 #include "llvm/CodeGen/MachineDominators.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/CodeGen/MachineLoopInfo.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
+#include "llvm/Support/ScaledNumber.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetInstrInfo.h"
 #include "llvm/Target/TargetLowering.h"
 #include "llvm/Target/TargetSubtargetInfo.h"
 #include <algorithm>
 using namespace llvm;
 
 #define DEBUG_TYPE "block-placement"
for (MachineBasicBlock *MBB : WorkList) {
     // OuterLp -> OuterCleanup -> Resume     InnerLp -> InnerCleanup
     if (BestBlock && (IsEHPad ^ (BestFreq >= CandidateFreq)))
       continue;
 
     BestBlock = MBB;
     BestFreq = CandidateFreq;
   }
 
+  if (!BestBlock)
+    return nullptr;
+
+  auto *MF = BestBlock->getParent();
+  if (MF->getColdFragmentStart())
+    return BestBlock;
+
+  bool IsCold = IsEHPad;
+  if (!IsCold) {
+    typedef ScaledNumber<uint64_t> Scaled64;
+    Scaled64 B(BestFreq.getFrequency(), 5);
+    Scaled64 E(MBFI->getEntryFreq(), 0);
+
+    IsCold = (B / E) < 1;
+  }
+
+  if (IsCold)
+    MF->setColdFragmentStart(BestBlock);
+
   return BestBlock;
 }
 
 /// \brief Retrieve the first unplaced basic block.
 ///
 /// This routine is called when we are unable to use the CFG to walk through
 /// all of the basic blocks and form a chain due to unnatural loops in the CFG.
 /// We walk through the function's blocks in order, starting from the
void MachineBlockPlacement::buildCFGChains(MachineFunction &F) {
 
   SmallVector<MachineBasicBlock *, 16> BlockWorkList;
   SmallVector<MachineBasicBlock *, 16> EHPadWorkList;
 
   SmallPtrSet<BlockChain *, 4> UpdatedPreds;
   for (MachineBasicBlock &MBB : F)
     fillWorkLists(&MBB, UpdatedPreds, BlockWorkList, EHPadWorkList);
 
+  // We are reordering blocks, make sure we reset the cold fragment
+  // start and reset it where apropriate.
+  F.setColdFragmentStart(nullptr);
+
   BlockChain &FunctionChain = *BlockToChain[&F.front()];
   buildChain(&F.front(), FunctionChain, BlockWorkList, EHPadWorkList);
 
 #ifndef NDEBUG
   typedef SmallPtrSet<MachineBasicBlock *, 16> FunctionBlockSetType;
 #endif
   DEBUG({
     // Crash at the end so we get all of the debugging output first.

lib/CodeGen/MachineFunction.cpp

if (!Fn->hasFnAttribute(Attribute::OptimizeForSize))
     Alignment = std::max(Alignment,
                          STI->getTargetLowering()->getPrefFunctionAlignment());
 
   if (AlignAllFunctions)
     Alignment = AlignAllFunctions;
 
   FunctionNumber = FunctionNum;
   JumpTableInfo = nullptr;
+  ColdFragmentStart = nullptr;
 
   if (isFuncletEHPersonality(classifyEHPersonality(
           F->hasPersonalityFn() ? F->getPersonalityFn() : nullptr))) {
     WinEHInfo = new (Allocator) WinEHFuncInfo();
   }
 
   assert(TM.isCompatibleDataLayout(getDataLayout()) &&
          "Can't create a MachineFunction using a Module with a "