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