/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

Bug Summary

File:	src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp
Warning:	line 316, column 13 Forming reference to null pointer

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 SymbolFileNativePDB.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/NativePDB/SymbolFileNativePDB.cpp

/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

→

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

11#include "clang/AST/Attr.h"
12#include "clang/AST/CharUnits.h"
13#include "clang/AST/Decl.h"
14#include "clang/AST/DeclCXX.h"
15#include "clang/AST/Type.h"

17#include "Plugins/ExpressionParser/Clang/ClangUtil.h"
18#include "Plugins/Language/CPlusPlus/MSVCUndecoratedNameParser.h"
19#include "Plugins/ObjectFile/PDB/ObjectFilePDB.h"
20#include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
21#include "lldb/Core/Module.h"
22#include "lldb/Core/PluginManager.h"
23#include "lldb/Core/StreamBuffer.h"
24#include "lldb/Core/StreamFile.h"
25#include "lldb/Symbol/CompileUnit.h"
26#include "lldb/Symbol/LineTable.h"
27#include "lldb/Symbol/ObjectFile.h"
28#include "lldb/Symbol/SymbolContext.h"
29#include "lldb/Symbol/SymbolVendor.h"
30#include "lldb/Symbol/Variable.h"
31#include "lldb/Symbol/VariableList.h"
32#include "lldb/Utility/Log.h"

34#include "llvm/DebugInfo/CodeView/CVRecord.h"
35#include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
36#include "llvm/DebugInfo/CodeView/DebugLinesSubsection.h"
37#include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
38#include "llvm/DebugInfo/CodeView/RecordName.h"
39#include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
40#include "llvm/DebugInfo/CodeView/SymbolRecordHelpers.h"
41#include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
42#include "llvm/DebugInfo/PDB/Native/DbiStream.h"
43#include "llvm/DebugInfo/PDB/Native/GlobalsStream.h"
44#include "llvm/DebugInfo/PDB/Native/InfoStream.h"
45#include "llvm/DebugInfo/PDB/Native/ModuleDebugStream.h"
46#include "llvm/DebugInfo/PDB/Native/NativeSession.h"
47#include "llvm/DebugInfo/PDB/Native/PDBFile.h"
48#include "llvm/DebugInfo/PDB/Native/SymbolStream.h"
49#include "llvm/DebugInfo/PDB/Native/TpiStream.h"
50#include "llvm/DebugInfo/PDB/PDB.h"
51#include "llvm/DebugInfo/PDB/PDBTypes.h"
52#include "llvm/Demangle/MicrosoftDemangle.h"
53#include "llvm/Object/COFF.h"
54#include "llvm/Support/Allocator.h"
55#include "llvm/Support/BinaryStreamReader.h"
56#include "llvm/Support/Error.h"
57#include "llvm/Support/ErrorOr.h"
58#include "llvm/Support/MemoryBuffer.h"

60#include "DWARFLocationExpression.h"
61#include "PdbAstBuilder.h"
62#include "PdbSymUid.h"
63#include "PdbUtil.h"
64#include "UdtRecordCompleter.h"

66using namespace lldb;
67using namespace lldb_private;
68using namespace npdb;
69using namespace llvm::codeview;
70using namespace llvm::pdb;

72char SymbolFileNativePDB::ID;

74static lldb::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;
}
85}

87static std::unique_ptr<PDBFile>
88loadMatchingPDBFile(std::string exe_path, llvm::BumpPtrAllocator &allocator) {
// Try to find a matching PDB for an EXE.
using namespace llvm::object;
auto expected_binary = createBinary(exe_path);

// If the file isn't a PE/COFF executable, fail.
if (!expected_binary) {
  llvm::consumeError(expected_binary.takeError());
  return nullptr;
}
OwningBinary<Binary> binary = std::move(*expected_binary);

// TODO: Avoid opening the PE/COFF binary twice by reading this information
// directly from the lldb_private::ObjectFile.
auto *obj = llvm::dyn_cast<llvm::object::COFFObjectFile>(binary.getBinary());
if (!obj)
  return nullptr;
const llvm::codeview::DebugInfo *pdb_info = nullptr;

// If it doesn't have a debug directory, fail.
llvm::StringRef pdb_file;
if (llvm::Error e = obj->getDebugPDBInfo(pdb_info, pdb_file)) {
  consumeError(std::move(e));
  return nullptr;
}

// If the file doesn't exist, perhaps the path specified at build time
// doesn't match the PDB's current location, so check the location of the
// executable.
if (!FileSystem::Instance().Exists(pdb_file)) {
  const auto exe_dir = FileSpec(exe_path).CopyByRemovingLastPathComponent();
  const auto pdb_name = FileSpec(pdb_file).GetFilename().GetCString();
  pdb_file = exe_dir.CopyByAppendingPathComponent(pdb_name).GetCString();
}

// If the file is not a PDB or if it doesn't have a matching GUID, fail.
auto pdb = ObjectFilePDB::loadPDBFile(std::string(pdb_file), allocator);
if (!pdb)
  return nullptr;

auto expected_info = pdb->getPDBInfoStream();
if (!expected_info) {
  llvm::consumeError(expected_info.takeError());
  return nullptr;
}
llvm::codeview::GUID guid;
memcpy(&guid, pdb_info->PDB70.Signature, 16);

if (expected_info->getGuid() != guid)
  return nullptr;
return pdb;
139}

141static bool IsFunctionPrologue(const CompilandIndexItem &cci,
                             lldb::addr_t addr) {
// FIXME: Implement this.
return false;
145}

147static bool IsFunctionEpilogue(const CompilandIndexItem &cci,
                             lldb::addr_t addr) {
// FIXME: Implement this.
return false;
151}

153static llvm::StringRef GetSimpleTypeName(SimpleTypeKind kind) {
switch (kind) {
case SimpleTypeKind::Boolean128:
case SimpleTypeKind::Boolean16:
case SimpleTypeKind::Boolean32:
case SimpleTypeKind::Boolean64:
case SimpleTypeKind::Boolean8:
  return "bool";
case SimpleTypeKind::Byte:
case SimpleTypeKind::UnsignedCharacter:
  return "unsigned char";
case SimpleTypeKind::NarrowCharacter:
  return "char";
case SimpleTypeKind::SignedCharacter:
case SimpleTypeKind::SByte:
  return "signed char";
case SimpleTypeKind::Character16:
  return "char16_t";
case SimpleTypeKind::Character32:
  return "char32_t";
case SimpleTypeKind::Complex80:
case SimpleTypeKind::Complex64:
case SimpleTypeKind::Complex32:
  return "complex";
case SimpleTypeKind::Float128:
case SimpleTypeKind::Float80:
  return "long double";
case SimpleTypeKind::Float64:
  return "double";
case SimpleTypeKind::Float32:
  return "float";
case SimpleTypeKind::Float16:
  return "single";
case SimpleTypeKind::Int128:
  return "__int128";
case SimpleTypeKind::Int64:
case SimpleTypeKind::Int64Quad:
  return "int64_t";
case SimpleTypeKind::Int32:
  return "int";
case SimpleTypeKind::Int16:
  return "short";
case SimpleTypeKind::UInt128:
  return "unsigned __int128";
case SimpleTypeKind::UInt64:
case SimpleTypeKind::UInt64Quad:
  return "uint64_t";
case SimpleTypeKind::HResult:
  return "HRESULT";
case SimpleTypeKind::UInt32:
  return "unsigned";
case SimpleTypeKind::UInt16:
case SimpleTypeKind::UInt16Short:
  return "unsigned short";
case SimpleTypeKind::Int32Long:
  return "long";
case SimpleTypeKind::UInt32Long:
  return "unsigned long";
case SimpleTypeKind::Void:
  return "void";
case SimpleTypeKind::WideCharacter:
  return "wchar_t";
default:
  return "";
}
218}

220static bool IsClassRecord(TypeLeafKind kind) {
switch (kind) {
case LF_STRUCTURE:
case LF_CLASS:
case LF_INTERFACE:
  return true;
default:
  return false;
}
229}

231void SymbolFileNativePDB::Initialize() {
PluginManager::RegisterPlugin(GetPluginNameStatic(),
                              GetPluginDescriptionStatic(), CreateInstance,
                              DebuggerInitialize);
235}

237void SymbolFileNativePDB::Terminate() {
PluginManager::UnregisterPlugin(CreateInstance);
239}

241void SymbolFileNativePDB::DebuggerInitialize(Debugger &debugger) {}

243ConstString SymbolFileNativePDB::GetPluginNameStatic() {
static ConstString g_name("native-pdb");
return g_name;
246}

248const char *SymbolFileNativePDB::GetPluginDescriptionStatic() {
return "Microsoft PDB debug symbol cross-platform file reader.";
250}

252SymbolFile *SymbolFileNativePDB::CreateInstance(ObjectFileSP objfile_sp) {
return new SymbolFileNativePDB(std::move(objfile_sp));
254}

256SymbolFileNativePDB::SymbolFileNativePDB(ObjectFileSP objfile_sp)
  : SymbolFile(std::move(objfile_sp)) {}

259SymbolFileNativePDB::~SymbolFileNativePDB() = default;

261uint32_t SymbolFileNativePDB::CalculateAbilities() {
uint32_t abilities = 0;
if (!m_objfile_sp)
  return 0;

if (!m_index) {
  // Lazily load and match the PDB file, but only do this once.
  PDBFile *pdb_file;
  if (auto *pdb = llvm::dyn_cast<ObjectFilePDB>(m_objfile_sp.get())) {
    pdb_file = &pdb->GetPDBFile();
  } else {
    m_file_up = loadMatchingPDBFile(m_objfile_sp->GetFileSpec().GetPath(),
                                    m_allocator);
    pdb_file = m_file_up.get();
  }

  if (!pdb_file)
    return 0;

  auto expected_index = PdbIndex::create(pdb_file);
  if (!expected_index) {
    llvm::consumeError(expected_index.takeError());
    return 0;
  }
  m_index = std::move(*expected_index);
}
if (!m_index)
  return 0;

// We don't especially have to be precise here.  We only distinguish between
// stripped and not stripped.
abilities = kAllAbilities;

if (m_index->dbi().isStripped())
  abilities &= ~(Blocks | LocalVariables);
return abilities;
297}

299void SymbolFileNativePDB::InitializeObject() {
m_obj_load_address = m_objfile_sp->GetModule()
                         ->GetObjectFile()
                         ->GetBaseAddress()
                         .GetFileAddress();
m_index->SetLoadAddress(m_obj_load_address);
m_index->ParseSectionContribs();

auto ts_or_err = m_objfile_sp->GetModule()->GetTypeSystemForLanguage(
    lldb::eLanguageTypeC_plus_plus);
if (auto err = ts_or_err.takeError()) {
1
Calling 'Error::operator bool'→
4
←
Returning from 'Error::operator bool'→
5
←
Taking false branch→
  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/NativePDB/SymbolFileNativePDB.cpp"
, __func__, "Failed to initialize"); } else ::llvm::consumeError
(::std::move(error_private)); } while (0)
                 std::move(err), "Failed to initialize")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/NativePDB/SymbolFileNativePDB.cpp"
, __func__, "Failed to initialize"); } else ::llvm::consumeError
(::std::move(error_private)); } while (0);
} else {
  ts_or_err->SetSymbolFile(this);
  auto *clang = llvm::cast_or_null<TypeSystemClang>(&ts_or_err.get());
6
←
Assuming null pointer is passed into cast→
7
←
'clang' initialized to a null pointer value→
  lldbassert(clang)lldb_private::lldb_assert(static_cast<bool>(clang), "clang"
, __FUNCTION__, "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp"
, 315);
  m_ast = std::make_unique<PdbAstBuilder>(*m_objfile_sp, *m_index, *clang);
8
←
Forming reference to null pointer
}
318}

320uint32_t SymbolFileNativePDB::CalculateNumCompileUnits() {
const DbiModuleList &modules = m_index->dbi().modules();
uint32_t count = modules.getModuleCount();
if (count == 0)
  return count;

// 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.
DbiModuleDescriptor last = modules.getModuleDescriptor(count - 1);
if (last.getModuleName() == "* Linker *")
  --count;
return count;
333}

335Block &SymbolFileNativePDB::CreateBlock(PdbCompilandSymId block_id) {
CompilandIndexItem *cii = m_index->compilands().GetCompiland(block_id.modi);
CVSymbol sym = cii->m_debug_stream.readSymbolAtOffset(block_id.offset);

if (sym.kind() == S_GPROC32 || sym.kind() == S_LPROC32) {
  // This is a function.  It must be global.  Creating the Function entry for
  // it automatically creates a block for it.
  CompUnitSP comp_unit = GetOrCreateCompileUnit(*cii);
  return GetOrCreateFunction(block_id, *comp_unit)->GetBlock(false);
}

lldbassert(sym.kind() == S_BLOCK32)lldb_private::lldb_assert(static_cast<bool>(sym.kind() ==
 S_BLOCK32), "sym.kind() == S_BLOCK32", __FUNCTION__, "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp"
, 346);

// This is a block.  Its parent is either a function or another block.  In
// either case, its parent can be viewed as a block (e.g. a function contains
// 1 big block.  So just get the parent block and add this block to it.
BlockSym block(static_cast<SymbolRecordKind>(sym.kind()));
cantFail(SymbolDeserializer::deserializeAs<BlockSym>(sym, block));
lldbassert(block.Parent != 0)lldb_private::lldb_assert(static_cast<bool>(block.Parent
 != 0), "block.Parent != 0", __FUNCTION__, "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp"
, 353);
PdbCompilandSymId parent_id(block_id.modi, block.Parent);
Block &parent_block = GetOrCreateBlock(parent_id);
lldb::user_id_t opaque_block_uid = toOpaqueUid(block_id);
BlockSP child_block = std::make_shared<Block>(opaque_block_uid);
parent_block.AddChild(child_block);

m_ast->GetOrCreateBlockDecl(block_id);

m_blocks.insert({opaque_block_uid, child_block});
return *child_block;
364}

366lldb::FunctionSP SymbolFileNativePDB::CreateFunction(PdbCompilandSymId func_id,
                                                   CompileUnit &comp_unit) {
const CompilandIndexItem *cci =
    m_index->compilands().GetCompiland(func_id.modi);
lldbassert(cci)lldb_private::lldb_assert(static_cast<bool>(cci), "cci"
, __FUNCTION__, "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp"
, 370);
CVSymbol sym_record = cci->m_debug_stream.readSymbolAtOffset(func_id.offset);

lldbassert(sym_record.kind() == S_LPROC32 || sym_record.kind() == S_GPROC32)lldb_private::lldb_assert(static_cast<bool>(sym_record.
kind() == S_LPROC32 || sym_record.kind() == S_GPROC32), "sym_record.kind() == S_LPROC32 || sym_record.kind() == S_GPROC32"
, __FUNCTION__, "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp"
, 373);
SegmentOffsetLength sol = GetSegmentOffsetAndLength(sym_record);

auto file_vm_addr = m_index->MakeVirtualAddress(sol.so);
if (file_vm_addr == LLDB_INVALID_ADDRESS0xffffffffffffffffULL || file_vm_addr == 0)
  return nullptr;

AddressRange func_range(file_vm_addr, sol.length,
                        comp_unit.GetModule()->GetSectionList());
if (!func_range.GetBaseAddress().IsValid())
  return nullptr;

ProcSym proc(static_cast<SymbolRecordKind>(sym_record.kind()));
cantFail(SymbolDeserializer::deserializeAs<ProcSym>(sym_record, proc));
if (proc.FunctionType == TypeIndex::None())
  return nullptr;
TypeSP func_type = GetOrCreateType(proc.FunctionType);
if (!func_type)
  return nullptr;

PdbTypeSymId sig_id(proc.FunctionType, false);
Mangled mangled(proc.Name);
FunctionSP func_sp = std::make_shared<Function>(
    &comp_unit, toOpaqueUid(func_id), toOpaqueUid(sig_id), mangled,
    func_type.get(), func_range);

comp_unit.AddFunction(func_sp);

m_ast->GetOrCreateFunctionDecl(func_id);

return func_sp;
404}

406CompUnitSP
407SymbolFileNativePDB::CreateCompileUnit(const CompilandIndexItem &cci) {
lldb::LanguageType lang =
    cci.m_compile_opts ? TranslateLanguage(cci.m_compile_opts->getLanguage())
                       : lldb::eLanguageTypeUnknown;

LazyBool optimized = eLazyBoolNo;
if (cci.m_compile_opts && cci.m_compile_opts->hasOptimizations())
  optimized = eLazyBoolYes;

llvm::SmallString<64> source_file_name =
    m_index->compilands().GetMainSourceFile(cci);
FileSpec fs(source_file_name);

CompUnitSP cu_sp =
    std::make_shared<CompileUnit>(m_objfile_sp->GetModule(), nullptr, fs,
                                  toOpaqueUid(cci.m_id), lang, optimized);

SetCompileUnitAtIndex(cci.m_id.modi, cu_sp);
return cu_sp;
426}

428lldb::TypeSP SymbolFileNativePDB::CreateModifierType(PdbTypeSymId type_id,
                                                   const ModifierRecord &mr,
                                                   CompilerType ct) {
TpiStream &stream = m_index->tpi();

std::string name;
if (mr.ModifiedType.isSimple())
  name = std::string(GetSimpleTypeName(mr.ModifiedType.getSimpleKind()));
else
  name = computeTypeName(stream.typeCollection(), mr.ModifiedType);
Declaration decl;
lldb::TypeSP modified_type = GetOrCreateType(mr.ModifiedType);

return std::make_shared<Type>(toOpaqueUid(type_id), this, ConstString(name),
                              modified_type->GetByteSize(nullptr), nullptr,
                              LLDB_INVALID_UID0xffffffffffffffffULL, Type::eEncodingIsUID, decl,
                              ct, Type::ResolveState::Full);
445}

447lldb::TypeSP
448SymbolFileNativePDB::CreatePointerType(PdbTypeSymId type_id,
                                     const llvm::codeview::PointerRecord &pr,
                                     CompilerType ct) {
TypeSP pointee = GetOrCreateType(pr.ReferentType);
if (!pointee)
  return nullptr;

if (pr.isPointerToMember()) {
  MemberPointerInfo mpi = pr.getMemberInfo();
  GetOrCreateType(mpi.ContainingType);
}

Declaration decl;
return std::make_shared<Type>(toOpaqueUid(type_id), this, ConstString(),
                              pr.getSize(), nullptr, LLDB_INVALID_UID0xffffffffffffffffULL,
                              Type::eEncodingIsUID, decl, ct,
                              Type::ResolveState::Full);
465}

467lldb::TypeSP SymbolFileNativePDB::CreateSimpleType(TypeIndex ti,
                                                 CompilerType ct) {
uint64_t uid = toOpaqueUid(PdbTypeSymId(ti, false));
if (ti == TypeIndex::NullptrT()) {
  Declaration decl;
  return std::make_shared<Type>(
      uid, this, ConstString("std::nullptr_t"), 0, nullptr, LLDB_INVALID_UID0xffffffffffffffffULL,
      Type::eEncodingIsUID, decl, ct, Type::ResolveState::Full);
}

if (ti.getSimpleMode() != SimpleTypeMode::Direct) {
  TypeSP direct_sp = GetOrCreateType(ti.makeDirect());
  uint32_t pointer_size = 0;
  switch (ti.getSimpleMode()) {
  case SimpleTypeMode::FarPointer32:
  case SimpleTypeMode::NearPointer32:
    pointer_size = 4;
    break;
  case SimpleTypeMode::NearPointer64:
    pointer_size = 8;
    break;
  default:
    // 128-bit and 16-bit pointers unsupported.
    return nullptr;
  }
  Declaration decl;
  return std::make_shared<Type>(
      uid, this, ConstString(), pointer_size, nullptr, LLDB_INVALID_UID0xffffffffffffffffULL,
      Type::eEncodingIsUID, decl, ct, Type::ResolveState::Full);
}

if (ti.getSimpleKind() == SimpleTypeKind::NotTranslated)
  return nullptr;

size_t size = GetTypeSizeForSimpleKind(ti.getSimpleKind());
llvm::StringRef type_name = GetSimpleTypeName(ti.getSimpleKind());

Declaration decl;
return std::make_shared<Type>(uid, this, ConstString(type_name), size,
                              nullptr, LLDB_INVALID_UID0xffffffffffffffffULL, Type::eEncodingIsUID,
                              decl, ct, Type::ResolveState::Full);
508}

510static std::string GetUnqualifiedTypeName(const TagRecord &record) {
if (!record.hasUniqueName()) {
  MSVCUndecoratedNameParser parser(record.Name);
  llvm::ArrayRef<MSVCUndecoratedNameSpecifier> specs = parser.GetSpecifiers();

  return std::string(specs.back().GetBaseName());
}

llvm::ms_demangle::Demangler demangler;
StringView sv(record.UniqueName.begin(), record.UniqueName.size());
llvm::ms_demangle::TagTypeNode *ttn = demangler.parseTagUniqueName(sv);
if (demangler.Error)
  return std::string(record.Name);

llvm::ms_demangle::IdentifierNode *idn =
    ttn->QualifiedName->getUnqualifiedIdentifier();
return idn->toString();
527}

529lldb::TypeSP
530SymbolFileNativePDB::CreateClassStructUnion(PdbTypeSymId type_id,
                                          const TagRecord &record,
                                          size_t size, CompilerType ct) {

std::string uname = GetUnqualifiedTypeName(record);

// FIXME: Search IPI stream for LF_UDT_MOD_SRC_LINE.
Declaration decl;
return std::make_shared<Type>(toOpaqueUid(type_id), this, ConstString(uname),
                              size, nullptr, LLDB_INVALID_UID0xffffffffffffffffULL,
                              Type::eEncodingIsUID, decl, ct,
                              Type::ResolveState::Forward);
542}

544lldb::TypeSP SymbolFileNativePDB::CreateTagType(PdbTypeSymId type_id,
                                              const ClassRecord &cr,
                                              CompilerType ct) {
return CreateClassStructUnion(type_id, cr, cr.getSize(), ct);
548}

550lldb::TypeSP SymbolFileNativePDB::CreateTagType(PdbTypeSymId type_id,
                                              const UnionRecord &ur,
                                              CompilerType ct) {
return CreateClassStructUnion(type_id, ur, ur.getSize(), ct);
554}

556lldb::TypeSP SymbolFileNativePDB::CreateTagType(PdbTypeSymId type_id,
                                              const EnumRecord &er,
                                              CompilerType ct) {
std::string uname = GetUnqualifiedTypeName(er);

Declaration decl;
TypeSP underlying_type = GetOrCreateType(er.UnderlyingType);

return std::make_shared<lldb_private::Type>(
    toOpaqueUid(type_id), this, ConstString(uname),
    underlying_type->GetByteSize(nullptr), nullptr, LLDB_INVALID_UID0xffffffffffffffffULL,
    lldb_private::Type::eEncodingIsUID, decl, ct,
    lldb_private::Type::ResolveState::Forward);
569}

571TypeSP SymbolFileNativePDB::CreateArrayType(PdbTypeSymId type_id,
                                          const ArrayRecord &ar,
                                          CompilerType ct) {
TypeSP element_type = GetOrCreateType(ar.ElementType);

Declaration decl;
TypeSP array_sp = std::make_shared<lldb_private::Type>(
    toOpaqueUid(type_id), this, ConstString(), ar.Size, nullptr,
    LLDB_INVALID_UID0xffffffffffffffffULL, lldb_private::Type::eEncodingIsUID, decl, ct,
    lldb_private::Type::ResolveState::Full);
array_sp->SetEncodingType(element_type.get());
return array_sp;
583}


586TypeSP SymbolFileNativePDB::CreateFunctionType(PdbTypeSymId type_id,
                                             const MemberFunctionRecord &mfr,
                                             CompilerType ct) {
Declaration decl;
return std::make_shared<lldb_private::Type>(
    toOpaqueUid(type_id), this, ConstString(), 0, nullptr, LLDB_INVALID_UID0xffffffffffffffffULL,
    lldb_private::Type::eEncodingIsUID, decl, ct,
    lldb_private::Type::ResolveState::Full);
594}

596TypeSP SymbolFileNativePDB::CreateProcedureType(PdbTypeSymId type_id,
                                              const ProcedureRecord &pr,
                                              CompilerType ct) {
Declaration decl;
return std::make_shared<lldb_private::Type>(
    toOpaqueUid(type_id), this, ConstString(), 0, nullptr, LLDB_INVALID_UID0xffffffffffffffffULL,
    lldb_private::Type::eEncodingIsUID, decl, ct,
    lldb_private::Type::ResolveState::Full);
604}

606TypeSP SymbolFileNativePDB::CreateType(PdbTypeSymId type_id, CompilerType ct) {
if (type_id.index.isSimple())
  return CreateSimpleType(type_id.index, ct);

TpiStream &stream = type_id.is_ipi ? m_index->ipi() : m_index->tpi();
CVType cvt = stream.getType(type_id.index);

if (cvt.kind() == LF_MODIFIER) {
  ModifierRecord modifier;
  llvm::cantFail(
      TypeDeserializer::deserializeAs<ModifierRecord>(cvt, modifier));
  return CreateModifierType(type_id, modifier, ct);
}

if (cvt.kind() == LF_POINTER) {
  PointerRecord pointer;
  llvm::cantFail(
      TypeDeserializer::deserializeAs<PointerRecord>(cvt, pointer));
  return CreatePointerType(type_id, pointer, ct);
}

if (IsClassRecord(cvt.kind())) {
  ClassRecord cr;
  llvm::cantFail(TypeDeserializer::deserializeAs<ClassRecord>(cvt, cr));
  return CreateTagType(type_id, cr, ct);
}

if (cvt.kind() == LF_ENUM) {
  EnumRecord er;
  llvm::cantFail(TypeDeserializer::deserializeAs<EnumRecord>(cvt, er));
  return CreateTagType(type_id, er, ct);
}

if (cvt.kind() == LF_UNION) {
  UnionRecord ur;
  llvm::cantFail(TypeDeserializer::deserializeAs<UnionRecord>(cvt, ur));
  return CreateTagType(type_id, ur, ct);
}

if (cvt.kind() == LF_ARRAY) {
  ArrayRecord ar;
  llvm::cantFail(TypeDeserializer::deserializeAs<ArrayRecord>(cvt, ar));
  return CreateArrayType(type_id, ar, ct);
}

if (cvt.kind() == LF_PROCEDURE) {
  ProcedureRecord pr;
  llvm::cantFail(TypeDeserializer::deserializeAs<ProcedureRecord>(cvt, pr));
  return CreateProcedureType(type_id, pr, ct);
}
if (cvt.kind() == LF_MFUNCTION) {
  MemberFunctionRecord mfr;
  llvm::cantFail(TypeDeserializer::deserializeAs<MemberFunctionRecord>(cvt, mfr));
  return CreateFunctionType(type_id, mfr, ct);
}

return nullptr;
663}

665TypeSP SymbolFileNativePDB::CreateAndCacheType(PdbTypeSymId type_id) {
// If they search for a UDT which is a forward ref, try and resolve the full
// decl and just map the forward ref uid to the full decl record.
llvm::Optional<PdbTypeSymId> full_decl_uid;
if (IsForwardRefUdt(type_id, m_index->tpi())) {
  auto expected_full_ti =
      m_index->tpi().findFullDeclForForwardRef(type_id.index);
  if (!expected_full_ti)
    llvm::consumeError(expected_full_ti.takeError());
  else if (*expected_full_ti != type_id.index) {
    full_decl_uid = PdbTypeSymId(*expected_full_ti, false);

    // It's possible that a lookup would occur for the full decl causing it
    // to be cached, then a second lookup would occur for the forward decl.
    // We don't want to create a second full decl, so make sure the full
    // decl hasn't already been cached.
    auto full_iter = m_types.find(toOpaqueUid(*full_decl_uid));
    if (full_iter != m_types.end()) {
      TypeSP result = full_iter->second;
      // Map the forward decl to the TypeSP for the full decl so we can take
      // the fast path next time.
      m_types[toOpaqueUid(type_id)] = result;
      return result;
    }
  }
}

PdbTypeSymId best_decl_id = full_decl_uid ? *full_decl_uid : type_id;

clang::QualType qt = m_ast->GetOrCreateType(best_decl_id);

TypeSP result = CreateType(best_decl_id, m_ast->ToCompilerType(qt));
if (!result)
  return nullptr;

uint64_t best_uid = toOpaqueUid(best_decl_id);
m_types[best_uid] = result;
// If we had both a forward decl and a full decl, make both point to the new
// type.
if (full_decl_uid)
  m_types[toOpaqueUid(type_id)] = result;

return result;
708}

710TypeSP SymbolFileNativePDB::GetOrCreateType(PdbTypeSymId type_id) {
// We can't use try_emplace / overwrite here because the process of creating
// a type could create nested types, which could invalidate iterators.  So
// we have to do a 2-phase lookup / insert.
auto iter = m_types.find(toOpaqueUid(type_id));
if (iter != m_types.end())
  return iter->second;

TypeSP type = CreateAndCacheType(type_id);
if (type)
  GetTypeList().Insert(type);
return type;
722}

724VariableSP SymbolFileNativePDB::CreateGlobalVariable(PdbGlobalSymId var_id) {
CVSymbol sym = m_index->symrecords().readRecord(var_id.offset);
if (sym.kind() == S_CONSTANT)
  return CreateConstantSymbol(var_id, sym);

lldb::ValueType scope = eValueTypeInvalid;
TypeIndex ti;
llvm::StringRef name;
lldb::addr_t addr = 0;
uint16_t section = 0;
uint32_t offset = 0;
bool is_external = false;
switch (sym.kind()) {
case S_GDATA32:
  is_external = true;
  LLVM_FALLTHROUGH[[gnu::fallthrough]];
case S_LDATA32: {
  DataSym ds(sym.kind());
  llvm::cantFail(SymbolDeserializer::deserializeAs<DataSym>(sym, ds));
  ti = ds.Type;
  scope = (sym.kind() == S_GDATA32) ? eValueTypeVariableGlobal
                                    : eValueTypeVariableStatic;
  name = ds.Name;
  section = ds.Segment;
  offset = ds.DataOffset;
  addr = m_index->MakeVirtualAddress(ds.Segment, ds.DataOffset);
  break;
}
case S_GTHREAD32:
  is_external = true;
  LLVM_FALLTHROUGH[[gnu::fallthrough]];
case S_LTHREAD32: {
  ThreadLocalDataSym tlds(sym.kind());
  llvm::cantFail(
      SymbolDeserializer::deserializeAs<ThreadLocalDataSym>(sym, tlds));
  ti = tlds.Type;
  name = tlds.Name;
  section = tlds.Segment;
  offset = tlds.DataOffset;
  addr = m_index->MakeVirtualAddress(tlds.Segment, tlds.DataOffset);
  scope = eValueTypeVariableThreadLocal;
  break;
}
default:
  llvm_unreachable("unreachable!")__builtin_unreachable();
}

CompUnitSP comp_unit;
llvm::Optional<uint16_t> modi = m_index->GetModuleIndexForVa(addr);
if (modi) {
  CompilandIndexItem &cci = m_index->compilands().GetOrCreateCompiland(*modi);
  comp_unit = GetOrCreateCompileUnit(cci);
}

Declaration decl;
PdbTypeSymId tid(ti, false);
SymbolFileTypeSP type_sp =
    std::make_shared<SymbolFileType>(*this, toOpaqueUid(tid));
Variable::RangeList ranges;

m_ast->GetOrCreateVariableDecl(var_id);

DWARFExpression location = MakeGlobalLocationExpression(
    section, offset, GetObjectFile()->GetModule());

std::string global_name("::");
global_name += name;
bool artificial = false;
bool location_is_constant_data = false;
bool static_member = false;
VariableSP var_sp = std::make_shared<Variable>(
    toOpaqueUid(var_id), name.str().c_str(), global_name.c_str(), type_sp,
    scope, comp_unit.get(), ranges, &decl, location, is_external, artificial,
    location_is_constant_data, static_member);

return var_sp;
800}

802lldb::VariableSP
803SymbolFileNativePDB::CreateConstantSymbol(PdbGlobalSymId var_id,
                                        const CVSymbol &cvs) {
TpiStream &tpi = m_index->tpi();
ConstantSym constant(cvs.kind());

llvm::cantFail(SymbolDeserializer::deserializeAs<ConstantSym>(cvs, constant));
std::string global_name("::");
global_name += constant.Name;
PdbTypeSymId tid(constant.Type, false);
SymbolFileTypeSP type_sp =
    std::make_shared<SymbolFileType>(*this, toOpaqueUid(tid));

Declaration decl;
Variable::RangeList ranges;
ModuleSP module = GetObjectFile()->GetModule();
DWARFExpression location = MakeConstantLocationExpression(
    constant.Type, tpi, constant.Value, module);

bool external = false;
bool artificial = false;
bool location_is_constant_data = true;
bool static_member = false;
VariableSP var_sp = std::make_shared<Variable>(
    toOpaqueUid(var_id), constant.Name.str().c_str(), global_name.c_str(),
    type_sp, eValueTypeVariableGlobal, module.get(), ranges, &decl, location,
    external, artificial, location_is_constant_data, static_member);
return var_sp;
830}

832VariableSP
833SymbolFileNativePDB::GetOrCreateGlobalVariable(PdbGlobalSymId var_id) {
auto emplace_result = m_global_vars.try_emplace(toOpaqueUid(var_id), nullptr);
if (emplace_result.second)
  emplace_result.first->second = CreateGlobalVariable(var_id);

return emplace_result.first->second;
839}

841lldb::TypeSP SymbolFileNativePDB::GetOrCreateType(TypeIndex ti) {
return GetOrCreateType(PdbTypeSymId(ti, false));
843}

845FunctionSP SymbolFileNativePDB::GetOrCreateFunction(PdbCompilandSymId func_id,
                                                  CompileUnit &comp_unit) {
auto emplace_result = m_functions.try_emplace(toOpaqueUid(func_id), nullptr);
if (emplace_result.second)
  emplace_result.first->second = CreateFunction(func_id, comp_unit);

return emplace_result.first->second;
852}

854CompUnitSP
855SymbolFileNativePDB::GetOrCreateCompileUnit(const CompilandIndexItem &cci) {

auto emplace_result =
    m_compilands.try_emplace(toOpaqueUid(cci.m_id), nullptr);
if (emplace_result.second)
  emplace_result.first->second = CreateCompileUnit(cci);

lldbassert(emplace_result.first->second)lldb_private::lldb_assert(static_cast<bool>(emplace_result
.first->second), "emplace_result.first->second", __FUNCTION__
, "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp"
, 862);
return emplace_result.first->second;
864}

866Block &SymbolFileNativePDB::GetOrCreateBlock(PdbCompilandSymId block_id) {
auto iter = m_blocks.find(toOpaqueUid(block_id));
if (iter != m_blocks.end())
  return *iter->second;

return CreateBlock(block_id);
872}

874void SymbolFileNativePDB::ParseDeclsForContext(
  lldb_private::CompilerDeclContext decl_ctx) {
clang::DeclContext *context = m_ast->FromCompilerDeclContext(decl_ctx);
if (!context)
  return;
m_ast->ParseDeclsForContext(*context);
880}

882lldb::CompUnitSP SymbolFileNativePDB::ParseCompileUnitAtIndex(uint32_t index) {
if (index >= GetNumCompileUnits())
  return CompUnitSP();
lldbassert(index < UINT16_MAX)lldb_private::lldb_assert(static_cast<bool>(index < 0xffff
), "index < UINT16_MAX", __FUNCTION__, "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp"
, 885);
if (index >= UINT16_MAX0xffff)
  return nullptr;

CompilandIndexItem &item = m_index->compilands().GetOrCreateCompiland(index);

return GetOrCreateCompileUnit(item);
892}

894lldb::LanguageType SymbolFileNativePDB::ParseLanguage(CompileUnit &comp_unit) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
PdbSymUid uid(comp_unit.GetID());
lldbassert(uid.kind() == PdbSymUidKind::Compiland)lldb_private::lldb_assert(static_cast<bool>(uid.kind() ==
 PdbSymUidKind::Compiland), "uid.kind() == PdbSymUidKind::Compiland"
, __FUNCTION__, "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp"
, 897);

CompilandIndexItem *item =
    m_index->compilands().GetCompiland(uid.asCompiland().modi);
lldbassert(item)lldb_private::lldb_assert(static_cast<bool>(item), "item"
, __FUNCTION__, "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp"
, 901);
if (!item->m_compile_opts)
  return lldb::eLanguageTypeUnknown;

return TranslateLanguage(item->m_compile_opts->getLanguage());
906}

908void SymbolFileNativePDB::AddSymbols(Symtab &symtab) { return; }

910size_t SymbolFileNativePDB::ParseFunctions(CompileUnit &comp_unit) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
PdbSymUid uid{comp_unit.GetID()};
lldbassert(uid.kind() == PdbSymUidKind::Compiland)lldb_private::lldb_assert(static_cast<bool>(uid.kind() ==
 PdbSymUidKind::Compiland), "uid.kind() == PdbSymUidKind::Compiland"
, __FUNCTION__, "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp"
, 913);
uint16_t modi = uid.asCompiland().modi;
CompilandIndexItem &cii = m_index->compilands().GetOrCreateCompiland(modi);

size_t count = comp_unit.GetNumFunctions();
const CVSymbolArray &syms = cii.m_debug_stream.getSymbolArray();
for (auto iter = syms.begin(); iter != syms.end(); ++iter) {
  if (iter->kind() != S_LPROC32 && iter->kind() != S_GPROC32)
    continue;

  PdbCompilandSymId sym_id{modi, iter.offset()};

  FunctionSP func = GetOrCreateFunction(sym_id, comp_unit);
}

size_t new_count = comp_unit.GetNumFunctions();
lldbassert(new_count >= count)lldb_private::lldb_assert(static_cast<bool>(new_count >=
 count), "new_count >= count", __FUNCTION__, "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp"
, 929);
return new_count - count;
931}

933static bool NeedsResolvedCompileUnit(uint32_t resolve_scope) {
// If any of these flags are set, we need to resolve the compile unit.
uint32_t flags = eSymbolContextCompUnit;
flags |= eSymbolContextVariable;
flags |= eSymbolContextFunction;
flags |= eSymbolContextBlock;
flags |= eSymbolContextLineEntry;
return (resolve_scope & flags) != 0;
941}

943uint32_t SymbolFileNativePDB::ResolveSymbolContext(
  const Address &addr, SymbolContextItem resolve_scope, SymbolContext &sc) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
uint32_t resolved_flags = 0;
lldb::addr_t file_addr = addr.GetFileAddress();

if (NeedsResolvedCompileUnit(resolve_scope)) {
  llvm::Optional<uint16_t> modi = m_index->GetModuleIndexForVa(file_addr);
  if (!modi)
    return 0;
  CompilandIndexItem *cci = m_index->compilands().GetCompiland(*modi);
  if (!cci)
    return 0;

  sc.comp_unit = GetOrCreateCompileUnit(*cci).get();
  resolved_flags |= eSymbolContextCompUnit;
}

if (resolve_scope & eSymbolContextFunction ||
    resolve_scope & eSymbolContextBlock) {
  lldbassert(sc.comp_unit)lldb_private::lldb_assert(static_cast<bool>(sc.comp_unit
), "sc.comp_unit", __FUNCTION__, "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp"
, 963);
  std::vector<SymbolAndUid> matches = m_index->FindSymbolsByVa(file_addr);
  // Search the matches in reverse.  This way if there are multiple matches
  // (for example we are 3 levels deep in a nested scope) it will find the
  // innermost one first.
  for (const auto &match : llvm::reverse(matches)) {
    if (match.uid.kind() != PdbSymUidKind::CompilandSym)
      continue;

    PdbCompilandSymId csid = match.uid.asCompilandSym();
    CVSymbol cvs = m_index->ReadSymbolRecord(csid);
    PDB_SymType type = CVSymToPDBSym(cvs.kind());
    if (type != PDB_SymType::Function && type != PDB_SymType::Block)
      continue;
    if (type == PDB_SymType::Function) {
      sc.function = GetOrCreateFunction(csid, *sc.comp_unit).get();
      sc.block = sc.GetFunctionBlock();
    }

    if (type == PDB_SymType::Block) {
      sc.block = &GetOrCreateBlock(csid);
      sc.function = sc.block->CalculateSymbolContextFunction();
    }
  resolved_flags |= eSymbolContextFunction;
  resolved_flags |= eSymbolContextBlock;
  break;
  }
}

if (resolve_scope & eSymbolContextLineEntry) {
  lldbassert(sc.comp_unit)lldb_private::lldb_assert(static_cast<bool>(sc.comp_unit
), "sc.comp_unit", __FUNCTION__, "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp"
, 993);
  if (auto *line_table = sc.comp_unit->GetLineTable()) {
    if (line_table->FindLineEntryByAddress(addr, sc.line_entry))
      resolved_flags |= eSymbolContextLineEntry;
  }
}

return resolved_flags;
1001}

1003uint32_t SymbolFileNativePDB::ResolveSymbolContext(
  const SourceLocationSpec &src_location_spec,
  lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list) {
return 0;
1007}

1009static void AppendLineEntryToSequence(LineTable &table, LineSequence &sequence,
                                    const CompilandIndexItem &cci,
                                    lldb::addr_t base_addr,
                                    uint32_t file_number,
                                    const LineFragmentHeader &block,
                                    const LineNumberEntry &cur) {
LineInfo cur_info(cur.Flags);

if (cur_info.isAlwaysStepInto() || cur_info.isNeverStepInto())
  return;

uint64_t addr = base_addr + cur.Offset;

bool is_statement = cur_info.isStatement();
bool is_prologue = IsFunctionPrologue(cci, addr);
bool is_epilogue = IsFunctionEpilogue(cci, addr);

uint32_t lno = cur_info.getStartLine();

table.AppendLineEntryToSequence(&sequence, addr, lno, 0, file_number,
                                is_statement, false, is_prologue, is_epilogue,
                                false);
1031}

1033static void TerminateLineSequence(LineTable &table,
                                const LineFragmentHeader &block,
                                lldb::addr_t base_addr, uint32_t file_number,
                                uint32_t last_line,
                                std::unique_ptr<LineSequence> seq) {
// The end is always a terminal entry, so insert it regardless.
table.AppendLineEntryToSequence(seq.get(), base_addr + block.CodeSize,
                                last_line, 0, file_number, false, false,
                                false, false, true);
table.InsertSequence(seq.get());
1043}

1045bool SymbolFileNativePDB::ParseLineTable(CompileUnit &comp_unit) {
// Unfortunately LLDB is set up to parse the entire compile unit line table
// all at once, even if all it really needs is line info for a specific
// function.  In the future it would be nice if it could set the sc.m_function
// member, and we could only get the line info for the function in question.
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
PdbSymUid cu_id(comp_unit.GetID());
lldbassert(cu_id.kind() == PdbSymUidKind::Compiland)lldb_private::lldb_assert(static_cast<bool>(cu_id.kind(
) == PdbSymUidKind::Compiland), "cu_id.kind() == PdbSymUidKind::Compiland"
, __FUNCTION__, "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp"
, 1052);
CompilandIndexItem *cci =
    m_index->compilands().GetCompiland(cu_id.asCompiland().modi);
lldbassert(cci)lldb_private::lldb_assert(static_cast<bool>(cci), "cci"
, __FUNCTION__, "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp"
, 1055);
auto line_table = std::make_unique<LineTable>(&comp_unit);

// This is basically a copy of the .debug$S subsections from all original COFF
// object files merged together with address relocations applied.  We are
// looking for all DEBUG_S_LINES subsections.
for (const DebugSubsectionRecord &dssr :
     cci->m_debug_stream.getSubsectionsArray()) {
  if (dssr.kind() != DebugSubsectionKind::Lines)
    continue;

  DebugLinesSubsectionRef lines;
  llvm::BinaryStreamReader reader(dssr.getRecordData());
  if (auto EC = lines.initialize(reader)) {
    llvm::consumeError(std::move(EC));
    return false;
  }

  const LineFragmentHeader *lfh = lines.header();
  uint64_t virtual_addr =
      m_index->MakeVirtualAddress(lfh->RelocSegment, lfh->RelocOffset);

  const auto &checksums = cci->m_strings.checksums().getArray();
  const auto &strings = cci->m_strings.strings();
  for (const LineColumnEntry &group : lines) {
    // Indices in this structure are actually offsets of records in the
    // DEBUG_S_FILECHECKSUMS subsection.  Those entries then have an index
    // into the global PDB string table.
    auto iter = checksums.at(group.NameIndex);
    if (iter == checksums.end())
      continue;

    llvm::Expected<llvm::StringRef> efn =
        strings.getString(iter->FileNameOffset);
    if (!efn) {
      llvm::consumeError(efn.takeError());
      continue;
    }

    // LLDB wants the index of the file in the list of support files.
    auto fn_iter = llvm::find(cci->m_file_list, *efn);
    lldbassert(fn_iter != cci->m_file_list.end())lldb_private::lldb_assert(static_cast<bool>(fn_iter != cci
->m_file_list.end()), "fn_iter != cci->m_file_list.end()"
, __FUNCTION__, "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp"
, 1096);
    uint32_t file_index = std::distance(cci->m_file_list.begin(), fn_iter);

    std::unique_ptr<LineSequence> sequence(
        line_table->CreateLineSequenceContainer());
    lldbassert(!group.LineNumbers.empty())lldb_private::lldb_assert(static_cast<bool>(!group.LineNumbers
.empty()), "!group.LineNumbers.empty()", __FUNCTION__, "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp"
, 1101);

    for (const LineNumberEntry &entry : group.LineNumbers) {
      AppendLineEntryToSequence(*line_table, *sequence, *cci, virtual_addr,
                                file_index, *lfh, entry);
    }
    LineInfo last_line(group.LineNumbers.back().Flags);
    TerminateLineSequence(*line_table, *lfh, virtual_addr, file_index,
                          last_line.getEndLine(), std::move(sequence));
  }
}

if (line_table->GetSize() == 0)
  return false;

comp_unit.SetLineTable(line_table.release());
return true;
1118}

1120bool SymbolFileNativePDB::ParseDebugMacros(CompileUnit &comp_unit) {
// PDB doesn't contain information about macros
return false;
1123}

1125bool SymbolFileNativePDB::ParseSupportFiles(CompileUnit &comp_unit,
                                          FileSpecList &support_files) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
PdbSymUid cu_id(comp_unit.GetID());
lldbassert(cu_id.kind() == PdbSymUidKind::Compiland)lldb_private::lldb_assert(static_cast<bool>(cu_id.kind(
) == PdbSymUidKind::Compiland), "cu_id.kind() == PdbSymUidKind::Compiland"
, __FUNCTION__, "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp"
, 1129);
CompilandIndexItem *cci =
    m_index->compilands().GetCompiland(cu_id.asCompiland().modi);
lldbassert(cci)lldb_private::lldb_assert(static_cast<bool>(cci), "cci"
, __FUNCTION__, "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp"
, 1132);

for (llvm::StringRef f : cci->m_file_list) {
  FileSpec::Style style =
      f.startswith("/") ? FileSpec::Style::posix : FileSpec::Style::windows;
  FileSpec spec(f, style);
  support_files.Append(spec);
}
return true;
1141}

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

1149size_t SymbolFileNativePDB::ParseBlocksRecursive(Function &func) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
GetOrCreateBlock(PdbSymUid(func.GetID()).asCompilandSym());
// FIXME: Parse child blocks
return 1;
1154}

1156void SymbolFileNativePDB::DumpClangAST(Stream &s) { m_ast->Dump(s); }

1158void SymbolFileNativePDB::FindGlobalVariables(
  ConstString name, const CompilerDeclContext &parent_decl_ctx,
  uint32_t max_matches, VariableList &variables) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
using SymbolAndOffset = std::pair<uint32_t, llvm::codeview::CVSymbol>;

std::vector<SymbolAndOffset> results = m_index->globals().findRecordsByName(
    name.GetStringRef(), m_index->symrecords());
for (const SymbolAndOffset &result : results) {
  VariableSP var;
  switch (result.second.kind()) {
  case SymbolKind::S_GDATA32:
  case SymbolKind::S_LDATA32:
  case SymbolKind::S_GTHREAD32:
  case SymbolKind::S_LTHREAD32:
  case SymbolKind::S_CONSTANT: {
    PdbGlobalSymId global(result.first, false);
    var = GetOrCreateGlobalVariable(global);
    variables.AddVariable(var);
    break;
  }
  default:
    continue;
  }
}
1183}

1185void SymbolFileNativePDB::FindFunctions(
  ConstString name, const CompilerDeclContext &parent_decl_ctx,
  FunctionNameType name_type_mask, bool include_inlines,
  SymbolContextList &sc_list) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
// For now we only support lookup by method name.
if (!(name_type_mask & eFunctionNameTypeMethod))
  return;

using SymbolAndOffset = std::pair<uint32_t, llvm::codeview::CVSymbol>;

std::vector<SymbolAndOffset> matches = m_index->globals().findRecordsByName(
    name.GetStringRef(), m_index->symrecords());
for (const SymbolAndOffset &match : matches) {
  if (match.second.kind() != S_PROCREF && match.second.kind() != S_LPROCREF)
    continue;
  ProcRefSym proc(match.second.kind());
  cantFail(SymbolDeserializer::deserializeAs<ProcRefSym>(match.second, proc));

  if (!IsValidRecord(proc))
    continue;

  CompilandIndexItem &cci =
      m_index->compilands().GetOrCreateCompiland(proc.modi());
  SymbolContext sc;

  sc.comp_unit = GetOrCreateCompileUnit(cci).get();
  PdbCompilandSymId func_id(proc.modi(), proc.SymOffset);
  sc.function = GetOrCreateFunction(func_id, *sc.comp_unit).get();

  sc_list.Append(sc);
}
1217}

1219void SymbolFileNativePDB::FindFunctions(const RegularExpression &regex,
                                      bool include_inlines,
                                      SymbolContextList &sc_list) {}

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

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

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

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

1242void SymbolFileNativePDB::FindTypesByName(llvm::StringRef name,
                                        uint32_t max_matches,
                                        TypeMap &types) {

std::vector<TypeIndex> matches = m_index->tpi().findRecordsByName(name);
if (max_matches > 0 && max_matches < matches.size())
  matches.resize(max_matches);

for (TypeIndex ti : matches) {
  TypeSP type = GetOrCreateType(ti);
  if (!type)
    continue;

  types.Insert(type);
}
1257}

1259size_t SymbolFileNativePDB::ParseTypes(CompileUnit &comp_unit) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
// Only do the full type scan the first time.
if (m_done_full_type_scan)
  return 0;

const size_t old_count = GetTypeList().GetSize();
LazyRandomTypeCollection &types = m_index->tpi().typeCollection();

// First process the entire TPI stream.
for (auto ti = types.getFirst(); ti; ti = types.getNext(*ti)) {
  TypeSP type = GetOrCreateType(*ti);
  if (type)
    (void)type->GetFullCompilerType();
}

// Next look for S_UDT records in the globals stream.
for (const uint32_t gid : m_index->globals().getGlobalsTable()) {
  PdbGlobalSymId global{gid, false};
  CVSymbol sym = m_index->ReadSymbolRecord(global);
  if (sym.kind() != S_UDT)
    continue;

  UDTSym udt = llvm::cantFail(SymbolDeserializer::deserializeAs<UDTSym>(sym));
  bool is_typedef = true;
  if (IsTagRecord(PdbTypeSymId{udt.Type, false}, m_index->tpi())) {
    CVType cvt = m_index->tpi().getType(udt.Type);
    llvm::StringRef name = CVTagRecord::create(cvt).name();
    if (name == udt.Name)
      is_typedef = false;
  }

  if (is_typedef)
    GetOrCreateTypedef(global);
}

const size_t new_count = GetTypeList().GetSize();

m_done_full_type_scan = true;

return new_count - old_count;
1300}

1302size_t
1303SymbolFileNativePDB::ParseVariablesForCompileUnit(CompileUnit &comp_unit,
                                                VariableList &variables) {
PdbSymUid sym_uid(comp_unit.GetID());
lldbassert(sym_uid.kind() == PdbSymUidKind::Compiland)lldb_private::lldb_assert(static_cast<bool>(sym_uid.kind
() == PdbSymUidKind::Compiland), "sym_uid.kind() == PdbSymUidKind::Compiland"
, __FUNCTION__, "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp"
, 1306);
return 0;
1308}

1310VariableSP SymbolFileNativePDB::CreateLocalVariable(PdbCompilandSymId scope_id,
                                                  PdbCompilandSymId var_id,
                                                  bool is_param) {
ModuleSP module = GetObjectFile()->GetModule();
Block &block = GetOrCreateBlock(scope_id);
VariableInfo var_info =
    GetVariableLocationInfo(*m_index, var_id, block, module);
if (!var_info.location || !var_info.ranges)
  return nullptr;

CompilandIndexItem *cii = m_index->compilands().GetCompiland(var_id.modi);
CompUnitSP comp_unit_sp = GetOrCreateCompileUnit(*cii);
TypeSP type_sp = GetOrCreateType(var_info.type);
std::string name = var_info.name.str();
Declaration decl;
SymbolFileTypeSP sftype =
    std::make_shared<SymbolFileType>(*this, type_sp->GetID());

ValueType var_scope =
    is_param ? eValueTypeVariableArgument : eValueTypeVariableLocal;
bool external = false;
bool artificial = false;
bool location_is_constant_data = false;
bool static_member = false;
VariableSP var_sp = std::make_shared<Variable>(
    toOpaqueUid(var_id), name.c_str(), name.c_str(), sftype, var_scope,
    comp_unit_sp.get(), *var_info.ranges, &decl, *var_info.location, external,
    artificial, location_is_constant_data, static_member);

if (!is_param)
  m_ast->GetOrCreateVariableDecl(scope_id, var_id);

m_local_variables[toOpaqueUid(var_id)] = var_sp;
return var_sp;
1344}

1346VariableSP SymbolFileNativePDB::GetOrCreateLocalVariable(
  PdbCompilandSymId scope_id, PdbCompilandSymId var_id, bool is_param) {
auto iter = m_local_variables.find(toOpaqueUid(var_id));
if (iter != m_local_variables.end())
  return iter->second;

return CreateLocalVariable(scope_id, var_id, is_param);
1353}

1355TypeSP SymbolFileNativePDB::CreateTypedef(PdbGlobalSymId id) {
CVSymbol sym = m_index->ReadSymbolRecord(id);
lldbassert(sym.kind() == SymbolKind::S_UDT)lldb_private::lldb_assert(static_cast<bool>(sym.kind() ==
 SymbolKind::S_UDT), "sym.kind() == SymbolKind::S_UDT", __FUNCTION__
, "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp"
, 1357);

UDTSym udt = llvm::cantFail(SymbolDeserializer::deserializeAs<UDTSym>(sym));

TypeSP target_type = GetOrCreateType(udt.Type);

(void)m_ast->GetOrCreateTypedefDecl(id);

Declaration decl;
return std::make_shared<lldb_private::Type>(
    toOpaqueUid(id), this, ConstString(udt.Name),
    target_type->GetByteSize(nullptr), nullptr, target_type->GetID(),
    lldb_private::Type::eEncodingIsTypedefUID, decl,
    target_type->GetForwardCompilerType(),
    lldb_private::Type::ResolveState::Forward);
1372}

1374TypeSP SymbolFileNativePDB::GetOrCreateTypedef(PdbGlobalSymId id) {
auto iter = m_types.find(toOpaqueUid(id));
if (iter != m_types.end())
  return iter->second;

return CreateTypedef(id);
1380}

1382size_t SymbolFileNativePDB::ParseVariablesForBlock(PdbCompilandSymId block_id) {
Block &block = GetOrCreateBlock(block_id);

size_t count = 0;

CompilandIndexItem *cii = m_index->compilands().GetCompiland(block_id.modi);
CVSymbol sym = cii->m_debug_stream.readSymbolAtOffset(block_id.offset);
uint32_t params_remaining = 0;
switch (sym.kind()) {
case S_GPROC32:
case S_LPROC32: {
  ProcSym proc(static_cast<SymbolRecordKind>(sym.kind()));
  cantFail(SymbolDeserializer::deserializeAs<ProcSym>(sym, proc));
  CVType signature = m_index->tpi().getType(proc.FunctionType);
  ProcedureRecord sig;
  cantFail(TypeDeserializer::deserializeAs<ProcedureRecord>(signature, sig));
  params_remaining = sig.getParameterCount();
  break;
}
case S_BLOCK32:
  break;
default:
  lldbassert(false && "Symbol is not a block!")lldb_private::lldb_assert(static_cast<bool>(false &&
 "Symbol is not a block!"), "false && \"Symbol is not a block!\""
, __FUNCTION__, "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp"
, 1404);
  return 0;
}

VariableListSP variables = block.GetBlockVariableList(false);
if (!variables) {
  variables = std::make_shared<VariableList>();
  block.SetVariableList(variables);
}

CVSymbolArray syms = limitSymbolArrayToScope(
    cii->m_debug_stream.getSymbolArray(), block_id.offset);

// Skip the first record since it's a PROC32 or BLOCK32, and there's
// no point examining it since we know it's not a local variable.
syms.drop_front();
auto iter = syms.begin();
auto end = syms.end();

while (iter != end) {
  uint32_t record_offset = iter.offset();
  CVSymbol variable_cvs = *iter;
  PdbCompilandSymId child_sym_id(block_id.modi, record_offset);
  ++iter;

  // If this is a block, recurse into its children and then skip it.
  if (variable_cvs.kind() == S_BLOCK32) {
    uint32_t block_end = getScopeEndOffset(variable_cvs);
    count += ParseVariablesForBlock(child_sym_id);
    iter = syms.at(block_end);
    continue;
  }

  bool is_param = params_remaining > 0;
  VariableSP variable;
  switch (variable_cvs.kind()) {
  case S_REGREL32:
  case S_REGISTER:
  case S_LOCAL:
    variable = GetOrCreateLocalVariable(block_id, child_sym_id, is_param);
    if (is_param)
      --params_remaining;
    if (variable)
      variables->AddVariableIfUnique(variable);
    break;
  default:
    break;
  }
}

// Pass false for set_children, since we call this recursively so that the
// children will call this for themselves.
block.SetDidParseVariables(true, false);

return count;
1459}

1461size_t SymbolFileNativePDB::ParseVariablesForContext(const SymbolContext &sc) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
lldbassert(sc.function || sc.comp_unit)lldb_private::lldb_assert(static_cast<bool>(sc.function
 || sc.comp_unit), "sc.function || sc.comp_unit", __FUNCTION__
, "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp"
, 1463);

VariableListSP variables;
if (sc.block) {
  PdbSymUid block_id(sc.block->GetID());

  size_t count = ParseVariablesForBlock(block_id.asCompilandSym());
  return count;
}

if (sc.function) {
  PdbSymUid block_id(sc.function->GetID());

  size_t count = ParseVariablesForBlock(block_id.asCompilandSym());
  return count;
}

if (sc.comp_unit) {
  variables = sc.comp_unit->GetVariableList(false);
  if (!variables) {
    variables = std::make_shared<VariableList>();
    sc.comp_unit->SetVariableList(variables);
  }
  return ParseVariablesForCompileUnit(*sc.comp_unit, *variables);
}

llvm_unreachable("Unreachable!")__builtin_unreachable();
1490}

1492CompilerDecl SymbolFileNativePDB::GetDeclForUID(lldb::user_id_t uid) {
if (auto decl = m_ast->GetOrCreateDeclForUid(uid))
  return decl.getValue();
else
  return CompilerDecl();
1497}

1499CompilerDeclContext
1500SymbolFileNativePDB::GetDeclContextForUID(lldb::user_id_t uid) {
clang::DeclContext *context =
    m_ast->GetOrCreateDeclContextForUid(PdbSymUid(uid));
if (!context)
  return {};

return m_ast->ToCompilerDeclContext(*context);
1507}

1509CompilerDeclContext
1510SymbolFileNativePDB::GetDeclContextContainingUID(lldb::user_id_t uid) {
clang::DeclContext *context = m_ast->GetParentDeclContext(PdbSymUid(uid));
return m_ast->ToCompilerDeclContext(*context);
1513}

1515Type *SymbolFileNativePDB::ResolveTypeUID(lldb::user_id_t type_uid) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
auto iter = m_types.find(type_uid);
// lldb should not be passing us non-sensical type uids.  the only way it
// could have a type uid in the first place is if we handed it out, in which
// case we should know about the type.  However, that doesn't mean we've
// instantiated it yet.  We can vend out a UID for a future type.  So if the
// type doesn't exist, let's instantiate it now.
if (iter != m_types.end())
  return &*iter->second;

PdbSymUid uid(type_uid);
lldbassert(uid.kind() == PdbSymUidKind::Type)lldb_private::lldb_assert(static_cast<bool>(uid.kind() ==
 PdbSymUidKind::Type), "uid.kind() == PdbSymUidKind::Type", __FUNCTION__
, "/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp"
, 1527);
PdbTypeSymId type_id = uid.asTypeSym();
if (type_id.index.isNoneType())
  return nullptr;

TypeSP type_sp = CreateAndCacheType(type_id);
return &*type_sp;
1534}

1536llvm::Optional<SymbolFile::ArrayInfo>
1537SymbolFileNativePDB::GetDynamicArrayInfoForUID(
  lldb::user_id_t type_uid, const lldb_private::ExecutionContext *exe_ctx) {
return llvm::None;
1540}


1543bool SymbolFileNativePDB::CompleteType(CompilerType &compiler_type) {
clang::QualType qt =
    clang::QualType::getFromOpaquePtr(compiler_type.GetOpaqueQualType());

return m_ast->CompleteType(qt);
1548}

1550void SymbolFileNativePDB::GetTypes(lldb_private::SymbolContextScope *sc_scope,
                                 TypeClass type_mask,
                                 lldb_private::TypeList &type_list) {}

1554CompilerDeclContext
1555SymbolFileNativePDB::FindNamespace(ConstString name,
                                 const CompilerDeclContext &parent_decl_ctx) {
return {};
1558}

1560llvm::Expected<TypeSystem &>
1561SymbolFileNativePDB::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;
1568}

1570ConstString SymbolFileNativePDB::GetPluginName() {
static ConstString g_name("pdb");
return g_name;
1573}

1575uint32_t SymbolFileNativePDB::GetPluginVersion() { return 1; }

←

/usr/src/gnu/usr.bin/clang/liblldbPluginSymbolFile/../../../llvm/llvm/include/llvm/Support/Error.h

1//===- llvm/Support/Error.h - Recoverable error handling --------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file defines an API used to report recoverable errors.
10//
11//===----------------------------------------------------------------------===//
12 
13#ifndef LLVM_SUPPORT_ERROR_H
14#define LLVM_SUPPORT_ERROR_H
15 
16#include "llvm-c/Error.h"
17#include "llvm/ADT/STLExtras.h"
18#include "llvm/ADT/SmallVector.h"
19#include "llvm/ADT/StringExtras.h"
20#include "llvm/ADT/Twine.h"
21#include "llvm/Config/abi-breaking.h"
22#include "llvm/Support/AlignOf.h"
23#include "llvm/Support/Compiler.h"
24#include "llvm/Support/Debug.h"
25#include "llvm/Support/ErrorHandling.h"
26#include "llvm/Support/ErrorOr.h"
27#include "llvm/Support/Format.h"
28#include "llvm/Support/raw_ostream.h"
29#include <algorithm>
30#include <cassert>
31#include <cstdint>
32#include <cstdlib>
33#include <functional>
34#include <memory>
35#include <new>
36#include <string>
37#include <system_error>
38#include <type_traits>
39#include <utility>
40#include <vector>
41 
42namespace llvm {
43 
44class ErrorSuccess;
45 
46/// Base class for error info classes. Do not extend this directly: Extend
47/// the ErrorInfo template subclass instead.
48class ErrorInfoBase {
49public:
50  virtual ~ErrorInfoBase() = default;
51 
52  /// Print an error message to an output stream.
53  virtual void log(raw_ostream &OS) const = 0;
54 
55  /// Return the error message as a string.
56  virtual std::string message() const {
57    std::string Msg;
58    raw_string_ostream OS(Msg);
59    log(OS);
60    return OS.str();
61  }
62 
63  /// Convert this error to a std::error_code.
64  ///
65  /// This is a temporary crutch to enable interaction with code still
66  /// using std::error_code. It will be removed in the future.
67  virtual std::error_code convertToErrorCode() const = 0;
68 
69  // Returns the class ID for this type.
70  static const void *classID() { return &ID; }
71 
72  // Returns the class ID for the dynamic type of this ErrorInfoBase instance.
73  virtual const void *dynamicClassID() const = 0;
74 
75  // Check whether this instance is a subclass of the class identified by
76  // ClassID.
77  virtual bool isA(const void *const ClassID) const {
78    return ClassID == classID();
79  }
80 
81  // Check whether this instance is a subclass of ErrorInfoT.
82  template <typename ErrorInfoT> bool isA() const {
83    return isA(ErrorInfoT::classID());
84  }
85 
86private:
87  virtual void anchor();
88 
89  static char ID;
90};
91 
92/// Lightweight error class with error context and mandatory checking.
93///
94/// Instances of this class wrap a ErrorInfoBase pointer. Failure states
95/// are represented by setting the pointer to a ErrorInfoBase subclass
96/// instance containing information describing the failure. Success is
97/// represented by a null pointer value.
98///
99/// Instances of Error also contains a 'Checked' flag, which must be set
100/// before the destructor is called, otherwise the destructor will trigger a
101/// runtime error. This enforces at runtime the requirement that all Error
102/// instances be checked or returned to the caller.
103///
104/// There are two ways to set the checked flag, depending on what state the
105/// Error instance is in. For Error instances indicating success, it
106/// is sufficient to invoke the boolean conversion operator. E.g.:
107///
108///   @code{.cpp}
109///   Error foo(<...>);
110///
111///   if (auto E = foo(<...>))
112///     return E; // <- Return E if it is in the error state.
113///   // We have verified that E was in the success state. It can now be safely
114///   // destroyed.
115///   @endcode
116///
117/// A success value *can not* be dropped. For example, just calling 'foo(<...>)'
118/// without testing the return value will raise a runtime error, even if foo
119/// returns success.
120///
121/// For Error instances representing failure, you must use either the
122/// handleErrors or handleAllErrors function with a typed handler. E.g.:
123///
124///   @code{.cpp}
125///   class MyErrorInfo : public ErrorInfo<MyErrorInfo> {
126///     // Custom error info.
127///   };
128///
129///   Error foo(<...>) { return make_error<MyErrorInfo>(...); }
130///
131///   auto E = foo(<...>); // <- foo returns failure with MyErrorInfo.
132///   auto NewE =
133///     handleErrors(E,
134///       [](const MyErrorInfo &M) {
135///         // Deal with the error.
136///       },
137///       [](std::unique_ptr<OtherError> M) -> Error {
138///         if (canHandle(*M)) {
139///           // handle error.
140///           return Error::success();
141///         }
142///         // Couldn't handle this error instance. Pass it up the stack.
143///         return Error(std::move(M));
144///       );
145///   // Note - we must check or return NewE in case any of the handlers
146///   // returned a new error.
147///   @endcode
148///
149/// The handleAllErrors function is identical to handleErrors, except
150/// that it has a void return type, and requires all errors to be handled and
151/// no new errors be returned. It prevents errors (assuming they can all be
152/// handled) from having to be bubbled all the way to the top-level.
153///
154/// *All* Error instances must be checked before destruction, even if
155/// they're moved-assigned or constructed from Success values that have already
156/// been checked. This enforces checking through all levels of the call stack.
157class LLVM_NODISCARD[[clang::warn_unused_result]] Error {
158  // ErrorList needs to be able to yank ErrorInfoBase pointers out of Errors
159  // to add to the error list. It can't rely on handleErrors for this, since
160  // handleErrors does not support ErrorList handlers.
161  friend class ErrorList;
162 
163  // handleErrors needs to be able to set the Checked flag.
164  template <typename... HandlerTs>
165  friend Error handleErrors(Error E, HandlerTs &&... Handlers);
166 
167  // Expected<T> needs to be able to steal the payload when constructed from an
168  // error.
169  template <typename T> friend class Expected;
170 
171  // wrap needs to be able to steal the payload.
172  friend LLVMErrorRef wrap(Error);
173 
174protected:
175  /// Create a success value. Prefer using 'Error::success()' for readability
176  Error() {
177    setPtr(nullptr);
178    setChecked(false);
179  }
180 
181public:
182  /// Create a success value.
183  static ErrorSuccess success();
184 
185  // Errors are not copy-constructable.
186  Error(const Error &Other) = delete;
187 
188  /// Move-construct an error value. The newly constructed error is considered
189  /// unchecked, even if the source error had been checked. The original error
190  /// becomes a checked Success value, regardless of its original state.
191  Error(Error &&Other) {
192    setChecked(true);
193    *this = std::move(Other);
194  }
195 
196  /// Create an error value. Prefer using the 'make_error' function, but
197  /// this constructor can be useful when "re-throwing" errors from handlers.
198  Error(std::unique_ptr<ErrorInfoBase> Payload) {
199    setPtr(Payload.release());
200    setChecked(false);
201  }
202 
203  // Errors are not copy-assignable.
204  Error &operator=(const Error &Other) = delete;
205 
206  /// Move-assign an error value. The current error must represent success, you
207  /// you cannot overwrite an unhandled error. The current error is then
208  /// considered unchecked. The source error becomes a checked success value,
209  /// regardless of its original state.
210  Error &operator=(Error &&Other) {
211    // Don't allow overwriting of unchecked values.
212    assertIsChecked();
213    setPtr(Other.getPtr());
214 
215    // This Error is unchecked, even if the source error was checked.
216    setChecked(false);
217 
218    // Null out Other's payload and set its checked bit.
219    Other.setPtr(nullptr);
220    Other.setChecked(true);
221 
222    return *this;
223  }
224 
225  /// Destroy a Error. Fails with a call to abort() if the error is
226  /// unchecked.
227  ~Error() {
228    assertIsChecked();
229    delete getPtr();
230  }
231 
232  /// Bool conversion. Returns true if this Error is in a failure state,
233  /// and false if it is in an accept state. If the error is in a Success state
234  /// it will be considered checked.
235  explicit operator bool() {
236    setChecked(getPtr() == nullptr);
2
←
Assuming the condition is true→
237    return getPtr() != nullptr;
3
←
Returning zero, which participates in a condition later→
238  }
239 
240  /// Check whether one error is a subclass of another.
241  template <typename ErrT> bool isA() const {
242    return getPtr() && getPtr()->isA(ErrT::classID());
243  }
244 
245  /// Returns the dynamic class id of this error, or null if this is a success
246  /// value.
247  const void* dynamicClassID() const {
248    if (!getPtr())
249      return nullptr;
250    return getPtr()->dynamicClassID();
251  }
252 
253private:
254#if LLVM_ENABLE_ABI_BREAKING_CHECKS0
255  // assertIsChecked() happens very frequently, but under normal circumstances
256  // is supposed to be a no-op.  So we want it to be inlined, but having a bunch
257  // of debug prints can cause the function to be too large for inlining.  So
258  // it's important that we define this function out of line so that it can't be
259  // inlined.
260  LLVM_ATTRIBUTE_NORETURN__attribute__((noreturn))
261  void fatalUncheckedError() const;
262#endif
263 
264  void assertIsChecked() {
265#if LLVM_ENABLE_ABI_BREAKING_CHECKS0
266    if (LLVM_UNLIKELY(!getChecked() || getPtr())__builtin_expect((bool)(!getChecked() || getPtr()), false))
267      fatalUncheckedError();
268#endif
269  }
270 
271  ErrorInfoBase *getPtr() const {
272#if LLVM_ENABLE_ABI_BREAKING_CHECKS0
273    return reinterpret_cast<ErrorInfoBase*>(
274             reinterpret_cast<uintptr_t>(Payload) &
275             ~static_cast<uintptr_t>(0x1));
276#else
277    return Payload;
278#endif
279  }
280 
281  void setPtr(ErrorInfoBase *EI) {
282#if LLVM_ENABLE_ABI_BREAKING_CHECKS0
283    Payload = reinterpret_cast<ErrorInfoBase*>(
284                (reinterpret_cast<uintptr_t>(EI) &
285                 ~static_cast<uintptr_t>(0x1)) |
286                (reinterpret_cast<uintptr_t>(Payload) & 0x1));
287#else
288    Payload = EI;
289#endif
290  }
291 
292  bool getChecked() const {
293#if LLVM_ENABLE_ABI_BREAKING_CHECKS0
294    return (reinterpret_cast<uintptr_t>(Payload) & 0x1) == 0;
295#else
296    return true;
297#endif
298  }
299 
300  void setChecked(bool V) {
301#if LLVM_ENABLE_ABI_BREAKING_CHECKS0
302    Payload = reinterpret_cast<ErrorInfoBase*>(
303                (reinterpret_cast<uintptr_t>(Payload) &
304                  ~static_cast<uintptr_t>(0x1)) |
305                  (V ? 0 : 1));
306#endif
307  }
308 
309  std::unique_ptr<ErrorInfoBase> takePayload() {
310    std::unique_ptr<ErrorInfoBase> Tmp(getPtr());
311    setPtr(nullptr);
312    setChecked(true);
313    return Tmp;
314  }
315 
316  friend raw_ostream &operator<<(raw_ostream &OS, const Error &E) {
317    if (auto P = E.getPtr())
318      P->log(OS);
319    else
320      OS << "success";
321    return OS;
322  }
323 
324  ErrorInfoBase *Payload = nullptr;
325};
326 
327/// Subclass of Error for the sole purpose of identifying the success path in
328/// the type system. This allows to catch invalid conversion to Expected<T> at
329/// compile time.
330class ErrorSuccess final : public Error {};
331 
332inline ErrorSuccess Error::success() { return ErrorSuccess(); }
333 
334/// Make a Error instance representing failure using the given error info
335/// type.
336template <typename ErrT, typename... ArgTs> Error make_error(ArgTs &&... Args) {
337  return Error(std::make_unique<ErrT>(std::forward<ArgTs>(Args)...));
338}
339 
340/// Base class for user error types. Users should declare their error types
341/// like:
342///
343/// class MyError : public ErrorInfo<MyError> {
344///   ....
345/// };
346///
347/// This class provides an implementation of the ErrorInfoBase::kind
348/// method, which is used by the Error RTTI system.
349template <typename ThisErrT, typename ParentErrT = ErrorInfoBase>
350class ErrorInfo : public ParentErrT {
351public:
352  using ParentErrT::ParentErrT; // inherit constructors
353 
354  static const void *classID() { return &ThisErrT::ID; }
355 
356  const void *dynamicClassID() const override { return &ThisErrT::ID; }
357 
358  bool isA(const void *const ClassID) const override {
359    return ClassID == classID() || ParentErrT::isA(ClassID);
360  }
361};
362 
363/// Special ErrorInfo subclass representing a list of ErrorInfos.
364/// Instances of this class are constructed by joinError.
365class ErrorList final : public ErrorInfo<ErrorList> {
366  // handleErrors needs to be able to iterate the payload list of an
367  // ErrorList.
368  template <typename... HandlerTs>
369  friend Error handleErrors(Error E, HandlerTs &&... Handlers);
370 
371  // joinErrors is implemented in terms of join.
372  friend Error joinErrors(Error, Error);
373 
374public:
375  void log(raw_ostream &OS) const override {
376    OS << "Multiple errors:\n";
377    for (auto &ErrPayload : Payloads) {
378      ErrPayload->log(OS);
379      OS << "\n";
380    }
381  }
382 
383  std::error_code convertToErrorCode() const override;
384 
385  // Used by ErrorInfo::classID.
386  static char ID;
387 
388private:
389  ErrorList(std::unique_ptr<ErrorInfoBase> Payload1,
390            std::unique_ptr<ErrorInfoBase> Payload2) {
391    assert(!Payload1->isA<ErrorList>() && !Payload2->isA<ErrorList>() &&((void)0)
392           "ErrorList constructor payloads should be singleton errors")((void)0);
393    Payloads.push_back(std::move(Payload1));
394    Payloads.push_back(std::move(Payload2));
395  }
396 
397  static Error join(Error E1, Error E2) {
398    if (!E1)
399      return E2;
400    if (!E2)
401      return E1;
402    if (E1.isA<ErrorList>()) {
403      auto &E1List = static_cast<ErrorList &>(*E1.getPtr());
404      if (E2.isA<ErrorList>()) {
405        auto E2Payload = E2.takePayload();
406        auto &E2List = static_cast<ErrorList &>(*E2Payload);
407        for (auto &Payload : E2List.Payloads)
408          E1List.Payloads.push_back(std::move(Payload));
409      } else
410        E1List.Payloads.push_back(E2.takePayload());
411 
412      return E1;
413    }
414    if (E2.isA<ErrorList>()) {
415      auto &E2List = static_cast<ErrorList &>(*E2.getPtr());
416      E2List.Payloads.insert(E2List.Payloads.begin(), E1.takePayload());
417      return E2;
418    }
419    return Error(std::unique_ptr<ErrorList>(
420        new ErrorList(E1.takePayload(), E2.takePayload())));
421  }
422 
423  std::vector<std::unique_ptr<ErrorInfoBase>> Payloads;
424};
425 
426/// Concatenate errors. The resulting Error is unchecked, and contains the
427/// ErrorInfo(s), if any, contained in E1, followed by the
428/// ErrorInfo(s), if any, contained in E2.
429inline Error joinErrors(Error E1, Error E2) {
430  return ErrorList::join(std::move(E1), std::move(E2));
431}
432 
433/// Tagged union holding either a T or a Error.
434///
435/// This class parallels ErrorOr, but replaces error_code with Error. Since
436/// Error cannot be copied, this class replaces getError() with
437/// takeError(). It also adds an bool errorIsA<ErrT>() method for testing the
438/// error class type.
439///
440/// Example usage of 'Expected<T>' as a function return type:
441///
442///   @code{.cpp}
443///     Expected<int> myDivide(int A, int B) {
444///       if (B == 0) {
445///         // return an Error
446///         return createStringError(inconvertibleErrorCode(),
447///                                  "B must not be zero!");
448///       }
449///       // return an integer
450///       return A / B;
451///     }
452///   @endcode
453///
454///   Checking the results of to a function returning 'Expected<T>':
455///   @code{.cpp}
456///     if (auto E = Result.takeError()) {
457///       // We must consume the error. Typically one of:
458///       // - return the error to our caller
459///       // - toString(), when logging
460///       // - consumeError(), to silently swallow the error
461///       // - handleErrors(), to distinguish error types
462///       errs() << "Problem with division " << toString(std::move(E)) << "\n";
463///       return;
464///     }
465///     // use the result
466///     outs() << "The answer is " << *Result << "\n";
467///   @endcode
468///
469///  For unit-testing a function returning an 'Expceted<T>', see the
470///  'EXPECT_THAT_EXPECTED' macros in llvm/Testing/Support/Error.h
471 
472template <class T> class LLVM_NODISCARD[[clang::warn_unused_result]] Expected {
473  template <class T1> friend class ExpectedAsOutParameter;
474  template <class OtherT> friend class Expected;
475 
476  static constexpr bool isRef = std::is_reference<T>::value;
477 
478  using wrap = std::reference_wrapper<std::remove_reference_t<T>>;
479 
480  using error_type = std::unique_ptr<ErrorInfoBase>;
481 
482public:
483  using storage_type = std::conditional_t<isRef, wrap, T>;
484  using value_type = T;
485 
486private:
487  using reference = std::remove_reference_t<T> &;
488  using const_reference = const std::remove_reference_t<T> &;
489  using pointer = std::remove_reference_t<T> *;
490  using const_pointer = const std::remove_reference_t<T> *;
491 
492public:
493  /// Create an Expected<T> error value from the given Error.
494  Expected(Error Err)
495      : HasError(true)
496#if LLVM_ENABLE_ABI_BREAKING_CHECKS0
497        // Expected is unchecked upon construction in Debug builds.
498        , Unchecked(true)
499#endif
500  {
501    assert(Err && "Cannot create Expected<T> from Error success value.")((void)0);
502    new (getErrorStorage()) error_type(Err.takePayload());
503  }
504 
505  /// Forbid to convert from Error::success() implicitly, this avoids having
506  /// Expected<T> foo() { return Error::success(); } which compiles otherwise
507  /// but triggers the assertion above.
508  Expected(ErrorSuccess) = delete;
509 
510  /// Create an Expected<T> success value from the given OtherT value, which
511  /// must be convertible to T.
512  template <typename OtherT>
513  Expected(OtherT &&Val,
514           std::enable_if_t<std::is_convertible<OtherT, T>::value> * = nullptr)
515      : HasError(false)
516#if LLVM_ENABLE_ABI_BREAKING_CHECKS0
517        // Expected is unchecked upon construction in Debug builds.
518        ,
519        Unchecked(true)
520#endif
521  {
522    new (getStorage()) storage_type(std::forward<OtherT>(Val));
523  }
524 
525  /// Move construct an Expected<T> value.
526  Expected(Expected &&Other) { moveConstruct(std::move(Other)); }
527 
528  /// Move construct an Expected<T> value from an Expected<OtherT>, where OtherT
529  /// must be convertible to T.
530  template <class OtherT>
531  Expected(
532      Expected<OtherT> &&Other,
533      std::enable_if_t<std::is_convertible<OtherT, T>::value> * = nullptr) {
534    moveConstruct(std::move(Other));
535  }
536 
537  /// Move construct an Expected<T> value from an Expected<OtherT>, where OtherT
538  /// isn't convertible to T.
539  template <class OtherT>
540  explicit Expected(
541      Expected<OtherT> &&Other,
542      std::enable_if_t<!std::is_convertible<OtherT, T>::value> * = nullptr) {
543    moveConstruct(std::move(Other));
544  }
545 
546  /// Move-assign from another Expected<T>.
547  Expected &operator=(Expected &&Other) {
548    moveAssign(std::move(Other));
549    return *this;
550  }
551 
552  /// Destroy an Expected<T>.
553  ~Expected() {
554    assertIsChecked();
555    if (!HasError)
556      getStorage()->~storage_type();
557    else
558      getErrorStorage()->~error_type();
559  }
560 
561  /// Return false if there is an error.
562  explicit operator bool() {
563#if LLVM_ENABLE_ABI_BREAKING_CHECKS0
564    Unchecked = HasError;
565#endif
566    return !HasError;
567  }
568 
569  /// Returns a reference to the stored T value.
570  reference get() {
571    assertIsChecked();
572    return *getStorage();
573  }
574 
575  /// Returns a const reference to the stored T value.
576  const_reference get() const {
577    assertIsChecked();
578    return const_cast<Expected<T> *>(this)->get();
579  }
580 
581  /// Check that this Expected<T> is an error of type ErrT.
582  template <typename ErrT> bool errorIsA() const {
583    return HasError && (*getErrorStorage())->template isA<ErrT>();
584  }
585 
586  /// Take ownership of the stored error.
587  /// After calling this the Expected<T> is in an indeterminate state that can
588  /// only be safely destructed. No further calls (beside the destructor) should
589  /// be made on the Expected<T> value.
590  Error takeError() {
591#if LLVM_ENABLE_ABI_BREAKING_CHECKS0
592    Unchecked = false;
593#endif
594    return HasError ? Error(std::move(*getErrorStorage())) : Error::success();
595  }
596 
597  /// Returns a pointer to the stored T value.
598  pointer operator->() {
599    assertIsChecked();
600    return toPointer(getStorage());
601  }
602 
603  /// Returns a const pointer to the stored T value.
604  const_pointer operator->() const {
605    assertIsChecked();
606    return toPointer(getStorage());
607  }
608 
609  /// Returns a reference to the stored T value.
610  reference operator*() {
611    assertIsChecked();
612    return *getStorage();
613  }
614 
615  /// Returns a const reference to the stored T value.
616  const_reference operator*() const {
617    assertIsChecked();
618    return *getStorage();
619  }
620 
621private:
622  template <class T1>
623  static bool compareThisIfSameType(const T1 &a, const T1 &b) {
624    return &a == &b;
625  }
626 
627  template <class T1, class T2>
628  static bool compareThisIfSameType(const T1 &, const T2 &) {
629    return false;
630  }
631 
632  template <class OtherT> void moveConstruct(Expected<OtherT> &&Other) {
633    HasError = Other.HasError;
634#if LLVM_ENABLE_ABI_BREAKING_CHECKS0
635    Unchecked = true;
636    Other.Unchecked = false;
637#endif
638 
639    if (!HasError)
640      new (getStorage()) storage_type(std::move(*Other.getStorage()));
641    else
642      new (getErrorStorage()) error_type(std::move(*Other.getErrorStorage()));
643  }
644 
645  template <class OtherT> void moveAssign(Expected<OtherT> &&Other) {
646    assertIsChecked();
647 
648    if (compareThisIfSameType(*this, Other))
649      return;
650 
651    this->~Expected();
652    new (this) Expected(std::move(Other));
653  }
654 
655  pointer toPointer(pointer Val) { return Val; }
656 
657  const_pointer toPointer(const_pointer Val) const { return Val; }
658 
659  pointer toPointer(wrap *Val) { return &Val->get(); }
660 
661  const_pointer toPointer(const wrap *Val) const { return &Val->get(); }
662 
663  storage_type *getStorage() {
664    assert(!HasError && "Cannot get value when an error exists!")((void)0);
665    return reinterpret_cast<storage_type *>(&TStorage);
666  }
667 
668  const storage_type *getStorage() const {
669    assert(!HasError && "Cannot get value when an error exists!")((void)0);
670    return reinterpret_cast<const storage_type *>(&TStorage);
671  }
672 
673  error_type *getErrorStorage() {
674    assert(HasError && "Cannot get error when a value exists!")((void)0);
675    return reinterpret_cast<error_type *>(&ErrorStorage);
676  }
677 
678  const error_type *getErrorStorage() const {
679    assert(HasError && "Cannot get error when a value exists!")((void)0);
680    return reinterpret_cast<const error_type *>(&ErrorStorage);
681  }
682 
683  // Used by ExpectedAsOutParameter to reset the checked flag.
684  void setUnchecked() {
685#if LLVM_ENABLE_ABI_BREAKING_CHECKS0
686    Unchecked = true;
687#endif
688  }
689 
690#if LLVM_ENABLE_ABI_BREAKING_CHECKS0
691  LLVM_ATTRIBUTE_NORETURN__attribute__((noreturn))
692  LLVM_ATTRIBUTE_NOINLINE__attribute__((noinline))
693  void fatalUncheckedExpected() const {
694    dbgs() << "Expected<T> must be checked before access or destruction.\n";
695    if (HasError) {
696      dbgs() << "Unchecked Expected<T> contained error:\n";
697      (*getErrorStorage())->log(dbgs());
698    } else
699      dbgs() << "Expected<T> value was in success state. (Note: Expected<T> "
700                "values in success mode must still be checked prior to being "
701                "destroyed).\n";
702    abort();
703  }
704#endif
705 
706  void assertIsChecked() const {
707#if LLVM_ENABLE_ABI_BREAKING_CHECKS0
708    if (LLVM_UNLIKELY(Unchecked)__builtin_expect((bool)(Unchecked), false))
709      fatalUncheckedExpected();
710#endif
711  }
712 
713  union {
714    AlignedCharArrayUnion<storage_type> TStorage;
715    AlignedCharArrayUnion<error_type> ErrorStorage;
716  };
717  bool HasError : 1;
718#if LLVM_ENABLE_ABI_BREAKING_CHECKS0
719  bool Unchecked : 1;
720#endif
721};
722 
723/// Report a serious error, calling any installed error handler. See
724/// ErrorHandling.h.
725LLVM_ATTRIBUTE_NORETURN__attribute__((noreturn)) void report_fatal_error(Error Err,
726                                                bool gen_crash_diag = true);
727 
728/// Report a fatal error if Err is a failure value.
729///
730/// This function can be used to wrap calls to fallible functions ONLY when it
731/// is known that the Error will always be a success value. E.g.
732///
733///   @code{.cpp}
734///   // foo only attempts the fallible operation if DoFallibleOperation is
735///   // true. If DoFallibleOperation is false then foo always returns
736///   // Error::success().
737///   Error foo(bool DoFallibleOperation);
738///
739///   cantFail(foo(false));
740///   @endcode
741inline void cantFail(Error Err, const char *Msg = nullptr) {
742  if (Err) {
743    if (!Msg)
744      Msg = "Failure value returned from cantFail wrapped call";
745#ifndef NDEBUG1
746    std::string Str;
747    raw_string_ostream OS(Str);
748    OS << Msg << "\n" << Err;
749    Msg = OS.str().c_str();
750#endif
751    llvm_unreachable(Msg)__builtin_unreachable();
752  }
753}
754 
755/// Report a fatal error if ValOrErr is a failure value, otherwise unwraps and
756/// returns the contained value.
757///
758/// This function can be used to wrap calls to fallible functions ONLY when it
759/// is known that the Error will always be a success value. E.g.
760///
761///   @code{.cpp}
762///   // foo only attempts the fallible operation if DoFallibleOperation is
763///   // true. If DoFallibleOperation is false then foo always returns an int.
764///   Expected<int> foo(bool DoFallibleOperation);
765///
766///   int X = cantFail(foo(false));
767///   @endcode
768template <typename T>
769T cantFail(Expected<T> ValOrErr, const char *Msg = nullptr) {
770  if (ValOrErr)
771    return std::move(*ValOrErr);
772  else {
773    if (!Msg)
774      Msg = "Failure value returned from cantFail wrapped call";
775#ifndef NDEBUG1
776    std::string Str;
777    raw_string_ostream OS(Str);
778    auto E = ValOrErr.takeError();
779    OS << Msg << "\n" << E;
780    Msg = OS.str().c_str();
781#endif
782    llvm_unreachable(Msg)__builtin_unreachable();
783  }
784}
785 
786/// Report a fatal error if ValOrErr is a failure value, otherwise unwraps and
787/// returns the contained reference.
788///
789/// This function can be used to wrap calls to fallible functions ONLY when it
790/// is known that the Error will always be a success value. E.g.
791///
792///   @code{.cpp}
793///   // foo only attempts the fallible operation if DoFallibleOperation is
794///   // true. If DoFallibleOperation is false then foo always returns a Bar&.
795///   Expected<Bar&> foo(bool DoFallibleOperation);
796///
797///   Bar &X = cantFail(foo(false));
798///   @endcode
799template <typename T>
800T& cantFail(Expected<T&> ValOrErr, const char *Msg = nullptr) {
801  if (ValOrErr)
802    return *ValOrErr;
803  else {
804    if (!Msg)
805      Msg = "Failure value returned from cantFail wrapped call";
806#ifndef NDEBUG1
807    std::string Str;
808    raw_string_ostream OS(Str);
809    auto E = ValOrErr.takeError();
810    OS << Msg << "\n" << E;
811    Msg = OS.str().c_str();
812#endif
813    llvm_unreachable(Msg)__builtin_unreachable();
814  }
815}
816 
817/// Helper for testing applicability of, and applying, handlers for
818/// ErrorInfo types.
819template <typename HandlerT>
820class ErrorHandlerTraits
821    : public ErrorHandlerTraits<decltype(
822          &std::remove_reference<HandlerT>::type::operator())> {};
823 
824// Specialization functions of the form 'Error (const ErrT&)'.
825template <typename ErrT> class ErrorHandlerTraits<Error (&)(ErrT &)> {
826public:
827  static bool appliesTo(const ErrorInfoBase &E) {
828    return E.template isA<ErrT>();
829  }
830 
831  template <typename HandlerT>
832  static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
833    assert(appliesTo(*E) && "Applying incorrect handler")((void)0);
834    return H(static_cast<ErrT &>(*E));
835  }
836};
837 
838// Specialization functions of the form 'void (const ErrT&)'.
839template <typename ErrT> class ErrorHandlerTraits<void (&)(ErrT &)> {
840public:
841  static bool appliesTo(const ErrorInfoBase &E) {
842    return E.template isA<ErrT>();
843  }
844 
845  template <typename HandlerT>
846  static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
847    assert(appliesTo(*E) && "Applying incorrect handler")((void)0);
848    H(static_cast<ErrT &>(*E));
849    return Error::success();
850  }
851};
852 
853/// Specialization for functions of the form 'Error (std::unique_ptr<ErrT>)'.
854template <typename ErrT>
855class ErrorHandlerTraits<Error (&)(std::unique_ptr<ErrT>)> {
856public:
857  static bool appliesTo(const ErrorInfoBase &E) {
858    return E.template isA<ErrT>();
859  }
860 
861  template <typename HandlerT>
862  static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
863    assert(appliesTo(*E) && "Applying incorrect handler")((void)0);
864    std::unique_ptr<ErrT> SubE(static_cast<ErrT *>(E.release()));
865    return H(std::move(SubE));
866  }
867};
868 
869/// Specialization for functions of the form 'void (std::unique_ptr<ErrT>)'.
870template <typename ErrT>
871class ErrorHandlerTraits<void (&)(std::unique_ptr<ErrT>)> {
872public:
873  static bool appliesTo(const ErrorInfoBase &E) {
874    return E.template isA<ErrT>();
875  }
876 
877  template <typename HandlerT>
878  static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
879    assert(appliesTo(*E) && "Applying incorrect handler")((void)0);
880    std::unique_ptr<ErrT> SubE(static_cast<ErrT *>(E.release()));
881    H(std::move(SubE));
882    return Error::success();
883  }
884};
885 
886// Specialization for member functions of the form 'RetT (const ErrT&)'.
887template <typename C, typename RetT, typename ErrT>
888class ErrorHandlerTraits<RetT (C::*)(ErrT &)>
889    : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
890 
891// Specialization for member functions of the form 'RetT (const ErrT&) const'.
892template <typename C, typename RetT, typename ErrT>
893class ErrorHandlerTraits<RetT (C::*)(ErrT &) const>
894    : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
895 
896// Specialization for member functions of the form 'RetT (const ErrT&)'.
897template <typename C, typename RetT, typename ErrT>
898class ErrorHandlerTraits<RetT (C::*)(const ErrT &)>
899    : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
900 
901// Specialization for member functions of the form 'RetT (const ErrT&) const'.
902template <typename C, typename RetT, typename ErrT>
903class ErrorHandlerTraits<RetT (C::*)(const ErrT &) const>
904    : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
905 
906/// Specialization for member functions of the form
907/// 'RetT (std::unique_ptr<ErrT>)'.
908template <typename C, typename RetT, typename ErrT>
909class ErrorHandlerTraits<RetT (C::*)(std::unique_ptr<ErrT>)>
910    : public ErrorHandlerTraits<RetT (&)(std::unique_ptr<ErrT>)> {};
911 
912/// Specialization for member functions of the form
913/// 'RetT (std::unique_ptr<ErrT>) const'.
914template <typename C, typename RetT, typename ErrT>
915class ErrorHandlerTraits<RetT (C::*)(std::unique_ptr<ErrT>) const>
916    : public ErrorHandlerTraits<RetT (&)(std::unique_ptr<ErrT>)> {};
917 
918inline Error handleErrorImpl(std::unique_ptr<ErrorInfoBase> Payload) {
919  return Error(std::move(Payload));
920}
921 
922template <typename HandlerT, typename... HandlerTs>
923Error handleErrorImpl(std::unique_ptr<ErrorInfoBase> Payload,
924                      HandlerT &&Handler, HandlerTs &&... Handlers) {
925  if (ErrorHandlerTraits<HandlerT>::appliesTo(*Payload))
926    return ErrorHandlerTraits<HandlerT>::apply(std::forward<HandlerT>(Handler),
927                                               std::move(Payload));
928  return handleErrorImpl(std::move(Payload),
929                         std::forward<HandlerTs>(Handlers)...);
930}
931 
932/// Pass the ErrorInfo(s) contained in E to their respective handlers. Any
933/// unhandled errors (or Errors returned by handlers) are re-concatenated and
934/// returned.
935/// Because this function returns an error, its result must also be checked
936/// or returned. If you intend to handle all errors use handleAllErrors
937/// (which returns void, and will abort() on unhandled errors) instead.
938template <typename... HandlerTs>
939Error handleErrors(Error E, HandlerTs &&... Hs) {
940  if (!E)
941    return Error::success();
942 
943  std::unique_ptr<ErrorInfoBase> Payload = E.takePayload();
944 
945  if (Payload->isA<ErrorList>()) {
946    ErrorList &List = static_cast<ErrorList &>(*Payload);
947    Error R;
948    for (auto &P : List.Payloads)
949      R = ErrorList::join(
950          std::move(R),
951          handleErrorImpl(std::move(P), std::forward<HandlerTs>(Hs)...));
952    return R;
953  }
954 
955  return handleErrorImpl(std::move(Payload), std::forward<HandlerTs>(Hs)...);
956}
957 
958/// Behaves the same as handleErrors, except that by contract all errors
959/// *must* be handled by the given handlers (i.e. there must be no remaining
960/// errors after running the handlers, or llvm_unreachable is called).
961template <typename... HandlerTs>
962void handleAllErrors(Error E, HandlerTs &&... Handlers) {
963  cantFail(handleErrors(std::move(E), std::forward<HandlerTs>(Handlers)...));
964}
965 
966/// Check that E is a non-error, then drop it.
967/// If E is an error, llvm_unreachable will be called.
968inline void handleAllErrors(Error E) {
969  cantFail(std::move(E));
970}
971 
972/// Handle any errors (if present) in an Expected<T>, then try a recovery path.
973///
974/// If the incoming value is a success value it is returned unmodified. If it
975/// is a failure value then it the contained error is passed to handleErrors.
976/// If handleErrors is able to handle the error then the RecoveryPath functor
977/// is called to supply the final result. If handleErrors is not able to
978/// handle all errors then the unhandled errors are returned.
979///
980/// This utility enables the follow pattern:
981///
982///   @code{.cpp}
983///   enum FooStrategy { Aggressive, Conservative };
984///   Expected<Foo> foo(FooStrategy S);
985///
986///   auto ResultOrErr =
987///     handleExpected(
988///       foo(Aggressive),
989///       []() { return foo(Conservative); },
990///       [](AggressiveStrategyError&) {
991///         // Implicitly conusme this - we'll recover by using a conservative
992///         // strategy.
993///       });
994///
995///   @endcode
996template <typename T, typename RecoveryFtor, typename... HandlerTs>
997Expected<T> handleExpected(Expected<T> ValOrErr, RecoveryFtor &&RecoveryPath,
998                           HandlerTs &&... Handlers) {
999  if (ValOrErr)
1000    return ValOrErr;
1001 
1002  if (auto Err = handleErrors(ValOrErr.takeError(),
1003                              std::forward<HandlerTs>(Handlers)...))
1004    return std::move(Err);
1005 
1006  return RecoveryPath();
1007}
1008 
1009/// Log all errors (if any) in E to OS. If there are any errors, ErrorBanner
1010/// will be printed before the first one is logged. A newline will be printed
1011/// after each error.
1012///
1013/// This function is compatible with the helpers from Support/WithColor.h. You
1014/// can pass any of them as the OS. Please consider using them instead of
1015/// including 'error: ' in the ErrorBanner.
1016///
1017/// This is useful in the base level of your program to allow clean termination
1018/// (allowing clean deallocation of resources, etc.), while reporting error
1019/// information to the user.
1020void logAllUnhandledErrors(Error E, raw_ostream &OS, Twine ErrorBanner = {});
1021 
1022/// Write all error messages (if any) in E to a string. The newline character
1023/// is used to separate error messages.
1024inline std::string toString(Error E) {
1025  SmallVector<std::string, 2> Errors;
1026  handleAllErrors(std::move(E), [&Errors](const ErrorInfoBase &EI) {
1027    Errors.push_back(EI.message());
1028  });
1029  return join(Errors.begin(), Errors.end(), "\n");
1030}
1031 
1032/// Consume a Error without doing anything. This method should be used
1033/// only where an error can be considered a reasonable and expected return
1034/// value.
1035///
1036/// Uses of this method are potentially indicative of design problems: If it's
1037/// legitimate to do nothing while processing an "error", the error-producer
1038/// might be more clearly refactored to return an Optional<T>.
1039inline void consumeError(Error Err) {
1040  handleAllErrors(std::move(Err), [](const ErrorInfoBase &) {});
1041}
1042 
1043/// Convert an Expected to an Optional without doing anything. This method
1044/// should be used only where an error can be considered a reasonable and
1045/// expected return value.
1046///
1047/// Uses of this method are potentially indicative of problems: perhaps the
1048/// error should be propagated further, or the error-producer should just
1049/// return an Optional in the first place.
1050template <typename T> Optional<T> expectedToOptional(Expected<T> &&E) {
1051  if (E)
1052    return std::move(*E);
1053  consumeError(E.takeError());
1054  return None;
1055}
1056 
1057/// Helper for converting an Error to a bool.
1058///
1059/// This method returns true if Err is in an error state, or false if it is
1060/// in a success state.  Puts Err in a checked state in both cases (unlike
1061/// Error::operator bool(), which only does this for success states).
1062inline bool errorToBool(Error Err) {
1063  bool IsError = static_cast<bool>(Err);
1064  if (IsError)
1065    consumeError(std::move(Err));
1066  return IsError;
1067}
1068 
1069/// Helper for Errors used as out-parameters.
1070///
1071/// This helper is for use with the Error-as-out-parameter idiom, where an error
1072/// is passed to a function or method by reference, rather than being returned.
1073/// In such cases it is helpful to set the checked bit on entry to the function
1074/// so that the error can be written to (unchecked Errors abort on assignment)
1075/// and clear the checked bit on exit so that clients cannot accidentally forget
1076/// to check the result. This helper performs these actions automatically using
1077/// RAII:
1078///
1079///   @code{.cpp}
1080///   Result foo(Error &Err) {
1081///     ErrorAsOutParameter ErrAsOutParam(&Err); // 'Checked' flag set
1082///     // <body of foo>
1083///     // <- 'Checked' flag auto-cleared when ErrAsOutParam is destructed.
1084///   }
1085///   @endcode
1086///
1087/// ErrorAsOutParameter takes an Error* rather than Error& so that it can be
1088/// used with optional Errors (Error pointers that are allowed to be null). If
1089/// ErrorAsOutParameter took an Error reference, an instance would have to be
1090/// created inside every condition that verified that Error was non-null. By
1091/// taking an Error pointer we can just create one instance at the top of the
1092/// function.
1093class ErrorAsOutParameter {
1094public:
1095  ErrorAsOutParameter(Error *Err) : Err(Err) {
1096    // Raise the checked bit if Err is success.
1097    if (Err)
1098      (void)!!*Err;
1099  }
1100 
1101  ~ErrorAsOutParameter() {
1102    // Clear the checked bit.
1103    if (Err && !*Err)
1104      *Err = Error::success();
1105  }
1106 
1107private:
1108  Error *Err;
1109};
1110 
1111/// Helper for Expected<T>s used as out-parameters.
1112///
1113/// See ErrorAsOutParameter.
1114template <typename T>
1115class ExpectedAsOutParameter {
1116public:
1117  ExpectedAsOutParameter(Expected<T> *ValOrErr)
1118    : ValOrErr(ValOrErr) {
1119    if (ValOrErr)
1120      (void)!!*ValOrErr;
1121  }
1122 
1123  ~ExpectedAsOutParameter() {
1124    if (ValOrErr)
1125      ValOrErr->setUnchecked();
1126  }
1127 
1128private:
1129  Expected<T> *ValOrErr;
1130};
1131 
1132/// This class wraps a std::error_code in a Error.
1133///
1134/// This is useful if you're writing an interface that returns a Error
1135/// (or Expected) and you want to call code that still returns
1136/// std::error_codes.
1137class ECError : public ErrorInfo<ECError> {
1138  friend Error errorCodeToError(std::error_code);
1139 
1140  virtual void anchor() override;
1141 
1142public:
1143  void setErrorCode(std::error_code EC) { this->EC = EC; }
1144  std::error_code convertToErrorCode() const override { return EC; }
1145  void log(raw_ostream &OS) const override { OS << EC.message(); }
1146 
1147  // Used by ErrorInfo::classID.
1148  static char ID;
1149 
1150protected:
1151  ECError() = default;
1152  ECError(std::error_code EC) : EC(EC) {}
1153 
1154  std::error_code EC;
1155};
1156 
1157/// The value returned by this function can be returned from convertToErrorCode
1158/// for Error values where no sensible translation to std::error_code exists.
1159/// It should only be used in this situation, and should never be used where a
1160/// sensible conversion to std::error_code is available, as attempts to convert
1161/// to/from this error will result in a fatal error. (i.e. it is a programmatic
1162///error to try to convert such a value).
1163std::error_code inconvertibleErrorCode();
1164 
1165/// Helper for converting an std::error_code to a Error.
1166Error errorCodeToError(std::error_code EC);
1167 
1168/// Helper for converting an ECError to a std::error_code.
1169///
1170/// This method requires that Err be Error() or an ECError, otherwise it
1171/// will trigger a call to abort().
1172std::error_code errorToErrorCode(Error Err);
1173 
1174/// Convert an ErrorOr<T> to an Expected<T>.
1175template <typename T> Expected<T> errorOrToExpected(ErrorOr<T> &&EO) {
1176  if (auto EC = EO.getError())
1177    return errorCodeToError(EC);
1178  return std::move(*EO);
1179}
1180 
1181/// Convert an Expected<T> to an ErrorOr<T>.
1182template <typename T> ErrorOr<T> expectedToErrorOr(Expected<T> &&E) {
1183  if (auto Err = E.takeError())
1184    return errorToErrorCode(std::move(Err));
1185  return std::move(*E);
1186}
1187 
1188/// This class wraps a string in an Error.
1189///
1190/// StringError is useful in cases where the client is not expected to be able
1191/// to consume the specific error message programmatically (for example, if the
1192/// error message is to be presented to the user).
1193///
1194/// StringError can also be used when additional information is to be printed
1195/// along with a error_code message. Depending on the constructor called, this
1196/// class can either display:
1197///    1. the error_code message (ECError behavior)
1198///    2. a string
1199///    3. the error_code message and a string
1200///
1201/// These behaviors are useful when subtyping is required; for example, when a
1202/// specific library needs an explicit error type. In the example below,
1203/// PDBError is derived from StringError:
1204///
1205///   @code{.cpp}
1206///   Expected<int> foo() {
1207///      return llvm::make_error<PDBError>(pdb_error_code::dia_failed_loading,
1208///                                        "Additional information");
1209///   }
1210///   @endcode
1211///
1212class StringError : public ErrorInfo<StringError> {
1213public:
1214  static char ID;
1215 
1216  // Prints EC + S and converts to EC
1217  StringError(std::error_code EC, const Twine &S = Twine());
1218 
1219  // Prints S and converts to EC
1220  StringError(const Twine &S, std::error_code EC);
1221 
1222  void log(raw_ostream &OS) const override;
1223  std::error_code convertToErrorCode() const override;
1224 
1225  const std::string &getMessage() const { return Msg; }
1226 
1227private:
1228  std::string Msg;
1229  std::error_code EC;
1230  const bool PrintMsgOnly = false;
1231};
1232 
1233/// Create formatted StringError object.
1234template <typename... Ts>
1235inline Error createStringError(std::error_code EC, char const *Fmt,
1236                               const Ts &... Vals) {
1237  std::string Buffer;
1238  raw_string_ostream Stream(Buffer);
1239  Stream << format(Fmt, Vals...);
1240  return make_error<StringError>(Stream.str(), EC);
1241}
1242 
1243Error createStringError(std::error_code EC, char const *Msg);
1244 
1245inline Error createStringError(std::error_code EC, const Twine &S) {
1246  return createStringError(EC, S.str().c_str());
1247}
1248 
1249template <typename... Ts>
1250inline Error createStringError(std::errc EC, char const *Fmt,
1251                               const Ts &... Vals) {
1252  return createStringError(std::make_error_code(EC), Fmt, Vals...);
1253}
1254 
1255/// This class wraps a filename and another Error.
1256///
1257/// In some cases, an error needs to live along a 'source' name, in order to
1258/// show more detailed information to the user.
1259class FileError final : public ErrorInfo<FileError> {
1260 
1261  friend Error createFileError(const Twine &, Error);
1262  friend Error createFileError(const Twine &, size_t, Error);
1263 
1264public:
1265  void log(raw_ostream &OS) const override {
1266    assert(Err && !FileName.empty() && "Trying to log after takeError().")((void)0);
1267    OS << "'" << FileName << "': ";
1268    if (Line.hasValue())
1269      OS << "line " << Line.getValue() << ": ";
1270    Err->log(OS);
1271  }
1272 
1273  StringRef getFileName() { return FileName; }
1274 
1275  Error takeError() { return Error(std::move(Err)); }
1276 
1277  std::error_code convertToErrorCode() const override;
1278 
1279  // Used by ErrorInfo::classID.
1280  static char ID;
1281 
1282private:
1283  FileError(const Twine &F, Optional<size_t> LineNum,
1284            std::unique_ptr<ErrorInfoBase> E) {
1285    assert(E && "Cannot create FileError from Error success value.")((void)0);
1286    assert(!F.isTriviallyEmpty() &&((void)0)
1287           "The file name provided to FileError must not be empty.")((void)0);
1288    FileName = F.str();
1289    Err = std::move(E);
1290    Line = std::move(LineNum);
1291  }
1292 
1293  static Error build(const Twine &F, Optional<size_t> Line, Error E) {
1294    std::unique_ptr<ErrorInfoBase> Payload;
1295    handleAllErrors(std::move(E),
1296                    [&](std::unique_ptr<ErrorInfoBase> EIB) -> Error {
1297                      Payload = std::move(EIB);
1298                      return Error::success();
1299                    });
1300    return Error(
1301        std::unique_ptr<FileError>(new FileError(F, Line, std::move(Payload))));
1302  }
1303 
1304  std::string FileName;
1305  Optional<size_t> Line;
1306  std::unique_ptr<ErrorInfoBase> Err;
1307};
1308 
1309/// Concatenate a source file path and/or name with an Error. The resulting
1310/// Error is unchecked.
1311inline Error createFileError(const Twine &F, Error E) {
1312  return FileError::build(F, Optional<size_t>(), std::move(E));
1313}
1314 
1315/// Concatenate a source file path and/or name with line number and an Error.
1316/// The resulting Error is unchecked.
1317inline Error createFileError(const Twine &F, size_t Line, Error E) {
1318  return FileError::build(F, Optional<size_t>(Line), std::move(E));
1319}
1320 
1321/// Concatenate a source file path and/or name with a std::error_code 
1322/// to form an Error object.
1323inline Error createFileError(const Twine &F, std::error_code EC) {
1324  return createFileError(F, errorCodeToError(EC));
1325}
1326 
1327/// Concatenate a source file path and/or name with line number and
1328/// std::error_code to form an Error object.
1329inline Error createFileError(const Twine &F, size_t Line, std::error_code EC) {
1330  return createFileError(F, Line, errorCodeToError(EC));
1331}
1332 
1333Error createFileError(const Twine &F, ErrorSuccess) = delete;
1334 
1335/// Helper for check-and-exit error handling.
1336///
1337/// For tool use only. NOT FOR USE IN LIBRARY CODE.
1338///
1339class ExitOnError {
1340public:
1341  /// Create an error on exit helper.
1342  ExitOnError(std::string Banner = "", int DefaultErrorExitCode = 1)
1343      : Banner(std::move(Banner)),
1344        GetExitCode([=](const Error &) { return DefaultErrorExitCode; }) {}
1345 
1346  /// Set the banner string for any errors caught by operator().
1347  void setBanner(std::string Banner) { this->Banner = std::move(Banner); }
1348 
1349  /// Set the exit-code mapper function.
1350  void setExitCodeMapper(std::function<int(const Error &)> GetExitCode) {
1351    this->GetExitCode = std::move(GetExitCode);
1352  }
1353 
1354  /// Check Err. If it's in a failure state log the error(s) and exit.
1355  void operator()(Error Err) const { checkError(std::move(Err)); }
1356 
1357  /// Check E. If it's in a success state then return the contained value. If
1358  /// it's in a failure state log the error(s) and exit.
1359  template <typename T> T operator()(Expected<T> &&E) const {
1360    checkError(E.takeError());
1361    return std::move(*E);
1362  }
1363 
1364  /// Check E. If it's in a success state then return the contained reference. If
1365  /// it's in a failure state log the error(s) and exit.
1366  template <typename T> T& operator()(Expected<T&> &&E) const {
1367    checkError(E.takeError());
1368    return *E;
1369  }
1370 
1371private:
1372  void checkError(Error Err) const {
1373    if (Err) {
1374      int ExitCode = GetExitCode(Err);
1375      logAllUnhandledErrors(std::move(Err), errs(), Banner);
1376      exit(ExitCode);
1377    }
1378  }
1379 
1380  std::string Banner;
1381  std::function<int(const Error &)> GetExitCode;
1382};
1383 
1384/// Conversion from Error to LLVMErrorRef for C error bindings.
1385inline LLVMErrorRef wrap(Error Err) {
1386  return reinterpret_cast<LLVMErrorRef>(Err.takePayload().release());
1387}
1388 
1389/// Conversion from LLVMErrorRef to Error for C error bindings.
1390inline Error unwrap(LLVMErrorRef ErrRef) {
1391  return Error(std::unique_ptr<ErrorInfoBase>(
1392      reinterpret_cast<ErrorInfoBase *>(ErrRef)));
1393}
1394 
1395} // end namespace llvm
1396 
1397#endif // LLVM_SUPPORT_ERROR_H