/build/source/llvm/include/llvm/Object/ObjectFile.h

Bug Summary

File:	build/source/llvm/include/llvm/Object/ObjectFile.h
Warning:	line 481, column 7 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 MachODumper.cpp -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/source/build-llvm/tools/clang/stage2-bins -resource-dir /usr/lib/llvm-17/lib/clang/17 -D _DEBUG -D _GLIBCXX_ASSERTIONS -D _GNU_SOURCE -D _LIBCPP_ENABLE_ASSERTIONS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I tools/llvm-readobj -I /build/source/llvm/tools/llvm-readobj -I include -I /build/source/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-17/lib/clang/17/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/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fmacro-prefix-map=/build/source/= -fcoverage-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fcoverage-prefix-map=/build/source/= -source-date-epoch 1683717183 -O2 -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 -Wno-misleading-indentation -std=c++17 -fdeprecated-macro -fdebug-compilation-dir=/build/source/build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/source/= -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-2023-05-10-133810-16478-1 -x c++ /build/source/llvm/tools/llvm-readobj/MachODumper.cpp

/build/source/llvm/tools/llvm-readobj/MachODumper.cpp

→

1//===- MachODumper.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 file implements the MachO-specific dumper for llvm-readobj.
10//
11//===----------------------------------------------------------------------===//

13#include "ObjDumper.h"
14#include "StackMapPrinter.h"
15#include "llvm-readobj.h"
16#include "llvm/ADT/SmallString.h"
17#include "llvm/ADT/StringExtras.h"
18#include "llvm/Object/MachO.h"
19#include "llvm/Support/BinaryStreamReader.h"
20#include "llvm/Support/Casting.h"
21#include "llvm/Support/ScopedPrinter.h"

23using namespace llvm;
24using namespace object;

26namespace {

28class MachODumper : public ObjDumper {
29public:
MachODumper(const MachOObjectFile *Obj, ScopedPrinter &Writer)
    : ObjDumper(Writer, Obj->getFileName()), Obj(Obj) {}

void printFileHeaders() override;
void printSectionHeaders() override;
void printRelocations() override;
void printUnwindInfo() override;
void printStackMap() const override;
void printCGProfile() override;

void printNeededLibraries() override;

bool canCompareSymbols() const override { return true; }
bool compareSymbolsByName(object::SymbolRef LHS,
                          object::SymbolRef RHS) const override;
bool compareSymbolsByType(object::SymbolRef LHS,
                          object::SymbolRef RHS) const override;
// MachO-specific.
void printMachODataInCode() override;
void printMachOVersionMin() override;
void printMachODysymtab() override;
void printMachOSegment() override;
void printMachOIndirectSymbols() override;
void printMachOLinkerOptions () override;

55private:
template<class MachHeader>
void printFileHeaders(const MachHeader &Header);

StringRef getSymbolName(const SymbolRef &Symbol) const;
uint8_t getSymbolType(const SymbolRef &Symbol) const;

void printSymbols() override;
void printSymbols(std::optional<SymbolComparator> SymComp) override;
void printDynamicSymbols() override;
void printDynamicSymbols(std::optional<SymbolComparator> SymComp) override;
void printSymbol(const SymbolRef &Symbol, ScopedPrinter &W);
void printSymbol(const SymbolRef &Symbol);

void printRelocation(const RelocationRef &Reloc);

void printRelocation(const MachOObjectFile *Obj, const RelocationRef &Reloc);

void printSectionHeaders(const MachOObjectFile *Obj);

const MachOObjectFile *Obj;
76};

78} // namespace


81namespace llvm {

83std::unique_ptr<ObjDumper> createMachODumper(const object::MachOObjectFile &Obj,
                                           ScopedPrinter &Writer) {
return std::make_unique<MachODumper>(&Obj, Writer);
86}

88} // namespace llvm

90const EnumEntry<uint32_t> MachOMagics[] = {
{ "Magic",      MachO::MH_MAGIC    },
{ "Cigam",      MachO::MH_CIGAM    },
{ "Magic64",    MachO::MH_MAGIC_64 },
{ "Cigam64",    MachO::MH_CIGAM_64 },
{ "FatMagic",   MachO::FAT_MAGIC   },
{ "FatCigam",   MachO::FAT_CIGAM   },
97};

99const EnumEntry<uint32_t> MachOHeaderFileTypes[] = {
{ "Relocatable",          MachO::MH_OBJECT      },
{ "Executable",           MachO::MH_EXECUTE     },
{ "FixedVMLibrary",       MachO::MH_FVMLIB      },
{ "Core",                 MachO::MH_CORE        },
{ "PreloadedExecutable",  MachO::MH_PRELOAD     },
{ "DynamicLibrary",       MachO::MH_DYLIB       },
{ "DynamicLinker",        MachO::MH_DYLINKER    },
{ "Bundle",               MachO::MH_BUNDLE      },
{ "DynamicLibraryStub",   MachO::MH_DYLIB_STUB  },
{ "DWARFSymbol",          MachO::MH_DSYM        },
{ "KextBundle",           MachO::MH_KEXT_BUNDLE },
111};

113const EnumEntry<uint32_t> MachOHeaderCpuTypes[] = {
{ "Any"       , static_cast<uint32_t>(MachO::CPU_TYPE_ANY) },
{ "X86"       , MachO::CPU_TYPE_X86       },
{ "X86-64"    , MachO::CPU_TYPE_X86_64    },
{ "Mc98000"   , MachO::CPU_TYPE_MC98000   },
{ "Arm"       , MachO::CPU_TYPE_ARM       },
{ "Arm64"     , MachO::CPU_TYPE_ARM64     },
{ "Sparc"     , MachO::CPU_TYPE_SPARC     },
{ "PowerPC"   , MachO::CPU_TYPE_POWERPC   },
{ "PowerPC64" , MachO::CPU_TYPE_POWERPC64 },
123};

125const EnumEntry<uint32_t> MachOHeaderCpuSubtypesX86[] = {
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_I386_ALL){ "CPU_SUBTYPE_I386_ALL", MachO::CPU_SUBTYPE_I386_ALL },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_386){ "CPU_SUBTYPE_386", MachO::CPU_SUBTYPE_386 },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_486){ "CPU_SUBTYPE_486", MachO::CPU_SUBTYPE_486 },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_486SX){ "CPU_SUBTYPE_486SX", MachO::CPU_SUBTYPE_486SX },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_586){ "CPU_SUBTYPE_586", MachO::CPU_SUBTYPE_586 },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_PENTPRO){ "CPU_SUBTYPE_PENTPRO", MachO::CPU_SUBTYPE_PENTPRO },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_PENTII_M3){ "CPU_SUBTYPE_PENTII_M3", MachO::CPU_SUBTYPE_PENTII_M3 },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_PENTII_M5){ "CPU_SUBTYPE_PENTII_M5", MachO::CPU_SUBTYPE_PENTII_M5 },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_CELERON){ "CPU_SUBTYPE_CELERON", MachO::CPU_SUBTYPE_CELERON },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_CELERON_MOBILE){ "CPU_SUBTYPE_CELERON_MOBILE", MachO::CPU_SUBTYPE_CELERON_MOBILE
 },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_PENTIUM_3){ "CPU_SUBTYPE_PENTIUM_3", MachO::CPU_SUBTYPE_PENTIUM_3 },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_PENTIUM_3_M){ "CPU_SUBTYPE_PENTIUM_3_M", MachO::CPU_SUBTYPE_PENTIUM_3_M },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_PENTIUM_3_XEON){ "CPU_SUBTYPE_PENTIUM_3_XEON", MachO::CPU_SUBTYPE_PENTIUM_3_XEON
 },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_PENTIUM_M){ "CPU_SUBTYPE_PENTIUM_M", MachO::CPU_SUBTYPE_PENTIUM_M },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_PENTIUM_4){ "CPU_SUBTYPE_PENTIUM_4", MachO::CPU_SUBTYPE_PENTIUM_4 },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_PENTIUM_4_M){ "CPU_SUBTYPE_PENTIUM_4_M", MachO::CPU_SUBTYPE_PENTIUM_4_M },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ITANIUM){ "CPU_SUBTYPE_ITANIUM", MachO::CPU_SUBTYPE_ITANIUM },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ITANIUM_2){ "CPU_SUBTYPE_ITANIUM_2", MachO::CPU_SUBTYPE_ITANIUM_2 },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_XEON){ "CPU_SUBTYPE_XEON", MachO::CPU_SUBTYPE_XEON },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_XEON_MP){ "CPU_SUBTYPE_XEON_MP", MachO::CPU_SUBTYPE_XEON_MP },
146};

148const EnumEntry<uint32_t> MachOHeaderCpuSubtypesX64[] = {
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_X86_64_ALL){ "CPU_SUBTYPE_X86_64_ALL", MachO::CPU_SUBTYPE_X86_64_ALL },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_X86_ARCH1){ "CPU_SUBTYPE_X86_ARCH1", MachO::CPU_SUBTYPE_X86_ARCH1 },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_X86_64_H){ "CPU_SUBTYPE_X86_64_H", MachO::CPU_SUBTYPE_X86_64_H },
152};

154const EnumEntry<uint32_t> MachOHeaderCpuSubtypesARM[] = {
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_ALL){ "CPU_SUBTYPE_ARM_ALL", MachO::CPU_SUBTYPE_ARM_ALL },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V4T){ "CPU_SUBTYPE_ARM_V4T", MachO::CPU_SUBTYPE_ARM_V4T },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V6){ "CPU_SUBTYPE_ARM_V6", MachO::CPU_SUBTYPE_ARM_V6 },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V5){ "CPU_SUBTYPE_ARM_V5", MachO::CPU_SUBTYPE_ARM_V5 },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V5TEJ){ "CPU_SUBTYPE_ARM_V5TEJ", MachO::CPU_SUBTYPE_ARM_V5TEJ },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_XSCALE){ "CPU_SUBTYPE_ARM_XSCALE", MachO::CPU_SUBTYPE_ARM_XSCALE },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V7){ "CPU_SUBTYPE_ARM_V7", MachO::CPU_SUBTYPE_ARM_V7 },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V7S){ "CPU_SUBTYPE_ARM_V7S", MachO::CPU_SUBTYPE_ARM_V7S },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V7K){ "CPU_SUBTYPE_ARM_V7K", MachO::CPU_SUBTYPE_ARM_V7K },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V6M){ "CPU_SUBTYPE_ARM_V6M", MachO::CPU_SUBTYPE_ARM_V6M },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V7M){ "CPU_SUBTYPE_ARM_V7M", MachO::CPU_SUBTYPE_ARM_V7M },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM_V7EM){ "CPU_SUBTYPE_ARM_V7EM", MachO::CPU_SUBTYPE_ARM_V7EM },
167};

169const EnumEntry<uint32_t> MachOHeaderCpuSubtypesARM64[] = {
  LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM64_ALL){ "CPU_SUBTYPE_ARM64_ALL", MachO::CPU_SUBTYPE_ARM64_ALL },
  LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM64_V8){ "CPU_SUBTYPE_ARM64_V8", MachO::CPU_SUBTYPE_ARM64_V8 },
  LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_ARM64E){ "CPU_SUBTYPE_ARM64E", MachO::CPU_SUBTYPE_ARM64E },
173};

175const EnumEntry<uint32_t> MachOHeaderCpuSubtypesSPARC[] = {
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_SPARC_ALL){ "CPU_SUBTYPE_SPARC_ALL", MachO::CPU_SUBTYPE_SPARC_ALL },
177};

179const EnumEntry<uint32_t> MachOHeaderCpuSubtypesPPC[] = {
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_ALL){ "CPU_SUBTYPE_POWERPC_ALL", MachO::CPU_SUBTYPE_POWERPC_ALL },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_601){ "CPU_SUBTYPE_POWERPC_601", MachO::CPU_SUBTYPE_POWERPC_601 },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_602){ "CPU_SUBTYPE_POWERPC_602", MachO::CPU_SUBTYPE_POWERPC_602 },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_603){ "CPU_SUBTYPE_POWERPC_603", MachO::CPU_SUBTYPE_POWERPC_603 },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_603e){ "CPU_SUBTYPE_POWERPC_603e", MachO::CPU_SUBTYPE_POWERPC_603e
 },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_603ev){ "CPU_SUBTYPE_POWERPC_603ev", MachO::CPU_SUBTYPE_POWERPC_603ev
 },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_604){ "CPU_SUBTYPE_POWERPC_604", MachO::CPU_SUBTYPE_POWERPC_604 },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_604e){ "CPU_SUBTYPE_POWERPC_604e", MachO::CPU_SUBTYPE_POWERPC_604e
 },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_620){ "CPU_SUBTYPE_POWERPC_620", MachO::CPU_SUBTYPE_POWERPC_620 },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_750){ "CPU_SUBTYPE_POWERPC_750", MachO::CPU_SUBTYPE_POWERPC_750 },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_7400){ "CPU_SUBTYPE_POWERPC_7400", MachO::CPU_SUBTYPE_POWERPC_7400
 },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_7450){ "CPU_SUBTYPE_POWERPC_7450", MachO::CPU_SUBTYPE_POWERPC_7450
 },
LLVM_READOBJ_ENUM_ENT(MachO, CPU_SUBTYPE_POWERPC_970){ "CPU_SUBTYPE_POWERPC_970", MachO::CPU_SUBTYPE_POWERPC_970 },
193};

195const EnumEntry<uint32_t> MachOHeaderFlags[] = {
LLVM_READOBJ_ENUM_ENT(MachO, MH_NOUNDEFS){ "MH_NOUNDEFS", MachO::MH_NOUNDEFS },
LLVM_READOBJ_ENUM_ENT(MachO, MH_INCRLINK){ "MH_INCRLINK", MachO::MH_INCRLINK },
LLVM_READOBJ_ENUM_ENT(MachO, MH_DYLDLINK){ "MH_DYLDLINK", MachO::MH_DYLDLINK },
LLVM_READOBJ_ENUM_ENT(MachO, MH_BINDATLOAD){ "MH_BINDATLOAD", MachO::MH_BINDATLOAD },
LLVM_READOBJ_ENUM_ENT(MachO, MH_PREBOUND){ "MH_PREBOUND", MachO::MH_PREBOUND },
LLVM_READOBJ_ENUM_ENT(MachO, MH_SPLIT_SEGS){ "MH_SPLIT_SEGS", MachO::MH_SPLIT_SEGS },
LLVM_READOBJ_ENUM_ENT(MachO, MH_LAZY_INIT){ "MH_LAZY_INIT", MachO::MH_LAZY_INIT },
LLVM_READOBJ_ENUM_ENT(MachO, MH_TWOLEVEL){ "MH_TWOLEVEL", MachO::MH_TWOLEVEL },
LLVM_READOBJ_ENUM_ENT(MachO, MH_FORCE_FLAT){ "MH_FORCE_FLAT", MachO::MH_FORCE_FLAT },
LLVM_READOBJ_ENUM_ENT(MachO, MH_NOMULTIDEFS){ "MH_NOMULTIDEFS", MachO::MH_NOMULTIDEFS },
LLVM_READOBJ_ENUM_ENT(MachO, MH_NOFIXPREBINDING){ "MH_NOFIXPREBINDING", MachO::MH_NOFIXPREBINDING },
LLVM_READOBJ_ENUM_ENT(MachO, MH_PREBINDABLE){ "MH_PREBINDABLE", MachO::MH_PREBINDABLE },
LLVM_READOBJ_ENUM_ENT(MachO, MH_ALLMODSBOUND){ "MH_ALLMODSBOUND", MachO::MH_ALLMODSBOUND },
LLVM_READOBJ_ENUM_ENT(MachO, MH_SUBSECTIONS_VIA_SYMBOLS){ "MH_SUBSECTIONS_VIA_SYMBOLS", MachO::MH_SUBSECTIONS_VIA_SYMBOLS
 },
LLVM_READOBJ_ENUM_ENT(MachO, MH_CANONICAL){ "MH_CANONICAL", MachO::MH_CANONICAL },
LLVM_READOBJ_ENUM_ENT(MachO, MH_WEAK_DEFINES){ "MH_WEAK_DEFINES", MachO::MH_WEAK_DEFINES },
LLVM_READOBJ_ENUM_ENT(MachO, MH_BINDS_TO_WEAK){ "MH_BINDS_TO_WEAK", MachO::MH_BINDS_TO_WEAK },
LLVM_READOBJ_ENUM_ENT(MachO, MH_ALLOW_STACK_EXECUTION){ "MH_ALLOW_STACK_EXECUTION", MachO::MH_ALLOW_STACK_EXECUTION
 },
LLVM_READOBJ_ENUM_ENT(MachO, MH_ROOT_SAFE){ "MH_ROOT_SAFE", MachO::MH_ROOT_SAFE },
LLVM_READOBJ_ENUM_ENT(MachO, MH_SETUID_SAFE){ "MH_SETUID_SAFE", MachO::MH_SETUID_SAFE },
LLVM_READOBJ_ENUM_ENT(MachO, MH_NO_REEXPORTED_DYLIBS){ "MH_NO_REEXPORTED_DYLIBS", MachO::MH_NO_REEXPORTED_DYLIBS },
LLVM_READOBJ_ENUM_ENT(MachO, MH_PIE){ "MH_PIE", MachO::MH_PIE },
LLVM_READOBJ_ENUM_ENT(MachO, MH_DEAD_STRIPPABLE_DYLIB){ "MH_DEAD_STRIPPABLE_DYLIB", MachO::MH_DEAD_STRIPPABLE_DYLIB
 },
LLVM_READOBJ_ENUM_ENT(MachO, MH_HAS_TLV_DESCRIPTORS){ "MH_HAS_TLV_DESCRIPTORS", MachO::MH_HAS_TLV_DESCRIPTORS },
LLVM_READOBJ_ENUM_ENT(MachO, MH_NO_HEAP_EXECUTION){ "MH_NO_HEAP_EXECUTION", MachO::MH_NO_HEAP_EXECUTION },
LLVM_READOBJ_ENUM_ENT(MachO, MH_APP_EXTENSION_SAFE){ "MH_APP_EXTENSION_SAFE", MachO::MH_APP_EXTENSION_SAFE },
222};

224const EnumEntry<unsigned> MachOSectionTypes[] = {
{ "Regular"                        , MachO::S_REGULAR },
{ "ZeroFill"                       , MachO::S_ZEROFILL },
{ "CStringLiterals"                , MachO::S_CSTRING_LITERALS },
{ "4ByteLiterals"                  , MachO::S_4BYTE_LITERALS },
{ "8ByteLiterals"                  , MachO::S_8BYTE_LITERALS },
{ "LiteralPointers"                , MachO::S_LITERAL_POINTERS },
{ "NonLazySymbolPointers"          , MachO::S_NON_LAZY_SYMBOL_POINTERS },
{ "LazySymbolPointers"             , MachO::S_LAZY_SYMBOL_POINTERS },
{ "SymbolStubs"                    , MachO::S_SYMBOL_STUBS },
{ "ModInitFuncPointers"            , MachO::S_MOD_INIT_FUNC_POINTERS },
{ "ModTermFuncPointers"            , MachO::S_MOD_TERM_FUNC_POINTERS },
{ "Coalesced"                      , MachO::S_COALESCED },
{ "GBZeroFill"                     , MachO::S_GB_ZEROFILL },
{ "Interposing"                    , MachO::S_INTERPOSING },
{ "16ByteLiterals"                 , MachO::S_16BYTE_LITERALS },
{ "DTraceDOF"                      , MachO::S_DTRACE_DOF },
{ "LazyDylibSymbolPointers"        , MachO::S_LAZY_DYLIB_SYMBOL_POINTERS },
{ "ThreadLocalRegular"             , MachO::S_THREAD_LOCAL_REGULAR },
{ "ThreadLocalZerofill"            , MachO::S_THREAD_LOCAL_ZEROFILL },
{ "ThreadLocalVariables"           , MachO::S_THREAD_LOCAL_VARIABLES },
{ "ThreadLocalVariablePointers"    , MachO::S_THREAD_LOCAL_VARIABLE_POINTERS },
{ "ThreadLocalInitFunctionPointers", MachO::S_THREAD_LOCAL_INIT_FUNCTION_POINTERS }
247};

249const EnumEntry<unsigned> MachOSectionAttributes[] = {
{ "LocReloc"         , 1 <<  0 /*S_ATTR_LOC_RELOC          */ },
{ "ExtReloc"         , 1 <<  1 /*S_ATTR_EXT_RELOC          */ },
{ "SomeInstructions" , 1 <<  2 /*S_ATTR_SOME_INSTRUCTIONS  */ },
{ "Debug"            , 1 << 17 /*S_ATTR_DEBUG              */ },
{ "SelfModifyingCode", 1 << 18 /*S_ATTR_SELF_MODIFYING_CODE*/ },
{ "LiveSupport"      , 1 << 19 /*S_ATTR_LIVE_SUPPORT       */ },
{ "NoDeadStrip"      , 1 << 20 /*S_ATTR_NO_DEAD_STRIP      */ },
{ "StripStaticSyms"  , 1 << 21 /*S_ATTR_STRIP_STATIC_SYMS  */ },
{ "NoTOC"            , 1 << 22 /*S_ATTR_NO_TOC             */ },
{ "PureInstructions" , 1 << 23 /*S_ATTR_PURE_INSTRUCTIONS  */ },
260};

262const EnumEntry<unsigned> MachOSymbolRefTypes[] = {
{ "UndefinedNonLazy",                     0 },
{ "ReferenceFlagUndefinedLazy",           1 },
{ "ReferenceFlagDefined",                 2 },
{ "ReferenceFlagPrivateDefined",          3 },
{ "ReferenceFlagPrivateUndefinedNonLazy", 4 },
{ "ReferenceFlagPrivateUndefinedLazy",    5 }
269};

271const EnumEntry<unsigned> MachOSymbolFlags[] = {
{ "ThumbDef",               0x8 },
{ "ReferencedDynamically", 0x10 },
{ "NoDeadStrip",           0x20 },
{ "WeakRef",               0x40 },
{ "WeakDef",               0x80 },
{ "SymbolResolver",       0x100 },
{ "AltEntry",             0x200 },
{ "ColdFunc",             0x400 },
280};

282const EnumEntry<unsigned> MachOSymbolTypes[] = {
{ "Undef",           0x0 },
{ "Abs",             0x2 },
{ "Indirect",        0xA },
{ "PreboundUndef",   0xC },
{ "Section",         0xE }
288};

290namespace {
struct MachOSection {
  ArrayRef<char> Name;
  ArrayRef<char> SegmentName;
  uint64_t Address;
  uint64_t Size;
  uint32_t Offset;
  uint32_t Alignment;
  uint32_t RelocationTableOffset;
  uint32_t NumRelocationTableEntries;
  uint32_t Flags;
  uint32_t Reserved1;
  uint32_t Reserved2;
  uint32_t Reserved3;
};

struct MachOSegment {
  std::string CmdName;
  std::string SegName;
  uint64_t cmdsize;
  uint64_t vmaddr;
  uint64_t vmsize;
  uint64_t fileoff;
  uint64_t filesize;
  uint32_t maxprot;
  uint32_t initprot;
  uint32_t nsects;
  uint32_t flags;
};

struct MachOSymbol {
  uint32_t StringIndex;
  uint8_t Type;
  uint8_t SectionIndex;
  uint16_t Flags;
  uint64_t Value;
};
327}

329static std::string getMask(uint32_t prot)
330{
// TODO (davide): This always assumes prot is valid.
// Catch mistakes and report if needed.
std::string Prot;
Prot = "";
Prot += (prot & MachO::VM_PROT_READ) ? "r" : "-";
Prot += (prot & MachO::VM_PROT_WRITE) ? "w" : "-";
Prot += (prot & MachO::VM_PROT_EXECUTE) ? "x" : "-";
return Prot;
339}

341static void getSection(const MachOObjectFile *Obj,
                     DataRefImpl Sec,
                     MachOSection &Section) {
if (!Obj->is64Bit()) {
  MachO::section Sect = Obj->getSection(Sec);
  Section.Address     = Sect.addr;
  Section.Size        = Sect.size;
  Section.Offset      = Sect.offset;
  Section.Alignment   = Sect.align;
  Section.RelocationTableOffset = Sect.reloff;
  Section.NumRelocationTableEntries = Sect.nreloc;
  Section.Flags       = Sect.flags;
  Section.Reserved1   = Sect.reserved1;
  Section.Reserved2   = Sect.reserved2;
  return;
}
MachO::section_64 Sect = Obj->getSection64(Sec);
Section.Address     = Sect.addr;
Section.Size        = Sect.size;
Section.Offset      = Sect.offset;
Section.Alignment   = Sect.align;
Section.RelocationTableOffset = Sect.reloff;
Section.NumRelocationTableEntries = Sect.nreloc;
Section.Flags       = Sect.flags;
Section.Reserved1   = Sect.reserved1;
Section.Reserved2   = Sect.reserved2;
Section.Reserved3   = Sect.reserved3;
368}

370static void getSegment(const MachOObjectFile *Obj,
                     const MachOObjectFile::LoadCommandInfo &L,
                     MachOSegment &Segment) {
if (!Obj->is64Bit()) {
  MachO::segment_command SC = Obj->getSegmentLoadCommand(L);
  Segment.CmdName = "LC_SEGMENT";
  Segment.SegName = SC.segname;
  Segment.cmdsize = SC.cmdsize;
  Segment.vmaddr = SC.vmaddr;
  Segment.vmsize = SC.vmsize;
  Segment.fileoff = SC.fileoff;
  Segment.filesize = SC.filesize;
  Segment.maxprot = SC.maxprot;
  Segment.initprot = SC.initprot;
  Segment.nsects = SC.nsects;
  Segment.flags = SC.flags;
  return;
}
MachO::segment_command_64 SC = Obj->getSegment64LoadCommand(L);
Segment.CmdName = "LC_SEGMENT_64";
Segment.SegName = SC.segname;
Segment.cmdsize = SC.cmdsize;
Segment.vmaddr = SC.vmaddr;
Segment.vmsize = SC.vmsize;
Segment.fileoff = SC.fileoff;
Segment.filesize = SC.filesize;
Segment.maxprot = SC.maxprot;
Segment.initprot = SC.initprot;
Segment.nsects = SC.nsects;
Segment.flags = SC.flags;
400}

402static void getSymbol(const MachOObjectFile *Obj,
                    DataRefImpl DRI,
                    MachOSymbol &Symbol) {
if (!Obj->is64Bit()) {
  MachO::nlist Entry = Obj->getSymbolTableEntry(DRI);
  Symbol.StringIndex  = Entry.n_strx;
  Symbol.Type         = Entry.n_type;
  Symbol.SectionIndex = Entry.n_sect;
  Symbol.Flags        = Entry.n_desc;
  Symbol.Value        = Entry.n_value;
  return;
}
MachO::nlist_64 Entry = Obj->getSymbol64TableEntry(DRI);
Symbol.StringIndex  = Entry.n_strx;
Symbol.Type         = Entry.n_type;
Symbol.SectionIndex = Entry.n_sect;
Symbol.Flags        = Entry.n_desc;
Symbol.Value        = Entry.n_value;
420}

422void MachODumper::printFileHeaders() {
DictScope H(W, "MachHeader");
if (!Obj->is64Bit()) {
  printFileHeaders(Obj->getHeader());
} else {
  printFileHeaders(Obj->getHeader64());
  W.printHex("Reserved", Obj->getHeader64().reserved);
}
430}

432template<class MachHeader>
433void MachODumper::printFileHeaders(const MachHeader &Header) {
W.printEnum("Magic", Header.magic, ArrayRef(MachOMagics));
W.printEnum("CpuType", Header.cputype, ArrayRef(MachOHeaderCpuTypes));
uint32_t subtype = Header.cpusubtype & ~MachO::CPU_SUBTYPE_MASK;
switch (Header.cputype) {
case MachO::CPU_TYPE_X86:
  W.printEnum("CpuSubType", subtype, ArrayRef(MachOHeaderCpuSubtypesX86));
  break;
case MachO::CPU_TYPE_X86_64:
  W.printEnum("CpuSubType", subtype, ArrayRef(MachOHeaderCpuSubtypesX64));
  break;
case MachO::CPU_TYPE_ARM:
  W.printEnum("CpuSubType", subtype, ArrayRef(MachOHeaderCpuSubtypesARM));
  break;
case MachO::CPU_TYPE_POWERPC:
  W.printEnum("CpuSubType", subtype, ArrayRef(MachOHeaderCpuSubtypesPPC));
  break;
case MachO::CPU_TYPE_SPARC:
  W.printEnum("CpuSubType", subtype, ArrayRef(MachOHeaderCpuSubtypesSPARC));
  break;
case MachO::CPU_TYPE_ARM64:
  W.printEnum("CpuSubType", subtype, ArrayRef(MachOHeaderCpuSubtypesARM64));
  break;
case MachO::CPU_TYPE_POWERPC64:
default:
  W.printHex("CpuSubtype", subtype);
}
W.printEnum("FileType", Header.filetype, ArrayRef(MachOHeaderFileTypes));
W.printNumber("NumOfLoadCommands", Header.ncmds);
W.printNumber("SizeOfLoadCommands", Header.sizeofcmds);
W.printFlags("Flags", Header.flags, ArrayRef(MachOHeaderFlags));
464}

466void MachODumper::printSectionHeaders() { return printSectionHeaders(Obj); }

468void MachODumper::printSectionHeaders(const MachOObjectFile *Obj) {
ListScope Group(W, "Sections");

int SectionIndex = -1;
for (const SectionRef &Section : Obj->sections()) {
  ++SectionIndex;

  MachOSection MOSection;
  getSection(Obj, Section.getRawDataRefImpl(), MOSection);
  DataRefImpl DR = Section.getRawDataRefImpl();
  StringRef Name = unwrapOrError(Obj->getFileName(), Section.getName());
  ArrayRef<char> RawName = Obj->getSectionRawName(DR);
  StringRef SegmentName = Obj->getSectionFinalSegmentName(DR);
  ArrayRef<char> RawSegmentName = Obj->getSectionRawFinalSegmentName(DR);

  DictScope SectionD(W, "Section");
  W.printNumber("Index", SectionIndex);
  W.printBinary("Name", Name, RawName);
  W.printBinary("Segment", SegmentName, RawSegmentName);
  W.printHex("Address", MOSection.Address);
  W.printHex("Size", MOSection.Size);
  W.printNumber("Offset", MOSection.Offset);
  W.printNumber("Alignment", MOSection.Alignment);
  W.printHex("RelocationOffset", MOSection.RelocationTableOffset);
  W.printNumber("RelocationCount", MOSection.NumRelocationTableEntries);
  W.printEnum("Type", MOSection.Flags & 0xFF, ArrayRef(MachOSectionTypes));
  W.printFlags("Attributes", MOSection.Flags >> 8,
               ArrayRef(MachOSectionAttributes));
  W.printHex("Reserved1", MOSection.Reserved1);
  W.printHex("Reserved2", MOSection.Reserved2);
  if (Obj->is64Bit())
    W.printHex("Reserved3", MOSection.Reserved3);

  if (opts::SectionRelocations) {
    ListScope D(W, "Relocations");
    for (const RelocationRef &Reloc : Section.relocations())
      printRelocation(Reloc);
  }

  if (opts::SectionSymbols) {
    ListScope D(W, "Symbols");
    for (const SymbolRef &Symbol : Obj->symbols()) {
      if (!Section.containsSymbol(Symbol))
        continue;

      printSymbol(Symbol);
    }
  }

  if (opts::SectionData && !Section.isBSS())
    W.printBinaryBlock("SectionData", unwrapOrError(Obj->getFileName(),
                                                    Section.getContents()));
}
521}

523void MachODumper::printRelocations() {
ListScope D(W, "Relocations");

std::error_code EC;
for (const SectionRef &Section : Obj->sections()) {
  StringRef Name = unwrapOrError(Obj->getFileName(), Section.getName());
  bool PrintedGroup = false;
  for (const RelocationRef &Reloc : Section.relocations()) {
    if (!PrintedGroup) {
      W.startLine() << "Section " << Name << " {\n";
      W.indent();
      PrintedGroup = true;
    }

    printRelocation(Reloc);
  }

  if (PrintedGroup) {
    W.unindent();
    W.startLine() << "}\n";
  }
}
545}

547void MachODumper::printRelocation(const RelocationRef &Reloc) {
return printRelocation(Obj, Reloc);
549}

551void MachODumper::printRelocation(const MachOObjectFile *Obj,
                                const RelocationRef &Reloc) {
uint64_t Offset = Reloc.getOffset();
SmallString<32> RelocName;
Reloc.getTypeName(RelocName);

DataRefImpl DR = Reloc.getRawDataRefImpl();
MachO::any_relocation_info RE = Obj->getRelocation(DR);
bool IsScattered = Obj->isRelocationScattered(RE);
bool IsExtern = !IsScattered && Obj->getPlainRelocationExternal(RE);

StringRef TargetName;
if (IsExtern) {
  symbol_iterator Symbol = Reloc.getSymbol();
  if (Symbol != Obj->symbol_end()) {
    TargetName = getSymbolName(*Symbol);
  }
} else if (!IsScattered) {
  section_iterator SecI = Obj->getRelocationSection(DR);
  if (SecI != Obj->section_end())
    TargetName = unwrapOrError(Obj->getFileName(), SecI->getName());
}
if (TargetName.empty())
  TargetName = "-";

if (opts::ExpandRelocs) {
  DictScope Group(W, "Relocation");
  W.printHex("Offset", Offset);
  W.printNumber("PCRel", Obj->getAnyRelocationPCRel(RE));
  W.printNumber("Length", Obj->getAnyRelocationLength(RE));
  W.printNumber("Type", RelocName, Obj->getAnyRelocationType(RE));
  if (IsScattered) {
    W.printHex("Value", Obj->getScatteredRelocationValue(RE));
  } else {
    const char *Kind = IsExtern ? "Symbol" : "Section";
    W.printNumber(Kind, TargetName, Obj->getPlainRelocationSymbolNum(RE));
  }
} else {
  SmallString<32> SymbolNameOrOffset("0x");
  if (IsScattered) {
    // Scattered relocations don't really have an associated symbol for some
    // reason, even if one exists in the symtab at the correct address.
    SymbolNameOrOffset += utohexstr(Obj->getScatteredRelocationValue(RE));
  } else {
    SymbolNameOrOffset = TargetName;
  }

  raw_ostream& OS = W.startLine();
  OS << W.hex(Offset)
     << " " << Obj->getAnyRelocationPCRel(RE)
     << " " << Obj->getAnyRelocationLength(RE);
  if (IsScattered)
    OS << " n/a";
  else
    OS << " " << Obj->getPlainRelocationExternal(RE);
  OS << " " << RelocName
     << " " << IsScattered
     << " " << SymbolNameOrOffset
     << "\n";
}
611}

613StringRef MachODumper::getSymbolName(const SymbolRef &Symbol) const {
Expected<StringRef> SymbolNameOrErr = Symbol.getName();
if (!SymbolNameOrErr) {
  reportError(SymbolNameOrErr.takeError(), Obj->getFileName());
}
return *SymbolNameOrErr;
619}

621uint8_t MachODumper::getSymbolType(const SymbolRef &Symbol) const {
return Obj->is64Bit()
    ? Obj->getSymbol64TableEntry(Symbol.getRawDataRefImpl()).n_type
    : Obj->getSymbolTableEntry(Symbol.getRawDataRefImpl()).n_type;
625}

627bool MachODumper::compareSymbolsByName(SymbolRef LHS, SymbolRef RHS) const {
return getSymbolName(LHS).str().compare(getSymbolName(RHS).str()) < 0;
629}

631bool MachODumper::compareSymbolsByType(SymbolRef LHS, SymbolRef RHS) const {
return getSymbolType(LHS) < getSymbolType(RHS);
633}

635void MachODumper::printSymbols() { printSymbols(std::nullopt); }

637void MachODumper::printSymbols(std::optional<SymbolComparator> SymComp) {
ListScope Group(W, "Symbols");
if (SymComp) {
  auto SymbolRange = Obj->symbols();
  std::vector<SymbolRef> SortedSymbols(SymbolRange.begin(),
                                       SymbolRange.end());
  llvm::stable_sort(SortedSymbols, *SymComp);
  for (SymbolRef Symbol : SortedSymbols)
    printSymbol(Symbol);
} else {
  for (const SymbolRef &Symbol : Obj->symbols()) {
    printSymbol(Symbol);
  }
}
651}

653void MachODumper::printDynamicSymbols() {
ListScope Group(W, "DynamicSymbols");
655}
656void MachODumper::printDynamicSymbols(std::optional<SymbolComparator> SymComp) {
ListScope Group(W, "DynamicSymbols");
658}

660void MachODumper::printSymbol(const SymbolRef &Symbol) {
printSymbol(Symbol, W);
662}

664void MachODumper::printSymbol(const SymbolRef &Symbol, ScopedPrinter &W) {
StringRef SymbolName = getSymbolName(Symbol);

MachOSymbol MOSymbol;
getSymbol(Obj, Symbol.getRawDataRefImpl(), MOSymbol);

StringRef SectionName = "";
// Don't ask a Mach-O STABS symbol for its section unless we 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.
// TODO: Add a whitelist of STABS symbol types that contain valid section
// indices.
if (!(MOSymbol.Type & MachO::N_STAB)) {
  Expected<section_iterator> SecIOrErr = Symbol.getSection();
  if (!SecIOrErr)
    reportError(SecIOrErr.takeError(), Obj->getFileName());

  section_iterator SecI = *SecIOrErr;
  if (SecI != Obj->section_end())
    SectionName = unwrapOrError(Obj->getFileName(), SecI->getName());
}

DictScope D(W, "Symbol");
W.printNumber("Name", SymbolName, MOSymbol.StringIndex);
if (MOSymbol.Type & MachO::N_STAB) {
  W.printHex("Type", "SymDebugTable", MOSymbol.Type);
} else {
  if (MOSymbol.Type & MachO::N_PEXT)
    W.startLine() << "PrivateExtern\n";
  if (MOSymbol.Type & MachO::N_EXT)
    W.startLine() << "Extern\n";
  W.printEnum("Type", uint8_t(MOSymbol.Type & MachO::N_TYPE),
              ArrayRef(MachOSymbolTypes));
}
W.printHex("Section", SectionName, MOSymbol.SectionIndex);
W.printEnum("RefType", static_cast<uint16_t>(MOSymbol.Flags & 0x7),
            ArrayRef(MachOSymbolRefTypes));
W.printFlags("Flags", static_cast<uint16_t>(MOSymbol.Flags & ~0x7),
             ArrayRef(MachOSymbolFlags));
W.printHex("Value", MOSymbol.Value);
704}

706void MachODumper::printUnwindInfo() {
W.startLine() << "UnwindInfo not implemented.\n";
708}

710void MachODumper::printStackMap() const {
object::SectionRef StackMapSection;
for (auto Sec : Obj->sections()) {
  StringRef Name;
  if (Expected<StringRef> NameOrErr = Sec.getName())
    Name = *NameOrErr;
  else
    consumeError(NameOrErr.takeError());

  if (Name == "__llvm_stackmaps") {
    StackMapSection = Sec;
    break;
  }
}

if (StackMapSection == object::SectionRef())
  return;

StringRef StackMapContents =
    unwrapOrError(Obj->getFileName(), StackMapSection.getContents());
ArrayRef<uint8_t> StackMapContentsArray =
    arrayRefFromStringRef(StackMapContents);

if (Obj->isLittleEndian())
  prettyPrintStackMap(
      W, StackMapParser<support::little>(StackMapContentsArray));
else
  prettyPrintStackMap(
      W, StackMapParser<support::big>(StackMapContentsArray));
739}

741void MachODumper::printCGProfile() {
object::SectionRef CGProfileSection;
1
Calling defaulted default constructor for 'SectionRef'→
3
←
Returning from default constructor for 'SectionRef'→
for (auto Sec : Obj->sections()) {
  StringRef Name;
  if (Expected<StringRef> NameOrErr = Sec.getName())
    Name = *NameOrErr;
  else
    consumeError(NameOrErr.takeError());

  if (Name == "__cg_profile") {
    CGProfileSection = Sec;
    break;
  }
}
if (CGProfileSection == object::SectionRef())
4
←
Taking false branch→
  return;

StringRef CGProfileContents =
    unwrapOrError(Obj->getFileName(), CGProfileSection.getContents());
5
←
Calling 'SectionRef::getContents'→
BinaryStreamReader Reader(CGProfileContents, Obj->isLittleEndian()
                                                 ? llvm::support::little
                                                 : llvm::support::big);

ListScope L(W, "CGProfile");
while (!Reader.empty()) {
  uint32_t FromIndex, ToIndex;
  uint64_t Count;
  if (Error Err = Reader.readInteger(FromIndex))
    reportError(std::move(Err), Obj->getFileName());
  if (Error Err = Reader.readInteger(ToIndex))
    reportError(std::move(Err), Obj->getFileName());
  if (Error Err = Reader.readInteger(Count))
    reportError(std::move(Err), Obj->getFileName());
  DictScope D(W, "CGProfileEntry");
  W.printNumber("From", getSymbolName(*Obj->getSymbolByIndex(FromIndex)),
                FromIndex);
  W.printNumber("To", getSymbolName(*Obj->getSymbolByIndex(ToIndex)),
                ToIndex);
  W.printNumber("Weight", Count);
}
781}

783void MachODumper::printNeededLibraries() {
ListScope D(W, "NeededLibraries");

using LibsTy = std::vector<StringRef>;
LibsTy Libs;

for (const auto &Command : Obj->load_commands()) {
  if (Command.C.cmd == MachO::LC_LOAD_DYLIB ||
      Command.C.cmd == MachO::LC_ID_DYLIB ||
      Command.C.cmd == MachO::LC_LOAD_WEAK_DYLIB ||
      Command.C.cmd == MachO::LC_REEXPORT_DYLIB ||
      Command.C.cmd == MachO::LC_LAZY_LOAD_DYLIB ||
      Command.C.cmd == MachO::LC_LOAD_UPWARD_DYLIB) {
    MachO::dylib_command Dl = Obj->getDylibIDLoadCommand(Command);
    if (Dl.dylib.name < Dl.cmdsize) {
      auto *P = static_cast<const char*>(Command.Ptr) + Dl.dylib.name;
      Libs.push_back(P);
    }
  }
}

llvm::stable_sort(Libs);

for (const auto &L : Libs) {
  W.startLine() << L << "\n";
}
809}

811void MachODumper::printMachODataInCode() {
for (const auto &Load : Obj->load_commands()) {
  if (Load.C.cmd  == MachO::LC_DATA_IN_CODE) {
    MachO::linkedit_data_command LLC = Obj->getLinkeditDataLoadCommand(Load);
    DictScope Group(W, "DataInCode");
    W.printNumber("Data offset", LLC.dataoff);
    W.printNumber("Data size", LLC.datasize);
    ListScope D(W, "Data entries");
    unsigned NumRegions = LLC.datasize / sizeof(MachO::data_in_code_entry);
    for (unsigned i = 0; i < NumRegions; ++i) {
      MachO::data_in_code_entry DICE = Obj->getDataInCodeTableEntry(
                                                            LLC.dataoff, i);
      DictScope Group(W, "Entry");
      W.printNumber("Index", i);
      W.printNumber("Offset", DICE.offset);
      W.printNumber("Length", DICE.length);
      W.printNumber("Kind", DICE.kind);
    }
  }
}
831}

833void MachODumper::printMachOVersionMin() {
for (const auto &Load : Obj->load_commands()) {
  StringRef Cmd;
  switch (Load.C.cmd) {
  case MachO::LC_VERSION_MIN_MACOSX:
    Cmd = "LC_VERSION_MIN_MACOSX";
    break;
  case MachO::LC_VERSION_MIN_IPHONEOS:
    Cmd = "LC_VERSION_MIN_IPHONEOS";
    break;
  case MachO::LC_VERSION_MIN_TVOS:
    Cmd = "LC_VERSION_MIN_TVOS";
    break;
  case MachO::LC_VERSION_MIN_WATCHOS:
    Cmd = "LC_VERSION_MIN_WATCHOS";
    break;
  case MachO::LC_BUILD_VERSION:
    Cmd = "LC_BUILD_VERSION";
    break;
  default:
    continue;
  }

  DictScope Group(W, "MinVersion");
  // Handle LC_BUILD_VERSION.
  if (Load.C.cmd == MachO::LC_BUILD_VERSION) {
    MachO::build_version_command BVC = Obj->getBuildVersionLoadCommand(Load);
    W.printString("Cmd", Cmd);
    W.printNumber("Size", BVC.cmdsize);
    W.printString("Platform",
                  MachOObjectFile::getBuildPlatform(BVC.platform));
    W.printString("Version", MachOObjectFile::getVersionString(BVC.minos));
    if (BVC.sdk)
      W.printString("SDK", MachOObjectFile::getVersionString(BVC.sdk));
    else
      W.printString("SDK", StringRef("n/a"));
    continue;
  }

  MachO::version_min_command VMC = Obj->getVersionMinLoadCommand(Load);
  W.printString("Cmd", Cmd);
  W.printNumber("Size", VMC.cmdsize);
  SmallString<32> Version;
  Version = utostr(MachOObjectFile::getVersionMinMajor(VMC, false)) + "." +
            utostr(MachOObjectFile::getVersionMinMinor(VMC, false));
  uint32_t Update = MachOObjectFile::getVersionMinUpdate(VMC, false);
  if (Update != 0)
    Version += "." + utostr(MachOObjectFile::getVersionMinUpdate(VMC, false));
  W.printString("Version", Version);
  SmallString<32> SDK;
  if (VMC.sdk == 0)
    SDK = "n/a";
  else {
    SDK = utostr(MachOObjectFile::getVersionMinMajor(VMC, true)) + "." +
          utostr(MachOObjectFile::getVersionMinMinor(VMC, true));
    uint32_t Update = MachOObjectFile::getVersionMinUpdate(VMC, true);
    if (Update != 0)
      SDK += "." + utostr(MachOObjectFile::getVersionMinUpdate(VMC, true));
  }
  W.printString("SDK", SDK);
}
894}

896void MachODumper::printMachODysymtab() {
for (const auto &Load : Obj->load_commands()) {
  if (Load.C.cmd == MachO::LC_DYSYMTAB) {
    MachO::dysymtab_command DLC = Obj->getDysymtabLoadCommand();
    DictScope Group(W, "Dysymtab");
    W.printNumber("ilocalsym", DLC.ilocalsym);
    W.printNumber("nlocalsym", DLC.nlocalsym);
    W.printNumber("iextdefsym", DLC.iextdefsym);
    W.printNumber("nextdefsym", DLC.nextdefsym);
    W.printNumber("iundefsym", DLC.iundefsym);
    W.printNumber("nundefsym", DLC.nundefsym);
    W.printNumber("tocoff", DLC.tocoff);
    W.printNumber("ntoc", DLC.ntoc);
    W.printNumber("modtaboff", DLC.modtaboff);
    W.printNumber("nmodtab", DLC.nmodtab);
    W.printNumber("extrefsymoff", DLC.extrefsymoff);
    W.printNumber("nextrefsyms", DLC.nextrefsyms);
    W.printNumber("indirectsymoff", DLC.indirectsymoff);
    W.printNumber("nindirectsyms", DLC.nindirectsyms);
    W.printNumber("extreloff", DLC.extreloff);
    W.printNumber("nextrel", DLC.nextrel);
    W.printNumber("locreloff", DLC.locreloff);
    W.printNumber("nlocrel", DLC.nlocrel);
  }
}
921}

923void MachODumper::printMachOSegment() {
for (const auto &Load : Obj->load_commands()) {
  if (Load.C.cmd == MachO::LC_SEGMENT || Load.C.cmd == MachO::LC_SEGMENT_64) {
    MachOSegment MOSegment;
    getSegment(Obj, Load, MOSegment);
    DictScope Group(W, "Segment");
    W.printString("Cmd", MOSegment.CmdName);
    W.printString("Name", MOSegment.SegName);
    W.printNumber("Size", MOSegment.cmdsize);
    W.printHex("vmaddr", MOSegment.vmaddr);
    W.printHex("vmsize", MOSegment.vmsize);
    W.printNumber("fileoff", MOSegment.fileoff);
    W.printNumber("filesize", MOSegment.filesize);
    W.printString("maxprot", getMask(MOSegment.maxprot));
    W.printString("initprot", getMask(MOSegment.initprot));
    W.printNumber("nsects", MOSegment.nsects);
    W.printHex("flags", MOSegment.flags);
  }
}
942}

944void MachODumper::printMachOIndirectSymbols() {
for (const auto &Load : Obj->load_commands()) {
  if (Load.C.cmd == MachO::LC_DYSYMTAB) {
    MachO::dysymtab_command DLC = Obj->getDysymtabLoadCommand();
    DictScope Group(W, "Indirect Symbols");
    W.printNumber("Number", DLC.nindirectsyms);
    ListScope D(W, "Symbols");
    for (unsigned i = 0; i < DLC.nindirectsyms; ++i) {
      DictScope Group(W, "Entry");
      W.printNumber("Entry Index", i);
      W.printHex("Symbol Index", Obj->getIndirectSymbolTableEntry(DLC, i));
    }
  }
}
958}

960void MachODumper::printMachOLinkerOptions() {
for (const auto &Load : Obj->load_commands()) {
  if (Load.C.cmd == MachO::LC_LINKER_OPTION) {
    MachO::linker_option_command LOLC = Obj->getLinkerOptionLoadCommand(Load);
    DictScope Group(W, "Linker Options");
    W.printNumber("Size", LOLC.cmdsize);
    ListScope D(W, "Strings");
    uint64_t DataSize = LOLC.cmdsize - sizeof(MachO::linker_option_command);
    const char *P = Load.Ptr + sizeof(MachO::linker_option_command);
    StringRef Data(P, DataSize);
    for (unsigned i = 0; i < LOLC.count; ++i) {
      std::pair<StringRef,StringRef> Split = Data.split('\0');
      W.printString("Value", Split.first);
      Data = Split.second;
    }
  }
}
977}

←

/build/source/llvm/include/llvm/Object/ObjectFile.h

1//===- ObjectFile.h - File format independent object file -------*- C++ -*-===//
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 file declares a file format independent ObjectFile class.
10//
11//===----------------------------------------------------------------------===//

13#ifndef LLVM_OBJECT_OBJECTFILE_H
14#define LLVM_OBJECT_OBJECTFILE_H

16#include "llvm/ADT/ArrayRef.h"
17#include "llvm/ADT/Hashing.h"
18#include "llvm/ADT/StringRef.h"
19#include "llvm/ADT/iterator_range.h"
20#include "llvm/BinaryFormat/Magic.h"
21#include "llvm/BinaryFormat/Swift.h"
22#include "llvm/Object/Binary.h"
23#include "llvm/Object/Error.h"
24#include "llvm/Object/SymbolicFile.h"
25#include "llvm/Support/Casting.h"
26#include "llvm/Support/Error.h"
27#include "llvm/Support/MemoryBufferRef.h"
28#include "llvm/TargetParser/Triple.h"
29#include <cassert>
30#include <cstdint>
31#include <memory>

33namespace llvm {

35class SubtargetFeatures;

37namespace object {

39class COFFObjectFile;
40class MachOObjectFile;
41class ObjectFile;
42class SectionRef;
43class SymbolRef;
44class symbol_iterator;
45class WasmObjectFile;

47using section_iterator = content_iterator<SectionRef>;

49/// This is a value type class that represents a single relocation in the list
50/// of relocations in the object file.
51class RelocationRef {
DataRefImpl RelocationPimpl;
const ObjectFile *OwningObject = nullptr;

55public:
RelocationRef() = default;
RelocationRef(DataRefImpl RelocationP, const ObjectFile *Owner);

bool operator==(const RelocationRef &Other) const;

void moveNext();

uint64_t getOffset() const;
symbol_iterator getSymbol() const;
uint64_t getType() const;

/// Get a string that represents the type of this relocation.
///
/// This is for display purposes only.
void getTypeName(SmallVectorImpl<char> &Result) const;

DataRefImpl getRawDataRefImpl() const;
const ObjectFile *getObject() const;
74};

76using relocation_iterator = content_iterator<RelocationRef>;

78/// This is a value type class that represents a single section in the list of
79/// sections in the object file.
80class SectionRef {
friend class SymbolRef;

DataRefImpl SectionPimpl;
const ObjectFile *OwningObject = nullptr;
2
←
Null pointer value stored to 'CGProfileSection.OwningObject'→

86public:
SectionRef() = default;
SectionRef(DataRefImpl SectionP, const ObjectFile *Owner);

bool operator==(const SectionRef &Other) const;
bool operator!=(const SectionRef &Other) const;
bool operator<(const SectionRef &Other) const;

void moveNext();

Expected<StringRef> getName() const;
uint64_t getAddress() const;
uint64_t getIndex() const;
uint64_t getSize() const;
Expected<StringRef> getContents() const;

/// Get the alignment of this section.
Align getAlignment() const;

bool isCompressed() const;
/// Whether this section contains instructions.
bool isText() const;
/// Whether this section contains data, not instructions.
bool isData() const;
/// Whether this section contains BSS uninitialized data.
bool isBSS() const;
bool isVirtual() const;
bool isBitcode() const;
bool isStripped() const;

/// Whether this section will be placed in the text segment, according to the
/// Berkeley size format. This is true if the section is allocatable, and
/// contains either code or readonly data.
bool isBerkeleyText() const;
/// Whether this section will be placed in the data segment, according to the
/// Berkeley size format. This is true if the section is allocatable and
/// contains data (e.g. PROGBITS), but is not text.
bool isBerkeleyData() const;

/// Whether this section is a debug section.
bool isDebugSection() const;

bool containsSymbol(SymbolRef S) const;

relocation_iterator relocation_begin() const;
relocation_iterator relocation_end() const;
iterator_range<relocation_iterator> relocations() const {
  return make_range(relocation_begin(), relocation_end());
}

/// Returns the related section if this section contains relocations. The
/// returned section may or may not have applied its relocations.
Expected<section_iterator> getRelocatedSection() const;

DataRefImpl getRawDataRefImpl() const;
const ObjectFile *getObject() const;
142};

144struct SectionedAddress {
const static uint64_t UndefSection = UINT64_MAX(18446744073709551615UL);

uint64_t Address = 0;
uint64_t SectionIndex = UndefSection;
149};

151inline bool operator<(const SectionedAddress &LHS,
                    const SectionedAddress &RHS) {
return std::tie(LHS.SectionIndex, LHS.Address) <
       std::tie(RHS.SectionIndex, RHS.Address);
155}

157inline bool operator==(const SectionedAddress &LHS,
                     const SectionedAddress &RHS) {
return std::tie(LHS.SectionIndex, LHS.Address) ==
       std::tie(RHS.SectionIndex, RHS.Address);
161}

163raw_ostream &operator<<(raw_ostream &OS, const SectionedAddress &Addr);

165/// This is a value type class that represents a single symbol in the list of
166/// symbols in the object file.
167class SymbolRef : public BasicSymbolRef {
friend class SectionRef;

170public:
enum Type {
  ST_Unknown, // Type not specified
  ST_Other,
  ST_Data,
  ST_Debug,
  ST_File,
  ST_Function,
};

SymbolRef() = default;
SymbolRef(DataRefImpl SymbolP, const ObjectFile *Owner);
SymbolRef(const BasicSymbolRef &B) : BasicSymbolRef(B) {
  assert(isa<ObjectFile>(BasicSymbolRef::getObject()))(static_cast <bool> (isa<ObjectFile>(BasicSymbolRef
::getObject())) ? void (0) : __assert_fail ("isa<ObjectFile>(BasicSymbolRef::getObject())"
, "llvm/include/llvm/Object/ObjectFile.h", 183, __extension__
 __PRETTY_FUNCTION__));
}

Expected<StringRef> getName() const;
/// Returns the symbol virtual address (i.e. address at which it will be
/// mapped).
Expected<uint64_t> getAddress() const;

/// Return the value of the symbol depending on the object this can be an
/// offset or a virtual address.
Expected<uint64_t> getValue() const;

/// Get the alignment of this symbol as the actual value (not log 2).
uint32_t getAlignment() const;
uint64_t getCommonSize() const;
Expected<SymbolRef::Type> getType() const;

/// Get section this symbol is defined in reference to. Result is
/// end_sections() if it is undefined or is an absolute symbol.
Expected<section_iterator> getSection() const;

const ObjectFile *getObject() const;
205};

207class symbol_iterator : public basic_symbol_iterator {
208public:
symbol_iterator(SymbolRef Sym) : basic_symbol_iterator(Sym) {}
symbol_iterator(const basic_symbol_iterator &B)
    : basic_symbol_iterator(SymbolRef(B->getRawDataRefImpl(),
                                      cast<ObjectFile>(B->getObject()))) {}

const SymbolRef *operator->() const {
  const BasicSymbolRef &P = basic_symbol_iterator::operator *();
  return static_cast<const SymbolRef*>(&P);
}

const SymbolRef &operator*() const {
  const BasicSymbolRef &P = basic_symbol_iterator::operator *();
  return static_cast<const SymbolRef&>(P);
}
223};

225/// This class is the base class for all object file types. Concrete instances
226/// of this object are created by createObjectFile, which figures out which type
227/// to create.
228class ObjectFile : public SymbolicFile {
virtual void anchor();

231protected:
ObjectFile(unsigned int Type, MemoryBufferRef Source);

const uint8_t *base() const {
  return reinterpret_cast<const uint8_t *>(Data.getBufferStart());
}

// These functions are for SymbolRef to call internally. The main goal of
// this is to allow SymbolRef::SymbolPimpl to point directly to the symbol
// entry in the memory mapped object file. SymbolPimpl cannot contain any
// virtual functions because then it could not point into the memory mapped
// file.
//
// Implementations assume that the DataRefImpl is valid and has not been
// modified externally. It's UB otherwise.
friend class SymbolRef;

virtual Expected<StringRef> getSymbolName(DataRefImpl Symb) const = 0;
Error printSymbolName(raw_ostream &OS,
                                DataRefImpl Symb) const override;
virtual Expected<uint64_t> getSymbolAddress(DataRefImpl Symb) const = 0;
virtual uint64_t getSymbolValueImpl(DataRefImpl Symb) const = 0;
virtual uint32_t getSymbolAlignment(DataRefImpl Symb) const;
virtual uint64_t getCommonSymbolSizeImpl(DataRefImpl Symb) const = 0;
virtual Expected<SymbolRef::Type> getSymbolType(DataRefImpl Symb) const = 0;
virtual Expected<section_iterator>
getSymbolSection(DataRefImpl Symb) const = 0;

// Same as above for SectionRef.
friend class SectionRef;

virtual void moveSectionNext(DataRefImpl &Sec) const = 0;
virtual Expected<StringRef> getSectionName(DataRefImpl Sec) const = 0;
virtual uint64_t getSectionAddress(DataRefImpl Sec) const = 0;
virtual uint64_t getSectionIndex(DataRefImpl Sec) const = 0;
virtual uint64_t getSectionSize(DataRefImpl Sec) const = 0;
virtual Expected<ArrayRef<uint8_t>>
getSectionContents(DataRefImpl Sec) const = 0;
virtual uint64_t getSectionAlignment(DataRefImpl Sec) const = 0;
virtual bool isSectionCompressed(DataRefImpl Sec) const = 0;
virtual bool isSectionText(DataRefImpl Sec) const = 0;
virtual bool isSectionData(DataRefImpl Sec) const = 0;
virtual bool isSectionBSS(DataRefImpl Sec) const = 0;
// A section is 'virtual' if its contents aren't present in the object image.
virtual bool isSectionVirtual(DataRefImpl Sec) const = 0;
virtual bool isSectionBitcode(DataRefImpl Sec) const;
virtual bool isSectionStripped(DataRefImpl Sec) const;
virtual bool isBerkeleyText(DataRefImpl Sec) const;
virtual bool isBerkeleyData(DataRefImpl Sec) const;
virtual bool isDebugSection(DataRefImpl Sec) const;
virtual relocation_iterator section_rel_begin(DataRefImpl Sec) const = 0;
virtual relocation_iterator section_rel_end(DataRefImpl Sec) const = 0;
virtual Expected<section_iterator> getRelocatedSection(DataRefImpl Sec) const;

// Same as above for RelocationRef.
friend class RelocationRef;
virtual void moveRelocationNext(DataRefImpl &Rel) const = 0;
virtual uint64_t getRelocationOffset(DataRefImpl Rel) const = 0;
virtual symbol_iterator getRelocationSymbol(DataRefImpl Rel) const = 0;
virtual uint64_t getRelocationType(DataRefImpl Rel) const = 0;
virtual void getRelocationTypeName(DataRefImpl Rel,
                                   SmallVectorImpl<char> &Result) const = 0;

virtual llvm::binaryformat::Swift5ReflectionSectionKind
mapReflectionSectionNameToEnumValue(StringRef SectionName) const {
  return llvm::binaryformat::Swift5ReflectionSectionKind::unknown;
};

Expected<uint64_t> getSymbolValue(DataRefImpl Symb) const;

301public:
ObjectFile() = delete;
ObjectFile(const ObjectFile &other) = delete;

uint64_t getCommonSymbolSize(DataRefImpl Symb) const {
  Expected<uint32_t> SymbolFlagsOrErr = getSymbolFlags(Symb);
  if (!SymbolFlagsOrErr)
    // TODO: Actually report errors helpfully.
    report_fatal_error(SymbolFlagsOrErr.takeError());
  assert(*SymbolFlagsOrErr & SymbolRef::SF_Common)(static_cast <bool> (*SymbolFlagsOrErr & SymbolRef::
SF_Common) ? void (0) : __assert_fail ("*SymbolFlagsOrErr & SymbolRef::SF_Common"
, "llvm/include/llvm/Object/ObjectFile.h", 310, __extension__
 __PRETTY_FUNCTION__));
  return getCommonSymbolSizeImpl(Symb);
}

virtual std::vector<SectionRef> dynamic_relocation_sections() const {
  return std::vector<SectionRef>();
}

using symbol_iterator_range = iterator_range<symbol_iterator>;
symbol_iterator_range symbols() const {
  return symbol_iterator_range(symbol_begin(), symbol_end());
}

virtual section_iterator section_begin() const = 0;
virtual section_iterator section_end() const = 0;

using section_iterator_range = iterator_range<section_iterator>;
section_iterator_range sections() const {
  return section_iterator_range(section_begin(), section_end());
}

virtual bool hasDebugInfo() const;

/// The number of bytes used to represent an address in this object
///        file format.
virtual uint8_t getBytesInAddress() const = 0;

virtual StringRef getFileFormatName() const = 0;
virtual Triple::ArchType getArch() const = 0;
virtual Expected<SubtargetFeatures> getFeatures() const = 0;
virtual std::optional<StringRef> tryGetCPUName() const {
  return std::nullopt;
};
virtual void setARMSubArch(Triple &TheTriple) const { }
virtual Expected<uint64_t> getStartAddress() const {
  return errorCodeToError(object_error::parse_failed);
};

/// Create a triple from the data in this object file.
Triple makeTriple() const;

/// Maps a debug section name to a standard DWARF section name.
virtual StringRef mapDebugSectionName(StringRef Name) const { return Name; }

/// True if this is a relocatable object (.o/.obj).
virtual bool isRelocatableObject() const = 0;

/// True if the reflection section can be stripped by the linker.
bool isReflectionSectionStrippable(
    llvm::binaryformat::Swift5ReflectionSectionKind ReflectionSectionKind)
    const;

/// @returns Pointer to ObjectFile subclass to handle this type of object.
/// @param ObjectPath The path to the object file. ObjectPath.isObject must
///        return true.
/// Create ObjectFile from path.
static Expected<OwningBinary<ObjectFile>>
createObjectFile(StringRef ObjectPath);

static Expected<std::unique_ptr<ObjectFile>>
createObjectFile(MemoryBufferRef Object, llvm::file_magic Type,
                 bool InitContent = true);
static Expected<std::unique_ptr<ObjectFile>>
createObjectFile(MemoryBufferRef Object) {
  return createObjectFile(Object, llvm::file_magic::unknown);
}

static bool classof(const Binary *v) {
  return v->isObject();
}

static Expected<std::unique_ptr<COFFObjectFile>>
createCOFFObjectFile(MemoryBufferRef Object);

static Expected<std::unique_ptr<ObjectFile>>
createXCOFFObjectFile(MemoryBufferRef Object, unsigned FileType);

static Expected<std::unique_ptr<ObjectFile>>
createELFObjectFile(MemoryBufferRef Object, bool InitContent = true);

static Expected<std::unique_ptr<MachOObjectFile>>
createMachOObjectFile(MemoryBufferRef Object,
                      uint32_t UniversalCputype = 0,
                      uint32_t UniversalIndex = 0);

static Expected<std::unique_ptr<ObjectFile>>
createGOFFObjectFile(MemoryBufferRef Object);

static Expected<std::unique_ptr<WasmObjectFile>>
createWasmObjectFile(MemoryBufferRef Object);
400};

402// Inline function definitions.
403inline SymbolRef::SymbolRef(DataRefImpl SymbolP, const ObjectFile *Owner)
  : BasicSymbolRef(SymbolP, Owner) {}

406inline Expected<StringRef> SymbolRef::getName() const {
return getObject()->getSymbolName(getRawDataRefImpl());
408}

410inline Expected<uint64_t> SymbolRef::getAddress() const {
return getObject()->getSymbolAddress(getRawDataRefImpl());
412}

414inline Expected<uint64_t> SymbolRef::getValue() const {
return getObject()->getSymbolValue(getRawDataRefImpl());
416}

418inline uint32_t SymbolRef::getAlignment() const {
return getObject()->getSymbolAlignment(getRawDataRefImpl());
420}

422inline uint64_t SymbolRef::getCommonSize() const {
return getObject()->getCommonSymbolSize(getRawDataRefImpl());
424}

426inline Expected<section_iterator> SymbolRef::getSection() const {
return getObject()->getSymbolSection(getRawDataRefImpl());
428}

430inline Expected<SymbolRef::Type> SymbolRef::getType() const {
return getObject()->getSymbolType(getRawDataRefImpl());
432}

434inline const ObjectFile *SymbolRef::getObject() const {
const SymbolicFile *O = BasicSymbolRef::getObject();
return cast<ObjectFile>(O);
437}

439/// SectionRef
440inline SectionRef::SectionRef(DataRefImpl SectionP,
                            const ObjectFile *Owner)
: SectionPimpl(SectionP)
, OwningObject(Owner) {}

445inline bool SectionRef::operator==(const SectionRef &Other) const {
return OwningObject == Other.OwningObject &&
       SectionPimpl == Other.SectionPimpl;
448}

450inline bool SectionRef::operator!=(const SectionRef &Other) const {
return !(*this == Other);
452}

454inline bool SectionRef::operator<(const SectionRef &Other) const {
assert(OwningObject == Other.OwningObject)(static_cast <bool> (OwningObject == Other.OwningObject
) ? void (0) : __assert_fail ("OwningObject == Other.OwningObject"
, "llvm/include/llvm/Object/ObjectFile.h", 455, __extension__
 __PRETTY_FUNCTION__));
return SectionPimpl < Other.SectionPimpl;
457}

459inline void SectionRef::moveNext() {
return OwningObject->moveSectionNext(SectionPimpl);
461}

463inline Expected<StringRef> SectionRef::getName() const {
return OwningObject->getSectionName(SectionPimpl);
465}

467inline uint64_t SectionRef::getAddress() const {
return OwningObject->getSectionAddress(SectionPimpl);
469}

471inline uint64_t SectionRef::getIndex() const {
return OwningObject->getSectionIndex(SectionPimpl);
473}

475inline uint64_t SectionRef::getSize() const {
return OwningObject->getSectionSize(SectionPimpl);
477}

479inline Expected<StringRef> SectionRef::getContents() const {
Expected<ArrayRef<uint8_t>> Res =
    OwningObject->getSectionContents(SectionPimpl);
6
←
Called C++ object pointer is null
if (!Res)
  return Res.takeError();
return StringRef(reinterpret_cast<const char *>(Res->data()), Res->size());
485}

487inline Align SectionRef::getAlignment() const {
return MaybeAlign(OwningObject->getSectionAlignment(SectionPimpl))
    .valueOrOne();
490}

492inline bool SectionRef::isCompressed() const {
return OwningObject->isSectionCompressed(SectionPimpl);
494}

496inline bool SectionRef::isText() const {
return OwningObject->isSectionText(SectionPimpl);
498}

500inline bool SectionRef::isData() const {
return OwningObject->isSectionData(SectionPimpl);
502}

504inline bool SectionRef::isBSS() const {
return OwningObject->isSectionBSS(SectionPimpl);
506}

508inline bool SectionRef::isVirtual() const {
return OwningObject->isSectionVirtual(SectionPimpl);
510}

512inline bool SectionRef::isBitcode() const {
return OwningObject->isSectionBitcode(SectionPimpl);
514}

516inline bool SectionRef::isStripped() const {
return OwningObject->isSectionStripped(SectionPimpl);
518}

520inline bool SectionRef::isBerkeleyText() const {
return OwningObject->isBerkeleyText(SectionPimpl);
522}

524inline bool SectionRef::isBerkeleyData() const {
return OwningObject->isBerkeleyData(SectionPimpl);
526}

528inline bool SectionRef::isDebugSection() const {
return OwningObject->isDebugSection(SectionPimpl);
530}

532inline relocation_iterator SectionRef::relocation_begin() const {
return OwningObject->section_rel_begin(SectionPimpl);
534}

536inline relocation_iterator SectionRef::relocation_end() const {
return OwningObject->section_rel_end(SectionPimpl);
538}

540inline Expected<section_iterator> SectionRef::getRelocatedSection() const {
return OwningObject->getRelocatedSection(SectionPimpl);
542}

544inline DataRefImpl SectionRef::getRawDataRefImpl() const {
return SectionPimpl;
546}

548inline const ObjectFile *SectionRef::getObject() const {
return OwningObject;
550}

552/// RelocationRef
553inline RelocationRef::RelocationRef(DataRefImpl RelocationP,
                            const ObjectFile *Owner)
: RelocationPimpl(RelocationP)
, OwningObject(Owner) {}

558inline bool RelocationRef::operator==(const RelocationRef &Other) const {
return RelocationPimpl == Other.RelocationPimpl;
560}

562inline void RelocationRef::moveNext() {
return OwningObject->moveRelocationNext(RelocationPimpl);
564}

566inline uint64_t RelocationRef::getOffset() const {
return OwningObject->getRelocationOffset(RelocationPimpl);
568}

570inline symbol_iterator RelocationRef::getSymbol() const {
return OwningObject->getRelocationSymbol(RelocationPimpl);
572}

574inline uint64_t RelocationRef::getType() const {
return OwningObject->getRelocationType(RelocationPimpl);
576}

578inline void RelocationRef::getTypeName(SmallVectorImpl<char> &Result) const {
return OwningObject->getRelocationTypeName(RelocationPimpl, Result);
580}

582inline DataRefImpl RelocationRef::getRawDataRefImpl() const {
return RelocationPimpl;
584}

586inline const ObjectFile *RelocationRef::getObject() const {
return OwningObject;
588}

590} // end namespace object

592template <> struct DenseMapInfo<object::SectionRef> {
static bool isEqual(const object::SectionRef &A,
                    const object::SectionRef &B) {
  return A == B;
}
static object::SectionRef getEmptyKey() {
  return object::SectionRef({}, nullptr);
}
static object::SectionRef getTombstoneKey() {
  object::DataRefImpl TS;
  TS.p = (uintptr_t)-1;
  return object::SectionRef(TS, nullptr);
}
static unsigned getHashValue(const object::SectionRef &Sec) {
  object::DataRefImpl Raw = Sec.getRawDataRefImpl();
  return hash_combine(Raw.p, Raw.d.a, Raw.d.b);
}
609};

611} // end namespace llvm

613#endif // LLVM_OBJECT_OBJECTFILE_H