1 //===-- SymbolContext.cpp ---------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "lldb/Symbol/SymbolContext.h"
12 #include "lldb/Core/Log.h"
13 #include "lldb/Core/Module.h"
14 #include "lldb/Core/ModuleSpec.h"
15 #include "lldb/Host/Host.h"
16 #include "lldb/Host/StringConvert.h"
17 #include "lldb/Symbol/Block.h"
18 #include "lldb/Symbol/ClangASTContext.h"
19 #include "lldb/Symbol/CompileUnit.h"
20 #include "lldb/Symbol/ObjectFile.h"
21 #include "lldb/Symbol/Symbol.h"
22 #include "lldb/Symbol/SymbolFile.h"
23 #include "lldb/Symbol/SymbolVendor.h"
24 #include "lldb/Symbol/Variable.h"
25 #include "lldb/Target/Target.h"
28 using namespace lldb_private;
30 SymbolContext::SymbolContext() :
42 SymbolContext::SymbolContext(const ModuleSP& m, CompileUnit *cu, Function *f, Block *b, LineEntry *le, Symbol *s) :
56 SymbolContext::SymbolContext(const TargetSP &t, const ModuleSP& m, CompileUnit *cu, Function *f, Block *b, LineEntry *le, Symbol *s) :
70 SymbolContext::SymbolContext(const SymbolContext& rhs) :
71 target_sp (rhs.target_sp),
72 module_sp (rhs.module_sp),
73 comp_unit (rhs.comp_unit),
74 function (rhs.function),
76 line_entry (rhs.line_entry),
78 variable (rhs.variable)
83 SymbolContext::SymbolContext (SymbolContextScope *sc_scope) :
93 sc_scope->CalculateSymbolContext (this);
96 SymbolContext::~SymbolContext ()
101 SymbolContext::operator= (const SymbolContext& rhs)
105 target_sp = rhs.target_sp;
106 module_sp = rhs.module_sp;
107 comp_unit = rhs.comp_unit;
108 function = rhs.function;
110 line_entry = rhs.line_entry;
112 variable = rhs.variable;
118 SymbolContext::Clear(bool clear_target)
132 SymbolContext::DumpStopContext (
134 ExecutionContextScope *exe_scope,
138 bool show_inlined_frames,
139 bool show_function_arguments,
140 bool show_function_name
143 bool dumped_something = false;
144 if (show_module && module_sp)
147 *s << module_sp->GetFileSpec();
149 *s << module_sp->GetFileSpec().GetFilename();
151 dumped_something = true;
154 if (function != nullptr)
156 SymbolContext inline_parent_sc;
157 Address inline_parent_addr;
158 if (show_function_name == false)
161 dumped_something = true;
163 else if (show_function_arguments == false && function->GetMangled().GetName(Mangled::ePreferDemangledWithoutArguments))
165 dumped_something = true;
166 function->GetMangled().GetName(Mangled::ePreferDemangledWithoutArguments).Dump(s);
168 else if (function->GetMangled().GetName())
170 dumped_something = true;
171 function->GetMangled().GetName().Dump(s);
176 const addr_t function_offset = addr.GetOffset() - function->GetAddressRange().GetBaseAddress().GetOffset();
177 if (show_function_name == false)
179 // Print +offset even if offset is 0
180 dumped_something = true;
181 s->Printf("+%" PRIu64 ">", function_offset);
183 else if (function_offset)
185 dumped_something = true;
186 s->Printf(" + %" PRIu64, function_offset);
190 if (GetParentOfInlinedScope (addr, inline_parent_sc, inline_parent_addr))
192 dumped_something = true;
193 Block *inlined_block = block->GetContainingInlinedBlock();
194 const InlineFunctionInfo* inlined_block_info = inlined_block->GetInlinedFunctionInfo();
195 s->Printf (" [inlined] %s", inlined_block_info->GetName().GetCString());
197 lldb_private::AddressRange block_range;
198 if (inlined_block->GetRangeContainingAddress(addr, block_range))
200 const addr_t inlined_function_offset = addr.GetOffset() - block_range.GetBaseAddress().GetOffset();
201 if (inlined_function_offset)
203 s->Printf(" + %" PRIu64, inlined_function_offset);
206 const Declaration &call_site = inlined_block_info->GetCallSite();
207 if (call_site.IsValid())
209 s->PutCString(" at ");
210 call_site.DumpStopContext (s, show_fullpaths);
212 if (show_inlined_frames)
216 const bool show_function_name = true;
217 return inline_parent_sc.DumpStopContext (s, exe_scope, inline_parent_addr, show_fullpaths, show_module, show_inlined_frames, show_function_arguments, show_function_name);
222 if (line_entry.IsValid())
224 dumped_something = true;
225 s->PutCString(" at ");
226 if (line_entry.DumpStopContext(s, show_fullpaths))
227 dumped_something = true;
231 else if (symbol != nullptr)
233 if (show_function_name == false)
236 dumped_something = true;
238 else if (symbol->GetMangled().GetName())
240 dumped_something = true;
241 if (symbol->GetType() == eSymbolTypeTrampoline)
242 s->PutCString("symbol stub for: ");
243 symbol->GetMangled().GetName().Dump(s);
246 if (addr.IsValid() && symbol->ValueIsAddress())
248 const addr_t symbol_offset = addr.GetOffset() - symbol->GetAddressRef().GetOffset();
249 if (show_function_name == false)
251 // Print +offset even if offset is 0
252 dumped_something = true;
253 s->Printf("+%" PRIu64 ">", symbol_offset);
255 else if (symbol_offset)
257 dumped_something = true;
258 s->Printf(" + %" PRIu64, symbol_offset);
262 else if (addr.IsValid())
264 addr.Dump(s, exe_scope, Address::DumpStyleModuleWithFileAddress);
265 dumped_something = true;
267 return dumped_something;
271 SymbolContext::GetDescription(Stream *s, lldb::DescriptionLevel level, Target *target) const
275 s->Indent(" Module: file = \"");
276 module_sp->GetFileSpec().Dump(s);
278 if (module_sp->GetArchitecture().IsValid())
279 s->Printf (", arch = \"%s\"", module_sp->GetArchitecture().GetArchitectureName());
283 if (comp_unit != nullptr)
285 s->Indent("CompileUnit: ");
286 comp_unit->GetDescription (s, level);
290 if (function != nullptr)
292 s->Indent(" Function: ");
293 function->GetDescription (s, level, target);
296 Type *func_type = function->GetType();
299 s->Indent(" FuncType: ");
300 func_type->GetDescription (s, level, false);
305 if (block != nullptr)
307 std::vector<Block *> blocks;
308 blocks.push_back (block);
309 Block *parent_block = block->GetParent();
313 blocks.push_back (parent_block);
314 parent_block = parent_block->GetParent();
316 std::vector<Block *>::reverse_iterator pos;
317 std::vector<Block *>::reverse_iterator begin = blocks.rbegin();
318 std::vector<Block *>::reverse_iterator end = blocks.rend();
319 for (pos = begin; pos != end; ++pos)
322 s->Indent(" Blocks: ");
325 (*pos)->GetDescription(s, function, level, target);
330 if (line_entry.IsValid())
332 s->Indent(" LineEntry: ");
333 line_entry.GetDescription (s, level, comp_unit, target, false);
337 if (symbol != nullptr)
339 s->Indent(" Symbol: ");
340 symbol->GetDescription(s, level, target);
344 if (variable != nullptr)
346 s->Indent(" Variable: ");
348 s->Printf("id = {0x%8.8" PRIx64 "}, ", variable->GetID());
350 switch (variable->GetScope())
352 case eValueTypeVariableGlobal:
353 s->PutCString("kind = global, ");
356 case eValueTypeVariableStatic:
357 s->PutCString("kind = static, ");
360 case eValueTypeVariableArgument:
361 s->PutCString("kind = argument, ");
364 case eValueTypeVariableLocal:
365 s->PutCString("kind = local, ");
372 s->Printf ("name = \"%s\"\n", variable->GetName().GetCString());
377 SymbolContext::GetResolvedMask () const
379 uint32_t resolved_mask = 0;
380 if (target_sp) resolved_mask |= eSymbolContextTarget;
381 if (module_sp) resolved_mask |= eSymbolContextModule;
382 if (comp_unit) resolved_mask |= eSymbolContextCompUnit;
383 if (function) resolved_mask |= eSymbolContextFunction;
384 if (block) resolved_mask |= eSymbolContextBlock;
385 if (line_entry.IsValid()) resolved_mask |= eSymbolContextLineEntry;
386 if (symbol) resolved_mask |= eSymbolContextSymbol;
387 if (variable) resolved_mask |= eSymbolContextVariable;
388 return resolved_mask;
392 SymbolContext::Dump(Stream *s, Target *target) const
394 *s << (void *)this << ": ";
396 s->PutCString("SymbolContext");
401 *s << "Module = " << (void *)module_sp.get() << ' ';
403 module_sp->GetFileSpec().Dump(s);
406 *s << "CompileUnit = " << (void *)comp_unit;
407 if (comp_unit != nullptr)
408 *s << " {0x" << comp_unit->GetID() << "} " << *(static_cast<FileSpec*> (comp_unit));
411 *s << "Function = " << (void *)function;
412 if (function != nullptr)
414 *s << " {0x" << function->GetID() << "} " << function->GetType()->GetName() << ", address-range = ";
415 function->GetAddressRange().Dump(s, target, Address::DumpStyleLoadAddress, Address::DumpStyleModuleWithFileAddress);
418 Type* func_type = function->GetType();
422 func_type->Dump (s, false);
427 *s << "Block = " << (void *)block;
428 if (block != nullptr)
429 *s << " {0x" << block->GetID() << '}';
430 // Dump the block and pass it a negative depth to we print all the parent blocks
432 // block->Dump(s, function->GetFileAddress(), INT_MIN);
435 *s << "LineEntry = ";
436 line_entry.Dump (s, target, true, Address::DumpStyleLoadAddress, Address::DumpStyleModuleWithFileAddress, true);
439 *s << "Symbol = " << (void *)symbol;
440 if (symbol != nullptr && symbol->GetMangled())
441 *s << ' ' << symbol->GetMangled().GetName().AsCString();
443 *s << "Variable = " << (void *)variable;
444 if (variable != nullptr)
446 *s << " {0x" << variable->GetID() << "} " << variable->GetType()->GetName();
454 lldb_private::operator== (const SymbolContext& lhs, const SymbolContext& rhs)
456 return lhs.function == rhs.function
457 && lhs.symbol == rhs.symbol
458 && lhs.module_sp.get() == rhs.module_sp.get()
459 && lhs.comp_unit == rhs.comp_unit
460 && lhs.target_sp.get() == rhs.target_sp.get()
461 && LineEntry::Compare(lhs.line_entry, rhs.line_entry) == 0
462 && lhs.variable == rhs.variable;
466 lldb_private::operator!= (const SymbolContext& lhs, const SymbolContext& rhs)
468 return lhs.function != rhs.function
469 || lhs.symbol != rhs.symbol
470 || lhs.module_sp.get() != rhs.module_sp.get()
471 || lhs.comp_unit != rhs.comp_unit
472 || lhs.target_sp.get() != rhs.target_sp.get()
473 || LineEntry::Compare(lhs.line_entry, rhs.line_entry) != 0
474 || lhs.variable != rhs.variable;
478 SymbolContext::GetAddressRange (uint32_t scope,
480 bool use_inline_block_range,
481 AddressRange &range) const
483 if ((scope & eSymbolContextLineEntry) && line_entry.IsValid())
485 range = line_entry.range;
489 if ((scope & eSymbolContextBlock) && (block != nullptr))
491 if (use_inline_block_range)
493 Block *inline_block = block->GetContainingInlinedBlock();
495 return inline_block->GetRangeAtIndex (range_idx, range);
499 return block->GetRangeAtIndex (range_idx, range);
503 if ((scope & eSymbolContextFunction) && (function != nullptr))
507 range = function->GetAddressRange();
512 if ((scope & eSymbolContextSymbol) && (symbol != nullptr))
516 if (symbol->ValueIsAddress())
518 range.GetBaseAddress() = symbol->GetAddressRef();
519 range.SetByteSize (symbol->GetByteSize());
529 SymbolContext::GetParentOfInlinedScope (const Address &curr_frame_pc,
530 SymbolContext &next_frame_sc,
531 Address &next_frame_pc) const
533 next_frame_sc.Clear(false);
534 next_frame_pc.Clear();
538 //const addr_t curr_frame_file_addr = curr_frame_pc.GetFileAddress();
540 // In order to get the parent of an inlined function we first need to
541 // see if we are in an inlined block as "this->block" could be an
542 // inlined block, or a parent of "block" could be. So lets check if
543 // this block or one of this blocks parents is an inlined function.
544 Block *curr_inlined_block = block->GetContainingInlinedBlock();
545 if (curr_inlined_block)
547 // "this->block" is contained in an inline function block, so to
548 // get the scope above the inlined block, we get the parent of the
549 // inlined block itself
550 Block *next_frame_block = curr_inlined_block->GetParent();
551 // Now calculate the symbol context of the containing block
552 next_frame_block->CalculateSymbolContext (&next_frame_sc);
554 // If we get here we weren't able to find the return line entry using the nesting of the blocks and
555 // the line table. So just use the call site info from our inlined block.
558 if (curr_inlined_block->GetRangeContainingAddress (curr_frame_pc, range))
560 // To see there this new frame block it, we need to look at the
561 // call site information from
562 const InlineFunctionInfo* curr_inlined_block_inlined_info = curr_inlined_block->GetInlinedFunctionInfo();
563 next_frame_pc = range.GetBaseAddress();
564 next_frame_sc.line_entry.range.GetBaseAddress() = next_frame_pc;
565 next_frame_sc.line_entry.file = curr_inlined_block_inlined_info->GetCallSite().GetFile();
566 next_frame_sc.line_entry.line = curr_inlined_block_inlined_info->GetCallSite().GetLine();
567 next_frame_sc.line_entry.column = curr_inlined_block_inlined_info->GetCallSite().GetColumn();
572 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_SYMBOLS));
576 log->Printf ("warning: inlined block 0x%8.8" PRIx64 " doesn't have a range that contains file address 0x%" PRIx64,
577 curr_inlined_block->GetID(), curr_frame_pc.GetFileAddress());
579 #ifdef LLDB_CONFIGURATION_DEBUG
582 ObjectFile *objfile = NULL;
585 SymbolVendor *symbol_vendor = module_sp->GetSymbolVendor();
588 SymbolFile *symbol_file = symbol_vendor->GetSymbolFile();
590 objfile = symbol_file->GetObjectFile();
595 Host::SystemLog (Host::eSystemLogWarning,
596 "warning: inlined block 0x%8.8" PRIx64 " doesn't have a range that contains file address 0x%" PRIx64 " in %s\n",
597 curr_inlined_block->GetID(),
598 curr_frame_pc.GetFileAddress(),
599 objfile->GetFileSpec().GetPath().c_str());
603 Host::SystemLog (Host::eSystemLogWarning,
604 "warning: inlined block 0x%8.8" PRIx64 " doesn't have a range that contains file address 0x%" PRIx64 "\n",
605 curr_inlined_block->GetID(),
606 curr_frame_pc.GetFileAddress());
618 SymbolContext::GetFunctionBlock ()
624 // If this symbol context has a block, check to see if this block
625 // is itself, or is contained within a block with inlined function
626 // information. If so, then the inlined block is the block that
627 // defines the function.
628 Block *inlined_block = block->GetContainingInlinedBlock();
630 return inlined_block;
632 // The block in this symbol context is not inside an inlined
633 // block, so the block that defines the function is the function's
634 // top level block, which is returned below.
637 // There is no block information in this symbol context, so we must
638 // assume that the block that is desired is the top level block of
639 // the function itself.
640 return &function->GetBlock(true);
646 SymbolContext::GetFunctionMethodInfo (lldb::LanguageType &language,
647 bool &is_instance_method,
648 ConstString &language_object_name)
652 Block *function_block = GetFunctionBlock ();
655 clang::DeclContext *decl_context = function_block->GetClangDeclContext();
659 return ClangASTContext::GetClassMethodInfoForDeclContext (decl_context,
662 language_object_name);
665 language = eLanguageTypeUnknown;
666 is_instance_method = false;
667 language_object_name.Clear();
672 SymbolContext::GetFunctionName (Mangled::NamePreference preference) const
678 Block *inlined_block = block->GetContainingInlinedBlock();
682 const InlineFunctionInfo *inline_info = inlined_block->GetInlinedFunctionInfo();
684 return inline_info->GetName();
687 return function->GetMangled().GetName(preference);
689 else if (symbol && symbol->ValueIsAddress())
691 return symbol->GetMangled().GetName(preference);
695 // No function, return an empty string.
696 return ConstString();
701 SymbolContext::GetFunctionStartLineEntry () const
703 LineEntry line_entry;
707 Block *inlined_block = block->GetContainingInlinedBlock();
710 if (inlined_block->GetStartAddress (start_addr))
712 if (start_addr.CalculateSymbolContextLineEntry (line_entry))
721 if (function->GetAddressRange().GetBaseAddress().CalculateSymbolContextLineEntry(line_entry))
727 //----------------------------------------------------------------------
729 // SymbolContextSpecifier
731 //----------------------------------------------------------------------
733 SymbolContextSpecifier::SymbolContextSpecifier (const TargetSP &target_sp) :
734 m_target_sp (target_sp),
742 m_address_range_ap (),
743 m_type (eNothingSpecified)
747 SymbolContextSpecifier::~SymbolContextSpecifier()
752 SymbolContextSpecifier::AddLineSpecification (uint32_t line_no, SpecificationType type)
754 bool return_value = true;
757 case eNothingSpecified:
760 case eLineStartSpecified:
761 m_start_line = line_no;
762 m_type |= eLineStartSpecified;
764 case eLineEndSpecified:
765 m_end_line = line_no;
766 m_type |= eLineEndSpecified;
769 return_value = false;
776 SymbolContextSpecifier::AddSpecification (const char *spec_string, SpecificationType type)
778 bool return_value = true;
781 case eNothingSpecified:
784 case eModuleSpecified:
786 // See if we can find the Module, if so stick it in the SymbolContext.
787 FileSpec module_file_spec(spec_string, false);
788 ModuleSpec module_spec (module_file_spec);
789 lldb::ModuleSP module_sp (m_target_sp->GetImages().FindFirstModule (module_spec));
790 m_type |= eModuleSpecified;
792 m_module_sp = module_sp;
794 m_module_spec.assign (spec_string);
798 // CompUnits can't necessarily be resolved here, since an inlined function might show up in
799 // a number of CompUnits. Instead we just convert to a FileSpec and store it away.
800 m_file_spec_ap.reset (new FileSpec (spec_string, false));
801 m_type |= eFileSpecified;
803 case eLineStartSpecified:
804 m_start_line = StringConvert::ToSInt32(spec_string, 0, 0, &return_value);
806 m_type |= eLineStartSpecified;
808 case eLineEndSpecified:
809 m_end_line = StringConvert::ToSInt32(spec_string, 0, 0, &return_value);
811 m_type |= eLineEndSpecified;
813 case eFunctionSpecified:
814 m_function_spec.assign(spec_string);
815 m_type |= eFunctionSpecified;
817 case eClassOrNamespaceSpecified:
819 m_class_name.assign (spec_string);
820 m_type = eClassOrNamespaceSpecified;
822 case eAddressRangeSpecified:
823 // Not specified yet...
831 SymbolContextSpecifier::Clear()
833 m_module_spec.clear();
834 m_file_spec_ap.reset();
835 m_function_spec.clear();
836 m_class_name.clear();
839 m_address_range_ap.reset();
841 m_type = eNothingSpecified;
845 SymbolContextSpecifier::SymbolContextMatches(SymbolContext &sc)
847 if (m_type == eNothingSpecified)
850 if (m_target_sp.get() != sc.target_sp.get())
853 if (m_type & eModuleSpecified)
857 if (m_module_sp.get() != nullptr)
859 if (m_module_sp.get() != sc.module_sp.get())
864 FileSpec module_file_spec (m_module_spec.c_str(), false);
865 if (!FileSpec::Equal (module_file_spec, sc.module_sp->GetFileSpec(), false))
870 if (m_type & eFileSpecified)
872 if (m_file_spec_ap.get())
874 // If we don't have a block or a comp_unit, then we aren't going to match a source file.
875 if (sc.block == nullptr && sc.comp_unit == nullptr)
878 // Check if the block is present, and if so is it inlined:
879 bool was_inlined = false;
880 if (sc.block != nullptr)
882 const InlineFunctionInfo *inline_info = sc.block->GetInlinedFunctionInfo();
883 if (inline_info != nullptr)
886 if (!FileSpec::Equal (inline_info->GetDeclaration().GetFile(), *(m_file_spec_ap.get()), false))
891 // Next check the comp unit, but only if the SymbolContext was not inlined.
892 if (!was_inlined && sc.comp_unit != nullptr)
894 if (!FileSpec::Equal (*(sc.comp_unit), *(m_file_spec_ap.get()), false))
899 if (m_type & eLineStartSpecified
900 || m_type & eLineEndSpecified)
902 if (sc.line_entry.line < m_start_line || sc.line_entry.line > m_end_line)
906 if (m_type & eFunctionSpecified)
908 // First check the current block, and if it is inlined, get the inlined function name:
909 bool was_inlined = false;
910 ConstString func_name(m_function_spec.c_str());
912 if (sc.block != nullptr)
914 const InlineFunctionInfo *inline_info = sc.block->GetInlinedFunctionInfo();
915 if (inline_info != nullptr)
918 const Mangled &name = inline_info->GetMangled();
919 if (!name.NameMatches (func_name))
923 // If it wasn't inlined, check the name in the function or symbol:
926 if (sc.function != nullptr)
928 if (!sc.function->GetMangled().NameMatches(func_name))
931 else if (sc.symbol != nullptr)
933 if (!sc.symbol->GetMangled().NameMatches(func_name))
945 SymbolContextSpecifier::AddressMatches(lldb::addr_t addr)
947 if (m_type & eAddressRangeSpecified)
953 Address match_address (addr, nullptr);
955 m_target_sp->GetImages().ResolveSymbolContextForAddress(match_address, eSymbolContextEverything, sc);
956 return SymbolContextMatches(sc);
962 SymbolContextSpecifier::GetDescription (Stream *s, lldb::DescriptionLevel level) const
964 char path_str[PATH_MAX + 1];
966 if (m_type == eNothingSpecified)
968 s->Printf ("Nothing specified.\n");
971 if (m_type == eModuleSpecified)
976 m_module_sp->GetFileSpec().GetPath (path_str, PATH_MAX);
977 s->Printf ("Module: %s\n", path_str);
980 s->Printf ("Module: %s\n", m_module_spec.c_str());
983 if (m_type == eFileSpecified && m_file_spec_ap.get() != nullptr)
985 m_file_spec_ap->GetPath (path_str, PATH_MAX);
987 s->Printf ("File: %s", path_str);
988 if (m_type == eLineStartSpecified)
990 s->Printf (" from line %" PRIu64 "", (uint64_t)m_start_line);
991 if (m_type == eLineEndSpecified)
992 s->Printf ("to line %" PRIu64 "", (uint64_t)m_end_line);
994 s->Printf ("to end");
996 else if (m_type == eLineEndSpecified)
998 s->Printf (" from start to line %" PRIu64 "", (uint64_t)m_end_line);
1003 if (m_type == eLineStartSpecified)
1006 s->Printf ("From line %" PRIu64 "", (uint64_t)m_start_line);
1007 if (m_type == eLineEndSpecified)
1008 s->Printf ("to line %" PRIu64 "", (uint64_t)m_end_line);
1010 s->Printf ("to end");
1013 else if (m_type == eLineEndSpecified)
1015 s->Printf ("From start to line %" PRIu64 ".\n", (uint64_t)m_end_line);
1018 if (m_type == eFunctionSpecified)
1021 s->Printf ("Function: %s.\n", m_function_spec.c_str());
1024 if (m_type == eClassOrNamespaceSpecified)
1027 s->Printf ("Class name: %s.\n", m_class_name.c_str());
1030 if (m_type == eAddressRangeSpecified && m_address_range_ap.get() != nullptr)
1033 s->PutCString ("Address range: ");
1034 m_address_range_ap->Dump (s, m_target_sp.get(), Address::DumpStyleLoadAddress, Address::DumpStyleFileAddress);
1035 s->PutCString ("\n");
1039 //----------------------------------------------------------------------
1041 // SymbolContextList
1043 //----------------------------------------------------------------------
1046 SymbolContextList::SymbolContextList() :
1051 SymbolContextList::~SymbolContextList()
1056 SymbolContextList::Append(const SymbolContext& sc)
1058 m_symbol_contexts.push_back(sc);
1062 SymbolContextList::Append (const SymbolContextList& sc_list)
1064 collection::const_iterator pos, end = sc_list.m_symbol_contexts.end();
1065 for (pos = sc_list.m_symbol_contexts.begin(); pos != end; ++pos)
1066 m_symbol_contexts.push_back (*pos);
1071 SymbolContextList::AppendIfUnique (const SymbolContextList& sc_list, bool merge_symbol_into_function)
1073 uint32_t unique_sc_add_count = 0;
1074 collection::const_iterator pos, end = sc_list.m_symbol_contexts.end();
1075 for (pos = sc_list.m_symbol_contexts.begin(); pos != end; ++pos)
1077 if (AppendIfUnique (*pos, merge_symbol_into_function))
1078 ++unique_sc_add_count;
1080 return unique_sc_add_count;
1084 SymbolContextList::AppendIfUnique (const SymbolContext& sc, bool merge_symbol_into_function)
1086 collection::iterator pos, end = m_symbol_contexts.end();
1087 for (pos = m_symbol_contexts.begin(); pos != end; ++pos)
1092 if (merge_symbol_into_function
1093 && sc.symbol != nullptr
1094 && sc.comp_unit == nullptr
1095 && sc.function == nullptr
1096 && sc.block == nullptr
1097 && sc.line_entry.IsValid() == false)
1099 if (sc.symbol->ValueIsAddress())
1101 for (pos = m_symbol_contexts.begin(); pos != end; ++pos)
1103 // Don't merge symbols into inlined function symbol contexts
1104 if (pos->block && pos->block->GetContainingInlinedBlock())
1109 if (pos->function->GetAddressRange().GetBaseAddress() == sc.symbol->GetAddressRef())
1111 // Do we already have a function with this symbol?
1112 if (pos->symbol == sc.symbol)
1114 if (pos->symbol == nullptr)
1116 pos->symbol = sc.symbol;
1124 m_symbol_contexts.push_back(sc);
1129 SymbolContextList::MergeSymbolContextIntoFunctionContext (const SymbolContext& symbol_sc,
1133 if (symbol_sc.symbol != nullptr
1134 && symbol_sc.comp_unit == nullptr
1135 && symbol_sc.function == nullptr
1136 && symbol_sc.block == nullptr
1137 && symbol_sc.line_entry.IsValid() == false)
1139 if (symbol_sc.symbol->ValueIsAddress())
1141 const size_t end = std::min<size_t>(m_symbol_contexts.size(), stop_idx);
1142 for (size_t i=start_idx; i<end; ++i)
1144 const SymbolContext &function_sc = m_symbol_contexts[i];
1145 // Don't merge symbols into inlined function symbol contexts
1146 if (function_sc.block && function_sc.block->GetContainingInlinedBlock())
1149 if (function_sc.function)
1151 if (function_sc.function->GetAddressRange().GetBaseAddress() == symbol_sc.symbol->GetAddressRef())
1153 // Do we already have a function with this symbol?
1154 if (function_sc.symbol == symbol_sc.symbol)
1155 return true; // Already have a symbol context with this symbol, return true
1157 if (function_sc.symbol == nullptr)
1159 // We successfully merged this symbol into an existing symbol context
1160 m_symbol_contexts[i].symbol = symbol_sc.symbol;
1172 SymbolContextList::Clear()
1174 m_symbol_contexts.clear();
1178 SymbolContextList::Dump(Stream *s, Target *target) const
1181 *s << (void *)this << ": ";
1183 s->PutCString("SymbolContextList");
1187 collection::const_iterator pos, end = m_symbol_contexts.end();
1188 for (pos = m_symbol_contexts.begin(); pos != end; ++pos)
1190 //pos->Dump(s, target);
1191 pos->GetDescription(s, eDescriptionLevelVerbose, target);
1197 SymbolContextList::GetContextAtIndex(size_t idx, SymbolContext& sc) const
1199 if (idx < m_symbol_contexts.size())
1201 sc = m_symbol_contexts[idx];
1208 SymbolContextList::GetLastContext(SymbolContext& sc) const
1210 if (!m_symbol_contexts.empty())
1212 sc = m_symbol_contexts.back();
1219 SymbolContextList::RemoveContextAtIndex (size_t idx)
1221 if (idx < m_symbol_contexts.size())
1223 m_symbol_contexts.erase(m_symbol_contexts.begin() + idx);
1230 SymbolContextList::GetSize() const
1232 return m_symbol_contexts.size();
1236 SymbolContextList::NumLineEntriesWithLine (uint32_t line) const
1238 uint32_t match_count = 0;
1239 const size_t size = m_symbol_contexts.size();
1240 for (size_t idx = 0; idx<size; ++idx)
1242 if (m_symbol_contexts[idx].line_entry.line == line)
1249 SymbolContextList::GetDescription(Stream *s,
1250 lldb::DescriptionLevel level,
1251 Target *target) const
1253 const size_t size = m_symbol_contexts.size();
1254 for (size_t idx = 0; idx<size; ++idx)
1255 m_symbol_contexts[idx].GetDescription (s, level, target);
1259 lldb_private::operator== (const SymbolContextList& lhs, const SymbolContextList& rhs)
1261 const uint32_t size = lhs.GetSize();
1262 if (size != rhs.GetSize())
1265 SymbolContext lhs_sc;
1266 SymbolContext rhs_sc;
1267 for (uint32_t i=0; i<size; ++i)
1269 lhs.GetContextAtIndex(i, lhs_sc);
1270 rhs.GetContextAtIndex(i, rhs_sc);
1271 if (lhs_sc != rhs_sc)
1278 lldb_private::operator!= (const SymbolContextList& lhs, const SymbolContextList& rhs)
1280 return !(lhs == rhs);