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 //===----------------------------------------------------------------------===//
8 
9 #include "ClangExpressionDeclMap.h"
10 
11 #include "ClangASTSource.h"
12 #include "ClangExpressionUtil.h"
13 #include "ClangExpressionVariable.h"
14 #include "ClangModulesDeclVendor.h"
15 #include "ClangPersistentVariables.h"
16 #include "ClangUtil.h"
17 
18 #include "NameSearchContext.h"
19 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
20 #include "lldb/Core/Address.h"
21 #include "lldb/Core/Module.h"
22 #include "lldb/Core/ModuleSpec.h"
23 #include "lldb/Core/ValueObjectConstResult.h"
24 #include "lldb/Core/ValueObjectVariable.h"
25 #include "lldb/Expression/DiagnosticManager.h"
26 #include "lldb/Expression/Materializer.h"
27 #include "lldb/Symbol/CompileUnit.h"
28 #include "lldb/Symbol/CompilerDecl.h"
29 #include "lldb/Symbol/CompilerDeclContext.h"
30 #include "lldb/Symbol/Function.h"
31 #include "lldb/Symbol/ObjectFile.h"
32 #include "lldb/Symbol/SymbolContext.h"
33 #include "lldb/Symbol/SymbolFile.h"
34 #include "lldb/Symbol/SymbolVendor.h"
35 #include "lldb/Symbol/Type.h"
36 #include "lldb/Symbol/TypeList.h"
37 #include "lldb/Symbol/Variable.h"
38 #include "lldb/Symbol/VariableList.h"
39 #include "lldb/Target/ExecutionContext.h"
40 #include "lldb/Target/Process.h"
41 #include "lldb/Target/RegisterContext.h"
42 #include "lldb/Target/StackFrame.h"
43 #include "lldb/Target/Target.h"
44 #include "lldb/Target/Thread.h"
45 #include "lldb/Utility/Endian.h"
46 #include "lldb/Utility/LLDBLog.h"
47 #include "lldb/Utility/Log.h"
48 #include "lldb/Utility/RegisterValue.h"
49 #include "lldb/Utility/Status.h"
50 #include "lldb/lldb-private-types.h"
51 #include "lldb/lldb-private.h"
52 #include "clang/AST/ASTConsumer.h"
53 #include "clang/AST/ASTContext.h"
54 #include "clang/AST/ASTImporter.h"
55 #include "clang/AST/Decl.h"
56 #include "clang/AST/DeclarationName.h"
57 #include "clang/AST/RecursiveASTVisitor.h"
58 
59 #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
60 #include "Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.h"
61 #include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
62 
63 using namespace lldb;
64 using namespace lldb_private;
65 using namespace clang;
66 
67 static const char *g_lldb_local_vars_namespace_cstr = "$__lldb_local_vars";
68 
69 namespace {
70 /// A lambda is represented by Clang as an artifical class whose
71 /// members are the lambda captures. If we capture a 'this' pointer,
72 /// the artifical class will contain a member variable named 'this'.
73 /// The function returns a ValueObject for the captured 'this' if such
74 /// member exists. If no 'this' was captured, return a nullptr.
75 lldb::ValueObjectSP GetCapturedThisValueObject(StackFrame *frame) {
76   assert(frame);
77 
78   if (auto thisValSP = frame->FindVariable(ConstString("this")))
79     if (auto thisThisValSP = thisValSP->GetChildMemberWithName("this"))
80       return thisThisValSP;
81 
82   return nullptr;
83 }
84 } // namespace
85 
86 ClangExpressionDeclMap::ClangExpressionDeclMap(
87     bool keep_result_in_memory,
88     Materializer::PersistentVariableDelegate *result_delegate,
89     const lldb::TargetSP &target,
90     const std::shared_ptr<ClangASTImporter> &importer, ValueObject *ctx_obj)
91     : ClangASTSource(target, importer), m_found_entities(), m_struct_members(),
92       m_keep_result_in_memory(keep_result_in_memory),
93       m_result_delegate(result_delegate), m_ctx_obj(ctx_obj), m_parser_vars(),
94       m_struct_vars() {
95   EnableStructVars();
96 }
97 
98 ClangExpressionDeclMap::~ClangExpressionDeclMap() {
99   // Note: The model is now that the parser's AST context and all associated
100   //   data does not vanish until the expression has been executed.  This means
101   //   that valuable lookup data (like namespaces) doesn't vanish, but
102 
103   DidParse();
104   DisableStructVars();
105 }
106 
107 bool ClangExpressionDeclMap::WillParse(ExecutionContext &exe_ctx,
108                                        Materializer *materializer) {
109   EnableParserVars();
110   m_parser_vars->m_exe_ctx = exe_ctx;
111 
112   Target *target = exe_ctx.GetTargetPtr();
113   if (exe_ctx.GetFramePtr())
114     m_parser_vars->m_sym_ctx =
115         exe_ctx.GetFramePtr()->GetSymbolContext(lldb::eSymbolContextEverything);
116   else if (exe_ctx.GetThreadPtr() &&
117            exe_ctx.GetThreadPtr()->GetStackFrameAtIndex(0))
118     m_parser_vars->m_sym_ctx =
119         exe_ctx.GetThreadPtr()->GetStackFrameAtIndex(0)->GetSymbolContext(
120             lldb::eSymbolContextEverything);
121   else if (exe_ctx.GetProcessPtr()) {
122     m_parser_vars->m_sym_ctx.Clear(true);
123     m_parser_vars->m_sym_ctx.target_sp = exe_ctx.GetTargetSP();
124   } else if (target) {
125     m_parser_vars->m_sym_ctx.Clear(true);
126     m_parser_vars->m_sym_ctx.target_sp = exe_ctx.GetTargetSP();
127   }
128 
129   if (target) {
130     m_parser_vars->m_persistent_vars = llvm::cast<ClangPersistentVariables>(
131         target->GetPersistentExpressionStateForLanguage(eLanguageTypeC));
132 
133     if (!ScratchTypeSystemClang::GetForTarget(*target))
134       return false;
135   }
136 
137   m_parser_vars->m_target_info = GetTargetInfo();
138   m_parser_vars->m_materializer = materializer;
139 
140   return true;
141 }
142 
143 void ClangExpressionDeclMap::InstallCodeGenerator(
144     clang::ASTConsumer *code_gen) {
145   assert(m_parser_vars);
146   m_parser_vars->m_code_gen = code_gen;
147 }
148 
149 void ClangExpressionDeclMap::InstallDiagnosticManager(
150     DiagnosticManager &diag_manager) {
151   assert(m_parser_vars);
152   m_parser_vars->m_diagnostics = &diag_manager;
153 }
154 
155 void ClangExpressionDeclMap::DidParse() {
156   if (m_parser_vars && m_parser_vars->m_persistent_vars) {
157     for (size_t entity_index = 0, num_entities = m_found_entities.GetSize();
158          entity_index < num_entities; ++entity_index) {
159       ExpressionVariableSP var_sp(
160           m_found_entities.GetVariableAtIndex(entity_index));
161       if (var_sp)
162         llvm::cast<ClangExpressionVariable>(var_sp.get())
163             ->DisableParserVars(GetParserID());
164     }
165 
166     for (size_t pvar_index = 0,
167                 num_pvars = m_parser_vars->m_persistent_vars->GetSize();
168          pvar_index < num_pvars; ++pvar_index) {
169       ExpressionVariableSP pvar_sp(
170           m_parser_vars->m_persistent_vars->GetVariableAtIndex(pvar_index));
171       if (ClangExpressionVariable *clang_var =
172               llvm::dyn_cast<ClangExpressionVariable>(pvar_sp.get()))
173         clang_var->DisableParserVars(GetParserID());
174     }
175 
176     DisableParserVars();
177   }
178 }
179 
180 // Interface for IRForTarget
181 
182 ClangExpressionDeclMap::TargetInfo ClangExpressionDeclMap::GetTargetInfo() {
183   assert(m_parser_vars.get());
184 
185   TargetInfo ret;
186 
187   ExecutionContext &exe_ctx = m_parser_vars->m_exe_ctx;
188 
189   Process *process = exe_ctx.GetProcessPtr();
190   if (process) {
191     ret.byte_order = process->GetByteOrder();
192     ret.address_byte_size = process->GetAddressByteSize();
193   } else {
194     Target *target = exe_ctx.GetTargetPtr();
195     if (target) {
196       ret.byte_order = target->GetArchitecture().GetByteOrder();
197       ret.address_byte_size = target->GetArchitecture().GetAddressByteSize();
198     }
199   }
200 
201   return ret;
202 }
203 
204 TypeFromUser ClangExpressionDeclMap::DeportType(TypeSystemClang &target,
205                                                 TypeSystemClang &source,
206                                                 TypeFromParser parser_type) {
207   assert(&target == GetScratchContext(*m_target).get());
208   assert((TypeSystem *)&source ==
209          parser_type.GetTypeSystem().GetSharedPointer().get());
210   assert(&source.getASTContext() == m_ast_context);
211 
212   return TypeFromUser(m_ast_importer_sp->DeportType(target, parser_type));
213 }
214 
215 bool ClangExpressionDeclMap::AddPersistentVariable(const NamedDecl *decl,
216                                                    ConstString name,
217                                                    TypeFromParser parser_type,
218                                                    bool is_result,
219                                                    bool is_lvalue) {
220   assert(m_parser_vars.get());
221   auto ast = parser_type.GetTypeSystem().dyn_cast_or_null<TypeSystemClang>();
222   if (ast == nullptr)
223     return false;
224 
225   // Check if we already declared a persistent variable with the same name.
226   if (lldb::ExpressionVariableSP conflicting_var =
227           m_parser_vars->m_persistent_vars->GetVariable(name)) {
228     std::string msg = llvm::formatv("redefinition of persistent variable '{0}'",
229                                     name).str();
230     m_parser_vars->m_diagnostics->AddDiagnostic(
231         msg, DiagnosticSeverity::eDiagnosticSeverityError,
232         DiagnosticOrigin::eDiagnosticOriginLLDB);
233     return false;
234   }
235 
236   if (m_parser_vars->m_materializer && is_result) {
237     Status err;
238 
239     ExecutionContext &exe_ctx = m_parser_vars->m_exe_ctx;
240     Target *target = exe_ctx.GetTargetPtr();
241     if (target == nullptr)
242       return false;
243 
244     auto clang_ast_context = GetScratchContext(*target);
245     if (!clang_ast_context)
246       return false;
247 
248     TypeFromUser user_type = DeportType(*clang_ast_context, *ast, parser_type);
249 
250     uint32_t offset = m_parser_vars->m_materializer->AddResultVariable(
251         user_type, is_lvalue, m_keep_result_in_memory, m_result_delegate, err);
252 
253     ClangExpressionVariable *var = new ClangExpressionVariable(
254         exe_ctx.GetBestExecutionContextScope(), name, user_type,
255         m_parser_vars->m_target_info.byte_order,
256         m_parser_vars->m_target_info.address_byte_size);
257 
258     m_found_entities.AddNewlyConstructedVariable(var);
259 
260     var->EnableParserVars(GetParserID());
261 
262     ClangExpressionVariable::ParserVars *parser_vars =
263         var->GetParserVars(GetParserID());
264 
265     parser_vars->m_named_decl = decl;
266 
267     var->EnableJITVars(GetParserID());
268 
269     ClangExpressionVariable::JITVars *jit_vars = var->GetJITVars(GetParserID());
270 
271     jit_vars->m_offset = offset;
272 
273     return true;
274   }
275 
276   Log *log = GetLog(LLDBLog::Expressions);
277   ExecutionContext &exe_ctx = m_parser_vars->m_exe_ctx;
278   Target *target = exe_ctx.GetTargetPtr();
279   if (target == nullptr)
280     return false;
281 
282   auto context = GetScratchContext(*target);
283   if (!context)
284     return false;
285 
286   TypeFromUser user_type = DeportType(*context, *ast, parser_type);
287 
288   if (!user_type.GetOpaqueQualType()) {
289     LLDB_LOG(log, "Persistent variable's type wasn't copied successfully");
290     return false;
291   }
292 
293   if (!m_parser_vars->m_target_info.IsValid())
294     return false;
295 
296   if (!m_parser_vars->m_persistent_vars)
297     return false;
298 
299   ClangExpressionVariable *var = llvm::cast<ClangExpressionVariable>(
300       m_parser_vars->m_persistent_vars
301           ->CreatePersistentVariable(
302               exe_ctx.GetBestExecutionContextScope(), name, user_type,
303               m_parser_vars->m_target_info.byte_order,
304               m_parser_vars->m_target_info.address_byte_size)
305           .get());
306 
307   if (!var)
308     return false;
309 
310   var->m_frozen_sp->SetHasCompleteType();
311 
312   if (is_result)
313     var->m_flags |= ClangExpressionVariable::EVNeedsFreezeDry;
314   else
315     var->m_flags |=
316         ClangExpressionVariable::EVKeepInTarget; // explicitly-declared
317                                                  // persistent variables should
318                                                  // persist
319 
320   if (is_lvalue) {
321     var->m_flags |= ClangExpressionVariable::EVIsProgramReference;
322   } else {
323     var->m_flags |= ClangExpressionVariable::EVIsLLDBAllocated;
324     var->m_flags |= ClangExpressionVariable::EVNeedsAllocation;
325   }
326 
327   if (m_keep_result_in_memory) {
328     var->m_flags |= ClangExpressionVariable::EVKeepInTarget;
329   }
330 
331   LLDB_LOG(log, "Created persistent variable with flags {0:x}", var->m_flags);
332 
333   var->EnableParserVars(GetParserID());
334 
335   ClangExpressionVariable::ParserVars *parser_vars =
336       var->GetParserVars(GetParserID());
337 
338   parser_vars->m_named_decl = decl;
339 
340   return true;
341 }
342 
343 bool ClangExpressionDeclMap::AddValueToStruct(const NamedDecl *decl,
344                                               ConstString name,
345                                               llvm::Value *value, size_t size,
346                                               lldb::offset_t alignment) {
347   assert(m_struct_vars.get());
348   assert(m_parser_vars.get());
349 
350   bool is_persistent_variable = false;
351 
352   Log *log = GetLog(LLDBLog::Expressions);
353 
354   m_struct_vars->m_struct_laid_out = false;
355 
356   if (ClangExpressionVariable::FindVariableInList(m_struct_members, decl,
357                                                   GetParserID()))
358     return true;
359 
360   ClangExpressionVariable *var(ClangExpressionVariable::FindVariableInList(
361       m_found_entities, decl, GetParserID()));
362 
363   if (!var && m_parser_vars->m_persistent_vars) {
364     var = ClangExpressionVariable::FindVariableInList(
365         *m_parser_vars->m_persistent_vars, decl, GetParserID());
366     is_persistent_variable = true;
367   }
368 
369   if (!var)
370     return false;
371 
372   LLDB_LOG(log, "Adding value for (NamedDecl*){0} [{1} - {2}] to the structure",
373            decl, name, var->GetName());
374 
375   // We know entity->m_parser_vars is valid because we used a parser variable
376   // to find it
377 
378   ClangExpressionVariable::ParserVars *parser_vars =
379       llvm::cast<ClangExpressionVariable>(var)->GetParserVars(GetParserID());
380 
381   parser_vars->m_llvm_value = value;
382 
383   if (ClangExpressionVariable::JITVars *jit_vars =
384           llvm::cast<ClangExpressionVariable>(var)->GetJITVars(GetParserID())) {
385     // We already laid this out; do not touch
386 
387     LLDB_LOG(log, "Already placed at {0:x}", jit_vars->m_offset);
388   }
389 
390   llvm::cast<ClangExpressionVariable>(var)->EnableJITVars(GetParserID());
391 
392   ClangExpressionVariable::JITVars *jit_vars =
393       llvm::cast<ClangExpressionVariable>(var)->GetJITVars(GetParserID());
394 
395   jit_vars->m_alignment = alignment;
396   jit_vars->m_size = size;
397 
398   m_struct_members.AddVariable(var->shared_from_this());
399 
400   if (m_parser_vars->m_materializer) {
401     uint32_t offset = 0;
402 
403     Status err;
404 
405     if (is_persistent_variable) {
406       ExpressionVariableSP var_sp(var->shared_from_this());
407       offset = m_parser_vars->m_materializer->AddPersistentVariable(
408           var_sp, nullptr, err);
409     } else {
410       if (const lldb_private::Symbol *sym = parser_vars->m_lldb_sym)
411         offset = m_parser_vars->m_materializer->AddSymbol(*sym, err);
412       else if (const RegisterInfo *reg_info = var->GetRegisterInfo())
413         offset = m_parser_vars->m_materializer->AddRegister(*reg_info, err);
414       else if (parser_vars->m_lldb_var)
415         offset = m_parser_vars->m_materializer->AddVariable(
416             parser_vars->m_lldb_var, err);
417       else if (parser_vars->m_lldb_valobj_provider) {
418         offset = m_parser_vars->m_materializer->AddValueObject(
419             name, parser_vars->m_lldb_valobj_provider, err);
420       }
421     }
422 
423     if (!err.Success())
424       return false;
425 
426     LLDB_LOG(log, "Placed at {0:x}", offset);
427 
428     jit_vars->m_offset =
429         offset; // TODO DoStructLayout() should not change this.
430   }
431 
432   return true;
433 }
434 
435 bool ClangExpressionDeclMap::DoStructLayout() {
436   assert(m_struct_vars.get());
437 
438   if (m_struct_vars->m_struct_laid_out)
439     return true;
440 
441   if (!m_parser_vars->m_materializer)
442     return false;
443 
444   m_struct_vars->m_struct_alignment =
445       m_parser_vars->m_materializer->GetStructAlignment();
446   m_struct_vars->m_struct_size =
447       m_parser_vars->m_materializer->GetStructByteSize();
448   m_struct_vars->m_struct_laid_out = true;
449   return true;
450 }
451 
452 bool ClangExpressionDeclMap::GetStructInfo(uint32_t &num_elements, size_t &size,
453                                            lldb::offset_t &alignment) {
454   assert(m_struct_vars.get());
455 
456   if (!m_struct_vars->m_struct_laid_out)
457     return false;
458 
459   num_elements = m_struct_members.GetSize();
460   size = m_struct_vars->m_struct_size;
461   alignment = m_struct_vars->m_struct_alignment;
462 
463   return true;
464 }
465 
466 bool ClangExpressionDeclMap::GetStructElement(const NamedDecl *&decl,
467                                               llvm::Value *&value,
468                                               lldb::offset_t &offset,
469                                               ConstString &name,
470                                               uint32_t index) {
471   assert(m_struct_vars.get());
472 
473   if (!m_struct_vars->m_struct_laid_out)
474     return false;
475 
476   if (index >= m_struct_members.GetSize())
477     return false;
478 
479   ExpressionVariableSP member_sp(m_struct_members.GetVariableAtIndex(index));
480 
481   if (!member_sp)
482     return false;
483 
484   ClangExpressionVariable::ParserVars *parser_vars =
485       llvm::cast<ClangExpressionVariable>(member_sp.get())
486           ->GetParserVars(GetParserID());
487   ClangExpressionVariable::JITVars *jit_vars =
488       llvm::cast<ClangExpressionVariable>(member_sp.get())
489           ->GetJITVars(GetParserID());
490 
491   if (!parser_vars || !jit_vars || !member_sp->GetValueObject())
492     return false;
493 
494   decl = parser_vars->m_named_decl;
495   value = parser_vars->m_llvm_value;
496   offset = jit_vars->m_offset;
497   name = member_sp->GetName();
498 
499   return true;
500 }
501 
502 bool ClangExpressionDeclMap::GetFunctionInfo(const NamedDecl *decl,
503                                              uint64_t &ptr) {
504   ClangExpressionVariable *entity(ClangExpressionVariable::FindVariableInList(
505       m_found_entities, decl, GetParserID()));
506 
507   if (!entity)
508     return false;
509 
510   // We know m_parser_vars is valid since we searched for the variable by its
511   // NamedDecl
512 
513   ClangExpressionVariable::ParserVars *parser_vars =
514       entity->GetParserVars(GetParserID());
515 
516   ptr = parser_vars->m_lldb_value.GetScalar().ULongLong();
517 
518   return true;
519 }
520 
521 addr_t ClangExpressionDeclMap::GetSymbolAddress(Target &target,
522                                                 Process *process,
523                                                 ConstString name,
524                                                 lldb::SymbolType symbol_type,
525                                                 lldb_private::Module *module) {
526   SymbolContextList sc_list;
527 
528   if (module)
529     module->FindSymbolsWithNameAndType(name, symbol_type, sc_list);
530   else
531     target.GetImages().FindSymbolsWithNameAndType(name, symbol_type, sc_list);
532 
533   addr_t symbol_load_addr = LLDB_INVALID_ADDRESS;
534 
535   for (const SymbolContext &sym_ctx : sc_list) {
536     if (symbol_load_addr != 0 && symbol_load_addr != LLDB_INVALID_ADDRESS)
537       break;
538 
539     const Address sym_address = sym_ctx.symbol->GetAddress();
540 
541     if (!sym_address.IsValid())
542       continue;
543 
544     switch (sym_ctx.symbol->GetType()) {
545     case eSymbolTypeCode:
546     case eSymbolTypeTrampoline:
547       symbol_load_addr = sym_address.GetCallableLoadAddress(&target);
548       break;
549 
550     case eSymbolTypeResolver:
551       symbol_load_addr = sym_address.GetCallableLoadAddress(&target, true);
552       break;
553 
554     case eSymbolTypeReExported: {
555       ConstString reexport_name = sym_ctx.symbol->GetReExportedSymbolName();
556       if (reexport_name) {
557         ModuleSP reexport_module_sp;
558         ModuleSpec reexport_module_spec;
559         reexport_module_spec.GetPlatformFileSpec() =
560             sym_ctx.symbol->GetReExportedSymbolSharedLibrary();
561         if (reexport_module_spec.GetPlatformFileSpec()) {
562           reexport_module_sp =
563               target.GetImages().FindFirstModule(reexport_module_spec);
564           if (!reexport_module_sp) {
565             reexport_module_spec.GetPlatformFileSpec().ClearDirectory();
566             reexport_module_sp =
567                 target.GetImages().FindFirstModule(reexport_module_spec);
568           }
569         }
570         symbol_load_addr = GetSymbolAddress(
571             target, process, sym_ctx.symbol->GetReExportedSymbolName(),
572             symbol_type, reexport_module_sp.get());
573       }
574     } break;
575 
576     case eSymbolTypeData:
577     case eSymbolTypeRuntime:
578     case eSymbolTypeVariable:
579     case eSymbolTypeLocal:
580     case eSymbolTypeParam:
581     case eSymbolTypeInvalid:
582     case eSymbolTypeAbsolute:
583     case eSymbolTypeException:
584     case eSymbolTypeSourceFile:
585     case eSymbolTypeHeaderFile:
586     case eSymbolTypeObjectFile:
587     case eSymbolTypeCommonBlock:
588     case eSymbolTypeBlock:
589     case eSymbolTypeVariableType:
590     case eSymbolTypeLineEntry:
591     case eSymbolTypeLineHeader:
592     case eSymbolTypeScopeBegin:
593     case eSymbolTypeScopeEnd:
594     case eSymbolTypeAdditional:
595     case eSymbolTypeCompiler:
596     case eSymbolTypeInstrumentation:
597     case eSymbolTypeUndefined:
598     case eSymbolTypeObjCClass:
599     case eSymbolTypeObjCMetaClass:
600     case eSymbolTypeObjCIVar:
601       symbol_load_addr = sym_address.GetLoadAddress(&target);
602       break;
603     }
604   }
605 
606   if (symbol_load_addr == LLDB_INVALID_ADDRESS && process) {
607     ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process);
608 
609     if (runtime) {
610       symbol_load_addr = runtime->LookupRuntimeSymbol(name);
611     }
612   }
613 
614   return symbol_load_addr;
615 }
616 
617 addr_t ClangExpressionDeclMap::GetSymbolAddress(ConstString name,
618                                                 lldb::SymbolType symbol_type) {
619   assert(m_parser_vars.get());
620 
621   if (!m_parser_vars->m_exe_ctx.GetTargetPtr())
622     return false;
623 
624   return GetSymbolAddress(m_parser_vars->m_exe_ctx.GetTargetRef(),
625                           m_parser_vars->m_exe_ctx.GetProcessPtr(), name,
626                           symbol_type);
627 }
628 
629 lldb::VariableSP ClangExpressionDeclMap::FindGlobalVariable(
630     Target &target, ModuleSP &module, ConstString name,
631     const CompilerDeclContext &namespace_decl) {
632   VariableList vars;
633 
634   if (module && namespace_decl)
635     module->FindGlobalVariables(name, namespace_decl, -1, vars);
636   else
637     target.GetImages().FindGlobalVariables(name, -1, vars);
638 
639   if (vars.GetSize() == 0)
640     return VariableSP();
641   return vars.GetVariableAtIndex(0);
642 }
643 
644 TypeSystemClang *ClangExpressionDeclMap::GetTypeSystemClang() {
645   StackFrame *frame = m_parser_vars->m_exe_ctx.GetFramePtr();
646   if (frame == nullptr)
647     return nullptr;
648 
649   SymbolContext sym_ctx = frame->GetSymbolContext(lldb::eSymbolContextFunction |
650                                                   lldb::eSymbolContextBlock);
651   if (sym_ctx.block == nullptr)
652     return nullptr;
653 
654   CompilerDeclContext frame_decl_context = sym_ctx.block->GetDeclContext();
655   if (!frame_decl_context)
656     return nullptr;
657 
658   return llvm::dyn_cast_or_null<TypeSystemClang>(
659       frame_decl_context.GetTypeSystem());
660 }
661 
662 // Interface for ClangASTSource
663 
664 void ClangExpressionDeclMap::FindExternalVisibleDecls(
665     NameSearchContext &context) {
666   assert(m_ast_context);
667 
668   const ConstString name(context.m_decl_name.getAsString().c_str());
669 
670   Log *log = GetLog(LLDBLog::Expressions);
671 
672   if (log) {
673     if (!context.m_decl_context)
674       LLDB_LOG(log,
675                "ClangExpressionDeclMap::FindExternalVisibleDecls for "
676                "'{0}' in a NULL DeclContext",
677                name);
678     else if (const NamedDecl *context_named_decl =
679                  dyn_cast<NamedDecl>(context.m_decl_context))
680       LLDB_LOG(log,
681                "ClangExpressionDeclMap::FindExternalVisibleDecls for "
682                "'{0}' in '{1}'",
683                name, context_named_decl->getNameAsString());
684     else
685       LLDB_LOG(log,
686                "ClangExpressionDeclMap::FindExternalVisibleDecls for "
687                "'{0}' in a '{1}'",
688                name, context.m_decl_context->getDeclKindName());
689   }
690 
691   if (const NamespaceDecl *namespace_context =
692           dyn_cast<NamespaceDecl>(context.m_decl_context)) {
693     if (namespace_context->getName().str() ==
694         std::string(g_lldb_local_vars_namespace_cstr)) {
695       CompilerDeclContext compiler_decl_ctx =
696           m_clang_ast_context->CreateDeclContext(
697               const_cast<clang::DeclContext *>(context.m_decl_context));
698       FindExternalVisibleDecls(context, lldb::ModuleSP(), compiler_decl_ctx);
699       return;
700     }
701 
702     ClangASTImporter::NamespaceMapSP namespace_map =
703         m_ast_importer_sp->GetNamespaceMap(namespace_context);
704 
705     if (!namespace_map)
706       return;
707 
708     LLDB_LOGV(log, "  CEDM::FEVD Inspecting (NamespaceMap*){0:x} ({1} entries)",
709               namespace_map.get(), namespace_map->size());
710 
711     for (ClangASTImporter::NamespaceMapItem &n : *namespace_map) {
712       LLDB_LOG(log, "  CEDM::FEVD Searching namespace {0} in module {1}",
713                n.second.GetName(), n.first->GetFileSpec().GetFilename());
714 
715       FindExternalVisibleDecls(context, n.first, n.second);
716     }
717   } else if (isa<TranslationUnitDecl>(context.m_decl_context)) {
718     CompilerDeclContext namespace_decl;
719 
720     LLDB_LOG(log, "  CEDM::FEVD Searching the root namespace");
721 
722     FindExternalVisibleDecls(context, lldb::ModuleSP(), namespace_decl);
723   }
724 
725   ClangASTSource::FindExternalVisibleDecls(context);
726 }
727 
728 void ClangExpressionDeclMap::MaybeRegisterFunctionBody(
729     FunctionDecl *copied_function_decl) {
730   if (copied_function_decl->getBody() && m_parser_vars->m_code_gen) {
731     clang::DeclGroupRef decl_group_ref(copied_function_decl);
732     m_parser_vars->m_code_gen->HandleTopLevelDecl(decl_group_ref);
733   }
734 }
735 
736 clang::NamedDecl *ClangExpressionDeclMap::GetPersistentDecl(ConstString name) {
737   if (!m_parser_vars)
738     return nullptr;
739   Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
740   if (!target)
741     return nullptr;
742 
743   ScratchTypeSystemClang::GetForTarget(*target);
744 
745   if (!m_parser_vars->m_persistent_vars)
746     return nullptr;
747   return m_parser_vars->m_persistent_vars->GetPersistentDecl(name);
748 }
749 
750 void ClangExpressionDeclMap::SearchPersistenDecls(NameSearchContext &context,
751                                                   const ConstString name) {
752   Log *log = GetLog(LLDBLog::Expressions);
753 
754   NamedDecl *persistent_decl = GetPersistentDecl(name);
755 
756   if (!persistent_decl)
757     return;
758 
759   Decl *parser_persistent_decl = CopyDecl(persistent_decl);
760 
761   if (!parser_persistent_decl)
762     return;
763 
764   NamedDecl *parser_named_decl = dyn_cast<NamedDecl>(parser_persistent_decl);
765 
766   if (!parser_named_decl)
767     return;
768 
769   if (clang::FunctionDecl *parser_function_decl =
770           llvm::dyn_cast<clang::FunctionDecl>(parser_named_decl)) {
771     MaybeRegisterFunctionBody(parser_function_decl);
772   }
773 
774   LLDB_LOG(log, "  CEDM::FEVD Found persistent decl {0}", name);
775 
776   context.AddNamedDecl(parser_named_decl);
777 }
778 
779 void ClangExpressionDeclMap::LookUpLldbClass(NameSearchContext &context) {
780   Log *log = GetLog(LLDBLog::Expressions);
781 
782   StackFrame *frame = m_parser_vars->m_exe_ctx.GetFramePtr();
783   SymbolContext sym_ctx;
784   if (frame != nullptr)
785     sym_ctx = frame->GetSymbolContext(lldb::eSymbolContextFunction |
786                                       lldb::eSymbolContextBlock);
787 
788   if (m_ctx_obj) {
789     Status status;
790     lldb::ValueObjectSP ctx_obj_ptr = m_ctx_obj->AddressOf(status);
791     if (!ctx_obj_ptr || status.Fail())
792       return;
793 
794     AddContextClassType(context, TypeFromUser(m_ctx_obj->GetCompilerType()));
795     return;
796   }
797 
798   // Clang is looking for the type of "this"
799 
800   if (frame == nullptr)
801     return;
802 
803   // Find the block that defines the function represented by "sym_ctx"
804   Block *function_block = sym_ctx.GetFunctionBlock();
805 
806   if (!function_block)
807     return;
808 
809   CompilerDeclContext function_decl_ctx = function_block->GetDeclContext();
810 
811   if (!function_decl_ctx)
812     return;
813 
814   clang::CXXMethodDecl *method_decl =
815       TypeSystemClang::DeclContextGetAsCXXMethodDecl(function_decl_ctx);
816 
817   if (method_decl) {
818     if (auto capturedThis = GetCapturedThisValueObject(frame)) {
819       // We're inside a lambda and we captured a 'this'.
820       // Import the outer class's AST instead of the
821       // (unnamed) lambda structure AST so unqualified
822       // member lookups are understood by the Clang parser.
823       //
824       // If we're in a lambda which didn't capture 'this',
825       // $__lldb_class will correspond to the lambda closure
826       // AST and references to captures will resolve like
827       // regular member varaiable accesses do.
828       TypeFromUser pointee_type =
829           capturedThis->GetCompilerType().GetPointeeType();
830 
831       LLDB_LOG(log,
832                "  CEDM::FEVD Adding captured type ({0} for"
833                " $__lldb_class: {1}",
834                capturedThis->GetTypeName(), capturedThis->GetName());
835 
836       AddContextClassType(context, pointee_type);
837       return;
838     }
839 
840     clang::CXXRecordDecl *class_decl = method_decl->getParent();
841 
842     QualType class_qual_type(class_decl->getTypeForDecl(), 0);
843 
844     TypeFromUser class_user_type(
845         class_qual_type.getAsOpaquePtr(),
846         function_decl_ctx.GetTypeSystem()->weak_from_this());
847 
848     LLDB_LOG(log, "  CEDM::FEVD Adding type for $__lldb_class: {0}",
849              class_qual_type.getAsString());
850 
851     AddContextClassType(context, class_user_type);
852     return;
853   }
854 
855   // This branch will get hit if we are executing code in the context of
856   // a function that claims to have an object pointer (through
857   // DW_AT_object_pointer?) but is not formally a method of the class.
858   // In that case, just look up the "this" variable in the current scope
859   // and use its type.
860   // FIXME: This code is formally correct, but clang doesn't currently
861   // emit DW_AT_object_pointer
862   // for C++ so it hasn't actually been tested.
863 
864   VariableList *vars = frame->GetVariableList(false, nullptr);
865 
866   lldb::VariableSP this_var = vars->FindVariable(ConstString("this"));
867 
868   if (this_var && this_var->IsInScope(frame) &&
869       this_var->LocationIsValidForFrame(frame)) {
870     Type *this_type = this_var->GetType();
871 
872     if (!this_type)
873       return;
874 
875     TypeFromUser pointee_type =
876         this_type->GetForwardCompilerType().GetPointeeType();
877 
878     LLDB_LOG(log, "  FEVD Adding type for $__lldb_class: {0}",
879              ClangUtil::GetQualType(pointee_type).getAsString());
880 
881     AddContextClassType(context, pointee_type);
882   }
883 }
884 
885 void ClangExpressionDeclMap::LookUpLldbObjCClass(NameSearchContext &context) {
886   Log *log = GetLog(LLDBLog::Expressions);
887 
888   StackFrame *frame = m_parser_vars->m_exe_ctx.GetFramePtr();
889 
890   if (m_ctx_obj) {
891     Status status;
892     lldb::ValueObjectSP ctx_obj_ptr = m_ctx_obj->AddressOf(status);
893     if (!ctx_obj_ptr || status.Fail())
894       return;
895 
896     AddOneType(context, TypeFromUser(m_ctx_obj->GetCompilerType()));
897     return;
898   }
899 
900   // Clang is looking for the type of "*self"
901 
902   if (!frame)
903     return;
904 
905   SymbolContext sym_ctx = frame->GetSymbolContext(lldb::eSymbolContextFunction |
906                                                   lldb::eSymbolContextBlock);
907 
908   // Find the block that defines the function represented by "sym_ctx"
909   Block *function_block = sym_ctx.GetFunctionBlock();
910 
911   if (!function_block)
912     return;
913 
914   CompilerDeclContext function_decl_ctx = function_block->GetDeclContext();
915 
916   if (!function_decl_ctx)
917     return;
918 
919   clang::ObjCMethodDecl *method_decl =
920       TypeSystemClang::DeclContextGetAsObjCMethodDecl(function_decl_ctx);
921 
922   if (method_decl) {
923     ObjCInterfaceDecl *self_interface = method_decl->getClassInterface();
924 
925     if (!self_interface)
926       return;
927 
928     const clang::Type *interface_type = self_interface->getTypeForDecl();
929 
930     if (!interface_type)
931       return; // This is unlikely, but we have seen crashes where this
932               // occurred
933 
934     TypeFromUser class_user_type(
935         QualType(interface_type, 0).getAsOpaquePtr(),
936         function_decl_ctx.GetTypeSystem()->weak_from_this());
937 
938     LLDB_LOG(log, "  FEVD[{0}] Adding type for $__lldb_objc_class: {1}",
939              ClangUtil::ToString(interface_type));
940 
941     AddOneType(context, class_user_type);
942     return;
943   }
944   // This branch will get hit if we are executing code in the context of
945   // a function that claims to have an object pointer (through
946   // DW_AT_object_pointer?) but is not formally a method of the class.
947   // In that case, just look up the "self" variable in the current scope
948   // and use its type.
949 
950   VariableList *vars = frame->GetVariableList(false, nullptr);
951 
952   lldb::VariableSP self_var = vars->FindVariable(ConstString("self"));
953 
954   if (!self_var)
955     return;
956   if (!self_var->IsInScope(frame))
957     return;
958   if (!self_var->LocationIsValidForFrame(frame))
959     return;
960 
961   Type *self_type = self_var->GetType();
962 
963   if (!self_type)
964     return;
965 
966   CompilerType self_clang_type = self_type->GetFullCompilerType();
967 
968   if (TypeSystemClang::IsObjCClassType(self_clang_type)) {
969     return;
970   }
971   if (!TypeSystemClang::IsObjCObjectPointerType(self_clang_type))
972     return;
973   self_clang_type = self_clang_type.GetPointeeType();
974 
975   if (!self_clang_type)
976     return;
977 
978   LLDB_LOG(log, "  FEVD[{0}] Adding type for $__lldb_objc_class: {1}",
979            ClangUtil::ToString(self_type->GetFullCompilerType()));
980 
981   TypeFromUser class_user_type(self_clang_type);
982 
983   AddOneType(context, class_user_type);
984 }
985 
986 void ClangExpressionDeclMap::LookupLocalVarNamespace(
987     SymbolContext &sym_ctx, NameSearchContext &name_context) {
988   if (sym_ctx.block == nullptr)
989     return;
990 
991   CompilerDeclContext frame_decl_context = sym_ctx.block->GetDeclContext();
992   if (!frame_decl_context)
993     return;
994 
995   TypeSystemClang *frame_ast = llvm::dyn_cast_or_null<TypeSystemClang>(
996       frame_decl_context.GetTypeSystem());
997   if (!frame_ast)
998     return;
999 
1000   clang::NamespaceDecl *namespace_decl =
1001       m_clang_ast_context->GetUniqueNamespaceDeclaration(
1002           g_lldb_local_vars_namespace_cstr, nullptr, OptionalClangModuleID());
1003   if (!namespace_decl)
1004     return;
1005 
1006   name_context.AddNamedDecl(namespace_decl);
1007   clang::DeclContext *ctxt = clang::Decl::castToDeclContext(namespace_decl);
1008   ctxt->setHasExternalVisibleStorage(true);
1009   name_context.m_found_local_vars_nsp = true;
1010 }
1011 
1012 void ClangExpressionDeclMap::LookupInModulesDeclVendor(
1013     NameSearchContext &context, ConstString name) {
1014   Log *log = GetLog(LLDBLog::Expressions);
1015 
1016   if (!m_target)
1017     return;
1018 
1019   std::shared_ptr<ClangModulesDeclVendor> modules_decl_vendor =
1020       GetClangModulesDeclVendor();
1021   if (!modules_decl_vendor)
1022     return;
1023 
1024   bool append = false;
1025   uint32_t max_matches = 1;
1026   std::vector<clang::NamedDecl *> decls;
1027 
1028   if (!modules_decl_vendor->FindDecls(name, append, max_matches, decls))
1029     return;
1030 
1031   assert(!decls.empty() && "FindDecls returned true but no decls?");
1032   clang::NamedDecl *const decl_from_modules = decls[0];
1033 
1034   LLDB_LOG(log,
1035            "  CAS::FEVD Matching decl found for "
1036            "\"{0}\" in the modules",
1037            name);
1038 
1039   clang::Decl *copied_decl = CopyDecl(decl_from_modules);
1040   if (!copied_decl) {
1041     LLDB_LOG(log, "  CAS::FEVD - Couldn't export a "
1042                   "declaration from the modules");
1043     return;
1044   }
1045 
1046   if (auto copied_function = dyn_cast<clang::FunctionDecl>(copied_decl)) {
1047     MaybeRegisterFunctionBody(copied_function);
1048 
1049     context.AddNamedDecl(copied_function);
1050 
1051     context.m_found_function_with_type_info = true;
1052     context.m_found_function = true;
1053   } else if (auto copied_var = dyn_cast<clang::VarDecl>(copied_decl)) {
1054     context.AddNamedDecl(copied_var);
1055     context.m_found_variable = true;
1056   }
1057 }
1058 
1059 bool ClangExpressionDeclMap::LookupLocalVariable(
1060     NameSearchContext &context, ConstString name, SymbolContext &sym_ctx,
1061     const CompilerDeclContext &namespace_decl) {
1062   if (sym_ctx.block == nullptr)
1063     return false;
1064 
1065   CompilerDeclContext decl_context = sym_ctx.block->GetDeclContext();
1066   if (!decl_context)
1067     return false;
1068 
1069   // Make sure that the variables are parsed so that we have the
1070   // declarations.
1071   StackFrame *frame = m_parser_vars->m_exe_ctx.GetFramePtr();
1072   VariableListSP vars = frame->GetInScopeVariableList(true);
1073   for (size_t i = 0; i < vars->GetSize(); i++)
1074     vars->GetVariableAtIndex(i)->GetDecl();
1075 
1076   // Search for declarations matching the name. Do not include imported
1077   // decls in the search if we are looking for decls in the artificial
1078   // namespace $__lldb_local_vars.
1079   std::vector<CompilerDecl> found_decls =
1080       decl_context.FindDeclByName(name, namespace_decl.IsValid());
1081 
1082   VariableSP var;
1083   bool variable_found = false;
1084   for (CompilerDecl decl : found_decls) {
1085     for (size_t vi = 0, ve = vars->GetSize(); vi != ve; ++vi) {
1086       VariableSP candidate_var = vars->GetVariableAtIndex(vi);
1087       if (candidate_var->GetDecl() == decl) {
1088         var = candidate_var;
1089         break;
1090       }
1091     }
1092 
1093     if (var && !variable_found) {
1094       variable_found = true;
1095       ValueObjectSP valobj = ValueObjectVariable::Create(frame, var);
1096       AddOneVariable(context, var, valobj);
1097       context.m_found_variable = true;
1098     }
1099   }
1100 
1101   // We're in a local_var_lookup but haven't found any local variables
1102   // so far. When performing a variable lookup from within the context of
1103   // a lambda, we count the lambda captures as local variables. Thus,
1104   // see if we captured any variables with the requested 'name'.
1105   if (!variable_found) {
1106     auto find_capture = [](ConstString varname,
1107                            StackFrame *frame) -> ValueObjectSP {
1108       if (auto lambda = ClangExpressionUtil::GetLambdaValueObject(frame)) {
1109         if (auto capture = lambda->GetChildMemberWithName(varname)) {
1110           return capture;
1111         }
1112       }
1113 
1114       return nullptr;
1115     };
1116 
1117     if (auto capture = find_capture(name, frame)) {
1118       variable_found = true;
1119       context.m_found_variable = true;
1120       AddOneVariable(context, std::move(capture), std::move(find_capture));
1121     }
1122   }
1123 
1124   return variable_found;
1125 }
1126 
1127 /// Structure to hold the info needed when comparing function
1128 /// declarations.
1129 namespace {
1130 struct FuncDeclInfo {
1131   ConstString m_name;
1132   CompilerType m_copied_type;
1133   uint32_t m_decl_lvl;
1134   SymbolContext m_sym_ctx;
1135 };
1136 } // namespace
1137 
1138 SymbolContextList ClangExpressionDeclMap::SearchFunctionsInSymbolContexts(
1139     const SymbolContextList &sc_list,
1140     const CompilerDeclContext &frame_decl_context) {
1141   // First, symplify things by looping through the symbol contexts to
1142   // remove unwanted functions and separate out the functions we want to
1143   // compare and prune into a separate list. Cache the info needed about
1144   // the function declarations in a vector for efficiency.
1145   SymbolContextList sc_sym_list;
1146   std::vector<FuncDeclInfo> decl_infos;
1147   decl_infos.reserve(sc_list.GetSize());
1148   clang::DeclContext *frame_decl_ctx =
1149       (clang::DeclContext *)frame_decl_context.GetOpaqueDeclContext();
1150   TypeSystemClang *ast = llvm::dyn_cast_or_null<TypeSystemClang>(
1151       frame_decl_context.GetTypeSystem());
1152 
1153   for (const SymbolContext &sym_ctx : sc_list) {
1154     FuncDeclInfo fdi;
1155 
1156     // We don't know enough about symbols to compare them, but we should
1157     // keep them in the list.
1158     Function *function = sym_ctx.function;
1159     if (!function) {
1160       sc_sym_list.Append(sym_ctx);
1161       continue;
1162     }
1163     // Filter out functions without declaration contexts, as well as
1164     // class/instance methods, since they'll be skipped in the code that
1165     // follows anyway.
1166     CompilerDeclContext func_decl_context = function->GetDeclContext();
1167     if (!func_decl_context || func_decl_context.IsClassMethod())
1168       continue;
1169     // We can only prune functions for which we can copy the type.
1170     CompilerType func_clang_type = function->GetType()->GetFullCompilerType();
1171     CompilerType copied_func_type = GuardedCopyType(func_clang_type);
1172     if (!copied_func_type) {
1173       sc_sym_list.Append(sym_ctx);
1174       continue;
1175     }
1176 
1177     fdi.m_sym_ctx = sym_ctx;
1178     fdi.m_name = function->GetName();
1179     fdi.m_copied_type = copied_func_type;
1180     fdi.m_decl_lvl = LLDB_INVALID_DECL_LEVEL;
1181     if (fdi.m_copied_type && func_decl_context) {
1182       // Call CountDeclLevels to get the number of parent scopes we have
1183       // to look through before we find the function declaration. When
1184       // comparing functions of the same type, the one with a lower count
1185       // will be closer to us in the lookup scope and shadows the other.
1186       clang::DeclContext *func_decl_ctx =
1187           (clang::DeclContext *)func_decl_context.GetOpaqueDeclContext();
1188       fdi.m_decl_lvl = ast->CountDeclLevels(frame_decl_ctx, func_decl_ctx,
1189                                             &fdi.m_name, &fdi.m_copied_type);
1190     }
1191     decl_infos.emplace_back(fdi);
1192   }
1193 
1194   // Loop through the functions in our cache looking for matching types,
1195   // then compare their scope levels to see which is closer.
1196   std::multimap<CompilerType, const FuncDeclInfo *> matches;
1197   for (const FuncDeclInfo &fdi : decl_infos) {
1198     const CompilerType t = fdi.m_copied_type;
1199     auto q = matches.find(t);
1200     if (q != matches.end()) {
1201       if (q->second->m_decl_lvl > fdi.m_decl_lvl)
1202         // This function is closer; remove the old set.
1203         matches.erase(t);
1204       else if (q->second->m_decl_lvl < fdi.m_decl_lvl)
1205         // The functions in our set are closer - skip this one.
1206         continue;
1207     }
1208     matches.insert(std::make_pair(t, &fdi));
1209   }
1210 
1211   // Loop through our matches and add their symbol contexts to our list.
1212   SymbolContextList sc_func_list;
1213   for (const auto &q : matches)
1214     sc_func_list.Append(q.second->m_sym_ctx);
1215 
1216   // Rejoin the lists with the functions in front.
1217   sc_func_list.Append(sc_sym_list);
1218   return sc_func_list;
1219 }
1220 
1221 void ClangExpressionDeclMap::LookupFunction(
1222     NameSearchContext &context, lldb::ModuleSP module_sp, ConstString name,
1223     const CompilerDeclContext &namespace_decl) {
1224   if (!m_parser_vars)
1225     return;
1226 
1227   Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
1228 
1229   std::vector<clang::NamedDecl *> decls_from_modules;
1230 
1231   if (target) {
1232     if (std::shared_ptr<ClangModulesDeclVendor> decl_vendor =
1233             GetClangModulesDeclVendor()) {
1234       decl_vendor->FindDecls(name, false, UINT32_MAX, decls_from_modules);
1235     }
1236   }
1237 
1238   SymbolContextList sc_list;
1239   if (namespace_decl && module_sp) {
1240     ModuleFunctionSearchOptions function_options;
1241     function_options.include_inlines = false;
1242     function_options.include_symbols = false;
1243 
1244     module_sp->FindFunctions(name, namespace_decl, eFunctionNameTypeBase,
1245                              function_options, sc_list);
1246   } else if (target && !namespace_decl) {
1247     ModuleFunctionSearchOptions function_options;
1248     function_options.include_inlines = false;
1249     function_options.include_symbols = true;
1250 
1251     // TODO Fix FindFunctions so that it doesn't return
1252     //   instance methods for eFunctionNameTypeBase.
1253 
1254     target->GetImages().FindFunctions(
1255         name, eFunctionNameTypeFull | eFunctionNameTypeBase, function_options,
1256         sc_list);
1257   }
1258 
1259   // If we found more than one function, see if we can use the frame's decl
1260   // context to remove functions that are shadowed by other functions which
1261   // match in type but are nearer in scope.
1262   //
1263   // AddOneFunction will not add a function whose type has already been
1264   // added, so if there's another function in the list with a matching type,
1265   // check to see if their decl context is a parent of the current frame's or
1266   // was imported via a and using statement, and pick the best match
1267   // according to lookup rules.
1268   if (sc_list.GetSize() > 1) {
1269     // Collect some info about our frame's context.
1270     StackFrame *frame = m_parser_vars->m_exe_ctx.GetFramePtr();
1271     SymbolContext frame_sym_ctx;
1272     if (frame != nullptr)
1273       frame_sym_ctx = frame->GetSymbolContext(lldb::eSymbolContextFunction |
1274                                               lldb::eSymbolContextBlock);
1275     CompilerDeclContext frame_decl_context =
1276         frame_sym_ctx.block != nullptr ? frame_sym_ctx.block->GetDeclContext()
1277                                        : CompilerDeclContext();
1278 
1279     // We can't do this without a compiler decl context for our frame.
1280     if (frame_decl_context) {
1281       sc_list = SearchFunctionsInSymbolContexts(sc_list, frame_decl_context);
1282     }
1283   }
1284 
1285   if (sc_list.GetSize()) {
1286     Symbol *extern_symbol = nullptr;
1287     Symbol *non_extern_symbol = nullptr;
1288 
1289     for (const SymbolContext &sym_ctx : sc_list) {
1290       if (sym_ctx.function) {
1291         CompilerDeclContext decl_ctx = sym_ctx.function->GetDeclContext();
1292 
1293         if (!decl_ctx)
1294           continue;
1295 
1296         // Filter out class/instance methods.
1297         if (decl_ctx.IsClassMethod())
1298           continue;
1299 
1300         AddOneFunction(context, sym_ctx.function, nullptr);
1301         context.m_found_function_with_type_info = true;
1302         context.m_found_function = true;
1303       } else if (sym_ctx.symbol) {
1304         Symbol *symbol = sym_ctx.symbol;
1305         if (target && symbol->GetType() == eSymbolTypeReExported) {
1306           symbol = symbol->ResolveReExportedSymbol(*target);
1307           if (symbol == nullptr)
1308             continue;
1309         }
1310 
1311         if (symbol->IsExternal())
1312           extern_symbol = symbol;
1313         else
1314           non_extern_symbol = symbol;
1315       }
1316     }
1317 
1318     if (!context.m_found_function_with_type_info) {
1319       for (clang::NamedDecl *decl : decls_from_modules) {
1320         if (llvm::isa<clang::FunctionDecl>(decl)) {
1321           clang::NamedDecl *copied_decl =
1322               llvm::cast_or_null<FunctionDecl>(CopyDecl(decl));
1323           if (copied_decl) {
1324             context.AddNamedDecl(copied_decl);
1325             context.m_found_function_with_type_info = true;
1326           }
1327         }
1328       }
1329     }
1330 
1331     if (!context.m_found_function_with_type_info) {
1332       if (extern_symbol) {
1333         AddOneFunction(context, nullptr, extern_symbol);
1334         context.m_found_function = true;
1335       } else if (non_extern_symbol) {
1336         AddOneFunction(context, nullptr, non_extern_symbol);
1337         context.m_found_function = true;
1338       }
1339     }
1340   }
1341 }
1342 
1343 void ClangExpressionDeclMap::FindExternalVisibleDecls(
1344     NameSearchContext &context, lldb::ModuleSP module_sp,
1345     const CompilerDeclContext &namespace_decl) {
1346   assert(m_ast_context);
1347 
1348   Log *log = GetLog(LLDBLog::Expressions);
1349 
1350   const ConstString name(context.m_decl_name.getAsString().c_str());
1351   if (IgnoreName(name, false))
1352     return;
1353 
1354   // Only look for functions by name out in our symbols if the function doesn't
1355   // start with our phony prefix of '$'
1356 
1357   Target *target = nullptr;
1358   StackFrame *frame = nullptr;
1359   SymbolContext sym_ctx;
1360   if (m_parser_vars) {
1361     target = m_parser_vars->m_exe_ctx.GetTargetPtr();
1362     frame = m_parser_vars->m_exe_ctx.GetFramePtr();
1363   }
1364   if (frame != nullptr)
1365     sym_ctx = frame->GetSymbolContext(lldb::eSymbolContextFunction |
1366                                       lldb::eSymbolContextBlock);
1367 
1368   // Try the persistent decls, which take precedence over all else.
1369   if (!namespace_decl)
1370     SearchPersistenDecls(context, name);
1371 
1372   if (name.GetStringRef().startswith("$") && !namespace_decl) {
1373     if (name == "$__lldb_class") {
1374       LookUpLldbClass(context);
1375       return;
1376     }
1377 
1378     if (name == "$__lldb_objc_class") {
1379       LookUpLldbObjCClass(context);
1380       return;
1381     }
1382     if (name == g_lldb_local_vars_namespace_cstr) {
1383       LookupLocalVarNamespace(sym_ctx, context);
1384       return;
1385     }
1386 
1387     // any other $__lldb names should be weeded out now
1388     if (name.GetStringRef().startswith("$__lldb"))
1389       return;
1390 
1391     // No ParserVars means we can't do register or variable lookup.
1392     if (!m_parser_vars || !m_parser_vars->m_persistent_vars)
1393       return;
1394 
1395     ExpressionVariableSP pvar_sp(
1396         m_parser_vars->m_persistent_vars->GetVariable(name));
1397 
1398     if (pvar_sp) {
1399       AddOneVariable(context, pvar_sp);
1400       return;
1401     }
1402 
1403     assert(name.GetStringRef().startswith("$"));
1404     llvm::StringRef reg_name = name.GetStringRef().substr(1);
1405 
1406     if (m_parser_vars->m_exe_ctx.GetRegisterContext()) {
1407       const RegisterInfo *reg_info(
1408           m_parser_vars->m_exe_ctx.GetRegisterContext()->GetRegisterInfoByName(
1409               reg_name));
1410 
1411       if (reg_info) {
1412         LLDB_LOG(log, "  CEDM::FEVD Found register {0}", reg_info->name);
1413 
1414         AddOneRegister(context, reg_info);
1415       }
1416     }
1417     return;
1418   }
1419 
1420   bool local_var_lookup = !namespace_decl || (namespace_decl.GetName() ==
1421                                               g_lldb_local_vars_namespace_cstr);
1422   if (frame && local_var_lookup)
1423     if (LookupLocalVariable(context, name, sym_ctx, namespace_decl))
1424       return;
1425 
1426   if (target) {
1427     ValueObjectSP valobj;
1428     VariableSP var;
1429     var = FindGlobalVariable(*target, module_sp, name, namespace_decl);
1430 
1431     if (var) {
1432       valobj = ValueObjectVariable::Create(target, var);
1433       AddOneVariable(context, var, valobj);
1434       context.m_found_variable = true;
1435       return;
1436     }
1437   }
1438 
1439   LookupFunction(context, module_sp, name, namespace_decl);
1440 
1441   // Try the modules next.
1442   if (!context.m_found_function_with_type_info)
1443     LookupInModulesDeclVendor(context, name);
1444 
1445   if (target && !context.m_found_variable && !namespace_decl) {
1446     // We couldn't find a non-symbol variable for this.  Now we'll hunt for a
1447     // generic data symbol, and -- if it is found -- treat it as a variable.
1448     Status error;
1449 
1450     const Symbol *data_symbol =
1451         m_parser_vars->m_sym_ctx.FindBestGlobalDataSymbol(name, error);
1452 
1453     if (!error.Success()) {
1454       const unsigned diag_id =
1455           m_ast_context->getDiagnostics().getCustomDiagID(
1456               clang::DiagnosticsEngine::Level::Error, "%0");
1457       m_ast_context->getDiagnostics().Report(diag_id) << error.AsCString();
1458     }
1459 
1460     if (data_symbol) {
1461       std::string warning("got name from symbols: ");
1462       warning.append(name.AsCString());
1463       const unsigned diag_id =
1464           m_ast_context->getDiagnostics().getCustomDiagID(
1465               clang::DiagnosticsEngine::Level::Warning, "%0");
1466       m_ast_context->getDiagnostics().Report(diag_id) << warning.c_str();
1467       AddOneGenericVariable(context, *data_symbol);
1468       context.m_found_variable = true;
1469     }
1470   }
1471 }
1472 
1473 bool ClangExpressionDeclMap::GetVariableValue(VariableSP &var,
1474                                               lldb_private::Value &var_location,
1475                                               TypeFromUser *user_type,
1476                                               TypeFromParser *parser_type) {
1477   Log *log = GetLog(LLDBLog::Expressions);
1478 
1479   Type *var_type = var->GetType();
1480 
1481   if (!var_type) {
1482     LLDB_LOG(log, "Skipped a definition because it has no type");
1483     return false;
1484   }
1485 
1486   CompilerType var_clang_type = var_type->GetFullCompilerType();
1487 
1488   if (!var_clang_type) {
1489     LLDB_LOG(log, "Skipped a definition because it has no Clang type");
1490     return false;
1491   }
1492 
1493   auto ts = var_type->GetForwardCompilerType().GetTypeSystem();
1494   auto clang_ast = ts.dyn_cast_or_null<TypeSystemClang>();
1495 
1496   if (!clang_ast) {
1497     LLDB_LOG(log, "Skipped a definition because it has no Clang AST");
1498     return false;
1499   }
1500 
1501   DWARFExpressionList &var_location_list = var->LocationExpressionList();
1502 
1503   Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
1504   Status err;
1505 
1506   if (var->GetLocationIsConstantValueData()) {
1507     DataExtractor const_value_extractor;
1508     if (var_location_list.GetExpressionData(const_value_extractor)) {
1509       var_location = Value(const_value_extractor.GetDataStart(),
1510                            const_value_extractor.GetByteSize());
1511       var_location.SetValueType(Value::ValueType::HostAddress);
1512     } else {
1513       LLDB_LOG(log, "Error evaluating constant variable: {0}", err.AsCString());
1514       return false;
1515     }
1516   }
1517 
1518   CompilerType type_to_use = GuardedCopyType(var_clang_type);
1519 
1520   if (!type_to_use) {
1521     LLDB_LOG(log,
1522              "Couldn't copy a variable's type into the parser's AST context");
1523 
1524     return false;
1525   }
1526 
1527   if (parser_type)
1528     *parser_type = TypeFromParser(type_to_use);
1529 
1530   if (var_location.GetContextType() == Value::ContextType::Invalid)
1531     var_location.SetCompilerType(type_to_use);
1532 
1533   if (var_location.GetValueType() == Value::ValueType::FileAddress) {
1534     SymbolContext var_sc;
1535     var->CalculateSymbolContext(&var_sc);
1536 
1537     if (!var_sc.module_sp)
1538       return false;
1539 
1540     Address so_addr(var_location.GetScalar().ULongLong(),
1541                     var_sc.module_sp->GetSectionList());
1542 
1543     lldb::addr_t load_addr = so_addr.GetLoadAddress(target);
1544 
1545     if (load_addr != LLDB_INVALID_ADDRESS) {
1546       var_location.GetScalar() = load_addr;
1547       var_location.SetValueType(Value::ValueType::LoadAddress);
1548     }
1549   }
1550 
1551   if (user_type)
1552     *user_type = TypeFromUser(var_clang_type);
1553 
1554   return true;
1555 }
1556 
1557 ClangExpressionVariable::ParserVars *
1558 ClangExpressionDeclMap::AddExpressionVariable(NameSearchContext &context,
1559                                               TypeFromParser const &pt,
1560                                               ValueObjectSP valobj) {
1561   clang::QualType parser_opaque_type =
1562       QualType::getFromOpaquePtr(pt.GetOpaqueQualType());
1563 
1564   if (parser_opaque_type.isNull())
1565     return nullptr;
1566 
1567   if (const clang::Type *parser_type = parser_opaque_type.getTypePtr()) {
1568     if (const TagType *tag_type = dyn_cast<TagType>(parser_type))
1569       CompleteType(tag_type->getDecl());
1570     if (const ObjCObjectPointerType *objc_object_ptr_type =
1571             dyn_cast<ObjCObjectPointerType>(parser_type))
1572       CompleteType(objc_object_ptr_type->getInterfaceDecl());
1573   }
1574 
1575   bool is_reference = pt.IsReferenceType();
1576 
1577   NamedDecl *var_decl = nullptr;
1578   if (is_reference)
1579     var_decl = context.AddVarDecl(pt);
1580   else
1581     var_decl = context.AddVarDecl(pt.GetLValueReferenceType());
1582 
1583   std::string decl_name(context.m_decl_name.getAsString());
1584   ConstString entity_name(decl_name.c_str());
1585   ClangExpressionVariable *entity(new ClangExpressionVariable(valobj));
1586   m_found_entities.AddNewlyConstructedVariable(entity);
1587 
1588   assert(entity);
1589   entity->EnableParserVars(GetParserID());
1590   ClangExpressionVariable::ParserVars *parser_vars =
1591       entity->GetParserVars(GetParserID());
1592 
1593   parser_vars->m_named_decl = var_decl;
1594 
1595   if (is_reference)
1596     entity->m_flags |= ClangExpressionVariable::EVTypeIsReference;
1597 
1598   return parser_vars;
1599 }
1600 
1601 void ClangExpressionDeclMap::AddOneVariable(
1602     NameSearchContext &context, ValueObjectSP valobj,
1603     ValueObjectProviderTy valobj_provider) {
1604   assert(m_parser_vars.get());
1605   assert(valobj);
1606 
1607   Log *log = GetLog(LLDBLog::Expressions);
1608 
1609   Value var_location = valobj->GetValue();
1610 
1611   TypeFromUser user_type = valobj->GetCompilerType();
1612 
1613   auto clang_ast =
1614       user_type.GetTypeSystem().dyn_cast_or_null<TypeSystemClang>();
1615 
1616   if (!clang_ast) {
1617     LLDB_LOG(log, "Skipped a definition because it has no Clang AST");
1618     return;
1619   }
1620 
1621   TypeFromParser parser_type = GuardedCopyType(user_type);
1622 
1623   if (!parser_type) {
1624     LLDB_LOG(log,
1625              "Couldn't copy a variable's type into the parser's AST context");
1626 
1627     return;
1628   }
1629 
1630   if (var_location.GetContextType() == Value::ContextType::Invalid)
1631     var_location.SetCompilerType(parser_type);
1632 
1633   ClangExpressionVariable::ParserVars *parser_vars =
1634       AddExpressionVariable(context, parser_type, valobj);
1635 
1636   if (!parser_vars)
1637     return;
1638 
1639   LLDB_LOG(log, "  CEDM::FEVD Found variable {0}, returned\n{1} (original {2})",
1640            context.m_decl_name, ClangUtil::DumpDecl(parser_vars->m_named_decl),
1641            ClangUtil::ToString(user_type));
1642 
1643   parser_vars->m_llvm_value = nullptr;
1644   parser_vars->m_lldb_value = std::move(var_location);
1645   parser_vars->m_lldb_valobj_provider = std::move(valobj_provider);
1646 }
1647 
1648 void ClangExpressionDeclMap::AddOneVariable(NameSearchContext &context,
1649                                             VariableSP var,
1650                                             ValueObjectSP valobj) {
1651   assert(m_parser_vars.get());
1652 
1653   Log *log = GetLog(LLDBLog::Expressions);
1654 
1655   TypeFromUser ut;
1656   TypeFromParser pt;
1657   Value var_location;
1658 
1659   if (!GetVariableValue(var, var_location, &ut, &pt))
1660     return;
1661 
1662   ClangExpressionVariable::ParserVars *parser_vars =
1663       AddExpressionVariable(context, pt, std::move(valobj));
1664 
1665   if (!parser_vars)
1666     return;
1667 
1668   LLDB_LOG(log, "  CEDM::FEVD Found variable {0}, returned\n{1} (original {2})",
1669            context.m_decl_name, ClangUtil::DumpDecl(parser_vars->m_named_decl),
1670            ClangUtil::ToString(ut));
1671 
1672   parser_vars->m_llvm_value = nullptr;
1673   parser_vars->m_lldb_value = var_location;
1674   parser_vars->m_lldb_var = var;
1675 }
1676 
1677 void ClangExpressionDeclMap::AddOneVariable(NameSearchContext &context,
1678                                             ExpressionVariableSP &pvar_sp) {
1679   Log *log = GetLog(LLDBLog::Expressions);
1680 
1681   TypeFromUser user_type(
1682       llvm::cast<ClangExpressionVariable>(pvar_sp.get())->GetTypeFromUser());
1683 
1684   TypeFromParser parser_type(GuardedCopyType(user_type));
1685 
1686   if (!parser_type.GetOpaqueQualType()) {
1687     LLDB_LOG(log, "  CEDM::FEVD Couldn't import type for pvar {0}",
1688              pvar_sp->GetName());
1689     return;
1690   }
1691 
1692   NamedDecl *var_decl =
1693       context.AddVarDecl(parser_type.GetLValueReferenceType());
1694 
1695   llvm::cast<ClangExpressionVariable>(pvar_sp.get())
1696       ->EnableParserVars(GetParserID());
1697   ClangExpressionVariable::ParserVars *parser_vars =
1698       llvm::cast<ClangExpressionVariable>(pvar_sp.get())
1699           ->GetParserVars(GetParserID());
1700   parser_vars->m_named_decl = var_decl;
1701   parser_vars->m_llvm_value = nullptr;
1702   parser_vars->m_lldb_value.Clear();
1703 
1704   LLDB_LOG(log, "  CEDM::FEVD Added pvar {0}, returned\n{1}",
1705            pvar_sp->GetName(), ClangUtil::DumpDecl(var_decl));
1706 }
1707 
1708 void ClangExpressionDeclMap::AddOneGenericVariable(NameSearchContext &context,
1709                                                    const Symbol &symbol) {
1710   assert(m_parser_vars.get());
1711 
1712   Log *log = GetLog(LLDBLog::Expressions);
1713 
1714   Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
1715 
1716   if (target == nullptr)
1717     return;
1718 
1719   auto scratch_ast_context = GetScratchContext(*target);
1720   if (!scratch_ast_context)
1721     return;
1722 
1723   TypeFromUser user_type(scratch_ast_context->GetBasicType(eBasicTypeVoid)
1724                              .GetPointerType()
1725                              .GetLValueReferenceType());
1726   TypeFromParser parser_type(m_clang_ast_context->GetBasicType(eBasicTypeVoid)
1727                                  .GetPointerType()
1728                                  .GetLValueReferenceType());
1729   NamedDecl *var_decl = context.AddVarDecl(parser_type);
1730 
1731   std::string decl_name(context.m_decl_name.getAsString());
1732   ConstString entity_name(decl_name.c_str());
1733   ClangExpressionVariable *entity(new ClangExpressionVariable(
1734       m_parser_vars->m_exe_ctx.GetBestExecutionContextScope(), entity_name,
1735       user_type, m_parser_vars->m_target_info.byte_order,
1736       m_parser_vars->m_target_info.address_byte_size));
1737   m_found_entities.AddNewlyConstructedVariable(entity);
1738 
1739   entity->EnableParserVars(GetParserID());
1740   ClangExpressionVariable::ParserVars *parser_vars =
1741       entity->GetParserVars(GetParserID());
1742 
1743   const Address symbol_address = symbol.GetAddress();
1744   lldb::addr_t symbol_load_addr = symbol_address.GetLoadAddress(target);
1745 
1746   // parser_vars->m_lldb_value.SetContext(Value::ContextType::ClangType,
1747   // user_type.GetOpaqueQualType());
1748   parser_vars->m_lldb_value.SetCompilerType(user_type);
1749   parser_vars->m_lldb_value.GetScalar() = symbol_load_addr;
1750   parser_vars->m_lldb_value.SetValueType(Value::ValueType::LoadAddress);
1751 
1752   parser_vars->m_named_decl = var_decl;
1753   parser_vars->m_llvm_value = nullptr;
1754   parser_vars->m_lldb_sym = &symbol;
1755 
1756   LLDB_LOG(log, "  CEDM::FEVD Found variable {0}, returned\n{1}", decl_name,
1757            ClangUtil::DumpDecl(var_decl));
1758 }
1759 
1760 void ClangExpressionDeclMap::AddOneRegister(NameSearchContext &context,
1761                                             const RegisterInfo *reg_info) {
1762   Log *log = GetLog(LLDBLog::Expressions);
1763 
1764   CompilerType clang_type =
1765       m_clang_ast_context->GetBuiltinTypeForEncodingAndBitSize(
1766           reg_info->encoding, reg_info->byte_size * 8);
1767 
1768   if (!clang_type) {
1769     LLDB_LOG(log, "  Tried to add a type for {0}, but couldn't get one",
1770              context.m_decl_name.getAsString());
1771     return;
1772   }
1773 
1774   TypeFromParser parser_clang_type(clang_type);
1775 
1776   NamedDecl *var_decl = context.AddVarDecl(parser_clang_type);
1777 
1778   ClangExpressionVariable *entity(new ClangExpressionVariable(
1779       m_parser_vars->m_exe_ctx.GetBestExecutionContextScope(),
1780       m_parser_vars->m_target_info.byte_order,
1781       m_parser_vars->m_target_info.address_byte_size));
1782   m_found_entities.AddNewlyConstructedVariable(entity);
1783 
1784   std::string decl_name(context.m_decl_name.getAsString());
1785   entity->SetName(ConstString(decl_name.c_str()));
1786   entity->SetRegisterInfo(reg_info);
1787   entity->EnableParserVars(GetParserID());
1788   ClangExpressionVariable::ParserVars *parser_vars =
1789       entity->GetParserVars(GetParserID());
1790   parser_vars->m_named_decl = var_decl;
1791   parser_vars->m_llvm_value = nullptr;
1792   parser_vars->m_lldb_value.Clear();
1793   entity->m_flags |= ClangExpressionVariable::EVBareRegister;
1794 
1795   LLDB_LOG(log, "  CEDM::FEVD Added register {0}, returned\n{1}",
1796            context.m_decl_name.getAsString(), ClangUtil::DumpDecl(var_decl));
1797 }
1798 
1799 void ClangExpressionDeclMap::AddOneFunction(NameSearchContext &context,
1800                                             Function *function,
1801                                             Symbol *symbol) {
1802   assert(m_parser_vars.get());
1803 
1804   Log *log = GetLog(LLDBLog::Expressions);
1805 
1806   NamedDecl *function_decl = nullptr;
1807   Address fun_address;
1808   CompilerType function_clang_type;
1809 
1810   bool is_indirect_function = false;
1811 
1812   if (function) {
1813     Type *function_type = function->GetType();
1814 
1815     const auto lang = function->GetCompileUnit()->GetLanguage();
1816     const auto name = function->GetMangled().GetMangledName().AsCString();
1817     const bool extern_c = (Language::LanguageIsC(lang) &&
1818                            !CPlusPlusLanguage::IsCPPMangledName(name)) ||
1819                           (Language::LanguageIsObjC(lang) &&
1820                            !Language::LanguageIsCPlusPlus(lang));
1821 
1822     if (!extern_c) {
1823       TypeSystem *type_system = function->GetDeclContext().GetTypeSystem();
1824       if (llvm::isa<TypeSystemClang>(type_system)) {
1825         clang::DeclContext *src_decl_context =
1826             (clang::DeclContext *)function->GetDeclContext()
1827                 .GetOpaqueDeclContext();
1828         clang::FunctionDecl *src_function_decl =
1829             llvm::dyn_cast_or_null<clang::FunctionDecl>(src_decl_context);
1830         if (src_function_decl &&
1831             src_function_decl->getTemplateSpecializationInfo()) {
1832           clang::FunctionTemplateDecl *function_template =
1833               src_function_decl->getTemplateSpecializationInfo()->getTemplate();
1834           clang::FunctionTemplateDecl *copied_function_template =
1835               llvm::dyn_cast_or_null<clang::FunctionTemplateDecl>(
1836                   CopyDecl(function_template));
1837           if (copied_function_template) {
1838             if (log) {
1839               StreamString ss;
1840 
1841               function->DumpSymbolContext(&ss);
1842 
1843               LLDB_LOG(log,
1844                        "  CEDM::FEVD Imported decl for function template"
1845                        " {0} (description {1}), returned\n{2}",
1846                        copied_function_template->getNameAsString(),
1847                        ss.GetData(),
1848                        ClangUtil::DumpDecl(copied_function_template));
1849             }
1850 
1851             context.AddNamedDecl(copied_function_template);
1852           }
1853         } else if (src_function_decl) {
1854           if (clang::FunctionDecl *copied_function_decl =
1855                   llvm::dyn_cast_or_null<clang::FunctionDecl>(
1856                       CopyDecl(src_function_decl))) {
1857             if (log) {
1858               StreamString ss;
1859 
1860               function->DumpSymbolContext(&ss);
1861 
1862               LLDB_LOG(log,
1863                        "  CEDM::FEVD Imported decl for function {0} "
1864                        "(description {1}), returned\n{2}",
1865                        copied_function_decl->getNameAsString(), ss.GetData(),
1866                        ClangUtil::DumpDecl(copied_function_decl));
1867             }
1868 
1869             context.AddNamedDecl(copied_function_decl);
1870             return;
1871           } else {
1872             LLDB_LOG(log, "  Failed to import the function decl for '{0}'",
1873                      src_function_decl->getName());
1874           }
1875         }
1876       }
1877     }
1878 
1879     if (!function_type) {
1880       LLDB_LOG(log, "  Skipped a function because it has no type");
1881       return;
1882     }
1883 
1884     function_clang_type = function_type->GetFullCompilerType();
1885 
1886     if (!function_clang_type) {
1887       LLDB_LOG(log, "  Skipped a function because it has no Clang type");
1888       return;
1889     }
1890 
1891     fun_address = function->GetAddressRange().GetBaseAddress();
1892 
1893     CompilerType copied_function_type = GuardedCopyType(function_clang_type);
1894     if (copied_function_type) {
1895       function_decl = context.AddFunDecl(copied_function_type, extern_c);
1896 
1897       if (!function_decl) {
1898         LLDB_LOG(log, "  Failed to create a function decl for '{0}' ({1:x})",
1899                  function_type->GetName(), function_type->GetID());
1900 
1901         return;
1902       }
1903     } else {
1904       // We failed to copy the type we found
1905       LLDB_LOG(log,
1906                "  Failed to import the function type '{0}' ({1:x})"
1907                " into the expression parser AST context",
1908                function_type->GetName(), function_type->GetID());
1909 
1910       return;
1911     }
1912   } else if (symbol) {
1913     fun_address = symbol->GetAddress();
1914     function_decl = context.AddGenericFunDecl();
1915     is_indirect_function = symbol->IsIndirect();
1916   } else {
1917     LLDB_LOG(log, "  AddOneFunction called with no function and no symbol");
1918     return;
1919   }
1920 
1921   Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
1922 
1923   lldb::addr_t load_addr =
1924       fun_address.GetCallableLoadAddress(target, is_indirect_function);
1925 
1926   ClangExpressionVariable *entity(new ClangExpressionVariable(
1927       m_parser_vars->m_exe_ctx.GetBestExecutionContextScope(),
1928       m_parser_vars->m_target_info.byte_order,
1929       m_parser_vars->m_target_info.address_byte_size));
1930   m_found_entities.AddNewlyConstructedVariable(entity);
1931 
1932   std::string decl_name(context.m_decl_name.getAsString());
1933   entity->SetName(ConstString(decl_name.c_str()));
1934   entity->SetCompilerType(function_clang_type);
1935   entity->EnableParserVars(GetParserID());
1936 
1937   ClangExpressionVariable::ParserVars *parser_vars =
1938       entity->GetParserVars(GetParserID());
1939 
1940   if (load_addr != LLDB_INVALID_ADDRESS) {
1941     parser_vars->m_lldb_value.SetValueType(Value::ValueType::LoadAddress);
1942     parser_vars->m_lldb_value.GetScalar() = load_addr;
1943   } else {
1944     // We have to try finding a file address.
1945 
1946     lldb::addr_t file_addr = fun_address.GetFileAddress();
1947 
1948     parser_vars->m_lldb_value.SetValueType(Value::ValueType::FileAddress);
1949     parser_vars->m_lldb_value.GetScalar() = file_addr;
1950   }
1951 
1952   parser_vars->m_named_decl = function_decl;
1953   parser_vars->m_llvm_value = nullptr;
1954 
1955   if (log) {
1956     StreamString ss;
1957 
1958     fun_address.Dump(&ss,
1959                      m_parser_vars->m_exe_ctx.GetBestExecutionContextScope(),
1960                      Address::DumpStyleResolvedDescription);
1961 
1962     LLDB_LOG(log,
1963              "  CEDM::FEVD Found {0} function {1} (description {2}), "
1964              "returned\n{3}",
1965              (function ? "specific" : "generic"), decl_name, ss.GetData(),
1966              ClangUtil::DumpDecl(function_decl));
1967   }
1968 }
1969 
1970 void ClangExpressionDeclMap::AddContextClassType(NameSearchContext &context,
1971                                                  const TypeFromUser &ut) {
1972   CompilerType copied_clang_type = GuardedCopyType(ut);
1973 
1974   Log *log = GetLog(LLDBLog::Expressions);
1975 
1976   if (!copied_clang_type) {
1977     LLDB_LOG(log,
1978              "ClangExpressionDeclMap::AddThisType - Couldn't import the type");
1979 
1980     return;
1981   }
1982 
1983   if (copied_clang_type.IsAggregateType() &&
1984       copied_clang_type.GetCompleteType()) {
1985     CompilerType void_clang_type =
1986         m_clang_ast_context->GetBasicType(eBasicTypeVoid);
1987     CompilerType void_ptr_clang_type = void_clang_type.GetPointerType();
1988 
1989     CompilerType method_type = m_clang_ast_context->CreateFunctionType(
1990         void_clang_type, &void_ptr_clang_type, 1, false, 0);
1991 
1992     const bool is_virtual = false;
1993     const bool is_static = false;
1994     const bool is_inline = false;
1995     const bool is_explicit = false;
1996     const bool is_attr_used = true;
1997     const bool is_artificial = false;
1998 
1999     CXXMethodDecl *method_decl = m_clang_ast_context->AddMethodToCXXRecordType(
2000         copied_clang_type.GetOpaqueQualType(), "$__lldb_expr", nullptr,
2001         method_type, lldb::eAccessPublic, is_virtual, is_static, is_inline,
2002         is_explicit, is_attr_used, is_artificial);
2003 
2004     LLDB_LOG(log,
2005              "  CEDM::AddThisType Added function $__lldb_expr "
2006              "(description {0}) for this type\n{1}",
2007              ClangUtil::ToString(copied_clang_type),
2008              ClangUtil::DumpDecl(method_decl));
2009   }
2010 
2011   if (!copied_clang_type.IsValid())
2012     return;
2013 
2014   TypeSourceInfo *type_source_info = m_ast_context->getTrivialTypeSourceInfo(
2015       QualType::getFromOpaquePtr(copied_clang_type.GetOpaqueQualType()));
2016 
2017   if (!type_source_info)
2018     return;
2019 
2020   // Construct a typedef type because if "*this" is a templated type we can't
2021   // just return ClassTemplateSpecializationDecls in response to name queries.
2022   // Using a typedef makes this much more robust.
2023 
2024   TypedefDecl *typedef_decl = TypedefDecl::Create(
2025       *m_ast_context, m_ast_context->getTranslationUnitDecl(), SourceLocation(),
2026       SourceLocation(), context.m_decl_name.getAsIdentifierInfo(),
2027       type_source_info);
2028 
2029   if (!typedef_decl)
2030     return;
2031 
2032   context.AddNamedDecl(typedef_decl);
2033 }
2034 
2035 void ClangExpressionDeclMap::AddOneType(NameSearchContext &context,
2036                                         const TypeFromUser &ut) {
2037   CompilerType copied_clang_type = GuardedCopyType(ut);
2038 
2039   if (!copied_clang_type) {
2040     Log *log = GetLog(LLDBLog::Expressions);
2041 
2042     LLDB_LOG(log,
2043              "ClangExpressionDeclMap::AddOneType - Couldn't import the type");
2044 
2045     return;
2046   }
2047 
2048   context.AddTypeDecl(copied_clang_type);
2049 }
2050