/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

Bug Summary

File:	src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp
Warning:	line 757, column 23 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 SymbolFilePDB.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/liblldbPluginSymbolFile/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../include -I /usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/obj -I /usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/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/liblldbPluginSymbolFile/../../../llvm/lldb/include -I /usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source -I /usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/clang/include -I /usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/obj/../include/lldb/Plugins -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/liblldbPluginSymbolFile/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/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

→

1//===-- SymbolFilePDB.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 "SymbolFilePDB.h"

11#include "PDBASTParser.h"
12#include "PDBLocationToDWARFExpression.h"

14#include "clang/Lex/Lexer.h"

16#include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
17#include "lldb/Core/Module.h"
18#include "lldb/Core/PluginManager.h"
19#include "lldb/Symbol/CompileUnit.h"
20#include "lldb/Symbol/LineTable.h"
21#include "lldb/Symbol/ObjectFile.h"
22#include "lldb/Symbol/SymbolContext.h"
23#include "lldb/Symbol/SymbolVendor.h"
24#include "lldb/Symbol/TypeList.h"
25#include "lldb/Symbol/TypeMap.h"
26#include "lldb/Symbol/Variable.h"
27#include "lldb/Utility/Log.h"
28#include "lldb/Utility/RegularExpression.h"

30#include "llvm/DebugInfo/PDB/GenericError.h"
31#include "llvm/DebugInfo/PDB/IPDBDataStream.h"
32#include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
33#include "llvm/DebugInfo/PDB/IPDBLineNumber.h"
34#include "llvm/DebugInfo/PDB/IPDBSectionContrib.h"
35#include "llvm/DebugInfo/PDB/IPDBSourceFile.h"
36#include "llvm/DebugInfo/PDB/IPDBTable.h"
37#include "llvm/DebugInfo/PDB/PDBSymbol.h"
38#include "llvm/DebugInfo/PDB/PDBSymbolBlock.h"
39#include "llvm/DebugInfo/PDB/PDBSymbolCompiland.h"
40#include "llvm/DebugInfo/PDB/PDBSymbolCompilandDetails.h"
41#include "llvm/DebugInfo/PDB/PDBSymbolData.h"
42#include "llvm/DebugInfo/PDB/PDBSymbolExe.h"
43#include "llvm/DebugInfo/PDB/PDBSymbolFunc.h"
44#include "llvm/DebugInfo/PDB/PDBSymbolFuncDebugEnd.h"
45#include "llvm/DebugInfo/PDB/PDBSymbolFuncDebugStart.h"
46#include "llvm/DebugInfo/PDB/PDBSymbolPublicSymbol.h"
47#include "llvm/DebugInfo/PDB/PDBSymbolTypeEnum.h"
48#include "llvm/DebugInfo/PDB/PDBSymbolTypeTypedef.h"
49#include "llvm/DebugInfo/PDB/PDBSymbolTypeUDT.h"

51#include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
52#include "Plugins/Language/CPlusPlus/MSVCUndecoratedNameParser.h"
53#include "Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h"

55using namespace lldb;
56using namespace lldb_private;
57using namespace llvm::pdb;

59LLDB_PLUGIN_DEFINE(SymbolFilePDB)namespace lldb_private { void lldb_initialize_SymbolFilePDB()
 { SymbolFilePDB::Initialize(); } void lldb_terminate_SymbolFilePDB
() { SymbolFilePDB::Terminate(); } }

61char SymbolFilePDB::ID;

63namespace {
64lldb::LanguageType TranslateLanguage(PDB_Lang lang) {
switch (lang) {
case PDB_Lang::Cpp:
  return lldb::LanguageType::eLanguageTypeC_plus_plus;
case PDB_Lang::C:
  return lldb::LanguageType::eLanguageTypeC;
case PDB_Lang::Swift:
  return lldb::LanguageType::eLanguageTypeSwift;
default:
  return lldb::LanguageType::eLanguageTypeUnknown;
}
75}

77bool ShouldAddLine(uint32_t requested_line, uint32_t actual_line,
                 uint32_t addr_length) {
return ((requested_line == 0 || actual_line == requested_line) &&
        addr_length > 0);
81}
82} // namespace

84static bool ShouldUseNativeReader() {
85#if defined(_WIN32)
llvm::StringRef use_native = ::getenv("LLDB_USE_NATIVE_PDB_READER");
return use_native.equals_insensitive("on") ||
       use_native.equals_insensitive("yes") ||
       use_native.equals_insensitive("1") ||
       use_native.equals_insensitive("true");
91#else
return true;
93#endif
94}

96void SymbolFilePDB::Initialize() {
if (ShouldUseNativeReader()) {
  npdb::SymbolFileNativePDB::Initialize();
} else {
  PluginManager::RegisterPlugin(GetPluginNameStatic(),
                                GetPluginDescriptionStatic(), CreateInstance,
                                DebuggerInitialize);
}
104}

106void SymbolFilePDB::Terminate() {
if (ShouldUseNativeReader()) {
  npdb::SymbolFileNativePDB::Terminate();
} else {
  PluginManager::UnregisterPlugin(CreateInstance);
}
112}

114void SymbolFilePDB::DebuggerInitialize(lldb_private::Debugger &debugger) {}

116lldb_private::ConstString SymbolFilePDB::GetPluginNameStatic() {
static ConstString g_name("pdb");
return g_name;
119}

121const char *SymbolFilePDB::GetPluginDescriptionStatic() {
return "Microsoft PDB debug symbol file reader.";
123}

125lldb_private::SymbolFile *
126SymbolFilePDB::CreateInstance(ObjectFileSP objfile_sp) {
return new SymbolFilePDB(std::move(objfile_sp));
128}

130SymbolFilePDB::SymbolFilePDB(lldb::ObjectFileSP objfile_sp)
  : SymbolFile(std::move(objfile_sp)), m_session_up(), m_global_scope_up() {}

133SymbolFilePDB::~SymbolFilePDB() = default;

135uint32_t SymbolFilePDB::CalculateAbilities() {
uint32_t abilities = 0;
if (!m_objfile_sp)
  return 0;

if (!m_session_up) {
  // Lazily load and match the PDB file, but only do this once.
  std::string exePath = m_objfile_sp->GetFileSpec().GetPath();
  auto error = loadDataForEXE(PDB_ReaderType::DIA, llvm::StringRef(exePath),
                              m_session_up);
  if (error) {
    llvm::consumeError(std::move(error));
    auto module_sp = m_objfile_sp->GetModule();
    if (!module_sp)
      return 0;
    // See if any symbol file is specified through `--symfile` option.
    FileSpec symfile = module_sp->GetSymbolFileFileSpec();
    if (!symfile)
      return 0;
    error = loadDataForPDB(PDB_ReaderType::DIA,
                           llvm::StringRef(symfile.GetPath()), m_session_up);
    if (error) {
      llvm::consumeError(std::move(error));
      return 0;
    }
  }
}
if (!m_session_up)
  return 0;

auto enum_tables_up = m_session_up->getEnumTables();
if (!enum_tables_up)
  return 0;
while (auto table_up = enum_tables_up->getNext()) {
  if (table_up->getItemCount() == 0)
    continue;
  auto type = table_up->getTableType();
  switch (type) {
  case PDB_TableType::Symbols:
    // This table represents a store of symbols with types listed in
    // PDBSym_Type
    abilities |= (CompileUnits | Functions | Blocks | GlobalVariables |
                  LocalVariables | VariableTypes);
    break;
  case PDB_TableType::LineNumbers:
    abilities |= LineTables;
    break;
  default:
    break;
  }
}
return abilities;
187}

189void SymbolFilePDB::InitializeObject() {
lldb::addr_t obj_load_address =
    m_objfile_sp->GetBaseAddress().GetFileAddress();
lldbassert(obj_load_address && obj_load_address != LLDB_INVALID_ADDRESS)lldb_private::lldb_assert(static_cast<bool>(obj_load_address
 && obj_load_address != 0xffffffffffffffffULL), "obj_load_address && obj_load_address != LLDB_INVALID_ADDRESS"
, __FUNCTION__, "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp"
, 192);
m_session_up->setLoadAddress(obj_load_address);
if (!m_global_scope_up)
  m_global_scope_up = m_session_up->getGlobalScope();
lldbassert(m_global_scope_up.get())lldb_private::lldb_assert(static_cast<bool>(m_global_scope_up
.get()), "m_global_scope_up.get()", __FUNCTION__, "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp"
, 196);
197}

199uint32_t SymbolFilePDB::CalculateNumCompileUnits() {
auto compilands = m_global_scope_up->findAllChildren<PDBSymbolCompiland>();
if (!compilands)
  return 0;

// The linker could link *.dll (compiland language = LINK), or import
// *.dll. For example, a compiland with name `Import:KERNEL32.dll` could be
// found as a child of the global scope (PDB executable). Usually, such
// compilands contain `thunk` symbols in which we are not interested for
// now. However we still count them in the compiland list. If we perform
// any compiland related activity, like finding symbols through
// llvm::pdb::IPDBSession methods, such compilands will all be searched
// automatically no matter whether we include them or not.
uint32_t compile_unit_count = compilands->getChildCount();

// The linker can inject an additional "dummy" compilation unit into the
// PDB. Ignore this special compile unit for our purposes, if it is there.
// It is always the last one.
auto last_compiland_up = compilands->getChildAtIndex(compile_unit_count - 1);
lldbassert(last_compiland_up.get())lldb_private::lldb_assert(static_cast<bool>(last_compiland_up
.get()), "last_compiland_up.get()", __FUNCTION__, "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp"
, 218);
std::string name = last_compiland_up->getName();
if (name == "* Linker *")
  --compile_unit_count;
return compile_unit_count;
223}

225void SymbolFilePDB::GetCompileUnitIndex(
  const llvm::pdb::PDBSymbolCompiland &pdb_compiland, uint32_t &index) {
auto results_up = m_global_scope_up->findAllChildren<PDBSymbolCompiland>();
if (!results_up)
  return;
auto uid = pdb_compiland.getSymIndexId();
for (uint32_t cu_idx = 0; cu_idx < GetNumCompileUnits(); ++cu_idx) {
  auto compiland_up = results_up->getChildAtIndex(cu_idx);
  if (!compiland_up)
    continue;
  if (compiland_up->getSymIndexId() == uid) {
    index = cu_idx;
    return;
  }
}
index = UINT32_MAX0xffffffffU;
return;
242}

244std::unique_ptr<llvm::pdb::PDBSymbolCompiland>
245SymbolFilePDB::GetPDBCompilandByUID(uint32_t uid) {
return m_session_up->getConcreteSymbolById<PDBSymbolCompiland>(uid);
247}

249lldb::CompUnitSP SymbolFilePDB::ParseCompileUnitAtIndex(uint32_t index) {
if (index >= GetNumCompileUnits())
  return CompUnitSP();

// Assuming we always retrieve same compilands listed in same order through
// `PDBSymbolExe::findAllChildren` method, otherwise using `index` to get a
// compile unit makes no sense.
auto results = m_global_scope_up->findAllChildren<PDBSymbolCompiland>();
if (!results)
  return CompUnitSP();
auto compiland_up = results->getChildAtIndex(index);
if (!compiland_up)
  return CompUnitSP();
return ParseCompileUnitForUID(compiland_up->getSymIndexId(), index);
263}

265lldb::LanguageType SymbolFilePDB::ParseLanguage(CompileUnit &comp_unit) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
auto compiland_up = GetPDBCompilandByUID(comp_unit.GetID());
if (!compiland_up)
  return lldb::eLanguageTypeUnknown;
auto details = compiland_up->findOneChild<PDBSymbolCompilandDetails>();
if (!details)
  return lldb::eLanguageTypeUnknown;
return TranslateLanguage(details->getLanguage());
274}

276lldb_private::Function *
277SymbolFilePDB::ParseCompileUnitFunctionForPDBFunc(const PDBSymbolFunc &pdb_func,
                                                CompileUnit &comp_unit) {
if (FunctionSP result = comp_unit.FindFunctionByUID(pdb_func.getSymIndexId()))
  return result.get();

auto file_vm_addr = pdb_func.getVirtualAddress();
if (file_vm_addr == LLDB_INVALID_ADDRESS0xffffffffffffffffULL || file_vm_addr == 0)
  return nullptr;

auto func_length = pdb_func.getLength();
AddressRange func_range =
    AddressRange(file_vm_addr, func_length,
                 GetObjectFile()->GetModule()->GetSectionList());
if (!func_range.GetBaseAddress().IsValid())
  return nullptr;

lldb_private::Type *func_type = ResolveTypeUID(pdb_func.getSymIndexId());
if (!func_type)
  return nullptr;

user_id_t func_type_uid = pdb_func.getSignatureId();

Mangled mangled = GetMangledForPDBFunc(pdb_func);

FunctionSP func_sp =
    std::make_shared<Function>(&comp_unit, pdb_func.getSymIndexId(),
                               func_type_uid, mangled, func_type, func_range);

comp_unit.AddFunction(func_sp);

LanguageType lang = ParseLanguage(comp_unit);
auto type_system_or_err = GetTypeSystemForLanguage(lang);
if (auto err = type_system_or_err.takeError()) {
  LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),do { ::lldb_private::Log *log_private = (lldb_private::GetLogIfAnyCategoriesSet
((1u << 20))); ::llvm::Error error_private = (std::move
(err)); if (log_private && error_private) { log_private
->FormatError(::std::move(error_private), "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp"
, __func__, "Unable to parse PDBFunc"); } else ::llvm::consumeError
(::std::move(error_private)); } while (0)
                 std::move(err), "Unable to parse PDBFunc")do { ::lldb_private::Log *log_private = (lldb_private::GetLogIfAnyCategoriesSet
((1u << 20))); ::llvm::Error error_private = (std::move
(err)); if (log_private && error_private) { log_private
->FormatError(::std::move(error_private), "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp"
, __func__, "Unable to parse PDBFunc"); } else ::llvm::consumeError
(::std::move(error_private)); } while (0);
  return nullptr;
}

TypeSystemClang *clang_type_system =
  llvm::dyn_cast_or_null<TypeSystemClang>(&type_system_or_err.get());
if (!clang_type_system)
  return nullptr;
clang_type_system->GetPDBParser()->GetDeclForSymbol(pdb_func);

return func_sp.get();
322}

324size_t SymbolFilePDB::ParseFunctions(CompileUnit &comp_unit) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
size_t func_added = 0;
auto compiland_up = GetPDBCompilandByUID(comp_unit.GetID());
if (!compiland_up)
  return 0;
auto results_up = compiland_up->findAllChildren<PDBSymbolFunc>();
if (!results_up)
  return 0;
while (auto pdb_func_up = results_up->getNext()) {
  auto func_sp = comp_unit.FindFunctionByUID(pdb_func_up->getSymIndexId());
  if (!func_sp) {
    if (ParseCompileUnitFunctionForPDBFunc(*pdb_func_up, comp_unit))
      ++func_added;
  }
}
return func_added;
341}

343bool SymbolFilePDB::ParseLineTable(CompileUnit &comp_unit) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
if (comp_unit.GetLineTable())
  return true;
return ParseCompileUnitLineTable(comp_unit, 0);
348}

350bool SymbolFilePDB::ParseDebugMacros(CompileUnit &comp_unit) {
// PDB doesn't contain information about macros
return false;
353}

355bool SymbolFilePDB::ParseSupportFiles(
  CompileUnit &comp_unit, lldb_private::FileSpecList &support_files) {

// In theory this is unnecessary work for us, because all of this information
// is easily (and quickly) accessible from DebugInfoPDB, so caching it a
// second time seems like a waste.  Unfortunately, there's no good way around
// this short of a moderate refactor since SymbolVendor depends on being able
// to cache this list.
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
auto compiland_up = GetPDBCompilandByUID(comp_unit.GetID());
if (!compiland_up)
  return false;
auto files = m_session_up->getSourceFilesForCompiland(*compiland_up);
if (!files || files->getChildCount() == 0)
  return false;

while (auto file = files->getNext()) {
  FileSpec spec(file->getFileName(), FileSpec::Style::windows);
  support_files.AppendIfUnique(spec);
}

return true;
377}

379bool SymbolFilePDB::ParseImportedModules(
  const lldb_private::SymbolContext &sc,
  std::vector<SourceModule> &imported_modules) {
// PDB does not yet support module debug info
return false;
384}

386static size_t ParseFunctionBlocksForPDBSymbol(
  uint64_t func_file_vm_addr, const llvm::pdb::PDBSymbol *pdb_symbol,
  lldb_private::Block *parent_block, bool is_top_parent) {
assert(pdb_symbol && parent_block)((void)0);

size_t num_added = 0;
switch (pdb_symbol->getSymTag()) {
case PDB_SymType::Block:
case PDB_SymType::Function: {
  Block *block = nullptr;
  auto &raw_sym = pdb_symbol->getRawSymbol();
  if (auto *pdb_func = llvm::dyn_cast<PDBSymbolFunc>(pdb_symbol)) {
    if (pdb_func->hasNoInlineAttribute())
      break;
    if (is_top_parent)
      block = parent_block;
    else
      break;
  } else if (llvm::dyn_cast<PDBSymbolBlock>(pdb_symbol)) {
    auto uid = pdb_symbol->getSymIndexId();
    if (parent_block->FindBlockByID(uid))
      break;
    if (raw_sym.getVirtualAddress() < func_file_vm_addr)
      break;

    auto block_sp = std::make_shared<Block>(pdb_symbol->getSymIndexId());
    parent_block->AddChild(block_sp);
    block = block_sp.get();
  } else
    llvm_unreachable("Unexpected PDB symbol!")__builtin_unreachable();

  block->AddRange(Block::Range(
      raw_sym.getVirtualAddress() - func_file_vm_addr, raw_sym.getLength()));
  block->FinalizeRanges();
  ++num_added;

  auto results_up = pdb_symbol->findAllChildren();
  if (!results_up)
    break;
  while (auto symbol_up = results_up->getNext()) {
    num_added += ParseFunctionBlocksForPDBSymbol(
        func_file_vm_addr, symbol_up.get(), block, false);
  }
} break;
default:
  break;
}
return num_added;
434}

436size_t SymbolFilePDB::ParseBlocksRecursive(Function &func) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
size_t num_added = 0;
auto uid = func.GetID();
auto pdb_func_up = m_session_up->getConcreteSymbolById<PDBSymbolFunc>(uid);
if (!pdb_func_up)
  return 0;
Block &parent_block = func.GetBlock(false);
num_added = ParseFunctionBlocksForPDBSymbol(
    pdb_func_up->getVirtualAddress(), pdb_func_up.get(), &parent_block, true);
return num_added;
447}

449size_t SymbolFilePDB::ParseTypes(CompileUnit &comp_unit) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());

size_t num_added = 0;
auto compiland = GetPDBCompilandByUID(comp_unit.GetID());
if (!compiland)
  return 0;

auto ParseTypesByTagFn = [&num_added, this](const PDBSymbol &raw_sym) {
  std::unique_ptr<IPDBEnumSymbols> results;
  PDB_SymType tags_to_search[] = {PDB_SymType::Enum, PDB_SymType::Typedef,
                                  PDB_SymType::UDT};
  for (auto tag : tags_to_search) {
    results = raw_sym.findAllChildren(tag);
    if (!results || results->getChildCount() == 0)
      continue;
    while (auto symbol = results->getNext()) {
      switch (symbol->getSymTag()) {
      case PDB_SymType::Enum:
      case PDB_SymType::UDT:
      case PDB_SymType::Typedef:
        break;
      default:
        continue;
      }

      // This should cause the type to get cached and stored in the `m_types`
      // lookup.
      if (auto type = ResolveTypeUID(symbol->getSymIndexId())) {
        // Resolve the type completely to avoid a completion
        // (and so a list change, which causes an iterators invalidation)
        // during a TypeList dumping
        type->GetFullCompilerType();
        ++num_added;
      }
    }
  }
};

ParseTypesByTagFn(*compiland);

// Also parse global types particularly coming from this compiland.
// Unfortunately, PDB has no compiland information for each global type. We
// have to parse them all. But ensure we only do this once.
static bool parse_all_global_types = false;
if (!parse_all_global_types) {
  ParseTypesByTagFn(*m_global_scope_up);
  parse_all_global_types = true;
}
return num_added;
499}

501size_t
502SymbolFilePDB::ParseVariablesForContext(const lldb_private::SymbolContext &sc) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
if (!sc.comp_unit)
  return 0;

size_t num_added = 0;
if (sc.function) {
  auto pdb_func = m_session_up->getConcreteSymbolById<PDBSymbolFunc>(
      sc.function->GetID());
  if (!pdb_func)
    return 0;

  num_added += ParseVariables(sc, *pdb_func);
  sc.function->GetBlock(false).SetDidParseVariables(true, true);
} else if (sc.comp_unit) {
  auto compiland = GetPDBCompilandByUID(sc.comp_unit->GetID());
  if (!compiland)
    return 0;

  if (sc.comp_unit->GetVariableList(false))
    return 0;

  auto results = m_global_scope_up->findAllChildren<PDBSymbolData>();
  if (results && results->getChildCount()) {
    while (auto result = results->getNext()) {
      auto cu_id = GetCompilandId(*result);
      // FIXME: We are not able to determine variable's compile unit.
      if (cu_id == 0)
        continue;

      if (cu_id == sc.comp_unit->GetID())
        num_added += ParseVariables(sc, *result);
    }
  }

  // FIXME: A `file static` or `global constant` variable appears both in
  // compiland's children and global scope's children with unexpectedly
  // different symbol's Id making it ambiguous.

  // FIXME: 'local constant', for example, const char var[] = "abc", declared
  // in a function scope, can't be found in PDB.

  // Parse variables in this compiland.
  num_added += ParseVariables(sc, *compiland);
}

return num_added;
549}

551lldb_private::Type *SymbolFilePDB::ResolveTypeUID(lldb::user_id_t type_uid) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
auto find_result = m_types.find(type_uid);
if (find_result != m_types.end())
  return find_result->second.get();

auto type_system_or_err =
    GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
if (auto err = type_system_or_err.takeError()) {
  LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),do { ::lldb_private::Log *log_private = (lldb_private::GetLogIfAnyCategoriesSet
((1u << 20))); ::llvm::Error error_private = (std::move
(err)); if (log_private && error_private) { log_private
->FormatError(::std::move(error_private), "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp"
, __func__, "Unable to ResolveTypeUID"); } else ::llvm::consumeError
(::std::move(error_private)); } while (0)
                 std::move(err), "Unable to ResolveTypeUID")do { ::lldb_private::Log *log_private = (lldb_private::GetLogIfAnyCategoriesSet
((1u << 20))); ::llvm::Error error_private = (std::move
(err)); if (log_private && error_private) { log_private
->FormatError(::std::move(error_private), "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp"
, __func__, "Unable to ResolveTypeUID"); } else ::llvm::consumeError
(::std::move(error_private)); } while (0);
  return nullptr;
}

TypeSystemClang *clang_type_system =
    llvm::dyn_cast_or_null<TypeSystemClang>(&type_system_or_err.get());
if (!clang_type_system)
  return nullptr;
PDBASTParser *pdb = clang_type_system->GetPDBParser();
if (!pdb)
  return nullptr;

auto pdb_type = m_session_up->getSymbolById(type_uid);
if (pdb_type == nullptr)
  return nullptr;

lldb::TypeSP result = pdb->CreateLLDBTypeFromPDBType(*pdb_type);
if (result) {
  m_types.insert(std::make_pair(type_uid, result));
  GetTypeList().Insert(result);
}
return result.get();
583}

585llvm::Optional<SymbolFile::ArrayInfo> SymbolFilePDB::GetDynamicArrayInfoForUID(
  lldb::user_id_t type_uid, const lldb_private::ExecutionContext *exe_ctx) {
return llvm::None;
588}

590bool SymbolFilePDB::CompleteType(lldb_private::CompilerType &compiler_type) {
std::lock_guard<std::recursive_mutex> guard(
    GetObjectFile()->GetModule()->GetMutex());

auto type_system_or_err =
    GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
if (auto err = type_system_or_err.takeError()) {
  LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),do { ::lldb_private::Log *log_private = (lldb_private::GetLogIfAnyCategoriesSet
((1u << 20))); ::llvm::Error error_private = (std::move
(err)); if (log_private && error_private) { log_private
->FormatError(::std::move(error_private), "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp"
, __func__, "Unable to get dynamic array info for UID"); } else
 ::llvm::consumeError(::std::move(error_private)); } while (0
)
                 std::move(err), "Unable to get dynamic array info for UID")do { ::lldb_private::Log *log_private = (lldb_private::GetLogIfAnyCategoriesSet
((1u << 20))); ::llvm::Error error_private = (std::move
(err)); if (log_private && error_private) { log_private
->FormatError(::std::move(error_private), "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp"
, __func__, "Unable to get dynamic array info for UID"); } else
 ::llvm::consumeError(::std::move(error_private)); } while (0
);
  return false;
}

TypeSystemClang *clang_ast_ctx =
    llvm::dyn_cast_or_null<TypeSystemClang>(&type_system_or_err.get());

if (!clang_ast_ctx)
  return false;

PDBASTParser *pdb = clang_ast_ctx->GetPDBParser();
if (!pdb)
  return false;

return pdb->CompleteTypeFromPDB(compiler_type);
613}

615lldb_private::CompilerDecl SymbolFilePDB::GetDeclForUID(lldb::user_id_t uid) {
auto type_system_or_err =
    GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
if (auto err = type_system_or_err.takeError()) {
  LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),do { ::lldb_private::Log *log_private = (lldb_private::GetLogIfAnyCategoriesSet
((1u << 20))); ::llvm::Error error_private = (std::move
(err)); if (log_private && error_private) { log_private
->FormatError(::std::move(error_private), "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp"
, __func__, "Unable to get decl for UID"); } else ::llvm::consumeError
(::std::move(error_private)); } while (0)
                 std::move(err), "Unable to get decl for UID")do { ::lldb_private::Log *log_private = (lldb_private::GetLogIfAnyCategoriesSet
((1u << 20))); ::llvm::Error error_private = (std::move
(err)); if (log_private && error_private) { log_private
->FormatError(::std::move(error_private), "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp"
, __func__, "Unable to get decl for UID"); } else ::llvm::consumeError
(::std::move(error_private)); } while (0);
  return CompilerDecl();
}

TypeSystemClang *clang_ast_ctx =
    llvm::dyn_cast_or_null<TypeSystemClang>(&type_system_or_err.get());
if (!clang_ast_ctx)
  return CompilerDecl();

PDBASTParser *pdb = clang_ast_ctx->GetPDBParser();
if (!pdb)
  return CompilerDecl();

auto symbol = m_session_up->getSymbolById(uid);
if (!symbol)
  return CompilerDecl();

auto decl = pdb->GetDeclForSymbol(*symbol);
if (!decl)
  return CompilerDecl();

return clang_ast_ctx->GetCompilerDecl(decl);
642}

644lldb_private::CompilerDeclContext
645SymbolFilePDB::GetDeclContextForUID(lldb::user_id_t uid) {
auto type_system_or_err =
    GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
if (auto err = type_system_or_err.takeError()) {
  LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),do { ::lldb_private::Log *log_private = (lldb_private::GetLogIfAnyCategoriesSet
((1u << 20))); ::llvm::Error error_private = (std::move
(err)); if (log_private && error_private) { log_private
->FormatError(::std::move(error_private), "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp"
, __func__, "Unable to get DeclContext for UID"); } else ::llvm
::consumeError(::std::move(error_private)); } while (0)
                 std::move(err), "Unable to get DeclContext for UID")do { ::lldb_private::Log *log_private = (lldb_private::GetLogIfAnyCategoriesSet
((1u << 20))); ::llvm::Error error_private = (std::move
(err)); if (log_private && error_private) { log_private
->FormatError(::std::move(error_private), "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp"
, __func__, "Unable to get DeclContext for UID"); } else ::llvm
::consumeError(::std::move(error_private)); } while (0);
  return CompilerDeclContext();
}

TypeSystemClang *clang_ast_ctx =
    llvm::dyn_cast_or_null<TypeSystemClang>(&type_system_or_err.get());
if (!clang_ast_ctx)
  return CompilerDeclContext();

PDBASTParser *pdb = clang_ast_ctx->GetPDBParser();
if (!pdb)
  return CompilerDeclContext();

auto symbol = m_session_up->getSymbolById(uid);
if (!symbol)
  return CompilerDeclContext();

auto decl_context = pdb->GetDeclContextForSymbol(*symbol);
if (!decl_context)
  return GetDeclContextContainingUID(uid);

return clang_ast_ctx->CreateDeclContext(decl_context);
672}

674lldb_private::CompilerDeclContext
675SymbolFilePDB::GetDeclContextContainingUID(lldb::user_id_t uid) {
auto type_system_or_err =
    GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
if (auto err = type_system_or_err.takeError()) {
  LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),do { ::lldb_private::Log *log_private = (lldb_private::GetLogIfAnyCategoriesSet
((1u << 20))); ::llvm::Error error_private = (std::move
(err)); if (log_private && error_private) { log_private
->FormatError(::std::move(error_private), "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp"
, __func__, "Unable to get DeclContext containing UID"); } else
 ::llvm::consumeError(::std::move(error_private)); } while (0
)
                 std::move(err), "Unable to get DeclContext containing UID")do { ::lldb_private::Log *log_private = (lldb_private::GetLogIfAnyCategoriesSet
((1u << 20))); ::llvm::Error error_private = (std::move
(err)); if (log_private && error_private) { log_private
->FormatError(::std::move(error_private), "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp"
, __func__, "Unable to get DeclContext containing UID"); } else
 ::llvm::consumeError(::std::move(error_private)); } while (0
);
  return CompilerDeclContext();
}

TypeSystemClang *clang_ast_ctx =
    llvm::dyn_cast_or_null<TypeSystemClang>(&type_system_or_err.get());
if (!clang_ast_ctx)
  return CompilerDeclContext();

PDBASTParser *pdb = clang_ast_ctx->GetPDBParser();
if (!pdb)
  return CompilerDeclContext();

auto symbol = m_session_up->getSymbolById(uid);
if (!symbol)
  return CompilerDeclContext();

auto decl_context = pdb->GetDeclContextContainingSymbol(*symbol);
assert(decl_context)((void)0);

return clang_ast_ctx->CreateDeclContext(decl_context);
701}

703void SymbolFilePDB::ParseDeclsForContext(
  lldb_private::CompilerDeclContext decl_ctx) {
auto type_system_or_err =
    GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
if (auto err = type_system_or_err.takeError()) {
  LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),do { ::lldb_private::Log *log_private = (lldb_private::GetLogIfAnyCategoriesSet
((1u << 20))); ::llvm::Error error_private = (std::move
(err)); if (log_private && error_private) { log_private
->FormatError(::std::move(error_private), "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp"
, __func__, "Unable to parse decls for context"); } else ::llvm
::consumeError(::std::move(error_private)); } while (0)
                 std::move(err), "Unable to parse decls for context")do { ::lldb_private::Log *log_private = (lldb_private::GetLogIfAnyCategoriesSet
((1u << 20))); ::llvm::Error error_private = (std::move
(err)); if (log_private && error_private) { log_private
->FormatError(::std::move(error_private), "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp"
, __func__, "Unable to parse decls for context"); } else ::llvm
::consumeError(::std::move(error_private)); } while (0);
  return;
}

TypeSystemClang *clang_ast_ctx =
    llvm::dyn_cast_or_null<TypeSystemClang>(&type_system_or_err.get());
if (!clang_ast_ctx)
  return;

PDBASTParser *pdb = clang_ast_ctx->GetPDBParser();
if (!pdb)
  return;

pdb->ParseDeclsForDeclContext(
    static_cast<clang::DeclContext *>(decl_ctx.GetOpaqueDeclContext()));
724}

726uint32_t
727SymbolFilePDB::ResolveSymbolContext(const lldb_private::Address &so_addr,
                                  SymbolContextItem resolve_scope,
                                  lldb_private::SymbolContext &sc) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
uint32_t resolved_flags = 0;
if (resolve_scope & eSymbolContextCompUnit ||
1
Assuming the condition is false→
    resolve_scope & eSymbolContextVariable ||
2
←
Assuming the condition is false→
    resolve_scope & eSymbolContextFunction ||
3
←
Assuming the condition is false→
    resolve_scope & eSymbolContextBlock ||
4
←
Assuming the condition is true→
    resolve_scope & eSymbolContextLineEntry) {
  auto cu_sp = GetCompileUnitContainsAddress(so_addr);
  if (!cu_sp) {
5
←
Calling 'shared_ptr::operator bool'→
8
←
Returning from 'shared_ptr::operator bool'→
9
←
Taking false branch→
    if (resolved_flags & eSymbolContextVariable) {
      // TODO: Resolve variables
    }
    return 0;
  }
  sc.comp_unit = cu_sp.get();
  resolved_flags |= eSymbolContextCompUnit;
  lldbassert(sc.module_sp == cu_sp->GetModule())lldb_private::lldb_assert(static_cast<bool>(sc.module_sp
 == cu_sp->GetModule()), "sc.module_sp == cu_sp->GetModule()"
, __FUNCTION__, "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp"
, 746);
}

if (resolve_scope & eSymbolContextFunction ||
10
←
Calling 'operator&'→
12
←
Returning from 'operator&'→
13
←
Taking true branch→
    resolve_scope & eSymbolContextBlock) {
  addr_t file_vm_addr = so_addr.GetFileAddress();
  auto symbol_up =
      m_session_up->findSymbolByAddress(file_vm_addr, PDB_SymType::Function);
  if (symbol_up) {
14
←
Calling 'unique_ptr::operator bool'→
17
←
Returning from 'unique_ptr::operator bool'→
18
←
Taking true branch→
    auto *pdb_func = llvm::dyn_cast<PDBSymbolFunc>(symbol_up.get());
19
←
Assuming the object is not a 'PDBSymbolFunc'→
20
←
'pdb_func' initialized to a null pointer value→
    assert(pdb_func)((void)0);
    auto func_uid = pdb_func->getSymIndexId();
21
←
Called C++ object pointer is null
    sc.function = sc.comp_unit->FindFunctionByUID(func_uid).get();
    if (sc.function == nullptr)
      sc.function =
          ParseCompileUnitFunctionForPDBFunc(*pdb_func, *sc.comp_unit);
    if (sc.function) {
      resolved_flags |= eSymbolContextFunction;
      if (resolve_scope & eSymbolContextBlock) {
        auto block_symbol = m_session_up->findSymbolByAddress(
            file_vm_addr, PDB_SymType::Block);
        auto block_id = block_symbol ? block_symbol->getSymIndexId()
                                     : sc.function->GetID();
        sc.block = sc.function->GetBlock(true).FindBlockByID(block_id);
        if (sc.block)
          resolved_flags |= eSymbolContextBlock;
      }
    }
  }
}

if (resolve_scope & eSymbolContextLineEntry) {
  if (auto *line_table = sc.comp_unit->GetLineTable()) {
    Address addr(so_addr);
    if (line_table->FindLineEntryByAddress(addr, sc.line_entry))
      resolved_flags |= eSymbolContextLineEntry;
  }
}

return resolved_flags;
786}

788uint32_t SymbolFilePDB::ResolveSymbolContext(
  const lldb_private::SourceLocationSpec &src_location_spec,
  SymbolContextItem resolve_scope, lldb_private::SymbolContextList &sc_list) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
const size_t old_size = sc_list.GetSize();
const FileSpec &file_spec = src_location_spec.GetFileSpec();
const uint32_t line = src_location_spec.GetLine().getValueOr(0);
if (resolve_scope & lldb::eSymbolContextCompUnit) {
  // Locate all compilation units with line numbers referencing the specified
  // file.  For example, if `file_spec` is <vector>, then this should return
  // all source files and header files that reference <vector>, either
  // directly or indirectly.
  auto compilands = m_session_up->findCompilandsForSourceFile(
      file_spec.GetPath(), PDB_NameSearchFlags::NS_CaseInsensitive);

  if (!compilands)
    return 0;

  // For each one, either find its previously parsed data or parse it afresh
  // and add it to the symbol context list.
  while (auto compiland = compilands->getNext()) {
    // If we're not checking inlines, then don't add line information for
    // this file unless the FileSpec matches. For inline functions, we don't
    // have to match the FileSpec since they could be defined in headers
    // other than file specified in FileSpec.
    if (!src_location_spec.GetCheckInlines()) {
      std::string source_file = compiland->getSourceFileFullPath();
      if (source_file.empty())
        continue;
      FileSpec this_spec(source_file, FileSpec::Style::windows);
      bool need_full_match = !file_spec.GetDirectory().IsEmpty();
      if (FileSpec::Compare(file_spec, this_spec, need_full_match) != 0)
        continue;
    }

    SymbolContext sc;
    auto cu = ParseCompileUnitForUID(compiland->getSymIndexId());
    if (!cu)
      continue;
    sc.comp_unit = cu.get();
    sc.module_sp = cu->GetModule();

    // If we were asked to resolve line entries, add all entries to the line
    // table that match the requested line (or all lines if `line` == 0).
    if (resolve_scope & (eSymbolContextFunction | eSymbolContextBlock |
                         eSymbolContextLineEntry)) {
      bool has_line_table = ParseCompileUnitLineTable(*sc.comp_unit, line);

      if ((resolve_scope & eSymbolContextLineEntry) && !has_line_table) {
        // The query asks for line entries, but we can't get them for the
        // compile unit. This is not normal for `line` = 0. So just assert
        // it.
        assert(line && "Couldn't get all line entries!\n")((void)0);

        // Current compiland does not have the requested line. Search next.
        continue;
      }

      if (resolve_scope & (eSymbolContextFunction | eSymbolContextBlock)) {
        if (!has_line_table)
          continue;

        auto *line_table = sc.comp_unit->GetLineTable();
        lldbassert(line_table)lldb_private::lldb_assert(static_cast<bool>(line_table)
, "line_table", __FUNCTION__, "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp"
, 851);

        uint32_t num_line_entries = line_table->GetSize();
        // Skip the terminal line entry.
        --num_line_entries;

        // If `line `!= 0, see if we can resolve function for each line entry
        // in the line table.
        for (uint32_t line_idx = 0; line && line_idx < num_line_entries;
             ++line_idx) {
          if (!line_table->GetLineEntryAtIndex(line_idx, sc.line_entry))
            continue;

          auto file_vm_addr =
              sc.line_entry.range.GetBaseAddress().GetFileAddress();
          if (file_vm_addr == LLDB_INVALID_ADDRESS0xffffffffffffffffULL || file_vm_addr == 0)
            continue;

          auto symbol_up = m_session_up->findSymbolByAddress(
              file_vm_addr, PDB_SymType::Function);
          if (symbol_up) {
            auto func_uid = symbol_up->getSymIndexId();
            sc.function = sc.comp_unit->FindFunctionByUID(func_uid).get();
            if (sc.function == nullptr) {
              auto pdb_func = llvm::dyn_cast<PDBSymbolFunc>(symbol_up.get());
              assert(pdb_func)((void)0);
              sc.function = ParseCompileUnitFunctionForPDBFunc(*pdb_func,
                                                               *sc.comp_unit);
            }
            if (sc.function && (resolve_scope & eSymbolContextBlock)) {
              Block &block = sc.function->GetBlock(true);
              sc.block = block.FindBlockByID(sc.function->GetID());
            }
          }
          sc_list.Append(sc);
        }
      } else if (has_line_table) {
        // We can parse line table for the compile unit. But no query to
        // resolve function or block. We append `sc` to the list anyway.
        sc_list.Append(sc);
      }
    } else {
      // No query for line entry, function or block. But we have a valid
      // compile unit, append `sc` to the list.
      sc_list.Append(sc);
    }
  }
}
return sc_list.GetSize() - old_size;
900}

902std::string SymbolFilePDB::GetMangledForPDBData(const PDBSymbolData &pdb_data) {
// Cache public names at first
if (m_public_names.empty())
  if (auto result_up =
          m_global_scope_up->findAllChildren(PDB_SymType::PublicSymbol))
    while (auto symbol_up = result_up->getNext())
      if (auto addr = symbol_up->getRawSymbol().getVirtualAddress())
        m_public_names[addr] = symbol_up->getRawSymbol().getName();

// Look up the name in the cache
return m_public_names.lookup(pdb_data.getVirtualAddress());
913}

915VariableSP SymbolFilePDB::ParseVariableForPDBData(
  const lldb_private::SymbolContext &sc,
  const llvm::pdb::PDBSymbolData &pdb_data) {
VariableSP var_sp;
uint32_t var_uid = pdb_data.getSymIndexId();
auto result = m_variables.find(var_uid);
if (result != m_variables.end())
  return result->second;

ValueType scope = eValueTypeInvalid;
bool is_static_member = false;
bool is_external = false;
bool is_artificial = false;

switch (pdb_data.getDataKind()) {
case PDB_DataKind::Global:
  scope = eValueTypeVariableGlobal;
  is_external = true;
  break;
case PDB_DataKind::Local:
  scope = eValueTypeVariableLocal;
  break;
case PDB_DataKind::FileStatic:
  scope = eValueTypeVariableStatic;
  break;
case PDB_DataKind::StaticMember:
  is_static_member = true;
  scope = eValueTypeVariableStatic;
  break;
case PDB_DataKind::Member:
  scope = eValueTypeVariableStatic;
  break;
case PDB_DataKind::Param:
  scope = eValueTypeVariableArgument;
  break;
case PDB_DataKind::Constant:
  scope = eValueTypeConstResult;
  break;
default:
  break;
}

switch (pdb_data.getLocationType()) {
case PDB_LocType::TLS:
  scope = eValueTypeVariableThreadLocal;
  break;
case PDB_LocType::RegRel: {
  // It is a `this` pointer.
  if (pdb_data.getDataKind() == PDB_DataKind::ObjectPtr) {
    scope = eValueTypeVariableArgument;
    is_artificial = true;
  }
} break;
default:
  break;
}

Declaration decl;
if (!is_artificial && !pdb_data.isCompilerGenerated()) {
  if (auto lines = pdb_data.getLineNumbers()) {
    if (auto first_line = lines->getNext()) {
      uint32_t src_file_id = first_line->getSourceFileId();
      auto src_file = m_session_up->getSourceFileById(src_file_id);
      if (src_file) {
        FileSpec spec(src_file->getFileName());
        decl.SetFile(spec);
        decl.SetColumn(first_line->getColumnNumber());
        decl.SetLine(first_line->getLineNumber());
      }
    }
  }
}

Variable::RangeList ranges;
SymbolContextScope *context_scope = sc.comp_unit;
if (scope == eValueTypeVariableLocal || scope == eValueTypeVariableArgument) {
  if (sc.function) {
    Block &function_block = sc.function->GetBlock(true);
    Block *block =
        function_block.FindBlockByID(pdb_data.getLexicalParentId());
    if (!block)
      block = &function_block;

    context_scope = block;

    for (size_t i = 0, num_ranges = block->GetNumRanges(); i < num_ranges;
         ++i) {
      AddressRange range;
      if (!block->GetRangeAtIndex(i, range))
        continue;

      ranges.Append(range.GetBaseAddress().GetFileAddress(),
                    range.GetByteSize());
    }
  }
}

SymbolFileTypeSP type_sp =
    std::make_shared<SymbolFileType>(*this, pdb_data.getTypeId());

auto var_name = pdb_data.getName();
auto mangled = GetMangledForPDBData(pdb_data);
auto mangled_cstr = mangled.empty() ? nullptr : mangled.c_str();

bool is_constant;
DWARFExpression location = ConvertPDBLocationToDWARFExpression(
    GetObjectFile()->GetModule(), pdb_data, ranges, is_constant);

var_sp = std::make_shared<Variable>(
    var_uid, var_name.c_str(), mangled_cstr, type_sp, scope, context_scope,
    ranges, &decl, location, is_external, is_artificial, is_constant,
    is_static_member);

m_variables.insert(std::make_pair(var_uid, var_sp));
return var_sp;
1030}

1032size_t
1033SymbolFilePDB::ParseVariables(const lldb_private::SymbolContext &sc,
                            const llvm::pdb::PDBSymbol &pdb_symbol,
                            lldb_private::VariableList *variable_list) {
size_t num_added = 0;

if (auto pdb_data = llvm::dyn_cast<PDBSymbolData>(&pdb_symbol)) {
  VariableListSP local_variable_list_sp;

  auto result = m_variables.find(pdb_data->getSymIndexId());
  if (result != m_variables.end()) {
    if (variable_list)
      variable_list->AddVariableIfUnique(result->second);
  } else {
    // Prepare right VariableList for this variable.
    if (auto lexical_parent = pdb_data->getLexicalParent()) {
      switch (lexical_parent->getSymTag()) {
      case PDB_SymType::Exe:
        assert(sc.comp_unit)((void)0);
        LLVM_FALLTHROUGH[[gnu::fallthrough]];
      case PDB_SymType::Compiland: {
        if (sc.comp_unit) {
          local_variable_list_sp = sc.comp_unit->GetVariableList(false);
          if (!local_variable_list_sp) {
            local_variable_list_sp = std::make_shared<VariableList>();
            sc.comp_unit->SetVariableList(local_variable_list_sp);
          }
        }
      } break;
      case PDB_SymType::Block:
      case PDB_SymType::Function: {
        if (sc.function) {
          Block *block = sc.function->GetBlock(true).FindBlockByID(
              lexical_parent->getSymIndexId());
          if (block) {
            local_variable_list_sp = block->GetBlockVariableList(false);
            if (!local_variable_list_sp) {
              local_variable_list_sp = std::make_shared<VariableList>();
              block->SetVariableList(local_variable_list_sp);
            }
          }
        }
      } break;
      default:
        break;
      }
    }

    if (local_variable_list_sp) {
      if (auto var_sp = ParseVariableForPDBData(sc, *pdb_data)) {
        local_variable_list_sp->AddVariableIfUnique(var_sp);
        if (variable_list)
          variable_list->AddVariableIfUnique(var_sp);
        ++num_added;
        PDBASTParser *ast = GetPDBAstParser();
        if (ast)
          ast->GetDeclForSymbol(*pdb_data);
      }
    }
  }
}

if (auto results = pdb_symbol.findAllChildren()) {
  while (auto result = results->getNext())
    num_added += ParseVariables(sc, *result, variable_list);
}

return num_added;
1100}

1102void SymbolFilePDB::FindGlobalVariables(
  lldb_private::ConstString name, const CompilerDeclContext &parent_decl_ctx,
  uint32_t max_matches, lldb_private::VariableList &variables) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
  return;
if (name.IsEmpty())
  return;

auto results = m_global_scope_up->findAllChildren<PDBSymbolData>();
if (!results)
  return;

uint32_t matches = 0;
size_t old_size = variables.GetSize();
while (auto result = results->getNext()) {
  auto pdb_data = llvm::dyn_cast<PDBSymbolData>(result.get());
  if (max_matches > 0 && matches >= max_matches)
    break;

  SymbolContext sc;
  sc.module_sp = m_objfile_sp->GetModule();
  lldbassert(sc.module_sp.get())lldb_private::lldb_assert(static_cast<bool>(sc.module_sp
.get()), "sc.module_sp.get()", __FUNCTION__, "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp"
, 1124);

  if (!name.GetStringRef().equals(
          MSVCUndecoratedNameParser::DropScope(pdb_data->getName())))
    continue;

  sc.comp_unit = ParseCompileUnitForUID(GetCompilandId(*pdb_data)).get();
  // FIXME: We are not able to determine the compile unit.
  if (sc.comp_unit == nullptr)
    continue;

  if (parent_decl_ctx.IsValid() &&
      GetDeclContextContainingUID(result->getSymIndexId()) != parent_decl_ctx)
    continue;

  ParseVariables(sc, *pdb_data, &variables);
  matches = variables.GetSize() - old_size;
}
1142}

1144void SymbolFilePDB::FindGlobalVariables(
  const lldb_private::RegularExpression &regex, uint32_t max_matches,
  lldb_private::VariableList &variables) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
if (!regex.IsValid())
  return;
auto results = m_global_scope_up->findAllChildren<PDBSymbolData>();
if (!results)
  return;

uint32_t matches = 0;
size_t old_size = variables.GetSize();
while (auto pdb_data = results->getNext()) {
  if (max_matches > 0 && matches >= max_matches)
    break;

  auto var_name = pdb_data->getName();
  if (var_name.empty())
    continue;
  if (!regex.Execute(var_name))
    continue;
  SymbolContext sc;
  sc.module_sp = m_objfile_sp->GetModule();
  lldbassert(sc.module_sp.get())lldb_private::lldb_assert(static_cast<bool>(sc.module_sp
.get()), "sc.module_sp.get()", __FUNCTION__, "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp"
, 1167);

  sc.comp_unit = ParseCompileUnitForUID(GetCompilandId(*pdb_data)).get();
  // FIXME: We are not able to determine the compile unit.
  if (sc.comp_unit == nullptr)
    continue;

  ParseVariables(sc, *pdb_data, &variables);
  matches = variables.GetSize() - old_size;
}
1177}

1179bool SymbolFilePDB::ResolveFunction(const llvm::pdb::PDBSymbolFunc &pdb_func,
                                  bool include_inlines,
                                  lldb_private::SymbolContextList &sc_list) {
lldb_private::SymbolContext sc;
sc.comp_unit = ParseCompileUnitForUID(pdb_func.getCompilandId()).get();
if (!sc.comp_unit)
  return false;
sc.module_sp = sc.comp_unit->GetModule();
sc.function = ParseCompileUnitFunctionForPDBFunc(pdb_func, *sc.comp_unit);
if (!sc.function)
  return false;

sc_list.Append(sc);
return true;
1193}

1195bool SymbolFilePDB::ResolveFunction(uint32_t uid, bool include_inlines,
                                  lldb_private::SymbolContextList &sc_list) {
auto pdb_func_up = m_session_up->getConcreteSymbolById<PDBSymbolFunc>(uid);
if (!pdb_func_up && !(include_inlines && pdb_func_up->hasInlineAttribute()))
  return false;
return ResolveFunction(*pdb_func_up, include_inlines, sc_list);
1201}

1203void SymbolFilePDB::CacheFunctionNames() {
if (!m_func_full_names.IsEmpty())
  return;

std::map<uint64_t, uint32_t> addr_ids;

if (auto results_up = m_global_scope_up->findAllChildren<PDBSymbolFunc>()) {
  while (auto pdb_func_up = results_up->getNext()) {
    if (pdb_func_up->isCompilerGenerated())
      continue;

    auto name = pdb_func_up->getName();
    auto demangled_name = pdb_func_up->getUndecoratedName();
    if (name.empty() && demangled_name.empty())
      continue;

    auto uid = pdb_func_up->getSymIndexId();
    if (!demangled_name.empty() && pdb_func_up->getVirtualAddress())
      addr_ids.insert(std::make_pair(pdb_func_up->getVirtualAddress(), uid));

    if (auto parent = pdb_func_up->getClassParent()) {

      // PDB have symbols for class/struct methods or static methods in Enum
      // Class. We won't bother to check if the parent is UDT or Enum here.
      m_func_method_names.Append(ConstString(name), uid);

      // To search a method name, like NS::Class:MemberFunc, LLDB searches
      // its base name, i.e. MemberFunc by default. Since PDBSymbolFunc does
      // not have information of this, we extract base names and cache them
      // by our own effort.
      llvm::StringRef basename = MSVCUndecoratedNameParser::DropScope(name);
      if (!basename.empty())
        m_func_base_names.Append(ConstString(basename), uid);
      else {
        m_func_base_names.Append(ConstString(name), uid);
      }

      if (!demangled_name.empty())
        m_func_full_names.Append(ConstString(demangled_name), uid);

    } else {
      // Handle not-method symbols.

      // The function name might contain namespace, or its lexical scope.
      llvm::StringRef basename = MSVCUndecoratedNameParser::DropScope(name);
      if (!basename.empty())
        m_func_base_names.Append(ConstString(basename), uid);
      else
        m_func_base_names.Append(ConstString(name), uid);

      if (name == "main") {
        m_func_full_names.Append(ConstString(name), uid);

        if (!demangled_name.empty() && name != demangled_name) {
          m_func_full_names.Append(ConstString(demangled_name), uid);
          m_func_base_names.Append(ConstString(demangled_name), uid);
        }
      } else if (!demangled_name.empty()) {
        m_func_full_names.Append(ConstString(demangled_name), uid);
      } else {
        m_func_full_names.Append(ConstString(name), uid);
      }
    }
  }
}

if (auto results_up =
        m_global_scope_up->findAllChildren<PDBSymbolPublicSymbol>()) {
  while (auto pub_sym_up = results_up->getNext()) {
    if (!pub_sym_up->isFunction())
      continue;
    auto name = pub_sym_up->getName();
    if (name.empty())
      continue;

    if (CPlusPlusLanguage::IsCPPMangledName(name.c_str())) {
      auto vm_addr = pub_sym_up->getVirtualAddress();

      // PDB public symbol has mangled name for its associated function.
      if (vm_addr && addr_ids.find(vm_addr) != addr_ids.end()) {
        // Cache mangled name.
        m_func_full_names.Append(ConstString(name), addr_ids[vm_addr]);
      }
    }
  }
}
// Sort them before value searching is working properly
m_func_full_names.Sort();
m_func_full_names.SizeToFit();
m_func_method_names.Sort();
m_func_method_names.SizeToFit();
m_func_base_names.Sort();
m_func_base_names.SizeToFit();
1296}

1298void SymbolFilePDB::FindFunctions(
  lldb_private::ConstString name,
  const lldb_private::CompilerDeclContext &parent_decl_ctx,
  FunctionNameType name_type_mask, bool include_inlines,
  lldb_private::SymbolContextList &sc_list) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
lldbassert((name_type_mask & eFunctionNameTypeAuto) == 0)lldb_private::lldb_assert(static_cast<bool>((name_type_mask
 & eFunctionNameTypeAuto) == 0), "(name_type_mask & eFunctionNameTypeAuto) == 0"
, __FUNCTION__, "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp"
, 1304);

if (name_type_mask == eFunctionNameTypeNone)
  return;
if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
  return;
if (name.IsEmpty())
  return;

if (name_type_mask & eFunctionNameTypeFull ||
    name_type_mask & eFunctionNameTypeBase ||
    name_type_mask & eFunctionNameTypeMethod) {
  CacheFunctionNames();

  std::set<uint32_t> resolved_ids;
  auto ResolveFn = [this, &name, parent_decl_ctx, include_inlines, &sc_list,
                    &resolved_ids](UniqueCStringMap<uint32_t> &Names) {
    std::vector<uint32_t> ids;
    if (!Names.GetValues(name, ids))
      return;

    for (uint32_t id : ids) {
      if (resolved_ids.find(id) != resolved_ids.end())
        continue;

      if (parent_decl_ctx.IsValid() &&
          GetDeclContextContainingUID(id) != parent_decl_ctx)
        continue;

      if (ResolveFunction(id, include_inlines, sc_list))
        resolved_ids.insert(id);
    }
  };
  if (name_type_mask & eFunctionNameTypeFull) {
    ResolveFn(m_func_full_names);
    ResolveFn(m_func_base_names);
    ResolveFn(m_func_method_names);
  }
  if (name_type_mask & eFunctionNameTypeBase)
    ResolveFn(m_func_base_names);
  if (name_type_mask & eFunctionNameTypeMethod)
    ResolveFn(m_func_method_names);
}
1347}

1349void SymbolFilePDB::FindFunctions(const lldb_private::RegularExpression &regex,
                                bool include_inlines,
                                lldb_private::SymbolContextList &sc_list) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
if (!regex.IsValid())
  return;

CacheFunctionNames();

std::set<uint32_t> resolved_ids;
auto ResolveFn = [&regex, include_inlines, &sc_list, &resolved_ids,
                  this](UniqueCStringMap<uint32_t> &Names) {
  std::vector<uint32_t> ids;
  if (Names.GetValues(regex, ids)) {
    for (auto id : ids) {
      if (resolved_ids.find(id) == resolved_ids.end())
        if (ResolveFunction(id, include_inlines, sc_list))
          resolved_ids.insert(id);
    }
  }
};
ResolveFn(m_func_full_names);
ResolveFn(m_func_base_names);
1372}

1374void SymbolFilePDB::GetMangledNamesForFunction(
  const std::string &scope_qualified_name,
  std::vector<lldb_private::ConstString> &mangled_names) {}

1378void SymbolFilePDB::AddSymbols(lldb_private::Symtab &symtab) {
std::set<lldb::addr_t> sym_addresses;
for (size_t i = 0; i < symtab.GetNumSymbols(); i++)
  sym_addresses.insert(symtab.SymbolAtIndex(i)->GetFileAddress());

auto results = m_global_scope_up->findAllChildren<PDBSymbolPublicSymbol>();
if (!results)
  return;

auto section_list = m_objfile_sp->GetSectionList();
if (!section_list)
  return;

while (auto pub_symbol = results->getNext()) {
  auto section_id = pub_symbol->getAddressSection();

  auto section = section_list->FindSectionByID(section_id);
  if (!section)
    continue;

  auto offset = pub_symbol->getAddressOffset();

  auto file_addr = section->GetFileAddress() + offset;
  if (sym_addresses.find(file_addr) != sym_addresses.end())
    continue;
  sym_addresses.insert(file_addr);

  auto size = pub_symbol->getLength();
  symtab.AddSymbol(
      Symbol(pub_symbol->getSymIndexId(),   // symID
             pub_symbol->getName().c_str(), // name
             pub_symbol->isCode() ? eSymbolTypeCode : eSymbolTypeData, // type
             true,      // external
             false,     // is_debug
             false,     // is_trampoline
             false,     // is_artificial
             section,   // section_sp
             offset,    // value
             size,      // size
             size != 0, // size_is_valid
             false,     // contains_linker_annotations
             0          // flags
             ));
}

symtab.CalculateSymbolSizes();
symtab.Finalize();
1425}

1427void SymbolFilePDB::FindTypes(
  lldb_private::ConstString name, const CompilerDeclContext &parent_decl_ctx,
  uint32_t max_matches,
  llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
  lldb_private::TypeMap &types) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
if (!name)
  return;
if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
  return;

searched_symbol_files.clear();
searched_symbol_files.insert(this);

// There is an assumption 'name' is not a regex
FindTypesByName(name.GetStringRef(), parent_decl_ctx, max_matches, types);
1443}

1445void SymbolFilePDB::DumpClangAST(Stream &s) {
auto type_system_or_err =
    GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
if (auto err = type_system_or_err.takeError()) {
  LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),do { ::lldb_private::Log *log_private = (lldb_private::GetLogIfAnyCategoriesSet
((1u << 20))); ::llvm::Error error_private = (std::move
(err)); if (log_private && error_private) { log_private
->FormatError(::std::move(error_private), "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp"
, __func__, "Unable to dump ClangAST"); } else ::llvm::consumeError
(::std::move(error_private)); } while (0)
                 std::move(err), "Unable to dump ClangAST")do { ::lldb_private::Log *log_private = (lldb_private::GetLogIfAnyCategoriesSet
((1u << 20))); ::llvm::Error error_private = (std::move
(err)); if (log_private && error_private) { log_private
->FormatError(::std::move(error_private), "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp"
, __func__, "Unable to dump ClangAST"); } else ::llvm::consumeError
(::std::move(error_private)); } while (0);
  return;
}

auto *clang_type_system =
    llvm::dyn_cast_or_null<TypeSystemClang>(&type_system_or_err.get());
if (!clang_type_system)
  return;
clang_type_system->Dump(s);
1459}

1461void SymbolFilePDB::FindTypesByRegex(
  const lldb_private::RegularExpression &regex, uint32_t max_matches,
  lldb_private::TypeMap &types) {
// When searching by regex, we need to go out of our way to limit the search
// space as much as possible since this searches EVERYTHING in the PDB,
// manually doing regex comparisons.  PDB library isn't optimized for regex
// searches or searches across multiple symbol types at the same time, so the
// best we can do is to search enums, then typedefs, then classes one by one,
// and do a regex comparison against each of them.
PDB_SymType tags_to_search[] = {PDB_SymType::Enum, PDB_SymType::Typedef,
                                PDB_SymType::UDT};
std::unique_ptr<IPDBEnumSymbols> results;

uint32_t matches = 0;

for (auto tag : tags_to_search) {
  results = m_global_scope_up->findAllChildren(tag);
  if (!results)
    continue;

  while (auto result = results->getNext()) {
    if (max_matches > 0 && matches >= max_matches)
      break;

    std::string type_name;
    if (auto enum_type = llvm::dyn_cast<PDBSymbolTypeEnum>(result.get()))
      type_name = enum_type->getName();
    else if (auto typedef_type =
                 llvm::dyn_cast<PDBSymbolTypeTypedef>(result.get()))
      type_name = typedef_type->getName();
    else if (auto class_type = llvm::dyn_cast<PDBSymbolTypeUDT>(result.get()))
      type_name = class_type->getName();
    else {
      // We're looking only for types that have names.  Skip symbols, as well
      // as unnamed types such as arrays, pointers, etc.
      continue;
    }

    if (!regex.Execute(type_name))
      continue;

    // This should cause the type to get cached and stored in the `m_types`
    // lookup.
    if (!ResolveTypeUID(result->getSymIndexId()))
      continue;

    auto iter = m_types.find(result->getSymIndexId());
    if (iter == m_types.end())
      continue;
    types.Insert(iter->second);
    ++matches;
  }
}
1514}

1516void SymbolFilePDB::FindTypesByName(
  llvm::StringRef name,
  const lldb_private::CompilerDeclContext &parent_decl_ctx,
  uint32_t max_matches, lldb_private::TypeMap &types) {
std::unique_ptr<IPDBEnumSymbols> results;
if (name.empty())
  return;
results = m_global_scope_up->findAllChildren(PDB_SymType::None);
if (!results)
  return;

uint32_t matches = 0;

while (auto result = results->getNext()) {
  if (max_matches > 0 && matches >= max_matches)
    break;

  if (MSVCUndecoratedNameParser::DropScope(
          result->getRawSymbol().getName()) != name)
    continue;

  switch (result->getSymTag()) {
  case PDB_SymType::Enum:
  case PDB_SymType::UDT:
  case PDB_SymType::Typedef:
    break;
  default:
    // We're looking only for types that have names.  Skip symbols, as well
    // as unnamed types such as arrays, pointers, etc.
    continue;
  }

  // This should cause the type to get cached and stored in the `m_types`
  // lookup.
  if (!ResolveTypeUID(result->getSymIndexId()))
    continue;

  if (parent_decl_ctx.IsValid() &&
      GetDeclContextContainingUID(result->getSymIndexId()) != parent_decl_ctx)
    continue;

  auto iter = m_types.find(result->getSymIndexId());
  if (iter == m_types.end())
    continue;
  types.Insert(iter->second);
  ++matches;
}
1563}

1565void SymbolFilePDB::FindTypes(
  llvm::ArrayRef<CompilerContext> pattern, LanguageSet languages,
  llvm::DenseSet<SymbolFile *> &searched_symbol_files,
  lldb_private::TypeMap &types) {}

1570void SymbolFilePDB::GetTypesForPDBSymbol(const llvm::pdb::PDBSymbol &pdb_symbol,
                                       uint32_t type_mask,
                                       TypeCollection &type_collection) {
bool can_parse = false;
switch (pdb_symbol.getSymTag()) {
case PDB_SymType::ArrayType:
  can_parse = ((type_mask & eTypeClassArray) != 0);
  break;
case PDB_SymType::BuiltinType:
  can_parse = ((type_mask & eTypeClassBuiltin) != 0);
  break;
case PDB_SymType::Enum:
  can_parse = ((type_mask & eTypeClassEnumeration) != 0);
  break;
case PDB_SymType::Function:
case PDB_SymType::FunctionSig:
  can_parse = ((type_mask & eTypeClassFunction) != 0);
  break;
case PDB_SymType::PointerType:
  can_parse = ((type_mask & (eTypeClassPointer | eTypeClassBlockPointer |
                             eTypeClassMemberPointer)) != 0);
  break;
case PDB_SymType::Typedef:
  can_parse = ((type_mask & eTypeClassTypedef) != 0);
  break;
case PDB_SymType::UDT: {
  auto *udt = llvm::dyn_cast<PDBSymbolTypeUDT>(&pdb_symbol);
  assert(udt)((void)0);
  can_parse = (udt->getUdtKind() != PDB_UdtType::Interface &&
               ((type_mask & (eTypeClassClass | eTypeClassStruct |
                              eTypeClassUnion)) != 0));
} break;
default:
  break;
}

if (can_parse) {
  if (auto *type = ResolveTypeUID(pdb_symbol.getSymIndexId())) {
    auto result =
        std::find(type_collection.begin(), type_collection.end(), type);
    if (result == type_collection.end())
      type_collection.push_back(type);
  }
}

auto results_up = pdb_symbol.findAllChildren();
while (auto symbol_up = results_up->getNext())
  GetTypesForPDBSymbol(*symbol_up, type_mask, type_collection);
1618}

1620void SymbolFilePDB::GetTypes(lldb_private::SymbolContextScope *sc_scope,
                           TypeClass type_mask,
                           lldb_private::TypeList &type_list) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
TypeCollection type_collection;
CompileUnit *cu =
    sc_scope ? sc_scope->CalculateSymbolContextCompileUnit() : nullptr;
if (cu) {
  auto compiland_up = GetPDBCompilandByUID(cu->GetID());
  if (!compiland_up)
    return;
  GetTypesForPDBSymbol(*compiland_up, type_mask, type_collection);
} else {
  for (uint32_t cu_idx = 0; cu_idx < GetNumCompileUnits(); ++cu_idx) {
    auto cu_sp = ParseCompileUnitAtIndex(cu_idx);
    if (cu_sp) {
      if (auto compiland_up = GetPDBCompilandByUID(cu_sp->GetID()))
        GetTypesForPDBSymbol(*compiland_up, type_mask, type_collection);
    }
  }
}

for (auto type : type_collection) {
  type->GetForwardCompilerType();
  type_list.Insert(type->shared_from_this());
}
1646}

1648llvm::Expected<lldb_private::TypeSystem &>
1649SymbolFilePDB::GetTypeSystemForLanguage(lldb::LanguageType language) {
auto type_system_or_err =
    m_objfile_sp->GetModule()->GetTypeSystemForLanguage(language);
if (type_system_or_err) {
  type_system_or_err->SetSymbolFile(this);
}
return type_system_or_err;
1656}

1658PDBASTParser *SymbolFilePDB::GetPDBAstParser() {
auto type_system_or_err =
    GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
if (auto err = type_system_or_err.takeError()) {
  LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),do { ::lldb_private::Log *log_private = (lldb_private::GetLogIfAnyCategoriesSet
((1u << 20))); ::llvm::Error error_private = (std::move
(err)); if (log_private && error_private) { log_private
->FormatError(::std::move(error_private), "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp"
, __func__, "Unable to get PDB AST parser"); } else ::llvm::consumeError
(::std::move(error_private)); } while (0)
                 std::move(err), "Unable to get PDB AST parser")do { ::lldb_private::Log *log_private = (lldb_private::GetLogIfAnyCategoriesSet
((1u << 20))); ::llvm::Error error_private = (std::move
(err)); if (log_private && error_private) { log_private
->FormatError(::std::move(error_private), "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp"
, __func__, "Unable to get PDB AST parser"); } else ::llvm::consumeError
(::std::move(error_private)); } while (0);
  return nullptr;
}

auto *clang_type_system =
    llvm::dyn_cast_or_null<TypeSystemClang>(&type_system_or_err.get());
if (!clang_type_system)
  return nullptr;

return clang_type_system->GetPDBParser();
1673}

1675lldb_private::CompilerDeclContext
1676SymbolFilePDB::FindNamespace(lldb_private::ConstString name,
                           const CompilerDeclContext &parent_decl_ctx) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
auto type_system_or_err =
    GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
if (auto err = type_system_or_err.takeError()) {
  LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),do { ::lldb_private::Log *log_private = (lldb_private::GetLogIfAnyCategoriesSet
((1u << 20))); ::llvm::Error error_private = (std::move
(err)); if (log_private && error_private) { log_private
->FormatError(::std::move(error_private), "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp"
, __func__, "Unable to find namespace {}", name.AsCString());
 } else ::llvm::consumeError(::std::move(error_private)); } while
 (0)
                 std::move(err), "Unable to find namespace {}",do { ::lldb_private::Log *log_private = (lldb_private::GetLogIfAnyCategoriesSet
((1u << 20))); ::llvm::Error error_private = (std::move
(err)); if (log_private && error_private) { log_private
->FormatError(::std::move(error_private), "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp"
, __func__, "Unable to find namespace {}", name.AsCString());
 } else ::llvm::consumeError(::std::move(error_private)); } while
 (0)
                 name.AsCString())do { ::lldb_private::Log *log_private = (lldb_private::GetLogIfAnyCategoriesSet
((1u << 20))); ::llvm::Error error_private = (std::move
(err)); if (log_private && error_private) { log_private
->FormatError(::std::move(error_private), "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp"
, __func__, "Unable to find namespace {}", name.AsCString());
 } else ::llvm::consumeError(::std::move(error_private)); } while
 (0);
  return CompilerDeclContext();
}

auto *clang_type_system =
    llvm::dyn_cast_or_null<TypeSystemClang>(&type_system_or_err.get());
if (!clang_type_system)
  return CompilerDeclContext();

PDBASTParser *pdb = clang_type_system->GetPDBParser();
if (!pdb)
  return CompilerDeclContext();

clang::DeclContext *decl_context = nullptr;
if (parent_decl_ctx)
  decl_context = static_cast<clang::DeclContext *>(
      parent_decl_ctx.GetOpaqueDeclContext());

auto namespace_decl =
    pdb->FindNamespaceDecl(decl_context, name.GetStringRef());
if (!namespace_decl)
  return CompilerDeclContext();

return clang_type_system->CreateDeclContext(namespace_decl);
1708}

1710lldb_private::ConstString SymbolFilePDB::GetPluginName() {
static ConstString g_name("pdb");
return g_name;
1713}

1715uint32_t SymbolFilePDB::GetPluginVersion() { return 1; }

1717IPDBSession &SymbolFilePDB::GetPDBSession() { return *m_session_up; }

1719const IPDBSession &SymbolFilePDB::GetPDBSession() const {
return *m_session_up;
1721}

1723lldb::CompUnitSP SymbolFilePDB::ParseCompileUnitForUID(uint32_t id,
                                                     uint32_t index) {
auto found_cu = m_comp_units.find(id);
if (found_cu != m_comp_units.end())
  return found_cu->second;

auto compiland_up = GetPDBCompilandByUID(id);
if (!compiland_up)
  return CompUnitSP();

lldb::LanguageType lang;
auto details = compiland_up->findOneChild<PDBSymbolCompilandDetails>();
if (!details)
  lang = lldb::eLanguageTypeC_plus_plus;
else
  lang = TranslateLanguage(details->getLanguage());

if (lang == lldb::LanguageType::eLanguageTypeUnknown)
  return CompUnitSP();

std::string path = compiland_up->getSourceFileFullPath();
if (path.empty())
  return CompUnitSP();

// Don't support optimized code for now, DebugInfoPDB does not return this
// information.
LazyBool optimized = eLazyBoolNo;
auto cu_sp = std::make_shared<CompileUnit>(m_objfile_sp->GetModule(), nullptr,
                                           path.c_str(), id, lang, optimized);

if (!cu_sp)
  return CompUnitSP();

m_comp_units.insert(std::make_pair(id, cu_sp));
if (index == UINT32_MAX0xffffffffU)
  GetCompileUnitIndex(*compiland_up, index);
lldbassert(index != UINT32_MAX)lldb_private::lldb_assert(static_cast<bool>(index != 0xffffffffU
), "index != UINT32_MAX", __FUNCTION__, "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp"
, 1759);
SetCompileUnitAtIndex(index, cu_sp);
return cu_sp;
1762}

1764bool SymbolFilePDB::ParseCompileUnitLineTable(CompileUnit &comp_unit,
                                            uint32_t match_line) {
auto compiland_up = GetPDBCompilandByUID(comp_unit.GetID());
if (!compiland_up)
  return false;

// LineEntry needs the *index* of the file into the list of support files
// returned by ParseCompileUnitSupportFiles.  But the underlying SDK gives us
// a globally unique idenfitifier in the namespace of the PDB.  So, we have
// to do a mapping so that we can hand out indices.
llvm::DenseMap<uint32_t, uint32_t> index_map;
BuildSupportFileIdToSupportFileIndexMap(*compiland_up, index_map);
auto line_table = std::make_unique<LineTable>(&comp_unit);

// Find contributions to `compiland` from all source and header files.
auto files = m_session_up->getSourceFilesForCompiland(*compiland_up);
if (!files)
  return false;

// For each source and header file, create a LineSequence for contributions
// to the compiland from that file, and add the sequence.
while (auto file = files->getNext()) {
  std::unique_ptr<LineSequence> sequence(
      line_table->CreateLineSequenceContainer());
  auto lines = m_session_up->findLineNumbers(*compiland_up, *file);
  if (!lines)
    continue;
  int entry_count = lines->getChildCount();

  uint64_t prev_addr;
  uint32_t prev_length;
  uint32_t prev_line;
  uint32_t prev_source_idx;

  for (int i = 0; i < entry_count; ++i) {
    auto line = lines->getChildAtIndex(i);

    uint64_t lno = line->getLineNumber();
    uint64_t addr = line->getVirtualAddress();
    uint32_t length = line->getLength();
    uint32_t source_id = line->getSourceFileId();
    uint32_t col = line->getColumnNumber();
    uint32_t source_idx = index_map[source_id];

    // There was a gap between the current entry and the previous entry if
    // the addresses don't perfectly line up.
    bool is_gap = (i > 0) && (prev_addr + prev_length < addr);

    // Before inserting the current entry, insert a terminal entry at the end
    // of the previous entry's address range if the current entry resulted in
    // a gap from the previous entry.
    if (is_gap && ShouldAddLine(match_line, prev_line, prev_length)) {
      line_table->AppendLineEntryToSequence(
          sequence.get(), prev_addr + prev_length, prev_line, 0,
          prev_source_idx, false, false, false, false, true);

      line_table->InsertSequence(sequence.get());
      sequence = line_table->CreateLineSequenceContainer();
    }

    if (ShouldAddLine(match_line, lno, length)) {
      bool is_statement = line->isStatement();
      bool is_prologue = false;
      bool is_epilogue = false;
      auto func =
          m_session_up->findSymbolByAddress(addr, PDB_SymType::Function);
      if (func) {
        auto prologue = func->findOneChild<PDBSymbolFuncDebugStart>();
        if (prologue)
          is_prologue = (addr == prologue->getVirtualAddress());

        auto epilogue = func->findOneChild<PDBSymbolFuncDebugEnd>();
        if (epilogue)
          is_epilogue = (addr == epilogue->getVirtualAddress());
      }

      line_table->AppendLineEntryToSequence(sequence.get(), addr, lno, col,
                                            source_idx, is_statement, false,
                                            is_prologue, is_epilogue, false);
    }

    prev_addr = addr;
    prev_length = length;
    prev_line = lno;
    prev_source_idx = source_idx;
  }

  if (entry_count > 0 && ShouldAddLine(match_line, prev_line, prev_length)) {
    // The end is always a terminal entry, so insert it regardless.
    line_table->AppendLineEntryToSequence(
        sequence.get(), prev_addr + prev_length, prev_line, 0,
        prev_source_idx, false, false, false, false, true);
  }

  line_table->InsertSequence(sequence.get());
}

if (line_table->GetSize()) {
  comp_unit.SetLineTable(line_table.release());
  return true;
}
return false;
1866}

1868void SymbolFilePDB::BuildSupportFileIdToSupportFileIndexMap(
  const PDBSymbolCompiland &compiland,
  llvm::DenseMap<uint32_t, uint32_t> &index_map) const {
// This is a hack, but we need to convert the source id into an index into
// the support files array.  We don't want to do path comparisons to avoid
// basename / full path issues that may or may not even be a problem, so we
// use the globally unique source file identifiers.  Ideally we could use the
// global identifiers everywhere, but LineEntry currently assumes indices.
auto source_files = m_session_up->getSourceFilesForCompiland(compiland);
if (!source_files)
  return;

int index = 0;
while (auto file = source_files->getNext()) {
  uint32_t source_id = file->getUniqueId();
  index_map[source_id] = index++;
}
1885}

1887lldb::CompUnitSP SymbolFilePDB::GetCompileUnitContainsAddress(
  const lldb_private::Address &so_addr) {
lldb::addr_t file_vm_addr = so_addr.GetFileAddress();
if (file_vm_addr == LLDB_INVALID_ADDRESS0xffffffffffffffffULL || file_vm_addr == 0)
  return nullptr;

// If it is a PDB function's vm addr, this is the first sure bet.
if (auto lines =
        m_session_up->findLineNumbersByAddress(file_vm_addr, /*Length=*/1)) {
  if (auto first_line = lines->getNext())
    return ParseCompileUnitForUID(first_line->getCompilandId());
}

// Otherwise we resort to section contributions.
if (auto sec_contribs = m_session_up->getSectionContribs()) {
  while (auto section = sec_contribs->getNext()) {
    auto va = section->getVirtualAddress();
    if (file_vm_addr >= va && file_vm_addr < va + section->getLength())
      return ParseCompileUnitForUID(section->getCompilandId());
  }
}
return nullptr;
1909}

1911Mangled
1912SymbolFilePDB::GetMangledForPDBFunc(const llvm::pdb::PDBSymbolFunc &pdb_func) {
Mangled mangled;
auto func_name = pdb_func.getName();
auto func_undecorated_name = pdb_func.getUndecoratedName();
std::string func_decorated_name;

// Seek from public symbols for non-static function's decorated name if any.
// For static functions, they don't have undecorated names and aren't exposed
// in Public Symbols either.
if (!func_undecorated_name.empty()) {
  auto result_up = m_global_scope_up->findChildren(
      PDB_SymType::PublicSymbol, func_undecorated_name,
      PDB_NameSearchFlags::NS_UndecoratedName);
  if (result_up) {
    while (auto symbol_up = result_up->getNext()) {
      // For a public symbol, it is unique.
      lldbassert(result_up->getChildCount() == 1)lldb_private::lldb_assert(static_cast<bool>(result_up->
getChildCount() == 1), "result_up->getChildCount() == 1", __FUNCTION__
, "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp"
, 1928);
      if (auto *pdb_public_sym =
              llvm::dyn_cast_or_null<PDBSymbolPublicSymbol>(
                  symbol_up.get())) {
        if (pdb_public_sym->isFunction()) {
          func_decorated_name = pdb_public_sym->getName();
          break;
        }
      }
    }
  }
}
if (!func_decorated_name.empty()) {
  mangled.SetMangledName(ConstString(func_decorated_name));

  // For MSVC, format of C funciton's decorated name depends on calling
  // convention. Unfortunately none of the format is recognized by current
  // LLDB. For example, `_purecall` is a __cdecl C function. From PDB,
  // `__purecall` is retrieved as both its decorated and undecorated name
  // (using PDBSymbolFunc::getUndecoratedName method). However `__purecall`
  // string is not treated as mangled in LLDB (neither `?` nor `_Z` prefix).
  // Mangled::GetDemangledName method will fail internally and caches an
  // empty string as its undecorated name. So we will face a contradiction
  // here for the same symbol:
  //   non-empty undecorated name from PDB
  //   empty undecorated name from LLDB
  if (!func_undecorated_name.empty() && mangled.GetDemangledName().IsEmpty())
    mangled.SetDemangledName(ConstString(func_undecorated_name));

  // LLDB uses several flags to control how a C++ decorated name is
  // undecorated for MSVC. See `safeUndecorateName` in Class Mangled. So the
  // yielded name could be different from what we retrieve from
  // PDB source unless we also apply same flags in getting undecorated
  // name through PDBSymbolFunc::getUndecoratedNameEx method.
  if (!func_undecorated_name.empty() &&
      mangled.GetDemangledName() != ConstString(func_undecorated_name))
    mangled.SetDemangledName(ConstString(func_undecorated_name));
} else if (!func_undecorated_name.empty()) {
  mangled.SetDemangledName(ConstString(func_undecorated_name));
} else if (!func_name.empty())
  mangled.SetValue(ConstString(func_name), false);

return mangled;
1971}

1973bool SymbolFilePDB::DeclContextMatchesThisSymbolFile(
  const lldb_private::CompilerDeclContext &decl_ctx) {
if (!decl_ctx.IsValid())
  return true;

TypeSystem *decl_ctx_type_system = decl_ctx.GetTypeSystem();
if (!decl_ctx_type_system)
  return false;
auto type_system_or_err = GetTypeSystemForLanguage(
    decl_ctx_type_system->GetMinimumLanguage(nullptr));
if (auto err = type_system_or_err.takeError()) {
  LLDB_LOG_ERROR(do { ::lldb_private::Log *log_private = (lldb_private::GetLogIfAnyCategoriesSet
((1u << 20))); ::llvm::Error error_private = (std::move
(err)); if (log_private && error_private) { log_private
->FormatError(::std::move(error_private), "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp"
, __func__, "Unable to determine if DeclContext matches this symbol file"
); } else ::llvm::consumeError(::std::move(error_private)); }
 while (0)
      lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),do { ::lldb_private::Log *log_private = (lldb_private::GetLogIfAnyCategoriesSet
((1u << 20))); ::llvm::Error error_private = (std::move
(err)); if (log_private && error_private) { log_private
->FormatError(::std::move(error_private), "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp"
, __func__, "Unable to determine if DeclContext matches this symbol file"
); } else ::llvm::consumeError(::std::move(error_private)); }
 while (0)
      std::move(err),do { ::lldb_private::Log *log_private = (lldb_private::GetLogIfAnyCategoriesSet
((1u << 20))); ::llvm::Error error_private = (std::move
(err)); if (log_private && error_private) { log_private
->FormatError(::std::move(error_private), "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp"
, __func__, "Unable to determine if DeclContext matches this symbol file"
); } else ::llvm::consumeError(::std::move(error_private)); }
 while (0)
      "Unable to determine if DeclContext matches this symbol file")do { ::lldb_private::Log *log_private = (lldb_private::GetLogIfAnyCategoriesSet
((1u << 20))); ::llvm::Error error_private = (std::move
(err)); if (log_private && error_private) { log_private
->FormatError(::std::move(error_private), "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp"
, __func__, "Unable to determine if DeclContext matches this symbol file"
); } else ::llvm::consumeError(::std::move(error_private)); }
 while (0);
  return false;
}

if (decl_ctx_type_system == &type_system_or_err.get())
  return true; // The type systems match, return true

return false;
1995}

1997uint32_t SymbolFilePDB::GetCompilandId(const llvm::pdb::PDBSymbolData &data) {
static const auto pred_upper = [](uint32_t lhs, SecContribInfo rhs) {
  return lhs < rhs.Offset;
};

// Cache section contributions
if (m_sec_contribs.empty()) {
  if (auto SecContribs = m_session_up->getSectionContribs()) {
    while (auto SectionContrib = SecContribs->getNext()) {
      auto comp_id = SectionContrib->getCompilandId();
      if (!comp_id)
        continue;

      auto sec = SectionContrib->getAddressSection();
      auto &sec_cs = m_sec_contribs[sec];

      auto offset = SectionContrib->getAddressOffset();
      auto it =
          std::upper_bound(sec_cs.begin(), sec_cs.end(), offset, pred_upper);

      auto size = SectionContrib->getLength();
      sec_cs.insert(it, {offset, size, comp_id});
    }
  }
}

// Check by line number
if (auto Lines = data.getLineNumbers()) {
  if (auto FirstLine = Lines->getNext())
    return FirstLine->getCompilandId();
}

// Retrieve section + offset
uint32_t DataSection = data.getAddressSection();
uint32_t DataOffset = data.getAddressOffset();
if (DataSection == 0) {
  if (auto RVA = data.getRelativeVirtualAddress())
    m_session_up->addressForRVA(RVA, DataSection, DataOffset);
}

if (DataSection) {
  // Search by section contributions
  auto &sec_cs = m_sec_contribs[DataSection];
  auto it =
      std::upper_bound(sec_cs.begin(), sec_cs.end(), DataOffset, pred_upper);
  if (it != sec_cs.begin()) {
    --it;
    if (DataOffset < it->Offset + it->Size)
      return it->CompilandId;
  }
} else {
  // Search in lexical tree
  auto LexParentId = data.getLexicalParentId();
  while (auto LexParent = m_session_up->getSymbolById(LexParentId)) {
    if (LexParent->getSymTag() == PDB_SymType::Exe)
      break;
    if (LexParent->getSymTag() == PDB_SymType::Compiland)
      return LexParentId;
    LexParentId = LexParent->getRawSymbol().getLexicalParentId();
  }
}

return 0;
2060}

←

/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;}
6
←
Assuming the condition is true→
7
←
Returning the value 1, 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;
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

←

/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/include/lldb/lldb-enumerations.h

→

1//===-- lldb-enumerations.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_LLDB_ENUMERATIONS_H
10#define LLDB_LLDB_ENUMERATIONS_H

12#include <type_traits>

14#ifndef SWIG
15// Macro to enable bitmask operations on an enum.  Without this, Enum | Enum
16// gets promoted to an int, so you have to say Enum a = Enum(eFoo | eBar).  If
17// you mark Enum with LLDB_MARK_AS_BITMASK_ENUM(Enum), however, you can simply
18// write Enum a = eFoo | eBar.
19// Unfortunately, swig<3.0 doesn't recognise the constexpr keyword, so remove
20// this entire block, as it is not necessary for swig processing.
21#define LLDB_MARK_AS_BITMASK_ENUM(Enum)constexpr Enum operator|(Enum a, Enum b) { return static_cast
<Enum>( static_cast<std::underlying_type<Enum>
::type>(a) | static_cast<std::underlying_type<Enum>
::type>(b)); } constexpr Enum operator&(Enum a, Enum b
) { return static_cast<Enum>( static_cast<std::underlying_type
<Enum>::type>(a) & static_cast<std::underlying_type
<Enum>::type>(b)); } constexpr Enum operator~(Enum a
) { return static_cast<Enum>( ~static_cast<std::underlying_type
<Enum>::type>(a)); } inline Enum &operator|=(Enum
 &a, Enum b) { a = a | b; return a; } inline Enum &operator
&=(Enum &a, Enum b) { a = a & b; return a; }                                        \
constexpr Enum operator|(Enum a, Enum b) {                                   \
  return static_cast<Enum>(                                                  \
      static_cast<std::underlying_type<Enum>::type>(a) |                     \
      static_cast<std::underlying_type<Enum>::type>(b));                     \
}                                                                            \
constexpr Enum operator&(Enum a, Enum b) {                                   \
  return static_cast<Enum>(                                                  \
      static_cast<std::underlying_type<Enum>::type>(a) &                     \
      static_cast<std::underlying_type<Enum>::type>(b));                     \
}                                                                            \
constexpr Enum operator~(Enum a) {                                           \
  return static_cast<Enum>(                                                  \
      ~static_cast<std::underlying_type<Enum>::type>(a));                    \
}                                                                            \
inline Enum &operator|=(Enum &a, Enum b) {                                   \
  a = a | b;                                                                 \
  return a;                                                                  \
}                                                                            \
inline Enum &operator&=(Enum &a, Enum b) {                                   \
  a = a & b;                                                                 \
  return a;                                                                  \
}
44#else
45#define LLDB_MARK_AS_BITMASK_ENUM(Enum)constexpr Enum operator|(Enum a, Enum b) { return static_cast
<Enum>( static_cast<std::underlying_type<Enum>
::type>(a) | static_cast<std::underlying_type<Enum>
::type>(b)); } constexpr Enum operator&(Enum a, Enum b
) { return static_cast<Enum>( static_cast<std::underlying_type
<Enum>::type>(a) & static_cast<std::underlying_type
<Enum>::type>(b)); } constexpr Enum operator~(Enum a
) { return static_cast<Enum>( ~static_cast<std::underlying_type
<Enum>::type>(a)); } inline Enum &operator|=(Enum
 &a, Enum b) { a = a | b; return a; } inline Enum &operator
&=(Enum &a, Enum b) { a = a & b; return a; }
46#endif

48#ifndef SWIG
49// With MSVC, the default type of an enum is always signed, even if one of the
50// enumerator values is too large to fit into a signed integer but would
51// otherwise fit into an unsigned integer.  As a result of this, all of LLDB's
52// flag-style enumerations that specify something like eValueFoo = 1u << 31
53// result in negative values.  This usually just results in a benign warning,
54// but in a few places we actually do comparisons on the enum values, which
55// would cause a real bug.  Furthermore, there's no way to silence only this
56// warning, as it's part of -Wmicrosoft which also catches a whole slew of
57// other useful issues.
58//
59// To make matters worse, early versions of SWIG don't recognize the syntax of
60// specifying the underlying type of an enum (and Python doesn't care anyway)
61// so we need a way to specify the underlying type when the enum is being used
62// from C++ code, but just use a regular enum when swig is pre-processing.
63#define FLAGS_ENUM(Name)enum Name : unsigned enum Name : unsigned
64#define FLAGS_ANONYMOUS_ENUM()enum : unsigned enum : unsigned
65#else
66#define FLAGS_ENUM(Name)enum Name : unsigned enum Name
67#define FLAGS_ANONYMOUS_ENUM()enum : unsigned enum
68#endif

70namespace lldb {

72/// Process and Thread States.
73enum StateType {
eStateInvalid = 0,
eStateUnloaded,  ///< Process is object is valid, but not currently loaded
eStateConnected, ///< Process is connected to remote debug services, but not
                 /// launched or attached to anything yet
eStateAttaching, ///< Process is currently trying to attach
eStateLaunching, ///< Process is in the process of launching
// The state changes eStateAttaching and eStateLaunching are both sent while
// the private state thread is either not yet started or paused. For that
// reason, they should only be signaled as public state changes, and not
// private state changes.
eStateStopped,   ///< Process or thread is stopped and can be examined.
eStateRunning,   ///< Process or thread is running and can't be examined.
eStateStepping,  ///< Process or thread is in the process of stepping and can
                 /// not be examined.
eStateCrashed,   ///< Process or thread has crashed and can be examined.
eStateDetached,  ///< Process has been detached and can't be examined.
eStateExited,    ///< Process has exited and can't be examined.
eStateSuspended, ///< Process or thread is in a suspended state as far
                 ///< as the debugger is concerned while other processes
                 ///< or threads get the chance to run.
kLastStateType = eStateSuspended
95};

97/// Launch Flags.
98FLAGS_ENUM(LaunchFlags)enum LaunchFlags : unsigned{
  eLaunchFlagNone = 0u,
  eLaunchFlagExec = (1u << 0),  ///< Exec when launching and turn the calling
                                /// process into a new process
  eLaunchFlagDebug = (1u << 1), ///< Stop as soon as the process launches to
                                /// allow the process to be debugged
  eLaunchFlagStopAtEntry = (1u
                            << 2), ///< Stop at the program entry point
                                   /// instead of auto-continuing when
                                   /// launching or attaching at entry point
  eLaunchFlagDisableASLR =
      (1u << 3), ///< Disable Address Space Layout Randomization
  eLaunchFlagDisableSTDIO =
      (1u << 4), ///< Disable stdio for inferior process (e.g. for a GUI app)
  eLaunchFlagLaunchInTTY =
      (1u << 5), ///< Launch the process in a new TTY if supported by the host
  eLaunchFlagLaunchInShell =
      (1u << 6), ///< Launch the process inside a shell to get shell expansion
  eLaunchFlagLaunchInSeparateProcessGroup =
      (1u << 7), ///< Launch the process in a separate process group
                 ///< If you are going to hand the process off (e.g. to
                 ///< debugserver)
  eLaunchFlagDontSetExitStatus = (1u << 8),
  ///< set this flag so lldb & the handee don't race to set its exit status.
  eLaunchFlagDetachOnError = (1u << 9), ///< If set, then the client stub
                                        ///< should detach rather than killing
                                        ///< the debugee
                                        ///< if it loses connection with lldb.
  eLaunchFlagShellExpandArguments =
      (1u << 10), ///< Perform shell-style argument expansion
  eLaunchFlagCloseTTYOnExit = (1u << 11), ///< Close the open TTY on exit
  eLaunchFlagInheritTCCFromParent =
      (1u << 12), ///< Don't make the inferior responsible for its own TCC
                  ///< permissions but instead inherit them from its parent.
132};

134/// Thread Run Modes.
135enum RunMode { eOnlyThisThread, eAllThreads, eOnlyDuringStepping };

137/// Byte ordering definitions.
138enum ByteOrder {
eByteOrderInvalid = 0,
eByteOrderBig = 1,
eByteOrderPDP = 2,
eByteOrderLittle = 4
143};

145/// Register encoding definitions.
146enum Encoding {
eEncodingInvalid = 0,
eEncodingUint,    ///< unsigned integer
eEncodingSint,    ///< signed integer
eEncodingIEEE754, ///< float
eEncodingVector   ///< vector registers
152};

154/// Display format definitions.
155enum Format {
eFormatDefault = 0,
eFormatInvalid = 0,
eFormatBoolean,
eFormatBinary,
eFormatBytes,
eFormatBytesWithASCII,
eFormatChar,
eFormatCharPrintable, ///< Only printable characters, '.' if not printable
eFormatComplex,       ///< Floating point complex type
eFormatComplexFloat = eFormatComplex,
eFormatCString, ///< NULL terminated C strings
eFormatDecimal,
eFormatEnum,
eFormatHex,
eFormatHexUppercase,
eFormatFloat,
eFormatOctal,
eFormatOSType, ///< OS character codes encoded into an integer 'PICT' 'text'
               ///< etc...
eFormatUnicode16,
eFormatUnicode32,
eFormatUnsigned,
eFormatPointer,
eFormatVectorOfChar,
eFormatVectorOfSInt8,
eFormatVectorOfUInt8,
eFormatVectorOfSInt16,
eFormatVectorOfUInt16,
eFormatVectorOfSInt32,
eFormatVectorOfUInt32,
eFormatVectorOfSInt64,
eFormatVectorOfUInt64,
eFormatVectorOfFloat16,
eFormatVectorOfFloat32,
eFormatVectorOfFloat64,
eFormatVectorOfUInt128,
eFormatComplexInteger, ///< Integer complex type
eFormatCharArray,      ///< Print characters with no single quotes, used for
                       ///< character arrays that can contain non printable
                       ///< characters
eFormatAddressInfo,    ///< Describe what an address points to (func + offset
                    ///< with file/line, symbol + offset, data, etc)
eFormatHexFloat,    ///< ISO C99 hex float string
eFormatInstruction, ///< Disassemble an opcode
eFormatVoid,        ///< Do not print this
eFormatUnicode8,
kNumFormats
203};

205/// Description levels for "void GetDescription(Stream *, DescriptionLevel)"
206/// calls.
207enum DescriptionLevel {
eDescriptionLevelBrief = 0,
eDescriptionLevelFull,
eDescriptionLevelVerbose,
eDescriptionLevelInitial,
kNumDescriptionLevels
213};

215/// Script interpreter types.
216enum ScriptLanguage {
eScriptLanguageNone = 0,
eScriptLanguagePython,
eScriptLanguageLua,
eScriptLanguageUnknown,
eScriptLanguageDefault = eScriptLanguagePython
222};

224/// Register numbering types.
225// See RegisterContext::ConvertRegisterKindToRegisterNumber to convert any of
226// these to the lldb internal register numbering scheme (eRegisterKindLLDB).
227enum RegisterKind {
eRegisterKindEHFrame = 0, ///< the register numbers seen in eh_frame
eRegisterKindDWARF,       ///< the register numbers seen DWARF
eRegisterKindGeneric, ///< insn ptr reg, stack ptr reg, etc not specific to
                      ///< any particular target
eRegisterKindProcessPlugin, ///< num used by the process plugin - e.g. by the
                            ///< remote gdb-protocol stub program
eRegisterKindLLDB,          ///< lldb's internal register numbers
kNumRegisterKinds
236};

238/// Thread stop reasons.
239enum StopReason {
eStopReasonInvalid = 0,
eStopReasonNone,
eStopReasonTrace,
eStopReasonBreakpoint,
eStopReasonWatchpoint,
eStopReasonSignal,
eStopReasonException,
eStopReasonExec, ///< Program was re-exec'ed
eStopReasonPlanComplete,
eStopReasonThreadExiting,
eStopReasonInstrumentation,
eStopReasonProcessorTrace,
eStopReasonFork,
eStopReasonVFork,
eStopReasonVForkDone,
255};

257/// Command Return Status Types.
258enum ReturnStatus {
eReturnStatusInvalid,
eReturnStatusSuccessFinishNoResult,
eReturnStatusSuccessFinishResult,
eReturnStatusSuccessContinuingNoResult,
eReturnStatusSuccessContinuingResult,
eReturnStatusStarted,
eReturnStatusFailed,
eReturnStatusQuit
267};

269/// The results of expression evaluation.
270enum ExpressionResults {
eExpressionCompleted = 0,
eExpressionSetupError,
eExpressionParseError,
eExpressionDiscarded,
eExpressionInterrupted,
eExpressionHitBreakpoint,
eExpressionTimedOut,
eExpressionResultUnavailable,
eExpressionStoppedForDebug,
eExpressionThreadVanished
281};

283enum SearchDepth {
eSearchDepthInvalid = 0,
eSearchDepthTarget,
eSearchDepthModule,
eSearchDepthCompUnit,
eSearchDepthFunction,
eSearchDepthBlock,
eSearchDepthAddress,
kLastSearchDepthKind = eSearchDepthAddress
292};

294/// Connection Status Types.
295enum ConnectionStatus {
eConnectionStatusSuccess,        ///< Success
eConnectionStatusEndOfFile,      ///< End-of-file encountered
eConnectionStatusError,          ///< Check GetError() for details
eConnectionStatusTimedOut,       ///< Request timed out
eConnectionStatusNoConnection,   ///< No connection
eConnectionStatusLostConnection, ///< Lost connection while connected to a
                                 ///< valid connection
eConnectionStatusInterrupted ///< Interrupted read
304};

306enum ErrorType {
eErrorTypeInvalid,
eErrorTypeGeneric,    ///< Generic errors that can be any value.
eErrorTypeMachKernel, ///< Mach kernel error codes.
eErrorTypePOSIX,      ///< POSIX error codes.
eErrorTypeExpression, ///< These are from the ExpressionResults enum.
eErrorTypeWin32       ///< Standard Win32 error codes.
313};

315enum ValueType {
eValueTypeInvalid = 0,
eValueTypeVariableGlobal = 1,   ///< globals variable
eValueTypeVariableStatic = 2,   ///< static variable
eValueTypeVariableArgument = 3, ///< function argument variables
eValueTypeVariableLocal = 4,    ///< function local variables
eValueTypeRegister = 5,         ///< stack frame register value
eValueTypeRegisterSet = 6, ///< A collection of stack frame register values
eValueTypeConstResult = 7, ///< constant result variables
eValueTypeVariableThreadLocal = 8 ///< thread local storage variable
325};

327/// Token size/granularities for Input Readers.

329enum InputReaderGranularity {
eInputReaderGranularityInvalid = 0,
eInputReaderGranularityByte,
eInputReaderGranularityWord,
eInputReaderGranularityLine,
eInputReaderGranularityAll
335};

337/// These mask bits allow a common interface for queries that can
338/// limit the amount of information that gets parsed to only the
339/// information that is requested. These bits also can indicate what
340/// actually did get resolved during query function calls.
341///
342/// Each definition corresponds to a one of the member variables
343/// in this class, and requests that that item be resolved, or
344/// indicates that the member did get resolved.
345FLAGS_ENUM(SymbolContextItem)enum SymbolContextItem : unsigned{
  /// Set when \a target is requested from a query, or was located
  /// in query results
  eSymbolContextTarget = (1u << 0),
  /// Set when \a module is requested from a query, or was located
  /// in query results
  eSymbolContextModule = (1u << 1),
  /// Set when \a comp_unit is requested from a query, or was
  /// located in query results
  eSymbolContextCompUnit = (1u << 2),
  /// Set when \a function is requested from a query, or was located
  /// in query results
  eSymbolContextFunction = (1u << 3),
  /// Set when the deepest \a block is requested from a query, or
  /// was located in query results
  eSymbolContextBlock = (1u << 4),
  /// Set when \a line_entry is requested from a query, or was
  /// located in query results
  eSymbolContextLineEntry = (1u << 5),
  /// Set when \a symbol is requested from a query, or was located
  /// in query results
  eSymbolContextSymbol = (1u << 6),
  /// Indicates to try and lookup everything up during a routine
  /// symbol context query.
  eSymbolContextEverything = ((eSymbolContextSymbol << 1) - 1u),
  /// Set when \a global or static variable is requested from a
  /// query, or was located in query results.
  /// eSymbolContextVariable is potentially expensive to lookup so
  /// it isn't included in eSymbolContextEverything which stops it
  /// from being used during frame PC lookups and many other
  /// potential address to symbol context lookups.
  eSymbolContextVariable = (1u << 7),
377};
378LLDB_MARK_AS_BITMASK_ENUM(SymbolContextItem)constexpr SymbolContextItem operator|(SymbolContextItem a, SymbolContextItem
 b) { return static_cast<SymbolContextItem>( static_cast
<std::underlying_type<SymbolContextItem>::type>(a
) | static_cast<std::underlying_type<SymbolContextItem>
::type>(b)); } constexpr SymbolContextItem operator&(SymbolContextItem
 a, SymbolContextItem b) { return static_cast<SymbolContextItem
>( static_cast<std::underlying_type<SymbolContextItem
>::type>(a) & static_cast<std::underlying_type<
SymbolContextItem>::type>(b)); } constexpr SymbolContextItem
 operator~(SymbolContextItem a) { return static_cast<SymbolContextItem
>( ~static_cast<std::underlying_type<SymbolContextItem
>::type>(a)); } inline SymbolContextItem &operator|=
(SymbolContextItem &a, SymbolContextItem b) { a = a | b; return
 a; } inline SymbolContextItem &operator&=(SymbolContextItem
 &a, SymbolContextItem b) { a = a & b; return a; }
11
←
Returning zero, which participates in a condition later→

380FLAGS_ENUM(Permissions)enum Permissions : unsigned{ePermissionsWritable = (1u << 0),
                      ePermissionsReadable = (1u << 1),
                      ePermissionsExecutable = (1u << 2)};
383LLDB_MARK_AS_BITMASK_ENUM(Permissions)constexpr Permissions operator|(Permissions a, Permissions b)
 { return static_cast<Permissions>( static_cast<std::
underlying_type<Permissions>::type>(a) | static_cast
<std::underlying_type<Permissions>::type>(b)); } constexpr
 Permissions operator&(Permissions a, Permissions b) { return
 static_cast<Permissions>( static_cast<std::underlying_type
<Permissions>::type>(a) & static_cast<std::underlying_type
<Permissions>::type>(b)); } constexpr Permissions operator
~(Permissions a) { return static_cast<Permissions>( ~static_cast
<std::underlying_type<Permissions>::type>(a)); } inline
 Permissions &operator|=(Permissions &a, Permissions b
) { a = a | b; return a; } inline Permissions &operator&=
(Permissions &a, Permissions b) { a = a & b; return a
; }

385enum InputReaderAction {
eInputReaderActivate, ///< reader is newly pushed onto the reader stack
eInputReaderAsynchronousOutputWritten, ///< an async output event occurred;
                                       ///< the reader may want to do
                                       ///< something
eInputReaderReactivate, ///< reader is on top of the stack again after another
                        ///< reader was popped off
eInputReaderDeactivate, ///< another reader was pushed on the stack
eInputReaderGotToken,   ///< reader got one of its tokens (granularity)
eInputReaderInterrupt, ///< reader received an interrupt signal (probably from
                       ///< a control-c)
eInputReaderEndOfFile, ///< reader received an EOF char (probably from a
                       ///< control-d)
eInputReaderDone       ///< reader was just popped off the stack and is done
399};

401FLAGS_ENUM(BreakpointEventType)enum BreakpointEventType : unsigned{
  eBreakpointEventTypeInvalidType = (1u << 0),
  eBreakpointEventTypeAdded = (1u << 1),
  eBreakpointEventTypeRemoved = (1u << 2),
  eBreakpointEventTypeLocationsAdded = (1u << 3), ///< Locations added doesn't
                                                  ///< get sent when the
                                                  ///< breakpoint is created
  eBreakpointEventTypeLocationsRemoved = (1u << 4),
  eBreakpointEventTypeLocationsResolved = (1u << 5),
  eBreakpointEventTypeEnabled = (1u << 6),
  eBreakpointEventTypeDisabled = (1u << 7),
  eBreakpointEventTypeCommandChanged = (1u << 8),
  eBreakpointEventTypeConditionChanged = (1u << 9),
  eBreakpointEventTypeIgnoreChanged = (1u << 10),
  eBreakpointEventTypeThreadChanged = (1u << 11),
  eBreakpointEventTypeAutoContinueChanged = (1u << 12)};

418FLAGS_ENUM(WatchpointEventType)enum WatchpointEventType : unsigned{
  eWatchpointEventTypeInvalidType = (1u << 0),
  eWatchpointEventTypeAdded = (1u << 1),
  eWatchpointEventTypeRemoved = (1u << 2),
  eWatchpointEventTypeEnabled = (1u << 6),
  eWatchpointEventTypeDisabled = (1u << 7),
  eWatchpointEventTypeCommandChanged = (1u << 8),
  eWatchpointEventTypeConditionChanged = (1u << 9),
  eWatchpointEventTypeIgnoreChanged = (1u << 10),
  eWatchpointEventTypeThreadChanged = (1u << 11),
  eWatchpointEventTypeTypeChanged = (1u << 12)};

430/// Programming language type.
431///
432/// These enumerations use the same language enumerations as the DWARF
433/// specification for ease of use and consistency.
434/// The enum -> string code is in Language.cpp, don't change this
435/// table without updating that code as well.
436enum LanguageType {
eLanguageTypeUnknown = 0x0000,        ///< Unknown or invalid language value.
eLanguageTypeC89 = 0x0001,            ///< ISO C:1989.
eLanguageTypeC = 0x0002,              ///< Non-standardized C, such as K&R.
eLanguageTypeAda83 = 0x0003,          ///< ISO Ada:1983.
eLanguageTypeC_plus_plus = 0x0004,    ///< ISO C++:1998.
eLanguageTypeCobol74 = 0x0005,        ///< ISO Cobol:1974.
eLanguageTypeCobol85 = 0x0006,        ///< ISO Cobol:1985.
eLanguageTypeFortran77 = 0x0007,      ///< ISO Fortran 77.
eLanguageTypeFortran90 = 0x0008,      ///< ISO Fortran 90.
eLanguageTypePascal83 = 0x0009,       ///< ISO Pascal:1983.
eLanguageTypeModula2 = 0x000a,        ///< ISO Modula-2:1996.
eLanguageTypeJava = 0x000b,           ///< Java.
eLanguageTypeC99 = 0x000c,            ///< ISO C:1999.
eLanguageTypeAda95 = 0x000d,          ///< ISO Ada:1995.
eLanguageTypeFortran95 = 0x000e,      ///< ISO Fortran 95.
eLanguageTypePLI = 0x000f,            ///< ANSI PL/I:1976.
eLanguageTypeObjC = 0x0010,           ///< Objective-C.
eLanguageTypeObjC_plus_plus = 0x0011, ///< Objective-C++.
eLanguageTypeUPC = 0x0012,            ///< Unified Parallel C.
eLanguageTypeD = 0x0013,              ///< D.
eLanguageTypePython = 0x0014,         ///< Python.
// NOTE: The below are DWARF5 constants, subject to change upon
// completion of the DWARF5 specification
eLanguageTypeOpenCL = 0x0015,         ///< OpenCL.
eLanguageTypeGo = 0x0016,             ///< Go.
eLanguageTypeModula3 = 0x0017,        ///< Modula 3.
eLanguageTypeHaskell = 0x0018,        ///< Haskell.
eLanguageTypeC_plus_plus_03 = 0x0019, ///< ISO C++:2003.
eLanguageTypeC_plus_plus_11 = 0x001a, ///< ISO C++:2011.
eLanguageTypeOCaml = 0x001b,          ///< OCaml.
eLanguageTypeRust = 0x001c,           ///< Rust.
eLanguageTypeC11 = 0x001d,            ///< ISO C:2011.
eLanguageTypeSwift = 0x001e,          ///< Swift.
eLanguageTypeJulia = 0x001f,          ///< Julia.
eLanguageTypeDylan = 0x0020,          ///< Dylan.
eLanguageTypeC_plus_plus_14 = 0x0021, ///< ISO C++:2014.
eLanguageTypeFortran03 = 0x0022,      ///< ISO Fortran 2003.
eLanguageTypeFortran08 = 0x0023,      ///< ISO Fortran 2008.
// Vendor Extensions
// Note: Language::GetNameForLanguageType
// assumes these can be used as indexes into array language_names, and
// Language::SetLanguageFromCString and Language::AsCString assume these can
// be used as indexes into array g_languages.
eLanguageTypeMipsAssembler = 0x0024,   ///< Mips_Assembler.
eLanguageTypeExtRenderScript = 0x0025, ///< RenderScript.
eNumLanguageTypes
483};

485enum InstrumentationRuntimeType {
eInstrumentationRuntimeTypeAddressSanitizer = 0x0000,
eInstrumentationRuntimeTypeThreadSanitizer = 0x0001,
eInstrumentationRuntimeTypeUndefinedBehaviorSanitizer = 0x0002,
eInstrumentationRuntimeTypeMainThreadChecker = 0x0003,
eInstrumentationRuntimeTypeSwiftRuntimeReporting = 0x0004,
eNumInstrumentationRuntimeTypes
492};

494enum DynamicValueType {
eNoDynamicValues = 0,
eDynamicCanRunTarget = 1,
eDynamicDontRunTarget = 2
498};

500enum StopShowColumn {
eStopShowColumnAnsiOrCaret = 0,
eStopShowColumnAnsi = 1,
eStopShowColumnCaret = 2,
eStopShowColumnNone = 3
505};

507enum AccessType {
eAccessNone,
eAccessPublic,
eAccessPrivate,
eAccessProtected,
eAccessPackage
513};

515enum CommandArgumentType {
eArgTypeAddress = 0,
eArgTypeAddressOrExpression,
eArgTypeAliasName,
eArgTypeAliasOptions,
eArgTypeArchitecture,
eArgTypeBoolean,
eArgTypeBreakpointID,
eArgTypeBreakpointIDRange,
eArgTypeBreakpointName,
eArgTypeByteSize,
eArgTypeClassName,
eArgTypeCommandName,
eArgTypeCount,
eArgTypeDescriptionVerbosity,
eArgTypeDirectoryName,
eArgTypeDisassemblyFlavor,
eArgTypeEndAddress,
eArgTypeExpression,
eArgTypeExpressionPath,
eArgTypeExprFormat,
eArgTypeFileLineColumn,
eArgTypeFilename,
eArgTypeFormat,
eArgTypeFrameIndex,
eArgTypeFullName,
eArgTypeFunctionName,
eArgTypeFunctionOrSymbol,
eArgTypeGDBFormat,
eArgTypeHelpText,
eArgTypeIndex,
eArgTypeLanguage,
eArgTypeLineNum,
eArgTypeLogCategory,
eArgTypeLogChannel,
eArgTypeMethod,
eArgTypeName,
eArgTypeNewPathPrefix,
eArgTypeNumLines,
eArgTypeNumberPerLine,
eArgTypeOffset,
eArgTypeOldPathPrefix,
eArgTypeOneLiner,
eArgTypePath,
eArgTypePermissionsNumber,
eArgTypePermissionsString,
eArgTypePid,
eArgTypePlugin,
eArgTypeProcessName,
eArgTypePythonClass,
eArgTypePythonFunction,
eArgTypePythonScript,
eArgTypeQueueName,
eArgTypeRegisterName,
eArgTypeRegularExpression,
eArgTypeRunArgs,
eArgTypeRunMode,
eArgTypeScriptedCommandSynchronicity,
eArgTypeScriptLang,
eArgTypeSearchWord,
eArgTypeSelector,
eArgTypeSettingIndex,
eArgTypeSettingKey,
eArgTypeSettingPrefix,
eArgTypeSettingVariableName,
eArgTypeShlibName,
eArgTypeSourceFile,
eArgTypeSortOrder,
eArgTypeStartAddress,
eArgTypeSummaryString,
eArgTypeSymbol,
eArgTypeThreadID,
eArgTypeThreadIndex,
eArgTypeThreadName,
eArgTypeTypeName,
eArgTypeUnsignedInteger,
eArgTypeUnixSignal,
eArgTypeVarName,
eArgTypeValue,
eArgTypeWidth,
eArgTypeNone,
eArgTypePlatform,
eArgTypeWatchpointID,
eArgTypeWatchpointIDRange,
eArgTypeWatchType,
eArgRawInput,
eArgTypeCommand,
eArgTypeColumnNum,
eArgTypeModuleUUID,
eArgTypeSaveCoreStyle,
eArgTypeLastArg // Always keep this entry as the last entry in this
                // enumeration!!
607};

609/// Symbol types.
610// Symbol holds the SymbolType in a 6-bit field (m_type), so if you get over 63
611// entries you will have to resize that field.
612enum SymbolType {
eSymbolTypeAny = 0,
eSymbolTypeInvalid = 0,
eSymbolTypeAbsolute,
eSymbolTypeCode,
eSymbolTypeResolver,
eSymbolTypeData,
eSymbolTypeTrampoline,
eSymbolTypeRuntime,
eSymbolTypeException,
eSymbolTypeSourceFile,
eSymbolTypeHeaderFile,
eSymbolTypeObjectFile,
eSymbolTypeCommonBlock,
eSymbolTypeBlock,
eSymbolTypeLocal,
eSymbolTypeParam,
eSymbolTypeVariable,
eSymbolTypeVariableType,
eSymbolTypeLineEntry,
eSymbolTypeLineHeader,
eSymbolTypeScopeBegin,
eSymbolTypeScopeEnd,
eSymbolTypeAdditional, ///< When symbols take more than one entry, the extra
                       ///< entries get this type
eSymbolTypeCompiler,
eSymbolTypeInstrumentation,
eSymbolTypeUndefined,
eSymbolTypeObjCClass,
eSymbolTypeObjCMetaClass,
eSymbolTypeObjCIVar,
eSymbolTypeReExported
644};

646enum SectionType {
eSectionTypeInvalid,
eSectionTypeCode,
eSectionTypeContainer, ///< The section contains child sections
eSectionTypeData,
eSectionTypeDataCString,         ///< Inlined C string data
eSectionTypeDataCStringPointers, ///< Pointers to C string data
eSectionTypeDataSymbolAddress,   ///< Address of a symbol in the symbol table
eSectionTypeData4,
eSectionTypeData8,
eSectionTypeData16,
eSectionTypeDataPointers,
eSectionTypeDebug,
eSectionTypeZeroFill,
eSectionTypeDataObjCMessageRefs, ///< Pointer to function pointer + selector
eSectionTypeDataObjCCFStrings,   ///< Objective-C const CFString/NSString
                                 ///< objects
eSectionTypeDWARFDebugAbbrev,
eSectionTypeDWARFDebugAddr,
eSectionTypeDWARFDebugAranges,
eSectionTypeDWARFDebugCuIndex,
eSectionTypeDWARFDebugFrame,
eSectionTypeDWARFDebugInfo,
eSectionTypeDWARFDebugLine,
eSectionTypeDWARFDebugLoc,
eSectionTypeDWARFDebugMacInfo,
eSectionTypeDWARFDebugMacro,
eSectionTypeDWARFDebugPubNames,
eSectionTypeDWARFDebugPubTypes,
eSectionTypeDWARFDebugRanges,
eSectionTypeDWARFDebugStr,
eSectionTypeDWARFDebugStrOffsets,
eSectionTypeDWARFAppleNames,
eSectionTypeDWARFAppleTypes,
eSectionTypeDWARFAppleNamespaces,
eSectionTypeDWARFAppleObjC,
eSectionTypeELFSymbolTable,       ///< Elf SHT_SYMTAB section
eSectionTypeELFDynamicSymbols,    ///< Elf SHT_DYNSYM section
eSectionTypeELFRelocationEntries, ///< Elf SHT_REL or SHT_REL section
eSectionTypeELFDynamicLinkInfo,   ///< Elf SHT_DYNAMIC section
eSectionTypeEHFrame,
eSectionTypeARMexidx,
eSectionTypeARMextab,
eSectionTypeCompactUnwind, ///< compact unwind section in Mach-O,
                           ///< __TEXT,__unwind_info
eSectionTypeGoSymtab,
eSectionTypeAbsoluteAddress, ///< Dummy section for symbols with absolute
                             ///< address
eSectionTypeDWARFGNUDebugAltLink,
eSectionTypeDWARFDebugTypes, ///< DWARF .debug_types section
eSectionTypeDWARFDebugNames, ///< DWARF v5 .debug_names
eSectionTypeOther,
eSectionTypeDWARFDebugLineStr,  ///< DWARF v5 .debug_line_str
eSectionTypeDWARFDebugRngLists, ///< DWARF v5 .debug_rnglists
eSectionTypeDWARFDebugLocLists, ///< DWARF v5 .debug_loclists
eSectionTypeDWARFDebugAbbrevDwo,
eSectionTypeDWARFDebugInfoDwo,
eSectionTypeDWARFDebugStrDwo,
eSectionTypeDWARFDebugStrOffsetsDwo,
eSectionTypeDWARFDebugTypesDwo,
eSectionTypeDWARFDebugRngListsDwo,
eSectionTypeDWARFDebugLocDwo,
eSectionTypeDWARFDebugLocListsDwo,
eSectionTypeDWARFDebugTuIndex,
710};

712FLAGS_ENUM(EmulateInstructionOptions)enum EmulateInstructionOptions : unsigned{
  eEmulateInstructionOptionNone = (0u),
  eEmulateInstructionOptionAutoAdvancePC = (1u << 0),
  eEmulateInstructionOptionIgnoreConditions = (1u << 1)};

717FLAGS_ENUM(FunctionNameType)enum FunctionNameType : unsigned{
  eFunctionNameTypeNone = 0u,
  eFunctionNameTypeAuto =
      (1u << 1), ///< Automatically figure out which FunctionNameType
                 ///< bits to set based on the function name.
  eFunctionNameTypeFull = (1u << 2), ///< The function name.
  ///< For C this is the same as just the name of the function For C++ this is
  ///< the mangled or demangled version of the mangled name. For ObjC this is
  ///< the full function signature with the + or - and the square brackets and
  ///< the class and selector
  eFunctionNameTypeBase = (1u
                           << 3), ///< The function name only, no namespaces
                                  ///< or arguments and no class
                                  ///< methods or selectors will be searched.
  eFunctionNameTypeMethod = (1u << 4), ///< Find function by method name (C++)
                                       ///< with no namespace or arguments
  eFunctionNameTypeSelector =
      (1u << 5), ///< Find function by selector name (ObjC) names
  eFunctionNameTypeAny =
      eFunctionNameTypeAuto ///< DEPRECATED: use eFunctionNameTypeAuto
737};
738LLDB_MARK_AS_BITMASK_ENUM(FunctionNameType)constexpr FunctionNameType operator|(FunctionNameType a, FunctionNameType
 b) { return static_cast<FunctionNameType>( static_cast
<std::underlying_type<FunctionNameType>::type>(a)
 | static_cast<std::underlying_type<FunctionNameType>
::type>(b)); } constexpr FunctionNameType operator&(FunctionNameType
 a, FunctionNameType b) { return static_cast<FunctionNameType
>( static_cast<std::underlying_type<FunctionNameType
>::type>(a) & static_cast<std::underlying_type<
FunctionNameType>::type>(b)); } constexpr FunctionNameType
 operator~(FunctionNameType a) { return static_cast<FunctionNameType
>( ~static_cast<std::underlying_type<FunctionNameType
>::type>(a)); } inline FunctionNameType &operator|=
(FunctionNameType &a, FunctionNameType b) { a = a | b; return
 a; } inline FunctionNameType &operator&=(FunctionNameType
 &a, FunctionNameType b) { a = a & b; return a; }

740/// Basic types enumeration for the public API SBType::GetBasicType().
741enum BasicType {
eBasicTypeInvalid = 0,
eBasicTypeVoid = 1,
eBasicTypeChar,
eBasicTypeSignedChar,
eBasicTypeUnsignedChar,
eBasicTypeWChar,
eBasicTypeSignedWChar,
eBasicTypeUnsignedWChar,
eBasicTypeChar16,
eBasicTypeChar32,
eBasicTypeShort,
eBasicTypeUnsignedShort,
eBasicTypeInt,
eBasicTypeUnsignedInt,
eBasicTypeLong,
eBasicTypeUnsignedLong,
eBasicTypeLongLong,
eBasicTypeUnsignedLongLong,
eBasicTypeInt128,
eBasicTypeUnsignedInt128,
eBasicTypeBool,
eBasicTypeHalf,
eBasicTypeFloat,
eBasicTypeDouble,
eBasicTypeLongDouble,
eBasicTypeFloatComplex,
eBasicTypeDoubleComplex,
eBasicTypeLongDoubleComplex,
eBasicTypeObjCID,
eBasicTypeObjCClass,
eBasicTypeObjCSel,
eBasicTypeNullPtr,
eBasicTypeOther
775};

777/// Deprecated
778enum TraceType {
eTraceTypeNone = 0,

/// Intel Processor Trace
eTraceTypeProcessorTrace
783};

785enum StructuredDataType {
eStructuredDataTypeInvalid = -1,
eStructuredDataTypeNull = 0,
eStructuredDataTypeGeneric,
eStructuredDataTypeArray,
eStructuredDataTypeInteger,
eStructuredDataTypeFloat,
eStructuredDataTypeBoolean,
eStructuredDataTypeString,
eStructuredDataTypeDictionary
795};

797FLAGS_ENUM(TypeClass)enum TypeClass : unsigned{
  eTypeClassInvalid = (0u), eTypeClassArray = (1u << 0),
  eTypeClassBlockPointer = (1u << 1), eTypeClassBuiltin = (1u << 2),
  eTypeClassClass = (1u << 3), eTypeClassComplexFloat = (1u << 4),
  eTypeClassComplexInteger = (1u << 5), eTypeClassEnumeration = (1u << 6),
  eTypeClassFunction = (1u << 7), eTypeClassMemberPointer = (1u << 8),
  eTypeClassObjCObject = (1u << 9), eTypeClassObjCInterface = (1u << 10),
  eTypeClassObjCObjectPointer = (1u << 11), eTypeClassPointer = (1u << 12),
  eTypeClassReference = (1u << 13), eTypeClassStruct = (1u << 14),
  eTypeClassTypedef = (1u << 15), eTypeClassUnion = (1u << 16),
  eTypeClassVector = (1u << 17),
  // Define the last type class as the MSBit of a 32 bit value
  eTypeClassOther = (1u << 31),
  // Define a mask that can be used for any type when finding types
  eTypeClassAny = (0xffffffffu)};
812LLDB_MARK_AS_BITMASK_ENUM(TypeClass)constexpr TypeClass operator|(TypeClass a, TypeClass b) { return
 static_cast<TypeClass>( static_cast<std::underlying_type
<TypeClass>::type>(a) | static_cast<std::underlying_type
<TypeClass>::type>(b)); } constexpr TypeClass operator
&(TypeClass a, TypeClass b) { return static_cast<TypeClass
>( static_cast<std::underlying_type<TypeClass>::type
>(a) & static_cast<std::underlying_type<TypeClass
>::type>(b)); } constexpr TypeClass operator~(TypeClass
 a) { return static_cast<TypeClass>( ~static_cast<std
::underlying_type<TypeClass>::type>(a)); } inline TypeClass
 &operator|=(TypeClass &a, TypeClass b) { a = a | b; return
 a; } inline TypeClass &operator&=(TypeClass &a, TypeClass
 b) { a = a & b; return a; }

814enum TemplateArgumentKind {
eTemplateArgumentKindNull = 0,
eTemplateArgumentKindType,
eTemplateArgumentKindDeclaration,
eTemplateArgumentKindIntegral,
eTemplateArgumentKindTemplate,
eTemplateArgumentKindTemplateExpansion,
eTemplateArgumentKindExpression,
eTemplateArgumentKindPack,
eTemplateArgumentKindNullPtr,
824};

826/// Options that can be set for a formatter to alter its behavior. Not
827/// all of these are applicable to all formatter types.
828FLAGS_ENUM(TypeOptions)enum TypeOptions : unsigned{eTypeOptionNone = (0u),
                      eTypeOptionCascade = (1u << 0),
                      eTypeOptionSkipPointers = (1u << 1),
                      eTypeOptionSkipReferences = (1u << 2),
                      eTypeOptionHideChildren = (1u << 3),
                      eTypeOptionHideValue = (1u << 4),
                      eTypeOptionShowOneLiner = (1u << 5),
                      eTypeOptionHideNames = (1u << 6),
                      eTypeOptionNonCacheable = (1u << 7),
                      eTypeOptionHideEmptyAggregates = (1u << 8),
                      eTypeOptionFrontEndWantsDereference = (1u << 9)};

840/// This is the return value for frame comparisons.  If you are comparing frame
841/// A to frame B the following cases arise:
842///
843///    1) When frame A pushes frame B (or a frame that ends up pushing
844///       B) A is Older than B.
845///
846///    2) When frame A pushed frame B (or if frameA is on the stack
847///       but B is not) A is Younger than B.
848///
849///    3) When frame A and frame B have the same StackID, they are
850///       Equal.
851///
852///    4) When frame A and frame B have the same immediate parent
853///       frame, but are not equal, the comparison yields SameParent.
854///
855///    5) If the two frames are on different threads or processes the
856///       comparison is Invalid.
857///
858///    6) If for some reason we can't figure out what went on, we
859///       return Unknown.
860enum FrameComparison {
eFrameCompareInvalid,
eFrameCompareUnknown,
eFrameCompareEqual,
eFrameCompareSameParent,
eFrameCompareYounger,
eFrameCompareOlder
867};

869/// File Permissions.
870///
871/// Designed to mimic the unix file permission bits so they can be used with
872/// functions that set 'mode_t' to certain values for permissions.
873FLAGS_ENUM(FilePermissions)enum FilePermissions : unsigned{
  eFilePermissionsUserRead = (1u << 8),
  eFilePermissionsUserWrite = (1u << 7),
  eFilePermissionsUserExecute = (1u << 6),
  eFilePermissionsGroupRead = (1u << 5),
  eFilePermissionsGroupWrite = (1u << 4),
  eFilePermissionsGroupExecute = (1u << 3),
  eFilePermissionsWorldRead = (1u << 2),
  eFilePermissionsWorldWrite = (1u << 1),
  eFilePermissionsWorldExecute = (1u << 0),

  eFilePermissionsUserRW = (eFilePermissionsUserRead |
                            eFilePermissionsUserWrite | 0),
  eFileFilePermissionsUserRX = (eFilePermissionsUserRead | 0 |
                                eFilePermissionsUserExecute),
  eFilePermissionsUserRWX = (eFilePermissionsUserRead |
                             eFilePermissionsUserWrite |
                             eFilePermissionsUserExecute),

  eFilePermissionsGroupRW = (eFilePermissionsGroupRead |
                             eFilePermissionsGroupWrite | 0),
  eFilePermissionsGroupRX = (eFilePermissionsGroupRead | 0 |
                             eFilePermissionsGroupExecute),
  eFilePermissionsGroupRWX = (eFilePermissionsGroupRead |
                              eFilePermissionsGroupWrite |
                              eFilePermissionsGroupExecute),

  eFilePermissionsWorldRW = (eFilePermissionsWorldRead |
                             eFilePermissionsWorldWrite | 0),
  eFilePermissionsWorldRX = (eFilePermissionsWorldRead | 0 |
                             eFilePermissionsWorldExecute),
  eFilePermissionsWorldRWX = (eFilePermissionsWorldRead |
                              eFilePermissionsWorldWrite |
                              eFilePermissionsWorldExecute),

  eFilePermissionsEveryoneR = (eFilePermissionsUserRead |
                               eFilePermissionsGroupRead |
                               eFilePermissionsWorldRead),
  eFilePermissionsEveryoneW = (eFilePermissionsUserWrite |
                               eFilePermissionsGroupWrite |
                               eFilePermissionsWorldWrite),
  eFilePermissionsEveryoneX = (eFilePermissionsUserExecute |
                               eFilePermissionsGroupExecute |
                               eFilePermissionsWorldExecute),

  eFilePermissionsEveryoneRW = (eFilePermissionsEveryoneR |
                                eFilePermissionsEveryoneW | 0),
  eFilePermissionsEveryoneRX = (eFilePermissionsEveryoneR | 0 |
                                eFilePermissionsEveryoneX),
  eFilePermissionsEveryoneRWX = (eFilePermissionsEveryoneR |
                                 eFilePermissionsEveryoneW |
                                 eFilePermissionsEveryoneX),
  eFilePermissionsFileDefault = eFilePermissionsUserRW,
  eFilePermissionsDirectoryDefault = eFilePermissionsUserRWX,
927};

929/// Queue work item types.
930///
931/// The different types of work that can be enqueued on a libdispatch aka Grand
932/// Central Dispatch (GCD) queue.
933enum QueueItemKind {
eQueueItemKindUnknown = 0,
eQueueItemKindFunction,
eQueueItemKindBlock
937};

939/// Queue type.
940///
941/// libdispatch aka Grand Central Dispatch (GCD) queues can be either
942/// serial (executing on one thread) or concurrent (executing on
943/// multiple threads).
944enum QueueKind {
eQueueKindUnknown = 0,
eQueueKindSerial,
eQueueKindConcurrent
948};

950/// Expression Evaluation Stages.
951///
952/// These are the cancellable stages of expression evaluation, passed
953/// to the expression evaluation callback, so that you can interrupt
954/// expression evaluation at the various points in its lifecycle.
955enum ExpressionEvaluationPhase {
eExpressionEvaluationParse = 0,
eExpressionEvaluationIRGen,
eExpressionEvaluationExecution,
eExpressionEvaluationComplete
960};

962/// Architecture-agnostic categorization of instructions for traversing the
963/// control flow of a trace.
964///
965/// A single instruction can match one or more of these categories.
966FLAGS_ENUM(TraceInstructionControlFlowType)enum TraceInstructionControlFlowType : unsigned{
  /// Any instruction.
  eTraceInstructionControlFlowTypeInstruction = (1u << 1),
  /// A conditional or unconditional branch/jump.
  eTraceInstructionControlFlowTypeBranch = (1u << 2),
  /// A conditional or unconditional branch/jump that changed
  /// the control flow of the program.
  eTraceInstructionControlFlowTypeTakenBranch = (1u << 3),
  /// A call to a function.
  eTraceInstructionControlFlowTypeCall = (1u << 4),
  /// A return from a function.
  eTraceInstructionControlFlowTypeReturn = (1u << 5)};

979LLDB_MARK_AS_BITMASK_ENUM(TraceInstructionControlFlowType)constexpr TraceInstructionControlFlowType operator|(TraceInstructionControlFlowType
 a, TraceInstructionControlFlowType b) { return static_cast<
TraceInstructionControlFlowType>( static_cast<std::underlying_type
<TraceInstructionControlFlowType>::type>(a) | static_cast
<std::underlying_type<TraceInstructionControlFlowType>
::type>(b)); } constexpr TraceInstructionControlFlowType operator
&(TraceInstructionControlFlowType a, TraceInstructionControlFlowType
 b) { return static_cast<TraceInstructionControlFlowType>
( static_cast<std::underlying_type<TraceInstructionControlFlowType
>::type>(a) & static_cast<std::underlying_type<
TraceInstructionControlFlowType>::type>(b)); } constexpr
 TraceInstructionControlFlowType operator~(TraceInstructionControlFlowType
 a) { return static_cast<TraceInstructionControlFlowType>
( ~static_cast<std::underlying_type<TraceInstructionControlFlowType
>::type>(a)); } inline TraceInstructionControlFlowType &
operator|=(TraceInstructionControlFlowType &a, TraceInstructionControlFlowType
 b) { a = a | b; return a; } inline TraceInstructionControlFlowType
 &operator&=(TraceInstructionControlFlowType &a, TraceInstructionControlFlowType
 b) { a = a & b; return a; }

981/// Watchpoint Kind.
982///
983/// Indicates what types of events cause the watchpoint to fire. Used by Native
984/// *Protocol-related classes.
985FLAGS_ENUM(WatchpointKind)enum WatchpointKind : unsigned{eWatchpointKindWrite = (1u << 0),
                         eWatchpointKindRead = (1u << 1)};

988enum GdbSignal {
eGdbSignalBadAccess = 0x91,
eGdbSignalBadInstruction = 0x92,
eGdbSignalArithmetic = 0x93,
eGdbSignalEmulation = 0x94,
eGdbSignalSoftware = 0x95,
eGdbSignalBreakpoint = 0x96
995};

997/// Used with SBHostOS::GetLLDBPath (lldb::PathType) to find files that are
998/// related to LLDB on the current host machine. Most files are
999/// relative to LLDB or are in known locations.
1000enum PathType {
ePathTypeLLDBShlibDir, ///< The directory where the lldb.so (unix) or LLDB
                       ///< mach-o file in LLDB.framework (MacOSX) exists
ePathTypeSupportExecutableDir, ///< Find LLDB support executable directory
                               ///< (debugserver, etc)
ePathTypeHeaderDir,            ///< Find LLDB header file directory
ePathTypePythonDir,            ///< Find Python modules (PYTHONPATH) directory
ePathTypeLLDBSystemPlugins,    ///< System plug-ins directory
ePathTypeLLDBUserPlugins,      ///< User plug-ins directory
ePathTypeLLDBTempSystemDir, ///< The LLDB temp directory for this system that
                            ///< will be cleaned up on exit
ePathTypeGlobalLLDBTempSystemDir, ///< The LLDB temp directory for this
                                  ///< system, NOT cleaned up on a process
                                  ///< exit.
ePathTypeClangDir ///< Find path to Clang builtin headers
1015};

1017/// Kind of member function.
1018///
1019/// Used by the type system.
1020enum MemberFunctionKind {
eMemberFunctionKindUnknown = 0,    ///< Not sure what the type of this is
eMemberFunctionKindConstructor,    ///< A function used to create instances
eMemberFunctionKindDestructor,     ///< A function used to tear down existing
                                   ///< instances
eMemberFunctionKindInstanceMethod, ///< A function that applies to a specific
                                   ///< instance
eMemberFunctionKindStaticMethod ///< A function that applies to a type rather
                                ///< than any instance
1029};

1031/// String matching algorithm used by SBTarget.
1032enum MatchType { eMatchTypeNormal, eMatchTypeRegex, eMatchTypeStartsWith };

1034/// Bitmask that describes details about a type.
1035FLAGS_ENUM(TypeFlags)enum TypeFlags : unsigned{
  eTypeHasChildren = (1u << 0),       eTypeHasValue = (1u << 1),
  eTypeIsArray = (1u << 2),           eTypeIsBlock = (1u << 3),
  eTypeIsBuiltIn = (1u << 4),         eTypeIsClass = (1u << 5),
  eTypeIsCPlusPlus = (1u << 6),       eTypeIsEnumeration = (1u << 7),
  eTypeIsFuncPrototype = (1u << 8),   eTypeIsMember = (1u << 9),
  eTypeIsObjC = (1u << 10),           eTypeIsPointer = (1u << 11),
  eTypeIsReference = (1u << 12),      eTypeIsStructUnion = (1u << 13),
  eTypeIsTemplate = (1u << 14),       eTypeIsTypedef = (1u << 15),
  eTypeIsVector = (1u << 16),         eTypeIsScalar = (1u << 17),
  eTypeIsInteger = (1u << 18),        eTypeIsFloat = (1u << 19),
  eTypeIsComplex = (1u << 20),        eTypeIsSigned = (1u << 21),
  eTypeInstanceIsPointer = (1u << 22)};

1049FLAGS_ENUM(CommandFlags)enum CommandFlags : unsigned{
  /// eCommandRequiresTarget
  ///
  /// Ensures a valid target is contained in m_exe_ctx prior to executing the
  /// command. If a target doesn't exist or is invalid, the command will fail
  /// and CommandObject::GetInvalidTargetDescription() will be returned as the
  /// error. CommandObject subclasses can override the virtual function for
  /// GetInvalidTargetDescription() to provide custom strings when needed.
  eCommandRequiresTarget = (1u << 0),
  /// eCommandRequiresProcess
  ///
  /// Ensures a valid process is contained in m_exe_ctx prior to executing the
  /// command. If a process doesn't exist or is invalid, the command will fail
  /// and CommandObject::GetInvalidProcessDescription() will be returned as
  /// the error. CommandObject subclasses can override the virtual function
  /// for GetInvalidProcessDescription() to provide custom strings when
  /// needed.
  eCommandRequiresProcess = (1u << 1),
  /// eCommandRequiresThread
  ///
  /// Ensures a valid thread is contained in m_exe_ctx prior to executing the
  /// command. If a thread doesn't exist or is invalid, the command will fail
  /// and CommandObject::GetInvalidThreadDescription() will be returned as the
  /// error. CommandObject subclasses can override the virtual function for
  /// GetInvalidThreadDescription() to provide custom strings when needed.
  eCommandRequiresThread = (1u << 2),
  /// eCommandRequiresFrame
  ///
  /// Ensures a valid frame is contained in m_exe_ctx prior to executing the
  /// command. If a frame doesn't exist or is invalid, the command will fail
  /// and CommandObject::GetInvalidFrameDescription() will be returned as the
  /// error. CommandObject subclasses can override the virtual function for
  /// GetInvalidFrameDescription() to provide custom strings when needed.
  eCommandRequiresFrame = (1u << 3),
  /// eCommandRequiresRegContext
  ///
  /// Ensures a valid register context (from the selected frame if there is a
  /// frame in m_exe_ctx, or from the selected thread from m_exe_ctx) is
  /// available from m_exe_ctx prior to executing the command. If a target
  /// doesn't exist or is invalid, the command will fail and
  /// CommandObject::GetInvalidRegContextDescription() will be returned as the
  /// error. CommandObject subclasses can override the virtual function for
  /// GetInvalidRegContextDescription() to provide custom strings when needed.
  eCommandRequiresRegContext = (1u << 4),
  /// eCommandTryTargetAPILock
  ///
  /// Attempts to acquire the target lock if a target is selected in the
  /// command interpreter. If the command object fails to acquire the API
  /// lock, the command will fail with an appropriate error message.
  eCommandTryTargetAPILock = (1u << 5),
  /// eCommandProcessMustBeLaunched
  ///
  /// Verifies that there is a launched process in m_exe_ctx, if there isn't,
  /// the command will fail with an appropriate error message.
  eCommandProcessMustBeLaunched = (1u << 6),
  /// eCommandProcessMustBePaused
  ///
  /// Verifies that there is a paused process in m_exe_ctx, if there isn't,
  /// the command will fail with an appropriate error message.
  eCommandProcessMustBePaused = (1u << 7),
  /// eCommandProcessMustBeTraced
  ///
  /// Verifies that the process is being traced by a Trace plug-in, if it
  /// isn't the command will fail with an appropriate error message.
  eCommandProcessMustBeTraced = (1u << 8)};

1115/// Whether a summary should cap how much data it returns to users or not.
1116enum TypeSummaryCapping {
eTypeSummaryCapped = true,
eTypeSummaryUncapped = false
1119};

1121/// The result from a command interpreter run.
1122enum CommandInterpreterResult {
/// Command interpreter finished successfully.
eCommandInterpreterResultSuccess,
/// Stopped because the corresponding option was set and the inferior
/// crashed.
eCommandInterpreterResultInferiorCrash,
/// Stopped because the corresponding option was set and a command returned
/// an error.
eCommandInterpreterResultCommandError,
/// Stopped because quit was requested.
eCommandInterpreterResultQuitRequested,
1133};

1135// Style of core file to create when calling SaveCore.
1136enum SaveCoreStyle {
eSaveCoreUnspecified = 0,
eSaveCoreFull = 1,
eSaveCoreDirtyOnly = 2,
1140};

1142} // namespace lldb

1144#endif // LLDB_LLDB_ENUMERATIONS_H

←

/usr/include/c++/v1/__memory/unique_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_UNIQUE_PTR_H
11#define _LIBCPP___MEMORY_UNIQUE_PTR_H
12 
13#include <__config>
14#include <__functional_base>
15#include <__functional/hash.h>
16#include <__functional/operations.h>
17#include <__memory/allocator_traits.h> // __pointer
18#include <__memory/compressed_pair.h>
19#include <__utility/forward.h>
20#include <cstddef>
21#include <type_traits>
22#include <utility>
23 
24#if _LIBCPP_STD_VER14 <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
25#   include <__memory/auto_ptr.h>
26#endif
27 
28#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
29#pragma GCC system_header
30#endif
31 
32_LIBCPP_PUSH_MACROSpush_macro("min")
 push_macro("max")
33#include <__undef_macros>
34 
35_LIBCPP_BEGIN_NAMESPACE_STDnamespace std { inline namespace __1 {
36 
37template <class _Tp>
38struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) default_delete {
39    static_assert(!is_function<_Tp>::value,
40                  "default_delete cannot be instantiated for function types");
41#ifndef _LIBCPP_CXX03_LANG
42  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
)) constexpr default_delete() _NOEXCEPTnoexcept = default;
43#else
44  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
)) default_delete() {}
45#endif
46  template <class _Up>
47  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
48  default_delete(const default_delete<_Up>&,
49                 typename enable_if<is_convertible<_Up*, _Tp*>::value>::type* =
50                     0) _NOEXCEPTnoexcept {}
51 
52  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
)) void operator()(_Tp* __ptr) const _NOEXCEPTnoexcept {
53    static_assert(sizeof(_Tp) > 0,
54                  "default_delete can not delete incomplete type");
55    static_assert(!is_void<_Tp>::value,
56                  "default_delete can not delete incomplete type");
57    delete __ptr;
58  }
59};
60 
61template <class _Tp>
62struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) default_delete<_Tp[]> {
63private:
64  template <class _Up>
65  struct _EnableIfConvertible
66      : enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value> {};
67 
68public:
69#ifndef _LIBCPP_CXX03_LANG
70  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
)) constexpr default_delete() _NOEXCEPTnoexcept = default;
71#else
72  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
)) default_delete() {}
73#endif
74 
75  template <class _Up>
76  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
77  default_delete(const default_delete<_Up[]>&,
78                 typename _EnableIfConvertible<_Up>::type* = 0) _NOEXCEPTnoexcept {}
79 
80  template <class _Up>
81  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
82  typename _EnableIfConvertible<_Up>::type
83  operator()(_Up* __ptr) const _NOEXCEPTnoexcept {
84    static_assert(sizeof(_Tp) > 0,
85                  "default_delete can not delete incomplete type");
86    static_assert(!is_void<_Tp>::value,
87                  "default_delete can not delete void type");
88    delete[] __ptr;
89  }
90};
91 
92template <class _Deleter>
93struct __unique_ptr_deleter_sfinae {
94  static_assert(!is_reference<_Deleter>::value, "incorrect specialization");
95  typedef const _Deleter& __lval_ref_type;
96  typedef _Deleter&& __good_rval_ref_type;
97  typedef true_type __enable_rval_overload;
98};
99 
100template <class _Deleter>
101struct __unique_ptr_deleter_sfinae<_Deleter const&> {
102  typedef const _Deleter& __lval_ref_type;
103  typedef const _Deleter&& __bad_rval_ref_type;
104  typedef false_type __enable_rval_overload;
105};
106 
107template <class _Deleter>
108struct __unique_ptr_deleter_sfinae<_Deleter&> {
109  typedef _Deleter& __lval_ref_type;
110  typedef _Deleter&& __bad_rval_ref_type;
111  typedef false_type __enable_rval_overload;
112};
113 
114#if defined(_LIBCPP_ABI_ENABLE_UNIQUE_PTR_TRIVIAL_ABI)
115#  define _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI __attribute__((trivial_abi))
116#else
117#  define _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI
118#endif
119 
120template <class _Tp, class _Dp = default_delete<_Tp> >
121class _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) unique_ptr {
122public:
123  typedef _Tp element_type;
124  typedef _Dp deleter_type;
125  typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) typename __pointer<_Tp, deleter_type>::type pointer;
126 
127  static_assert(!is_rvalue_reference<deleter_type>::value,
128                "the specified deleter type cannot be an rvalue reference");
129 
130private:
131  __compressed_pair<pointer, deleter_type> __ptr_;
132 
133  struct __nat { int __for_bool_; };
134 
135  typedef _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) __unique_ptr_deleter_sfinae<_Dp> _DeleterSFINAE;
136 
137  template <bool _Dummy>
138  using _LValRefType _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) =
139      typename __dependent_type<_DeleterSFINAE, _Dummy>::__lval_ref_type;
140 
141  template <bool _Dummy>
142  using _GoodRValRefType _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) =
143      typename __dependent_type<_DeleterSFINAE, _Dummy>::__good_rval_ref_type;
144 
145  template <bool _Dummy>
146  using _BadRValRefType _LIBCPP_NODEBUG_TYPE__attribute__((nodebug))  =
147      typename __dependent_type<_DeleterSFINAE, _Dummy>::__bad_rval_ref_type;
148 
149  template <bool _Dummy, class _Deleter = typename __dependent_type<
150                             __identity<deleter_type>, _Dummy>::type>
151  using _EnableIfDeleterDefaultConstructible _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) =
152      typename enable_if<is_default_constructible<_Deleter>::value &&
153                         !is_pointer<_Deleter>::value>::type;
154 
155  template <class _ArgType>
156  using _EnableIfDeleterConstructible _LIBCPP_NODEBUG_TYPE__attribute__((nodebug))  =
157      typename enable_if<is_constructible<deleter_type, _ArgType>::value>::type;
158 
159  template <class _UPtr, class _Up>
160  using _EnableIfMoveConvertible _LIBCPP_NODEBUG_TYPE__attribute__((nodebug))  = typename enable_if<
161      is_convertible<typename _UPtr::pointer, pointer>::value &&
162      !is_array<_Up>::value
163  >::type;
164 
165  template <class _UDel>
166  using _EnableIfDeleterConvertible _LIBCPP_NODEBUG_TYPE__attribute__((nodebug))  = typename enable_if<
167      (is_reference<_Dp>::value && is_same<_Dp, _UDel>::value) ||
168      (!is_reference<_Dp>::value && is_convertible<_UDel, _Dp>::value)
169    >::type;
170 
171  template <class _UDel>
172  using _EnableIfDeleterAssignable = typename enable_if<
173      is_assignable<_Dp&, _UDel&&>::value
174    >::type;
175 
176public:
177  template <bool _Dummy = true,
178            class = _EnableIfDeleterDefaultConstructible<_Dummy> >
179  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
180  _LIBCPP_CONSTEXPRconstexpr unique_ptr() _NOEXCEPTnoexcept : __ptr_(pointer(), __default_init_tag()) {}
181 
182  template <bool _Dummy = true,
183            class = _EnableIfDeleterDefaultConstructible<_Dummy> >
184  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
185  _LIBCPP_CONSTEXPRconstexpr unique_ptr(nullptr_t) _NOEXCEPTnoexcept : __ptr_(pointer(), __default_init_tag()) {}
186 
187  template <bool _Dummy = true,
188            class = _EnableIfDeleterDefaultConstructible<_Dummy> >
189  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
190  explicit unique_ptr(pointer __p) _NOEXCEPTnoexcept : __ptr_(__p, __default_init_tag()) {}
191 
192  template <bool _Dummy = true,
193            class = _EnableIfDeleterConstructible<_LValRefType<_Dummy> > >
194  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
195  unique_ptr(pointer __p, _LValRefType<_Dummy> __d) _NOEXCEPTnoexcept
196      : __ptr_(__p, __d) {}
197 
198  template <bool _Dummy = true,
199            class = _EnableIfDeleterConstructible<_GoodRValRefType<_Dummy> > >
200  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
201  unique_ptr(pointer __p, _GoodRValRefType<_Dummy> __d) _NOEXCEPTnoexcept
202      : __ptr_(__p, _VSTDstd::__1::move(__d)) {
203    static_assert(!is_reference<deleter_type>::value,
204                  "rvalue deleter bound to reference");
205  }
206 
207  template <bool _Dummy = true,
208            class = _EnableIfDeleterConstructible<_BadRValRefType<_Dummy> > >
209  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
210  unique_ptr(pointer __p, _BadRValRefType<_Dummy> __d) = delete;
211 
212  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
213  unique_ptr(unique_ptr&& __u) _NOEXCEPTnoexcept
214      : __ptr_(__u.release(), _VSTDstd::__1::forward<deleter_type>(__u.get_deleter())) {
215  }
216 
217  template <class _Up, class _Ep,
218      class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>,
219      class = _EnableIfDeleterConvertible<_Ep>
220  >
221  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
222  unique_ptr(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPTnoexcept
223      : __ptr_(__u.release(), _VSTDstd::__1::forward<_Ep>(__u.get_deleter())) {}
224 
225#if _LIBCPP_STD_VER14 <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
226  template <class _Up>
227  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
228  unique_ptr(auto_ptr<_Up>&& __p,
229             typename enable_if<is_convertible<_Up*, _Tp*>::value &&
230                                    is_same<_Dp, default_delete<_Tp> >::value,
231                                __nat>::type = __nat()) _NOEXCEPTnoexcept
232      : __ptr_(__p.release(), __default_init_tag()) {}
233#endif
234 
235  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
236  unique_ptr& operator=(unique_ptr&& __u) _NOEXCEPTnoexcept {
237    reset(__u.release());
238    __ptr_.second() = _VSTDstd::__1::forward<deleter_type>(__u.get_deleter());
239    return *this;
240  }
241 
242  template <class _Up, class _Ep,
243      class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>,
244      class = _EnableIfDeleterAssignable<_Ep>
245  >
246  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
247  unique_ptr& operator=(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPTnoexcept {
248    reset(__u.release());
249    __ptr_.second() = _VSTDstd::__1::forward<_Ep>(__u.get_deleter());
250    return *this;
251  }
252 
253#if _LIBCPP_STD_VER14 <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
254  template <class _Up>
255  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
256      typename enable_if<is_convertible<_Up*, _Tp*>::value &&
257                             is_same<_Dp, default_delete<_Tp> >::value,
258                         unique_ptr&>::type
259      operator=(auto_ptr<_Up> __p) {
260    reset(__p.release());
261    return *this;
262  }
263#endif
264 
265#ifdef _LIBCPP_CXX03_LANG
266  unique_ptr(unique_ptr const&) = delete;
267  unique_ptr& operator=(unique_ptr const&) = delete;
268#endif
269 
270 
271  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
272  ~unique_ptr() { reset(); }
273 
274  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
275  unique_ptr& operator=(nullptr_t) _NOEXCEPTnoexcept {
276    reset();
277    return *this;
278  }
279 
280  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
281  typename add_lvalue_reference<_Tp>::type
282  operator*() const {
283    return *__ptr_.first();
284  }
285  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
286  pointer operator->() const _NOEXCEPTnoexcept {
287    return __ptr_.first();
288  }
289  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
290  pointer get() const _NOEXCEPTnoexcept {
291    return __ptr_.first();
292  }
293  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
294  deleter_type& get_deleter() _NOEXCEPTnoexcept {
295    return __ptr_.second();
296  }
297  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
298  const deleter_type& get_deleter() const _NOEXCEPTnoexcept {
299    return __ptr_.second();
300  }
301  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
302  explicit operator bool() const _NOEXCEPTnoexcept {
303    return __ptr_.first() != nullptr;
15
←
Assuming the condition is true→
16
←
Returning the value 1, which participates in a condition later→
304  }
305 
306  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
307  pointer release() _NOEXCEPTnoexcept {
308    pointer __t = __ptr_.first();
309    __ptr_.first() = pointer();
310    return __t;
311  }
312 
313  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
314  void reset(pointer __p = pointer()) _NOEXCEPTnoexcept {
315    pointer __tmp = __ptr_.first();
316    __ptr_.first() = __p;
317    if (__tmp)
318      __ptr_.second()(__tmp);
319  }
320 
321  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
322  void swap(unique_ptr& __u) _NOEXCEPTnoexcept {
323    __ptr_.swap(__u.__ptr_);
324  }
325};
326 
327 
328template <class _Tp, class _Dp>
329class _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) unique_ptr<_Tp[], _Dp> {
330public:
331  typedef _Tp element_type;
332  typedef _Dp deleter_type;
333  typedef typename __pointer<_Tp, deleter_type>::type pointer;
334 
335private:
336  __compressed_pair<pointer, deleter_type> __ptr_;
337 
338  template <class _From>
339  struct _CheckArrayPointerConversion : is_same<_From, pointer> {};
340 
341  template <class _FromElem>
342  struct _CheckArrayPointerConversion<_FromElem*>
343      : integral_constant<bool,
344          is_same<_FromElem*, pointer>::value ||
345            (is_same<pointer, element_type*>::value &&
346             is_convertible<_FromElem(*)[], element_type(*)[]>::value)
347      >
348  {};
349 
350  typedef __unique_ptr_deleter_sfinae<_Dp> _DeleterSFINAE;
351 
352  template <bool _Dummy>
353  using _LValRefType _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) =
354      typename __dependent_type<_DeleterSFINAE, _Dummy>::__lval_ref_type;
355 
356  template <bool _Dummy>
357  using _GoodRValRefType _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) =
358      typename __dependent_type<_DeleterSFINAE, _Dummy>::__good_rval_ref_type;
359 
360  template <bool _Dummy>
361  using _BadRValRefType _LIBCPP_NODEBUG_TYPE__attribute__((nodebug)) =
362      typename __dependent_type<_DeleterSFINAE, _Dummy>::__bad_rval_ref_type;
363 
364  template <bool _Dummy, class _Deleter = typename __dependent_type<
365                             __identity<deleter_type>, _Dummy>::type>
366  using _EnableIfDeleterDefaultConstructible _LIBCPP_NODEBUG_TYPE__attribute__((nodebug))  =
367      typename enable_if<is_default_constructible<_Deleter>::value &&
368                         !is_pointer<_Deleter>::value>::type;
369 
370  template <class _ArgType>
371  using _EnableIfDeleterConstructible _LIBCPP_NODEBUG_TYPE__attribute__((nodebug))  =
372      typename enable_if<is_constructible<deleter_type, _ArgType>::value>::type;
373 
374  template <class _Pp>
375  using _EnableIfPointerConvertible _LIBCPP_NODEBUG_TYPE__attribute__((nodebug))  = typename enable_if<
376      _CheckArrayPointerConversion<_Pp>::value
377  >::type;
378 
379  template <class _UPtr, class _Up,
380        class _ElemT = typename _UPtr::element_type>
381  using _EnableIfMoveConvertible _LIBCPP_NODEBUG_TYPE__attribute__((nodebug))  = typename enable_if<
382      is_array<_Up>::value &&
383      is_same<pointer, element_type*>::value &&
384      is_same<typename _UPtr::pointer, _ElemT*>::value &&
385      is_convertible<_ElemT(*)[], element_type(*)[]>::value
386    >::type;
387 
388  template <class _UDel>
389  using _EnableIfDeleterConvertible _LIBCPP_NODEBUG_TYPE__attribute__((nodebug))  = typename enable_if<
390      (is_reference<_Dp>::value && is_same<_Dp, _UDel>::value) ||
391      (!is_reference<_Dp>::value && is_convertible<_UDel, _Dp>::value)
392    >::type;
393 
394  template <class _UDel>
395  using _EnableIfDeleterAssignable _LIBCPP_NODEBUG_TYPE__attribute__((nodebug))  = typename enable_if<
396      is_assignable<_Dp&, _UDel&&>::value
397    >::type;
398 
399public:
400  template <bool _Dummy = true,
401            class = _EnableIfDeleterDefaultConstructible<_Dummy> >
402  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
403  _LIBCPP_CONSTEXPRconstexpr unique_ptr() _NOEXCEPTnoexcept : __ptr_(pointer(), __default_init_tag()) {}
404 
405  template <bool _Dummy = true,
406            class = _EnableIfDeleterDefaultConstructible<_Dummy> >
407  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
408  _LIBCPP_CONSTEXPRconstexpr unique_ptr(nullptr_t) _NOEXCEPTnoexcept : __ptr_(pointer(), __default_init_tag()) {}
409 
410  template <class _Pp, bool _Dummy = true,
411            class = _EnableIfDeleterDefaultConstructible<_Dummy>,
412            class = _EnableIfPointerConvertible<_Pp> >
413  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
414  explicit unique_ptr(_Pp __p) _NOEXCEPTnoexcept
415      : __ptr_(__p, __default_init_tag()) {}
416 
417  template <class _Pp, bool _Dummy = true,
418            class = _EnableIfDeleterConstructible<_LValRefType<_Dummy> >,
419            class = _EnableIfPointerConvertible<_Pp> >
420  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
421  unique_ptr(_Pp __p, _LValRefType<_Dummy> __d) _NOEXCEPTnoexcept
422      : __ptr_(__p, __d) {}
423 
424  template <bool _Dummy = true,
425            class = _EnableIfDeleterConstructible<_LValRefType<_Dummy> > >
426  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
427  unique_ptr(nullptr_t, _LValRefType<_Dummy> __d) _NOEXCEPTnoexcept
428      : __ptr_(nullptr, __d) {}
429 
430  template <class _Pp, bool _Dummy = true,
431            class = _EnableIfDeleterConstructible<_GoodRValRefType<_Dummy> >,
432            class = _EnableIfPointerConvertible<_Pp> >
433  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
434  unique_ptr(_Pp __p, _GoodRValRefType<_Dummy> __d) _NOEXCEPTnoexcept
435      : __ptr_(__p, _VSTDstd::__1::move(__d)) {
436    static_assert(!is_reference<deleter_type>::value,
437                  "rvalue deleter bound to reference");
438  }
439 
440  template <bool _Dummy = true,
441            class = _EnableIfDeleterConstructible<_GoodRValRefType<_Dummy> > >
442  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
443  unique_ptr(nullptr_t, _GoodRValRefType<_Dummy> __d) _NOEXCEPTnoexcept
444      : __ptr_(nullptr, _VSTDstd::__1::move(__d)) {
445    static_assert(!is_reference<deleter_type>::value,
446                  "rvalue deleter bound to reference");
447  }
448 
449  template <class _Pp, bool _Dummy = true,
450            class = _EnableIfDeleterConstructible<_BadRValRefType<_Dummy> >,
451            class = _EnableIfPointerConvertible<_Pp> >
452  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
453  unique_ptr(_Pp __p, _BadRValRefType<_Dummy> __d) = delete;
454 
455  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
456  unique_ptr(unique_ptr&& __u) _NOEXCEPTnoexcept
457      : __ptr_(__u.release(), _VSTDstd::__1::forward<deleter_type>(__u.get_deleter())) {
458  }
459 
460  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
461  unique_ptr& operator=(unique_ptr&& __u) _NOEXCEPTnoexcept {
462    reset(__u.release());
463    __ptr_.second() = _VSTDstd::__1::forward<deleter_type>(__u.get_deleter());
464    return *this;
465  }
466 
467  template <class _Up, class _Ep,
468      class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>,
469      class = _EnableIfDeleterConvertible<_Ep>
470  >
471  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
472  unique_ptr(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPTnoexcept
473      : __ptr_(__u.release(), _VSTDstd::__1::forward<_Ep>(__u.get_deleter())) {
474  }
475 
476  template <class _Up, class _Ep,
477      class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>,
478      class = _EnableIfDeleterAssignable<_Ep>
479  >
480  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
481  unique_ptr&
482  operator=(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPTnoexcept {
483    reset(__u.release());
484    __ptr_.second() = _VSTDstd::__1::forward<_Ep>(__u.get_deleter());
485    return *this;
486  }
487 
488#ifdef _LIBCPP_CXX03_LANG
489  unique_ptr(unique_ptr const&) = delete;
490  unique_ptr& operator=(unique_ptr const&) = delete;
491#endif
492 
493public:
494  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
495  ~unique_ptr() { reset(); }
496 
497  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
498  unique_ptr& operator=(nullptr_t) _NOEXCEPTnoexcept {
499    reset();
500    return *this;
501  }
502 
503  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
504  typename add_lvalue_reference<_Tp>::type
505  operator[](size_t __i) const {
506    return __ptr_.first()[__i];
507  }
508  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
509  pointer get() const _NOEXCEPTnoexcept {
510    return __ptr_.first();
511  }
512 
513  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
514  deleter_type& get_deleter() _NOEXCEPTnoexcept {
515    return __ptr_.second();
516  }
517 
518  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
519  const deleter_type& get_deleter() const _NOEXCEPTnoexcept {
520    return __ptr_.second();
521  }
522  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
523  explicit operator bool() const _NOEXCEPTnoexcept {
524    return __ptr_.first() != nullptr;
525  }
526 
527  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
528  pointer release() _NOEXCEPTnoexcept {
529    pointer __t = __ptr_.first();
530    __ptr_.first() = pointer();
531    return __t;
532  }
533 
534  template <class _Pp>
535  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
536  typename enable_if<
537      _CheckArrayPointerConversion<_Pp>::value
538  >::type
539  reset(_Pp __p) _NOEXCEPTnoexcept {
540    pointer __tmp = __ptr_.first();
541    __ptr_.first() = __p;
542    if (__tmp)
543      __ptr_.second()(__tmp);
544  }
545 
546  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
547  void reset(nullptr_t = nullptr) _NOEXCEPTnoexcept {
548    pointer __tmp = __ptr_.first();
549    __ptr_.first() = nullptr;
550    if (__tmp)
551      __ptr_.second()(__tmp);
552  }
553 
554  _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
555  void swap(unique_ptr& __u) _NOEXCEPTnoexcept {
556    __ptr_.swap(__u.__ptr_);
557  }
558 
559};
560 
561template <class _Tp, class _Dp>
562inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
563typename enable_if<
564    __is_swappable<_Dp>::value,
565    void
566>::type
567swap(unique_ptr<_Tp, _Dp>& __x, unique_ptr<_Tp, _Dp>& __y) _NOEXCEPTnoexcept {__x.swap(__y);}
568 
569template <class _T1, class _D1, class _T2, class _D2>
570inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
571bool
572operator==(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return __x.get() == __y.get();}
573 
574template <class _T1, class _D1, class _T2, class _D2>
575inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
576bool
577operator!=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__x == __y);}
578 
579template <class _T1, class _D1, class _T2, class _D2>
580inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
581bool
582operator< (const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y)
583{
584    typedef typename unique_ptr<_T1, _D1>::pointer _P1;
585    typedef typename unique_ptr<_T2, _D2>::pointer _P2;
586    typedef typename common_type<_P1, _P2>::type _Vp;
587    return less<_Vp>()(__x.get(), __y.get());
588}
589 
590template <class _T1, class _D1, class _T2, class _D2>
591inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
592bool
593operator> (const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return __y < __x;}
594 
595template <class _T1, class _D1, class _T2, class _D2>
596inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
597bool
598operator<=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__y < __x);}
599 
600template <class _T1, class _D1, class _T2, class _D2>
601inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
602bool
603operator>=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__x < __y);}
604 
605template <class _T1, class _D1>
606inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
607bool
608operator==(const unique_ptr<_T1, _D1>& __x, nullptr_t) _NOEXCEPTnoexcept
609{
610    return !__x;
611}
612 
613template <class _T1, class _D1>
614inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
615bool
616operator==(nullptr_t, const unique_ptr<_T1, _D1>& __x) _NOEXCEPTnoexcept
617{
618    return !__x;
619}
620 
621template <class _T1, class _D1>
622inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
623bool
624operator!=(const unique_ptr<_T1, _D1>& __x, nullptr_t) _NOEXCEPTnoexcept
625{
626    return static_cast<bool>(__x);
627}
628 
629template <class _T1, class _D1>
630inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
631bool
632operator!=(nullptr_t, const unique_ptr<_T1, _D1>& __x) _NOEXCEPTnoexcept
633{
634    return static_cast<bool>(__x);
635}
636 
637template <class _T1, class _D1>
638inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
639bool
640operator<(const unique_ptr<_T1, _D1>& __x, nullptr_t)
641{
642    typedef typename unique_ptr<_T1, _D1>::pointer _P1;
643    return less<_P1>()(__x.get(), nullptr);
644}
645 
646template <class _T1, class _D1>
647inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
648bool
649operator<(nullptr_t, const unique_ptr<_T1, _D1>& __x)
650{
651    typedef typename unique_ptr<_T1, _D1>::pointer _P1;
652    return less<_P1>()(nullptr, __x.get());
653}
654 
655template <class _T1, class _D1>
656inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
657bool
658operator>(const unique_ptr<_T1, _D1>& __x, nullptr_t)
659{
660    return nullptr < __x;
661}
662 
663template <class _T1, class _D1>
664inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
665bool
666operator>(nullptr_t, const unique_ptr<_T1, _D1>& __x)
667{
668    return __x < nullptr;
669}
670 
671template <class _T1, class _D1>
672inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
673bool
674operator<=(const unique_ptr<_T1, _D1>& __x, nullptr_t)
675{
676    return !(nullptr < __x);
677}
678 
679template <class _T1, class _D1>
680inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
681bool
682operator<=(nullptr_t, const unique_ptr<_T1, _D1>& __x)
683{
684    return !(__x < nullptr);
685}
686 
687template <class _T1, class _D1>
688inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
689bool
690operator>=(const unique_ptr<_T1, _D1>& __x, nullptr_t)
691{
692    return !(__x < nullptr);
693}
694 
695template <class _T1, class _D1>
696inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
697bool
698operator>=(nullptr_t, const unique_ptr<_T1, _D1>& __x)
699{
700    return !(nullptr < __x);
701}
702 
703#if _LIBCPP_STD_VER14 > 11
704 
705template<class _Tp>
706struct __unique_if
707{
708    typedef unique_ptr<_Tp> __unique_single;
709};
710 
711template<class _Tp>
712struct __unique_if<_Tp[]>
713{
714    typedef unique_ptr<_Tp[]> __unique_array_unknown_bound;
715};
716 
717template<class _Tp, size_t _Np>
718struct __unique_if<_Tp[_Np]>
719{
720    typedef void __unique_array_known_bound;
721};
722 
723template<class _Tp, class... _Args>
724inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
725typename __unique_if<_Tp>::__unique_single
726make_unique(_Args&&... __args)
727{
728    return unique_ptr<_Tp>(new _Tp(_VSTDstd::__1::forward<_Args>(__args)...));
729}
730 
731template<class _Tp>
732inline _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
733typename __unique_if<_Tp>::__unique_array_unknown_bound
734make_unique(size_t __n)
735{
736    typedef typename remove_extent<_Tp>::type _Up;
737    return unique_ptr<_Tp>(new _Up[__n]());
738}
739 
740template<class _Tp, class... _Args>
741    typename __unique_if<_Tp>::__unique_array_known_bound
742    make_unique(_Args&&...) = delete;
743 
744#endif // _LIBCPP_STD_VER > 11
745 
746template <class _Tp> struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) hash;
747 
748template <class _Tp, class _Dp>
749#ifdef _LIBCPP_CXX03_LANG
750struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) hash<unique_ptr<_Tp, _Dp> >
751#else
752struct _LIBCPP_TEMPLATE_VIS__attribute__ ((__type_visibility__("default"))) hash<__enable_hash_helper<
753    unique_ptr<_Tp, _Dp>, typename unique_ptr<_Tp, _Dp>::pointer> >
754#endif
755{
756#if _LIBCPP_STD_VER14 <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
757    _LIBCPP_DEPRECATED_IN_CXX17 typedef unique_ptr<_Tp, _Dp> argument_type;
758    _LIBCPP_DEPRECATED_IN_CXX17 typedef size_t               result_type;
759#endif
760 
761    _LIBCPP_INLINE_VISIBILITY__attribute__ ((__visibility__("hidden"))) __attribute__ ((__exclude_from_explicit_instantiation__
))
762    size_t operator()(const unique_ptr<_Tp, _Dp>& __ptr) const
763    {
764        typedef typename unique_ptr<_Tp, _Dp>::pointer pointer;
765        return hash<pointer>()(__ptr.get());
766    }
767};
768 
769_LIBCPP_END_NAMESPACE_STD} }
770 
771_LIBCPP_POP_MACROSpop_macro("min")
 pop_macro("max")
772 
773#endif // _LIBCPP___MEMORY_UNIQUE_PTR_H