LLDB  mainline
Symbol.cpp
Go to the documentation of this file.
1 //===-- Symbol.cpp --------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "lldb/Symbol/Symbol.h"
10 
11 #include "lldb/Core/Module.h"
12 #include "lldb/Core/ModuleSpec.h"
13 #include "lldb/Core/Section.h"
14 #include "lldb/Symbol/Function.h"
15 #include "lldb/Symbol/ObjectFile.h"
17 #include "lldb/Symbol/Symtab.h"
18 #include "lldb/Target/Process.h"
19 #include "lldb/Target/Target.h"
21 #include "lldb/Utility/Stream.h"
22 
23 using namespace lldb;
24 using namespace lldb_private;
25 
26 Symbol::Symbol()
27  : SymbolContextScope(), m_type_data_resolved(false), m_is_synthetic(false),
28  m_is_debug(false), m_is_external(false), m_size_is_sibling(false),
29  m_size_is_synthesized(false), m_size_is_valid(false),
30  m_demangled_is_synthesized(false), m_contains_linker_annotations(false),
31  m_is_weak(false), m_type(eSymbolTypeInvalid), m_mangled(),
32  m_addr_range() {}
33 
34 Symbol::Symbol(uint32_t symID, llvm::StringRef name, SymbolType type,
35  bool external, bool is_debug, bool is_trampoline,
36  bool is_artificial, const lldb::SectionSP &section_sp,
37  addr_t offset, addr_t size, bool size_is_valid,
38  bool contains_linker_annotations, uint32_t flags)
39  : SymbolContextScope(), m_uid(symID), m_type_data_resolved(false),
40  m_is_synthetic(is_artificial), m_is_debug(is_debug),
41  m_is_external(external), m_size_is_sibling(false),
42  m_size_is_synthesized(false), m_size_is_valid(size_is_valid || size > 0),
43  m_demangled_is_synthesized(false),
44  m_contains_linker_annotations(contains_linker_annotations),
45  m_is_weak(false), m_type(type), m_mangled(name),
46  m_addr_range(section_sp, offset, size), m_flags(flags) {}
47 
48 Symbol::Symbol(uint32_t symID, const Mangled &mangled, SymbolType type,
49  bool external, bool is_debug, bool is_trampoline,
50  bool is_artificial, const AddressRange &range,
51  bool size_is_valid, bool contains_linker_annotations,
52  uint32_t flags)
53  : SymbolContextScope(), m_uid(symID), m_type_data_resolved(false),
54  m_is_synthetic(is_artificial), m_is_debug(is_debug),
55  m_is_external(external), m_size_is_sibling(false),
56  m_size_is_synthesized(false),
57  m_size_is_valid(size_is_valid || range.GetByteSize() > 0),
58  m_demangled_is_synthesized(false),
59  m_contains_linker_annotations(contains_linker_annotations),
60  m_is_weak(false), m_type(type), m_mangled(mangled), m_addr_range(range),
61  m_flags(flags) {}
62 
64  : SymbolContextScope(rhs), m_uid(rhs.m_uid), m_type_data(rhs.m_type_data),
65  m_type_data_resolved(rhs.m_type_data_resolved),
66  m_is_synthetic(rhs.m_is_synthetic), m_is_debug(rhs.m_is_debug),
67  m_is_external(rhs.m_is_external),
68  m_size_is_sibling(rhs.m_size_is_sibling), m_size_is_synthesized(false),
69  m_size_is_valid(rhs.m_size_is_valid),
70  m_demangled_is_synthesized(rhs.m_demangled_is_synthesized),
71  m_contains_linker_annotations(rhs.m_contains_linker_annotations),
72  m_is_weak(rhs.m_is_weak), m_type(rhs.m_type), m_mangled(rhs.m_mangled),
73  m_addr_range(rhs.m_addr_range), m_flags(rhs.m_flags) {}
74 
75 const Symbol &Symbol::operator=(const Symbol &rhs) {
76  if (this != &rhs) {
77  SymbolContextScope::operator=(rhs);
78  m_uid = rhs.m_uid;
82  m_is_debug = rhs.m_is_debug;
89  m_is_weak = rhs.m_is_weak;
90  m_type = rhs.m_type;
91  m_mangled = rhs.m_mangled;
93  m_flags = rhs.m_flags;
94  }
95  return *this;
96 }
97 
98 void Symbol::Clear() {
99  m_uid = UINT32_MAX;
100  m_mangled.Clear();
101  m_type_data = 0;
102  m_type_data_resolved = false;
103  m_is_synthetic = false;
104  m_is_debug = false;
105  m_is_external = false;
106  m_size_is_sibling = false;
107  m_size_is_synthesized = false;
108  m_size_is_valid = false;
111  m_is_weak = false;
113  m_flags = 0;
115 }
116 
118  return (bool)m_addr_range.GetBaseAddress().GetSection();
119 }
120 
122  return GetMangled().GetDisplayDemangledName();
123 }
124 
126  if (m_type == eSymbolTypeReExported) {
127  // For eSymbolTypeReExported, the "const char *" from a ConstString is used
128  // as the offset in the address range base address. We can then make this
129  // back into a string that is the re-exported name.
130  intptr_t str_ptr = m_addr_range.GetBaseAddress().GetOffset();
131  if (str_ptr != 0)
132  return ConstString((const char *)str_ptr);
133  else
134  return GetName();
135  }
136  return ConstString();
137 }
138 
140  if (m_type == eSymbolTypeReExported) {
141  // For eSymbolTypeReExported, the "const char *" from a ConstString is used
142  // as the offset in the address range base address. We can then make this
143  // back into a string that is the re-exported name.
144  intptr_t str_ptr = m_addr_range.GetByteSize();
145  if (str_ptr != 0)
146  return FileSpec((const char *)str_ptr);
147  }
148  return FileSpec();
149 }
150 
153  // For eSymbolTypeReExported, the "const char *" from a ConstString is used
154  // as the offset in the address range base address.
155  m_addr_range.GetBaseAddress().SetOffset((uintptr_t)name.GetCString());
156 }
157 
159  if (m_type == eSymbolTypeReExported) {
160  // For eSymbolTypeReExported, the "const char *" from a ConstString is used
161  // as the offset in the address range base address.
163  (uintptr_t)ConstString(fspec.GetPath().c_str()).GetCString());
164  return true;
165  }
166  return false;
167 }
168 
171 }
172 
174 
175 bool Symbol::IsIndirect() const { return m_type == eSymbolTypeResolver; }
176 
178  Target *target) const {
179  s->Printf("id = {0x%8.8x}", m_uid);
180 
182  if (ValueIsAddress()) {
183  const lldb::addr_t byte_size = GetByteSize();
184  if (byte_size > 0) {
185  s->PutCString(", range = ");
188  } else {
189  s->PutCString(", address = ");
190  m_addr_range.GetBaseAddress().Dump(s, target,
193  }
194  } else
195  s->Printf(", value = 0x%16.16" PRIx64,
197  } else {
198  if (m_size_is_sibling)
199  s->Printf(", sibling = %5" PRIu64,
201  else
202  s->Printf(", value = 0x%16.16" PRIx64,
204  }
205  ConstString demangled = GetMangled().GetDemangledName();
206  if (demangled)
207  s->Printf(", name=\"%s\"", demangled.AsCString());
208  if (m_mangled.GetMangledName())
209  s->Printf(", mangled=\"%s\"", m_mangled.GetMangledName().AsCString());
210 }
211 
212 void Symbol::Dump(Stream *s, Target *target, uint32_t index,
213  Mangled::NamePreference name_preference) const {
214  s->Printf("[%5u] %6u %c%c%c %-15s ", index, GetID(), m_is_debug ? 'D' : ' ',
215  m_is_synthetic ? 'S' : ' ', m_is_external ? 'X' : ' ',
216  GetTypeAsString());
217 
218  // Make sure the size of the symbol is up to date before dumping
219  GetByteSize();
220 
221  ConstString name = GetMangled().GetName(name_preference);
222  if (ValueIsAddress()) {
223  if (!m_addr_range.GetBaseAddress().Dump(s, nullptr,
225  s->Printf("%*s", 18, "");
226 
227  s->PutChar(' ');
228 
229  if (!m_addr_range.GetBaseAddress().Dump(s, target,
231  s->Printf("%*s", 18, "");
232 
233  const char *format = m_size_is_sibling ? " Sibling -> [%5llu] 0x%8.8x %s\n"
234  : " 0x%16.16" PRIx64 " 0x%8.8x %s\n";
235  s->Printf(format, GetByteSize(), m_flags, name.AsCString(""));
236  } else if (m_type == eSymbolTypeReExported) {
237  s->Printf(
238  " 0x%8.8x %s",
239  m_flags, name.AsCString(""));
240 
241  ConstString reexport_name = GetReExportedSymbolName();
242  intptr_t shlib = m_addr_range.GetByteSize();
243  if (shlib)
244  s->Printf(" -> %s`%s\n", (const char *)shlib, reexport_name.GetCString());
245  else
246  s->Printf(" -> %s\n", reexport_name.GetCString());
247  } else {
248  const char *format =
250  ? "0x%16.16" PRIx64
251  " Sibling -> [%5llu] 0x%8.8x %s\n"
252  : "0x%16.16" PRIx64 " 0x%16.16" PRIx64
253  " 0x%8.8x %s\n";
255  m_flags, name.AsCString(""));
256  }
257 }
258 
261  if (!m_type_data_resolved) {
262  m_type_data_resolved = true;
263 
264  const Address &base_address = m_addr_range.GetBaseAddress();
265  Function *function = base_address.CalculateSymbolContextFunction();
266  if (function) {
267  // Functions have line entries which can also potentially have end of
268  // prologue information. So if this symbol points to a function, use
269  // the prologue information from there.
270  m_type_data = function->GetPrologueByteSize();
271  } else {
272  ModuleSP module_sp(base_address.GetModule());
273  SymbolContext sc;
274  if (module_sp) {
275  uint32_t resolved_flags = module_sp->ResolveSymbolContextForAddress(
276  base_address, eSymbolContextLineEntry, sc);
277  if (resolved_flags & eSymbolContextLineEntry) {
278  // Default to the end of the first line entry.
280 
281  // Set address for next line.
282  Address addr(base_address);
283  addr.Slide(m_type_data);
284 
285  // Check the first few instructions and look for one that has a
286  // line number that is different than the first entry. This is also
287  // done in Function::GetPrologueByteSize().
288  uint16_t total_offset = m_type_data;
289  for (int idx = 0; idx < 6; ++idx) {
290  SymbolContext sc_temp;
291  resolved_flags = module_sp->ResolveSymbolContextForAddress(
292  addr, eSymbolContextLineEntry, sc_temp);
293  // Make sure we got line number information...
294  if (!(resolved_flags & eSymbolContextLineEntry))
295  break;
296 
297  // If this line number is different than our first one, use it
298  // and we're done.
299  if (sc_temp.line_entry.line != sc.line_entry.line) {
300  m_type_data = total_offset;
301  break;
302  }
303 
304  // Slide addr up to the next line address.
305  addr.Slide(sc_temp.line_entry.range.GetByteSize());
306  total_offset += sc_temp.line_entry.range.GetByteSize();
307  // If we've gone too far, bail out.
308  if (total_offset >= m_addr_range.GetByteSize())
309  break;
310  }
311 
312  // Sanity check - this may be a function in the middle of code that
313  // has debug information, but not for this symbol. So the line
314  // entries surrounding us won't lie inside our function. In that
315  // case, the line entry will be bigger than we are, so we do that
316  // quick check and if that is true, we just return 0.
318  m_type_data = 0;
319  } else {
320  // TODO: expose something in Process to figure out the
321  // size of a function prologue.
322  m_type_data = 0;
323  }
324  }
325  }
326  }
327  return m_type_data;
328  }
329  return 0;
330 }
331 
332 bool Symbol::Compare(ConstString name, SymbolType type) const {
333  if (type == eSymbolTypeAny || m_type == type) {
334  const Mangled &mangled = GetMangled();
335  return mangled.GetMangledName() == name ||
336  mangled.GetDemangledName() == name;
337  }
338  return false;
339 }
340 
341 #define ENUM_TO_CSTRING(x) \
342  case eSymbolType##x: \
343  return #x;
344 
345 const char *Symbol::GetTypeAsString() const {
346  switch (m_type) {
348  ENUM_TO_CSTRING(Absolute);
349  ENUM_TO_CSTRING(Code);
350  ENUM_TO_CSTRING(Resolver);
351  ENUM_TO_CSTRING(Data);
352  ENUM_TO_CSTRING(Trampoline);
355  ENUM_TO_CSTRING(SourceFile);
356  ENUM_TO_CSTRING(HeaderFile);
358  ENUM_TO_CSTRING(CommonBlock);
360  ENUM_TO_CSTRING(Local);
361  ENUM_TO_CSTRING(Param);
363  ENUM_TO_CSTRING(VariableType);
365  ENUM_TO_CSTRING(LineHeader);
366  ENUM_TO_CSTRING(ScopeBegin);
367  ENUM_TO_CSTRING(ScopeEnd);
368  ENUM_TO_CSTRING(Additional);
369  ENUM_TO_CSTRING(Compiler);
370  ENUM_TO_CSTRING(Instrumentation);
371  ENUM_TO_CSTRING(Undefined);
372  ENUM_TO_CSTRING(ObjCClass);
373  ENUM_TO_CSTRING(ObjCMetaClass);
374  ENUM_TO_CSTRING(ObjCIVar);
375  ENUM_TO_CSTRING(ReExported);
376  default:
377  break;
378  }
379  return "<unknown SymbolType>";
380 }
381 
383  // Symbols can reconstruct the symbol and the module in the symbol context
384  sc->symbol = this;
385  if (ValueIsAddress())
387  else
388  sc->module_sp.reset();
389 }
390 
392  if (ValueIsAddress())
393  return GetAddressRef().GetModule();
394  return ModuleSP();
395 }
396 
398 
400  bool dumped_module = false;
401  if (ValueIsAddress()) {
402  ModuleSP module_sp(GetAddressRef().GetModule());
403  if (module_sp) {
404  dumped_module = true;
405  module_sp->DumpSymbolContext(s);
406  }
407  }
408  if (dumped_module)
409  s->PutCString(", ");
410 
411  s->Printf("Symbol{0x%8.8x}", GetID());
412 }
413 
415 
417  Target &target, ConstString &reexport_name, ModuleSpec &module_spec,
418  ModuleList &seen_modules) const {
419  ModuleSP module_sp;
420  if (module_spec.GetFileSpec()) {
421  // Try searching for the module file spec first using the full path
422  module_sp = target.GetImages().FindFirstModule(module_spec);
423  if (!module_sp) {
424  // Next try and find the module by basename in case environment variables
425  // or other runtime trickery causes shared libraries to be loaded from
426  // alternate paths
427  module_spec.GetFileSpec().ClearDirectory();
428  module_sp = target.GetImages().FindFirstModule(module_spec);
429  }
430  }
431 
432  if (module_sp) {
433  // There should not be cycles in the reexport list, but we don't want to
434  // crash if there are so make sure we haven't seen this before:
435  if (!seen_modules.AppendIfNeeded(module_sp))
436  return nullptr;
437 
439  module_sp->FindSymbolsWithNameAndType(reexport_name, eSymbolTypeAny,
440  sc_list);
441  const size_t num_scs = sc_list.GetSize();
442  if (num_scs > 0) {
443  for (size_t i = 0; i < num_scs; ++i) {
445  if (sc_list.GetContextAtIndex(i, sc)) {
446  if (sc.symbol->IsExternal())
447  return sc.symbol;
448  }
449  }
450  }
451  // If we didn't find the symbol in this module, it may be because this
452  // module re-exports some whole other library. We have to search those as
453  // well:
454  seen_modules.Append(module_sp);
455 
456  FileSpecList reexported_libraries =
457  module_sp->GetObjectFile()->GetReExportedLibraries();
458  size_t num_reexported_libraries = reexported_libraries.GetSize();
459  for (size_t idx = 0; idx < num_reexported_libraries; idx++) {
460  ModuleSpec reexported_module_spec;
461  reexported_module_spec.GetFileSpec() =
462  reexported_libraries.GetFileSpecAtIndex(idx);
464  target, reexport_name, reexported_module_spec, seen_modules);
465  if (result_symbol)
466  return result_symbol;
467  }
468  }
469  return nullptr;
470 }
471 
473  ConstString reexport_name(GetReExportedSymbolName());
474  if (reexport_name) {
475  ModuleSpec module_spec;
476  ModuleList seen_modules;
478  if (module_spec.GetFileSpec()) {
479  return ResolveReExportedSymbolInModuleSpec(target, reexport_name,
480  module_spec, seen_modules);
481  }
482  }
483  return nullptr;
484 }
485 
487  if (ValueIsAddress())
488  return GetAddressRef().GetFileAddress();
489  else
490  return LLDB_INVALID_ADDRESS;
491 }
492 
494  if (ValueIsAddress())
495  return GetAddressRef().GetLoadAddress(target);
496  else
497  return LLDB_INVALID_ADDRESS;
498 }
499 
500 ConstString Symbol::GetName() const { return GetMangled().GetName(); }
501 
503  return GetMangled().GetName(Mangled::ePreferDemangledWithoutArguments);
504 }
505 
508  return LLDB_INVALID_ADDRESS;
509 
510  Address func_so_addr;
511 
512  bool is_indirect = IsIndirect();
513  if (GetType() == eSymbolTypeReExported) {
514  Symbol *reexported_symbol = ResolveReExportedSymbol(target);
515  if (reexported_symbol) {
516  func_so_addr = reexported_symbol->GetAddress();
517  is_indirect = reexported_symbol->IsIndirect();
518  }
519  } else {
520  func_so_addr = GetAddress();
521  is_indirect = IsIndirect();
522  }
523 
524  if (func_so_addr.IsValid()) {
525  if (!target.GetProcessSP() && is_indirect) {
526  // can't resolve indirect symbols without calling a function...
527  return LLDB_INVALID_ADDRESS;
528  }
529 
530  lldb::addr_t load_addr =
531  func_so_addr.GetCallableLoadAddress(&target, is_indirect);
532 
533  if (load_addr != LLDB_INVALID_ADDRESS) {
534  return load_addr;
535  }
536  }
537 
538  return LLDB_INVALID_ADDRESS;
539 }
540 
541 lldb::DisassemblerSP Symbol::GetInstructions(const ExecutionContext &exe_ctx,
542  const char *flavor,
543  bool prefer_file_cache) {
544  ModuleSP module_sp(m_addr_range.GetBaseAddress().GetModule());
545  if (module_sp && exe_ctx.HasTargetScope()) {
546  return Disassembler::DisassembleRange(module_sp->GetArchitecture(), nullptr,
547  flavor, exe_ctx.GetTargetRef(),
548  m_addr_range, !prefer_file_cache);
549  }
550  return lldb::DisassemblerSP();
551 }
552 
553 bool Symbol::GetDisassembly(const ExecutionContext &exe_ctx, const char *flavor,
554  bool prefer_file_cache, Stream &strm) {
555  lldb::DisassemblerSP disassembler_sp =
556  GetInstructions(exe_ctx, flavor, prefer_file_cache);
557  if (disassembler_sp) {
558  const bool show_address = true;
559  const bool show_bytes = false;
560  const bool show_control_flow_kind = false;
561  disassembler_sp->GetInstructionList().Dump(
562  &strm, show_address, show_bytes, show_control_flow_kind, &exe_ctx);
563  return true;
564  }
565  return false;
566 }
567 
569  return m_addr_range.ContainsFileAddress(file_addr);
570 }
571 
573  if (!IsSynthetic())
574  return false;
575  if (!m_mangled)
576  return true;
577  ConstString demangled = m_mangled.GetDemangledName();
578  return demangled.GetStringRef().startswith(GetSyntheticSymbolPrefix());
579 }
580 
582  if (m_is_synthetic && !m_mangled) {
583  // Synthetic symbol names don't mean anything, but they do uniquely
584  // identify individual symbols so we give them a unique name. The name
585  // starts with the synthetic symbol prefix, followed by a unique number.
586  // Typically the UserID of a real symbol is the symbol table index of the
587  // symbol in the object file's symbol table(s), so it will be the same
588  // every time you read in the object file. We want the same persistence for
589  // synthetic symbols so that users can identify them across multiple debug
590  // sessions, to understand crashes in those symbols and to reliably set
591  // breakpoints on them.
592  llvm::SmallString<256> name;
593  llvm::raw_svector_ostream os(name);
594  os << GetSyntheticSymbolPrefix() << GetID();
595  m_mangled.SetDemangledName(ConstString(os.str()));
596  }
597 }
598 
599 bool Symbol::Decode(const DataExtractor &data, lldb::offset_t *offset_ptr,
600  const SectionList *section_list,
601  const StringTableReader &strtab) {
602  if (!data.ValidOffsetForDataOfSize(*offset_ptr, 8))
603  return false;
604  m_uid = data.GetU32(offset_ptr);
605  m_type_data = data.GetU16(offset_ptr);
606  const uint16_t bitfields = data.GetU16(offset_ptr);
607  m_type_data_resolved = (1u << 15 & bitfields) != 0;
608  m_is_synthetic = (1u << 14 & bitfields) != 0;
609  m_is_debug = (1u << 13 & bitfields) != 0;
610  m_is_external = (1u << 12 & bitfields) != 0;
611  m_size_is_sibling = (1u << 11 & bitfields) != 0;
612  m_size_is_synthesized = (1u << 10 & bitfields) != 0;
613  m_size_is_valid = (1u << 9 & bitfields) != 0;
614  m_demangled_is_synthesized = (1u << 8 & bitfields) != 0;
615  m_contains_linker_annotations = (1u << 7 & bitfields) != 0;
616  m_is_weak = (1u << 6 & bitfields) != 0;
617  m_type = bitfields & 0x003f;
618  if (!m_mangled.Decode(data, offset_ptr, strtab))
619  return false;
620  if (!data.ValidOffsetForDataOfSize(*offset_ptr, 20))
621  return false;
622  const bool is_addr = data.GetU8(offset_ptr) != 0;
623  const uint64_t value = data.GetU64(offset_ptr);
624  if (is_addr) {
626  value, section_list);
627  } else {
630  }
631  m_addr_range.SetByteSize(data.GetU64(offset_ptr));
632  m_flags = data.GetU32(offset_ptr);
633  return true;
634 }
635 
636 /// The encoding format for the symbol is as follows:
637 ///
638 /// uint32_t m_uid;
639 /// uint16_t m_type_data;
640 /// uint16_t bitfield_data;
641 /// Mangled mangled;
642 /// uint8_t is_addr;
643 /// uint64_t file_addr_or_value;
644 /// uint64_t size;
645 /// uint32_t flags;
646 ///
647 /// The only tricky thing in this encoding is encoding all of the bits in the
648 /// bitfields. We use a trick to store all bitfields as a 16 bit value and we
649 /// do the same thing when decoding the symbol. There are test that ensure this
650 /// encoding works for each individual bit. Everything else is very easy to
651 /// store.
652 void Symbol::Encode(DataEncoder &file, ConstStringTable &strtab) const {
653  file.AppendU32(m_uid);
654  file.AppendU16(m_type_data);
655  uint16_t bitfields = m_type;
657  bitfields |= 1u << 15;
658  if (m_is_synthetic)
659  bitfields |= 1u << 14;
660  if (m_is_debug)
661  bitfields |= 1u << 13;
662  if (m_is_external)
663  bitfields |= 1u << 12;
664  if (m_size_is_sibling)
665  bitfields |= 1u << 11;
667  bitfields |= 1u << 10;
668  if (m_size_is_valid)
669  bitfields |= 1u << 9;
671  bitfields |= 1u << 8;
673  bitfields |= 1u << 7;
674  if (m_is_weak)
675  bitfields |= 1u << 6;
676  file.AppendU16(bitfields);
677  m_mangled.Encode(file, strtab);
678  // A symbol's value might be an address, or it might be a constant. If the
679  // symbol's base address doesn't have a section, then it is a constant value.
680  // If it does have a section, we will encode the file address and re-resolve
681  // the address when we decode it.
682  bool is_addr = m_addr_range.GetBaseAddress().GetSection().get() != nullptr;
683  file.AppendU8(is_addr);
684  file.AppendU64(m_addr_range.GetBaseAddress().GetFileAddress());
685  file.AppendU64(m_addr_range.GetByteSize());
686  file.AppendU32(m_flags);
687 }
688 
689 bool Symbol::operator==(const Symbol &rhs) const {
690  if (m_uid != rhs.m_uid)
691  return false;
692  if (m_type_data != rhs.m_type_data)
693  return false;
695  return false;
696  if (m_is_synthetic != rhs.m_is_synthetic)
697  return false;
698  if (m_is_debug != rhs.m_is_debug)
699  return false;
700  if (m_is_external != rhs.m_is_external)
701  return false;
703  return false;
705  return false;
706  if (m_size_is_valid != rhs.m_size_is_valid)
707  return false;
709  return false;
711  return false;
712  if (m_is_weak != rhs.m_is_weak)
713  return false;
714  if (m_type != rhs.m_type)
715  return false;
716  if (m_mangled != rhs.m_mangled)
717  return false;
719  return false;
721  return false;
722  if (m_flags != rhs.m_flags)
723  return false;
724  return true;
725 }
lldb_private::AddressRange::GetBaseAddress
Address & GetBaseAddress()
Get accessor for the base address of the range.
Definition: AddressRange.h:209
lldb_private::ExecutionContext
Definition: ExecutionContext.h:292
lldb_private::CompilerContextKind::Invalid
@ Invalid
lldb_private::Symbol::m_type
uint16_t m_type
Definition: Symbol.h:324
lldb_private::Symbol::Encode
void Encode(DataEncoder &encoder, ConstStringTable &strtab) const
Encode this object into a data encoder object.
Definition: Symbol.cpp:652
lldb_private::ExecutionContext::HasTargetScope
bool HasTargetScope() const
Returns true the ExecutionContext object contains a valid target.
Definition: ExecutionContext.cpp:379
lldb_private::StringTableReader
Many cache files require string tables to store data efficiently.
Definition: DataFileCache.h:212
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::Symbol::Decode
bool Decode(const DataExtractor &data, lldb::offset_t *offset_ptr, const SectionList *section_list, const StringTableReader &strtab)
Decode a serialized version of this object from data.
Definition: Symbol.cpp:599
lldb_private::Symbol::GetPrologueByteSize
uint32_t GetPrologueByteSize()
Definition: Symbol.cpp:259
lldb_private::Symbol::GetSyntheticSymbolPrefix
static llvm::StringRef GetSyntheticSymbolPrefix()
Definition: Symbol.h:244
ModuleSpec.h
lldb_private::Address::CalculateSymbolContextFunction
Function * CalculateSymbolContextFunction() const
Definition: Address.cpp:865
lldb_private::Symbol::GetDescription
void GetDescription(Stream *s, lldb::DescriptionLevel level, Target *target) const
Definition: Symbol.cpp:177
lldb_private::Symbol
Definition: Symbol.h:20
lldb_private::Symbol::ValueIsAddress
bool ValueIsAddress() const
Definition: Symbol.cpp:117
lldb::eSymbolTypeInvalid
@ eSymbolTypeInvalid
Definition: lldb-enumerations.h:620
lldb_private::Symbol::DumpSymbolContext
void DumpSymbolContext(Stream *s) override
Dump the object's symbol context to the stream s.
Definition: Symbol.cpp:399
lldb_private::Address::DumpStyleFileAddress
@ DumpStyleFileAddress
Display as the file address (if any).
Definition: Address.h:84
lldb_private::ConstStringTable
Many cache files require string tables to store data efficiently.
Definition: DataFileCache.h:180
lldb::eSymbolTypeTrampoline
@ eSymbolTypeTrampoline
Definition: lldb-enumerations.h:625
lldb_private::AddressRange::GetByteSize
lldb::addr_t GetByteSize() const
Get accessor for the byte size of this range.
Definition: AddressRange.h:221
Module.h
lldb_private::Symbol::m_size_is_valid
uint16_t m_size_is_valid
Definition: Symbol.h:316
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::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::Symbol::SetType
void SetType(lldb::SymbolType type)
Definition: Symbol.h:155
lldb_private::SectionList
Definition: Section.h:34
lldb_private::Symbol::CalculateSymbolContextModule
lldb::ModuleSP CalculateSymbolContextModule() override
Definition: Symbol.cpp:391
lldb::offset_t
uint64_t offset_t
Definition: lldb-types.h:87
lldb_private::Symbol::GetReExportedSymbolName
ConstString GetReExportedSymbolName() const
Definition: Symbol.cpp:125
lldb_private::Symbol::CalculateSymbolContextSymbol
Symbol * CalculateSymbolContextSymbol() override
Definition: Symbol.cpp:397
lldb_private::Stream
Definition: Stream.h:28
lldb_private::Symbol::m_uid
uint32_t m_uid
Definition: Symbol.h:300
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
lldb_private::Symbol::IsSyntheticWithAutoGeneratedName
bool IsSyntheticWithAutoGeneratedName() const
Definition: Symbol.cpp:572
lldb_private::SymbolContext
Definition: SymbolContext.h:33
lldb_private::Target
Definition: Target.h:469
Section.h
lldb_private::DataExtractor::GetU64
uint64_t GetU64(lldb::offset_t *offset_ptr) const
Extract a uint64_t value from *offset_ptr.
Definition: DataExtractor.cpp:474
lldb_private::Target::GetImages
const ModuleList & GetImages() const
Get accessor for the images for this process.
Definition: Target.h:947
lldb_private::Symbol::m_mangled
Mangled m_mangled
Definition: Symbol.h:325
Process.h
lldb_private::Symbol::ResolveCallableAddress
lldb::addr_t ResolveCallableAddress(Target &target) const
Definition: Symbol.cpp:506
lldb_private::Symbol::m_is_synthetic
uint16_t m_is_synthetic
Definition: Symbol.h:305
Target.h
lldb_private::Symbol::m_type_data_resolved
uint16_t m_type_data_resolved
Definition: Symbol.h:303
lldb_private::Symbol::ContainsFileAddress
bool ContainsFileAddress(lldb::addr_t file_addr) const
Definition: Symbol.cpp:568
lldb_private::Symbol::Dump
void Dump(Stream *s, Target *target, uint32_t index, Mangled::NamePreference name_preference=Mangled::ePreferDemangled) const
Definition: Symbol.cpp:212
lldb_private::FileSpec
Definition: FileSpec.h:55
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_private::Function
Definition: Function.h:409
lldb_private::Disassembler::DisassembleRange
static lldb::DisassemblerSP DisassembleRange(const ArchSpec &arch, const char *plugin_name, const char *flavor, Target &target, const AddressRange &disasm_range, bool force_live_memory=false)
Definition: Disassembler.cpp:122
lldb_private::Address::DumpStyleLoadAddress
@ DumpStyleLoadAddress
Display as the load address (if resolved).
Definition: Address.h:96
lldb_private::DataExtractor
Definition: DataExtractor.h:48
lldb_private::ConstString::GetStringRef
llvm::StringRef GetStringRef() const
Get the string value as a llvm::StringRef.
Definition: ConstString.h:201
lldb_private::ModuleList
Definition: ModuleList.h:82
lldb::eSymbolTypeUndefined
@ eSymbolTypeUndefined
Definition: lldb-enumerations.h:645
lldb_private::Symbol::SetReExportedSymbolSharedLibrary
bool SetReExportedSymbolSharedLibrary(const FileSpec &fspec)
Definition: Symbol.cpp:158
lldb_private::Symbol::m_size_is_sibling
uint16_t m_size_is_sibling
Definition: Symbol.h:311
lldb_private::Address::GetCallableLoadAddress
lldb::addr_t GetCallableLoadAddress(Target *target, bool is_indirect=false) const
Get the load address as a callable code load address.
Definition: Address.cpp:336
lldb_private::Symbol::m_demangled_is_synthesized
uint16_t m_demangled_is_synthesized
Definition: Symbol.h:317
lldb_private::Symbol::CalculateSymbolContext
void CalculateSymbolContext(SymbolContext *sc) override
Reconstruct the object's symbol context into sc.
Definition: Symbol.cpp:382
lldb_private::Address::GetFileAddress
lldb::addr_t GetFileAddress() const
Get the file address.
Definition: Address.cpp:291
lldb_private::Symbol::GetAddressRef
Address & GetAddressRef()
Definition: Symbol.h:57
lldb_private::Symbol::GetInstructions
lldb::DisassemblerSP GetInstructions(const ExecutionContext &exe_ctx, const char *flavor, bool prefer_file_cache)
Definition: Symbol.cpp:541
lldb_private::Symbol::operator=
const Symbol & operator=(const Symbol &rhs)
Definition: Symbol.cpp:75
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::Symbol::Clear
void Clear()
Definition: Symbol.cpp:98
lldb_private::DataExtractor::GetU8
uint8_t GetU8(lldb::offset_t *offset_ptr) const
Extract a uint8_t value from *offset_ptr.
Definition: DataExtractor.cpp:316
lldb_private::Symbol::m_contains_linker_annotations
uint16_t m_contains_linker_annotations
Definition: Symbol.h:320
lldb_private::AddressRange
Definition: AddressRange.h:25
lldb_private::ModuleList::FindFirstModule
lldb::ModuleSP FindFirstModule(const ModuleSpec &module_spec) const
Definition: ModuleList.cpp:623
DataEncoder.h
lldb_private::Symbol::IsExternal
bool IsExternal() const
Definition: Symbol.h:180
lldb_private::Symbol::Compare
bool Compare(ConstString name, lldb::SymbolType type) const
Definition: Symbol.cpp:332
lldb_private::Symbol::IsSynthetic
bool IsSynthetic() const
Definition: Symbol.h:166
lldb_private::Address::GetSection
lldb::SectionSP GetSection() const
Get const accessor for the section.
Definition: Address.h:429
lldb_private::WindowsLog::Exception
@ Exception
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::Symbol::GetTypeAsString
const char * GetTypeAsString() const
Definition: Symbol.cpp:345
lldb::SymbolType
SymbolType
Symbol types.
Definition: lldb-enumerations.h:618
lldb_private::Runtime
Definition: Runtime.h:15
lldb_private::Symbol::m_is_external
uint16_t m_is_external
Definition: Symbol.h:310
lldb_private::SymbolContextScope
Definition: SymbolContextScope.h:64
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::AddressRange::ContainsFileAddress
bool ContainsFileAddress(const Address &so_addr) const
Check if a section offset address is contained in this range.
Definition: AddressRange.cpp:62
Symbol.h
lldb_private::Symbol::GetName
ConstString GetName() const
Definition: Symbol.cpp:500
lldb_private::Symbol::m_flags
uint32_t m_flags
Definition: Symbol.h:329
lldb_private::Target::GetProcessSP
const lldb::ProcessSP & GetProcessSP() const
Definition: Target.cpp:217
lldb_private::Symbol::Symbol
Symbol()
Definition: Symbol.cpp:26
lldb_private::ModuleSpec::GetFileSpec
FileSpec & GetFileSpec()
Definition: ModuleSpec.h:53
lldb_private::ModuleSpec
Definition: ModuleSpec.h:27
lldb_private::Symbol::GetDisassembly
bool GetDisassembly(const ExecutionContext &exe_ctx, const char *flavor, bool prefer_file_cache, Stream &strm)
Definition: Symbol.cpp:553
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
uint32_t
lldb_private::AddressRange::Dump
bool Dump(Stream *s, Target *target, Address::DumpStyle style, Address::DumpStyle fallback_style=Address::DumpStyleInvalid) const
Dump a description of this object to a Stream.
Definition: AddressRange.cpp:148
lldb_private::Address
Definition: Address.h:59
lldb_private::ModuleList::AppendIfNeeded
bool AppendIfNeeded(const lldb::ModuleSP &new_module, bool notify=true)
Append a module to the module list, if it is not already there.
Symtab.h
lldb_private::Address::GetLoadAddress
lldb::addr_t GetLoadAddress(Target *target) const
Get the load address.
Definition: Address.cpp:311
lldb_private::Address::ResolveAddressUsingFileSections
bool ResolveAddressUsingFileSections(lldb::addr_t addr, const SectionList *sections)
Resolve a file virtual address using a section list.
Definition: Address.cpp:248
lldb_private::Symbol::GetByteSize
lldb::addr_t GetByteSize() const
Definition: Symbol.cpp:414
UINT32_MAX
#define UINT32_MAX
Definition: lldb-defines.h:19
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
uint16_t
lldb_private::Symbol::SynthesizeNameIfNeeded
void SynthesizeNameIfNeeded() const
Definition: Symbol.cpp:581
lldb_private::Symbol::GetFileAddress
lldb::addr_t GetFileAddress() const
Definition: Symbol.cpp:486
lldb_private::DataExtractor::GetU32
uint32_t GetU32(lldb::offset_t *offset_ptr) const
Extract a uint32_t value from *offset_ptr.
Definition: DataExtractor.cpp:425
lldb_private::Address::SetOffset
bool SetOffset(lldb::addr_t offset)
Set accessor for the offset.
Definition: Address.h:438
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_INVALID_ADDRESS
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:74
lldb_private::ConstString::GetCString
const char * GetCString() const
Get the string value as a C string.
Definition: ConstString.h:215
Function.h
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::ExecutionContext::GetTargetRef
Target & GetTargetRef() const
Returns a reference to the target object.
Definition: ExecutionContext.cpp:224
lldb::eSymbolTypeReExported
@ eSymbolTypeReExported
Definition: lldb-enumerations.h:649
lldb_private::Symbol::m_addr_range
AddressRange m_addr_range
Definition: Symbol.h:326
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::DataExtractor::GetU16
uint16_t GetU16(lldb::offset_t *offset_ptr) const
Extract a uint16_t value from *offset_ptr.
Definition: DataExtractor.cpp:347
lldb_private::Symbol::operator==
bool operator==(const Symbol &rhs) const
Definition: Symbol.cpp:689
lldb_private::Symbol::IsTrampoline
bool IsTrampoline() const
Definition: Symbol.cpp:173
lldb_private::Address::GetOffset
lldb::addr_t GetOffset() const
Get the section relative offset value.
Definition: Address.h:319
lldb_private::Symbol::m_type_data
uint16_t m_type_data
Definition: Symbol.h:302
lldb_private::Symbol::GetNameNoArguments
ConstString GetNameNoArguments() const
Definition: Symbol.cpp:502
lldb_private::Address::GetModule
lldb::ModuleSP GetModule() const
Get accessor for the module for this address.
Definition: Address.cpp:283
Stream.h
lldb_private::Variable
Definition: Variable.h:25
lldb_private::Stream::PutCString
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
Definition: Stream.cpp:63
lldb::eSymbolTypeResolver
@ eSymbolTypeResolver
Definition: lldb-enumerations.h:623
lldb_private::Symbol::IsIndirect
bool IsIndirect() const
Definition: Symbol.cpp:175
lldb_private::Symbol::SetReExportedSymbolName
void SetReExportedSymbolName(ConstString name)
Definition: Symbol.cpp:151
lldb_private::Symbol::GetLoadAddress
lldb::addr_t GetLoadAddress(Target *target) const
Definition: Symbol.cpp:493
lldb_private::SymbolContext::line_entry
LineEntry line_entry
The LineEntry for a given query.
Definition: SymbolContext.h:322
SymbolVendor.h
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::GetDisplayName
ConstString GetDisplayName() const
Definition: Symbol.cpp:121
lldb_private::Symbol::GetType
lldb::SymbolType GetType() const
Definition: Symbol.h:153
lldb_private::Address::Slide
bool Slide(int64_t offset)
Definition: Address.h:449
lldb_private::Symbol::m_size_is_synthesized
uint16_t m_size_is_synthesized
Definition: Symbol.h:313
lldb_private::DataExtractor::ValidOffsetForDataOfSize
bool ValidOffsetForDataOfSize(lldb::offset_t offset, lldb::offset_t length) const
Test the availability of length bytes of data from offset.
Definition: DataExtractor.h:965
lldb
Definition: SBAddress.h:15
lldb_private::Symbol::m_is_weak
uint16_t m_is_weak
Definition: Symbol.h:323
lldb_private::LineEntry
Definition: LineEntry.h:20
lldb_private::Symbol::ResolveReExportedSymbol
Symbol * ResolveReExportedSymbol(Target &target) const
Definition: Symbol.cpp:472
lldb_private::ObjectFile
Definition: ObjectFile.h:60
lldb_private::ModuleList::Append
void Append(const lldb::ModuleSP &module_sp, bool notify=true)
Append a module to the module list.
lldb_private::Symbol::ResolveReExportedSymbolInModuleSpec
Symbol * ResolveReExportedSymbolInModuleSpec(Target &target, ConstString &reexport_name, lldb_private::ModuleSpec &module_spec, lldb_private::ModuleList &seen_modules) const
Definition: Symbol.cpp:416
lldb::DescriptionLevel
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
Definition: lldb-enumerations.h:207
lldb_private::Symbol::m_is_debug
uint16_t m_is_debug
Definition: Symbol.h:308
ENUM_TO_CSTRING
#define ENUM_TO_CSTRING(x)
Definition: Symbol.cpp:341
lldb_private::Symbol::GetSiblingIndex
uint32_t GetSiblingIndex() const
Definition: Symbol.cpp:169
lldb_private::Symbol::GetID
uint32_t GetID() const
Definition: Symbol.h:121
lldb_private::Symbol::GetAddress
Address GetAddress() const
Definition: Symbol.h:73