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