contrib/llvm/tools/lldb/source/Symbol/ObjectFile.cpp

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