Codegen: Don't outline in favor of return blocks

[iteratee]

Summary

When outlining optional branches, an early exit condition will make the
rest of the function optional. If we outline in favor of this exit
block, it can place the return block in the middle of the function. In 3
very different benchmarks, I found that not outlining in favor of the
return block would fix the performance regression. Two of the benchmarks
are in the test-suite:
MultiSource/Applications/lambda-0.1.3/lambda.test
SingleSource/Benchmarks/fib2

lambda exhibits far worse instruction decode cache with outlining
enabled and without this patch.

fib2 exhibits worse branch prediction, which by itself isn't an argument
for this patch, but it is another point in a pattern.

The internal benchmark that slowed down was basically a large function
where incorrect exit placement created additional icache misses

Taken together these three data points, along with the absence of any
obvious regressions in the test-suite with outlining enabled vs this
patch suggest that this is a reasonable heuristic.

[mcrosier]

Please include a test case.

lib/CodeGen/MachineBlockPlacement.cpp

for (MachineBasicBlock *Succ : Successors) {
     if (SuccProbN >= SuccProbD)
       SuccProb = BranchProbability::getOne();
     else
       SuccProb = BranchProbability(SuccProbN, SuccProbD);
 
     // If we outline optional branches, look whether Succ is unavoidable, i.e.
     // dominates all terminators of the MachineFunction. If it does, other
     // successors must be optional. Don't do this for cold branches.
+    // Also, return branches seem to behave perversely as well. Don't outline in
+    // favor of them either, unless the exit branch is hot.
     if (OutlineOptionalBranches && SuccProb > HotProb.getCompl() &&
-        UnavoidableBlocks.count(Succ) > 0) {
+        UnavoidableBlocks.count(Succ) > 0 &&
+        (!Succ->isReturnBlock() || SuccProb > HotProb)) {
       auto HasShortOptionalBranch = [&]() {
         for (MachineBasicBlock *Pred : Succ->predecessors()) {
           // Check whether there is an unplaced optional branch.
           if (Pred == Succ || (BlockFilter && !BlockFilter->count(Pred)) ||
               BlockToChain[Pred] == &Chain)
             continue;
           // Check whether the optional branch has exactly one BB.
           if (Pred->pred_size() > 1 || *Pred->pred_begin() != BB)
for (;;) {
     assert(BB);
     assert(BlockToChain[BB] == &Chain);
     assert(*std::prev(Chain.end()) == BB);
 
     // Look for the best viable successor if there is one to place immediately
     // after this block.
     MachineBasicBlock *BestSucc = selectBestSuccessor(BB, Chain, BlockFilter);
 
-    // If an immediate successor isn't available, look for the best viable
     // block among those we've identified as not violating the loop's CFG at
     // this point. This won't be a fallthrough, but it will increase locality.
     if (!BestSucc)
       BestSucc = selectBestCandidateBlock(Chain, BlockWorkList);
     if (!BestSucc)
       BestSucc = selectBestCandidateBlock(Chain, EHPadWorkList);
 
     if (!BestSucc) {