LLDB  mainline
ObjectFile.cpp
Go to the documentation of this file.
1 //===-- ObjectFile.cpp ----------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
10 #include "lldb/Core/Module.h"
11 #include "lldb/Core/ModuleSpec.h"
13 #include "lldb/Core/Section.h"
16 #include "lldb/Symbol/SymbolFile.h"
17 #include "lldb/Target/Process.h"
19 #include "lldb/Target/Target.h"
22 #include "lldb/Utility/Log.h"
23 #include "lldb/Utility/Timer.h"
24 #include "lldb/lldb-private.h"
25 
26 using namespace lldb;
27 using namespace lldb_private;
28 
29 char ObjectFile::ID;
30 
31 static ObjectFileSP
32 CreateObjectFromContainer(const lldb::ModuleSP &module_sp, const FileSpec *file,
33  lldb::offset_t file_offset, lldb::offset_t file_size,
34  DataBufferSP &data_sp, lldb::offset_t &data_offset) {
36  for (uint32_t idx = 0;
37  (callback = PluginManager::GetObjectContainerCreateCallbackAtIndex(
38  idx)) != nullptr;
39  ++idx) {
40  std::unique_ptr<ObjectContainer> object_container_up(callback(
41  module_sp, data_sp, data_offset, file, file_offset, file_size));
42  if (object_container_up)
43  return object_container_up->GetObjectFile(file);
44  }
45  return {};
46 }
47 
48 ObjectFileSP
49 ObjectFile::FindPlugin(const lldb::ModuleSP &module_sp, const FileSpec *file,
50  lldb::offset_t file_offset, lldb::offset_t file_size,
51  DataBufferSP &data_sp, lldb::offset_t &data_offset) {
53  "ObjectFile::FindPlugin (module = %s, file = %p, file_offset = "
54  "0x%8.8" PRIx64 ", file_size = 0x%8.8" PRIx64 ")",
55  module_sp->GetFileSpec().GetPath().c_str(),
56  static_cast<const void *>(file), static_cast<uint64_t>(file_offset),
57  static_cast<uint64_t>(file_size));
58 
59  if (!module_sp)
60  return {};
61 
62  if (!file)
63  return {};
64 
65  if (!data_sp) {
66  const bool file_exists = FileSystem::Instance().Exists(*file);
67  // We have an object name which most likely means we have a .o file in
68  // a static archive (.a file). Try and see if we have a cached archive
69  // first without reading any data first
70  if (file_exists && module_sp->GetObjectName()) {
71  ObjectFileSP object_file_sp = CreateObjectFromContainer(
72  module_sp, file, file_offset, file_size, data_sp, data_offset);
73  if (object_file_sp)
74  return object_file_sp;
75  }
76  // Ok, we didn't find any containers that have a named object, now lets
77  // read the first 512 bytes from the file so the object file and object
78  // container plug-ins can use these bytes to see if they can parse this
79  // file.
80  if (file_size > 0) {
81  data_sp = FileSystem::Instance().CreateDataBuffer(file->GetPath(), 512,
82  file_offset);
83  data_offset = 0;
84  }
85  }
86 
87  if (!data_sp || data_sp->GetByteSize() == 0) {
88  // Check for archive file with format "/path/to/archive.a(object.o)"
89  llvm::SmallString<256> path_with_object;
90  module_sp->GetFileSpec().GetPath(path_with_object);
91 
92  FileSpec archive_file;
93  ConstString archive_object;
94  const bool must_exist = true;
95  if (ObjectFile::SplitArchivePathWithObject(path_with_object, archive_file,
96  archive_object, must_exist)) {
97  file_size = FileSystem::Instance().GetByteSize(archive_file);
98  if (file_size > 0) {
99  file = &archive_file;
100  module_sp->SetFileSpecAndObjectName(archive_file, archive_object);
101  // Check if this is a object container by iterating through all
102  // object container plugin instances and then trying to get an
103  // object file from the container plugins since we had a name.
104  // Also, don't read
105  // ANY data in case there is data cached in the container plug-ins
106  // (like BSD archives caching the contained objects within an
107  // file).
108  ObjectFileSP object_file_sp = CreateObjectFromContainer(
109  module_sp, file, file_offset, file_size, data_sp, data_offset);
110  if (object_file_sp)
111  return object_file_sp;
112  // We failed to find any cached object files in the container plug-
113  // ins, so lets read the first 512 bytes and try again below...
114  data_sp = FileSystem::Instance().CreateDataBuffer(
115  archive_file.GetPath(), 512, file_offset);
116  }
117  }
118  }
119 
120  if (data_sp && data_sp->GetByteSize() > 0) {
121  // Check if this is a normal object file by iterating through all
122  // object file plugin instances.
123  ObjectFileCreateInstance callback;
124  for (uint32_t idx = 0;
125  (callback = PluginManager::GetObjectFileCreateCallbackAtIndex(idx)) !=
126  nullptr;
127  ++idx) {
128  ObjectFileSP object_file_sp(callback(module_sp, data_sp, data_offset,
129  file, file_offset, file_size));
130  if (object_file_sp.get())
131  return object_file_sp;
132  }
133 
134  // Check if this is a object container by iterating through all object
135  // container plugin instances and then trying to get an object file
136  // from the container.
137  ObjectFileSP object_file_sp = CreateObjectFromContainer(
138  module_sp, file, file_offset, file_size, data_sp, data_offset);
139  if (object_file_sp)
140  return object_file_sp;
141  }
142 
143  // We didn't find it, so clear our shared pointer in case it contains
144  // anything and return an empty shared pointer
145  return {};
146 }
147 
148 ObjectFileSP ObjectFile::FindPlugin(const lldb::ModuleSP &module_sp,
149  const ProcessSP &process_sp,
150  lldb::addr_t header_addr,
151  DataBufferSP &data_sp) {
152  ObjectFileSP object_file_sp;
153 
154  if (module_sp) {
155  LLDB_SCOPED_TIMERF("ObjectFile::FindPlugin (module = "
156  "%s, process = %p, header_addr = "
157  "0x%" PRIx64 ")",
158  module_sp->GetFileSpec().GetPath().c_str(),
159  static_cast<void *>(process_sp.get()), header_addr);
160  uint32_t idx;
161 
162  // Check if this is a normal object file by iterating through all object
163  // file plugin instances.
164  ObjectFileCreateMemoryInstance create_callback;
165  for (idx = 0;
166  (create_callback =
167  PluginManager::GetObjectFileCreateMemoryCallbackAtIndex(idx)) !=
168  nullptr;
169  ++idx) {
170  object_file_sp.reset(
171  create_callback(module_sp, data_sp, process_sp, header_addr));
172  if (object_file_sp.get())
173  return object_file_sp;
174  }
175  }
176 
177  // We didn't find it, so clear our shared pointer in case it contains
178  // anything and return an empty shared pointer
179  object_file_sp.reset();
180  return object_file_sp;
181 }
182 
183 size_t ObjectFile::GetModuleSpecifications(const FileSpec &file,
184  lldb::offset_t file_offset,
185  lldb::offset_t file_size,
186  ModuleSpecList &specs,
187  DataBufferSP data_sp) {
188  if (!data_sp)
189  data_sp = FileSystem::Instance().CreateDataBuffer(file.GetPath(), 512,
190  file_offset);
191  if (data_sp) {
192  if (file_size == 0) {
193  const lldb::offset_t actual_file_size =
194  FileSystem::Instance().GetByteSize(file);
195  if (actual_file_size > file_offset)
196  file_size = actual_file_size - file_offset;
197  }
198  return ObjectFile::GetModuleSpecifications(file, // file spec
199  data_sp, // data bytes
200  0, // data offset
201  file_offset, // file offset
202  file_size, // file length
203  specs);
204  }
205  return 0;
206 }
207 
208 size_t ObjectFile::GetModuleSpecifications(
209  const lldb_private::FileSpec &file, lldb::DataBufferSP &data_sp,
210  lldb::offset_t data_offset, lldb::offset_t file_offset,
211  lldb::offset_t file_size, lldb_private::ModuleSpecList &specs) {
212  const size_t initial_count = specs.GetSize();
213  ObjectFileGetModuleSpecifications callback;
214  uint32_t i;
215  // Try the ObjectFile plug-ins
216  for (i = 0;
217  (callback =
218  PluginManager::GetObjectFileGetModuleSpecificationsCallbackAtIndex(
219  i)) != nullptr;
220  ++i) {
221  if (callback(file, data_sp, data_offset, file_offset, file_size, specs) > 0)
222  return specs.GetSize() - initial_count;
223  }
224 
225  // Try the ObjectContainer plug-ins
226  for (i = 0;
227  (callback = PluginManager::
228  GetObjectContainerGetModuleSpecificationsCallbackAtIndex(i)) !=
229  nullptr;
230  ++i) {
231  if (callback(file, data_sp, data_offset, file_offset, file_size, specs) > 0)
232  return specs.GetSize() - initial_count;
233  }
234  return 0;
235 }
236 
237 ObjectFile::ObjectFile(const lldb::ModuleSP &module_sp,
238  const FileSpec *file_spec_ptr,
239  lldb::offset_t file_offset, lldb::offset_t length,
240  const lldb::DataBufferSP &data_sp,
241  lldb::offset_t data_offset)
242  : ModuleChild(module_sp),
243  m_file(), // This file could be different from the original module's file
244  m_type(eTypeInvalid), m_strata(eStrataInvalid),
245  m_file_offset(file_offset), m_length(length), m_data(), m_process_wp(),
246  m_memory_addr(LLDB_INVALID_ADDRESS), m_sections_up(), m_symtab_up(),
247  m_synthetic_symbol_idx(0) {
248  if (file_spec_ptr)
249  m_file = *file_spec_ptr;
250  if (data_sp)
251  m_data.SetData(data_sp, data_offset, length);
253  LLDB_LOGF(log,
254  "%p ObjectFile::ObjectFile() module = %p (%s), file = %s, "
255  "file_offset = 0x%8.8" PRIx64 ", size = %" PRIu64,
256  static_cast<void *>(this), static_cast<void *>(module_sp.get()),
257  module_sp->GetSpecificationDescription().c_str(),
258  m_file ? m_file.GetPath().c_str() : "<NULL>", m_file_offset,
259  m_length);
260 }
261 
262 ObjectFile::ObjectFile(const lldb::ModuleSP &module_sp,
263  const ProcessSP &process_sp, lldb::addr_t header_addr,
264  DataBufferSP &header_data_sp)
265  : ModuleChild(module_sp), m_file(), m_type(eTypeInvalid),
266  m_strata(eStrataInvalid), m_file_offset(0), m_length(0), m_data(),
267  m_process_wp(process_sp), m_memory_addr(header_addr), m_sections_up(),
268  m_symtab_up(), m_synthetic_symbol_idx(0) {
269  if (header_data_sp)
270  m_data.SetData(header_data_sp, 0, header_data_sp->GetByteSize());
272  LLDB_LOGF(log,
273  "%p ObjectFile::ObjectFile() module = %p (%s), process = %p, "
274  "header_addr = 0x%" PRIx64,
275  static_cast<void *>(this), static_cast<void *>(module_sp.get()),
276  module_sp->GetSpecificationDescription().c_str(),
277  static_cast<void *>(process_sp.get()), m_memory_addr);
278 }
279 
282  LLDB_LOGF(log, "%p ObjectFile::~ObjectFile ()\n", static_cast<void *>(this));
283 }
284 
286  ModuleSP module_sp(GetModule());
287  if (module_sp)
288  return module_sp->SetArchitecture(new_arch);
289  return false;
290 }
291 
293  Symtab *symtab = GetSymtab();
294  if (symtab) {
295  Symbol *symbol = symtab->FindSymbolContainingFileAddress(file_addr);
296  if (symbol) {
297  if (symbol->ValueIsAddress()) {
298  const SectionSP section_sp(symbol->GetAddressRef().GetSection());
299  if (section_sp) {
300  const SectionType section_type = section_sp->GetType();
301  switch (section_type) {
302  case eSectionTypeInvalid:
303  return AddressClass::eUnknown;
304  case eSectionTypeCode:
305  return AddressClass::eCode;
307  return AddressClass::eUnknown;
308  case eSectionTypeData:
312  case eSectionTypeData4:
313  case eSectionTypeData8:
314  case eSectionTypeData16:
320  return AddressClass::eData;
321  case eSectionTypeDebug:
356  return AddressClass::eDebug;
357  case eSectionTypeEHFrame:
361  return AddressClass::eRuntime;
366  case eSectionTypeOther:
367  return AddressClass::eUnknown;
369  // In case of absolute sections decide the address class based on
370  // the symbol type because the section type isn't specify if it is
371  // a code or a data section.
372  break;
373  }
374  }
375  }
376 
377  const SymbolType symbol_type = symbol->GetType();
378  switch (symbol_type) {
379  case eSymbolTypeAny:
380  return AddressClass::eUnknown;
381  case eSymbolTypeAbsolute:
382  return AddressClass::eUnknown;
383  case eSymbolTypeCode:
384  return AddressClass::eCode;
386  return AddressClass::eCode;
387  case eSymbolTypeResolver:
388  return AddressClass::eCode;
389  case eSymbolTypeData:
390  return AddressClass::eData;
391  case eSymbolTypeRuntime:
392  return AddressClass::eRuntime;
394  return AddressClass::eRuntime;
396  return AddressClass::eDebug;
398  return AddressClass::eDebug;
400  return AddressClass::eDebug;
402  return AddressClass::eDebug;
403  case eSymbolTypeBlock:
404  return AddressClass::eDebug;
405  case eSymbolTypeLocal:
406  return AddressClass::eData;
407  case eSymbolTypeParam:
408  return AddressClass::eData;
409  case eSymbolTypeVariable:
410  return AddressClass::eData;
412  return AddressClass::eDebug;
414  return AddressClass::eDebug;
416  return AddressClass::eDebug;
418  return AddressClass::eDebug;
419  case eSymbolTypeScopeEnd:
420  return AddressClass::eDebug;
422  return AddressClass::eUnknown;
423  case eSymbolTypeCompiler:
424  return AddressClass::eDebug;
426  return AddressClass::eDebug;
428  return AddressClass::eUnknown;
430  return AddressClass::eRuntime;
432  return AddressClass::eRuntime;
433  case eSymbolTypeObjCIVar:
434  return AddressClass::eRuntime;
436  return AddressClass::eRuntime;
437  }
438  }
439  }
440  return AddressClass::eUnknown;
441 }
442 
443 DataBufferSP ObjectFile::ReadMemory(const ProcessSP &process_sp,
444  lldb::addr_t addr, size_t byte_size) {
445  DataBufferSP data_sp;
446  if (process_sp) {
447  std::unique_ptr<DataBufferHeap> data_up(new DataBufferHeap(byte_size, 0));
448  Status error;
449  const size_t bytes_read = process_sp->ReadMemory(
450  addr, data_up->GetBytes(), data_up->GetByteSize(), error);
451  if (bytes_read == byte_size)
452  data_sp.reset(data_up.release());
453  }
454  return data_sp;
455 }
456 
457 size_t ObjectFile::GetData(lldb::offset_t offset, size_t length,
458  DataExtractor &data) const {
459  // The entire file has already been mmap'ed into m_data, so just copy from
460  // there as the back mmap buffer will be shared with shared pointers.
461  return data.SetData(m_data, offset, length);
462 }
463 
464 size_t ObjectFile::CopyData(lldb::offset_t offset, size_t length,
465  void *dst) const {
466  // The entire file has already been mmap'ed into m_data, so just copy from
467  // there Note that the data remains in target byte order.
468  return m_data.CopyData(offset, length, dst);
469 }
470 
472  lldb::offset_t section_offset, void *dst,
473  size_t dst_len) {
474  assert(section);
475  section_offset *= section->GetTargetByteSize();
476 
477  // If some other objectfile owns this data, pass this to them.
478  if (section->GetObjectFile() != this)
479  return section->GetObjectFile()->ReadSectionData(section, section_offset,
480  dst, dst_len);
481 
482  if (!section->IsRelocated())
483  RelocateSection(section);
484 
485  if (IsInMemory()) {
486  ProcessSP process_sp(m_process_wp.lock());
487  if (process_sp) {
488  Status error;
489  const addr_t base_load_addr =
490  section->GetLoadBaseAddress(&process_sp->GetTarget());
491  if (base_load_addr != LLDB_INVALID_ADDRESS)
492  return process_sp->ReadMemory(base_load_addr + section_offset, dst,
493  dst_len, error);
494  }
495  } else {
496  const lldb::offset_t section_file_size = section->GetFileSize();
497  if (section_offset < section_file_size) {
498  const size_t section_bytes_left = section_file_size - section_offset;
499  size_t section_dst_len = dst_len;
500  if (section_dst_len > section_bytes_left)
501  section_dst_len = section_bytes_left;
502  return CopyData(section->GetFileOffset() + section_offset,
503  section_dst_len, dst);
504  } else {
505  if (section->GetType() == eSectionTypeZeroFill) {
506  const uint64_t section_size = section->GetByteSize();
507  const uint64_t section_bytes_left = section_size - section_offset;
508  uint64_t section_dst_len = dst_len;
509  if (section_dst_len > section_bytes_left)
510  section_dst_len = section_bytes_left;
511  memset(dst, 0, section_dst_len);
512  return section_dst_len;
513  }
514  }
515  }
516  return 0;
517 }
518 
519 // Get the section data the file on disk
521  DataExtractor &section_data) {
522  // If some other objectfile owns this data, pass this to them.
523  if (section->GetObjectFile() != this)
524  return section->GetObjectFile()->ReadSectionData(section, section_data);
525 
526  if (!section->IsRelocated())
527  RelocateSection(section);
528 
529  if (IsInMemory()) {
530  ProcessSP process_sp(m_process_wp.lock());
531  if (process_sp) {
532  const addr_t base_load_addr =
533  section->GetLoadBaseAddress(&process_sp->GetTarget());
534  if (base_load_addr != LLDB_INVALID_ADDRESS) {
535  DataBufferSP data_sp(
536  ReadMemory(process_sp, base_load_addr, section->GetByteSize()));
537  if (data_sp) {
538  section_data.SetData(data_sp, 0, data_sp->GetByteSize());
539  section_data.SetByteOrder(process_sp->GetByteOrder());
540  section_data.SetAddressByteSize(process_sp->GetAddressByteSize());
541  return section_data.GetByteSize();
542  }
543  }
544  }
545  }
546 
547  // The object file now contains a full mmap'ed copy of the object file
548  // data, so just use this
549  return GetData(section->GetFileOffset(), section->GetFileSize(),
550  section_data);
551 }
552 
553 bool ObjectFile::SplitArchivePathWithObject(llvm::StringRef path_with_object,
554  FileSpec &archive_file,
555  ConstString &archive_object,
556  bool must_exist) {
557  size_t len = path_with_object.size();
558  if (len < 2 || path_with_object.back() != ')')
559  return false;
560  llvm::StringRef archive = path_with_object.substr(0, path_with_object.rfind('('));
561  if (archive.empty())
562  return false;
563  llvm::StringRef object = path_with_object.substr(archive.size() + 1).drop_back();
564  archive_file.SetFile(archive, FileSpec::Style::native);
565  if (must_exist && !FileSystem::Instance().Exists(archive_file))
566  return false;
567  archive_object.SetString(object);
568  return true;
569 }
570 
572  ModuleSP module_sp(GetModule());
573  if (module_sp) {
574  std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
576  LLDB_LOGF(log, "%p ObjectFile::ClearSymtab () symtab = %p",
577  static_cast<void *>(this),
578  static_cast<void *>(m_symtab_up.get()));
579  m_symtab_up.reset();
580  }
581 }
582 
583 SectionList *ObjectFile::GetSectionList(bool update_module_section_list) {
584  if (m_sections_up == nullptr) {
585  if (update_module_section_list) {
586  ModuleSP module_sp(GetModule());
587  if (module_sp) {
588  std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
589  CreateSections(*module_sp->GetUnifiedSectionList());
590  }
591  } else {
592  SectionList unified_section_list;
593  CreateSections(unified_section_list);
594  }
595  }
596  return m_sections_up.get();
597 }
598 
601  lldb::SymbolType symbol_type_hint) {
602  if (!name.empty()) {
603  if (name.startswith("_OBJC_")) {
604  // ObjC
605  if (name.startswith("_OBJC_CLASS_$_"))
607  if (name.startswith("_OBJC_METACLASS_$_"))
609  if (name.startswith("_OBJC_IVAR_$_"))
611  } else if (name.startswith(".objc_class_name_")) {
612  // ObjC v1
614  }
615  }
616  return symbol_type_hint;
617 }
618 
619 std::vector<ObjectFile::LoadableData>
621  std::vector<LoadableData> loadables;
622  SectionList *section_list = GetSectionList();
623  if (!section_list)
624  return loadables;
625  // Create a list of loadable data from loadable sections
626  size_t section_count = section_list->GetNumSections(0);
627  for (size_t i = 0; i < section_count; ++i) {
628  LoadableData loadable;
629  SectionSP section_sp = section_list->GetSectionAtIndex(i);
630  loadable.Dest =
631  target.GetSectionLoadList().GetSectionLoadAddress(section_sp);
632  if (loadable.Dest == LLDB_INVALID_ADDRESS)
633  continue;
634  // We can skip sections like bss
635  if (section_sp->GetFileSize() == 0)
636  continue;
637  DataExtractor section_data;
638  section_sp->GetSectionData(section_data);
639  loadable.Contents = llvm::ArrayRef<uint8_t>(section_data.GetDataStart(),
640  section_data.GetByteSize());
641  loadables.push_back(loadable);
642  }
643  return loadables;
644 }
645 
646 std::unique_ptr<CallFrameInfo> ObjectFile::CreateCallFrameInfo() {
647  return {};
648 }
649 
651 {
652 }
653 
654 DataBufferSP ObjectFile::MapFileData(const FileSpec &file, uint64_t Size,
655  uint64_t Offset) {
656  return FileSystem::Instance().CreateDataBuffer(file.GetPath(), Size, Offset);
657 }
658 
659 void llvm::format_provider<ObjectFile::Type>::format(
660  const ObjectFile::Type &type, raw_ostream &OS, StringRef Style) {
661  switch (type) {
663  OS << "invalid";
664  break;
666  OS << "core file";
667  break;
669  OS << "executable";
670  break;
672  OS << "debug info";
673  break;
675  OS << "dynamic linker";
676  break;
678  OS << "object file";
679  break;
681  OS << "shared library";
682  break;
684  OS << "stub library";
685  break;
687  OS << "jit";
688  break;
690  OS << "unknown";
691  break;
692  }
693 }
694 
695 void llvm::format_provider<ObjectFile::Strata>::format(
696  const ObjectFile::Strata &strata, raw_ostream &OS, StringRef Style) {
697  switch (strata) {
699  OS << "invalid";
700  break;
702  OS << "unknown";
703  break;
705  OS << "user";
706  break;
708  OS << "kernel";
709  break;
711  OS << "raw image";
712  break;
714  OS << "jit";
715  break;
716  }
717 }
lldb_private::ObjectFile::GetSymbolTypeFromName
static lldb::SymbolType GetSymbolTypeFromName(llvm::StringRef name, lldb::SymbolType symbol_type_hint=lldb::eSymbolTypeUndefined)
Definition: ObjectFile.cpp:600
lldb_private::ObjectFile::MapFileData
static lldb::DataBufferSP MapFileData(const FileSpec &file, uint64_t Size, uint64_t Offset)
Definition: ObjectFile.cpp:654
lldb_private::AddressClass::eData
@ eData
lldb::eSymbolTypeCompiler
@ eSymbolTypeCompiler
Definition: lldb-enumerations.h:637
lldb::eSectionTypeDWARFDebugLoc
@ eSectionTypeDWARFDebugLoc
Definition: lldb-enumerations.h:670
lldb::eSectionTypeData8
@ eSectionTypeData8
Definition: lldb-enumerations.h:655
lldb::eSectionTypeDWARFDebugRngListsDwo
@ eSectionTypeDWARFDebugRngListsDwo
Definition: lldb-enumerations.h:706
lldb::eSymbolTypeParam
@ eSymbolTypeParam
Definition: lldb-enumerations.h:628
lldb::eSymbolTypeObjCIVar
@ eSymbolTypeObjCIVar
Definition: lldb-enumerations.h:642
lldb::eSectionTypeDWARFAppleNamespaces
@ eSectionTypeDWARFAppleNamespaces
Definition: lldb-enumerations.h:680
lldb::eSectionTypeDWARFAppleObjC
@ eSectionTypeDWARFAppleObjC
Definition: lldb-enumerations.h:681
lldb_private::ObjectFile::CreateSections
virtual void CreateSections(SectionList &unified_section_list)=0
lldb_private::ArchSpec
Definition: ArchSpec.h:33
lldb::eSectionTypeDebug
@ eSectionTypeDebug
Definition: lldb-enumerations.h:658
lldb_private::ModuleChild
Definition: ModuleChild.h:19
lldb::eSymbolTypeHeaderFile
@ eSymbolTypeHeaderFile
Definition: lldb-enumerations.h:623
lldb::eSymbolTypeCode
@ eSymbolTypeCode
Definition: lldb-enumerations.h:616
lldb_private::ObjectFile::m_memory_addr
const lldb::addr_t m_memory_addr
Definition: ObjectFile.h:708
lldb::eSymbolTypeInstrumentation
@ eSymbolTypeInstrumentation
Definition: lldb-enumerations.h:638
ModuleSpec.h
lldb_private::AddressClass
AddressClass
Definition: lldb-private-enumerations.h:48
lldb_private::Symbol
Definition: Symbol.h:20
lldb_private::Symbol::ValueIsAddress
bool ValueIsAddress() const
Definition: Symbol.cpp:117
lldb::eSectionTypeData16
@ eSectionTypeData16
Definition: lldb-enumerations.h:656
lldb::eSectionTypeDataCStringPointers
@ eSectionTypeDataCStringPointers
Pointers to C string data.
Definition: lldb-enumerations.h:652
lldb::eSymbolTypeLineEntry
@ eSymbolTypeLineEntry
Definition: lldb-enumerations.h:631
lldb_private::ObjectFile::GetSymtab
virtual Symtab * GetSymtab()=0
Gets the symbol table for the currently selected architecture (and object for archives).
lldb_private::ObjectFile::eTypeExecutable
@ eTypeExecutable
A normal executable.
Definition: ObjectFile.h:69
lldb_private::Section::GetType
lldb::SectionType GetType() const
Definition: Section.h:174
lldb::eSectionTypeDataPointers
@ eSectionTypeDataPointers
Definition: lldb-enumerations.h:657
lldb_private::Section::IsRelocated
bool IsRelocated() const
Definition: Section.h:235
lldb::eSectionTypeDWARFDebugAranges
@ eSectionTypeDWARFDebugAranges
Definition: lldb-enumerations.h:665
lldb_private::ObjectFile::m_process_wp
lldb::ProcessWP m_process_wp
Definition: ObjectFile.h:707
lldb_private::ObjectFile::eStrataKernel
@ eStrataKernel
Definition: ObjectFile.h:89
lldb::eSymbolTypeCommonBlock
@ eSymbolTypeCommonBlock
Definition: lldb-enumerations.h:625
lldb::eSymbolTypeTrampoline
@ eSymbolTypeTrampoline
Definition: lldb-enumerations.h:619
lldb::eSectionTypeELFSymbolTable
@ eSectionTypeELFSymbolTable
Elf SHT_SYMTAB section.
Definition: lldb-enumerations.h:682
lldb_private::ModuleSpecList
Definition: ModuleSpec.h:280
lldb::eSectionTypeDWARFDebugStrOffsetsDwo
@ eSectionTypeDWARFDebugStrOffsetsDwo
Definition: lldb-enumerations.h:704
LLDB_LOGF
#define LLDB_LOGF(log,...)
Definition: Log.h:249
lldb::eSectionTypeDWARFDebugRanges
@ eSectionTypeDWARFDebugRanges
Definition: lldb-enumerations.h:675
lldb::eSectionTypeDWARFDebugMacro
@ eSectionTypeDWARFDebugMacro
Definition: lldb-enumerations.h:672
lldb::eSectionTypeDWARFDebugInfoDwo
@ eSectionTypeDWARFDebugInfoDwo
Definition: lldb-enumerations.h:702
lldb_private::ObjectFile::RelocateSection
virtual void RelocateSection(lldb_private::Section *section)
Perform relocations on the section if necessary.
Definition: ObjectFile.cpp:650
lldb::eSectionTypeDWARFDebugFrame
@ eSectionTypeDWARFDebugFrame
Definition: lldb-enumerations.h:667
Module.h
lldb_private::ObjectFile::eStrataInvalid
@ eStrataInvalid
Definition: ObjectFile.h:86
lldb::eSectionTypeDWARFDebugLine
@ eSectionTypeDWARFDebugLine
Definition: lldb-enumerations.h:669
lldb_private::ObjectFile::ObjectFile
ObjectFile(const lldb::ModuleSP &module_sp, const FileSpec *file_spec_ptr, lldb::offset_t file_offset, lldb::offset_t length, const lldb::DataBufferSP &data_sp, lldb::offset_t data_offset)
Construct with a parent module, offset, and header data.
Definition: ObjectFile.cpp:237
lldb_private::ObjectFile::m_symtab_up
std::unique_ptr< lldb_private::Symtab > m_symtab_up
Definition: ObjectFile.h:710
lldb::eSectionTypeDWARFDebugAbbrevDwo
@ eSectionTypeDWARFDebugAbbrevDwo
Definition: lldb-enumerations.h:701
lldb_private::ObjectFile::m_file
FileSpec m_file
Definition: ObjectFile.h:697
lldb_private::ObjectFile::GetAddressClass
virtual AddressClass GetAddressClass(lldb::addr_t file_addr)
Get the address type given a file address in an object file.
Definition: ObjectFile.cpp:292
lldb::eSymbolTypeScopeBegin
@ eSymbolTypeScopeBegin
Definition: lldb-enumerations.h:633
lldb::eSymbolTypeData
@ eSymbolTypeData
Definition: lldb-enumerations.h:618
lldb_private::ObjectFile::ReadSectionData
virtual size_t ReadSectionData(Section *section, lldb::offset_t section_offset, void *dst, size_t dst_len)
Definition: ObjectFile.cpp:471
lldb::eSectionTypeDWARFDebugAddr
@ eSectionTypeDWARFDebugAddr
Definition: lldb-enumerations.h:664
SectionLoadList.h
lldb_private::SectionList
Definition: Section.h:34
lldb_private::Section::GetFileSize
lldb::offset_t GetFileSize() const
Definition: Section.h:146
lldb::offset_t
uint64_t offset_t
Definition: lldb-types.h:87
lldb::eSymbolTypeRuntime
@ eSymbolTypeRuntime
Definition: lldb-enumerations.h:620
lldb_private::Section::GetTargetByteSize
uint32_t GetTargetByteSize() const
Definition: Section.h:233
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
lldb_private::ObjectFile::Type
Type
Definition: ObjectFile.h:64
lldb::eSectionTypeDWARFDebugStrOffsets
@ eSectionTypeDWARFDebugStrOffsets
Definition: lldb-enumerations.h:677
lldb_private::SectionList::GetNumSections
size_t GetNumSections(uint32_t depth) const
Definition: Section.cpp:465
lldb_private::Target
Definition: Target.h:445
Section.h
lldb_private::ObjectFile::ReadMemory
static lldb::DataBufferSP ReadMemory(const lldb::ProcessSP &process_sp, lldb::addr_t addr, size_t byte_size)
Definition: ObjectFile.cpp:443
lldb_private::DataExtractor::SetData
lldb::offset_t SetData(const void *bytes, lldb::offset_t length, lldb::ByteOrder byte_order)
Set data with a buffer that is caller owned.
Definition: DataExtractor.cpp:225
lldb_private::AddressClass::eUnknown
@ eUnknown
lldb_private::ObjectFile::eTypeObjectFile
@ eTypeObjectFile
An intermediate object file.
Definition: ObjectFile.h:75
Process.h
Target.h
lldb_private::DataExtractor::SetByteOrder
void SetByteOrder(lldb::ByteOrder byte_order)
Set the byte_order value.
Definition: DataExtractor.h:920
lldb::eSectionTypeELFRelocationEntries
@ eSectionTypeELFRelocationEntries
Elf SHT_REL or SHT_REL section.
Definition: lldb-enumerations.h:684
lldb::eSectionTypeDWARFDebugLocDwo
@ eSectionTypeDWARFDebugLocDwo
Definition: lldb-enumerations.h:707
lldb_private::FileSpec
Definition: FileSpec.h:56
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
lldb::eSymbolTypeAny
@ eSymbolTypeAny
Definition: lldb-enumerations.h:613
lldb::eSymbolTypeBlock
@ eSymbolTypeBlock
Definition: lldb-enumerations.h:626
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:583
lldb::eSectionTypeDataObjCMessageRefs
@ eSectionTypeDataObjCMessageRefs
Pointer to function pointer + selector.
Definition: lldb-enumerations.h:660
lldb_private::SectionLoadList::GetSectionLoadAddress
lldb::addr_t GetSectionLoadAddress(const lldb::SectionSP &section_sp) const
Definition: SectionLoadList.cpp:49
lldb::eSectionTypeDWARFDebugLocListsDwo
@ eSectionTypeDWARFDebugLocListsDwo
Definition: lldb-enumerations.h:708
lldb_private::ObjectFile::LoadableData
Definition: ObjectFile.h:105
ID
static char ID
Definition: IRDynamicChecks.cpp:32
lldb_private::ConstString::SetString
void SetString(const llvm::StringRef &s)
Definition: ConstString.cpp:306
lldb::eSectionTypeDWARFDebugAbbrev
@ eSectionTypeDWARFDebugAbbrev
Definition: lldb-enumerations.h:663
lldb_private::AddressClass::eRuntime
@ eRuntime
lldb::eSectionTypeCompactUnwind
@ eSectionTypeCompactUnwind
compact unwind section in Mach-O, __TEXT,__unwind_info
Definition: lldb-enumerations.h:689
lldb::eSymbolTypeSourceFile
@ eSymbolTypeSourceFile
Definition: lldb-enumerations.h:622
lldb_private::DataExtractor
Definition: DataExtractor.h:48
lldb::eSectionTypeDataSymbolAddress
@ eSectionTypeDataSymbolAddress
Address of a symbol in the symbol table.
Definition: lldb-enumerations.h:653
lldb::eSectionTypeDataObjCCFStrings
@ eSectionTypeDataObjCCFStrings
Objective-C const CFString/NSString objects.
Definition: lldb-enumerations.h:661
Log.h
lldb::eSymbolTypeUndefined
@ eSymbolTypeUndefined
Definition: lldb-enumerations.h:639
lldb_private::ObjectFile::m_length
lldb::addr_t m_length
The length of this object file if it is known (can be zero if length is unknown or can't be determine...
Definition: ObjectFile.h:702
lldb::eSymbolTypeObjectFile
@ eSymbolTypeObjectFile
Definition: lldb-enumerations.h:624
lldb_private::ObjectFile::LoadableData::Dest
lldb::addr_t Dest
Definition: ObjectFile.h:106
lldb_private::ObjectFile::eStrataUser
@ eStrataUser
Definition: ObjectFile.h:88
lldb::eSectionTypeDWARFDebugStr
@ eSectionTypeDWARFDebugStr
Definition: lldb-enumerations.h:676
lldb_private::ObjectFile::LoadableData::Contents
llvm::ArrayRef< uint8_t > Contents
Definition: ObjectFile.h:107
lldb_private::ObjectFile::eStrataRawImage
@ eStrataRawImage
Definition: ObjectFile.h:90
lldb_private::DataExtractor::SetAddressByteSize
void SetAddressByteSize(uint32_t addr_size)
Set the address byte size.
Definition: DataExtractor.h:834
lldb_private::Symbol::GetAddressRef
Address & GetAddressRef()
Definition: Symbol.h:57
lldb_private::ObjectFile::eTypeCoreFile
@ eTypeCoreFile
A core file that has a checkpoint of a program's execution state.
Definition: ObjectFile.h:67
lldb_private::DataExtractor::GetDataStart
const uint8_t * GetDataStart() const
Get the data start pointer.
Definition: DataExtractor.h:411
lldb_private::ConstString
Definition: ConstString.h:40
lldb_private::FileSystem::CreateDataBuffer
std::shared_ptr< DataBufferLLVM > CreateDataBuffer(const llvm::Twine &path, uint64_t size=0, uint64_t offset=0)
Create memory buffer from path.
Definition: common/FileSystem.cpp:297
lldb::eSectionTypeDWARFDebugInfo
@ eSectionTypeDWARFDebugInfo
Definition: lldb-enumerations.h:668
lldb_private::Symtab::FindSymbolContainingFileAddress
Symbol * FindSymbolContainingFileAddress(lldb::addr_t file_addr)
Definition: Symtab.cpp:1022
Timer.h
lldb_private::GetLogIfAllCategoriesSet
Log * GetLogIfAllCategoriesSet(uint32_t mask)
Definition: Logging.cpp:58
lldb::eSectionTypeDWARFDebugTypes
@ eSectionTypeDWARFDebugTypes
DWARF .debug_types section.
Definition: lldb-enumerations.h:695
ObjectContainerCreateInstance
lldb_private::SectionList::GetSectionAtIndex
lldb::SectionSP GetSectionAtIndex(size_t idx) const
Definition: Section.cpp:476
lldb::eSectionTypeZeroFill
@ eSectionTypeZeroFill
Definition: lldb-enumerations.h:659
lldb::eSectionTypeDWARFAppleTypes
@ eSectionTypeDWARFAppleTypes
Definition: lldb-enumerations.h:679
lldb::eSectionTypeDWARFAppleNames
@ eSectionTypeDWARFAppleNames
Definition: lldb-enumerations.h:678
lldb::eSymbolTypeObjCClass
@ eSymbolTypeObjCClass
Definition: lldb-enumerations.h:640
lldb::eSectionTypeDWARFGNUDebugAltLink
@ eSectionTypeDWARFGNUDebugAltLink
Definition: lldb-enumerations.h:694
lldb::eSymbolTypeAdditional
@ eSymbolTypeAdditional
When symbols take more than one entry, the extra entries get this type.
Definition: lldb-enumerations.h:635
lldb::eSectionTypeELFDynamicSymbols
@ eSectionTypeELFDynamicSymbols
Elf SHT_DYNSYM section.
Definition: lldb-enumerations.h:683
lldb_private::ObjectFile::eTypeSharedLibrary
@ eTypeSharedLibrary
A shared library that can be used during execution.
Definition: ObjectFile.h:77
lldb_private::Section::GetLoadBaseAddress
lldb::addr_t GetLoadBaseAddress(Target *target) const
Definition: Section.cpp:238
lldb_private::Address::GetSection
lldb::SectionSP GetSection() const
Get const accessor for the section.
Definition: Address.h:416
lldb::eSectionTypeAbsoluteAddress
@ eSectionTypeAbsoluteAddress
Dummy section for symbols with absolute address.
Definition: lldb-enumerations.h:692
lldb::SymbolType
SymbolType
Symbol types.
Definition: lldb-enumerations.h:612
lldb::eSymbolTypeVariable
@ eSymbolTypeVariable
Definition: lldb-enumerations.h:629
lldb::eSymbolTypeScopeEnd
@ eSymbolTypeScopeEnd
Definition: lldb-enumerations.h:634
lldb::eSectionTypeDWARFDebugCuIndex
@ eSectionTypeDWARFDebugCuIndex
Definition: lldb-enumerations.h:666
lldb_private::ObjectFile::~ObjectFile
~ObjectFile() override
Destructor.
Definition: ObjectFile.cpp:280
lldb_private::ObjectFile::eTypeJIT
@ eTypeJIT
JIT code that has symbols, sections and possibly debug info.
Definition: ObjectFile.h:81
lldb::eSectionTypeData
@ eSectionTypeData
Definition: lldb-enumerations.h:650
ObjectFile.h
lldb-private.h
lldb_private::Section
Definition: Section.h:96
lldb::eSectionTypeDWARFDebugTuIndex
@ eSectionTypeDWARFDebugTuIndex
Definition: lldb-enumerations.h:709
lldb::eSectionTypeData4
@ eSectionTypeData4
Definition: lldb-enumerations.h:654
lldb_private::ObjectFile::eStrataUnknown
@ eStrataUnknown
Definition: ObjectFile.h:87
lldb::eSectionTypeOther
@ eSectionTypeOther
Definition: lldb-enumerations.h:697
lldb::eSectionTypeCode
@ eSectionTypeCode
Definition: lldb-enumerations.h:648
lldb_private::Section::GetByteSize
lldb::addr_t GetByteSize() const
Definition: Section.h:156
lldb_private::ObjectFile::GetData
size_t GetData(lldb::offset_t offset, size_t length, DataExtractor &data) const
Definition: ObjectFile.cpp:457
lldb_private::Status
Definition: Status.h:44
lldb::eSectionTypeContainer
@ eSectionTypeContainer
The section contains child sections.
Definition: lldb-enumerations.h:649
LIBLLDB_LOG_OBJECT
#define LIBLLDB_LOG_OBJECT
Definition: Logging.h:25
lldb::eSectionTypeEHFrame
@ eSectionTypeEHFrame
Definition: lldb-enumerations.h:686
lldb_private::ObjectFile::SplitArchivePathWithObject
static bool SplitArchivePathWithObject(llvm::StringRef path_with_object, lldb_private::FileSpec &archive_file, lldb_private::ConstString &archive_object, bool must_exist)
Split a path into a file path with object name.
Definition: ObjectFile.cpp:553
lldb::eSectionTypeELFDynamicLinkInfo
@ eSectionTypeELFDynamicLinkInfo
Elf SHT_DYNAMIC section.
Definition: lldb-enumerations.h:685
lldb_private::Symtab
Definition: Symtab.h:22
lldb_private::ObjectFile::eTypeInvalid
@ eTypeInvalid
Definition: ObjectFile.h:65
uint32_t
lldb_private::ObjectFile::eTypeDebugInfo
@ eTypeDebugInfo
An object file that contains only debug information.
Definition: ObjectFile.h:71
lldb::SectionType
SectionType
Definition: lldb-enumerations.h:646
lldb::eSectionTypeDWARFDebugStrDwo
@ eSectionTypeDWARFDebugStrDwo
Definition: lldb-enumerations.h:703
lldb::eSectionTypeDWARFDebugPubTypes
@ eSectionTypeDWARFDebugPubTypes
Definition: lldb-enumerations.h:674
lldb::eSectionTypeDWARFDebugNames
@ eSectionTypeDWARFDebugNames
DWARF v5 .debug_names.
Definition: lldb-enumerations.h:696
lldb_private::ObjectFile::GetLoadableData
virtual std::vector< LoadableData > GetLoadableData(Target &target)
Loads this objfile to memory.
Definition: ObjectFile.cpp:620
lldb::eSectionTypeARMextab
@ eSectionTypeARMextab
Definition: lldb-enumerations.h:688
lldb_private::ObjectFile::eTypeStubLibrary
@ eTypeStubLibrary
A library that can be linked against but not used for execution.
Definition: ObjectFile.h:79
lldb::eSectionTypeDWARFDebugPubNames
@ eSectionTypeDWARFDebugPubNames
Definition: lldb-enumerations.h:673
CallFrameInfo.h
lldb::eSectionTypeInvalid
@ eSectionTypeInvalid
Definition: lldb-enumerations.h:647
lldb_private::ObjectFile::ClearSymtab
virtual void ClearSymtab()
Frees the symbol table.
Definition: ObjectFile.cpp:571
lldb_private::AddressClass::eCode
@ eCode
lldb::eSectionTypeDataCString
@ eSectionTypeDataCString
Inlined C string data.
Definition: lldb-enumerations.h:651
lldb_private::ObjectFile::m_data
DataExtractor m_data
The data for this object file so things can be parsed lazily.
Definition: ObjectFile.h:706
lldb::eSymbolTypeObjCMetaClass
@ eSymbolTypeObjCMetaClass
Definition: lldb-enumerations.h:641
lldb::eSymbolTypeVariableType
@ eSymbolTypeVariableType
Definition: lldb-enumerations.h:630
lldb_private::ModuleChild::GetModule
lldb::ModuleSP GetModule() const
Get const accessor for the module pointer.
Definition: ModuleChild.cpp:24
lldb_private::ObjectFile::m_file_offset
lldb::addr_t m_file_offset
The offset in bytes into the file, or the address in memory.
Definition: ObjectFile.h:700
lldb::eSectionTypeDWARFDebugLineStr
@ eSectionTypeDWARFDebugLineStr
DWARF v5 .debug_line_str.
Definition: lldb-enumerations.h:698
PluginManager.h
lldb_private::Target::GetSectionLoadList
SectionLoadList & GetSectionLoadList()
Definition: Target.h:1034
LLDB_INVALID_ADDRESS
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:86
lldb_private::ObjectFile::eStrataJIT
@ eStrataJIT
Definition: ObjectFile.h:91
LLDB_SCOPED_TIMERF
#define LLDB_SCOPED_TIMERF(FMT,...)
Definition: Timer.h:99
lldb_private::AddressClass::eDebug
@ eDebug
lldb_private::FileSystem::Instance
static FileSystem & Instance()
Definition: common/FileSystem.cpp:45
lldb::eSymbolTypeReExported
@ eSymbolTypeReExported
Definition: lldb-enumerations.h:643
lldb_private::DataExtractor::CopyData
lldb::offset_t CopyData(lldb::offset_t offset, lldb::offset_t length, void *dst) const
Copy length bytes from *offset, without swapping bytes.
Definition: DataExtractor.cpp:680
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::ObjectFile::IsInMemory
bool IsInMemory() const
Definition: ObjectFile.h:654
ObjectFileCreateInstance
lldb_private::Section::GetFileOffset
lldb::offset_t GetFileOffset() const
Definition: Section.h:140
lldb::eSymbolTypeLineHeader
@ eSymbolTypeLineHeader
Definition: lldb-enumerations.h:632
ObjectContainer.h
lldb::eSymbolTypeException
@ eSymbolTypeException
Definition: lldb-enumerations.h:621
lldb_private::ObjectFile::eTypeUnknown
@ eTypeUnknown
Definition: ObjectFile.h:82
lldb_private::ModuleSpecList::GetSize
size_t GetSize() const
Definition: ModuleSpec.h:303
lldb_private::Log
Definition: Log.h:49
lldb_private::Section::GetObjectFile
ObjectFile * GetObjectFile()
Definition: Section.h:190
lldb_private::FileSpec::SetFile
void SetFile(llvm::StringRef path, Style style)
Change the file specified with a new path.
Definition: FileSpec.cpp:174
lldb_private::ObjectFile::eTypeDynamicLinker
@ eTypeDynamicLinker
The platform's dynamic linker executable.
Definition: ObjectFile.h:73
lldb::eSymbolTypeResolver
@ eSymbolTypeResolver
Definition: lldb-enumerations.h:617
lldb_private::ObjectFile::CopyData
size_t CopyData(lldb::offset_t offset, size_t length, void *dst) const
Definition: ObjectFile.cpp:464
lldb_private::ObjectFile::SetModulesArchitecture
bool SetModulesArchitecture(const ArchSpec &new_arch)
Sets the architecture for a module.
Definition: ObjectFile.cpp:285
lldb::eSectionTypeDWARFDebugMacInfo
@ eSectionTypeDWARFDebugMacInfo
Definition: lldb-enumerations.h:671
lldb::eSectionTypeARMexidx
@ eSectionTypeARMexidx
Definition: lldb-enumerations.h:687
lldb::eSymbolTypeAbsolute
@ eSymbolTypeAbsolute
Definition: lldb-enumerations.h:615
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:348
DataBuffer.h
lldb_private::DataExtractor::GetByteSize
uint64_t GetByteSize() const
Get the number of bytes contained in this object.
Definition: DataExtractor.h:259
lldb_private::DataBufferHeap
Definition: DataBufferHeap.h:30
lldb_private::Symbol::GetType
lldb::SymbolType GetType() const
Definition: Symbol.h:143
lldb::eSectionTypeDWARFDebugTypesDwo
@ eSectionTypeDWARFDebugTypesDwo
Definition: lldb-enumerations.h:705
lldb_private::ObjectFile::CreateCallFrameInfo
virtual std::unique_ptr< CallFrameInfo > CreateCallFrameInfo()
Creates a plugin-specific call frame info.
Definition: ObjectFile.cpp:646
lldb::eSymbolTypeLocal
@ eSymbolTypeLocal
Definition: lldb-enumerations.h:627
lldb_private::ObjectFile::Strata
Strata
Definition: ObjectFile.h:85
lldb
Definition: SBAddress.h:15
CreateObjectFromContainer
static ObjectFileSP CreateObjectFromContainer(const lldb::ModuleSP &module_sp, const FileSpec *file, lldb::offset_t file_offset, lldb::offset_t file_size, DataBufferSP &data_sp, lldb::offset_t &data_offset)
Definition: ObjectFile.cpp:32
lldb::eSectionTypeDWARFDebugLocLists
@ eSectionTypeDWARFDebugLocLists
DWARF v5 .debug_loclists.
Definition: lldb-enumerations.h:700
SymbolFile.h
lldb::eSectionTypeGoSymtab
@ eSectionTypeGoSymtab
Definition: lldb-enumerations.h:691
DataBufferHeap.h
lldb_private::ObjectFile::m_sections_up
std::unique_ptr< lldb_private::SectionList > m_sections_up
Definition: ObjectFile.h:709
lldb::eSectionTypeDWARFDebugRngLists
@ eSectionTypeDWARFDebugRngLists
DWARF v5 .debug_rnglists.
Definition: lldb-enumerations.h:699