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