/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/llvm/tools/llvm-objdump/llvm-objdump.cpp

Bug Summary

File:	build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/llvm/tools/llvm-objdump/llvm-objdump.cpp
Warning:	line 2066, column 33 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name llvm-objdump.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/build-llvm -resource-dir /usr/lib/llvm-15/lib/clang/15.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I tools/llvm-objdump -I /build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/llvm/tools/llvm-objdump -I include -I /build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/llvm/include -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-15/lib/clang/15.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/build-llvm=build-llvm -fmacro-prefix-map=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/= -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/build-llvm=build-llvm -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/= -O3 -Wno-unused-command-line-argument -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/build-llvm -fdebug-prefix-map=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/build-llvm=build-llvm -fdebug-prefix-map=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/= -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-04-20-140412-16051-1 -x c++ /build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/llvm/tools/llvm-objdump/llvm-objdump.cpp

1//===-- llvm-objdump.cpp - Object file dumping utility for llvm -----------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This program is a utility that works like binutils "objdump", that is, it
10// dumps out a plethora of information about an object file depending on the
11// flags.
12//
13// The flags and output of this program should be near identical to those of
14// binutils objdump.
15//
16//===----------------------------------------------------------------------===//

18#include "llvm-objdump.h"
19#include "COFFDump.h"
20#include "ELFDump.h"
21#include "MachODump.h"
22#include "ObjdumpOptID.h"
23#include "SourcePrinter.h"
24#include "WasmDump.h"
25#include "XCOFFDump.h"
26#include "llvm/ADT/IndexedMap.h"
27#include "llvm/ADT/Optional.h"
28#include "llvm/ADT/STLExtras.h"
29#include "llvm/ADT/SetOperations.h"
30#include "llvm/ADT/SmallSet.h"
31#include "llvm/ADT/StringExtras.h"
32#include "llvm/ADT/StringSet.h"
33#include "llvm/ADT/Triple.h"
34#include "llvm/ADT/Twine.h"
35#include "llvm/DebugInfo/DWARF/DWARFContext.h"
36#include "llvm/DebugInfo/Symbolize/SymbolizableModule.h"
37#include "llvm/DebugInfo/Symbolize/Symbolize.h"
38#include "llvm/Demangle/Demangle.h"
39#include "llvm/MC/MCAsmInfo.h"
40#include "llvm/MC/MCContext.h"
41#include "llvm/MC/MCDisassembler/MCDisassembler.h"
42#include "llvm/MC/MCDisassembler/MCRelocationInfo.h"
43#include "llvm/MC/MCInst.h"
44#include "llvm/MC/MCInstPrinter.h"
45#include "llvm/MC/MCInstrAnalysis.h"
46#include "llvm/MC/MCInstrInfo.h"
47#include "llvm/MC/MCObjectFileInfo.h"
48#include "llvm/MC/MCRegisterInfo.h"
49#include "llvm/MC/MCSubtargetInfo.h"
50#include "llvm/MC/MCTargetOptions.h"
51#include "llvm/MC/TargetRegistry.h"
52#include "llvm/Object/Archive.h"
53#include "llvm/Object/COFF.h"
54#include "llvm/Object/COFFImportFile.h"
55#include "llvm/Object/ELFObjectFile.h"
56#include "llvm/Object/FaultMapParser.h"
57#include "llvm/Object/MachO.h"
58#include "llvm/Object/MachOUniversal.h"
59#include "llvm/Object/ObjectFile.h"
60#include "llvm/Object/Wasm.h"
61#include "llvm/Option/Arg.h"
62#include "llvm/Option/ArgList.h"
63#include "llvm/Option/Option.h"
64#include "llvm/Support/Casting.h"
65#include "llvm/Support/Debug.h"
66#include "llvm/Support/Errc.h"
67#include "llvm/Support/FileSystem.h"
68#include "llvm/Support/Format.h"
69#include "llvm/Support/FormatVariadic.h"
70#include "llvm/Support/GraphWriter.h"
71#include "llvm/Support/Host.h"
72#include "llvm/Support/InitLLVM.h"
73#include "llvm/Support/MemoryBuffer.h"
74#include "llvm/Support/SourceMgr.h"
75#include "llvm/Support/StringSaver.h"
76#include "llvm/Support/TargetSelect.h"
77#include "llvm/Support/WithColor.h"
78#include "llvm/Support/raw_ostream.h"
79#include <algorithm>
80#include <cctype>
81#include <cstring>
82#include <system_error>
83#include <unordered_map>
84#include <utility>

86using namespace llvm;
87using namespace llvm::object;
88using namespace llvm::objdump;
89using namespace llvm::opt;

91namespace {

93class CommonOptTable : public opt::OptTable {
94public:
CommonOptTable(ArrayRef<Info> OptionInfos, const char *Usage,
               const char *Description)
    : OptTable(OptionInfos), Usage(Usage), Description(Description) {
  setGroupedShortOptions(true);
}

void printHelp(StringRef Argv0, bool ShowHidden = false) const {
  Argv0 = sys::path::filename(Argv0);
  opt::OptTable::printHelp(outs(), (Argv0 + Usage).str().c_str(), Description,
                           ShowHidden, ShowHidden);
  // TODO Replace this with OptTable API once it adds extrahelp support.
  outs() << "\nPass @FILE as argument to read options from FILE.\n";
}

109private:
const char *Usage;
const char *Description;
112};

114// ObjdumpOptID is in ObjdumpOptID.h

116#define PREFIX(NAME, VALUE) const char *const OBJDUMP_##NAME[] = VALUE;
117#include "ObjdumpOpts.inc"
118#undef PREFIX

120static constexpr opt::OptTable::Info ObjdumpInfoTable[] = {
121#define OBJDUMP_nullptr nullptr
122#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
             HELPTEXT, METAVAR, VALUES)                                      \
{OBJDUMP_##PREFIX, NAME,         HELPTEXT,                                   \
 METAVAR,          OBJDUMP_##ID, opt::Option::KIND##Class,                   \
 PARAM,            FLAGS,        OBJDUMP_##GROUP,                            \
 OBJDUMP_##ALIAS,  ALIASARGS,    VALUES},
128#include "ObjdumpOpts.inc"
129#undef OPTION
130#undef OBJDUMP_nullptr
131};

133class ObjdumpOptTable : public CommonOptTable {
134public:
ObjdumpOptTable()
    : CommonOptTable(ObjdumpInfoTable, " [options] <input object files>",
                     "llvm object file dumper") {}
138};

140enum OtoolOptID {
OTOOL_INVALID = 0, // This is not an option ID.
142#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
             HELPTEXT, METAVAR, VALUES)                                      \
OTOOL_##ID,
145#include "OtoolOpts.inc"
146#undef OPTION
147};

149#define PREFIX(NAME, VALUE) const char *const OTOOL_##NAME[] = VALUE;
150#include "OtoolOpts.inc"
151#undef PREFIX

153static constexpr opt::OptTable::Info OtoolInfoTable[] = {
154#define OTOOL_nullptr nullptr
155#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
             HELPTEXT, METAVAR, VALUES)                                      \
{OTOOL_##PREFIX, NAME,       HELPTEXT,                                       \
 METAVAR,        OTOOL_##ID, opt::Option::KIND##Class,                       \
 PARAM,          FLAGS,      OTOOL_##GROUP,                                  \
 OTOOL_##ALIAS,  ALIASARGS,  VALUES},
161#include "OtoolOpts.inc"
162#undef OPTION
163#undef OTOOL_nullptr
164};

166class OtoolOptTable : public CommonOptTable {
167public:
OtoolOptTable()
    : CommonOptTable(OtoolInfoTable, " [option...] [file...]",
                     "Mach-O object file displaying tool") {}
171};

173} // namespace

175#define DEBUG_TYPE"objdump" "objdump"

177static uint64_t AdjustVMA;
178static bool AllHeaders;
179static std::string ArchName;
180bool objdump::ArchiveHeaders;
181bool objdump::Demangle;
182bool objdump::Disassemble;
183bool objdump::DisassembleAll;
184bool objdump::SymbolDescription;
185static std::vector<std::string> DisassembleSymbols;
186static bool DisassembleZeroes;
187static std::vector<std::string> DisassemblerOptions;
188DIDumpType objdump::DwarfDumpType;
189static bool DynamicRelocations;
190static bool FaultMapSection;
191static bool FileHeaders;
192bool objdump::SectionContents;
193static std::vector<std::string> InputFilenames;
194bool objdump::PrintLines;
195static bool MachOOpt;
196std::string objdump::MCPU;
197std::vector<std::string> objdump::MAttrs;
198bool objdump::ShowRawInsn;
199bool objdump::LeadingAddr;
200static bool RawClangAST;
201bool objdump::Relocations;
202bool objdump::PrintImmHex;
203bool objdump::PrivateHeaders;
204std::vector<std::string> objdump::FilterSections;
205bool objdump::SectionHeaders;
206static bool ShowLMA;
207bool objdump::PrintSource;

209static uint64_t StartAddress;
210static bool HasStartAddressFlag;
211static uint64_t StopAddress = UINT64_MAX(18446744073709551615UL);
212static bool HasStopAddressFlag;

214bool objdump::SymbolTable;
215static bool SymbolizeOperands;
216static bool DynamicSymbolTable;
217std::string objdump::TripleName;
218bool objdump::UnwindInfo;
219static bool Wide;
220std::string objdump::Prefix;
221uint32_t objdump::PrefixStrip;

223DebugVarsFormat objdump::DbgVariables = DVDisabled;

225int objdump::DbgIndent = 52;

227static StringSet<> DisasmSymbolSet;
228StringSet<> objdump::FoundSectionSet;
229static StringRef ToolName;

231namespace {
232struct FilterResult {
// True if the section should not be skipped.
bool Keep;

// True if the index counter should be incremented, even if the section should
// be skipped. For example, sections may be skipped if they are not included
// in the --section flag, but we still want those to count toward the section
// count.
bool IncrementIndex;
241};
242} // namespace

244static FilterResult checkSectionFilter(object::SectionRef S) {
if (FilterSections.empty())
  return {/*Keep=*/true, /*IncrementIndex=*/true};

Expected<StringRef> SecNameOrErr = S.getName();
if (!SecNameOrErr) {
  consumeError(SecNameOrErr.takeError());
  return {/*Keep=*/false, /*IncrementIndex=*/false};
}
StringRef SecName = *SecNameOrErr;

// StringSet does not allow empty key so avoid adding sections with
// no name (such as the section with index 0) here.
if (!SecName.empty())
  FoundSectionSet.insert(SecName);

// Only show the section if it's in the FilterSections list, but always
// increment so the indexing is stable.
return {/*Keep=*/is_contained(FilterSections, SecName),
        /*IncrementIndex=*/true};
264}

266SectionFilter objdump::ToolSectionFilter(object::ObjectFile const &O,
                                       uint64_t *Idx) {
// Start at UINT64_MAX so that the first index returned after an increment is
// zero (after the unsigned wrap).
if (Idx)
  *Idx = UINT64_MAX(18446744073709551615UL);
return SectionFilter(
    [Idx](object::SectionRef S) {
      FilterResult Result = checkSectionFilter(S);
      if (Idx != nullptr && Result.IncrementIndex)
        *Idx += 1;
      return Result.Keep;
    },
    O);
280}

282std::string objdump::getFileNameForError(const object::Archive::Child &C,
                                       unsigned Index) {
Expected<StringRef> NameOrErr = C.getName();
if (NameOrErr)
  return std::string(NameOrErr.get());
// If we have an error getting the name then we print the index of the archive
// member. Since we are already in an error state, we just ignore this error.
consumeError(NameOrErr.takeError());
return "<file index: " + std::to_string(Index) + ">";
291}

293void objdump::reportWarning(const Twine &Message, StringRef File) {
// Output order between errs() and outs() matters especially for archive
// files where the output is per member object.
outs().flush();
WithColor::warning(errs(), ToolName)
    << "'" << File << "': " << Message << "\n";
299}

301[[noreturn]] void objdump::reportError(StringRef File, const Twine &Message) {
outs().flush();
WithColor::error(errs(), ToolName) << "'" << File << "': " << Message << "\n";
exit(1);
305}

307[[noreturn]] void objdump::reportError(Error E, StringRef FileName,
                                     StringRef ArchiveName,
                                     StringRef ArchitectureName) {
assert(E)(static_cast <bool> (E) ? void (0) : __assert_fail ("E"
, "llvm/tools/llvm-objdump/llvm-objdump.cpp", 310, __extension__
 __PRETTY_FUNCTION__));
outs().flush();
WithColor::error(errs(), ToolName);
if (ArchiveName != "")
  errs() << ArchiveName << "(" << FileName << ")";
else
  errs() << "'" << FileName << "'";
if (!ArchitectureName.empty())
  errs() << " (for architecture " << ArchitectureName << ")";
errs() << ": ";
logAllUnhandledErrors(std::move(E), errs());
exit(1);
322}

324static void reportCmdLineWarning(const Twine &Message) {
WithColor::warning(errs(), ToolName) << Message << "\n";
326}

328[[noreturn]] static void reportCmdLineError(const Twine &Message) {
WithColor::error(errs(), ToolName) << Message << "\n";
exit(1);
331}

333static void warnOnNoMatchForSections() {
SetVector<StringRef> MissingSections;
for (StringRef S : FilterSections) {
  if (FoundSectionSet.count(S))
    return;
  // User may specify a unnamed section. Don't warn for it.
  if (!S.empty())
    MissingSections.insert(S);
}

// Warn only if no section in FilterSections is matched.
for (StringRef S : MissingSections)
  reportCmdLineWarning("section '" + S +
                       "' mentioned in a -j/--section option, but not "
                       "found in any input file");
348}

350static const Target *getTarget(const ObjectFile *Obj) {
// Figure out the target triple.
Triple TheTriple("unknown-unknown-unknown");
if (TripleName.empty()) {
  TheTriple = Obj->makeTriple();
} else {
  TheTriple.setTriple(Triple::normalize(TripleName));
  auto Arch = Obj->getArch();
  if (Arch == Triple::arm || Arch == Triple::armeb)
    Obj->setARMSubArch(TheTriple);
}

// Get the target specific parser.
std::string Error;
const Target *TheTarget = TargetRegistry::lookupTarget(ArchName, TheTriple,
                                                       Error);
if (!TheTarget)
  reportError(Obj->getFileName(), "can't find target: " + Error);

// Update the triple name and return the found target.
TripleName = TheTriple.getTriple();
return TheTarget;
372}

374bool objdump::isRelocAddressLess(RelocationRef A, RelocationRef B) {
return A.getOffset() < B.getOffset();
376}

378static Error getRelocationValueString(const RelocationRef &Rel,
                                    SmallVectorImpl<char> &Result) {
const ObjectFile *Obj = Rel.getObject();
if (auto *ELF = dyn_cast<ELFObjectFileBase>(Obj))
  return getELFRelocationValueString(ELF, Rel, Result);
if (auto *COFF = dyn_cast<COFFObjectFile>(Obj))
  return getCOFFRelocationValueString(COFF, Rel, Result);
if (auto *Wasm = dyn_cast<WasmObjectFile>(Obj))
  return getWasmRelocationValueString(Wasm, Rel, Result);
if (auto *MachO = dyn_cast<MachOObjectFile>(Obj))
  return getMachORelocationValueString(MachO, Rel, Result);
if (auto *XCOFF = dyn_cast<XCOFFObjectFile>(Obj))
  return getXCOFFRelocationValueString(XCOFF, Rel, Result);
llvm_unreachable("unknown object file format")::llvm::llvm_unreachable_internal("unknown object file format"
, "llvm/tools/llvm-objdump/llvm-objdump.cpp", 391);
392}

394/// Indicates whether this relocation should hidden when listing
395/// relocations, usually because it is the trailing part of a multipart
396/// relocation that will be printed as part of the leading relocation.
397static bool getHidden(RelocationRef RelRef) {
auto *MachO = dyn_cast<MachOObjectFile>(RelRef.getObject());
if (!MachO)
  return false;

unsigned Arch = MachO->getArch();
DataRefImpl Rel = RelRef.getRawDataRefImpl();
uint64_t Type = MachO->getRelocationType(Rel);

// On arches that use the generic relocations, GENERIC_RELOC_PAIR
// is always hidden.
if (Arch == Triple::x86 || Arch == Triple::arm || Arch == Triple::ppc)
  return Type == MachO::GENERIC_RELOC_PAIR;

if (Arch == Triple::x86_64) {
  // On x86_64, X86_64_RELOC_UNSIGNED is hidden only when it follows
  // an X86_64_RELOC_SUBTRACTOR.
  if (Type == MachO::X86_64_RELOC_UNSIGNED && Rel.d.a > 0) {
    DataRefImpl RelPrev = Rel;
    RelPrev.d.a--;
    uint64_t PrevType = MachO->getRelocationType(RelPrev);
    if (PrevType == MachO::X86_64_RELOC_SUBTRACTOR)
      return true;
  }
}

return false;
424}

426namespace {

428/// Get the column at which we want to start printing the instruction
429/// disassembly, taking into account anything which appears to the left of it.
430unsigned getInstStartColumn(const MCSubtargetInfo &STI) {
return !ShowRawInsn ? 16 : STI.getTargetTriple().isX86() ? 40 : 24;
432}

434static bool isAArch64Elf(const ObjectFile *Obj) {
const auto *Elf = dyn_cast<ELFObjectFileBase>(Obj);
return Elf && Elf->getEMachine() == ELF::EM_AARCH64;
437}

439static bool isArmElf(const ObjectFile *Obj) {
const auto *Elf = dyn_cast<ELFObjectFileBase>(Obj);
return Elf && Elf->getEMachine() == ELF::EM_ARM;
442}

444static bool isCSKYElf(const ObjectFile *Obj) {
const auto *Elf = dyn_cast<ELFObjectFileBase>(Obj);
return Elf && Elf->getEMachine() == ELF::EM_CSKY;
447}

449static bool hasMappingSymbols(const ObjectFile *Obj) {
return isArmElf(Obj) || isAArch64Elf(Obj) || isCSKYElf(Obj) ;
451}

453static void printRelocation(formatted_raw_ostream &OS, StringRef FileName,
                          const RelocationRef &Rel, uint64_t Address,
                          bool Is64Bits) {
StringRef Fmt = Is64Bits ? "\t\t%016" PRIx64"l" "x" ":  " : "\t\t\t%08" PRIx64"l" "x" ":  ";
SmallString<16> Name;
SmallString<32> Val;
Rel.getTypeName(Name);
if (Error E = getRelocationValueString(Rel, Val))
  reportError(std::move(E), FileName);
OS << format(Fmt.data(), Address) << Name << "\t" << Val;
463}

465class PrettyPrinter {
466public:
virtual ~PrettyPrinter() = default;
virtual void
printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef<uint8_t> Bytes,
          object::SectionedAddress Address, formatted_raw_ostream &OS,
          StringRef Annot, MCSubtargetInfo const &STI, SourcePrinter *SP,
          StringRef ObjectFilename, std::vector<RelocationRef> *Rels,
          LiveVariablePrinter &LVP) {
  if (SP && (PrintSource || PrintLines))
    SP->printSourceLine(OS, Address, ObjectFilename, LVP);
  LVP.printBetweenInsts(OS, false);

  size_t Start = OS.tell();
  if (LeadingAddr)
    OS << format("%8" PRIx64"l" "x" ":", Address.Address);
  if (ShowRawInsn) {
    OS << ' ';
    dumpBytes(Bytes, OS);
  }

  // The output of printInst starts with a tab. Print some spaces so that
  // the tab has 1 column and advances to the target tab stop.
  unsigned TabStop = getInstStartColumn(STI);
  unsigned Column = OS.tell() - Start;
  OS.indent(Column < TabStop - 1 ? TabStop - 1 - Column : 7 - Column % 8);

  if (MI) {
    // See MCInstPrinter::printInst. On targets where a PC relative immediate
    // is relative to the next instruction and the length of a MCInst is
    // difficult to measure (x86), this is the address of the next
    // instruction.
    uint64_t Addr =
        Address.Address + (STI.getTargetTriple().isX86() ? Bytes.size() : 0);
    IP.printInst(MI, Addr, "", STI, OS);
  } else
    OS << "\t<unknown>";
}
503};
504PrettyPrinter PrettyPrinterInst;

506class HexagonPrettyPrinter : public PrettyPrinter {
507public:
void printLead(ArrayRef<uint8_t> Bytes, uint64_t Address,
               formatted_raw_ostream &OS) {
  uint32_t opcode =
    (Bytes[3] << 24) | (Bytes[2] << 16) | (Bytes[1] << 8) | Bytes[0];
  if (LeadingAddr)
    OS << format("%8" PRIx64"l" "x" ":", Address);
  if (ShowRawInsn) {
    OS << "\t";
    dumpBytes(Bytes.slice(0, 4), OS);
    OS << format("\t%08" PRIx32"x", opcode);
  }
}
void printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef<uint8_t> Bytes,
               object::SectionedAddress Address, formatted_raw_ostream &OS,
               StringRef Annot, MCSubtargetInfo const &STI, SourcePrinter *SP,
               StringRef ObjectFilename, std::vector<RelocationRef> *Rels,
               LiveVariablePrinter &LVP) override {
  if (SP && (PrintSource || PrintLines))
    SP->printSourceLine(OS, Address, ObjectFilename, LVP, "");
  if (!MI) {
    printLead(Bytes, Address.Address, OS);
    OS << " <unknown>";
    return;
  }
  std::string Buffer;
  {
    raw_string_ostream TempStream(Buffer);
    IP.printInst(MI, Address.Address, "", STI, TempStream);
  }
  StringRef Contents(Buffer);
  // Split off bundle attributes
  auto PacketBundle = Contents.rsplit('\n');
  // Split off first instruction from the rest
  auto HeadTail = PacketBundle.first.split('\n');
  auto Preamble = " { ";
  auto Separator = "";

  // Hexagon's packets require relocations to be inline rather than
  // clustered at the end of the packet.
  std::vector<RelocationRef>::const_iterator RelCur = Rels->begin();
  std::vector<RelocationRef>::const_iterator RelEnd = Rels->end();
  auto PrintReloc = [&]() -> void {
    while ((RelCur != RelEnd) && (RelCur->getOffset() <= Address.Address)) {
      if (RelCur->getOffset() == Address.Address) {
        printRelocation(OS, ObjectFilename, *RelCur, Address.Address, false);
        return;
      }
      ++RelCur;
    }
  };

  while (!HeadTail.first.empty()) {
    OS << Separator;
    Separator = "\n";
    if (SP && (PrintSource || PrintLines))
      SP->printSourceLine(OS, Address, ObjectFilename, LVP, "");
    printLead(Bytes, Address.Address, OS);
    OS << Preamble;
    Preamble = "   ";
    StringRef Inst;
    auto Duplex = HeadTail.first.split('\v');
    if (!Duplex.second.empty()) {
      OS << Duplex.first;
      OS << "; ";
      Inst = Duplex.second;
    }
    else
      Inst = HeadTail.first;
    OS << Inst;
    HeadTail = HeadTail.second.split('\n');
    if (HeadTail.first.empty())
      OS << " } " << PacketBundle.second;
    PrintReloc();
    Bytes = Bytes.slice(4);
    Address.Address += 4;
  }
}
585};
586HexagonPrettyPrinter HexagonPrettyPrinterInst;

588class AMDGCNPrettyPrinter : public PrettyPrinter {
589public:
void printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef<uint8_t> Bytes,
               object::SectionedAddress Address, formatted_raw_ostream &OS,
               StringRef Annot, MCSubtargetInfo const &STI, SourcePrinter *SP,
               StringRef ObjectFilename, std::vector<RelocationRef> *Rels,
               LiveVariablePrinter &LVP) override {
  if (SP && (PrintSource || PrintLines))
    SP->printSourceLine(OS, Address, ObjectFilename, LVP);

  if (MI) {
    SmallString<40> InstStr;
    raw_svector_ostream IS(InstStr);

    IP.printInst(MI, Address.Address, "", STI, IS);

    OS << left_justify(IS.str(), 60);
  } else {
    // an unrecognized encoding - this is probably data so represent it
    // using the .long directive, or .byte directive if fewer than 4 bytes
    // remaining
    if (Bytes.size() >= 4) {
      OS << format("\t.long 0x%08" PRIx32"x" " ",
                   support::endian::read32<support::little>(Bytes.data()));
      OS.indent(42);
    } else {
        OS << format("\t.byte 0x%02" PRIx8"x", Bytes[0]);
        for (unsigned int i = 1; i < Bytes.size(); i++)
          OS << format(", 0x%02" PRIx8"x", Bytes[i]);
        OS.indent(55 - (6 * Bytes.size()));
    }
  }

  OS << format("// %012" PRIX64"l" "X" ":", Address.Address);
  if (Bytes.size() >= 4) {
    // D should be casted to uint32_t here as it is passed by format to
    // snprintf as vararg.
    for (uint32_t D : makeArrayRef(
             reinterpret_cast<const support::little32_t *>(Bytes.data()),
             Bytes.size() / 4))
      OS << format(" %08" PRIX32"X", D);
  } else {
    for (unsigned char B : Bytes)
      OS << format(" %02" PRIX8"X", B);
  }

  if (!Annot.empty())
    OS << " // " << Annot;
}
637};
638AMDGCNPrettyPrinter AMDGCNPrettyPrinterInst;

640class BPFPrettyPrinter : public PrettyPrinter {
641public:
void printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef<uint8_t> Bytes,
               object::SectionedAddress Address, formatted_raw_ostream &OS,
               StringRef Annot, MCSubtargetInfo const &STI, SourcePrinter *SP,
               StringRef ObjectFilename, std::vector<RelocationRef> *Rels,
               LiveVariablePrinter &LVP) override {
  if (SP && (PrintSource || PrintLines))
    SP->printSourceLine(OS, Address, ObjectFilename, LVP);
  if (LeadingAddr)
    OS << format("%8" PRId64"l" "d" ":", Address.Address / 8);
  if (ShowRawInsn) {
    OS << "\t";
    dumpBytes(Bytes, OS);
  }
  if (MI)
    IP.printInst(MI, Address.Address, "", STI, OS);
  else
    OS << "\t<unknown>";
}
660};
661BPFPrettyPrinter BPFPrettyPrinterInst;

663PrettyPrinter &selectPrettyPrinter(Triple const &Triple) {
switch(Triple.getArch()) {
default:
  return PrettyPrinterInst;
case Triple::hexagon:
  return HexagonPrettyPrinterInst;
case Triple::amdgcn:
  return AMDGCNPrettyPrinterInst;
case Triple::bpfel:
case Triple::bpfeb:
  return BPFPrettyPrinterInst;
}
675}
676}

678static uint8_t getElfSymbolType(const ObjectFile *Obj, const SymbolRef &Sym) {
assert(Obj->isELF())(static_cast <bool> (Obj->isELF()) ? void (0) : __assert_fail
 ("Obj->isELF()", "llvm/tools/llvm-objdump/llvm-objdump.cpp"
, 679, __extension__ __PRETTY_FUNCTION__));
if (auto *Elf32LEObj = dyn_cast<ELF32LEObjectFile>(Obj))
  return unwrapOrError(Elf32LEObj->getSymbol(Sym.getRawDataRefImpl()),
                       Obj->getFileName())
      ->getType();
if (auto *Elf64LEObj = dyn_cast<ELF64LEObjectFile>(Obj))
  return unwrapOrError(Elf64LEObj->getSymbol(Sym.getRawDataRefImpl()),
                       Obj->getFileName())
      ->getType();
if (auto *Elf32BEObj = dyn_cast<ELF32BEObjectFile>(Obj))
  return unwrapOrError(Elf32BEObj->getSymbol(Sym.getRawDataRefImpl()),
                       Obj->getFileName())
      ->getType();
if (auto *Elf64BEObj = cast<ELF64BEObjectFile>(Obj))
  return unwrapOrError(Elf64BEObj->getSymbol(Sym.getRawDataRefImpl()),
                       Obj->getFileName())
      ->getType();
llvm_unreachable("Unsupported binary format")::llvm::llvm_unreachable_internal("Unsupported binary format"
, "llvm/tools/llvm-objdump/llvm-objdump.cpp", 696);
697}

699template <class ELFT> static void
700addDynamicElfSymbols(const ELFObjectFile<ELFT> *Obj,
                   std::map<SectionRef, SectionSymbolsTy> &AllSymbols) {
for (auto Symbol : Obj->getDynamicSymbolIterators()) {
  uint8_t SymbolType = Symbol.getELFType();
  if (SymbolType == ELF::STT_SECTION)
    continue;

  uint64_t Address = unwrapOrError(Symbol.getAddress(), Obj->getFileName());
  // ELFSymbolRef::getAddress() returns size instead of value for common
  // symbols which is not desirable for disassembly output. Overriding.
  if (SymbolType == ELF::STT_COMMON)
    Address = unwrapOrError(Obj->getSymbol(Symbol.getRawDataRefImpl()),
                            Obj->getFileName())
                  ->st_value;

  StringRef Name = unwrapOrError(Symbol.getName(), Obj->getFileName());
  if (Name.empty())
    continue;

  section_iterator SecI =
      unwrapOrError(Symbol.getSection(), Obj->getFileName());
  if (SecI == Obj->section_end())
    continue;

  AllSymbols[*SecI].emplace_back(Address, Name, SymbolType);
}
726}

728static void
729addDynamicElfSymbols(const ObjectFile *Obj,
                   std::map<SectionRef, SectionSymbolsTy> &AllSymbols) {
assert(Obj->isELF())(static_cast <bool> (Obj->isELF()) ? void (0) : __assert_fail
 ("Obj->isELF()", "llvm/tools/llvm-objdump/llvm-objdump.cpp"
, 731, __extension__ __PRETTY_FUNCTION__));
if (auto *Elf32LEObj = dyn_cast<ELF32LEObjectFile>(Obj))
  addDynamicElfSymbols(Elf32LEObj, AllSymbols);
else if (auto *Elf64LEObj = dyn_cast<ELF64LEObjectFile>(Obj))
  addDynamicElfSymbols(Elf64LEObj, AllSymbols);
else if (auto *Elf32BEObj = dyn_cast<ELF32BEObjectFile>(Obj))
  addDynamicElfSymbols(Elf32BEObj, AllSymbols);
else if (auto *Elf64BEObj = cast<ELF64BEObjectFile>(Obj))
  addDynamicElfSymbols(Elf64BEObj, AllSymbols);
else
  llvm_unreachable("Unsupported binary format")::llvm::llvm_unreachable_internal("Unsupported binary format"
, "llvm/tools/llvm-objdump/llvm-objdump.cpp", 741);
742}

744static Optional<SectionRef> getWasmCodeSection(const WasmObjectFile *Obj) {
for (auto SecI : Obj->sections()) {
  const WasmSection &Section = Obj->getWasmSection(SecI);
  if (Section.Type == wasm::WASM_SEC_CODE)
    return SecI;
}
return None;
751}

753static void
754addMissingWasmCodeSymbols(const WasmObjectFile *Obj,
                        std::map<SectionRef, SectionSymbolsTy> &AllSymbols) {
Optional<SectionRef> Section = getWasmCodeSection(Obj);
if (!Section)
  return;
SectionSymbolsTy &Symbols = AllSymbols[*Section];

std::set<uint64_t> SymbolAddresses;
for (const auto &Sym : Symbols)
  SymbolAddresses.insert(Sym.Addr);

for (const wasm::WasmFunction &Function : Obj->functions()) {
  uint64_t Address = Function.CodeSectionOffset;
  // Only add fallback symbols for functions not already present in the symbol
  // table.
  if (SymbolAddresses.count(Address))
    continue;
  // This function has no symbol, so it should have no SymbolName.
  assert(Function.SymbolName.empty())(static_cast <bool> (Function.SymbolName.empty()) ? void
 (0) : __assert_fail ("Function.SymbolName.empty()", "llvm/tools/llvm-objdump/llvm-objdump.cpp"
, 772, __extension__ __PRETTY_FUNCTION__));
  // We use DebugName for the name, though it may be empty if there is no
  // "name" custom section, or that section is missing a name for this
  // function.
  StringRef Name = Function.DebugName;
  Symbols.emplace_back(Address, Name, ELF::STT_NOTYPE);
}
779}

781static void addPltEntries(const ObjectFile *Obj,
                        std::map<SectionRef, SectionSymbolsTy> &AllSymbols,
                        StringSaver &Saver) {
Optional<SectionRef> Plt = None;
for (const SectionRef &Section : Obj->sections()) {
  Expected<StringRef> SecNameOrErr = Section.getName();
  if (!SecNameOrErr) {
    consumeError(SecNameOrErr.takeError());
    continue;
  }
  if (*SecNameOrErr == ".plt")
    Plt = Section;
}
if (!Plt)
  return;
if (auto *ElfObj = dyn_cast<ELFObjectFileBase>(Obj)) {
  for (auto PltEntry : ElfObj->getPltAddresses()) {
    if (PltEntry.first) {
      SymbolRef Symbol(*PltEntry.first, ElfObj);
      uint8_t SymbolType = getElfSymbolType(Obj, Symbol);
      if (Expected<StringRef> NameOrErr = Symbol.getName()) {
        if (!NameOrErr->empty())
          AllSymbols[*Plt].emplace_back(
              PltEntry.second, Saver.save((*NameOrErr + "@plt").str()),
              SymbolType);
        continue;
      } else {
        // The warning has been reported in disassembleObject().
        consumeError(NameOrErr.takeError());
      }
    }
    reportWarning("PLT entry at 0x" + Twine::utohexstr(PltEntry.second) +
                      " references an invalid symbol",
                  Obj->getFileName());
  }
}
817}

819// Normally the disassembly output will skip blocks of zeroes. This function
820// returns the number of zero bytes that can be skipped when dumping the
821// disassembly of the instructions in Buf.
822static size_t countSkippableZeroBytes(ArrayRef<uint8_t> Buf) {
// Find the number of leading zeroes.
size_t N = 0;
while (N < Buf.size() && !Buf[N])
  ++N;

// We may want to skip blocks of zero bytes, but unless we see
// at least 8 of them in a row.
if (N < 8)
  return 0;

// We skip zeroes in multiples of 4 because do not want to truncate an
// instruction if it starts with a zero byte.
return N & ~0x3;
836}

838// Returns a map from sections to their relocations.
839static std::map<SectionRef, std::vector<RelocationRef>>
840getRelocsMap(object::ObjectFile const &Obj) {
std::map<SectionRef, std::vector<RelocationRef>> Ret;
uint64_t I = (uint64_t)-1;
for (SectionRef Sec : Obj.sections()) {
  ++I;
  Expected<section_iterator> RelocatedOrErr = Sec.getRelocatedSection();
  if (!RelocatedOrErr)
    reportError(Obj.getFileName(),
                "section (" + Twine(I) +
                    "): failed to get a relocated section: " +
                    toString(RelocatedOrErr.takeError()));

  section_iterator Relocated = *RelocatedOrErr;
  if (Relocated == Obj.section_end() || !checkSectionFilter(*Relocated).Keep)
    continue;
  std::vector<RelocationRef> &V = Ret[*Relocated];
  append_range(V, Sec.relocations());
  // Sort relocations by address.
  llvm::stable_sort(V, isRelocAddressLess);
}
return Ret;
861}

863// Used for --adjust-vma to check if address should be adjusted by the
864// specified value for a given section.
865// For ELF we do not adjust non-allocatable sections like debug ones,
866// because they are not loadable.
867// TODO: implement for other file formats.
868static bool shouldAdjustVA(const SectionRef &Section) {
const ObjectFile *Obj = Section.getObject();
if (Obj->isELF())
  return ELFSectionRef(Section).getFlags() & ELF::SHF_ALLOC;
return false;
873}


876typedef std::pair<uint64_t, char> MappingSymbolPair;
877static char getMappingSymbolKind(ArrayRef<MappingSymbolPair> MappingSymbols,
                               uint64_t Address) {
auto It =
    partition_point(MappingSymbols, [Address](const MappingSymbolPair &Val) {
      return Val.first <= Address;
    });
// Return zero for any address before the first mapping symbol; this means
// we should use the default disassembly mode, depending on the target.
if (It == MappingSymbols.begin())
  return '\x00';
return (It - 1)->second;
888}

890static uint64_t dumpARMELFData(uint64_t SectionAddr, uint64_t Index,
                             uint64_t End, const ObjectFile *Obj,
                             ArrayRef<uint8_t> Bytes,
                             ArrayRef<MappingSymbolPair> MappingSymbols,
                             raw_ostream &OS) {
support::endianness Endian =
    Obj->isLittleEndian() ? support::little : support::big;
OS << format("%8" PRIx64"l" "x" ":\t", SectionAddr + Index);
if (Index + 4 <= End) {
  dumpBytes(Bytes.slice(Index, 4), OS);
  OS << "\t.word\t"
         << format_hex(support::endian::read32(Bytes.data() + Index, Endian),
                       10);
  return 4;
}
if (Index + 2 <= End) {
  dumpBytes(Bytes.slice(Index, 2), OS);
  OS << "\t\t.short\t"
         << format_hex(support::endian::read16(Bytes.data() + Index, Endian),
                       6);
  return 2;
}
dumpBytes(Bytes.slice(Index, 1), OS);
OS << "\t\t.byte\t" << format_hex(Bytes[0], 4);
return 1;
915}

917static void dumpELFData(uint64_t SectionAddr, uint64_t Index, uint64_t End,
                      ArrayRef<uint8_t> Bytes) {
// print out data up to 8 bytes at a time in hex and ascii
uint8_t AsciiData[9] = {'\0'};
uint8_t Byte;
int NumBytes = 0;

for (; Index < End; ++Index) {
  if (NumBytes == 0)
    outs() << format("%8" PRIx64"l" "x" ":", SectionAddr + Index);
  Byte = Bytes.slice(Index)[0];
  outs() << format(" %02x", Byte);
  AsciiData[NumBytes] = isPrint(Byte) ? Byte : '.';

  uint8_t IndentOffset = 0;
  NumBytes++;
  if (Index == End - 1 || NumBytes > 8) {
    // Indent the space for less than 8 bytes data.
    // 2 spaces for byte and one for space between bytes
    IndentOffset = 3 * (8 - NumBytes);
    for (int Excess = NumBytes; Excess < 8; Excess++)
      AsciiData[Excess] = '\0';
    NumBytes = 8;
  }
  if (NumBytes == 8) {
    AsciiData[8] = '\0';
    outs() << std::string(IndentOffset, ' ') << "         ";
    outs() << reinterpret_cast<char *>(AsciiData);
    outs() << '\n';
    NumBytes = 0;
  }
}
949}

951SymbolInfoTy objdump::createSymbolInfo(const ObjectFile *Obj,
                                     const SymbolRef &Symbol) {
const StringRef FileName = Obj->getFileName();
const uint64_t Addr = unwrapOrError(Symbol.getAddress(), FileName);
const StringRef Name = unwrapOrError(Symbol.getName(), FileName);

if (Obj->isXCOFF() && SymbolDescription) {
  const auto *XCOFFObj = cast<XCOFFObjectFile>(Obj);
  DataRefImpl SymbolDRI = Symbol.getRawDataRefImpl();

  const uint32_t SymbolIndex = XCOFFObj->getSymbolIndex(SymbolDRI.p);
  Optional<XCOFF::StorageMappingClass> Smc =
      getXCOFFSymbolCsectSMC(XCOFFObj, Symbol);
  return SymbolInfoTy(Addr, Name, Smc, SymbolIndex,
                      isLabel(XCOFFObj, Symbol));
} else if (Obj->isXCOFF()) {
  const SymbolRef::Type SymType = unwrapOrError(Symbol.getType(), FileName);
  return SymbolInfoTy(Addr, Name, SymType, true);
} else
  return SymbolInfoTy(Addr, Name,
                      Obj->isELF() ? getElfSymbolType(Obj, Symbol)
                                   : (uint8_t)ELF::STT_NOTYPE);
973}

975static SymbolInfoTy createDummySymbolInfo(const ObjectFile *Obj,
                                        const uint64_t Addr, StringRef &Name,
                                        uint8_t Type) {
if (Obj->isXCOFF() && SymbolDescription)
  return SymbolInfoTy(Addr, Name, None, None, false);
else
  return SymbolInfoTy(Addr, Name, Type);
982}

984static void
985collectLocalBranchTargets(ArrayRef<uint8_t> Bytes, const MCInstrAnalysis *MIA,
                        MCDisassembler *DisAsm, MCInstPrinter *IP,
                        const MCSubtargetInfo *STI, uint64_t SectionAddr,
                        uint64_t Start, uint64_t End,
                        std::unordered_map<uint64_t, std::string> &Labels) {
// So far only supports PowerPC and X86.
if (!STI->getTargetTriple().isPPC() && !STI->getTargetTriple().isX86())
  return;

Labels.clear();
unsigned LabelCount = 0;
Start += SectionAddr;
End += SectionAddr;
uint64_t Index = Start;
while (Index < End) {
  // Disassemble a real instruction and record function-local branch labels.
  MCInst Inst;
  uint64_t Size;
  bool Disassembled = DisAsm->getInstruction(
      Inst, Size, Bytes.slice(Index - SectionAddr), Index, nulls());
  if (Size == 0)
    Size = 1;

  if (Disassembled && MIA) {
    uint64_t Target;
    bool TargetKnown = MIA->evaluateBranch(Inst, Index, Size, Target);
    // On PowerPC, if the address of a branch is the same as the target, it
    // means that it's a function call. Do not mark the label for this case.
    if (TargetKnown && (Target >= Start && Target < End) &&
        !Labels.count(Target) &&
        !(STI->getTargetTriple().isPPC() && Target == Index))
      Labels[Target] = ("L" + Twine(LabelCount++)).str();
  }

  Index += Size;
}
1021}

1023// Create an MCSymbolizer for the target and add it to the MCDisassembler.
1024// This is currently only used on AMDGPU, and assumes the format of the
1025// void * argument passed to AMDGPU's createMCSymbolizer.
1026static void addSymbolizer(
  MCContext &Ctx, const Target *Target, StringRef TripleName,
  MCDisassembler *DisAsm, uint64_t SectionAddr, ArrayRef<uint8_t> Bytes,
  SectionSymbolsTy &Symbols,
  std::vector<std::unique_ptr<std::string>> &SynthesizedLabelNames) {

std::unique_ptr<MCRelocationInfo> RelInfo(
    Target->createMCRelocationInfo(TripleName, Ctx));
if (!RelInfo)
  return;
std::unique_ptr<MCSymbolizer> Symbolizer(Target->createMCSymbolizer(
    TripleName, nullptr, nullptr, &Symbols, &Ctx, std::move(RelInfo)));
MCSymbolizer *SymbolizerPtr = &*Symbolizer;
DisAsm->setSymbolizer(std::move(Symbolizer));

if (!SymbolizeOperands)
  return;

// Synthesize labels referenced by branch instructions by
// disassembling, discarding the output, and collecting the referenced
// addresses from the symbolizer.
for (size_t Index = 0; Index != Bytes.size();) {
  MCInst Inst;
  uint64_t Size;
  DisAsm->getInstruction(Inst, Size, Bytes.slice(Index), SectionAddr + Index,
                         nulls());
  if (Size == 0)
    Size = 1;
  Index += Size;
}
ArrayRef<uint64_t> LabelAddrsRef = SymbolizerPtr->getReferencedAddresses();
// Copy and sort to remove duplicates.
std::vector<uint64_t> LabelAddrs;
LabelAddrs.insert(LabelAddrs.end(), LabelAddrsRef.begin(),
                  LabelAddrsRef.end());
llvm::sort(LabelAddrs);
LabelAddrs.resize(std::unique(LabelAddrs.begin(), LabelAddrs.end()) -
                  LabelAddrs.begin());
// Add the labels.
for (unsigned LabelNum = 0; LabelNum != LabelAddrs.size(); ++LabelNum) {
  auto Name = std::make_unique<std::string>();
  *Name = (Twine("L") + Twine(LabelNum)).str();
  SynthesizedLabelNames.push_back(std::move(Name));
  Symbols.push_back(SymbolInfoTy(
      LabelAddrs[LabelNum], *SynthesizedLabelNames.back(), ELF::STT_NOTYPE));
}
llvm::stable_sort(Symbols);
// Recreate the symbolizer with the new symbols list.
RelInfo.reset(Target->createMCRelocationInfo(TripleName, Ctx));
Symbolizer.reset(Target->createMCSymbolizer(
    TripleName, nullptr, nullptr, &Symbols, &Ctx, std::move(RelInfo)));
DisAsm->setSymbolizer(std::move(Symbolizer));
1078}

1080static StringRef getSegmentName(const MachOObjectFile *MachO,
                              const SectionRef &Section) {
if (MachO) {
  DataRefImpl DR = Section.getRawDataRefImpl();
  StringRef SegmentName = MachO->getSectionFinalSegmentName(DR);
  return SegmentName;
}
return "";
1088}

1090static void emitPostInstructionInfo(formatted_raw_ostream &FOS,
                                  const MCAsmInfo &MAI,
                                  const MCSubtargetInfo &STI,
                                  StringRef Comments,
                                  LiveVariablePrinter &LVP) {
do {
  if (!Comments.empty()) {
    // Emit a line of comments.
    StringRef Comment;
    std::tie(Comment, Comments) = Comments.split('\n');
    // MAI.getCommentColumn() assumes that instructions are printed at the
    // position of 8, while getInstStartColumn() returns the actual position.
    unsigned CommentColumn =
        MAI.getCommentColumn() - 8 + getInstStartColumn(STI);
    FOS.PadToColumn(CommentColumn);
    FOS << MAI.getCommentString() << ' ' << Comment;
  }
  LVP.printAfterInst(FOS);
  FOS << '\n';
} while (!Comments.empty());
FOS.flush();
1111}

1113static 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) {
const MCSubtargetInfo *STI = PrimarySTI;
MCDisassembler *DisAsm = PrimaryDisAsm;
bool PrimaryIsThumb = false;
if (isArmElf(Obj))
  PrimaryIsThumb = STI->checkFeatures("+thumb-mode");

std::map<SectionRef, std::vector<RelocationRef>> RelocMap;
if (InlineRelocs)
  RelocMap = getRelocsMap(*Obj);
bool Is64Bits = Obj->getBytesInAddress() > 4;

// Create a mapping from virtual address to symbol name.  This is used to
// pretty print the symbols while disassembling.
std::map<SectionRef, SectionSymbolsTy> AllSymbols;
SectionSymbolsTy AbsoluteSymbols;
const StringRef FileName = Obj->getFileName();
const MachOObjectFile *MachO = dyn_cast<const MachOObjectFile>(Obj);
for (const SymbolRef &Symbol : Obj->symbols()) {
  Expected<StringRef> NameOrErr = Symbol.getName();
  if (!NameOrErr) {
    reportWarning(toString(NameOrErr.takeError()), FileName);
    continue;
  }
  if (NameOrErr->empty() && !(Obj->isXCOFF() && SymbolDescription))
    continue;

  if (Obj->isELF() && getElfSymbolType(Obj, Symbol) == ELF::STT_SECTION)
    continue;

  if (MachO) {
    // __mh_(execute|dylib|dylinker|bundle|preload|object)_header are special
    // symbols that support MachO header introspection. They do not bind to
    // code locations and are irrelevant for disassembly.
    if (NameOrErr->startswith("__mh_") && NameOrErr->endswith("_header"))
      continue;
    // Don't ask a Mach-O STAB symbol for its section unless you know that
    // STAB symbol's section field refers to a valid section index. Otherwise
    // the symbol may error trying to load a section that does not exist.
    DataRefImpl SymDRI = Symbol.getRawDataRefImpl();
    uint8_t NType = (MachO->is64Bit() ?
                     MachO->getSymbol64TableEntry(SymDRI).n_type:
                     MachO->getSymbolTableEntry(SymDRI).n_type);
    if (NType & MachO::N_STAB)
      continue;
  }

  section_iterator SecI = unwrapOrError(Symbol.getSection(), FileName);
  if (SecI != Obj->section_end())
    AllSymbols[*SecI].push_back(createSymbolInfo(Obj, Symbol));
  else
    AbsoluteSymbols.push_back(createSymbolInfo(Obj, Symbol));
}

if (AllSymbols.empty() && Obj->isELF())
  addDynamicElfSymbols(Obj, AllSymbols);

if (Obj->isWasm())
  addMissingWasmCodeSymbols(cast<WasmObjectFile>(Obj), AllSymbols);

BumpPtrAllocator A;
StringSaver Saver(A);
addPltEntries(Obj, AllSymbols, Saver);

// Create a mapping from virtual address to section. An empty section can
// cause more than one section at the same address. Sort such sections to be
// before same-addressed non-empty sections so that symbol lookups prefer the
// non-empty section.
std::vector<std::pair<uint64_t, SectionRef>> SectionAddresses;
for (SectionRef Sec : Obj->sections())
  SectionAddresses.emplace_back(Sec.getAddress(), Sec);
llvm::stable_sort(SectionAddresses, [](const auto &LHS, const auto &RHS) {
  if (LHS.first != RHS.first)
    return LHS.first < RHS.first;
  return LHS.second.getSize() < RHS.second.getSize();
});

// Linked executables (.exe and .dll files) typically don't include a real
// symbol table but they might contain an export table.
if (const auto *COFFObj = dyn_cast<COFFObjectFile>(Obj)) {
  for (const auto &ExportEntry : COFFObj->export_directories()) {
    StringRef Name;
    if (Error E = ExportEntry.getSymbolName(Name))
      reportError(std::move(E), Obj->getFileName());
    if (Name.empty())
      continue;

    uint32_t RVA;
    if (Error E = ExportEntry.getExportRVA(RVA))
      reportError(std::move(E), Obj->getFileName());

    uint64_t VA = COFFObj->getImageBase() + RVA;
    auto Sec = partition_point(
        SectionAddresses, [VA](const std::pair<uint64_t, SectionRef> &O) {
          return O.first <= VA;
        });
    if (Sec != SectionAddresses.begin()) {
      --Sec;
      AllSymbols[Sec->second].emplace_back(VA, Name, ELF::STT_NOTYPE);
    } else
      AbsoluteSymbols.emplace_back(VA, Name, ELF::STT_NOTYPE);
  }
}

// Sort all the symbols, this allows us to use a simple binary search to find
// Multiple symbols can have the same address. Use a stable sort to stabilize
// the output.
StringSet<> FoundDisasmSymbolSet;
for (std::pair<const SectionRef, SectionSymbolsTy> &SecSyms : AllSymbols)
  llvm::stable_sort(SecSyms.second);
llvm::stable_sort(AbsoluteSymbols);

std::unique_ptr<DWARFContext> DICtx;
LiveVariablePrinter LVP(*Ctx.getRegisterInfo(), *STI);

if (DbgVariables != DVDisabled) {
  DICtx = DWARFContext::create(*Obj);
  for (const std::unique_ptr<DWARFUnit> &CU : DICtx->compile_units())
    LVP.addCompileUnit(CU->getUnitDIE(false));
}

LLVM_DEBUG(LVP.dump())do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType
("objdump")) { LVP.dump(); } } while (false);

for (const SectionRef &Section : ToolSectionFilter(*Obj)) {
  if (FilterSections.empty() && !DisassembleAll &&
      (!Section.isText() || Section.isVirtual()))
    continue;

  uint64_t SectionAddr = Section.getAddress();
  uint64_t SectSize = Section.getSize();
  if (!SectSize)
    continue;

  // Get the list of all the symbols in this section.
  SectionSymbolsTy &Symbols = AllSymbols[Section];
  std::vector<MappingSymbolPair> MappingSymbols;
  if (hasMappingSymbols(Obj)) {
    for (const auto &Symb : Symbols) {
      uint64_t Address = Symb.Addr;
      StringRef Name = Symb.Name;
      if (Name.startswith("$d"))
        MappingSymbols.emplace_back(Address - SectionAddr, 'd');
      if (Name.startswith("$x"))
        MappingSymbols.emplace_back(Address - SectionAddr, 'x');
      if (Name.startswith("$a"))
        MappingSymbols.emplace_back(Address - SectionAddr, 'a');
      if (Name.startswith("$t"))
        MappingSymbols.emplace_back(Address - SectionAddr, 't');
    }
  }

  llvm::sort(MappingSymbols);

  ArrayRef<uint8_t> Bytes = arrayRefFromStringRef(
      unwrapOrError(Section.getContents(), Obj->getFileName()));

  std::vector<std::unique_ptr<std::string>> SynthesizedLabelNames;
  if (Obj->isELF() && Obj->getArch() == Triple::amdgcn) {
    // AMDGPU disassembler uses symbolizer for printing labels
    addSymbolizer(Ctx, TheTarget, TripleName, DisAsm, SectionAddr, Bytes,
                  Symbols, SynthesizedLabelNames);
  }

  StringRef SegmentName = getSegmentName(MachO, Section);
  StringRef SectionName = unwrapOrError(Section.getName(), Obj->getFileName());
  // If the section has no symbol at the start, just insert a dummy one.
  if (Symbols.empty() || Symbols[0].Addr != 0) {
    Symbols.insert(Symbols.begin(),
                   createDummySymbolInfo(Obj, SectionAddr, SectionName,
                                         Section.isText() ? ELF::STT_FUNC
                                                          : ELF::STT_OBJECT));
  }

  SmallString<40> Comments;
  raw_svector_ostream CommentStream(Comments);

  uint64_t VMAAdjustment = 0;
  if (shouldAdjustVA(Section))
    VMAAdjustment = AdjustVMA;

  // In executable and shared objects, r_offset holds a virtual address.
  // Subtract SectionAddr from the r_offset field of a relocation to get
  // the section offset.
  uint64_t RelAdjustment = Obj->isRelocatableObject() ? 0 : SectionAddr;
  uint64_t Size;
  uint64_t Index;
  bool PrintedSection = false;
  std::vector<RelocationRef> Rels = RelocMap[Section];
  std::vector<RelocationRef>::const_iterator RelCur = Rels.begin();
  std::vector<RelocationRef>::const_iterator RelEnd = Rels.end();
  // Disassemble symbol by symbol.
  for (unsigned SI = 0, SE = Symbols.size(); SI != SE; ++SI) {
    std::string SymbolName = Symbols[SI].Name.str();
    if (Demangle)
      SymbolName = demangle(SymbolName);

    // Skip if --disassemble-symbols is not empty and the symbol is not in
    // the list.
    if (!DisasmSymbolSet.empty() && !DisasmSymbolSet.count(SymbolName))
      continue;

    uint64_t Start = Symbols[SI].Addr;
    if (Start < SectionAddr || StopAddress <= Start)
      continue;
    else
      FoundDisasmSymbolSet.insert(SymbolName);

    // The end is the section end, the beginning of the next symbol, or
    // --stop-address.
    uint64_t End = std::min<uint64_t>(SectionAddr + SectSize, StopAddress);
    if (SI + 1 < SE)
      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 ";
      if (!SegmentName.empty())
        outs() << SegmentName << ",";
      outs() << SectionName << ":\n";
    }

    outs() << '\n';
    if (LeadingAddr)
      outs() << format(Is64Bits ? "%016" PRIx64"l" "x" " " : "%08" PRIx64"l" "x" " ",
                       SectionAddr + Start + VMAAdjustment);
    if (Obj->isXCOFF() && SymbolDescription) {
      outs() << getXCOFFSymbolDescription(Symbols[SI], SymbolName) << ":\n";
    } else
      outs() << '<' << 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";
      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
               << " : 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";
        }
      }
    } else {
      Size = 0;
    }

    Start += Size;

    Index = Start;
    if (SectionAddr < StartAddress)
      Index = std::max<uint64_t>(Index, StartAddress - SectionAddr);

    // If there is a data/common symbol inside an ELF text section and we are
    // only disassembling text (applicable all architectures), we are in a
    // situation where we must print the data and not disassemble it.
    if (Obj->isELF() && !DisassembleAll && Section.isText()) {
      uint8_t SymTy = Symbols[SI].Type;
      if (SymTy == ELF::STT_OBJECT || SymTy == ELF::STT_COMMON) {
        dumpELFData(SectionAddr, Index, End, Bytes);
        Index = End;
      }
    }

    bool CheckARMELFData = hasMappingSymbols(Obj) &&
                           Symbols[SI].Type != ELF::STT_OBJECT &&
                           !DisassembleAll;
    bool DumpARMELFData = false;
    formatted_raw_ostream FOS(outs());

    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
      // same section. We rely on the markers introduced to understand what
      // we need to dump. If the data marker is within a function, it is
      // denoted as a word/short etc.
      if (CheckARMELFData) {
        char Kind = getMappingSymbolKind(MappingSymbols, Index);
        DumpARMELFData = Kind == 'd';
        if (SecondarySTI) {
          if (Kind == 'a') {
            STI = PrimaryIsThumb ? SecondarySTI : PrimarySTI;
            DisAsm = PrimaryIsThumb ? SecondaryDisAsm : PrimaryDisAsm;
          } else if (Kind == 't') {
            STI = PrimaryIsThumb ? PrimarySTI : SecondarySTI;
            DisAsm = PrimaryIsThumb ? PrimaryDisAsm : SecondaryDisAsm;
          }
        }
      }

      if (DumpARMELFData) {
        Size = dumpARMELFData(SectionAddr, Index, End, Obj, Bytes,
                              MappingSymbols, FOS);
      } else {
        // When -z or --disassemble-zeroes are given we always dissasemble
        // them. Otherwise we might want to skip zero bytes we see.
        if (!DisassembleZeroes) {
          uint64_t MaxOffset = End - Index;
          // For --reloc: print zero blocks patched by relocations, so that
          // relocations can be shown in the dump.
          if (RelCur != RelEnd)
            MaxOffset = std::min(RelCur->getOffset() - RelAdjustment - Index,
                                 MaxOffset);

          if (size_t N =
                  countSkippableZeroBytes(Bytes.slice(Index, MaxOffset))) {
            FOS << "\t\t..." << '\n';
            Index += N;
            continue;
          }
        }

        // Print local label if there's any.
        auto Iter = AllLabels.find(SectionAddr + Index);
        if (Iter != AllLabels.end())
          FOS << "<" << Iter->second << ">:\n";

        // Disassemble a real instruction or a data when disassemble all is
        // provided
        MCInst Inst;
        bool Disassembled =
            DisAsm->getInstruction(Inst, Size, Bytes.slice(Index),
                                   SectionAddr + Index, CommentStream);
        if (Size == 0)
          Size = 1;

        LVP.update({Index, Section.getIndex()},
                   {Index + Size, Section.getIndex()}, Index + Size != End);

        IP->setCommentStream(CommentStream);

        PIP.printInst(
            *IP, Disassembled ? &Inst : nullptr, Bytes.slice(Index, Size),
            {SectionAddr + Index + VMAAdjustment, Section.getIndex()}, FOS,
            "", *STI, &SP, Obj->getFileName(), &Rels, LVP);

        IP->setCommentStream(llvm::nulls());

        // If disassembly has failed, avoid analysing invalid/incomplete
        // instruction information. Otherwise, try to resolve the target
        // address (jump target or memory operand address) and print it on the
        // right of the instruction.
        if (Disassembled && MIA) {
          // Branch targets are printed just after the instructions.
          llvm::raw_ostream *TargetOS = &FOS;
          uint64_t Target;
          bool PrintTarget =
              MIA->evaluateBranch(Inst, SectionAddr + Index, Size, Target);
          if (!PrintTarget)
            if (Optional<uint64_t> MaybeTarget =
                    MIA->evaluateMemoryOperandAddress(
                        Inst, STI, SectionAddr + Index, Size)) {
              Target = *MaybeTarget;
              PrintTarget = true;
              // Do not print real address when symbolizing.
              if (!SymbolizeOperands) {
                // Memory operand addresses are printed as comments.
                TargetOS = &CommentStream;
                *TargetOS << "0x" << Twine::utohexstr(Target);
              }
            }
          if (PrintTarget) {
            // In a relocatable object, the target's section must reside in
            // the same section as the call instruction or it is accessed
            // through a relocation.
            //
            // In a non-relocatable object, the target may be in any section.
            // In that case, locate the section(s) containing the target
            // address and find the symbol in one of those, if possible.
            //
            // N.B. We don't walk the relocations in the relocatable case yet.
            std::vector<const SectionSymbolsTy *> TargetSectionSymbols;
            if (!Obj->isRelocatableObject()) {
              auto It = llvm::partition_point(
                  SectionAddresses,
                  [=](const std::pair<uint64_t, SectionRef> &O) {
                    return O.first <= Target;
                  });
              uint64_t TargetSecAddr = 0;
              while (It != SectionAddresses.begin()) {
                --It;
                if (TargetSecAddr == 0)
                  TargetSecAddr = It->first;
                if (It->first != TargetSecAddr)
                  break;
                TargetSectionSymbols.push_back(&AllSymbols[It->second]);
              }
            } else {
              TargetSectionSymbols.push_back(&Symbols);
            }
            TargetSectionSymbols.push_back(&AbsoluteSymbols);

            // Find the last symbol in the first candidate section whose
            // offset is less than or equal to the target. If there are no
            // such symbols, try in the next section and so on, before finally
            // using the nearest preceding absolute symbol (if any), if there
            // are no other valid symbols.
            const SymbolInfoTy *TargetSym = nullptr;
            for (const SectionSymbolsTy *TargetSymbols :
                 TargetSectionSymbols) {
              auto It = llvm::partition_point(
                  *TargetSymbols,
                  [=](const SymbolInfoTy &O) { return O.Addr <= Target; });
              if (It != TargetSymbols->begin()) {
                TargetSym = &*(It - 1);
                break;
              }
            }

            // Print the labels corresponding to the target if there's any.
            bool LabelAvailable = AllLabels.count(Target);
            if (TargetSym != nullptr) {
              uint64_t TargetAddress = TargetSym->Addr;
              uint64_t Disp = Target - TargetAddress;
              std::string TargetName = TargetSym->Name.str();
              if (Demangle)
                TargetName = demangle(TargetName);

              *TargetOS << " <";
              if (!Disp) {
                // Always Print the binary symbol precisely corresponding to
                // the target address.
                *TargetOS << TargetName;
              } else if (!LabelAvailable) {
                // Always Print the binary symbol plus an offset if there's no
                // local label corresponding to the target address.
                *TargetOS << TargetName << "+0x" << Twine::utohexstr(Disp);
              } else {
                *TargetOS << AllLabels[Target];
              }
              *TargetOS << ">";
            } else if (LabelAvailable) {
              *TargetOS << " <" << AllLabels[Target] << ">";
            }
            // By convention, each record in the comment stream should be
            // terminated.
            if (TargetOS == &CommentStream)
              *TargetOS << "\n";
          }
        }
      }

      assert(Ctx.getAsmInfo())(static_cast <bool> (Ctx.getAsmInfo()) ? void (0) : __assert_fail
 ("Ctx.getAsmInfo()", "llvm/tools/llvm-objdump/llvm-objdump.cpp"
, 1591, __extension__ __PRETTY_FUNCTION__));
      emitPostInstructionInfo(FOS, *Ctx.getAsmInfo(), *STI,
                              CommentStream.str(), LVP);
      Comments.clear();

      // Hexagon does this in pretty printer
      if (Obj->getArch() != Triple::hexagon) {
        // Print relocation for instruction and data.
        while (RelCur != RelEnd) {
          uint64_t Offset = RelCur->getOffset() - RelAdjustment;
          // If this relocation is hidden, skip it.
          if (getHidden(*RelCur) || SectionAddr + Offset < StartAddress) {
            ++RelCur;
            continue;
          }

          // Stop when RelCur's offset is past the disassembled
          // instruction/data. Note that it's possible the disassembled data
          // is not the complete data: we might see the relocation printed in
          // the middle of the data, but this matches the binutils objdump
          // output.
          if (Offset >= Index + Size)
            break;

          // When --adjust-vma is used, update the address printed.
          if (RelCur->getSymbol() != Obj->symbol_end()) {
            Expected<section_iterator> SymSI =
                RelCur->getSymbol()->getSection();
            if (SymSI && *SymSI != Obj->section_end() &&
                shouldAdjustVA(**SymSI))
              Offset += AdjustVMA;
          }

          printRelocation(FOS, Obj->getFileName(), *RelCur,
                          SectionAddr + Offset, Is64Bits);
          LVP.printAfterOtherLine(FOS, true);
          ++RelCur;
        }
      }

      Index += Size;
    }
  }
}
StringSet<> MissingDisasmSymbolSet =
    set_difference(DisasmSymbolSet, FoundDisasmSymbolSet);
for (StringRef Sym : MissingDisasmSymbolSet.keys())
  reportWarning("failed to disassemble missing symbol " + Sym, FileName);
1639}

1641static void disassembleObject(const ObjectFile *Obj, bool InlineRelocs) {
const Target *TheTarget = getTarget(Obj);

// Package up features to be passed to target/subtarget
SubtargetFeatures Features = Obj->getFeatures();
if (!MAttrs.empty())
  for (unsigned I = 0; I != MAttrs.size(); ++I)
    Features.AddFeature(MAttrs[I]);

std::unique_ptr<const MCRegisterInfo> MRI(
    TheTarget->createMCRegInfo(TripleName));
if (!MRI)
  reportError(Obj->getFileName(),
              "no register info for target " + TripleName);

// Set up disassembler.
MCTargetOptions MCOptions;
std::unique_ptr<const MCAsmInfo> AsmInfo(
    TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
if (!AsmInfo)
  reportError(Obj->getFileName(),
              "no assembly info for target " + TripleName);

if (MCPU.empty())
  MCPU = Obj->tryGetCPUName().getValueOr("").str();

std::unique_ptr<const MCSubtargetInfo> STI(
    TheTarget->createMCSubtargetInfo(TripleName, MCPU, Features.getString()));
if (!STI)
  reportError(Obj->getFileName(),
              "no subtarget info for target " + TripleName);
std::unique_ptr<const MCInstrInfo> MII(TheTarget->createMCInstrInfo());
if (!MII)
  reportError(Obj->getFileName(),
              "no instruction info for target " + TripleName);
MCContext Ctx(Triple(TripleName), AsmInfo.get(), MRI.get(), STI.get());
// FIXME: for now initialize MCObjectFileInfo with default values
std::unique_ptr<MCObjectFileInfo> MOFI(
    TheTarget->createMCObjectFileInfo(Ctx, /*PIC=*/false));
Ctx.setObjectFileInfo(MOFI.get());

std::unique_ptr<MCDisassembler> DisAsm(
    TheTarget->createMCDisassembler(*STI, Ctx));
if (!DisAsm)
  reportError(Obj->getFileName(), "no disassembler for target " + TripleName);

// If we have an ARM object file, we need a second disassembler, because
// ARM CPUs have two different instruction sets: ARM mode, and Thumb mode.
// We use mapping symbols to switch between the two assemblers, where
// appropriate.
std::unique_ptr<MCDisassembler> SecondaryDisAsm;
std::unique_ptr<const MCSubtargetInfo> SecondarySTI;
if (isArmElf(Obj) && !STI->checkFeatures("+mclass")) {
  if (STI->checkFeatures("+thumb-mode"))
    Features.AddFeature("-thumb-mode");
  else
    Features.AddFeature("+thumb-mode");
  SecondarySTI.reset(TheTarget->createMCSubtargetInfo(TripleName, MCPU,
                                                      Features.getString()));
  SecondaryDisAsm.reset(TheTarget->createMCDisassembler(*SecondarySTI, Ctx));
}

std::unique_ptr<const MCInstrAnalysis> MIA(
    TheTarget->createMCInstrAnalysis(MII.get()));

int AsmPrinterVariant = AsmInfo->getAssemblerDialect();
std::unique_ptr<MCInstPrinter> IP(TheTarget->createMCInstPrinter(
    Triple(TripleName), AsmPrinterVariant, *AsmInfo, *MII, *MRI));
if (!IP)
  reportError(Obj->getFileName(),
              "no instruction printer for target " + TripleName);
IP->setPrintImmHex(PrintImmHex);
IP->setPrintBranchImmAsAddress(true);
IP->setSymbolizeOperands(SymbolizeOperands);
IP->setMCInstrAnalysis(MIA.get());

PrettyPrinter &PIP = selectPrettyPrinter(Triple(TripleName));
SourcePrinter SP(Obj, TheTarget->getName());

for (StringRef Opt : DisassemblerOptions)
  if (!IP->applyTargetSpecificCLOption(Opt))
    reportError(Obj->getFileName(),
                "Unrecognized disassembler option: " + Opt);

disassembleObject(TheTarget, Obj, Ctx, DisAsm.get(), SecondaryDisAsm.get(),
                  MIA.get(), IP.get(), STI.get(), SecondarySTI.get(), PIP,
                  SP, InlineRelocs);
1728}

1730void objdump::printRelocations(const ObjectFile *Obj) {
StringRef Fmt = Obj->getBytesInAddress() > 4 ? "%016" PRIx64"l" "x" :
                                               "%08" PRIx64"l" "x";
// Regular objdump doesn't print relocations in non-relocatable object
// files.
if (!Obj->isRelocatableObject())
  return;

// Build a mapping from relocation target to a vector of relocation
// sections. Usually, there is an only one relocation section for
// each relocated section.
MapVector<SectionRef, std::vector<SectionRef>> SecToRelSec;
uint64_t Ndx;
for (const SectionRef &Section : ToolSectionFilter(*Obj, &Ndx)) {
  if (Section.relocation_begin() == Section.relocation_end())
    continue;
  Expected<section_iterator> SecOrErr = Section.getRelocatedSection();
  if (!SecOrErr)
    reportError(Obj->getFileName(),
                "section (" + Twine(Ndx) +
                    "): unable to get a relocation target: " +
                    toString(SecOrErr.takeError()));
  SecToRelSec[**SecOrErr].push_back(Section);
}

for (std::pair<SectionRef, std::vector<SectionRef>> &P : SecToRelSec) {
  StringRef SecName = unwrapOrError(P.first.getName(), Obj->getFileName());
  outs() << "\nRELOCATION RECORDS FOR [" << SecName << "]:\n";
  uint32_t OffsetPadding = (Obj->getBytesInAddress() > 4 ? 16 : 8);
  uint32_t TypePadding = 24;
  outs() << left_justify("OFFSET", OffsetPadding) << " "
         << left_justify("TYPE", TypePadding) << " "
         << "VALUE\n";

  for (SectionRef Section : P.second) {
    for (const RelocationRef &Reloc : Section.relocations()) {
      uint64_t Address = Reloc.getOffset();
      SmallString<32> RelocName;
      SmallString<32> ValueStr;
      if (Address < StartAddress || Address > StopAddress || getHidden(Reloc))
        continue;
      Reloc.getTypeName(RelocName);
      if (Error E = getRelocationValueString(Reloc, ValueStr))
        reportError(std::move(E), Obj->getFileName());

      outs() << format(Fmt.data(), Address) << " "
             << left_justify(RelocName, TypePadding) << " " << ValueStr
             << "\n";
    }
  }
}
1781}

1783void objdump::printDynamicRelocations(const ObjectFile *Obj) {
// For the moment, this option is for ELF only
if (!Obj->isELF())
  return;

const auto *Elf = dyn_cast<ELFObjectFileBase>(Obj);
if (!Elf || !any_of(Elf->sections(), [](const ELFSectionRef Sec) {
      return Sec.getType() == ELF::SHT_DYNAMIC;
    })) {
  reportError(Obj->getFileName(), "not a dynamic object");
  return;
}

std::vector<SectionRef> DynRelSec = Obj->dynamic_relocation_sections();
if (DynRelSec.empty())
  return;

outs() << "\nDYNAMIC RELOCATION RECORDS\n";
const uint32_t OffsetPadding = (Obj->getBytesInAddress() > 4 ? 16 : 8);
const uint32_t TypePadding = 24;
outs() << left_justify("OFFSET", OffsetPadding) << ' '
       << left_justify("TYPE", TypePadding) << " VALUE\n";

StringRef Fmt = Obj->getBytesInAddress() > 4 ? "%016" PRIx64"l" "x" : "%08" PRIx64"l" "x";
for (const SectionRef &Section : DynRelSec)
  for (const RelocationRef &Reloc : Section.relocations()) {
    uint64_t Address = Reloc.getOffset();
    SmallString<32> RelocName;
    SmallString<32> ValueStr;
    Reloc.getTypeName(RelocName);
    if (Error E = getRelocationValueString(Reloc, ValueStr))
      reportError(std::move(E), Obj->getFileName());
    outs() << format(Fmt.data(), Address) << ' '
           << left_justify(RelocName, TypePadding) << ' ' << ValueStr << '\n';
  }
1818}

1820// Returns true if we need to show LMA column when dumping section headers. We
1821// show it only when the platform is ELF and either we have at least one section
1822// whose VMA and LMA are different and/or when --show-lma flag is used.
1823static bool shouldDisplayLMA(const ObjectFile *Obj) {
if (!Obj->isELF())
  return false;
for (const SectionRef &S : ToolSectionFilter(*Obj))
  if (S.getAddress() != getELFSectionLMA(S))
    return true;
return ShowLMA;
1830}

1832static size_t getMaxSectionNameWidth(const ObjectFile *Obj) {
// Default column width for names is 13 even if no names are that long.
size_t MaxWidth = 13;
for (const SectionRef &Section : ToolSectionFilter(*Obj)) {
  StringRef Name = unwrapOrError(Section.getName(), Obj->getFileName());
  MaxWidth = std::max(MaxWidth, Name.size());
}
return MaxWidth;
1840}

1842void objdump::printSectionHeaders(const ObjectFile *Obj) {
size_t NameWidth = getMaxSectionNameWidth(Obj);
size_t AddressWidth = 2 * Obj->getBytesInAddress();
bool HasLMAColumn = shouldDisplayLMA(Obj);
outs() << "\nSections:\n";
if (HasLMAColumn)
  outs() << "Idx " << left_justify("Name", NameWidth) << " Size     "
         << left_justify("VMA", AddressWidth) << " "
         << left_justify("LMA", AddressWidth) << " Type\n";
else
  outs() << "Idx " << left_justify("Name", NameWidth) << " Size     "
         << left_justify("VMA", AddressWidth) << " Type\n";

uint64_t Idx;
for (const SectionRef &Section : ToolSectionFilter(*Obj, &Idx)) {
  StringRef Name = unwrapOrError(Section.getName(), Obj->getFileName());
  uint64_t VMA = Section.getAddress();
  if (shouldAdjustVA(Section))
    VMA += AdjustVMA;

  uint64_t Size = Section.getSize();

  std::string Type = Section.isText() ? "TEXT" : "";
  if (Section.isData())
    Type += Type.empty() ? "DATA" : ", DATA";
  if (Section.isBSS())
    Type += Type.empty() ? "BSS" : ", BSS";
  if (Section.isDebugSection())
    Type += Type.empty() ? "DEBUG" : ", DEBUG";

  if (HasLMAColumn)
    outs() << format("%3" PRIu64"l" "u" " %-*s %08" PRIx64"l" "x" " ", Idx, NameWidth,
                     Name.str().c_str(), Size)
           << format_hex_no_prefix(VMA, AddressWidth) << " "
           << format_hex_no_prefix(getELFSectionLMA(Section), AddressWidth)
           << " " << Type << "\n";
  else
    outs() << format("%3" PRIu64"l" "u" " %-*s %08" PRIx64"l" "x" " ", Idx, NameWidth,
                     Name.str().c_str(), Size)
           << format_hex_no_prefix(VMA, AddressWidth) << " " << Type << "\n";
}
1883}

1885void objdump::printSectionContents(const ObjectFile *Obj) {
const MachOObjectFile *MachO = dyn_cast<const MachOObjectFile>(Obj);

for (const SectionRef &Section : ToolSectionFilter(*Obj)) {
  StringRef Name = unwrapOrError(Section.getName(), Obj->getFileName());
  uint64_t BaseAddr = Section.getAddress();
  uint64_t Size = Section.getSize();
  if (!Size)
    continue;

  outs() << "Contents of section ";
  StringRef SegmentName = getSegmentName(MachO, Section);
  if (!SegmentName.empty())
    outs() << SegmentName << ",";
  outs() << Name << ":\n";
  if (Section.isBSS()) {
    outs() << format("<skipping contents of bss section at [%04" PRIx64"l" "x"
                     ", %04" PRIx64"l" "x" ")>\n",
                     BaseAddr, BaseAddr + Size);
    continue;
  }

  StringRef Contents = unwrapOrError(Section.getContents(), Obj->getFileName());

  // Dump out the content as hex and printable ascii characters.
  for (std::size_t Addr = 0, End = Contents.size(); Addr < End; Addr += 16) {
    outs() << format(" %04" PRIx64"l" "x" " ", BaseAddr + Addr);
    // Dump line of hex.
    for (std::size_t I = 0; I < 16; ++I) {
      if (I != 0 && I % 4 == 0)
        outs() << ' ';
      if (Addr + I < End)
        outs() << hexdigit((Contents[Addr + I] >> 4) & 0xF, true)
               << hexdigit(Contents[Addr + I] & 0xF, true);
      else
        outs() << "  ";
    }
    // Print ascii.
    outs() << "  ";
    for (std::size_t I = 0; I < 16 && Addr + I < End; ++I) {
      if (isPrint(static_cast<unsigned char>(Contents[Addr + I]) & 0xFF))
        outs() << Contents[Addr + I];
      else
        outs() << ".";
    }
    outs() << "\n";
  }
}
1933}

1935void objdump::printSymbolTable(const ObjectFile *O, StringRef ArchiveName,
                             StringRef ArchitectureName, bool DumpDynamic) {
if (O->isCOFF() && !DumpDynamic) {
  outs() << "\nSYMBOL TABLE:\n";
  printCOFFSymbolTable(cast<const COFFObjectFile>(O));
  return;
}

const StringRef FileName = O->getFileName();

if (!DumpDynamic) {
  outs() << "\nSYMBOL TABLE:\n";
  for (auto I = O->symbol_begin(); I != O->symbol_end(); ++I)
    printSymbol(O, *I, {}, FileName, ArchiveName, ArchitectureName,
                DumpDynamic);
  return;
}

outs() << "\nDYNAMIC SYMBOL TABLE:\n";
if (!O->isELF()) {
  reportWarning(
      "this operation is not currently supported for this file format",
      FileName);
  return;
}

const ELFObjectFileBase *ELF = cast<const ELFObjectFileBase>(O);
auto Symbols = ELF->getDynamicSymbolIterators();
Expected<std::vector<VersionEntry>> SymbolVersionsOrErr =
    ELF->readDynsymVersions();
if (!SymbolVersionsOrErr) {
  reportWarning(toString(SymbolVersionsOrErr.takeError()), FileName);
  SymbolVersionsOrErr = std::vector<VersionEntry>();
  (void)!SymbolVersionsOrErr;
}
for (auto &Sym : Symbols)
  printSymbol(O, Sym, *SymbolVersionsOrErr, FileName, ArchiveName,
              ArchitectureName, DumpDynamic);
1973}

1975void objdump::printSymbol(const ObjectFile *O, const SymbolRef &Symbol,
                        ArrayRef<VersionEntry> SymbolVersions,
                        StringRef FileName, StringRef ArchiveName,
                        StringRef ArchitectureName, bool DumpDynamic) {
const MachOObjectFile *MachO = dyn_cast<const MachOObjectFile>(O);
1
Assuming 'O' is not a 'MachOObjectFile'→
uint64_t Address = unwrapOrError(Symbol.getAddress(), FileName, ArchiveName,
                                 ArchitectureName);
if ((Address < StartAddress) || (Address > StopAddress))
2
←
Assuming 'Address' is >= 'StartAddress'→
3
←
Assuming 'Address' is <= 'StopAddress'→
4
←
Taking false branch→
  return;
SymbolRef::Type Type =
    unwrapOrError(Symbol.getType(), FileName, ArchiveName, ArchitectureName);
uint32_t Flags =
    unwrapOrError(Symbol.getFlags(), FileName, ArchiveName, ArchitectureName);

// Don't ask a Mach-O STAB symbol for its section unless you know that
// STAB symbol's section field refers to a valid section index. Otherwise
// the symbol may error trying to load a section that does not exist.
bool IsSTAB = false;
if (MachO4.1
'MachO' is null
) {
  DataRefImpl SymDRI = Symbol.getRawDataRefImpl();
  uint8_t NType =
      (MachO->is64Bit() ? MachO->getSymbol64TableEntry(SymDRI).n_type
                        : MachO->getSymbolTableEntry(SymDRI).n_type);
  if (NType & MachO::N_STAB)
    IsSTAB = true;
}
section_iterator Section = IsSTAB

5.1	'IsSTAB' is false

←

Taking false branch

→

←

'?' condition is false

→

2002 ? O->section_end() 2003 : unwrapOrError(Symbol.getSection(), FileName, 2004 ArchiveName, ArchitectureName); 2005 2006 StringRef Name; 2007 if (Type == SymbolRef::ST_Debug && Section != O->section_end()) {

←

Assuming 'Type' is not equal to ST_Debug

→

←

Taking false branch

→

2008 if (Expected<StringRef> NameOrErr = Section->getName()) 2009 Name = *NameOrErr; 2010 else 2011 consumeError(NameOrErr.takeError()); 2012 2013 } else { 2014 Name = unwrapOrError(Symbol.getName(), FileName, ArchiveName, 2015 ArchitectureName); 2016 } 2017 2018 bool Global = Flags & SymbolRef::SF_Global; 2019 bool Weak = Flags & SymbolRef::SF_Weak; 2020 bool Absolute = Flags & SymbolRef::SF_Absolute; 2021 bool Common = Flags & SymbolRef::SF_Common; 2022 bool Hidden = Flags & SymbolRef::SF_Hidden; 2023 2024 char GlobLoc = ' '; 2025 if ((Section != O->section_end() || Absolute) && !Weak)

←

Assuming the condition is false

→

←

Assuming 'Absolute' is false

→

←

Taking false branch

→

2026 GlobLoc = Global ? 'g' : 'l'; 2027 char IFunc = ' '; 2028 if (O->isELF()) {

←

Taking false branch

→

2029 if (ELFSymbolRef(Symbol).getELFType() == ELF::STT_GNU_IFUNC) 2030 IFunc = 'i'; 2031 if (ELFSymbolRef(Symbol).getBinding() == ELF::STB_GNU_UNIQUE) 2032 GlobLoc = 'u'; 2033 } 2034 2035 char Debug = ' '; 2036 if (DumpDynamic)

←

Assuming 'DumpDynamic' is false

→

2037 Debug = 'D'; 2038 else if (Type

13.1	'Type' is not equal to ST_Debug

== SymbolRef::ST_Debug || Type == SymbolRef::ST_File)

←

Assuming 'Type' is not equal to ST_File

→

←

Taking false branch

→

2039 Debug = 'd'; 2040 2041 char FileFunc = ' '; 2042 if (Type

15.1	'Type' is not equal to ST_File

== SymbolRef::ST_File)

←

Taking false branch

→

2043 FileFunc = 'f'; 2044 else if (Type == SymbolRef::ST_Function)

←

Assuming 'Type' is not equal to ST_Function

→

←

Taking false branch

→

2045 FileFunc = 'F'; 2046 else if (Type == SymbolRef::ST_Data)

←

Assuming 'Type' is not equal to ST_Data

→

2047 FileFunc = 'O'; 2048 2049 const char *Fmt = O->getBytesInAddress() > 4 ? "%016" PRIx64"l" "x" : "%08" PRIx64"l" "x";

←

Taking false branch

→

←

Assuming the condition is false

→

←

'?' condition is false

→

2050 2051 outs() << format(Fmt, Address) << " " 2052 << GlobLoc // Local -> 'l', Global -> 'g', Neither -> ' ' 2053 << (Weak ? 'w' : ' ') // Weak?

←

Assuming 'Weak' is false

→

←

'?' condition is false

→

2054 << ' ' // Constructor. Not supported yet. 2055 << ' ' // Warning. Not supported yet. 2056 << IFunc // Indirect reference to another symbol. 2057 << Debug // Debugging (d) or dynamic (D) symbol. 2058 << FileFunc // Name of function (F), file (f) or object (O). 2059 << ' '; 2060 if (Absolute

24.1	'Absolute' is false

) {

←

Taking false branch

→

2061 outs() << "*ABS*"; 2062 } else if (Common) {

←

Assuming 'Common' is false

→

←

Taking false branch

→

2063 outs() << "*COM*"; 2064 } else if (Section == O->section_end()) {

←

Assuming the condition is true

→

←

Taking true branch

→

2065 if (O->isXCOFF()) {

←

Taking true branch

→

2066 XCOFFSymbolRef XCOFFSym = dyn_cast<const XCOFFObjectFile>(O)->toSymbolRef(

←

Assuming 'O' is not a 'XCOFFObjectFile'

→

←

Called C++ object pointer is null

2067 Symbol.getRawDataRefImpl()); 2068 if (XCOFF::N_DEBUG == XCOFFSym.getSectionNumber()) 2069 outs() << "*DEBUG*"; 2070 else 2071 outs() << "*UND*"; 2072 } else 2073 outs() << "*UND*"; 2074 } else { 2075 StringRef SegmentName = getSegmentName(MachO, *Section); 2076 if (!SegmentName.empty()) 2077 outs() << SegmentName << ","; 2078 StringRef SectionName = unwrapOrError(Section->getName(), FileName); 2079 outs() << SectionName; 2080 if (O->isXCOFF()) { 2081 Optional<SymbolRef> SymRef = getXCOFFSymbolContainingSymbolRef( 2082 dyn_cast<const XCOFFObjectFile>(O), Symbol); 2083 if (SymRef) { 2084 2085 Expected<StringRef> NameOrErr = SymRef.getValue().getName(); 2086 2087 if (NameOrErr) { 2088 outs() << " (csect:"; 2089 std::string SymName(NameOrErr.get()); 2090 2091 if (Demangle) 2092 SymName = demangle(SymName); 2093 2094 if (SymbolDescription) 2095 SymName = getXCOFFSymbolDescription( 2096 createSymbolInfo(O, SymRef.getValue()), SymName); 2097 2098 outs() << ' ' << SymName; 2099 outs() << ") "; 2100 } else 2101 reportWarning(toString(NameOrErr.takeError()), FileName); 2102 } 2103 } 2104 } 2105 2106 if (Common) 2107 outs() << '\t' << format(Fmt, static_cast<uint64_t>(Symbol.getAlignment())); 2108 else if (O->isXCOFF()) 2109 outs() << '\t' 2110 << format(Fmt, dyn_cast<const XCOFFObjectFile>(O)->getSymbolSize( 2111 Symbol.getRawDataRefImpl())); 2112 else if (O->isELF()) 2113 outs() << '\t' << format(Fmt, ELFSymbolRef(Symbol).getSize()); 2114 2115 if (O->isELF()) { 2116 if (!SymbolVersions.empty()) { 2117 const VersionEntry &Ver = 2118 SymbolVersions[Symbol.getRawDataRefImpl().d.b - 1]; 2119 std::string Str; 2120 if (!Ver.Name.empty()) 2121 Str = Ver.IsVerDef ? ' ' + Ver.Name : '(' + Ver.Name + ')'; 2122 outs() << ' ' << left_justify(Str, 12); 2123 } 2124 2125 uint8_t Other = ELFSymbolRef(Symbol).getOther(); 2126 switch (Other) { 2127 case ELF::STV_DEFAULT: 2128 break; 2129 case ELF::STV_INTERNAL: 2130 outs() << " .internal"; 2131 break; 2132 case ELF::STV_HIDDEN: 2133 outs() << " .hidden"; 2134 break; 2135 case ELF::STV_PROTECTED: 2136 outs() << " .protected"; 2137 break; 2138 default: 2139 outs() << format(" 0x%02x", Other); 2140 break; 2141 } 2142 } else if (Hidden) { 2143 outs() << " .hidden"; 2144 } 2145 2146 std::string SymName(Name); 2147 if (Demangle) 2148 SymName = demangle(SymName); 2149 2150 if (O->isXCOFF() && SymbolDescription) 2151 SymName = getXCOFFSymbolDescription(createSymbolInfo(O, Symbol), SymName); 2152 2153 outs() << ' ' << SymName << '\n'; 2154} 2155 2156static void printUnwindInfo(const ObjectFile *O) { 2157 outs() << "Unwind info:\n\n"; 2158 2159 if (const COFFObjectFile *Coff = dyn_cast<COFFObjectFile>(O)) 2160 printCOFFUnwindInfo(Coff); 2161 else if (const MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(O)) 2162 printMachOUnwindInfo(MachO); 2163 else 2164 // TODO: Extract DWARF dump tool to objdump. 2165 WithColor::error(errs(), ToolName) 2166 << "This operation is only currently supported " 2167 "for COFF and MachO object files.\n"; 2168} 2169 2170/// Dump the raw contents of the __clangast section so the output can be piped 2171/// into llvm-bcanalyzer. 2172static void printRawClangAST(const ObjectFile *Obj) { 2173 if (outs().is_displayed()) { 2174 WithColor::error(errs(), ToolName) 2175 << "The -raw-clang-ast option will dump the raw binary contents of " 2176 "the clang ast section.\n" 2177 "Please redirect the output to a file or another program such as " 2178 "llvm-bcanalyzer.\n"; 2179 return; 2180 } 2181 2182 StringRef ClangASTSectionName("__clangast"); 2183 if (Obj->isCOFF()) { 2184 ClangASTSectionName = "clangast"; 2185 } 2186 2187 Optional<object::SectionRef> ClangASTSection; 2188 for (auto Sec : ToolSectionFilter(*Obj)) { 2189 StringRef Name; 2190 if (Expected<StringRef> NameOrErr = Sec.getName()) 2191 Name = *NameOrErr; 2192 else 2193 consumeError(NameOrErr.takeError()); 2194 2195 if (Name == ClangASTSectionName) { 2196 ClangASTSection = Sec; 2197 break; 2198 } 2199 } 2200 if (!ClangASTSection) 2201 return; 2202 2203 StringRef ClangASTContents = unwrapOrError( 2204 ClangASTSection.getValue().getContents(), Obj->getFileName()); 2205 outs().write(ClangASTContents.data(), ClangASTContents.size()); 2206} 2207 2208static void printFaultMaps(const ObjectFile *Obj) { 2209 StringRef FaultMapSectionName; 2210 2211 if (Obj->isELF()) { 2212 FaultMapSectionName = ".llvm_faultmaps"; 2213 } else if (Obj->isMachO()) { 2214 FaultMapSectionName = "__llvm_faultmaps"; 2215 } else { 2216 WithColor::error(errs(), ToolName) 2217 << "This operation is only currently supported " 2218 "for ELF and Mach-O executable files.\n"; 2219 return; 2220 } 2221 2222 Optional<object::SectionRef> FaultMapSection; 2223 2224 for (auto Sec : ToolSectionFilter(*Obj)) { 2225 StringRef Name; 2226 if (Expected<StringRef> NameOrErr = Sec.getName()) 2227 Name = *NameOrErr; 2228 else 2229 consumeError(NameOrErr.takeError()); 2230 2231 if (Name == FaultMapSectionName) { 2232 FaultMapSection = Sec; 2233 break; 2234 } 2235 } 2236 2237 outs() << "FaultMap table:\n"; 2238 2239 if (!FaultMapSection.hasValue()) { 2240 outs() << "<not found>\n"; 2241 return; 2242 } 2243 2244 StringRef FaultMapContents = 2245 unwrapOrError(FaultMapSection.getValue().getContents(), Obj->getFileName()); 2246 FaultMapParser FMP(FaultMapContents.bytes_begin(), 2247 FaultMapContents.bytes_end()); 2248 2249 outs() << FMP; 2250} 2251 2252static void printPrivateFileHeaders(const ObjectFile *O, bool OnlyFirst) { 2253 if (O->isELF()) { 2254 printELFFileHeader(O); 2255 printELFDynamicSection(O); 2256 printELFSymbolVersionInfo(O); 2257 return; 2258 } 2259 if (O->isCOFF()) 2260 return printCOFFFileHeader(cast<object::COFFObjectFile>(*O)); 2261 if (O->isWasm()) 2262 return printWasmFileHeader(O); 2263 if (O->isMachO()) { 2264 printMachOFileHeader(O); 2265 if (!OnlyFirst) 2266 printMachOLoadCommands(O); 2267 return; 2268 } 2269 reportError(O->getFileName(), "Invalid/Unsupported object file format"); 2270} 2271 2272static void printFileHeaders(const ObjectFile *O) { 2273 if (!O->isELF() && !O->isCOFF()) 2274 reportError(O->getFileName(), "Invalid/Unsupported object file format"); 2275 2276 Triple::ArchType AT = O->getArch(); 2277 outs() << "architecture: " << Triple::getArchTypeName(AT) << "\n"; 2278 uint64_t Address = unwrapOrError(O->getStartAddress(), O->getFileName()); 2279 2280 StringRef Fmt = O->getBytesInAddress() > 4 ? "%016" PRIx64"l" "x" : "%08" PRIx64"l" "x"; 2281 outs() << "start address: " 2282 << "0x" << format(Fmt.data(), Address) << "\n"; 2283} 2284 2285static void printArchiveChild(StringRef Filename, const Archive::Child &C) { 2286 Expected<sys::fs::perms> ModeOrErr = C.getAccessMode(); 2287 if (!ModeOrErr) { 2288 WithColor::error(errs(), ToolName) << "ill-formed archive entry.\n"; 2289 consumeError(ModeOrErr.takeError()); 2290 return; 2291 } 2292 sys::fs::perms Mode = ModeOrErr.get(); 2293 outs() << ((Mode & sys::fs::owner_read) ? "r" : "-"); 2294 outs() << ((Mode & sys::fs::owner_write) ? "w" : "-"); 2295 outs() << ((Mode & sys::fs::owner_exe) ? "x" : "-"); 2296 outs() << ((Mode & sys::fs::group_read) ? "r" : "-"); 2297 outs() << ((Mode & sys::fs::group_write) ? "w" : "-"); 2298 outs() << ((Mode & sys::fs::group_exe) ? "x" : "-"); 2299 outs() << ((Mode & sys::fs::others_read) ? "r" : "-"); 2300 outs() << ((Mode & sys::fs::others_write) ? "w" : "-"); 2301 outs() << ((Mode & sys::fs::others_exe) ? "x" : "-"); 2302 2303 outs() << " "; 2304 2305 outs() << format("%d/%d %6" PRId64"l" "d" " ", unwrapOrError(C.getUID(), Filename), 2306 unwrapOrError(C.getGID(), Filename), 2307 unwrapOrError(C.getRawSize(), Filename)); 2308 2309 StringRef RawLastModified = C.getRawLastModified(); 2310 unsigned Seconds; 2311 if (RawLastModified.getAsInteger(10, Seconds)) 2312 outs() << "(date: \"" << RawLastModified 2313 << "\" contains non-decimal chars) "; 2314 else { 2315 // Since ctime(3) returns a 26 character string of the form: 2316 // "Sun Sep 16 01:03:52 1973\n\0" 2317 // just print 24 characters. 2318 time_t t = Seconds; 2319 outs() << format("%.24s ", ctime(&t)); 2320 } 2321 2322 StringRef Name = ""; 2323 Expected<StringRef> NameOrErr = C.getName(); 2324 if (!NameOrErr) { 2325 consumeError(NameOrErr.takeError()); 2326 Name = unwrapOrError(C.getRawName(), Filename); 2327 } else { 2328 Name = NameOrErr.get(); 2329 } 2330 outs() << Name << "\n"; 2331} 2332 2333// For ELF only now. 2334static bool shouldWarnForInvalidStartStopAddress(ObjectFile *Obj) { 2335 if (const auto *Elf = dyn_cast<ELFObjectFileBase>(Obj)) { 2336 if (Elf->getEType() != ELF::ET_REL) 2337 return true; 2338 } 2339 return false; 2340} 2341 2342static void checkForInvalidStartStopAddress(ObjectFile *Obj, 2343 uint64_t Start, uint64_t Stop) { 2344 if (!shouldWarnForInvalidStartStopAddress(Obj)) 2345 return; 2346 2347 for (const SectionRef &Section : Obj->sections()) 2348 if (ELFSectionRef(Section).getFlags() & ELF::SHF_ALLOC) { 2349 uint64_t BaseAddr = Section.getAddress(); 2350 uint64_t Size = Section.getSize(); 2351 if ((Start < BaseAddr + Size) && Stop > BaseAddr) 2352 return; 2353 } 2354 2355 if (!HasStartAddressFlag) 2356 reportWarning("no section has address less than 0x" + 2357 Twine::utohexstr(Stop) + " specified by --stop-address", 2358 Obj->getFileName()); 2359 else if (!HasStopAddressFlag) 2360 reportWarning("no section has address greater than or equal to 0x" + 2361 Twine::utohexstr(Start) + " specified by --start-address", 2362 Obj->getFileName()); 2363 else 2364 reportWarning("no section overlaps the range [0x" + 2365 Twine::utohexstr(Start) + ",0x" + Twine::utohexstr(Stop) + 2366 ") specified by --start-address/--stop-address", 2367 Obj->getFileName()); 2368} 2369 2370static void dumpObject(ObjectFile *O, const Archive *A = nullptr, 2371 const Archive::Child *C = nullptr) { 2372 // Avoid other output when using a raw option. 2373 if (!RawClangAST) { 2374 outs() << '\n'; 2375 if (A) 2376 outs() << A->getFileName() << "(" << O->getFileName() << ")"; 2377 else 2378 outs() << O->getFileName(); 2379 outs() << ":\tfile format " << O->getFileFormatName().lower() << "\n"; 2380 } 2381 2382 if (HasStartAddressFlag || HasStopAddressFlag) 2383 checkForInvalidStartStopAddress(O, StartAddress, StopAddress); 2384 2385 // Note: the order here matches GNU objdump for compatability. 2386 StringRef ArchiveName = A ? A->getFileName() : ""; 2387 if (ArchiveHeaders && !MachOOpt && C) 2388 printArchiveChild(ArchiveName, *C); 2389 if (FileHeaders) 2390 printFileHeaders(O); 2391 if (PrivateHeaders || FirstPrivateHeader) 2392 printPrivateFileHeaders(O, FirstPrivateHeader); 2393 if (SectionHeaders) 2394 printSectionHeaders(O); 2395 if (SymbolTable) 2396 printSymbolTable(O, ArchiveName); 2397 if (DynamicSymbolTable) 2398 printSymbolTable(O, ArchiveName, /*ArchitectureName=*/"", 2399 /*DumpDynamic=*/true); 2400 if (DwarfDumpType != DIDT_Null) { 2401 std::unique_ptr<DIContext> DICtx = DWARFContext::create(*O); 2402 // Dump the complete DWARF structure. 2403 DIDumpOptions DumpOpts; 2404 DumpOpts.DumpType = DwarfDumpType; 2405 DICtx->dump(outs(), DumpOpts); 2406 } 2407 if (Relocations && !Disassemble) 2408 printRelocations(O); 2409 if (DynamicRelocations) 2410 printDynamicRelocations(O); 2411 if (SectionContents) 2412 printSectionContents(O); 2413 if (Disassemble) 2414 disassembleObject(O, Relocations); 2415 if (UnwindInfo) 2416 printUnwindInfo(O); 2417 2418 // Mach-O specific options: 2419 if (ExportsTrie) 2420 printExportsTrie(O); 2421 if (Rebase) 2422 printRebaseTable(O); 2423 if (Bind) 2424 printBindTable(O); 2425 if (LazyBind) 2426 printLazyBindTable(O); 2427 if (WeakBind) 2428 printWeakBindTable(O); 2429 2430 // Other special sections: 2431 if (RawClangAST) 2432 printRawClangAST(O); 2433 if (FaultMapSection) 2434 printFaultMaps(O); 2435} 2436 2437static void dumpObject(const COFFImportFile *I, const Archive *A, 2438 const Archive::Child *C = nullptr) { 2439 StringRef ArchiveName = A ? A->getFileName() : ""; 2440 2441 // Avoid other output when using a raw option. 2442 if (!RawClangAST) 2443 outs() << '\n' 2444 << ArchiveName << "(" << I->getFileName() << ")" 2445 << ":\tfile format COFF-import-file" 2446 << "\n\n"; 2447 2448 if (ArchiveHeaders && !MachOOpt && C) 2449 printArchiveChild(ArchiveName, *C); 2450 if (SymbolTable) 2451 printCOFFSymbolTable(I); 2452} 2453 2454/// Dump each object file in \a a; 2455static void dumpArchive(const Archive *A) { 2456 Error Err = Error::success(); 2457 unsigned I = -1; 2458 for (auto &C : A->children(Err)) { 2459 ++I; 2460 Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary(); 2461 if (!ChildOrErr) { 2462 if (auto E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError())) 2463 reportError(std::move(E), getFileNameForError(C, I), A->getFileName()); 2464 continue; 2465 } 2466 if (ObjectFile *O = dyn_cast<ObjectFile>(&*ChildOrErr.get())) 2467 dumpObject(O, A, &C); 2468 else if (COFFImportFile *I = dyn_cast<COFFImportFile>(&*ChildOrErr.get())) 2469 dumpObject(I, A, &C); 2470 else 2471 reportError(errorCodeToError(object_error::invalid_file_type), 2472 A->getFileName()); 2473 } 2474 if (Err) 2475 reportError(std::move(Err), A->getFileName()); 2476} 2477 2478/// Open file and figure out how to dump it. 2479static void dumpInput(StringRef file) { 2480 // If we are using the Mach-O specific object file parser, then let it parse 2481 // the file and process the command line options. So the -arch flags can 2482 // be used to select specific slices, etc. 2483 if (MachOOpt) { 2484 parseInputMachO(file); 2485 return; 2486 } 2487 2488 // Attempt to open the binary. 2489 OwningBinary<Binary> OBinary = unwrapOrError(createBinary(file), file); 2490 Binary &Binary = *OBinary.getBinary(); 2491 2492 if (Archive *A = dyn_cast<Archive>(&Binary)) 2493 dumpArchive(A); 2494 else if (ObjectFile *O = dyn_cast<ObjectFile>(&Binary)) 2495 dumpObject(O); 2496 else if (MachOUniversalBinary *UB = dyn_cast<MachOUniversalBinary>(&Binary)) 2497 parseInputMachO(UB); 2498 else 2499 reportError(errorCodeToError(object_error::invalid_file_type), file); 2500} 2501 2502template <typename T> 2503static void parseIntArg(const llvm::opt::InputArgList &InputArgs, int ID, 2504 T &Value) { 2505 if (const opt::Arg *A = InputArgs.getLastArg(ID)) { 2506 StringRef V(A->getValue()); 2507 if (!llvm::to_integer(V, Value, 0)) { 2508 reportCmdLineError(A->getSpelling() + 2509 ": expected a non-negative integer, but got '" + V + 2510 "'"); 2511 } 2512 } 2513} 2514 2515static void invalidArgValue(const opt::Arg *A) { 2516 reportCmdLineError("'" + StringRef(A->getValue()) + 2517 "' is not a valid value for '" + A->getSpelling() + "'"); 2518} 2519 2520static std::vector<std::string> 2521commaSeparatedValues(const llvm::opt::InputArgList &InputArgs, int ID) { 2522 std::vector<std::string> Values; 2523 for (StringRef Value : InputArgs.getAllArgValues(ID)) { 2524 llvm::SmallVector<StringRef, 2> SplitValues; 2525 llvm::SplitString(Value, SplitValues, ","); 2526 for (StringRef SplitValue : SplitValues) 2527 Values.push_back(SplitValue.str()); 2528 } 2529 return Values; 2530} 2531 2532static void parseOtoolOptions(const llvm::opt::InputArgList &InputArgs) { 2533 MachOOpt = true; 2534 FullLeadingAddr = true; 2535 PrintImmHex = true; 2536 2537 ArchName = InputArgs.getLastArgValue(OTOOL_arch).str(); 2538 LinkOptHints = InputArgs.hasArg(OTOOL_C); 2539 if (InputArgs.hasArg(OTOOL_d)) 2540 FilterSections.push_back("__DATA,__data"); 2541 DylibId = InputArgs.hasArg(OTOOL_D); 2542 UniversalHeaders = InputArgs.hasArg(OTOOL_f); 2543 DataInCode = InputArgs.hasArg(OTOOL_G); 2544 FirstPrivateHeader = InputArgs.hasArg(OTOOL_h); 2545 IndirectSymbols = InputArgs.hasArg(OTOOL_I); 2546 ShowRawInsn = InputArgs.hasArg(OTOOL_j); 2547 PrivateHeaders = InputArgs.hasArg(OTOOL_l); 2548 DylibsUsed = InputArgs.hasArg(OTOOL_L); 2549 MCPU = InputArgs.getLastArgValue(OTOOL_mcpu_EQ).str(); 2550 ObjcMetaData = InputArgs.hasArg(OTOOL_o); 2551 DisSymName = InputArgs.getLastArgValue(OTOOL_p).str(); 2552 InfoPlist = InputArgs.hasArg(OTOOL_P); 2553 Relocations = InputArgs.hasArg(OTOOL_r); 2554 if (const Arg *A = InputArgs.getLastArg(OTOOL_s)) { 2555 auto Filter = (A->getValue(0) + StringRef(",") + A->getValue(1)).str(); 2556 FilterSections.push_back(Filter); 2557 } 2558 if (InputArgs.hasArg(OTOOL_t)) 2559 FilterSections.push_back("__TEXT,__text"); 2560 Verbose = InputArgs.hasArg(OTOOL_v) || InputArgs.hasArg(OTOOL_V) || 2561 InputArgs.hasArg(OTOOL_o); 2562 SymbolicOperands = InputArgs.hasArg(OTOOL_V); 2563 if (InputArgs.hasArg(OTOOL_x)) 2564 FilterSections.push_back(",__text"); 2565 LeadingAddr = LeadingHeaders = !InputArgs.hasArg(OTOOL_X); 2566 2567 InputFilenames = InputArgs.getAllArgValues(OTOOL_INPUT); 2568 if (InputFilenames.empty()) 2569 reportCmdLineError("no input file"); 2570 2571 for (const Arg *A : InputArgs) { 2572 const Option &O = A->getOption(); 2573 if (O.getGroup().isValid() && O.getGroup().getID() == OTOOL_grp_obsolete) { 2574 reportCmdLineWarning(O.getPrefixedName() + 2575 " is obsolete and not implemented"); 2576 } 2577 } 2578} 2579 2580static void parseObjdumpOptions(const llvm::opt::InputArgList &InputArgs) { 2581 parseIntArg(InputArgs, OBJDUMP_adjust_vma_EQ, AdjustVMA); 2582 AllHeaders = InputArgs.hasArg(OBJDUMP_all_headers); 2583 ArchName = InputArgs.getLastArgValue(OBJDUMP_arch_name_EQ).str(); 2584 ArchiveHeaders = InputArgs.hasArg(OBJDUMP_archive_headers); 2585 Demangle = InputArgs.hasArg(OBJDUMP_demangle); 2586 Disassemble = InputArgs.hasArg(OBJDUMP_disassemble); 2587 DisassembleAll = InputArgs.hasArg(OBJDUMP_disassemble_all); 2588 SymbolDescription = InputArgs.hasArg(OBJDUMP_symbol_description); 2589 DisassembleSymbols = 2590 commaSeparatedValues(InputArgs, OBJDUMP_disassemble_symbols_EQ); 2591 DisassembleZeroes = InputArgs.hasArg(OBJDUMP_disassemble_zeroes); 2592 if (const opt::Arg *A = InputArgs.getLastArg(OBJDUMP_dwarf_EQ)) { 2593 DwarfDumpType = StringSwitch<DIDumpType>(A->getValue()) 2594 .Case("frames", DIDT_DebugFrame) 2595 .Default(DIDT_Null); 2596 if (DwarfDumpType == DIDT_Null) 2597 invalidArgValue(A); 2598 } 2599 DynamicRelocations = InputArgs.hasArg(OBJDUMP_dynamic_reloc); 2600 FaultMapSection = InputArgs.hasArg(OBJDUMP_fault_map_section); 2601 FileHeaders = InputArgs.hasArg(OBJDUMP_file_headers); 2602 SectionContents = InputArgs.hasArg(OBJDUMP_full_contents); 2603 PrintLines = InputArgs.hasArg(OBJDUMP_line_numbers); 2604 InputFilenames = InputArgs.getAllArgValues(OBJDUMP_INPUT); 2605 MachOOpt = InputArgs.hasArg(OBJDUMP_macho); 2606 MCPU = InputArgs.getLastArgValue(OBJDUMP_mcpu_EQ).str(); 2607 MAttrs = commaSeparatedValues(InputArgs, OBJDUMP_mattr_EQ); 2608 ShowRawInsn = !InputArgs.hasArg(OBJDUMP_no_show_raw_insn); 2609 LeadingAddr = !InputArgs.hasArg(OBJDUMP_no_leading_addr); 2610 RawClangAST = InputArgs.hasArg(OBJDUMP_raw_clang_ast); 2611 Relocations = InputArgs.hasArg(OBJDUMP_reloc); 2612 PrintImmHex = 2613 InputArgs.hasFlag(OBJDUMP_print_imm_hex, OBJDUMP_no_print_imm_hex, false); 2614 PrivateHeaders = InputArgs.hasArg(OBJDUMP_private_headers); 2615 FilterSections = InputArgs.getAllArgValues(OBJDUMP_section_EQ); 2616 SectionHeaders = InputArgs.hasArg(OBJDUMP_section_headers); 2617 ShowLMA = InputArgs.hasArg(OBJDUMP_show_lma); 2618 PrintSource = InputArgs.hasArg(OBJDUMP_source); 2619 parseIntArg(InputArgs, OBJDUMP_start_address_EQ, StartAddress); 2620 HasStartAddressFlag = InputArgs.hasArg(OBJDUMP_start_address_EQ); 2621 parseIntArg(InputArgs, OBJDUMP_stop_address_EQ, StopAddress); 2622 HasStopAddressFlag = InputArgs.hasArg(OBJDUMP_stop_address_EQ); 2623 SymbolTable = InputArgs.hasArg(OBJDUMP_syms); 2624 SymbolizeOperands = InputArgs.hasArg(OBJDUMP_symbolize_operands); 2625 DynamicSymbolTable = InputArgs.hasArg(OBJDUMP_dynamic_syms); 2626 TripleName = InputArgs.getLastArgValue(OBJDUMP_triple_EQ).str(); 2627 UnwindInfo = InputArgs.hasArg(OBJDUMP_unwind_info); 2628 Wide = InputArgs.hasArg(OBJDUMP_wide); 2629 Prefix = InputArgs.getLastArgValue(OBJDUMP_prefix).str(); 2630 parseIntArg(InputArgs, OBJDUMP_prefix_strip, PrefixStrip); 2631 if (const opt::Arg *A = InputArgs.getLastArg(OBJDUMP_debug_vars_EQ)) { 2632 DbgVariables = StringSwitch<DebugVarsFormat>(A->getValue()) 2633 .Case("ascii", DVASCII) 2634 .Case("unicode", DVUnicode) 2635 .Default(DVInvalid); 2636 if (DbgVariables == DVInvalid) 2637 invalidArgValue(A); 2638 } 2639 parseIntArg(InputArgs, OBJDUMP_debug_vars_indent_EQ, DbgIndent); 2640 2641 parseMachOOptions(InputArgs); 2642 2643 // Parse -M (--disassembler-options) and deprecated 2644 // --x86-asm-syntax={att,intel}. 2645 // 2646 // Note, for x86, the asm dialect (AssemblerDialect) is initialized when the 2647 // MCAsmInfo is constructed. MCInstPrinter::applyTargetSpecificCLOption is 2648 // called too late. For now we have to use the internal cl::opt option. 2649 const char *AsmSyntax = nullptr; 2650 for (const auto *A : InputArgs.filtered(OBJDUMP_disassembler_options_EQ, 2651 OBJDUMP_x86_asm_syntax_att, 2652 OBJDUMP_x86_asm_syntax_intel)) { 2653 switch (A->getOption().getID()) { 2654 case OBJDUMP_x86_asm_syntax_att: 2655 AsmSyntax = "--x86-asm-syntax=att"; 2656 continue; 2657 case OBJDUMP_x86_asm_syntax_intel: 2658 AsmSyntax = "--x86-asm-syntax=intel"; 2659 continue; 2660 } 2661 2662 SmallVector<StringRef, 2> Values; 2663 llvm::SplitString(A->getValue(), Values, ","); 2664 for (StringRef V : Values) { 2665 if (V == "att") 2666 AsmSyntax = "--x86-asm-syntax=att"; 2667 else if (V == "intel") 2668 AsmSyntax = "--x86-asm-syntax=intel"; 2669 else 2670 DisassemblerOptions.push_back(V.str()); 2671 } 2672 } 2673 if (AsmSyntax) { 2674 const char *Argv[] = {"llvm-objdump", AsmSyntax}; 2675 llvm::cl::ParseCommandLineOptions(2, Argv); 2676 } 2677 2678 // objdump defaults to a.out if no filenames specified. 2679 if (InputFilenames.empty()) 2680 InputFilenames.push_back("a.out"); 2681} 2682 2683int main(int argc, char **argv) { 2684 using namespace llvm; 2685 InitLLVM X(argc, argv); 2686 2687 ToolName = argv[0]; 2688 std::unique_ptr<CommonOptTable> T; 2689 OptSpecifier Unknown, HelpFlag, HelpHiddenFlag, VersionFlag; 2690 2691 StringRef Stem = sys::path::stem(ToolName); 2692 auto Is = [=](StringRef Tool) { 2693 // We need to recognize the following filenames: 2694 // 2695 // llvm-objdump -> objdump 2696 // llvm-otool-10.exe -> otool 2697 // powerpc64-unknown-freebsd13-objdump -> objdump 2698 auto I = Stem.rfind_insensitive(Tool); 2699 return I != StringRef::npos && 2700 (I + Tool.size() == Stem.size() || !isAlnum(Stem[I + Tool.size()])); 2701 }; 2702 if (Is("otool")) { 2703 T = std::make_unique<OtoolOptTable>(); 2704 Unknown = OTOOL_UNKNOWN; 2705 HelpFlag = OTOOL_help; 2706 HelpHiddenFlag = OTOOL_help_hidden; 2707 VersionFlag = OTOOL_version; 2708 } else { 2709 T = std::make_unique<ObjdumpOptTable>(); 2710 Unknown = OBJDUMP_UNKNOWN; 2711 HelpFlag = OBJDUMP_help; 2712 HelpHiddenFlag = OBJDUMP_help_hidden; 2713 VersionFlag = OBJDUMP_version; 2714 } 2715 2716 BumpPtrAllocator A; 2717 StringSaver Saver(A); 2718 opt::InputArgList InputArgs = 2719 T->parseArgs(argc, argv, Unknown, Saver, 2720 [&](StringRef Msg) { reportCmdLineError(Msg); }); 2721 2722 if (InputArgs.size() == 0 || InputArgs.hasArg(HelpFlag)) { 2723 T->printHelp(ToolName); 2724 return 0; 2725 } 2726 if (InputArgs.hasArg(HelpHiddenFlag)) { 2727 T->printHelp(ToolName, /*ShowHidden=*/true); 2728 return 0; 2729 } 2730 2731 // Initialize targets and assembly printers/parsers. 2732 InitializeAllTargetInfos(); 2733 InitializeAllTargetMCs(); 2734 InitializeAllDisassemblers(); 2735 2736 if (InputArgs.hasArg(VersionFlag)) { 2737 cl::PrintVersionMessage(); 2738 if (!Is("otool")) { 2739 outs() << '\n'; 2740 TargetRegistry::printRegisteredTargetsForVersion(outs()); 2741 } 2742 return 0; 2743 } 2744 2745 if (Is("otool")) 2746 parseOtoolOptions(InputArgs); 2747 else 2748 parseObjdumpOptions(InputArgs); 2749 2750 if (StartAddress >= StopAddress) 2751 reportCmdLineError("start address should be less than stop address"); 2752 2753 // Removes trailing separators from prefix. 2754 while (!Prefix.empty() && sys::path::is_separator(Prefix.back())) 2755 Prefix.pop_back(); 2756 2757 if (AllHeaders) 2758 ArchiveHeaders = FileHeaders = PrivateHeaders = Relocations = 2759 SectionHeaders = SymbolTable = true; 2760 2761 if (DisassembleAll || PrintSource || PrintLines || 2762 !DisassembleSymbols.empty()) 2763 Disassemble = true; 2764 2765 if (!ArchiveHeaders && !Disassemble && DwarfDumpType == DIDT_Null && 2766 !DynamicRelocations && !FileHeaders && !PrivateHeaders && !RawClangAST && 2767 !Relocations && !SectionHeaders && !SectionContents && !SymbolTable && 2768 !DynamicSymbolTable && !UnwindInfo && !FaultMapSection && 2769 !(MachOOpt && (Bind || DataInCode || DyldInfo || DylibId || DylibsUsed || 2770 ExportsTrie || FirstPrivateHeader || FunctionStarts || 2771 IndirectSymbols || InfoPlist || LazyBind || LinkOptHints || 2772 ObjcMetaData || Rebase || Rpaths || UniversalHeaders || 2773 WeakBind || !FilterSections.empty()))) { 2774 T->printHelp(ToolName); 2775 return 2; 2776 } 2777 2778 DisasmSymbolSet.insert(DisassembleSymbols.begin(), DisassembleSymbols.end()); 2779 2780 llvm::for_each(InputFilenames, dumpInput); 2781 2782 warnOnNoMatchForSections(); 2783 2784 return EXIT_SUCCESS0; 2785}