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