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/Debugger.h"
12 #include "lldb/Core/Module.h"
13 #include "lldb/Core/ModuleSpec.h"
14 #include "lldb/Host/Host.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/LLDBLog.h"
24 #include "lldb/Utility/Log.h"
25 #include "lldb/Utility/StreamString.h"
26 
27 using namespace lldb;
28 using namespace lldb_private;
29 
30 SymbolContext::SymbolContext() : target_sp(), module_sp(), line_entry() {}
31 
32 SymbolContext::SymbolContext(const ModuleSP &m, CompileUnit *cu, Function *f,
33                              Block *b, LineEntry *le, Symbol *s)
34     : target_sp(), module_sp(m), comp_unit(cu), function(f), block(b),
35       line_entry(), symbol(s) {
36   if (le)
37     line_entry = *le;
38 }
39 
40 SymbolContext::SymbolContext(const TargetSP &t, const ModuleSP &m,
41                              CompileUnit *cu, Function *f, Block *b,
42                              LineEntry *le, Symbol *s)
43     : target_sp(t), module_sp(m), comp_unit(cu), function(f), block(b),
44       line_entry(), symbol(s) {
45   if (le)
46     line_entry = *le;
47 }
48 
49 SymbolContext::SymbolContext(SymbolContextScope *sc_scope)
50     : target_sp(), module_sp(), line_entry() {
51   sc_scope->CalculateSymbolContext(this);
52 }
53 
54 SymbolContext::~SymbolContext() = default;
55 
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 
68 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 
186 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 
285 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 
306 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 
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 
375 bool lldb_private::operator!=(const SymbolContext &lhs,
376                               const SymbolContext &rhs) {
377   return !(lhs == rhs);
378 }
379 
380 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 
418 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 
437 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 = GetLog(LLDBLog::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             Debugger::ReportWarning(llvm::formatv(
499                 "inlined block {0:x} doesn't have a range that contains file "
500                 "address {1:x} in {2}",
501                 curr_inlined_block->GetID(), curr_frame_pc.GetFileAddress(),
502                 objfile->GetFileSpec().GetPath()));
503           } else {
504             Debugger::ReportWarning(llvm::formatv(
505                 "inlined block {0:x} doesn't have a range that contains file "
506                 "address {1:x}",
507                 curr_inlined_block->GetID(), curr_frame_pc.GetFileAddress()));
508           }
509         }
510 #endif
511       }
512     }
513   }
514 
515   return false;
516 }
517 
518 Block *SymbolContext::GetFunctionBlock() {
519   if (function) {
520     if (block) {
521       // If this symbol context has a block, check to see if this block is
522       // itself, or is contained within a block with inlined function
523       // information. If so, then the inlined block is the block that defines
524       // the function.
525       Block *inlined_block = block->GetContainingInlinedBlock();
526       if (inlined_block)
527         return inlined_block;
528 
529       // The block in this symbol context is not inside an inlined block, so
530       // the block that defines the function is the function's top level block,
531       // which is returned below.
532     }
533 
534     // There is no block information in this symbol context, so we must assume
535     // that the block that is desired is the top level block of the function
536     // itself.
537     return &function->GetBlock(true);
538   }
539   return nullptr;
540 }
541 
542 bool SymbolContext::GetFunctionMethodInfo(lldb::LanguageType &language,
543                                           bool &is_instance_method,
544                                           ConstString &language_object_name)
545 
546 {
547   Block *function_block = GetFunctionBlock();
548   if (function_block) {
549     CompilerDeclContext decl_ctx = function_block->GetDeclContext();
550     if (decl_ctx)
551       return decl_ctx.IsClassMethod(&language, &is_instance_method,
552                                     &language_object_name);
553   }
554   return false;
555 }
556 
557 void SymbolContext::SortTypeList(TypeMap &type_map, TypeList &type_list) const {
558   Block *curr_block = block;
559   bool isInlinedblock = false;
560   if (curr_block != nullptr &&
561       curr_block->GetContainingInlinedBlock() != nullptr)
562     isInlinedblock = true;
563 
564   // Find all types that match the current block if we have one and put them
565   // first in the list. Keep iterating up through all blocks.
566   while (curr_block != nullptr && !isInlinedblock) {
567     type_map.ForEach(
568         [curr_block, &type_list](const lldb::TypeSP &type_sp) -> bool {
569           SymbolContextScope *scs = type_sp->GetSymbolContextScope();
570           if (scs && curr_block == scs->CalculateSymbolContextBlock())
571             type_list.Insert(type_sp);
572           return true; // Keep iterating
573         });
574 
575     // Remove any entries that are now in "type_list" from "type_map" since we
576     // can't remove from type_map while iterating
577     type_list.ForEach([&type_map](const lldb::TypeSP &type_sp) -> bool {
578       type_map.Remove(type_sp);
579       return true; // Keep iterating
580     });
581     curr_block = curr_block->GetParent();
582   }
583   // Find all types that match the current function, if we have onem, and put
584   // them next in the list.
585   if (function != nullptr && !type_map.Empty()) {
586     const size_t old_type_list_size = type_list.GetSize();
587     type_map.ForEach([this, &type_list](const lldb::TypeSP &type_sp) -> bool {
588       SymbolContextScope *scs = type_sp->GetSymbolContextScope();
589       if (scs && function == scs->CalculateSymbolContextFunction())
590         type_list.Insert(type_sp);
591       return true; // Keep iterating
592     });
593 
594     // Remove any entries that are now in "type_list" from "type_map" since we
595     // can't remove from type_map while iterating
596     const size_t new_type_list_size = type_list.GetSize();
597     if (new_type_list_size > old_type_list_size) {
598       for (size_t i = old_type_list_size; i < new_type_list_size; ++i)
599         type_map.Remove(type_list.GetTypeAtIndex(i));
600     }
601   }
602   // Find all types that match the current compile unit, if we have one, and
603   // put them next in the list.
604   if (comp_unit != nullptr && !type_map.Empty()) {
605     const size_t old_type_list_size = type_list.GetSize();
606 
607     type_map.ForEach([this, &type_list](const lldb::TypeSP &type_sp) -> bool {
608       SymbolContextScope *scs = type_sp->GetSymbolContextScope();
609       if (scs && comp_unit == scs->CalculateSymbolContextCompileUnit())
610         type_list.Insert(type_sp);
611       return true; // Keep iterating
612     });
613 
614     // Remove any entries that are now in "type_list" from "type_map" since we
615     // can't remove from type_map while iterating
616     const size_t new_type_list_size = type_list.GetSize();
617     if (new_type_list_size > old_type_list_size) {
618       for (size_t i = old_type_list_size; i < new_type_list_size; ++i)
619         type_map.Remove(type_list.GetTypeAtIndex(i));
620     }
621   }
622   // Find all types that match the current module, if we have one, and put them
623   // next in the list.
624   if (module_sp && !type_map.Empty()) {
625     const size_t old_type_list_size = type_list.GetSize();
626     type_map.ForEach([this, &type_list](const lldb::TypeSP &type_sp) -> bool {
627       SymbolContextScope *scs = type_sp->GetSymbolContextScope();
628       if (scs && module_sp == scs->CalculateSymbolContextModule())
629         type_list.Insert(type_sp);
630       return true; // Keep iterating
631     });
632     // Remove any entries that are now in "type_list" from "type_map" since we
633     // can't remove from type_map while iterating
634     const size_t new_type_list_size = type_list.GetSize();
635     if (new_type_list_size > old_type_list_size) {
636       for (size_t i = old_type_list_size; i < new_type_list_size; ++i)
637         type_map.Remove(type_list.GetTypeAtIndex(i));
638     }
639   }
640   // Any types that are left get copied into the list an any order.
641   if (!type_map.Empty()) {
642     type_map.ForEach([&type_list](const lldb::TypeSP &type_sp) -> bool {
643       type_list.Insert(type_sp);
644       return true; // Keep iterating
645     });
646   }
647 }
648 
649 ConstString
650 SymbolContext::GetFunctionName(Mangled::NamePreference preference) const {
651   if (function) {
652     if (block) {
653       Block *inlined_block = block->GetContainingInlinedBlock();
654 
655       if (inlined_block) {
656         const InlineFunctionInfo *inline_info =
657             inlined_block->GetInlinedFunctionInfo();
658         if (inline_info)
659           return inline_info->GetName();
660       }
661     }
662     return function->GetMangled().GetName(preference);
663   } else if (symbol && symbol->ValueIsAddress()) {
664     return symbol->GetMangled().GetName(preference);
665   } else {
666     // No function, return an empty string.
667     return ConstString();
668   }
669 }
670 
671 LineEntry SymbolContext::GetFunctionStartLineEntry() const {
672   LineEntry line_entry;
673   Address start_addr;
674   if (block) {
675     Block *inlined_block = block->GetContainingInlinedBlock();
676     if (inlined_block) {
677       if (inlined_block->GetStartAddress(start_addr)) {
678         if (start_addr.CalculateSymbolContextLineEntry(line_entry))
679           return line_entry;
680       }
681       return LineEntry();
682     }
683   }
684 
685   if (function) {
686     if (function->GetAddressRange()
687             .GetBaseAddress()
688             .CalculateSymbolContextLineEntry(line_entry))
689       return line_entry;
690   }
691   return LineEntry();
692 }
693 
694 bool SymbolContext::GetAddressRangeFromHereToEndLine(uint32_t end_line,
695                                                      AddressRange &range,
696                                                      Status &error) {
697   if (!line_entry.IsValid()) {
698     error.SetErrorString("Symbol context has no line table.");
699     return false;
700   }
701 
702   range = line_entry.range;
703   if (line_entry.line > end_line) {
704     error.SetErrorStringWithFormat(
705         "end line option %d must be after the current line: %d", end_line,
706         line_entry.line);
707     return false;
708   }
709 
710   uint32_t line_index = 0;
711   bool found = false;
712   while (true) {
713     LineEntry this_line;
714     line_index = comp_unit->FindLineEntry(line_index, line_entry.line, nullptr,
715                                           false, &this_line);
716     if (line_index == UINT32_MAX)
717       break;
718     if (LineEntry::Compare(this_line, line_entry) == 0) {
719       found = true;
720       break;
721     }
722   }
723 
724   LineEntry end_entry;
725   if (!found) {
726     // Can't find the index of the SymbolContext's line entry in the
727     // SymbolContext's CompUnit.
728     error.SetErrorString(
729         "Can't find the current line entry in the CompUnit - can't process "
730         "the end-line option");
731     return false;
732   }
733 
734   line_index = comp_unit->FindLineEntry(line_index, end_line, nullptr, false,
735                                         &end_entry);
736   if (line_index == UINT32_MAX) {
737     error.SetErrorStringWithFormat(
738         "could not find a line table entry corresponding "
739         "to end line number %d",
740         end_line);
741     return false;
742   }
743 
744   Block *func_block = GetFunctionBlock();
745   if (func_block && func_block->GetRangeIndexContainingAddress(
746                         end_entry.range.GetBaseAddress()) == UINT32_MAX) {
747     error.SetErrorStringWithFormat(
748         "end line number %d is not contained within the current function.",
749         end_line);
750     return false;
751   }
752 
753   lldb::addr_t range_size = end_entry.range.GetBaseAddress().GetFileAddress() -
754                             range.GetBaseAddress().GetFileAddress();
755   range.SetByteSize(range_size);
756   return true;
757 }
758 
759 const Symbol *SymbolContext::FindBestGlobalDataSymbol(ConstString name,
760                                                       Status &error) {
761   error.Clear();
762 
763   if (!target_sp) {
764     return nullptr;
765   }
766 
767   Target &target = *target_sp;
768   Module *module = module_sp.get();
769 
770   auto ProcessMatches = [this, &name, &target,
771                          module](SymbolContextList &sc_list,
772                                  Status &error) -> const Symbol * {
773     llvm::SmallVector<const Symbol *, 1> external_symbols;
774     llvm::SmallVector<const Symbol *, 1> internal_symbols;
775     const uint32_t matches = sc_list.GetSize();
776     for (uint32_t i = 0; i < matches; ++i) {
777       SymbolContext sym_ctx;
778       sc_list.GetContextAtIndex(i, sym_ctx);
779       if (sym_ctx.symbol) {
780         const Symbol *symbol = sym_ctx.symbol;
781         const Address sym_address = symbol->GetAddress();
782 
783         if (sym_address.IsValid()) {
784           switch (symbol->GetType()) {
785           case eSymbolTypeData:
786           case eSymbolTypeRuntime:
787           case eSymbolTypeAbsolute:
788           case eSymbolTypeObjCClass:
789           case eSymbolTypeObjCMetaClass:
790           case eSymbolTypeObjCIVar:
791             if (symbol->GetDemangledNameIsSynthesized()) {
792               // If the demangled name was synthesized, then don't use it for
793               // expressions. Only let the symbol match if the mangled named
794               // matches for these symbols.
795               if (symbol->GetMangled().GetMangledName() != name)
796                 break;
797             }
798             if (symbol->IsExternal()) {
799               external_symbols.push_back(symbol);
800             } else {
801               internal_symbols.push_back(symbol);
802             }
803             break;
804           case eSymbolTypeReExported: {
805             ConstString reexport_name = symbol->GetReExportedSymbolName();
806             if (reexport_name) {
807               ModuleSP reexport_module_sp;
808               ModuleSpec reexport_module_spec;
809               reexport_module_spec.GetPlatformFileSpec() =
810                   symbol->GetReExportedSymbolSharedLibrary();
811               if (reexport_module_spec.GetPlatformFileSpec()) {
812                 reexport_module_sp =
813                     target.GetImages().FindFirstModule(reexport_module_spec);
814                 if (!reexport_module_sp) {
815                   reexport_module_spec.GetPlatformFileSpec().ClearDirectory();
816                   reexport_module_sp =
817                       target.GetImages().FindFirstModule(reexport_module_spec);
818                 }
819               }
820               // Don't allow us to try and resolve a re-exported symbol if it
821               // is the same as the current symbol
822               if (name == symbol->GetReExportedSymbolName() &&
823                   module == reexport_module_sp.get())
824                 return nullptr;
825 
826               return FindBestGlobalDataSymbol(symbol->GetReExportedSymbolName(),
827                                               error);
828             }
829           } break;
830 
831           case eSymbolTypeCode: // We already lookup functions elsewhere
832           case eSymbolTypeVariable:
833           case eSymbolTypeLocal:
834           case eSymbolTypeParam:
835           case eSymbolTypeTrampoline:
836           case eSymbolTypeInvalid:
837           case eSymbolTypeException:
838           case eSymbolTypeSourceFile:
839           case eSymbolTypeHeaderFile:
840           case eSymbolTypeObjectFile:
841           case eSymbolTypeCommonBlock:
842           case eSymbolTypeBlock:
843           case eSymbolTypeVariableType:
844           case eSymbolTypeLineEntry:
845           case eSymbolTypeLineHeader:
846           case eSymbolTypeScopeBegin:
847           case eSymbolTypeScopeEnd:
848           case eSymbolTypeAdditional:
849           case eSymbolTypeCompiler:
850           case eSymbolTypeInstrumentation:
851           case eSymbolTypeUndefined:
852           case eSymbolTypeResolver:
853             break;
854           }
855         }
856       }
857     }
858 
859     if (external_symbols.size() > 1) {
860       StreamString ss;
861       ss.Printf("Multiple external symbols found for '%s'\n", name.AsCString());
862       for (const Symbol *symbol : external_symbols) {
863         symbol->GetDescription(&ss, eDescriptionLevelFull, &target);
864       }
865       ss.PutChar('\n');
866       error.SetErrorString(ss.GetData());
867       return nullptr;
868     } else if (external_symbols.size()) {
869       return external_symbols[0];
870     } else if (internal_symbols.size() > 1) {
871       StreamString ss;
872       ss.Printf("Multiple internal symbols found for '%s'\n", name.AsCString());
873       for (const Symbol *symbol : internal_symbols) {
874         symbol->GetDescription(&ss, eDescriptionLevelVerbose, &target);
875         ss.PutChar('\n');
876       }
877       error.SetErrorString(ss.GetData());
878       return nullptr;
879     } else if (internal_symbols.size()) {
880       return internal_symbols[0];
881     } else {
882       return nullptr;
883     }
884   };
885 
886   if (module) {
887     SymbolContextList sc_list;
888     module->FindSymbolsWithNameAndType(name, eSymbolTypeAny, sc_list);
889     const Symbol *const module_symbol = ProcessMatches(sc_list, error);
890 
891     if (!error.Success()) {
892       return nullptr;
893     } else if (module_symbol) {
894       return module_symbol;
895     }
896   }
897 
898   {
899     SymbolContextList sc_list;
900     target.GetImages().FindSymbolsWithNameAndType(name, eSymbolTypeAny,
901                                                   sc_list);
902     const Symbol *const target_symbol = ProcessMatches(sc_list, error);
903 
904     if (!error.Success()) {
905       return nullptr;
906     } else if (target_symbol) {
907       return target_symbol;
908     }
909   }
910 
911   return nullptr; // no error; we just didn't find anything
912 }
913 
914 //
915 //  SymbolContextSpecifier
916 //
917 
918 SymbolContextSpecifier::SymbolContextSpecifier(const TargetSP &target_sp)
919     : m_target_sp(target_sp), m_module_spec(), m_module_sp(), m_file_spec_up(),
920       m_start_line(0), m_end_line(0), m_function_spec(), m_class_name(),
921       m_address_range_up(), m_type(eNothingSpecified) {}
922 
923 SymbolContextSpecifier::~SymbolContextSpecifier() = default;
924 
925 bool SymbolContextSpecifier::AddLineSpecification(uint32_t line_no,
926                                                   SpecificationType type) {
927   bool return_value = true;
928   switch (type) {
929   case eNothingSpecified:
930     Clear();
931     break;
932   case eLineStartSpecified:
933     m_start_line = line_no;
934     m_type |= eLineStartSpecified;
935     break;
936   case eLineEndSpecified:
937     m_end_line = line_no;
938     m_type |= eLineEndSpecified;
939     break;
940   default:
941     return_value = false;
942     break;
943   }
944   return return_value;
945 }
946 
947 bool SymbolContextSpecifier::AddSpecification(const char *spec_string,
948                                               SpecificationType type) {
949   bool return_value = true;
950   switch (type) {
951   case eNothingSpecified:
952     Clear();
953     break;
954   case eModuleSpecified: {
955     // See if we can find the Module, if so stick it in the SymbolContext.
956     FileSpec module_file_spec(spec_string);
957     ModuleSpec module_spec(module_file_spec);
958     lldb::ModuleSP module_sp =
959         m_target_sp ? m_target_sp->GetImages().FindFirstModule(module_spec)
960                     : nullptr;
961     m_type |= eModuleSpecified;
962     if (module_sp)
963       m_module_sp = module_sp;
964     else
965       m_module_spec.assign(spec_string);
966   } break;
967   case eFileSpecified:
968     // CompUnits can't necessarily be resolved here, since an inlined function
969     // might show up in a number of CompUnits.  Instead we just convert to a
970     // FileSpec and store it away.
971     m_file_spec_up = std::make_unique<FileSpec>(spec_string);
972     m_type |= eFileSpecified;
973     break;
974   case eLineStartSpecified:
975     if ((return_value = llvm::to_integer(spec_string, m_start_line)))
976       m_type |= eLineStartSpecified;
977     break;
978   case eLineEndSpecified:
979     if ((return_value = llvm::to_integer(spec_string, m_end_line)))
980       m_type |= eLineEndSpecified;
981     break;
982   case eFunctionSpecified:
983     m_function_spec.assign(spec_string);
984     m_type |= eFunctionSpecified;
985     break;
986   case eClassOrNamespaceSpecified:
987     Clear();
988     m_class_name.assign(spec_string);
989     m_type = eClassOrNamespaceSpecified;
990     break;
991   case eAddressRangeSpecified:
992     // Not specified yet...
993     break;
994   }
995 
996   return return_value;
997 }
998 
999 void SymbolContextSpecifier::Clear() {
1000   m_module_spec.clear();
1001   m_file_spec_up.reset();
1002   m_function_spec.clear();
1003   m_class_name.clear();
1004   m_start_line = 0;
1005   m_end_line = 0;
1006   m_address_range_up.reset();
1007 
1008   m_type = eNothingSpecified;
1009 }
1010 
1011 bool SymbolContextSpecifier::SymbolContextMatches(const SymbolContext &sc) {
1012   if (m_type == eNothingSpecified)
1013     return true;
1014 
1015   // Only compare targets if this specifier has one and it's not the Dummy
1016   // target.  Otherwise if a specifier gets made in the dummy target and
1017   // copied over we'll artificially fail the comparision.
1018   if (m_target_sp && !m_target_sp->IsDummyTarget() &&
1019       m_target_sp != sc.target_sp)
1020     return false;
1021 
1022   if (m_type & eModuleSpecified) {
1023     if (sc.module_sp) {
1024       if (m_module_sp.get() != nullptr) {
1025         if (m_module_sp.get() != sc.module_sp.get())
1026           return false;
1027       } else {
1028         FileSpec module_file_spec(m_module_spec);
1029         if (!FileSpec::Match(module_file_spec, sc.module_sp->GetFileSpec()))
1030           return false;
1031       }
1032     }
1033   }
1034   if (m_type & eFileSpecified) {
1035     if (m_file_spec_up) {
1036       // If we don't have a block or a comp_unit, then we aren't going to match
1037       // a source file.
1038       if (sc.block == nullptr && sc.comp_unit == nullptr)
1039         return false;
1040 
1041       // Check if the block is present, and if so is it inlined:
1042       bool was_inlined = false;
1043       if (sc.block != nullptr) {
1044         const InlineFunctionInfo *inline_info =
1045             sc.block->GetInlinedFunctionInfo();
1046         if (inline_info != nullptr) {
1047           was_inlined = true;
1048           if (!FileSpec::Match(*m_file_spec_up,
1049                                inline_info->GetDeclaration().GetFile()))
1050             return false;
1051         }
1052       }
1053 
1054       // Next check the comp unit, but only if the SymbolContext was not
1055       // inlined.
1056       if (!was_inlined && sc.comp_unit != nullptr) {
1057         if (!FileSpec::Match(*m_file_spec_up, sc.comp_unit->GetPrimaryFile()))
1058           return false;
1059       }
1060     }
1061   }
1062   if (m_type & eLineStartSpecified || m_type & eLineEndSpecified) {
1063     if (sc.line_entry.line < m_start_line || sc.line_entry.line > m_end_line)
1064       return false;
1065   }
1066 
1067   if (m_type & eFunctionSpecified) {
1068     // First check the current block, and if it is inlined, get the inlined
1069     // function name:
1070     bool was_inlined = false;
1071     ConstString func_name(m_function_spec.c_str());
1072 
1073     if (sc.block != nullptr) {
1074       const InlineFunctionInfo *inline_info =
1075           sc.block->GetInlinedFunctionInfo();
1076       if (inline_info != nullptr) {
1077         was_inlined = true;
1078         const Mangled &name = inline_info->GetMangled();
1079         if (!name.NameMatches(func_name))
1080           return false;
1081       }
1082     }
1083     //  If it wasn't inlined, check the name in the function or symbol:
1084     if (!was_inlined) {
1085       if (sc.function != nullptr) {
1086         if (!sc.function->GetMangled().NameMatches(func_name))
1087           return false;
1088       } else if (sc.symbol != nullptr) {
1089         if (!sc.symbol->GetMangled().NameMatches(func_name))
1090           return false;
1091       }
1092     }
1093   }
1094 
1095   return true;
1096 }
1097 
1098 bool SymbolContextSpecifier::AddressMatches(lldb::addr_t addr) {
1099   if (m_type & eAddressRangeSpecified) {
1100 
1101   } else {
1102     Address match_address(addr, nullptr);
1103     SymbolContext sc;
1104     m_target_sp->GetImages().ResolveSymbolContextForAddress(
1105         match_address, eSymbolContextEverything, sc);
1106     return SymbolContextMatches(sc);
1107   }
1108   return true;
1109 }
1110 
1111 void SymbolContextSpecifier::GetDescription(
1112     Stream *s, lldb::DescriptionLevel level) const {
1113   char path_str[PATH_MAX + 1];
1114 
1115   if (m_type == eNothingSpecified) {
1116     s->Printf("Nothing specified.\n");
1117   }
1118 
1119   if (m_type == eModuleSpecified) {
1120     s->Indent();
1121     if (m_module_sp) {
1122       m_module_sp->GetFileSpec().GetPath(path_str, PATH_MAX);
1123       s->Printf("Module: %s\n", path_str);
1124     } else
1125       s->Printf("Module: %s\n", m_module_spec.c_str());
1126   }
1127 
1128   if (m_type == eFileSpecified && m_file_spec_up != nullptr) {
1129     m_file_spec_up->GetPath(path_str, PATH_MAX);
1130     s->Indent();
1131     s->Printf("File: %s", path_str);
1132     if (m_type == eLineStartSpecified) {
1133       s->Printf(" from line %" PRIu64 "", (uint64_t)m_start_line);
1134       if (m_type == eLineEndSpecified)
1135         s->Printf("to line %" PRIu64 "", (uint64_t)m_end_line);
1136       else
1137         s->Printf("to end");
1138     } else if (m_type == eLineEndSpecified) {
1139       s->Printf(" from start to line %" PRIu64 "", (uint64_t)m_end_line);
1140     }
1141     s->Printf(".\n");
1142   }
1143 
1144   if (m_type == eLineStartSpecified) {
1145     s->Indent();
1146     s->Printf("From line %" PRIu64 "", (uint64_t)m_start_line);
1147     if (m_type == eLineEndSpecified)
1148       s->Printf("to line %" PRIu64 "", (uint64_t)m_end_line);
1149     else
1150       s->Printf("to end");
1151     s->Printf(".\n");
1152   } else if (m_type == eLineEndSpecified) {
1153     s->Printf("From start to line %" PRIu64 ".\n", (uint64_t)m_end_line);
1154   }
1155 
1156   if (m_type == eFunctionSpecified) {
1157     s->Indent();
1158     s->Printf("Function: %s.\n", m_function_spec.c_str());
1159   }
1160 
1161   if (m_type == eClassOrNamespaceSpecified) {
1162     s->Indent();
1163     s->Printf("Class name: %s.\n", m_class_name.c_str());
1164   }
1165 
1166   if (m_type == eAddressRangeSpecified && m_address_range_up != nullptr) {
1167     s->Indent();
1168     s->PutCString("Address range: ");
1169     m_address_range_up->Dump(s, m_target_sp.get(),
1170                              Address::DumpStyleLoadAddress,
1171                              Address::DumpStyleFileAddress);
1172     s->PutCString("\n");
1173   }
1174 }
1175 
1176 //
1177 //  SymbolContextList
1178 //
1179 
1180 SymbolContextList::SymbolContextList() : m_symbol_contexts() {}
1181 
1182 SymbolContextList::~SymbolContextList() = default;
1183 
1184 void SymbolContextList::Append(const SymbolContext &sc) {
1185   m_symbol_contexts.push_back(sc);
1186 }
1187 
1188 void SymbolContextList::Append(const SymbolContextList &sc_list) {
1189   collection::const_iterator pos, end = sc_list.m_symbol_contexts.end();
1190   for (pos = sc_list.m_symbol_contexts.begin(); pos != end; ++pos)
1191     m_symbol_contexts.push_back(*pos);
1192 }
1193 
1194 uint32_t SymbolContextList::AppendIfUnique(const SymbolContextList &sc_list,
1195                                            bool merge_symbol_into_function) {
1196   uint32_t unique_sc_add_count = 0;
1197   collection::const_iterator pos, end = sc_list.m_symbol_contexts.end();
1198   for (pos = sc_list.m_symbol_contexts.begin(); pos != end; ++pos) {
1199     if (AppendIfUnique(*pos, merge_symbol_into_function))
1200       ++unique_sc_add_count;
1201   }
1202   return unique_sc_add_count;
1203 }
1204 
1205 bool SymbolContextList::AppendIfUnique(const SymbolContext &sc,
1206                                        bool merge_symbol_into_function) {
1207   collection::iterator pos, end = m_symbol_contexts.end();
1208   for (pos = m_symbol_contexts.begin(); pos != end; ++pos) {
1209     if (*pos == sc)
1210       return false;
1211   }
1212   if (merge_symbol_into_function && sc.symbol != nullptr &&
1213       sc.comp_unit == nullptr && sc.function == nullptr &&
1214       sc.block == nullptr && !sc.line_entry.IsValid()) {
1215     if (sc.symbol->ValueIsAddress()) {
1216       for (pos = m_symbol_contexts.begin(); pos != end; ++pos) {
1217         // Don't merge symbols into inlined function symbol contexts
1218         if (pos->block && pos->block->GetContainingInlinedBlock())
1219           continue;
1220 
1221         if (pos->function) {
1222           if (pos->function->GetAddressRange().GetBaseAddress() ==
1223               sc.symbol->GetAddressRef()) {
1224             // Do we already have a function with this symbol?
1225             if (pos->symbol == sc.symbol)
1226               return false;
1227             if (pos->symbol == nullptr) {
1228               pos->symbol = sc.symbol;
1229               return false;
1230             }
1231           }
1232         }
1233       }
1234     }
1235   }
1236   m_symbol_contexts.push_back(sc);
1237   return true;
1238 }
1239 
1240 void SymbolContextList::Clear() { m_symbol_contexts.clear(); }
1241 
1242 void SymbolContextList::Dump(Stream *s, Target *target) const {
1243 
1244   *s << this << ": ";
1245   s->Indent();
1246   s->PutCString("SymbolContextList");
1247   s->EOL();
1248   s->IndentMore();
1249 
1250   collection::const_iterator pos, end = m_symbol_contexts.end();
1251   for (pos = m_symbol_contexts.begin(); pos != end; ++pos) {
1252     // pos->Dump(s, target);
1253     pos->GetDescription(s, eDescriptionLevelVerbose, target);
1254   }
1255   s->IndentLess();
1256 }
1257 
1258 bool SymbolContextList::GetContextAtIndex(size_t idx, SymbolContext &sc) const {
1259   if (idx < m_symbol_contexts.size()) {
1260     sc = m_symbol_contexts[idx];
1261     return true;
1262   }
1263   return false;
1264 }
1265 
1266 bool SymbolContextList::RemoveContextAtIndex(size_t idx) {
1267   if (idx < m_symbol_contexts.size()) {
1268     m_symbol_contexts.erase(m_symbol_contexts.begin() + idx);
1269     return true;
1270   }
1271   return false;
1272 }
1273 
1274 uint32_t SymbolContextList::GetSize() const { return m_symbol_contexts.size(); }
1275 
1276 bool SymbolContextList::IsEmpty() const { return m_symbol_contexts.empty(); }
1277 
1278 uint32_t SymbolContextList::NumLineEntriesWithLine(uint32_t line) const {
1279   uint32_t match_count = 0;
1280   const size_t size = m_symbol_contexts.size();
1281   for (size_t idx = 0; idx < size; ++idx) {
1282     if (m_symbol_contexts[idx].line_entry.line == line)
1283       ++match_count;
1284   }
1285   return match_count;
1286 }
1287 
1288 void SymbolContextList::GetDescription(Stream *s, lldb::DescriptionLevel level,
1289                                        Target *target) const {
1290   const size_t size = m_symbol_contexts.size();
1291   for (size_t idx = 0; idx < size; ++idx)
1292     m_symbol_contexts[idx].GetDescription(s, level, target);
1293 }
1294 
1295 bool lldb_private::operator==(const SymbolContextList &lhs,
1296                               const SymbolContextList &rhs) {
1297   const uint32_t size = lhs.GetSize();
1298   if (size != rhs.GetSize())
1299     return false;
1300 
1301   SymbolContext lhs_sc;
1302   SymbolContext rhs_sc;
1303   for (uint32_t i = 0; i < size; ++i) {
1304     lhs.GetContextAtIndex(i, lhs_sc);
1305     rhs.GetContextAtIndex(i, rhs_sc);
1306     if (lhs_sc != rhs_sc)
1307       return false;
1308   }
1309   return true;
1310 }
1311 
1312 bool lldb_private::operator!=(const SymbolContextList &lhs,
1313                               const SymbolContextList &rhs) {
1314   return !(lhs == rhs);
1315 }
1316