[llvm-objdump][NFC] Add quiet disassembly

[necipfazil]

Summary

Add a boolean to control whether object disassembly (disassembleObject())
prints. It is always set to false, which makes this an NFC.

It will be set for the upcoming --call-graph-info option, which will utilize
disassembleObject() to collect function and call site addresses.

Patch 1/6: Extract call graph information from binary

Original RFC: https://lists.llvm.org/pipermail/llvm-dev/2021-June/151044.html
Updated RFC: https://lists.llvm.org/pipermail/llvm-dev/2021-July/151739.html

[morehouse]

llvm/tools/llvm-objdump/llvm-objdump.cpp

222

[necipfazil]

Fix nit

llvm/tools/llvm-objdump/llvm-objdump.cpp

 static bool SymbolizeOperands;
 static bool DynamicSymbolTable;
 std::string objdump::TripleName;
 bool objdump::UnwindInfo;
 static bool Wide;
 std::string objdump::Prefix;
 uint32_t objdump::PrefixStrip;
 
+static bool QuietDisasm;
+
 DebugVarsFormat objdump::DbgVariables = DVDisabled;
 
 int objdump::DbgIndent = 52;
 
 static StringSet<> DisasmSymbolSet;
 StringSet<> objdump::FoundSectionSet;
 static StringRef ToolName;
 
if (!Comments.empty()) {
       FOS << MAI.getCommentString() << ' ' << Comment;
     }
     LVP.printAfterInst(FOS);
     FOS << '\n';
   } while (!Comments.empty());
   FOS.flush();
 }
 
+static raw_ostream &disasmOuts() { return QuietDisasm ? nulls() : outs(); }
+
 static void disassembleObject(const Target *TheTarget, const ObjectFile *Obj,
                               MCContext &Ctx, MCDisassembler *PrimaryDisAsm,
                               MCDisassembler *SecondaryDisAsm,
                               const MCInstrAnalysis *MIA, MCInstPrinter *IP,
                               const MCSubtargetInfo *PrimarySTI,
                               const MCSubtargetInfo *SecondarySTI,
                               PrettyPrinter &PIP,
                               SourcePrinter &SP, bool InlineRelocs) {
for (unsigned SI = 0, SE = Symbols.size(); SI != SE; ++SI) {
         End = std::min(End, Symbols[SI + 1].Addr);
       if (Start >= End || End <= StartAddress)
         continue;
       Start -= SectionAddr;
       End -= SectionAddr;
 
       if (!PrintedSection) {
         PrintedSection = true;
-        outs() << "\nDisassembly of section ";
+        disasmOuts() << "\nDisassembly of section ";
         if (!SegmentName.empty())
-          outs() << SegmentName << ",";
-        outs() << SectionName << ":\n";
+          disasmOuts() << SegmentName << ",";
+        disasmOuts() << SectionName << ":\n";
       }
 
-      outs() << '\n';
+      disasmOuts() << '\n';
       if (LeadingAddr)
-        outs() << format(Is64Bits ? "%016" PRIx64 " " : "%08" PRIx64 " ",
+        disasmOuts() << format(Is64Bits ? "%016" PRIx64 " " : "%08" PRIx64 " ",
                                SectionAddr + Start + VMAAdjustment);
       if (Obj->isXCOFF() && SymbolDescription) {
-        outs() << getXCOFFSymbolDescription(Symbols[SI], SymbolName) << ":\n";
+        disasmOuts() << getXCOFFSymbolDescription(Symbols[SI], SymbolName)
+                     << ":\n";
       } else
-        outs() << '<' << SymbolName << ">:\n";
+        disasmOuts() << '<' << SymbolName << ">:\n";
 
       // Don't print raw contents of a virtual section. A virtual section
       // doesn't have any contents in the file.
       if (Section.isVirtual()) {
-        outs() << "...\n";
+        disasmOuts() << "...\n";
         continue;
       }
 
       auto Status = DisAsm->onSymbolStart(Symbols[SI], Size,
                                           Bytes.slice(Start, End - Start),
                                           SectionAddr + Start, CommentStream);
       // To have round trippable disassembly, we fall back to decoding the
       // remaining bytes as instructions.
       //
       // If there is a failure, we disassemble the failed region as bytes before
       // falling back. The target is expected to print nothing in this case.
       //
       // If there is Success or SoftFail i.e no 'real' failure, we go ahead by
       // Size bytes before falling back.
       // So if the entire symbol is 'eaten' by the target:
       //   Start += Size  // Now Start = End and we will never decode as
       //                  // instructions
       //
       // Right now, most targets return None i.e ignore to treat a symbol
       // separately. But WebAssembly decodes preludes for some symbols.
       //
       if (Status.hasValue()) {
         if (Status.getValue() == MCDisassembler::Fail) {
-          outs() << "// Error in decoding " << SymbolName
+          disasmOuts() << "// Error in decoding " << SymbolName
                        << " : Decoding failed region as bytes.\n";
           for (uint64_t I = 0; I < Size; ++I) {
-            outs() << "\t.byte\t " << format_hex(Bytes[I], 1, /*Upper=*/true)
-                   << "\n";
+            disasmOuts() << "\t.byte\t "
+                         << format_hex(Bytes[I], 1, /*Upper=*/true) << "\n";
           }
         }
       } else {
         Size = 0;
       }
 
       Start += Size;
 
for (unsigned SI = 0, SE = Symbols.size(); SI != SE; ++SI) {
           Index = End;
         }
       }
 
       bool CheckARMELFData = hasMappingSymbols(Obj) &&
                              Symbols[SI].Type != ELF::STT_OBJECT &&
                              !DisassembleAll;
       bool DumpARMELFData = false;
-      formatted_raw_ostream FOS(outs());
+      formatted_raw_ostream FOS(disasmOuts());
 
       std::unordered_map<uint64_t, std::string> AllLabels;
       if (SymbolizeOperands)
         collectLocalBranchTargets(Bytes, MIA, DisAsm, IP, PrimarySTI,
                                   SectionAddr, Index, End, AllLabels);
 
       while (Index < End) {
         // ARM and AArch64 ELF binaries can interleave data and text in the
for (StringRef V : Values) {
         DisassemblerOptions.push_back(V.str());
     }
   }
   if (AsmSyntax) {
     const char *Argv[] = {"llvm-objdump", AsmSyntax};
     llvm::cl::ParseCommandLineOptions(2, Argv);
   }
 
+  QuietDisasm = false;
+
   // objdump defaults to a.out if no filenames specified.
   if (InputFilenames.empty())
     InputFilenames.push_back("a.out");
 }
 
 int main(int argc, char **argv) {
   using namespace llvm;
   InitLLVM X(argc, argv);