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