/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 1127, column 50 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 ||
    resolve_scope & eSymbolContextVariable ||
    resolve_scope & eSymbolContextFunction ||
    resolve_scope & eSymbolContextBlock ||
    resolve_scope & eSymbolContextLineEntry) {
  auto cu_sp = GetCompileUnitContainsAddress(so_addr);
  if (!cu_sp) {
    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 ||
    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) {
    auto *pdb_func = llvm::dyn_cast<PDBSymbolFunc>(symbol_up.get());
    assert(pdb_func)((void)0);
    auto func_uid = pdb_func->getSymIndexId();
    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))
1
Calling 'SymbolFilePDB::DeclContextMatchesThisSymbolFile'→
8
←
Returning from 'SymbolFilePDB::DeclContextMatchesThisSymbolFile'→
9
←
Taking false branch→
  return;
if (name.IsEmpty())
10
←
Calling 'ConstString::IsEmpty'→
14
←
Returning from 'ConstString::IsEmpty'→
15
←
Taking false branch→
  return;

auto results = m_global_scope_up->findAllChildren<PDBSymbolData>();
if (!results)
16
←
Calling 'unique_ptr::operator bool'→
18
←
Returning from 'unique_ptr::operator bool'→
19
←
Taking false branch→
  return;

uint32_t matches = 0;
size_t old_size = variables.GetSize();
while (auto result = results->getNext()) {
20
←
Calling 'unique_ptr::operator bool'→
22
←
Returning from 'unique_ptr::operator bool'→
23
←
Loop condition is true.  Entering loop body→
  auto pdb_data = llvm::dyn_cast<PDBSymbolData>(result.get());
24
←
Assuming the object is not a 'PDBSymbolData'→
25
←
'pdb_data' initialized to a null pointer value→
  if (max_matches > 0 && matches >= max_matches)
26
←
Assuming 'max_matches' is <= 0→
    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())))
27
←
Called C++ object pointer is null
    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())
2
←
Calling 'CompilerDeclContext::IsValid'→
5
←
Returning from 'CompilerDeclContext::IsValid'→
6
←
Taking true branch→
  return true;
7
←
Returning the value 1, which participates in a condition later→

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/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/include/lldb/Symbol/CompilerDeclContext.h

→

1//===-- CompilerDeclContext.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_SYMBOL_COMPILERDECLCONTEXT_H
10#define LLDB_SYMBOL_COMPILERDECLCONTEXT_H

12#include <vector>

14#include "lldb/Utility/ConstString.h"
15#include "lldb/lldb-private.h"

17namespace lldb_private {

19/// Represents a generic declaration context in a program. A declaration context
20/// is data structure that contains declarations (e.g. namespaces).
21///
22/// This class serves as an abstraction for a declaration context inside one of
23/// the TypeSystems implemented by the language plugins. It does not have any
24/// actual logic in it but only stores an opaque pointer and a pointer to the
25/// TypeSystem that gives meaning to this opaque pointer. All methods of this
26/// class should call their respective method in the TypeSystem interface and
27/// pass the opaque pointer along.
28///
29/// \see lldb_private::TypeSystem
30class CompilerDeclContext {
31public:
/// Constructs an invalid CompilerDeclContext.
CompilerDeclContext() = default;

/// Constructs a CompilerDeclContext with the given opaque decl context
/// and its respective TypeSystem instance.
///
/// This constructor should only be called from the respective TypeSystem
/// implementation.
///
/// \see lldb_private::TypeSystemClang::CreateDeclContext(clang::DeclContext*)
CompilerDeclContext(TypeSystem *type_system, void *decl_ctx)
    : m_type_system(type_system), m_opaque_decl_ctx(decl_ctx) {}

// Tests

explicit operator bool() const { return IsValid(); }

bool operator<(const CompilerDeclContext &rhs) const {
  if (m_type_system == rhs.m_type_system)
    return m_opaque_decl_ctx < rhs.m_opaque_decl_ctx;
  return m_type_system < rhs.m_type_system;
}

bool IsValid() const {
  return m_type_system != nullptr && m_opaque_decl_ctx != nullptr;
3
←
Assuming the condition is false→
4
←
Returning zero, which participates in a condition later→
}

std::vector<CompilerDecl> FindDeclByName(ConstString name,
                                         const bool ignore_using_decls);

/// Checks if this decl context represents a method of a class.
///
/// \param[out] language_ptr
///     If non NULL and \b true is returned from this function,
///     this will indicate if the language that respresents the method.
///
/// \param[out] is_instance_method_ptr
///     If non NULL and \b true is returned from this function,
///     this will indicate if the method is an instance function (true)
///     or a class method (false indicating the function is static, or
///     doesn't require an instance of the class to be called).
///
/// \param[out] language_object_name_ptr
///     If non NULL and \b true is returned from this function,
///     this will indicate if implicit object name for the language
///     like "this" for C++, and "self" for Objective C.
///
/// \return
///     Returns true if this is a decl context that represents a method
///     in a struct, union or class.
bool IsClassMethod(lldb::LanguageType *language_ptr,
                   bool *is_instance_method_ptr,
                   ConstString *language_object_name_ptr);

/// Check if the given other decl context is contained in the lookup
/// of this decl context (for example because the other context is a nested
/// inline namespace).
///
/// @param[in] other
///     The other decl context for which we should check if it is contained
///     in the lookoup of this context.
///
/// @return
///     Returns true iff the other decl context is contained in the lookup
///     of this decl context.
bool IsContainedInLookup(CompilerDeclContext other) const;

// Accessors

TypeSystem *GetTypeSystem() const { return m_type_system; }

void *GetOpaqueDeclContext() const { return m_opaque_decl_ctx; }

void SetDeclContext(TypeSystem *type_system, void *decl_ctx) {
  m_type_system = type_system;
  m_opaque_decl_ctx = decl_ctx;
}

void Clear() {
  m_type_system = nullptr;
  m_opaque_decl_ctx = nullptr;
}

ConstString GetName() const;

ConstString GetScopeQualifiedName() const;

119private:
TypeSystem *m_type_system = nullptr;
void *m_opaque_decl_ctx = nullptr;
122};

124bool operator==(const CompilerDeclContext &lhs, const CompilerDeclContext &rhs);
125bool operator!=(const CompilerDeclContext &lhs, const CompilerDeclContext &rhs);

127} // namespace lldb_private

129#endif // LLDB_SYMBOL_COMPILERDECLCONTEXT_H

←

/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/include/lldb/Utility/ConstString.h

→

1//===-- ConstString.h -------------------------------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//

9#ifndef LLDB_UTILITY_CONSTSTRING_H
10#define LLDB_UTILITY_CONSTSTRING_H

12#include "llvm/ADT/DenseMapInfo.h"
13#include "llvm/ADT/StringRef.h"
14#include "llvm/Support/FormatVariadic.h"
15#include "llvm/Support/YAMLTraits.h"

17#include <cstddef>

19namespace lldb_private {
20class Stream;
21}
22namespace llvm {
23class raw_ostream;
24}

26namespace lldb_private {

28/// \class ConstString ConstString.h "lldb/Utility/ConstString.h"
29/// A uniqued constant string class.
30///
31/// Provides an efficient way to store strings as uniqued strings. After the
32/// strings are uniqued, finding strings that are equal to one another is very
33/// fast as just the pointers need to be compared. It also allows for many
34/// common strings from many different sources to be shared to keep the memory
35/// footprint low.
36///
37/// No reference counting is done on strings that are added to the string
38/// pool, once strings are added they are in the string pool for the life of
39/// the program.
40class ConstString {
41public:
/// Default constructor
///
/// Initializes the string to an empty string.
ConstString() = default;

explicit ConstString(const llvm::StringRef &s);

/// Construct with C String value
///
/// Constructs this object with a C string by looking to see if the
/// C string already exists in the global string pool. If it doesn't
/// exist, it is added to the string pool.
///
/// \param[in] cstr
///     A NULL terminated C string to add to the string pool.
explicit ConstString(const char *cstr);

/// Construct with C String value with max length
///
/// Constructs this object with a C string with a length. If \a max_cstr_len
/// is greater than the actual length of the string, the string length will
/// be truncated. This allows substrings to be created without the need to
/// NULL terminate the string as it is passed into this function.
///
/// \param[in] cstr
///     A pointer to the first character in the C string. The C
///     string can be NULL terminated in a buffer that contains
///     more characters than the length of the string, or the
///     string can be part of another string and a new substring
///     can be created.
///
/// \param[in] max_cstr_len
///     The max length of \a cstr. If the string length of \a cstr
///     is less than \a max_cstr_len, then the string will be
///     truncated. If the string length of \a cstr is greater than
///     \a max_cstr_len, then only max_cstr_len bytes will be used
///     from \a cstr.
explicit ConstString(const char *cstr, size_t max_cstr_len);

/// C string equality binary predicate function object for ConstString
/// objects.
struct StringIsEqual {
  /// C equality test.
  ///
  /// Two C strings are equal when they are contained in ConstString objects
  /// when their pointer values are equal to each other.
  ///
  /// \return
  ///     Returns \b true if the C string in \a lhs is equal to
  ///     the C string value in \a rhs, \b false otherwise.
  bool operator()(const char *lhs, const char *rhs) const {
    return lhs == rhs;
  }
};

/// Convert to bool operator.
///
/// This allows code to check a ConstString object to see if it contains a
/// valid string using code such as:
///
/// \code
/// ConstString str(...);
/// if (str)
/// { ...
/// \endcode
///
/// \return
///     /b True this object contains a valid non-empty C string, \b
///     false otherwise.
explicit operator bool() const { return !IsEmpty(); }

/// Equal to operator
///
/// Returns true if this string is equal to the string in \a rhs. This
/// operation is very fast as it results in a pointer comparison since all
/// strings are in a uniqued in a global string pool.
///
/// \param[in] rhs
///     Another string object to compare this object to.
///
/// \return
///     true if this object is equal to \a rhs.
///     false if this object is not equal to \a rhs.
bool operator==(ConstString rhs) const {
  // We can do a pointer compare to compare these strings since they must
  // come from the same pool in order to be equal.
  return m_string == rhs.m_string;
}

/// Equal to operator against a non-ConstString value.
///
/// Returns true if this string is equal to the string in \a rhs. This
/// overload is usually slower than comparing against a ConstString value.
/// However, if the rhs string not already a ConstString and it is impractical
/// to turn it into a non-temporary variable, then this overload is faster.
///
/// \param[in] rhs
///     Another string object to compare this object to.
///
/// \return
///     \b true if this object is equal to \a rhs.
///     \b false if this object is not equal to \a rhs.
bool operator==(const char *rhs) const {
  // ConstString differentiates between empty strings and nullptr strings, but
  // StringRef doesn't. Therefore we have to do this check manually now.
  if (m_string == nullptr && rhs != nullptr)
    return false;
  if (m_string != nullptr && rhs == nullptr)
    return false;

  return GetStringRef() == rhs;
}

/// Not equal to operator
///
/// Returns true if this string is not equal to the string in \a rhs. This
/// operation is very fast as it results in a pointer comparison since all
/// strings are in a uniqued in a global string pool.
///
/// \param[in] rhs
///     Another string object to compare this object to.
///
/// \return
///     \b true if this object is not equal to \a rhs.
///     \b false if this object is equal to \a rhs.
bool operator!=(ConstString rhs) const { return m_string != rhs.m_string; }

/// Not equal to operator against a non-ConstString value.
///
/// Returns true if this string is not equal to the string in \a rhs. This
/// overload is usually slower than comparing against a ConstString value.
/// However, if the rhs string not already a ConstString and it is impractical
/// to turn it into a non-temporary variable, then this overload is faster.
///
/// \param[in] rhs
///     Another string object to compare this object to.
///
/// \return \b true if this object is not equal to \a rhs, false otherwise.
bool operator!=(const char *rhs) const { return !(*this == rhs); }

bool operator<(ConstString rhs) const;

/// Get the string value as a C string.
///
/// Get the value of the contained string as a NULL terminated C string
/// value.
///
/// If \a value_if_empty is nullptr, then nullptr will be returned.
///
/// \return Returns \a value_if_empty if the string is empty, otherwise
///     the C string value contained in this object.
const char *AsCString(const char *value_if_empty = nullptr) const {
  return (IsEmpty() ? value_if_empty : m_string);
}

/// Get the string value as a llvm::StringRef
///
/// \return
///     Returns a new llvm::StringRef object filled in with the
///     needed data.
llvm::StringRef GetStringRef() const {
  return llvm::StringRef(m_string, GetLength());
}

/// Get the string value as a C string.
///
/// Get the value of the contained string as a NULL terminated C string
/// value. Similar to the ConstString::AsCString() function, yet this
/// function will always return nullptr if the string is not valid. So this
/// function is a direct accessor to the string pointer value.
///
/// \return
///     Returns nullptr the string is invalid, otherwise the C string
///     value contained in this object.
const char *GetCString() const { return m_string; }

/// Get the length in bytes of string value.
///
/// The string pool stores the length of the string, so we can avoid calling
/// strlen() on the pointer value with this function.
///
/// \return
///     Returns the number of bytes that this string occupies in
///     memory, not including the NULL termination byte.
size_t GetLength() const;

/// Clear this object's state.
///
/// Clear any contained string and reset the value to the empty string
/// value.
void Clear() { m_string = nullptr; }

/// Equal to operator
///
/// Returns true if this string is equal to the string in \a rhs. If case
/// sensitive equality is tested, this operation is very fast as it results
/// in a pointer comparison since all strings are in a uniqued in a global
/// string pool.
///
/// \param[in] lhs
///     The Left Hand Side const ConstString object reference.
///
/// \param[in] rhs
///     The Right Hand Side const ConstString object reference.
///
/// \param[in] case_sensitive
///     Case sensitivity. If true, case sensitive equality
///     will be tested, otherwise character case will be ignored
///
/// \return \b true if this object is equal to \a rhs, \b false otherwise.
static bool Equals(ConstString lhs, ConstString rhs,
                   const bool case_sensitive = true);

/// Compare two string objects.
///
/// Compares the C string values contained in \a lhs and \a rhs and returns
/// an integer result.
///
/// NOTE: only call this function when you want a true string
/// comparison. If you want string equality use the, use the == operator as
/// it is much more efficient. Also if you want string inequality, use the
/// != operator for the same reasons.
///
/// \param[in] lhs
///     The Left Hand Side const ConstString object reference.
///
/// \param[in] rhs
///     The Right Hand Side const ConstString object reference.
///
/// \param[in] case_sensitive
///     Case sensitivity of compare. If true, case sensitive compare
///     will be performed, otherwise character case will be ignored
///
/// \return -1 if lhs < rhs, 0 if lhs == rhs, 1 if lhs > rhs
static int Compare(ConstString lhs, ConstString rhs,
                   const bool case_sensitive = true);

/// Dump the object description to a stream.
///
/// Dump the string value to the stream \a s. If the contained string is
/// empty, print \a value_if_empty to the stream instead. If \a
/// value_if_empty is nullptr, then nothing will be dumped to the stream.
///
/// \param[in] s
///     The stream that will be used to dump the object description.
///
/// \param[in] value_if_empty
///     The value to dump if the string is empty. If nullptr, nothing
///     will be output to the stream.
void Dump(Stream *s, const char *value_if_empty = nullptr) const;

/// Dump the object debug description to a stream.
///
/// \param[in] s
///     The stream that will be used to dump the object description.
void DumpDebug(Stream *s) const;

/// Test for empty string.
///
/// \return
///     \b true if the contained string is empty.
///     \b false if the contained string is not empty.
bool IsEmpty() const { return m_string == nullptr || m_string[0] == '\0'; }
11
←
Assuming the condition is false→
12
←
Assuming the condition is false→
13
←
Returning zero, which participates in a condition later→

/// Test for null string.
///
/// \return
///     \b true if there is no string associated with this instance.
///     \b false if there is a string associated with this instance.
bool IsNull() const { return m_string == nullptr; }

/// Set the C string value.
///
/// Set the string value in the object by uniquing the \a cstr string value
/// in our global string pool.
///
/// If the C string already exists in the global string pool, it finds the
/// current entry and returns the existing value. If it doesn't exist, it is
/// added to the string pool.
///
/// \param[in] cstr
///     A NULL terminated C string to add to the string pool.
void SetCString(const char *cstr);

void SetString(const llvm::StringRef &s);

/// Set the C string value and its mangled counterpart.
///
/// Object files and debug symbols often use mangled string to represent the
/// linkage name for a symbol, function or global. The string pool can
/// efficiently store these values and their counterparts so when we run
/// into another instance of a mangled name, we can avoid calling the name
/// demangler over and over on the same strings and then trying to unique
/// them.
///
/// \param[in] demangled
///     The demangled string to correlate with the \a mangled name.
///
/// \param[in] mangled
///     The already uniqued mangled ConstString to correlate the
///     soon to be uniqued version of \a demangled.
void SetStringWithMangledCounterpart(llvm::StringRef demangled,
                                     ConstString mangled);

/// Retrieve the mangled or demangled counterpart for a mangled or demangled
/// ConstString.
///
/// Object files and debug symbols often use mangled string to represent the
/// linkage name for a symbol, function or global. The string pool can
/// efficiently store these values and their counterparts so when we run
/// into another instance of a mangled name, we can avoid calling the name
/// demangler over and over on the same strings and then trying to unique
/// them.
///
/// \param[in] counterpart
///     A reference to a ConstString object that might get filled in
///     with the demangled/mangled counterpart.
///
/// \return
///     /b True if \a counterpart was filled in with the counterpart
///     /b false otherwise.
bool GetMangledCounterpart(ConstString &counterpart) const;

/// Set the C string value with length.
///
/// Set the string value in the object by uniquing \a cstr_len bytes
/// starting at the \a cstr string value in our global string pool. If trim
/// is true, then \a cstr_len indicates a maximum length of the CString and
/// if the actual length of the string is less, then it will be trimmed.
///
/// If the C string already exists in the global string pool, it finds the
/// current entry and returns the existing value. If it doesn't exist, it is
/// added to the string pool.
///
/// \param[in] cstr
///     A NULL terminated C string to add to the string pool.
///
/// \param[in] cstr_len
///     The maximum length of the C string.
void SetCStringWithLength(const char *cstr, size_t cstr_len);

/// Set the C string value with the minimum length between \a fixed_cstr_len
/// and the actual length of the C string. This can be used for data
/// structures that have a fixed length to store a C string where the string
/// might not be NULL terminated if the string takes the entire buffer.
void SetTrimmedCStringWithLength(const char *cstr, size_t fixed_cstr_len);

/// Get the memory cost of this object.
///
/// Return the size in bytes that this object takes in memory. This returns
/// the size in bytes of this object, which does not include any the shared
/// string values it may refer to.
///
/// \return
///     The number of bytes that this object occupies in memory.
///
/// \see ConstString::StaticMemorySize ()
size_t MemorySize() const { return sizeof(ConstString); }

/// Get the size in bytes of the current global string pool.
///
/// Reports the size in bytes of all shared C string values, containers and
/// any other values as a byte size for the entire string pool.
///
/// \return
///     The number of bytes that the global string pool occupies
///     in memory.
static size_t StaticMemorySize();

411protected:
template <typename T> friend struct ::llvm::DenseMapInfo;
/// Only used by DenseMapInfo.
static ConstString FromStringPoolPointer(const char *ptr) {
  ConstString s;
  s.m_string = ptr;
  return s;
};

const char *m_string = nullptr;
421};

423/// Stream the string value \a str to the stream \a s
424Stream &operator<<(Stream &s, ConstString str);

426} // namespace lldb_private

428namespace llvm {
429template <> struct format_provider<lldb_private::ConstString> {
static void format(const lldb_private::ConstString &CS, llvm::raw_ostream &OS,
                   llvm::StringRef Options);
432};

434/// DenseMapInfo implementation.
435/// \{
436template <> struct DenseMapInfo<lldb_private::ConstString> {
static inline lldb_private::ConstString getEmptyKey() {
  return lldb_private::ConstString::FromStringPoolPointer(
      DenseMapInfo<const char *>::getEmptyKey());
}
static inline lldb_private::ConstString getTombstoneKey() {
  return lldb_private::ConstString::FromStringPoolPointer(
      DenseMapInfo<const char *>::getTombstoneKey());
}
static unsigned getHashValue(lldb_private::ConstString val) {
  return DenseMapInfo<const char *>::getHashValue(val.m_string);
}
static bool isEqual(lldb_private::ConstString LHS,
                    lldb_private::ConstString RHS) {
  return LHS == RHS;
}
452};
453/// \}

455namespace yaml {
456template <> struct ScalarTraits<lldb_private::ConstString> {
static void output(const lldb_private::ConstString &, void *, raw_ostream &);
static StringRef input(StringRef, void *, lldb_private::ConstString &);
static QuotingType mustQuote(StringRef S) { return QuotingType::Double; }
460};
461} // namespace yaml

463inline raw_ostream &operator<<(raw_ostream &os, lldb_private::ConstString s) {
os << s.GetStringRef();
return os;
466}
467} // namespace llvm

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

471#endif // LLDB_UTILITY_CONSTSTRING_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;
17
←
Returning the value 1, which participates in a condition later→
21
←
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