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