Testing

[rnk]

Summary

Testing Phab upload

llvm/lib/CodeGen/BranchFolding.h

private:
     /// MachineBasicBlock::iterator into that MBB indicating the instruction
     /// where the matching code sequence begins.  Order of elements in SameTails
     /// is the reverse of the order in which those blocks appear in
     /// MergePotentials (where they are not necessarily consecutive).
     unsigned ComputeSameTails(unsigned CurHash, unsigned minCommonTailLength,
                               MachineBasicBlock *SuccBB,
                               MachineBasicBlock *PredBB);
 
+    unsigned HashEndOfMBB(const MachineBasicBlock &MBB) const;
+
     /// Remove all blocks with hash CurHash from MergePotentials, restoring
     /// branches at ends of blocks as appropriate.
     void RemoveBlocksWithHash(unsigned CurHash, MachineBasicBlock* SuccBB,
                                                 MachineBasicBlock* PredBB);
 
     /// None of the blocks to be tail-merged consist only of the common tail.
     /// Create a block that does by splitting one.
     bool CreateCommonTailOnlyBlock(MachineBasicBlock *&PredBB,

llvm/lib/CodeGen/BranchFolding.cpp

for (unsigned i = 0, e = MI.getNumOperands(); i != e; ++i) {
     }
 
     Hash += ((OperandHash << 3) | Op.getType()) << (i & 31);
   }
   return Hash;
 }
 
 /// HashEndOfMBB - Hash the last instruction in the MBB.
-static unsigned HashEndOfMBB(const MachineBasicBlock &MBB) {
+unsigned BranchFolder::HashEndOfMBB(const MachineBasicBlock &MBB) const {
+  unsigned LastInstrHash = 0;
   MachineBasicBlock::const_iterator I = MBB.getLastNonDebugInstr(false);
-  if (I == MBB.end())
-    return 0;
+  if (I != MBB.end())
+    LastInstrHash = HashMachineInstr(*I);
 
-  return HashMachineInstr(*I);
+  // Avoid trying to tail merge across EH scopes.
+  unsigned EHScope = 0;
+  if (!EHScopeMembership.empty()) {
+    assert(EHScopeMembership.count(&MBB));
+    EHScope = EHScopeMembership.find(&MBB)->second;
+    llvm::errs() << "EHScope for " << printMBBReference(MBB) << ": " << EHScope << '\n';
+  }
+  return LastInstrHash + EHScope;
 }
 
 /// Whether MI should be counted as an instruction when calculating common tail.
 static bool countsAsInstruction(const MachineInstr &MI) {
   return !(MI.isDebugInstr() || MI.isCFIInstruction());
 }
 
 /// Iterate backwards from the given iterator \p I, towards the beginning of the
bool BranchFolder::TailMergeBlocks(MachineFunction &MF) {
   // with a conceptual B to IBB after that, which never actually exists.
   // With those changes, we see whether the predecessors' tails match,
   // and merge them if so.  We change things out of canonical form and
   // back to the way they were later in the process.  (OptimizeBranches
   // would undo some of this, but we can't use it, because we'd get into
   // a compile-time infinite loop repeatedly doing and undoing the same
   // transformations.)
 
+  llvm::errs() << "after TryTailMergeBlocks\n";
+
   for (MachineFunction::iterator I = std::next(MF.begin()), E = MF.end();
        I != E; ++I) {
     if (I->pred_size() < 2) continue;
     SmallPtrSet<MachineBasicBlock *, 8> UniquePreds;
     MachineBasicBlock *IBB = &*I;
     MachineBasicBlock *PredBB = &*std::prev(I);
     MergePotentials.clear();
     MachineLoop *ML;
for (MachineFunction::iterator I = std::next(MF.begin()), E = MF.end();
 
     // Reinsert an unconditional branch if needed. The 1 below can occur as a
     // result of removing blocks in TryTailMergeBlocks.
     PredBB = &*std::prev(I); // this may have been changed in TryTailMergeBlocks
     if (MergePotentials.size() == 1 &&
         MergePotentials.begin()->getBlock() != PredBB)
       FixTail(MergePotentials.begin()->getBlock(), IBB, TII);
   }
+  llvm::errs() << "after after TryTailMergeBlocks\n";
 
   return MadeChange;
 }
 
 void BranchFolder::setCommonTailEdgeWeights(MachineBasicBlock &TailMBB) {
   SmallVector<BlockFrequency, 2> EdgeFreqLs(TailMBB.succ_size());
   BlockFrequency AccumulatedMBBFreq;
 
bool BranchFolder::OptimizeBranches(MachineFunction &MF) {
   EHScopeMembership = getEHScopeMembership(MF);
 
   for (MachineBasicBlock &MBB :
        llvm::make_early_inc_range(llvm::drop_begin(MF))) {
     MadeChange |= OptimizeBlock(&MBB);
 
     // If it is dead, remove it.
     if (MBB.pred_empty() && !MBB.isMachineBlockAddressTaken()) {
+      LLVM_DEBUG(dbgs() << "OptimizeBlock removed predecessors of "
+                        << printMBBReference(MBB) << '\n');
       RemoveDeadBlock(&MBB);
       MadeChange = true;
       ++NumDeadBlocks;
     }
   }
 
   return MadeChange;
 }
ReoptimizeBlock:
   bool CurUnAnalyzable =
       TII->analyzeBranch(*MBB, CurTBB, CurFBB, CurCond, true);
 
   // If this block is empty, make everyone use its fall-through, not the block
   // explicitly.  Landing pads should not do this since the landing-pad table
   // points to this block.  Blocks with their addresses taken shouldn't be
   // optimized away.
   if (IsEmptyBlock(MBB) && !MBB->isEHPad() && !MBB->hasAddressTaken() &&
-      SameEHScope) {
+      SameEHScope && !MBB->hasEHPadSuccessor()) {
     salvageDebugInfoFromEmptyBlock(TII, *MBB);
     // Dead block?  Leave for cleanup later.
     if (MBB->pred_empty()) return MadeChange;
 
     if (FallThrough == MF.end()) {
       // TODO: Simplify preds to not branch here if possible!
     } else if (FallThrough->isEHPad()) {
       // Don't rewrite to a landing pad fallthough.  That could lead to the case