/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

Bug Summary

File:	src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp
Warning:	line 1173, column 24 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name ClangExpressionDeclMap.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/liblldbPluginExpressionParser/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../include -I /usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/obj -I /usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/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/liblldbPluginExpressionParser/../../../llvm/lldb/include -I /usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source -I /usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/clang/include -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/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/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

→

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

11#include "ClangASTSource.h"
12#include "ClangModulesDeclVendor.h"
13#include "ClangPersistentVariables.h"
14#include "ClangUtil.h"

16#include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
17#include "lldb/Core/Address.h"
18#include "lldb/Core/Module.h"
19#include "lldb/Core/ModuleSpec.h"
20#include "lldb/Core/ValueObjectConstResult.h"
21#include "lldb/Core/ValueObjectVariable.h"
22#include "lldb/Expression/DiagnosticManager.h"
23#include "lldb/Expression/Materializer.h"
24#include "lldb/Symbol/CompileUnit.h"
25#include "lldb/Symbol/CompilerDecl.h"
26#include "lldb/Symbol/CompilerDeclContext.h"
27#include "lldb/Symbol/Function.h"
28#include "lldb/Symbol/ObjectFile.h"
29#include "lldb/Symbol/SymbolContext.h"
30#include "lldb/Symbol/SymbolFile.h"
31#include "lldb/Symbol/SymbolVendor.h"
32#include "lldb/Symbol/Type.h"
33#include "lldb/Symbol/TypeList.h"
34#include "lldb/Symbol/Variable.h"
35#include "lldb/Symbol/VariableList.h"
36#include "lldb/Target/ExecutionContext.h"
37#include "lldb/Target/Process.h"
38#include "lldb/Target/RegisterContext.h"
39#include "lldb/Target/StackFrame.h"
40#include "lldb/Target/Target.h"
41#include "lldb/Target/Thread.h"
42#include "lldb/Utility/Endian.h"
43#include "lldb/Utility/Log.h"
44#include "lldb/Utility/RegisterValue.h"
45#include "lldb/Utility/Status.h"
46#include "lldb/lldb-private.h"
47#include "clang/AST/ASTConsumer.h"
48#include "clang/AST/ASTContext.h"
49#include "clang/AST/ASTImporter.h"
50#include "clang/AST/Decl.h"
51#include "clang/AST/DeclarationName.h"
52#include "clang/AST/RecursiveASTVisitor.h"

54#include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
55#include "Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.h"
56#include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"

58using namespace lldb;
59using namespace lldb_private;
60using namespace clang;

62namespace {
63const char *g_lldb_local_vars_namespace_cstr = "$__lldb_local_vars";
64} // anonymous namespace

66ClangExpressionDeclMap::ClangExpressionDeclMap(
  bool keep_result_in_memory,
  Materializer::PersistentVariableDelegate *result_delegate,
  const lldb::TargetSP &target,
  const std::shared_ptr<ClangASTImporter> &importer, ValueObject *ctx_obj)
  : ClangASTSource(target, importer), m_found_entities(), m_struct_members(),
    m_keep_result_in_memory(keep_result_in_memory),
    m_result_delegate(result_delegate), m_ctx_obj(ctx_obj), m_parser_vars(),
    m_struct_vars() {
EnableStructVars();
76}

78ClangExpressionDeclMap::~ClangExpressionDeclMap() {
// Note: The model is now that the parser's AST context and all associated
//   data does not vanish until the expression has been executed.  This means
//   that valuable lookup data (like namespaces) doesn't vanish, but

DidParse();
DisableStructVars();
85}

87bool ClangExpressionDeclMap::WillParse(ExecutionContext &exe_ctx,
                                     Materializer *materializer) {
EnableParserVars();
m_parser_vars->m_exe_ctx = exe_ctx;

Target *target = exe_ctx.GetTargetPtr();
if (exe_ctx.GetFramePtr())
  m_parser_vars->m_sym_ctx =
      exe_ctx.GetFramePtr()->GetSymbolContext(lldb::eSymbolContextEverything);
else if (exe_ctx.GetThreadPtr() &&
         exe_ctx.GetThreadPtr()->GetStackFrameAtIndex(0))
  m_parser_vars->m_sym_ctx =
      exe_ctx.GetThreadPtr()->GetStackFrameAtIndex(0)->GetSymbolContext(
          lldb::eSymbolContextEverything);
else if (exe_ctx.GetProcessPtr()) {
  m_parser_vars->m_sym_ctx.Clear(true);
  m_parser_vars->m_sym_ctx.target_sp = exe_ctx.GetTargetSP();
} else if (target) {
  m_parser_vars->m_sym_ctx.Clear(true);
  m_parser_vars->m_sym_ctx.target_sp = exe_ctx.GetTargetSP();
}

if (target) {
  m_parser_vars->m_persistent_vars = llvm::cast<ClangPersistentVariables>(
      target->GetPersistentExpressionStateForLanguage(eLanguageTypeC));

  if (!ScratchTypeSystemClang::GetForTarget(*target))
    return false;
}

m_parser_vars->m_target_info = GetTargetInfo();
m_parser_vars->m_materializer = materializer;

return true;
121}

123void ClangExpressionDeclMap::InstallCodeGenerator(
  clang::ASTConsumer *code_gen) {
assert(m_parser_vars)((void)0);
m_parser_vars->m_code_gen = code_gen;
127}

129void ClangExpressionDeclMap::InstallDiagnosticManager(
  DiagnosticManager &diag_manager) {
assert(m_parser_vars)((void)0);
m_parser_vars->m_diagnostics = &diag_manager;
133}

135void ClangExpressionDeclMap::DidParse() {
if (m_parser_vars && m_parser_vars->m_persistent_vars) {
  for (size_t entity_index = 0, num_entities = m_found_entities.GetSize();
       entity_index < num_entities; ++entity_index) {
    ExpressionVariableSP var_sp(
        m_found_entities.GetVariableAtIndex(entity_index));
    if (var_sp)
      llvm::cast<ClangExpressionVariable>(var_sp.get())
          ->DisableParserVars(GetParserID());
  }

  for (size_t pvar_index = 0,
              num_pvars = m_parser_vars->m_persistent_vars->GetSize();
       pvar_index < num_pvars; ++pvar_index) {
    ExpressionVariableSP pvar_sp(
        m_parser_vars->m_persistent_vars->GetVariableAtIndex(pvar_index));
    if (ClangExpressionVariable *clang_var =
            llvm::dyn_cast<ClangExpressionVariable>(pvar_sp.get()))
      clang_var->DisableParserVars(GetParserID());
  }

  DisableParserVars();
}
158}

160// Interface for IRForTarget

162ClangExpressionDeclMap::TargetInfo ClangExpressionDeclMap::GetTargetInfo() {
assert(m_parser_vars.get())((void)0);

TargetInfo ret;

ExecutionContext &exe_ctx = m_parser_vars->m_exe_ctx;

Process *process = exe_ctx.GetProcessPtr();
if (process) {
  ret.byte_order = process->GetByteOrder();
  ret.address_byte_size = process->GetAddressByteSize();
} else {
  Target *target = exe_ctx.GetTargetPtr();
  if (target) {
    ret.byte_order = target->GetArchitecture().GetByteOrder();
    ret.address_byte_size = target->GetArchitecture().GetAddressByteSize();
  }
}

return ret;
182}

184TypeFromUser ClangExpressionDeclMap::DeportType(TypeSystemClang &target,
                                              TypeSystemClang &source,
                                              TypeFromParser parser_type) {
assert(&target == GetScratchContext(*m_target))((void)0);
assert((TypeSystem *)&source == parser_type.GetTypeSystem())((void)0);
assert(&source.getASTContext() == m_ast_context)((void)0);

return TypeFromUser(m_ast_importer_sp->DeportType(target, parser_type));
192}

194bool ClangExpressionDeclMap::AddPersistentVariable(const NamedDecl *decl,
                                                 ConstString name,
                                                 TypeFromParser parser_type,
                                                 bool is_result,
                                                 bool is_lvalue) {
assert(m_parser_vars.get())((void)0);

TypeSystemClang *ast =
    llvm::dyn_cast_or_null<TypeSystemClang>(parser_type.GetTypeSystem());
if (ast == nullptr)
  return false;

// Check if we already declared a persistent variable with the same name.
if (lldb::ExpressionVariableSP conflicting_var =
        m_parser_vars->m_persistent_vars->GetVariable(name)) {
  std::string msg = llvm::formatv("redefinition of persistent variable '{0}'",
                                  name).str();
  m_parser_vars->m_diagnostics->AddDiagnostic(
      msg, DiagnosticSeverity::eDiagnosticSeverityError,
      DiagnosticOrigin::eDiagnosticOriginLLDB);
  return false;
}

if (m_parser_vars->m_materializer && is_result) {
  Status err;

  ExecutionContext &exe_ctx = m_parser_vars->m_exe_ctx;
  Target *target = exe_ctx.GetTargetPtr();
  if (target == nullptr)
    return false;

  auto *clang_ast_context = GetScratchContext(*target);
  if (!clang_ast_context)
    return false;

  TypeFromUser user_type = DeportType(*clang_ast_context, *ast, parser_type);

  uint32_t offset = m_parser_vars->m_materializer->AddResultVariable(
      user_type, is_lvalue, m_keep_result_in_memory, m_result_delegate, err);

  ClangExpressionVariable *var = new ClangExpressionVariable(
      exe_ctx.GetBestExecutionContextScope(), name, user_type,
      m_parser_vars->m_target_info.byte_order,
      m_parser_vars->m_target_info.address_byte_size);

  m_found_entities.AddNewlyConstructedVariable(var);

  var->EnableParserVars(GetParserID());

  ClangExpressionVariable::ParserVars *parser_vars =
      var->GetParserVars(GetParserID());

  parser_vars->m_named_decl = decl;

  var->EnableJITVars(GetParserID());

  ClangExpressionVariable::JITVars *jit_vars = var->GetJITVars(GetParserID());

  jit_vars->m_offset = offset;

  return true;
}

Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8)));
ExecutionContext &exe_ctx = m_parser_vars->m_exe_ctx;
Target *target = exe_ctx.GetTargetPtr();
if (target == nullptr)
  return false;

TypeSystemClang *context = GetScratchContext(*target);
if (!context)
  return false;

TypeFromUser user_type = DeportType(*context, *ast, parser_type);

if (!user_type.GetOpaqueQualType()) {
  LLDB_LOG(log, "Persistent variable's type wasn't copied successfully")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "Persistent variable's type wasn't copied successfully"
); } while (0);
  return false;
}

if (!m_parser_vars->m_target_info.IsValid())
  return false;

if (!m_parser_vars->m_persistent_vars)
  return false;

ClangExpressionVariable *var = llvm::cast<ClangExpressionVariable>(
    m_parser_vars->m_persistent_vars
        ->CreatePersistentVariable(
            exe_ctx.GetBestExecutionContextScope(), name, user_type,
            m_parser_vars->m_target_info.byte_order,
            m_parser_vars->m_target_info.address_byte_size)
        .get());

if (!var)
  return false;

var->m_frozen_sp->SetHasCompleteType();

if (is_result)
  var->m_flags |= ClangExpressionVariable::EVNeedsFreezeDry;
else
  var->m_flags |=
      ClangExpressionVariable::EVKeepInTarget; // explicitly-declared
                                               // persistent variables should
                                               // persist

if (is_lvalue) {
  var->m_flags |= ClangExpressionVariable::EVIsProgramReference;
} else {
  var->m_flags |= ClangExpressionVariable::EVIsLLDBAllocated;
  var->m_flags |= ClangExpressionVariable::EVNeedsAllocation;
}

if (m_keep_result_in_memory) {
  var->m_flags |= ClangExpressionVariable::EVKeepInTarget;
}

LLDB_LOG(log, "Created persistent variable with flags {0:x}", var->m_flags)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "Created persistent variable with flags {0:x}", var
->m_flags); } while (0);

var->EnableParserVars(GetParserID());

ClangExpressionVariable::ParserVars *parser_vars =
    var->GetParserVars(GetParserID());

parser_vars->m_named_decl = decl;

return true;
322}

324bool ClangExpressionDeclMap::AddValueToStruct(const NamedDecl *decl,
                                            ConstString name,
                                            llvm::Value *value, size_t size,
                                            lldb::offset_t alignment) {
assert(m_struct_vars.get())((void)0);
assert(m_parser_vars.get())((void)0);

bool is_persistent_variable = false;

Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8)));

m_struct_vars->m_struct_laid_out = false;

if (ClangExpressionVariable::FindVariableInList(m_struct_members, decl,
                                                GetParserID()))
  return true;

ClangExpressionVariable *var(ClangExpressionVariable::FindVariableInList(
    m_found_entities, decl, GetParserID()));

if (!var && m_parser_vars->m_persistent_vars) {
  var = ClangExpressionVariable::FindVariableInList(
      *m_parser_vars->m_persistent_vars, decl, GetParserID());
  is_persistent_variable = true;
}

if (!var)
  return false;

LLDB_LOG(log, "Adding value for (NamedDecl*){0} [{1} - {2}] to the structure",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "Adding value for (NamedDecl*){0} [{1} - {2}] to the structure"
, decl, name, var->GetName()); } while (0)
         decl, name, var->GetName())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "Adding value for (NamedDecl*){0} [{1} - {2}] to the structure"
, decl, name, var->GetName()); } while (0);

// We know entity->m_parser_vars is valid because we used a parser variable
// to find it

ClangExpressionVariable::ParserVars *parser_vars =
    llvm::cast<ClangExpressionVariable>(var)->GetParserVars(GetParserID());

parser_vars->m_llvm_value = value;

if (ClangExpressionVariable::JITVars *jit_vars =
        llvm::cast<ClangExpressionVariable>(var)->GetJITVars(GetParserID())) {
  // We already laid this out; do not touch

  LLDB_LOG(log, "Already placed at {0:x}", jit_vars->m_offset)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "Already placed at {0:x}", jit_vars->m_offset)
; } while (0);
}

llvm::cast<ClangExpressionVariable>(var)->EnableJITVars(GetParserID());

ClangExpressionVariable::JITVars *jit_vars =
    llvm::cast<ClangExpressionVariable>(var)->GetJITVars(GetParserID());

jit_vars->m_alignment = alignment;
jit_vars->m_size = size;

m_struct_members.AddVariable(var->shared_from_this());

if (m_parser_vars->m_materializer) {
  uint32_t offset = 0;

  Status err;

  if (is_persistent_variable) {
    ExpressionVariableSP var_sp(var->shared_from_this());
    offset = m_parser_vars->m_materializer->AddPersistentVariable(
        var_sp, nullptr, err);
  } else {
    if (const lldb_private::Symbol *sym = parser_vars->m_lldb_sym)
      offset = m_parser_vars->m_materializer->AddSymbol(*sym, err);
    else if (const RegisterInfo *reg_info = var->GetRegisterInfo())
      offset = m_parser_vars->m_materializer->AddRegister(*reg_info, err);
    else if (parser_vars->m_lldb_var)
      offset = m_parser_vars->m_materializer->AddVariable(
          parser_vars->m_lldb_var, err);
  }

  if (!err.Success())
    return false;

  LLDB_LOG(log, "Placed at {0:x}", offset)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "Placed at {0:x}", offset); } while (0);

  jit_vars->m_offset =
      offset; // TODO DoStructLayout() should not change this.
}

return true;
410}

412bool ClangExpressionDeclMap::DoStructLayout() {
assert(m_struct_vars.get())((void)0);

if (m_struct_vars->m_struct_laid_out)
  return true;

if (!m_parser_vars->m_materializer)
  return false;

m_struct_vars->m_struct_alignment =
    m_parser_vars->m_materializer->GetStructAlignment();
m_struct_vars->m_struct_size =
    m_parser_vars->m_materializer->GetStructByteSize();
m_struct_vars->m_struct_laid_out = true;
return true;
427}

429bool ClangExpressionDeclMap::GetStructInfo(uint32_t &num_elements, size_t &size,
                                         lldb::offset_t &alignment) {
assert(m_struct_vars.get())((void)0);

if (!m_struct_vars->m_struct_laid_out)
  return false;

num_elements = m_struct_members.GetSize();
size = m_struct_vars->m_struct_size;
alignment = m_struct_vars->m_struct_alignment;

return true;
441}

443bool ClangExpressionDeclMap::GetStructElement(const NamedDecl *&decl,
                                            llvm::Value *&value,
                                            lldb::offset_t &offset,
                                            ConstString &name,
                                            uint32_t index) {
assert(m_struct_vars.get())((void)0);

if (!m_struct_vars->m_struct_laid_out)
  return false;

if (index >= m_struct_members.GetSize())
  return false;

ExpressionVariableSP member_sp(m_struct_members.GetVariableAtIndex(index));

if (!member_sp)
  return false;

ClangExpressionVariable::ParserVars *parser_vars =
    llvm::cast<ClangExpressionVariable>(member_sp.get())
        ->GetParserVars(GetParserID());
ClangExpressionVariable::JITVars *jit_vars =
    llvm::cast<ClangExpressionVariable>(member_sp.get())
        ->GetJITVars(GetParserID());

if (!parser_vars || !jit_vars || !member_sp->GetValueObject())
  return false;

decl = parser_vars->m_named_decl;
value = parser_vars->m_llvm_value;
offset = jit_vars->m_offset;
name = member_sp->GetName();

return true;
477}

479bool ClangExpressionDeclMap::GetFunctionInfo(const NamedDecl *decl,
                                           uint64_t &ptr) {
ClangExpressionVariable *entity(ClangExpressionVariable::FindVariableInList(
    m_found_entities, decl, GetParserID()));

if (!entity)
  return false;

// We know m_parser_vars is valid since we searched for the variable by its
// NamedDecl

ClangExpressionVariable::ParserVars *parser_vars =
    entity->GetParserVars(GetParserID());

ptr = parser_vars->m_lldb_value.GetScalar().ULongLong();

return true;
496}

498addr_t ClangExpressionDeclMap::GetSymbolAddress(Target &target,
                                              Process *process,
                                              ConstString name,
                                              lldb::SymbolType symbol_type,
                                              lldb_private::Module *module) {
SymbolContextList sc_list;

if (module)
  module->FindSymbolsWithNameAndType(name, symbol_type, sc_list);
else
  target.GetImages().FindSymbolsWithNameAndType(name, symbol_type, sc_list);

const uint32_t num_matches = sc_list.GetSize();
addr_t symbol_load_addr = LLDB_INVALID_ADDRESS0xffffffffffffffffULL;

for (uint32_t i = 0;
     i < num_matches &&
     (symbol_load_addr == 0 || symbol_load_addr == LLDB_INVALID_ADDRESS0xffffffffffffffffULL);
     i++) {
  SymbolContext sym_ctx;
  sc_list.GetContextAtIndex(i, sym_ctx);

  const Address sym_address = sym_ctx.symbol->GetAddress();

  if (!sym_address.IsValid())
    continue;

  switch (sym_ctx.symbol->GetType()) {
  case eSymbolTypeCode:
  case eSymbolTypeTrampoline:
    symbol_load_addr = sym_address.GetCallableLoadAddress(&target);
    break;

  case eSymbolTypeResolver:
    symbol_load_addr = sym_address.GetCallableLoadAddress(&target, true);
    break;

  case eSymbolTypeReExported: {
    ConstString reexport_name = sym_ctx.symbol->GetReExportedSymbolName();
    if (reexport_name) {
      ModuleSP reexport_module_sp;
      ModuleSpec reexport_module_spec;
      reexport_module_spec.GetPlatformFileSpec() =
          sym_ctx.symbol->GetReExportedSymbolSharedLibrary();
      if (reexport_module_spec.GetPlatformFileSpec()) {
        reexport_module_sp =
            target.GetImages().FindFirstModule(reexport_module_spec);
        if (!reexport_module_sp) {
          reexport_module_spec.GetPlatformFileSpec().GetDirectory().Clear();
          reexport_module_sp =
              target.GetImages().FindFirstModule(reexport_module_spec);
        }
      }
      symbol_load_addr = GetSymbolAddress(
          target, process, sym_ctx.symbol->GetReExportedSymbolName(),
          symbol_type, reexport_module_sp.get());
    }
  } break;

  case eSymbolTypeData:
  case eSymbolTypeRuntime:
  case eSymbolTypeVariable:
  case eSymbolTypeLocal:
  case eSymbolTypeParam:
  case eSymbolTypeInvalid:
  case eSymbolTypeAbsolute:
  case eSymbolTypeException:
  case eSymbolTypeSourceFile:
  case eSymbolTypeHeaderFile:
  case eSymbolTypeObjectFile:
  case eSymbolTypeCommonBlock:
  case eSymbolTypeBlock:
  case eSymbolTypeVariableType:
  case eSymbolTypeLineEntry:
  case eSymbolTypeLineHeader:
  case eSymbolTypeScopeBegin:
  case eSymbolTypeScopeEnd:
  case eSymbolTypeAdditional:
  case eSymbolTypeCompiler:
  case eSymbolTypeInstrumentation:
  case eSymbolTypeUndefined:
  case eSymbolTypeObjCClass:
  case eSymbolTypeObjCMetaClass:
  case eSymbolTypeObjCIVar:
    symbol_load_addr = sym_address.GetLoadAddress(&target);
    break;
  }
}

if (symbol_load_addr == LLDB_INVALID_ADDRESS0xffffffffffffffffULL && process) {
  ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process);

  if (runtime) {
    symbol_load_addr = runtime->LookupRuntimeSymbol(name);
  }
}

return symbol_load_addr;
596}

598addr_t ClangExpressionDeclMap::GetSymbolAddress(ConstString name,
                                              lldb::SymbolType symbol_type) {
assert(m_parser_vars.get())((void)0);

if (!m_parser_vars->m_exe_ctx.GetTargetPtr())
  return false;

return GetSymbolAddress(m_parser_vars->m_exe_ctx.GetTargetRef(),
                        m_parser_vars->m_exe_ctx.GetProcessPtr(), name,
                        symbol_type);
608}

610lldb::VariableSP ClangExpressionDeclMap::FindGlobalVariable(
  Target &target, ModuleSP &module, ConstString name,
  const CompilerDeclContext &namespace_decl) {
VariableList vars;

if (module && namespace_decl)
  module->FindGlobalVariables(name, namespace_decl, -1, vars);
else
  target.GetImages().FindGlobalVariables(name, -1, vars);

if (vars.GetSize() == 0)
  return VariableSP();
return vars.GetVariableAtIndex(0);
623}

625TypeSystemClang *ClangExpressionDeclMap::GetTypeSystemClang() {
StackFrame *frame = m_parser_vars->m_exe_ctx.GetFramePtr();
if (frame == nullptr)
  return nullptr;

SymbolContext sym_ctx = frame->GetSymbolContext(lldb::eSymbolContextFunction |
                                                lldb::eSymbolContextBlock);
if (sym_ctx.block == nullptr)
  return nullptr;

CompilerDeclContext frame_decl_context = sym_ctx.block->GetDeclContext();
if (!frame_decl_context)
  return nullptr;

return llvm::dyn_cast_or_null<TypeSystemClang>(
    frame_decl_context.GetTypeSystem());
641}

643// Interface for ClangASTSource

645void ClangExpressionDeclMap::FindExternalVisibleDecls(
  NameSearchContext &context) {
assert(m_ast_context)((void)0);

const ConstString name(context.m_decl_name.getAsString().c_str());

Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8)));

if (log) {
  if (!context.m_decl_context)
    LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "ClangExpressionDeclMap::FindExternalVisibleDecls for "
 "'{0}' in a NULL DeclContext", name); } while (0)
             "ClangExpressionDeclMap::FindExternalVisibleDecls for "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "ClangExpressionDeclMap::FindExternalVisibleDecls for "
 "'{0}' in a NULL DeclContext", name); } while (0)
             "'{0}' in a NULL DeclContext",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "ClangExpressionDeclMap::FindExternalVisibleDecls for "
 "'{0}' in a NULL DeclContext", name); } while (0)
             name)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "ClangExpressionDeclMap::FindExternalVisibleDecls for "
 "'{0}' in a NULL DeclContext", name); } while (0);
  else if (const NamedDecl *context_named_decl =
               dyn_cast<NamedDecl>(context.m_decl_context))
    LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "ClangExpressionDeclMap::FindExternalVisibleDecls for "
 "'{0}' in '{1}'", name, context_named_decl->getNameAsString
()); } while (0)
             "ClangExpressionDeclMap::FindExternalVisibleDecls for "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "ClangExpressionDeclMap::FindExternalVisibleDecls for "
 "'{0}' in '{1}'", name, context_named_decl->getNameAsString
()); } while (0)
             "'{0}' in '{1}'",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "ClangExpressionDeclMap::FindExternalVisibleDecls for "
 "'{0}' in '{1}'", name, context_named_decl->getNameAsString
()); } while (0)
             name, context_named_decl->getNameAsString())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "ClangExpressionDeclMap::FindExternalVisibleDecls for "
 "'{0}' in '{1}'", name, context_named_decl->getNameAsString
()); } while (0);
  else
    LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "ClangExpressionDeclMap::FindExternalVisibleDecls for "
 "'{0}' in a '{1}'", name, context.m_decl_context->getDeclKindName
()); } while (0)
             "ClangExpressionDeclMap::FindExternalVisibleDecls for "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "ClangExpressionDeclMap::FindExternalVisibleDecls for "
 "'{0}' in a '{1}'", name, context.m_decl_context->getDeclKindName
()); } while (0)
             "'{0}' in a '{1}'",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "ClangExpressionDeclMap::FindExternalVisibleDecls for "
 "'{0}' in a '{1}'", name, context.m_decl_context->getDeclKindName
()); } while (0)
             name, context.m_decl_context->getDeclKindName())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "ClangExpressionDeclMap::FindExternalVisibleDecls for "
 "'{0}' in a '{1}'", name, context.m_decl_context->getDeclKindName
()); } while (0);
}

if (const NamespaceDecl *namespace_context =
        dyn_cast<NamespaceDecl>(context.m_decl_context)) {
  if (namespace_context->getName().str() ==
      std::string(g_lldb_local_vars_namespace_cstr)) {
    CompilerDeclContext compiler_decl_ctx =
        m_clang_ast_context->CreateDeclContext(
            const_cast<clang::DeclContext *>(context.m_decl_context));
    FindExternalVisibleDecls(context, lldb::ModuleSP(), compiler_decl_ctx);
    return;
  }

  ClangASTImporter::NamespaceMapSP namespace_map =
      m_ast_importer_sp->GetNamespaceMap(namespace_context);

  if (!namespace_map)
    return;

  LLDB_LOGV(log, "  CEDM::FEVD Inspecting (NamespaceMap*){0:x} ({1} entries)",do { ::lldb_private::Log *log_private = (log); if (log_private
 && log_private->GetVerbose()) log_private->Format
("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::FEVD Inspecting (NamespaceMap*){0:x} ({1} entries)"
, namespace_map.get(), namespace_map->size()); } while (0)
            namespace_map.get(), namespace_map->size())do { ::lldb_private::Log *log_private = (log); if (log_private
 && log_private->GetVerbose()) log_private->Format
("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::FEVD Inspecting (NamespaceMap*){0:x} ({1} entries)"
, namespace_map.get(), namespace_map->size()); } while (0);

  for (ClangASTImporter::NamespaceMapItem &n : *namespace_map) {
    LLDB_LOG(log, "  CEDM::FEVD Searching namespace {0} in module {1}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::FEVD Searching namespace {0} in module {1}"
, n.second.GetName(), n.first->GetFileSpec().GetFilename()
); } while (0)
             n.second.GetName(), n.first->GetFileSpec().GetFilename())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::FEVD Searching namespace {0} in module {1}"
, n.second.GetName(), n.first->GetFileSpec().GetFilename()
); } while (0);

    FindExternalVisibleDecls(context, n.first, n.second);
  }
} else if (isa<TranslationUnitDecl>(context.m_decl_context)) {
  CompilerDeclContext namespace_decl;

  LLDB_LOG(log, "  CEDM::FEVD Searching the root namespace")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::FEVD Searching the root namespace"); } while
 (0);

  FindExternalVisibleDecls(context, lldb::ModuleSP(), namespace_decl);
}

ClangASTSource::FindExternalVisibleDecls(context);
707}

709void ClangExpressionDeclMap::MaybeRegisterFunctionBody(
  FunctionDecl *copied_function_decl) {
if (copied_function_decl->getBody() && m_parser_vars->m_code_gen) {
  clang::DeclGroupRef decl_group_ref(copied_function_decl);
  m_parser_vars->m_code_gen->HandleTopLevelDecl(decl_group_ref);
}
715}

717clang::NamedDecl *ClangExpressionDeclMap::GetPersistentDecl(ConstString name) {
if (!m_parser_vars)
  return nullptr;
Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
if (!target)
  return nullptr;

ScratchTypeSystemClang::GetForTarget(*target);

if (!m_parser_vars->m_persistent_vars)
  return nullptr;
return m_parser_vars->m_persistent_vars->GetPersistentDecl(name);
729}

731void ClangExpressionDeclMap::SearchPersistenDecls(NameSearchContext &context,
                                                const ConstString name) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8)));

NamedDecl *persistent_decl = GetPersistentDecl(name);

if (!persistent_decl)
  return;

Decl *parser_persistent_decl = CopyDecl(persistent_decl);

if (!parser_persistent_decl)
  return;

NamedDecl *parser_named_decl = dyn_cast<NamedDecl>(parser_persistent_decl);

if (!parser_named_decl)
  return;

if (clang::FunctionDecl *parser_function_decl =
        llvm::dyn_cast<clang::FunctionDecl>(parser_named_decl)) {
  MaybeRegisterFunctionBody(parser_function_decl);
}

LLDB_LOG(log, "  CEDM::FEVD Found persistent decl {0}", name)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::FEVD Found persistent decl {0}", name); }
 while (0);

context.AddNamedDecl(parser_named_decl);
758}

760void ClangExpressionDeclMap::LookUpLldbClass(NameSearchContext &context) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8)));

StackFrame *frame = m_parser_vars->m_exe_ctx.GetFramePtr();
SymbolContext sym_ctx;
if (frame != nullptr)
  sym_ctx = frame->GetSymbolContext(lldb::eSymbolContextFunction |
                                    lldb::eSymbolContextBlock);

if (m_ctx_obj) {
  Status status;
  lldb::ValueObjectSP ctx_obj_ptr = m_ctx_obj->AddressOf(status);
  if (!ctx_obj_ptr || status.Fail())
    return;

  AddContextClassType(context, TypeFromUser(m_ctx_obj->GetCompilerType()));

  m_struct_vars->m_object_pointer_type =
      TypeFromUser(ctx_obj_ptr->GetCompilerType());

  return;
}

// Clang is looking for the type of "this"

if (frame == nullptr)
  return;

// Find the block that defines the function represented by "sym_ctx"
Block *function_block = sym_ctx.GetFunctionBlock();

if (!function_block)
  return;

CompilerDeclContext function_decl_ctx = function_block->GetDeclContext();

if (!function_decl_ctx)
  return;

clang::CXXMethodDecl *method_decl =
    TypeSystemClang::DeclContextGetAsCXXMethodDecl(function_decl_ctx);

if (method_decl) {
  clang::CXXRecordDecl *class_decl = method_decl->getParent();

  QualType class_qual_type(class_decl->getTypeForDecl(), 0);

  TypeFromUser class_user_type(class_qual_type.getAsOpaquePtr(),
                               function_decl_ctx.GetTypeSystem());

  LLDB_LOG(log, "  CEDM::FEVD Adding type for $__lldb_class: {1}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::FEVD Adding type for $__lldb_class: {1}"
, class_qual_type.getAsString()); } while (0)
           class_qual_type.getAsString())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::FEVD Adding type for $__lldb_class: {1}"
, class_qual_type.getAsString()); } while (0);

  AddContextClassType(context, class_user_type);

  if (method_decl->isInstance()) {
    // self is a pointer to the object

    QualType class_pointer_type =
        method_decl->getASTContext().getPointerType(class_qual_type);

    TypeFromUser self_user_type(class_pointer_type.getAsOpaquePtr(),
                                function_decl_ctx.GetTypeSystem());

    m_struct_vars->m_object_pointer_type = self_user_type;
  }
  return;
}

// This branch will get hit if we are executing code in the context of
// a function that claims to have an object pointer (through
// DW_AT_object_pointer?) but is not formally a method of the class.
// In that case, just look up the "this" variable in the current scope
// and use its type.
// FIXME: This code is formally correct, but clang doesn't currently
// emit DW_AT_object_pointer
// for C++ so it hasn't actually been tested.

VariableList *vars = frame->GetVariableList(false);

lldb::VariableSP this_var = vars->FindVariable(ConstString("this"));

if (this_var && this_var->IsInScope(frame) &&
    this_var->LocationIsValidForFrame(frame)) {
  Type *this_type = this_var->GetType();

  if (!this_type)
    return;

  TypeFromUser pointee_type =
      this_type->GetForwardCompilerType().GetPointeeType();

  LLDB_LOG(log, "  FEVD Adding type for $__lldb_class: {1}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  FEVD Adding type for $__lldb_class: {1}", ClangUtil
::GetQualType(pointee_type).getAsString()); } while (0)
           ClangUtil::GetQualType(pointee_type).getAsString())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  FEVD Adding type for $__lldb_class: {1}", ClangUtil
::GetQualType(pointee_type).getAsString()); } while (0);

  AddContextClassType(context, pointee_type);
  TypeFromUser this_user_type(this_type->GetFullCompilerType());
  m_struct_vars->m_object_pointer_type = this_user_type;
}
859}

861void ClangExpressionDeclMap::LookUpLldbObjCClass(NameSearchContext &context) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8)));

StackFrame *frame = m_parser_vars->m_exe_ctx.GetFramePtr();

if (m_ctx_obj) {
  Status status;
  lldb::ValueObjectSP ctx_obj_ptr = m_ctx_obj->AddressOf(status);
  if (!ctx_obj_ptr || status.Fail())
    return;

  AddOneType(context, TypeFromUser(m_ctx_obj->GetCompilerType()));

  m_struct_vars->m_object_pointer_type =
      TypeFromUser(ctx_obj_ptr->GetCompilerType());

  return;
}

// Clang is looking for the type of "*self"

if (!frame)
  return;

SymbolContext sym_ctx = frame->GetSymbolContext(lldb::eSymbolContextFunction |
                                                lldb::eSymbolContextBlock);

// Find the block that defines the function represented by "sym_ctx"
Block *function_block = sym_ctx.GetFunctionBlock();

if (!function_block)
  return;

CompilerDeclContext function_decl_ctx = function_block->GetDeclContext();

if (!function_decl_ctx)
  return;

clang::ObjCMethodDecl *method_decl =
    TypeSystemClang::DeclContextGetAsObjCMethodDecl(function_decl_ctx);

if (method_decl) {
  ObjCInterfaceDecl *self_interface = method_decl->getClassInterface();

  if (!self_interface)
    return;

  const clang::Type *interface_type = self_interface->getTypeForDecl();

  if (!interface_type)
    return; // This is unlikely, but we have seen crashes where this
            // occurred

  TypeFromUser class_user_type(QualType(interface_type, 0).getAsOpaquePtr(),
                               function_decl_ctx.GetTypeSystem());

  LLDB_LOG(log, "  FEVD[{0}] Adding type for $__lldb_objc_class: {1}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  FEVD[{0}] Adding type for $__lldb_objc_class: {1}"
, ClangUtil::ToString(interface_type)); } while (0)
           ClangUtil::ToString(interface_type))do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  FEVD[{0}] Adding type for $__lldb_objc_class: {1}"
, ClangUtil::ToString(interface_type)); } while (0);

  AddOneType(context, class_user_type);

  if (method_decl->isInstanceMethod()) {
    // self is a pointer to the object

    QualType class_pointer_type =
        method_decl->getASTContext().getObjCObjectPointerType(
            QualType(interface_type, 0));

    TypeFromUser self_user_type(class_pointer_type.getAsOpaquePtr(),
                                function_decl_ctx.GetTypeSystem());

    m_struct_vars->m_object_pointer_type = self_user_type;
  } else {
    // self is a Class pointer
    QualType class_type = method_decl->getASTContext().getObjCClassType();

    TypeFromUser self_user_type(class_type.getAsOpaquePtr(),
                                function_decl_ctx.GetTypeSystem());

    m_struct_vars->m_object_pointer_type = self_user_type;
  }

  return;
}
// This branch will get hit if we are executing code in the context of
// a function that claims to have an object pointer (through
// DW_AT_object_pointer?) but is not formally a method of the class.
// In that case, just look up the "self" variable in the current scope
// and use its type.

VariableList *vars = frame->GetVariableList(false);

lldb::VariableSP self_var = vars->FindVariable(ConstString("self"));

if (!self_var)
  return;
if (!self_var->IsInScope(frame))
  return;
if (!self_var->LocationIsValidForFrame(frame))
  return;

Type *self_type = self_var->GetType();

if (!self_type)
  return;

CompilerType self_clang_type = self_type->GetFullCompilerType();

if (TypeSystemClang::IsObjCClassType(self_clang_type)) {
  return;
}
if (!TypeSystemClang::IsObjCObjectPointerType(self_clang_type))
  return;
self_clang_type = self_clang_type.GetPointeeType();

if (!self_clang_type)
  return;

LLDB_LOG(log, "  FEVD[{0}] Adding type for $__lldb_objc_class: {1}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  FEVD[{0}] Adding type for $__lldb_objc_class: {1}"
, ClangUtil::ToString(self_type->GetFullCompilerType())); }
 while (0)
         ClangUtil::ToString(self_type->GetFullCompilerType()))do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  FEVD[{0}] Adding type for $__lldb_objc_class: {1}"
, ClangUtil::ToString(self_type->GetFullCompilerType())); }
 while (0);

TypeFromUser class_user_type(self_clang_type);

AddOneType(context, class_user_type);

TypeFromUser self_user_type(self_type->GetFullCompilerType());

m_struct_vars->m_object_pointer_type = self_user_type;
989}

991void ClangExpressionDeclMap::LookupLocalVarNamespace(
  SymbolContext &sym_ctx, NameSearchContext &name_context) {
if (sym_ctx.block == nullptr)
  return;

CompilerDeclContext frame_decl_context = sym_ctx.block->GetDeclContext();
if (!frame_decl_context)
  return;

TypeSystemClang *frame_ast = llvm::dyn_cast_or_null<TypeSystemClang>(
    frame_decl_context.GetTypeSystem());
if (!frame_ast)
  return;

clang::NamespaceDecl *namespace_decl =
    m_clang_ast_context->GetUniqueNamespaceDeclaration(
        g_lldb_local_vars_namespace_cstr, nullptr, OptionalClangModuleID());
if (!namespace_decl)
  return;

name_context.AddNamedDecl(namespace_decl);
clang::DeclContext *ctxt = clang::Decl::castToDeclContext(namespace_decl);
ctxt->setHasExternalVisibleStorage(true);
name_context.m_found_local_vars_nsp = true;
1015}

1017void ClangExpressionDeclMap::LookupInModulesDeclVendor(
  NameSearchContext &context, ConstString name) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8)));

if (!m_target)
  return;

std::shared_ptr<ClangModulesDeclVendor> modules_decl_vendor =
    GetClangModulesDeclVendor();
if (!modules_decl_vendor)
  return;

bool append = false;
uint32_t max_matches = 1;
std::vector<clang::NamedDecl *> decls;

if (!modules_decl_vendor->FindDecls(name, append, max_matches, decls))
  return;

assert(!decls.empty() && "FindDecls returned true but no decls?")((void)0);
clang::NamedDecl *const decl_from_modules = decls[0];

LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CAS::FEVD Matching decl found for " "\"{1}\" in the modules"
, name); } while (0)
         "  CAS::FEVD Matching decl found for "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CAS::FEVD Matching decl found for " "\"{1}\" in the modules"
, name); } while (0)
         "\"{1}\" in the modules",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CAS::FEVD Matching decl found for " "\"{1}\" in the modules"
, name); } while (0)
         name)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CAS::FEVD Matching decl found for " "\"{1}\" in the modules"
, name); } while (0);

clang::Decl *copied_decl = CopyDecl(decl_from_modules);
if (!copied_decl) {
  LLDB_LOG(log, "  CAS::FEVD - Couldn't export a "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CAS::FEVD - Couldn't export a " "declaration from the modules"
); } while (0)
                "declaration from the modules")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CAS::FEVD - Couldn't export a " "declaration from the modules"
); } while (0);
  return;
}

if (auto copied_function = dyn_cast<clang::FunctionDecl>(copied_decl)) {
  MaybeRegisterFunctionBody(copied_function);

  context.AddNamedDecl(copied_function);

  context.m_found_function_with_type_info = true;
  context.m_found_function = true;
} else if (auto copied_var = dyn_cast<clang::VarDecl>(copied_decl)) {
  context.AddNamedDecl(copied_var);
  context.m_found_variable = true;
}
1062}

1064bool ClangExpressionDeclMap::LookupLocalVariable(
  NameSearchContext &context, ConstString name, SymbolContext &sym_ctx,
  const CompilerDeclContext &namespace_decl) {
if (sym_ctx.block == nullptr)
  return false;

CompilerDeclContext decl_context = sym_ctx.block->GetDeclContext();
if (!decl_context)
  return false;

// Make sure that the variables are parsed so that we have the
// declarations.
StackFrame *frame = m_parser_vars->m_exe_ctx.GetFramePtr();
VariableListSP vars = frame->GetInScopeVariableList(true);
for (size_t i = 0; i < vars->GetSize(); i++)
  vars->GetVariableAtIndex(i)->GetDecl();

// Search for declarations matching the name. Do not include imported
// decls in the search if we are looking for decls in the artificial
// namespace $__lldb_local_vars.
std::vector<CompilerDecl> found_decls =
    decl_context.FindDeclByName(name, namespace_decl.IsValid());

VariableSP var;
bool variable_found = false;
for (CompilerDecl decl : found_decls) {
  for (size_t vi = 0, ve = vars->GetSize(); vi != ve; ++vi) {
    VariableSP candidate_var = vars->GetVariableAtIndex(vi);
    if (candidate_var->GetDecl() == decl) {
      var = candidate_var;
      break;
    }
  }

  if (var && !variable_found) {
    variable_found = true;
    ValueObjectSP valobj = ValueObjectVariable::Create(frame, var);
    AddOneVariable(context, var, valobj);
    context.m_found_variable = true;
  }
}
return variable_found;
1106}

1108/// Structure to hold the info needed when comparing function
1109/// declarations.
1110namespace {
1111struct FuncDeclInfo {
ConstString m_name;
CompilerType m_copied_type;
uint32_t m_decl_lvl;
SymbolContext m_sym_ctx;
1116};
1117} // namespace

1119SymbolContextList ClangExpressionDeclMap::SearchFunctionsInSymbolContexts(
  const SymbolContextList &sc_list,
  const CompilerDeclContext &frame_decl_context) {
// First, symplify things by looping through the symbol contexts to
// remove unwanted functions and separate out the functions we want to
// compare and prune into a separate list. Cache the info needed about
// the function declarations in a vector for efficiency.
uint32_t num_indices = sc_list.GetSize();
SymbolContextList sc_sym_list;
std::vector<FuncDeclInfo> decl_infos;
decl_infos.reserve(num_indices);
clang::DeclContext *frame_decl_ctx =
    (clang::DeclContext *)frame_decl_context.GetOpaqueDeclContext();
TypeSystemClang *ast = llvm::dyn_cast_or_null<TypeSystemClang>(
1
Assuming null pointer is passed into cast→
2
←
'ast' initialized to a null pointer value→
    frame_decl_context.GetTypeSystem());

for (uint32_t index = 0; index < num_indices; ++index) {
3
←
Assuming 'index' is < 'num_indices'→
4
←
Loop condition is true.  Entering loop body→
  FuncDeclInfo fdi;
  SymbolContext sym_ctx;
  sc_list.GetContextAtIndex(index, sym_ctx);

  // We don't know enough about symbols to compare them, but we should
  // keep them in the list.
  Function *function = sym_ctx.function;
  if (!function) {
5
←
Assuming 'function' is non-null→
6
←
Taking false branch→
    sc_sym_list.Append(sym_ctx);
    continue;
  }
  // Filter out functions without declaration contexts, as well as
  // class/instance methods, since they'll be skipped in the code that
  // follows anyway.
  CompilerDeclContext func_decl_context = function->GetDeclContext();
  if (!func_decl_context ||
7
←
Calling 'CompilerDeclContext::operator bool'→
14
←
Returning from 'CompilerDeclContext::operator bool'→
16
←
Taking false branch→
      func_decl_context.IsClassMethod(nullptr, nullptr, nullptr))
15
←
Assuming the condition is false→
    continue;
  // We can only prune functions for which we can copy the type.
  CompilerType func_clang_type = function->GetType()->GetFullCompilerType();
  CompilerType copied_func_type = GuardedCopyType(func_clang_type);
  if (!copied_func_type) {
17
←
Calling 'CompilerType::operator bool'→
21
←
Returning from 'CompilerType::operator bool'→
22
←
Taking false branch→
    sc_sym_list.Append(sym_ctx);
    continue;
  }

  fdi.m_sym_ctx = sym_ctx;
  fdi.m_name = function->GetName();
  fdi.m_copied_type = copied_func_type;
  fdi.m_decl_lvl = LLDB_INVALID_DECL_LEVEL0xffffffffU;
  if (fdi.m_copied_type && func_decl_context) {
23
←
Calling 'CompilerType::operator bool'→
25
←
Returning from 'CompilerType::operator bool'→
26
←
Calling 'CompilerDeclContext::operator bool'→
33
←
Returning from 'CompilerDeclContext::operator bool'→
34
←
Taking true branch→
    // Call CountDeclLevels to get the number of parent scopes we have
    // to look through before we find the function declaration. When
    // comparing functions of the same type, the one with a lower count
    // will be closer to us in the lookup scope and shadows the other.
    clang::DeclContext *func_decl_ctx =
        (clang::DeclContext *)func_decl_context.GetOpaqueDeclContext();
    fdi.m_decl_lvl = ast->CountDeclLevels(frame_decl_ctx, func_decl_ctx,
35
←
Called C++ object pointer is null
                                          &fdi.m_name, &fdi.m_copied_type);
  }
  decl_infos.emplace_back(fdi);
}

// Loop through the functions in our cache looking for matching types,
// then compare their scope levels to see which is closer.
std::multimap<CompilerType, const FuncDeclInfo *> matches;
for (const FuncDeclInfo &fdi : decl_infos) {
  const CompilerType t = fdi.m_copied_type;
  auto q = matches.find(t);
  if (q != matches.end()) {
    if (q->second->m_decl_lvl > fdi.m_decl_lvl)
      // This function is closer; remove the old set.
      matches.erase(t);
    else if (q->second->m_decl_lvl < fdi.m_decl_lvl)
      // The functions in our set are closer - skip this one.
      continue;
  }
  matches.insert(std::make_pair(t, &fdi));
}

// Loop through our matches and add their symbol contexts to our list.
SymbolContextList sc_func_list;
for (const auto &q : matches)
  sc_func_list.Append(q.second->m_sym_ctx);

// Rejoin the lists with the functions in front.
sc_func_list.Append(sc_sym_list);
return sc_func_list;
1204}

1206void ClangExpressionDeclMap::LookupFunction(
  NameSearchContext &context, lldb::ModuleSP module_sp, ConstString name,
  const CompilerDeclContext &namespace_decl) {
if (!m_parser_vars)
  return;

Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();

std::vector<clang::NamedDecl *> decls_from_modules;

if (target) {
  if (std::shared_ptr<ClangModulesDeclVendor> decl_vendor =
          GetClangModulesDeclVendor()) {
    decl_vendor->FindDecls(name, false, UINT32_MAX0xffffffffU, decls_from_modules);
  }
}

const bool include_inlines = false;
SymbolContextList sc_list;
if (namespace_decl && module_sp) {
  const bool include_symbols = false;

  module_sp->FindFunctions(name, namespace_decl, eFunctionNameTypeBase,
                           include_symbols, include_inlines, sc_list);
} else if (target && !namespace_decl) {
  const bool include_symbols = true;

  // TODO Fix FindFunctions so that it doesn't return
  //   instance methods for eFunctionNameTypeBase.

  target->GetImages().FindFunctions(
      name, eFunctionNameTypeFull | eFunctionNameTypeBase, include_symbols,
      include_inlines, sc_list);
}

// If we found more than one function, see if we can use the frame's decl
// context to remove functions that are shadowed by other functions which
// match in type but are nearer in scope.
//
// AddOneFunction will not add a function whose type has already been
// added, so if there's another function in the list with a matching type,
// check to see if their decl context is a parent of the current frame's or
// was imported via a and using statement, and pick the best match
// according to lookup rules.
if (sc_list.GetSize() > 1) {
  // Collect some info about our frame's context.
  StackFrame *frame = m_parser_vars->m_exe_ctx.GetFramePtr();
  SymbolContext frame_sym_ctx;
  if (frame != nullptr)
    frame_sym_ctx = frame->GetSymbolContext(lldb::eSymbolContextFunction |
                                            lldb::eSymbolContextBlock);
  CompilerDeclContext frame_decl_context =
      frame_sym_ctx.block != nullptr ? frame_sym_ctx.block->GetDeclContext()
                                     : CompilerDeclContext();

  // We can't do this without a compiler decl context for our frame.
  if (frame_decl_context) {
    sc_list = SearchFunctionsInSymbolContexts(sc_list, frame_decl_context);
  }
}

if (sc_list.GetSize()) {
  Symbol *extern_symbol = nullptr;
  Symbol *non_extern_symbol = nullptr;

  for (uint32_t index = 0, num_indices = sc_list.GetSize();
       index < num_indices; ++index) {
    SymbolContext sym_ctx;
    sc_list.GetContextAtIndex(index, sym_ctx);

    if (sym_ctx.function) {
      CompilerDeclContext decl_ctx = sym_ctx.function->GetDeclContext();

      if (!decl_ctx)
        continue;

      // Filter out class/instance methods.
      if (decl_ctx.IsClassMethod(nullptr, nullptr, nullptr))
        continue;

      AddOneFunction(context, sym_ctx.function, nullptr);
      context.m_found_function_with_type_info = true;
      context.m_found_function = true;
    } else if (sym_ctx.symbol) {
      if (sym_ctx.symbol->GetType() == eSymbolTypeReExported && target) {
        sym_ctx.symbol = sym_ctx.symbol->ResolveReExportedSymbol(*target);
        if (sym_ctx.symbol == nullptr)
          continue;
      }

      if (sym_ctx.symbol->IsExternal())
        extern_symbol = sym_ctx.symbol;
      else
        non_extern_symbol = sym_ctx.symbol;
    }
  }

  if (!context.m_found_function_with_type_info) {
    for (clang::NamedDecl *decl : decls_from_modules) {
      if (llvm::isa<clang::FunctionDecl>(decl)) {
        clang::NamedDecl *copied_decl =
            llvm::cast_or_null<FunctionDecl>(CopyDecl(decl));
        if (copied_decl) {
          context.AddNamedDecl(copied_decl);
          context.m_found_function_with_type_info = true;
        }
      }
    }
  }

  if (!context.m_found_function_with_type_info) {
    if (extern_symbol) {
      AddOneFunction(context, nullptr, extern_symbol);
      context.m_found_function = true;
    } else if (non_extern_symbol) {
      AddOneFunction(context, nullptr, non_extern_symbol);
      context.m_found_function = true;
    }
  }
}
1326}

1328void ClangExpressionDeclMap::FindExternalVisibleDecls(
  NameSearchContext &context, lldb::ModuleSP module_sp,
  const CompilerDeclContext &namespace_decl) {
assert(m_ast_context)((void)0);

Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8)));

const ConstString name(context.m_decl_name.getAsString().c_str());
if (IgnoreName(name, false))
  return;

// Only look for functions by name out in our symbols if the function doesn't
// start with our phony prefix of '$'

Target *target = nullptr;
StackFrame *frame = nullptr;
SymbolContext sym_ctx;
if (m_parser_vars) {
  target = m_parser_vars->m_exe_ctx.GetTargetPtr();
  frame = m_parser_vars->m_exe_ctx.GetFramePtr();
}
if (frame != nullptr)
  sym_ctx = frame->GetSymbolContext(lldb::eSymbolContextFunction |
                                    lldb::eSymbolContextBlock);

// Try the persistent decls, which take precedence over all else.
if (!namespace_decl)
  SearchPersistenDecls(context, name);

if (name.GetStringRef().startswith("$") && !namespace_decl) {
  if (name == "$__lldb_class") {
    LookUpLldbClass(context);
    return;
  }

  if (name == "$__lldb_objc_class") {
    LookUpLldbObjCClass(context);
    return;
  }
  if (name == g_lldb_local_vars_namespace_cstr) {
    LookupLocalVarNamespace(sym_ctx, context);
    return;
  }

  // any other $__lldb names should be weeded out now
  if (name.GetStringRef().startswith("$__lldb"))
    return;

  // No ParserVars means we can't do register or variable lookup.
  if (!m_parser_vars || !m_parser_vars->m_persistent_vars)
    return;

  ExpressionVariableSP pvar_sp(
      m_parser_vars->m_persistent_vars->GetVariable(name));

  if (pvar_sp) {
    AddOneVariable(context, pvar_sp);
    return;
  }

  assert(name.GetStringRef().startswith("$"))((void)0);
  llvm::StringRef reg_name = name.GetStringRef().substr(1);

  if (m_parser_vars->m_exe_ctx.GetRegisterContext()) {
    const RegisterInfo *reg_info(
        m_parser_vars->m_exe_ctx.GetRegisterContext()->GetRegisterInfoByName(
            reg_name));

    if (reg_info) {
      LLDB_LOG(log, "  CEDM::FEVD Found register {0}", reg_info->name)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::FEVD Found register {0}", reg_info->name
); } while (0);

      AddOneRegister(context, reg_info);
    }
  }
  return;
}

bool local_var_lookup = !namespace_decl || (namespace_decl.GetName() ==
                                            g_lldb_local_vars_namespace_cstr);
if (frame && local_var_lookup)
  if (LookupLocalVariable(context, name, sym_ctx, namespace_decl))
    return;

if (target) {
  ValueObjectSP valobj;
  VariableSP var;
  var = FindGlobalVariable(*target, module_sp, name, namespace_decl);

  if (var) {
    valobj = ValueObjectVariable::Create(target, var);
    AddOneVariable(context, var, valobj);
    context.m_found_variable = true;
    return;
  }
}

LookupFunction(context, module_sp, name, namespace_decl);

// Try the modules next.
if (!context.m_found_function_with_type_info)
  LookupInModulesDeclVendor(context, name);

if (target && !context.m_found_variable && !namespace_decl) {
  // We couldn't find a non-symbol variable for this.  Now we'll hunt for a
  // generic data symbol, and -- if it is found -- treat it as a variable.
  Status error;

  const Symbol *data_symbol =
      m_parser_vars->m_sym_ctx.FindBestGlobalDataSymbol(name, error);

  if (!error.Success()) {
    const unsigned diag_id =
        m_ast_context->getDiagnostics().getCustomDiagID(
            clang::DiagnosticsEngine::Level::Error, "%0");
    m_ast_context->getDiagnostics().Report(diag_id) << error.AsCString();
  }

  if (data_symbol) {
    std::string warning("got name from symbols: ");
    warning.append(name.AsCString());
    const unsigned diag_id =
        m_ast_context->getDiagnostics().getCustomDiagID(
            clang::DiagnosticsEngine::Level::Warning, "%0");
    m_ast_context->getDiagnostics().Report(diag_id) << warning.c_str();
    AddOneGenericVariable(context, *data_symbol);
    context.m_found_variable = true;
  }
}
1456}

1458bool ClangExpressionDeclMap::GetVariableValue(VariableSP &var,
                                            lldb_private::Value &var_location,
                                            TypeFromUser *user_type,
                                            TypeFromParser *parser_type) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8)));

Type *var_type = var->GetType();

if (!var_type) {
  LLDB_LOG(log, "Skipped a definition because it has no type")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "Skipped a definition because it has no type"); }
 while (0);
  return false;
}

CompilerType var_clang_type = var_type->GetFullCompilerType();

if (!var_clang_type) {
  LLDB_LOG(log, "Skipped a definition because it has no Clang type")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "Skipped a definition because it has no Clang type"
); } while (0);
  return false;
}

TypeSystemClang *clang_ast = llvm::dyn_cast_or_null<TypeSystemClang>(
    var_type->GetForwardCompilerType().GetTypeSystem());

if (!clang_ast) {
  LLDB_LOG(log, "Skipped a definition because it has no Clang AST")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "Skipped a definition because it has no Clang AST"
); } while (0);
  return false;
}

DWARFExpression &var_location_expr = var->LocationExpression();

Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
Status err;

if (var->GetLocationIsConstantValueData()) {
  DataExtractor const_value_extractor;

  if (var_location_expr.GetExpressionData(const_value_extractor)) {
    var_location = Value(const_value_extractor.GetDataStart(),
                         const_value_extractor.GetByteSize());
    var_location.SetValueType(Value::ValueType::HostAddress);
  } else {
    LLDB_LOG(log, "Error evaluating constant variable: {0}", err.AsCString())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "Error evaluating constant variable: {0}", err.AsCString
()); } while (0);
    return false;
  }
}

CompilerType type_to_use = GuardedCopyType(var_clang_type);

if (!type_to_use) {
  LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "Couldn't copy a variable's type into the parser's AST context"
); } while (0)
           "Couldn't copy a variable's type into the parser's AST context")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "Couldn't copy a variable's type into the parser's AST context"
); } while (0);

  return false;
}

if (parser_type)
  *parser_type = TypeFromParser(type_to_use);

if (var_location.GetContextType() == Value::ContextType::Invalid)
  var_location.SetCompilerType(type_to_use);

if (var_location.GetValueType() == Value::ValueType::FileAddress) {
  SymbolContext var_sc;
  var->CalculateSymbolContext(&var_sc);

  if (!var_sc.module_sp)
    return false;

  Address so_addr(var_location.GetScalar().ULongLong(),
                  var_sc.module_sp->GetSectionList());

  lldb::addr_t load_addr = so_addr.GetLoadAddress(target);

  if (load_addr != LLDB_INVALID_ADDRESS0xffffffffffffffffULL) {
    var_location.GetScalar() = load_addr;
    var_location.SetValueType(Value::ValueType::LoadAddress);
  }
}

if (user_type)
  *user_type = TypeFromUser(var_clang_type);

return true;
1541}

1543void ClangExpressionDeclMap::AddOneVariable(NameSearchContext &context,
                                          VariableSP var,
                                          ValueObjectSP valobj) {
assert(m_parser_vars.get())((void)0);

Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8)));

TypeFromUser ut;
TypeFromParser pt;
Value var_location;

if (!GetVariableValue(var, var_location, &ut, &pt))
  return;

clang::QualType parser_opaque_type =
    QualType::getFromOpaquePtr(pt.GetOpaqueQualType());

if (parser_opaque_type.isNull())
  return;

if (const clang::Type *parser_type = parser_opaque_type.getTypePtr()) {
  if (const TagType *tag_type = dyn_cast<TagType>(parser_type))
    CompleteType(tag_type->getDecl());
  if (const ObjCObjectPointerType *objc_object_ptr_type =
          dyn_cast<ObjCObjectPointerType>(parser_type))
    CompleteType(objc_object_ptr_type->getInterfaceDecl());
}

bool is_reference = pt.IsReferenceType();

NamedDecl *var_decl = nullptr;
if (is_reference)
  var_decl = context.AddVarDecl(pt);
else
  var_decl = context.AddVarDecl(pt.GetLValueReferenceType());

std::string decl_name(context.m_decl_name.getAsString());
ConstString entity_name(decl_name.c_str());
ClangExpressionVariable *entity(new ClangExpressionVariable(valobj));
m_found_entities.AddNewlyConstructedVariable(entity);

assert(entity)((void)0);
entity->EnableParserVars(GetParserID());
ClangExpressionVariable::ParserVars *parser_vars =
    entity->GetParserVars(GetParserID());
parser_vars->m_named_decl = var_decl;
parser_vars->m_llvm_value = nullptr;
parser_vars->m_lldb_value = var_location;
parser_vars->m_lldb_var = var;

if (is_reference)
  entity->m_flags |= ClangExpressionVariable::EVTypeIsReference;

LLDB_LOG(log, "  CEDM::FEVD Found variable {1}, returned\n{2} (original {3})",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::FEVD Found variable {1}, returned\n{2} (original {3})"
, decl_name, ClangUtil::DumpDecl(var_decl), ClangUtil::ToString
(ut)); } while (0)
         decl_name, ClangUtil::DumpDecl(var_decl), ClangUtil::ToString(ut))do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::FEVD Found variable {1}, returned\n{2} (original {3})"
, decl_name, ClangUtil::DumpDecl(var_decl), ClangUtil::ToString
(ut)); } while (0);
1598}

1600void ClangExpressionDeclMap::AddOneVariable(NameSearchContext &context,
                                          ExpressionVariableSP &pvar_sp) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8)));

TypeFromUser user_type(
    llvm::cast<ClangExpressionVariable>(pvar_sp.get())->GetTypeFromUser());

TypeFromParser parser_type(GuardedCopyType(user_type));

if (!parser_type.GetOpaqueQualType()) {
  LLDB_LOG(log, "  CEDM::FEVD Couldn't import type for pvar {0}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::FEVD Couldn't import type for pvar {0}",
 pvar_sp->GetName()); } while (0)
           pvar_sp->GetName())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::FEVD Couldn't import type for pvar {0}",
 pvar_sp->GetName()); } while (0);
  return;
}

NamedDecl *var_decl =
    context.AddVarDecl(parser_type.GetLValueReferenceType());

llvm::cast<ClangExpressionVariable>(pvar_sp.get())
    ->EnableParserVars(GetParserID());
ClangExpressionVariable::ParserVars *parser_vars =
    llvm::cast<ClangExpressionVariable>(pvar_sp.get())
        ->GetParserVars(GetParserID());
parser_vars->m_named_decl = var_decl;
parser_vars->m_llvm_value = nullptr;
parser_vars->m_lldb_value.Clear();

LLDB_LOG(log, "  CEDM::FEVD Added pvar {1}, returned\n{2}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::FEVD Added pvar {1}, returned\n{2}", pvar_sp
->GetName(), ClangUtil::DumpDecl(var_decl)); } while (0)
         pvar_sp->GetName(), ClangUtil::DumpDecl(var_decl))do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::FEVD Added pvar {1}, returned\n{2}", pvar_sp
->GetName(), ClangUtil::DumpDecl(var_decl)); } while (0);
1629}

1631void ClangExpressionDeclMap::AddOneGenericVariable(NameSearchContext &context,
                                                 const Symbol &symbol) {
assert(m_parser_vars.get())((void)0);

Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8)));

Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();

if (target == nullptr)
  return;

TypeSystemClang *scratch_ast_context = GetScratchContext(*target);
if (!scratch_ast_context)
  return;

TypeFromUser user_type(scratch_ast_context->GetBasicType(eBasicTypeVoid)
                           .GetPointerType()
                           .GetLValueReferenceType());
TypeFromParser parser_type(m_clang_ast_context->GetBasicType(eBasicTypeVoid)
                               .GetPointerType()
                               .GetLValueReferenceType());
NamedDecl *var_decl = context.AddVarDecl(parser_type);

std::string decl_name(context.m_decl_name.getAsString());
ConstString entity_name(decl_name.c_str());
ClangExpressionVariable *entity(new ClangExpressionVariable(
    m_parser_vars->m_exe_ctx.GetBestExecutionContextScope(), entity_name,
    user_type, m_parser_vars->m_target_info.byte_order,
    m_parser_vars->m_target_info.address_byte_size));
m_found_entities.AddNewlyConstructedVariable(entity);

entity->EnableParserVars(GetParserID());
ClangExpressionVariable::ParserVars *parser_vars =
    entity->GetParserVars(GetParserID());

const Address symbol_address = symbol.GetAddress();
lldb::addr_t symbol_load_addr = symbol_address.GetLoadAddress(target);

// parser_vars->m_lldb_value.SetContext(Value::ContextType::ClangType,
// user_type.GetOpaqueQualType());
parser_vars->m_lldb_value.SetCompilerType(user_type);
parser_vars->m_lldb_value.GetScalar() = symbol_load_addr;
parser_vars->m_lldb_value.SetValueType(Value::ValueType::LoadAddress);

parser_vars->m_named_decl = var_decl;
parser_vars->m_llvm_value = nullptr;
parser_vars->m_lldb_sym = &symbol;

LLDB_LOG(log, "  CEDM::FEVD Found variable {1}, returned\n{2}", decl_name,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::FEVD Found variable {1}, returned\n{2}",
 decl_name, ClangUtil::DumpDecl(var_decl)); } while (0)
         ClangUtil::DumpDecl(var_decl))do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::FEVD Found variable {1}, returned\n{2}",
 decl_name, ClangUtil::DumpDecl(var_decl)); } while (0);
1681}

1683void ClangExpressionDeclMap::AddOneRegister(NameSearchContext &context,
                                          const RegisterInfo *reg_info) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8)));

CompilerType clang_type =
    m_clang_ast_context->GetBuiltinTypeForEncodingAndBitSize(
        reg_info->encoding, reg_info->byte_size * 8);

if (!clang_type) {
  LLDB_LOG(log, "  Tried to add a type for {0}, but couldn't get one",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  Tried to add a type for {0}, but couldn't get one"
, context.m_decl_name.getAsString()); } while (0)
           context.m_decl_name.getAsString())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  Tried to add a type for {0}, but couldn't get one"
, context.m_decl_name.getAsString()); } while (0);
  return;
}

TypeFromParser parser_clang_type(clang_type);

NamedDecl *var_decl = context.AddVarDecl(parser_clang_type);

ClangExpressionVariable *entity(new ClangExpressionVariable(
    m_parser_vars->m_exe_ctx.GetBestExecutionContextScope(),
    m_parser_vars->m_target_info.byte_order,
    m_parser_vars->m_target_info.address_byte_size));
m_found_entities.AddNewlyConstructedVariable(entity);

std::string decl_name(context.m_decl_name.getAsString());
entity->SetName(ConstString(decl_name.c_str()));
entity->SetRegisterInfo(reg_info);
entity->EnableParserVars(GetParserID());
ClangExpressionVariable::ParserVars *parser_vars =
    entity->GetParserVars(GetParserID());
parser_vars->m_named_decl = var_decl;
parser_vars->m_llvm_value = nullptr;
parser_vars->m_lldb_value.Clear();
entity->m_flags |= ClangExpressionVariable::EVBareRegister;

LLDB_LOG(log, "  CEDM::FEVD Added register {1}, returned\n{2}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::FEVD Added register {1}, returned\n{2}",
 context.m_decl_name.getAsString(), ClangUtil::DumpDecl(var_decl
)); } while (0)
         context.m_decl_name.getAsString(), ClangUtil::DumpDecl(var_decl))do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::FEVD Added register {1}, returned\n{2}",
 context.m_decl_name.getAsString(), ClangUtil::DumpDecl(var_decl
)); } while (0);
1720}

1722void ClangExpressionDeclMap::AddOneFunction(NameSearchContext &context,
                                          Function *function,
                                          Symbol *symbol) {
assert(m_parser_vars.get())((void)0);

Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8)));

NamedDecl *function_decl = nullptr;
Address fun_address;
CompilerType function_clang_type;

bool is_indirect_function = false;

if (function) {
  Type *function_type = function->GetType();

  const auto lang = function->GetCompileUnit()->GetLanguage();
  const auto name = function->GetMangled().GetMangledName().AsCString();
  const bool extern_c = (Language::LanguageIsC(lang) &&
                         !CPlusPlusLanguage::IsCPPMangledName(name)) ||
                        (Language::LanguageIsObjC(lang) &&
                         !Language::LanguageIsCPlusPlus(lang));

  if (!extern_c) {
    TypeSystem *type_system = function->GetDeclContext().GetTypeSystem();
    if (llvm::isa<TypeSystemClang>(type_system)) {
      clang::DeclContext *src_decl_context =
          (clang::DeclContext *)function->GetDeclContext()
              .GetOpaqueDeclContext();
      clang::FunctionDecl *src_function_decl =
          llvm::dyn_cast_or_null<clang::FunctionDecl>(src_decl_context);
      if (src_function_decl &&
          src_function_decl->getTemplateSpecializationInfo()) {
        clang::FunctionTemplateDecl *function_template =
            src_function_decl->getTemplateSpecializationInfo()->getTemplate();
        clang::FunctionTemplateDecl *copied_function_template =
            llvm::dyn_cast_or_null<clang::FunctionTemplateDecl>(
                CopyDecl(function_template));
        if (copied_function_template) {
          if (log) {
            StreamString ss;

            function->DumpSymbolContext(&ss);

            LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::FEVD Imported decl for function template"
 " {1} (description {2}), returned\n{3}", copied_function_template
->getNameAsString(), ss.GetData(), ClangUtil::DumpDecl(copied_function_template
)); } while (0)
                     "  CEDM::FEVD Imported decl for function template"do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::FEVD Imported decl for function template"
 " {1} (description {2}), returned\n{3}", copied_function_template
->getNameAsString(), ss.GetData(), ClangUtil::DumpDecl(copied_function_template
)); } while (0)
                     " {1} (description {2}), returned\n{3}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::FEVD Imported decl for function template"
 " {1} (description {2}), returned\n{3}", copied_function_template
->getNameAsString(), ss.GetData(), ClangUtil::DumpDecl(copied_function_template
)); } while (0)
                     copied_function_template->getNameAsString(),do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::FEVD Imported decl for function template"
 " {1} (description {2}), returned\n{3}", copied_function_template
->getNameAsString(), ss.GetData(), ClangUtil::DumpDecl(copied_function_template
)); } while (0)
                     ss.GetData(),do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::FEVD Imported decl for function template"
 " {1} (description {2}), returned\n{3}", copied_function_template
->getNameAsString(), ss.GetData(), ClangUtil::DumpDecl(copied_function_template
)); } while (0)
                     ClangUtil::DumpDecl(copied_function_template))do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::FEVD Imported decl for function template"
 " {1} (description {2}), returned\n{3}", copied_function_template
->getNameAsString(), ss.GetData(), ClangUtil::DumpDecl(copied_function_template
)); } while (0);
          }

          context.AddNamedDecl(copied_function_template);
        }
      } else if (src_function_decl) {
        if (clang::FunctionDecl *copied_function_decl =
                llvm::dyn_cast_or_null<clang::FunctionDecl>(
                    CopyDecl(src_function_decl))) {
          if (log) {
            StreamString ss;

            function->DumpSymbolContext(&ss);

            LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::FEVD Imported decl for function {1} " "(description {2}), returned\n{3}"
, copied_function_decl->getNameAsString(), ss.GetData(), ClangUtil
::DumpDecl(copied_function_decl)); } while (0)
                     "  CEDM::FEVD Imported decl for function {1} "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::FEVD Imported decl for function {1} " "(description {2}), returned\n{3}"
, copied_function_decl->getNameAsString(), ss.GetData(), ClangUtil
::DumpDecl(copied_function_decl)); } while (0)
                     "(description {2}), returned\n{3}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::FEVD Imported decl for function {1} " "(description {2}), returned\n{3}"
, copied_function_decl->getNameAsString(), ss.GetData(), ClangUtil
::DumpDecl(copied_function_decl)); } while (0)
                     copied_function_decl->getNameAsString(), ss.GetData(),do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::FEVD Imported decl for function {1} " "(description {2}), returned\n{3}"
, copied_function_decl->getNameAsString(), ss.GetData(), ClangUtil
::DumpDecl(copied_function_decl)); } while (0)
                     ClangUtil::DumpDecl(copied_function_decl))do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::FEVD Imported decl for function {1} " "(description {2}), returned\n{3}"
, copied_function_decl->getNameAsString(), ss.GetData(), ClangUtil
::DumpDecl(copied_function_decl)); } while (0);
          }

          context.AddNamedDecl(copied_function_decl);
          return;
        } else {
          LLDB_LOG(log, "  Failed to import the function decl for '{0}'",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  Failed to import the function decl for '{0}'",
 src_function_decl->getName()); } while (0)
                   src_function_decl->getName())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  Failed to import the function decl for '{0}'",
 src_function_decl->getName()); } while (0);
        }
      }
    }
  }

  if (!function_type) {
    LLDB_LOG(log, "  Skipped a function because it has no type")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  Skipped a function because it has no type"); }
 while (0);
    return;
  }

  function_clang_type = function_type->GetFullCompilerType();

  if (!function_clang_type) {
    LLDB_LOG(log, "  Skipped a function because it has no Clang type")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  Skipped a function because it has no Clang type"
); } while (0);
    return;
  }

  fun_address = function->GetAddressRange().GetBaseAddress();

  CompilerType copied_function_type = GuardedCopyType(function_clang_type);
  if (copied_function_type) {
    function_decl = context.AddFunDecl(copied_function_type, extern_c);

    if (!function_decl) {
      LLDB_LOG(log, "  Failed to create a function decl for '{0}' ({1:x})",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  Failed to create a function decl for '{0}' ({1:x})"
, function_type->GetName(), function_type->GetID()); } while
 (0)
               function_type->GetName(), function_type->GetID())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  Failed to create a function decl for '{0}' ({1:x})"
, function_type->GetName(), function_type->GetID()); } while
 (0);

      return;
    }
  } else {
    // We failed to copy the type we found
    LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  Failed to import the function type '{0}' ({1:x})"
 " into the expression parser AST contenxt", function_type->
GetName(), function_type->GetID()); } while (0)
             "  Failed to import the function type '{0}' ({1:x})"do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  Failed to import the function type '{0}' ({1:x})"
 " into the expression parser AST contenxt", function_type->
GetName(), function_type->GetID()); } while (0)
             " into the expression parser AST contenxt",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  Failed to import the function type '{0}' ({1:x})"
 " into the expression parser AST contenxt", function_type->
GetName(), function_type->GetID()); } while (0)
             function_type->GetName(), function_type->GetID())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  Failed to import the function type '{0}' ({1:x})"
 " into the expression parser AST contenxt", function_type->
GetName(), function_type->GetID()); } while (0);

    return;
  }
} else if (symbol) {
  fun_address = symbol->GetAddress();
  function_decl = context.AddGenericFunDecl();
  is_indirect_function = symbol->IsIndirect();
} else {
  LLDB_LOG(log, "  AddOneFunction called with no function and no symbol")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  AddOneFunction called with no function and no symbol"
); } while (0);
  return;
}

Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();

lldb::addr_t load_addr =
    fun_address.GetCallableLoadAddress(target, is_indirect_function);

ClangExpressionVariable *entity(new ClangExpressionVariable(
    m_parser_vars->m_exe_ctx.GetBestExecutionContextScope(),
    m_parser_vars->m_target_info.byte_order,
    m_parser_vars->m_target_info.address_byte_size));
m_found_entities.AddNewlyConstructedVariable(entity);

std::string decl_name(context.m_decl_name.getAsString());
entity->SetName(ConstString(decl_name.c_str()));
entity->SetCompilerType(function_clang_type);
entity->EnableParserVars(GetParserID());

ClangExpressionVariable::ParserVars *parser_vars =
    entity->GetParserVars(GetParserID());

if (load_addr != LLDB_INVALID_ADDRESS0xffffffffffffffffULL) {
  parser_vars->m_lldb_value.SetValueType(Value::ValueType::LoadAddress);
  parser_vars->m_lldb_value.GetScalar() = load_addr;
} else {
  // We have to try finding a file address.

  lldb::addr_t file_addr = fun_address.GetFileAddress();

  parser_vars->m_lldb_value.SetValueType(Value::ValueType::FileAddress);
  parser_vars->m_lldb_value.GetScalar() = file_addr;
}

parser_vars->m_named_decl = function_decl;
parser_vars->m_llvm_value = nullptr;

if (log) {
  StreamString ss;

  fun_address.Dump(&ss,
                   m_parser_vars->m_exe_ctx.GetBestExecutionContextScope(),
                   Address::DumpStyleResolvedDescription);

  LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::FEVD Found {1} function {2} (description {3}), "
 "returned\n{4}", (function ? "specific" : "generic"), decl_name
, ss.GetData(), ClangUtil::DumpDecl(function_decl)); } while (
0)
           "  CEDM::FEVD Found {1} function {2} (description {3}), "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::FEVD Found {1} function {2} (description {3}), "
 "returned\n{4}", (function ? "specific" : "generic"), decl_name
, ss.GetData(), ClangUtil::DumpDecl(function_decl)); } while (
0)
           "returned\n{4}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::FEVD Found {1} function {2} (description {3}), "
 "returned\n{4}", (function ? "specific" : "generic"), decl_name
, ss.GetData(), ClangUtil::DumpDecl(function_decl)); } while (
0)
           (function ? "specific" : "generic"), decl_name, ss.GetData(),do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::FEVD Found {1} function {2} (description {3}), "
 "returned\n{4}", (function ? "specific" : "generic"), decl_name
, ss.GetData(), ClangUtil::DumpDecl(function_decl)); } while (
0)
           ClangUtil::DumpDecl(function_decl))do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::FEVD Found {1} function {2} (description {3}), "
 "returned\n{4}", (function ? "specific" : "generic"), decl_name
, ss.GetData(), ClangUtil::DumpDecl(function_decl)); } while (
0);
}
1891}

1893void ClangExpressionDeclMap::AddContextClassType(NameSearchContext &context,
                                               const TypeFromUser &ut) {
CompilerType copied_clang_type = GuardedCopyType(ut);

Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8)));

if (!copied_clang_type) {
  LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "ClangExpressionDeclMap::AddThisType - Couldn't import the type"
); } while (0)
           "ClangExpressionDeclMap::AddThisType - Couldn't import the type")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "ClangExpressionDeclMap::AddThisType - Couldn't import the type"
); } while (0);

  return;
}

if (copied_clang_type.IsAggregateType() &&
    copied_clang_type.GetCompleteType()) {
  CompilerType void_clang_type =
      m_clang_ast_context->GetBasicType(eBasicTypeVoid);
  CompilerType void_ptr_clang_type = void_clang_type.GetPointerType();

  CompilerType method_type = m_clang_ast_context->CreateFunctionType(
      void_clang_type, &void_ptr_clang_type, 1, false, 0);

  const bool is_virtual = false;
  const bool is_static = false;
  const bool is_inline = false;
  const bool is_explicit = false;
  const bool is_attr_used = true;
  const bool is_artificial = false;

  CXXMethodDecl *method_decl = m_clang_ast_context->AddMethodToCXXRecordType(
      copied_clang_type.GetOpaqueQualType(), "$__lldb_expr", nullptr,
      method_type, lldb::eAccessPublic, is_virtual, is_static, is_inline,
      is_explicit, is_attr_used, is_artificial);

  LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::AddThisType Added function $__lldb_expr "
 "(description {0}) for this type\n{1}", ClangUtil::ToString(
copied_clang_type), ClangUtil::DumpDecl(method_decl)); } while
 (0)
           "  CEDM::AddThisType Added function $__lldb_expr "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::AddThisType Added function $__lldb_expr "
 "(description {0}) for this type\n{1}", ClangUtil::ToString(
copied_clang_type), ClangUtil::DumpDecl(method_decl)); } while
 (0)
           "(description {0}) for this type\n{1}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::AddThisType Added function $__lldb_expr "
 "(description {0}) for this type\n{1}", ClangUtil::ToString(
copied_clang_type), ClangUtil::DumpDecl(method_decl)); } while
 (0)
           ClangUtil::ToString(copied_clang_type),do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::AddThisType Added function $__lldb_expr "
 "(description {0}) for this type\n{1}", ClangUtil::ToString(
copied_clang_type), ClangUtil::DumpDecl(method_decl)); } while
 (0)
           ClangUtil::DumpDecl(method_decl))do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "  CEDM::AddThisType Added function $__lldb_expr "
 "(description {0}) for this type\n{1}", ClangUtil::ToString(
copied_clang_type), ClangUtil::DumpDecl(method_decl)); } while
 (0);
}

if (!copied_clang_type.IsValid())
  return;

TypeSourceInfo *type_source_info = m_ast_context->getTrivialTypeSourceInfo(
    QualType::getFromOpaquePtr(copied_clang_type.GetOpaqueQualType()));

if (!type_source_info)
  return;

// Construct a typedef type because if "*this" is a templated type we can't
// just return ClassTemplateSpecializationDecls in response to name queries.
// Using a typedef makes this much more robust.

TypedefDecl *typedef_decl = TypedefDecl::Create(
    *m_ast_context, m_ast_context->getTranslationUnitDecl(), SourceLocation(),
    SourceLocation(), context.m_decl_name.getAsIdentifierInfo(),
    type_source_info);

if (!typedef_decl)
  return;

context.AddNamedDecl(typedef_decl);

return;
1958}

1960void ClangExpressionDeclMap::AddOneType(NameSearchContext &context,
                                      const TypeFromUser &ut) {
CompilerType copied_clang_type = GuardedCopyType(ut);

if (!copied_clang_type) {
  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS(1u << 8)));

  LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "ClangExpressionDeclMap::AddOneType - Couldn't import the type"
); } while (0)
           "ClangExpressionDeclMap::AddOneType - Couldn't import the type")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp"
, __func__, "ClangExpressionDeclMap::AddOneType - Couldn't import the type"
); } while (0);

  return;
}

context.AddTypeDecl(copied_clang_type);
1974}

←

/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/include/lldb/Symbol/CompilerDeclContext.h

→

1//===-- CompilerDeclContext.h -----------------------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8 
9#ifndef LLDB_SYMBOL_COMPILERDECLCONTEXT_H
10#define LLDB_SYMBOL_COMPILERDECLCONTEXT_H
11 
12#include <vector>
13 
14#include "lldb/Utility/ConstString.h"
15#include "lldb/lldb-private.h"
16 
17namespace lldb_private {
18 
19/// Represents a generic declaration context in a program. A declaration context
20/// is data structure that contains declarations (e.g. namespaces).
21///
22/// This class serves as an abstraction for a declaration context inside one of
23/// the TypeSystems implemented by the language plugins. It does not have any
24/// actual logic in it but only stores an opaque pointer and a pointer to the
25/// TypeSystem that gives meaning to this opaque pointer. All methods of this
26/// class should call their respective method in the TypeSystem interface and
27/// pass the opaque pointer along.
28///
29/// \see lldb_private::TypeSystem
30class CompilerDeclContext {
31public:
32  /// Constructs an invalid CompilerDeclContext.
33  CompilerDeclContext() = default;
34 
35  /// Constructs a CompilerDeclContext with the given opaque decl context
36  /// and its respective TypeSystem instance.
37  ///
38  /// This constructor should only be called from the respective TypeSystem
39  /// implementation.
40  ///
41  /// \see lldb_private::TypeSystemClang::CreateDeclContext(clang::DeclContext*)
42  CompilerDeclContext(TypeSystem *type_system, void *decl_ctx)
43      : m_type_system(type_system), m_opaque_decl_ctx(decl_ctx) {}
44 
45  // Tests
46 
47  explicit operator bool() const { return IsValid(); }
8
←
Calling 'CompilerDeclContext::IsValid'→
12
←
Returning from 'CompilerDeclContext::IsValid'→
13
←
Returning the value 1, which participates in a condition later→
27
←
Calling 'CompilerDeclContext::IsValid'→
31
←
Returning from 'CompilerDeclContext::IsValid'→
32
←
Returning the value 1, which participates in a condition later→
48 
49  bool operator<(const CompilerDeclContext &rhs) const {
50    if (m_type_system == rhs.m_type_system)
51      return m_opaque_decl_ctx < rhs.m_opaque_decl_ctx;
52    return m_type_system < rhs.m_type_system;
53  }
54 
55  bool IsValid() const {
56    return m_type_system != nullptr && m_opaque_decl_ctx != nullptr;
9
←
Assuming the condition is true→
10
←
Assuming the condition is true→
11
←
Returning the value 1, which participates in a condition later→
28
←
Assuming the condition is true→
29
←
Assuming the condition is true→
30
←
Returning the value 1, which participates in a condition later→
57  }
58 
59  std::vector<CompilerDecl> FindDeclByName(ConstString name,
60                                           const bool ignore_using_decls);
61 
62  /// Checks if this decl context represents a method of a class.
63  ///
64  /// \param[out] language_ptr
65  ///     If non NULL and \b true is returned from this function,
66  ///     this will indicate if the language that respresents the method.
67  ///
68  /// \param[out] is_instance_method_ptr
69  ///     If non NULL and \b true is returned from this function,
70  ///     this will indicate if the method is an instance function (true)
71  ///     or a class method (false indicating the function is static, or
72  ///     doesn't require an instance of the class to be called).
73  ///
74  /// \param[out] language_object_name_ptr
75  ///     If non NULL and \b true is returned from this function,
76  ///     this will indicate if implicit object name for the language
77  ///     like "this" for C++, and "self" for Objective C.
78  ///
79  /// \return
80  ///     Returns true if this is a decl context that represents a method
81  ///     in a struct, union or class.
82  bool IsClassMethod(lldb::LanguageType *language_ptr,
83                     bool *is_instance_method_ptr,
84                     ConstString *language_object_name_ptr);
85 
86  /// Check if the given other decl context is contained in the lookup
87  /// of this decl context (for example because the other context is a nested
88  /// inline namespace).
89  ///
90  /// @param[in] other
91  ///     The other decl context for which we should check if it is contained
92  ///     in the lookoup of this context.
93  ///
94  /// @return
95  ///     Returns true iff the other decl context is contained in the lookup
96  ///     of this decl context.
97  bool IsContainedInLookup(CompilerDeclContext other) const;
98 
99  // Accessors
100 
101  TypeSystem *GetTypeSystem() const { return m_type_system; }
102 
103  void *GetOpaqueDeclContext() const { return m_opaque_decl_ctx; }
104 
105  void SetDeclContext(TypeSystem *type_system, void *decl_ctx) {
106    m_type_system = type_system;
107    m_opaque_decl_ctx = decl_ctx;
108  }
109 
110  void Clear() {
111    m_type_system = nullptr;
112    m_opaque_decl_ctx = nullptr;
113  }
114 
115  ConstString GetName() const;
116 
117  ConstString GetScopeQualifiedName() const;
118 
119private:
120  TypeSystem *m_type_system = nullptr;
121  void *m_opaque_decl_ctx = nullptr;
122};
123 
124bool operator==(const CompilerDeclContext &lhs, const CompilerDeclContext &rhs);
125bool operator!=(const CompilerDeclContext &lhs, const CompilerDeclContext &rhs);
126 
127} // namespace lldb_private
128 
129#endif // LLDB_SYMBOL_COMPILERDECLCONTEXT_H

←

/usr/src/gnu/usr.bin/clang/liblldbPluginExpressionParser/../../../llvm/lldb/include/lldb/Symbol/CompilerType.h

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

9#ifndef LLDB_SYMBOL_COMPILERTYPE_H
10#define LLDB_SYMBOL_COMPILERTYPE_H

12#include <functional>
13#include <string>
14#include <vector>

16#include "lldb/lldb-private.h"
17#include "llvm/ADT/APSInt.h"

19namespace lldb_private {

21class DataExtractor;

23/// Generic representation of a type in a programming language.
24///
25/// This class serves as an abstraction for a type inside one of the TypeSystems
26/// implemented by the language plugins. It does not have any actual logic in it
27/// but only stores an opaque pointer and a pointer to the TypeSystem that
28/// gives meaning to this opaque pointer. All methods of this class should call
29/// their respective method in the TypeSystem interface and pass the opaque
30/// pointer along.
31///
32/// \see lldb_private::TypeSystem
33class CompilerType {
34public:
/// Creates a CompilerType with the given TypeSystem and opaque compiler type.
///
/// This constructor should only be called from the respective TypeSystem
/// implementation.
///
/// \see lldb_private::TypeSystemClang::GetType(clang::QualType)
CompilerType(TypeSystem *type_system, lldb::opaque_compiler_type_t type)
    : m_type(type), m_type_system(type_system) {
  assert(Verify() && "verification failed")((void)0);
}

CompilerType(const CompilerType &rhs)
    : m_type(rhs.m_type), m_type_system(rhs.m_type_system) {}

CompilerType() = default;

/// Operators.
/// \{
const CompilerType &operator=(const CompilerType &rhs) {
  m_type = rhs.m_type;
  m_type_system = rhs.m_type_system;
  return *this;
}

bool operator<(const CompilerType &rhs) const {
  if (m_type_system == rhs.m_type_system)
    return m_type < rhs.m_type;
  return m_type_system < rhs.m_type_system;
}
/// \}

/// Tests.
/// \{
explicit operator bool() const {
  return m_type != nullptr && m_type_system != nullptr;
18
←
Assuming the condition is true→
19
←
Assuming the condition is true→
20
←
Returning the value 1, which participates in a condition later→
24
←
Returning the value 1, which participates in a condition later→
}

bool IsValid() const { return m_type != nullptr && m_type_system != nullptr; }

bool IsArrayType(CompilerType *element_type = nullptr,
                 uint64_t *size = nullptr,
                 bool *is_incomplete = nullptr) const;

bool IsVectorType(CompilerType *element_type = nullptr,
                  uint64_t *size = nullptr) const;

bool IsArrayOfScalarType() const;

bool IsAggregateType() const;

bool IsAnonymousType() const;

bool IsScopedEnumerationType() const;

bool IsBeingDefined() const;

bool IsCharType() const;

bool IsCompleteType() const;

bool IsConst() const;

bool IsCStringType(uint32_t &length) const;

bool IsDefined() const;

bool IsFloatingPointType(uint32_t &count, bool &is_complex) const;

bool IsFunctionType() const;

uint32_t IsHomogeneousAggregate(CompilerType *base_type_ptr) const;

size_t GetNumberOfFunctionArguments() const;

CompilerType GetFunctionArgumentAtIndex(const size_t index) const;

bool IsVariadicFunctionType() const;

bool IsFunctionPointerType() const;

bool
IsBlockPointerType(CompilerType *function_pointer_type_ptr = nullptr) const;

bool IsIntegerType(bool &is_signed) const;

bool IsEnumerationType(bool &is_signed) const;

bool IsIntegerOrEnumerationType(bool &is_signed) const;

bool IsPolymorphicClass() const;

/// \param target_type    Can pass nullptr.
bool IsPossibleDynamicType(CompilerType *target_type, bool check_cplusplus,
                           bool check_objc) const;

bool IsPointerToScalarType() const;

bool IsRuntimeGeneratedType() const;

bool IsPointerType(CompilerType *pointee_type = nullptr) const;

bool IsPointerOrReferenceType(CompilerType *pointee_type = nullptr) const;

bool IsReferenceType(CompilerType *pointee_type = nullptr,
                     bool *is_rvalue = nullptr) const;

bool ShouldTreatScalarValueAsAddress() const;

bool IsScalarType() const;

bool IsTypedefType() const;

bool IsVoidType() const;
/// \}

/// Type Completion.
/// \{
bool GetCompleteType() const;
/// \}

/// AST related queries.
/// \{
size_t GetPointerByteSize() const;
/// \}

/// Accessors.
/// \{
TypeSystem *GetTypeSystem() const { return m_type_system; }

ConstString GetTypeName() const;

ConstString GetDisplayTypeName() const;

uint32_t
GetTypeInfo(CompilerType *pointee_or_element_compiler_type = nullptr) const;

lldb::LanguageType GetMinimumLanguage();

lldb::opaque_compiler_type_t GetOpaqueQualType() const { return m_type; }

lldb::TypeClass GetTypeClass() const;

void SetCompilerType(TypeSystem *type_system,
                     lldb::opaque_compiler_type_t type);

unsigned GetTypeQualifiers() const;
/// \}

/// Creating related types.
/// \{
CompilerType GetArrayElementType(ExecutionContextScope *exe_scope) const;

CompilerType GetArrayType(uint64_t size) const;

CompilerType GetCanonicalType() const;

CompilerType GetFullyUnqualifiedType() const;

CompilerType GetEnumerationIntegerType() const;

/// Returns -1 if this isn't a function of if the function doesn't
/// have a prototype Returns a value >= 0 if there is a prototype.
int GetFunctionArgumentCount() const;

CompilerType GetFunctionArgumentTypeAtIndex(size_t idx) const;

CompilerType GetFunctionReturnType() const;

size_t GetNumMemberFunctions() const;

TypeMemberFunctionImpl GetMemberFunctionAtIndex(size_t idx);

/// If this type is a reference to a type (L value or R value reference),
/// return a new type with the reference removed, else return the current type
/// itself.
CompilerType GetNonReferenceType() const;

/// If this type is a pointer type, return the type that the pointer points
/// to, else return an invalid type.
CompilerType GetPointeeType() const;

/// Return a new CompilerType that is a pointer to this type
CompilerType GetPointerType() const;

/// Return a new CompilerType that is a L value reference to this type if this
/// type is valid and the type system supports L value references, else return
/// an invalid type.
CompilerType GetLValueReferenceType() const;

/// Return a new CompilerType that is a R value reference to this type if this
/// type is valid and the type system supports R value references, else return
/// an invalid type.
CompilerType GetRValueReferenceType() const;

/// Return a new CompilerType adds a const modifier to this type if this type
/// is valid and the type system supports const modifiers, else return an
/// invalid type.
CompilerType AddConstModifier() const;

/// Return a new CompilerType adds a volatile modifier to this type if this
/// type is valid and the type system supports volatile modifiers, else return
/// an invalid type.
CompilerType AddVolatileModifier() const;

/// Return a new CompilerType that is the atomic type of this type. If this
/// type is not valid or the type system doesn't support atomic types, this
/// returns an invalid type.
CompilerType GetAtomicType() const;

/// Return a new CompilerType adds a restrict modifier to this type if this
/// type is valid and the type system supports restrict modifiers, else return
/// an invalid type.
CompilerType AddRestrictModifier() const;

/// Create a typedef to this type using "name" as the name of the typedef this
/// type is valid and the type system supports typedefs, else return an
/// invalid type.
/// \param payload   The typesystem-specific \p lldb::Type payload.
CompilerType CreateTypedef(const char *name,
                           const CompilerDeclContext &decl_ctx,
                           uint32_t payload) const;

/// If the current object represents a typedef type, get the underlying type
CompilerType GetTypedefedType() const;

/// Create related types using the current type's AST
CompilerType GetBasicTypeFromAST(lldb::BasicType basic_type) const;
/// \}

/// Exploring the type.
/// \{
struct IntegralTemplateArgument;

/// Return the size of the type in bytes.
llvm::Optional<uint64_t> GetByteSize(ExecutionContextScope *exe_scope) const;
/// Return the size of the type in bits.
llvm::Optional<uint64_t> GetBitSize(ExecutionContextScope *exe_scope) const;

lldb::Encoding GetEncoding(uint64_t &count) const;

lldb::Format GetFormat() const;

llvm::Optional<size_t>
GetTypeBitAlign(ExecutionContextScope *exe_scope) const;

uint32_t GetNumChildren(bool omit_empty_base_classes,
                        const ExecutionContext *exe_ctx) const;

lldb::BasicType GetBasicTypeEnumeration() const;

static lldb::BasicType GetBasicTypeEnumeration(ConstString name);

/// If this type is an enumeration, iterate through all of its enumerators
/// using a callback. If the callback returns true, keep iterating, else abort
/// the iteration.
void ForEachEnumerator(
    std::function<bool(const CompilerType &integer_type, ConstString name,
                       const llvm::APSInt &value)> const &callback) const;

uint32_t GetNumFields() const;

CompilerType GetFieldAtIndex(size_t idx, std::string &name,
                             uint64_t *bit_offset_ptr,
                             uint32_t *bitfield_bit_size_ptr,
                             bool *is_bitfield_ptr) const;

uint32_t GetNumDirectBaseClasses() const;

uint32_t GetNumVirtualBaseClasses() const;

CompilerType GetDirectBaseClassAtIndex(size_t idx,
                                       uint32_t *bit_offset_ptr) const;

CompilerType GetVirtualBaseClassAtIndex(size_t idx,
                                        uint32_t *bit_offset_ptr) const;

uint32_t GetIndexOfFieldWithName(const char *name,
                                 CompilerType *field_compiler_type = nullptr,
                                 uint64_t *bit_offset_ptr = nullptr,
                                 uint32_t *bitfield_bit_size_ptr = nullptr,
                                 bool *is_bitfield_ptr = nullptr) const;

CompilerType GetChildCompilerTypeAtIndex(
    ExecutionContext *exe_ctx, size_t idx, bool transparent_pointers,
    bool omit_empty_base_classes, bool ignore_array_bounds,
    std::string &child_name, uint32_t &child_byte_size,
    int32_t &child_byte_offset, uint32_t &child_bitfield_bit_size,
    uint32_t &child_bitfield_bit_offset, bool &child_is_base_class,
    bool &child_is_deref_of_parent, ValueObject *valobj,
    uint64_t &language_flags) const;

/// Lookup a child given a name. This function will match base class names and
/// member member names in "clang_type" only, not descendants.
uint32_t GetIndexOfChildWithName(const char *name,
                                 bool omit_empty_base_classes) const;

/// Lookup a child member given a name. This function will match member names
/// only and will descend into "clang_type" children in search for the first
/// member in this class, or any base class that matches "name".
/// TODO: Return all matches for a given name by returning a
/// vector<vector<uint32_t>>
/// so we catch all names that match a given child name, not just the first.
size_t
GetIndexOfChildMemberWithName(const char *name, bool omit_empty_base_classes,
                              std::vector<uint32_t> &child_indexes) const;

size_t GetNumTemplateArguments() const;

lldb::TemplateArgumentKind GetTemplateArgumentKind(size_t idx) const;
CompilerType GetTypeTemplateArgument(size_t idx) const;

/// Returns the value of the template argument and its type.
llvm::Optional<IntegralTemplateArgument>
GetIntegralTemplateArgument(size_t idx) const;

CompilerType GetTypeForFormatters() const;

LazyBool ShouldPrintAsOneLiner(ValueObject *valobj) const;

bool IsMeaninglessWithoutDynamicResolution() const;
/// \}

/// Dumping types.
/// \{
359#ifndef NDEBUG1
/// Convenience LLVM-style dump method for use in the debugger only.
/// Don't call this function from actual code.
LLVM_DUMP_METHOD__attribute__((noinline)) void dump() const;
363#endif

void DumpValue(ExecutionContext *exe_ctx, Stream *s, lldb::Format format,
               const DataExtractor &data, lldb::offset_t data_offset,
               size_t data_byte_size, uint32_t bitfield_bit_size,
               uint32_t bitfield_bit_offset, bool show_types,
               bool show_summary, bool verbose, uint32_t depth);

bool DumpTypeValue(Stream *s, lldb::Format format, const DataExtractor &data,
                   lldb::offset_t data_offset, size_t data_byte_size,
                   uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
                   ExecutionContextScope *exe_scope);

void DumpSummary(ExecutionContext *exe_ctx, Stream *s,
                 const DataExtractor &data, lldb::offset_t data_offset,
                 size_t data_byte_size);

/// Dump to stdout.
void DumpTypeDescription(lldb::DescriptionLevel level =
                         lldb::eDescriptionLevelFull) const;

/// Print a description of the type to a stream. The exact implementation
/// varies, but the expectation is that eDescriptionLevelFull returns a
/// source-like representation of the type, whereas eDescriptionLevelVerbose
/// does a dump of the underlying AST if applicable.
void DumpTypeDescription(Stream *s, lldb::DescriptionLevel level =
                                        lldb::eDescriptionLevelFull) const;
/// \}

bool GetValueAsScalar(const DataExtractor &data, lldb::offset_t data_offset,
                      size_t data_byte_size, Scalar &value,
                      ExecutionContextScope *exe_scope) const;
void Clear() {
  m_type = nullptr;
  m_type_system = nullptr;
}

400private:
401#ifndef NDEBUG1
/// If the type is valid, ask the TypeSystem to verify the integrity
/// of the type to catch CompilerTypes that mix and match invalid
/// TypeSystem/Opaque type pairs.
bool Verify() const;
406#endif

lldb::opaque_compiler_type_t m_type = nullptr;
TypeSystem *m_type_system = nullptr;
410};

412bool operator==(const CompilerType &lhs, const CompilerType &rhs);
413bool operator!=(const CompilerType &lhs, const CompilerType &rhs);

415struct CompilerType::IntegralTemplateArgument {
llvm::APSInt value;
CompilerType type;
418};

420} // namespace lldb_private

422#endif // LLDB_SYMBOL_COMPILERTYPE_H