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
29using namespace lldb;
30using namespace lldb_private;
31
32char ObjectFile::ID;
33size_t ObjectFile::g_initial_bytes_to_read = 512;
34
35static ObjectFileSP
36CreateObjectFromContainer(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
52ObjectFileSP
53ObjectFile::FindPlugin(const lldb::ModuleSP &module_sp, const FileSpec *file,
54                       lldb::offset_t file_offset, lldb::offset_t file_size,
55                       DataBufferSP &data_sp, lldb::offset_t &data_offset) {
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
152ObjectFileSP 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
187size_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
212size_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
241ObjectFile::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
265ObjectFile::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
283ObjectFile::~ObjectFile() {
284  Log *log = GetLog(LLDBLog::Object);
285  LLDB_LOGF(log, "%p ObjectFile::~ObjectFile ()\n", static_cast<void *>(this));
286}
287
288bool 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
295AddressClass 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
448DataBufferSP 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
462size_t ObjectFile::GetData(lldb::offset_t offset, size_t length,
463                           DataExtractor &data) const {
464  // The entire file has already been mmap'ed into m_data, so just copy from
465  // there as the back mmap buffer will be shared with shared pointers.
466  return data.SetData(m_data, offset, length);
467}
468
469size_t ObjectFile::CopyData(lldb::offset_t offset, size_t length,
470                            void *dst) const {
471  // The entire file has already been mmap'ed into m_data, so just copy from
472  // there Note that the data remains in target byte order.
473  return m_data.CopyData(offset, length, dst);
474}
475
476size_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
525size_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
558bool ObjectFile::SplitArchivePathWithObject(llvm::StringRef path_with_object,
559                                            FileSpec &archive_file,
560                                            ConstString &archive_object,
561                                            bool must_exist) {
562  size_t len = path_with_object.size();
563  if (len < 2 || path_with_object.back() != ')')
564    return false;
565  llvm::StringRef archive = path_with_object.substr(0, path_with_object.rfind('('));
566  if (archive.empty())
567    return false;
568  llvm::StringRef object = path_with_object.substr(archive.size() + 1).drop_back();
569  archive_file.SetFile(archive, FileSpec::Style::native);
570  if (must_exist && !FileSystem::Instance().Exists(archive_file))
571    return false;
572  archive_object.SetString(object);
573  return true;
574}
575
576void 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
590SectionList *ObjectFile::GetSectionList(bool update_module_section_list) {
591  if (m_sections_up == nullptr) {
592    if (update_module_section_list) {
593      ModuleSP module_sp(GetModule());
594      if (module_sp) {
595        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
596        CreateSections(*module_sp->GetUnifiedSectionList());
597      }
598    } else {
599      SectionList unified_section_list;
600      CreateSections(unified_section_list);
601    }
602  }
603  return m_sections_up.get();
604}
605
606lldb::SymbolType
607ObjectFile::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
626std::vector<ObjectFile::LoadableData>
627ObjectFile::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
653std::unique_ptr<CallFrameInfo> ObjectFile::CreateCallFrameInfo() {
654  return {};
655}
656
657void ObjectFile::RelocateSection(lldb_private::Section *section)
658{
659}
660
661DataBufferSP ObjectFile::MapFileData(const FileSpec &file, uint64_t Size,
662                                     uint64_t Offset) {
663  return FileSystem::Instance().CreateDataBuffer(file.GetPath(), Size, Offset);
664}
665
666void llvm::format_provider<ObjectFile::Type>::format(
667    const ObjectFile::Type &type, raw_ostream &OS, StringRef Style) {
668  switch (type) {
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
702void 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
727Symtab *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
758uint32_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
767namespace llvm {
768namespace json {
769
770bool fromJSON(const llvm::json::Value &value,
771              lldb_private::ObjectFile::Type &type, llvm::json::Path path) {
772  if (auto str = value.getAsString()) {
773    type = llvm::StringSwitch<ObjectFile::Type>(*str)
774               .Case("corefile", ObjectFile::eTypeCoreFile)
775               .Case("executable", ObjectFile::eTypeExecutable)
776               .Case("debuginfo", ObjectFile::eTypeDebugInfo)
777               .Case("dynamiclinker", ObjectFile::eTypeDynamicLinker)
778               .Case("objectfile", ObjectFile::eTypeObjectFile)
779               .Case("sharedlibrary", ObjectFile::eTypeSharedLibrary)
780               .Case("stublibrary", ObjectFile::eTypeStubLibrary)
781               .Case("jit", ObjectFile::eTypeJIT)
782               .Case("unknown", ObjectFile::eTypeUnknown)
783               .Default(ObjectFile::eTypeInvalid);
784
785    if (type == ObjectFile::eTypeInvalid) {
786      path.report("invalid object type");
787      return false;
788    }
789
790    return true;
791  }
792  path.report("expected string");
793  return false;
794}
795} // namespace json
796} // namespace llvm
797