[BOLT][NFC] Use ListSeparator in BinaryFunction print methods

[rafauler]

Nice!

bolt/lib/Core/BinaryFunction.cpp

 #include "bolt/Core/BinaryDomTree.h"
 #include "bolt/Core/DynoStats.h"
 #include "bolt/Core/MCPlusBuilder.h"
 #include "bolt/Utils/NameResolver.h"
 #include "bolt/Utils/NameShortener.h"
 #include "bolt/Utils/Utils.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallSet.h"
+#include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/edit_distance.h"
 #include "llvm/Demangle/Demangle.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCAsmLayout.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDisassembler/MCDisassembler.h"
 #include "llvm/MC/MCExpr.h"
void BinaryFunction::print(raw_ostream &OS, std::string Annotation,
   if (IsFragment)
     OS << "\n  IsFragment  : true";
   if (isFolded())
     OS << "\n  FoldedInto  : " << *getFoldedIntoFunction();
   for (BinaryFunction *ParentFragment : ParentFragments)
     OS << "\n  Parent      : " << *ParentFragment;
   if (!Fragments.empty()) {
     OS << "\n  Fragments   : ";
-    const char *Sep = "";
-    for (BinaryFunction *Frag : Fragments) {
-      OS << Sep << *Frag;
-      Sep = ", ";
-    }
+    ListSeparator LS;
+    for (BinaryFunction *Frag : Fragments)
+      OS << LS << *Frag;
   }
   if (hasCFG())
     OS << "\n  Hash        : " << Twine::utohexstr(computeHash());
   if (isMultiEntry()) {
     OS << "\n  Secondary Entry Points : ";
-    const char *Sep = "";
-    for (const auto &KV : SecondaryEntryPoints) {
-      OS << Sep << KV.second->getName();
-      Sep = ", ";
-    }
+    ListSeparator LS;
+    for (const auto &KV : SecondaryEntryPoints)
+      OS << LS << KV.second->getName();
   }
   if (FrameInstructions.size())
     OS << "\n  CFI Instrs  : " << FrameInstructions.size();
   if (BasicBlocksLayout.size()) {
     OS << "\n  BB Layout   : ";
-    const char *Sep = "";
-    for (BinaryBasicBlock *BB : BasicBlocksLayout) {
-      OS << Sep << BB->getName();
-      Sep = ", ";
-    }
+    ListSeparator LS;
+    for (BinaryBasicBlock *BB : BasicBlocksLayout)
+      OS << LS << BB->getName();
   }
   if (ImageAddress)
     OS << "\n  Image       : 0x" << Twine::utohexstr(ImageAddress);
   if (ExecutionCount != COUNT_NO_PROFILE) {
     OS << "\n  Exec Count  : " << ExecutionCount;
     OS << "\n  Profile Acc : " << format("%.1f%%", ProfileMatchRatio * 100.0f);
   }
 
for (uint32_t I = 0, E = BasicBlocksLayout.size(); I != E; ++I) {
     if (BB->getCFIState() >= 0)
       OS << "  CFI State : " << BB->getCFIState() << '\n';
     if (opts::EnableBAT) {
       OS << "  Input offset: " << Twine::utohexstr(BB->getInputOffset())
          << "\n";
     }
     if (!BB->pred_empty()) {
       OS << "  Predecessors: ";
-      const char *Sep = "";
-      for (BinaryBasicBlock *Pred : BB->predecessors()) {
-        OS << Sep << Pred->getName();
-        Sep = ", ";
-      }
+      ListSeparator LS;
+      for (BinaryBasicBlock *Pred : BB->predecessors())
+        OS << LS << Pred->getName();
       OS << '\n';
     }
     if (!BB->throw_empty()) {
       OS << "  Throwers: ";
-      const char *Sep = "";
-      for (BinaryBasicBlock *Throw : BB->throwers()) {
-        OS << Sep << Throw->getName();
-        Sep = ", ";
-      }
+      ListSeparator LS;
+      for (BinaryBasicBlock *Throw : BB->throwers())
+        OS << LS << Throw->getName();
       OS << '\n';
     }
 
     Offset = alignTo(Offset, BB->getAlignment());
 
     // Note: offsets are imprecise since this is happening prior to relaxation.
     Offset = BC.printInstructions(OS, BB->begin(), BB->end(), Offset, this);
 
     if (!BB->succ_empty()) {
       OS << "  Successors: ";
       // For more than 2 successors, sort them based on frequency.
       std::vector<uint64_t> Indices(BB->succ_size());
       std::iota(Indices.begin(), Indices.end(), 0);
       if (BB->succ_size() > 2 && BB->getKnownExecutionCount()) {
         std::stable_sort(Indices.begin(), Indices.end(),
                          [&](const uint64_t A, const uint64_t B) {
                            return BB->BranchInfo[B] < BB->BranchInfo[A];
                          });
       }
-      const char *Sep = "";
+      ListSeparator LS;
       for (unsigned I = 0; I < Indices.size(); ++I) {
         BinaryBasicBlock *Succ = BB->Successors[Indices[I]];
         BinaryBasicBlock::BinaryBranchInfo &BI = BB->BranchInfo[Indices[I]];
-        OS << Sep << Succ->getName();
+        OS << LS << Succ->getName();
         if (ExecutionCount != COUNT_NO_PROFILE &&
             BI.MispredictedCount != BinaryBasicBlock::COUNT_INFERRED) {
           OS << " (mispreds: " << BI.MispredictedCount
              << ", count: " << BI.Count << ")";
         } else if (ExecutionCount != COUNT_NO_PROFILE &&
                    BI.Count != BinaryBasicBlock::COUNT_NO_PROFILE) {
           OS << " (inferred count: " << BI.Count << ")";
         }
-        Sep = ", ";
       }
       OS << '\n';
     }
 
     if (!BB->lp_empty()) {
       OS << "  Landing Pads: ";
-      const char *Sep = "";
+      ListSeparator LS;
       for (BinaryBasicBlock *LP : BB->landing_pads()) {
-        OS << Sep << LP->getName();
+        OS << LS << LP->getName();
         if (ExecutionCount != COUNT_NO_PROFILE) {
           OS << " (count: " << LP->getExecutionCount() << ")";
         }
-        Sep = ", ";
       }
       OS << '\n';
     }
 
     // In CFG_Finalized state we can miscalculate CFI state at exit.
     if (CurrentState == State::CFG) {
       const int32_t CFIStateAtExit = BB->getCFIStateAtExit();
       if (CFIStateAtExit >= 0)
while (!St.empty()) {
 
     if (!hasValidProfile())
       continue;
 
     OS << (L->getLoopDepth() > 1 ? "Nested" : "Outer")
        << " loop header: " << L->getHeader()->getName();
     OS << "\n";
     OS << "Loop basic blocks: ";
-    const char *Sep = "";
-    for (auto BI = L->block_begin(), BE = L->block_end(); BI != BE; ++BI) {
-      OS << Sep << (*BI)->getName();
-      Sep = ", ";
-    }
+    ListSeparator LS;
+    for (BinaryBasicBlock *BB : L->blocks())
+      OS << LS << BB->getName();
     OS << "\n";
     if (hasValidProfile()) {
       OS << "Total back edge count: " << L->TotalBackEdgeCount << "\n";
       OS << "Loop entry count: " << L->EntryCount << "\n";
       OS << "Loop exit count: " << L->ExitCount << "\n";
       if (L->EntryCount > 0) {
         OS << "Average iters per entry: "
            << format("%.4lf", (double)L->TotalBackEdgeCount / L->EntryCount)