[SimplifyCFG] Collect non-contiguous block hoist statistics

[chill]

Summary

Count how many times, when hoisting instructions by
HoistThenElseCodeToIf, they did not belong to a single
contiguous block.

[chill]

Not sure if we want to commit it, but here it is, for reference.

llvm/lib/Transforms/Utils/SimplifyCFG.cpp

STATISTIC(NumFoldValueComparisonIntoPredecessors,
           "Number of value comparisons folded into predecessor basic blocks");
 STATISTIC(NumFoldBranchToCommonDest,
           "Number of branches folded into predecessor basic block");
 STATISTIC(
     NumHoistCommonCode,
     "Number of common instruction 'blocks' hoisted up to the begin block");
 STATISTIC(NumHoistCommonInstrs,
           "Number of common instructions hoisted up to the begin block");
+STATISTIC(
+    NumHoistCommonCodeNonContiguous,
+    "Number of non-contiguous common instruction 'blocks' hoisted up to the begin block");
 STATISTIC(NumSinkCommonCode,
           "Number of common instruction 'blocks' sunk down to the end block");
 STATISTIC(NumSinkCommonInstrs,
           "Number of common instructions sunk down to the end block");
 STATISTIC(NumSpeculations, "Number of speculative executed instructions");
 STATISTIC(NumInvokes,
           "Number of invokes with empty resume blocks simplified into calls");
 STATISTIC(NumInvokesMerged, "Number of invokes that were merged together");
if (!DBI1 || !DBI2 || !DBI1->isIdenticalToWhenDefined(DBI2)) {
     while (isa<DbgInfoIntrinsic>(I2))
       I2 = &*BB2_Itr++;
   }
   if (isa<PHINode>(I1))
     return false;
 
   BasicBlock *BIParent = BI->getParent();
 
-  bool Changed = false;
-
-  auto _ = make_scope_exit([&]() {
-    if (Changed)
-      ++NumHoistCommonCode;
-  });
 
   // Check if only hoisting terminators is allowed. This does not add new
   // instructions to the hoist location.
   if (EqTermsOnly) {
     // Skip any debug intrinsics, as they are free to hoist.
     auto *I1NonDbg = &*skipDebugIntrinsics(I1->getIterator());
     auto *I2NonDbg = &*skipDebugIntrinsics(I2->getIterator());
     if (!I1NonDbg->isIdenticalToWhenDefined(I2NonDbg))
       return false;
     if (!I1NonDbg->isTerminator())
       return false;
     // Now we know that we only need to hoist debug intrinsics and the
     // terminator. Let the loop below handle those 2 cases.
   }
 
   // Count how many instructions were not hoisted so far. There's a limit on how
   // many instructions we skip, serving as a compilation time control as well as
   // preventing excessive increase of life ranges.
   unsigned NumSkipped = 0;
-  
+  // Count how many instructions were reordered over other instructions, for
+  // statistics.
+  unsigned NumReordered = 0;
+
   // Record if any non-hoisted instruction contains side-effects, as it could
   // make it illegal to reorder some instructions across.
   bool ForceNoReadMemOrSideEffectsBB1 = false;
   bool ForceNoReadMemOrSideEffectsBB2 = false;
 
   // Record if any non-hoisted instructions does not necessarily transfer
   // control to the next instruction. Then we can hoist only instrucions which
   // are safe to speculate.
   bool ForceNoSpeculationBB1 = false;
   bool ForceNoSpeculationBB2 = false;
 
+  bool Changed = false;
+
+  auto _ = make_scope_exit([&]() {
+    if (Changed) {
+      ++NumHoistCommonCode;
+      if (NumReordered)
+        ++NumHoistCommonCodeNonContiguous;
+    }
+  });
+
   for (;;) {
     // If we are hoisting the terminator instruction, don't move one (making a
     // broken BB), instead clone it, and remove BI.
     if (I1->isTerminator() || I2->isTerminator()) {
       // If any instructions remain in the block, we cannot hoist terminators.
       if (NumSkipped || !I1->isIdenticalToWhenDefined(I2))
         return Changed;
       goto HoistTerminator;
if (I1->isIdenticalToWhenDefined(I2)) {
         // I1 and I2 are being combined into a single instruction.  Its debug
         // location is the merged locations of the original instructions.
         I1->applyMergedLocation(I1->getDebugLoc(), I2->getDebugLoc());
 
         I2->eraseFromParent();
       }
       Changed = true;
       ++NumHoistCommonInstrs;
+      if (NumSkipped)
+        ++NumReordered;
     } else {
       if (NumSkipped >= HoistCommonSkipLimit)
         return Changed;
       // We are about to skip over a pair of non-identical instructions. Record
       // if any of them has side effects.
       if (I1->mayHaveSideEffects())
         ForceNoReadMemOrSideEffectsBB1 = true;
       if (I2->mayHaveSideEffects())