1 //===-- ObjectFile.cpp ------------------------------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "lldb/Symbol/ObjectFile.h"
11 #include "lldb/Core/Module.h"
12 #include "lldb/Core/ModuleSpec.h"
13 #include "lldb/Core/PluginManager.h"
14 #include "lldb/Core/Section.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/Log.h"
23 #include "lldb/Utility/RegularExpression.h"
24 #include "lldb/Utility/Timer.h"
25 #include "lldb/lldb-private.h"
26 
27 using namespace lldb;
28 using namespace lldb_private;
29 
30 ObjectFileSP
31 ObjectFile::FindPlugin(const lldb::ModuleSP &module_sp, const FileSpec *file,
32                        lldb::offset_t file_offset, lldb::offset_t file_size,
33                        DataBufferSP &data_sp, lldb::offset_t &data_offset) {
34   ObjectFileSP object_file_sp;
35 
36   if (module_sp) {
37     static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
38     Timer scoped_timer(
39         func_cat,
40         "ObjectFile::FindPlugin (module = %s, file = %p, file_offset = "
41         "0x%8.8" PRIx64 ", file_size = 0x%8.8" PRIx64 ")",
42         module_sp->GetFileSpec().GetPath().c_str(),
43         static_cast<const void *>(file), static_cast<uint64_t>(file_offset),
44         static_cast<uint64_t>(file_size));
45     if (file) {
46       FileSpec archive_file;
47       ObjectContainerCreateInstance create_object_container_callback;
48 
49       const bool file_exists = FileSystem::Instance().Exists(*file);
50       if (!data_sp) {
51         // We have an object name which most likely means we have a .o file in
52         // a static archive (.a file). Try and see if we have a cached archive
53         // first without reading any data first
54         if (file_exists && module_sp->GetObjectName()) {
55           for (uint32_t idx = 0;
56                (create_object_container_callback =
57                     PluginManager::GetObjectContainerCreateCallbackAtIndex(
58                         idx)) != nullptr;
59                ++idx) {
60             std::unique_ptr<ObjectContainer> object_container_ap(
61                 create_object_container_callback(module_sp, data_sp,
62                                                  data_offset, file, file_offset,
63                                                  file_size));
64 
65             if (object_container_ap.get())
66               object_file_sp = object_container_ap->GetObjectFile(file);
67 
68             if (object_file_sp.get())
69               return object_file_sp;
70           }
71         }
72         // Ok, we didn't find any containers that have a named object, now lets
73         // read the first 512 bytes from the file so the object file and object
74         // container plug-ins can use these bytes to see if they can parse this
75         // file.
76         if (file_size > 0) {
77           data_sp = FileSystem::Instance().CreateDataBuffer(file->GetPath(),
78                                                             512, file_offset);
79           data_offset = 0;
80         }
81       }
82 
83       if (!data_sp || data_sp->GetByteSize() == 0) {
84         // Check for archive file with format "/path/to/archive.a(object.o)"
85         char path_with_object[PATH_MAX * 2];
86         module_sp->GetFileSpec().GetPath(path_with_object,
87                                          sizeof(path_with_object));
88 
89         ConstString archive_object;
90         const bool must_exist = true;
91         if (ObjectFile::SplitArchivePathWithObject(
92                 path_with_object, archive_file, archive_object, must_exist)) {
93           file_size = FileSystem::Instance().GetByteSize(archive_file);
94           if (file_size > 0) {
95             file = &archive_file;
96             module_sp->SetFileSpecAndObjectName(archive_file, archive_object);
97             // Check if this is a object container by iterating through all
98             // object container plugin instances and then trying to get an
99             // object file from the container plugins since we had a name.
100             // Also, don't read
101             // ANY data in case there is data cached in the container plug-ins
102             // (like BSD archives caching the contained objects within an
103             // file).
104             for (uint32_t idx = 0;
105                  (create_object_container_callback =
106                       PluginManager::GetObjectContainerCreateCallbackAtIndex(
107                           idx)) != nullptr;
108                  ++idx) {
109               std::unique_ptr<ObjectContainer> object_container_ap(
110                   create_object_container_callback(module_sp, data_sp,
111                                                    data_offset, file,
112                                                    file_offset, file_size));
113 
114               if (object_container_ap.get())
115                 object_file_sp = object_container_ap->GetObjectFile(file);
116 
117               if (object_file_sp.get())
118                 return object_file_sp;
119             }
120             // We failed to find any cached object files in the container plug-
121             // ins, so lets read the first 512 bytes and try again below...
122             data_sp = FileSystem::Instance().CreateDataBuffer(
123                 archive_file.GetPath(), 512, file_offset);
124           }
125         }
126       }
127 
128       if (data_sp && data_sp->GetByteSize() > 0) {
129         // Check if this is a normal object file by iterating through all
130         // object file plugin instances.
131         ObjectFileCreateInstance create_object_file_callback;
132         for (uint32_t idx = 0;
133              (create_object_file_callback =
134                   PluginManager::GetObjectFileCreateCallbackAtIndex(idx)) !=
135              nullptr;
136              ++idx) {
137           object_file_sp.reset(create_object_file_callback(
138               module_sp, data_sp, data_offset, file, file_offset, file_size));
139           if (object_file_sp.get())
140             return object_file_sp;
141         }
142 
143         // Check if this is a object container by iterating through all object
144         // container plugin instances and then trying to get an object file
145         // from the container.
146         for (uint32_t idx = 0;
147              (create_object_container_callback =
148                   PluginManager::GetObjectContainerCreateCallbackAtIndex(
149                       idx)) != nullptr;
150              ++idx) {
151           std::unique_ptr<ObjectContainer> object_container_ap(
152               create_object_container_callback(module_sp, data_sp, data_offset,
153                                                file, file_offset, file_size));
154 
155           if (object_container_ap.get())
156             object_file_sp = object_container_ap->GetObjectFile(file);
157 
158           if (object_file_sp.get())
159             return object_file_sp;
160         }
161       }
162     }
163   }
164   // We didn't find it, so clear our shared pointer in case it contains
165   // anything and return an empty shared pointer
166   object_file_sp.reset();
167   return object_file_sp;
168 }
169 
170 ObjectFileSP ObjectFile::FindPlugin(const lldb::ModuleSP &module_sp,
171                                     const ProcessSP &process_sp,
172                                     lldb::addr_t header_addr,
173                                     DataBufferSP &data_sp) {
174   ObjectFileSP object_file_sp;
175 
176   if (module_sp) {
177     static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
178     Timer scoped_timer(func_cat,
179                        "ObjectFile::FindPlugin (module = "
180                        "%s, process = %p, header_addr = "
181                        "0x%" PRIx64 ")",
182                        module_sp->GetFileSpec().GetPath().c_str(),
183                        static_cast<void *>(process_sp.get()), header_addr);
184     uint32_t idx;
185 
186     // Check if this is a normal object file by iterating through all object
187     // file plugin instances.
188     ObjectFileCreateMemoryInstance create_callback;
189     for (idx = 0;
190          (create_callback =
191               PluginManager::GetObjectFileCreateMemoryCallbackAtIndex(idx)) !=
192          nullptr;
193          ++idx) {
194       object_file_sp.reset(
195           create_callback(module_sp, data_sp, process_sp, header_addr));
196       if (object_file_sp.get())
197         return object_file_sp;
198     }
199   }
200 
201   // We didn't find it, so clear our shared pointer in case it contains
202   // anything and return an empty shared pointer
203   object_file_sp.reset();
204   return object_file_sp;
205 }
206 
207 size_t ObjectFile::GetModuleSpecifications(const FileSpec &file,
208                                            lldb::offset_t file_offset,
209                                            lldb::offset_t file_size,
210                                            ModuleSpecList &specs) {
211   DataBufferSP data_sp =
212       FileSystem::Instance().CreateDataBuffer(file.GetPath(), 512, file_offset);
213   if (data_sp) {
214     if (file_size == 0) {
215       const lldb::offset_t actual_file_size =
216           FileSystem::Instance().GetByteSize(file);
217       if (actual_file_size > file_offset)
218         file_size = actual_file_size - file_offset;
219     }
220     return ObjectFile::GetModuleSpecifications(file,        // file spec
221                                                data_sp,     // data bytes
222                                                0,           // data offset
223                                                file_offset, // file offset
224                                                file_size,   // file length
225                                                specs);
226   }
227   return 0;
228 }
229 
230 size_t ObjectFile::GetModuleSpecifications(
231     const lldb_private::FileSpec &file, lldb::DataBufferSP &data_sp,
232     lldb::offset_t data_offset, lldb::offset_t file_offset,
233     lldb::offset_t file_size, lldb_private::ModuleSpecList &specs) {
234   const size_t initial_count = specs.GetSize();
235   ObjectFileGetModuleSpecifications callback;
236   uint32_t i;
237   // Try the ObjectFile plug-ins
238   for (i = 0;
239        (callback =
240             PluginManager::GetObjectFileGetModuleSpecificationsCallbackAtIndex(
241                 i)) != nullptr;
242        ++i) {
243     if (callback(file, data_sp, data_offset, file_offset, file_size, specs) > 0)
244       return specs.GetSize() - initial_count;
245   }
246 
247   // Try the ObjectContainer plug-ins
248   for (i = 0;
249        (callback = PluginManager::
250             GetObjectContainerGetModuleSpecificationsCallbackAtIndex(i)) !=
251        nullptr;
252        ++i) {
253     if (callback(file, data_sp, data_offset, file_offset, file_size, specs) > 0)
254       return specs.GetSize() - initial_count;
255   }
256   return 0;
257 }
258 
259 ObjectFile::ObjectFile(const lldb::ModuleSP &module_sp,
260                        const FileSpec *file_spec_ptr,
261                        lldb::offset_t file_offset, lldb::offset_t length,
262                        const lldb::DataBufferSP &data_sp,
263                        lldb::offset_t data_offset)
264     : ModuleChild(module_sp),
265       m_file(), // This file could be different from the original module's file
266       m_type(eTypeInvalid), m_strata(eStrataInvalid),
267       m_file_offset(file_offset), m_length(length), m_data(),
268       m_unwind_table(*this), m_process_wp(),
269       m_memory_addr(LLDB_INVALID_ADDRESS), m_sections_ap(), m_symtab_ap(),
270       m_synthetic_symbol_idx(0) {
271   if (file_spec_ptr)
272     m_file = *file_spec_ptr;
273   if (data_sp)
274     m_data.SetData(data_sp, data_offset, length);
275   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
276   if (log)
277     log->Printf("%p ObjectFile::ObjectFile() module = %p (%s), file = %s, "
278                 "file_offset = 0x%8.8" PRIx64 ", size = %" PRIu64,
279                 static_cast<void *>(this), static_cast<void *>(module_sp.get()),
280                 module_sp->GetSpecificationDescription().c_str(),
281                 m_file ? m_file.GetPath().c_str() : "<NULL>", m_file_offset,
282                 m_length);
283 }
284 
285 ObjectFile::ObjectFile(const lldb::ModuleSP &module_sp,
286                        const ProcessSP &process_sp, lldb::addr_t header_addr,
287                        DataBufferSP &header_data_sp)
288     : ModuleChild(module_sp), m_file(), m_type(eTypeInvalid),
289       m_strata(eStrataInvalid), m_file_offset(0), m_length(0), m_data(),
290       m_unwind_table(*this), m_process_wp(process_sp),
291       m_memory_addr(header_addr), m_sections_ap(), m_symtab_ap(),
292       m_synthetic_symbol_idx(0) {
293   if (header_data_sp)
294     m_data.SetData(header_data_sp, 0, header_data_sp->GetByteSize());
295   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
296   if (log)
297     log->Printf("%p ObjectFile::ObjectFile() module = %p (%s), process = %p, "
298                 "header_addr = 0x%" PRIx64,
299                 static_cast<void *>(this), static_cast<void *>(module_sp.get()),
300                 module_sp->GetSpecificationDescription().c_str(),
301                 static_cast<void *>(process_sp.get()), m_memory_addr);
302 }
303 
304 ObjectFile::~ObjectFile() {
305   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
306   if (log)
307     log->Printf("%p ObjectFile::~ObjectFile ()\n", static_cast<void *>(this));
308 }
309 
310 bool ObjectFile::SetModulesArchitecture(const ArchSpec &new_arch) {
311   ModuleSP module_sp(GetModule());
312   if (module_sp)
313     return module_sp->SetArchitecture(new_arch);
314   return false;
315 }
316 
317 AddressClass ObjectFile::GetAddressClass(addr_t file_addr) {
318   Symtab *symtab = GetSymtab();
319   if (symtab) {
320     Symbol *symbol = symtab->FindSymbolContainingFileAddress(file_addr);
321     if (symbol) {
322       if (symbol->ValueIsAddress()) {
323         const SectionSP section_sp(symbol->GetAddressRef().GetSection());
324         if (section_sp) {
325           const SectionType section_type = section_sp->GetType();
326           switch (section_type) {
327           case eSectionTypeInvalid:
328             return AddressClass::eUnknown;
329           case eSectionTypeCode:
330             return AddressClass::eCode;
331           case eSectionTypeContainer:
332             return AddressClass::eUnknown;
333           case eSectionTypeData:
334           case eSectionTypeDataCString:
335           case eSectionTypeDataCStringPointers:
336           case eSectionTypeDataSymbolAddress:
337           case eSectionTypeData4:
338           case eSectionTypeData8:
339           case eSectionTypeData16:
340           case eSectionTypeDataPointers:
341           case eSectionTypeZeroFill:
342           case eSectionTypeDataObjCMessageRefs:
343           case eSectionTypeDataObjCCFStrings:
344           case eSectionTypeGoSymtab:
345             return AddressClass::eData;
346           case eSectionTypeDebug:
347           case eSectionTypeDWARFDebugAbbrev:
348           case eSectionTypeDWARFDebugAbbrevDwo:
349           case eSectionTypeDWARFDebugAddr:
350           case eSectionTypeDWARFDebugAranges:
351           case eSectionTypeDWARFDebugCuIndex:
352           case eSectionTypeDWARFDebugFrame:
353           case eSectionTypeDWARFDebugInfo:
354           case eSectionTypeDWARFDebugInfoDwo:
355           case eSectionTypeDWARFDebugLine:
356           case eSectionTypeDWARFDebugLineStr:
357           case eSectionTypeDWARFDebugLoc:
358           case eSectionTypeDWARFDebugLocLists:
359           case eSectionTypeDWARFDebugMacInfo:
360           case eSectionTypeDWARFDebugMacro:
361           case eSectionTypeDWARFDebugNames:
362           case eSectionTypeDWARFDebugPubNames:
363           case eSectionTypeDWARFDebugPubTypes:
364           case eSectionTypeDWARFDebugRanges:
365           case eSectionTypeDWARFDebugRngLists:
366           case eSectionTypeDWARFDebugStr:
367           case eSectionTypeDWARFDebugStrDwo:
368           case eSectionTypeDWARFDebugStrOffsets:
369           case eSectionTypeDWARFDebugStrOffsetsDwo:
370           case eSectionTypeDWARFDebugTypes:
371           case eSectionTypeDWARFAppleNames:
372           case eSectionTypeDWARFAppleTypes:
373           case eSectionTypeDWARFAppleNamespaces:
374           case eSectionTypeDWARFAppleObjC:
375           case eSectionTypeDWARFGNUDebugAltLink:
376             return AddressClass::eDebug;
377           case eSectionTypeEHFrame:
378           case eSectionTypeARMexidx:
379           case eSectionTypeARMextab:
380           case eSectionTypeCompactUnwind:
381             return AddressClass::eRuntime;
382           case eSectionTypeELFSymbolTable:
383           case eSectionTypeELFDynamicSymbols:
384           case eSectionTypeELFRelocationEntries:
385           case eSectionTypeELFDynamicLinkInfo:
386           case eSectionTypeOther:
387             return AddressClass::eUnknown;
388           case eSectionTypeAbsoluteAddress:
389             // In case of absolute sections decide the address class based on
390             // the symbol type because the section type isn't specify if it is
391             // a code or a data section.
392             break;
393           }
394         }
395       }
396 
397       const SymbolType symbol_type = symbol->GetType();
398       switch (symbol_type) {
399       case eSymbolTypeAny:
400         return AddressClass::eUnknown;
401       case eSymbolTypeAbsolute:
402         return AddressClass::eUnknown;
403       case eSymbolTypeCode:
404         return AddressClass::eCode;
405       case eSymbolTypeTrampoline:
406         return AddressClass::eCode;
407       case eSymbolTypeResolver:
408         return AddressClass::eCode;
409       case eSymbolTypeData:
410         return AddressClass::eData;
411       case eSymbolTypeRuntime:
412         return AddressClass::eRuntime;
413       case eSymbolTypeException:
414         return AddressClass::eRuntime;
415       case eSymbolTypeSourceFile:
416         return AddressClass::eDebug;
417       case eSymbolTypeHeaderFile:
418         return AddressClass::eDebug;
419       case eSymbolTypeObjectFile:
420         return AddressClass::eDebug;
421       case eSymbolTypeCommonBlock:
422         return AddressClass::eDebug;
423       case eSymbolTypeBlock:
424         return AddressClass::eDebug;
425       case eSymbolTypeLocal:
426         return AddressClass::eData;
427       case eSymbolTypeParam:
428         return AddressClass::eData;
429       case eSymbolTypeVariable:
430         return AddressClass::eData;
431       case eSymbolTypeVariableType:
432         return AddressClass::eDebug;
433       case eSymbolTypeLineEntry:
434         return AddressClass::eDebug;
435       case eSymbolTypeLineHeader:
436         return AddressClass::eDebug;
437       case eSymbolTypeScopeBegin:
438         return AddressClass::eDebug;
439       case eSymbolTypeScopeEnd:
440         return AddressClass::eDebug;
441       case eSymbolTypeAdditional:
442         return AddressClass::eUnknown;
443       case eSymbolTypeCompiler:
444         return AddressClass::eDebug;
445       case eSymbolTypeInstrumentation:
446         return AddressClass::eDebug;
447       case eSymbolTypeUndefined:
448         return AddressClass::eUnknown;
449       case eSymbolTypeObjCClass:
450         return AddressClass::eRuntime;
451       case eSymbolTypeObjCMetaClass:
452         return AddressClass::eRuntime;
453       case eSymbolTypeObjCIVar:
454         return AddressClass::eRuntime;
455       case eSymbolTypeReExported:
456         return AddressClass::eRuntime;
457       }
458     }
459   }
460   return AddressClass::eUnknown;
461 }
462 
463 DataBufferSP ObjectFile::ReadMemory(const ProcessSP &process_sp,
464                                     lldb::addr_t addr, size_t byte_size) {
465   DataBufferSP data_sp;
466   if (process_sp) {
467     std::unique_ptr<DataBufferHeap> data_ap(new DataBufferHeap(byte_size, 0));
468     Status error;
469     const size_t bytes_read = process_sp->ReadMemory(
470         addr, data_ap->GetBytes(), data_ap->GetByteSize(), error);
471     if (bytes_read == byte_size)
472       data_sp.reset(data_ap.release());
473   }
474   return data_sp;
475 }
476 
477 size_t ObjectFile::GetData(lldb::offset_t offset, size_t length,
478                            DataExtractor &data) const {
479   // The entire file has already been mmap'ed into m_data, so just copy from
480   // there as the back mmap buffer will be shared with shared pointers.
481   return data.SetData(m_data, offset, length);
482 }
483 
484 size_t ObjectFile::CopyData(lldb::offset_t offset, size_t length,
485                             void *dst) const {
486   // The entire file has already been mmap'ed into m_data, so just copy from
487   // there Note that the data remains in target byte order.
488   return m_data.CopyData(offset, length, dst);
489 }
490 
491 size_t ObjectFile::ReadSectionData(Section *section,
492                                    lldb::offset_t section_offset, void *dst,
493                                    size_t dst_len) {
494   assert(section);
495   section_offset *= section->GetTargetByteSize();
496 
497   // If some other objectfile owns this data, pass this to them.
498   if (section->GetObjectFile() != this)
499     return section->GetObjectFile()->ReadSectionData(section, section_offset,
500                                                      dst, dst_len);
501 
502   if (IsInMemory()) {
503     ProcessSP process_sp(m_process_wp.lock());
504     if (process_sp) {
505       Status error;
506       const addr_t base_load_addr =
507           section->GetLoadBaseAddress(&process_sp->GetTarget());
508       if (base_load_addr != LLDB_INVALID_ADDRESS)
509         return process_sp->ReadMemory(base_load_addr + section_offset, dst,
510                                       dst_len, error);
511     }
512   } else {
513     if (!section->IsRelocated())
514       RelocateSection(section);
515 
516     const lldb::offset_t section_file_size = section->GetFileSize();
517     if (section_offset < section_file_size) {
518       const size_t section_bytes_left = section_file_size - section_offset;
519       size_t section_dst_len = dst_len;
520       if (section_dst_len > section_bytes_left)
521         section_dst_len = section_bytes_left;
522       return CopyData(section->GetFileOffset() + section_offset,
523                       section_dst_len, dst);
524     } else {
525       if (section->GetType() == eSectionTypeZeroFill) {
526         const uint64_t section_size = section->GetByteSize();
527         const uint64_t section_bytes_left = section_size - section_offset;
528         uint64_t section_dst_len = dst_len;
529         if (section_dst_len > section_bytes_left)
530           section_dst_len = section_bytes_left;
531         memset(dst, 0, section_dst_len);
532         return section_dst_len;
533       }
534     }
535   }
536   return 0;
537 }
538 
539 //----------------------------------------------------------------------
540 // Get the section data the file on disk
541 //----------------------------------------------------------------------
542 size_t ObjectFile::ReadSectionData(Section *section,
543                                    DataExtractor &section_data) {
544   // If some other objectfile owns this data, pass this to them.
545   if (section->GetObjectFile() != this)
546     return section->GetObjectFile()->ReadSectionData(section, section_data);
547 
548   if (IsInMemory()) {
549     ProcessSP process_sp(m_process_wp.lock());
550     if (process_sp) {
551       const addr_t base_load_addr =
552           section->GetLoadBaseAddress(&process_sp->GetTarget());
553       if (base_load_addr != LLDB_INVALID_ADDRESS) {
554         DataBufferSP data_sp(
555             ReadMemory(process_sp, base_load_addr, section->GetByteSize()));
556         if (data_sp) {
557           section_data.SetData(data_sp, 0, data_sp->GetByteSize());
558           section_data.SetByteOrder(process_sp->GetByteOrder());
559           section_data.SetAddressByteSize(process_sp->GetAddressByteSize());
560           return section_data.GetByteSize();
561         }
562       }
563     }
564     return GetData(section->GetFileOffset(), section->GetFileSize(),
565                    section_data);
566   } else {
567     // The object file now contains a full mmap'ed copy of the object file
568     // data, so just use this
569     if (!section->IsRelocated())
570       RelocateSection(section);
571 
572     return GetData(section->GetFileOffset(), section->GetFileSize(),
573                    section_data);
574   }
575 }
576 
577 bool ObjectFile::SplitArchivePathWithObject(const char *path_with_object,
578                                             FileSpec &archive_file,
579                                             ConstString &archive_object,
580                                             bool must_exist) {
581   RegularExpression g_object_regex(llvm::StringRef("(.*)\\(([^\\)]+)\\)$"));
582   RegularExpression::Match regex_match(2);
583   if (g_object_regex.Execute(llvm::StringRef::withNullAsEmpty(path_with_object),
584                              &regex_match)) {
585     std::string path;
586     std::string obj;
587     if (regex_match.GetMatchAtIndex(path_with_object, 1, path) &&
588         regex_match.GetMatchAtIndex(path_with_object, 2, obj)) {
589       archive_file.SetFile(path, FileSpec::Style::native);
590       archive_object.SetCString(obj.c_str());
591       if (must_exist && !FileSystem::Instance().Exists(archive_file))
592         return false;
593       return true;
594     }
595   }
596   return false;
597 }
598 
599 void ObjectFile::ClearSymtab() {
600   ModuleSP module_sp(GetModule());
601   if (module_sp) {
602     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
603     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
604     if (log)
605       log->Printf("%p ObjectFile::ClearSymtab () symtab = %p",
606                   static_cast<void *>(this),
607                   static_cast<void *>(m_symtab_ap.get()));
608     m_symtab_ap.reset();
609   }
610 }
611 
612 SectionList *ObjectFile::GetSectionList(bool update_module_section_list) {
613   if (m_sections_ap.get() == nullptr) {
614     if (update_module_section_list) {
615       ModuleSP module_sp(GetModule());
616       if (module_sp) {
617         std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
618         CreateSections(*module_sp->GetUnifiedSectionList());
619       }
620     } else {
621       SectionList unified_section_list;
622       CreateSections(unified_section_list);
623     }
624   }
625   return m_sections_ap.get();
626 }
627 
628 lldb::SymbolType
629 ObjectFile::GetSymbolTypeFromName(llvm::StringRef name,
630                                   lldb::SymbolType symbol_type_hint) {
631   if (!name.empty()) {
632     if (name.startswith("_OBJC_")) {
633       // ObjC
634       if (name.startswith("_OBJC_CLASS_$_"))
635         return lldb::eSymbolTypeObjCClass;
636       if (name.startswith("_OBJC_METACLASS_$_"))
637         return lldb::eSymbolTypeObjCMetaClass;
638       if (name.startswith("_OBJC_IVAR_$_"))
639         return lldb::eSymbolTypeObjCIVar;
640     } else if (name.startswith(".objc_class_name_")) {
641       // ObjC v1
642       return lldb::eSymbolTypeObjCClass;
643     }
644   }
645   return symbol_type_hint;
646 }
647 
648 ConstString ObjectFile::GetNextSyntheticSymbolName() {
649   StreamString ss;
650   ConstString file_name = GetModule()->GetFileSpec().GetFilename();
651   ss.Printf("___lldb_unnamed_symbol%u$$%s", ++m_synthetic_symbol_idx,
652             file_name.GetCString());
653   return ConstString(ss.GetString());
654 }
655 
656 std::vector<ObjectFile::LoadableData>
657 ObjectFile::GetLoadableData(Target &target) {
658   std::vector<LoadableData> loadables;
659   SectionList *section_list = GetSectionList();
660   if (!section_list)
661     return loadables;
662   // Create a list of loadable data from loadable sections
663   size_t section_count = section_list->GetNumSections(0);
664   for (size_t i = 0; i < section_count; ++i) {
665     LoadableData loadable;
666     SectionSP section_sp = section_list->GetSectionAtIndex(i);
667     loadable.Dest =
668         target.GetSectionLoadList().GetSectionLoadAddress(section_sp);
669     if (loadable.Dest == LLDB_INVALID_ADDRESS)
670       continue;
671     // We can skip sections like bss
672     if (section_sp->GetFileSize() == 0)
673       continue;
674     DataExtractor section_data;
675     section_sp->GetSectionData(section_data);
676     loadable.Contents = llvm::ArrayRef<uint8_t>(section_data.GetDataStart(),
677                                                 section_data.GetByteSize());
678     loadables.push_back(loadable);
679   }
680   return loadables;
681 }
682 
683 void ObjectFile::RelocateSection(lldb_private::Section *section)
684 {
685 }
686 
687 DataBufferSP ObjectFile::MapFileData(const FileSpec &file, uint64_t Size,
688                                      uint64_t Offset) {
689   return FileSystem::Instance().CreateDataBuffer(file.GetPath(), Size, Offset);
690 }
691