[SelectOptimize] Add some debug logging. NFC

[dmgreen]

Summary

This is some quick debug messages for the SelectOptimize pass, adding some information for the costs that are measured from getInstructionCost calls, and re-using the existing optimization remarks to print some information about if transforms were performed or not.

[dmgreen]

Thanks.

I've added one extra quick debug message for showing which select the base heuristic is currently analyzing at, to show which the Opt remark relates to. With that I'll commit this now, it has seemed useful.

llvm/lib/CodeGen/SelectOptimize.cpp

void SelectOptimize::findProfitableSIGroupsBase(SelectGroups &SIGroups,
                                                 SelectGroups &ProfSIGroups) {
   for (SelectGroup &ASI : SIGroups) {
     ++NumSelectOptAnalyzed;
     if (isConvertToBranchProfitableBase(ASI))
       ProfSIGroups.push_back(ASI);
   }
 }
 
+static void EmitAndPrintRemark(OptimizationRemarkEmitter *ORE,
+                               DiagnosticInfoOptimizationBase &Rem) {
+  LLVM_DEBUG(dbgs() << Rem.getMsg() << "\n");
+  ORE->emit(Rem);
+}
+
 void SelectOptimize::findProfitableSIGroupsInnerLoops(
     const Loop *L, SelectGroups &SIGroups, SelectGroups &ProfSIGroups) {
   NumSelectOptAnalyzed += SIGroups.size();
   // For each select group in an inner-most loop,
   // a branch is more preferable than a select/conditional-move if:
   // i) conversion to branches for all the select groups of the loop satisfies
   //    loop-level heuristics including reducing the loop's critical path by
   //    some threshold (see SelectOptimize::checkLoopHeuristics); and
for (SelectInst *SI : ASI) {
       SelectCost = std::max(SelectCost, InstCostMap[SI].PredCost);
       BranchCost = std::max(BranchCost, InstCostMap[SI].NonPredCost);
     }
     if (BranchCost < SelectCost) {
       OptimizationRemark OR(DEBUG_TYPE, "SelectOpti", ASI.front());
       OR << "Profitable to convert to branch (loop analysis). BranchCost="
          << BranchCost.toString() << ", SelectCost=" << SelectCost.toString()
          << ". ";
-      ORE->emit(OR);
+      EmitAndPrintRemark(ORE, OR);
       ++NumSelectConvertedLoop;
       ProfSIGroups.push_back(ASI);
     } else {
       OptimizationRemarkMissed ORmiss(DEBUG_TYPE, "SelectOpti", ASI.front());
       ORmiss << "Select is more profitable (loop analysis). BranchCost="
              << BranchCost.toString()
              << ", SelectCost=" << SelectCost.toString() << ". ";
-      ORE->emit(ORmiss);
+      EmitAndPrintRemark(ORE, ORmiss);
     }
   }
 }
 
 bool SelectOptimize::isConvertToBranchProfitableBase(
     const SmallVector<SelectInst *, 2> &ASI) {
   SelectInst *SI = ASI.front();
+  LLVM_DEBUG(dbgs() << "Analyzing select group containing " << *SI << "\n");
   OptimizationRemark OR(DEBUG_TYPE, "SelectOpti", SI);
   OptimizationRemarkMissed ORmiss(DEBUG_TYPE, "SelectOpti", SI);
 
   // Skip cold basic blocks. Better to optimize for size for cold blocks.
   if (PSI->isColdBlock(SI->getParent(), BFI.get())) {
     ++NumSelectColdBB;
     ORmiss << "Not converted to branch because of cold basic block. ";
-    ORE->emit(ORmiss);
+    EmitAndPrintRemark(ORE, ORmiss);
     return false;
   }
 
   // If unpredictable, branch form is less profitable.
   if (SI->getMetadata(LLVMContext::MD_unpredictable)) {
     ++NumSelectUnPred;
     ORmiss << "Not converted to branch because of unpredictable branch. ";
-    ORE->emit(ORmiss);
+    EmitAndPrintRemark(ORE, ORmiss);
     return false;
   }
 
   // If highly predictable, branch form is more profitable, unless a
   // predictable select is inexpensive in the target architecture.
   if (isSelectHighlyPredictable(SI) && TLI->isPredictableSelectExpensive()) {
     ++NumSelectConvertedHighPred;
     OR << "Converted to branch because of highly predictable branch. ";
-    ORE->emit(OR);
+    EmitAndPrintRemark(ORE, OR);
     return true;
   }
 
   // Look for expensive instructions in the cold operand's (if any) dependence
   // slice of any of the selects in the group.
   if (hasExpensiveColdOperand(ASI)) {
     ++NumSelectConvertedExpColdOperand;
     OR << "Converted to branch because of expensive cold operand.";
-    ORE->emit(OR);
+    EmitAndPrintRemark(ORE, OR);
     return true;
   }
 
   ORmiss << "Not profitable to convert to branch (base heuristic).";
-  ORE->emit(ORmiss);
+  EmitAndPrintRemark(ORE, ORmiss);
   return false;
 }
 
 static InstructionCost divideNearest(InstructionCost Numerator,
                                      uint64_t Denominator) {
   return (Numerator + (Denominator / 2)) / Denominator;
 }
 
 bool SelectOptimize::hasExpensiveColdOperand(
     const SmallVector<SelectInst *, 2> &ASI) {
   bool ColdOperand = false;
   uint64_t TrueWeight, FalseWeight, TotalWeight;
   if (extractBranchWeights(*ASI.front(), TrueWeight, FalseWeight)) {
     uint64_t MinWeight = std::min(TrueWeight, FalseWeight);
     TotalWeight = TrueWeight + FalseWeight;
     // Is there a path with frequency <ColdOperandThreshold% (default:20%) ?
     ColdOperand = TotalWeight * ColdOperandThreshold > 100 * MinWeight;
   } else if (PSI->hasProfileSummary()) {
     OptimizationRemarkMissed ORmiss(DEBUG_TYPE, "SelectOpti", ASI.front());
     ORmiss << "Profile data available but missing branch-weights metadata for "
               "select instruction. ";
-    ORE->emit(ORmiss);
+    EmitAndPrintRemark(ORE, ORmiss);
   }
   if (!ColdOperand)
     return false;
   // Check if the cold path's dependence slice is expensive for any of the
   // selects of the group.
   for (SelectInst *SI : ASI) {
     Instruction *ColdI = nullptr;
     uint64_t HotWeight;
bool SelectOptimize::checkLoopHeuristics(const Loop *L,
 
   OptimizationRemarkMissed ORmissL(DEBUG_TYPE, "SelectOpti",
                                    L->getHeader()->getFirstNonPHI());
 
   if (LoopCost[0].NonPredCost > LoopCost[0].PredCost ||
       LoopCost[1].NonPredCost >= LoopCost[1].PredCost) {
     ORmissL << "No select conversion in the loop due to no reduction of loop's "
                "critical path. ";
-    ORE->emit(ORmissL);
+    EmitAndPrintRemark(ORE, ORmissL);
     return false;
   }
 
   Scaled64 Gain[2] = {LoopCost[0].PredCost - LoopCost[0].NonPredCost,
                       LoopCost[1].PredCost - LoopCost[1].NonPredCost};
 
   // Profitably converting to branches need to reduce the loop's critical path
   // by at least some threshold (absolute gain of GainCycleThreshold cycles and
   // relative gain of 12.5%).
   if (Gain[1] < Scaled64::get(GainCycleThreshold) ||
       Gain[1] * Scaled64::get(GainRelativeThreshold) < LoopCost[1].PredCost) {
     Scaled64 RelativeGain = Scaled64::get(100) * Gain[1] / LoopCost[1].PredCost;
     ORmissL << "No select conversion in the loop due to small reduction of "
                "loop's critical path. Gain="
             << Gain[1].toString()
             << ", RelativeGain=" << RelativeGain.toString() << "%. ";
-    ORE->emit(ORmissL);
+    EmitAndPrintRemark(ORE, ORmissL);
     return false;
   }
 
   // If the loop's critical path involves loop-carried dependences, the gradient
   // of the gain needs to be at least GainGradientThreshold% (defaults to 25%).
   // This check ensures that the latency reduction for the loop's critical path
   // keeps decreasing with sufficient rate beyond the two analyzed loop
   // iterations.
   if (Gain[1] > Gain[0]) {
     Scaled64 GradientGain = Scaled64::get(100) * (Gain[1] - Gain[0]) /
                             (LoopCost[1].PredCost - LoopCost[0].PredCost);
     if (GradientGain < Scaled64::get(GainGradientThreshold)) {
       ORmissL << "No select conversion in the loop due to small gradient gain. "
                  "GradientGain="
               << GradientGain.toString() << "%. ";
-      ORE->emit(ORmissL);
+      EmitAndPrintRemark(ORE, ORmissL);
       return false;
     }
   }
   // If the gain decreases it is not profitable to convert.
   else if (Gain[1] < Gain[0]) {
     ORmissL
         << "No select conversion in the loop due to negative gradient gain. ";
-    ORE->emit(ORmissL);
+    EmitAndPrintRemark(ORE, ORmissL);
     return false;
   }
 
   // Non-predicated version of the loop is more profitable than its
   // predicated version.
   return true;
 }
 
 // Computes instruction and loop-critical-path costs for both the predicated
 // and non-predicated version of the given loop.
 // Returns false if unable to compute these costs due to invalid cost of loop
 // instruction(s).
 bool SelectOptimize::computeLoopCosts(
     const Loop *L, const SelectGroups &SIGroups,
     DenseMap<const Instruction *, CostInfo> &InstCostMap, CostInfo *LoopCost) {
+  LLVM_DEBUG(dbgs() << "Calculating Latency / IPredCost / INonPredCost of loop "
+                    << L->getHeader()->getName() << "\n");
   const auto &SIset = getSIset(SIGroups);
   // Compute instruction and loop-critical-path costs across two iterations for
   // both predicated and non-predicated version.
   const unsigned Iterations = 2;
   for (unsigned Iter = 0; Iter < Iterations; ++Iter) {
     // Cost of the loop's critical path.
     CostInfo &MaxCost = LoopCost[Iter];
     for (BasicBlock *BB : L->getBlocks()) {
for (BasicBlock *BB : L->getBlocks()) {
           }
         }
         auto ILatency = computeInstCost(&I);
         if (!ILatency) {
           OptimizationRemarkMissed ORmissL(DEBUG_TYPE, "SelectOpti", &I);
           ORmissL << "Invalid instruction cost preventing analysis and "
                      "optimization of the inner-most loop containing this "
                      "instruction. ";
-          ORE->emit(ORmissL);
+          EmitAndPrintRemark(ORE, ORmissL);
           return false;
         }
         IPredCost += Scaled64::get(ILatency.value());
         INonPredCost += Scaled64::get(ILatency.value());
 
         // For a select that can be converted to branch,
         // compute its cost as a branch (non-predicated cost).
         //
for (BasicBlock *BB : L->getBlocks()) {
           Scaled64 CondCost = Scaled64::getZero();
           if (auto *CI = dyn_cast<Instruction>(SI->getCondition()))
             if (InstCostMap.count(CI))
               CondCost = InstCostMap[CI].NonPredCost;
           Scaled64 MispredictCost = getMispredictionCost(SI, CondCost);
 
           INonPredCost = PredictedPathCost + MispredictCost;
         }
+        LLVM_DEBUG(dbgs() << " " << ILatency << "/" << IPredCost << "/"
+                          << INonPredCost << " for " << I << "\n");
 
         InstCostMap[&I] = {IPredCost, INonPredCost};
         MaxCost.PredCost = std::max(MaxCost.PredCost, IPredCost);
         MaxCost.NonPredCost = std::max(MaxCost.NonPredCost, INonPredCost);
       }
     }
+    LLVM_DEBUG(dbgs() << "Iteration " << Iter + 1
+                      << " MaxCost = " << MaxCost.PredCost << " "
+                      << MaxCost.NonPredCost << "\n");
   }
   return true;
 }
 
 SmallPtrSet<const Instruction *, 2>
 SelectOptimize::getSIset(const SelectGroups &SIGroups) {
   SmallPtrSet<const Instruction *, 2> SIset;
   for (const SelectGroup &ASI : SIGroups)