1 //===-- ObjectFile.cpp ----------------------------------------------------===//
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
7 //===----------------------------------------------------------------------===//
9 #include "lldb/Symbol/ObjectFile.h"
10 #include "lldb/Core/Module.h"
11 #include "lldb/Core/ModuleSpec.h"
12 #include "lldb/Core/PluginManager.h"
13 #include "lldb/Core/Section.h"
14 #include "lldb/Symbol/CallFrameInfo.h"
15 #include "lldb/Symbol/ObjectContainer.h"
16 #include "lldb/Symbol/SymbolFile.h"
17 #include "lldb/Target/Process.h"
18 #include "lldb/Target/SectionLoadList.h"
19 #include "lldb/Target/Target.h"
20 #include "lldb/Utility/DataBuffer.h"
21 #include "lldb/Utility/DataBufferHeap.h"
22 #include "lldb/Utility/LLDBLog.h"
23 #include "lldb/Utility/Log.h"
24 #include "lldb/Utility/Timer.h"
25 #include "lldb/lldb-private.h"
27 #include "llvm/Support/DJB.h"
30 using namespace lldb_private;
33 size_t ObjectFile::g_initial_bytes_to_read = 512;
36 CreateObjectFromContainer(const lldb::ModuleSP &module_sp, const FileSpec *file,
37 lldb::offset_t file_offset, lldb::offset_t file_size,
38 DataBufferSP data_sp, lldb::offset_t &data_offset) {
39 ObjectContainerCreateInstance callback;
40 for (uint32_t idx = 0;
41 (callback = PluginManager::GetObjectContainerCreateCallbackAtIndex(
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);
53 ObjectFile::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));
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()) {
75 ObjectFileSP object_file_sp = CreateObjectFromContainer(
76 module_sp, file, file_offset, file_size, data_sp, data_offset);
78 return object_file_sp;
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
85 data_sp = FileSystem::Instance().CreateDataBuffer(
86 file->GetPath(), g_initial_bytes_to_read, file_offset);
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);
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);
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.
109 // ANY data in case there is data cached in the container plug-ins
110 // (like BSD archives caching the contained objects within an
112 ObjectFileSP object_file_sp = CreateObjectFromContainer(
113 module_sp, file, file_offset, file_size, data_sp, data_offset);
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...
118 data_sp = FileSystem::Instance().CreateDataBuffer(
119 archive_file.GetPath(), g_initial_bytes_to_read, file_offset);
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.
127 ObjectFileCreateInstance callback;
128 for (uint32_t idx = 0;
129 (callback = PluginManager::GetObjectFileCreateCallbackAtIndex(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;
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.
141 ObjectFileSP object_file_sp = CreateObjectFromContainer(
142 module_sp, file, file_offset, file_size, data_sp, data_offset);
144 return object_file_sp;
147 // We didn't find it, so clear our shared pointer in case it contains
148 // anything and return an empty shared pointer
152 ObjectFileSP ObjectFile::FindPlugin(const lldb::ModuleSP &module_sp,
153 const ProcessSP &process_sp,
154 lldb::addr_t header_addr,
155 WritableDataBufferSP data_sp) {
156 ObjectFileSP object_file_sp;
159 LLDB_SCOPED_TIMERF("ObjectFile::FindPlugin (module = "
160 "%s, process = %p, header_addr = "
162 module_sp->GetFileSpec().GetPath().c_str(),
163 static_cast<void *>(process_sp.get()), header_addr);
166 // Check if this is a normal object file by iterating through all object
167 // file plugin instances.
168 ObjectFileCreateMemoryInstance create_callback;
171 PluginManager::GetObjectFileCreateMemoryCallbackAtIndex(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;
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;
187 size_t ObjectFile::GetModuleSpecifications(const FileSpec &file,
188 lldb::offset_t file_offset,
189 lldb::offset_t file_size,
190 ModuleSpecList &specs,
191 DataBufferSP data_sp) {
193 data_sp = FileSystem::Instance().CreateDataBuffer(
194 file.GetPath(), g_initial_bytes_to_read, file_offset);
196 if (file_size == 0) {
197 const lldb::offset_t actual_file_size =
198 FileSystem::Instance().GetByteSize(file);
199 if (actual_file_size > file_offset)
200 file_size = actual_file_size - file_offset;
202 return ObjectFile::GetModuleSpecifications(file, // file spec
203 data_sp, // data bytes
205 file_offset, // file offset
206 file_size, // file length
212 size_t ObjectFile::GetModuleSpecifications(
213 const lldb_private::FileSpec &file, lldb::DataBufferSP &data_sp,
214 lldb::offset_t data_offset, lldb::offset_t file_offset,
215 lldb::offset_t file_size, lldb_private::ModuleSpecList &specs) {
216 const size_t initial_count = specs.GetSize();
217 ObjectFileGetModuleSpecifications callback;
219 // Try the ObjectFile plug-ins
222 PluginManager::GetObjectFileGetModuleSpecificationsCallbackAtIndex(
225 if (callback(file, data_sp, data_offset, file_offset, file_size, specs) > 0)
226 return specs.GetSize() - initial_count;
229 // Try the ObjectContainer plug-ins
231 (callback = PluginManager::
232 GetObjectContainerGetModuleSpecificationsCallbackAtIndex(i)) !=
235 if (callback(file, data_sp, data_offset, file_offset, file_size, specs) > 0)
236 return specs.GetSize() - initial_count;
241 ObjectFile::ObjectFile(const lldb::ModuleSP &module_sp,
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()) {
252 m_file = *file_spec_ptr;
254 m_data.SetData(data_sp, data_offset, length);
255 Log *log = GetLog(LLDBLog::Object);
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,
265 ObjectFile::ObjectFile(const lldb::ModuleSP &module_sp,
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()) {
273 m_data.SetData(header_data_sp, 0, header_data_sp->GetByteSize());
274 Log *log = GetLog(LLDBLog::Object);
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);
283 ObjectFile::~ObjectFile() {
284 Log *log = GetLog(LLDBLog::Object);
285 LLDB_LOGF(log, "%p ObjectFile::~ObjectFile ()\n", static_cast<void *>(this));
288 bool ObjectFile::SetModulesArchitecture(const ArchSpec &new_arch) {
289 ModuleSP module_sp(GetModule());
291 return module_sp->SetArchitecture(new_arch);
295 AddressClass ObjectFile::GetAddressClass(addr_t file_addr) {
296 Symtab *symtab = GetSymtab();
298 Symbol *symbol = symtab->FindSymbolContainingFileAddress(file_addr);
300 if (symbol->ValueIsAddress()) {
301 const SectionSP section_sp(symbol->GetAddressRef().GetSection());
303 const SectionType section_type = section_sp->GetType();
304 switch (section_type) {
305 case eSectionTypeInvalid:
306 return AddressClass::eUnknown;
307 case eSectionTypeCode:
308 return AddressClass::eCode;
309 case eSectionTypeContainer:
310 return AddressClass::eUnknown;
311 case eSectionTypeData:
312 case eSectionTypeDataCString:
313 case eSectionTypeDataCStringPointers:
314 case eSectionTypeDataSymbolAddress:
315 case eSectionTypeData4:
316 case eSectionTypeData8:
317 case eSectionTypeData16:
318 case eSectionTypeDataPointers:
319 case eSectionTypeZeroFill:
320 case eSectionTypeDataObjCMessageRefs:
321 case eSectionTypeDataObjCCFStrings:
322 case eSectionTypeGoSymtab:
323 return AddressClass::eData;
324 case eSectionTypeDebug:
325 case eSectionTypeDWARFDebugAbbrev:
326 case eSectionTypeDWARFDebugAbbrevDwo:
327 case eSectionTypeDWARFDebugAddr:
328 case eSectionTypeDWARFDebugAranges:
329 case eSectionTypeDWARFDebugCuIndex:
330 case eSectionTypeDWARFDebugFrame:
331 case eSectionTypeDWARFDebugInfo:
332 case eSectionTypeDWARFDebugInfoDwo:
333 case eSectionTypeDWARFDebugLine:
334 case eSectionTypeDWARFDebugLineStr:
335 case eSectionTypeDWARFDebugLoc:
336 case eSectionTypeDWARFDebugLocDwo:
337 case eSectionTypeDWARFDebugLocLists:
338 case eSectionTypeDWARFDebugLocListsDwo:
339 case eSectionTypeDWARFDebugMacInfo:
340 case eSectionTypeDWARFDebugMacro:
341 case eSectionTypeDWARFDebugNames:
342 case eSectionTypeDWARFDebugPubNames:
343 case eSectionTypeDWARFDebugPubTypes:
344 case eSectionTypeDWARFDebugRanges:
345 case eSectionTypeDWARFDebugRngLists:
346 case eSectionTypeDWARFDebugRngListsDwo:
347 case eSectionTypeDWARFDebugStr:
348 case eSectionTypeDWARFDebugStrDwo:
349 case eSectionTypeDWARFDebugStrOffsets:
350 case eSectionTypeDWARFDebugStrOffsetsDwo:
351 case eSectionTypeDWARFDebugTuIndex:
352 case eSectionTypeDWARFDebugTypes:
353 case eSectionTypeDWARFDebugTypesDwo:
354 case eSectionTypeDWARFAppleNames:
355 case eSectionTypeDWARFAppleTypes:
356 case eSectionTypeDWARFAppleNamespaces:
357 case eSectionTypeDWARFAppleObjC:
358 case eSectionTypeDWARFGNUDebugAltLink:
359 case eSectionTypeCTF:
360 return AddressClass::eDebug;
361 case eSectionTypeEHFrame:
362 case eSectionTypeARMexidx:
363 case eSectionTypeARMextab:
364 case eSectionTypeCompactUnwind:
365 return AddressClass::eRuntime;
366 case eSectionTypeELFSymbolTable:
367 case eSectionTypeELFDynamicSymbols:
368 case eSectionTypeELFRelocationEntries:
369 case eSectionTypeELFDynamicLinkInfo:
370 case eSectionTypeOther:
371 return AddressClass::eUnknown;
372 case eSectionTypeAbsoluteAddress:
373 // In case of absolute sections decide the address class based on
374 // the symbol type because the section type isn't specify if it is
375 // a code or a data section.
381 const SymbolType symbol_type = symbol->GetType();
382 switch (symbol_type) {
384 return AddressClass::eUnknown;
385 case eSymbolTypeAbsolute:
386 return AddressClass::eUnknown;
387 case eSymbolTypeCode:
388 return AddressClass::eCode;
389 case eSymbolTypeTrampoline:
390 return AddressClass::eCode;
391 case eSymbolTypeResolver:
392 return AddressClass::eCode;
393 case eSymbolTypeData:
394 return AddressClass::eData;
395 case eSymbolTypeRuntime:
396 return AddressClass::eRuntime;
397 case eSymbolTypeException:
398 return AddressClass::eRuntime;
399 case eSymbolTypeSourceFile:
400 return AddressClass::eDebug;
401 case eSymbolTypeHeaderFile:
402 return AddressClass::eDebug;
403 case eSymbolTypeObjectFile:
404 return AddressClass::eDebug;
405 case eSymbolTypeCommonBlock:
406 return AddressClass::eDebug;
407 case eSymbolTypeBlock:
408 return AddressClass::eDebug;
409 case eSymbolTypeLocal:
410 return AddressClass::eData;
411 case eSymbolTypeParam:
412 return AddressClass::eData;
413 case eSymbolTypeVariable:
414 return AddressClass::eData;
415 case eSymbolTypeVariableType:
416 return AddressClass::eDebug;
417 case eSymbolTypeLineEntry:
418 return AddressClass::eDebug;
419 case eSymbolTypeLineHeader:
420 return AddressClass::eDebug;
421 case eSymbolTypeScopeBegin:
422 return AddressClass::eDebug;
423 case eSymbolTypeScopeEnd:
424 return AddressClass::eDebug;
425 case eSymbolTypeAdditional:
426 return AddressClass::eUnknown;
427 case eSymbolTypeCompiler:
428 return AddressClass::eDebug;
429 case eSymbolTypeInstrumentation:
430 return AddressClass::eDebug;
431 case eSymbolTypeUndefined:
432 return AddressClass::eUnknown;
433 case eSymbolTypeObjCClass:
434 return AddressClass::eRuntime;
435 case eSymbolTypeObjCMetaClass:
436 return AddressClass::eRuntime;
437 case eSymbolTypeObjCIVar:
438 return AddressClass::eRuntime;
439 case eSymbolTypeReExported:
440 return AddressClass::eRuntime;
444 return AddressClass::eUnknown;
447 DataBufferSP ObjectFile::ReadMemory(const ProcessSP &process_sp,
448 lldb::addr_t addr, size_t byte_size) {
449 DataBufferSP data_sp;
451 std::unique_ptr<DataBufferHeap> data_up(new DataBufferHeap(byte_size, 0));
453 const size_t bytes_read = process_sp->ReadMemory(
454 addr, data_up->GetBytes(), data_up->GetByteSize(), error);
455 if (bytes_read == byte_size)
456 data_sp.reset(data_up.release());
461 size_t ObjectFile::GetData(lldb::offset_t offset, size_t length,
462 DataExtractor &data) const {
463 // The entire file has already been mmap'ed into m_data, so just copy from
464 // there as the back mmap buffer will be shared with shared pointers.
465 return data.SetData(m_data, offset, length);
468 size_t ObjectFile::CopyData(lldb::offset_t offset, size_t length,
470 // The entire file has already been mmap'ed into m_data, so just copy from
471 // there Note that the data remains in target byte order.
472 return m_data.CopyData(offset, length, dst);
475 size_t ObjectFile::ReadSectionData(Section *section,
476 lldb::offset_t section_offset, void *dst,
479 section_offset *= section->GetTargetByteSize();
481 // If some other objectfile owns this data, pass this to them.
482 if (section->GetObjectFile() != this)
483 return section->GetObjectFile()->ReadSectionData(section, section_offset,
486 if (!section->IsRelocated())
487 RelocateSection(section);
490 ProcessSP process_sp(m_process_wp.lock());
493 const addr_t base_load_addr =
494 section->GetLoadBaseAddress(&process_sp->GetTarget());
495 if (base_load_addr != LLDB_INVALID_ADDRESS)
496 return process_sp->ReadMemory(base_load_addr + section_offset, dst,
500 const lldb::offset_t section_file_size = section->GetFileSize();
501 if (section_offset < section_file_size) {
502 const size_t section_bytes_left = section_file_size - section_offset;
503 size_t section_dst_len = dst_len;
504 if (section_dst_len > section_bytes_left)
505 section_dst_len = section_bytes_left;
506 return CopyData(section->GetFileOffset() + section_offset,
507 section_dst_len, dst);
509 if (section->GetType() == eSectionTypeZeroFill) {
510 const uint64_t section_size = section->GetByteSize();
511 const uint64_t section_bytes_left = section_size - section_offset;
512 uint64_t section_dst_len = dst_len;
513 if (section_dst_len > section_bytes_left)
514 section_dst_len = section_bytes_left;
515 memset(dst, 0, section_dst_len);
516 return section_dst_len;
523 // Get the section data the file on disk
524 size_t ObjectFile::ReadSectionData(Section *section,
525 DataExtractor §ion_data) {
526 // If some other objectfile owns this data, pass this to them.
527 if (section->GetObjectFile() != this)
528 return section->GetObjectFile()->ReadSectionData(section, section_data);
530 if (!section->IsRelocated())
531 RelocateSection(section);
534 ProcessSP process_sp(m_process_wp.lock());
536 const addr_t base_load_addr =
537 section->GetLoadBaseAddress(&process_sp->GetTarget());
538 if (base_load_addr != LLDB_INVALID_ADDRESS) {
539 DataBufferSP data_sp(
540 ReadMemory(process_sp, base_load_addr, section->GetByteSize()));
542 section_data.SetData(data_sp, 0, data_sp->GetByteSize());
543 section_data.SetByteOrder(process_sp->GetByteOrder());
544 section_data.SetAddressByteSize(process_sp->GetAddressByteSize());
545 return section_data.GetByteSize();
551 // The object file now contains a full mmap'ed copy of the object file
552 // data, so just use this
553 return GetData(section->GetFileOffset(), section->GetFileSize(),
557 bool ObjectFile::SplitArchivePathWithObject(llvm::StringRef path_with_object,
558 FileSpec &archive_file,
559 ConstString &archive_object,
561 size_t len = path_with_object.size();
562 if (len < 2 || path_with_object.back() != ')')
564 llvm::StringRef archive = path_with_object.substr(0, path_with_object.rfind('('));
567 llvm::StringRef object = path_with_object.substr(archive.size() + 1).drop_back();
568 archive_file.SetFile(archive, FileSpec::Style::native);
569 if (must_exist && !FileSystem::Instance().Exists(archive_file))
571 archive_object.SetString(object);
575 void ObjectFile::ClearSymtab() {
576 ModuleSP module_sp(GetModule());
578 Log *log = GetLog(LLDBLog::Object);
579 LLDB_LOGF(log, "%p ObjectFile::ClearSymtab () symtab = %p",
580 static_cast<void *>(this),
581 static_cast<void *>(m_symtab_up.get()));
582 // Since we need to clear the symbol table, we need a new llvm::once_flag
583 // instance so we can safely create another symbol table
584 m_symtab_once_up.reset(new llvm::once_flag());
589 SectionList *ObjectFile::GetSectionList(bool update_module_section_list) {
590 if (m_sections_up == nullptr) {
591 if (update_module_section_list) {
592 ModuleSP module_sp(GetModule());
594 std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
595 CreateSections(*module_sp->GetUnifiedSectionList());
598 SectionList unified_section_list;
599 CreateSections(unified_section_list);
602 return m_sections_up.get();
606 ObjectFile::GetSymbolTypeFromName(llvm::StringRef name,
607 lldb::SymbolType symbol_type_hint) {
609 if (name.startswith("_OBJC_")) {
611 if (name.startswith("_OBJC_CLASS_$_"))
612 return lldb::eSymbolTypeObjCClass;
613 if (name.startswith("_OBJC_METACLASS_$_"))
614 return lldb::eSymbolTypeObjCMetaClass;
615 if (name.startswith("_OBJC_IVAR_$_"))
616 return lldb::eSymbolTypeObjCIVar;
617 } else if (name.startswith(".objc_class_name_")) {
619 return lldb::eSymbolTypeObjCClass;
622 return symbol_type_hint;
625 std::vector<ObjectFile::LoadableData>
626 ObjectFile::GetLoadableData(Target &target) {
627 std::vector<LoadableData> loadables;
628 SectionList *section_list = GetSectionList();
631 // Create a list of loadable data from loadable sections
632 size_t section_count = section_list->GetNumSections(0);
633 for (size_t i = 0; i < section_count; ++i) {
634 LoadableData loadable;
635 SectionSP section_sp = section_list->GetSectionAtIndex(i);
637 target.GetSectionLoadList().GetSectionLoadAddress(section_sp);
638 if (loadable.Dest == LLDB_INVALID_ADDRESS)
640 // We can skip sections like bss
641 if (section_sp->GetFileSize() == 0)
643 DataExtractor section_data;
644 section_sp->GetSectionData(section_data);
645 loadable.Contents = llvm::ArrayRef<uint8_t>(section_data.GetDataStart(),
646 section_data.GetByteSize());
647 loadables.push_back(loadable);
652 std::unique_ptr<CallFrameInfo> ObjectFile::CreateCallFrameInfo() {
656 void ObjectFile::RelocateSection(lldb_private::Section *section)
660 DataBufferSP ObjectFile::MapFileData(const FileSpec &file, uint64_t Size,
662 return FileSystem::Instance().CreateDataBuffer(file.GetPath(), Size, Offset);
665 void llvm::format_provider<ObjectFile::Type>::format(
666 const ObjectFile::Type &type, raw_ostream &OS, StringRef Style) {
668 case ObjectFile::eTypeInvalid:
671 case ObjectFile::eTypeCoreFile:
674 case ObjectFile::eTypeExecutable:
677 case ObjectFile::eTypeDebugInfo:
680 case ObjectFile::eTypeDynamicLinker:
681 OS << "dynamic linker";
683 case ObjectFile::eTypeObjectFile:
686 case ObjectFile::eTypeSharedLibrary:
687 OS << "shared library";
689 case ObjectFile::eTypeStubLibrary:
690 OS << "stub library";
692 case ObjectFile::eTypeJIT:
695 case ObjectFile::eTypeUnknown:
701 void llvm::format_provider<ObjectFile::Strata>::format(
702 const ObjectFile::Strata &strata, raw_ostream &OS, StringRef Style) {
704 case ObjectFile::eStrataInvalid:
707 case ObjectFile::eStrataUnknown:
710 case ObjectFile::eStrataUser:
713 case ObjectFile::eStrataKernel:
716 case ObjectFile::eStrataRawImage:
719 case ObjectFile::eStrataJIT:
726 Symtab *ObjectFile::GetSymtab() {
727 ModuleSP module_sp(GetModule());
729 // We can't take the module lock in ObjectFile::GetSymtab() or we can
730 // deadlock in DWARF indexing when any file asks for the symbol table from
731 // an object file. This currently happens in the preloading of symbols in
732 // SymbolFileDWARF::PreloadSymbols() because the main thread will take the
733 // module lock, and then threads will be spun up to index the DWARF and
734 // any of those threads might end up trying to relocate items in the DWARF
735 // sections which causes ObjectFile::GetSectionData(...) to relocate section
736 // data which requires the symbol table.
738 // So to work around this, we create the symbol table one time using
739 // llvm::once_flag, lock it, and then set the unique pointer. Any other
740 // thread that gets ahold of the symbol table before parsing is done, will
741 // not be able to access the symbol table contents since all APIs in Symtab
742 // are protected by a mutex in the Symtab object itself.
743 llvm::call_once(*m_symtab_once_up, [&]() {
744 Symtab *symtab = new Symtab(this);
745 std::lock_guard<std::recursive_mutex> symtab_guard(symtab->GetMutex());
746 m_symtab_up.reset(symtab);
747 if (!m_symtab_up->LoadFromCache()) {
748 ElapsedTime elapsed(module_sp->GetSymtabParseTime());
749 ParseSymtab(*m_symtab_up);
750 m_symtab_up->Finalize();
754 return m_symtab_up.get();
757 uint32_t ObjectFile::GetCacheHash() {
759 return *m_cache_hash;
761 strm.Format("{0}-{1}-{2}", m_file, GetType(), GetStrata());
762 m_cache_hash = llvm::djbHash(strm.GetString());
763 return *m_cache_hash;
769 bool fromJSON(const llvm::json::Value &value,
770 lldb_private::ObjectFile::Type &type, llvm::json::Path path) {
771 if (auto str = value.getAsString()) {
772 type = llvm::StringSwitch<ObjectFile::Type>(*str)
773 .Case("corefile", ObjectFile::eTypeCoreFile)
774 .Case("executable", ObjectFile::eTypeExecutable)
775 .Case("debuginfo", ObjectFile::eTypeDebugInfo)
776 .Case("dynamiclinker", ObjectFile::eTypeDynamicLinker)
777 .Case("objectfile", ObjectFile::eTypeObjectFile)
778 .Case("sharedlibrary", ObjectFile::eTypeSharedLibrary)
779 .Case("stublibrary", ObjectFile::eTypeStubLibrary)
780 .Case("jit", ObjectFile::eTypeJIT)
781 .Case("unknown", ObjectFile::eTypeUnknown)
782 .Default(ObjectFile::eTypeInvalid);
784 if (type == ObjectFile::eTypeInvalid) {
785 path.report("invalid object type");
791 path.report("expected string");