LLDB  mainline
Symtab.cpp
Go to the documentation of this file.
1 //===-- Symtab.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 <map>
10 #include <set>
11 
13 #include "lldb/Core/Module.h"
15 #include "lldb/Core/Section.h"
16 #include "lldb/Symbol/ObjectFile.h"
17 #include "lldb/Symbol/Symbol.h"
19 #include "lldb/Symbol/Symtab.h"
20 #include "lldb/Target/Language.h"
22 #include "lldb/Utility/Endian.h"
24 #include "lldb/Utility/Stream.h"
25 #include "lldb/Utility/Timer.h"
26 
27 #include "llvm/ADT/ArrayRef.h"
28 #include "llvm/ADT/StringRef.h"
29 #include "llvm/Support/DJB.h"
30 
31 using namespace lldb;
32 using namespace lldb_private;
33 
34 Symtab::Symtab(ObjectFile *objfile)
35  : m_objfile(objfile), m_symbols(), m_file_addr_to_index(*this),
36  m_name_to_symbol_indices(), m_mutex(),
37  m_file_addr_to_index_computed(false), m_name_indexes_computed(false),
38  m_loaded_from_cache(false), m_saved_to_cache(false) {
39  m_name_to_symbol_indices.emplace(std::make_pair(
40  lldb::eFunctionNameTypeNone, UniqueCStringMap<uint32_t>()));
41  m_name_to_symbol_indices.emplace(std::make_pair(
42  lldb::eFunctionNameTypeBase, UniqueCStringMap<uint32_t>()));
43  m_name_to_symbol_indices.emplace(std::make_pair(
44  lldb::eFunctionNameTypeMethod, UniqueCStringMap<uint32_t>()));
45  m_name_to_symbol_indices.emplace(std::make_pair(
46  lldb::eFunctionNameTypeSelector, UniqueCStringMap<uint32_t>()));
47 }
48 
49 Symtab::~Symtab() = default;
50 
51 void Symtab::Reserve(size_t count) {
52  // Clients should grab the mutex from this symbol table and lock it manually
53  // when calling this function to avoid performance issues.
54  m_symbols.reserve(count);
55 }
56 
57 Symbol *Symtab::Resize(size_t count) {
58  // Clients should grab the mutex from this symbol table and lock it manually
59  // when calling this function to avoid performance issues.
60  m_symbols.resize(count);
61  return m_symbols.empty() ? nullptr : &m_symbols[0];
62 }
63 
65  // Clients should grab the mutex from this symbol table and lock it manually
66  // when calling this function to avoid performance issues.
67  uint32_t symbol_idx = m_symbols.size();
68  auto &name_to_index = GetNameToSymbolIndexMap(lldb::eFunctionNameTypeNone);
69  name_to_index.Clear();
71  m_symbols.push_back(symbol);
74  return symbol_idx;
75 }
76 
77 size_t Symtab::GetNumSymbols() const {
78  std::lock_guard<std::recursive_mutex> guard(m_mutex);
79  return m_symbols.size();
80 }
81 
83  auto &name_to_index = GetNameToSymbolIndexMap(lldb::eFunctionNameTypeNone);
84  name_to_index.Clear();
86 }
87 
88 void Symtab::Dump(Stream *s, Target *target, SortOrder sort_order,
89  Mangled::NamePreference name_preference) {
90  std::lock_guard<std::recursive_mutex> guard(m_mutex);
91 
92  // s->Printf("%.*p: ", (int)sizeof(void*) * 2, this);
93  s->Indent();
94  const FileSpec &file_spec = m_objfile->GetFileSpec();
95  const char *object_name = nullptr;
96  if (m_objfile->GetModule())
97  object_name = m_objfile->GetModule()->GetObjectName().GetCString();
98 
99  if (file_spec)
100  s->Printf("Symtab, file = %s%s%s%s, num_symbols = %" PRIu64,
101  file_spec.GetPath().c_str(), object_name ? "(" : "",
102  object_name ? object_name : "", object_name ? ")" : "",
103  (uint64_t)m_symbols.size());
104  else
105  s->Printf("Symtab, num_symbols = %" PRIu64 "", (uint64_t)m_symbols.size());
106 
107  if (!m_symbols.empty()) {
108  switch (sort_order) {
109  case eSortOrderNone: {
110  s->PutCString(":\n");
111  DumpSymbolHeader(s);
112  const_iterator begin = m_symbols.begin();
113  const_iterator end = m_symbols.end();
114  for (const_iterator pos = m_symbols.begin(); pos != end; ++pos) {
115  s->Indent();
116  pos->Dump(s, target, std::distance(begin, pos), name_preference);
117  }
118  }
119  break;
120 
121  case eSortOrderByName: {
122  // Although we maintain a lookup by exact name map, the table isn't
123  // sorted by name. So we must make the ordered symbol list up ourselves.
124  s->PutCString(" (sorted by name):\n");
125  DumpSymbolHeader(s);
126 
127  std::multimap<llvm::StringRef, const Symbol *> name_map;
128  for (const_iterator pos = m_symbols.begin(), end = m_symbols.end();
129  pos != end; ++pos) {
130  const char *name = pos->GetName().AsCString();
131  if (name && name[0])
132  name_map.insert(std::make_pair(name, &(*pos)));
133  }
134 
135  for (const auto &name_to_symbol : name_map) {
136  const Symbol *symbol = name_to_symbol.second;
137  s->Indent();
138  symbol->Dump(s, target, symbol - &m_symbols[0], name_preference);
139  }
140  } break;
141 
142  case eSortOrderByAddress:
143  s->PutCString(" (sorted by address):\n");
144  DumpSymbolHeader(s);
147  const size_t num_entries = m_file_addr_to_index.GetSize();
148  for (size_t i = 0; i < num_entries; ++i) {
149  s->Indent();
150  const uint32_t symbol_idx = m_file_addr_to_index.GetEntryRef(i).data;
151  m_symbols[symbol_idx].Dump(s, target, symbol_idx, name_preference);
152  }
153  break;
154  }
155  } else {
156  s->PutCString("\n");
157  }
158 }
159 
160 void Symtab::Dump(Stream *s, Target *target, std::vector<uint32_t> &indexes,
161  Mangled::NamePreference name_preference) const {
162  std::lock_guard<std::recursive_mutex> guard(m_mutex);
163 
164  const size_t num_symbols = GetNumSymbols();
165  // s->Printf("%.*p: ", (int)sizeof(void*) * 2, this);
166  s->Indent();
167  s->Printf("Symtab %" PRIu64 " symbol indexes (%" PRIu64 " symbols total):\n",
168  (uint64_t)indexes.size(), (uint64_t)m_symbols.size());
169  s->IndentMore();
170 
171  if (!indexes.empty()) {
172  std::vector<uint32_t>::const_iterator pos;
173  std::vector<uint32_t>::const_iterator end = indexes.end();
174  DumpSymbolHeader(s);
175  for (pos = indexes.begin(); pos != end; ++pos) {
176  size_t idx = *pos;
177  if (idx < num_symbols) {
178  s->Indent();
179  m_symbols[idx].Dump(s, target, idx, name_preference);
180  }
181  }
182  }
183  s->IndentLess();
184 }
185 
187  s->Indent(" Debug symbol\n");
188  s->Indent(" |Synthetic symbol\n");
189  s->Indent(" ||Externally Visible\n");
190  s->Indent(" |||\n");
191  s->Indent("Index UserID DSX Type File Address/Value Load "
192  "Address Size Flags Name\n");
193  s->Indent("------- ------ --- --------------- ------------------ "
194  "------------------ ------------------ ---------- "
195  "----------------------------------\n");
196 }
197 
198 static int CompareSymbolID(const void *key, const void *p) {
199  const user_id_t match_uid = *(const user_id_t *)key;
200  const user_id_t symbol_uid = ((const Symbol *)p)->GetID();
201  if (match_uid < symbol_uid)
202  return -1;
203  if (match_uid > symbol_uid)
204  return 1;
205  return 0;
206 }
207 
209  std::lock_guard<std::recursive_mutex> guard(m_mutex);
210 
211  Symbol *symbol =
212  (Symbol *)::bsearch(&symbol_uid, &m_symbols[0], m_symbols.size(),
213  sizeof(m_symbols[0]), CompareSymbolID);
214  return symbol;
215 }
216 
218  // Clients should grab the mutex from this symbol table and lock it manually
219  // when calling this function to avoid performance issues.
220  if (idx < m_symbols.size())
221  return &m_symbols[idx];
222  return nullptr;
223 }
224 
225 const Symbol *Symtab::SymbolAtIndex(size_t idx) const {
226  // Clients should grab the mutex from this symbol table and lock it manually
227  // when calling this function to avoid performance issues.
228  if (idx < m_symbols.size())
229  return &m_symbols[idx];
230  return nullptr;
231 }
232 
233 static bool lldb_skip_name(llvm::StringRef mangled,
234  Mangled::ManglingScheme scheme) {
235  switch (scheme) {
236  case Mangled::eManglingSchemeItanium: {
237  if (mangled.size() < 3 || !mangled.startswith("_Z"))
238  return true;
239 
240  // Avoid the following types of symbols in the index.
241  switch (mangled[2]) {
242  case 'G': // guard variables
243  case 'T': // virtual tables, VTT structures, typeinfo structures + names
244  case 'Z': // named local entities (if we eventually handle
245  // eSymbolTypeData, we will want this back)
246  return true;
247 
248  default:
249  break;
250  }
251 
252  // Include this name in the index.
253  return false;
254  }
255 
256  // No filters for this scheme yet. Include all names in indexing.
257  case Mangled::eManglingSchemeMSVC:
258  case Mangled::eManglingSchemeRustV0:
259  case Mangled::eManglingSchemeD:
260  return false;
261 
262  // Don't try and demangle things we can't categorize.
263  case Mangled::eManglingSchemeNone:
264  return true;
265  }
266  llvm_unreachable("unknown scheme!");
267 }
268 
270  // Protected function, no need to lock mutex...
273  ElapsedTime elapsed(m_objfile->GetModule()->GetSymtabIndexTime());
275 
276  // Collect all loaded language plugins.
277  std::vector<Language *> languages;
278  Language::ForEach([&languages](Language *l) {
279  languages.push_back(l);
280  return true;
281  });
282 
283  auto &name_to_index = GetNameToSymbolIndexMap(lldb::eFunctionNameTypeNone);
284  auto &basename_to_index =
285  GetNameToSymbolIndexMap(lldb::eFunctionNameTypeBase);
286  auto &method_to_index =
287  GetNameToSymbolIndexMap(lldb::eFunctionNameTypeMethod);
288  auto &selector_to_index =
289  GetNameToSymbolIndexMap(lldb::eFunctionNameTypeSelector);
290  // Create the name index vector to be able to quickly search by name
291  const size_t num_symbols = m_symbols.size();
292  name_to_index.Reserve(num_symbols);
293 
294  // The "const char *" in "class_contexts" and backlog::value_type::second
295  // must come from a ConstString::GetCString()
296  std::set<const char *> class_contexts;
297  std::vector<std::pair<NameToIndexMap::Entry, const char *>> backlog;
298  backlog.reserve(num_symbols / 2);
299 
300  // Instantiation of the demangler is expensive, so better use a single one
301  // for all entries during batch processing.
303  for (uint32_t value = 0; value < num_symbols; ++value) {
304  Symbol *symbol = &m_symbols[value];
305 
306  // Don't let trampolines get into the lookup by name map If we ever need
307  // the trampoline symbols to be searchable by name we can remove this and
308  // then possibly add a new bool to any of the Symtab functions that
309  // lookup symbols by name to indicate if they want trampolines. We also
310  // don't want any synthetic symbols with auto generated names in the
311  // name lookups.
312  if (symbol->IsTrampoline() || symbol->IsSyntheticWithAutoGeneratedName())
313  continue;
314 
315  // If the symbol's name string matched a Mangled::ManglingScheme, it is
316  // stored in the mangled field.
317  Mangled &mangled = symbol->GetMangled();
318  if (ConstString name = mangled.GetMangledName()) {
319  name_to_index.Append(name, value);
320 
321  if (symbol->ContainsLinkerAnnotations()) {
322  // If the symbol has linker annotations, also add the version without
323  // the annotations.
324  ConstString stripped = ConstString(
325  m_objfile->StripLinkerSymbolAnnotations(name.GetStringRef()));
326  name_to_index.Append(stripped, value);
327  }
328 
329  const SymbolType type = symbol->GetType();
330  if (type == eSymbolTypeCode || type == eSymbolTypeResolver) {
331  if (mangled.GetRichManglingInfo(rmc, lldb_skip_name)) {
332  RegisterMangledNameEntry(value, class_contexts, backlog, rmc);
333  continue;
334  }
335  }
336  }
337 
338  // Symbol name strings that didn't match a Mangled::ManglingScheme, are
339  // stored in the demangled field.
340  if (ConstString name = mangled.GetDemangledName()) {
341  name_to_index.Append(name, value);
342 
343  if (symbol->ContainsLinkerAnnotations()) {
344  // If the symbol has linker annotations, also add the version without
345  // the annotations.
346  name = ConstString(
347  m_objfile->StripLinkerSymbolAnnotations(name.GetStringRef()));
348  name_to_index.Append(name, value);
349  }
350 
351  // If the demangled name turns out to be an ObjC name, and is a category
352  // name, add the version without categories to the index too.
353  for (Language *lang : languages) {
354  for (auto variant : lang->GetMethodNameVariants(name)) {
355  if (variant.GetType() & lldb::eFunctionNameTypeSelector)
356  selector_to_index.Append(variant.GetName(), value);
357  else if (variant.GetType() & lldb::eFunctionNameTypeFull)
358  name_to_index.Append(variant.GetName(), value);
359  else if (variant.GetType() & lldb::eFunctionNameTypeMethod)
360  method_to_index.Append(variant.GetName(), value);
361  else if (variant.GetType() & lldb::eFunctionNameTypeBase)
362  basename_to_index.Append(variant.GetName(), value);
363  }
364  }
365  }
366  }
367 
368  for (const auto &record : backlog) {
369  RegisterBacklogEntry(record.first, record.second, class_contexts);
370  }
371 
372  name_to_index.Sort();
373  name_to_index.SizeToFit();
374  selector_to_index.Sort();
375  selector_to_index.SizeToFit();
376  basename_to_index.Sort();
377  basename_to_index.SizeToFit();
378  method_to_index.Sort();
379  method_to_index.SizeToFit();
380  }
381 }
382 
384  uint32_t value, std::set<const char *> &class_contexts,
385  std::vector<std::pair<NameToIndexMap::Entry, const char *>> &backlog,
386  RichManglingContext &rmc) {
387  // Only register functions that have a base name.
388  llvm::StringRef base_name = rmc.ParseFunctionBaseName();
389  if (base_name.empty())
390  return;
391 
392  // The base name will be our entry's name.
393  NameToIndexMap::Entry entry(ConstString(base_name), value);
394  llvm::StringRef decl_context = rmc.ParseFunctionDeclContextName();
395 
396  // Register functions with no context.
397  if (decl_context.empty()) {
398  // This has to be a basename
399  auto &basename_to_index =
400  GetNameToSymbolIndexMap(lldb::eFunctionNameTypeBase);
401  basename_to_index.Append(entry);
402  // If there is no context (no namespaces or class scopes that come before
403  // the function name) then this also could be a fullname.
404  auto &name_to_index = GetNameToSymbolIndexMap(lldb::eFunctionNameTypeNone);
405  name_to_index.Append(entry);
406  return;
407  }
408 
409  // Make sure we have a pool-string pointer and see if we already know the
410  // context name.
411  const char *decl_context_ccstr = ConstString(decl_context).GetCString();
412  auto it = class_contexts.find(decl_context_ccstr);
413 
414  auto &method_to_index =
415  GetNameToSymbolIndexMap(lldb::eFunctionNameTypeMethod);
416  // Register constructors and destructors. They are methods and create
417  // declaration contexts.
418  if (rmc.IsCtorOrDtor()) {
419  method_to_index.Append(entry);
420  if (it == class_contexts.end())
421  class_contexts.insert(it, decl_context_ccstr);
422  return;
423  }
424 
425  // Register regular methods with a known declaration context.
426  if (it != class_contexts.end()) {
427  method_to_index.Append(entry);
428  return;
429  }
430 
431  // Regular methods in unknown declaration contexts are put to the backlog. We
432  // will revisit them once we processed all remaining symbols.
433  backlog.push_back(std::make_pair(entry, decl_context_ccstr));
434 }
435 
437  const NameToIndexMap::Entry &entry, const char *decl_context,
438  const std::set<const char *> &class_contexts) {
439  auto &method_to_index =
440  GetNameToSymbolIndexMap(lldb::eFunctionNameTypeMethod);
441  auto it = class_contexts.find(decl_context);
442  if (it != class_contexts.end()) {
443  method_to_index.Append(entry);
444  } else {
445  // If we got here, we have something that had a context (was inside
446  // a namespace or class) yet we don't know the entry
447  method_to_index.Append(entry);
448  auto &basename_to_index =
449  GetNameToSymbolIndexMap(lldb::eFunctionNameTypeBase);
450  basename_to_index.Append(entry);
451  }
452 }
453 
455  std::lock_guard<std::recursive_mutex> guard(m_mutex);
456  InitNameIndexes();
457 }
458 
460  bool add_demangled, bool add_mangled,
461  NameToIndexMap &name_to_index_map) const {
463  if (add_demangled || add_mangled) {
464  std::lock_guard<std::recursive_mutex> guard(m_mutex);
465 
466  // Create the name index vector to be able to quickly search by name
467  const size_t num_indexes = indexes.size();
468  for (size_t i = 0; i < num_indexes; ++i) {
469  uint32_t value = indexes[i];
470  assert(i < m_symbols.size());
471  const Symbol *symbol = &m_symbols[value];
472 
473  const Mangled &mangled = symbol->GetMangled();
474  if (add_demangled) {
475  if (ConstString name = mangled.GetDemangledName())
476  name_to_index_map.Append(name, value);
477  }
478 
479  if (add_mangled) {
480  if (ConstString name = mangled.GetMangledName())
481  name_to_index_map.Append(name, value);
482  }
483  }
484  }
485 }
486 
488  std::vector<uint32_t> &indexes,
489  uint32_t start_idx,
490  uint32_t end_index) const {
491  std::lock_guard<std::recursive_mutex> guard(m_mutex);
492 
493  uint32_t prev_size = indexes.size();
494 
495  const uint32_t count = std::min<uint32_t>(m_symbols.size(), end_index);
496 
497  for (uint32_t i = start_idx; i < count; ++i) {
498  if (symbol_type == eSymbolTypeAny || m_symbols[i].GetType() == symbol_type)
499  indexes.push_back(i);
500  }
501 
502  return indexes.size() - prev_size;
503 }
504 
506  SymbolType symbol_type, uint32_t flags_value,
507  std::vector<uint32_t> &indexes, uint32_t start_idx,
508  uint32_t end_index) const {
509  std::lock_guard<std::recursive_mutex> guard(m_mutex);
510 
511  uint32_t prev_size = indexes.size();
512 
513  const uint32_t count = std::min<uint32_t>(m_symbols.size(), end_index);
514 
515  for (uint32_t i = start_idx; i < count; ++i) {
516  if ((symbol_type == eSymbolTypeAny ||
517  m_symbols[i].GetType() == symbol_type) &&
518  m_symbols[i].GetFlags() == flags_value)
519  indexes.push_back(i);
520  }
521 
522  return indexes.size() - prev_size;
523 }
524 
526  Debug symbol_debug_type,
527  Visibility symbol_visibility,
528  std::vector<uint32_t> &indexes,
529  uint32_t start_idx,
530  uint32_t end_index) const {
531  std::lock_guard<std::recursive_mutex> guard(m_mutex);
532 
533  uint32_t prev_size = indexes.size();
534 
535  const uint32_t count = std::min<uint32_t>(m_symbols.size(), end_index);
536 
537  for (uint32_t i = start_idx; i < count; ++i) {
538  if (symbol_type == eSymbolTypeAny ||
539  m_symbols[i].GetType() == symbol_type) {
540  if (CheckSymbolAtIndex(i, symbol_debug_type, symbol_visibility))
541  indexes.push_back(i);
542  }
543  }
544 
545  return indexes.size() - prev_size;
546 }
547 
549  if (!m_symbols.empty()) {
550  const Symbol *first_symbol = &m_symbols[0];
551  if (symbol >= first_symbol && symbol < first_symbol + m_symbols.size())
552  return symbol - first_symbol;
553  }
554  return UINT32_MAX;
555 }
556 
558  const bool sort_by_load_addr;
559  const Symbol *symbols;
560 };
561 
562 namespace {
563 struct SymbolIndexComparator {
564  const std::vector<Symbol> &symbols;
565  std::vector<lldb::addr_t> &addr_cache;
566 
567  // Getting from the symbol to the Address to the File Address involves some
568  // work. Since there are potentially many symbols here, and we're using this
569  // for sorting so we're going to be computing the address many times, cache
570  // that in addr_cache. The array passed in has to be the same size as the
571  // symbols array passed into the member variable symbols, and should be
572  // initialized with LLDB_INVALID_ADDRESS.
573  // NOTE: You have to make addr_cache externally and pass it in because
574  // std::stable_sort
575  // makes copies of the comparator it is initially passed in, and you end up
576  // spending huge amounts of time copying this array...
577 
578  SymbolIndexComparator(const std::vector<Symbol> &s,
579  std::vector<lldb::addr_t> &a)
580  : symbols(s), addr_cache(a) {
581  assert(symbols.size() == addr_cache.size());
582  }
583  bool operator()(uint32_t index_a, uint32_t index_b) {
584  addr_t value_a = addr_cache[index_a];
585  if (value_a == LLDB_INVALID_ADDRESS) {
586  value_a = symbols[index_a].GetAddressRef().GetFileAddress();
587  addr_cache[index_a] = value_a;
588  }
589 
590  addr_t value_b = addr_cache[index_b];
591  if (value_b == LLDB_INVALID_ADDRESS) {
592  value_b = symbols[index_b].GetAddressRef().GetFileAddress();
593  addr_cache[index_b] = value_b;
594  }
595 
596  if (value_a == value_b) {
597  // The if the values are equal, use the original symbol user ID
598  lldb::user_id_t uid_a = symbols[index_a].GetID();
599  lldb::user_id_t uid_b = symbols[index_b].GetID();
600  if (uid_a < uid_b)
601  return true;
602  if (uid_a > uid_b)
603  return false;
604  return false;
605  } else if (value_a < value_b)
606  return true;
607 
608  return false;
609  }
610 };
611 }
612 
613 void Symtab::SortSymbolIndexesByValue(std::vector<uint32_t> &indexes,
614  bool remove_duplicates) const {
615  std::lock_guard<std::recursive_mutex> guard(m_mutex);
617  // No need to sort if we have zero or one items...
618  if (indexes.size() <= 1)
619  return;
620 
621  // Sort the indexes in place using std::stable_sort.
622  // NOTE: The use of std::stable_sort instead of llvm::sort here is strictly
623  // for performance, not correctness. The indexes vector tends to be "close"
624  // to sorted, which the stable sort handles better.
625 
626  std::vector<lldb::addr_t> addr_cache(m_symbols.size(), LLDB_INVALID_ADDRESS);
627 
628  SymbolIndexComparator comparator(m_symbols, addr_cache);
629  std::stable_sort(indexes.begin(), indexes.end(), comparator);
630 
631  // Remove any duplicates if requested
632  if (remove_duplicates) {
633  auto last = std::unique(indexes.begin(), indexes.end());
634  indexes.erase(last, indexes.end());
635  }
636 }
637 
639  std::vector<uint32_t> &indexes) {
640  auto &name_to_index = GetNameToSymbolIndexMap(lldb::eFunctionNameTypeNone);
641  const uint32_t count = name_to_index.GetValues(symbol_name, indexes);
642  if (count)
643  return count;
644  // Synthetic symbol names are not added to the name indexes, but they start
645  // with a prefix and end with a the symbol UserID. This allows users to find
646  // these symbols without having to add them to the name indexes. These
647  // queries will not happen very often since the names don't mean anything, so
648  // performance is not paramount in this case.
649  llvm::StringRef name = symbol_name.GetStringRef();
650  // String the synthetic prefix if the name starts with it.
651  if (!name.consume_front(Symbol::GetSyntheticSymbolPrefix()))
652  return 0; // Not a synthetic symbol name
653 
654  // Extract the user ID from the symbol name
655  unsigned long long uid = 0;
656  if (getAsUnsignedInteger(name, /*Radix=*/10, uid))
657  return 0; // Failed to extract the user ID as an integer
658  Symbol *symbol = FindSymbolByID(uid);
659  if (symbol == nullptr)
660  return 0;
661  const uint32_t symbol_idx = GetIndexForSymbol(symbol);
662  if (symbol_idx == UINT32_MAX)
663  return 0;
664  indexes.push_back(symbol_idx);
665  return 1;
666 }
667 
669  std::vector<uint32_t> &indexes) {
670  std::lock_guard<std::recursive_mutex> guard(m_mutex);
671 
672  if (symbol_name) {
674  InitNameIndexes();
675 
676  return GetNameIndexes(symbol_name, indexes);
677  }
678  return 0;
679 }
680 
682  Debug symbol_debug_type,
683  Visibility symbol_visibility,
684  std::vector<uint32_t> &indexes) {
685  std::lock_guard<std::recursive_mutex> guard(m_mutex);
686 
688  if (symbol_name) {
689  const size_t old_size = indexes.size();
691  InitNameIndexes();
692 
693  std::vector<uint32_t> all_name_indexes;
694  const size_t name_match_count =
695  GetNameIndexes(symbol_name, all_name_indexes);
696  for (size_t i = 0; i < name_match_count; ++i) {
697  if (CheckSymbolAtIndex(all_name_indexes[i], symbol_debug_type,
698  symbol_visibility))
699  indexes.push_back(all_name_indexes[i]);
700  }
701  return indexes.size() - old_size;
702  }
703  return 0;
704 }
705 
706 uint32_t
708  SymbolType symbol_type,
709  std::vector<uint32_t> &indexes) {
710  std::lock_guard<std::recursive_mutex> guard(m_mutex);
711 
712  if (AppendSymbolIndexesWithName(symbol_name, indexes) > 0) {
713  std::vector<uint32_t>::iterator pos = indexes.begin();
714  while (pos != indexes.end()) {
715  if (symbol_type == eSymbolTypeAny ||
716  m_symbols[*pos].GetType() == symbol_type)
717  ++pos;
718  else
719  pos = indexes.erase(pos);
720  }
721  }
722  return indexes.size();
723 }
724 
726  ConstString symbol_name, SymbolType symbol_type,
727  Debug symbol_debug_type, Visibility symbol_visibility,
728  std::vector<uint32_t> &indexes) {
729  std::lock_guard<std::recursive_mutex> guard(m_mutex);
730 
731  if (AppendSymbolIndexesWithName(symbol_name, symbol_debug_type,
732  symbol_visibility, indexes) > 0) {
733  std::vector<uint32_t>::iterator pos = indexes.begin();
734  while (pos != indexes.end()) {
735  if (symbol_type == eSymbolTypeAny ||
736  m_symbols[*pos].GetType() == symbol_type)
737  ++pos;
738  else
739  pos = indexes.erase(pos);
740  }
741  }
742  return indexes.size();
743 }
744 
746  const RegularExpression &regexp, SymbolType symbol_type,
747  std::vector<uint32_t> &indexes, Mangled::NamePreference name_preference) {
748  std::lock_guard<std::recursive_mutex> guard(m_mutex);
749 
750  uint32_t prev_size = indexes.size();
751  uint32_t sym_end = m_symbols.size();
752 
753  for (uint32_t i = 0; i < sym_end; i++) {
754  if (symbol_type == eSymbolTypeAny ||
755  m_symbols[i].GetType() == symbol_type) {
756  const char *name =
757  m_symbols[i].GetMangled().GetName(name_preference).AsCString();
758  if (name) {
759  if (regexp.Execute(name))
760  indexes.push_back(i);
761  }
762  }
763  }
764  return indexes.size() - prev_size;
765 }
766 
768  const RegularExpression &regexp, SymbolType symbol_type,
769  Debug symbol_debug_type, Visibility symbol_visibility,
770  std::vector<uint32_t> &indexes, Mangled::NamePreference name_preference) {
771  std::lock_guard<std::recursive_mutex> guard(m_mutex);
772 
773  uint32_t prev_size = indexes.size();
774  uint32_t sym_end = m_symbols.size();
775 
776  for (uint32_t i = 0; i < sym_end; i++) {
777  if (symbol_type == eSymbolTypeAny ||
778  m_symbols[i].GetType() == symbol_type) {
779  if (!CheckSymbolAtIndex(i, symbol_debug_type, symbol_visibility))
780  continue;
781 
782  const char *name =
783  m_symbols[i].GetMangled().GetName(name_preference).AsCString();
784  if (name) {
785  if (regexp.Execute(name))
786  indexes.push_back(i);
787  }
788  }
789  }
790  return indexes.size() - prev_size;
791 }
792 
794  Debug symbol_debug_type,
795  Visibility symbol_visibility,
796  uint32_t &start_idx) {
797  std::lock_guard<std::recursive_mutex> guard(m_mutex);
798 
799  const size_t count = m_symbols.size();
800  for (size_t idx = start_idx; idx < count; ++idx) {
801  if (symbol_type == eSymbolTypeAny ||
802  m_symbols[idx].GetType() == symbol_type) {
803  if (CheckSymbolAtIndex(idx, symbol_debug_type, symbol_visibility)) {
804  start_idx = idx;
805  return &m_symbols[idx];
806  }
807  }
808  }
809  return nullptr;
810 }
811 
812 void
814  SymbolType symbol_type,
815  std::vector<uint32_t> &symbol_indexes) {
816  std::lock_guard<std::recursive_mutex> guard(m_mutex);
817 
818  // Initialize all of the lookup by name indexes before converting NAME to a
819  // uniqued string NAME_STR below.
821  InitNameIndexes();
822 
823  if (name) {
824  // The string table did have a string that matched, but we need to check
825  // the symbols and match the symbol_type if any was given.
826  AppendSymbolIndexesWithNameAndType(name, symbol_type, symbol_indexes);
827  }
828 }
829 
831  ConstString name, SymbolType symbol_type, Debug symbol_debug_type,
832  Visibility symbol_visibility, std::vector<uint32_t> &symbol_indexes) {
833  std::lock_guard<std::recursive_mutex> guard(m_mutex);
834 
836  // Initialize all of the lookup by name indexes before converting NAME to a
837  // uniqued string NAME_STR below.
839  InitNameIndexes();
840 
841  if (name) {
842  // The string table did have a string that matched, but we need to check
843  // the symbols and match the symbol_type if any was given.
844  AppendSymbolIndexesWithNameAndType(name, symbol_type, symbol_debug_type,
845  symbol_visibility, symbol_indexes);
846  }
847 }
848 
850  const RegularExpression &regex, SymbolType symbol_type,
851  Debug symbol_debug_type, Visibility symbol_visibility,
852  std::vector<uint32_t> &symbol_indexes,
853  Mangled::NamePreference name_preference) {
854  std::lock_guard<std::recursive_mutex> guard(m_mutex);
855 
856  AppendSymbolIndexesMatchingRegExAndType(regex, symbol_type, symbol_debug_type,
857  symbol_visibility, symbol_indexes,
858  name_preference);
859 }
860 
862  SymbolType symbol_type,
863  Debug symbol_debug_type,
864  Visibility symbol_visibility) {
865  std::lock_guard<std::recursive_mutex> guard(m_mutex);
868  InitNameIndexes();
869 
870  if (name) {
871  std::vector<uint32_t> matching_indexes;
872  // The string table did have a string that matched, but we need to check
873  // the symbols and match the symbol_type if any was given.
874  if (AppendSymbolIndexesWithNameAndType(name, symbol_type, symbol_debug_type,
875  symbol_visibility,
876  matching_indexes)) {
877  std::vector<uint32_t>::const_iterator pos, end = matching_indexes.end();
878  for (pos = matching_indexes.begin(); pos != end; ++pos) {
879  Symbol *symbol = SymbolAtIndex(*pos);
880 
881  if (symbol->Compare(name, symbol_type))
882  return symbol;
883  }
884  }
885  }
886  return nullptr;
887 }
888 
889 typedef struct {
890  const Symtab *symtab;
896 
897 // Add all the section file start address & size to the RangeVector, recusively
898 // adding any children sections.
899 static void AddSectionsToRangeMap(SectionList *sectlist,
900  RangeVector<addr_t, addr_t> &section_ranges) {
901  const int num_sections = sectlist->GetNumSections(0);
902  for (int i = 0; i < num_sections; i++) {
903  SectionSP sect_sp = sectlist->GetSectionAtIndex(i);
904  if (sect_sp) {
905  SectionList &child_sectlist = sect_sp->GetChildren();
906 
907  // If this section has children, add the children to the RangeVector.
908  // Else add this section to the RangeVector.
909  if (child_sectlist.GetNumSections(0) > 0) {
910  AddSectionsToRangeMap(&child_sectlist, section_ranges);
911  } else {
912  size_t size = sect_sp->GetByteSize();
913  if (size > 0) {
914  addr_t base_addr = sect_sp->GetFileAddress();
916  entry.SetRangeBase(base_addr);
917  entry.SetByteSize(size);
918  section_ranges.Append(entry);
919  }
920  }
921  }
922  }
923 }
924 
926  // Protected function, no need to lock mutex...
927  if (!m_file_addr_to_index_computed && !m_symbols.empty()) {
929 
931  const_iterator begin = m_symbols.begin();
932  const_iterator end = m_symbols.end();
933  for (const_iterator pos = m_symbols.begin(); pos != end; ++pos) {
934  if (pos->ValueIsAddress()) {
935  entry.SetRangeBase(pos->GetAddressRef().GetFileAddress());
936  entry.SetByteSize(pos->GetByteSize());
937  entry.data = std::distance(begin, pos);
939  }
940  }
941  const size_t num_entries = m_file_addr_to_index.GetSize();
942  if (num_entries > 0) {
944 
945  // Create a RangeVector with the start & size of all the sections for
946  // this objfile. We'll need to check this for any FileRangeToIndexMap
947  // entries with an uninitialized size, which could potentially be a large
948  // number so reconstituting the weak pointer is busywork when it is
949  // invariant information.
950  SectionList *sectlist = m_objfile->GetSectionList();
951  RangeVector<addr_t, addr_t> section_ranges;
952  if (sectlist) {
953  AddSectionsToRangeMap(sectlist, section_ranges);
954  section_ranges.Sort();
955  }
956 
957  // Iterate through the FileRangeToIndexMap and fill in the size for any
958  // entries that didn't already have a size from the Symbol (e.g. if we
959  // have a plain linker symbol with an address only, instead of debug info
960  // where we get an address and a size and a type, etc.)
961  for (size_t i = 0; i < num_entries; i++) {
964  if (entry->GetByteSize() == 0) {
965  addr_t curr_base_addr = entry->GetRangeBase();
966  const RangeVector<addr_t, addr_t>::Entry *containing_section =
967  section_ranges.FindEntryThatContains(curr_base_addr);
968 
969  // Use the end of the section as the default max size of the symbol
970  addr_t sym_size = 0;
971  if (containing_section) {
972  sym_size =
973  containing_section->GetByteSize() -
974  (entry->GetRangeBase() - containing_section->GetRangeBase());
975  }
976 
977  for (size_t j = i; j < num_entries; j++) {
978  FileRangeToIndexMap::Entry *next_entry =
980  addr_t next_base_addr = next_entry->GetRangeBase();
981  if (next_base_addr > curr_base_addr) {
982  addr_t size_to_next_symbol = next_base_addr - curr_base_addr;
983 
984  // Take the difference between this symbol and the next one as
985  // its size, if it is less than the size of the section.
986  if (sym_size == 0 || size_to_next_symbol < sym_size) {
987  sym_size = size_to_next_symbol;
988  }
989  break;
990  }
991  }
992 
993  if (sym_size > 0) {
994  entry->SetByteSize(sym_size);
995  Symbol &symbol = m_symbols[entry->data];
996  symbol.SetByteSize(sym_size);
997  symbol.SetSizeIsSynthesized(true);
998  }
999  }
1000  }
1001 
1002  // Sort again in case the range size changes the ordering
1004  }
1005  }
1006 }
1007 
1009  std::lock_guard<std::recursive_mutex> guard(m_mutex);
1010  // Calculate the size of symbols inside InitAddressIndexes.
1012  // Shrink to fit the symbols so we don't waste memory
1013  if (m_symbols.capacity() > m_symbols.size()) {
1014  collection new_symbols(m_symbols.begin(), m_symbols.end());
1015  m_symbols.swap(new_symbols);
1016  }
1017  SaveToCache();
1018 }
1019 
1021  std::lock_guard<std::recursive_mutex> guard(m_mutex);
1024 
1025  const FileRangeToIndexMap::Entry *entry =
1027  if (entry) {
1028  Symbol *symbol = SymbolAtIndex(entry->data);
1029  if (symbol->GetFileAddress() == file_addr)
1030  return symbol;
1031  }
1032  return nullptr;
1033 }
1034 
1036  std::lock_guard<std::recursive_mutex> guard(m_mutex);
1037 
1040 
1041  const FileRangeToIndexMap::Entry *entry =
1043  if (entry) {
1044  Symbol *symbol = SymbolAtIndex(entry->data);
1045  if (symbol->ContainsFileAddress(file_addr))
1046  return symbol;
1047  }
1048  return nullptr;
1049 }
1050 
1052  addr_t file_addr, std::function<bool(Symbol *)> const &callback) {
1053  std::lock_guard<std::recursive_mutex> guard(m_mutex);
1054 
1057 
1058  std::vector<uint32_t> all_addr_indexes;
1059 
1060  // Get all symbols with file_addr
1061  const size_t addr_match_count =
1063  all_addr_indexes);
1064 
1065  for (size_t i = 0; i < addr_match_count; ++i) {
1066  Symbol *symbol = SymbolAtIndex(all_addr_indexes[i]);
1067  if (symbol->ContainsFileAddress(file_addr)) {
1068  if (!callback(symbol))
1069  break;
1070  }
1071  }
1072 }
1073 
1075  std::vector<uint32_t> &symbol_indexes, SymbolContextList &sc_list) {
1076  // No need to protect this call using m_mutex all other method calls are
1077  // already thread safe.
1078 
1079  const bool merge_symbol_into_function = true;
1080  size_t num_indices = symbol_indexes.size();
1081  if (num_indices > 0) {
1082  SymbolContext sc;
1083  sc.module_sp = m_objfile->GetModule();
1084  for (size_t i = 0; i < num_indices; i++) {
1085  sc.symbol = SymbolAtIndex(symbol_indexes[i]);
1086  if (sc.symbol)
1087  sc_list.AppendIfUnique(sc, merge_symbol_into_function);
1088  }
1089  }
1090 }
1091 
1093  SymbolContextList &sc_list) {
1094  std::vector<uint32_t> symbol_indexes;
1095 
1096  // eFunctionNameTypeAuto should be pre-resolved by a call to
1097  // Module::LookupInfo::LookupInfo()
1098  assert((name_type_mask & eFunctionNameTypeAuto) == 0);
1099 
1100  if (name_type_mask & (eFunctionNameTypeBase | eFunctionNameTypeFull)) {
1101  std::vector<uint32_t> temp_symbol_indexes;
1102  FindAllSymbolsWithNameAndType(name, eSymbolTypeAny, temp_symbol_indexes);
1103 
1104  unsigned temp_symbol_indexes_size = temp_symbol_indexes.size();
1105  if (temp_symbol_indexes_size > 0) {
1106  std::lock_guard<std::recursive_mutex> guard(m_mutex);
1107  for (unsigned i = 0; i < temp_symbol_indexes_size; i++) {
1108  SymbolContext sym_ctx;
1109  sym_ctx.symbol = SymbolAtIndex(temp_symbol_indexes[i]);
1110  if (sym_ctx.symbol) {
1111  switch (sym_ctx.symbol->GetType()) {
1112  case eSymbolTypeCode:
1113  case eSymbolTypeResolver:
1114  case eSymbolTypeReExported:
1115  case eSymbolTypeAbsolute:
1116  symbol_indexes.push_back(temp_symbol_indexes[i]);
1117  break;
1118  default:
1119  break;
1120  }
1121  }
1122  }
1123  }
1124  }
1125 
1127  InitNameIndexes();
1128 
1129  for (lldb::FunctionNameType type :
1130  {lldb::eFunctionNameTypeBase, lldb::eFunctionNameTypeMethod,
1131  lldb::eFunctionNameTypeSelector}) {
1132  if (name_type_mask & type) {
1133  auto map = GetNameToSymbolIndexMap(type);
1134 
1135  const UniqueCStringMap<uint32_t>::Entry *match;
1136  for (match = map.FindFirstValueForName(name); match != nullptr;
1137  match = map.FindNextValueForName(match)) {
1138  symbol_indexes.push_back(match->value);
1139  }
1140  }
1141  }
1142 
1143  if (!symbol_indexes.empty()) {
1144  llvm::sort(symbol_indexes);
1145  symbol_indexes.erase(
1146  std::unique(symbol_indexes.begin(), symbol_indexes.end()),
1147  symbol_indexes.end());
1148  SymbolIndicesToSymbolContextList(symbol_indexes, sc_list);
1149  }
1150 }
1151 
1152 const Symbol *Symtab::GetParent(Symbol *child_symbol) const {
1153  uint32_t child_idx = GetIndexForSymbol(child_symbol);
1154  if (child_idx != UINT32_MAX && child_idx > 0) {
1155  for (uint32_t idx = child_idx - 1; idx != UINT32_MAX; --idx) {
1156  const Symbol *symbol = SymbolAtIndex(idx);
1157  const uint32_t sibling_idx = symbol->GetSiblingIndex();
1158  if (sibling_idx != UINT32_MAX && sibling_idx > child_idx)
1159  return symbol;
1160  }
1161  }
1162  return nullptr;
1163 }
1164 
1166  std::string key;
1167  llvm::raw_string_ostream strm(key);
1168  // Symbol table can come from different object files for the same module. A
1169  // module can have one object file as the main executable and might have
1170  // another object file in a separate symbol file.
1171  strm << m_objfile->GetModule()->GetCacheKey() << "-symtab-"
1172  << llvm::format_hex(m_objfile->GetCacheHash(), 10);
1173  return strm.str();
1174 }
1175 
1178  if (!cache)
1179  return; // Caching is not enabled.
1180  InitNameIndexes(); // Init the name indexes so we can cache them as well.
1181  const auto byte_order = endian::InlHostByteOrder();
1182  DataEncoder file(byte_order, /*addr_size=*/8);
1183  // Encode will return false if the symbol table's object file doesn't have
1184  // anything to make a signature from.
1185  if (Encode(file))
1186  if (cache->SetCachedData(GetCacheKey(), file.GetData()))
1188 }
1189 
1190 constexpr llvm::StringLiteral kIdentifierCStrMap("CMAP");
1191 
1192 static void EncodeCStrMap(DataEncoder &encoder, ConstStringTable &strtab,
1193  const UniqueCStringMap<uint32_t> &cstr_map) {
1194  encoder.AppendData(kIdentifierCStrMap);
1195  encoder.AppendU32(cstr_map.GetSize());
1196  for (const auto &entry: cstr_map) {
1197  // Make sure there are no empty strings.
1198  assert((bool)entry.cstring);
1199  encoder.AppendU32(strtab.Add(entry.cstring));
1200  encoder.AppendU32(entry.value);
1201  }
1202 }
1203 
1204 bool DecodeCStrMap(const DataExtractor &data, lldb::offset_t *offset_ptr,
1205  const StringTableReader &strtab,
1206  UniqueCStringMap<uint32_t> &cstr_map) {
1207  llvm::StringRef identifier((const char *)data.GetData(offset_ptr, 4), 4);
1208  if (identifier != kIdentifierCStrMap)
1209  return false;
1210  const uint32_t count = data.GetU32(offset_ptr);
1211  cstr_map.Reserve(count);
1212  for (uint32_t i=0; i<count; ++i)
1213  {
1214  llvm::StringRef str(strtab.Get(data.GetU32(offset_ptr)));
1215  uint32_t value = data.GetU32(offset_ptr);
1216  // No empty strings in the name indexes in Symtab
1217  if (str.empty())
1218  return false;
1219  cstr_map.Append(ConstString(str), value);
1220  }
1221  // We must sort the UniqueCStringMap after decoding it since it is a vector
1222  // of UniqueCStringMap::Entry objects which contain a ConstString and type T.
1223  // ConstString objects are sorted by "const char *" and then type T and
1224  // the "const char *" are point values that will depend on the order in which
1225  // ConstString objects are created and in which of the 256 string pools they
1226  // are created in. So after we decode all of the entries, we must sort the
1227  // name map to ensure name lookups succeed. If we encode and decode within
1228  // the same process we wouldn't need to sort, so unit testing didn't catch
1229  // this issue when first checked in.
1230  cstr_map.Sort();
1231  return true;
1232 }
1233 
1234 constexpr llvm::StringLiteral kIdentifierSymbolTable("SYMB");
1236 
1237 /// The encoding format for the symbol table is as follows:
1238 ///
1239 /// Signature signature;
1240 /// ConstStringTable strtab;
1241 /// Identifier four character code: 'SYMB'
1242 /// uint32_t version;
1243 /// uint32_t num_symbols;
1244 /// Symbol symbols[num_symbols];
1245 /// uint8_t num_cstr_maps;
1246 /// UniqueCStringMap<uint32_t> cstr_maps[num_cstr_maps]
1247 bool Symtab::Encode(DataEncoder &encoder) const {
1248  // Name indexes must be computed before calling this function.
1249  assert(m_name_indexes_computed);
1250 
1251  // Encode the object file's signature
1252  CacheSignature signature(m_objfile);
1253  if (!signature.Encode(encoder))
1254  return false;
1255  ConstStringTable strtab;
1256 
1257  // Encoder the symbol table into a separate encoder first. This allows us
1258  // gather all of the strings we willl need in "strtab" as we will need to
1259  // write the string table out before the symbol table.
1260  DataEncoder symtab_encoder(encoder.GetByteOrder(),
1261  encoder.GetAddressByteSize());
1262  symtab_encoder.AppendData(kIdentifierSymbolTable);
1263  // Encode the symtab data version.
1264  symtab_encoder.AppendU32(CURRENT_CACHE_VERSION);
1265  // Encode the number of symbols.
1266  symtab_encoder.AppendU32(m_symbols.size());
1267  // Encode the symbol data for all symbols.
1268  for (const auto &symbol: m_symbols)
1269  symbol.Encode(symtab_encoder, strtab);
1270 
1271  // Emit a byte for how many C string maps we emit. We will fix this up after
1272  // we emit the C string maps since we skip emitting C string maps if they are
1273  // empty.
1274  size_t num_cmaps_offset = symtab_encoder.GetByteSize();
1275  uint8_t num_cmaps = 0;
1276  symtab_encoder.AppendU8(0);
1277  for (const auto &pair: m_name_to_symbol_indices) {
1278  if (pair.second.IsEmpty())
1279  continue;
1280  ++num_cmaps;
1281  symtab_encoder.AppendU8(pair.first);
1282  EncodeCStrMap(symtab_encoder, strtab, pair.second);
1283  }
1284  if (num_cmaps > 0)
1285  symtab_encoder.PutU8(num_cmaps_offset, num_cmaps);
1286 
1287  // Now that all strings have been gathered, we will emit the string table.
1288  strtab.Encode(encoder);
1289  // Followed the the symbol table data.
1290  encoder.AppendData(symtab_encoder.GetData());
1291  return true;
1292 }
1293 
1294 bool Symtab::Decode(const DataExtractor &data, lldb::offset_t *offset_ptr,
1295  bool &signature_mismatch) {
1296  signature_mismatch = false;
1297  CacheSignature signature;
1298  StringTableReader strtab;
1299  { // Scope for "elapsed" object below so it can measure the time parse.
1300  ElapsedTime elapsed(m_objfile->GetModule()->GetSymtabParseTime());
1301  if (!signature.Decode(data, offset_ptr))
1302  return false;
1303  if (CacheSignature(m_objfile) != signature) {
1304  signature_mismatch = true;
1305  return false;
1306  }
1307  // We now decode the string table for all strings in the data cache file.
1308  if (!strtab.Decode(data, offset_ptr))
1309  return false;
1310 
1311  // And now we can decode the symbol table with string table we just decoded.
1312  llvm::StringRef identifier((const char *)data.GetData(offset_ptr, 4), 4);
1313  if (identifier != kIdentifierSymbolTable)
1314  return false;
1315  const uint32_t version = data.GetU32(offset_ptr);
1316  if (version != CURRENT_CACHE_VERSION)
1317  return false;
1318  const uint32_t num_symbols = data.GetU32(offset_ptr);
1319  if (num_symbols == 0)
1320  return true;
1321  m_symbols.resize(num_symbols);
1322  SectionList *sections = m_objfile->GetModule()->GetSectionList();
1323  for (uint32_t i=0; i<num_symbols; ++i) {
1324  if (!m_symbols[i].Decode(data, offset_ptr, sections, strtab))
1325  return false;
1326  }
1327  }
1328 
1329  { // Scope for "elapsed" object below so it can measure the time to index.
1330  ElapsedTime elapsed(m_objfile->GetModule()->GetSymtabIndexTime());
1331  const uint8_t num_cstr_maps = data.GetU8(offset_ptr);
1332  for (uint8_t i=0; i<num_cstr_maps; ++i) {
1333  uint8_t type = data.GetU8(offset_ptr);
1334  UniqueCStringMap<uint32_t> &cstr_map =
1335  GetNameToSymbolIndexMap((lldb::FunctionNameType)type);
1336  if (!DecodeCStrMap(data, offset_ptr, strtab, cstr_map))
1337  return false;
1338  }
1339  m_name_indexes_computed = true;
1340  }
1341  return true;
1342 }
1343 
1346  if (!cache)
1347  return false;
1348 
1349  std::unique_ptr<llvm::MemoryBuffer> mem_buffer_up =
1350  cache->GetCachedData(GetCacheKey());
1351  if (!mem_buffer_up)
1352  return false;
1353  DataExtractor data(mem_buffer_up->getBufferStart(),
1354  mem_buffer_up->getBufferSize(),
1357  bool signature_mismatch = false;
1358  lldb::offset_t offset = 0;
1359  const bool result = Decode(data, &offset, signature_mismatch);
1360  if (signature_mismatch)
1361  cache->RemoveCacheFile(GetCacheKey());
1362  if (result)
1364  return result;
1365 }
RegularExpression.h
SymbolSearchInfo::symtab
const Symtab * symtab
Definition: Symtab.cpp:890
lldb_private::Stream::IndentLess
void IndentLess(unsigned amount=2)
Decrement the current indentation level.
Definition: Stream.cpp:171
lldb_private::ConstStringTable::Encode
bool Encode(DataEncoder &encoder)
Definition: DataFileCache.cpp:279
lldb_private::eSortOrderByAddress
@ eSortOrderByAddress
Definition: lldb-private-enumerations.h:110
lldb_private::Range::GetRangeBase
BaseType GetRangeBase() const
Definition: RangeMap.h:46
lldb_private::Symtab::m_file_addr_to_index
FileRangeToIndexMap m_file_addr_to_index
Definition: Symtab.h:275
lldb_private::UniqueCStringMap::Sort
void Sort()
Definition: UniqueCStringMap.h:168
lldb_private::RegularExpression
Definition: RegularExpression.h:18
lldb_private::StringTableReader
Many cache files require string tables to store data efficiently.
Definition: DataFileCache.h:212
lldb_private::ObjectFile::GetFileSpec
virtual FileSpec & GetFileSpec()
Get accessor to the object file specification.
Definition: ObjectFile.h:292
lldb_private::Symtab::m_objfile
ObjectFile * m_objfile
Definition: Symtab.h:273
lldb::eSymbolTypeCode
@ eSymbolTypeCode
Definition: lldb-enumerations.h:623
lldb_private::Symtab::SetWasSavedToCache
void SetWasSavedToCache()
Definition: Symtab.h:237
SymbolSearchInfo::file_addr
const addr_t file_addr
Definition: Symtab.cpp:891
lldb_private::Symtab::AppendSymbolIndexesWithTypeAndFlagsValue
uint32_t AppendSymbolIndexesWithTypeAndFlagsValue(lldb::SymbolType symbol_type, uint32_t flags_value, std::vector< uint32_t > &indexes, uint32_t start_idx=0, uint32_t end_index=UINT32_MAX) const
Definition: Symtab.cpp:505
lldb_private::Symtab::AppendSymbolNamesToMap
void AppendSymbolNamesToMap(const IndexCollection &indexes, bool add_demangled, bool add_mangled, NameToIndexMap &name_to_index_map) const
Definition: Symtab.cpp:459
lldb_private::RangeDataVector::GetEntryRef
Entry & GetEntryRef(size_t i)
Definition: RangeMap.h:538
lldb_private::Symbol::GetSyntheticSymbolPrefix
static llvm::StringRef GetSyntheticSymbolPrefix()
Definition: Symbol.h:244
lldb_private::Symtab::GetNameToSymbolIndexMap
UniqueCStringMap< uint32_t > & GetNameToSymbolIndexMap(lldb::FunctionNameType type)
Definition: Symtab.h:287
lldb_private::DataFileCache::GetCachedData
std::unique_ptr< llvm::MemoryBuffer > GetCachedData(llvm::StringRef key)
Get cached data from the cache directory for the specified key.
Definition: DataFileCache.cpp:74
lldb_private::Symbol::SetSizeIsSynthesized
void SetSizeIsSynthesized(bool b)
Definition: Symbol.h:174
lldb_private::RangeVector::Sort
void Sort()
Definition: RangeMap.h:217
lldb_private::Symbol
Definition: Symbol.h:20
lldb_private::Module::GetIndexCache
static DataFileCache * GetIndexCache()
Get the global index file cache.
Definition: Module.cpp:1719
lldb_private::Symtab::GetParent
const Symbol * GetParent(Symbol *symbol) const
Get the parent symbol for the given symbol.
Definition: Symtab.cpp:1152
lldb_private::Symtab::PreloadSymbols
void PreloadSymbols()
Definition: Symtab.cpp:454
lldb_private::ConstStringTable
Many cache files require string tables to store data efficiently.
Definition: DataFileCache.h:180
lldb_private::Symtab::m_symbols
collection m_symbols
Definition: Symtab.h:274
lldb_private::Symtab::Debug
Debug
Definition: Symtab.h:27
lldb_private::ElapsedTime
A class that measures elapsed time in an exception safe way.
Definition: Statistics.h:67
SymbolSearchInfo
Definition: Symtab.cpp:889
Module.h
lldb_private::RichManglingContext::IsCtorOrDtor
bool IsCtorOrDtor() const
If this symbol describes a constructor or destructor.
Definition: RichManglingContext.cpp:66
lldb_private::RangeDataVector::Sort
void Sort()
Definition: RangeMap.h:460
lldb_private::Symtab::~Symtab
~Symtab()
lldb_private::SymbolContextList
Definition: SymbolContext.h:379
AddSectionsToRangeMap
static void AddSectionsToRangeMap(SectionList *sectlist, RangeVector< addr_t, addr_t > &section_ranges)
Definition: Symtab.cpp:899
lldb_private::SectionList
Definition: Section.h:34
lldb::offset_t
uint64_t offset_t
Definition: lldb-types.h:87
lldb_private::RangeDataVector::Clear
void Clear()
Definition: RangeMap.h:522
lldb_private::Stream
Definition: Stream.h:28
lldb_private::RangeData
Definition: RangeMap.h:415
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
Language.h
lldb_private::Symtab::SymbolAtIndex
Symbol * SymbolAtIndex(size_t idx)
Definition: Symtab.cpp:217
lldb_private::Symbol::IsSyntheticWithAutoGeneratedName
bool IsSyntheticWithAutoGeneratedName() const
Definition: Symbol.cpp:572
SymbolSortInfo::sort_by_load_addr
const bool sort_by_load_addr
Definition: Symtab.cpp:558
lldb_private::SectionList::GetNumSections
size_t GetNumSections(uint32_t depth) const
Definition: Section.cpp:527
lldb_private::SymbolContext
Definition: SymbolContext.h:33
lldb_private::Target
Definition: Target.h:469
Section.h
lldb_private::Symtab::SetWasLoadedFromCache
void SetWasLoadedFromCache()
Definition: Symtab.h:231
lldb_private::eSortOrderNone
@ eSortOrderNone
Definition: lldb-private-enumerations.h:110
lldb_private::RichManglingContext::ParseFunctionBaseName
llvm::StringRef ParseFunctionBaseName()
Get the base name of a function.
Definition: RichManglingContext.cpp:112
lldb_private::RangeVector::Append
void Append(const Entry &entry)
Definition: RangeMap.h:179
lldb_private::Symtab::FindFunctionSymbols
void FindFunctionSymbols(ConstString name, uint32_t name_type_mask, SymbolContextList &sc_list)
Definition: Symtab.cpp:1092
DataFileCache.h
lldb_private::CacheSignature::Decode
bool Decode(const DataExtractor &data, lldb::offset_t *offset_ptr)
Decode a serialized version of this object from data.
Definition: DataFileCache.cpp:232
lldb_private::Symtab::Encode
bool Encode(DataEncoder &encoder) const
Encode this object into a data encoder object.
Definition: Symtab.cpp:1247
lldb_private::CacheSignature::Encode
bool Encode(DataEncoder &encoder) const
Encode this object into a data encoder object.
Definition: DataFileCache.cpp:210
lldb_private::ConstStringTable::Add
uint32_t Add(ConstString s)
Add a string into the string table.
Definition: DataFileCache.cpp:266
lldb_private::DataFileCache::SetCachedData
bool SetCachedData(llvm::StringRef key, llvm::ArrayRef< uint8_t > data)
Set cached data for the specified key.
Definition: DataFileCache.cpp:108
lldb_private::Symtab::FindFirstSymbolWithNameAndType
Symbol * FindFirstSymbolWithNameAndType(ConstString name, lldb::SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility)
Definition: Symtab.cpp:861
lldb_private::Symbol::ContainsFileAddress
bool ContainsFileAddress(lldb::addr_t file_addr) const
Definition: Symbol.cpp:568
lldb_private::RangeDataVector::FindEntryThatContains
Entry * FindEntryThatContains(B addr)
Definition: RangeMap.h:563
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
elapsed
static double elapsed(const StatsTimepoint &start, const StatsTimepoint &end)
Definition: Statistics.cpp:36
lldb::eSymbolTypeAny
@ eSymbolTypeAny
Definition: lldb-enumerations.h:620
lldb_private::SymbolContext::symbol
Symbol * symbol
The Symbol for a given query.
Definition: SymbolContext.h:323
lldb_private::ObjectFile::GetSectionList
virtual SectionList * GetSectionList(bool update_module_section_list=true)
Gets the section list for the currently selected architecture (and object for archives).
Definition: ObjectFile.cpp:588
lldb_private::Symtab::m_mutex
std::recursive_mutex m_mutex
Definition: Symtab.h:281
lldb_private::Symbol::SetByteSize
void SetByteSize(lldb::addr_t size)
Definition: Symbol.h:196
lldb_private::DataFileCache::RemoveCacheFile
Status RemoveCacheFile(llvm::StringRef key)
Remove the cache file associated with the key.
Definition: DataFileCache.cpp:158
lldb_private::Symtab::LoadFromCache
bool LoadFromCache()
Load the symbol table from the index cache.
Definition: Symtab.cpp:1344
lldb_private::RangeDataVector::Append
void Append(const Entry &entry)
Definition: RangeMap.h:451
lldb_private::RangeDataVector::FindEntryIndexesThatContain
uint32_t FindEntryIndexesThatContain(B addr, std::vector< uint32_t > &indexes)
Definition: RangeMap.h:553
kIdentifierSymbolTable
constexpr llvm::StringLiteral kIdentifierSymbolTable("SYMB")
lldb_private::Stream::Indent
size_t Indent(llvm::StringRef s="")
Indent the current line in the stream.
Definition: Stream.cpp:130
lldb_private::Symtab::m_name_to_symbol_indices
std::map< lldb::FunctionNameType, UniqueCStringMap< uint32_t > > m_name_to_symbol_indices
Maps function names to symbol indices (grouped by FunctionNameTypes)
Definition: Symtab.h:279
EncodeCStrMap
static void EncodeCStrMap(DataEncoder &encoder, ConstStringTable &strtab, const UniqueCStringMap< uint32_t > &cstr_map)
Definition: Symtab.cpp:1192
lldb_private::DataExtractor
Definition: DataExtractor.h:48
lldb_private::Symtab::Dump
void Dump(Stream *s, Target *target, SortOrder sort_type, Mangled::NamePreference name_preference=Mangled::ePreferDemangled)
Definition: Symtab.cpp:88
lldb_private::ConstString::GetStringRef
llvm::StringRef GetStringRef() const
Get the string value as a llvm::StringRef.
Definition: ConstString.h:201
CURRENT_CACHE_VERSION
constexpr uint32_t CURRENT_CACHE_VERSION
Definition: Symtab.cpp:1235
lldb_private::Symtab::DumpSymbolHeader
static void DumpSymbolHeader(Stream *s)
Definition: Symtab.cpp:186
lldb_private::UniqueCStringMap::GetSize
size_t GetSize() const
Definition: UniqueCStringMap.h:148
lldb_private::Symtab::Finalize
void Finalize()
Definition: Symtab.cpp:1008
kIdentifierCStrMap
constexpr llvm::StringLiteral kIdentifierCStrMap("CMAP")
lldb_private::StringTableReader::Decode
bool Decode(const DataExtractor &data, lldb::offset_t *offset_ptr)
Definition: DataFileCache.cpp:301
lldb_private::UniqueCStringMap::FindFirstValueForName
const Entry * FindFirstValueForName(ConstString unique_cstr) const
Definition: UniqueCStringMap.h:98
lldb_private::Symtab::GetNameIndexes
uint32_t GetNameIndexes(ConstString symbol_name, std::vector< uint32_t > &indexes)
A helper function that looks up full function names.
Definition: Symtab.cpp:638
lldb_private::ObjectFile::StripLinkerSymbolAnnotations
virtual llvm::StringRef StripLinkerSymbolAnnotations(llvm::StringRef symbol_name) const
Definition: ObjectFile.h:681
lldb_private::Symtab::m_file_addr_to_index_computed
bool m_file_addr_to_index_computed
Definition: Symtab.h:282
lldb_private::ConstString
Definition: ConstString.h:39
lldb_private::ObjectFile::GetByteOrder
virtual lldb::ByteOrder GetByteOrder() const =0
Gets whether endian swapping should occur when extracting data from this object file.
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::Symtab::FindSymbolContainingFileAddress
Symbol * FindSymbolContainingFileAddress(lldb::addr_t file_addr)
Definition: Symtab.cpp:1035
lldb_private::Symtab::SaveToCache
void SaveToCache()
Save the symbol table data out into a cache.
Definition: Symtab.cpp:1176
Timer.h
lldb_private::CacheSignature
A signature for a given file on disk.
Definition: DataFileCache.h:108
DataEncoder.h
lldb_private::Symtab::const_iterator
collection::const_iterator const_iterator
Definition: Symtab.h:245
lldb_private::SectionList::GetSectionAtIndex
lldb::SectionSP GetSectionAtIndex(size_t idx) const
Definition: Section.cpp:538
lldb_private::Range
Definition: Process.h:61
LLDB_SCOPED_TIMER
#define LLDB_SCOPED_TIMER()
Definition: Timer.h:83
lldb_private::Symbol::Compare
bool Compare(ConstString name, lldb::SymbolType type) const
Definition: Symbol.cpp:332
lldb_private::Symtab::FindAllSymbolsMatchingRexExAndType
void FindAllSymbolsMatchingRexExAndType(const RegularExpression &regex, lldb::SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility, std::vector< uint32_t > &symbol_indexes, Mangled::NamePreference name_preference=Mangled::ePreferDemangled)
Definition: Symtab.cpp:849
lldb_private::SymbolContextList::AppendIfUnique
bool AppendIfUnique(const SymbolContext &sc, bool merge_symbol_into_function)
Definition: SymbolContext.cpp:1205
lldb_private::Symtab::GetIndexForSymbol
uint32_t GetIndexForSymbol(const Symbol *symbol) const
Definition: Symtab.cpp:548
lldb_private::Symtab::InitAddressIndexes
void InitAddressIndexes()
Definition: Symtab.cpp:925
lldb_private::Symtab::FindSymbolWithType
Symbol * FindSymbolWithType(lldb::SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility, uint32_t &start_idx)
Definition: Symtab.cpp:793
lldb_private::Symbol::ContainsLinkerAnnotations
bool ContainsLinkerAnnotations() const
Definition: Symbol.h:215
string
string(SUBSTRING ${p} 10 -1 pStripped) if($
Definition: Plugins/CMakeLists.txt:40
lldb_private::Symtab::FindSymbolAtFileAddress
Symbol * FindSymbolAtFileAddress(lldb::addr_t file_addr)
Definition: Symtab.cpp:1020
lldb_private::Symbol::GetMangled
Mangled & GetMangled()
Definition: Symbol.h:131
lldb::SymbolType
SymbolType
Symbol types.
Definition: lldb-enumerations.h:619
lldb_private::RangeVector
Definition: RangeMap.h:136
lldb_private::UniqueCStringMap< uint32_t >
lldb_private::Symtab::RegisterBacklogEntry
void RegisterBacklogEntry(const NameToIndexMap::Entry &entry, const char *decl_context, const std::set< const char * > &class_contexts)
Definition: Symtab.cpp:436
lldb_private::UniqueCStringMap::Reserve
void Reserve(size_t n)
Definition: UniqueCStringMap.h:157
ObjectFile.h
lldb_private::RangeDataVector::FindEntryStartsAt
const Entry * FindEntryStartsAt(B addr) const
Definition: RangeMap.h:592
Symbol.h
lldb_private::Symtab::GetNumSymbols
size_t GetNumSymbols() const
Definition: Symtab.cpp:77
lldb_private::Symtab::Reserve
void Reserve(size_t count)
Definition: Symtab.cpp:51
SymbolSearchInfo::match_index_ptr
const uint32_t * match_index_ptr
Definition: Symtab.cpp:893
lldb_private::Symtab::InitNameIndexes
void InitNameIndexes()
Definition: Symtab.cpp:269
lldb_private::Symtab::AddSymbol
uint32_t AddSymbol(const Symbol &symbol)
Definition: Symtab.cpp:64
lldb_private::Symtab::CheckSymbolAtIndex
bool CheckSymbolAtIndex(size_t idx, Debug symbol_debug_type, Visibility symbol_visibility) const
Definition: Symtab.h:292
lldb_private::RichManglingContext::ParseFunctionDeclContextName
llvm::StringRef ParseFunctionDeclContextName()
Get the context name for a function.
Definition: RichManglingContext.cpp:129
lldb_private::RichManglingContext
Uniform wrapper for access to rich mangling information from different providers.
Definition: RichManglingContext.h:25
lldb_private::UniqueCStringMap::Append
void Append(ConstString unique_cstr, const T &value)
Definition: UniqueCStringMap.h:42
lldb_private::Symtab::AppendSymbolIndexesWithType
uint32_t AppendSymbolIndexesWithType(lldb::SymbolType symbol_type, std::vector< uint32_t > &indexes, uint32_t start_idx=0, uint32_t end_index=UINT32_MAX) const
Definition: Symtab.cpp:487
lldb_private::Symtab
Definition: Symtab.h:22
lldb_private::Symtab::AppendSymbolIndexesWithName
uint32_t AppendSymbolIndexesWithName(ConstString symbol_name, std::vector< uint32_t > &matches)
Definition: Symtab.cpp:668
uint32_t
lldb_private::Stream::IndentMore
void IndentMore(unsigned amount=2)
Increment the current indentation level.
Definition: Stream.cpp:168
lldb_private::Language
Definition: Language.h:29
lldb_private::RangeDataVector::GetSize
size_t GetSize() const
Definition: RangeMap.h:526
DecodeCStrMap
bool DecodeCStrMap(const DataExtractor &data, lldb::offset_t *offset_ptr, const StringTableReader &strtab, UniqueCStringMap< uint32_t > &cstr_map)
Definition: Symtab.cpp:1204
SymbolSearchInfo::match_symbol
Symbol * match_symbol
Definition: Symtab.cpp:892
lldb_skip_name
static bool lldb_skip_name(llvm::StringRef mangled, Mangled::ManglingScheme scheme)
Definition: Symtab.cpp:233
lldb_private::endian::InlHostByteOrder
lldb::ByteOrder InlHostByteOrder()
Definition: Endian.h:25
lldb_private::Symtab::FindSymbolByID
Symbol * FindSymbolByID(lldb::user_id_t uid) const
Definition: Symtab.cpp:208
Symtab.h
lldb_private::Range::SetRangeBase
void SetRangeBase(BaseType b)
Definition: RangeMap.h:48
lldb_private::Symtab::AppendSymbolIndexesMatchingRegExAndType
uint32_t AppendSymbolIndexesMatchingRegExAndType(const RegularExpression &regex, lldb::SymbolType symbol_type, std::vector< uint32_t > &indexes, Mangled::NamePreference name_preference=Mangled::ePreferDemangled)
Definition: Symtab.cpp:745
lldb_private::Range::GetByteSize
SizeType GetByteSize() const
Definition: RangeMap.h:87
UINT32_MAX
#define UINT32_MAX
Definition: lldb-defines.h:19
lldb_private::Symtab::Visibility
Visibility
Definition: Symtab.h:33
lldb_private::Range::SetByteSize
void SetByteSize(SizeType s)
Definition: RangeMap.h:89
lldb_private::ModuleChild::GetModule
lldb::ModuleSP GetModule() const
Get const accessor for the module pointer.
Definition: ModuleChild.cpp:24
lldb_private::Symtab::Decode
bool Decode(const DataExtractor &data, lldb::offset_t *offset_ptr, bool &uuid_mismatch)
Decode a serialized version of this object from data.
Definition: Symtab.cpp:1294
lldb_private::Symtab::AppendSymbolIndexesWithNameAndType
uint32_t AppendSymbolIndexesWithNameAndType(ConstString symbol_name, lldb::SymbolType symbol_type, std::vector< uint32_t > &matches)
Definition: Symtab.cpp:707
lldb_private::SymbolContext::module_sp
lldb::ModuleSP module_sp
The Module for a given query.
Definition: SymbolContext.h:318
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::ObjectFile::GetCacheHash
uint32_t GetCacheHash()
Get a hash that can be used for caching object file releated information.
Definition: ObjectFile.cpp:756
lldb_private::Symtab::SectionFileAddressesChanged
void SectionFileAddressesChanged()
Definition: Symtab.cpp:82
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
lldb_private::SortOrder
SortOrder
Definition: lldb-private-enumerations.h:110
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::DataFileCache
This class enables data to be cached into a directory using the llvm caching code.
Definition: DataFileCache.h:44
SymbolSortInfo::symbols
const Symbol * symbols
Definition: Symtab.cpp:559
lldb::user_id_t
uint64_t user_id_t
Definition: lldb-types.h:84
lldb::eSymbolTypeReExported
@ eSymbolTypeReExported
Definition: lldb-enumerations.h:650
SymbolContext.h
lldb_private::Symtab::GetCacheKey
std::string GetCacheKey()
Get the cache key string for this symbol table.
Definition: Symtab.cpp:1165
lldb_private::Symtab::RegisterMangledNameEntry
void RegisterMangledNameEntry(uint32_t value, std::set< const char * > &class_contexts, std::vector< std::pair< NameToIndexMap::Entry, const char * >> &backlog, RichManglingContext &rmc)
Definition: Symtab.cpp:383
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::RangeDataVector::GetMutableEntryAtIndex
Entry * GetMutableEntryAtIndex(size_t i)
Definition: RangeMap.h:532
lldb_private::ObjectFile::GetAddressByteSize
virtual uint32_t GetAddressByteSize() const =0
Gets the address size in bytes for the current object file.
lldb_private::Symtab::FindAllSymbolsWithNameAndType
void FindAllSymbolsWithNameAndType(ConstString name, lldb::SymbolType symbol_type, std::vector< uint32_t > &symbol_indexes)
Definition: Symtab.cpp:813
lldb_private::Symbol::IsTrampoline
bool IsTrampoline() const
Definition: Symbol.cpp:173
lldb_private::RegularExpression::Execute
bool Execute(llvm::StringRef string, llvm::SmallVectorImpl< llvm::StringRef > *matches=nullptr) const
Execute a regular expression match using the compiled regular expression that is already in this obje...
Definition: RegularExpression.cpp:23
lldb_private::Symtab::SortSymbolIndexesByValue
void SortSymbolIndexesByValue(std::vector< uint32_t > &indexes, bool remove_duplicates) const
Definition: Symtab.cpp:613
Entry
FormatEntity::Entry Entry
Definition: FormatEntity.cpp:82
lldb_private::eSortOrderByName
@ eSortOrderByName
Definition: lldb-private-enumerations.h:110
lldb_private::DataExtractor::GetData
const void * GetData(lldb::offset_t *offset_ptr, lldb::offset_t length) const
Extract length bytes from *offset_ptr.
Definition: DataExtractor.h:337
lldb_private::RangeVector::FindEntryThatContains
const Entry * FindEntryThatContains(B addr) const
Definition: RangeMap.h:338
lldb_private::Symtab::m_name_indexes_computed
bool m_name_indexes_computed
Definition: Symtab.h:282
RichManglingContext.h
Stream.h
lldb_private::Symtab::Resize
Symbol * Resize(size_t count)
Definition: Symtab.cpp:57
lldb_private::Stream::PutCString
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
Definition: Stream.cpp:63
lldb_private::UniqueCStringMap::FindNextValueForName
const Entry * FindNextValueForName(const Entry *entry_ptr) const
Definition: UniqueCStringMap.h:111
lldb_private::Symtab::collection
std::vector< Symbol > collection
Definition: Symtab.h:243
lldb::eSymbolTypeResolver
@ eSymbolTypeResolver
Definition: lldb-enumerations.h:624
lldb_private::Language::ForEach
static void ForEach(std::function< bool(Language *)> callback)
Definition: Language.cpp:100
lldb_private::Symtab::IndexCollection
std::vector< uint32_t > IndexCollection
Definition: Symtab.h:24
lldb_private::RangeData::data
DataType data
Definition: RangeMap.h:418
lldb::eSymbolTypeAbsolute
@ eSymbolTypeAbsolute
Definition: lldb-enumerations.h:622
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
Definition: SBAddress.h:15
Endian.h
lldb_private::Symtab::SymbolIndicesToSymbolContextList
void SymbolIndicesToSymbolContextList(std::vector< uint32_t > &symbol_indexes, SymbolContextList &sc_list)
Definition: Symtab.cpp:1074
lldb_private::ObjectFile
Definition: ObjectFile.h:60
lldb_private::StringTableReader::Get
llvm::StringRef Get(uint32_t offset) const
Definition: DataFileCache.cpp:317
SymbolSortInfo
Definition: Symtab.cpp:557
lldb_private::Symtab::ForEachSymbolContainingFileAddress
void ForEachSymbolContainingFileAddress(lldb::addr_t file_addr, std::function< bool(Symbol *)> const &callback)
Definition: Symtab.cpp:1051
CompareSymbolID
static int CompareSymbolID(const void *key, const void *p)
Definition: Symtab.cpp:198
lldb_private::Symbol::GetSiblingIndex
uint32_t GetSiblingIndex() const
Definition: Symbol.cpp:169
SymbolSearchInfo::match_offset
addr_t match_offset
Definition: Symtab.cpp:894