[BOLT] Add skip-non-simple for boltdiff

[Amir]

Summary

Extra filtering for boltdiff, excluding non-simple functions from comparison.

[Amir]

Filter non-simple funcs in BB and edge differences

[maksfb]

LGTM

bolt/lib/Rewrite/BoltDiff.cpp

86–89

Make it cl::ReallyHidden?

[Amir]

ReallyHidden and clang-format

bolt/lib/Rewrite/BoltDiff.cpp

 
 static cl::opt<bool> NormalizeByBin1(
     "normalize-by-bin1",
     cl::desc("show execution count of functions in binary 2 as a ratio of the "
              "total samples in binary 1 - make sure both profiles have equal "
              "collection time and sampling rate for this to make sense"),
     cl::cat(BoltDiffCategory));
 
+static cl::opt<bool>
+    SkipNonSimple("skip-non-simple",
+                  cl::desc("skip non-simple functions in reporting"),
+                  cl::ReallyHidden, cl::cat(BoltDiffCategory));
+
 } // end namespace opts
 
 namespace llvm {
 namespace bolt {
 
 namespace {
 
 /// Helper used to print colored numbers
outs()
         << " largest differences in basic block performance bin 2 -> bin 1:\n";
     outs() << "=========================================================\n";
     setRegularColor();
     outs() << " * Functions with different contents do not appear here\n\n";
     for (const BinaryBasicBlock *BB2 :
          llvm::make_second_range(llvm::reverse(LargestDiffs))) {
       const double Score2 = getNormalizedScore(*BB2, RI2);
       const double Score1 = getNormalizedScore(*BBMap[BB2], RI1);
-      outs() << "BB " << BB2->getName() << " from "
-             << BBToFuncMap[BB2]->getDemangledName()
+      const BinaryFunction *Func = BBToFuncMap[BB2];
+      if (opts::SkipNonSimple && !Func->isSimple())
+        continue;
+      outs() << "BB " << BB2->getName() << " from " << Func->getDemangledName()
              << "\n\tScore bin1 = " << format("%.4f", Score1 * 100.0)
              << "%\n\tScore bin2 = " << format("%.4f", Score2 * 100.0);
       outs() << "%\t(Difference: ";
       printColoredPercentage((Score2 - Score1) * 100.0);
       outs() << ")\n";
       if (opts::PrintDiffBBs) {
         setLightColor();
         BB2->dump();
void reportHottestEdgeDiffs() {
     setRegularColor();
     outs() << " * Functions with different contents do not appear here\n";
     for (std::pair<EdgeTy, EdgeTy> &EI :
          llvm::make_second_range(llvm::reverse(EdgeMap))) {
       EdgeTy &Edge2 = EI.first;
       EdgeTy &Edge1 = EI.second;
       const double Score2 = std::get<2>(Edge2);
       const double Score1 = std::get<2>(Edge1);
+      const BinaryFunction *Func = BBToFuncMap[std::get<0>(Edge2)];
+      if (opts::SkipNonSimple && !Func->isSimple())
+        continue;
       outs() << "Edge (" << std::get<0>(Edge2)->getName() << " -> "
              << std::get<1>(Edge2)->getName() << ") in "
-             << BBToFuncMap[std::get<0>(Edge2)]->getDemangledName()
+             << Func->getDemangledName()
              << "\n\tScore bin1 = " << format("%.4f", Score1 * 100.0)
              << "%\n\tScore bin2 = " << format("%.4f", Score2 * 100.0);
       outs() << "%\t(Difference: ";
       printColoredPercentage((Score2 - Score1) * 100.0);
       outs() << ")\n";
       if (opts::PrintDiffBBs) {
         setLightColor();
         std::get<0>(Edge2)->dump();
for (const auto &MapEntry : FuncMap) {
       if (Iter1 != LTOMap1.end())
         Score1 = LTOAggregatedScore1[Iter1->second];
       double Score2 = getNormalizedScore(*Func2, RI2);
       auto Iter2 = LTOMap2.find(Func2);
       if (Iter2 != LTOMap2.end())
         Score2 = LTOAggregatedScore2[Iter2->second];
       if (Score1 == 0.0 || Score2 == 0.0)
         continue;
+      if (opts::SkipNonSimple && !Func1->isSimple() && !Func2->isSimple())
+        continue;
       LargestDiffs.insert(
           std::make_pair<>(std::abs(Score1 - Score2), MapEntry));
       ScoreMap[Func2] = std::make_pair<>(Score1, Score2);
     }
 
     unsigned Printed = 0;
     setTitleColor();
     outs() << "\nTop " << opts::DisplayCount