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