1 //===-- SymbolContext.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 "lldb/Symbol/SymbolContext.h" 10 11 #include "lldb/Core/Module.h" 12 #include "lldb/Core/ModuleSpec.h" 13 #include "lldb/Host/Host.h" 14 #include "lldb/Symbol/Block.h" 15 #include "lldb/Symbol/CompileUnit.h" 16 #include "lldb/Symbol/ObjectFile.h" 17 #include "lldb/Symbol/Symbol.h" 18 #include "lldb/Symbol/SymbolFile.h" 19 #include "lldb/Symbol/SymbolVendor.h" 20 #include "lldb/Symbol/Variable.h" 21 #include "lldb/Target/Target.h" 22 #include "lldb/Utility/Log.h" 23 #include "lldb/Utility/StreamString.h" 24 25 using namespace lldb; 26 using namespace lldb_private; 27 28 SymbolContext::SymbolContext() : target_sp(), module_sp(), line_entry() {} 29 30 SymbolContext::SymbolContext(const ModuleSP &m, CompileUnit *cu, Function *f, 31 Block *b, LineEntry *le, Symbol *s) 32 : target_sp(), module_sp(m), comp_unit(cu), function(f), block(b), 33 line_entry(), symbol(s), variable(nullptr) { 34 if (le) 35 line_entry = *le; 36 } 37 38 SymbolContext::SymbolContext(const TargetSP &t, const ModuleSP &m, 39 CompileUnit *cu, Function *f, Block *b, 40 LineEntry *le, Symbol *s) 41 : target_sp(t), module_sp(m), comp_unit(cu), function(f), block(b), 42 line_entry(), symbol(s), variable(nullptr) { 43 if (le) 44 line_entry = *le; 45 } 46 47 SymbolContext::SymbolContext(SymbolContextScope *sc_scope) 48 : target_sp(), module_sp(), comp_unit(nullptr), function(nullptr), 49 block(nullptr), line_entry(), symbol(nullptr), variable(nullptr) { 50 sc_scope->CalculateSymbolContext(this); 51 } 52 53 SymbolContext::~SymbolContext() = default; 54 55 void SymbolContext::Clear(bool clear_target) { 56 if (clear_target) 57 target_sp.reset(); 58 module_sp.reset(); 59 comp_unit = nullptr; 60 function = nullptr; 61 block = nullptr; 62 line_entry.Clear(); 63 symbol = nullptr; 64 variable = nullptr; 65 } 66 67 bool SymbolContext::DumpStopContext(Stream *s, ExecutionContextScope *exe_scope, 68 const Address &addr, bool show_fullpaths, 69 bool show_module, bool show_inlined_frames, 70 bool show_function_arguments, 71 bool show_function_name) const { 72 bool dumped_something = false; 73 if (show_module && module_sp) { 74 if (show_fullpaths) 75 *s << module_sp->GetFileSpec(); 76 else 77 *s << module_sp->GetFileSpec().GetFilename(); 78 s->PutChar('`'); 79 dumped_something = true; 80 } 81 82 if (function != nullptr) { 83 SymbolContext inline_parent_sc; 84 Address inline_parent_addr; 85 if (!show_function_name) { 86 s->Printf("<"); 87 dumped_something = true; 88 } else { 89 ConstString name; 90 if (!show_function_arguments) 91 name = function->GetNameNoArguments(); 92 if (!name) 93 name = function->GetName(); 94 if (name) 95 name.Dump(s); 96 } 97 98 if (addr.IsValid()) { 99 const addr_t function_offset = 100 addr.GetOffset() - 101 function->GetAddressRange().GetBaseAddress().GetOffset(); 102 if (!show_function_name) { 103 // Print +offset even if offset is 0 104 dumped_something = true; 105 s->Printf("+%" PRIu64 ">", function_offset); 106 } else if (function_offset) { 107 dumped_something = true; 108 s->Printf(" + %" PRIu64, function_offset); 109 } 110 } 111 112 if (GetParentOfInlinedScope(addr, inline_parent_sc, inline_parent_addr)) { 113 dumped_something = true; 114 Block *inlined_block = block->GetContainingInlinedBlock(); 115 const InlineFunctionInfo *inlined_block_info = 116 inlined_block->GetInlinedFunctionInfo(); 117 s->Printf(" [inlined] %s", inlined_block_info->GetName().GetCString()); 118 119 lldb_private::AddressRange block_range; 120 if (inlined_block->GetRangeContainingAddress(addr, block_range)) { 121 const addr_t inlined_function_offset = 122 addr.GetOffset() - block_range.GetBaseAddress().GetOffset(); 123 if (inlined_function_offset) { 124 s->Printf(" + %" PRIu64, inlined_function_offset); 125 } 126 } 127 // "line_entry" will always be valid as GetParentOfInlinedScope(...) will 128 // fill it in correctly with the calling file and line. Previous code 129 // was extracting the calling file and line from inlined_block_info and 130 // using it right away which is not correct. On the first call to this 131 // function "line_entry" will contain the actual line table entry. On 132 // susequent calls "line_entry" will contain the calling file and line 133 // from the previous inline info. 134 if (line_entry.IsValid()) { 135 s->PutCString(" at "); 136 line_entry.DumpStopContext(s, show_fullpaths); 137 } 138 139 if (show_inlined_frames) { 140 s->EOL(); 141 s->Indent(); 142 const bool show_function_name = true; 143 return inline_parent_sc.DumpStopContext( 144 s, exe_scope, inline_parent_addr, show_fullpaths, show_module, 145 show_inlined_frames, show_function_arguments, show_function_name); 146 } 147 } else { 148 if (line_entry.IsValid()) { 149 dumped_something = true; 150 s->PutCString(" at "); 151 if (line_entry.DumpStopContext(s, show_fullpaths)) 152 dumped_something = true; 153 } 154 } 155 } else if (symbol != nullptr) { 156 if (!show_function_name) { 157 s->Printf("<"); 158 dumped_something = true; 159 } else if (symbol->GetName()) { 160 dumped_something = true; 161 if (symbol->GetType() == eSymbolTypeTrampoline) 162 s->PutCString("symbol stub for: "); 163 symbol->GetName().Dump(s); 164 } 165 166 if (addr.IsValid() && symbol->ValueIsAddress()) { 167 const addr_t symbol_offset = 168 addr.GetOffset() - symbol->GetAddressRef().GetOffset(); 169 if (!show_function_name) { 170 // Print +offset even if offset is 0 171 dumped_something = true; 172 s->Printf("+%" PRIu64 ">", symbol_offset); 173 } else if (symbol_offset) { 174 dumped_something = true; 175 s->Printf(" + %" PRIu64, symbol_offset); 176 } 177 } 178 } else if (addr.IsValid()) { 179 addr.Dump(s, exe_scope, Address::DumpStyleModuleWithFileAddress); 180 dumped_something = true; 181 } 182 return dumped_something; 183 } 184 185 void SymbolContext::GetDescription(Stream *s, lldb::DescriptionLevel level, 186 Target *target) const { 187 if (module_sp) { 188 s->Indent(" Module: file = \""); 189 module_sp->GetFileSpec().Dump(s->AsRawOstream()); 190 *s << '"'; 191 if (module_sp->GetArchitecture().IsValid()) 192 s->Printf(", arch = \"%s\"", 193 module_sp->GetArchitecture().GetArchitectureName()); 194 s->EOL(); 195 } 196 197 if (comp_unit != nullptr) { 198 s->Indent("CompileUnit: "); 199 comp_unit->GetDescription(s, level); 200 s->EOL(); 201 } 202 203 if (function != nullptr) { 204 s->Indent(" Function: "); 205 function->GetDescription(s, level, target); 206 s->EOL(); 207 208 Type *func_type = function->GetType(); 209 if (func_type) { 210 s->Indent(" FuncType: "); 211 func_type->GetDescription(s, level, false, target); 212 s->EOL(); 213 } 214 } 215 216 if (block != nullptr) { 217 std::vector<Block *> blocks; 218 blocks.push_back(block); 219 Block *parent_block = block->GetParent(); 220 221 while (parent_block) { 222 blocks.push_back(parent_block); 223 parent_block = parent_block->GetParent(); 224 } 225 std::vector<Block *>::reverse_iterator pos; 226 std::vector<Block *>::reverse_iterator begin = blocks.rbegin(); 227 std::vector<Block *>::reverse_iterator end = blocks.rend(); 228 for (pos = begin; pos != end; ++pos) { 229 if (pos == begin) 230 s->Indent(" Blocks: "); 231 else 232 s->Indent(" "); 233 (*pos)->GetDescription(s, function, level, target); 234 s->EOL(); 235 } 236 } 237 238 if (line_entry.IsValid()) { 239 s->Indent(" LineEntry: "); 240 line_entry.GetDescription(s, level, comp_unit, target, false); 241 s->EOL(); 242 } 243 244 if (symbol != nullptr) { 245 s->Indent(" Symbol: "); 246 symbol->GetDescription(s, level, target); 247 s->EOL(); 248 } 249 250 if (variable != nullptr) { 251 s->Indent(" Variable: "); 252 253 s->Printf("id = {0x%8.8" PRIx64 "}, ", variable->GetID()); 254 255 switch (variable->GetScope()) { 256 case eValueTypeVariableGlobal: 257 s->PutCString("kind = global, "); 258 break; 259 260 case eValueTypeVariableStatic: 261 s->PutCString("kind = static, "); 262 break; 263 264 case eValueTypeVariableArgument: 265 s->PutCString("kind = argument, "); 266 break; 267 268 case eValueTypeVariableLocal: 269 s->PutCString("kind = local, "); 270 break; 271 272 case eValueTypeVariableThreadLocal: 273 s->PutCString("kind = thread local, "); 274 break; 275 276 default: 277 break; 278 } 279 280 s->Printf("name = \"%s\"\n", variable->GetName().GetCString()); 281 } 282 } 283 284 uint32_t SymbolContext::GetResolvedMask() const { 285 uint32_t resolved_mask = 0; 286 if (target_sp) 287 resolved_mask |= eSymbolContextTarget; 288 if (module_sp) 289 resolved_mask |= eSymbolContextModule; 290 if (comp_unit) 291 resolved_mask |= eSymbolContextCompUnit; 292 if (function) 293 resolved_mask |= eSymbolContextFunction; 294 if (block) 295 resolved_mask |= eSymbolContextBlock; 296 if (line_entry.IsValid()) 297 resolved_mask |= eSymbolContextLineEntry; 298 if (symbol) 299 resolved_mask |= eSymbolContextSymbol; 300 if (variable) 301 resolved_mask |= eSymbolContextVariable; 302 return resolved_mask; 303 } 304 305 void SymbolContext::Dump(Stream *s, Target *target) const { 306 *s << this << ": "; 307 s->Indent(); 308 s->PutCString("SymbolContext"); 309 s->IndentMore(); 310 s->EOL(); 311 s->IndentMore(); 312 s->Indent(); 313 *s << "Module = " << module_sp.get() << ' '; 314 if (module_sp) 315 module_sp->GetFileSpec().Dump(s->AsRawOstream()); 316 s->EOL(); 317 s->Indent(); 318 *s << "CompileUnit = " << comp_unit; 319 if (comp_unit != nullptr) 320 s->Format(" {{{0:x-16}} {1}", comp_unit->GetID(), 321 comp_unit->GetPrimaryFile()); 322 s->EOL(); 323 s->Indent(); 324 *s << "Function = " << function; 325 if (function != nullptr) { 326 s->Format(" {{{0:x-16}} {1}, address-range = ", function->GetID(), 327 function->GetType()->GetName()); 328 function->GetAddressRange().Dump(s, target, Address::DumpStyleLoadAddress, 329 Address::DumpStyleModuleWithFileAddress); 330 s->EOL(); 331 s->Indent(); 332 Type *func_type = function->GetType(); 333 if (func_type) { 334 *s << " Type = "; 335 func_type->Dump(s, false); 336 } 337 } 338 s->EOL(); 339 s->Indent(); 340 *s << "Block = " << block; 341 if (block != nullptr) 342 s->Format(" {{{0:x-16}}", block->GetID()); 343 s->EOL(); 344 s->Indent(); 345 *s << "LineEntry = "; 346 line_entry.Dump(s, target, true, Address::DumpStyleLoadAddress, 347 Address::DumpStyleModuleWithFileAddress, true); 348 s->EOL(); 349 s->Indent(); 350 *s << "Symbol = " << symbol; 351 if (symbol != nullptr && symbol->GetMangled()) 352 *s << ' ' << symbol->GetName().AsCString(); 353 s->EOL(); 354 *s << "Variable = " << variable; 355 if (variable != nullptr) { 356 s->Format(" {{{0:x-16}} {1}", variable->GetID(), 357 variable->GetType()->GetName()); 358 s->EOL(); 359 } 360 s->IndentLess(); 361 s->IndentLess(); 362 } 363 364 bool lldb_private::operator==(const SymbolContext &lhs, 365 const SymbolContext &rhs) { 366 return lhs.function == rhs.function && lhs.symbol == rhs.symbol && 367 lhs.module_sp.get() == rhs.module_sp.get() && 368 lhs.comp_unit == rhs.comp_unit && 369 lhs.target_sp.get() == rhs.target_sp.get() && 370 LineEntry::Compare(lhs.line_entry, rhs.line_entry) == 0 && 371 lhs.variable == rhs.variable; 372 } 373 374 bool lldb_private::operator!=(const SymbolContext &lhs, 375 const SymbolContext &rhs) { 376 return !(lhs == rhs); 377 } 378 379 bool SymbolContext::GetAddressRange(uint32_t scope, uint32_t range_idx, 380 bool use_inline_block_range, 381 AddressRange &range) const { 382 if ((scope & eSymbolContextLineEntry) && line_entry.IsValid()) { 383 range = line_entry.range; 384 return true; 385 } 386 387 if ((scope & eSymbolContextBlock) && (block != nullptr)) { 388 if (use_inline_block_range) { 389 Block *inline_block = block->GetContainingInlinedBlock(); 390 if (inline_block) 391 return inline_block->GetRangeAtIndex(range_idx, range); 392 } else { 393 return block->GetRangeAtIndex(range_idx, range); 394 } 395 } 396 397 if ((scope & eSymbolContextFunction) && (function != nullptr)) { 398 if (range_idx == 0) { 399 range = function->GetAddressRange(); 400 return true; 401 } 402 } 403 404 if ((scope & eSymbolContextSymbol) && (symbol != nullptr)) { 405 if (range_idx == 0) { 406 if (symbol->ValueIsAddress()) { 407 range.GetBaseAddress() = symbol->GetAddressRef(); 408 range.SetByteSize(symbol->GetByteSize()); 409 return true; 410 } 411 } 412 } 413 range.Clear(); 414 return false; 415 } 416 417 LanguageType SymbolContext::GetLanguage() const { 418 LanguageType lang; 419 if (function && (lang = function->GetLanguage()) != eLanguageTypeUnknown) { 420 return lang; 421 } else if (variable && 422 (lang = variable->GetLanguage()) != eLanguageTypeUnknown) { 423 return lang; 424 } else if (symbol && (lang = symbol->GetLanguage()) != eLanguageTypeUnknown) { 425 return lang; 426 } else if (comp_unit && 427 (lang = comp_unit->GetLanguage()) != eLanguageTypeUnknown) { 428 return lang; 429 } else if (symbol) { 430 // If all else fails, try to guess the language from the name. 431 return symbol->GetMangled().GuessLanguage(); 432 } 433 return eLanguageTypeUnknown; 434 } 435 436 bool SymbolContext::GetParentOfInlinedScope(const Address &curr_frame_pc, 437 SymbolContext &next_frame_sc, 438 Address &next_frame_pc) const { 439 next_frame_sc.Clear(false); 440 next_frame_pc.Clear(); 441 442 if (block) { 443 // const addr_t curr_frame_file_addr = curr_frame_pc.GetFileAddress(); 444 445 // In order to get the parent of an inlined function we first need to see 446 // if we are in an inlined block as "this->block" could be an inlined 447 // block, or a parent of "block" could be. So lets check if this block or 448 // one of this blocks parents is an inlined function. 449 Block *curr_inlined_block = block->GetContainingInlinedBlock(); 450 if (curr_inlined_block) { 451 // "this->block" is contained in an inline function block, so to get the 452 // scope above the inlined block, we get the parent of the inlined block 453 // itself 454 Block *next_frame_block = curr_inlined_block->GetParent(); 455 // Now calculate the symbol context of the containing block 456 next_frame_block->CalculateSymbolContext(&next_frame_sc); 457 458 // If we get here we weren't able to find the return line entry using the 459 // nesting of the blocks and the line table. So just use the call site 460 // info from our inlined block. 461 462 AddressRange range; 463 if (curr_inlined_block->GetRangeContainingAddress(curr_frame_pc, range)) { 464 // To see there this new frame block it, we need to look at the call 465 // site information from 466 const InlineFunctionInfo *curr_inlined_block_inlined_info = 467 curr_inlined_block->GetInlinedFunctionInfo(); 468 next_frame_pc = range.GetBaseAddress(); 469 next_frame_sc.line_entry.range.GetBaseAddress() = next_frame_pc; 470 next_frame_sc.line_entry.file = 471 curr_inlined_block_inlined_info->GetCallSite().GetFile(); 472 next_frame_sc.line_entry.original_file = 473 curr_inlined_block_inlined_info->GetCallSite().GetFile(); 474 next_frame_sc.line_entry.line = 475 curr_inlined_block_inlined_info->GetCallSite().GetLine(); 476 next_frame_sc.line_entry.column = 477 curr_inlined_block_inlined_info->GetCallSite().GetColumn(); 478 return true; 479 } else { 480 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_SYMBOLS)); 481 482 if (log) { 483 LLDB_LOGF( 484 log, 485 "warning: inlined block 0x%8.8" PRIx64 486 " doesn't have a range that contains file address 0x%" PRIx64, 487 curr_inlined_block->GetID(), curr_frame_pc.GetFileAddress()); 488 } 489 #ifdef LLDB_CONFIGURATION_DEBUG 490 else { 491 ObjectFile *objfile = nullptr; 492 if (module_sp) { 493 if (SymbolFile *symbol_file = module_sp->GetSymbolFile()) 494 objfile = symbol_file->GetObjectFile(); 495 } 496 if (objfile) { 497 Host::SystemLog( 498 Host::eSystemLogWarning, 499 "warning: inlined block 0x%8.8" PRIx64 500 " doesn't have a range that contains file address 0x%" PRIx64 501 " in %s\n", 502 curr_inlined_block->GetID(), curr_frame_pc.GetFileAddress(), 503 objfile->GetFileSpec().GetPath().c_str()); 504 } else { 505 Host::SystemLog( 506 Host::eSystemLogWarning, 507 "warning: inlined block 0x%8.8" PRIx64 508 " doesn't have a range that contains file address 0x%" PRIx64 509 "\n", 510 curr_inlined_block->GetID(), curr_frame_pc.GetFileAddress()); 511 } 512 } 513 #endif 514 } 515 } 516 } 517 518 return false; 519 } 520 521 Block *SymbolContext::GetFunctionBlock() { 522 if (function) { 523 if (block) { 524 // If this symbol context has a block, check to see if this block is 525 // itself, or is contained within a block with inlined function 526 // information. If so, then the inlined block is the block that defines 527 // the function. 528 Block *inlined_block = block->GetContainingInlinedBlock(); 529 if (inlined_block) 530 return inlined_block; 531 532 // The block in this symbol context is not inside an inlined block, so 533 // the block that defines the function is the function's top level block, 534 // which is returned below. 535 } 536 537 // There is no block information in this symbol context, so we must assume 538 // that the block that is desired is the top level block of the function 539 // itself. 540 return &function->GetBlock(true); 541 } 542 return nullptr; 543 } 544 545 bool SymbolContext::GetFunctionMethodInfo(lldb::LanguageType &language, 546 bool &is_instance_method, 547 ConstString &language_object_name) 548 549 { 550 Block *function_block = GetFunctionBlock(); 551 if (function_block) { 552 CompilerDeclContext decl_ctx = function_block->GetDeclContext(); 553 if (decl_ctx) 554 return decl_ctx.IsClassMethod(&language, &is_instance_method, 555 &language_object_name); 556 } 557 return false; 558 } 559 560 void SymbolContext::SortTypeList(TypeMap &type_map, TypeList &type_list) const { 561 Block *curr_block = block; 562 bool isInlinedblock = false; 563 if (curr_block != nullptr && 564 curr_block->GetContainingInlinedBlock() != nullptr) 565 isInlinedblock = true; 566 567 // Find all types that match the current block if we have one and put them 568 // first in the list. Keep iterating up through all blocks. 569 while (curr_block != nullptr && !isInlinedblock) { 570 type_map.ForEach( 571 [curr_block, &type_list](const lldb::TypeSP &type_sp) -> bool { 572 SymbolContextScope *scs = type_sp->GetSymbolContextScope(); 573 if (scs && curr_block == scs->CalculateSymbolContextBlock()) 574 type_list.Insert(type_sp); 575 return true; // Keep iterating 576 }); 577 578 // Remove any entries that are now in "type_list" from "type_map" since we 579 // can't remove from type_map while iterating 580 type_list.ForEach([&type_map](const lldb::TypeSP &type_sp) -> bool { 581 type_map.Remove(type_sp); 582 return true; // Keep iterating 583 }); 584 curr_block = curr_block->GetParent(); 585 } 586 // Find all types that match the current function, if we have onem, and put 587 // them next in the list. 588 if (function != nullptr && !type_map.Empty()) { 589 const size_t old_type_list_size = type_list.GetSize(); 590 type_map.ForEach([this, &type_list](const lldb::TypeSP &type_sp) -> bool { 591 SymbolContextScope *scs = type_sp->GetSymbolContextScope(); 592 if (scs && function == scs->CalculateSymbolContextFunction()) 593 type_list.Insert(type_sp); 594 return true; // Keep iterating 595 }); 596 597 // Remove any entries that are now in "type_list" from "type_map" since we 598 // can't remove from type_map while iterating 599 const size_t new_type_list_size = type_list.GetSize(); 600 if (new_type_list_size > old_type_list_size) { 601 for (size_t i = old_type_list_size; i < new_type_list_size; ++i) 602 type_map.Remove(type_list.GetTypeAtIndex(i)); 603 } 604 } 605 // Find all types that match the current compile unit, if we have one, and 606 // put them next in the list. 607 if (comp_unit != nullptr && !type_map.Empty()) { 608 const size_t old_type_list_size = type_list.GetSize(); 609 610 type_map.ForEach([this, &type_list](const lldb::TypeSP &type_sp) -> bool { 611 SymbolContextScope *scs = type_sp->GetSymbolContextScope(); 612 if (scs && comp_unit == scs->CalculateSymbolContextCompileUnit()) 613 type_list.Insert(type_sp); 614 return true; // Keep iterating 615 }); 616 617 // Remove any entries that are now in "type_list" from "type_map" since we 618 // can't remove from type_map while iterating 619 const size_t new_type_list_size = type_list.GetSize(); 620 if (new_type_list_size > old_type_list_size) { 621 for (size_t i = old_type_list_size; i < new_type_list_size; ++i) 622 type_map.Remove(type_list.GetTypeAtIndex(i)); 623 } 624 } 625 // Find all types that match the current module, if we have one, and put them 626 // next in the list. 627 if (module_sp && !type_map.Empty()) { 628 const size_t old_type_list_size = type_list.GetSize(); 629 type_map.ForEach([this, &type_list](const lldb::TypeSP &type_sp) -> bool { 630 SymbolContextScope *scs = type_sp->GetSymbolContextScope(); 631 if (scs && module_sp == scs->CalculateSymbolContextModule()) 632 type_list.Insert(type_sp); 633 return true; // Keep iterating 634 }); 635 // Remove any entries that are now in "type_list" from "type_map" since we 636 // can't remove from type_map while iterating 637 const size_t new_type_list_size = type_list.GetSize(); 638 if (new_type_list_size > old_type_list_size) { 639 for (size_t i = old_type_list_size; i < new_type_list_size; ++i) 640 type_map.Remove(type_list.GetTypeAtIndex(i)); 641 } 642 } 643 // Any types that are left get copied into the list an any order. 644 if (!type_map.Empty()) { 645 type_map.ForEach([&type_list](const lldb::TypeSP &type_sp) -> bool { 646 type_list.Insert(type_sp); 647 return true; // Keep iterating 648 }); 649 } 650 } 651 652 ConstString 653 SymbolContext::GetFunctionName(Mangled::NamePreference preference) const { 654 if (function) { 655 if (block) { 656 Block *inlined_block = block->GetContainingInlinedBlock(); 657 658 if (inlined_block) { 659 const InlineFunctionInfo *inline_info = 660 inlined_block->GetInlinedFunctionInfo(); 661 if (inline_info) 662 return inline_info->GetName(); 663 } 664 } 665 return function->GetMangled().GetName(preference); 666 } else if (symbol && symbol->ValueIsAddress()) { 667 return symbol->GetMangled().GetName(preference); 668 } else { 669 // No function, return an empty string. 670 return ConstString(); 671 } 672 } 673 674 LineEntry SymbolContext::GetFunctionStartLineEntry() const { 675 LineEntry line_entry; 676 Address start_addr; 677 if (block) { 678 Block *inlined_block = block->GetContainingInlinedBlock(); 679 if (inlined_block) { 680 if (inlined_block->GetStartAddress(start_addr)) { 681 if (start_addr.CalculateSymbolContextLineEntry(line_entry)) 682 return line_entry; 683 } 684 return LineEntry(); 685 } 686 } 687 688 if (function) { 689 if (function->GetAddressRange() 690 .GetBaseAddress() 691 .CalculateSymbolContextLineEntry(line_entry)) 692 return line_entry; 693 } 694 return LineEntry(); 695 } 696 697 bool SymbolContext::GetAddressRangeFromHereToEndLine(uint32_t end_line, 698 AddressRange &range, 699 Status &error) { 700 if (!line_entry.IsValid()) { 701 error.SetErrorString("Symbol context has no line table."); 702 return false; 703 } 704 705 range = line_entry.range; 706 if (line_entry.line > end_line) { 707 error.SetErrorStringWithFormat( 708 "end line option %d must be after the current line: %d", end_line, 709 line_entry.line); 710 return false; 711 } 712 713 uint32_t line_index = 0; 714 bool found = false; 715 while (true) { 716 LineEntry this_line; 717 line_index = comp_unit->FindLineEntry(line_index, line_entry.line, nullptr, 718 false, &this_line); 719 if (line_index == UINT32_MAX) 720 break; 721 if (LineEntry::Compare(this_line, line_entry) == 0) { 722 found = true; 723 break; 724 } 725 } 726 727 LineEntry end_entry; 728 if (!found) { 729 // Can't find the index of the SymbolContext's line entry in the 730 // SymbolContext's CompUnit. 731 error.SetErrorString( 732 "Can't find the current line entry in the CompUnit - can't process " 733 "the end-line option"); 734 return false; 735 } 736 737 line_index = comp_unit->FindLineEntry(line_index, end_line, nullptr, false, 738 &end_entry); 739 if (line_index == UINT32_MAX) { 740 error.SetErrorStringWithFormat( 741 "could not find a line table entry corresponding " 742 "to end line number %d", 743 end_line); 744 return false; 745 } 746 747 Block *func_block = GetFunctionBlock(); 748 if (func_block && func_block->GetRangeIndexContainingAddress( 749 end_entry.range.GetBaseAddress()) == UINT32_MAX) { 750 error.SetErrorStringWithFormat( 751 "end line number %d is not contained within the current function.", 752 end_line); 753 return false; 754 } 755 756 lldb::addr_t range_size = end_entry.range.GetBaseAddress().GetFileAddress() - 757 range.GetBaseAddress().GetFileAddress(); 758 range.SetByteSize(range_size); 759 return true; 760 } 761 762 const Symbol *SymbolContext::FindBestGlobalDataSymbol(ConstString name, 763 Status &error) { 764 error.Clear(); 765 766 if (!target_sp) { 767 return nullptr; 768 } 769 770 Target &target = *target_sp; 771 Module *module = module_sp.get(); 772 773 auto ProcessMatches = [this, &name, &target, 774 module](SymbolContextList &sc_list, 775 Status &error) -> const Symbol * { 776 llvm::SmallVector<const Symbol *, 1> external_symbols; 777 llvm::SmallVector<const Symbol *, 1> internal_symbols; 778 const uint32_t matches = sc_list.GetSize(); 779 for (uint32_t i = 0; i < matches; ++i) { 780 SymbolContext sym_ctx; 781 sc_list.GetContextAtIndex(i, sym_ctx); 782 if (sym_ctx.symbol) { 783 const Symbol *symbol = sym_ctx.symbol; 784 const Address sym_address = symbol->GetAddress(); 785 786 if (sym_address.IsValid()) { 787 switch (symbol->GetType()) { 788 case eSymbolTypeData: 789 case eSymbolTypeRuntime: 790 case eSymbolTypeAbsolute: 791 case eSymbolTypeObjCClass: 792 case eSymbolTypeObjCMetaClass: 793 case eSymbolTypeObjCIVar: 794 if (symbol->GetDemangledNameIsSynthesized()) { 795 // If the demangled name was synthesized, then don't use it for 796 // expressions. Only let the symbol match if the mangled named 797 // matches for these symbols. 798 if (symbol->GetMangled().GetMangledName() != name) 799 break; 800 } 801 if (symbol->IsExternal()) { 802 external_symbols.push_back(symbol); 803 } else { 804 internal_symbols.push_back(symbol); 805 } 806 break; 807 case eSymbolTypeReExported: { 808 ConstString reexport_name = symbol->GetReExportedSymbolName(); 809 if (reexport_name) { 810 ModuleSP reexport_module_sp; 811 ModuleSpec reexport_module_spec; 812 reexport_module_spec.GetPlatformFileSpec() = 813 symbol->GetReExportedSymbolSharedLibrary(); 814 if (reexport_module_spec.GetPlatformFileSpec()) { 815 reexport_module_sp = 816 target.GetImages().FindFirstModule(reexport_module_spec); 817 if (!reexport_module_sp) { 818 reexport_module_spec.GetPlatformFileSpec() 819 .GetDirectory() 820 .Clear(); 821 reexport_module_sp = 822 target.GetImages().FindFirstModule(reexport_module_spec); 823 } 824 } 825 // Don't allow us to try and resolve a re-exported symbol if it 826 // is the same as the current symbol 827 if (name == symbol->GetReExportedSymbolName() && 828 module == reexport_module_sp.get()) 829 return nullptr; 830 831 return FindBestGlobalDataSymbol(symbol->GetReExportedSymbolName(), 832 error); 833 } 834 } break; 835 836 case eSymbolTypeCode: // We already lookup functions elsewhere 837 case eSymbolTypeVariable: 838 case eSymbolTypeLocal: 839 case eSymbolTypeParam: 840 case eSymbolTypeTrampoline: 841 case eSymbolTypeInvalid: 842 case eSymbolTypeException: 843 case eSymbolTypeSourceFile: 844 case eSymbolTypeHeaderFile: 845 case eSymbolTypeObjectFile: 846 case eSymbolTypeCommonBlock: 847 case eSymbolTypeBlock: 848 case eSymbolTypeVariableType: 849 case eSymbolTypeLineEntry: 850 case eSymbolTypeLineHeader: 851 case eSymbolTypeScopeBegin: 852 case eSymbolTypeScopeEnd: 853 case eSymbolTypeAdditional: 854 case eSymbolTypeCompiler: 855 case eSymbolTypeInstrumentation: 856 case eSymbolTypeUndefined: 857 case eSymbolTypeResolver: 858 break; 859 } 860 } 861 } 862 } 863 864 if (external_symbols.size() > 1) { 865 StreamString ss; 866 ss.Printf("Multiple external symbols found for '%s'\n", name.AsCString()); 867 for (const Symbol *symbol : external_symbols) { 868 symbol->GetDescription(&ss, eDescriptionLevelFull, &target); 869 } 870 ss.PutChar('\n'); 871 error.SetErrorString(ss.GetData()); 872 return nullptr; 873 } else if (external_symbols.size()) { 874 return external_symbols[0]; 875 } else if (internal_symbols.size() > 1) { 876 StreamString ss; 877 ss.Printf("Multiple internal symbols found for '%s'\n", name.AsCString()); 878 for (const Symbol *symbol : internal_symbols) { 879 symbol->GetDescription(&ss, eDescriptionLevelVerbose, &target); 880 ss.PutChar('\n'); 881 } 882 error.SetErrorString(ss.GetData()); 883 return nullptr; 884 } else if (internal_symbols.size()) { 885 return internal_symbols[0]; 886 } else { 887 return nullptr; 888 } 889 }; 890 891 if (module) { 892 SymbolContextList sc_list; 893 module->FindSymbolsWithNameAndType(name, eSymbolTypeAny, sc_list); 894 const Symbol *const module_symbol = ProcessMatches(sc_list, error); 895 896 if (!error.Success()) { 897 return nullptr; 898 } else if (module_symbol) { 899 return module_symbol; 900 } 901 } 902 903 { 904 SymbolContextList sc_list; 905 target.GetImages().FindSymbolsWithNameAndType(name, eSymbolTypeAny, 906 sc_list); 907 const Symbol *const target_symbol = ProcessMatches(sc_list, error); 908 909 if (!error.Success()) { 910 return nullptr; 911 } else if (target_symbol) { 912 return target_symbol; 913 } 914 } 915 916 return nullptr; // no error; we just didn't find anything 917 } 918 919 // 920 // SymbolContextSpecifier 921 // 922 923 SymbolContextSpecifier::SymbolContextSpecifier(const TargetSP &target_sp) 924 : m_target_sp(target_sp), m_module_spec(), m_module_sp(), m_file_spec_up(), 925 m_start_line(0), m_end_line(0), m_function_spec(), m_class_name(), 926 m_address_range_up(), m_type(eNothingSpecified) {} 927 928 SymbolContextSpecifier::~SymbolContextSpecifier() = default; 929 930 bool SymbolContextSpecifier::AddLineSpecification(uint32_t line_no, 931 SpecificationType type) { 932 bool return_value = true; 933 switch (type) { 934 case eNothingSpecified: 935 Clear(); 936 break; 937 case eLineStartSpecified: 938 m_start_line = line_no; 939 m_type |= eLineStartSpecified; 940 break; 941 case eLineEndSpecified: 942 m_end_line = line_no; 943 m_type |= eLineEndSpecified; 944 break; 945 default: 946 return_value = false; 947 break; 948 } 949 return return_value; 950 } 951 952 bool SymbolContextSpecifier::AddSpecification(const char *spec_string, 953 SpecificationType type) { 954 bool return_value = true; 955 switch (type) { 956 case eNothingSpecified: 957 Clear(); 958 break; 959 case eModuleSpecified: { 960 // See if we can find the Module, if so stick it in the SymbolContext. 961 FileSpec module_file_spec(spec_string); 962 ModuleSpec module_spec(module_file_spec); 963 lldb::ModuleSP module_sp( 964 m_target_sp->GetImages().FindFirstModule(module_spec)); 965 m_type |= eModuleSpecified; 966 if (module_sp) 967 m_module_sp = module_sp; 968 else 969 m_module_spec.assign(spec_string); 970 } break; 971 case eFileSpecified: 972 // CompUnits can't necessarily be resolved here, since an inlined function 973 // might show up in a number of CompUnits. Instead we just convert to a 974 // FileSpec and store it away. 975 m_file_spec_up = std::make_unique<FileSpec>(spec_string); 976 m_type |= eFileSpecified; 977 break; 978 case eLineStartSpecified: 979 if ((return_value = llvm::to_integer(spec_string, m_start_line))) 980 m_type |= eLineStartSpecified; 981 break; 982 case eLineEndSpecified: 983 if ((return_value = llvm::to_integer(spec_string, m_end_line))) 984 m_type |= eLineEndSpecified; 985 break; 986 case eFunctionSpecified: 987 m_function_spec.assign(spec_string); 988 m_type |= eFunctionSpecified; 989 break; 990 case eClassOrNamespaceSpecified: 991 Clear(); 992 m_class_name.assign(spec_string); 993 m_type = eClassOrNamespaceSpecified; 994 break; 995 case eAddressRangeSpecified: 996 // Not specified yet... 997 break; 998 } 999 1000 return return_value; 1001 } 1002 1003 void SymbolContextSpecifier::Clear() { 1004 m_module_spec.clear(); 1005 m_file_spec_up.reset(); 1006 m_function_spec.clear(); 1007 m_class_name.clear(); 1008 m_start_line = 0; 1009 m_end_line = 0; 1010 m_address_range_up.reset(); 1011 1012 m_type = eNothingSpecified; 1013 } 1014 1015 bool SymbolContextSpecifier::SymbolContextMatches(const SymbolContext &sc) { 1016 if (m_type == eNothingSpecified) 1017 return true; 1018 1019 // Only compare targets if this specifier has one and it's not the Dummy 1020 // target. Otherwise if a specifier gets made in the dummy target and 1021 // copied over we'll artificially fail the comparision. 1022 if (m_target_sp && !m_target_sp->IsDummyTarget() && 1023 m_target_sp != sc.target_sp) 1024 return false; 1025 1026 if (m_type & eModuleSpecified) { 1027 if (sc.module_sp) { 1028 if (m_module_sp.get() != nullptr) { 1029 if (m_module_sp.get() != sc.module_sp.get()) 1030 return false; 1031 } else { 1032 FileSpec module_file_spec(m_module_spec); 1033 if (!FileSpec::Match(module_file_spec, sc.module_sp->GetFileSpec())) 1034 return false; 1035 } 1036 } 1037 } 1038 if (m_type & eFileSpecified) { 1039 if (m_file_spec_up) { 1040 // If we don't have a block or a comp_unit, then we aren't going to match 1041 // a source file. 1042 if (sc.block == nullptr && sc.comp_unit == nullptr) 1043 return false; 1044 1045 // Check if the block is present, and if so is it inlined: 1046 bool was_inlined = false; 1047 if (sc.block != nullptr) { 1048 const InlineFunctionInfo *inline_info = 1049 sc.block->GetInlinedFunctionInfo(); 1050 if (inline_info != nullptr) { 1051 was_inlined = true; 1052 if (!FileSpec::Match(*m_file_spec_up, 1053 inline_info->GetDeclaration().GetFile())) 1054 return false; 1055 } 1056 } 1057 1058 // Next check the comp unit, but only if the SymbolContext was not 1059 // inlined. 1060 if (!was_inlined && sc.comp_unit != nullptr) { 1061 if (!FileSpec::Match(*m_file_spec_up, sc.comp_unit->GetPrimaryFile())) 1062 return false; 1063 } 1064 } 1065 } 1066 if (m_type & eLineStartSpecified || m_type & eLineEndSpecified) { 1067 if (sc.line_entry.line < m_start_line || sc.line_entry.line > m_end_line) 1068 return false; 1069 } 1070 1071 if (m_type & eFunctionSpecified) { 1072 // First check the current block, and if it is inlined, get the inlined 1073 // function name: 1074 bool was_inlined = false; 1075 ConstString func_name(m_function_spec.c_str()); 1076 1077 if (sc.block != nullptr) { 1078 const InlineFunctionInfo *inline_info = 1079 sc.block->GetInlinedFunctionInfo(); 1080 if (inline_info != nullptr) { 1081 was_inlined = true; 1082 const Mangled &name = inline_info->GetMangled(); 1083 if (!name.NameMatches(func_name)) 1084 return false; 1085 } 1086 } 1087 // If it wasn't inlined, check the name in the function or symbol: 1088 if (!was_inlined) { 1089 if (sc.function != nullptr) { 1090 if (!sc.function->GetMangled().NameMatches(func_name)) 1091 return false; 1092 } else if (sc.symbol != nullptr) { 1093 if (!sc.symbol->GetMangled().NameMatches(func_name)) 1094 return false; 1095 } 1096 } 1097 } 1098 1099 return true; 1100 } 1101 1102 bool SymbolContextSpecifier::AddressMatches(lldb::addr_t addr) { 1103 if (m_type & eAddressRangeSpecified) { 1104 1105 } else { 1106 Address match_address(addr, nullptr); 1107 SymbolContext sc; 1108 m_target_sp->GetImages().ResolveSymbolContextForAddress( 1109 match_address, eSymbolContextEverything, sc); 1110 return SymbolContextMatches(sc); 1111 } 1112 return true; 1113 } 1114 1115 void SymbolContextSpecifier::GetDescription( 1116 Stream *s, lldb::DescriptionLevel level) const { 1117 char path_str[PATH_MAX + 1]; 1118 1119 if (m_type == eNothingSpecified) { 1120 s->Printf("Nothing specified.\n"); 1121 } 1122 1123 if (m_type == eModuleSpecified) { 1124 s->Indent(); 1125 if (m_module_sp) { 1126 m_module_sp->GetFileSpec().GetPath(path_str, PATH_MAX); 1127 s->Printf("Module: %s\n", path_str); 1128 } else 1129 s->Printf("Module: %s\n", m_module_spec.c_str()); 1130 } 1131 1132 if (m_type == eFileSpecified && m_file_spec_up != nullptr) { 1133 m_file_spec_up->GetPath(path_str, PATH_MAX); 1134 s->Indent(); 1135 s->Printf("File: %s", path_str); 1136 if (m_type == eLineStartSpecified) { 1137 s->Printf(" from line %" PRIu64 "", (uint64_t)m_start_line); 1138 if (m_type == eLineEndSpecified) 1139 s->Printf("to line %" PRIu64 "", (uint64_t)m_end_line); 1140 else 1141 s->Printf("to end"); 1142 } else if (m_type == eLineEndSpecified) { 1143 s->Printf(" from start to line %" PRIu64 "", (uint64_t)m_end_line); 1144 } 1145 s->Printf(".\n"); 1146 } 1147 1148 if (m_type == eLineStartSpecified) { 1149 s->Indent(); 1150 s->Printf("From line %" PRIu64 "", (uint64_t)m_start_line); 1151 if (m_type == eLineEndSpecified) 1152 s->Printf("to line %" PRIu64 "", (uint64_t)m_end_line); 1153 else 1154 s->Printf("to end"); 1155 s->Printf(".\n"); 1156 } else if (m_type == eLineEndSpecified) { 1157 s->Printf("From start to line %" PRIu64 ".\n", (uint64_t)m_end_line); 1158 } 1159 1160 if (m_type == eFunctionSpecified) { 1161 s->Indent(); 1162 s->Printf("Function: %s.\n", m_function_spec.c_str()); 1163 } 1164 1165 if (m_type == eClassOrNamespaceSpecified) { 1166 s->Indent(); 1167 s->Printf("Class name: %s.\n", m_class_name.c_str()); 1168 } 1169 1170 if (m_type == eAddressRangeSpecified && m_address_range_up != nullptr) { 1171 s->Indent(); 1172 s->PutCString("Address range: "); 1173 m_address_range_up->Dump(s, m_target_sp.get(), 1174 Address::DumpStyleLoadAddress, 1175 Address::DumpStyleFileAddress); 1176 s->PutCString("\n"); 1177 } 1178 } 1179 1180 // 1181 // SymbolContextList 1182 // 1183 1184 SymbolContextList::SymbolContextList() : m_symbol_contexts() {} 1185 1186 SymbolContextList::~SymbolContextList() = default; 1187 1188 void SymbolContextList::Append(const SymbolContext &sc) { 1189 m_symbol_contexts.push_back(sc); 1190 } 1191 1192 void SymbolContextList::Append(const SymbolContextList &sc_list) { 1193 collection::const_iterator pos, end = sc_list.m_symbol_contexts.end(); 1194 for (pos = sc_list.m_symbol_contexts.begin(); pos != end; ++pos) 1195 m_symbol_contexts.push_back(*pos); 1196 } 1197 1198 uint32_t SymbolContextList::AppendIfUnique(const SymbolContextList &sc_list, 1199 bool merge_symbol_into_function) { 1200 uint32_t unique_sc_add_count = 0; 1201 collection::const_iterator pos, end = sc_list.m_symbol_contexts.end(); 1202 for (pos = sc_list.m_symbol_contexts.begin(); pos != end; ++pos) { 1203 if (AppendIfUnique(*pos, merge_symbol_into_function)) 1204 ++unique_sc_add_count; 1205 } 1206 return unique_sc_add_count; 1207 } 1208 1209 bool SymbolContextList::AppendIfUnique(const SymbolContext &sc, 1210 bool merge_symbol_into_function) { 1211 collection::iterator pos, end = m_symbol_contexts.end(); 1212 for (pos = m_symbol_contexts.begin(); pos != end; ++pos) { 1213 if (*pos == sc) 1214 return false; 1215 } 1216 if (merge_symbol_into_function && sc.symbol != nullptr && 1217 sc.comp_unit == nullptr && sc.function == nullptr && 1218 sc.block == nullptr && !sc.line_entry.IsValid()) { 1219 if (sc.symbol->ValueIsAddress()) { 1220 for (pos = m_symbol_contexts.begin(); pos != end; ++pos) { 1221 // Don't merge symbols into inlined function symbol contexts 1222 if (pos->block && pos->block->GetContainingInlinedBlock()) 1223 continue; 1224 1225 if (pos->function) { 1226 if (pos->function->GetAddressRange().GetBaseAddress() == 1227 sc.symbol->GetAddressRef()) { 1228 // Do we already have a function with this symbol? 1229 if (pos->symbol == sc.symbol) 1230 return false; 1231 if (pos->symbol == nullptr) { 1232 pos->symbol = sc.symbol; 1233 return false; 1234 } 1235 } 1236 } 1237 } 1238 } 1239 } 1240 m_symbol_contexts.push_back(sc); 1241 return true; 1242 } 1243 1244 void SymbolContextList::Clear() { m_symbol_contexts.clear(); } 1245 1246 void SymbolContextList::Dump(Stream *s, Target *target) const { 1247 1248 *s << this << ": "; 1249 s->Indent(); 1250 s->PutCString("SymbolContextList"); 1251 s->EOL(); 1252 s->IndentMore(); 1253 1254 collection::const_iterator pos, end = m_symbol_contexts.end(); 1255 for (pos = m_symbol_contexts.begin(); pos != end; ++pos) { 1256 // pos->Dump(s, target); 1257 pos->GetDescription(s, eDescriptionLevelVerbose, target); 1258 } 1259 s->IndentLess(); 1260 } 1261 1262 bool SymbolContextList::GetContextAtIndex(size_t idx, SymbolContext &sc) const { 1263 if (idx < m_symbol_contexts.size()) { 1264 sc = m_symbol_contexts[idx]; 1265 return true; 1266 } 1267 return false; 1268 } 1269 1270 bool SymbolContextList::RemoveContextAtIndex(size_t idx) { 1271 if (idx < m_symbol_contexts.size()) { 1272 m_symbol_contexts.erase(m_symbol_contexts.begin() + idx); 1273 return true; 1274 } 1275 return false; 1276 } 1277 1278 uint32_t SymbolContextList::GetSize() const { return m_symbol_contexts.size(); } 1279 1280 bool SymbolContextList::IsEmpty() const { return m_symbol_contexts.empty(); } 1281 1282 uint32_t SymbolContextList::NumLineEntriesWithLine(uint32_t line) const { 1283 uint32_t match_count = 0; 1284 const size_t size = m_symbol_contexts.size(); 1285 for (size_t idx = 0; idx < size; ++idx) { 1286 if (m_symbol_contexts[idx].line_entry.line == line) 1287 ++match_count; 1288 } 1289 return match_count; 1290 } 1291 1292 void SymbolContextList::GetDescription(Stream *s, lldb::DescriptionLevel level, 1293 Target *target) const { 1294 const size_t size = m_symbol_contexts.size(); 1295 for (size_t idx = 0; idx < size; ++idx) 1296 m_symbol_contexts[idx].GetDescription(s, level, target); 1297 } 1298 1299 bool lldb_private::operator==(const SymbolContextList &lhs, 1300 const SymbolContextList &rhs) { 1301 const uint32_t size = lhs.GetSize(); 1302 if (size != rhs.GetSize()) 1303 return false; 1304 1305 SymbolContext lhs_sc; 1306 SymbolContext rhs_sc; 1307 for (uint32_t i = 0; i < size; ++i) { 1308 lhs.GetContextAtIndex(i, lhs_sc); 1309 rhs.GetContextAtIndex(i, rhs_sc); 1310 if (lhs_sc != rhs_sc) 1311 return false; 1312 } 1313 return true; 1314 } 1315 1316 bool lldb_private::operator!=(const SymbolContextList &lhs, 1317 const SymbolContextList &rhs) { 1318 return !(lhs == rhs); 1319 } 1320