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"
13#include "lldb/Core/Section.h"
17#include "lldb/Target/Process.h"
19#include "lldb/Target/Target.h"
23#include "lldb/Utility/Log.h"
24#include "lldb/Utility/Timer.h"
25#include "lldb/lldb-private.h"
26
27#include "llvm/Support/DJB.h"
28
29using namespace lldb;
30using namespace lldb_private;
31
34
35static ObjectFileSP
37 lldb::offset_t file_offset, lldb::offset_t file_size,
38 DataBufferSP data_sp, lldb::offset_t &data_offset) {
40 for (uint32_t idx = 0;
42 idx)) != nullptr;
43 ++idx) {
44 std::unique_ptr<ObjectContainer> object_container_up(callback(
45 module_sp, data_sp, data_offset, file, file_offset, file_size));
46 if (object_container_up)
47 return object_container_up->GetObjectFile(file);
48 }
49 return {};
50}
51
53ObjectFile::FindPlugin(const lldb::ModuleSP &module_sp, const FileSpec *file,
54 lldb::offset_t file_offset, lldb::offset_t file_size,
55 DataBufferSP &data_sp, lldb::offset_t &data_offset) {
57 "ObjectFile::FindPlugin (module = %s, file = %p, file_offset = "
58 "0x%8.8" PRIx64 ", file_size = 0x%8.8" PRIx64 ")",
59 module_sp->GetFileSpec().GetPath().c_str(),
60 static_cast<const void *>(file), static_cast<uint64_t>(file_offset),
61 static_cast<uint64_t>(file_size));
62
63 if (!module_sp)
64 return {};
65
66 if (!file)
67 return {};
68
69 if (!data_sp) {
70 const bool file_exists = FileSystem::Instance().Exists(*file);
71 // We have an object name which most likely means we have a .o file in
72 // a static archive (.a file). Try and see if we have a cached archive
73 // first without reading any data first
74 if (file_exists && module_sp->GetObjectName()) {
76 module_sp, file, file_offset, file_size, data_sp, data_offset);
77 if (object_file_sp)
78 return object_file_sp;
79 }
80 // Ok, we didn't find any containers that have a named object, now lets
81 // read the first 512 bytes from the file so the object file and object
82 // container plug-ins can use these bytes to see if they can parse this
83 // file.
84 if (file_size > 0) {
86 file->GetPath(), g_initial_bytes_to_read, file_offset);
87 data_offset = 0;
88 }
89 }
90
91 if (!data_sp || data_sp->GetByteSize() == 0) {
92 // Check for archive file with format "/path/to/archive.a(object.o)"
93 llvm::SmallString<256> path_with_object;
94 module_sp->GetFileSpec().GetPath(path_with_object);
95
96 FileSpec archive_file;
97 ConstString archive_object;
98 const bool must_exist = true;
99 if (ObjectFile::SplitArchivePathWithObject(path_with_object, archive_file,
100 archive_object, must_exist)) {
101 file_size = FileSystem::Instance().GetByteSize(archive_file);
102 if (file_size > 0) {
103 file = &archive_file;
104 module_sp->SetFileSpecAndObjectName(archive_file, archive_object);
105 // Check if this is a object container by iterating through all
106 // object container plugin instances and then trying to get an
107 // object file from the container plugins since we had a name.
108 // Also, don't read
109 // ANY data in case there is data cached in the container plug-ins
110 // (like BSD archives caching the contained objects within an
111 // file).
113 module_sp, file, file_offset, file_size, data_sp, data_offset);
114 if (object_file_sp)
115 return object_file_sp;
116 // We failed to find any cached object files in the container plug-
117 // ins, so lets read the first 512 bytes and try again below...
119 archive_file.GetPath(), g_initial_bytes_to_read, file_offset);
120 }
121 }
122 }
123
124 if (data_sp && data_sp->GetByteSize() > 0) {
125 // Check if this is a normal object file by iterating through all
126 // object file plugin instances.
128 for (uint32_t idx = 0;
130 nullptr;
131 ++idx) {
132 ObjectFileSP object_file_sp(callback(module_sp, data_sp, data_offset,
133 file, file_offset, file_size));
134 if (object_file_sp.get())
135 return object_file_sp;
136 }
137
138 // Check if this is a object container by iterating through all object
139 // container plugin instances and then trying to get an object file
140 // from the container.
142 module_sp, file, file_offset, file_size, data_sp, data_offset);
143 if (object_file_sp)
144 return object_file_sp;
145 }
146
147 // We didn't find it, so clear our shared pointer in case it contains
148 // anything and return an empty shared pointer
149 return {};
150}
151
153 const ProcessSP &process_sp,
154 lldb::addr_t header_addr,
155 WritableDataBufferSP data_sp) {
156 ObjectFileSP object_file_sp;
157
158 if (module_sp) {
159 LLDB_SCOPED_TIMERF("ObjectFile::FindPlugin (module = "
160 "%s, process = %p, header_addr = "
161 "0x%" PRIx64 ")",
162 module_sp->GetFileSpec().GetPath().c_str(),
163 static_cast<void *>(process_sp.get()), header_addr);
164 uint32_t idx;
165
166 // Check if this is a normal object file by iterating through all object
167 // file plugin instances.
168 ObjectFileCreateMemoryInstance create_callback;
169 for (idx = 0;
170 (create_callback =
172 nullptr;
173 ++idx) {
174 object_file_sp.reset(
175 create_callback(module_sp, data_sp, process_sp, header_addr));
176 if (object_file_sp.get())
177 return object_file_sp;
178 }
179 }
180
181 // We didn't find it, so clear our shared pointer in case it contains
182 // anything and return an empty shared pointer
183 object_file_sp.reset();
184 return object_file_sp;
185}
186
188 lldb::offset_t file_offset,
189 lldb::offset_t file_size,
190 ModuleSpecList &specs,
191 DataBufferSP data_sp) {
192 if (!data_sp)
194 file.GetPath(), g_initial_bytes_to_read, file_offset);
195 if (data_sp) {
196 if (file_size == 0) {
197 const lldb::offset_t actual_file_size =
199 if (actual_file_size > file_offset)
200 file_size = actual_file_size - file_offset;
201 }
202 return ObjectFile::GetModuleSpecifications(file, // file spec
203 data_sp, // data bytes
204 0, // data offset
205 file_offset, // file offset
206 file_size, // file length
207 specs);
208 }
209 return 0;
210}
211
213 const lldb_private::FileSpec &file, lldb::DataBufferSP &data_sp,
214 lldb::offset_t data_offset, lldb::offset_t file_offset,
216 const size_t initial_count = specs.GetSize();
218 uint32_t i;
219 // Try the ObjectFile plug-ins
220 for (i = 0;
221 (callback =
223 i)) != nullptr;
224 ++i) {
225 if (callback(file, data_sp, data_offset, file_offset, file_size, specs) > 0)
226 return specs.GetSize() - initial_count;
227 }
228
229 // Try the ObjectContainer plug-ins
230 for (i = 0;
231 (callback = PluginManager::
233 nullptr;
234 ++i) {
235 if (callback(file, data_sp, data_offset, file_offset, file_size, specs) > 0)
236 return specs.GetSize() - initial_count;
237 }
238 return 0;
239}
240
242 const FileSpec *file_spec_ptr,
243 lldb::offset_t file_offset, lldb::offset_t length,
244 lldb::DataBufferSP data_sp, lldb::offset_t data_offset)
245 : ModuleChild(module_sp),
246 m_file(), // This file could be different from the original module's file
247 m_type(eTypeInvalid), m_strata(eStrataInvalid),
248 m_file_offset(file_offset), m_length(length), m_data(), m_process_wp(),
249 m_memory_addr(LLDB_INVALID_ADDRESS), m_sections_up(), m_symtab_up(),
250 m_symtab_once_up(new llvm::once_flag()) {
251 if (file_spec_ptr)
252 m_file = *file_spec_ptr;
253 if (data_sp)
254 m_data.SetData(data_sp, data_offset, length);
255 Log *log = GetLog(LLDBLog::Object);
256 LLDB_LOGF(log,
257 "%p ObjectFile::ObjectFile() module = %p (%s), file = %s, "
258 "file_offset = 0x%8.8" PRIx64 ", size = %" PRIu64,
259 static_cast<void *>(this), static_cast<void *>(module_sp.get()),
260 module_sp->GetSpecificationDescription().c_str(),
261 m_file ? m_file.GetPath().c_str() : "<NULL>", m_file_offset,
262 m_length);
263}
264
266 const ProcessSP &process_sp, lldb::addr_t header_addr,
267 DataBufferSP header_data_sp)
268 : ModuleChild(module_sp), m_file(), m_type(eTypeInvalid),
269 m_strata(eStrataInvalid), m_file_offset(0), m_length(0), m_data(),
270 m_process_wp(process_sp), m_memory_addr(header_addr), m_sections_up(),
271 m_symtab_up(), m_symtab_once_up(new llvm::once_flag()) {
272 if (header_data_sp)
273 m_data.SetData(header_data_sp, 0, header_data_sp->GetByteSize());
274 Log *log = GetLog(LLDBLog::Object);
275 LLDB_LOGF(log,
276 "%p ObjectFile::ObjectFile() module = %p (%s), process = %p, "
277 "header_addr = 0x%" PRIx64,
278 static_cast<void *>(this), static_cast<void *>(module_sp.get()),
279 module_sp->GetSpecificationDescription().c_str(),
280 static_cast<void *>(process_sp.get()), m_memory_addr);
281}
282
284 Log *log = GetLog(LLDBLog::Object);
285 LLDB_LOGF(log, "%p ObjectFile::~ObjectFile ()\n", static_cast<void *>(this));
286}
287
289 ModuleSP module_sp(GetModule());
290 if (module_sp)
291 return module_sp->SetArchitecture(new_arch);
292 return false;
293}
294
296 Symtab *symtab = GetSymtab();
297 if (symtab) {
298 Symbol *symbol = symtab->FindSymbolContainingFileAddress(file_addr);
299 if (symbol) {
300 if (symbol->ValueIsAddress()) {
301 const SectionSP section_sp(symbol->GetAddressRef().GetSection());
302 if (section_sp) {
303 const SectionType section_type = section_sp->GetType();
304 switch (section_type) {
307 case eSectionTypeCode:
308 return AddressClass::eCode;
311 case eSectionTypeData:
323 return AddressClass::eData;
359 case eSectionTypeCTF:
374 // In case of absolute sections decide the address class based on
375 // the symbol type because the section type isn't specify if it is
376 // a code or a data section.
377 break;
378 }
379 }
380 }
381
382 const SymbolType symbol_type = symbol->GetType();
383 switch (symbol_type) {
384 case eSymbolTypeAny:
388 case eSymbolTypeCode:
389 return AddressClass::eCode;
391 return AddressClass::eCode;
393 return AddressClass::eCode;
394 case eSymbolTypeData:
395 return AddressClass::eData;
408 case eSymbolTypeBlock:
410 case eSymbolTypeLocal:
411 return AddressClass::eData;
412 case eSymbolTypeParam:
413 return AddressClass::eData;
415 return AddressClass::eData;
442 }
443 }
444 }
446}
447
449 lldb::addr_t addr, size_t byte_size) {
450 DataBufferSP data_sp;
451 if (process_sp) {
452 std::unique_ptr<DataBufferHeap> data_up(new DataBufferHeap(byte_size, 0));
454 const size_t bytes_read = process_sp->ReadMemory(
455 addr, data_up->GetBytes(), data_up->GetByteSize(), error);
456 if (bytes_read == byte_size)
457 data_sp.reset(data_up.release());
458 }
459 return data_sp;
460}
461
462size_t ObjectFile::GetData(lldb::offset_t offset, size_t length,
463 DataExtractor &data) const {
464 // The entire file has already been mmap'ed into m_data, so just copy from
465 // there as the back mmap buffer will be shared with shared pointers.
466 return data.SetData(m_data, offset, length);
467}
468
469size_t ObjectFile::CopyData(lldb::offset_t offset, size_t length,
470 void *dst) const {
471 // The entire file has already been mmap'ed into m_data, so just copy from
472 // there Note that the data remains in target byte order.
473 return m_data.CopyData(offset, length, dst);
474}
475
477 lldb::offset_t section_offset, void *dst,
478 size_t dst_len) {
479 assert(section);
480 section_offset *= section->GetTargetByteSize();
481
482 // If some other objectfile owns this data, pass this to them.
483 if (section->GetObjectFile() != this)
484 return section->GetObjectFile()->ReadSectionData(section, section_offset,
485 dst, dst_len);
486
487 if (!section->IsRelocated())
488 RelocateSection(section);
489
490 if (IsInMemory()) {
491 ProcessSP process_sp(m_process_wp.lock());
492 if (process_sp) {
494 const addr_t base_load_addr =
495 section->GetLoadBaseAddress(&process_sp->GetTarget());
496 if (base_load_addr != LLDB_INVALID_ADDRESS)
497 return process_sp->ReadMemory(base_load_addr + section_offset, dst,
498 dst_len, error);
499 }
500 } else {
501 const lldb::offset_t section_file_size = section->GetFileSize();
502 if (section_offset < section_file_size) {
503 const size_t section_bytes_left = section_file_size - section_offset;
504 size_t section_dst_len = dst_len;
505 if (section_dst_len > section_bytes_left)
506 section_dst_len = section_bytes_left;
507 return CopyData(section->GetFileOffset() + section_offset,
508 section_dst_len, dst);
509 } else {
510 if (section->GetType() == eSectionTypeZeroFill) {
511 const uint64_t section_size = section->GetByteSize();
512 const uint64_t section_bytes_left = section_size - section_offset;
513 uint64_t section_dst_len = dst_len;
514 if (section_dst_len > section_bytes_left)
515 section_dst_len = section_bytes_left;
516 memset(dst, 0, section_dst_len);
517 return section_dst_len;
518 }
519 }
520 }
521 return 0;
522}
523
524// Get the section data the file on disk
526 DataExtractor &section_data) {
527 // If some other objectfile owns this data, pass this to them.
528 if (section->GetObjectFile() != this)
529 return section->GetObjectFile()->ReadSectionData(section, section_data);
530
531 if (!section->IsRelocated())
532 RelocateSection(section);
533
534 if (IsInMemory()) {
535 ProcessSP process_sp(m_process_wp.lock());
536 if (process_sp) {
537 const addr_t base_load_addr =
538 section->GetLoadBaseAddress(&process_sp->GetTarget());
539 if (base_load_addr != LLDB_INVALID_ADDRESS) {
540 DataBufferSP data_sp(
541 ReadMemory(process_sp, base_load_addr, section->GetByteSize()));
542 if (data_sp) {
543 section_data.SetData(data_sp, 0, data_sp->GetByteSize());
544 section_data.SetByteOrder(process_sp->GetByteOrder());
545 section_data.SetAddressByteSize(process_sp->GetAddressByteSize());
546 return section_data.GetByteSize();
547 }
548 }
549 }
550 }
551
552 // The object file now contains a full mmap'ed copy of the object file
553 // data, so just use this
554 return GetData(section->GetFileOffset(), GetSectionDataSize(section),
555 section_data);
556}
557
558bool ObjectFile::SplitArchivePathWithObject(llvm::StringRef path_with_object,
559 FileSpec &archive_file,
560 ConstString &archive_object,
561 bool must_exist) {
562 size_t len = path_with_object.size();
563 if (len < 2 || path_with_object.back() != ')')
564 return false;
565 llvm::StringRef archive = path_with_object.substr(0, path_with_object.rfind('('));
566 if (archive.empty())
567 return false;
568 llvm::StringRef object = path_with_object.substr(archive.size() + 1).drop_back();
569 archive_file.SetFile(archive, FileSpec::Style::native);
570 if (must_exist && !FileSystem::Instance().Exists(archive_file))
571 return false;
572 archive_object.SetString(object);
573 return true;
574}
575
577 ModuleSP module_sp(GetModule());
578 if (module_sp) {
579 Log *log = GetLog(LLDBLog::Object);
580 LLDB_LOGF(log, "%p ObjectFile::ClearSymtab () symtab = %p",
581 static_cast<void *>(this),
582 static_cast<void *>(m_symtab_up.get()));
583 // Since we need to clear the symbol table, we need a new llvm::once_flag
584 // instance so we can safely create another symbol table
585 m_symtab_once_up.reset(new llvm::once_flag());
586 m_symtab_up.reset();
587 }
588}
589
590SectionList *ObjectFile::GetSectionList(bool update_module_section_list) {
591 if (m_sections_up == nullptr) {
592 if (update_module_section_list) {
593 ModuleSP module_sp(GetModule());
594 if (module_sp) {
595 std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
596 CreateSections(*module_sp->GetUnifiedSectionList());
597 }
598 } else {
599 SectionList unified_section_list;
600 CreateSections(unified_section_list);
601 }
602 }
603 return m_sections_up.get();
604}
605
608 lldb::SymbolType symbol_type_hint) {
609 if (!name.empty()) {
610 if (name.starts_with("_OBJC_")) {
611 // ObjC
612 if (name.starts_with("_OBJC_CLASS_$_"))
614 if (name.starts_with("_OBJC_METACLASS_$_"))
616 if (name.starts_with("_OBJC_IVAR_$_"))
618 } else if (name.starts_with(".objc_class_name_")) {
619 // ObjC v1
621 }
622 }
623 return symbol_type_hint;
624}
625
626std::vector<ObjectFile::LoadableData>
628 std::vector<LoadableData> loadables;
629 SectionList *section_list = GetSectionList();
630 if (!section_list)
631 return loadables;
632 // Create a list of loadable data from loadable sections
633 size_t section_count = section_list->GetNumSections(0);
634 for (size_t i = 0; i < section_count; ++i) {
635 LoadableData loadable;
636 SectionSP section_sp = section_list->GetSectionAtIndex(i);
637 loadable.Dest =
638 target.GetSectionLoadList().GetSectionLoadAddress(section_sp);
639 if (loadable.Dest == LLDB_INVALID_ADDRESS)
640 continue;
641 // We can skip sections like bss
642 if (section_sp->GetFileSize() == 0)
643 continue;
644 DataExtractor section_data;
645 section_sp->GetSectionData(section_data);
646 loadable.Contents = llvm::ArrayRef<uint8_t>(section_data.GetDataStart(),
647 section_data.GetByteSize());
648 loadables.push_back(loadable);
649 }
650 return loadables;
651}
652
653std::unique_ptr<CallFrameInfo> ObjectFile::CreateCallFrameInfo() {
654 return {};
655}
656
658{
659}
660
662 uint64_t Offset) {
663 return FileSystem::Instance().CreateDataBuffer(file.GetPath(), Size, Offset);
664}
665
666void llvm::format_provider<ObjectFile::Type>::format(
667 const ObjectFile::Type &type, raw_ostream &OS, StringRef Style) {
668 switch (type) {
670 OS << "invalid";
671 break;
673 OS << "core file";
674 break;
676 OS << "executable";
677 break;
679 OS << "debug info";
680 break;
682 OS << "dynamic linker";
683 break;
685 OS << "object file";
686 break;
688 OS << "shared library";
689 break;
691 OS << "stub library";
692 break;
694 OS << "jit";
695 break;
697 OS << "unknown";
698 break;
699 }
700}
701
702void llvm::format_provider<ObjectFile::Strata>::format(
703 const ObjectFile::Strata &strata, raw_ostream &OS, StringRef Style) {
704 switch (strata) {
706 OS << "invalid";
707 break;
709 OS << "unknown";
710 break;
712 OS << "user";
713 break;
715 OS << "kernel";
716 break;
718 OS << "raw image";
719 break;
721 OS << "jit";
722 break;
723 }
724}
725
726
728 ModuleSP module_sp(GetModule());
729 if (module_sp) {
730 // We can't take the module lock in ObjectFile::GetSymtab() or we can
731 // deadlock in DWARF indexing when any file asks for the symbol table from
732 // an object file. This currently happens in the preloading of symbols in
733 // SymbolFileDWARF::PreloadSymbols() because the main thread will take the
734 // module lock, and then threads will be spun up to index the DWARF and
735 // any of those threads might end up trying to relocate items in the DWARF
736 // sections which causes ObjectFile::GetSectionData(...) to relocate section
737 // data which requires the symbol table.
738 //
739 // So to work around this, we create the symbol table one time using
740 // llvm::once_flag, lock it, and then set the unique pointer. Any other
741 // thread that gets ahold of the symbol table before parsing is done, will
742 // not be able to access the symbol table contents since all APIs in Symtab
743 // are protected by a mutex in the Symtab object itself.
744 llvm::call_once(*m_symtab_once_up, [&]() {
745 Symtab *symtab = new Symtab(this);
746 std::lock_guard<std::recursive_mutex> symtab_guard(symtab->GetMutex());
747 m_symtab_up.reset(symtab);
748 if (!m_symtab_up->LoadFromCache()) {
749 ElapsedTime elapsed(module_sp->GetSymtabParseTime());
751 m_symtab_up->Finalize();
752 }
753 });
754 }
755 return m_symtab_up.get();
756}
757
759 if (m_cache_hash)
760 return *m_cache_hash;
761 StreamString strm;
762 strm.Format("{0}-{1}-{2}", m_file, GetType(), GetStrata());
763 m_cache_hash = llvm::djbHash(strm.GetString());
764 return *m_cache_hash;
765}
766
767namespace llvm {
768namespace json {
769
770bool fromJSON(const llvm::json::Value &value,
771 lldb_private::ObjectFile::Type &type, llvm::json::Path path) {
772 if (auto str = value.getAsString()) {
773 type = llvm::StringSwitch<ObjectFile::Type>(*str)
774 .Case("corefile", ObjectFile::eTypeCoreFile)
775 .Case("executable", ObjectFile::eTypeExecutable)
776 .Case("debuginfo", ObjectFile::eTypeDebugInfo)
777 .Case("dynamiclinker", ObjectFile::eTypeDynamicLinker)
778 .Case("objectfile", ObjectFile::eTypeObjectFile)
779 .Case("sharedlibrary", ObjectFile::eTypeSharedLibrary)
780 .Case("stublibrary", ObjectFile::eTypeStubLibrary)
781 .Case("jit", ObjectFile::eTypeJIT)
782 .Case("unknown", ObjectFile::eTypeUnknown)
783 .Default(ObjectFile::eTypeInvalid);
784
785 if (type == ObjectFile::eTypeInvalid) {
786 path.report("invalid object type");
787 return false;
788 }
789
790 return true;
791 }
792 path.report("expected string");
793 return false;
794}
795} // namespace json
796} // namespace llvm
static llvm::raw_ostream & error(Stream &strm)
#define LLDB_LOGF(log,...)
Definition: Log.h:366
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:36
static double elapsed(const StatsTimepoint &start, const StatsTimepoint &end)
Definition: Statistics.cpp:38
#define LLDB_SCOPED_TIMERF(...)
Definition: Timer.h:86
lldb::SectionSP GetSection() const
Get const accessor for the section.
Definition: Address.h:439
An architecture specification class.
Definition: ArchSpec.h:31
A uniqued constant string class.
Definition: ConstString.h:40
void SetString(llvm::StringRef s)
A subclass of DataBuffer that stores a data buffer on the heap.
An data extractor class.
Definition: DataExtractor.h:48
lldb::offset_t CopyData(lldb::offset_t offset, lldb::offset_t length, void *dst) const
Copy length bytes from *offset, without swapping bytes.
void SetByteOrder(lldb::ByteOrder byte_order)
Set the byte_order value.
uint64_t GetByteSize() const
Get the number of bytes contained in this object.
const uint8_t * GetDataStart() const
Get the data start pointer.
lldb::offset_t SetData(const void *bytes, lldb::offset_t length, lldb::ByteOrder byte_order)
Set data with a buffer that is caller owned.
void SetAddressByteSize(uint32_t addr_size)
Set the address byte size.
A class that measures elapsed time in an exception safe way.
Definition: Statistics.h:68
A file utility class.
Definition: FileSpec.h:56
void SetFile(llvm::StringRef path, Style style)
Change the file specified with a new path.
Definition: FileSpec.cpp:174
size_t GetPath(char *path, size_t max_path_length, bool denormalize=true) const
Extract the full path to the file.
Definition: FileSpec.cpp:367
uint64_t GetByteSize(const FileSpec &file_spec) const
Returns the on-disk size of the given file in bytes.
bool Exists(const FileSpec &file_spec) const
Returns whether the given file exists.
static FileSystem & Instance()
std::shared_ptr< DataBuffer > CreateDataBuffer(const llvm::Twine &path, uint64_t size=0, uint64_t offset=0)
Create memory buffer from path.
A mix in class that contains a pointer back to the module that owns the object which inherits from it...
Definition: ModuleChild.h:19
lldb::ModuleSP GetModule() const
Get const accessor for the module pointer.
Definition: ModuleChild.cpp:24
static lldb::ObjectFileSP FindPlugin(const lldb::ModuleSP &module_sp, const FileSpec *file_spec, lldb::offset_t file_offset, lldb::offset_t file_size, lldb::DataBufferSP &data_sp, lldb::offset_t &data_offset)
Find a ObjectFile plug-in that can parse file_spec.
Definition: ObjectFile.cpp:53
DataExtractor m_data
The data for this object file so things can be parsed lazily.
Definition: ObjectFile.h:756
Symtab * GetSymtab()
Gets the symbol table for the currently selected architecture (and object for archives).
Definition: ObjectFile.cpp:727
std::unique_ptr< lldb_private::SectionList > m_sections_up
Definition: ObjectFile.h:760
static lldb::DataBufferSP MapFileData(const FileSpec &file, uint64_t Size, uint64_t Offset)
Definition: ObjectFile.cpp:661
ObjectFile(const lldb::ModuleSP &module_sp, const FileSpec *file_spec_ptr, lldb::offset_t file_offset, lldb::offset_t length, lldb::DataBufferSP data_sp, lldb::offset_t data_offset)
Construct with a parent module, offset, and header data.
Definition: ObjectFile.cpp:241
virtual std::vector< LoadableData > GetLoadableData(Target &target)
Loads this objfile to memory.
Definition: ObjectFile.cpp:627
~ObjectFile() override
Destructor.
Definition: ObjectFile.cpp:283
std::unique_ptr< lldb_private::Symtab > m_symtab_up
Definition: ObjectFile.h:761
const lldb::addr_t m_memory_addr
Set if the object file only exists in memory.
Definition: ObjectFile.h:759
static size_t g_initial_bytes_to_read
The number of bytes to read when going through the plugins.
Definition: ObjectFile.h:783
virtual void ParseSymtab(Symtab &symtab)=0
Parse the symbol table into the provides symbol table object.
virtual AddressClass GetAddressClass(lldb::addr_t file_addr)
Get the address type given a file address in an object file.
Definition: ObjectFile.cpp:295
static lldb::DataBufferSP ReadMemory(const lldb::ProcessSP &process_sp, lldb::addr_t addr, size_t byte_size)
Definition: ObjectFile.cpp:448
size_t GetData(lldb::offset_t offset, size_t length, DataExtractor &data) const
Definition: ObjectFile.cpp:462
@ eTypeExecutable
A normal executable.
Definition: ObjectFile.h:53
@ eTypeDebugInfo
An object file that contains only debug information.
Definition: ObjectFile.h:55
@ eTypeStubLibrary
A library that can be linked against but not used for execution.
Definition: ObjectFile.h:63
@ eTypeObjectFile
An intermediate object file.
Definition: ObjectFile.h:59
@ eTypeDynamicLinker
The platform's dynamic linker executable.
Definition: ObjectFile.h:57
@ eTypeCoreFile
A core file that has a checkpoint of a program's execution state.
Definition: ObjectFile.h:51
@ eTypeSharedLibrary
A shared library that can be used during execution.
Definition: ObjectFile.h:61
@ eTypeJIT
JIT code that has symbols, sections and possibly debug info.
Definition: ObjectFile.h:65
lldb::addr_t m_file_offset
The offset in bytes into the file, or the address in memory.
Definition: ObjectFile.h:750
static lldb::SymbolType GetSymbolTypeFromName(llvm::StringRef name, lldb::SymbolType symbol_type_hint=lldb::eSymbolTypeUndefined)
Definition: ObjectFile.cpp:607
virtual size_t GetSectionDataSize(Section *section)
Definition: ObjectFile.h:684
virtual std::unique_ptr< CallFrameInfo > CreateCallFrameInfo()
Creates a plugin-specific call frame info.
Definition: ObjectFile.cpp:653
virtual void ClearSymtab()
Frees the symbol table.
Definition: ObjectFile.cpp:576
bool SetModulesArchitecture(const ArchSpec &new_arch)
Sets the architecture for a module.
Definition: ObjectFile.cpp:288
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:558
virtual void CreateSections(SectionList &unified_section_list)=0
size_t CopyData(lldb::offset_t offset, size_t length, void *dst) const
Definition: ObjectFile.cpp:469
virtual void RelocateSection(lldb_private::Section *section)
Perform relocations on the section if necessary.
Definition: ObjectFile.cpp:657
std::optional< uint32_t > m_cache_hash
Definition: ObjectFile.h:768
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:590
std::unique_ptr< llvm::once_flag > m_symtab_once_up
We need a llvm::once_flag that we can use to avoid locking the module lock and deadlocking LLDB.
Definition: ObjectFile.h:767
bool IsInMemory() const
Returns true if the object file exists only in memory.
Definition: ObjectFile.h:689
lldb::ProcessWP m_process_wp
Definition: ObjectFile.h:757
uint32_t GetCacheHash()
Get a hash that can be used for caching object file releated information.
Definition: ObjectFile.cpp:758
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:752
virtual size_t ReadSectionData(Section *section, lldb::offset_t section_offset, void *dst, size_t dst_len)
Definition: ObjectFile.cpp:476
static size_t GetModuleSpecifications(const FileSpec &file, lldb::offset_t file_offset, lldb::offset_t file_size, ModuleSpecList &specs, lldb::DataBufferSP data_sp=lldb::DataBufferSP())
Definition: ObjectFile.cpp:187
static ObjectFileCreateMemoryInstance GetObjectFileCreateMemoryCallbackAtIndex(uint32_t idx)
static ObjectContainerCreateInstance GetObjectContainerCreateCallbackAtIndex(uint32_t idx)
static ObjectFileCreateInstance GetObjectFileCreateCallbackAtIndex(uint32_t idx)
static ObjectFileGetModuleSpecifications GetObjectContainerGetModuleSpecificationsCallbackAtIndex(uint32_t idx)
static ObjectFileGetModuleSpecifications GetObjectFileGetModuleSpecificationsCallbackAtIndex(uint32_t idx)
size_t GetNumSections(uint32_t depth) const
Definition: Section.cpp:533
lldb::SectionSP GetSectionAtIndex(size_t idx) const
Definition: Section.cpp:544
lldb::addr_t GetSectionLoadAddress(const lldb::SectionSP &section_sp) const
uint32_t GetTargetByteSize() const
Definition: Section.h:247
lldb::offset_t GetFileOffset() const
Definition: Section.h:154
ObjectFile * GetObjectFile()
Definition: Section.h:204
lldb::SectionType GetType() const
Definition: Section.h:188
lldb::addr_t GetLoadBaseAddress(Target *target) const
Definition: Section.cpp:228
lldb::addr_t GetByteSize() const
Definition: Section.h:170
lldb::offset_t GetFileSize() const
Definition: Section.h:160
bool IsRelocated() const
Definition: Section.h:249
An error handling class.
Definition: Status.h:44
llvm::StringRef GetString() const
void Format(const char *format, Args &&... args)
Definition: Stream.h:353
bool ValueIsAddress() const
Definition: Symbol.cpp:169
Address & GetAddressRef()
Definition: Symbol.h:72
lldb::SymbolType GetType() const
Definition: Symbol.h:168
Symbol * FindSymbolContainingFileAddress(lldb::addr_t file_addr)
Definition: Symtab.cpp:1044
std::recursive_mutex & GetMutex()
Definition: Symtab.h:51
SectionLoadList & GetSectionLoadList()
Definition: Target.h:1136
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:82
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
Definition: Log.h:331
size_t(* ObjectFileGetModuleSpecifications)(const FileSpec &file, lldb::DataBufferSP &data_sp, lldb::offset_t data_offset, lldb::offset_t file_offset, lldb::offset_t length, ModuleSpecList &module_specs)
ObjectFile *(* ObjectFileCreateMemoryInstance)(const lldb::ModuleSP &module_sp, lldb::WritableDataBufferSP data_sp, const lldb::ProcessSP &process_sp, lldb::addr_t offset)
bool fromJSON(const llvm::json::Value &value, TraceSupportedResponse &info, llvm::json::Path path)
Definition: SBAddress.h:15
uint64_t offset_t
Definition: lldb-types.h:83
std::shared_ptr< lldb_private::ObjectFile > ObjectFileSP
Definition: lldb-forward.h:367
std::shared_ptr< lldb_private::Process > ProcessSP
Definition: lldb-forward.h:381
SymbolType
Symbol types.
@ eSymbolTypeUndefined
@ eSymbolTypeVariableType
@ eSymbolTypeObjCMetaClass
@ eSymbolTypeReExported
@ eSymbolTypeObjCClass
@ eSymbolTypeObjectFile
@ eSymbolTypeTrampoline
@ eSymbolTypeResolver
@ eSymbolTypeParam
@ eSymbolTypeSourceFile
@ eSymbolTypeException
@ eSymbolTypeVariable
@ eSymbolTypeAbsolute
@ eSymbolTypeAdditional
When symbols take more than one entry, the extra entries get this type.
@ eSymbolTypeInstrumentation
@ eSymbolTypeLocal
@ eSymbolTypeHeaderFile
@ eSymbolTypeBlock
@ eSymbolTypeCommonBlock
@ eSymbolTypeCompiler
@ eSymbolTypeLineHeader
@ eSymbolTypeObjCIVar
@ eSymbolTypeLineEntry
@ eSymbolTypeRuntime
@ eSymbolTypeScopeBegin
@ eSymbolTypeScopeEnd
std::shared_ptr< lldb_private::DataBuffer > DataBufferSP
Definition: lldb-forward.h:328
std::shared_ptr< lldb_private::Section > SectionSP
Definition: lldb-forward.h:406
std::shared_ptr< lldb_private::WritableDataBuffer > WritableDataBufferSP
Definition: lldb-forward.h:329
uint64_t addr_t
Definition: lldb-types.h:79
@ eSectionTypeDWARFDebugStrOffsets
@ eSectionTypeELFDynamicSymbols
Elf SHT_DYNSYM section.
@ eSectionTypeData
@ eSectionTypeInvalid
@ eSectionTypeDWARFDebugPubNames
@ eSectionTypeDataObjCCFStrings
Objective-C const CFString/NSString objects.
@ eSectionTypeData16
@ eSectionTypeZeroFill
@ eSectionTypeDWARFDebugLocDwo
@ eSectionTypeDWARFDebugFrame
@ eSectionTypeARMextab
@ eSectionTypeContainer
The section contains child sections.
@ eSectionTypeDWARFDebugLocLists
DWARF v5 .debug_loclists.
@ eSectionTypeDWARFDebugTypes
DWARF .debug_types section.
@ eSectionTypeDataSymbolAddress
Address of a symbol in the symbol table.
@ eSectionTypeELFDynamicLinkInfo
Elf SHT_DYNAMIC section.
@ eSectionTypeDWARFDebugMacInfo
@ eSectionTypeAbsoluteAddress
Dummy section for symbols with absolute address.
@ eSectionTypeCompactUnwind
compact unwind section in Mach-O, __TEXT,__unwind_info
@ eSectionTypeELFRelocationEntries
Elf SHT_REL or SHT_REL section.
@ eSectionTypeDWARFAppleNamespaces
@ eSectionTypeOther
@ eSectionTypeDWARFDebugNames
DWARF v5 .debug_names.
@ eSectionTypeDWARFDebugRngLists
DWARF v5 .debug_rnglists.
@ eSectionTypeEHFrame
@ eSectionTypeDWARFDebugStrOffsetsDwo
@ eSectionTypeDWARFDebugMacro
@ eSectionTypeDWARFAppleTypes
@ eSectionTypeDWARFDebugInfo
@ eSectionTypeDWARFDebugTypesDwo
@ eSectionTypeDWARFDebugRanges
@ eSectionTypeDWARFDebugRngListsDwo
@ eSectionTypeGoSymtab
@ eSectionTypeARMexidx
@ eSectionTypeDWARFDebugLine
@ eSectionTypeDWARFDebugPubTypes
@ eSectionTypeDataObjCMessageRefs
Pointer to function pointer + selector.
@ eSectionTypeDWARFDebugTuIndex
@ eSectionTypeData4
@ eSectionTypeDWARFDebugStr
@ eSectionTypeDWARFDebugLineStr
DWARF v5 .debug_line_str.
@ eSectionTypeDWARFDebugLoc
@ eSectionTypeDWARFAppleNames
@ eSectionTypeDataCStringPointers
Pointers to C string data.
@ eSectionTypeDWARFAppleObjC
@ eSectionTypeCode
@ eSectionTypeData8
@ eSectionTypeSwiftModules
@ eSectionTypeDebug
@ eSectionTypeDWARFDebugCuIndex
@ eSectionTypeDWARFDebugAranges
@ eSectionTypeDWARFDebugAbbrevDwo
@ eSectionTypeDWARFGNUDebugAltLink
@ eSectionTypeDWARFDebugStrDwo
@ eSectionTypeDWARFDebugAbbrev
@ eSectionTypeDataPointers
@ eSectionTypeDWARFDebugLocListsDwo
@ eSectionTypeDWARFDebugInfoDwo
@ eSectionTypeDWARFDebugAddr
@ eSectionTypeDataCString
Inlined C string data.
@ eSectionTypeELFSymbolTable
Elf SHT_SYMTAB section.
std::shared_ptr< lldb_private::Module > ModuleSP
Definition: lldb-forward.h:365
Definition: Debugger.h:53
llvm::ArrayRef< uint8_t > Contents
Definition: ObjectFile.h:91