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 
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"
26 
27 #include "llvm/Support/DJB.h"
28 
29 using namespace lldb;
30 using namespace lldb_private;
31 
32 char ObjectFile::ID;
33 size_t ObjectFile::g_initial_bytes_to_read = 512;
34 
35 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)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(
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 
52 ObjectFileSP
FindPlugin(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)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) {
56   LLDB_SCOPED_TIMERF(
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()) {
75       ObjectFileSP object_file_sp = CreateObjectFromContainer(
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) {
85       data_sp = FileSystem::Instance().CreateDataBuffer(
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).
112         ObjectFileSP object_file_sp = CreateObjectFromContainer(
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...
118         data_sp = FileSystem::Instance().CreateDataBuffer(
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.
127     ObjectFileCreateInstance callback;
128     for (uint32_t idx = 0;
129          (callback = PluginManager::GetObjectFileCreateCallbackAtIndex(idx)) !=
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.
141     ObjectFileSP object_file_sp = CreateObjectFromContainer(
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 
FindPlugin(const lldb::ModuleSP & module_sp,const ProcessSP & process_sp,lldb::addr_t header_addr,WritableDataBufferSP data_sp)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;
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 =
171               PluginManager::GetObjectFileCreateMemoryCallbackAtIndex(idx)) !=
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 
GetModuleSpecifications(const FileSpec & file,lldb::offset_t file_offset,lldb::offset_t file_size,ModuleSpecList & specs,DataBufferSP data_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) {
192   if (!data_sp)
193     data_sp = FileSystem::Instance().CreateDataBuffer(
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 =
198           FileSystem::Instance().GetByteSize(file);
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 
GetModuleSpecifications(const lldb_private::FileSpec & file,lldb::DataBufferSP & data_sp,lldb::offset_t data_offset,lldb::offset_t file_offset,lldb::offset_t file_size,lldb_private::ModuleSpecList & specs)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;
218   uint32_t i;
219   // Try the ObjectFile plug-ins
220   for (i = 0;
221        (callback =
222             PluginManager::GetObjectFileGetModuleSpecificationsCallbackAtIndex(
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::
232             GetObjectContainerGetModuleSpecificationsCallbackAtIndex(i)) !=
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 
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)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()) {
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 
ObjectFile(const lldb::ModuleSP & module_sp,const ProcessSP & process_sp,lldb::addr_t header_addr,DataBufferSP header_data_sp)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()) {
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 
~ObjectFile()283 ObjectFile::~ObjectFile() {
284   Log *log = GetLog(LLDBLog::Object);
285   LLDB_LOGF(log, "%p ObjectFile::~ObjectFile ()\n", static_cast<void *>(this));
286 }
287 
SetModulesArchitecture(const ArchSpec & new_arch)288 bool ObjectFile::SetModulesArchitecture(const ArchSpec &new_arch) {
289   ModuleSP module_sp(GetModule());
290   if (module_sp)
291     return module_sp->SetArchitecture(new_arch);
292   return false;
293 }
294 
GetAddressClass(addr_t file_addr)295 AddressClass ObjectFile::GetAddressClass(addr_t file_addr) {
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) {
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           case eSectionTypeSwiftModules:
361             return AddressClass::eDebug;
362           case eSectionTypeEHFrame:
363           case eSectionTypeARMexidx:
364           case eSectionTypeARMextab:
365           case eSectionTypeCompactUnwind:
366             return AddressClass::eRuntime;
367           case eSectionTypeELFSymbolTable:
368           case eSectionTypeELFDynamicSymbols:
369           case eSectionTypeELFRelocationEntries:
370           case eSectionTypeELFDynamicLinkInfo:
371           case eSectionTypeOther:
372             return AddressClass::eUnknown;
373           case eSectionTypeAbsoluteAddress:
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:
385         return AddressClass::eUnknown;
386       case eSymbolTypeAbsolute:
387         return AddressClass::eUnknown;
388       case eSymbolTypeCode:
389         return AddressClass::eCode;
390       case eSymbolTypeTrampoline:
391         return AddressClass::eCode;
392       case eSymbolTypeResolver:
393         return AddressClass::eCode;
394       case eSymbolTypeData:
395         return AddressClass::eData;
396       case eSymbolTypeRuntime:
397         return AddressClass::eRuntime;
398       case eSymbolTypeException:
399         return AddressClass::eRuntime;
400       case eSymbolTypeSourceFile:
401         return AddressClass::eDebug;
402       case eSymbolTypeHeaderFile:
403         return AddressClass::eDebug;
404       case eSymbolTypeObjectFile:
405         return AddressClass::eDebug;
406       case eSymbolTypeCommonBlock:
407         return AddressClass::eDebug;
408       case eSymbolTypeBlock:
409         return AddressClass::eDebug;
410       case eSymbolTypeLocal:
411         return AddressClass::eData;
412       case eSymbolTypeParam:
413         return AddressClass::eData;
414       case eSymbolTypeVariable:
415         return AddressClass::eData;
416       case eSymbolTypeVariableType:
417         return AddressClass::eDebug;
418       case eSymbolTypeLineEntry:
419         return AddressClass::eDebug;
420       case eSymbolTypeLineHeader:
421         return AddressClass::eDebug;
422       case eSymbolTypeScopeBegin:
423         return AddressClass::eDebug;
424       case eSymbolTypeScopeEnd:
425         return AddressClass::eDebug;
426       case eSymbolTypeAdditional:
427         return AddressClass::eUnknown;
428       case eSymbolTypeCompiler:
429         return AddressClass::eDebug;
430       case eSymbolTypeInstrumentation:
431         return AddressClass::eDebug;
432       case eSymbolTypeUndefined:
433         return AddressClass::eUnknown;
434       case eSymbolTypeObjCClass:
435         return AddressClass::eRuntime;
436       case eSymbolTypeObjCMetaClass:
437         return AddressClass::eRuntime;
438       case eSymbolTypeObjCIVar:
439         return AddressClass::eRuntime;
440       case eSymbolTypeReExported:
441         return AddressClass::eRuntime;
442       }
443     }
444   }
445   return AddressClass::eUnknown;
446 }
447 
ReadMemory(const ProcessSP & process_sp,lldb::addr_t addr,size_t byte_size)448 DataBufferSP ObjectFile::ReadMemory(const ProcessSP &process_sp,
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));
453     Status error;
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 
GetData(lldb::offset_t offset,size_t length,DataExtractor & data) const462 size_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 
CopyData(lldb::offset_t offset,size_t length,void * dst) const469 size_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 
ReadSectionData(Section * section,lldb::offset_t section_offset,void * dst,size_t dst_len)476 size_t ObjectFile::ReadSectionData(Section *section,
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) {
493       Status error;
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
ReadSectionData(Section * section,DataExtractor & section_data)525 size_t ObjectFile::ReadSectionData(Section *section,
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 
SplitArchivePathWithObject(llvm::StringRef path_with_object,FileSpec & archive_file,ConstString & archive_object,bool must_exist)558 bool 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 
ClearSymtab()576 void ObjectFile::ClearSymtab() {
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 
GetSectionList(bool update_module_section_list)590 SectionList *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 
606 lldb::SymbolType
GetSymbolTypeFromName(llvm::StringRef name,lldb::SymbolType symbol_type_hint)607 ObjectFile::GetSymbolTypeFromName(llvm::StringRef name,
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_$_"))
613         return lldb::eSymbolTypeObjCClass;
614       if (name.starts_with("_OBJC_METACLASS_$_"))
615         return lldb::eSymbolTypeObjCMetaClass;
616       if (name.starts_with("_OBJC_IVAR_$_"))
617         return lldb::eSymbolTypeObjCIVar;
618     } else if (name.starts_with(".objc_class_name_")) {
619       // ObjC v1
620       return lldb::eSymbolTypeObjCClass;
621     }
622   }
623   return symbol_type_hint;
624 }
625 
626 std::vector<ObjectFile::LoadableData>
GetLoadableData(Target & target)627 ObjectFile::GetLoadableData(Target &target) {
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 
CreateCallFrameInfo()653 std::unique_ptr<CallFrameInfo> ObjectFile::CreateCallFrameInfo() {
654   return {};
655 }
656 
RelocateSection(lldb_private::Section * section)657 void ObjectFile::RelocateSection(lldb_private::Section *section)
658 {
659 }
660 
MapFileData(const FileSpec & file,uint64_t Size,uint64_t Offset)661 DataBufferSP ObjectFile::MapFileData(const FileSpec &file, uint64_t Size,
662                                      uint64_t Offset) {
663   return FileSystem::Instance().CreateDataBuffer(file.GetPath(), Size, Offset);
664 }
665 
format(const ObjectFile::Type & type,raw_ostream & OS,StringRef Style)666 void llvm::format_provider<ObjectFile::Type>::format(
667     const ObjectFile::Type &type, raw_ostream &OS, StringRef Style) {
668   switch (type) {
669   case ObjectFile::eTypeInvalid:
670     OS << "invalid";
671     break;
672   case ObjectFile::eTypeCoreFile:
673     OS << "core file";
674     break;
675   case ObjectFile::eTypeExecutable:
676     OS << "executable";
677     break;
678   case ObjectFile::eTypeDebugInfo:
679     OS << "debug info";
680     break;
681   case ObjectFile::eTypeDynamicLinker:
682     OS << "dynamic linker";
683     break;
684   case ObjectFile::eTypeObjectFile:
685     OS << "object file";
686     break;
687   case ObjectFile::eTypeSharedLibrary:
688     OS << "shared library";
689     break;
690   case ObjectFile::eTypeStubLibrary:
691     OS << "stub library";
692     break;
693   case ObjectFile::eTypeJIT:
694     OS << "jit";
695     break;
696   case ObjectFile::eTypeUnknown:
697     OS << "unknown";
698     break;
699   }
700 }
701 
format(const ObjectFile::Strata & strata,raw_ostream & OS,StringRef Style)702 void llvm::format_provider<ObjectFile::Strata>::format(
703     const ObjectFile::Strata &strata, raw_ostream &OS, StringRef Style) {
704   switch (strata) {
705   case ObjectFile::eStrataInvalid:
706     OS << "invalid";
707     break;
708   case ObjectFile::eStrataUnknown:
709     OS << "unknown";
710     break;
711   case ObjectFile::eStrataUser:
712     OS << "user";
713     break;
714   case ObjectFile::eStrataKernel:
715     OS << "kernel";
716     break;
717   case ObjectFile::eStrataRawImage:
718     OS << "raw image";
719     break;
720   case ObjectFile::eStrataJIT:
721     OS << "jit";
722     break;
723   }
724 }
725 
726 
GetSymtab()727 Symtab *ObjectFile::GetSymtab() {
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());
750         ParseSymtab(*m_symtab_up);
751         m_symtab_up->Finalize();
752       }
753     });
754   }
755   return m_symtab_up.get();
756 }
757 
GetCacheHash()758 uint32_t ObjectFile::GetCacheHash() {
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 
767 namespace llvm {
768 namespace json {
769 
fromJSON(const llvm::json::Value & value,lldb_private::ObjectFile::Type & type,llvm::json::Path path)770 bool 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
797