/usr/src/gnu/usr.bin/clang/liblldbPluginObjectFile/../../../llvm/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

Bug Summary

File:	src/gnu/usr.bin/clang/liblldbPluginObjectFile/../../../llvm/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp
Warning:	line 2209, column 7 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name ObjectFileELF.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 -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/liblldbPluginObjectFile/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/liblldbPluginObjectFile/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/liblldbPluginObjectFile/../include -I /usr/src/gnu/usr.bin/clang/liblldbPluginObjectFile/obj -I /usr/src/gnu/usr.bin/clang/liblldbPluginObjectFile/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -I /usr/src/gnu/usr.bin/clang/liblldbPluginObjectFile/../../../llvm/lldb/include -I /usr/src/gnu/usr.bin/clang/liblldbPluginObjectFile/../../../llvm/lldb/source -I /usr/src/gnu/usr.bin/clang/liblldbPluginObjectFile/../../../llvm/clang/include -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/liblldbPluginObjectFile/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/liblldbPluginObjectFile/../../../llvm/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

/usr/src/gnu/usr.bin/clang/liblldbPluginObjectFile/../../../llvm/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

→

1//===-- ObjectFileELF.cpp -------------------------------------------------===//
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//===----------------------------------------------------------------------===//

9#include "ObjectFileELF.h"

11#include <algorithm>
12#include <cassert>
13#include <unordered_map>

15#include "lldb/Core/FileSpecList.h"
16#include "lldb/Core/Module.h"
17#include "lldb/Core/ModuleSpec.h"
18#include "lldb/Core/PluginManager.h"
19#include "lldb/Core/Progress.h"
20#include "lldb/Core/Section.h"
21#include "lldb/Host/FileSystem.h"
22#include "lldb/Host/LZMA.h"
23#include "lldb/Symbol/DWARFCallFrameInfo.h"
24#include "lldb/Symbol/SymbolContext.h"
25#include "lldb/Target/SectionLoadList.h"
26#include "lldb/Target/Target.h"
27#include "lldb/Utility/ArchSpec.h"
28#include "lldb/Utility/DataBufferHeap.h"
29#include "lldb/Utility/Log.h"
30#include "lldb/Utility/RangeMap.h"
31#include "lldb/Utility/Status.h"
32#include "lldb/Utility/Stream.h"
33#include "lldb/Utility/Timer.h"
34#include "llvm/ADT/IntervalMap.h"
35#include "llvm/ADT/PointerUnion.h"
36#include "llvm/ADT/StringRef.h"
37#include "llvm/BinaryFormat/ELF.h"
38#include "llvm/Object/Decompressor.h"
39#include "llvm/Support/ARMBuildAttributes.h"
40#include "llvm/Support/CRC.h"
41#include "llvm/Support/FormatVariadic.h"
42#include "llvm/Support/MathExtras.h"
43#include "llvm/Support/MemoryBuffer.h"
44#include "llvm/Support/MipsABIFlags.h"

46#define CASE_AND_STREAM(s, def, width)case def: s->Printf("%-*s", width, "def"); break;                                         \
case def:                                                                    \
  s->Printf("%-*s", width, #def);                                            \
  break;

51using namespace lldb;
52using namespace lldb_private;
53using namespace elf;
54using namespace llvm::ELF;

56LLDB_PLUGIN_DEFINE(ObjectFileELF)namespace lldb_private { void lldb_initialize_ObjectFileELF()
 { ObjectFileELF::Initialize(); } void lldb_terminate_ObjectFileELF
() { ObjectFileELF::Terminate(); } }

58namespace {

60// ELF note owner definitions
61const char *const LLDB_NT_OWNER_FREEBSD = "FreeBSD";
62const char *const LLDB_NT_OWNER_GNU = "GNU";
63const char *const LLDB_NT_OWNER_NETBSD = "NetBSD";
64const char *const LLDB_NT_OWNER_NETBSDCORE = "NetBSD-CORE";
65const char *const LLDB_NT_OWNER_OPENBSD = "OpenBSD";
66const char *const LLDB_NT_OWNER_ANDROID = "Android";
67const char *const LLDB_NT_OWNER_CORE = "CORE";
68const char *const LLDB_NT_OWNER_LINUX = "LINUX";

70// ELF note type definitions
71const elf_word LLDB_NT_FREEBSD_ABI_TAG = 0x01;
72const elf_word LLDB_NT_FREEBSD_ABI_SIZE = 4;

74const elf_word LLDB_NT_GNU_ABI_TAG = 0x01;
75const elf_word LLDB_NT_GNU_ABI_SIZE = 16;

77const elf_word LLDB_NT_GNU_BUILD_ID_TAG = 0x03;

79const elf_word LLDB_NT_NETBSD_IDENT_TAG = 1;
80const elf_word LLDB_NT_NETBSD_IDENT_DESCSZ = 4;
81const elf_word LLDB_NT_NETBSD_IDENT_NAMESZ = 7;
82const elf_word LLDB_NT_NETBSD_PROCINFO = 1;

84// GNU ABI note OS constants
85const elf_word LLDB_NT_GNU_ABI_OS_LINUX = 0x00;
86const elf_word LLDB_NT_GNU_ABI_OS_HURD = 0x01;
87const elf_word LLDB_NT_GNU_ABI_OS_SOLARIS = 0x02;

89//===----------------------------------------------------------------------===//
90/// \class ELFRelocation
91/// Generic wrapper for ELFRel and ELFRela.
92///
93/// This helper class allows us to parse both ELFRel and ELFRela relocation
94/// entries in a generic manner.
95class ELFRelocation {
96public:
/// Constructs an ELFRelocation entry with a personality as given by @p
/// type.
///
/// \param type Either DT_REL or DT_RELA.  Any other value is invalid.
ELFRelocation(unsigned type);

~ELFRelocation();

bool Parse(const lldb_private::DataExtractor &data, lldb::offset_t *offset);

static unsigned RelocType32(const ELFRelocation &rel);

static unsigned RelocType64(const ELFRelocation &rel);

static unsigned RelocSymbol32(const ELFRelocation &rel);

static unsigned RelocSymbol64(const ELFRelocation &rel);

static unsigned RelocOffset32(const ELFRelocation &rel);

static unsigned RelocOffset64(const ELFRelocation &rel);

static unsigned RelocAddend32(const ELFRelocation &rel);

static unsigned RelocAddend64(const ELFRelocation &rel);

123private:
typedef llvm::PointerUnion<ELFRel *, ELFRela *> RelocUnion;

RelocUnion reloc;
127};

129ELFRelocation::ELFRelocation(unsigned type) {
if (type == DT_REL || type == SHT_REL)
  reloc = new ELFRel();
else if (type == DT_RELA || type == SHT_RELA)
  reloc = new ELFRela();
else {
  assert(false && "unexpected relocation type")((void)0);
  reloc = static_cast<ELFRel *>(nullptr);
}
138}

140ELFRelocation::~ELFRelocation() {
if (reloc.is<ELFRel *>())
  delete reloc.get<ELFRel *>();
else
  delete reloc.get<ELFRela *>();
145}

147bool ELFRelocation::Parse(const lldb_private::DataExtractor &data,
                        lldb::offset_t *offset) {
if (reloc.is<ELFRel *>())
  return reloc.get<ELFRel *>()->Parse(data, offset);
else
  return reloc.get<ELFRela *>()->Parse(data, offset);
153}

155unsigned ELFRelocation::RelocType32(const ELFRelocation &rel) {
if (rel.reloc.is<ELFRel *>())
  return ELFRel::RelocType32(*rel.reloc.get<ELFRel *>());
else
  return ELFRela::RelocType32(*rel.reloc.get<ELFRela *>());
160}

162unsigned ELFRelocation::RelocType64(const ELFRelocation &rel) {
if (rel.reloc.is<ELFRel *>())
  return ELFRel::RelocType64(*rel.reloc.get<ELFRel *>());
else
  return ELFRela::RelocType64(*rel.reloc.get<ELFRela *>());
167}

169unsigned ELFRelocation::RelocSymbol32(const ELFRelocation &rel) {
if (rel.reloc.is<ELFRel *>())
  return ELFRel::RelocSymbol32(*rel.reloc.get<ELFRel *>());
else
  return ELFRela::RelocSymbol32(*rel.reloc.get<ELFRela *>());
174}

176unsigned ELFRelocation::RelocSymbol64(const ELFRelocation &rel) {
if (rel.reloc.is<ELFRel *>())
  return ELFRel::RelocSymbol64(*rel.reloc.get<ELFRel *>());
else
  return ELFRela::RelocSymbol64(*rel.reloc.get<ELFRela *>());
181}

183unsigned ELFRelocation::RelocOffset32(const ELFRelocation &rel) {
if (rel.reloc.is<ELFRel *>())
  return rel.reloc.get<ELFRel *>()->r_offset;
else
  return rel.reloc.get<ELFRela *>()->r_offset;
188}

190unsigned ELFRelocation::RelocOffset64(const ELFRelocation &rel) {
if (rel.reloc.is<ELFRel *>())
  return rel.reloc.get<ELFRel *>()->r_offset;
else
  return rel.reloc.get<ELFRela *>()->r_offset;
195}

197unsigned ELFRelocation::RelocAddend32(const ELFRelocation &rel) {
if (rel.reloc.is<ELFRel *>())
  return 0;
else
  return rel.reloc.get<ELFRela *>()->r_addend;
202}

204unsigned ELFRelocation::RelocAddend64(const ELFRelocation &rel) {
if (rel.reloc.is<ELFRel *>())
  return 0;
else
  return rel.reloc.get<ELFRela *>()->r_addend;
209}

211} // end anonymous namespace

213static user_id_t SegmentID(size_t PHdrIndex) {
return ~user_id_t(PHdrIndex);
215}

217bool ELFNote::Parse(const DataExtractor &data, lldb::offset_t *offset) {
// Read all fields.
if (data.GetU32(offset, &n_namesz, 3) == nullptr)
  return false;

// The name field is required to be nul-terminated, and n_namesz includes the
// terminating nul in observed implementations (contrary to the ELF-64 spec).
// A special case is needed for cores generated by some older Linux versions,
// which write a note named "CORE" without a nul terminator and n_namesz = 4.
if (n_namesz == 4) {
  char buf[4];
  if (data.ExtractBytes(*offset, 4, data.GetByteOrder(), buf) != 4)
    return false;
  if (strncmp(buf, "CORE", 4) == 0) {
    n_name = "CORE";
    *offset += 4;
    return true;
  }
}

const char *cstr = data.GetCStr(offset, llvm::alignTo(n_namesz, 4));
if (cstr == nullptr) {
  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYMBOLS(1u << 20)));
  LLDB_LOGF(log, "Failed to parse note name lacking nul terminator")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("Failed to parse note name lacking nul terminator"
); } while (0);

  return false;
}
n_name = cstr;
return true;
246}

248static uint32_t mipsVariantFromElfFlags (const elf::ELFHeader &header) {
const uint32_t mips_arch = header.e_flags & llvm::ELF::EF_MIPS_ARCH;
uint32_t endian = header.e_ident[EI_DATA];
uint32_t arch_variant = ArchSpec::eMIPSSubType_unknown;
uint32_t fileclass = header.e_ident[EI_CLASS];

// If there aren't any elf flags available (e.g core elf file) then return
// default
// 32 or 64 bit arch (without any architecture revision) based on object file's class.
if (header.e_type == ET_CORE) {
  switch (fileclass) {
  case llvm::ELF::ELFCLASS32:
    return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips32el
                                   : ArchSpec::eMIPSSubType_mips32;
  case llvm::ELF::ELFCLASS64:
    return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips64el
                                   : ArchSpec::eMIPSSubType_mips64;
  default:
    return arch_variant;
  }
}

switch (mips_arch) {
case llvm::ELF::EF_MIPS_ARCH_1:
case llvm::ELF::EF_MIPS_ARCH_2:
case llvm::ELF::EF_MIPS_ARCH_32:
  return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips32el
                                 : ArchSpec::eMIPSSubType_mips32;
case llvm::ELF::EF_MIPS_ARCH_32R2:
  return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips32r2el
                                 : ArchSpec::eMIPSSubType_mips32r2;
case llvm::ELF::EF_MIPS_ARCH_32R6:
  return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips32r6el
                                 : ArchSpec::eMIPSSubType_mips32r6;
case llvm::ELF::EF_MIPS_ARCH_3:
case llvm::ELF::EF_MIPS_ARCH_4:
case llvm::ELF::EF_MIPS_ARCH_5:
case llvm::ELF::EF_MIPS_ARCH_64:
  return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips64el
                                 : ArchSpec::eMIPSSubType_mips64;
case llvm::ELF::EF_MIPS_ARCH_64R2:
  return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips64r2el
                                 : ArchSpec::eMIPSSubType_mips64r2;
case llvm::ELF::EF_MIPS_ARCH_64R6:
  return (endian == ELFDATA2LSB) ? ArchSpec::eMIPSSubType_mips64r6el
                                 : ArchSpec::eMIPSSubType_mips64r6;
default:
  break;
}

return arch_variant;
299}

301static uint32_t riscvVariantFromElfFlags(const elf::ELFHeader &header) {
uint32_t fileclass = header.e_ident[EI_CLASS];
switch (fileclass) {
case llvm::ELF::ELFCLASS32:
  return ArchSpec::eRISCVSubType_riscv32;
case llvm::ELF::ELFCLASS64:
  return ArchSpec::eRISCVSubType_riscv64;
default:
  return ArchSpec::eRISCVSubType_unknown;
}
311}

313static uint32_t subTypeFromElfHeader(const elf::ELFHeader &header) {
if (header.e_machine == llvm::ELF::EM_MIPS)
  return mipsVariantFromElfFlags(header);
else if (header.e_machine == llvm::ELF::EM_RISCV)
  return riscvVariantFromElfFlags(header);

return LLDB_INVALID_CPUTYPE(0xFFFFFFFEu);
320}

322char ObjectFileELF::ID;

324// Arbitrary constant used as UUID prefix for core files.
325const uint32_t ObjectFileELF::g_core_uuid_magic(0xE210C);

327// Static methods.
328void ObjectFileELF::Initialize() {
PluginManager::RegisterPlugin(GetPluginNameStatic(),
                              GetPluginDescriptionStatic(), CreateInstance,
                              CreateMemoryInstance, GetModuleSpecifications);
332}

334void ObjectFileELF::Terminate() {
PluginManager::UnregisterPlugin(CreateInstance);
336}

338lldb_private::ConstString ObjectFileELF::GetPluginNameStatic() {
static ConstString g_name("elf");
return g_name;
341}

343const char *ObjectFileELF::GetPluginDescriptionStatic() {
return "ELF object file reader.";
345}

347ObjectFile *ObjectFileELF::CreateInstance(const lldb::ModuleSP &module_sp,
                                        DataBufferSP &data_sp,
                                        lldb::offset_t data_offset,
                                        const lldb_private::FileSpec *file,
                                        lldb::offset_t file_offset,
                                        lldb::offset_t length) {
if (!data_sp) {
  data_sp = MapFileData(*file, length, file_offset);
  if (!data_sp)
    return nullptr;
  data_offset = 0;
}

assert(data_sp)((void)0);

if (data_sp->GetByteSize() <= (llvm::ELF::EI_NIDENT + data_offset))
  return nullptr;

const uint8_t *magic = data_sp->GetBytes() + data_offset;
if (!ELFHeader::MagicBytesMatch(magic))
  return nullptr;

// Update the data to contain the entire file if it doesn't already
if (data_sp->GetByteSize() < length) {
  data_sp = MapFileData(*file, length, file_offset);
  if (!data_sp)
    return nullptr;
  data_offset = 0;
  magic = data_sp->GetBytes();
}

unsigned address_size = ELFHeader::AddressSizeInBytes(magic);
if (address_size == 4 || address_size == 8) {
  std::unique_ptr<ObjectFileELF> objfile_up(new ObjectFileELF(
      module_sp, data_sp, data_offset, file, file_offset, length));
  ArchSpec spec = objfile_up->GetArchitecture();
  if (spec && objfile_up->SetModulesArchitecture(spec))
    return objfile_up.release();
}

return nullptr;
388}

390ObjectFile *ObjectFileELF::CreateMemoryInstance(
  const lldb::ModuleSP &module_sp, DataBufferSP &data_sp,
  const lldb::ProcessSP &process_sp, lldb::addr_t header_addr) {
if (data_sp && data_sp->GetByteSize() > (llvm::ELF::EI_NIDENT)) {
  const uint8_t *magic = data_sp->GetBytes();
  if (ELFHeader::MagicBytesMatch(magic)) {
    unsigned address_size = ELFHeader::AddressSizeInBytes(magic);
    if (address_size == 4 || address_size == 8) {
      std::unique_ptr<ObjectFileELF> objfile_up(
          new ObjectFileELF(module_sp, data_sp, process_sp, header_addr));
      ArchSpec spec = objfile_up->GetArchitecture();
      if (spec && objfile_up->SetModulesArchitecture(spec))
        return objfile_up.release();
    }
  }
}
return nullptr;
407}

409bool ObjectFileELF::MagicBytesMatch(DataBufferSP &data_sp,
                                  lldb::addr_t data_offset,
                                  lldb::addr_t data_length) {
if (data_sp &&
    data_sp->GetByteSize() > (llvm::ELF::EI_NIDENT + data_offset)) {
  const uint8_t *magic = data_sp->GetBytes() + data_offset;
  return ELFHeader::MagicBytesMatch(magic);
}
return false;
418}

420static uint32_t calc_crc32(uint32_t init, const DataExtractor &data) {
return llvm::crc32(
    init, llvm::makeArrayRef(data.GetDataStart(), data.GetByteSize()));
423}

425uint32_t ObjectFileELF::CalculateELFNotesSegmentsCRC32(
  const ProgramHeaderColl &program_headers, DataExtractor &object_data) {

uint32_t core_notes_crc = 0;

for (const ELFProgramHeader &H : program_headers) {
  if (H.p_type == llvm::ELF::PT_NOTE) {
    const elf_off ph_offset = H.p_offset;
    const size_t ph_size = H.p_filesz;

    DataExtractor segment_data;
    if (segment_data.SetData(object_data, ph_offset, ph_size) != ph_size) {
      // The ELF program header contained incorrect data, probably corefile
      // is incomplete or corrupted.
      break;
    }

    core_notes_crc = calc_crc32(core_notes_crc, segment_data);
  }
}

return core_notes_crc;
447}

449static const char *OSABIAsCString(unsigned char osabi_byte) {
450#define _MAKE_OSABI_CASE(x)                                                    \
case x:                                                                      \
  return #x
switch (osabi_byte) {
  _MAKE_OSABI_CASE(ELFOSABI_NONE);
  _MAKE_OSABI_CASE(ELFOSABI_HPUX);
  _MAKE_OSABI_CASE(ELFOSABI_NETBSD);
  _MAKE_OSABI_CASE(ELFOSABI_GNU);
  _MAKE_OSABI_CASE(ELFOSABI_HURD);
  _MAKE_OSABI_CASE(ELFOSABI_SOLARIS);
  _MAKE_OSABI_CASE(ELFOSABI_AIX);
  _MAKE_OSABI_CASE(ELFOSABI_IRIX);
  _MAKE_OSABI_CASE(ELFOSABI_FREEBSD);
  _MAKE_OSABI_CASE(ELFOSABI_TRU64);
  _MAKE_OSABI_CASE(ELFOSABI_MODESTO);
  _MAKE_OSABI_CASE(ELFOSABI_OPENBSD);
  _MAKE_OSABI_CASE(ELFOSABI_OPENVMS);
  _MAKE_OSABI_CASE(ELFOSABI_NSK);
  _MAKE_OSABI_CASE(ELFOSABI_AROS);
  _MAKE_OSABI_CASE(ELFOSABI_FENIXOS);
  _MAKE_OSABI_CASE(ELFOSABI_C6000_ELFABI);
  _MAKE_OSABI_CASE(ELFOSABI_C6000_LINUX);
  _MAKE_OSABI_CASE(ELFOSABI_ARM);
  _MAKE_OSABI_CASE(ELFOSABI_STANDALONE);
default:
  return "<unknown-osabi>";
}
477#undef _MAKE_OSABI_CASE
478}

480//
481// WARNING : This function is being deprecated
482// It's functionality has moved to ArchSpec::SetArchitecture This function is
483// only being kept to validate the move.
484//
485// TODO : Remove this function
486static bool GetOsFromOSABI(unsigned char osabi_byte,
                         llvm::Triple::OSType &ostype) {
switch (osabi_byte) {
case ELFOSABI_AIX:
  ostype = llvm::Triple::OSType::AIX;
  break;
case ELFOSABI_FREEBSD:
  ostype = llvm::Triple::OSType::FreeBSD;
  break;
case ELFOSABI_GNU:
  ostype = llvm::Triple::OSType::Linux;
  break;
case ELFOSABI_NETBSD:
  ostype = llvm::Triple::OSType::NetBSD;
  break;
case ELFOSABI_OPENBSD:
  ostype = llvm::Triple::OSType::OpenBSD;
  break;
case ELFOSABI_SOLARIS:
  ostype = llvm::Triple::OSType::Solaris;
  break;
default:
  ostype = llvm::Triple::OSType::UnknownOS;
}
return ostype != llvm::Triple::OSType::UnknownOS;
511}

513size_t ObjectFileELF::GetModuleSpecifications(
  const lldb_private::FileSpec &file, lldb::DataBufferSP &data_sp,
  lldb::offset_t data_offset, lldb::offset_t file_offset,
  lldb::offset_t length, lldb_private::ModuleSpecList &specs) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_MODULES(1u << 21)));

const size_t initial_count = specs.GetSize();

if (ObjectFileELF::MagicBytesMatch(data_sp, 0, data_sp->GetByteSize())) {
  DataExtractor data;
  data.SetData(data_sp);
  elf::ELFHeader header;
  lldb::offset_t header_offset = data_offset;
  if (header.Parse(data, &header_offset)) {
    if (data_sp) {
      ModuleSpec spec(file);

      const uint32_t sub_type = subTypeFromElfHeader(header);
      spec.GetArchitecture().SetArchitecture(
          eArchTypeELF, header.e_machine, sub_type, header.e_ident[EI_OSABI]);

      if (spec.GetArchitecture().IsValid()) {
        llvm::Triple::OSType ostype;
        llvm::Triple::VendorType vendor;
        llvm::Triple::OSType spec_ostype =
            spec.GetArchitecture().GetTriple().getOS();

        LLDB_LOGF(log, "ObjectFileELF::%s file '%s' module OSABI: %s",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s file '%s' module OSABI: %s"
, __FUNCTION__, file.GetPath().c_str(), OSABIAsCString(header
.e_ident[EI_OSABI])); } while (0)
                  __FUNCTION__, file.GetPath().c_str(),do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s file '%s' module OSABI: %s"
, __FUNCTION__, file.GetPath().c_str(), OSABIAsCString(header
.e_ident[EI_OSABI])); } while (0)
                  OSABIAsCString(header.e_ident[EI_OSABI]))do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s file '%s' module OSABI: %s"
, __FUNCTION__, file.GetPath().c_str(), OSABIAsCString(header
.e_ident[EI_OSABI])); } while (0);

        // SetArchitecture should have set the vendor to unknown
        vendor = spec.GetArchitecture().GetTriple().getVendor();
        assert(vendor == llvm::Triple::UnknownVendor)((void)0);
        UNUSED_IF_ASSERT_DISABLED(vendor)((void)(vendor));

        //
        // Validate it is ok to remove GetOsFromOSABI
        GetOsFromOSABI(header.e_ident[EI_OSABI], ostype);
        assert(spec_ostype == ostype)((void)0);
        if (spec_ostype != llvm::Triple::OSType::UnknownOS) {
          LLDB_LOGF(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s file '%s' set ELF module OS type "
 "from ELF header OSABI.", __FUNCTION__, file.GetPath().c_str
()); } while (0)
                    "ObjectFileELF::%s file '%s' set ELF module OS type "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s file '%s' set ELF module OS type "
 "from ELF header OSABI.", __FUNCTION__, file.GetPath().c_str
()); } while (0)
                    "from ELF header OSABI.",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s file '%s' set ELF module OS type "
 "from ELF header OSABI.", __FUNCTION__, file.GetPath().c_str
()); } while (0)
                    __FUNCTION__, file.GetPath().c_str())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s file '%s' set ELF module OS type "
 "from ELF header OSABI.", __FUNCTION__, file.GetPath().c_str
()); } while (0);
        }

        if (data_sp->GetByteSize() < length)
          data_sp = MapFileData(file, -1, file_offset);
        if (data_sp)
          data.SetData(data_sp);
        // In case there is header extension in the section #0, the header we
        // parsed above could have sentinel values for e_phnum, e_shnum, and
        // e_shstrndx.  In this case we need to reparse the header with a
        // bigger data source to get the actual values.
        if (header.HasHeaderExtension()) {
          lldb::offset_t header_offset = data_offset;
          header.Parse(data, &header_offset);
        }

        uint32_t gnu_debuglink_crc = 0;
        std::string gnu_debuglink_file;
        SectionHeaderColl section_headers;
        lldb_private::UUID &uuid = spec.GetUUID();

        GetSectionHeaderInfo(section_headers, data, header, uuid,
                             gnu_debuglink_file, gnu_debuglink_crc,
                             spec.GetArchitecture());

        llvm::Triple &spec_triple = spec.GetArchitecture().GetTriple();

        LLDB_LOGF(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s file '%s' module set to triple: %s "
 "(architecture %s)", __FUNCTION__, file.GetPath().c_str(), spec_triple
.getTriple().c_str(), spec.GetArchitecture().GetArchitectureName
()); } while (0)
                  "ObjectFileELF::%s file '%s' module set to triple: %s "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s file '%s' module set to triple: %s "
 "(architecture %s)", __FUNCTION__, file.GetPath().c_str(), spec_triple
.getTriple().c_str(), spec.GetArchitecture().GetArchitectureName
()); } while (0)
                  "(architecture %s)",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s file '%s' module set to triple: %s "
 "(architecture %s)", __FUNCTION__, file.GetPath().c_str(), spec_triple
.getTriple().c_str(), spec.GetArchitecture().GetArchitectureName
()); } while (0)
                  __FUNCTION__, file.GetPath().c_str(),do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s file '%s' module set to triple: %s "
 "(architecture %s)", __FUNCTION__, file.GetPath().c_str(), spec_triple
.getTriple().c_str(), spec.GetArchitecture().GetArchitectureName
()); } while (0)
                  spec_triple.getTriple().c_str(),do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s file '%s' module set to triple: %s "
 "(architecture %s)", __FUNCTION__, file.GetPath().c_str(), spec_triple
.getTriple().c_str(), spec.GetArchitecture().GetArchitectureName
()); } while (0)
                  spec.GetArchitecture().GetArchitectureName())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s file '%s' module set to triple: %s "
 "(architecture %s)", __FUNCTION__, file.GetPath().c_str(), spec_triple
.getTriple().c_str(), spec.GetArchitecture().GetArchitectureName
()); } while (0);

        if (!uuid.IsValid()) {
          uint32_t core_notes_crc = 0;

          if (!gnu_debuglink_crc) {
            LLDB_SCOPED_TIMERF(static ::lldb_private::Timer::Category _cat(__PRETTY_FUNCTION__
); ::lldb_private::Timer _scoped_timer(_cat, "Calculating module crc32 %s with size %"
 "llu" " KiB", file.GetLastPathComponent().AsCString(), (length
 - file_offset) / 1024); do { } while (0); auto _scoped_signpost
 = llvm::make_scope_exit([&_scoped_timer]() { ::lldb_private
::GetSignposts().endInterval(&_scoped_timer); })
                "Calculating module crc32 %s with size %" PRIu64 " KiB",static ::lldb_private::Timer::Category _cat(__PRETTY_FUNCTION__
); ::lldb_private::Timer _scoped_timer(_cat, "Calculating module crc32 %s with size %"
 "llu" " KiB", file.GetLastPathComponent().AsCString(), (length
 - file_offset) / 1024); do { } while (0); auto _scoped_signpost
 = llvm::make_scope_exit([&_scoped_timer]() { ::lldb_private
::GetSignposts().endInterval(&_scoped_timer); })
                file.GetLastPathComponent().AsCString(),static ::lldb_private::Timer::Category _cat(__PRETTY_FUNCTION__
); ::lldb_private::Timer _scoped_timer(_cat, "Calculating module crc32 %s with size %"
 "llu" " KiB", file.GetLastPathComponent().AsCString(), (length
 - file_offset) / 1024); do { } while (0); auto _scoped_signpost
 = llvm::make_scope_exit([&_scoped_timer]() { ::lldb_private
::GetSignposts().endInterval(&_scoped_timer); })
                (length - file_offset) / 1024)static ::lldb_private::Timer::Category _cat(__PRETTY_FUNCTION__
); ::lldb_private::Timer _scoped_timer(_cat, "Calculating module crc32 %s with size %"
 "llu" " KiB", file.GetLastPathComponent().AsCString(), (length
 - file_offset) / 1024); do { } while (0); auto _scoped_signpost
 = llvm::make_scope_exit([&_scoped_timer]() { ::lldb_private
::GetSignposts().endInterval(&_scoped_timer); });

            // For core files - which usually don't happen to have a
            // gnu_debuglink, and are pretty bulky - calculating whole
            // contents crc32 would be too much of luxury.  Thus we will need
            // to fallback to something simpler.
            if (header.e_type == llvm::ELF::ET_CORE) {
              ProgramHeaderColl program_headers;
              GetProgramHeaderInfo(program_headers, data, header);

              core_notes_crc =
                  CalculateELFNotesSegmentsCRC32(program_headers, data);
            } else {
              gnu_debuglink_crc = calc_crc32(0, data);
            }
          }
          using u32le = llvm::support::ulittle32_t;
          if (gnu_debuglink_crc) {
            // Use 4 bytes of crc from the .gnu_debuglink section.
            u32le data(gnu_debuglink_crc);
            uuid = UUID::fromData(&data, sizeof(data));
          } else if (core_notes_crc) {
            // Use 8 bytes - first 4 bytes for *magic* prefix, mainly to make
            // it look different form .gnu_debuglink crc followed by 4 bytes
            // of note segments crc.
            u32le data[] = {u32le(g_core_uuid_magic), u32le(core_notes_crc)};
            uuid = UUID::fromData(data, sizeof(data));
          }
        }

        specs.Append(spec);
      }
    }
  }
}

return specs.GetSize() - initial_count;
635}

637// PluginInterface protocol
638lldb_private::ConstString ObjectFileELF::GetPluginName() {
return GetPluginNameStatic();
640}

642uint32_t ObjectFileELF::GetPluginVersion() { return m_plugin_version; }
643// ObjectFile protocol

645ObjectFileELF::ObjectFileELF(const lldb::ModuleSP &module_sp,
                           DataBufferSP &data_sp, lldb::offset_t data_offset,
                           const FileSpec *file, lldb::offset_t file_offset,
                           lldb::offset_t length)
  : ObjectFile(module_sp, file, file_offset, length, data_sp, data_offset) {
if (file)
  m_file = *file;
652}

654ObjectFileELF::ObjectFileELF(const lldb::ModuleSP &module_sp,
                           DataBufferSP &header_data_sp,
                           const lldb::ProcessSP &process_sp,
                           addr_t header_addr)
  : ObjectFile(module_sp, process_sp, header_addr, header_data_sp) {}

660bool ObjectFileELF::IsExecutable() const {
return ((m_header.e_type & ET_EXEC) != 0) || (m_header.e_entry != 0);
662}

664bool ObjectFileELF::SetLoadAddress(Target &target, lldb::addr_t value,
                                 bool value_is_offset) {
ModuleSP module_sp = GetModule();
if (module_sp) {
  size_t num_loaded_sections = 0;
  SectionList *section_list = GetSectionList();
  if (section_list) {
    if (!value_is_offset) {
      addr_t base = GetBaseAddress().GetFileAddress();
      if (base == LLDB_INVALID_ADDRESS0xffffffffffffffffULL)
        return false;
      value -= base;
    }

    const size_t num_sections = section_list->GetSize();
    size_t sect_idx = 0;

    for (sect_idx = 0; sect_idx < num_sections; ++sect_idx) {
      // Iterate through the object file sections to find all of the sections
      // that have SHF_ALLOC in their flag bits.
      SectionSP section_sp(section_list->GetSectionAtIndex(sect_idx));
      if (section_sp->Test(SHF_ALLOC) ||
          section_sp->GetType() == eSectionTypeContainer) {
        lldb::addr_t load_addr = section_sp->GetFileAddress();
        // We don't want to update the load address of a section with type
        // eSectionTypeAbsoluteAddress as they already have the absolute load
        // address already specified
        if (section_sp->GetType() != eSectionTypeAbsoluteAddress)
          load_addr += value;

        // On 32-bit systems the load address have to fit into 4 bytes. The
        // rest of the bytes are the overflow from the addition.
        if (GetAddressByteSize() == 4)
          load_addr &= 0xFFFFFFFF;

        if (target.GetSectionLoadList().SetSectionLoadAddress(section_sp,
                                                              load_addr))
          ++num_loaded_sections;
      }
    }
    return num_loaded_sections > 0;
  }
}
return false;
708}

710ByteOrder ObjectFileELF::GetByteOrder() const {
if (m_header.e_ident[EI_DATA] == ELFDATA2MSB)
  return eByteOrderBig;
if (m_header.e_ident[EI_DATA] == ELFDATA2LSB)
  return eByteOrderLittle;
return eByteOrderInvalid;
716}

718uint32_t ObjectFileELF::GetAddressByteSize() const {
return m_data.GetAddressByteSize();
720}

722AddressClass ObjectFileELF::GetAddressClass(addr_t file_addr) {
Symtab *symtab = GetSymtab();
if (!symtab)
  return AddressClass::eUnknown;

// The address class is determined based on the symtab. Ask it from the
// object file what contains the symtab information.
ObjectFile *symtab_objfile = symtab->GetObjectFile();
if (symtab_objfile != nullptr && symtab_objfile != this)
  return symtab_objfile->GetAddressClass(file_addr);

auto res = ObjectFile::GetAddressClass(file_addr);
if (res != AddressClass::eCode)
  return res;

auto ub = m_address_class_map.upper_bound(file_addr);
if (ub == m_address_class_map.begin()) {
  // No entry in the address class map before the address. Return default
  // address class for an address in a code section.
  return AddressClass::eCode;
}

// Move iterator to the address class entry preceding address
--ub;

return ub->second;
748}

750size_t ObjectFileELF::SectionIndex(const SectionHeaderCollIter &I) {
return std::distance(m_section_headers.begin(), I);
752}

754size_t ObjectFileELF::SectionIndex(const SectionHeaderCollConstIter &I) const {
return std::distance(m_section_headers.begin(), I);
756}

758bool ObjectFileELF::ParseHeader() {
lldb::offset_t offset = 0;
return m_header.Parse(m_data, &offset);
761}

763UUID ObjectFileELF::GetUUID() {
// Need to parse the section list to get the UUIDs, so make sure that's been
// done.
if (!ParseSectionHeaders() && GetType() != ObjectFile::eTypeCoreFile)
  return UUID();

if (!m_uuid) {
  using u32le = llvm::support::ulittle32_t;
  if (GetType() == ObjectFile::eTypeCoreFile) {
    uint32_t core_notes_crc = 0;

    if (!ParseProgramHeaders())
      return UUID();

    core_notes_crc =
        CalculateELFNotesSegmentsCRC32(m_program_headers, m_data);

    if (core_notes_crc) {
      // Use 8 bytes - first 4 bytes for *magic* prefix, mainly to make it
      // look different form .gnu_debuglink crc - followed by 4 bytes of note
      // segments crc.
      u32le data[] = {u32le(g_core_uuid_magic), u32le(core_notes_crc)};
      m_uuid = UUID::fromData(data, sizeof(data));
    }
  } else {
    if (!m_gnu_debuglink_crc)
      m_gnu_debuglink_crc = calc_crc32(0, m_data);
    if (m_gnu_debuglink_crc) {
      // Use 4 bytes of crc from the .gnu_debuglink section.
      u32le data(m_gnu_debuglink_crc);
      m_uuid = UUID::fromData(&data, sizeof(data));
    }
  }
}

return m_uuid;
799}

801llvm::Optional<FileSpec> ObjectFileELF::GetDebugLink() {
if (m_gnu_debuglink_file.empty())
  return llvm::None;
return FileSpec(m_gnu_debuglink_file);
805}

807uint32_t ObjectFileELF::GetDependentModules(FileSpecList &files) {
size_t num_modules = ParseDependentModules();
uint32_t num_specs = 0;

for (unsigned i = 0; i < num_modules; ++i) {
  if (files.AppendIfUnique(m_filespec_up->GetFileSpecAtIndex(i)))
    num_specs++;
}

return num_specs;
817}

819Address ObjectFileELF::GetImageInfoAddress(Target *target) {
if (!ParseDynamicSymbols())
  return Address();

SectionList *section_list = GetSectionList();
if (!section_list)
  return Address();

// Find the SHT_DYNAMIC (.dynamic) section.
SectionSP dynsym_section_sp(
    section_list->FindSectionByType(eSectionTypeELFDynamicLinkInfo, true));
if (!dynsym_section_sp)
  return Address();
assert(dynsym_section_sp->GetObjectFile() == this)((void)0);

user_id_t dynsym_id = dynsym_section_sp->GetID();
const ELFSectionHeaderInfo *dynsym_hdr = GetSectionHeaderByIndex(dynsym_id);
if (!dynsym_hdr)
  return Address();

for (size_t i = 0; i < m_dynamic_symbols.size(); ++i) {
  ELFDynamic &symbol = m_dynamic_symbols[i];

  if (symbol.d_tag == DT_DEBUG) {
    // Compute the offset as the number of previous entries plus the size of
    // d_tag.
    addr_t offset = i * dynsym_hdr->sh_entsize + GetAddressByteSize();
    return Address(dynsym_section_sp, offset);
  }
  // MIPS executables uses DT_MIPS_RLD_MAP_REL to support PIE. DT_MIPS_RLD_MAP
  // exists in non-PIE.
  else if ((symbol.d_tag == DT_MIPS_RLD_MAP ||
            symbol.d_tag == DT_MIPS_RLD_MAP_REL) &&
           target) {
    addr_t offset = i * dynsym_hdr->sh_entsize + GetAddressByteSize();
    addr_t dyn_base = dynsym_section_sp->GetLoadBaseAddress(target);
    if (dyn_base == LLDB_INVALID_ADDRESS0xffffffffffffffffULL)
      return Address();

    Status error;
    if (symbol.d_tag == DT_MIPS_RLD_MAP) {
      // DT_MIPS_RLD_MAP tag stores an absolute address of the debug pointer.
      Address addr;
      if (target->ReadPointerFromMemory(dyn_base + offset, error, addr, true))
        return addr;
    }
    if (symbol.d_tag == DT_MIPS_RLD_MAP_REL) {
      // DT_MIPS_RLD_MAP_REL tag stores the offset to the debug pointer,
      // relative to the address of the tag.
      uint64_t rel_offset;
      rel_offset = target->ReadUnsignedIntegerFromMemory(
          dyn_base + offset, GetAddressByteSize(), UINT64_MAX0xffffffffffffffffULL, error, true);
      if (error.Success() && rel_offset != UINT64_MAX0xffffffffffffffffULL) {
        Address addr;
        addr_t debug_ptr_address =
            dyn_base + (offset - GetAddressByteSize()) + rel_offset;
        addr.SetOffset(debug_ptr_address);
        return addr;
      }
    }
  }
}

return Address();
883}

885lldb_private::Address ObjectFileELF::GetEntryPointAddress() {
if (m_entry_point_address.IsValid())
  return m_entry_point_address;

if (!ParseHeader() || !IsExecutable())
  return m_entry_point_address;

SectionList *section_list = GetSectionList();
addr_t offset = m_header.e_entry;

if (!section_list)
  m_entry_point_address.SetOffset(offset);
else
  m_entry_point_address.ResolveAddressUsingFileSections(offset, section_list);
return m_entry_point_address;
900}

902Address ObjectFileELF::GetBaseAddress() {
for (const auto &EnumPHdr : llvm::enumerate(ProgramHeaders())) {
  const ELFProgramHeader &H = EnumPHdr.value();
  if (H.p_type != PT_LOAD)
    continue;

  return Address(
      GetSectionList()->FindSectionByID(SegmentID(EnumPHdr.index())), 0);
}
return LLDB_INVALID_ADDRESS0xffffffffffffffffULL;
912}

914// ParseDependentModules
915size_t ObjectFileELF::ParseDependentModules() {
if (m_filespec_up)
  return m_filespec_up->GetSize();

m_filespec_up = std::make_unique<FileSpecList>();

if (!ParseSectionHeaders())
  return 0;

SectionList *section_list = GetSectionList();
if (!section_list)
  return 0;

// Find the SHT_DYNAMIC section.
Section *dynsym =
    section_list->FindSectionByType(eSectionTypeELFDynamicLinkInfo, true)
        .get();
if (!dynsym)
  return 0;
assert(dynsym->GetObjectFile() == this)((void)0);

const ELFSectionHeaderInfo *header = GetSectionHeaderByIndex(dynsym->GetID());
if (!header)
  return 0;
// sh_link: section header index of string table used by entries in the
// section.
Section *dynstr = section_list->FindSectionByID(header->sh_link).get();
if (!dynstr)
  return 0;

DataExtractor dynsym_data;
DataExtractor dynstr_data;
if (ReadSectionData(dynsym, dynsym_data) &&
    ReadSectionData(dynstr, dynstr_data)) {
  ELFDynamic symbol;
  const lldb::offset_t section_size = dynsym_data.GetByteSize();
  lldb::offset_t offset = 0;

  // The only type of entries we are concerned with are tagged DT_NEEDED,
  // yielding the name of a required library.
  while (offset < section_size) {
    if (!symbol.Parse(dynsym_data, &offset))
      break;

    if (symbol.d_tag != DT_NEEDED)
      continue;

    uint32_t str_index = static_cast<uint32_t>(symbol.d_val);
    const char *lib_name = dynstr_data.PeekCStr(str_index);
    FileSpec file_spec(lib_name);
    FileSystem::Instance().Resolve(file_spec);
    m_filespec_up->Append(file_spec);
  }
}

return m_filespec_up->GetSize();
971}

973// GetProgramHeaderInfo
974size_t ObjectFileELF::GetProgramHeaderInfo(ProgramHeaderColl &program_headers,
                                         DataExtractor &object_data,
                                         const ELFHeader &header) {
// We have already parsed the program headers
if (!program_headers.empty())
  return program_headers.size();

// If there are no program headers to read we are done.
if (header.e_phnum == 0)
  return 0;

program_headers.resize(header.e_phnum);
if (program_headers.size() != header.e_phnum)
  return 0;

const size_t ph_size = header.e_phnum * header.e_phentsize;
const elf_off ph_offset = header.e_phoff;
DataExtractor data;
if (data.SetData(object_data, ph_offset, ph_size) != ph_size)
  return 0;

uint32_t idx;
lldb::offset_t offset;
for (idx = 0, offset = 0; idx < header.e_phnum; ++idx) {
  if (!program_headers[idx].Parse(data, &offset))
    break;
}

if (idx < program_headers.size())
  program_headers.resize(idx);

return program_headers.size();
1006}

1008// ParseProgramHeaders
1009bool ObjectFileELF::ParseProgramHeaders() {
return GetProgramHeaderInfo(m_program_headers, m_data, m_header) != 0;
1011}

1013lldb_private::Status
1014ObjectFileELF::RefineModuleDetailsFromNote(lldb_private::DataExtractor &data,
                                         lldb_private::ArchSpec &arch_spec,
                                         lldb_private::UUID &uuid) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_MODULES(1u << 21)));
Status error;

lldb::offset_t offset = 0;

while (true) {
  // Parse the note header.  If this fails, bail out.
  const lldb::offset_t note_offset = offset;
  ELFNote note = ELFNote();
  if (!note.Parse(data, &offset)) {
    // We're done.
    return error;
  }

  LLDB_LOGF(log, "ObjectFileELF::%s parsing note name='%s', type=%" PRIu32,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s parsing note name='%s', type=%"
 "u", __FUNCTION__, note.n_name.c_str(), note.n_type); } while
 (0)
            __FUNCTION__, note.n_name.c_str(), note.n_type)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s parsing note name='%s', type=%"
 "u", __FUNCTION__, note.n_name.c_str(), note.n_type); } while
 (0);

  // Process FreeBSD ELF notes.
  if ((note.n_name == LLDB_NT_OWNER_FREEBSD) &&
      (note.n_type == LLDB_NT_FREEBSD_ABI_TAG) &&
      (note.n_descsz == LLDB_NT_FREEBSD_ABI_SIZE)) {
    // Pull out the min version info.
    uint32_t version_info;
    if (data.GetU32(&offset, &version_info, 1) == nullptr) {
      error.SetErrorString("failed to read FreeBSD ABI note payload");
      return error;
    }

    // Convert the version info into a major/minor number.
    const uint32_t version_major = version_info / 100000;
    const uint32_t version_minor = (version_info / 1000) % 100;

    char os_name[32];
    snprintf(os_name, sizeof(os_name), "freebsd%" PRIu32"u" ".%" PRIu32"u",
             version_major, version_minor);

    // Set the elf OS version to FreeBSD.  Also clear the vendor.
    arch_spec.GetTriple().setOSName(os_name);
    arch_spec.GetTriple().setVendor(llvm::Triple::VendorType::UnknownVendor);

    LLDB_LOGF(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s detected FreeBSD %"
 "u" ".%" "u" ".%" "u", __FUNCTION__, version_major, version_minor
, static_cast<uint32_t>(version_info % 1000)); } while (
0)
              "ObjectFileELF::%s detected FreeBSD %" PRIu32 ".%" PRIu32do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s detected FreeBSD %"
 "u" ".%" "u" ".%" "u", __FUNCTION__, version_major, version_minor
, static_cast<uint32_t>(version_info % 1000)); } while (
0)
              ".%" PRIu32,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s detected FreeBSD %"
 "u" ".%" "u" ".%" "u", __FUNCTION__, version_major, version_minor
, static_cast<uint32_t>(version_info % 1000)); } while (
0)
              __FUNCTION__, version_major, version_minor,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s detected FreeBSD %"
 "u" ".%" "u" ".%" "u", __FUNCTION__, version_major, version_minor
, static_cast<uint32_t>(version_info % 1000)); } while (
0)
              static_cast<uint32_t>(version_info % 1000))do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s detected FreeBSD %"
 "u" ".%" "u" ".%" "u", __FUNCTION__, version_major, version_minor
, static_cast<uint32_t>(version_info % 1000)); } while (
0);
  }
  // Process GNU ELF notes.
  else if (note.n_name == LLDB_NT_OWNER_GNU) {
    switch (note.n_type) {
    case LLDB_NT_GNU_ABI_TAG:
      if (note.n_descsz == LLDB_NT_GNU_ABI_SIZE) {
        // Pull out the min OS version supporting the ABI.
        uint32_t version_info[4];
        if (data.GetU32(&offset, &version_info[0], note.n_descsz / 4) ==
            nullptr) {
          error.SetErrorString("failed to read GNU ABI note payload");
          return error;
        }

        // Set the OS per the OS field.
        switch (version_info[0]) {
        case LLDB_NT_GNU_ABI_OS_LINUX:
          arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux);
          arch_spec.GetTriple().setVendor(
              llvm::Triple::VendorType::UnknownVendor);
          LLDB_LOGF(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s detected Linux, min version %"
 "u" ".%" "u" ".%" "u", __FUNCTION__, version_info[1], version_info
[2], version_info[3]); } while (0)
                    "ObjectFileELF::%s detected Linux, min version %" PRIu32do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s detected Linux, min version %"
 "u" ".%" "u" ".%" "u", __FUNCTION__, version_info[1], version_info
[2], version_info[3]); } while (0)
                    ".%" PRIu32 ".%" PRIu32,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s detected Linux, min version %"
 "u" ".%" "u" ".%" "u", __FUNCTION__, version_info[1], version_info
[2], version_info[3]); } while (0)
                    __FUNCTION__, version_info[1], version_info[2],do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s detected Linux, min version %"
 "u" ".%" "u" ".%" "u", __FUNCTION__, version_info[1], version_info
[2], version_info[3]); } while (0)
                    version_info[3])do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s detected Linux, min version %"
 "u" ".%" "u" ".%" "u", __FUNCTION__, version_info[1], version_info
[2], version_info[3]); } while (0);
          // FIXME we have the minimal version number, we could be propagating
          // that.  version_info[1] = OS Major, version_info[2] = OS Minor,
          // version_info[3] = Revision.
          break;
        case LLDB_NT_GNU_ABI_OS_HURD:
          arch_spec.GetTriple().setOS(llvm::Triple::OSType::UnknownOS);
          arch_spec.GetTriple().setVendor(
              llvm::Triple::VendorType::UnknownVendor);
          LLDB_LOGF(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s detected Hurd (unsupported), min "
 "version %" "u" ".%" "u" ".%" "u", __FUNCTION__, version_info
[1], version_info[2], version_info[3]); } while (0)
                    "ObjectFileELF::%s detected Hurd (unsupported), min "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s detected Hurd (unsupported), min "
 "version %" "u" ".%" "u" ".%" "u", __FUNCTION__, version_info
[1], version_info[2], version_info[3]); } while (0)
                    "version %" PRIu32 ".%" PRIu32 ".%" PRIu32,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s detected Hurd (unsupported), min "
 "version %" "u" ".%" "u" ".%" "u", __FUNCTION__, version_info
[1], version_info[2], version_info[3]); } while (0)
                    __FUNCTION__, version_info[1], version_info[2],do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s detected Hurd (unsupported), min "
 "version %" "u" ".%" "u" ".%" "u", __FUNCTION__, version_info
[1], version_info[2], version_info[3]); } while (0)
                    version_info[3])do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s detected Hurd (unsupported), min "
 "version %" "u" ".%" "u" ".%" "u", __FUNCTION__, version_info
[1], version_info[2], version_info[3]); } while (0);
          break;
        case LLDB_NT_GNU_ABI_OS_SOLARIS:
          arch_spec.GetTriple().setOS(llvm::Triple::OSType::Solaris);
          arch_spec.GetTriple().setVendor(
              llvm::Triple::VendorType::UnknownVendor);
          LLDB_LOGF(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s detected Solaris, min version %"
 "u" ".%" "u" ".%" "u", __FUNCTION__, version_info[1], version_info
[2], version_info[3]); } while (0)
                    "ObjectFileELF::%s detected Solaris, min version %" PRIu32do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s detected Solaris, min version %"
 "u" ".%" "u" ".%" "u", __FUNCTION__, version_info[1], version_info
[2], version_info[3]); } while (0)
                    ".%" PRIu32 ".%" PRIu32,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s detected Solaris, min version %"
 "u" ".%" "u" ".%" "u", __FUNCTION__, version_info[1], version_info
[2], version_info[3]); } while (0)
                    __FUNCTION__, version_info[1], version_info[2],do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s detected Solaris, min version %"
 "u" ".%" "u" ".%" "u", __FUNCTION__, version_info[1], version_info
[2], version_info[3]); } while (0)
                    version_info[3])do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s detected Solaris, min version %"
 "u" ".%" "u" ".%" "u", __FUNCTION__, version_info[1], version_info
[2], version_info[3]); } while (0);
          break;
        default:
          LLDB_LOGF(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s unrecognized OS in note, id %"
 "u" ", min version %" "u" ".%" "u" ".%" "u", __FUNCTION__, version_info
[0], version_info[1], version_info[2], version_info[3]); } while
 (0)
                    "ObjectFileELF::%s unrecognized OS in note, id %" PRIu32do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s unrecognized OS in note, id %"
 "u" ", min version %" "u" ".%" "u" ".%" "u", __FUNCTION__, version_info
[0], version_info[1], version_info[2], version_info[3]); } while
 (0)
                    ", min version %" PRIu32 ".%" PRIu32 ".%" PRIu32,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s unrecognized OS in note, id %"
 "u" ", min version %" "u" ".%" "u" ".%" "u", __FUNCTION__, version_info
[0], version_info[1], version_info[2], version_info[3]); } while
 (0)
                    __FUNCTION__, version_info[0], version_info[1],do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s unrecognized OS in note, id %"
 "u" ", min version %" "u" ".%" "u" ".%" "u", __FUNCTION__, version_info
[0], version_info[1], version_info[2], version_info[3]); } while
 (0)
                    version_info[2], version_info[3])do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s unrecognized OS in note, id %"
 "u" ", min version %" "u" ".%" "u" ".%" "u", __FUNCTION__, version_info
[0], version_info[1], version_info[2], version_info[3]); } while
 (0);
          break;
        }
      }
      break;

    case LLDB_NT_GNU_BUILD_ID_TAG:
      // Only bother processing this if we don't already have the uuid set.
      if (!uuid.IsValid()) {
        // 16 bytes is UUID|MD5, 20 bytes is SHA1. Other linkers may produce a
        // build-id of a different length. Accept it as long as it's at least
        // 4 bytes as it will be better than our own crc32.
        if (note.n_descsz >= 4) {
          if (const uint8_t *buf = data.PeekData(offset, note.n_descsz)) {
            // Save the build id as the UUID for the module.
            uuid = UUID::fromData(buf, note.n_descsz);
          } else {
            error.SetErrorString("failed to read GNU_BUILD_ID note payload");
            return error;
          }
        }
      }
      break;
    }
    if (arch_spec.IsMIPS() &&
        arch_spec.GetTriple().getOS() == llvm::Triple::OSType::UnknownOS)
      // The note.n_name == LLDB_NT_OWNER_GNU is valid for Linux platform
      arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux);
  }
  // Process NetBSD ELF executables and shared libraries
  else if ((note.n_name == LLDB_NT_OWNER_NETBSD) &&
           (note.n_type == LLDB_NT_NETBSD_IDENT_TAG) &&
           (note.n_descsz == LLDB_NT_NETBSD_IDENT_DESCSZ) &&
           (note.n_namesz == LLDB_NT_NETBSD_IDENT_NAMESZ)) {
    // Pull out the version info.
    uint32_t version_info;
    if (data.GetU32(&offset, &version_info, 1) == nullptr) {
      error.SetErrorString("failed to read NetBSD ABI note payload");
      return error;
    }
    // Convert the version info into a major/minor/patch number.
    //     #define __NetBSD_Version__ MMmmrrpp00
    //
    //     M = major version
    //     m = minor version; a minor number of 99 indicates current.
    //     r = 0 (since NetBSD 3.0 not used)
    //     p = patchlevel
    const uint32_t version_major = version_info / 100000000;
    const uint32_t version_minor = (version_info % 100000000) / 1000000;
    const uint32_t version_patch = (version_info % 10000) / 100;
    // Set the elf OS version to NetBSD.  Also clear the vendor.
    arch_spec.GetTriple().setOSName(
        llvm::formatv("netbsd{0}.{1}.{2}", version_major, version_minor,
                      version_patch).str());
    arch_spec.GetTriple().setVendor(llvm::Triple::VendorType::UnknownVendor);
  }
  // Process NetBSD ELF core(5) notes
  else if ((note.n_name == LLDB_NT_OWNER_NETBSDCORE) &&
           (note.n_type == LLDB_NT_NETBSD_PROCINFO)) {
    // Set the elf OS version to NetBSD.  Also clear the vendor.
    arch_spec.GetTriple().setOS(llvm::Triple::OSType::NetBSD);
    arch_spec.GetTriple().setVendor(llvm::Triple::VendorType::UnknownVendor);
  }
  // Process OpenBSD ELF notes.
  else if (note.n_name == LLDB_NT_OWNER_OPENBSD) {
    // Set the elf OS version to OpenBSD.  Also clear the vendor.
    arch_spec.GetTriple().setOS(llvm::Triple::OSType::OpenBSD);
    arch_spec.GetTriple().setVendor(llvm::Triple::VendorType::UnknownVendor);
  } else if (note.n_name == LLDB_NT_OWNER_ANDROID) {
    arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux);
    arch_spec.GetTriple().setEnvironment(
        llvm::Triple::EnvironmentType::Android);
  } else if (note.n_name == LLDB_NT_OWNER_LINUX) {
    // This is sometimes found in core files and usually contains extended
    // register info
    arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux);
  } else if (note.n_name == LLDB_NT_OWNER_CORE) {
    // Parse the NT_FILE to look for stuff in paths to shared libraries As
    // the contents look like this in a 64 bit ELF core file: count     =
    // 0x000000000000000a (10) page_size = 0x0000000000001000 (4096) Index
    // start              end                file_ofs           path =====
    // 0x0000000000401000 0x0000000000000000 /tmp/a.out [  1]
    // 0x0000000000600000 0x0000000000601000 0x0000000000000000 /tmp/a.out [
    // 2] 0x0000000000601000 0x0000000000602000 0x0000000000000001 /tmp/a.out
    // [  3] 0x00007fa79c9ed000 0x00007fa79cba8000 0x0000000000000000
    // /lib/x86_64-linux-gnu/libc-2.19.so [  4] 0x00007fa79cba8000
    // 0x00007fa79cda7000 0x00000000000001bb /lib/x86_64-linux-
    // gnu/libc-2.19.so [  5] 0x00007fa79cda7000 0x00007fa79cdab000
    // 0x00000000000001ba /lib/x86_64-linux-gnu/libc-2.19.so [  6]
    // 0x00007fa79cdab000 0x00007fa79cdad000 0x00000000000001be /lib/x86_64
    // -linux-gnu/libc-2.19.so [  7] 0x00007fa79cdb2000 0x00007fa79cdd5000
    // 0x0000000000000000 /lib/x86_64-linux-gnu/ld-2.19.so [  8]
    // 0x00007fa79cfd4000 0x00007fa79cfd5000 0x0000000000000022 /lib/x86_64
    // -linux-gnu/ld-2.19.so [  9] 0x00007fa79cfd5000 0x00007fa79cfd6000
    // 0x0000000000000023 /lib/x86_64-linux-gnu/ld-2.19.so In the 32 bit ELFs
    // the count, page_size, start, end, file_ofs are uint32_t For reference:
    // see readelf source code (in binutils).
    if (note.n_type == NT_FILE) {
      uint64_t count = data.GetAddress(&offset);
      const char *cstr;
      data.GetAddress(&offset); // Skip page size
      offset += count * 3 *
                data.GetAddressByteSize(); // Skip all start/end/file_ofs
      for (size_t i = 0; i < count; ++i) {
        cstr = data.GetCStr(&offset);
        if (cstr == nullptr) {
          error.SetErrorStringWithFormat("ObjectFileELF::%s trying to read "
                                         "at an offset after the end "
                                         "(GetCStr returned nullptr)",
                                         __FUNCTION__);
          return error;
        }
        llvm::StringRef path(cstr);
        if (path.contains("/lib/x86_64-linux-gnu") || path.contains("/lib/i386-linux-gnu")) {
          arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux);
          break;
        }
      }
      if (arch_spec.IsMIPS() &&
          arch_spec.GetTriple().getOS() == llvm::Triple::OSType::UnknownOS)
        // In case of MIPSR6, the LLDB_NT_OWNER_GNU note is missing for some
        // cases (e.g. compile with -nostdlib) Hence set OS to Linux
        arch_spec.GetTriple().setOS(llvm::Triple::OSType::Linux);
    }
  }

  // Calculate the offset of the next note just in case "offset" has been
  // used to poke at the contents of the note data
  offset = note_offset + note.GetByteSize();
}

return error;
1248}

1250void ObjectFileELF::ParseARMAttributes(DataExtractor &data, uint64_t length,
                                     ArchSpec &arch_spec) {
lldb::offset_t Offset = 0;

uint8_t FormatVersion = data.GetU8(&Offset);
if (FormatVersion != llvm::ELFAttrs::Format_Version)
  return;

Offset = Offset + sizeof(uint32_t); // Section Length
llvm::StringRef VendorName = data.GetCStr(&Offset);

if (VendorName != "aeabi")
  return;

if (arch_spec.GetTriple().getEnvironment() ==
    llvm::Triple::UnknownEnvironment)
  arch_spec.GetTriple().setEnvironment(llvm::Triple::EABI);

while (Offset < length) {
  uint8_t Tag = data.GetU8(&Offset);
  uint32_t Size = data.GetU32(&Offset);

  if (Tag != llvm::ARMBuildAttrs::File || Size == 0)
    continue;

  while (Offset < length) {
    uint64_t Tag = data.GetULEB128(&Offset);
    switch (Tag) {
    default:
      if (Tag < 32)
        data.GetULEB128(&Offset);
      else if (Tag % 2 == 0)
        data.GetULEB128(&Offset);
      else
        data.GetCStr(&Offset);

      break;

    case llvm::ARMBuildAttrs::CPU_raw_name:
    case llvm::ARMBuildAttrs::CPU_name:
      data.GetCStr(&Offset);

      break;

    case llvm::ARMBuildAttrs::ABI_VFP_args: {
      uint64_t VFPArgs = data.GetULEB128(&Offset);

      if (VFPArgs == llvm::ARMBuildAttrs::BaseAAPCS) {
        if (arch_spec.GetTriple().getEnvironment() ==
                llvm::Triple::UnknownEnvironment ||
            arch_spec.GetTriple().getEnvironment() == llvm::Triple::EABIHF)
          arch_spec.GetTriple().setEnvironment(llvm::Triple::EABI);

        arch_spec.SetFlags(ArchSpec::eARM_abi_soft_float);
      } else if (VFPArgs == llvm::ARMBuildAttrs::HardFPAAPCS) {
        if (arch_spec.GetTriple().getEnvironment() ==
                llvm::Triple::UnknownEnvironment ||
            arch_spec.GetTriple().getEnvironment() == llvm::Triple::EABI)
          arch_spec.GetTriple().setEnvironment(llvm::Triple::EABIHF);

        arch_spec.SetFlags(ArchSpec::eARM_abi_hard_float);
      }

      break;
    }
    }
  }
}
1318}

1320// GetSectionHeaderInfo
1321size_t ObjectFileELF::GetSectionHeaderInfo(SectionHeaderColl &section_headers,
                                         DataExtractor &object_data,
                                         const elf::ELFHeader &header,
                                         lldb_private::UUID &uuid,
                                         std::string &gnu_debuglink_file,
                                         uint32_t &gnu_debuglink_crc,
                                         ArchSpec &arch_spec) {
// Don't reparse the section headers if we already did that.
if (!section_headers.empty())
  return section_headers.size();

// Only initialize the arch_spec to okay defaults if they're not already set.
// We'll refine this with note data as we parse the notes.
if (arch_spec.GetTriple().getOS() == llvm::Triple::OSType::UnknownOS) {
  llvm::Triple::OSType ostype;
  llvm::Triple::OSType spec_ostype;
  const uint32_t sub_type = subTypeFromElfHeader(header);
  arch_spec.SetArchitecture(eArchTypeELF, header.e_machine, sub_type,
                            header.e_ident[EI_OSABI]);

  // Validate if it is ok to remove GetOsFromOSABI. Note, that now the OS is
  // determined based on EI_OSABI flag and the info extracted from ELF notes
  // (see RefineModuleDetailsFromNote). However in some cases that still
  // might be not enough: for example a shared library might not have any
  // notes at all and have EI_OSABI flag set to System V, as result the OS
  // will be set to UnknownOS.
  GetOsFromOSABI(header.e_ident[EI_OSABI], ostype);
  spec_ostype = arch_spec.GetTriple().getOS();
  assert(spec_ostype == ostype)((void)0);
  UNUSED_IF_ASSERT_DISABLED(spec_ostype)((void)(spec_ostype));
}

if (arch_spec.GetMachine() == llvm::Triple::mips ||
    arch_spec.GetMachine() == llvm::Triple::mipsel ||
    arch_spec.GetMachine() == llvm::Triple::mips64 ||
    arch_spec.GetMachine() == llvm::Triple::mips64el) {
  switch (header.e_flags & llvm::ELF::EF_MIPS_ARCH_ASE) {
  case llvm::ELF::EF_MIPS_MICROMIPS:
    arch_spec.SetFlags(ArchSpec::eMIPSAse_micromips);
    break;
  case llvm::ELF::EF_MIPS_ARCH_ASE_M16:
    arch_spec.SetFlags(ArchSpec::eMIPSAse_mips16);
    break;
  case llvm::ELF::EF_MIPS_ARCH_ASE_MDMX:
    arch_spec.SetFlags(ArchSpec::eMIPSAse_mdmx);
    break;
  default:
    break;
  }
}

if (arch_spec.GetMachine() == llvm::Triple::arm ||
    arch_spec.GetMachine() == llvm::Triple::thumb) {
  if (header.e_flags & llvm::ELF::EF_ARM_SOFT_FLOAT)
    arch_spec.SetFlags(ArchSpec::eARM_abi_soft_float);
  else if (header.e_flags & llvm::ELF::EF_ARM_VFP_FLOAT)
    arch_spec.SetFlags(ArchSpec::eARM_abi_hard_float);
}

// If there are no section headers we are done.
if (header.e_shnum == 0)
  return 0;

Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_MODULES(1u << 21)));

section_headers.resize(header.e_shnum);
if (section_headers.size() != header.e_shnum)
  return 0;

const size_t sh_size = header.e_shnum * header.e_shentsize;
const elf_off sh_offset = header.e_shoff;
DataExtractor sh_data;
if (sh_data.SetData(object_data, sh_offset, sh_size) != sh_size)
  return 0;

uint32_t idx;
lldb::offset_t offset;
for (idx = 0, offset = 0; idx < header.e_shnum; ++idx) {
  if (!section_headers[idx].Parse(sh_data, &offset))
    break;
}
if (idx < section_headers.size())
  section_headers.resize(idx);

const unsigned strtab_idx = header.e_shstrndx;
if (strtab_idx && strtab_idx < section_headers.size()) {
  const ELFSectionHeaderInfo &sheader = section_headers[strtab_idx];
  const size_t byte_size = sheader.sh_size;
  const Elf64_Off offset = sheader.sh_offset;
  lldb_private::DataExtractor shstr_data;

  if (shstr_data.SetData(object_data, offset, byte_size) == byte_size) {
    for (SectionHeaderCollIter I = section_headers.begin();
         I != section_headers.end(); ++I) {
      static ConstString g_sect_name_gnu_debuglink(".gnu_debuglink");
      const ELFSectionHeaderInfo &sheader = *I;
      const uint64_t section_size =
          sheader.sh_type == SHT_NOBITS ? 0 : sheader.sh_size;
      ConstString name(shstr_data.PeekCStr(I->sh_name));

      I->section_name = name;

      if (arch_spec.IsMIPS()) {
        uint32_t arch_flags = arch_spec.GetFlags();
        DataExtractor data;
        if (sheader.sh_type == SHT_MIPS_ABIFLAGS) {

          if (section_size && (data.SetData(object_data, sheader.sh_offset,
                                            section_size) == section_size)) {
            // MIPS ASE Mask is at offset 12 in MIPS.abiflags section
            lldb::offset_t offset = 12; // MIPS ABI Flags Version: 0
            arch_flags |= data.GetU32(&offset);

            // The floating point ABI is at offset 7
            offset = 7;
            switch (data.GetU8(&offset)) {
            case llvm::Mips::Val_GNU_MIPS_ABI_FP_ANY:
              arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_ANY;
              break;
            case llvm::Mips::Val_GNU_MIPS_ABI_FP_DOUBLE:
              arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_DOUBLE;
              break;
            case llvm::Mips::Val_GNU_MIPS_ABI_FP_SINGLE:
              arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_SINGLE;
              break;
            case llvm::Mips::Val_GNU_MIPS_ABI_FP_SOFT:
              arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_SOFT;
              break;
            case llvm::Mips::Val_GNU_MIPS_ABI_FP_OLD_64:
              arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_OLD_64;
              break;
            case llvm::Mips::Val_GNU_MIPS_ABI_FP_XX:
              arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_XX;
              break;
            case llvm::Mips::Val_GNU_MIPS_ABI_FP_64:
              arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_64;
              break;
            case llvm::Mips::Val_GNU_MIPS_ABI_FP_64A:
              arch_flags |= lldb_private::ArchSpec::eMIPS_ABI_FP_64A;
              break;
            }
          }
        }
        // Settings appropriate ArchSpec ABI Flags
        switch (header.e_flags & llvm::ELF::EF_MIPS_ABI) {
        case llvm::ELF::EF_MIPS_ABI_O32:
          arch_flags |= lldb_private::ArchSpec::eMIPSABI_O32;
          break;
        case EF_MIPS_ABI_O64:
          arch_flags |= lldb_private::ArchSpec::eMIPSABI_O64;
          break;
        case EF_MIPS_ABI_EABI32:
          arch_flags |= lldb_private::ArchSpec::eMIPSABI_EABI32;
          break;
        case EF_MIPS_ABI_EABI64:
          arch_flags |= lldb_private::ArchSpec::eMIPSABI_EABI64;
          break;
        default:
          // ABI Mask doesn't cover N32 and N64 ABI.
          if (header.e_ident[EI_CLASS] == llvm::ELF::ELFCLASS64)
            arch_flags |= lldb_private::ArchSpec::eMIPSABI_N64;
          else if (header.e_flags & llvm::ELF::EF_MIPS_ABI2)
            arch_flags |= lldb_private::ArchSpec::eMIPSABI_N32;
          break;
        }
        arch_spec.SetFlags(arch_flags);
      }

      if (arch_spec.GetMachine() == llvm::Triple::arm ||
          arch_spec.GetMachine() == llvm::Triple::thumb) {
        DataExtractor data;

        if (sheader.sh_type == SHT_ARM_ATTRIBUTES && section_size != 0 &&
            data.SetData(object_data, sheader.sh_offset, section_size) == section_size)
          ParseARMAttributes(data, section_size, arch_spec);
      }

      if (name == g_sect_name_gnu_debuglink) {
        DataExtractor data;
        if (section_size && (data.SetData(object_data, sheader.sh_offset,
                                          section_size) == section_size)) {
          lldb::offset_t gnu_debuglink_offset = 0;
          gnu_debuglink_file = data.GetCStr(&gnu_debuglink_offset);
          gnu_debuglink_offset = llvm::alignTo(gnu_debuglink_offset, 4);
          data.GetU32(&gnu_debuglink_offset, &gnu_debuglink_crc, 1);
        }
      }

      // Process ELF note section entries.
      bool is_note_header = (sheader.sh_type == SHT_NOTE);

      // The section header ".note.android.ident" is stored as a
      // PROGBITS type header but it is actually a note header.
      static ConstString g_sect_name_android_ident(".note.android.ident");
      if (!is_note_header && name == g_sect_name_android_ident)
        is_note_header = true;

      if (is_note_header) {
        // Allow notes to refine module info.
        DataExtractor data;
        if (section_size && (data.SetData(object_data, sheader.sh_offset,
                                          section_size) == section_size)) {
          Status error = RefineModuleDetailsFromNote(data, arch_spec, uuid);
          if (error.Fail()) {
            LLDB_LOGF(log, "ObjectFileELF::%s ELF note processing failed: %s",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s ELF note processing failed: %s"
, __FUNCTION__, error.AsCString()); } while (0)
                      __FUNCTION__, error.AsCString())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("ObjectFileELF::%s ELF note processing failed: %s"
, __FUNCTION__, error.AsCString()); } while (0);
          }
        }
      }
    }

    // Make any unknown triple components to be unspecified unknowns.
    if (arch_spec.GetTriple().getVendor() == llvm::Triple::UnknownVendor)
      arch_spec.GetTriple().setVendorName(llvm::StringRef());
    if (arch_spec.GetTriple().getOS() == llvm::Triple::UnknownOS)
      arch_spec.GetTriple().setOSName(llvm::StringRef());

    return section_headers.size();
  }
}

section_headers.clear();
return 0;
1544}

1546llvm::StringRef
1547ObjectFileELF::StripLinkerSymbolAnnotations(llvm::StringRef symbol_name) const {
size_t pos = symbol_name.find('@');
return symbol_name.substr(0, pos);
1550}

1552// ParseSectionHeaders
1553size_t ObjectFileELF::ParseSectionHeaders() {
return GetSectionHeaderInfo(m_section_headers, m_data, m_header, m_uuid,
                            m_gnu_debuglink_file, m_gnu_debuglink_crc,
                            m_arch_spec);
1557}

1559const ObjectFileELF::ELFSectionHeaderInfo *
1560ObjectFileELF::GetSectionHeaderByIndex(lldb::user_id_t id) {
if (!ParseSectionHeaders())
  return nullptr;

if (id < m_section_headers.size())
  return &m_section_headers[id];

return nullptr;
1568}

1570lldb::user_id_t ObjectFileELF::GetSectionIndexByName(const char *name) {
if (!name || !name[0] || !ParseSectionHeaders())
  return 0;
for (size_t i = 1; i < m_section_headers.size(); ++i)
  if (m_section_headers[i].section_name == ConstString(name))
    return i;
return 0;
1577}

1579static SectionType GetSectionTypeFromName(llvm::StringRef Name) {
if (Name.consume_front(".debug_") || Name.consume_front(".zdebug_")) {
  return llvm::StringSwitch<SectionType>(Name)
      .Case("abbrev", eSectionTypeDWARFDebugAbbrev)
      .Case("abbrev.dwo", eSectionTypeDWARFDebugAbbrevDwo)
      .Case("addr", eSectionTypeDWARFDebugAddr)
      .Case("aranges", eSectionTypeDWARFDebugAranges)
      .Case("cu_index", eSectionTypeDWARFDebugCuIndex)
      .Case("frame", eSectionTypeDWARFDebugFrame)
      .Case("info", eSectionTypeDWARFDebugInfo)
      .Case("info.dwo", eSectionTypeDWARFDebugInfoDwo)
      .Cases("line", "line.dwo", eSectionTypeDWARFDebugLine)
      .Cases("line_str", "line_str.dwo", eSectionTypeDWARFDebugLineStr)
      .Case("loc", eSectionTypeDWARFDebugLoc)
      .Case("loc.dwo", eSectionTypeDWARFDebugLocDwo)
      .Case("loclists", eSectionTypeDWARFDebugLocLists)
      .Case("loclists.dwo", eSectionTypeDWARFDebugLocListsDwo)
      .Case("macinfo", eSectionTypeDWARFDebugMacInfo)
      .Cases("macro", "macro.dwo", eSectionTypeDWARFDebugMacro)
      .Case("names", eSectionTypeDWARFDebugNames)
      .Case("pubnames", eSectionTypeDWARFDebugPubNames)
      .Case("pubtypes", eSectionTypeDWARFDebugPubTypes)
      .Case("ranges", eSectionTypeDWARFDebugRanges)
      .Case("rnglists", eSectionTypeDWARFDebugRngLists)
      .Case("rnglists.dwo", eSectionTypeDWARFDebugRngListsDwo)
      .Case("str", eSectionTypeDWARFDebugStr)
      .Case("str.dwo", eSectionTypeDWARFDebugStrDwo)
      .Case("str_offsets", eSectionTypeDWARFDebugStrOffsets)
      .Case("str_offsets.dwo", eSectionTypeDWARFDebugStrOffsetsDwo)
      .Case("tu_index", eSectionTypeDWARFDebugTuIndex)
      .Case("types", eSectionTypeDWARFDebugTypes)
      .Case("types.dwo", eSectionTypeDWARFDebugTypesDwo)
      .Default(eSectionTypeOther);
}
return llvm::StringSwitch<SectionType>(Name)
    .Case(".ARM.exidx", eSectionTypeARMexidx)
    .Case(".ARM.extab", eSectionTypeARMextab)
    .Cases(".bss", ".tbss", eSectionTypeZeroFill)
    .Cases(".data", ".tdata", eSectionTypeData)
    .Case(".eh_frame", eSectionTypeEHFrame)
    .Case(".gnu_debugaltlink", eSectionTypeDWARFGNUDebugAltLink)
    .Case(".gosymtab", eSectionTypeGoSymtab)
    .Case(".text", eSectionTypeCode)
    .Default(eSectionTypeOther);
1623}

1625SectionType ObjectFileELF::GetSectionType(const ELFSectionHeaderInfo &H) const {
switch (H.sh_type) {
case SHT_PROGBITS:
  if (H.sh_flags & SHF_EXECINSTR)
    return eSectionTypeCode;
  break;
case SHT_SYMTAB:
  return eSectionTypeELFSymbolTable;
case SHT_DYNSYM:
  return eSectionTypeELFDynamicSymbols;
case SHT_RELA:
case SHT_REL:
  return eSectionTypeELFRelocationEntries;
case SHT_DYNAMIC:
  return eSectionTypeELFDynamicLinkInfo;
}
return GetSectionTypeFromName(H.section_name.GetStringRef());
1642}

1644static uint32_t GetTargetByteSize(SectionType Type, const ArchSpec &arch) {
switch (Type) {
case eSectionTypeData:
case eSectionTypeZeroFill:
  return arch.GetDataByteSize();
case eSectionTypeCode:
  return arch.GetCodeByteSize();
default:
  return 1;
}
1654}

1656static Permissions GetPermissions(const ELFSectionHeader &H) {
Permissions Perm = Permissions(0);
if (H.sh_flags & SHF_ALLOC)
  Perm |= ePermissionsReadable;
if (H.sh_flags & SHF_WRITE)
  Perm |= ePermissionsWritable;
if (H.sh_flags & SHF_EXECINSTR)
  Perm |= ePermissionsExecutable;
return Perm;
1665}

1667static Permissions GetPermissions(const ELFProgramHeader &H) {
Permissions Perm = Permissions(0);
if (H.p_flags & PF_R)
  Perm |= ePermissionsReadable;
if (H.p_flags & PF_W)
  Perm |= ePermissionsWritable;
if (H.p_flags & PF_X)
  Perm |= ePermissionsExecutable;
return Perm;
1676}

1678namespace {

1680using VMRange = lldb_private::Range<addr_t, addr_t>;

1682struct SectionAddressInfo {
SectionSP Segment;
VMRange Range;
1685};

1687// (Unlinked) ELF object files usually have 0 for every section address, meaning
1688// we need to compute synthetic addresses in order for "file addresses" from
1689// different sections to not overlap. This class handles that logic.
1690class VMAddressProvider {
using VMMap = llvm::IntervalMap<addr_t, SectionSP, 4,
                                     llvm::IntervalMapHalfOpenInfo<addr_t>>;

ObjectFile::Type ObjectType;
addr_t NextVMAddress = 0;
VMMap::Allocator Alloc;
VMMap Segments = VMMap(Alloc);
VMMap Sections = VMMap(Alloc);
lldb_private::Log *Log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_MODULES(1u << 21));
size_t SegmentCount = 0;
std::string SegmentName;

VMRange GetVMRange(const ELFSectionHeader &H) {
  addr_t Address = H.sh_addr;
  addr_t Size = H.sh_flags & SHF_ALLOC ? H.sh_size : 0;
  if (ObjectType == ObjectFile::Type::eTypeObjectFile && Segments.empty() && (H.sh_flags & SHF_ALLOC)) {
    NextVMAddress =
        llvm::alignTo(NextVMAddress, std::max<addr_t>(H.sh_addralign, 1));
    Address = NextVMAddress;
    NextVMAddress += Size;
  }
  return VMRange(Address, Size);
}

1715public:
VMAddressProvider(ObjectFile::Type Type, llvm::StringRef SegmentName)
    : ObjectType(Type), SegmentName(std::string(SegmentName)) {}

std::string GetNextSegmentName() const {
  return llvm::formatv("{0}[{1}]", SegmentName, SegmentCount).str();
}

llvm::Optional<VMRange> GetAddressInfo(const ELFProgramHeader &H) {
  if (H.p_memsz == 0) {
    LLDB_LOG(Log, "Ignoring zero-sized {0} segment. Corrupt object file?",do { ::lldb_private::Log *log_private = (Log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginObjectFile/../../../llvm/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp"
, __func__, "Ignoring zero-sized {0} segment. Corrupt object file?"
, SegmentName); } while (0)
             SegmentName)do { ::lldb_private::Log *log_private = (Log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginObjectFile/../../../llvm/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp"
, __func__, "Ignoring zero-sized {0} segment. Corrupt object file?"
, SegmentName); } while (0);
    return llvm::None;
  }

  if (Segments.overlaps(H.p_vaddr, H.p_vaddr + H.p_memsz)) {
    LLDB_LOG(Log, "Ignoring overlapping {0} segment. Corrupt object file?",do { ::lldb_private::Log *log_private = (Log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginObjectFile/../../../llvm/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp"
, __func__, "Ignoring overlapping {0} segment. Corrupt object file?"
, SegmentName); } while (0)
             SegmentName)do { ::lldb_private::Log *log_private = (Log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginObjectFile/../../../llvm/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp"
, __func__, "Ignoring overlapping {0} segment. Corrupt object file?"
, SegmentName); } while (0);
    return llvm::None;
  }
  return VMRange(H.p_vaddr, H.p_memsz);
}

llvm::Optional<SectionAddressInfo> GetAddressInfo(const ELFSectionHeader &H) {
  VMRange Range = GetVMRange(H);
  SectionSP Segment;
  auto It = Segments.find(Range.GetRangeBase());
  if ((H.sh_flags & SHF_ALLOC) && It.valid()) {
    addr_t MaxSize;
    if (It.start() <= Range.GetRangeBase()) {
      MaxSize = It.stop() - Range.GetRangeBase();
      Segment = *It;
    } else
      MaxSize = It.start() - Range.GetRangeBase();
    if (Range.GetByteSize() > MaxSize) {
      LLDB_LOG(Log, "Shortening section crossing segment boundaries. "do { ::lldb_private::Log *log_private = (Log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginObjectFile/../../../llvm/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp"
, __func__, "Shortening section crossing segment boundaries. "
 "Corrupt object file?"); } while (0)
                    "Corrupt object file?")do { ::lldb_private::Log *log_private = (Log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginObjectFile/../../../llvm/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp"
, __func__, "Shortening section crossing segment boundaries. "
 "Corrupt object file?"); } while (0);
      Range.SetByteSize(MaxSize);
    }
  }
  if (Range.GetByteSize() > 0 &&
      Sections.overlaps(Range.GetRangeBase(), Range.GetRangeEnd())) {
    LLDB_LOG(Log, "Ignoring overlapping section. Corrupt object file?")do { ::lldb_private::Log *log_private = (Log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginObjectFile/../../../llvm/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp"
, __func__, "Ignoring overlapping section. Corrupt object file?"
); } while (0);
    return llvm::None;
  }
  if (Segment)
    Range.Slide(-Segment->GetFileAddress());
  return SectionAddressInfo{Segment, Range};
}

void AddSegment(const VMRange &Range, SectionSP Seg) {
  Segments.insert(Range.GetRangeBase(), Range.GetRangeEnd(), std::move(Seg));
  ++SegmentCount;
}

void AddSection(SectionAddressInfo Info, SectionSP Sect) {
  if (Info.Range.GetByteSize() == 0)
    return;
  if (Info.Segment)
    Info.Range.Slide(Info.Segment->GetFileAddress());
  Sections.insert(Info.Range.GetRangeBase(), Info.Range.GetRangeEnd(),
                  std::move(Sect));
}
1778};
1779}

1781void ObjectFileELF::CreateSections(SectionList &unified_section_list) {
if (m_sections_up)
  return;

m_sections_up = std::make_unique<SectionList>();
VMAddressProvider regular_provider(GetType(), "PT_LOAD");
VMAddressProvider tls_provider(GetType(), "PT_TLS");

for (const auto &EnumPHdr : llvm::enumerate(ProgramHeaders())) {
  const ELFProgramHeader &PHdr = EnumPHdr.value();
  if (PHdr.p_type != PT_LOAD && PHdr.p_type != PT_TLS)
    continue;

  VMAddressProvider &provider =
      PHdr.p_type == PT_TLS ? tls_provider : regular_provider;
  auto InfoOr = provider.GetAddressInfo(PHdr);
  if (!InfoOr)
    continue;

  uint32_t Log2Align = llvm::Log2_64(std::max<elf_xword>(PHdr.p_align, 1));
  SectionSP Segment = std::make_shared<Section>(
      GetModule(), this, SegmentID(EnumPHdr.index()),
      ConstString(provider.GetNextSegmentName()), eSectionTypeContainer,
      InfoOr->GetRangeBase(), InfoOr->GetByteSize(), PHdr.p_offset,
      PHdr.p_filesz, Log2Align, /*flags*/ 0);
  Segment->SetPermissions(GetPermissions(PHdr));
  Segment->SetIsThreadSpecific(PHdr.p_type == PT_TLS);
  m_sections_up->AddSection(Segment);

  provider.AddSegment(*InfoOr, std::move(Segment));
}

ParseSectionHeaders();
if (m_section_headers.empty())
  return;

for (SectionHeaderCollIter I = std::next(m_section_headers.begin());
     I != m_section_headers.end(); ++I) {
  const ELFSectionHeaderInfo &header = *I;

  ConstString &name = I->section_name;
  const uint64_t file_size =
      header.sh_type == SHT_NOBITS ? 0 : header.sh_size;

  VMAddressProvider &provider =
      header.sh_flags & SHF_TLS ? tls_provider : regular_provider;
  auto InfoOr = provider.GetAddressInfo(header);
  if (!InfoOr)
    continue;

  SectionType sect_type = GetSectionType(header);

  const uint32_t target_bytes_size =
      GetTargetByteSize(sect_type, m_arch_spec);

  elf::elf_xword log2align =
      (header.sh_addralign == 0) ? 0 : llvm::Log2_64(header.sh_addralign);

  SectionSP section_sp(new Section(
      InfoOr->Segment, GetModule(), // Module to which this section belongs.
      this,            // ObjectFile to which this section belongs and should
                       // read section data from.
      SectionIndex(I), // Section ID.
      name,            // Section name.
      sect_type,       // Section type.
      InfoOr->Range.GetRangeBase(), // VM address.
      InfoOr->Range.GetByteSize(),  // VM size in bytes of this section.
      header.sh_offset,             // Offset of this section in the file.
      file_size,           // Size of the section as found in the file.
      log2align,           // Alignment of the section
      header.sh_flags,     // Flags for this section.
      target_bytes_size)); // Number of host bytes per target byte

  section_sp->SetPermissions(GetPermissions(header));
  section_sp->SetIsThreadSpecific(header.sh_flags & SHF_TLS);
  (InfoOr->Segment ? InfoOr->Segment->GetChildren() : *m_sections_up)
      .AddSection(section_sp);
  provider.AddSection(std::move(*InfoOr), std::move(section_sp));
}

// For eTypeDebugInfo files, the Symbol Vendor will take care of updating the
// unified section list.
if (GetType() != eTypeDebugInfo)
  unified_section_list = *m_sections_up;

// If there's a .gnu_debugdata section, we'll try to read the .symtab that's
// embedded in there and replace the one in the original object file (if any).
// If there's none in the orignal object file, we add it to it.
if (auto gdd_obj_file = GetGnuDebugDataObjectFile()) {
  if (auto gdd_objfile_section_list = gdd_obj_file->GetSectionList()) {
    if (SectionSP symtab_section_sp =
            gdd_objfile_section_list->FindSectionByType(
                eSectionTypeELFSymbolTable, true)) {
      SectionSP module_section_sp = unified_section_list.FindSectionByType(
          eSectionTypeELFSymbolTable, true);
      if (module_section_sp)
        unified_section_list.ReplaceSection(module_section_sp->GetID(),
                                            symtab_section_sp);
      else
        unified_section_list.AddSection(symtab_section_sp);
    }
  }
}
1884}

1886std::shared_ptr<ObjectFileELF> ObjectFileELF::GetGnuDebugDataObjectFile() {
if (m_gnu_debug_data_object_file != nullptr)
  return m_gnu_debug_data_object_file;

SectionSP section =
    GetSectionList()->FindSectionByName(ConstString(".gnu_debugdata"));
if (!section)
  return nullptr;

if (!lldb_private::lzma::isAvailable()) {
  GetModule()->ReportWarning(
      "No LZMA support found for reading .gnu_debugdata section");
  return nullptr;
}

// Uncompress the data
DataExtractor data;
section->GetSectionData(data);
llvm::SmallVector<uint8_t, 0> uncompressedData;
auto err = lldb_private::lzma::uncompress(data.GetData(), uncompressedData);
if (err) {
  GetModule()->ReportWarning(
      "An error occurred while decompression the section %s: %s",
      section->GetName().AsCString(), llvm::toString(std::move(err)).c_str());
  return nullptr;
}

// Construct ObjectFileELF object from decompressed buffer
DataBufferSP gdd_data_buf(
    new DataBufferHeap(uncompressedData.data(), uncompressedData.size()));
auto fspec = GetFileSpec().CopyByAppendingPathComponent(
    llvm::StringRef("gnu_debugdata"));
m_gnu_debug_data_object_file.reset(new ObjectFileELF(
    GetModule(), gdd_data_buf, 0, &fspec, 0, gdd_data_buf->GetByteSize()));

// This line is essential; otherwise a breakpoint can be set but not hit.
m_gnu_debug_data_object_file->SetType(ObjectFile::eTypeDebugInfo);

ArchSpec spec = m_gnu_debug_data_object_file->GetArchitecture();
if (spec && m_gnu_debug_data_object_file->SetModulesArchitecture(spec))
  return m_gnu_debug_data_object_file;

return nullptr;
1929}

1931// Find the arm/aarch64 mapping symbol character in the given symbol name.
1932// Mapping symbols have the form of "$<char>[.<any>]*". Additionally we
1933// recognize cases when the mapping symbol prefixed by an arbitrary string
1934// because if a symbol prefix added to each symbol in the object file with
1935// objcopy then the mapping symbols are also prefixed.
1936static char FindArmAarch64MappingSymbol(const char *symbol_name) {
if (!symbol_name)
  return '\0';

const char *dollar_pos = ::strchr(symbol_name, '$');
if (!dollar_pos || dollar_pos[1] == '\0')
  return '\0';

if (dollar_pos[2] == '\0' || dollar_pos[2] == '.')
  return dollar_pos[1];
return '\0';
1947}

1949#define STO_MIPS_ISA(3 << 6) (3 << 6)
1950#define STO_MICROMIPS(2 << 6) (2 << 6)
1951#define IS_MICROMIPS(ST_OTHER)(((ST_OTHER)&(3 << 6)) == (2 << 6)) (((ST_OTHER)&STO_MIPS_ISA(3 << 6)) == STO_MICROMIPS(2 << 6))

1953// private
1954unsigned ObjectFileELF::ParseSymbols(Symtab *symtab, user_id_t start_id,
                                   SectionList *section_list,
                                   const size_t num_symbols,
                                   const DataExtractor &symtab_data,
                                   const DataExtractor &strtab_data) {
ELFSymbol symbol;
lldb::offset_t offset = 0;

static ConstString text_section_name(".text");
static ConstString init_section_name(".init");
static ConstString fini_section_name(".fini");
static ConstString ctors_section_name(".ctors");
static ConstString dtors_section_name(".dtors");

static ConstString data_section_name(".data");
static ConstString rodata_section_name(".rodata");
static ConstString rodata1_section_name(".rodata1");
static ConstString data2_section_name(".data1");
static ConstString bss_section_name(".bss");
static ConstString opd_section_name(".opd"); // For ppc64

// On Android the oatdata and the oatexec symbols in the oat and odex files
// covers the full .text section what causes issues with displaying unusable
// symbol name to the user and very slow unwinding speed because the
// instruction emulation based unwind plans try to emulate all instructions
// in these symbols. Don't add these symbols to the symbol list as they have
// no use for the debugger and they are causing a lot of trouble. Filtering
// can't be restricted to Android because this special object file don't
// contain the note section specifying the environment to Android but the
// custom extension and file name makes it highly unlikely that this will
// collide with anything else.
ConstString file_extension = m_file.GetFileNameExtension();
bool skip_oatdata_oatexec =
    file_extension == ".oat" || file_extension == ".odex";
1
Assuming the condition is false→

ArchSpec arch = GetArchitecture();
ModuleSP module_sp(GetModule());
SectionList *module_section_list =
3
←
'module_section_list' initialized to a null pointer value→
    module_sp ? module_sp->GetSectionList() : nullptr;
2
←
'?' condition is false→

// Local cache to avoid doing a FindSectionByName for each symbol. The "const
// char*" key must came from a ConstString object so they can be compared by
// pointer
std::unordered_map<const char *, lldb::SectionSP> section_name_to_section;

unsigned i;
for (i = 0; i < num_symbols; ++i) {
4
←
Assuming 'i' is < 'num_symbols'→
5
←
Loop condition is true.  Entering loop body→
  if (!symbol.Parse(symtab_data, &offset))
6
←
Assuming the condition is false→
7
←
Taking false branch→
    break;

  const char *symbol_name = strtab_data.PeekCStr(symbol.st_name);
  if (!symbol_name)
8
←
Assuming 'symbol_name' is non-null→
9
←
Taking false branch→
    symbol_name = "";

  // No need to add non-section symbols that have no names
  if (symbol.getType() != STT_SECTION &&
10
←
Assuming the condition is false→
      (symbol_name == nullptr || symbol_name[0] == '\0'))
    continue;

  // Skipping oatdata and oatexec sections if it is requested. See details
  // above the definition of skip_oatdata_oatexec for the reasons.
  if (skip_oatdata_oatexec && (::strcmp(symbol_name, "oatdata") == 0 ||
11
←
Assuming 'skip_oatdata_oatexec' is false→
                               ::strcmp(symbol_name, "oatexec") == 0))
    continue;

  SectionSP symbol_section_sp;
  SymbolType symbol_type = eSymbolTypeInvalid;
  Elf64_Half shndx = symbol.st_shndx;

  switch (shndx) {
12
←
Control jumps to 'case SHN_ABS:'  at line 2024→
  case SHN_ABS:
    symbol_type = eSymbolTypeAbsolute;
    break;
13
←
 Execution continues on line 2037→
  case SHN_UNDEF:
    symbol_type = eSymbolTypeUndefined;
    break;
  default:
    symbol_section_sp = section_list->FindSectionByID(shndx);
    break;
  }

  // If a symbol is undefined do not process it further even if it has a STT
  // type
  if (symbol_type13.1
'symbol_type' is not equal to eSymbolTypeUndefined
1
'symbol_type' is not equal to eSymbolTypeUndefined
1
'symbol_type' is not equal to eSymbolTypeUndefined
 != eSymbolTypeUndefined) {
14
←
Taking true branch→
    switch (symbol.getType()) {
15
←
Control jumps to 'case STT_SECTION:'  at line 2055→
    default:
    case STT_NOTYPE:
      // The symbol's type is not specified.
      break;

    case STT_OBJECT:
      // The symbol is associated with a data object, such as a variable, an
      // array, etc.
      symbol_type = eSymbolTypeData;
      break;

    case STT_FUNC:
      // The symbol is associated with a function or other executable code.
      symbol_type = eSymbolTypeCode;
      break;

    case STT_SECTION:
      // The symbol is associated with a section. Symbol table entries of
      // this type exist primarily for relocation and normally have STB_LOCAL
      // binding.
      break;
16
←
 Execution continues on line 2077→

    case STT_FILE:
      // Conventionally, the symbol's name gives the name of the source file
      // associated with the object file. A file symbol has STB_LOCAL
      // binding, its section index is SHN_ABS, and it precedes the other
      // STB_LOCAL symbols for the file, if it is present.
      symbol_type = eSymbolTypeSourceFile;
      break;

    case STT_GNU_IFUNC:
      // The symbol is associated with an indirect function. The actual
      // function will be resolved if it is referenced.
      symbol_type = eSymbolTypeResolver;
      break;
    }
  }

  if (symbol_type16.1
'symbol_type' is not equal to eSymbolTypeInvalid
1
'symbol_type' is not equal to eSymbolTypeInvalid
1
'symbol_type' is not equal to eSymbolTypeInvalid
 == eSymbolTypeInvalid && symbol.getType() != STT_SECTION) {
    if (symbol_section_sp) {
      ConstString sect_name = symbol_section_sp->GetName();
      if (sect_name == text_section_name || sect_name == init_section_name ||
          sect_name == fini_section_name || sect_name == ctors_section_name ||
          sect_name == dtors_section_name) {
        symbol_type = eSymbolTypeCode;
      } else if (sect_name == data_section_name ||
                 sect_name == data2_section_name ||
                 sect_name == rodata_section_name ||
                 sect_name == rodata1_section_name ||
                 sect_name == bss_section_name) {
        symbol_type = eSymbolTypeData;
      }
    }
  }

  int64_t symbol_value_offset = 0;
  uint32_t additional_flags = 0;

  if (arch.IsValid()) {
17
←
Calling 'ArchSpec::IsValid'→
20
←
Returning from 'ArchSpec::IsValid'→
21
←
Taking false branch→
    if (arch.GetMachine() == llvm::Triple::arm) {
      if (symbol.getBinding() == STB_LOCAL) {
        char mapping_symbol = FindArmAarch64MappingSymbol(symbol_name);
        if (symbol_type == eSymbolTypeCode) {
          switch (mapping_symbol) {
          case 'a':
            // $a[.<any>]* - marks an ARM instruction sequence
            m_address_class_map[symbol.st_value] = AddressClass::eCode;
            break;
          case 'b':
          case 't':
            // $b[.<any>]* - marks a THUMB BL instruction sequence
            // $t[.<any>]* - marks a THUMB instruction sequence
            m_address_class_map[symbol.st_value] =
                AddressClass::eCodeAlternateISA;
            break;
          case 'd':
            // $d[.<any>]* - marks a data item sequence (e.g. lit pool)
            m_address_class_map[symbol.st_value] = AddressClass::eData;
            break;
          }
        }
        if (mapping_symbol)
          continue;
      }
    } else if (arch.GetMachine() == llvm::Triple::aarch64) {
      if (symbol.getBinding() == STB_LOCAL) {
        char mapping_symbol = FindArmAarch64MappingSymbol(symbol_name);
        if (symbol_type == eSymbolTypeCode) {
          switch (mapping_symbol) {
          case 'x':
            // $x[.<any>]* - marks an A64 instruction sequence
            m_address_class_map[symbol.st_value] = AddressClass::eCode;
            break;
          case 'd':
            // $d[.<any>]* - marks a data item sequence (e.g. lit pool)
            m_address_class_map[symbol.st_value] = AddressClass::eData;
            break;
          }
        }
        if (mapping_symbol)
          continue;
      }
    }

    if (arch.GetMachine() == llvm::Triple::arm) {
      if (symbol_type == eSymbolTypeCode) {
        if (symbol.st_value & 1) {
          // Subtracting 1 from the address effectively unsets the low order
          // bit, which results in the address actually pointing to the
          // beginning of the symbol. This delta will be used below in
          // conjunction with symbol.st_value to produce the final
          // symbol_value that we store in the symtab.
          symbol_value_offset = -1;
          m_address_class_map[symbol.st_value ^ 1] =
              AddressClass::eCodeAlternateISA;
        } else {
          // This address is ARM
          m_address_class_map[symbol.st_value] = AddressClass::eCode;
        }
      }
    }

    /*
     * MIPS:
     * The bit #0 of an address is used for ISA mode (1 for microMIPS, 0 for
     * MIPS).
     * This allows processor to switch between microMIPS and MIPS without any
     * need
     * for special mode-control register. However, apart from .debug_line,
     * none of
     * the ELF/DWARF sections set the ISA bit (for symbol or section). Use
     * st_other
     * flag to check whether the symbol is microMIPS and then set the address
     * class
     * accordingly.
    */
    if (arch.IsMIPS()) {
      if (IS_MICROMIPS(symbol.st_other)(((symbol.st_other)&(3 << 6)) == (2 << 6)))
        m_address_class_map[symbol.st_value] = AddressClass::eCodeAlternateISA;
      else if ((symbol.st_value & 1) && (symbol_type == eSymbolTypeCode)) {
        symbol.st_value = symbol.st_value & (~1ull);
        m_address_class_map[symbol.st_value] = AddressClass::eCodeAlternateISA;
      } else {
        if (symbol_type == eSymbolTypeCode)
          m_address_class_map[symbol.st_value] = AddressClass::eCode;
        else if (symbol_type == eSymbolTypeData)
          m_address_class_map[symbol.st_value] = AddressClass::eData;
        else
          m_address_class_map[symbol.st_value] = AddressClass::eUnknown;
      }
    }
  }

  // symbol_value_offset may contain 0 for ARM symbols or -1 for THUMB
  // symbols. See above for more details.
  uint64_t symbol_value = symbol.st_value + symbol_value_offset;

  if (symbol_section_sp == nullptr && shndx27.1
'shndx' is equal to SHN_ABS
1
'shndx' is equal to SHN_ABS
1
'shndx' is equal to SHN_ABS
 == SHN_ABS &&
22
←
Calling 'operator==<lldb_private::Section>'→
27
←
Returning from 'operator==<lldb_private::Section>'→
29
←
Taking true branch→
      symbol.st_size != 0) {
28
←
Assuming field 'st_size' is not equal to 0→
    // We don't have a section for a symbol with non-zero size. Create a new
    // section for it so the address range covered by the symbol is also
    // covered by the module (represented through the section list). It is
    // needed so module lookup for the addresses covered by this symbol will
    // be successfull. This case happens for absolute symbols.
    ConstString fake_section_name(std::string(".absolute.") + symbol_name);
    symbol_section_sp =
        std::make_shared<Section>(module_sp, this, SHN_ABS, fake_section_name,
                                  eSectionTypeAbsoluteAddress, symbol_value,
                                  symbol.st_size, 0, 0, 0, SHF_ALLOC);

    module_section_list->AddSection(symbol_section_sp);
30
←
Called C++ object pointer is null
    section_list->AddSection(symbol_section_sp);
  }

  if (symbol_section_sp &&
      CalculateType() != ObjectFile::Type::eTypeObjectFile)
    symbol_value -= symbol_section_sp->GetFileAddress();

  if (symbol_section_sp && module_section_list &&
      module_section_list != section_list) {
    ConstString sect_name = symbol_section_sp->GetName();
    auto section_it = section_name_to_section.find(sect_name.GetCString());
    if (section_it == section_name_to_section.end())
      section_it =
          section_name_to_section
              .emplace(sect_name.GetCString(),
                       module_section_list->FindSectionByName(sect_name))
              .first;
    if (section_it->second)
      symbol_section_sp = section_it->second;
  }

  bool is_global = symbol.getBinding() == STB_GLOBAL;
  uint32_t flags = symbol.st_other << 8 | symbol.st_info | additional_flags;
  llvm::StringRef symbol_ref(symbol_name);

  // Symbol names may contain @VERSION suffixes. Find those and strip them
  // temporarily.
  size_t version_pos = symbol_ref.find('@');
  bool has_suffix = version_pos != llvm::StringRef::npos;
  llvm::StringRef symbol_bare = symbol_ref.substr(0, version_pos);
  Mangled mangled(symbol_bare);

  // Now append the suffix back to mangled and unmangled names. Only do it if
  // the demangling was successful (string is not empty).
  if (has_suffix) {
    llvm::StringRef suffix = symbol_ref.substr(version_pos);

    llvm::StringRef mangled_name = mangled.GetMangledName().GetStringRef();
    if (!mangled_name.empty())
      mangled.SetMangledName(ConstString((mangled_name + suffix).str()));

    ConstString demangled = mangled.GetDemangledName();
    llvm::StringRef demangled_name = demangled.GetStringRef();
    if (!demangled_name.empty())
      mangled.SetDemangledName(ConstString((demangled_name + suffix).str()));
  }

  // In ELF all symbol should have a valid size but it is not true for some
  // function symbols coming from hand written assembly. As none of the
  // function symbol should have 0 size we try to calculate the size for
  // these symbols in the symtab with saying that their original size is not
  // valid.
  bool symbol_size_valid =
      symbol.st_size != 0 || symbol.getType() != STT_FUNC;

  Symbol dc_symbol(
      i + start_id, // ID is the original symbol table index.
      mangled,
      symbol_type,                    // Type of this symbol
      is_global,                      // Is this globally visible?
      false,                          // Is this symbol debug info?
      false,                          // Is this symbol a trampoline?
      false,                          // Is this symbol artificial?
      AddressRange(symbol_section_sp, // Section in which this symbol is
                                      // defined or null.
                   symbol_value,      // Offset in section or symbol value.
                   symbol.st_size),   // Size in bytes of this symbol.
      symbol_size_valid,              // Symbol size is valid
      has_suffix,                     // Contains linker annotations?
      flags);                         // Symbol flags.
  if (symbol.getBinding() == STB_WEAK)
    dc_symbol.SetIsWeak(true);
  symtab->AddSymbol(dc_symbol);
}
return i;
2285}

2287unsigned ObjectFileELF::ParseSymbolTable(Symtab *symbol_table,
                                       user_id_t start_id,
                                       lldb_private::Section *symtab) {
if (symtab->GetObjectFile() != this) {
  // If the symbol table section is owned by a different object file, have it
  // do the parsing.
  ObjectFileELF *obj_file_elf =
      static_cast<ObjectFileELF *>(symtab->GetObjectFile());
  return obj_file_elf->ParseSymbolTable(symbol_table, start_id, symtab);
}

// Get section list for this object file.
SectionList *section_list = m_sections_up.get();
if (!section_list)
  return 0;

user_id_t symtab_id = symtab->GetID();
const ELFSectionHeaderInfo *symtab_hdr = GetSectionHeaderByIndex(symtab_id);
assert(symtab_hdr->sh_type == SHT_SYMTAB ||((void)0)
       symtab_hdr->sh_type == SHT_DYNSYM)((void)0);

// sh_link: section header index of associated string table.
user_id_t strtab_id = symtab_hdr->sh_link;
Section *strtab = section_list->FindSectionByID(strtab_id).get();

if (symtab && strtab) {
  assert(symtab->GetObjectFile() == this)((void)0);
  assert(strtab->GetObjectFile() == this)((void)0);

  DataExtractor symtab_data;
  DataExtractor strtab_data;
  if (ReadSectionData(symtab, symtab_data) &&
      ReadSectionData(strtab, strtab_data)) {
    size_t num_symbols = symtab_data.GetByteSize() / symtab_hdr->sh_entsize;

    return ParseSymbols(symbol_table, start_id, section_list, num_symbols,
                        symtab_data, strtab_data);
  }
}

return 0;
2328}

2330size_t ObjectFileELF::ParseDynamicSymbols() {
if (m_dynamic_symbols.size())
  return m_dynamic_symbols.size();

SectionList *section_list = GetSectionList();
if (!section_list)
  return 0;

// Find the SHT_DYNAMIC section.
Section *dynsym =
    section_list->FindSectionByType(eSectionTypeELFDynamicLinkInfo, true)
        .get();
if (!dynsym)
  return 0;
assert(dynsym->GetObjectFile() == this)((void)0);

ELFDynamic symbol;
DataExtractor dynsym_data;
if (ReadSectionData(dynsym, dynsym_data)) {
  const lldb::offset_t section_size = dynsym_data.GetByteSize();
  lldb::offset_t cursor = 0;

  while (cursor < section_size) {
    if (!symbol.Parse(dynsym_data, &cursor))
      break;

    m_dynamic_symbols.push_back(symbol);
  }
}

return m_dynamic_symbols.size();
2361}

2363const ELFDynamic *ObjectFileELF::FindDynamicSymbol(unsigned tag) {
if (!ParseDynamicSymbols())
  return nullptr;

DynamicSymbolCollIter I = m_dynamic_symbols.begin();
DynamicSymbolCollIter E = m_dynamic_symbols.end();
for (; I != E; ++I) {
  ELFDynamic *symbol = &*I;

  if (symbol->d_tag == tag)
    return symbol;
}

return nullptr;
2377}

2379unsigned ObjectFileELF::PLTRelocationType() {
// DT_PLTREL
//  This member specifies the type of relocation entry to which the
//  procedure linkage table refers. The d_val member holds DT_REL or
//  DT_RELA, as appropriate. All relocations in a procedure linkage table
//  must use the same relocation.
const ELFDynamic *symbol = FindDynamicSymbol(DT_PLTREL);

if (symbol)
  return symbol->d_val;

return 0;
2391}

2393// Returns the size of the normal plt entries and the offset of the first
2394// normal plt entry. The 0th entry in the plt table is usually a resolution
2395// entry which have different size in some architectures then the rest of the
2396// plt entries.
2397static std::pair<uint64_t, uint64_t>
2398GetPltEntrySizeAndOffset(const ELFSectionHeader *rel_hdr,
                       const ELFSectionHeader *plt_hdr) {
const elf_xword num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize;

// Clang 3.3 sets entsize to 4 for 32-bit binaries, but the plt entries are
// 16 bytes. So round the entsize up by the alignment if addralign is set.
elf_xword plt_entsize =
    plt_hdr->sh_addralign
        ? llvm::alignTo(plt_hdr->sh_entsize, plt_hdr->sh_addralign)
        : plt_hdr->sh_entsize;

// Some linkers e.g ld for arm, fill plt_hdr->sh_entsize field incorrectly.
// PLT entries relocation code in general requires multiple instruction and
// should be greater than 4 bytes in most cases. Try to guess correct size
// just in case.
if (plt_entsize <= 4) {
  // The linker haven't set the plt_hdr->sh_entsize field. Try to guess the
  // size of the plt entries based on the number of entries and the size of
  // the plt section with the assumption that the size of the 0th entry is at
  // least as big as the size of the normal entries and it isn't much bigger
  // then that.
  if (plt_hdr->sh_addralign)
    plt_entsize = plt_hdr->sh_size / plt_hdr->sh_addralign /
                  (num_relocations + 1) * plt_hdr->sh_addralign;
  else
    plt_entsize = plt_hdr->sh_size / (num_relocations + 1);
}

elf_xword plt_offset = plt_hdr->sh_size - num_relocations * plt_entsize;

return std::make_pair(plt_entsize, plt_offset);
2429}

2431static unsigned ParsePLTRelocations(
  Symtab *symbol_table, user_id_t start_id, unsigned rel_type,
  const ELFHeader *hdr, const ELFSectionHeader *rel_hdr,
  const ELFSectionHeader *plt_hdr, const ELFSectionHeader *sym_hdr,
  const lldb::SectionSP &plt_section_sp, DataExtractor &rel_data,
  DataExtractor &symtab_data, DataExtractor &strtab_data) {
ELFRelocation rel(rel_type);
ELFSymbol symbol;
lldb::offset_t offset = 0;

uint64_t plt_offset, plt_entsize;
std::tie(plt_entsize, plt_offset) =
    GetPltEntrySizeAndOffset(rel_hdr, plt_hdr);
const elf_xword num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize;

typedef unsigned (*reloc_info_fn)(const ELFRelocation &rel);
reloc_info_fn reloc_type;
reloc_info_fn reloc_symbol;

if (hdr->Is32Bit()) {
  reloc_type = ELFRelocation::RelocType32;
  reloc_symbol = ELFRelocation::RelocSymbol32;
} else {
  reloc_type = ELFRelocation::RelocType64;
  reloc_symbol = ELFRelocation::RelocSymbol64;
}

unsigned slot_type = hdr->GetRelocationJumpSlotType();
unsigned i;
for (i = 0; i < num_relocations; ++i) {
  if (!rel.Parse(rel_data, &offset))
    break;

  if (reloc_type(rel) != slot_type)
    continue;

  lldb::offset_t symbol_offset = reloc_symbol(rel) * sym_hdr->sh_entsize;
  if (!symbol.Parse(symtab_data, &symbol_offset))
    break;

  const char *symbol_name = strtab_data.PeekCStr(symbol.st_name);
  uint64_t plt_index = plt_offset + i * plt_entsize;

  Symbol jump_symbol(
      i + start_id,          // Symbol table index
      symbol_name,           // symbol name.
      eSymbolTypeTrampoline, // Type of this symbol
      false,                 // Is this globally visible?
      false,                 // Is this symbol debug info?
      true,                  // Is this symbol a trampoline?
      true,                  // Is this symbol artificial?
      plt_section_sp, // Section in which this symbol is defined or null.
      plt_index,      // Offset in section or symbol value.
      plt_entsize,    // Size in bytes of this symbol.
      true,           // Size is valid
      false,          // Contains linker annotations?
      0);             // Symbol flags.

  symbol_table->AddSymbol(jump_symbol);
}

return i;
2493}

2495unsigned
2496ObjectFileELF::ParseTrampolineSymbols(Symtab *symbol_table, user_id_t start_id,
                                    const ELFSectionHeaderInfo *rel_hdr,
                                    user_id_t rel_id) {
assert(rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL)((void)0);

// The link field points to the associated symbol table.
user_id_t symtab_id = rel_hdr->sh_link;

// If the link field doesn't point to the appropriate symbol name table then
// try to find it by name as some compiler don't fill in the link fields.
if (!symtab_id)
  symtab_id = GetSectionIndexByName(".dynsym");

// Get PLT section.  We cannot use rel_hdr->sh_info, since current linkers
// point that to the .got.plt or .got section instead of .plt.
user_id_t plt_id = GetSectionIndexByName(".plt");

if (!symtab_id || !plt_id)
  return 0;

const ELFSectionHeaderInfo *plt_hdr = GetSectionHeaderByIndex(plt_id);
if (!plt_hdr)
  return 0;

const ELFSectionHeaderInfo *sym_hdr = GetSectionHeaderByIndex(symtab_id);
if (!sym_hdr)
  return 0;

SectionList *section_list = m_sections_up.get();
if (!section_list)
  return 0;

Section *rel_section = section_list->FindSectionByID(rel_id).get();
if (!rel_section)
  return 0;

SectionSP plt_section_sp(section_list->FindSectionByID(plt_id));
if (!plt_section_sp)
  return 0;

Section *symtab = section_list->FindSectionByID(symtab_id).get();
if (!symtab)
  return 0;

// sh_link points to associated string table.
Section *strtab = section_list->FindSectionByID(sym_hdr->sh_link).get();
if (!strtab)
  return 0;

DataExtractor rel_data;
if (!ReadSectionData(rel_section, rel_data))
  return 0;

DataExtractor symtab_data;
if (!ReadSectionData(symtab, symtab_data))
  return 0;

DataExtractor strtab_data;
if (!ReadSectionData(strtab, strtab_data))
  return 0;

unsigned rel_type = PLTRelocationType();
if (!rel_type)
  return 0;

return ParsePLTRelocations(symbol_table, start_id, rel_type, &m_header,
                           rel_hdr, plt_hdr, sym_hdr, plt_section_sp,
                           rel_data, symtab_data, strtab_data);
2564}

2566unsigned ObjectFileELF::ApplyRelocations(
  Symtab *symtab, const ELFHeader *hdr, const ELFSectionHeader *rel_hdr,
  const ELFSectionHeader *symtab_hdr, const ELFSectionHeader *debug_hdr,
  DataExtractor &rel_data, DataExtractor &symtab_data,
  DataExtractor &debug_data, Section *rel_section) {
ELFRelocation rel(rel_hdr->sh_type);
lldb::addr_t offset = 0;
const unsigned num_relocations = rel_hdr->sh_size / rel_hdr->sh_entsize;
typedef unsigned (*reloc_info_fn)(const ELFRelocation &rel);
reloc_info_fn reloc_type;
reloc_info_fn reloc_symbol;

if (hdr->Is32Bit()) {
  reloc_type = ELFRelocation::RelocType32;
  reloc_symbol = ELFRelocation::RelocSymbol32;
} else {
  reloc_type = ELFRelocation::RelocType64;
  reloc_symbol = ELFRelocation::RelocSymbol64;
}

for (unsigned i = 0; i < num_relocations; ++i) {
  if (!rel.Parse(rel_data, &offset))
    break;

  Symbol *symbol = nullptr;

  if (hdr->Is32Bit()) {
    switch (reloc_type(rel)) {
    case R_386_32:
    case R_386_PC32:
    default:
      // FIXME: This asserts with this input:
      //
      // foo.cpp
      // int main(int argc, char **argv) { return 0; }
      //
      // clang++.exe --target=i686-unknown-linux-gnu -g -c foo.cpp -o foo.o
      //
      // and running this on the foo.o module.
      assert(false && "unexpected relocation type")((void)0);
    }
  } else {
    switch (reloc_type(rel)) {
    case R_AARCH64_ABS64:
    case R_X86_64_64: {
      symbol = symtab->FindSymbolByID(reloc_symbol(rel));
      if (symbol) {
        addr_t value = symbol->GetAddressRef().GetFileAddress();
        DataBufferSP &data_buffer_sp = debug_data.GetSharedDataBuffer();
        uint64_t *dst = reinterpret_cast<uint64_t *>(
            data_buffer_sp->GetBytes() + rel_section->GetFileOffset() +
            ELFRelocation::RelocOffset64(rel));
        uint64_t val_offset = value + ELFRelocation::RelocAddend64(rel);
        memcpy(dst, &val_offset, sizeof(uint64_t));
      }
      break;
    }
    case R_X86_64_32:
    case R_X86_64_32S:
    case R_AARCH64_ABS32: {
      symbol = symtab->FindSymbolByID(reloc_symbol(rel));
      if (symbol) {
        addr_t value = symbol->GetAddressRef().GetFileAddress();
        value += ELFRelocation::RelocAddend32(rel);
        if ((reloc_type(rel) == R_X86_64_32 && (value > UINT32_MAX0xffffffffU)) ||
            (reloc_type(rel) == R_X86_64_32S &&
             ((int64_t)value > INT32_MAX0x7fffffff && (int64_t)value < INT32_MIN(-0x7fffffff - 1))) ||
            (reloc_type(rel) == R_AARCH64_ABS32 &&
             ((int64_t)value > INT32_MAX0x7fffffff && (int64_t)value < INT32_MIN(-0x7fffffff - 1)))) {
          Log *log =
              lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_MODULES(1u << 21));
          LLDB_LOGF(log, "Failed to apply debug info relocations")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Printf("Failed to apply debug info relocations"
); } while (0);
          break;
        }
        uint32_t truncated_addr = (value & 0xFFFFFFFF);
        DataBufferSP &data_buffer_sp = debug_data.GetSharedDataBuffer();
        uint32_t *dst = reinterpret_cast<uint32_t *>(
            data_buffer_sp->GetBytes() + rel_section->GetFileOffset() +
            ELFRelocation::RelocOffset32(rel));
        memcpy(dst, &truncated_addr, sizeof(uint32_t));
      }
      break;
    }
    case R_X86_64_PC32:
    default:
      assert(false && "unexpected relocation type")((void)0);
    }
  }
}

return 0;
2657}

2659unsigned ObjectFileELF::RelocateDebugSections(const ELFSectionHeader *rel_hdr,
                                            user_id_t rel_id,
                                            lldb_private::Symtab *thetab) {
assert(rel_hdr->sh_type == SHT_RELA || rel_hdr->sh_type == SHT_REL)((void)0);

// Parse in the section list if needed.
SectionList *section_list = GetSectionList();
if (!section_list)
  return 0;

user_id_t symtab_id = rel_hdr->sh_link;
user_id_t debug_id = rel_hdr->sh_info;

const ELFSectionHeader *symtab_hdr = GetSectionHeaderByIndex(symtab_id);
if (!symtab_hdr)
  return 0;

const ELFSectionHeader *debug_hdr = GetSectionHeaderByIndex(debug_id);
if (!debug_hdr)
  return 0;

Section *rel = section_list->FindSectionByID(rel_id).get();
if (!rel)
  return 0;

Section *symtab = section_list->FindSectionByID(symtab_id).get();
if (!symtab)
  return 0;

Section *debug = section_list->FindSectionByID(debug_id).get();
if (!debug)
  return 0;

DataExtractor rel_data;
DataExtractor symtab_data;
DataExtractor debug_data;

if (GetData(rel->GetFileOffset(), rel->GetFileSize(), rel_data) &&
    GetData(symtab->GetFileOffset(), symtab->GetFileSize(), symtab_data) &&
    GetData(debug->GetFileOffset(), debug->GetFileSize(), debug_data)) {
  ApplyRelocations(thetab, &m_header, rel_hdr, symtab_hdr, debug_hdr,
                   rel_data, symtab_data, debug_data, debug);
}

return 0;
2704}

2706Symtab *ObjectFileELF::GetSymtab() {
ModuleSP module_sp(GetModule());
if (!module_sp)
  return nullptr;

Progress progress(llvm::formatv("Parsing symbol table for {0}",
                                m_file.GetFilename().AsCString("<Unknown>")));

// We always want to use the main object file so we (hopefully) only have one
// cached copy of our symtab, dynamic sections, etc.
ObjectFile *module_obj_file = module_sp->GetObjectFile();
if (module_obj_file && module_obj_file != this)
  return module_obj_file->GetSymtab();

if (m_symtab_up == nullptr) {
  SectionList *section_list = module_sp->GetSectionList();
  if (!section_list)
    return nullptr;

  uint64_t symbol_id = 0;
  std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());

  // Sharable objects and dynamic executables usually have 2 distinct symbol
  // tables, one named ".symtab", and the other ".dynsym". The dynsym is a
  // smaller version of the symtab that only contains global symbols. The
  // information found in the dynsym is therefore also found in the symtab,
  // while the reverse is not necessarily true.
  Section *symtab =
      section_list->FindSectionByType(eSectionTypeELFSymbolTable, true).get();
  if (symtab) {
    m_symtab_up = std::make_unique<Symtab>(symtab->GetObjectFile());
    symbol_id += ParseSymbolTable(m_symtab_up.get(), symbol_id, symtab);
  }

  // The symtab section is non-allocable and can be stripped, while the
  // .dynsym section which should always be always be there. To support the
  // minidebuginfo case we parse .dynsym when there's a .gnu_debuginfo
  // section, nomatter if .symtab was already parsed or not. This is because
  // minidebuginfo normally removes the .symtab symbols which have their
  // matching .dynsym counterparts.
  if (!symtab ||
      GetSectionList()->FindSectionByName(ConstString(".gnu_debugdata"))) {
    Section *dynsym =
        section_list->FindSectionByType(eSectionTypeELFDynamicSymbols, true)
            .get();
    if (dynsym) {
      if (!m_symtab_up)
        m_symtab_up = std::make_unique<Symtab>(dynsym->GetObjectFile());
      symbol_id += ParseSymbolTable(m_symtab_up.get(), symbol_id, dynsym);
    }
  }

  // DT_JMPREL
  //      If present, this entry's d_ptr member holds the address of
  //      relocation
  //      entries associated solely with the procedure linkage table.
  //      Separating
  //      these relocation entries lets the dynamic linker ignore them during
  //      process initialization, if lazy binding is enabled. If this entry is
  //      present, the related entries of types DT_PLTRELSZ and DT_PLTREL must
  //      also be present.
  const ELFDynamic *symbol = FindDynamicSymbol(DT_JMPREL);
  if (symbol) {
    const ELFDynamic *pltrelsz = FindDynamicSymbol(DT_PLTRELSZ);
    assert(pltrelsz != NULL)((void)0);
    // Synthesize trampoline symbols to help navigate the PLT.
    addr_t addr = symbol->d_ptr;
    Section *reloc_section =
        section_list->FindSectionContainingFileAddress(addr).get();
    if (reloc_section && pltrelsz->d_val > 0) {
      user_id_t reloc_id = reloc_section->GetID();
      const ELFSectionHeaderInfo *reloc_header =
          GetSectionHeaderByIndex(reloc_id);
      if (reloc_header) {
        if (m_symtab_up == nullptr)
          m_symtab_up =
              std::make_unique<Symtab>(reloc_section->GetObjectFile());

        ParseTrampolineSymbols(m_symtab_up.get(), symbol_id, reloc_header,
                               reloc_id);
      }
    }
  }

  if (DWARFCallFrameInfo *eh_frame =
          GetModule()->GetUnwindTable().GetEHFrameInfo()) {
    if (m_symtab_up == nullptr)
      m_symtab_up = std::make_unique<Symtab>(this);
    ParseUnwindSymbols(m_symtab_up.get(), eh_frame);
  }

  // If we still don't have any symtab then create an empty instance to avoid
  // do the section lookup next time.
  if (m_symtab_up == nullptr)
    m_symtab_up = std::make_unique<Symtab>(this);

  // In the event that there's no symbol entry for the entry point we'll
  // artificially create one. We delegate to the symtab object the figuring
  // out of the proper size, this will usually make it span til the next
  // symbol it finds in the section. This means that if there are missing
  // symbols the entry point might span beyond its function definition.
  // We're fine with this as it doesn't make it worse than not having a
  // symbol entry at all.
  if (CalculateType() == eTypeExecutable) {
    ArchSpec arch = GetArchitecture();
    auto entry_point_addr = GetEntryPointAddress();
    bool is_valid_entry_point =
        entry_point_addr.IsValid() && entry_point_addr.IsSectionOffset();
    addr_t entry_point_file_addr = entry_point_addr.GetFileAddress();
    if (is_valid_entry_point && !m_symtab_up->FindSymbolContainingFileAddress(
                                    entry_point_file_addr)) {
      uint64_t symbol_id = m_symtab_up->GetNumSymbols();
      // Don't set the name for any synthetic symbols, the Symbol
      // object will generate one if needed when the name is accessed
      // via accessors.
      SectionSP section_sp = entry_point_addr.GetSection();
      Symbol symbol(
          /*symID=*/symbol_id,
          /*name=*/llvm::StringRef(), // Name will be auto generated.
          /*type=*/eSymbolTypeCode,
          /*external=*/true,
          /*is_debug=*/false,
          /*is_trampoline=*/false,
          /*is_artificial=*/true,
          /*section_sp=*/section_sp,
          /*offset=*/0,
          /*size=*/0, // FDE can span multiple symbols so don't use its size.
          /*size_is_valid=*/false,
          /*contains_linker_annotations=*/false,
          /*flags=*/0);
      // When the entry point is arm thumb we need to explicitly set its
      // class address to reflect that. This is important because expression
      // evaluation relies on correctly setting a breakpoint at this
      // address.
      if (arch.GetMachine() == llvm::Triple::arm &&
          (entry_point_file_addr & 1)) {
        symbol.GetAddressRef().SetOffset(entry_point_addr.GetOffset() ^ 1);
        m_address_class_map[entry_point_file_addr ^ 1] =
            AddressClass::eCodeAlternateISA;
      } else {
        m_address_class_map[entry_point_file_addr] = AddressClass::eCode;
      }
      m_symtab_up->AddSymbol(symbol);
    }
  }

  m_symtab_up->CalculateSymbolSizes();
}

return m_symtab_up.get();
2856}

2858void ObjectFileELF::RelocateSection(lldb_private::Section *section)
2859{
static const char *debug_prefix = ".debug";

// Set relocated bit so we stop getting called, regardless of whether we
// actually relocate.
section->SetIsRelocated(true);

// We only relocate in ELF relocatable files
if (CalculateType() != eTypeObjectFile)
  return;

const char *section_name = section->GetName().GetCString();
// Can't relocate that which can't be named
if (section_name == nullptr)
  return;

// We don't relocate non-debug sections at the moment
if (strncmp(section_name, debug_prefix, strlen(debug_prefix)))
  return;

// Relocation section names to look for
std::string needle = std::string(".rel") + section_name;
std::string needlea = std::string(".rela") + section_name;

for (SectionHeaderCollIter I = m_section_headers.begin();
     I != m_section_headers.end(); ++I) {
  if (I->sh_type == SHT_RELA || I->sh_type == SHT_REL) {
    const char *hay_name = I->section_name.GetCString();
    if (hay_name == nullptr)
      continue;
    if (needle == hay_name || needlea == hay_name) {
      const ELFSectionHeader &reloc_header = *I;
      user_id_t reloc_id = SectionIndex(I);
      RelocateDebugSections(&reloc_header, reloc_id, GetSymtab());
      break;
    }
  }
}
2897}

2899void ObjectFileELF::ParseUnwindSymbols(Symtab *symbol_table,
                                     DWARFCallFrameInfo *eh_frame) {
SectionList *section_list = GetSectionList();
if (!section_list)
  return;

// First we save the new symbols into a separate list and add them to the
// symbol table after we collected all symbols we want to add. This is
// neccessary because adding a new symbol invalidates the internal index of
// the symtab what causing the next lookup to be slow because it have to
// recalculate the index first.
std::vector<Symbol> new_symbols;

size_t num_symbols = symbol_table->GetNumSymbols();
uint64_t last_symbol_id =
    num_symbols ? symbol_table->SymbolAtIndex(num_symbols - 1)->GetID() : 0;
eh_frame->ForEachFDEEntries([&](lldb::addr_t file_addr, uint32_t size,
                                dw_offset_t) {
  Symbol *symbol = symbol_table->FindSymbolAtFileAddress(file_addr);
  if (symbol) {
    if (!symbol->GetByteSizeIsValid()) {
      symbol->SetByteSize(size);
      symbol->SetSizeIsSynthesized(true);
    }
  } else {
    SectionSP section_sp =
        section_list->FindSectionContainingFileAddress(file_addr);
    if (section_sp) {
      addr_t offset = file_addr - section_sp->GetFileAddress();
      uint64_t symbol_id = ++last_symbol_id;
      // Don't set the name for any synthetic symbols, the Symbol
      // object will generate one if needed when the name is accessed
      // via accessors.
      Symbol eh_symbol(
          /*symID=*/symbol_id,
          /*name=*/llvm::StringRef(), // Name will be auto generated.
          /*type=*/eSymbolTypeCode,
          /*external=*/true,
          /*is_debug=*/false,
          /*is_trampoline=*/false,
          /*is_artificial=*/true,
          /*section_sp=*/section_sp,
          /*offset=*/offset,
          /*size=*/0, // FDE can span multiple symbols so don't use its size.
          /*size_is_valid=*/false,
          /*contains_linker_annotations=*/false,
          /*flags=*/0);
      new_symbols.push_back(eh_symbol);
    }
  }
  return true;
});

for (const Symbol &s : new_symbols)
  symbol_table->AddSymbol(s);
2954}

2956bool ObjectFileELF::IsStripped() {
// TODO: determine this for ELF
return false;
2959}

2961//===----------------------------------------------------------------------===//
2962// Dump
2963//
2964// Dump the specifics of the runtime file container (such as any headers
2965// segments, sections, etc).
2966void ObjectFileELF::Dump(Stream *s) {
ModuleSP module_sp(GetModule());
if (!module_sp) {
  return;
}

std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
s->Printf("%p: ", static_cast<void *>(this));
s->Indent();
s->PutCString("ObjectFileELF");

ArchSpec header_arch = GetArchitecture();

*s << ", file = '" << m_file
   << "', arch = " << header_arch.GetArchitectureName() << "\n";

DumpELFHeader(s, m_header);
s->EOL();
DumpELFProgramHeaders(s);
s->EOL();
DumpELFSectionHeaders(s);
s->EOL();
SectionList *section_list = GetSectionList();
if (section_list)
  section_list->Dump(s->AsRawOstream(), s->GetIndentLevel(), nullptr, true,
                     UINT32_MAX0xffffffffU);
Symtab *symtab = GetSymtab();
if (symtab)
  symtab->Dump(s, nullptr, eSortOrderNone);
s->EOL();
DumpDependentModules(s);
s->EOL();
2998}

3000// DumpELFHeader
3001//
3002// Dump the ELF header to the specified output stream
3003void ObjectFileELF::DumpELFHeader(Stream *s, const ELFHeader &header) {
s->PutCString("ELF Header\n");
s->Printf("e_ident[EI_MAG0   ] = 0x%2.2x\n", header.e_ident[EI_MAG0]);
s->Printf("e_ident[EI_MAG1   ] = 0x%2.2x '%c'\n", header.e_ident[EI_MAG1],
          header.e_ident[EI_MAG1]);
s->Printf("e_ident[EI_MAG2   ] = 0x%2.2x '%c'\n", header.e_ident[EI_MAG2],
          header.e_ident[EI_MAG2]);
s->Printf("e_ident[EI_MAG3   ] = 0x%2.2x '%c'\n", header.e_ident[EI_MAG3],
          header.e_ident[EI_MAG3]);

s->Printf("e_ident[EI_CLASS  ] = 0x%2.2x\n", header.e_ident[EI_CLASS]);
s->Printf("e_ident[EI_DATA   ] = 0x%2.2x ", header.e_ident[EI_DATA]);
DumpELFHeader_e_ident_EI_DATA(s, header.e_ident[EI_DATA]);
s->Printf("\ne_ident[EI_VERSION] = 0x%2.2x\n", header.e_ident[EI_VERSION]);
s->Printf("e_ident[EI_PAD    ] = 0x%2.2x\n", header.e_ident[EI_PAD]);

s->Printf("e_type      = 0x%4.4x ", header.e_type);
DumpELFHeader_e_type(s, header.e_type);
s->Printf("\ne_machine   = 0x%4.4x\n", header.e_machine);
s->Printf("e_version   = 0x%8.8x\n", header.e_version);
s->Printf("e_entry     = 0x%8.8" PRIx64"llx" "\n", header.e_entry);
s->Printf("e_phoff     = 0x%8.8" PRIx64"llx" "\n", header.e_phoff);
s->Printf("e_shoff     = 0x%8.8" PRIx64"llx" "\n", header.e_shoff);
s->Printf("e_flags     = 0x%8.8x\n", header.e_flags);
s->Printf("e_ehsize    = 0x%4.4x\n", header.e_ehsize);
s->Printf("e_phentsize = 0x%4.4x\n", header.e_phentsize);
s->Printf("e_phnum     = 0x%8.8x\n", header.e_phnum);
s->Printf("e_shentsize = 0x%4.4x\n", header.e_shentsize);
s->Printf("e_shnum     = 0x%8.8x\n", header.e_shnum);
s->Printf("e_shstrndx  = 0x%8.8x\n", header.e_shstrndx);
3033}

3035// DumpELFHeader_e_type
3036//
3037// Dump an token value for the ELF header member e_type
3038void ObjectFileELF::DumpELFHeader_e_type(Stream *s, elf_half e_type) {
switch (e_type) {
case ET_NONE:
  *s << "ET_NONE";
  break;
case ET_REL:
  *s << "ET_REL";
  break;
case ET_EXEC:
  *s << "ET_EXEC";
  break;
case ET_DYN:
  *s << "ET_DYN";
  break;
case ET_CORE:
  *s << "ET_CORE";
  break;
default:
  break;
}
3058}

3060// DumpELFHeader_e_ident_EI_DATA
3061//
3062// Dump an token value for the ELF header member e_ident[EI_DATA]
3063void ObjectFileELF::DumpELFHeader_e_ident_EI_DATA(Stream *s,
                                                unsigned char ei_data) {
switch (ei_data) {
case ELFDATANONE:
  *s << "ELFDATANONE";
  break;
case ELFDATA2LSB:
  *s << "ELFDATA2LSB - Little Endian";
  break;
case ELFDATA2MSB:
  *s << "ELFDATA2MSB - Big Endian";
  break;
default:
  break;
}
3078}

3080// DumpELFProgramHeader
3081//
3082// Dump a single ELF program header to the specified output stream
3083void ObjectFileELF::DumpELFProgramHeader(Stream *s,
                                       const ELFProgramHeader &ph) {
DumpELFProgramHeader_p_type(s, ph.p_type);
s->Printf(" %8.8" PRIx64"llx" " %8.8" PRIx64"llx" " %8.8" PRIx64"llx", ph.p_offset,
          ph.p_vaddr, ph.p_paddr);
s->Printf(" %8.8" PRIx64"llx" " %8.8" PRIx64"llx" " %8.8x (", ph.p_filesz, ph.p_memsz,
          ph.p_flags);

DumpELFProgramHeader_p_flags(s, ph.p_flags);
s->Printf(") %8.8" PRIx64"llx", ph.p_align);
3093}

3095// DumpELFProgramHeader_p_type
3096//
3097// Dump an token value for the ELF program header member p_type which describes
3098// the type of the program header
3099void ObjectFileELF::DumpELFProgramHeader_p_type(Stream *s, elf_word p_type) {
const int kStrWidth = 15;
switch (p_type) {
  CASE_AND_STREAM(s, PT_NULL, kStrWidth)case PT_NULL: s->Printf("%-*s", kStrWidth, "PT_NULL"); break
;;
  CASE_AND_STREAM(s, PT_LOAD, kStrWidth)case PT_LOAD: s->Printf("%-*s", kStrWidth, "PT_LOAD"); break
;;
  CASE_AND_STREAM(s, PT_DYNAMIC, kStrWidth)case PT_DYNAMIC: s->Printf("%-*s", kStrWidth, "PT_DYNAMIC"
); break;;
  CASE_AND_STREAM(s, PT_INTERP, kStrWidth)case PT_INTERP: s->Printf("%-*s", kStrWidth, "PT_INTERP");
 break;;
  CASE_AND_STREAM(s, PT_NOTE, kStrWidth)case PT_NOTE: s->Printf("%-*s", kStrWidth, "PT_NOTE"); break
;;
  CASE_AND_STREAM(s, PT_SHLIB, kStrWidth)case PT_SHLIB: s->Printf("%-*s", kStrWidth, "PT_SHLIB"); break
;;
  CASE_AND_STREAM(s, PT_PHDR, kStrWidth)case PT_PHDR: s->Printf("%-*s", kStrWidth, "PT_PHDR"); break
;;
  CASE_AND_STREAM(s, PT_TLS, kStrWidth)case PT_TLS: s->Printf("%-*s", kStrWidth, "PT_TLS"); break
;;
  CASE_AND_STREAM(s, PT_GNU_EH_FRAME, kStrWidth)case PT_GNU_EH_FRAME: s->Printf("%-*s", kStrWidth, "PT_GNU_EH_FRAME"
); break;;
default:
  s->Printf("0x%8.8x%*s", p_type, kStrWidth - 10, "");
  break;
}
3115}

3117// DumpELFProgramHeader_p_flags
3118//
3119// Dump an token value for the ELF program header member p_flags
3120void ObjectFileELF::DumpELFProgramHeader_p_flags(Stream *s, elf_word p_flags) {
*s << ((p_flags & PF_X) ? "PF_X" : "    ")
   << (((p_flags & PF_X) && (p_flags & PF_W)) ? '+' : ' ')
   << ((p_flags & PF_W) ? "PF_W" : "    ")
   << (((p_flags & PF_W) && (p_flags & PF_R)) ? '+' : ' ')
   << ((p_flags & PF_R) ? "PF_R" : "    ");
3126}

3128// DumpELFProgramHeaders
3129//
3130// Dump all of the ELF program header to the specified output stream
3131void ObjectFileELF::DumpELFProgramHeaders(Stream *s) {
if (!ParseProgramHeaders())
  return;

s->PutCString("Program Headers\n");
s->PutCString("IDX  p_type          p_offset p_vaddr  p_paddr  "
              "p_filesz p_memsz  p_flags                   p_align\n");
s->PutCString("==== --------------- -------- -------- -------- "
              "-------- -------- ------------------------- --------\n");

for (const auto &H : llvm::enumerate(m_program_headers)) {
  s->Format("[{0,2}] ", H.index());
  ObjectFileELF::DumpELFProgramHeader(s, H.value());
  s->EOL();
}
3146}

3148// DumpELFSectionHeader
3149//
3150// Dump a single ELF section header to the specified output stream
3151void ObjectFileELF::DumpELFSectionHeader(Stream *s,
                                       const ELFSectionHeaderInfo &sh) {
s->Printf("%8.8x ", sh.sh_name);
DumpELFSectionHeader_sh_type(s, sh.sh_type);
s->Printf(" %8.8" PRIx64"llx" " (", sh.sh_flags);
DumpELFSectionHeader_sh_flags(s, sh.sh_flags);
s->Printf(") %8.8" PRIx64"llx" " %8.8" PRIx64"llx" " %8.8" PRIx64"llx", sh.sh_addr,
          sh.sh_offset, sh.sh_size);
s->Printf(" %8.8x %8.8x", sh.sh_link, sh.sh_info);
s->Printf(" %8.8" PRIx64"llx" " %8.8" PRIx64"llx", sh.sh_addralign, sh.sh_entsize);
3161}

3163// DumpELFSectionHeader_sh_type
3164//
3165// Dump an token value for the ELF section header member sh_type which
3166// describes the type of the section
3167void ObjectFileELF::DumpELFSectionHeader_sh_type(Stream *s, elf_word sh_type) {
const int kStrWidth = 12;
switch (sh_type) {
  CASE_AND_STREAM(s, SHT_NULL, kStrWidth)case SHT_NULL: s->Printf("%-*s", kStrWidth, "SHT_NULL"); break
;;
  CASE_AND_STREAM(s, SHT_PROGBITS, kStrWidth)case SHT_PROGBITS: s->Printf("%-*s", kStrWidth, "SHT_PROGBITS"
); break;;
  CASE_AND_STREAM(s, SHT_SYMTAB, kStrWidth)case SHT_SYMTAB: s->Printf("%-*s", kStrWidth, "SHT_SYMTAB"
); break;;
  CASE_AND_STREAM(s, SHT_STRTAB, kStrWidth)case SHT_STRTAB: s->Printf("%-*s", kStrWidth, "SHT_STRTAB"
); break;;
  CASE_AND_STREAM(s, SHT_RELA, kStrWidth)case SHT_RELA: s->Printf("%-*s", kStrWidth, "SHT_RELA"); break
;;
  CASE_AND_STREAM(s, SHT_HASH, kStrWidth)case SHT_HASH: s->Printf("%-*s", kStrWidth, "SHT_HASH"); break
;;
  CASE_AND_STREAM(s, SHT_DYNAMIC, kStrWidth)case SHT_DYNAMIC: s->Printf("%-*s", kStrWidth, "SHT_DYNAMIC"
); break;;
  CASE_AND_STREAM(s, SHT_NOTE, kStrWidth)case SHT_NOTE: s->Printf("%-*s", kStrWidth, "SHT_NOTE"); break
;;
  CASE_AND_STREAM(s, SHT_NOBITS, kStrWidth)case SHT_NOBITS: s->Printf("%-*s", kStrWidth, "SHT_NOBITS"
); break;;
  CASE_AND_STREAM(s, SHT_REL, kStrWidth)case SHT_REL: s->Printf("%-*s", kStrWidth, "SHT_REL"); break
;;
  CASE_AND_STREAM(s, SHT_SHLIB, kStrWidth)case SHT_SHLIB: s->Printf("%-*s", kStrWidth, "SHT_SHLIB");
 break;;
  CASE_AND_STREAM(s, SHT_DYNSYM, kStrWidth)case SHT_DYNSYM: s->Printf("%-*s", kStrWidth, "SHT_DYNSYM"
); break;;
  CASE_AND_STREAM(s, SHT_LOPROC, kStrWidth)case SHT_LOPROC: s->Printf("%-*s", kStrWidth, "SHT_LOPROC"
); break;;
  CASE_AND_STREAM(s, SHT_HIPROC, kStrWidth)case SHT_HIPROC: s->Printf("%-*s", kStrWidth, "SHT_HIPROC"
); break;;
  CASE_AND_STREAM(s, SHT_LOUSER, kStrWidth)case SHT_LOUSER: s->Printf("%-*s", kStrWidth, "SHT_LOUSER"
); break;;
  CASE_AND_STREAM(s, SHT_HIUSER, kStrWidth)case SHT_HIUSER: s->Printf("%-*s", kStrWidth, "SHT_HIUSER"
); break;;
default:
  s->Printf("0x%8.8x%*s", sh_type, kStrWidth - 10, "");
  break;
}
3190}

3192// DumpELFSectionHeader_sh_flags
3193//
3194// Dump an token value for the ELF section header member sh_flags
3195void ObjectFileELF::DumpELFSectionHeader_sh_flags(Stream *s,
                                                elf_xword sh_flags) {
*s << ((sh_flags & SHF_WRITE) ? "WRITE" : "     ")
   << (((sh_flags & SHF_WRITE) && (sh_flags & SHF_ALLOC)) ? '+' : ' ')
   << ((sh_flags & SHF_ALLOC) ? "ALLOC" : "     ")
   << (((sh_flags & SHF_ALLOC) && (sh_flags & SHF_EXECINSTR)) ? '+' : ' ')
   << ((sh_flags & SHF_EXECINSTR) ? "EXECINSTR" : "         ");
3202}

3204// DumpELFSectionHeaders
3205//
3206// Dump all of the ELF section header to the specified output stream
3207void ObjectFileELF::DumpELFSectionHeaders(Stream *s) {
if (!ParseSectionHeaders())
  return;

s->PutCString("Section Headers\n");
s->PutCString("IDX  name     type         flags                            "
              "addr     offset   size     link     info     addralgn "
              "entsize  Name\n");
s->PutCString("==== -------- ------------ -------------------------------- "
              "-------- -------- -------- -------- -------- -------- "
              "-------- ====================\n");

uint32_t idx = 0;
for (SectionHeaderCollConstIter I = m_section_headers.begin();
     I != m_section_headers.end(); ++I, ++idx) {
  s->Printf("[%2u] ", idx);
  ObjectFileELF::DumpELFSectionHeader(s, *I);
  const char *section_name = I->section_name.AsCString("");
  if (section_name)
    *s << ' ' << section_name << "\n";
}
3228}

3230void ObjectFileELF::DumpDependentModules(lldb_private::Stream *s) {
size_t num_modules = ParseDependentModules();

if (num_modules > 0) {
  s->PutCString("Dependent Modules:\n");
  for (unsigned i = 0; i < num_modules; ++i) {
    const FileSpec &spec = m_filespec_up->GetFileSpecAtIndex(i);
    s->Printf("   %s\n", spec.GetFilename().GetCString());
  }
}
3240}

3242ArchSpec ObjectFileELF::GetArchitecture() {
if (!ParseHeader())
  return ArchSpec();

if (m_section_headers.empty()) {
  // Allow elf notes to be parsed which may affect the detected architecture.
  ParseSectionHeaders();
}

if (CalculateType() == eTypeCoreFile &&
    !m_arch_spec.TripleOSWasSpecified()) {
  // Core files don't have section headers yet they have PT_NOTE program
  // headers that might shed more light on the architecture
  for (const elf::ELFProgramHeader &H : ProgramHeaders()) {
    if (H.p_type != PT_NOTE || H.p_offset == 0 || H.p_filesz == 0)
      continue;
    DataExtractor data;
    if (data.SetData(m_data, H.p_offset, H.p_filesz) == H.p_filesz) {
      UUID uuid;
      RefineModuleDetailsFromNote(data, m_arch_spec, uuid);
    }
  }
}
return m_arch_spec;
3266}

3268ObjectFile::Type ObjectFileELF::CalculateType() {
switch (m_header.e_type) {
case llvm::ELF::ET_NONE:
  // 0 - No file type
  return eTypeUnknown;

case llvm::ELF::ET_REL:
  // 1 - Relocatable file
  return eTypeObjectFile;

case llvm::ELF::ET_EXEC:
  // 2 - Executable file
  return eTypeExecutable;

case llvm::ELF::ET_DYN:
  // 3 - Shared object file
  return eTypeSharedLibrary;

case ET_CORE:
  // 4 - Core file
  return eTypeCoreFile;

default:
  break;
}
return eTypeUnknown;
3294}

3296ObjectFile::Strata ObjectFileELF::CalculateStrata() {
switch (m_header.e_type) {
case llvm::ELF::ET_NONE:
  // 0 - No file type
  return eStrataUnknown;

case llvm::ELF::ET_REL:
  // 1 - Relocatable file
  return eStrataUnknown;

case llvm::ELF::ET_EXEC:
  // 2 - Executable file
  // TODO: is there any way to detect that an executable is a kernel
  // related executable by inspecting the program headers, section headers,
  // symbols, or any other flag bits???
  return eStrataUser;

case llvm::ELF::ET_DYN:
  // 3 - Shared object file
  // TODO: is there any way to detect that an shared library is a kernel
  // related executable by inspecting the program headers, section headers,
  // symbols, or any other flag bits???
  return eStrataUnknown;

case ET_CORE:
  // 4 - Core file
  // TODO: is there any way to detect that an core file is a kernel
  // related executable by inspecting the program headers, section headers,
  // symbols, or any other flag bits???
  return eStrataUnknown;

default:
  break;
}
return eStrataUnknown;
3331}

3333size_t ObjectFileELF::ReadSectionData(Section *section,
                     lldb::offset_t section_offset, void *dst,
                     size_t dst_len) {
// If some other objectfile owns this data, pass this to them.
if (section->GetObjectFile() != this)
  return section->GetObjectFile()->ReadSectionData(section, section_offset,
                                                   dst, dst_len);

if (!section->Test(SHF_COMPRESSED))
  return ObjectFile::ReadSectionData(section, section_offset, dst, dst_len);

// For compressed sections we need to read to full data to be able to
// decompress.
DataExtractor data;
ReadSectionData(section, data);
return data.CopyData(section_offset, dst_len, dst);
3349}

3351size_t ObjectFileELF::ReadSectionData(Section *section,
                                    DataExtractor &section_data) {
// If some other objectfile owns this data, pass this to them.
if (section->GetObjectFile() != this)
  return section->GetObjectFile()->ReadSectionData(section, section_data);

size_t result = ObjectFile::ReadSectionData(section, section_data);
if (result == 0 || !llvm::object::Decompressor::isCompressedELFSection(
                       section->Get(), section->GetName().GetStringRef()))
  return result;

auto Decompressor = llvm::object::Decompressor::create(
    section->GetName().GetStringRef(),
    {reinterpret_cast<const char *>(section_data.GetDataStart()),
     size_t(section_data.GetByteSize())},
    GetByteOrder() == eByteOrderLittle, GetAddressByteSize() == 8);
if (!Decompressor) {
  GetModule()->ReportWarning(
      "Unable to initialize decompressor for section '%s': %s",
      section->GetName().GetCString(),
      llvm::toString(Decompressor.takeError()).c_str());
  section_data.Clear();
  return 0;
}

auto buffer_sp =
    std::make_shared<DataBufferHeap>(Decompressor->getDecompressedSize(), 0);
if (auto error = Decompressor->decompress(
        {reinterpret_cast<char *>(buffer_sp->GetBytes()),
         size_t(buffer_sp->GetByteSize())})) {
  GetModule()->ReportWarning(
      "Decompression of section '%s' failed: %s",
      section->GetName().GetCString(),
      llvm::toString(std::move(error)).c_str());
  section_data.Clear();
  return 0;
}

section_data.SetData(buffer_sp);
return buffer_sp->GetByteSize();
3391}

3393llvm::ArrayRef<ELFProgramHeader> ObjectFileELF::ProgramHeaders() {
ParseProgramHeaders();
return m_program_headers;
3396}

3398DataExtractor ObjectFileELF::GetSegmentData(const ELFProgramHeader &H) {
return DataExtractor(m_data, H.p_offset, H.p_filesz);
3400}

3402bool ObjectFileELF::AnySegmentHasPhysicalAddress() {
for (const ELFProgramHeader &H : ProgramHeaders()) {
  if (H.p_paddr != 0)
    return true;
}
return false;
3408}

3410std::vector<ObjectFile::LoadableData>
3411ObjectFileELF::GetLoadableData(Target &target) {
// Create a list of loadable data from loadable segments, using physical
// addresses if they aren't all null
std::vector<LoadableData> loadables;
bool should_use_paddr = AnySegmentHasPhysicalAddress();
for (const ELFProgramHeader &H : ProgramHeaders()) {
  LoadableData loadable;
  if (H.p_type != llvm::ELF::PT_LOAD)
    continue;
  loadable.Dest = should_use_paddr ? H.p_paddr : H.p_vaddr;
  if (loadable.Dest == LLDB_INVALID_ADDRESS0xffffffffffffffffULL)
    continue;
  if (H.p_filesz == 0)
    continue;
  auto segment_data = GetSegmentData(H);
  loadable.Contents = llvm::ArrayRef<uint8_t>(segment_data.GetDataStart(),
                                              segment_data.GetByteSize());
  loadables.push_back(loadable);
}
return loadables;
3431}

←

/usr/src/gnu/usr.bin/clang/liblldbPluginObjectFile/../../../llvm/lldb/include/lldb/Utility/ArchSpec.h

→

1//===-- ArchSpec.h ----------------------------------------------*- 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//===----------------------------------------------------------------------===//

9#ifndef LLDB_UTILITY_ARCHSPEC_H
10#define LLDB_UTILITY_ARCHSPEC_H

12#include "lldb/Utility/CompletionRequest.h"
13#include "lldb/Utility/ConstString.h"
14#include "lldb/lldb-enumerations.h"
15#include "lldb/lldb-forward.h"
16#include "lldb/lldb-private-enumerations.h"
17#include "llvm/ADT/StringRef.h"
18#include "llvm/ADT/Triple.h"
19#include "llvm/Support/YAMLTraits.h"
20#include <cstddef>
21#include <cstdint>
22#include <string>

24namespace lldb_private {

26/// \class ArchSpec ArchSpec.h "lldb/Utility/ArchSpec.h" An architecture
27/// specification class.
28///
29/// A class designed to be created from a cpu type and subtype, a
30/// string representation, or an llvm::Triple.  Keeping all of the conversions
31/// of strings to architecture enumeration values confined to this class
32/// allows new architecture support to be added easily.
33class ArchSpec {
34public:
enum MIPSSubType {
  eMIPSSubType_unknown,
  eMIPSSubType_mips32,
  eMIPSSubType_mips32r2,
  eMIPSSubType_mips32r6,
  eMIPSSubType_mips32el,
  eMIPSSubType_mips32r2el,
  eMIPSSubType_mips32r6el,
  eMIPSSubType_mips64,
  eMIPSSubType_mips64r2,
  eMIPSSubType_mips64r6,
  eMIPSSubType_mips64el,
  eMIPSSubType_mips64r2el,
  eMIPSSubType_mips64r6el,
};

// Masks for the ases word of an ABI flags structure.
enum MIPSASE {
  eMIPSAse_dsp = 0x00000001,       // DSP ASE
  eMIPSAse_dspr2 = 0x00000002,     // DSP R2 ASE
  eMIPSAse_eva = 0x00000004,       // Enhanced VA Scheme
  eMIPSAse_mcu = 0x00000008,       // MCU (MicroController) ASE
  eMIPSAse_mdmx = 0x00000010,      // MDMX ASE
  eMIPSAse_mips3d = 0x00000020,    // MIPS-3D ASE
  eMIPSAse_mt = 0x00000040,        // MT ASE
  eMIPSAse_smartmips = 0x00000080, // SmartMIPS ASE
  eMIPSAse_virt = 0x00000100,      // VZ ASE
  eMIPSAse_msa = 0x00000200,       // MSA ASE
  eMIPSAse_mips16 = 0x00000400,    // MIPS16 ASE
  eMIPSAse_micromips = 0x00000800, // MICROMIPS ASE
  eMIPSAse_xpa = 0x00001000,       // XPA ASE
  eMIPSAse_mask = 0x00001fff,
  eMIPSABI_O32 = 0x00002000,
  eMIPSABI_N32 = 0x00004000,
  eMIPSABI_N64 = 0x00008000,
  eMIPSABI_O64 = 0x00020000,
  eMIPSABI_EABI32 = 0x00040000,
  eMIPSABI_EABI64 = 0x00080000,
  eMIPSABI_mask = 0x000ff000
};

// MIPS Floating point ABI Values
enum MIPS_ABI_FP {
  eMIPS_ABI_FP_ANY = 0x00000000,
  eMIPS_ABI_FP_DOUBLE = 0x00100000, // hard float / -mdouble-float
  eMIPS_ABI_FP_SINGLE = 0x00200000, // hard float / -msingle-float
  eMIPS_ABI_FP_SOFT = 0x00300000,   // soft float
  eMIPS_ABI_FP_OLD_64 = 0x00400000, // -mips32r2 -mfp64
  eMIPS_ABI_FP_XX = 0x00500000,     // -mfpxx
  eMIPS_ABI_FP_64 = 0x00600000,     // -mips32r2 -mfp64
  eMIPS_ABI_FP_64A = 0x00700000,    // -mips32r2 -mfp64 -mno-odd-spreg
  eMIPS_ABI_FP_mask = 0x00700000
};

// ARM specific e_flags
enum ARMeflags {
  eARM_abi_soft_float = 0x00000200,
  eARM_abi_hard_float = 0x00000400
};

enum RISCVSubType {
  eRISCVSubType_unknown,
  eRISCVSubType_riscv32,
  eRISCVSubType_riscv64,
};

enum Core {
  eCore_arm_generic,
  eCore_arm_armv4,
  eCore_arm_armv4t,
  eCore_arm_armv5,
  eCore_arm_armv5e,
  eCore_arm_armv5t,
  eCore_arm_armv6,
  eCore_arm_armv6m,
  eCore_arm_armv7,
  eCore_arm_armv7l,
  eCore_arm_armv7f,
  eCore_arm_armv7s,
  eCore_arm_armv7k,
  eCore_arm_armv7m,
  eCore_arm_armv7em,
  eCore_arm_xscale,

  eCore_thumb,
  eCore_thumbv4t,
  eCore_thumbv5,
  eCore_thumbv5e,
  eCore_thumbv6,
  eCore_thumbv6m,
  eCore_thumbv7,
  eCore_thumbv7s,
  eCore_thumbv7k,
  eCore_thumbv7f,
  eCore_thumbv7m,
  eCore_thumbv7em,
  eCore_arm_arm64,
  eCore_arm_armv8,
  eCore_arm_armv8l,
  eCore_arm_arm64e,
  eCore_arm_arm64_32,
  eCore_arm_aarch64,

  eCore_mips32,
  eCore_mips32r2,
  eCore_mips32r3,
  eCore_mips32r5,
  eCore_mips32r6,
  eCore_mips32el,
  eCore_mips32r2el,
  eCore_mips32r3el,
  eCore_mips32r5el,
  eCore_mips32r6el,
  eCore_mips64,
  eCore_mips64r2,
  eCore_mips64r3,
  eCore_mips64r5,
  eCore_mips64r6,
  eCore_mips64el,
  eCore_mips64r2el,
  eCore_mips64r3el,
  eCore_mips64r5el,
  eCore_mips64r6el,

  eCore_ppc_generic,
  eCore_ppc_ppc601,
  eCore_ppc_ppc602,
  eCore_ppc_ppc603,
  eCore_ppc_ppc603e,
  eCore_ppc_ppc603ev,
  eCore_ppc_ppc604,
  eCore_ppc_ppc604e,
  eCore_ppc_ppc620,
  eCore_ppc_ppc750,
  eCore_ppc_ppc7400,
  eCore_ppc_ppc7450,
  eCore_ppc_ppc970,

  eCore_ppc64le_generic,
  eCore_ppc64_generic,
  eCore_ppc64_ppc970_64,

  eCore_s390x_generic,

  eCore_sparc_generic,

  eCore_sparc9_generic,

  eCore_x86_32_i386,
  eCore_x86_32_i486,
  eCore_x86_32_i486sx,
  eCore_x86_32_i686,

  eCore_x86_64_x86_64,
  eCore_x86_64_x86_64h, // Haswell enabled x86_64
  eCore_x86_64_amd64,
  eCore_hexagon_generic,
  eCore_hexagon_hexagonv4,
  eCore_hexagon_hexagonv5,

  eCore_riscv32,
  eCore_riscv64,

  eCore_uknownMach32,
  eCore_uknownMach64,

  eCore_arc, // little endian ARC

  eCore_avr,

  eCore_wasm32,

  kNumCores,

  kCore_invalid,
  // The following constants are used for wildcard matching only
  kCore_any,
  kCore_arm_any,
  kCore_ppc_any,
  kCore_ppc64_any,
  kCore_x86_32_any,
  kCore_x86_64_any,
  kCore_hexagon_any,

  kCore_arm_first = eCore_arm_generic,
  kCore_arm_last = eCore_arm_xscale,

  kCore_thumb_first = eCore_thumb,
  kCore_thumb_last = eCore_thumbv7em,

  kCore_ppc_first = eCore_ppc_generic,
  kCore_ppc_last = eCore_ppc_ppc970,

  kCore_ppc64_first = eCore_ppc64_generic,
  kCore_ppc64_last = eCore_ppc64_ppc970_64,

  kCore_x86_32_first = eCore_x86_32_i386,
  kCore_x86_32_last = eCore_x86_32_i686,

  kCore_x86_64_first = eCore_x86_64_x86_64,
  kCore_x86_64_last = eCore_x86_64_x86_64h,

  kCore_hexagon_first = eCore_hexagon_generic,
  kCore_hexagon_last = eCore_hexagon_hexagonv5,

  kCore_mips32_first = eCore_mips32,
  kCore_mips32_last = eCore_mips32r6,

  kCore_mips32el_first = eCore_mips32el,
  kCore_mips32el_last = eCore_mips32r6el,

  kCore_mips64_first = eCore_mips64,
  kCore_mips64_last = eCore_mips64r6,

  kCore_mips64el_first = eCore_mips64el,
  kCore_mips64el_last = eCore_mips64r6el,

  kCore_mips_first = eCore_mips32,
  kCore_mips_last = eCore_mips64r6el

};

/// Default constructor.
///
/// Default constructor that initializes the object with invalid cpu type
/// and subtype values.
ArchSpec();

/// Constructor over triple.
///
/// Constructs an ArchSpec with properties consistent with the given Triple.
explicit ArchSpec(const llvm::Triple &triple);
explicit ArchSpec(const char *triple_cstr);
explicit ArchSpec(llvm::StringRef triple_str);
/// Constructor over architecture name.
///
/// Constructs an ArchSpec with properties consistent with the given object
/// type and architecture name.
explicit ArchSpec(ArchitectureType arch_type, uint32_t cpu_type,
                  uint32_t cpu_subtype);

/// Destructor.
~ArchSpec();

/// Returns true if the OS, vendor and environment fields of the triple are
/// unset. The triple is expected to be normalized
/// (llvm::Triple::normalize).
static bool ContainsOnlyArch(const llvm::Triple &normalized_triple);

static void ListSupportedArchNames(StringList &list);
static void AutoComplete(CompletionRequest &request);

/// Returns a static string representing the current architecture.
///
/// \return A static string corresponding to the current
///         architecture.
const char *GetArchitectureName() const;

/// if MIPS architecture return true.
///
///  \return a boolean value.
bool IsMIPS() const;

/// Returns a string representing current architecture as a target CPU for
/// tools like compiler, disassembler etc.
///
/// \return A string representing target CPU for the current
///         architecture.
std::string GetClangTargetCPU() const;

/// Return a string representing target application ABI.
///
/// \return A string representing target application ABI.
std::string GetTargetABI() const;

/// Clears the object state.
///
/// Clears the object state back to a default invalid state.
void Clear();

/// Returns the size in bytes of an address of the current architecture.
///
/// \return The byte size of an address of the current architecture.
uint32_t GetAddressByteSize() const;

/// Returns a machine family for the current architecture.
///
/// \return An LLVM arch type.
llvm::Triple::ArchType GetMachine() const;

/// Returns the distribution id of the architecture.
///
/// This will be something like "ubuntu", "fedora", etc. on Linux.
///
/// \return A ConstString ref containing the distribution id,
///         potentially empty.
ConstString GetDistributionId() const;

/// Set the distribution id of the architecture.
///
/// This will be something like "ubuntu", "fedora", etc. on Linux. This
/// should be the same value returned by HostInfo::GetDistributionId ().
void SetDistributionId(const char *distribution_id);

/// Tests if this ArchSpec is valid.
///
/// \return True if the current architecture is valid, false
///         otherwise.
bool IsValid() const {
  return m_core17.1
Field 'm_core' is >= eCore_arm_generic
1
Field 'm_core' is >= eCore_arm_generic
1
Field 'm_core' is >= eCore_arm_generic
 >= eCore_arm_generic && m_core < kNumCores;
18
←
Assuming field 'm_core' is >= kNumCores→
19
←
Returning zero, which participates in a condition later→
}
explicit operator bool() const { return IsValid(); }

bool TripleVendorWasSpecified() const {
  return !m_triple.getVendorName().empty();
}

bool TripleOSWasSpecified() const { return !m_triple.getOSName().empty(); }

bool TripleEnvironmentWasSpecified() const {
  return m_triple.hasEnvironment();
}

/// Merges fields from another ArchSpec into this ArchSpec.
///
/// This will use the supplied ArchSpec to fill in any fields of the triple
/// in this ArchSpec which were unspecified.  This can be used to refine a
/// generic ArchSpec with a more specific one. For example, if this
/// ArchSpec's triple is something like i386-unknown-unknown-unknown, and we
/// have a triple which is x64-pc-windows-msvc, then merging that triple
/// into this one will result in the triple i386-pc-windows-msvc.
///
void MergeFrom(const ArchSpec &other);

/// Change the architecture object type, CPU type and OS type.
///
/// \param[in] arch_type The object type of this ArchSpec.
///
/// \param[in] cpu The required CPU type.
///
/// \param[in] os The optional OS type
/// The default value of 0 was chosen to from the ELF spec value
/// ELFOSABI_NONE.  ELF is the only one using this parameter.  If another
/// format uses this parameter and 0 does not work, use a value over
/// 255 because in the ELF header this is value is only a byte.
///
/// \return True if the object, and CPU were successfully set.
///
/// As a side effect, the vendor value is usually set to unknown. The
/// exceptions are
///   aarch64-apple-ios
///   arm-apple-ios
///   thumb-apple-ios
///   x86-apple-
///   x86_64-apple-
///
/// As a side effect, the os value is usually set to unknown The exceptions
/// are
///   *-*-aix
///   aarch64-apple-ios
///   arm-apple-ios
///   thumb-apple-ios
///   powerpc-apple-darwin
///   *-*-freebsd
///   *-*-linux
///   *-*-netbsd
///   *-*-openbsd
///   *-*-solaris
bool SetArchitecture(ArchitectureType arch_type, uint32_t cpu, uint32_t sub,
                     uint32_t os = 0);

/// Returns the byte order for the architecture specification.
///
/// \return The endian enumeration for the current endianness of
///     the architecture specification
lldb::ByteOrder GetByteOrder() const;

/// Sets this ArchSpec's byte order.
///
/// In the common case there is no need to call this method as the byte
/// order can almost always be determined by the architecture. However, many
/// CPU's are bi-endian (ARM, Alpha, PowerPC, etc) and the default/assumed
/// byte order may be incorrect.
void SetByteOrder(lldb::ByteOrder byte_order) { m_byte_order = byte_order; }

uint32_t GetMinimumOpcodeByteSize() const;

uint32_t GetMaximumOpcodeByteSize() const;

Core GetCore() const { return m_core; }

uint32_t GetMachOCPUType() const;

uint32_t GetMachOCPUSubType() const;

/// Architecture data byte width accessor
///
/// \return the size in 8-bit (host) bytes of a minimum addressable unit
/// from the Architecture's data bus
uint32_t GetDataByteSize() const;

/// Architecture code byte width accessor
///
/// \return the size in 8-bit (host) bytes of a minimum addressable unit
/// from the Architecture's code bus
uint32_t GetCodeByteSize() const;

/// Architecture triple accessor.
///
/// \return A triple describing this ArchSpec.
llvm::Triple &GetTriple() { return m_triple; }

/// Architecture triple accessor.
///
/// \return A triple describing this ArchSpec.
const llvm::Triple &GetTriple() const { return m_triple; }

void DumpTriple(llvm::raw_ostream &s) const;

/// Architecture triple setter.
///
/// Configures this ArchSpec according to the given triple.  If the triple
/// has unknown components in all of the vendor, OS, and the optional
/// environment field (i.e. "i386-unknown-unknown") then default values are
/// taken from the host.  Architecture and environment components are used
/// to further resolve the CPU type and subtype, endian characteristics,
/// etc.
///
/// \return A triple describing this ArchSpec.
bool SetTriple(const llvm::Triple &triple);

bool SetTriple(llvm::StringRef triple_str);

/// Returns the default endianness of the architecture.
///
/// \return The endian enumeration for the default endianness of
///         the architecture.
lldb::ByteOrder GetDefaultEndian() const;

/// Returns true if 'char' is a signed type by default in the architecture
/// false otherwise
///
/// \return True if 'char' is a signed type by default on the
///         architecture and false otherwise.
bool CharIsSignedByDefault() const;

/// Compare an ArchSpec to another ArchSpec, requiring an exact cpu type
/// match between them. e.g. armv7s is not an exact match with armv7 - this
/// would return false
///
/// \return true if the two ArchSpecs match.
bool IsExactMatch(const ArchSpec &rhs) const;

/// Compare an ArchSpec to another ArchSpec, requiring a compatible cpu type
/// match between them. e.g. armv7s is compatible with armv7 - this method
/// would return true
///
/// \return true if the two ArchSpecs are compatible
bool IsCompatibleMatch(const ArchSpec &rhs) const;

bool IsFullySpecifiedTriple() const;

void PiecewiseTripleCompare(const ArchSpec &other, bool &arch_different,
                            bool &vendor_different, bool &os_different,
                            bool &os_version_different,
                            bool &env_different) const;

/// Detect whether this architecture uses thumb code exclusively
///
/// Some embedded ARM chips (e.g. the ARM Cortex M0-7 line) can only execute
/// the Thumb instructions, never Arm.  We should normally pick up
/// arm/thumbness from their the processor status bits (cpsr/xpsr) or hints
/// on each function - but when doing bare-boards low level debugging
/// (especially common with these embedded processors), we may not have
/// those things easily accessible.
///
/// \return true if this is an arm ArchSpec which can only execute Thumb
///         instructions
bool IsAlwaysThumbInstructions() const;

uint32_t GetFlags() const { return m_flags; }

void SetFlags(uint32_t flags) { m_flags = flags; }

void SetFlags(const std::string &elf_abi);

521protected:
bool IsEqualTo(const ArchSpec &rhs, bool exact_match) const;
void UpdateCore();

llvm::Triple m_triple;
Core m_core = kCore_invalid;
lldb::ByteOrder m_byte_order = lldb::eByteOrderInvalid;

// Additional arch flags which we cannot get from triple and core For MIPS
// these are application specific extensions like micromips, mips16 etc.
uint32_t m_flags = 0;

ConstString m_distribution_id;

// Called when m_def or m_entry are changed.  Fills in all remaining members
// with default values.
void CoreUpdated(bool update_triple);
538};

540/// \fn bool operator< (const ArchSpec& lhs, const ArchSpec& rhs) Less than
541/// operator.
542///
543/// Tests two ArchSpec objects to see if \a lhs is less than \a rhs.
544///
545/// \param[in] lhs The Left Hand Side ArchSpec object to compare. \param[in]
546/// rhs The Left Hand Side ArchSpec object to compare.
547///
548/// \return true if \a lhs is less than \a rhs
549bool operator<(const ArchSpec &lhs, const ArchSpec &rhs);
550bool operator==(const ArchSpec &lhs, const ArchSpec &rhs);

552bool ParseMachCPUDashSubtypeTriple(llvm::StringRef triple_str, ArchSpec &arch);

554} // namespace lldb_private

556namespace llvm {
557namespace yaml {
558template <> struct ScalarTraits<lldb_private::ArchSpec> {
static void output(const lldb_private::ArchSpec &, void *, raw_ostream &);
static StringRef input(StringRef, void *, lldb_private::ArchSpec &);
static QuotingType mustQuote(StringRef S) { return QuotingType::Double; }
562};
563} // namespace yaml
564} // namespace llvm

566LLVM_YAML_IS_SEQUENCE_VECTOR(lldb_private::ArchSpec)namespace llvm { namespace yaml { static_assert( !std::is_fundamental
<lldb_private::ArchSpec>::value && !std::is_same
<lldb_private::ArchSpec, std::string>::value &&
 !std::is_same<lldb_private::ArchSpec, llvm::StringRef>
::value, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<lldb_private
::ArchSpec> { static const bool flow = false; }; } }

568#endif // LLDB_UTILITY_ARCHSPEC_H

←

/usr/include/c++/v1/__memory/shared_ptr.h

1// -*- C++ -*-
2//===----------------------------------------------------------------------===//
3//
4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5// See https://llvm.org/LICENSE.txt for license information.
6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7//
8//===----------------------------------------------------------------------===//
9 
10#ifndef _LIBCPP___MEMORY_SHARED_PTR_H
11#define _LIBCPP___MEMORY_SHARED_PTR_H
12 
13#include <__availability>
14#include <__config>
15#include <__functional_base>
16#include <__functional/binary_function.h>
17#include <__functional/operations.h>
18#include <__functional/reference_wrapper.h>
19#include <__memory/addressof.h>
20#include <__memory/allocation_guard.h>
21#include <__memory/allocator_traits.h>
22#include <__memory/allocator.h>
23#include <__memory/compressed_pair.h>
24#include <__memory/pointer_traits.h>
25#include <__memory/unique_ptr.h>
26#include <__utility/forward.h>
27#include <cstddef>
28#include <cstdlib> // abort
29#include <iosfwd>
30#include <stdexcept>
31#include <typeinfo>
32#include <type_traits>
33#include <utility>
34#if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
35#  include <atomic>
36#endif
37 
38#if _LIBCPP_STD_VER14 <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
39#   include <__memory/auto_ptr.h>
40#endif
41 
42#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
43#pragma GCC system_header
44#endif
45 
46_LIBCPP_PUSH_MACROSpush_macro("min")
 push_macro("max")
47#include <__undef_macros>
48 
49_LIBCPP_BEGIN_NAMESPACE_STDnamespace std { inline namespace __1 {
50 
51template <class _Alloc>
52class __allocator_destructor
53{
54    typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) allocator_traits<_Alloc> __alloc_traits;
55public:
56    typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) typename __alloc_traits::pointer pointer;
57    typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) typename __alloc_traits::size_type size_type;
58private:
59    _Alloc& __alloc_;
60    size_type __s_;
61public:
62    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
)) __allocator_destructor(_Alloc& __a, size_type __s)
63             _NOEXCEPTnoexcept
64        : __alloc_(__a), __s_(__s) {}
65    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
66    void operator()(pointer __p) _NOEXCEPTnoexcept
67        {__alloc_traits::deallocate(__alloc_, __p, __s_);}
68};
69 
70// NOTE: Relaxed and acq/rel atomics (for increment and decrement respectively)
71// should be sufficient for thread safety.
72// See https://llvm.org/PR22803
73#if defined(__clang__1) && __has_builtin(__atomic_add_fetch)1          \
74                       && defined(__ATOMIC_RELAXED0)                  \
75                       && defined(__ATOMIC_ACQ_REL4)
76#   define _LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT
77#elif defined(_LIBCPP_COMPILER_GCC)
78#   define _LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT
79#endif
80 
81template <class _ValueType>
82inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
83_ValueType __libcpp_relaxed_load(_ValueType const* __value) {
84#if !defined(_LIBCPP_HAS_NO_THREADS) && \
85    defined(__ATOMIC_RELAXED0) &&        \
86    (__has_builtin(__atomic_load_n)1 || defined(_LIBCPP_COMPILER_GCC))
87    return __atomic_load_n(__value, __ATOMIC_RELAXED0);
88#else
89    return *__value;
90#endif
91}
92 
93template <class _ValueType>
94inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
95_ValueType __libcpp_acquire_load(_ValueType const* __value) {
96#if !defined(_LIBCPP_HAS_NO_THREADS) && \
97    defined(__ATOMIC_ACQUIRE2) &&        \
98    (__has_builtin(__atomic_load_n)1 || defined(_LIBCPP_COMPILER_GCC))
99    return __atomic_load_n(__value, __ATOMIC_ACQUIRE2);
100#else
101    return *__value;
102#endif
103}
104 
105template <class _Tp>
106inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
)) _Tp
107__libcpp_atomic_refcount_increment(_Tp& __t) _NOEXCEPTnoexcept
108{
109#if defined(_LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT) && !defined(_LIBCPP_HAS_NO_THREADS)
110    return __atomic_add_fetch(&__t, 1, __ATOMIC_RELAXED0);
111#else
112    return __t += 1;
113#endif
114}
115 
116template <class _Tp>
117inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
)) _Tp
118__libcpp_atomic_refcount_decrement(_Tp& __t) _NOEXCEPTnoexcept
119{
120#if defined(_LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT) && !defined(_LIBCPP_HAS_NO_THREADS)
121    return __atomic_add_fetch(&__t, -1, __ATOMIC_ACQ_REL4);
122#else
123    return __t -= 1;
124#endif
125}
126 
127class _LIBCPP_EXCEPTION_ABI__attribute__ ((__visibility__("default"))) bad_weak_ptr
128    : public std::exception
129{
130public:
131    bad_weak_ptr() _NOEXCEPTnoexcept = default;
132    bad_weak_ptr(const bad_weak_ptr&) _NOEXCEPTnoexcept = default;
133    virtual ~bad_weak_ptr() _NOEXCEPTnoexcept;
134    virtual const char* what() const  _NOEXCEPTnoexcept;
135};
136 
137_LIBCPP_NORETURN[[noreturn]] inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
138void __throw_bad_weak_ptr()
139{
140#ifndef _LIBCPP_NO_EXCEPTIONS
141    throw bad_weak_ptr();
142#else
143    _VSTDstd::__1::abort();
144#endif
145}
146 
147template<class _Tp> class _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) weak_ptr;
148 
149class _LIBCPP_TYPE_VIS__attribute__ ((__visibility__("default"))) __shared_count
150{
151    __shared_count(const __shared_count&);
152    __shared_count& operator=(const __shared_count&);
153 
154protected:
155    long __shared_owners_;
156    virtual ~__shared_count();
157private:
158    virtual void __on_zero_shared() _NOEXCEPTnoexcept = 0;
159 
160public:
161    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
162    explicit __shared_count(long __refs = 0) _NOEXCEPTnoexcept
163        : __shared_owners_(__refs) {}
164 
165#if defined(_LIBCPP_BUILDING_LIBRARY) && \
166    defined(_LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS)
167    void __add_shared() _NOEXCEPTnoexcept;
168    bool __release_shared() _NOEXCEPTnoexcept;
169#else
170    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
171    void __add_shared() _NOEXCEPTnoexcept {
172      __libcpp_atomic_refcount_increment(__shared_owners_);
173    }
174    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
175    bool __release_shared() _NOEXCEPTnoexcept {
176      if (__libcpp_atomic_refcount_decrement(__shared_owners_) == -1) {
177        __on_zero_shared();
178        return true;
179      }
180      return false;
181    }
182#endif
183    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
184    long use_count() const _NOEXCEPTnoexcept {
185        return __libcpp_relaxed_load(&__shared_owners_) + 1;
186    }
187};
188 
189class _LIBCPP_TYPE_VIS__attribute__ ((__visibility__("default"))) __shared_weak_count
190    : private __shared_count
191{
192    long __shared_weak_owners_;
193 
194public:
195    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
196    explicit __shared_weak_count(long __refs = 0) _NOEXCEPTnoexcept
197        : __shared_count(__refs),
198          __shared_weak_owners_(__refs) {}
199protected:
200    virtual ~__shared_weak_count();
201 
202public:
203#if defined(_LIBCPP_BUILDING_LIBRARY) && \
204    defined(_LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS)
205    void __add_shared() _NOEXCEPTnoexcept;
206    void __add_weak() _NOEXCEPTnoexcept;
207    void __release_shared() _NOEXCEPTnoexcept;
208#else
209    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
210    void __add_shared() _NOEXCEPTnoexcept {
211      __shared_count::__add_shared();
212    }
213    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
214    void __add_weak() _NOEXCEPTnoexcept {
215      __libcpp_atomic_refcount_increment(__shared_weak_owners_);
216    }
217    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
218    void __release_shared() _NOEXCEPTnoexcept {
219      if (__shared_count::__release_shared())
220        __release_weak();
221    }
222#endif
223    void __release_weak() _NOEXCEPTnoexcept;
224    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
225    long use_count() const _NOEXCEPTnoexcept {return __shared_count::use_count();}
226    __shared_weak_count* lock() _NOEXCEPTnoexcept;
227 
228    virtual const void* __get_deleter(const type_info&) const _NOEXCEPTnoexcept;
229private:
230    virtual void __on_zero_shared_weak() _NOEXCEPTnoexcept = 0;
231};
232 
233template <class _Tp, class _Dp, class _Alloc>
234class __shared_ptr_pointer
235    : public __shared_weak_count
236{
237    __compressed_pair<__compressed_pair<_Tp, _Dp>, _Alloc> __data_;
238public:
239    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
240    __shared_ptr_pointer(_Tp __p, _Dp __d, _Alloc __a)
241        :  __data_(__compressed_pair<_Tp, _Dp>(__p, _VSTDstd::__1::move(__d)), _VSTDstd::__1::move(__a)) {}
242 
243#ifndef _LIBCPP_NO_RTTI
244    virtual const void* __get_deleter(const type_info&) const _NOEXCEPTnoexcept;
245#endif
246 
247private:
248    virtual void __on_zero_shared() _NOEXCEPTnoexcept;
249    virtual void __on_zero_shared_weak() _NOEXCEPTnoexcept;
250};
251 
252#ifndef _LIBCPP_NO_RTTI
253 
254template <class _Tp, class _Dp, class _Alloc>
255const void*
256__shared_ptr_pointer<_Tp, _Dp, _Alloc>::__get_deleter(const type_info& __t) const _NOEXCEPTnoexcept
257{
258    return __t == typeid(_Dp) ? _VSTDstd::__1::addressof(__data_.first().second()) : nullptr;
259}
260 
261#endif // _LIBCPP_NO_RTTI
262 
263template <class _Tp, class _Dp, class _Alloc>
264void
265__shared_ptr_pointer<_Tp, _Dp, _Alloc>::__on_zero_shared() _NOEXCEPTnoexcept
266{
267    __data_.first().second()(__data_.first().first());
268    __data_.first().second().~_Dp();
269}
270 
271template <class _Tp, class _Dp, class _Alloc>
272void
273__shared_ptr_pointer<_Tp, _Dp, _Alloc>::__on_zero_shared_weak() _NOEXCEPTnoexcept
274{
275    typedef typename __allocator_traits_rebind<_Alloc, __shared_ptr_pointer>::type _Al;
276    typedef allocator_traits<_Al> _ATraits;
277    typedef pointer_traits<typename _ATraits::pointer> _PTraits;
278 
279    _Al __a(__data_.second());
280    __data_.second().~_Alloc();
281    __a.deallocate(_PTraits::pointer_to(*this), 1);
282}
283 
284template <class _Tp, class _Alloc>
285struct __shared_ptr_emplace
286    : __shared_weak_count
287{
288    template<class ..._Args>
289    _LIBCPP_HIDE_FROM_ABI__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
290    explicit __shared_ptr_emplace(_Alloc __a, _Args&& ...__args)
291        : __storage_(_VSTDstd::__1::move(__a))
292    {
293#if _LIBCPP_STD_VER14 > 17
294        using _TpAlloc = typename __allocator_traits_rebind<_Alloc, _Tp>::type;
295        _TpAlloc __tmp(*__get_alloc());
296        allocator_traits<_TpAlloc>::construct(__tmp, __get_elem(), _VSTDstd::__1::forward<_Args>(__args)...);
297#else
298        ::new ((void*)__get_elem()) _Tp(_VSTDstd::__1::forward<_Args>(__args)...);
299#endif
300    }
301 
302    _LIBCPP_HIDE_FROM_ABI__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
303    _Alloc* __get_alloc() _NOEXCEPTnoexcept { return __storage_.__get_alloc(); }
304 
305    _LIBCPP_HIDE_FROM_ABI__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
306    _Tp* __get_elem() _NOEXCEPTnoexcept { return __storage_.__get_elem(); }
307 
308private:
309    virtual void __on_zero_shared() _NOEXCEPTnoexcept {
310#if _LIBCPP_STD_VER14 > 17
311        using _TpAlloc = typename __allocator_traits_rebind<_Alloc, _Tp>::type;
312        _TpAlloc __tmp(*__get_alloc());
313        allocator_traits<_TpAlloc>::destroy(__tmp, __get_elem());
314#else
315        __get_elem()->~_Tp();
316#endif
317    }
318 
319    virtual void __on_zero_shared_weak() _NOEXCEPTnoexcept {
320        using _ControlBlockAlloc = typename __allocator_traits_rebind<_Alloc, __shared_ptr_emplace>::type;
321        using _ControlBlockPointer = typename allocator_traits<_ControlBlockAlloc>::pointer;
322        _ControlBlockAlloc __tmp(*__get_alloc());
323        __storage_.~_Storage();
324        allocator_traits<_ControlBlockAlloc>::deallocate(__tmp,
325            pointer_traits<_ControlBlockPointer>::pointer_to(*this), 1);
326    }
327 
328    // This class implements the control block for non-array shared pointers created
329    // through `std::allocate_shared` and `std::make_shared`.
330    //
331    // In previous versions of the library, we used a compressed pair to store
332    // both the _Alloc and the _Tp. This implies using EBO, which is incompatible
333    // with Allocator construction for _Tp. To allow implementing P0674 in C++20,
334    // we now use a properly aligned char buffer while making sure that we maintain
335    // the same layout that we had when we used a compressed pair.
336    using _CompressedPair = __compressed_pair<_Alloc, _Tp>;
337    struct _ALIGNAS_TYPE(_CompressedPair)alignas(_CompressedPair) _Storage {
338        char __blob_[sizeof(_CompressedPair)];
339 
340        _LIBCPP_HIDE_FROM_ABI__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
)) explicit _Storage(_Alloc&& __a) {
341            ::new ((void*)__get_alloc()) _Alloc(_VSTDstd::__1::move(__a));
342        }
343        _LIBCPP_HIDE_FROM_ABI__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
)) ~_Storage() {
344            __get_alloc()->~_Alloc();
345        }
346        _Alloc* __get_alloc() _NOEXCEPTnoexcept {
347            _CompressedPair *__as_pair = reinterpret_cast<_CompressedPair*>(__blob_);
348            typename _CompressedPair::_Base1* __first = _CompressedPair::__get_first_base(__as_pair);
349            _Alloc *__alloc = reinterpret_cast<_Alloc*>(__first);
350            return __alloc;
351        }
352        _LIBCPP_NO_CFI__attribute__((__no_sanitize__("cfi"))) _Tp* __get_elem() _NOEXCEPTnoexcept {
353            _CompressedPair *__as_pair = reinterpret_cast<_CompressedPair*>(__blob_);
354            typename _CompressedPair::_Base2* __second = _CompressedPair::__get_second_base(__as_pair);
355            _Tp *__elem = reinterpret_cast<_Tp*>(__second);
356            return __elem;
357        }
358    };
359 
360    static_assert(_LIBCPP_ALIGNOF(_Storage)alignof(_Storage) == _LIBCPP_ALIGNOF(_CompressedPair)alignof(_CompressedPair), "");
361    static_assert(sizeof(_Storage) == sizeof(_CompressedPair), "");
362    _Storage __storage_;
363};
364 
365struct __shared_ptr_dummy_rebind_allocator_type;
366template <>
367class _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) allocator<__shared_ptr_dummy_rebind_allocator_type>
368{
369public:
370    template <class _Other>
371    struct rebind
372    {
373        typedef allocator<_Other> other;
374    };
375};
376 
377template<class _Tp> class _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) enable_shared_from_this;
378 
379template<class _Tp, class _Up>
380struct __compatible_with
381#if _LIBCPP_STD_VER14 > 14
382    : is_convertible<remove_extent_t<_Tp>*, remove_extent_t<_Up>*> {};
383#else
384    : is_convertible<_Tp*, _Up*> {};
385#endif // _LIBCPP_STD_VER > 14
386 
387template <class _Ptr, class = void>
388struct __is_deletable : false_type { };
389template <class _Ptr>
390struct __is_deletable<_Ptr, decltype(delete declval<_Ptr>())> : true_type { };
391 
392template <class _Ptr, class = void>
393struct __is_array_deletable : false_type { };
394template <class _Ptr>
395struct __is_array_deletable<_Ptr, decltype(delete[] declval<_Ptr>())> : true_type { };
396 
397template <class _Dp, class _Pt,
398    class = decltype(declval<_Dp>()(declval<_Pt>()))>
399static true_type __well_formed_deleter_test(int);
400 
401template <class, class>
402static false_type __well_formed_deleter_test(...);
403 
404template <class _Dp, class _Pt>
405struct __well_formed_deleter : decltype(__well_formed_deleter_test<_Dp, _Pt>(0)) {};
406 
407template<class _Dp, class _Tp, class _Yp>
408struct __shared_ptr_deleter_ctor_reqs
409{
410    static const bool value = __compatible_with<_Tp, _Yp>::value &&
411                              is_move_constructible<_Dp>::value &&
412                              __well_formed_deleter<_Dp, _Tp*>::value;
413};
414 
415#if defined(_LIBCPP_ABI_ENABLE_SHARED_PTR_TRIVIAL_ABI)
416#  define _LIBCPP_SHARED_PTR_TRIVIAL_ABI __attribute__((trivial_abi))
417#else
418#  define _LIBCPP_SHARED_PTR_TRIVIAL_ABI
419#endif
420 
421template<class _Tp>
422class _LIBCPP_SHARED_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) shared_ptr
423{
424public:
425#if _LIBCPP_STD_VER14 > 14
426    typedef weak_ptr<_Tp> weak_type;
427    typedef remove_extent_t<_Tp> element_type;
428#else
429    typedef _Tp element_type;
430#endif
431 
432private:
433    element_type*      __ptr_;
434    __shared_weak_count* __cntrl_;
435 
436    struct __nat {int __for_bool_;};
437public:
438    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
439    _LIBCPP_CONSTEXPRconstexpr shared_ptr() _NOEXCEPTnoexcept;
440    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
441    _LIBCPP_CONSTEXPRconstexpr shared_ptr(nullptr_t) _NOEXCEPTnoexcept;
442 
443    template<class _Yp, class = _EnableIf<
444        _And<
445            __compatible_with<_Yp, _Tp>
446            // In C++03 we get errors when trying to do SFINAE with the
447            // delete operator, so we always pretend that it's deletable.
448            // The same happens on GCC.
449#if !defined(_LIBCPP_CXX03_LANG) && !defined(_LIBCPP_COMPILER_GCC)
450            , _If<is_array<_Tp>::value, __is_array_deletable<_Yp*>, __is_deletable<_Yp*> >
451#endif
452        >::value
453    > >
454    explicit shared_ptr(_Yp* __p) : __ptr_(__p) {
455        unique_ptr<_Yp> __hold(__p);
456        typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
457        typedef __shared_ptr_pointer<_Yp*, __shared_ptr_default_delete<_Tp, _Yp>, _AllocT > _CntrlBlk;
458        __cntrl_ = new _CntrlBlk(__p, __shared_ptr_default_delete<_Tp, _Yp>(), _AllocT());
459        __hold.release();
460        __enable_weak_this(__p, __p);
461    }
462 
463    template<class _Yp, class _Dp>
464        shared_ptr(_Yp* __p, _Dp __d,
465                   typename enable_if<__shared_ptr_deleter_ctor_reqs<_Dp, _Yp, element_type>::value, __nat>::type = __nat());
466    template<class _Yp, class _Dp, class _Alloc>
467        shared_ptr(_Yp* __p, _Dp __d, _Alloc __a,
468                   typename enable_if<__shared_ptr_deleter_ctor_reqs<_Dp, _Yp, element_type>::value, __nat>::type = __nat());
469    template <class _Dp> shared_ptr(nullptr_t __p, _Dp __d);
470    template <class _Dp, class _Alloc> shared_ptr(nullptr_t __p, _Dp __d, _Alloc __a);
471    template<class _Yp> _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
)) shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) _NOEXCEPTnoexcept;
472    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
473    shared_ptr(const shared_ptr& __r) _NOEXCEPTnoexcept;
474    template<class _Yp>
475        _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
476        shared_ptr(const shared_ptr<_Yp>& __r,
477                   typename enable_if<__compatible_with<_Yp, element_type>::value, __nat>::type = __nat())
478                       _NOEXCEPTnoexcept;
479    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
480    shared_ptr(shared_ptr&& __r) _NOEXCEPTnoexcept;
481    template<class _Yp> _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))  shared_ptr(shared_ptr<_Yp>&& __r,
482                   typename enable_if<__compatible_with<_Yp, element_type>::value, __nat>::type = __nat())
483                       _NOEXCEPTnoexcept;
484    template<class _Yp> explicit shared_ptr(const weak_ptr<_Yp>& __r,
485                   typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type= __nat());
486#if _LIBCPP_STD_VER14 <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
487    template<class _Yp>
488        shared_ptr(auto_ptr<_Yp>&& __r,
489                   typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type = __nat());
490#endif
491    template <class _Yp, class _Dp>
492        shared_ptr(unique_ptr<_Yp, _Dp>&&,
493                   typename enable_if
494                   <
495                       !is_lvalue_reference<_Dp>::value &&
496                       is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
497                       __nat
498                   >::type = __nat());
499    template <class _Yp, class _Dp>
500        shared_ptr(unique_ptr<_Yp, _Dp>&&,
501                   typename enable_if
502                   <
503                       is_lvalue_reference<_Dp>::value &&
504                       is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
505                       __nat
506                   >::type = __nat());
507 
508    ~shared_ptr();
509 
510    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
511    shared_ptr& operator=(const shared_ptr& __r) _NOEXCEPTnoexcept;
512    template<class _Yp>
513        typename enable_if
514        <
515            __compatible_with<_Yp, element_type>::value,
516            shared_ptr&
517        >::type
518        _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
519        operator=(const shared_ptr<_Yp>& __r) _NOEXCEPTnoexcept;
520    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
521    shared_ptr& operator=(shared_ptr&& __r) _NOEXCEPTnoexcept;
522    template<class _Yp>
523        typename enable_if
524        <
525            __compatible_with<_Yp, element_type>::value,
526            shared_ptr&
527        >::type
528        _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
529        operator=(shared_ptr<_Yp>&& __r);
530#if _LIBCPP_STD_VER14 <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
531    template<class _Yp>
532        _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
533        typename enable_if
534        <
535            !is_array<_Yp>::value &&
536            is_convertible<_Yp*, element_type*>::value,
537            shared_ptr
538        >::type&
539        operator=(auto_ptr<_Yp>&& __r);
540#endif
541    template <class _Yp, class _Dp>
542        typename enable_if
543        <
544            is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
545            shared_ptr&
546        >::type
547        _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
548        operator=(unique_ptr<_Yp, _Dp>&& __r);
549 
550    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
551    void swap(shared_ptr& __r) _NOEXCEPTnoexcept;
552    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
553    void reset() _NOEXCEPTnoexcept;
554    template<class _Yp>
555        typename enable_if
556        <
557            __compatible_with<_Yp, element_type>::value,
558            void
559        >::type
560        _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
561        reset(_Yp* __p);
562    template<class _Yp, class _Dp>
563        typename enable_if
564        <
565            __compatible_with<_Yp, element_type>::value,
566            void
567        >::type
568        _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
569        reset(_Yp* __p, _Dp __d);
570    template<class _Yp, class _Dp, class _Alloc>
571        typename enable_if
572        <
573            __compatible_with<_Yp, element_type>::value,
574            void
575        >::type
576        _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
577        reset(_Yp* __p, _Dp __d, _Alloc __a);
578 
579    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
580    element_type* get() const _NOEXCEPTnoexcept {return __ptr_;}
581    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
582    typename add_lvalue_reference<element_type>::type operator*() const _NOEXCEPTnoexcept
583        {return *__ptr_;}
584    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
585    element_type* operator->() const _NOEXCEPTnoexcept
586    {
587        static_assert(!is_array<_Tp>::value,
588                      "std::shared_ptr<T>::operator-> is only valid when T is not an array type.");
589        return __ptr_;
590    }
591    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
592    long use_count() const _NOEXCEPTnoexcept {return __cntrl_ ? __cntrl_->use_count() : 0;}
593    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
594    bool unique() const _NOEXCEPTnoexcept {return use_count() == 1;}
595    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
596    explicit operator bool() const _NOEXCEPTnoexcept {return get() != nullptr;}
24
←
Returning zero, which participates in a condition later→
597    template <class _Up>
598        _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
599        bool owner_before(shared_ptr<_Up> const& __p) const _NOEXCEPTnoexcept
600        {return __cntrl_ < __p.__cntrl_;}
601    template <class _Up>
602        _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
603        bool owner_before(weak_ptr<_Up> const& __p) const _NOEXCEPTnoexcept
604        {return __cntrl_ < __p.__cntrl_;}
605    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
606    bool
607    __owner_equivalent(const shared_ptr& __p) const
608        {return __cntrl_ == __p.__cntrl_;}
609 
610#if _LIBCPP_STD_VER14 > 14
611    typename add_lvalue_reference<element_type>::type
612    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
613    operator[](ptrdiff_t __i) const
614    {
615            static_assert(is_array<_Tp>::value,
616                          "std::shared_ptr<T>::operator[] is only valid when T is an array type.");
617            return __ptr_[__i];
618    }
619#endif
620 
621#ifndef _LIBCPP_NO_RTTI
622    template <class _Dp>
623        _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
624        _Dp* __get_deleter() const _NOEXCEPTnoexcept
625            {return static_cast<_Dp*>(__cntrl_
626                    ? const_cast<void *>(__cntrl_->__get_deleter(typeid(_Dp)))
627                      : nullptr);}
628#endif // _LIBCPP_NO_RTTI
629 
630    template<class _Yp, class _CntrlBlk>
631    static shared_ptr<_Tp>
632    __create_with_control_block(_Yp* __p, _CntrlBlk* __cntrl) _NOEXCEPTnoexcept
633    {
634        shared_ptr<_Tp> __r;
635        __r.__ptr_ = __p;
636        __r.__cntrl_ = __cntrl;
637        __r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
638        return __r;
639    }
640 
641private:
642    template <class _Yp, bool = is_function<_Yp>::value>
643        struct __shared_ptr_default_allocator
644        {
645            typedef allocator<_Yp> type;
646        };
647 
648    template <class _Yp>
649        struct __shared_ptr_default_allocator<_Yp, true>
650        {
651            typedef allocator<__shared_ptr_dummy_rebind_allocator_type> type;
652        };
653 
654    template <class _Yp, class _OrigPtr>
655        _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
656        typename enable_if<is_convertible<_OrigPtr*,
657                                          const enable_shared_from_this<_Yp>*
658        >::value,
659            void>::type
660        __enable_weak_this(const enable_shared_from_this<_Yp>* __e,
661                           _OrigPtr* __ptr) _NOEXCEPTnoexcept
662        {
663            typedef typename remove_cv<_Yp>::type _RawYp;
664            if (__e && __e->__weak_this_.expired())
665            {
666                __e->__weak_this_ = shared_ptr<_RawYp>(*this,
667                    const_cast<_RawYp*>(static_cast<const _Yp*>(__ptr)));
668            }
669        }
670 
671    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
)) void __enable_weak_this(...) _NOEXCEPTnoexcept {}
672 
673    template <class, class _Yp>
674        struct __shared_ptr_default_delete
675            : default_delete<_Yp> {};
676 
677    template <class _Yp, class _Un, size_t _Sz>
678        struct __shared_ptr_default_delete<_Yp[_Sz], _Un>
679            : default_delete<_Yp[]> {};
680 
681    template <class _Yp, class _Un>
682        struct __shared_ptr_default_delete<_Yp[], _Un>
683            : default_delete<_Yp[]> {};
684 
685    template <class _Up> friend class _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) shared_ptr;
686    template <class _Up> friend class _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) weak_ptr;
687};
688 
689#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
690template<class _Tp>
691shared_ptr(weak_ptr<_Tp>) -> shared_ptr<_Tp>;
692template<class _Tp, class _Dp>
693shared_ptr(unique_ptr<_Tp, _Dp>) -> shared_ptr<_Tp>;
694#endif
695 
696template<class _Tp>
697inline
698_LIBCPP_CONSTEXPRconstexpr
699shared_ptr<_Tp>::shared_ptr() _NOEXCEPTnoexcept
700    : __ptr_(nullptr),
701      __cntrl_(nullptr)
702{
703}
704 
705template<class _Tp>
706inline
707_LIBCPP_CONSTEXPRconstexpr
708shared_ptr<_Tp>::shared_ptr(nullptr_t) _NOEXCEPTnoexcept
709    : __ptr_(nullptr),
710      __cntrl_(nullptr)
711{
712}
713 
714template<class _Tp>
715template<class _Yp, class _Dp>
716shared_ptr<_Tp>::shared_ptr(_Yp* __p, _Dp __d,
717                            typename enable_if<__shared_ptr_deleter_ctor_reqs<_Dp, _Yp, element_type>::value, __nat>::type)
718    : __ptr_(__p)
719{
720#ifndef _LIBCPP_NO_EXCEPTIONS
721    try
722    {
723#endif // _LIBCPP_NO_EXCEPTIONS
724        typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
725        typedef __shared_ptr_pointer<_Yp*, _Dp, _AllocT > _CntrlBlk;
726#ifndef _LIBCPP_CXX03_LANG
727        __cntrl_ = new _CntrlBlk(__p, _VSTDstd::__1::move(__d), _AllocT());
728#else
729        __cntrl_ = new _CntrlBlk(__p, __d, _AllocT());
730#endif // not _LIBCPP_CXX03_LANG
731        __enable_weak_this(__p, __p);
732#ifndef _LIBCPP_NO_EXCEPTIONS
733    }
734    catch (...)
735    {
736        __d(__p);
737        throw;
738    }
739#endif // _LIBCPP_NO_EXCEPTIONS
740}
741 
742template<class _Tp>
743template<class _Dp>
744shared_ptr<_Tp>::shared_ptr(nullptr_t __p, _Dp __d)
745    : __ptr_(nullptr)
746{
747#ifndef _LIBCPP_NO_EXCEPTIONS
748    try
749    {
750#endif // _LIBCPP_NO_EXCEPTIONS
751        typedef typename __shared_ptr_default_allocator<_Tp>::type _AllocT;
752        typedef __shared_ptr_pointer<nullptr_t, _Dp, _AllocT > _CntrlBlk;
753#ifndef _LIBCPP_CXX03_LANG
754        __cntrl_ = new _CntrlBlk(__p, _VSTDstd::__1::move(__d), _AllocT());
755#else
756        __cntrl_ = new _CntrlBlk(__p, __d, _AllocT());
757#endif // not _LIBCPP_CXX03_LANG
758#ifndef _LIBCPP_NO_EXCEPTIONS
759    }
760    catch (...)
761    {
762        __d(__p);
763        throw;
764    }
765#endif // _LIBCPP_NO_EXCEPTIONS
766}
767 
768template<class _Tp>
769template<class _Yp, class _Dp, class _Alloc>
770shared_ptr<_Tp>::shared_ptr(_Yp* __p, _Dp __d, _Alloc __a,
771                            typename enable_if<__shared_ptr_deleter_ctor_reqs<_Dp, _Yp, element_type>::value, __nat>::type)
772    : __ptr_(__p)
773{
774#ifndef _LIBCPP_NO_EXCEPTIONS
775    try
776    {
777#endif // _LIBCPP_NO_EXCEPTIONS
778        typedef __shared_ptr_pointer<_Yp*, _Dp, _Alloc> _CntrlBlk;
779        typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _A2;
780        typedef __allocator_destructor<_A2> _D2;
781        _A2 __a2(__a);
782        unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
783        ::new ((void*)_VSTDstd::__1::addressof(*__hold2.get()))
784#ifndef _LIBCPP_CXX03_LANG
785            _CntrlBlk(__p, _VSTDstd::__1::move(__d), __a);
786#else
787            _CntrlBlk(__p, __d, __a);
788#endif // not _LIBCPP_CXX03_LANG
789        __cntrl_ = _VSTDstd::__1::addressof(*__hold2.release());
790        __enable_weak_this(__p, __p);
791#ifndef _LIBCPP_NO_EXCEPTIONS
792    }
793    catch (...)
794    {
795        __d(__p);
796        throw;
797    }
798#endif // _LIBCPP_NO_EXCEPTIONS
799}
800 
801template<class _Tp>
802template<class _Dp, class _Alloc>
803shared_ptr<_Tp>::shared_ptr(nullptr_t __p, _Dp __d, _Alloc __a)
804    : __ptr_(nullptr)
805{
806#ifndef _LIBCPP_NO_EXCEPTIONS
807    try
808    {
809#endif // _LIBCPP_NO_EXCEPTIONS
810        typedef __shared_ptr_pointer<nullptr_t, _Dp, _Alloc> _CntrlBlk;
811        typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _A2;
812        typedef __allocator_destructor<_A2> _D2;
813        _A2 __a2(__a);
814        unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
815        ::new ((void*)_VSTDstd::__1::addressof(*__hold2.get()))
816#ifndef _LIBCPP_CXX03_LANG
817            _CntrlBlk(__p, _VSTDstd::__1::move(__d), __a);
818#else
819            _CntrlBlk(__p, __d, __a);
820#endif // not _LIBCPP_CXX03_LANG
821        __cntrl_ = _VSTDstd::__1::addressof(*__hold2.release());
822#ifndef _LIBCPP_NO_EXCEPTIONS
823    }
824    catch (...)
825    {
826        __d(__p);
827        throw;
828    }
829#endif // _LIBCPP_NO_EXCEPTIONS
830}
831 
832template<class _Tp>
833template<class _Yp>
834inline
835shared_ptr<_Tp>::shared_ptr(const shared_ptr<_Yp>& __r, element_type *__p) _NOEXCEPTnoexcept
836    : __ptr_(__p),
837      __cntrl_(__r.__cntrl_)
838{
839    if (__cntrl_)
840        __cntrl_->__add_shared();
841}
842 
843template<class _Tp>
844inline
845shared_ptr<_Tp>::shared_ptr(const shared_ptr& __r) _NOEXCEPTnoexcept
846    : __ptr_(__r.__ptr_),
847      __cntrl_(__r.__cntrl_)
848{
849    if (__cntrl_)
850        __cntrl_->__add_shared();
851}
852 
853template<class _Tp>
854template<class _Yp>
855inline
856shared_ptr<_Tp>::shared_ptr(const shared_ptr<_Yp>& __r,
857                            typename enable_if<__compatible_with<_Yp, element_type>::value, __nat>::type)
858         _NOEXCEPTnoexcept
859    : __ptr_(__r.__ptr_),
860      __cntrl_(__r.__cntrl_)
861{
862    if (__cntrl_)
863        __cntrl_->__add_shared();
864}
865 
866template<class _Tp>
867inline
868shared_ptr<_Tp>::shared_ptr(shared_ptr&& __r) _NOEXCEPTnoexcept
869    : __ptr_(__r.__ptr_),
870      __cntrl_(__r.__cntrl_)
871{
872    __r.__ptr_ = nullptr;
873    __r.__cntrl_ = nullptr;
874}
875 
876template<class _Tp>
877template<class _Yp>
878inline
879shared_ptr<_Tp>::shared_ptr(shared_ptr<_Yp>&& __r,
880                            typename enable_if<__compatible_with<_Yp, element_type>::value, __nat>::type)
881         _NOEXCEPTnoexcept
882    : __ptr_(__r.__ptr_),
883      __cntrl_(__r.__cntrl_)
884{
885    __r.__ptr_ = nullptr;
886    __r.__cntrl_ = nullptr;
887}
888 
889#if _LIBCPP_STD_VER14 <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
890template<class _Tp>
891template<class _Yp>
892shared_ptr<_Tp>::shared_ptr(auto_ptr<_Yp>&& __r,
893                            typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type)
894    : __ptr_(__r.get())
895{
896    typedef __shared_ptr_pointer<_Yp*, default_delete<_Yp>, allocator<_Yp> > _CntrlBlk;
897    __cntrl_ = new _CntrlBlk(__r.get(), default_delete<_Yp>(), allocator<_Yp>());
898    __enable_weak_this(__r.get(), __r.get());
899    __r.release();
900}
901#endif
902 
903template<class _Tp>
904template <class _Yp, class _Dp>
905shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp>&& __r,
906                            typename enable_if
907                            <
908                                !is_lvalue_reference<_Dp>::value &&
909                                is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
910                                __nat
911                            >::type)
912    : __ptr_(__r.get())
913{
914#if _LIBCPP_STD_VER14 > 11
915    if (__ptr_ == nullptr)
916        __cntrl_ = nullptr;
917    else
918#endif
919    {
920        typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
921        typedef __shared_ptr_pointer<typename unique_ptr<_Yp, _Dp>::pointer, _Dp, _AllocT > _CntrlBlk;
922        __cntrl_ = new _CntrlBlk(__r.get(), __r.get_deleter(), _AllocT());
923        __enable_weak_this(__r.get(), __r.get());
924    }
925    __r.release();
926}
927 
928template<class _Tp>
929template <class _Yp, class _Dp>
930shared_ptr<_Tp>::shared_ptr(unique_ptr<_Yp, _Dp>&& __r,
931                            typename enable_if
932                            <
933                                is_lvalue_reference<_Dp>::value &&
934                                is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
935                                __nat
936                            >::type)
937    : __ptr_(__r.get())
938{
939#if _LIBCPP_STD_VER14 > 11
940    if (__ptr_ == nullptr)
941        __cntrl_ = nullptr;
942    else
943#endif
944    {
945        typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
946        typedef __shared_ptr_pointer<typename unique_ptr<_Yp, _Dp>::pointer,
947                                     reference_wrapper<typename remove_reference<_Dp>::type>,
948                                     _AllocT > _CntrlBlk;
949        __cntrl_ = new _CntrlBlk(__r.get(), _VSTDstd::__1::ref(__r.get_deleter()), _AllocT());
950        __enable_weak_this(__r.get(), __r.get());
951    }
952    __r.release();
953}
954 
955template<class _Tp>
956shared_ptr<_Tp>::~shared_ptr()
957{
958    if (__cntrl_)
959        __cntrl_->__release_shared();
960}
961 
962template<class _Tp>
963inline
964shared_ptr<_Tp>&
965shared_ptr<_Tp>::operator=(const shared_ptr& __r) _NOEXCEPTnoexcept
966{
967    shared_ptr(__r).swap(*this);
968    return *this;
969}
970 
971template<class _Tp>
972template<class _Yp>
973inline
974typename enable_if
975<
976    __compatible_with<_Yp, typename shared_ptr<_Tp>::element_type>::value,
977    shared_ptr<_Tp>&
978>::type
979shared_ptr<_Tp>::operator=(const shared_ptr<_Yp>& __r) _NOEXCEPTnoexcept
980{
981    shared_ptr(__r).swap(*this);
982    return *this;
983}
984 
985template<class _Tp>
986inline
987shared_ptr<_Tp>&
988shared_ptr<_Tp>::operator=(shared_ptr&& __r) _NOEXCEPTnoexcept
989{
990    shared_ptr(_VSTDstd::__1::move(__r)).swap(*this);
991    return *this;
992}
993 
994template<class _Tp>
995template<class _Yp>
996inline
997typename enable_if
998<
999    __compatible_with<_Yp, typename shared_ptr<_Tp>::element_type>::value,
1000    shared_ptr<_Tp>&
1001>::type
1002shared_ptr<_Tp>::operator=(shared_ptr<_Yp>&& __r)
1003{
1004    shared_ptr(_VSTDstd::__1::move(__r)).swap(*this);
1005    return *this;
1006}
1007 
1008#if _LIBCPP_STD_VER14 <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
1009template<class _Tp>
1010template<class _Yp>
1011inline
1012typename enable_if
1013<
1014    !is_array<_Yp>::value &&
1015    is_convertible<_Yp*, typename shared_ptr<_Tp>::element_type*>::value,
1016    shared_ptr<_Tp>
1017>::type&
1018shared_ptr<_Tp>::operator=(auto_ptr<_Yp>&& __r)
1019{
1020    shared_ptr(_VSTDstd::__1::move(__r)).swap(*this);
1021    return *this;
1022}
1023#endif
1024 
1025template<class _Tp>
1026template <class _Yp, class _Dp>
1027inline
1028typename enable_if
1029<
1030    is_convertible<typename unique_ptr<_Yp, _Dp>::pointer,
1031                   typename shared_ptr<_Tp>::element_type*>::value,
1032    shared_ptr<_Tp>&
1033>::type
1034shared_ptr<_Tp>::operator=(unique_ptr<_Yp, _Dp>&& __r)
1035{
1036    shared_ptr(_VSTDstd::__1::move(__r)).swap(*this);
1037    return *this;
1038}
1039 
1040template<class _Tp>
1041inline
1042void
1043shared_ptr<_Tp>::swap(shared_ptr& __r) _NOEXCEPTnoexcept
1044{
1045    _VSTDstd::__1::swap(__ptr_, __r.__ptr_);
1046    _VSTDstd::__1::swap(__cntrl_, __r.__cntrl_);
1047}
1048 
1049template<class _Tp>
1050inline
1051void
1052shared_ptr<_Tp>::reset() _NOEXCEPTnoexcept
1053{
1054    shared_ptr().swap(*this);
1055}
1056 
1057template<class _Tp>
1058template<class _Yp>
1059inline
1060typename enable_if
1061<
1062    __compatible_with<_Yp, typename shared_ptr<_Tp>::element_type>::value,
1063    void
1064>::type
1065shared_ptr<_Tp>::reset(_Yp* __p)
1066{
1067    shared_ptr(__p).swap(*this);
1068}
1069 
1070template<class _Tp>
1071template<class _Yp, class _Dp>
1072inline
1073typename enable_if
1074<
1075    __compatible_with<_Yp, typename shared_ptr<_Tp>::element_type>::value,
1076    void
1077>::type
1078shared_ptr<_Tp>::reset(_Yp* __p, _Dp __d)
1079{
1080    shared_ptr(__p, __d).swap(*this);
1081}
1082 
1083template<class _Tp>
1084template<class _Yp, class _Dp, class _Alloc>
1085inline
1086typename enable_if
1087<
1088    __compatible_with<_Yp, typename shared_ptr<_Tp>::element_type>::value,
1089    void
1090>::type
1091shared_ptr<_Tp>::reset(_Yp* __p, _Dp __d, _Alloc __a)
1092{
1093    shared_ptr(__p, __d, __a).swap(*this);
1094}
1095 
1096//
1097// std::allocate_shared and std::make_shared
1098//
1099template<class _Tp, class _Alloc, class ..._Args, class = _EnableIf<!is_array<_Tp>::value> >
1100_LIBCPP_HIDE_FROM_ABI__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1101shared_ptr<_Tp> allocate_shared(const _Alloc& __a, _Args&& ...__args)
1102{
1103    using _ControlBlock = __shared_ptr_emplace<_Tp, _Alloc>;
1104    using _ControlBlockAllocator = typename __allocator_traits_rebind<_Alloc, _ControlBlock>::type;
1105    __allocation_guard<_ControlBlockAllocator> __guard(__a, 1);
1106    ::new ((void*)_VSTDstd::__1::addressof(*__guard.__get())) _ControlBlock(__a, _VSTDstd::__1::forward<_Args>(__args)...);
1107    auto __control_block = __guard.__release_ptr();
1108    return shared_ptr<_Tp>::__create_with_control_block((*__control_block).__get_elem(), _VSTDstd::__1::addressof(*__control_block));
1109}
1110 
1111template<class _Tp, class ..._Args, class = _EnableIf<!is_array<_Tp>::value> >
1112_LIBCPP_HIDE_FROM_ABI__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1113shared_ptr<_Tp> make_shared(_Args&& ...__args)
1114{
1115    return _VSTDstd::__1::allocate_shared<_Tp>(allocator<_Tp>(), _VSTDstd::__1::forward<_Args>(__args)...);
1116}
1117 
1118template<class _Tp, class _Up>
1119inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1120bool
1121operator==(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPTnoexcept
1122{
1123    return __x.get() == __y.get();
1124}
1125 
1126template<class _Tp, class _Up>
1127inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1128bool
1129operator!=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPTnoexcept
1130{
1131    return !(__x == __y);
1132}
1133 
1134template<class _Tp, class _Up>
1135inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1136bool
1137operator<(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPTnoexcept
1138{
1139#if _LIBCPP_STD_VER14 <= 11
1140    typedef typename common_type<_Tp*, _Up*>::type _Vp;
1141    return less<_Vp>()(__x.get(), __y.get());
1142#else
1143    return less<>()(__x.get(), __y.get());
1144#endif
1145 
1146}
1147 
1148template<class _Tp, class _Up>
1149inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1150bool
1151operator>(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPTnoexcept
1152{
1153    return __y < __x;
1154}
1155 
1156template<class _Tp, class _Up>
1157inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1158bool
1159operator<=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPTnoexcept
1160{
1161    return !(__y < __x);
1162}
1163 
1164template<class _Tp, class _Up>
1165inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1166bool
1167operator>=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPTnoexcept
1168{
1169    return !(__x < __y);
1170}
1171 
1172template<class _Tp>
1173inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1174bool
1175operator==(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPTnoexcept
1176{
1177    return !__x;
23
←
Calling 'shared_ptr::operator bool'→
25
←
Returning from 'shared_ptr::operator bool'→
26
←
Returning the value 1, which participates in a condition later→
1178}
1179 
1180template<class _Tp>
1181inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1182bool
1183operator==(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPTnoexcept
1184{
1185    return !__x;
1186}
1187 
1188template<class _Tp>
1189inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1190bool
1191operator!=(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPTnoexcept
1192{
1193    return static_cast<bool>(__x);
1194}
1195 
1196template<class _Tp>
1197inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1198bool
1199operator!=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPTnoexcept
1200{
1201    return static_cast<bool>(__x);
1202}
1203 
1204template<class _Tp>
1205inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1206bool
1207operator<(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPTnoexcept
1208{
1209    return less<_Tp*>()(__x.get(), nullptr);
1210}
1211 
1212template<class _Tp>
1213inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1214bool
1215operator<(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPTnoexcept
1216{
1217    return less<_Tp*>()(nullptr, __x.get());
1218}
1219 
1220template<class _Tp>
1221inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1222bool
1223operator>(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPTnoexcept
1224{
1225    return nullptr < __x;
1226}
1227 
1228template<class _Tp>
1229inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1230bool
1231operator>(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPTnoexcept
1232{
1233    return __x < nullptr;
1234}
1235 
1236template<class _Tp>
1237inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1238bool
1239operator<=(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPTnoexcept
1240{
1241    return !(nullptr < __x);
1242}
1243 
1244template<class _Tp>
1245inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1246bool
1247operator<=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPTnoexcept
1248{
1249    return !(__x < nullptr);
1250}
1251 
1252template<class _Tp>
1253inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1254bool
1255operator>=(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPTnoexcept
1256{
1257    return !(__x < nullptr);
1258}
1259 
1260template<class _Tp>
1261inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1262bool
1263operator>=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPTnoexcept
1264{
1265    return !(nullptr < __x);
1266}
1267 
1268template<class _Tp>
1269inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1270void
1271swap(shared_ptr<_Tp>& __x, shared_ptr<_Tp>& __y) _NOEXCEPTnoexcept
1272{
1273    __x.swap(__y);
1274}
1275 
1276template<class _Tp, class _Up>
1277inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1278shared_ptr<_Tp>
1279static_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPTnoexcept
1280{
1281    return shared_ptr<_Tp>(__r,
1282                           static_cast<
1283                               typename shared_ptr<_Tp>::element_type*>(__r.get()));
1284}
1285 
1286template<class _Tp, class _Up>
1287inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1288shared_ptr<_Tp>
1289dynamic_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPTnoexcept
1290{
1291    typedef typename shared_ptr<_Tp>::element_type _ET;
1292    _ET* __p = dynamic_cast<_ET*>(__r.get());
1293    return __p ? shared_ptr<_Tp>(__r, __p) : shared_ptr<_Tp>();
1294}
1295 
1296template<class _Tp, class _Up>
1297shared_ptr<_Tp>
1298const_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPTnoexcept
1299{
1300    typedef typename shared_ptr<_Tp>::element_type _RTp;
1301    return shared_ptr<_Tp>(__r, const_cast<_RTp*>(__r.get()));
1302}
1303 
1304template<class _Tp, class _Up>
1305shared_ptr<_Tp>
1306reinterpret_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPTnoexcept
1307{
1308    return shared_ptr<_Tp>(__r,
1309                           reinterpret_cast<
1310                               typename shared_ptr<_Tp>::element_type*>(__r.get()));
1311}
1312 
1313#ifndef _LIBCPP_NO_RTTI
1314 
1315template<class _Dp, class _Tp>
1316inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1317_Dp*
1318get_deleter(const shared_ptr<_Tp>& __p) _NOEXCEPTnoexcept
1319{
1320    return __p.template __get_deleter<_Dp>();
1321}
1322 
1323#endif // _LIBCPP_NO_RTTI
1324 
1325template<class _Tp>
1326class _LIBCPP_SHARED_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) weak_ptr
1327{
1328public:
1329    typedef _Tp element_type;
1330private:
1331    element_type*        __ptr_;
1332    __shared_weak_count* __cntrl_;
1333 
1334public:
1335    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1336    _LIBCPP_CONSTEXPRconstexpr weak_ptr() _NOEXCEPTnoexcept;
1337    template<class _Yp> _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
)) weak_ptr(shared_ptr<_Yp> const& __r,
1338                   typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type = 0)
1339                        _NOEXCEPTnoexcept;
1340    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1341    weak_ptr(weak_ptr const& __r) _NOEXCEPTnoexcept;
1342    template<class _Yp> _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
)) weak_ptr(weak_ptr<_Yp> const& __r,
1343                   typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type = 0)
1344                         _NOEXCEPTnoexcept;
1345 
1346    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1347    weak_ptr(weak_ptr&& __r) _NOEXCEPTnoexcept;
1348    template<class _Yp> _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
)) weak_ptr(weak_ptr<_Yp>&& __r,
1349                   typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type = 0)
1350                         _NOEXCEPTnoexcept;
1351    ~weak_ptr();
1352 
1353    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1354    weak_ptr& operator=(weak_ptr const& __r) _NOEXCEPTnoexcept;
1355    template<class _Yp>
1356        typename enable_if
1357        <
1358            is_convertible<_Yp*, element_type*>::value,
1359            weak_ptr&
1360        >::type
1361        _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1362        operator=(weak_ptr<_Yp> const& __r) _NOEXCEPTnoexcept;
1363 
1364    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1365    weak_ptr& operator=(weak_ptr&& __r) _NOEXCEPTnoexcept;
1366    template<class _Yp>
1367        typename enable_if
1368        <
1369            is_convertible<_Yp*, element_type*>::value,
1370            weak_ptr&
1371        >::type
1372        _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1373        operator=(weak_ptr<_Yp>&& __r) _NOEXCEPTnoexcept;
1374 
1375    template<class _Yp>
1376        typename enable_if
1377        <
1378            is_convertible<_Yp*, element_type*>::value,
1379            weak_ptr&
1380        >::type
1381        _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1382        operator=(shared_ptr<_Yp> const& __r) _NOEXCEPTnoexcept;
1383 
1384    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1385    void swap(weak_ptr& __r) _NOEXCEPTnoexcept;
1386    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1387    void reset() _NOEXCEPTnoexcept;
1388 
1389    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1390    long use_count() const _NOEXCEPTnoexcept
1391        {return __cntrl_ ? __cntrl_->use_count() : 0;}
1392    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1393    bool expired() const _NOEXCEPTnoexcept
1394        {return __cntrl_ == nullptr || __cntrl_->use_count() == 0;}
1395    shared_ptr<_Tp> lock() const _NOEXCEPTnoexcept;
1396    template<class _Up>
1397        _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1398        bool owner_before(const shared_ptr<_Up>& __r) const _NOEXCEPTnoexcept
1399        {return __cntrl_ < __r.__cntrl_;}
1400    template<class _Up>
1401        _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1402        bool owner_before(const weak_ptr<_Up>& __r) const _NOEXCEPTnoexcept
1403        {return __cntrl_ < __r.__cntrl_;}
1404 
1405    template <class _Up> friend class _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) weak_ptr;
1406    template <class _Up> friend class _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) shared_ptr;
1407};
1408 
1409#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
1410template<class _Tp>
1411weak_ptr(shared_ptr<_Tp>) -> weak_ptr<_Tp>;
1412#endif
1413 
1414template<class _Tp>
1415inline
1416_LIBCPP_CONSTEXPRconstexpr
1417weak_ptr<_Tp>::weak_ptr() _NOEXCEPTnoexcept
1418    : __ptr_(nullptr),
1419      __cntrl_(nullptr)
1420{
1421}
1422 
1423template<class _Tp>
1424inline
1425weak_ptr<_Tp>::weak_ptr(weak_ptr const& __r) _NOEXCEPTnoexcept
1426    : __ptr_(__r.__ptr_),
1427      __cntrl_(__r.__cntrl_)
1428{
1429    if (__cntrl_)
1430        __cntrl_->__add_weak();
1431}
1432 
1433template<class _Tp>
1434template<class _Yp>
1435inline
1436weak_ptr<_Tp>::weak_ptr(shared_ptr<_Yp> const& __r,
1437                        typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type)
1438                         _NOEXCEPTnoexcept
1439    : __ptr_(__r.__ptr_),
1440      __cntrl_(__r.__cntrl_)
1441{
1442    if (__cntrl_)
1443        __cntrl_->__add_weak();
1444}
1445 
1446template<class _Tp>
1447template<class _Yp>
1448inline
1449weak_ptr<_Tp>::weak_ptr(weak_ptr<_Yp> const& __r,
1450                        typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type)
1451         _NOEXCEPTnoexcept
1452    : __ptr_(__r.__ptr_),
1453      __cntrl_(__r.__cntrl_)
1454{
1455    if (__cntrl_)
1456        __cntrl_->__add_weak();
1457}
1458 
1459template<class _Tp>
1460inline
1461weak_ptr<_Tp>::weak_ptr(weak_ptr&& __r) _NOEXCEPTnoexcept
1462    : __ptr_(__r.__ptr_),
1463      __cntrl_(__r.__cntrl_)
1464{
1465    __r.__ptr_ = nullptr;
1466    __r.__cntrl_ = nullptr;
1467}
1468 
1469template<class _Tp>
1470template<class _Yp>
1471inline
1472weak_ptr<_Tp>::weak_ptr(weak_ptr<_Yp>&& __r,
1473                        typename enable_if<is_convertible<_Yp*, _Tp*>::value, __nat*>::type)
1474         _NOEXCEPTnoexcept
1475    : __ptr_(__r.__ptr_),
1476      __cntrl_(__r.__cntrl_)
1477{
1478    __r.__ptr_ = nullptr;
1479    __r.__cntrl_ = nullptr;
1480}
1481 
1482template<class _Tp>
1483weak_ptr<_Tp>::~weak_ptr()
1484{
1485    if (__cntrl_)
1486        __cntrl_->__release_weak();
1487}
1488 
1489template<class _Tp>
1490inline
1491weak_ptr<_Tp>&
1492weak_ptr<_Tp>::operator=(weak_ptr const& __r) _NOEXCEPTnoexcept
1493{
1494    weak_ptr(__r).swap(*this);
1495    return *this;
1496}
1497 
1498template<class _Tp>
1499template<class _Yp>
1500inline
1501typename enable_if
1502<
1503    is_convertible<_Yp*, _Tp*>::value,
1504    weak_ptr<_Tp>&
1505>::type
1506weak_ptr<_Tp>::operator=(weak_ptr<_Yp> const& __r) _NOEXCEPTnoexcept
1507{
1508    weak_ptr(__r).swap(*this);
1509    return *this;
1510}
1511 
1512template<class _Tp>
1513inline
1514weak_ptr<_Tp>&
1515weak_ptr<_Tp>::operator=(weak_ptr&& __r) _NOEXCEPTnoexcept
1516{
1517    weak_ptr(_VSTDstd::__1::move(__r)).swap(*this);
1518    return *this;
1519}
1520 
1521template<class _Tp>
1522template<class _Yp>
1523inline
1524typename enable_if
1525<
1526    is_convertible<_Yp*, _Tp*>::value,
1527    weak_ptr<_Tp>&
1528>::type
1529weak_ptr<_Tp>::operator=(weak_ptr<_Yp>&& __r) _NOEXCEPTnoexcept
1530{
1531    weak_ptr(_VSTDstd::__1::move(__r)).swap(*this);
1532    return *this;
1533}
1534 
1535template<class _Tp>
1536template<class _Yp>
1537inline
1538typename enable_if
1539<
1540    is_convertible<_Yp*, _Tp*>::value,
1541    weak_ptr<_Tp>&
1542>::type
1543weak_ptr<_Tp>::operator=(shared_ptr<_Yp> const& __r) _NOEXCEPTnoexcept
1544{
1545    weak_ptr(__r).swap(*this);
1546    return *this;
1547}
1548 
1549template<class _Tp>
1550inline
1551void
1552weak_ptr<_Tp>::swap(weak_ptr& __r) _NOEXCEPTnoexcept
1553{
1554    _VSTDstd::__1::swap(__ptr_, __r.__ptr_);
1555    _VSTDstd::__1::swap(__cntrl_, __r.__cntrl_);
1556}
1557 
1558template<class _Tp>
1559inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1560void
1561swap(weak_ptr<_Tp>& __x, weak_ptr<_Tp>& __y) _NOEXCEPTnoexcept
1562{
1563    __x.swap(__y);
1564}
1565 
1566template<class _Tp>
1567inline
1568void
1569weak_ptr<_Tp>::reset() _NOEXCEPTnoexcept
1570{
1571    weak_ptr().swap(*this);
1572}
1573 
1574template<class _Tp>
1575template<class _Yp>
1576shared_ptr<_Tp>::shared_ptr(const weak_ptr<_Yp>& __r,
1577                            typename enable_if<is_convertible<_Yp*, element_type*>::value, __nat>::type)
1578    : __ptr_(__r.__ptr_),
1579      __cntrl_(__r.__cntrl_ ? __r.__cntrl_->lock() : __r.__cntrl_)
1580{
1581    if (__cntrl_ == nullptr)
1582        __throw_bad_weak_ptr();
1583}
1584 
1585template<class _Tp>
1586shared_ptr<_Tp>
1587weak_ptr<_Tp>::lock() const _NOEXCEPTnoexcept
1588{
1589    shared_ptr<_Tp> __r;
1590    __r.__cntrl_ = __cntrl_ ? __cntrl_->lock() : __cntrl_;
1591    if (__r.__cntrl_)
1592        __r.__ptr_ = __ptr_;
1593    return __r;
1594}
1595 
1596#if _LIBCPP_STD_VER14 > 14
1597template <class _Tp = void> struct owner_less;
1598#else
1599template <class _Tp> struct owner_less;
1600#endif
1601 
1602 
1603_LIBCPP_SUPPRESS_DEPRECATED_PUSHGCC diagnostic push
 GCC diagnostic ignored "-Wdeprecated"
 GCC
 diagnostic ignored "-Wdeprecated-declarations"
1604template <class _Tp>
1605struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) owner_less<shared_ptr<_Tp> >
1606#if !defined(_LIBCPP_ABI_NO_BINDER_BASES)
1607    : binary_function<shared_ptr<_Tp>, shared_ptr<_Tp>, bool>
1608#endif
1609{
1610_LIBCPP_SUPPRESS_DEPRECATED_POPGCC diagnostic pop
1611#if _LIBCPP_STD_VER14 <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
1612    _LIBCPP_DEPRECATED_IN_CXX17 typedef bool result_type;
1613    _LIBCPP_DEPRECATED_IN_CXX17 typedef shared_ptr<_Tp> first_argument_type;
1614    _LIBCPP_DEPRECATED_IN_CXX17 typedef shared_ptr<_Tp> second_argument_type;
1615#endif
1616    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1617    bool operator()(shared_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPTnoexcept
1618        {return __x.owner_before(__y);}
1619    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1620    bool operator()(shared_ptr<_Tp> const& __x,   weak_ptr<_Tp> const& __y) const _NOEXCEPTnoexcept
1621        {return __x.owner_before(__y);}
1622    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1623    bool operator()(  weak_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPTnoexcept
1624        {return __x.owner_before(__y);}
1625};
1626 
1627_LIBCPP_SUPPRESS_DEPRECATED_PUSHGCC diagnostic push
 GCC diagnostic ignored "-Wdeprecated"
 GCC
 diagnostic ignored "-Wdeprecated-declarations"
1628template <class _Tp>
1629struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) owner_less<weak_ptr<_Tp> >
1630#if !defined(_LIBCPP_ABI_NO_BINDER_BASES)
1631    : binary_function<weak_ptr<_Tp>, weak_ptr<_Tp>, bool>
1632#endif
1633{
1634_LIBCPP_SUPPRESS_DEPRECATED_POPGCC diagnostic pop
1635#if _LIBCPP_STD_VER14 <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
1636    _LIBCPP_DEPRECATED_IN_CXX17 typedef bool result_type;
1637    _LIBCPP_DEPRECATED_IN_CXX17 typedef weak_ptr<_Tp> first_argument_type;
1638    _LIBCPP_DEPRECATED_IN_CXX17 typedef weak_ptr<_Tp> second_argument_type;
1639#endif
1640    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1641    bool operator()(  weak_ptr<_Tp> const& __x,   weak_ptr<_Tp> const& __y) const _NOEXCEPTnoexcept
1642        {return __x.owner_before(__y);}
1643    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1644    bool operator()(shared_ptr<_Tp> const& __x,   weak_ptr<_Tp> const& __y) const _NOEXCEPTnoexcept
1645        {return __x.owner_before(__y);}
1646    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1647    bool operator()(  weak_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPTnoexcept
1648        {return __x.owner_before(__y);}
1649};
1650 
1651#if _LIBCPP_STD_VER14 > 14
1652template <>
1653struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) owner_less<void>
1654{
1655    template <class _Tp, class _Up>
1656    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1657    bool operator()( shared_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) const _NOEXCEPTnoexcept
1658        {return __x.owner_before(__y);}
1659    template <class _Tp, class _Up>
1660    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1661    bool operator()( shared_ptr<_Tp> const& __x,   weak_ptr<_Up> const& __y) const _NOEXCEPTnoexcept
1662        {return __x.owner_before(__y);}
1663    template <class _Tp, class _Up>
1664    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1665    bool operator()(   weak_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) const _NOEXCEPTnoexcept
1666        {return __x.owner_before(__y);}
1667    template <class _Tp, class _Up>
1668    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1669    bool operator()(   weak_ptr<_Tp> const& __x,   weak_ptr<_Up> const& __y) const _NOEXCEPTnoexcept
1670        {return __x.owner_before(__y);}
1671    typedef void is_transparent;
1672};
1673#endif
1674 
1675template<class _Tp>
1676class _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) enable_shared_from_this
1677{
1678    mutable weak_ptr<_Tp> __weak_this_;
1679protected:
1680    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
)) _LIBCPP_CONSTEXPRconstexpr
1681    enable_shared_from_this() _NOEXCEPTnoexcept {}
1682    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1683    enable_shared_from_this(enable_shared_from_this const&) _NOEXCEPTnoexcept {}
1684    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1685    enable_shared_from_this& operator=(enable_shared_from_this const&) _NOEXCEPTnoexcept
1686        {return *this;}
1687    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1688    ~enable_shared_from_this() {}
1689public:
1690    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1691    shared_ptr<_Tp> shared_from_this()
1692        {return shared_ptr<_Tp>(__weak_this_);}
1693    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1694    shared_ptr<_Tp const> shared_from_this() const
1695        {return shared_ptr<const _Tp>(__weak_this_);}
1696 
1697#if _LIBCPP_STD_VER14 > 14
1698    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1699    weak_ptr<_Tp> weak_from_this() _NOEXCEPTnoexcept
1700       { return __weak_this_; }
1701 
1702    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1703    weak_ptr<const _Tp> weak_from_this() const _NOEXCEPTnoexcept
1704        { return __weak_this_; }
1705#endif // _LIBCPP_STD_VER > 14
1706 
1707    template <class _Up> friend class shared_ptr;
1708};
1709 
1710template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) hash;
1711 
1712template <class _Tp>
1713struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) hash<shared_ptr<_Tp> >
1714{
1715#if _LIBCPP_STD_VER14 <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
1716    _LIBCPP_DEPRECATED_IN_CXX17 typedef shared_ptr<_Tp> argument_type;
1717    _LIBCPP_DEPRECATED_IN_CXX17 typedef size_t          result_type;
1718#endif
1719 
1720    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1721    size_t operator()(const shared_ptr<_Tp>& __ptr) const _NOEXCEPTnoexcept
1722    {
1723        return hash<typename shared_ptr<_Tp>::element_type*>()(__ptr.get());
1724    }
1725};
1726 
1727template<class _CharT, class _Traits, class _Yp>
1728inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1729basic_ostream<_CharT, _Traits>&
1730operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Yp> const& __p);
1731 
1732 
1733#if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
1734 
1735class _LIBCPP_TYPE_VIS__attribute__ ((__visibility__("default"))) __sp_mut
1736{
1737    void* __lx;
1738public:
1739    void lock() _NOEXCEPTnoexcept;
1740    void unlock() _NOEXCEPTnoexcept;
1741 
1742private:
1743    _LIBCPP_CONSTEXPRconstexpr __sp_mut(void*) _NOEXCEPTnoexcept;
1744    __sp_mut(const __sp_mut&);
1745    __sp_mut& operator=(const __sp_mut&);
1746 
1747    friend _LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) __sp_mut& __get_sp_mut(const void*);
1748};
1749 
1750_LIBCPP_FUNC_VIS__attribute__ ((__visibility__("default"))) _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
1751__sp_mut& __get_sp_mut(const void*);
1752 
1753template <class _Tp>
1754inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1755bool
1756atomic_is_lock_free(const shared_ptr<_Tp>*)
1757{
1758    return false;
1759}
1760 
1761template <class _Tp>
1762_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
1763shared_ptr<_Tp>
1764atomic_load(const shared_ptr<_Tp>* __p)
1765{
1766    __sp_mut& __m = __get_sp_mut(__p);
1767    __m.lock();
1768    shared_ptr<_Tp> __q = *__p;
1769    __m.unlock();
1770    return __q;
1771}
1772 
1773template <class _Tp>
1774inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1775_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
1776shared_ptr<_Tp>
1777atomic_load_explicit(const shared_ptr<_Tp>* __p, memory_order)
1778{
1779    return atomic_load(__p);
1780}
1781 
1782template <class _Tp>
1783_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
1784void
1785atomic_store(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
1786{
1787    __sp_mut& __m = __get_sp_mut(__p);
1788    __m.lock();
1789    __p->swap(__r);
1790    __m.unlock();
1791}
1792 
1793template <class _Tp>
1794inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1795_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
1796void
1797atomic_store_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, memory_order)
1798{
1799    atomic_store(__p, __r);
1800}
1801 
1802template <class _Tp>
1803_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
1804shared_ptr<_Tp>
1805atomic_exchange(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
1806{
1807    __sp_mut& __m = __get_sp_mut(__p);
1808    __m.lock();
1809    __p->swap(__r);
1810    __m.unlock();
1811    return __r;
1812}
1813 
1814template <class _Tp>
1815inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1816_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
1817shared_ptr<_Tp>
1818atomic_exchange_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, memory_order)
1819{
1820    return atomic_exchange(__p, __r);
1821}
1822 
1823template <class _Tp>
1824_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
1825bool
1826atomic_compare_exchange_strong(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w)
1827{
1828    shared_ptr<_Tp> __temp;
1829    __sp_mut& __m = __get_sp_mut(__p);
1830    __m.lock();
1831    if (__p->__owner_equivalent(*__v))
1832    {
1833        _VSTDstd::__1::swap(__temp, *__p);
1834        *__p = __w;
1835        __m.unlock();
1836        return true;
1837    }
1838    _VSTDstd::__1::swap(__temp, *__v);
1839    *__v = *__p;
1840    __m.unlock();
1841    return false;
1842}
1843 
1844template <class _Tp>
1845inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1846_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
1847bool
1848atomic_compare_exchange_weak(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w)
1849{
1850    return atomic_compare_exchange_strong(__p, __v, __w);
1851}
1852 
1853template <class _Tp>
1854inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1855_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
1856bool
1857atomic_compare_exchange_strong_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
1858                                        shared_ptr<_Tp> __w, memory_order, memory_order)
1859{
1860    return atomic_compare_exchange_strong(__p, __v, __w);
1861}
1862 
1863template <class _Tp>
1864inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
1865_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
1866bool
1867atomic_compare_exchange_weak_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
1868                                      shared_ptr<_Tp> __w, memory_order, memory_order)
1869{
1870    return atomic_compare_exchange_weak(__p, __v, __w);
1871}
1872 
1873#endif // !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
1874 
1875_LIBCPP_END_NAMESPACE_STD} }
1876 
1877_LIBCPP_POP_MACROSpop_macro("min")
 pop_macro("max")
1878 
1879#endif // _LIBCPP___MEMORY_SHARED_PTR_H