LLDB  mainline
SymbolContext.cpp
Go to the documentation of this file.
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 
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"
17 #include "lldb/Symbol/ObjectFile.h"
18 #include "lldb/Symbol/Symbol.h"
19 #include "lldb/Symbol/SymbolFile.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"
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 
50  : target_sp(), module_sp(), line_entry() {
51  sc_scope->CalculateSymbolContext(this);
52 }
53 
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 
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;
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 
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()) {
258  s->PutCString("kind = global, ");
259  break;
260 
262  s->PutCString("kind = static, ");
263  break;
264 
266  s->PutCString("kind = argument, ");
267  break;
268 
270  s->PutCString("kind = local, ");
271  break;
272 
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 
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(),
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,
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 = ";
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 
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 
376  const SymbolContext &rhs) {
377  return !(lhs == rhs);
378 }
379 
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 
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 
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 
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 
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 
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 
673  Address start_addr;
674  if (block) {
675  Block *inlined_block = block->GetContainingInlinedBlock();
676  if (inlined_block) {
677  if (inlined_block->GetStartAddress(start_addr)) {
679  return line_entry;
680  }
681  return LineEntry();
682  }
683  }
684 
685  if (function) {
687  .GetBaseAddress()
689  return line_entry;
690  }
691  return LineEntry();
692 }
693 
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 
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:
790  case eSymbolTypeObjCIVar:
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() =
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 
827  error);
828  }
829  } break;
830 
831  case eSymbolTypeCode: // We already lookup functions elsewhere
832  case eSymbolTypeVariable:
833  case eSymbolTypeLocal:
834  case eSymbolTypeParam:
836  case eSymbolTypeInvalid:
842  case eSymbolTypeBlock:
847  case eSymbolTypeScopeEnd:
849  case eSymbolTypeCompiler:
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) {
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) {
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 
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 
924 
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;
935  break;
936  case eLineEndSpecified:
937  m_end_line = line_no;
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;
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);
973  break;
974  case eLineStartSpecified:
975  if ((return_value = llvm::to_integer(spec_string, m_start_line)))
977  break;
978  case eLineEndSpecified:
979  if ((return_value = llvm::to_integer(spec_string, m_end_line)))
981  break;
982  case eFunctionSpecified:
983  m_function_spec.assign(spec_string);
985  break;
987  Clear();
988  m_class_name.assign(spec_string);
990  break;
992  // Not specified yet...
993  break;
994  }
995 
996  return return_value;
997 }
998 
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 
1009 }
1010 
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 =
1046  if (inline_info != nullptr) {
1047  was_inlined = true;
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) {
1058  return false;
1059  }
1060  }
1061  }
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 =
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 
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 
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 
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(),
1172  s->PutCString("\n");
1173  }
1174 }
1175 
1176 //
1177 // SymbolContextList
1178 //
1179 
1180 SymbolContextList::SymbolContextList() : m_symbol_contexts() {}
1181 
1183 
1185  m_symbol_contexts.push_back(sc);
1186 }
1187 
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 
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 
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 
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 
1259  if (idx < m_symbol_contexts.size()) {
1260  sc = m_symbol_contexts[idx];
1261  return true;
1262  }
1263  return false;
1264 }
1265 
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 
1275 
1276 bool SymbolContextList::IsEmpty() const { return m_symbol_contexts.empty(); }
1277 
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 
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 
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 
1313  const SymbolContextList &rhs) {
1314  return !(lhs == rhs);
1315 }
lldb_private::AddressRange::GetBaseAddress
Address & GetBaseAddress()
Get accessor for the base address of the range.
Definition: AddressRange.h:209
Block.h
lldb_private::Stream::IndentLess
void IndentLess(unsigned amount=2)
Decrement the current indentation level.
Definition: Stream.cpp:171
lldb_private::Stream::Format
void Format(const char *format, Args &&... args)
Definition: Stream.h:309
lldb::eSymbolTypeCompiler
@ eSymbolTypeCompiler
Definition: lldb-enumerations.h:643
lldb_private::Variable::GetScope
lldb::ValueType GetScope() const
Definition: Variable.h:66
lldb_private::SymbolContextSpecifier::~SymbolContextSpecifier
~SymbolContextSpecifier()
lldb_private::Block::GetRangeContainingAddress
bool GetRangeContainingAddress(const Address &addr, AddressRange &range)
Definition: Block.cpp:250
lldb_private::SymbolFile
Provides public interface for all SymbolFiles.
Definition: SymbolFile.h:46
lldb_private::SymbolContext::block
Block * block
The Block for a given query.
Definition: SymbolContext.h:321
lldb_private::LineEntry::Compare
static int Compare(const LineEntry &lhs, const LineEntry &rhs)
Compare two LineEntry objects.
Definition: LineEntry.cpp:157
lldb::eSymbolTypeParam
@ eSymbolTypeParam
Definition: lldb-enumerations.h:634
lldb_private::SymbolContext::comp_unit
CompileUnit * comp_unit
The CompileUnit for a given query.
Definition: SymbolContext.h:319
lldb_private::SymbolContextSpecifier::AddSpecification
bool AddSpecification(const char *spec_string, SpecificationType type)
Definition: SymbolContext.cpp:947
lldb::eSymbolTypeObjCIVar
@ eSymbolTypeObjCIVar
Definition: lldb-enumerations.h:648
lldb_private::LineEntry::file
FileSpec file
The source file, possibly mapped by the target.source-map setting.
Definition: LineEntry.h:140
lldb::eValueTypeVariableGlobal
@ eValueTypeVariableGlobal
globals variable
Definition: lldb-enumerations.h:317
lldb_private::ObjectFile::GetFileSpec
virtual FileSpec & GetFileSpec()
Get accessor to the object file specification.
Definition: ObjectFile.h:292
lldb_private::ModuleSpec::GetPlatformFileSpec
FileSpec & GetPlatformFileSpec()
Definition: ModuleSpec.h:65
lldb::eSymbolTypeHeaderFile
@ eSymbolTypeHeaderFile
Definition: lldb-enumerations.h:629
lldb_private::SymbolContextSpecifier::eNothingSpecified
@ eNothingSpecified
Definition: SymbolContext.h:331
lldb_private::Address::Clear
void Clear()
Clear the object's state.
Definition: Address.h:178
lldb_private::Address::IsValid
bool IsValid() const
Check if the object state is valid.
Definition: Address.h:345
lldb::eSymbolTypeCode
@ eSymbolTypeCode
Definition: lldb-enumerations.h:622
lldb_private::LineEntry::DumpStopContext
bool DumpStopContext(Stream *s, bool show_fullpaths) const
Dumps information specific to a process that stops at this line entry to the supplied stream s.
Definition: LineEntry.cpp:50
lldb_private::SymbolContextSpecifier::eLineEndSpecified
@ eLineEndSpecified
Definition: SymbolContext.h:335
lldb_private::LLDBLog::Symbols
@ Symbols
lldb_private::InlineFunctionInfo
Definition: Function.h:125
lldb_private::Debugger::ReportWarning
static void ReportWarning(std::string message, llvm::Optional< lldb::user_id_t > debugger_id=llvm::None, std::once_flag *once=nullptr)
Report warning events.
Definition: Debugger.cpp:1365
CompileUnit.h
lldb_private::LineEntry::IsValid
bool IsValid() const
Check if a line entry object is valid.
Definition: LineEntry.cpp:46
lldb::eSymbolTypeInstrumentation
@ eSymbolTypeInstrumentation
Definition: lldb-enumerations.h:644
lldb_private::SymbolContextSpecifier::m_type
uint32_t m_type
Definition: SymbolContext.h:368
ModuleSpec.h
lldb_private::Function::GetAddressRange
const AddressRange & GetAddressRange()
Definition: Function.h:457
lldb_private::Symbol::GetDescription
void GetDescription(Stream *s, lldb::DescriptionLevel level, Target *target) const
Definition: Symbol.cpp:177
lldb_private::SymbolContextScope::CalculateSymbolContextModule
virtual lldb::ModuleSP CalculateSymbolContextModule()
Definition: SymbolContextScope.h:78
lldb_private::SymbolContextList::~SymbolContextList
~SymbolContextList()
Destructor.
lldb_private::SymbolContextSpecifier::m_module_spec
std::string m_module_spec
Definition: SymbolContext.h:360
lldb_private::Symbol
Definition: Symbol.h:20
lldb_private::Symbol::ValueIsAddress
bool ValueIsAddress() const
Definition: Symbol.cpp:117
lldb_private::SymbolContextSpecifier::m_function_spec
std::string m_function_spec
Definition: SymbolContext.h:365
lldb::eSymbolTypeInvalid
@ eSymbolTypeInvalid
Definition: lldb-enumerations.h:620
Host.h
lldb_private::SymbolContext::GetAddressRange
bool GetAddressRange(uint32_t scope, uint32_t range_idx, bool use_inline_block_range, AddressRange &range) const
Get the address range contained within a symbol context.
Definition: SymbolContext.cpp:380
lldb_private::SymbolContext::target_sp
lldb::TargetSP target_sp
The Target for a given query.
Definition: SymbolContext.h:317
lldb::eSymbolTypeLineEntry
@ eSymbolTypeLineEntry
Definition: lldb-enumerations.h:637
lldb_private::SymbolContextSpecifier::eFileSpecified
@ eFileSpecified
Definition: SymbolContext.h:333
lldb_private::SymbolContextList::Append
void Append(const SymbolContext &sc)
Append a new symbol context to the list.
Definition: SymbolContext.cpp:1184
lldb_private::Address::DumpStyleFileAddress
@ DumpStyleFileAddress
Display as the file address (if any).
Definition: Address.h:84
lldb_private::SymbolContextScope::CalculateSymbolContextFunction
virtual Function * CalculateSymbolContextFunction()
Definition: SymbolContextScope.h:84
lldb::eSymbolTypeCommonBlock
@ eSymbolTypeCommonBlock
Definition: lldb-enumerations.h:631
lldb::eSymbolTypeTrampoline
@ eSymbolTypeTrampoline
Definition: lldb-enumerations.h:625
lldb_private::Block::GetParent
Block * GetParent() const
Get the parent block.
Definition: Block.cpp:202
LLDB_LOGF
#define LLDB_LOGF(log,...)
Definition: Log.h:344
Module.h
lldb_private::InlineFunctionInfo::GetCallSite
Declaration & GetCallSite()
Get accessor for the call site declaration information.
Definition: Function.cpp:108
lldb::LanguageType
LanguageType
Programming language type.
Definition: lldb-enumerations.h:436
lldb::eSymbolTypeScopeBegin
@ eSymbolTypeScopeBegin
Definition: lldb-enumerations.h:639
lldb::eSymbolTypeData
@ eSymbolTypeData
Definition: lldb-enumerations.h:624
lldb_private::SymbolContextList
Definition: SymbolContext.h:379
lldb_private::SymbolContextList::GetContextAtIndex
bool GetContextAtIndex(size_t idx, SymbolContext &sc) const
Get accessor for a symbol context at index idx.
Definition: SymbolContext.cpp:1258
lldb_private::Module
Definition: Module.h:85
lldb_private::ConstString::AsCString
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
Definition: ConstString.h:192
lldb_private::SymbolContextSpecifier::Clear
void Clear()
Definition: SymbolContext.cpp:999
lldb_private::Declaration::GetFile
FileSpec & GetFile()
Get accessor for file specification.
Definition: Declaration.h:107
lldb::eSymbolTypeRuntime
@ eSymbolTypeRuntime
Definition: lldb-enumerations.h:626
lldb_private::Symbol::GetReExportedSymbolName
ConstString GetReExportedSymbolName() const
Definition: Symbol.cpp:125
lldb_private::SymbolContextSpecifier::AddLineSpecification
bool AddLineSpecification(uint32_t line_no, SpecificationType type)
Definition: SymbolContext.cpp:925
lldb_private::Declaration::GetColumn
uint16_t GetColumn() const
Get accessor for the declaration column number.
Definition: Declaration.h:127
lldb_private::Stream
Definition: Stream.h:28
lldb_private::Type::GetName
ConstString GetName()
Definition: Type.cpp:302
lldb_private::TypeList::GetTypeAtIndex
lldb::TypeSP GetTypeAtIndex(uint32_t idx)
Definition: TypeList.cpp:66
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
lldb_private::SymbolContext::~SymbolContext
~SymbolContext()
lldb_private::SymbolContext::SortTypeList
void SortTypeList(TypeMap &type_map, TypeList &type_list) const
Sorts the types in TypeMap according to SymbolContext to TypeList.
Definition: SymbolContext.cpp:557
lldb_private::SymbolContextSpecifier::eLineStartSpecified
@ eLineStartSpecified
Definition: SymbolContext.h:334
lldb_private::SymbolContextSpecifier::SymbolContextSpecifier
SymbolContextSpecifier(const lldb::TargetSP &target_sp)
Definition: SymbolContext.cpp:918
lldb_private::Variable::GetName
ConstString GetName() const
Definition: Variable.cpp:71
Debugger.h
lldb_private::SymbolContext
Definition: SymbolContext.h:33
lldb_private::Target
Definition: Target.h:469
lldb_private::TypeList::ForEach
void ForEach(std::function< bool(const lldb::TypeSP &type_sp)> const &callback) const
Definition: TypeList.cpp:78
lldb_private::SymbolContextList::Clear
void Clear()
Clear the object's state.
Definition: SymbolContext.cpp:1240
lldb_private::SymbolContextSpecifier::eFunctionSpecified
@ eFunctionSpecified
Definition: SymbolContext.h:336
lldb_private::Type::Dump
void Dump(Stream *s, bool show_context, lldb::DescriptionLevel level=lldb::eDescriptionLevelFull)
Definition: Type.cpp:236
lldb_private::SymbolContextList::SymbolContextList
SymbolContextList()
Default constructor.
Definition: SymbolContext.cpp:1180
lldb_private::LineEntry::GetDescription
bool GetDescription(Stream *s, lldb::DescriptionLevel level, CompileUnit *cu, Target *target, bool show_address_only) const
Definition: LineEntry.cpp:105
lldb_private::CompileUnit
Definition: CompileUnit.h:38
lldb_private::SymbolContextSpecifier::eClassOrNamespaceSpecified
@ eClassOrNamespaceSpecified
Definition: SymbolContext.h:337
lldb_private::SymbolContextSpecifier::GetDescription
void GetDescription(Stream *s, lldb::DescriptionLevel level) const
Definition: SymbolContext.cpp:1111
lldb_private::SymbolContextList::Dump
void Dump(Stream *s, Target *target) const
Dump a description of this object to a Stream.
Definition: SymbolContext.cpp:1242
Target.h
lldb_private::Address::CalculateSymbolContextLineEntry
bool CalculateSymbolContextLineEntry(LineEntry &line_entry) const
Definition: Address.cpp:907
lldb_private::SymbolContextSpecifier::m_class_name
std::string m_class_name
Definition: SymbolContext.h:366
lldb_private::operator==
bool operator==(const Address &lhs, const Address &rhs)
Definition: Address.cpp:1016
lldb_private::FileSpec
Definition: FileSpec.h:55
lldb_private::SymbolContextSpecifier::m_module_sp
lldb::ModuleSP m_module_sp
Definition: SymbolContext.h:361
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
lldb::eSymbolTypeAny
@ eSymbolTypeAny
Definition: lldb-enumerations.h:619
lldb_private::SymbolContext::symbol
Symbol * symbol
The Symbol for a given query.
Definition: SymbolContext.h:323
lldb::eSymbolTypeBlock
@ eSymbolTypeBlock
Definition: lldb-enumerations.h:632
lldb_private::LineEntry::Dump
bool Dump(Stream *s, Target *target, bool show_file, Address::DumpStyle style, Address::DumpStyle fallback_style, bool show_range) const
Dump a description of this object to a Stream.
Definition: LineEntry.cpp:70
lldb_private::Function
Definition: Function.h:409
lldb_private::SymbolContext::DumpStopContext
bool DumpStopContext(Stream *s, ExecutionContextScope *exe_scope, const Address &so_addr, bool show_fullpaths, bool show_module, bool show_inlined_frames, bool show_function_arguments, bool show_function_name) const
Dump the stop context in this object to a Stream.
Definition: SymbolContext.cpp:68
lldb_private::Stream::Indent
size_t Indent(llvm::StringRef s="")
Indent the current line in the stream.
Definition: Stream.cpp:130
lldb::eSymbolTypeSourceFile
@ eSymbolTypeSourceFile
Definition: lldb-enumerations.h:628
lldb_private::Address::DumpStyleLoadAddress
@ DumpStyleLoadAddress
Display as the load address (if resolved).
Definition: Address.h:96
Log.h
lldb::eSymbolTypeUndefined
@ eSymbolTypeUndefined
Definition: lldb-enumerations.h:645
lldb_private::ExecutionContextScope
Definition: ExecutionContextScope.h:32
lldb::eSymbolTypeObjectFile
@ eSymbolTypeObjectFile
Definition: lldb-enumerations.h:630
lldb_private::SymbolContextScope::CalculateSymbolContextCompileUnit
virtual CompileUnit * CalculateSymbolContextCompileUnit()
Definition: SymbolContextScope.h:82
lldb_private::TypeList::Insert
void Insert(const lldb::TypeSP &type)
Definition: TypeList.cpp:27
lldb_private::SymbolContext::Dump
void Dump(Stream *s, Target *target) const
Dump a description of this object to a Stream.
Definition: SymbolContext.cpp:306
lldb_private::FileSpec::Match
static bool Match(const FileSpec &pattern, const FileSpec &file)
Match FileSpec pattern against FileSpec file.
Definition: FileSpec.cpp:299
lldb_private::SymbolContext::GetFunctionStartLineEntry
LineEntry GetFunctionStartLineEntry() const
Get the line entry that corresponds to the function.
Definition: SymbolContext.cpp:671
lldb_private::TypeMap::Empty
bool Empty() const
Definition: TypeMap.cpp:77
lldb_private::SymbolContextSpecifier::m_address_range_up
std::unique_ptr< AddressRange > m_address_range_up
Definition: SymbolContext.h:367
lldb_private::StreamString::GetData
const char * GetData() const
Definition: StreamString.h:43
lldb_private::SymbolContextScope::CalculateSymbolContext
virtual void CalculateSymbolContext(SymbolContext *sc)=0
Reconstruct the object's symbol context into sc.
lldb_private::SymbolContext::function
Function * function
The Function for a given query.
Definition: SymbolContext.h:320
StreamString.h
lldb_private::Address::GetFileAddress
lldb::addr_t GetFileAddress() const
Get the file address.
Definition: Address.cpp:291
lldb_private::SymbolContextSpecifier::AddressMatches
bool AddressMatches(lldb::addr_t addr)
Definition: SymbolContext.cpp:1098
lldb_private::Symbol::GetAddressRef
Address & GetAddressRef()
Definition: Symbol.h:57
lldb_private::InlineFunctionInfo::GetMangled
Mangled & GetMangled()
Get accessor for the mangled name object.
Definition: Function.cpp:114
lldb_private::TypeList::GetSize
uint32_t GetSize() const
Definition: TypeList.cpp:60
lldb_private::Variable::GetLanguage
lldb::LanguageType GetLanguage() const
Definition: Variable.cpp:54
lldb_private::SymbolContextList::GetSize
uint32_t GetSize() const
Get accessor for a symbol context list size.
Definition: SymbolContext.cpp:1274
lldb_private::ConstString
Definition: ConstString.h:39
lldb_private::StreamString
Definition: StreamString.h:23
lldb_private::SymbolContextSpecifier::m_file_spec_up
std::unique_ptr< FileSpec > m_file_spec_up
Definition: SymbolContext.h:362
lldb::eDescriptionLevelFull
@ eDescriptionLevelFull
Definition: lldb-enumerations.h:209
lldb_private::AddressRange
Definition: AddressRange.h:25
lldb_private::SymbolContext::GetFunctionName
ConstString GetFunctionName(Mangled::NamePreference preference=Mangled::ePreferDemangled) const
Find a name of the innermost function for the symbol context.
Definition: SymbolContext.cpp:650
lldb_private::Symbol::IsExternal
bool IsExternal() const
Definition: Symbol.h:180
lldb_private::SymbolContextSpecifier::m_start_line
size_t m_start_line
Definition: SymbolContext.h:363
lldb_private::InlineFunctionInfo::GetName
ConstString GetName() const
Definition: Function.cpp:96
lldb_private::SymbolContext::GetFunctionBlock
Block * GetFunctionBlock()
Find a block that defines the function represented by this symbol context.
Definition: SymbolContext.cpp:518
lldb_private::SymbolContextList::m_symbol_contexts
collection m_symbol_contexts
The list of symbol contexts.
Definition: SymbolContext.h:469
lldb::eSymbolTypeObjCClass
@ eSymbolTypeObjCClass
Definition: lldb-enumerations.h:646
lldb_private::SymbolContextList::AppendIfUnique
bool AppendIfUnique(const SymbolContext &sc, bool merge_symbol_into_function)
Definition: SymbolContext.cpp:1205
lldb::eSymbolTypeAdditional
@ eSymbolTypeAdditional
When symbols take more than one entry, the extra entries get this type.
Definition: lldb-enumerations.h:641
lldb_private::SymbolContext::variable
Variable * variable
The global variable matching the given query.
Definition: SymbolContext.h:324
lldb_private::CompileUnit::GetPrimaryFile
const FileSpec & GetPrimaryFile() const
Return the primary source file associated with this compile unit.
Definition: CompileUnit.h:227
lldb::eValueTypeVariableArgument
@ eValueTypeVariableArgument
function argument variables
Definition: lldb-enumerations.h:319
lldb_private::SymbolContextSpecifier::m_target_sp
lldb::TargetSP m_target_sp
Definition: SymbolContext.h:359
lldb_private::CompileUnit::GetLanguage
lldb::LanguageType GetLanguage()
Definition: CompileUnit.cpp:150
lldb_private::SymbolContextScope::CalculateSymbolContextBlock
virtual Block * CalculateSymbolContextBlock()
Definition: SymbolContextScope.h:86
lldb_private::LineEntry::column
uint16_t column
The column number of the source line, or zero if there is no column information.
Definition: LineEntry.h:146
lldb_private::Stream::PutChar
size_t PutChar(char ch)
Definition: Stream.cpp:104
lldb_private::Symbol::GetMangled
Mangled & GetMangled()
Definition: Symbol.h:131
lldb_private::ConstString::Dump
void Dump(Stream *s, const char *value_if_empty=nullptr) const
Dump the object description to a stream.
Definition: ConstString.cpp:282
lldb::eSymbolTypeVariable
@ eSymbolTypeVariable
Definition: lldb-enumerations.h:635
lldb::eSymbolTypeScopeEnd
@ eSymbolTypeScopeEnd
Definition: lldb-enumerations.h:640
lldb_private::SymbolContextList::NumLineEntriesWithLine
uint32_t NumLineEntriesWithLine(uint32_t line) const
Definition: SymbolContext.cpp:1278
lldb_private::TypeMap
Definition: TypeMap.h:20
lldb_private::Address::DumpStyleModuleWithFileAddress
@ DumpStyleModuleWithFileAddress
Display as the file address with the module name prepended (if any).
Definition: Address.h:90
lldb_private::CompilerDeclContext
Represents a generic declaration context in a program.
Definition: CompilerDeclContext.h:30
lldb_private::operator!=
bool operator!=(const Address &lhs, const Address &rhs)
Definition: Address.cpp:1022
lldb_private::LineEntry::original_file
FileSpec original_file
The original source file, from debug info.
Definition: LineEntry.h:142
lldb_private::SymbolContextScope
Definition: SymbolContextScope.h:64
lldb_private::SymbolContext::FindBestGlobalDataSymbol
const Symbol * FindBestGlobalDataSymbol(ConstString name, Status &error)
Find the best global data symbol visible from this context.
Definition: SymbolContext.cpp:759
ObjectFile.h
lldb_private::LineEntry::line
uint32_t line
The source line number, or zero if there is no line number information.
Definition: LineEntry.h:143
lldb_private::UserID::GetID
lldb::user_id_t GetID() const
Get accessor for the user ID.
Definition: UserID.h:47
lldb_private::FunctionInfo::GetDeclaration
Declaration & GetDeclaration()
Get accessor for the declaration information.
Definition: Function.cpp:53
lldb_private::SymbolContext::SymbolContext
SymbolContext()
Default constructor.
Definition: SymbolContext.cpp:30
lldb_private::Type::GetDescription
void GetDescription(Stream *s, lldb::DescriptionLevel level, bool show_name, ExecutionContextScope *exe_scope)
Definition: Type.cpp:171
Symbol.h
lldb_private::Symbol::GetName
ConstString GetName() const
Definition: Symbol.cpp:500
lldb_private::SymbolContextSpecifier::eModuleSpecified
@ eModuleSpecified
Definition: SymbolContext.h:332
lldb_private::ModuleSpec
Definition: ModuleSpec.h:27
lldb_private::Symbol::GetDemangledNameIsSynthesized
bool GetDemangledNameIsSynthesized() const
Definition: Symbol.h:209
lldb_private::SymbolContextSpecifier::m_end_line
size_t m_end_line
Definition: SymbolContext.h:364
lldb_private::Declaration::GetLine
uint32_t GetLine() const
Get accessor for the declaration line number.
Definition: Declaration.h:120
lldb_private::CompileUnit::FindLineEntry
uint32_t FindLineEntry(uint32_t start_idx, uint32_t line, const FileSpec *file_spec_ptr, bool exact, LineEntry *line_entry)
Find the line entry by line and optional inlined file spec.
Definition: CompileUnit.cpp:229
lldb::eValueTypeVariableLocal
@ eValueTypeVariableLocal
function local variables
Definition: lldb-enumerations.h:320
lldb_private::Status
Definition: Status.h:44
lldb_private::Symbol::GetReExportedSymbolSharedLibrary
FileSpec GetReExportedSymbolSharedLibrary() const
Definition: Symbol.cpp:139
lldb_private::FileSpec::ClearDirectory
void ClearDirectory()
Clear the directory in this object.
Definition: FileSpec.cpp:357
lldb_private::Address::Dump
bool Dump(Stream *s, ExecutionContextScope *exe_scope, DumpStyle style, DumpStyle fallback_style=DumpStyleInvalid, uint32_t addr_byte_size=UINT32_MAX, bool all_ranges=false) const
Dump a description of this object to a Stream.
Definition: Address.cpp:406
lldb_private::Block
Definition: Block.h:41
lldb_private::AddressRange::Clear
void Clear()
Clear the object's state.
Definition: AddressRange.cpp:143
lldb::eLanguageTypeUnknown
@ eLanguageTypeUnknown
Unknown or invalid language value.
Definition: lldb-enumerations.h:437
lldb_private::SymbolContext::GetDescription
void GetDescription(Stream *s, lldb::DescriptionLevel level, Target *target) const
Definition: SymbolContext.cpp:186
uint32_t
lldb_private::Stream::IndentMore
void IndentMore(unsigned amount=2)
Increment the current indentation level.
Definition: Stream.cpp:168
lldb_private::Block::GetDeclContext
CompilerDeclContext GetDeclContext()
Definition: Block.cpp:480
lldb_private::Address
Definition: Address.h:59
lldb_private::SymbolContext::GetFunctionMethodInfo
bool GetFunctionMethodInfo(lldb::LanguageType &language, bool &is_instance_method, ConstString &language_object_name)
If this symbol context represents a function that is a method, return true and provide information ab...
Definition: SymbolContext.cpp:542
lldb_private::Stream::EOL
size_t EOL()
Output and End of Line character to the stream.
Definition: Stream.cpp:128
lldb_private::SymbolContext::GetResolvedMask
uint32_t GetResolvedMask() const
Definition: SymbolContext.cpp:285
lldb_private::Block::GetRangeAtIndex
bool GetRangeAtIndex(uint32_t range_idx, AddressRange &range)
Definition: Block.cpp:303
lldb_private::Symbol::GetLanguage
lldb::LanguageType GetLanguage() const
Definition: Symbol.h:123
lldb_private::SymbolContextSpecifier::eAddressRangeSpecified
@ eAddressRangeSpecified
Definition: SymbolContext.h:338
lldb_private::Type
Definition: Type.h:66
lldb_private::Symbol::GetByteSize
lldb::addr_t GetByteSize() const
Definition: Symbol.cpp:414
lldb_private::Stream::AsRawOstream
llvm::raw_ostream & AsRawOstream()
Returns a raw_ostream that forwards the data to this Stream object.
Definition: Stream.h:357
UINT32_MAX
#define UINT32_MAX
Definition: lldb-defines.h:19
lldb_private::TypeMap::ForEach
void ForEach(std::function< bool(const lldb::TypeSP &type_sp)> const &callback) const
Definition: TypeMap.cpp:94
lldb::eSymbolTypeObjCMetaClass
@ eSymbolTypeObjCMetaClass
Definition: lldb-enumerations.h:647
lldb_private::SymbolContext::GetParentOfInlinedScope
bool GetParentOfInlinedScope(const Address &curr_frame_pc, SymbolContext &next_frame_sc, Address &inlined_frame_addr) const
Find the block containing the inlined block that contains this block.
Definition: SymbolContext.cpp:437
lldb::eSymbolTypeVariableType
@ eSymbolTypeVariableType
Definition: lldb-enumerations.h:636
lldb_private::LineEntry::range
AddressRange range
The section offset address range for this line entry.
Definition: LineEntry.h:139
lldb_private::SymbolContext::module_sp
lldb::ModuleSP module_sp
The Module for a given query.
Definition: SymbolContext.h:318
lldb_private::AddressRange::SetByteSize
void SetByteSize(lldb::addr_t byte_size)
Set accessor for the byte size of this range.
Definition: AddressRange.h:237
lldb_private::ConstString::GetCString
const char * GetCString() const
Get the string value as a C string.
Definition: ConstString.h:215
lldb_private::Stream::Printf
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:107
lldb_private::Function::GetType
Type * GetType()
Get accessor for the type that describes the function return value type, and parameter types.
Definition: Function.cpp:500
lldb_private::TypeMap::Remove
bool Remove(const lldb::TypeSP &type_sp)
Definition: TypeMap.cpp:110
lldb_private::SymbolContextList::IsEmpty
bool IsEmpty() const
Definition: SymbolContext.cpp:1276
lldb_private::Function::GetMangled
const Mangled & GetMangled() const
Definition: Function.h:538
lldb_private::SymbolContextSpecifier::SpecificationType
SpecificationType
Definition: SymbolContext.h:330
lldb::eSymbolTypeReExported
@ eSymbolTypeReExported
Definition: lldb-enumerations.h:649
SymbolContext.h
lldb_private::LineEntry::Clear
void Clear()
Clear the object's state.
Definition: LineEntry.cpp:33
lldb_private::SymbolContext::Clear
void Clear(bool clear_target)
Clear the object's state.
Definition: SymbolContext.cpp:56
lldb::eValueTypeVariableThreadLocal
@ eValueTypeVariableThreadLocal
thread local storage variable
Definition: lldb-enumerations.h:324
lldb_private::Block::GetRangeIndexContainingAddress
uint32_t GetRangeIndexContainingAddress(const Address &addr)
Definition: Block.cpp:286
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb::eDescriptionLevelVerbose
@ eDescriptionLevelVerbose
Definition: lldb-enumerations.h:210
lldb_private::SymbolContext::GetLanguage
lldb::LanguageType GetLanguage() const
Definition: SymbolContext.cpp:418
lldb_private::TypeList
Definition: TypeList.h:20
lldb::eSymbolTypeLineHeader
@ eSymbolTypeLineHeader
Definition: lldb-enumerations.h:638
lldb_private::Address::GetOffset
lldb::addr_t GetOffset() const
Get the section relative offset value.
Definition: Address.h:319
lldb_private::Variable::GetType
Type * GetType()
Definition: Variable.cpp:96
lldb_private::Module::FindSymbolsWithNameAndType
void FindSymbolsWithNameAndType(ConstString name, lldb::SymbolType symbol_type, SymbolContextList &sc_list)
Definition: Module.cpp:1371
lldb::eSymbolTypeException
@ eSymbolTypeException
Definition: lldb-enumerations.h:627
lldb_private::Block::GetStartAddress
bool GetStartAddress(Address &addr)
Definition: Block.cpp:317
lldb_private::Log
Definition: Log.h:115
lldb::eValueTypeVariableStatic
@ eValueTypeVariableStatic
static variable
Definition: lldb-enumerations.h:318
lldb_private::Block::GetInlinedFunctionInfo
const InlineFunctionInfo * GetInlinedFunctionInfo() const
Get const accessor for any inlined function information.
Definition: Block.h:276
lldb_private::Stream::PutCString
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
Definition: Stream.cpp:63
lldb_private::CompileUnit::GetDescription
void GetDescription(Stream *s, lldb::DescriptionLevel level) const
Definition: CompileUnit.cpp:53
lldb::eSymbolTypeResolver
@ eSymbolTypeResolver
Definition: lldb-enumerations.h:623
lldb_private::SymbolContext::line_entry
LineEntry line_entry
The LineEntry for a given query.
Definition: SymbolContext.h:322
SymbolVendor.h
lldb::eSymbolTypeAbsolute
@ eSymbolTypeAbsolute
Definition: lldb-enumerations.h:621
Variable.h
lldb_private::SymbolContextList::GetDescription
void GetDescription(Stream *s, lldb::DescriptionLevel level, Target *target) const
Definition: SymbolContext.cpp:1288
PATH_MAX
#define PATH_MAX
Definition: windows/PosixApi.h:25
lldb_private::GetLog
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:309
lldb_private::FileSpec::GetPath
size_t GetPath(char *path, size_t max_path_length, bool denormalize=true) const
Extract the full path to the file.
Definition: FileSpec.cpp:364
lldb_private::Symbol::GetType
lldb::SymbolType GetType() const
Definition: Symbol.h:153
lldb::eSymbolTypeLocal
@ eSymbolTypeLocal
Definition: lldb-enumerations.h:633
lldb
Definition: SBAddress.h:15
lldb_private::SymbolContext::GetAddressRangeFromHereToEndLine
bool GetAddressRangeFromHereToEndLine(uint32_t end_line, AddressRange &range, Status &error)
Definition: SymbolContext.cpp:694
lldb_private::Function::GetLanguage
lldb::LanguageType GetLanguage() const
Definition: Function.cpp:643
lldb_private::Block::CalculateSymbolContext
void CalculateSymbolContext(SymbolContext *sc) override
Reconstruct the object's symbol context into sc.
Definition: Block.cpp:136
LLDBLog.h
SymbolFile.h
lldb_private::LineEntry
Definition: LineEntry.h:20
lldb_private::Block::GetContainingInlinedBlock
Block * GetContainingInlinedBlock()
Get the inlined block that contains this block.
Definition: Block.cpp:208
lldb_private::SymbolContextSpecifier::SymbolContextMatches
bool SymbolContextMatches(const SymbolContext &sc)
Definition: SymbolContext.cpp:1011
lldb_private::ObjectFile
Definition: ObjectFile.h:60
lldb::DescriptionLevel
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
Definition: lldb-enumerations.h:207
lldb_private::SymbolContextList::RemoveContextAtIndex
bool RemoveContextAtIndex(size_t idx)
Definition: SymbolContext.cpp:1266
lldb_private::CompilerDeclContext::IsClassMethod
bool IsClassMethod(lldb::LanguageType *language_ptr, bool *is_instance_method_ptr, ConstString *language_object_name_ptr)
Checks if this decl context represents a method of a class.
Definition: CompilerDeclContext.cpp:37
lldb_private::Symbol::GetAddress
Address GetAddress() const
Definition: Symbol.h:73