[BOLT][NFC] Remove unused PrintInstructions argument

[maksfb]

Summary

PrintInstructions was unused in BinaryFunction::print() and dump().

bolt/include/bolt/Core/BinaryFunction.h

public:
 
   /// Determine direction of the call to callee symbol relative to the start
   /// of this function.
   /// Note: this doesn't take function splitting into account.
   bool isForwardCall(const MCSymbol *CalleeSymbol) const;
 
   /// Dump function information to debug output. If \p PrintInstructions
   /// is true - include instruction disassembly.
-  void dump(bool PrintInstructions = true) const;
+  void dump() const;
 
   /// Print function information to the \p OS stream.
-  void print(raw_ostream &OS, std::string Annotation = "",
-             bool PrintInstructions = true);
+  void print(raw_ostream &OS, std::string Annotation = "");
 
   /// Print all relocations between \p Offset and \p Offset + \p Size in
   /// this function.
   void printRelocations(raw_ostream &OS, uint64_t Offset, uint64_t Size) const;
 
   /// Return true if function has a profile, even if the profile does not
   /// match CFG 100%.
   bool hasProfile() const { return ExecutionCount != COUNT_NO_PROFILE; }

bolt/lib/Core/BinaryFunction.cpp

bool BinaryFunction::isForwardCall(const MCSymbol *CalleeSymbol) const {
   } else {
     // Absolute symbol.
     ErrorOr<uint64_t> CalleeAddressOrError = BC.getSymbolValue(*CalleeSymbol);
     assert(CalleeAddressOrError && "unregistered symbol found");
     return *CalleeAddressOrError > getAddress();
   }
 }
 
-void BinaryFunction::dump(bool PrintInstructions) const {
+void BinaryFunction::dump() const {
   // getDynoStats calls FunctionLayout::updateLayoutIndices and
   // BasicBlock::analyzeBranch. The former cannot be const, but should be
   // removed, the latter should be made const, but seems to require refactoring.
   // Forcing all callers to have a non-const reference to BinaryFunction to call
   // dump non-const however is not ideal either. Adding this const_cast is right
   // now the best solution. It is safe, because BinaryFunction itself is not
   // modified. Only BinaryBasicBlocks are actually modified (if it all) and we
   // have mutable pointers to those regardless whether this function is
   // const-qualified or not.
-  const_cast<BinaryFunction &>(*this).print(dbgs(), "", PrintInstructions);
+  const_cast<BinaryFunction &>(*this).print(dbgs(), "");
 }
 
-void BinaryFunction::print(raw_ostream &OS, std::string Annotation,
-                           bool PrintInstructions) {
+void BinaryFunction::print(raw_ostream &OS, std::string Annotation) {
   if (!opts::shouldPrint(*this))
     return;
 
   StringRef SectionName =
       OriginSection ? OriginSection->getName() : "<no origin section>";
   OS << "Binary Function \"" << *this << "\" " << Annotation << " {";
   std::vector<StringRef> AllNames = getNames();
   if (AllNames.size() > 1) {
void BinaryFunction::print(raw_ostream &OS, std::string Annotation) {
   if (opts::PrintDynoStats && !getLayout().block_empty()) {
     OS << '\n';
     DynoStats dynoStats = getDynoStats(*this);
     OS << dynoStats;
   }
 
   OS << "\n}\n";
 
-  if (opts::PrintDynoStatsOnly || !PrintInstructions || !BC.InstPrinter)
+  if (opts::PrintDynoStatsOnly || !BC.InstPrinter)
     return;
 
   // Offset of the instruction in function.
   uint64_t Offset = 0;
 
   if (BasicBlocks.empty() && !Instructions.empty()) {
     // Print before CFG was built.
     for (const std::pair<const uint32_t, MCInst> &II : Instructions) {

bolt/lib/Passes/MCF.cpp

 void estimateEdgeCounts(BinaryFunction &BF) {
   EdgeWeightMap PredEdgeWeights;
   EdgeWeightMap SuccEdgeWeights;
   if (!opts::IterativeGuess) {
     computeEdgeWeights<Inverse<BinaryBasicBlock *>>(BF, PredEdgeWeights);
     computeEdgeWeights<BinaryBasicBlock *>(BF, SuccEdgeWeights);
   }
   if (opts::EqualizeBBCounts) {
-    LLVM_DEBUG(BF.print(dbgs(), "before equalize BB counts", true));
+    LLVM_DEBUG(BF.print(dbgs(), "before equalize BB counts"));
     auto Info = DataflowInfoManager(BF, nullptr, nullptr);
     equalizeBBCounts(Info, BF);
-    LLVM_DEBUG(BF.print(dbgs(), "after equalize BB counts", true));
+    LLVM_DEBUG(BF.print(dbgs(), "after equalize BB counts"));
   }
   if (opts::IterativeGuess)
     guessEdgeByIterativeApproach(BF);
   else
     guessEdgeByRelHotness(BF, /*UseSuccs=*/false, PredEdgeWeights,
                           SuccEdgeWeights);
   recalculateBBCounts(BF, /*AllEdges=*/false);
 }
 
 void solveMCF(BinaryFunction &BF, MCFCostFunction CostFunction) {
   llvm_unreachable("not implemented");
 }
 
 } // namespace bolt
 } // namespace llvm

bolt/lib/Rewrite/BinaryPassManager.cpp

for (size_t PassIdx = 0; PassIdx < Passes.size(); PassIdx++) {
     const std::string Message = std::string("after ") + Pass->getName();
 
     for (auto &It : BFs) {
       BinaryFunction &Function = It.second;
 
       if (!Pass->shouldPrint(Function))
         continue;
 
-      Function.print(outs(), Message, true);
+      Function.print(outs(), Message);
 
       if (opts::DumpDotAll)
         Function.dumpGraphForPass(PassIdName);
     }
   }
 }
 
 void BinaryFunctionPassManager::runAllPasses(BinaryContext &BC) {

bolt/lib/Rewrite/MachORewriteInstance.cpp

 
 void MachORewriteInstance::disassembleFunctions() {
   for (auto &BFI : BC->getBinaryFunctions()) {
     BinaryFunction &Function = BFI.second;
     if (!Function.isSimple())
       continue;
     Function.disassemble();
     if (opts::PrintDisasm)
-      Function.print(outs(), "after disassembly", true);
+      Function.print(outs(), "after disassembly");
   }
 }
 
 void MachORewriteInstance::buildFunctionsCFG() {
   for (auto &BFI : BC->getBinaryFunctions()) {
     BinaryFunction &Function = BFI.second;
     if (!Function.isSimple())
       continue;
     if (!Function.buildCFG(/*AllocId*/ 0)) {
       errs() << "BOLT-WARNING: failed to build CFG for the function "
              << Function << "\n";
     }
   }
 }
 
 void MachORewriteInstance::postProcessFunctions() {
   for (auto &BFI : BC->getBinaryFunctions()) {
     BinaryFunction &Function = BFI.second;
     if (Function.empty())
       continue;
     Function.postProcessCFG();
     if (opts::PrintCFG)
-      Function.print(outs(), "after building cfg", true);
+      Function.print(outs(), "after building cfg");
   }
 }
 
 void MachORewriteInstance::runOptimizationPasses() {
   BinaryFunctionPassManager Manager(*BC);
   if (opts::Instrument) {
     Manager.registerPass(std::make_unique<PatchEntries>());
     Manager.registerPass(std::make_unique<Instrumentation>(opts::NeverPrint));

bolt/lib/Rewrite/RewriteInstance.cpp

if (!Function.disassemble()) {
         outs() << "BOLT-INFO: could not disassemble function " << Function
                << ". Will ignore.\n";
       // Forcefully ignore the function.
       Function.setIgnored();
       continue;
     }
 
     if (opts::PrintAll || opts::PrintDisasm)
-      Function.print(outs(), "after disassembly", true);
+      Function.print(outs(), "after disassembly");
   }
 
   BC->processInterproceduralReferences();
   BC->populateJumpTables();
 
   for (auto &BFI : BC->getBinaryFunctions()) {
     BinaryFunction &Function = BFI.second;
 
void RewriteInstance::buildFunctionsCFG() {
 
   ParallelUtilities::WorkFuncWithAllocTy WorkFun =
       [&](BinaryFunction &BF, MCPlusBuilder::AllocatorIdTy AllocId) {
         if (!BF.buildCFG(AllocId))
           return;
 
         if (opts::PrintAll) {
           auto L = BC->scopeLock();
-          BF.print(outs(), "while building cfg", true);
+          BF.print(outs(), "while building cfg");
         }
       };
 
   ParallelUtilities::PredicateTy SkipPredicate = [&](const BinaryFunction &BF) {
     return !shouldDisassemble(BF) || !BF.isSimple();
   };
 
   ParallelUtilities::runOnEachFunctionWithUniqueAllocId(
for (auto &BFI : BC->getBinaryFunctions()) {
     BinaryFunction &Function = BFI.second;
 
     if (Function.empty())
       continue;
 
     Function.postProcessCFG();
 
     if (opts::PrintAll || opts::PrintCFG)
-      Function.print(outs(), "after building cfg", true);
+      Function.print(outs(), "after building cfg");
 
     if (opts::DumpDotAll)
       Function.dumpGraphForPass("00_build-cfg");
 
     if (opts::PrintLoopInfo) {
       Function.calculateLoopInfo();
       Function.printLoopInfo(outs());
     }