[Lldb-commits] [lldb] r373778 - [MachO] Add early returns to save some indentation.

Jonas Devlieghere via lldb-commits lldb-commits at lists.llvm.org
Fri Oct 4 12:37:59 PDT 2019


Author: jdevlieghere
Date: Fri Oct  4 12:37:59 2019
New Revision: 373778

URL: http://llvm.org/viewvc/llvm-project?rev=373778&view=rev
Log:
[MachO] Add early returns to save some indentation.

This file really suffered from the Great Reformat. I'm adding a few
early returns to give the deeply nested code some more breathing room.

Modified:
    lldb/trunk/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

Modified: lldb/trunk/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp?rev=373778&r1=373777&r2=373778&view=diff
==============================================================================
--- lldb/trunk/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp (original)
+++ lldb/trunk/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp Fri Oct  4 12:37:59 2019
@@ -976,89 +976,89 @@ bool ObjectFileMachO::ParseHeader(DataEx
 
 bool ObjectFileMachO::ParseHeader() {
   ModuleSP module_sp(GetModule());
-  if (module_sp) {
-    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
-    bool can_parse = false;
-    lldb::offset_t offset = 0;
+  if (!module_sp)
+    return false;
+
+  std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
+  bool can_parse = false;
+  lldb::offset_t offset = 0;
+  m_data.SetByteOrder(endian::InlHostByteOrder());
+  // Leave magic in the original byte order
+  m_header.magic = m_data.GetU32(&offset);
+  switch (m_header.magic) {
+  case MH_MAGIC:
     m_data.SetByteOrder(endian::InlHostByteOrder());
-    // Leave magic in the original byte order
-    m_header.magic = m_data.GetU32(&offset);
-    switch (m_header.magic) {
-    case MH_MAGIC:
-      m_data.SetByteOrder(endian::InlHostByteOrder());
-      m_data.SetAddressByteSize(4);
-      can_parse = true;
-      break;
+    m_data.SetAddressByteSize(4);
+    can_parse = true;
+    break;
 
-    case MH_MAGIC_64:
-      m_data.SetByteOrder(endian::InlHostByteOrder());
-      m_data.SetAddressByteSize(8);
-      can_parse = true;
-      break;
+  case MH_MAGIC_64:
+    m_data.SetByteOrder(endian::InlHostByteOrder());
+    m_data.SetAddressByteSize(8);
+    can_parse = true;
+    break;
 
-    case MH_CIGAM:
-      m_data.SetByteOrder(endian::InlHostByteOrder() == eByteOrderBig
-                              ? eByteOrderLittle
-                              : eByteOrderBig);
-      m_data.SetAddressByteSize(4);
-      can_parse = true;
-      break;
+  case MH_CIGAM:
+    m_data.SetByteOrder(endian::InlHostByteOrder() == eByteOrderBig
+                            ? eByteOrderLittle
+                            : eByteOrderBig);
+    m_data.SetAddressByteSize(4);
+    can_parse = true;
+    break;
 
-    case MH_CIGAM_64:
-      m_data.SetByteOrder(endian::InlHostByteOrder() == eByteOrderBig
-                              ? eByteOrderLittle
-                              : eByteOrderBig);
-      m_data.SetAddressByteSize(8);
-      can_parse = true;
-      break;
+  case MH_CIGAM_64:
+    m_data.SetByteOrder(endian::InlHostByteOrder() == eByteOrderBig
+                            ? eByteOrderLittle
+                            : eByteOrderBig);
+    m_data.SetAddressByteSize(8);
+    can_parse = true;
+    break;
 
-    default:
-      break;
-    }
+  default:
+    break;
+  }
 
-    if (can_parse) {
-      m_data.GetU32(&offset, &m_header.cputype, 6);
+  if (can_parse) {
+    m_data.GetU32(&offset, &m_header.cputype, 6);
 
-      ModuleSpecList all_specs;
-      ModuleSpec base_spec;
-      GetAllArchSpecs(m_header, m_data, MachHeaderSizeFromMagic(m_header.magic),
-                      base_spec, all_specs);
-
-      for (unsigned i = 0, e = all_specs.GetSize(); i != e; ++i) {
-        ArchSpec mach_arch =
-            all_specs.GetModuleSpecRefAtIndex(i).GetArchitecture();
-
-        // Check if the module has a required architecture
-        const ArchSpec &module_arch = module_sp->GetArchitecture();
-        if (module_arch.IsValid() && !module_arch.IsCompatibleMatch(mach_arch))
-          continue;
+    ModuleSpecList all_specs;
+    ModuleSpec base_spec;
+    GetAllArchSpecs(m_header, m_data, MachHeaderSizeFromMagic(m_header.magic),
+                    base_spec, all_specs);
 
-        if (SetModulesArchitecture(mach_arch)) {
-          const size_t header_and_lc_size =
-              m_header.sizeofcmds + MachHeaderSizeFromMagic(m_header.magic);
-          if (m_data.GetByteSize() < header_and_lc_size) {
-            DataBufferSP data_sp;
-            ProcessSP process_sp(m_process_wp.lock());
-            if (process_sp) {
-              data_sp =
-                  ReadMemory(process_sp, m_memory_addr, header_and_lc_size);
-            } else {
-              // Read in all only the load command data from the file on disk
-              data_sp = MapFileData(m_file, header_and_lc_size, m_file_offset);
-              if (data_sp->GetByteSize() != header_and_lc_size)
-                continue;
-            }
-            if (data_sp)
-              m_data.SetData(data_sp);
+    for (unsigned i = 0, e = all_specs.GetSize(); i != e; ++i) {
+      ArchSpec mach_arch =
+          all_specs.GetModuleSpecRefAtIndex(i).GetArchitecture();
+
+      // Check if the module has a required architecture
+      const ArchSpec &module_arch = module_sp->GetArchitecture();
+      if (module_arch.IsValid() && !module_arch.IsCompatibleMatch(mach_arch))
+        continue;
+
+      if (SetModulesArchitecture(mach_arch)) {
+        const size_t header_and_lc_size =
+            m_header.sizeofcmds + MachHeaderSizeFromMagic(m_header.magic);
+        if (m_data.GetByteSize() < header_and_lc_size) {
+          DataBufferSP data_sp;
+          ProcessSP process_sp(m_process_wp.lock());
+          if (process_sp) {
+            data_sp = ReadMemory(process_sp, m_memory_addr, header_and_lc_size);
+          } else {
+            // Read in all only the load command data from the file on disk
+            data_sp = MapFileData(m_file, header_and_lc_size, m_file_offset);
+            if (data_sp->GetByteSize() != header_and_lc_size)
+              continue;
           }
+          if (data_sp)
+            m_data.SetData(data_sp);
         }
-        return true;
       }
-      // None found.
-      return false;
-    } else {
-      memset(&m_header, 0, sizeof(struct mach_header));
+      return true;
     }
+    // None found.
+    return false;
+  } else {
+    memset(&m_header, 0, sizeof(struct mach_header));
   }
   return false;
 }
@@ -1081,160 +1081,161 @@ uint32_t ObjectFileMachO::GetAddressByte
 
 AddressClass ObjectFileMachO::GetAddressClass(lldb::addr_t file_addr) {
   Symtab *symtab = GetSymtab();
-  if (symtab) {
-    Symbol *symbol = symtab->FindSymbolContainingFileAddress(file_addr);
-    if (symbol) {
-      if (symbol->ValueIsAddress()) {
-        SectionSP section_sp(symbol->GetAddressRef().GetSection());
-        if (section_sp) {
-          const lldb::SectionType section_type = section_sp->GetType();
-          switch (section_type) {
-          case eSectionTypeInvalid:
-            return AddressClass::eUnknown;
-
-          case eSectionTypeCode:
-            if (m_header.cputype == llvm::MachO::CPU_TYPE_ARM) {
-              // For ARM we have a bit in the n_desc field of the symbol that
-              // tells us ARM/Thumb which is bit 0x0008.
-              if (symbol->GetFlags() & MACHO_NLIST_ARM_SYMBOL_IS_THUMB)
-                return AddressClass::eCodeAlternateISA;
-            }
-            return AddressClass::eCode;
+  if (!symtab)
+    return AddressClass::eUnknown;
 
-          case eSectionTypeContainer:
-            return AddressClass::eUnknown;
-
-          case eSectionTypeData:
-          case eSectionTypeDataCString:
-          case eSectionTypeDataCStringPointers:
-          case eSectionTypeDataSymbolAddress:
-          case eSectionTypeData4:
-          case eSectionTypeData8:
-          case eSectionTypeData16:
-          case eSectionTypeDataPointers:
-          case eSectionTypeZeroFill:
-          case eSectionTypeDataObjCMessageRefs:
-          case eSectionTypeDataObjCCFStrings:
-          case eSectionTypeGoSymtab:
-            return AddressClass::eData;
-
-          case eSectionTypeDebug:
-          case eSectionTypeDWARFDebugAbbrev:
-          case eSectionTypeDWARFDebugAbbrevDwo:
-          case eSectionTypeDWARFDebugAddr:
-          case eSectionTypeDWARFDebugAranges:
-          case eSectionTypeDWARFDebugCuIndex:
-          case eSectionTypeDWARFDebugFrame:
-          case eSectionTypeDWARFDebugInfo:
-          case eSectionTypeDWARFDebugInfoDwo:
-          case eSectionTypeDWARFDebugLine:
-          case eSectionTypeDWARFDebugLineStr:
-          case eSectionTypeDWARFDebugLoc:
-          case eSectionTypeDWARFDebugLocLists:
-          case eSectionTypeDWARFDebugMacInfo:
-          case eSectionTypeDWARFDebugMacro:
-          case eSectionTypeDWARFDebugNames:
-          case eSectionTypeDWARFDebugPubNames:
-          case eSectionTypeDWARFDebugPubTypes:
-          case eSectionTypeDWARFDebugRanges:
-          case eSectionTypeDWARFDebugRngLists:
-          case eSectionTypeDWARFDebugStr:
-          case eSectionTypeDWARFDebugStrDwo:
-          case eSectionTypeDWARFDebugStrOffsets:
-          case eSectionTypeDWARFDebugStrOffsetsDwo:
-          case eSectionTypeDWARFDebugTypes:
-          case eSectionTypeDWARFDebugTypesDwo:
-          case eSectionTypeDWARFAppleNames:
-          case eSectionTypeDWARFAppleTypes:
-          case eSectionTypeDWARFAppleNamespaces:
-          case eSectionTypeDWARFAppleObjC:
-          case eSectionTypeDWARFGNUDebugAltLink:
-            return AddressClass::eDebug;
-
-          case eSectionTypeEHFrame:
-          case eSectionTypeARMexidx:
-          case eSectionTypeARMextab:
-          case eSectionTypeCompactUnwind:
-            return AddressClass::eRuntime;
-
-          case eSectionTypeAbsoluteAddress:
-          case eSectionTypeELFSymbolTable:
-          case eSectionTypeELFDynamicSymbols:
-          case eSectionTypeELFRelocationEntries:
-          case eSectionTypeELFDynamicLinkInfo:
-          case eSectionTypeOther:
-            return AddressClass::eUnknown;
-          }
-        }
-      }
-
-      const SymbolType symbol_type = symbol->GetType();
-      switch (symbol_type) {
-      case eSymbolTypeAny:
-        return AddressClass::eUnknown;
-      case eSymbolTypeAbsolute:
-        return AddressClass::eUnknown;
-
-      case eSymbolTypeCode:
-      case eSymbolTypeTrampoline:
-      case eSymbolTypeResolver:
-        if (m_header.cputype == llvm::MachO::CPU_TYPE_ARM) {
-          // For ARM we have a bit in the n_desc field of the symbol that tells
-          // us ARM/Thumb which is bit 0x0008.
-          if (symbol->GetFlags() & MACHO_NLIST_ARM_SYMBOL_IS_THUMB)
-            return AddressClass::eCodeAlternateISA;
-        }
-        return AddressClass::eCode;
-
-      case eSymbolTypeData:
-        return AddressClass::eData;
-      case eSymbolTypeRuntime:
-        return AddressClass::eRuntime;
-      case eSymbolTypeException:
-        return AddressClass::eRuntime;
-      case eSymbolTypeSourceFile:
-        return AddressClass::eDebug;
-      case eSymbolTypeHeaderFile:
-        return AddressClass::eDebug;
-      case eSymbolTypeObjectFile:
-        return AddressClass::eDebug;
-      case eSymbolTypeCommonBlock:
-        return AddressClass::eDebug;
-      case eSymbolTypeBlock:
-        return AddressClass::eDebug;
-      case eSymbolTypeLocal:
-        return AddressClass::eData;
-      case eSymbolTypeParam:
-        return AddressClass::eData;
-      case eSymbolTypeVariable:
-        return AddressClass::eData;
-      case eSymbolTypeVariableType:
-        return AddressClass::eDebug;
-      case eSymbolTypeLineEntry:
-        return AddressClass::eDebug;
-      case eSymbolTypeLineHeader:
-        return AddressClass::eDebug;
-      case eSymbolTypeScopeBegin:
-        return AddressClass::eDebug;
-      case eSymbolTypeScopeEnd:
-        return AddressClass::eDebug;
-      case eSymbolTypeAdditional:
-        return AddressClass::eUnknown;
-      case eSymbolTypeCompiler:
-        return AddressClass::eDebug;
-      case eSymbolTypeInstrumentation:
-        return AddressClass::eDebug;
-      case eSymbolTypeUndefined:
-        return AddressClass::eUnknown;
-      case eSymbolTypeObjCClass:
-        return AddressClass::eRuntime;
-      case eSymbolTypeObjCMetaClass:
-        return AddressClass::eRuntime;
-      case eSymbolTypeObjCIVar:
-        return AddressClass::eRuntime;
-      case eSymbolTypeReExported:
-        return AddressClass::eRuntime;
-      }
+  Symbol *symbol = symtab->FindSymbolContainingFileAddress(file_addr);
+  if (symbol) {
+    if (symbol->ValueIsAddress()) {
+      SectionSP section_sp(symbol->GetAddressRef().GetSection());
+      if (section_sp) {
+        const lldb::SectionType section_type = section_sp->GetType();
+        switch (section_type) {
+        case eSectionTypeInvalid:
+          return AddressClass::eUnknown;
+
+        case eSectionTypeCode:
+          if (m_header.cputype == llvm::MachO::CPU_TYPE_ARM) {
+            // For ARM we have a bit in the n_desc field of the symbol that
+            // tells us ARM/Thumb which is bit 0x0008.
+            if (symbol->GetFlags() & MACHO_NLIST_ARM_SYMBOL_IS_THUMB)
+              return AddressClass::eCodeAlternateISA;
+          }
+          return AddressClass::eCode;
+
+        case eSectionTypeContainer:
+          return AddressClass::eUnknown;
+
+        case eSectionTypeData:
+        case eSectionTypeDataCString:
+        case eSectionTypeDataCStringPointers:
+        case eSectionTypeDataSymbolAddress:
+        case eSectionTypeData4:
+        case eSectionTypeData8:
+        case eSectionTypeData16:
+        case eSectionTypeDataPointers:
+        case eSectionTypeZeroFill:
+        case eSectionTypeDataObjCMessageRefs:
+        case eSectionTypeDataObjCCFStrings:
+        case eSectionTypeGoSymtab:
+          return AddressClass::eData;
+
+        case eSectionTypeDebug:
+        case eSectionTypeDWARFDebugAbbrev:
+        case eSectionTypeDWARFDebugAbbrevDwo:
+        case eSectionTypeDWARFDebugAddr:
+        case eSectionTypeDWARFDebugAranges:
+        case eSectionTypeDWARFDebugCuIndex:
+        case eSectionTypeDWARFDebugFrame:
+        case eSectionTypeDWARFDebugInfo:
+        case eSectionTypeDWARFDebugInfoDwo:
+        case eSectionTypeDWARFDebugLine:
+        case eSectionTypeDWARFDebugLineStr:
+        case eSectionTypeDWARFDebugLoc:
+        case eSectionTypeDWARFDebugLocLists:
+        case eSectionTypeDWARFDebugMacInfo:
+        case eSectionTypeDWARFDebugMacro:
+        case eSectionTypeDWARFDebugNames:
+        case eSectionTypeDWARFDebugPubNames:
+        case eSectionTypeDWARFDebugPubTypes:
+        case eSectionTypeDWARFDebugRanges:
+        case eSectionTypeDWARFDebugRngLists:
+        case eSectionTypeDWARFDebugStr:
+        case eSectionTypeDWARFDebugStrDwo:
+        case eSectionTypeDWARFDebugStrOffsets:
+        case eSectionTypeDWARFDebugStrOffsetsDwo:
+        case eSectionTypeDWARFDebugTypes:
+        case eSectionTypeDWARFDebugTypesDwo:
+        case eSectionTypeDWARFAppleNames:
+        case eSectionTypeDWARFAppleTypes:
+        case eSectionTypeDWARFAppleNamespaces:
+        case eSectionTypeDWARFAppleObjC:
+        case eSectionTypeDWARFGNUDebugAltLink:
+          return AddressClass::eDebug;
+
+        case eSectionTypeEHFrame:
+        case eSectionTypeARMexidx:
+        case eSectionTypeARMextab:
+        case eSectionTypeCompactUnwind:
+          return AddressClass::eRuntime;
+
+        case eSectionTypeAbsoluteAddress:
+        case eSectionTypeELFSymbolTable:
+        case eSectionTypeELFDynamicSymbols:
+        case eSectionTypeELFRelocationEntries:
+        case eSectionTypeELFDynamicLinkInfo:
+        case eSectionTypeOther:
+          return AddressClass::eUnknown;
+        }
+      }
+    }
+
+    const SymbolType symbol_type = symbol->GetType();
+    switch (symbol_type) {
+    case eSymbolTypeAny:
+      return AddressClass::eUnknown;
+    case eSymbolTypeAbsolute:
+      return AddressClass::eUnknown;
+
+    case eSymbolTypeCode:
+    case eSymbolTypeTrampoline:
+    case eSymbolTypeResolver:
+      if (m_header.cputype == llvm::MachO::CPU_TYPE_ARM) {
+        // For ARM we have a bit in the n_desc field of the symbol that tells
+        // us ARM/Thumb which is bit 0x0008.
+        if (symbol->GetFlags() & MACHO_NLIST_ARM_SYMBOL_IS_THUMB)
+          return AddressClass::eCodeAlternateISA;
+      }
+      return AddressClass::eCode;
+
+    case eSymbolTypeData:
+      return AddressClass::eData;
+    case eSymbolTypeRuntime:
+      return AddressClass::eRuntime;
+    case eSymbolTypeException:
+      return AddressClass::eRuntime;
+    case eSymbolTypeSourceFile:
+      return AddressClass::eDebug;
+    case eSymbolTypeHeaderFile:
+      return AddressClass::eDebug;
+    case eSymbolTypeObjectFile:
+      return AddressClass::eDebug;
+    case eSymbolTypeCommonBlock:
+      return AddressClass::eDebug;
+    case eSymbolTypeBlock:
+      return AddressClass::eDebug;
+    case eSymbolTypeLocal:
+      return AddressClass::eData;
+    case eSymbolTypeParam:
+      return AddressClass::eData;
+    case eSymbolTypeVariable:
+      return AddressClass::eData;
+    case eSymbolTypeVariableType:
+      return AddressClass::eDebug;
+    case eSymbolTypeLineEntry:
+      return AddressClass::eDebug;
+    case eSymbolTypeLineHeader:
+      return AddressClass::eDebug;
+    case eSymbolTypeScopeBegin:
+      return AddressClass::eDebug;
+    case eSymbolTypeScopeEnd:
+      return AddressClass::eDebug;
+    case eSymbolTypeAdditional:
+      return AddressClass::eUnknown;
+    case eSymbolTypeCompiler:
+      return AddressClass::eDebug;
+    case eSymbolTypeInstrumentation:
+      return AddressClass::eDebug;
+    case eSymbolTypeUndefined:
+      return AddressClass::eUnknown;
+    case eSymbolTypeObjCClass:
+      return AddressClass::eRuntime;
+    case eSymbolTypeObjCMetaClass:
+      return AddressClass::eRuntime;
+    case eSymbolTypeObjCIVar:
+      return AddressClass::eRuntime;
+    case eSymbolTypeReExported:
+      return AddressClass::eRuntime;
     }
   }
   return AddressClass::eUnknown;
@@ -2145,2606 +2146,2552 @@ size_t ObjectFileMachO::ParseSymtab() {
     offset = cmd_offset + lc.cmdsize;
   }
 
-  if (symtab_load_command.cmd) {
-    Symtab *symtab = m_symtab_up.get();
-    SectionList *section_list = GetSectionList();
-    if (section_list == nullptr)
-      return 0;
+  if (!symtab_load_command.cmd)
+    return 0;
+
+  Symtab *symtab = m_symtab_up.get();
+  SectionList *section_list = GetSectionList();
+  if (section_list == nullptr)
+    return 0;
 
-    const uint32_t addr_byte_size = m_data.GetAddressByteSize();
-    const ByteOrder byte_order = m_data.GetByteOrder();
-    bool bit_width_32 = addr_byte_size == 4;
-    const size_t nlist_byte_size =
-        bit_width_32 ? sizeof(struct nlist) : sizeof(struct nlist_64);
-
-    DataExtractor nlist_data(nullptr, 0, byte_order, addr_byte_size);
-    DataExtractor strtab_data(nullptr, 0, byte_order, addr_byte_size);
-    DataExtractor function_starts_data(nullptr, 0, byte_order, addr_byte_size);
-    DataExtractor indirect_symbol_index_data(nullptr, 0, byte_order,
-                                             addr_byte_size);
-    DataExtractor dyld_trie_data(nullptr, 0, byte_order, addr_byte_size);
-
-    const addr_t nlist_data_byte_size =
-        symtab_load_command.nsyms * nlist_byte_size;
-    const addr_t strtab_data_byte_size = symtab_load_command.strsize;
-    addr_t strtab_addr = LLDB_INVALID_ADDRESS;
-
-    ProcessSP process_sp(m_process_wp.lock());
-    Process *process = process_sp.get();
-
-    uint32_t memory_module_load_level = eMemoryModuleLoadLevelComplete;
-
-    if (process && m_header.filetype != llvm::MachO::MH_OBJECT) {
-      Target &target = process->GetTarget();
-
-      memory_module_load_level = target.GetMemoryModuleLoadLevel();
-
-      SectionSP linkedit_section_sp(
-          section_list->FindSectionByName(GetSegmentNameLINKEDIT()));
-      // Reading mach file from memory in a process or core file...
-
-      if (linkedit_section_sp) {
-        addr_t linkedit_load_addr =
-            linkedit_section_sp->GetLoadBaseAddress(&target);
-        if (linkedit_load_addr == LLDB_INVALID_ADDRESS) {
-          // We might be trying to access the symbol table before the
-          // __LINKEDIT's load address has been set in the target. We can't
-          // fail to read the symbol table, so calculate the right address
-          // manually
-          linkedit_load_addr = CalculateSectionLoadAddressForMemoryImage(
-              m_memory_addr, GetMachHeaderSection(), linkedit_section_sp.get());
-        }
-
-        const addr_t linkedit_file_offset =
-            linkedit_section_sp->GetFileOffset();
-        const addr_t symoff_addr = linkedit_load_addr +
-                                   symtab_load_command.symoff -
-                                   linkedit_file_offset;
-        strtab_addr = linkedit_load_addr + symtab_load_command.stroff -
-                      linkedit_file_offset;
+  const uint32_t addr_byte_size = m_data.GetAddressByteSize();
+  const ByteOrder byte_order = m_data.GetByteOrder();
+  bool bit_width_32 = addr_byte_size == 4;
+  const size_t nlist_byte_size =
+      bit_width_32 ? sizeof(struct nlist) : sizeof(struct nlist_64);
+
+  DataExtractor nlist_data(nullptr, 0, byte_order, addr_byte_size);
+  DataExtractor strtab_data(nullptr, 0, byte_order, addr_byte_size);
+  DataExtractor function_starts_data(nullptr, 0, byte_order, addr_byte_size);
+  DataExtractor indirect_symbol_index_data(nullptr, 0, byte_order,
+                                           addr_byte_size);
+  DataExtractor dyld_trie_data(nullptr, 0, byte_order, addr_byte_size);
+
+  const addr_t nlist_data_byte_size =
+      symtab_load_command.nsyms * nlist_byte_size;
+  const addr_t strtab_data_byte_size = symtab_load_command.strsize;
+  addr_t strtab_addr = LLDB_INVALID_ADDRESS;
+
+  ProcessSP process_sp(m_process_wp.lock());
+  Process *process = process_sp.get();
+
+  uint32_t memory_module_load_level = eMemoryModuleLoadLevelComplete;
+
+  if (process && m_header.filetype != llvm::MachO::MH_OBJECT) {
+    Target &target = process->GetTarget();
+
+    memory_module_load_level = target.GetMemoryModuleLoadLevel();
+
+    SectionSP linkedit_section_sp(
+        section_list->FindSectionByName(GetSegmentNameLINKEDIT()));
+    // Reading mach file from memory in a process or core file...
+
+    if (linkedit_section_sp) {
+      addr_t linkedit_load_addr =
+          linkedit_section_sp->GetLoadBaseAddress(&target);
+      if (linkedit_load_addr == LLDB_INVALID_ADDRESS) {
+        // We might be trying to access the symbol table before the
+        // __LINKEDIT's load address has been set in the target. We can't
+        // fail to read the symbol table, so calculate the right address
+        // manually
+        linkedit_load_addr = CalculateSectionLoadAddressForMemoryImage(
+            m_memory_addr, GetMachHeaderSection(), linkedit_section_sp.get());
+      }
+
+      const addr_t linkedit_file_offset = linkedit_section_sp->GetFileOffset();
+      const addr_t symoff_addr = linkedit_load_addr +
+                                 symtab_load_command.symoff -
+                                 linkedit_file_offset;
+      strtab_addr = linkedit_load_addr + symtab_load_command.stroff -
+                    linkedit_file_offset;
 
-        bool data_was_read = false;
+      bool data_was_read = false;
 
 #if defined(__APPLE__) &&                                                      \
     (defined(__arm__) || defined(__arm64__) || defined(__aarch64__))
-        if (m_header.flags & 0x80000000u &&
-            process->GetAddressByteSize() == sizeof(void *)) {
-          // This mach-o memory file is in the dyld shared cache. If this
-          // program is not remote and this is iOS, then this process will
-          // share the same shared cache as the process we are debugging and we
-          // can read the entire __LINKEDIT from the address space in this
-          // process. This is a needed optimization that is used for local iOS
-          // debugging only since all shared libraries in the shared cache do
-          // not have corresponding files that exist in the file system of the
-          // device. They have been combined into a single file. This means we
-          // always have to load these files from memory. All of the symbol and
-          // string tables from all of the __LINKEDIT sections from the shared
-          // libraries in the shared cache have been merged into a single large
-          // symbol and string table. Reading all of this symbol and string
-          // table data across can slow down debug launch times, so we optimize
-          // this by reading the memory for the __LINKEDIT section from this
-          // process.
-
-          UUID lldb_shared_cache;
-          addr_t lldb_shared_cache_addr;
-          GetLLDBSharedCacheUUID(lldb_shared_cache_addr, lldb_shared_cache);
-          UUID process_shared_cache;
-          addr_t process_shared_cache_addr;
-          GetProcessSharedCacheUUID(process, process_shared_cache_addr,
-                                    process_shared_cache);
-          bool use_lldb_cache = true;
-          if (lldb_shared_cache.IsValid() && process_shared_cache.IsValid() &&
-              (lldb_shared_cache != process_shared_cache ||
-               process_shared_cache_addr != lldb_shared_cache_addr)) {
-            use_lldb_cache = false;
-          }
-
-          PlatformSP platform_sp(target.GetPlatform());
-          if (platform_sp && platform_sp->IsHost() && use_lldb_cache) {
-            data_was_read = true;
-            nlist_data.SetData((void *)symoff_addr, nlist_data_byte_size,
-                               eByteOrderLittle);
-            strtab_data.SetData((void *)strtab_addr, strtab_data_byte_size,
-                                eByteOrderLittle);
-            if (function_starts_load_command.cmd) {
-              const addr_t func_start_addr =
-                  linkedit_load_addr + function_starts_load_command.dataoff -
-                  linkedit_file_offset;
-              function_starts_data.SetData(
-                  (void *)func_start_addr,
-                  function_starts_load_command.datasize, eByteOrderLittle);
-            }
+      if (m_header.flags & 0x80000000u &&
+          process->GetAddressByteSize() == sizeof(void *)) {
+        // This mach-o memory file is in the dyld shared cache. If this
+        // program is not remote and this is iOS, then this process will
+        // share the same shared cache as the process we are debugging and we
+        // can read the entire __LINKEDIT from the address space in this
+        // process. This is a needed optimization that is used for local iOS
+        // debugging only since all shared libraries in the shared cache do
+        // not have corresponding files that exist in the file system of the
+        // device. They have been combined into a single file. This means we
+        // always have to load these files from memory. All of the symbol and
+        // string tables from all of the __LINKEDIT sections from the shared
+        // libraries in the shared cache have been merged into a single large
+        // symbol and string table. Reading all of this symbol and string
+        // table data across can slow down debug launch times, so we optimize
+        // this by reading the memory for the __LINKEDIT section from this
+        // process.
+
+        UUID lldb_shared_cache;
+        addr_t lldb_shared_cache_addr;
+        GetLLDBSharedCacheUUID(lldb_shared_cache_addr, lldb_shared_cache);
+        UUID process_shared_cache;
+        addr_t process_shared_cache_addr;
+        GetProcessSharedCacheUUID(process, process_shared_cache_addr,
+                                  process_shared_cache);
+        bool use_lldb_cache = true;
+        if (lldb_shared_cache.IsValid() && process_shared_cache.IsValid() &&
+            (lldb_shared_cache != process_shared_cache ||
+             process_shared_cache_addr != lldb_shared_cache_addr)) {
+          use_lldb_cache = false;
+        }
+
+        PlatformSP platform_sp(target.GetPlatform());
+        if (platform_sp && platform_sp->IsHost() && use_lldb_cache) {
+          data_was_read = true;
+          nlist_data.SetData((void *)symoff_addr, nlist_data_byte_size,
+                             eByteOrderLittle);
+          strtab_data.SetData((void *)strtab_addr, strtab_data_byte_size,
+                              eByteOrderLittle);
+          if (function_starts_load_command.cmd) {
+            const addr_t func_start_addr =
+                linkedit_load_addr + function_starts_load_command.dataoff -
+                linkedit_file_offset;
+            function_starts_data.SetData((void *)func_start_addr,
+                                         function_starts_load_command.datasize,
+                                         eByteOrderLittle);
           }
         }
+      }
 #endif
 
-        if (!data_was_read) {
-          // Always load dyld - the dynamic linker - from memory if we didn't
-          // find a binary anywhere else. lldb will not register
-          // dylib/framework/bundle loads/unloads if we don't have the dyld
-          // symbols, we force dyld to load from memory despite the user's
-          // target.memory-module-load-level setting.
-          if (memory_module_load_level == eMemoryModuleLoadLevelComplete ||
-              m_header.filetype == llvm::MachO::MH_DYLINKER) {
-            DataBufferSP nlist_data_sp(
-                ReadMemory(process_sp, symoff_addr, nlist_data_byte_size));
-            if (nlist_data_sp)
-              nlist_data.SetData(nlist_data_sp, 0,
-                                 nlist_data_sp->GetByteSize());
-            if (m_dysymtab.nindirectsyms != 0) {
-              const addr_t indirect_syms_addr = linkedit_load_addr +
-                                                m_dysymtab.indirectsymoff -
-                                                linkedit_file_offset;
-              DataBufferSP indirect_syms_data_sp(
-                  ReadMemory(process_sp, indirect_syms_addr,
-                             m_dysymtab.nindirectsyms * 4));
-              if (indirect_syms_data_sp)
-                indirect_symbol_index_data.SetData(
-                    indirect_syms_data_sp, 0,
-                    indirect_syms_data_sp->GetByteSize());
-              // If this binary is outside the shared cache,
-              // cache the string table.
-              // Binaries in the shared cache all share a giant string table,
-              // and we can't share the string tables across multiple
-              // ObjectFileMachO's, so we'd end up re-reading this mega-strtab
-              // for every binary in the shared cache - it would be a big perf
-              // problem. For binaries outside the shared cache, it's faster to
-              // read the entire strtab at once instead of piece-by-piece as we
-              // process the nlist records.
-              if ((m_header.flags & 0x80000000u) == 0) {
-                DataBufferSP strtab_data_sp(
-                    ReadMemory(process_sp, strtab_addr, strtab_data_byte_size));
-                if (strtab_data_sp) {
-                  strtab_data.SetData(strtab_data_sp, 0,
-                                      strtab_data_sp->GetByteSize());
-                }
+      if (!data_was_read) {
+        // Always load dyld - the dynamic linker - from memory if we didn't
+        // find a binary anywhere else. lldb will not register
+        // dylib/framework/bundle loads/unloads if we don't have the dyld
+        // symbols, we force dyld to load from memory despite the user's
+        // target.memory-module-load-level setting.
+        if (memory_module_load_level == eMemoryModuleLoadLevelComplete ||
+            m_header.filetype == llvm::MachO::MH_DYLINKER) {
+          DataBufferSP nlist_data_sp(
+              ReadMemory(process_sp, symoff_addr, nlist_data_byte_size));
+          if (nlist_data_sp)
+            nlist_data.SetData(nlist_data_sp, 0, nlist_data_sp->GetByteSize());
+          if (m_dysymtab.nindirectsyms != 0) {
+            const addr_t indirect_syms_addr = linkedit_load_addr +
+                                              m_dysymtab.indirectsymoff -
+                                              linkedit_file_offset;
+            DataBufferSP indirect_syms_data_sp(ReadMemory(
+                process_sp, indirect_syms_addr, m_dysymtab.nindirectsyms * 4));
+            if (indirect_syms_data_sp)
+              indirect_symbol_index_data.SetData(
+                  indirect_syms_data_sp, 0,
+                  indirect_syms_data_sp->GetByteSize());
+            // If this binary is outside the shared cache,
+            // cache the string table.
+            // Binaries in the shared cache all share a giant string table,
+            // and we can't share the string tables across multiple
+            // ObjectFileMachO's, so we'd end up re-reading this mega-strtab
+            // for every binary in the shared cache - it would be a big perf
+            // problem. For binaries outside the shared cache, it's faster to
+            // read the entire strtab at once instead of piece-by-piece as we
+            // process the nlist records.
+            if ((m_header.flags & 0x80000000u) == 0) {
+              DataBufferSP strtab_data_sp(
+                  ReadMemory(process_sp, strtab_addr, strtab_data_byte_size));
+              if (strtab_data_sp) {
+                strtab_data.SetData(strtab_data_sp, 0,
+                                    strtab_data_sp->GetByteSize());
               }
             }
           }
-          if (memory_module_load_level >= eMemoryModuleLoadLevelPartial) {
-            if (function_starts_load_command.cmd) {
-              const addr_t func_start_addr =
-                  linkedit_load_addr + function_starts_load_command.dataoff -
-                  linkedit_file_offset;
-              DataBufferSP func_start_data_sp(
-                  ReadMemory(process_sp, func_start_addr,
-                             function_starts_load_command.datasize));
-              if (func_start_data_sp)
-                function_starts_data.SetData(func_start_data_sp, 0,
-                                             func_start_data_sp->GetByteSize());
-            }
+        }
+        if (memory_module_load_level >= eMemoryModuleLoadLevelPartial) {
+          if (function_starts_load_command.cmd) {
+            const addr_t func_start_addr =
+                linkedit_load_addr + function_starts_load_command.dataoff -
+                linkedit_file_offset;
+            DataBufferSP func_start_data_sp(
+                ReadMemory(process_sp, func_start_addr,
+                           function_starts_load_command.datasize));
+            if (func_start_data_sp)
+              function_starts_data.SetData(func_start_data_sp, 0,
+                                           func_start_data_sp->GetByteSize());
           }
         }
       }
-    } else {
-      nlist_data.SetData(m_data, symtab_load_command.symoff,
-                         nlist_data_byte_size);
-      strtab_data.SetData(m_data, symtab_load_command.stroff,
-                          strtab_data_byte_size);
-
-      if (dyld_info.export_size > 0) {
-        dyld_trie_data.SetData(m_data, dyld_info.export_off,
-                               dyld_info.export_size);
-      }
-
-      if (m_dysymtab.nindirectsyms != 0) {
-        indirect_symbol_index_data.SetData(m_data, m_dysymtab.indirectsymoff,
-                                           m_dysymtab.nindirectsyms * 4);
-      }
-      if (function_starts_load_command.cmd) {
-        function_starts_data.SetData(m_data,
-                                     function_starts_load_command.dataoff,
-                                     function_starts_load_command.datasize);
-      }
+    }
+  } else {
+    nlist_data.SetData(m_data, symtab_load_command.symoff,
+                       nlist_data_byte_size);
+    strtab_data.SetData(m_data, symtab_load_command.stroff,
+                        strtab_data_byte_size);
+
+    if (dyld_info.export_size > 0) {
+      dyld_trie_data.SetData(m_data, dyld_info.export_off,
+                             dyld_info.export_size);
     }
 
-    if (nlist_data.GetByteSize() == 0 &&
-        memory_module_load_level == eMemoryModuleLoadLevelComplete) {
-      if (log)
-        module_sp->LogMessage(log, "failed to read nlist data");
-      return 0;
+    if (m_dysymtab.nindirectsyms != 0) {
+      indirect_symbol_index_data.SetData(m_data, m_dysymtab.indirectsymoff,
+                                         m_dysymtab.nindirectsyms * 4);
+    }
+    if (function_starts_load_command.cmd) {
+      function_starts_data.SetData(m_data, function_starts_load_command.dataoff,
+                                   function_starts_load_command.datasize);
     }
+  }
 
-    const bool have_strtab_data = strtab_data.GetByteSize() > 0;
-    if (!have_strtab_data) {
-      if (process) {
-        if (strtab_addr == LLDB_INVALID_ADDRESS) {
-          if (log)
-            module_sp->LogMessage(log, "failed to locate the strtab in memory");
-          return 0;
-        }
-      } else {
+  if (nlist_data.GetByteSize() == 0 &&
+      memory_module_load_level == eMemoryModuleLoadLevelComplete) {
+    if (log)
+      module_sp->LogMessage(log, "failed to read nlist data");
+    return 0;
+  }
+
+  const bool have_strtab_data = strtab_data.GetByteSize() > 0;
+  if (!have_strtab_data) {
+    if (process) {
+      if (strtab_addr == LLDB_INVALID_ADDRESS) {
         if (log)
-          module_sp->LogMessage(log, "failed to read strtab data");
+          module_sp->LogMessage(log, "failed to locate the strtab in memory");
         return 0;
       }
+    } else {
+      if (log)
+        module_sp->LogMessage(log, "failed to read strtab data");
+      return 0;
     }
+  }
 
-    ConstString g_segment_name_TEXT = GetSegmentNameTEXT();
-    ConstString g_segment_name_DATA = GetSegmentNameDATA();
-    ConstString g_segment_name_DATA_DIRTY = GetSegmentNameDATA_DIRTY();
-    ConstString g_segment_name_DATA_CONST = GetSegmentNameDATA_CONST();
-    ConstString g_segment_name_OBJC = GetSegmentNameOBJC();
-    ConstString g_section_name_eh_frame = GetSectionNameEHFrame();
-    SectionSP text_section_sp(
-        section_list->FindSectionByName(g_segment_name_TEXT));
-    SectionSP data_section_sp(
-        section_list->FindSectionByName(g_segment_name_DATA));
-    SectionSP data_dirty_section_sp(
-        section_list->FindSectionByName(g_segment_name_DATA_DIRTY));
-    SectionSP data_const_section_sp(
-        section_list->FindSectionByName(g_segment_name_DATA_CONST));
-    SectionSP objc_section_sp(
-        section_list->FindSectionByName(g_segment_name_OBJC));
-    SectionSP eh_frame_section_sp;
-    if (text_section_sp.get())
-      eh_frame_section_sp = text_section_sp->GetChildren().FindSectionByName(
-          g_section_name_eh_frame);
-    else
-      eh_frame_section_sp =
-          section_list->FindSectionByName(g_section_name_eh_frame);
-
-    const bool is_arm = (m_header.cputype == llvm::MachO::CPU_TYPE_ARM);
-
-    // lldb works best if it knows the start address of all functions in a
-    // module. Linker symbols or debug info are normally the best source of
-    // information for start addr / size but they may be stripped in a released
-    // binary. Two additional sources of information exist in Mach-O binaries:
-    //    LC_FUNCTION_STARTS - a list of ULEB128 encoded offsets of each
-    //    function's start address in the
-    //                         binary, relative to the text section.
-    //    eh_frame           - the eh_frame FDEs have the start addr & size of
-    //    each function
-    //  LC_FUNCTION_STARTS is the fastest source to read in, and is present on
-    //  all modern binaries.
-    //  Binaries built to run on older releases may need to use eh_frame
-    //  information.
-
-    if (text_section_sp && function_starts_data.GetByteSize()) {
-      FunctionStarts::Entry function_start_entry;
-      function_start_entry.data = false;
-      lldb::offset_t function_start_offset = 0;
-      function_start_entry.addr = text_section_sp->GetFileAddress();
-      uint64_t delta;
-      while ((delta = function_starts_data.GetULEB128(&function_start_offset)) >
-             0) {
-        // Now append the current entry
-        function_start_entry.addr += delta;
-        function_starts.Append(function_start_entry);
-      }
-    } else {
-      // If m_type is eTypeDebugInfo, then this is a dSYM - it will have the
-      // load command claiming an eh_frame but it doesn't actually have the
-      // eh_frame content.  And if we have a dSYM, we don't need to do any of
-      // this fill-in-the-missing-symbols works anyway - the debug info should
-      // give us all the functions in the module.
-      if (text_section_sp.get() && eh_frame_section_sp.get() &&
-          m_type != eTypeDebugInfo) {
-        DWARFCallFrameInfo eh_frame(*this, eh_frame_section_sp,
-                                    DWARFCallFrameInfo::EH);
-        DWARFCallFrameInfo::FunctionAddressAndSizeVector functions;
-        eh_frame.GetFunctionAddressAndSizeVector(functions);
-        addr_t text_base_addr = text_section_sp->GetFileAddress();
-        size_t count = functions.GetSize();
-        for (size_t i = 0; i < count; ++i) {
-          const DWARFCallFrameInfo::FunctionAddressAndSizeVector::Entry *func =
-              functions.GetEntryAtIndex(i);
-          if (func) {
-            FunctionStarts::Entry function_start_entry;
-            function_start_entry.addr = func->base - text_base_addr;
-            function_starts.Append(function_start_entry);
-          }
+  ConstString g_segment_name_TEXT = GetSegmentNameTEXT();
+  ConstString g_segment_name_DATA = GetSegmentNameDATA();
+  ConstString g_segment_name_DATA_DIRTY = GetSegmentNameDATA_DIRTY();
+  ConstString g_segment_name_DATA_CONST = GetSegmentNameDATA_CONST();
+  ConstString g_segment_name_OBJC = GetSegmentNameOBJC();
+  ConstString g_section_name_eh_frame = GetSectionNameEHFrame();
+  SectionSP text_section_sp(
+      section_list->FindSectionByName(g_segment_name_TEXT));
+  SectionSP data_section_sp(
+      section_list->FindSectionByName(g_segment_name_DATA));
+  SectionSP data_dirty_section_sp(
+      section_list->FindSectionByName(g_segment_name_DATA_DIRTY));
+  SectionSP data_const_section_sp(
+      section_list->FindSectionByName(g_segment_name_DATA_CONST));
+  SectionSP objc_section_sp(
+      section_list->FindSectionByName(g_segment_name_OBJC));
+  SectionSP eh_frame_section_sp;
+  if (text_section_sp.get())
+    eh_frame_section_sp = text_section_sp->GetChildren().FindSectionByName(
+        g_section_name_eh_frame);
+  else
+    eh_frame_section_sp =
+        section_list->FindSectionByName(g_section_name_eh_frame);
+
+  const bool is_arm = (m_header.cputype == llvm::MachO::CPU_TYPE_ARM);
+
+  // lldb works best if it knows the start address of all functions in a
+  // module. Linker symbols or debug info are normally the best source of
+  // information for start addr / size but they may be stripped in a released
+  // binary. Two additional sources of information exist in Mach-O binaries:
+  //    LC_FUNCTION_STARTS - a list of ULEB128 encoded offsets of each
+  //    function's start address in the
+  //                         binary, relative to the text section.
+  //    eh_frame           - the eh_frame FDEs have the start addr & size of
+  //    each function
+  //  LC_FUNCTION_STARTS is the fastest source to read in, and is present on
+  //  all modern binaries.
+  //  Binaries built to run on older releases may need to use eh_frame
+  //  information.
+
+  if (text_section_sp && function_starts_data.GetByteSize()) {
+    FunctionStarts::Entry function_start_entry;
+    function_start_entry.data = false;
+    lldb::offset_t function_start_offset = 0;
+    function_start_entry.addr = text_section_sp->GetFileAddress();
+    uint64_t delta;
+    while ((delta = function_starts_data.GetULEB128(&function_start_offset)) >
+           0) {
+      // Now append the current entry
+      function_start_entry.addr += delta;
+      function_starts.Append(function_start_entry);
+    }
+  } else {
+    // If m_type is eTypeDebugInfo, then this is a dSYM - it will have the
+    // load command claiming an eh_frame but it doesn't actually have the
+    // eh_frame content.  And if we have a dSYM, we don't need to do any of
+    // this fill-in-the-missing-symbols works anyway - the debug info should
+    // give us all the functions in the module.
+    if (text_section_sp.get() && eh_frame_section_sp.get() &&
+        m_type != eTypeDebugInfo) {
+      DWARFCallFrameInfo eh_frame(*this, eh_frame_section_sp,
+                                  DWARFCallFrameInfo::EH);
+      DWARFCallFrameInfo::FunctionAddressAndSizeVector functions;
+      eh_frame.GetFunctionAddressAndSizeVector(functions);
+      addr_t text_base_addr = text_section_sp->GetFileAddress();
+      size_t count = functions.GetSize();
+      for (size_t i = 0; i < count; ++i) {
+        const DWARFCallFrameInfo::FunctionAddressAndSizeVector::Entry *func =
+            functions.GetEntryAtIndex(i);
+        if (func) {
+          FunctionStarts::Entry function_start_entry;
+          function_start_entry.addr = func->base - text_base_addr;
+          function_starts.Append(function_start_entry);
         }
       }
     }
+  }
 
-    const size_t function_starts_count = function_starts.GetSize();
-
-    // For user process binaries (executables, dylibs, frameworks, bundles), if
-    // we don't have LC_FUNCTION_STARTS/eh_frame section in this binary, we're
-    // going to assume the binary has been stripped.  Don't allow assembly
-    // language instruction emulation because we don't know proper function
-    // start boundaries.
-    //
-    // For all other types of binaries (kernels, stand-alone bare board
-    // binaries, kexts), they may not have LC_FUNCTION_STARTS / eh_frame
-    // sections - we should not make any assumptions about them based on that.
-    if (function_starts_count == 0 && CalculateStrata() == eStrataUser) {
-      m_allow_assembly_emulation_unwind_plans = false;
-      Log *unwind_or_symbol_log(lldb_private::GetLogIfAnyCategoriesSet(
-          LIBLLDB_LOG_SYMBOLS | LIBLLDB_LOG_UNWIND));
-
-      if (unwind_or_symbol_log)
-        module_sp->LogMessage(
-            unwind_or_symbol_log,
-            "no LC_FUNCTION_STARTS, will not allow assembly profiled unwinds");
-    }
-
-    const user_id_t TEXT_eh_frame_sectID =
-        eh_frame_section_sp.get() ? eh_frame_section_sp->GetID()
-                                  : static_cast<user_id_t>(NO_SECT);
-
-    lldb::offset_t nlist_data_offset = 0;
-
-    uint32_t N_SO_index = UINT32_MAX;
-
-    MachSymtabSectionInfo section_info(section_list);
-    std::vector<uint32_t> N_FUN_indexes;
-    std::vector<uint32_t> N_NSYM_indexes;
-    std::vector<uint32_t> N_INCL_indexes;
-    std::vector<uint32_t> N_BRAC_indexes;
-    std::vector<uint32_t> N_COMM_indexes;
-    typedef std::multimap<uint64_t, uint32_t> ValueToSymbolIndexMap;
-    typedef std::map<uint32_t, uint32_t> NListIndexToSymbolIndexMap;
-    typedef std::map<const char *, uint32_t> ConstNameToSymbolIndexMap;
-    ValueToSymbolIndexMap N_FUN_addr_to_sym_idx;
-    ValueToSymbolIndexMap N_STSYM_addr_to_sym_idx;
-    ConstNameToSymbolIndexMap N_GSYM_name_to_sym_idx;
-    // Any symbols that get merged into another will get an entry in this map
-    // so we know
-    NListIndexToSymbolIndexMap m_nlist_idx_to_sym_idx;
-    uint32_t nlist_idx = 0;
-    Symbol *symbol_ptr = nullptr;
-
-    uint32_t sym_idx = 0;
-    Symbol *sym = nullptr;
-    size_t num_syms = 0;
-    std::string memory_symbol_name;
-    uint32_t unmapped_local_symbols_found = 0;
-
-    std::vector<TrieEntryWithOffset> trie_entries;
-    std::set<lldb::addr_t> resolver_addresses;
-
-    if (dyld_trie_data.GetByteSize() > 0) {
-      std::vector<llvm::StringRef> nameSlices;
-      ParseTrieEntries(dyld_trie_data, 0, is_arm, nameSlices,
-                       resolver_addresses, trie_entries);
-
-      ConstString text_segment_name("__TEXT");
-      SectionSP text_segment_sp =
-          GetSectionList()->FindSectionByName(text_segment_name);
-      if (text_segment_sp) {
-        const lldb::addr_t text_segment_file_addr =
-            text_segment_sp->GetFileAddress();
-        if (text_segment_file_addr != LLDB_INVALID_ADDRESS) {
-          for (auto &e : trie_entries)
-            e.entry.address += text_segment_file_addr;
-        }
+  const size_t function_starts_count = function_starts.GetSize();
+
+  // For user process binaries (executables, dylibs, frameworks, bundles), if
+  // we don't have LC_FUNCTION_STARTS/eh_frame section in this binary, we're
+  // going to assume the binary has been stripped.  Don't allow assembly
+  // language instruction emulation because we don't know proper function
+  // start boundaries.
+  //
+  // For all other types of binaries (kernels, stand-alone bare board
+  // binaries, kexts), they may not have LC_FUNCTION_STARTS / eh_frame
+  // sections - we should not make any assumptions about them based on that.
+  if (function_starts_count == 0 && CalculateStrata() == eStrataUser) {
+    m_allow_assembly_emulation_unwind_plans = false;
+    Log *unwind_or_symbol_log(lldb_private::GetLogIfAnyCategoriesSet(
+        LIBLLDB_LOG_SYMBOLS | LIBLLDB_LOG_UNWIND));
+
+    if (unwind_or_symbol_log)
+      module_sp->LogMessage(
+          unwind_or_symbol_log,
+          "no LC_FUNCTION_STARTS, will not allow assembly profiled unwinds");
+  }
+
+  const user_id_t TEXT_eh_frame_sectID = eh_frame_section_sp.get()
+                                             ? eh_frame_section_sp->GetID()
+                                             : static_cast<user_id_t>(NO_SECT);
+
+  lldb::offset_t nlist_data_offset = 0;
+
+  uint32_t N_SO_index = UINT32_MAX;
+
+  MachSymtabSectionInfo section_info(section_list);
+  std::vector<uint32_t> N_FUN_indexes;
+  std::vector<uint32_t> N_NSYM_indexes;
+  std::vector<uint32_t> N_INCL_indexes;
+  std::vector<uint32_t> N_BRAC_indexes;
+  std::vector<uint32_t> N_COMM_indexes;
+  typedef std::multimap<uint64_t, uint32_t> ValueToSymbolIndexMap;
+  typedef std::map<uint32_t, uint32_t> NListIndexToSymbolIndexMap;
+  typedef std::map<const char *, uint32_t> ConstNameToSymbolIndexMap;
+  ValueToSymbolIndexMap N_FUN_addr_to_sym_idx;
+  ValueToSymbolIndexMap N_STSYM_addr_to_sym_idx;
+  ConstNameToSymbolIndexMap N_GSYM_name_to_sym_idx;
+  // Any symbols that get merged into another will get an entry in this map
+  // so we know
+  NListIndexToSymbolIndexMap m_nlist_idx_to_sym_idx;
+  uint32_t nlist_idx = 0;
+  Symbol *symbol_ptr = nullptr;
+
+  uint32_t sym_idx = 0;
+  Symbol *sym = nullptr;
+  size_t num_syms = 0;
+  std::string memory_symbol_name;
+  uint32_t unmapped_local_symbols_found = 0;
+
+  std::vector<TrieEntryWithOffset> trie_entries;
+  std::set<lldb::addr_t> resolver_addresses;
+
+  if (dyld_trie_data.GetByteSize() > 0) {
+    std::vector<llvm::StringRef> nameSlices;
+    ParseTrieEntries(dyld_trie_data, 0, is_arm, nameSlices, resolver_addresses,
+                     trie_entries);
+
+    ConstString text_segment_name("__TEXT");
+    SectionSP text_segment_sp =
+        GetSectionList()->FindSectionByName(text_segment_name);
+    if (text_segment_sp) {
+      const lldb::addr_t text_segment_file_addr =
+          text_segment_sp->GetFileAddress();
+      if (text_segment_file_addr != LLDB_INVALID_ADDRESS) {
+        for (auto &e : trie_entries)
+          e.entry.address += text_segment_file_addr;
       }
     }
+  }
 
-    typedef std::set<ConstString> IndirectSymbols;
-    IndirectSymbols indirect_symbol_names;
+  typedef std::set<ConstString> IndirectSymbols;
+  IndirectSymbols indirect_symbol_names;
 
 #if defined(__APPLE__) &&                                                      \
     (defined(__arm__) || defined(__arm64__) || defined(__aarch64__))
 
-    // Some recent builds of the dyld_shared_cache (hereafter: DSC) have been
-    // optimized by moving LOCAL symbols out of the memory mapped portion of
-    // the DSC. The symbol information has all been retained, but it isn't
-    // available in the normal nlist data. However, there *are* duplicate
-    // entries of *some*
-    // LOCAL symbols in the normal nlist data. To handle this situation
-    // correctly, we must first attempt
-    // to parse any DSC unmapped symbol information. If we find any, we set a
-    // flag that tells the normal nlist parser to ignore all LOCAL symbols.
-
-    if (m_header.flags & 0x80000000u) {
-      // Before we can start mapping the DSC, we need to make certain the
-      // target process is actually using the cache we can find.
-
-      // Next we need to determine the correct path for the dyld shared cache.
-
-      ArchSpec header_arch;
-      GetArchitecture(header_arch);
-      char dsc_path[PATH_MAX];
-      char dsc_path_development[PATH_MAX];
-
-      snprintf(
-          dsc_path, sizeof(dsc_path), "%s%s%s",
-          "/System/Library/Caches/com.apple.dyld/", /* IPHONE_DYLD_SHARED_CACHE_DIR
-                                                     */
-          "dyld_shared_cache_", /* DYLD_SHARED_CACHE_BASE_NAME */
-          header_arch.GetArchitectureName());
-
-      snprintf(
-          dsc_path_development, sizeof(dsc_path), "%s%s%s%s",
-          "/System/Library/Caches/com.apple.dyld/", /* IPHONE_DYLD_SHARED_CACHE_DIR
-                                                     */
-          "dyld_shared_cache_", /* DYLD_SHARED_CACHE_BASE_NAME */
-          header_arch.GetArchitectureName(), ".development");
-
-      FileSpec dsc_nondevelopment_filespec(dsc_path);
-      FileSpec dsc_development_filespec(dsc_path_development);
-      FileSpec dsc_filespec;
-
-      UUID dsc_uuid;
-      UUID process_shared_cache_uuid;
-      addr_t process_shared_cache_base_addr;
-
-      if (process) {
-        GetProcessSharedCacheUUID(process, process_shared_cache_base_addr,
-                                  process_shared_cache_uuid);
-      }
-
-      // First see if we can find an exact match for the inferior process
-      // shared cache UUID in the development or non-development shared caches
-      // on disk.
-      if (process_shared_cache_uuid.IsValid()) {
-        if (FileSystem::Instance().Exists(dsc_development_filespec)) {
-          UUID dsc_development_uuid = GetSharedCacheUUID(
-              dsc_development_filespec, byte_order, addr_byte_size);
-          if (dsc_development_uuid.IsValid() &&
-              dsc_development_uuid == process_shared_cache_uuid) {
-            dsc_filespec = dsc_development_filespec;
-            dsc_uuid = dsc_development_uuid;
-          }
-        }
-        if (!dsc_uuid.IsValid() &&
-            FileSystem::Instance().Exists(dsc_nondevelopment_filespec)) {
-          UUID dsc_nondevelopment_uuid = GetSharedCacheUUID(
-              dsc_nondevelopment_filespec, byte_order, addr_byte_size);
-          if (dsc_nondevelopment_uuid.IsValid() &&
-              dsc_nondevelopment_uuid == process_shared_cache_uuid) {
-            dsc_filespec = dsc_nondevelopment_filespec;
-            dsc_uuid = dsc_nondevelopment_uuid;
-          }
-        }
-      }
-
-      // Failing a UUID match, prefer the development dyld_shared cache if both
-      // are present.
-      if (!FileSystem::Instance().Exists(dsc_filespec)) {
-        if (FileSystem::Instance().Exists(dsc_development_filespec)) {
+  // Some recent builds of the dyld_shared_cache (hereafter: DSC) have been
+  // optimized by moving LOCAL symbols out of the memory mapped portion of
+  // the DSC. The symbol information has all been retained, but it isn't
+  // available in the normal nlist data. However, there *are* duplicate
+  // entries of *some*
+  // LOCAL symbols in the normal nlist data. To handle this situation
+  // correctly, we must first attempt
+  // to parse any DSC unmapped symbol information. If we find any, we set a
+  // flag that tells the normal nlist parser to ignore all LOCAL symbols.
+
+  if (m_header.flags & 0x80000000u) {
+    // Before we can start mapping the DSC, we need to make certain the
+    // target process is actually using the cache we can find.
+
+    // Next we need to determine the correct path for the dyld shared cache.
+
+    ArchSpec header_arch;
+    GetArchitecture(header_arch);
+    char dsc_path[PATH_MAX];
+    char dsc_path_development[PATH_MAX];
+
+    snprintf(
+        dsc_path, sizeof(dsc_path), "%s%s%s",
+        "/System/Library/Caches/com.apple.dyld/", /* IPHONE_DYLD_SHARED_CACHE_DIR
+                                                   */
+        "dyld_shared_cache_", /* DYLD_SHARED_CACHE_BASE_NAME */
+        header_arch.GetArchitectureName());
+
+    snprintf(
+        dsc_path_development, sizeof(dsc_path), "%s%s%s%s",
+        "/System/Library/Caches/com.apple.dyld/", /* IPHONE_DYLD_SHARED_CACHE_DIR
+                                                   */
+        "dyld_shared_cache_", /* DYLD_SHARED_CACHE_BASE_NAME */
+        header_arch.GetArchitectureName(), ".development");
+
+    FileSpec dsc_nondevelopment_filespec(dsc_path);
+    FileSpec dsc_development_filespec(dsc_path_development);
+    FileSpec dsc_filespec;
+
+    UUID dsc_uuid;
+    UUID process_shared_cache_uuid;
+    addr_t process_shared_cache_base_addr;
+
+    if (process) {
+      GetProcessSharedCacheUUID(process, process_shared_cache_base_addr,
+                                process_shared_cache_uuid);
+    }
+
+    // First see if we can find an exact match for the inferior process
+    // shared cache UUID in the development or non-development shared caches
+    // on disk.
+    if (process_shared_cache_uuid.IsValid()) {
+      if (FileSystem::Instance().Exists(dsc_development_filespec)) {
+        UUID dsc_development_uuid = GetSharedCacheUUID(
+            dsc_development_filespec, byte_order, addr_byte_size);
+        if (dsc_development_uuid.IsValid() &&
+            dsc_development_uuid == process_shared_cache_uuid) {
           dsc_filespec = dsc_development_filespec;
-        } else {
+          dsc_uuid = dsc_development_uuid;
+        }
+      }
+      if (!dsc_uuid.IsValid() &&
+          FileSystem::Instance().Exists(dsc_nondevelopment_filespec)) {
+        UUID dsc_nondevelopment_uuid = GetSharedCacheUUID(
+            dsc_nondevelopment_filespec, byte_order, addr_byte_size);
+        if (dsc_nondevelopment_uuid.IsValid() &&
+            dsc_nondevelopment_uuid == process_shared_cache_uuid) {
           dsc_filespec = dsc_nondevelopment_filespec;
+          dsc_uuid = dsc_nondevelopment_uuid;
         }
       }
+    }
 
-      /* The dyld_cache_header has a pointer to the
-         dyld_cache_local_symbols_info structure (localSymbolsOffset).
-         The dyld_cache_local_symbols_info structure gives us three things:
-           1. The start and count of the nlist records in the dyld_shared_cache
-         file
-           2. The start and size of the strings for these nlist records
-           3. The start and count of dyld_cache_local_symbols_entry entries
-
-         There is one dyld_cache_local_symbols_entry per dylib/framework in the
-         dyld shared cache.
-         The "dylibOffset" field is the Mach-O header of this dylib/framework in
-         the dyld shared cache.
-         The dyld_cache_local_symbols_entry also lists the start of this
-         dylib/framework's nlist records
-         and the count of how many nlist records there are for this
-         dylib/framework.
-      */
-
-      // Process the dyld shared cache header to find the unmapped symbols
-
-      DataBufferSP dsc_data_sp = MapFileData(
-          dsc_filespec, sizeof(struct lldb_copy_dyld_cache_header_v1), 0);
-      if (!dsc_uuid.IsValid()) {
-        dsc_uuid = GetSharedCacheUUID(dsc_filespec, byte_order, addr_byte_size);
-      }
-      if (dsc_data_sp) {
-        DataExtractor dsc_header_data(dsc_data_sp, byte_order, addr_byte_size);
-
-        bool uuid_match = true;
-        if (dsc_uuid.IsValid() && process) {
-          if (process_shared_cache_uuid.IsValid() &&
-              dsc_uuid != process_shared_cache_uuid) {
-            // The on-disk dyld_shared_cache file is not the same as the one in
-            // this process' memory, don't use it.
-            uuid_match = false;
-            ModuleSP module_sp(GetModule());
-            if (module_sp)
-              module_sp->ReportWarning("process shared cache does not match "
-                                       "on-disk dyld_shared_cache file, some "
-                                       "symbol names will be missing.");
-          }
-        }
-
-        offset = offsetof(struct lldb_copy_dyld_cache_header_v1, mappingOffset);
-
-        uint32_t mappingOffset = dsc_header_data.GetU32(&offset);
-
-        // If the mappingOffset points to a location inside the header, we've
-        // opened an old dyld shared cache, and should not proceed further.
-        if (uuid_match &&
-            mappingOffset >= sizeof(struct lldb_copy_dyld_cache_header_v1)) {
-
-          DataBufferSP dsc_mapping_info_data_sp = MapFileData(
-              dsc_filespec, sizeof(struct lldb_copy_dyld_cache_mapping_info),
-              mappingOffset);
-
-          DataExtractor dsc_mapping_info_data(dsc_mapping_info_data_sp,
-                                              byte_order, addr_byte_size);
-          offset = 0;
-
-          // The File addresses (from the in-memory Mach-O load commands) for
-          // the shared libraries in the shared library cache need to be
-          // adjusted by an offset to match up with the dylibOffset identifying
-          // field in the dyld_cache_local_symbol_entry's.  This offset is
-          // recorded in mapping_offset_value.
-          const uint64_t mapping_offset_value =
-              dsc_mapping_info_data.GetU64(&offset);
-
-          offset = offsetof(struct lldb_copy_dyld_cache_header_v1,
-                            localSymbolsOffset);
-          uint64_t localSymbolsOffset = dsc_header_data.GetU64(&offset);
-          uint64_t localSymbolsSize = dsc_header_data.GetU64(&offset);
-
-          if (localSymbolsOffset && localSymbolsSize) {
-            // Map the local symbols
-            DataBufferSP dsc_local_symbols_data_sp =
-                MapFileData(dsc_filespec, localSymbolsSize, localSymbolsOffset);
-
-            if (dsc_local_symbols_data_sp) {
-              DataExtractor dsc_local_symbols_data(dsc_local_symbols_data_sp,
-                                                   byte_order, addr_byte_size);
-
-              offset = 0;
-
-              typedef std::map<ConstString, uint16_t> UndefinedNameToDescMap;
-              typedef std::map<uint32_t, ConstString> SymbolIndexToName;
-              UndefinedNameToDescMap undefined_name_to_desc;
-              SymbolIndexToName reexport_shlib_needs_fixup;
-
-              // Read the local_symbols_infos struct in one shot
-              struct lldb_copy_dyld_cache_local_symbols_info local_symbols_info;
-              dsc_local_symbols_data.GetU32(&offset,
-                                            &local_symbols_info.nlistOffset, 6);
-
-              SectionSP text_section_sp(
-                  section_list->FindSectionByName(GetSegmentNameTEXT()));
-
-              uint32_t header_file_offset =
-                  (text_section_sp->GetFileAddress() - mapping_offset_value);
-
-              offset = local_symbols_info.entriesOffset;
-              for (uint32_t entry_index = 0;
-                   entry_index < local_symbols_info.entriesCount;
-                   entry_index++) {
-                struct lldb_copy_dyld_cache_local_symbols_entry
-                    local_symbols_entry;
-                local_symbols_entry.dylibOffset =
-                    dsc_local_symbols_data.GetU32(&offset);
-                local_symbols_entry.nlistStartIndex =
-                    dsc_local_symbols_data.GetU32(&offset);
-                local_symbols_entry.nlistCount =
-                    dsc_local_symbols_data.GetU32(&offset);
-
-                if (header_file_offset == local_symbols_entry.dylibOffset) {
-                  unmapped_local_symbols_found = local_symbols_entry.nlistCount;
-
-                  // The normal nlist code cannot correctly size the Symbols
-                  // array, we need to allocate it here.
-                  sym = symtab->Resize(
-                      symtab_load_command.nsyms + m_dysymtab.nindirectsyms +
-                      unmapped_local_symbols_found - m_dysymtab.nlocalsym);
-                  num_syms = symtab->GetNumSymbols();
-
-                  nlist_data_offset =
-                      local_symbols_info.nlistOffset +
-                      (nlist_byte_size * local_symbols_entry.nlistStartIndex);
-                  uint32_t string_table_offset =
-                      local_symbols_info.stringsOffset;
-
-                  for (uint32_t nlist_index = 0;
-                       nlist_index < local_symbols_entry.nlistCount;
-                       nlist_index++) {
-                    /////////////////////////////
-                    {
-                      struct nlist_64 nlist;
-                      if (!dsc_local_symbols_data.ValidOffsetForDataOfSize(
-                              nlist_data_offset, nlist_byte_size))
-                        break;
+    // Failing a UUID match, prefer the development dyld_shared cache if both
+    // are present.
+    if (!FileSystem::Instance().Exists(dsc_filespec)) {
+      if (FileSystem::Instance().Exists(dsc_development_filespec)) {
+        dsc_filespec = dsc_development_filespec;
+      } else {
+        dsc_filespec = dsc_nondevelopment_filespec;
+      }
+    }
 
-                      nlist.n_strx = dsc_local_symbols_data.GetU32_unchecked(
-                          &nlist_data_offset);
-                      nlist.n_type = dsc_local_symbols_data.GetU8_unchecked(
-                          &nlist_data_offset);
-                      nlist.n_sect = dsc_local_symbols_data.GetU8_unchecked(
-                          &nlist_data_offset);
-                      nlist.n_desc = dsc_local_symbols_data.GetU16_unchecked(
-                          &nlist_data_offset);
-                      nlist.n_value =
-                          dsc_local_symbols_data.GetAddress_unchecked(
-                              &nlist_data_offset);
-
-                      SymbolType type = eSymbolTypeInvalid;
-                      const char *symbol_name = dsc_local_symbols_data.PeekCStr(
-                          string_table_offset + nlist.n_strx);
-
-                      if (symbol_name == NULL) {
-                        // No symbol should be NULL, even the symbols with no
-                        // string values should have an offset zero which
-                        // points to an empty C-string
-                        Host::SystemLog(
-                            Host::eSystemLogError,
-                            "error: DSC unmapped local symbol[%u] has invalid "
-                            "string table offset 0x%x in %s, ignoring symbol\n",
-                            entry_index, nlist.n_strx,
-                            module_sp->GetFileSpec().GetPath().c_str());
-                        continue;
-                      }
-                      if (symbol_name[0] == '\0')
-                        symbol_name = NULL;
+    /* The dyld_cache_header has a pointer to the
+       dyld_cache_local_symbols_info structure (localSymbolsOffset).
+       The dyld_cache_local_symbols_info structure gives us three things:
+         1. The start and count of the nlist records in the dyld_shared_cache
+       file
+         2. The start and size of the strings for these nlist records
+         3. The start and count of dyld_cache_local_symbols_entry entries
+
+       There is one dyld_cache_local_symbols_entry per dylib/framework in the
+       dyld shared cache.
+       The "dylibOffset" field is the Mach-O header of this dylib/framework in
+       the dyld shared cache.
+       The dyld_cache_local_symbols_entry also lists the start of this
+       dylib/framework's nlist records
+       and the count of how many nlist records there are for this
+       dylib/framework.
+    */
+
+    // Process the dyld shared cache header to find the unmapped symbols
+
+    DataBufferSP dsc_data_sp = MapFileData(
+        dsc_filespec, sizeof(struct lldb_copy_dyld_cache_header_v1), 0);
+    if (!dsc_uuid.IsValid()) {
+      dsc_uuid = GetSharedCacheUUID(dsc_filespec, byte_order, addr_byte_size);
+    }
+    if (dsc_data_sp) {
+      DataExtractor dsc_header_data(dsc_data_sp, byte_order, addr_byte_size);
+
+      bool uuid_match = true;
+      if (dsc_uuid.IsValid() && process) {
+        if (process_shared_cache_uuid.IsValid() &&
+            dsc_uuid != process_shared_cache_uuid) {
+          // The on-disk dyld_shared_cache file is not the same as the one in
+          // this process' memory, don't use it.
+          uuid_match = false;
+          ModuleSP module_sp(GetModule());
+          if (module_sp)
+            module_sp->ReportWarning("process shared cache does not match "
+                                     "on-disk dyld_shared_cache file, some "
+                                     "symbol names will be missing.");
+        }
+      }
+
+      offset = offsetof(struct lldb_copy_dyld_cache_header_v1, mappingOffset);
+
+      uint32_t mappingOffset = dsc_header_data.GetU32(&offset);
+
+      // If the mappingOffset points to a location inside the header, we've
+      // opened an old dyld shared cache, and should not proceed further.
+      if (uuid_match &&
+          mappingOffset >= sizeof(struct lldb_copy_dyld_cache_header_v1)) {
+
+        DataBufferSP dsc_mapping_info_data_sp = MapFileData(
+            dsc_filespec, sizeof(struct lldb_copy_dyld_cache_mapping_info),
+            mappingOffset);
+
+        DataExtractor dsc_mapping_info_data(dsc_mapping_info_data_sp,
+                                            byte_order, addr_byte_size);
+        offset = 0;
+
+        // The File addresses (from the in-memory Mach-O load commands) for
+        // the shared libraries in the shared library cache need to be
+        // adjusted by an offset to match up with the dylibOffset identifying
+        // field in the dyld_cache_local_symbol_entry's.  This offset is
+        // recorded in mapping_offset_value.
+        const uint64_t mapping_offset_value =
+            dsc_mapping_info_data.GetU64(&offset);
+
+        offset =
+            offsetof(struct lldb_copy_dyld_cache_header_v1, localSymbolsOffset);
+        uint64_t localSymbolsOffset = dsc_header_data.GetU64(&offset);
+        uint64_t localSymbolsSize = dsc_header_data.GetU64(&offset);
+
+        if (localSymbolsOffset && localSymbolsSize) {
+          // Map the local symbols
+          DataBufferSP dsc_local_symbols_data_sp =
+              MapFileData(dsc_filespec, localSymbolsSize, localSymbolsOffset);
+
+          if (dsc_local_symbols_data_sp) {
+            DataExtractor dsc_local_symbols_data(dsc_local_symbols_data_sp,
+                                                 byte_order, addr_byte_size);
+
+            offset = 0;
+
+            typedef std::map<ConstString, uint16_t> UndefinedNameToDescMap;
+            typedef std::map<uint32_t, ConstString> SymbolIndexToName;
+            UndefinedNameToDescMap undefined_name_to_desc;
+            SymbolIndexToName reexport_shlib_needs_fixup;
+
+            // Read the local_symbols_infos struct in one shot
+            struct lldb_copy_dyld_cache_local_symbols_info local_symbols_info;
+            dsc_local_symbols_data.GetU32(&offset,
+                                          &local_symbols_info.nlistOffset, 6);
+
+            SectionSP text_section_sp(
+                section_list->FindSectionByName(GetSegmentNameTEXT()));
+
+            uint32_t header_file_offset =
+                (text_section_sp->GetFileAddress() - mapping_offset_value);
+
+            offset = local_symbols_info.entriesOffset;
+            for (uint32_t entry_index = 0;
+                 entry_index < local_symbols_info.entriesCount; entry_index++) {
+              struct lldb_copy_dyld_cache_local_symbols_entry
+                  local_symbols_entry;
+              local_symbols_entry.dylibOffset =
+                  dsc_local_symbols_data.GetU32(&offset);
+              local_symbols_entry.nlistStartIndex =
+                  dsc_local_symbols_data.GetU32(&offset);
+              local_symbols_entry.nlistCount =
+                  dsc_local_symbols_data.GetU32(&offset);
+
+              if (header_file_offset == local_symbols_entry.dylibOffset) {
+                unmapped_local_symbols_found = local_symbols_entry.nlistCount;
+
+                // The normal nlist code cannot correctly size the Symbols
+                // array, we need to allocate it here.
+                sym = symtab->Resize(
+                    symtab_load_command.nsyms + m_dysymtab.nindirectsyms +
+                    unmapped_local_symbols_found - m_dysymtab.nlocalsym);
+                num_syms = symtab->GetNumSymbols();
+
+                nlist_data_offset =
+                    local_symbols_info.nlistOffset +
+                    (nlist_byte_size * local_symbols_entry.nlistStartIndex);
+                uint32_t string_table_offset = local_symbols_info.stringsOffset;
+
+                for (uint32_t nlist_index = 0;
+                     nlist_index < local_symbols_entry.nlistCount;
+                     nlist_index++) {
+                  /////////////////////////////
+                  {
+                    struct nlist_64 nlist;
+                    if (!dsc_local_symbols_data.ValidOffsetForDataOfSize(
+                            nlist_data_offset, nlist_byte_size))
+                      break;
+
+                    nlist.n_strx = dsc_local_symbols_data.GetU32_unchecked(
+                        &nlist_data_offset);
+                    nlist.n_type = dsc_local_symbols_data.GetU8_unchecked(
+                        &nlist_data_offset);
+                    nlist.n_sect = dsc_local_symbols_data.GetU8_unchecked(
+                        &nlist_data_offset);
+                    nlist.n_desc = dsc_local_symbols_data.GetU16_unchecked(
+                        &nlist_data_offset);
+                    nlist.n_value = dsc_local_symbols_data.GetAddress_unchecked(
+                        &nlist_data_offset);
+
+                    SymbolType type = eSymbolTypeInvalid;
+                    const char *symbol_name = dsc_local_symbols_data.PeekCStr(
+                        string_table_offset + nlist.n_strx);
+
+                    if (symbol_name == NULL) {
+                      // No symbol should be NULL, even the symbols with no
+                      // string values should have an offset zero which
+                      // points to an empty C-string
+                      Host::SystemLog(
+                          Host::eSystemLogError,
+                          "error: DSC unmapped local symbol[%u] has invalid "
+                          "string table offset 0x%x in %s, ignoring symbol\n",
+                          entry_index, nlist.n_strx,
+                          module_sp->GetFileSpec().GetPath().c_str());
+                      continue;
+                    }
+                    if (symbol_name[0] == '\0')
+                      symbol_name = NULL;
 
-                      const char *symbol_name_non_abi_mangled = NULL;
+                    const char *symbol_name_non_abi_mangled = NULL;
 
-                      SectionSP symbol_section;
-                      uint32_t symbol_byte_size = 0;
-                      bool add_nlist = true;
-                      bool is_debug = ((nlist.n_type & N_STAB) != 0);
-                      bool demangled_is_synthesized = false;
-                      bool is_gsym = false;
-                      bool set_value = true;
-
-                      assert(sym_idx < num_syms);
-
-                      sym[sym_idx].SetDebug(is_debug);
-
-                      if (is_debug) {
-                        switch (nlist.n_type) {
-                        case N_GSYM:
-                          // global symbol: name,,NO_SECT,type,0
-                          // Sometimes the N_GSYM value contains the address.
-
-                          // FIXME: In the .o files, we have a GSYM and a debug
-                          // symbol for all the ObjC data.  They
-                          // have the same address, but we want to ensure that
-                          // we always find only the real symbol, 'cause we
-                          // don't currently correctly attribute the
-                          // GSYM one to the ObjCClass/Ivar/MetaClass
-                          // symbol type.  This is a temporary hack to make
-                          // sure the ObjectiveC symbols get treated correctly.
-                          // To do this right, we should coalesce all the GSYM
-                          // & global symbols that have the same address.
-
-                          is_gsym = true;
-                          sym[sym_idx].SetExternal(true);
-
-                          if (symbol_name && symbol_name[0] == '_' &&
-                              symbol_name[1] == 'O') {
-                            llvm::StringRef symbol_name_ref(symbol_name);
-                            if (symbol_name_ref.startswith(
-                                    g_objc_v2_prefix_class)) {
-                              symbol_name_non_abi_mangled = symbol_name + 1;
-                              symbol_name =
-                                  symbol_name + g_objc_v2_prefix_class.size();
-                              type = eSymbolTypeObjCClass;
-                              demangled_is_synthesized = true;
-
-                            } else if (symbol_name_ref.startswith(
-                                           g_objc_v2_prefix_metaclass)) {
-                              symbol_name_non_abi_mangled = symbol_name + 1;
-                              symbol_name = symbol_name +
-                                            g_objc_v2_prefix_metaclass.size();
-                              type = eSymbolTypeObjCMetaClass;
-                              demangled_is_synthesized = true;
-                            } else if (symbol_name_ref.startswith(
-                                           g_objc_v2_prefix_ivar)) {
-                              symbol_name_non_abi_mangled = symbol_name + 1;
-                              symbol_name =
-                                  symbol_name + g_objc_v2_prefix_ivar.size();
-                              type = eSymbolTypeObjCIVar;
-                              demangled_is_synthesized = true;
-                            }
-                          } else {
-                            if (nlist.n_value != 0)
-                              symbol_section = section_info.GetSection(
-                                  nlist.n_sect, nlist.n_value);
-                            type = eSymbolTypeData;
+                    SectionSP symbol_section;
+                    uint32_t symbol_byte_size = 0;
+                    bool add_nlist = true;
+                    bool is_debug = ((nlist.n_type & N_STAB) != 0);
+                    bool demangled_is_synthesized = false;
+                    bool is_gsym = false;
+                    bool set_value = true;
+
+                    assert(sym_idx < num_syms);
+
+                    sym[sym_idx].SetDebug(is_debug);
+
+                    if (is_debug) {
+                      switch (nlist.n_type) {
+                      case N_GSYM:
+                        // global symbol: name,,NO_SECT,type,0
+                        // Sometimes the N_GSYM value contains the address.
+
+                        // FIXME: In the .o files, we have a GSYM and a debug
+                        // symbol for all the ObjC data.  They
+                        // have the same address, but we want to ensure that
+                        // we always find only the real symbol, 'cause we
+                        // don't currently correctly attribute the
+                        // GSYM one to the ObjCClass/Ivar/MetaClass
+                        // symbol type.  This is a temporary hack to make
+                        // sure the ObjectiveC symbols get treated correctly.
+                        // To do this right, we should coalesce all the GSYM
+                        // & global symbols that have the same address.
+
+                        is_gsym = true;
+                        sym[sym_idx].SetExternal(true);
+
+                        if (symbol_name && symbol_name[0] == '_' &&
+                            symbol_name[1] == 'O') {
+                          llvm::StringRef symbol_name_ref(symbol_name);
+                          if (symbol_name_ref.startswith(
+                                  g_objc_v2_prefix_class)) {
+                            symbol_name_non_abi_mangled = symbol_name + 1;
+                            symbol_name =
+                                symbol_name + g_objc_v2_prefix_class.size();
+                            type = eSymbolTypeObjCClass;
+                            demangled_is_synthesized = true;
+
+                          } else if (symbol_name_ref.startswith(
+                                         g_objc_v2_prefix_metaclass)) {
+                            symbol_name_non_abi_mangled = symbol_name + 1;
+                            symbol_name =
+                                symbol_name + g_objc_v2_prefix_metaclass.size();
+                            type = eSymbolTypeObjCMetaClass;
+                            demangled_is_synthesized = true;
+                          } else if (symbol_name_ref.startswith(
+                                         g_objc_v2_prefix_ivar)) {
+                            symbol_name_non_abi_mangled = symbol_name + 1;
+                            symbol_name =
+                                symbol_name + g_objc_v2_prefix_ivar.size();
+                            type = eSymbolTypeObjCIVar;
+                            demangled_is_synthesized = true;
                           }
-                          break;
-
-                        case N_FNAME:
-                          // procedure name (f77 kludge): name,,NO_SECT,0,0
-                          type = eSymbolTypeCompiler;
-                          break;
-
-                        case N_FUN:
-                          // procedure: name,,n_sect,linenumber,address
-                          if (symbol_name) {
-                            type = eSymbolTypeCode;
+                        } else {
+                          if (nlist.n_value != 0)
                             symbol_section = section_info.GetSection(
                                 nlist.n_sect, nlist.n_value);
+                          type = eSymbolTypeData;
+                        }
+                        break;
 
-                            N_FUN_addr_to_sym_idx.insert(
-                                std::make_pair(nlist.n_value, sym_idx));
-                            // We use the current number of symbols in the
-                            // symbol table in lieu of using nlist_idx in case
-                            // we ever start trimming entries out
-                            N_FUN_indexes.push_back(sym_idx);
-                          } else {
-                            type = eSymbolTypeCompiler;
-
-                            if (!N_FUN_indexes.empty()) {
-                              // Copy the size of the function into the
-                              // original
-                              // STAB entry so we don't have
-                              // to hunt for it later
-                              symtab->SymbolAtIndex(N_FUN_indexes.back())
-                                  ->SetByteSize(nlist.n_value);
-                              N_FUN_indexes.pop_back();
-                              // We don't really need the end function STAB as
-                              // it contains the size which we already placed
-                              // with the original symbol, so don't add it if
-                              // we want a minimal symbol table
-                              add_nlist = false;
-                            }
-                          }
-                          break;
+                      case N_FNAME:
+                        // procedure name (f77 kludge): name,,NO_SECT,0,0
+                        type = eSymbolTypeCompiler;
+                        break;
 
-                        case N_STSYM:
-                          // static symbol: name,,n_sect,type,address
-                          N_STSYM_addr_to_sym_idx.insert(
-                              std::make_pair(nlist.n_value, sym_idx));
+                      case N_FUN:
+                        // procedure: name,,n_sect,linenumber,address
+                        if (symbol_name) {
+                          type = eSymbolTypeCode;
                           symbol_section = section_info.GetSection(
                               nlist.n_sect, nlist.n_value);
-                          if (symbol_name && symbol_name[0]) {
-                            type = ObjectFile::GetSymbolTypeFromName(
-                                symbol_name + 1, eSymbolTypeData);
+
+                          N_FUN_addr_to_sym_idx.insert(
+                              std::make_pair(nlist.n_value, sym_idx));
+                          // We use the current number of symbols in the
+                          // symbol table in lieu of using nlist_idx in case
+                          // we ever start trimming entries out
+                          N_FUN_indexes.push_back(sym_idx);
+                        } else {
+                          type = eSymbolTypeCompiler;
+
+                          if (!N_FUN_indexes.empty()) {
+                            // Copy the size of the function into the
+                            // original
+                            // STAB entry so we don't have
+                            // to hunt for it later
+                            symtab->SymbolAtIndex(N_FUN_indexes.back())
+                                ->SetByteSize(nlist.n_value);
+                            N_FUN_indexes.pop_back();
+                            // We don't really need the end function STAB as
+                            // it contains the size which we already placed
+                            // with the original symbol, so don't add it if
+                            // we want a minimal symbol table
+                            add_nlist = false;
                           }
-                          break;
+                        }
+                        break;
 
-                        case N_LCSYM:
-                          // .lcomm symbol: name,,n_sect,type,address
-                          symbol_section = section_info.GetSection(
-                              nlist.n_sect, nlist.n_value);
-                          type = eSymbolTypeCommonBlock;
-                          break;
+                      case N_STSYM:
+                        // static symbol: name,,n_sect,type,address
+                        N_STSYM_addr_to_sym_idx.insert(
+                            std::make_pair(nlist.n_value, sym_idx));
+                        symbol_section = section_info.GetSection(nlist.n_sect,
+                                                                 nlist.n_value);
+                        if (symbol_name && symbol_name[0]) {
+                          type = ObjectFile::GetSymbolTypeFromName(
+                              symbol_name + 1, eSymbolTypeData);
+                        }
+                        break;
 
-                        case N_BNSYM:
-                          // We use the current number of symbols in the symbol
-                          // table in lieu of using nlist_idx in case we ever
-                          // start trimming entries out Skip these if we want
-                          // minimal symbol tables
-                          add_nlist = false;
-                          break;
+                      case N_LCSYM:
+                        // .lcomm symbol: name,,n_sect,type,address
+                        symbol_section = section_info.GetSection(nlist.n_sect,
+                                                                 nlist.n_value);
+                        type = eSymbolTypeCommonBlock;
+                        break;
 
-                        case N_ENSYM:
-                          // Set the size of the N_BNSYM to the terminating
-                          // index of this N_ENSYM so that we can always skip
-                          // the entire symbol if we need to navigate more
-                          // quickly at the source level when parsing STABS
-                          // Skip these if we want minimal symbol tables
-                          add_nlist = false;
-                          break;
+                      case N_BNSYM:
+                        // We use the current number of symbols in the symbol
+                        // table in lieu of using nlist_idx in case we ever
+                        // start trimming entries out Skip these if we want
+                        // minimal symbol tables
+                        add_nlist = false;
+                        break;
 
-                        case N_OPT:
-                          // emitted with gcc2_compiled and in gcc source
-                          type = eSymbolTypeCompiler;
-                          break;
+                      case N_ENSYM:
+                        // Set the size of the N_BNSYM to the terminating
+                        // index of this N_ENSYM so that we can always skip
+                        // the entire symbol if we need to navigate more
+                        // quickly at the source level when parsing STABS
+                        // Skip these if we want minimal symbol tables
+                        add_nlist = false;
+                        break;
 
-                        case N_RSYM:
-                          // register sym: name,,NO_SECT,type,register
-                          type = eSymbolTypeVariable;
-                          break;
+                      case N_OPT:
+                        // emitted with gcc2_compiled and in gcc source
+                        type = eSymbolTypeCompiler;
+                        break;
 
-                        case N_SLINE:
-                          // src line: 0,,n_sect,linenumber,address
-                          symbol_section = section_info.GetSection(
-                              nlist.n_sect, nlist.n_value);
-                          type = eSymbolTypeLineEntry;
-                          break;
+                      case N_RSYM:
+                        // register sym: name,,NO_SECT,type,register
+                        type = eSymbolTypeVariable;
+                        break;
 
-                        case N_SSYM:
-                          // structure elt: name,,NO_SECT,type,struct_offset
-                          type = eSymbolTypeVariableType;
-                          break;
+                      case N_SLINE:
+                        // src line: 0,,n_sect,linenumber,address
+                        symbol_section = section_info.GetSection(nlist.n_sect,
+                                                                 nlist.n_value);
+                        type = eSymbolTypeLineEntry;
+                        break;
 
-                        case N_SO:
-                          // source file name
-                          type = eSymbolTypeSourceFile;
-                          if (symbol_name == NULL) {
-                            add_nlist = false;
-                            if (N_SO_index != UINT32_MAX) {
-                              // Set the size of the N_SO to the terminating
-                              // index of this N_SO so that we can always skip
-                              // the entire N_SO if we need to navigate more
-                              // quickly at the source level when parsing STABS
-                              symbol_ptr = symtab->SymbolAtIndex(N_SO_index);
-                              symbol_ptr->SetByteSize(sym_idx);
-                              symbol_ptr->SetSizeIsSibling(true);
+                      case N_SSYM:
+                        // structure elt: name,,NO_SECT,type,struct_offset
+                        type = eSymbolTypeVariableType;
+                        break;
+
+                      case N_SO:
+                        // source file name
+                        type = eSymbolTypeSourceFile;
+                        if (symbol_name == NULL) {
+                          add_nlist = false;
+                          if (N_SO_index != UINT32_MAX) {
+                            // Set the size of the N_SO to the terminating
+                            // index of this N_SO so that we can always skip
+                            // the entire N_SO if we need to navigate more
+                            // quickly at the source level when parsing STABS
+                            symbol_ptr = symtab->SymbolAtIndex(N_SO_index);
+                            symbol_ptr->SetByteSize(sym_idx);
+                            symbol_ptr->SetSizeIsSibling(true);
+                          }
+                          N_NSYM_indexes.clear();
+                          N_INCL_indexes.clear();
+                          N_BRAC_indexes.clear();
+                          N_COMM_indexes.clear();
+                          N_FUN_indexes.clear();
+                          N_SO_index = UINT32_MAX;
+                        } else {
+                          // We use the current number of symbols in the
+                          // symbol table in lieu of using nlist_idx in case
+                          // we ever start trimming entries out
+                          const bool N_SO_has_full_path = symbol_name[0] == '/';
+                          if (N_SO_has_full_path) {
+                            if ((N_SO_index == sym_idx - 1) &&
+                                ((sym_idx - 1) < num_syms)) {
+                              // We have two consecutive N_SO entries where
+                              // the first contains a directory and the
+                              // second contains a full path.
+                              sym[sym_idx - 1].GetMangled().SetValue(
+                                  ConstString(symbol_name), false);
+                              m_nlist_idx_to_sym_idx[nlist_idx] = sym_idx - 1;
+                              add_nlist = false;
+                            } else {
+                              // This is the first entry in a N_SO that
+                              // contains a directory or
+                              // a full path to the source file
+                              N_SO_index = sym_idx;
                             }
-                            N_NSYM_indexes.clear();
-                            N_INCL_indexes.clear();
-                            N_BRAC_indexes.clear();
-                            N_COMM_indexes.clear();
-                            N_FUN_indexes.clear();
-                            N_SO_index = UINT32_MAX;
-                          } else {
-                            // We use the current number of symbols in the
-                            // symbol table in lieu of using nlist_idx in case
-                            // we ever start trimming entries out
-                            const bool N_SO_has_full_path =
-                                symbol_name[0] == '/';
-                            if (N_SO_has_full_path) {
-                              if ((N_SO_index == sym_idx - 1) &&
-                                  ((sym_idx - 1) < num_syms)) {
-                                // We have two consecutive N_SO entries where
-                                // the first contains a directory and the
-                                // second contains a full path.
-                                sym[sym_idx - 1].GetMangled().SetValue(
-                                    ConstString(symbol_name), false);
-                                m_nlist_idx_to_sym_idx[nlist_idx] = sym_idx - 1;
-                                add_nlist = false;
-                              } else {
-                                // This is the first entry in a N_SO that
-                                // contains a directory or
-                                // a full path to the source file
-                                N_SO_index = sym_idx;
-                              }
-                            } else if ((N_SO_index == sym_idx - 1) &&
-                                       ((sym_idx - 1) < num_syms)) {
-                              // This is usually the second N_SO entry that
-                              // contains just the filename, so here we combine
-                              // it with the first one if we are minimizing the
-                              // symbol table
-                              const char *so_path =
-                                  sym[sym_idx - 1]
-                                      .GetMangled()
-                                      .GetDemangledName(
-                                          lldb::eLanguageTypeUnknown)
-                                      .AsCString();
-                              if (so_path && so_path[0]) {
-                                std::string full_so_path(so_path);
-                                const size_t double_slash_pos =
-                                    full_so_path.find("//");
-                                if (double_slash_pos != std::string::npos) {
-                                  // The linker has been generating bad N_SO
-                                  // entries with doubled up paths
-                                  // in the format "%s%s" where the first
-                                  // string in the DW_AT_comp_dir, and the
-                                  // second is the directory for the source
-                                  // file so you end up with a path that looks
-                                  // like "/tmp/src//tmp/src/"
-                                  FileSpec so_dir(so_path);
-                                  if (!FileSystem::Instance().Exists(so_dir)) {
-                                    so_dir.SetFile(
-                                        &full_so_path[double_slash_pos + 1],
-                                        FileSpec::Style::native);
-                                    if (FileSystem::Instance().Exists(so_dir)) {
-                                      // Trim off the incorrect path
-                                      full_so_path.erase(0,
-                                                         double_slash_pos + 1);
-                                    }
+                          } else if ((N_SO_index == sym_idx - 1) &&
+                                     ((sym_idx - 1) < num_syms)) {
+                            // This is usually the second N_SO entry that
+                            // contains just the filename, so here we combine
+                            // it with the first one if we are minimizing the
+                            // symbol table
+                            const char *so_path =
+                                sym[sym_idx - 1]
+                                    .GetMangled()
+                                    .GetDemangledName(
+                                        lldb::eLanguageTypeUnknown)
+                                    .AsCString();
+                            if (so_path && so_path[0]) {
+                              std::string full_so_path(so_path);
+                              const size_t double_slash_pos =
+                                  full_so_path.find("//");
+                              if (double_slash_pos != std::string::npos) {
+                                // The linker has been generating bad N_SO
+                                // entries with doubled up paths
+                                // in the format "%s%s" where the first
+                                // string in the DW_AT_comp_dir, and the
+                                // second is the directory for the source
+                                // file so you end up with a path that looks
+                                // like "/tmp/src//tmp/src/"
+                                FileSpec so_dir(so_path);
+                                if (!FileSystem::Instance().Exists(so_dir)) {
+                                  so_dir.SetFile(
+                                      &full_so_path[double_slash_pos + 1],
+                                      FileSpec::Style::native);
+                                  if (FileSystem::Instance().Exists(so_dir)) {
+                                    // Trim off the incorrect path
+                                    full_so_path.erase(0, double_slash_pos + 1);
                                   }
                                 }
-                                if (*full_so_path.rbegin() != '/')
-                                  full_so_path += '/';
-                                full_so_path += symbol_name;
-                                sym[sym_idx - 1].GetMangled().SetValue(
-                                    ConstString(full_so_path.c_str()), false);
-                                add_nlist = false;
-                                m_nlist_idx_to_sym_idx[nlist_idx] = sym_idx - 1;
                               }
-                            } else {
-                              // This could be a relative path to a N_SO
-                              N_SO_index = sym_idx;
+                              if (*full_so_path.rbegin() != '/')
+                                full_so_path += '/';
+                              full_so_path += symbol_name;
+                              sym[sym_idx - 1].GetMangled().SetValue(
+                                  ConstString(full_so_path.c_str()), false);
+                              add_nlist = false;
+                              m_nlist_idx_to_sym_idx[nlist_idx] = sym_idx - 1;
                             }
+                          } else {
+                            // This could be a relative path to a N_SO
+                            N_SO_index = sym_idx;
                           }
-                          break;
+                        }
+                        break;
 
-                        case N_OSO:
-                          // object file name: name,,0,0,st_mtime
-                          type = eSymbolTypeObjectFile;
-                          break;
+                      case N_OSO:
+                        // object file name: name,,0,0,st_mtime
+                        type = eSymbolTypeObjectFile;
+                        break;
 
-                        case N_LSYM:
-                          // local sym: name,,NO_SECT,type,offset
-                          type = eSymbolTypeLocal;
-                          break;
+                      case N_LSYM:
+                        // local sym: name,,NO_SECT,type,offset
+                        type = eSymbolTypeLocal;
+                        break;
 
-                        // INCL scopes
-                        case N_BINCL:
-                          // include file beginning: name,,NO_SECT,0,sum We use
-                          // the current number of symbols in the symbol table
-                          // in lieu of using nlist_idx in case we ever start
-                          // trimming entries out
-                          N_INCL_indexes.push_back(sym_idx);
-                          type = eSymbolTypeScopeBegin;
-                          break;
+                      // INCL scopes
+                      case N_BINCL:
+                        // include file beginning: name,,NO_SECT,0,sum We use
+                        // the current number of symbols in the symbol table
+                        // in lieu of using nlist_idx in case we ever start
+                        // trimming entries out
+                        N_INCL_indexes.push_back(sym_idx);
+                        type = eSymbolTypeScopeBegin;
+                        break;
 
-                        case N_EINCL:
-                          // include file end: name,,NO_SECT,0,0
-                          // Set the size of the N_BINCL to the terminating
-                          // index of this N_EINCL so that we can always skip
-                          // the entire symbol if we need to navigate more
-                          // quickly at the source level when parsing STABS
-                          if (!N_INCL_indexes.empty()) {
-                            symbol_ptr =
-                                symtab->SymbolAtIndex(N_INCL_indexes.back());
-                            symbol_ptr->SetByteSize(sym_idx + 1);
-                            symbol_ptr->SetSizeIsSibling(true);
-                            N_INCL_indexes.pop_back();
-                          }
-                          type = eSymbolTypeScopeEnd;
-                          break;
+                      case N_EINCL:
+                        // include file end: name,,NO_SECT,0,0
+                        // Set the size of the N_BINCL to the terminating
+                        // index of this N_EINCL so that we can always skip
+                        // the entire symbol if we need to navigate more
+                        // quickly at the source level when parsing STABS
+                        if (!N_INCL_indexes.empty()) {
+                          symbol_ptr =
+                              symtab->SymbolAtIndex(N_INCL_indexes.back());
+                          symbol_ptr->SetByteSize(sym_idx + 1);
+                          symbol_ptr->SetSizeIsSibling(true);
+                          N_INCL_indexes.pop_back();
+                        }
+                        type = eSymbolTypeScopeEnd;
+                        break;
 
-                        case N_SOL:
-                          // #included file name: name,,n_sect,0,address
-                          type = eSymbolTypeHeaderFile;
+                      case N_SOL:
+                        // #included file name: name,,n_sect,0,address
+                        type = eSymbolTypeHeaderFile;
 
-                          // We currently don't use the header files on darwin
-                          add_nlist = false;
-                          break;
+                        // We currently don't use the header files on darwin
+                        add_nlist = false;
+                        break;
 
-                        case N_PARAMS:
-                          // compiler parameters: name,,NO_SECT,0,0
-                          type = eSymbolTypeCompiler;
-                          break;
+                      case N_PARAMS:
+                        // compiler parameters: name,,NO_SECT,0,0
+                        type = eSymbolTypeCompiler;
+                        break;
 
-                        case N_VERSION:
-                          // compiler version: name,,NO_SECT,0,0
-                          type = eSymbolTypeCompiler;
-                          break;
+                      case N_VERSION:
+                        // compiler version: name,,NO_SECT,0,0
+                        type = eSymbolTypeCompiler;
+                        break;
 
-                        case N_OLEVEL:
-                          // compiler -O level: name,,NO_SECT,0,0
-                          type = eSymbolTypeCompiler;
-                          break;
+                      case N_OLEVEL:
+                        // compiler -O level: name,,NO_SECT,0,0
+                        type = eSymbolTypeCompiler;
+                        break;
 
-                        case N_PSYM:
-                          // parameter: name,,NO_SECT,type,offset
-                          type = eSymbolTypeVariable;
-                          break;
+                      case N_PSYM:
+                        // parameter: name,,NO_SECT,type,offset
+                        type = eSymbolTypeVariable;
+                        break;
 
-                        case N_ENTRY:
-                          // alternate entry: name,,n_sect,linenumber,address
-                          symbol_section = section_info.GetSection(
-                              nlist.n_sect, nlist.n_value);
-                          type = eSymbolTypeLineEntry;
-                          break;
+                      case N_ENTRY:
+                        // alternate entry: name,,n_sect,linenumber,address
+                        symbol_section = section_info.GetSection(nlist.n_sect,
+                                                                 nlist.n_value);
+                        type = eSymbolTypeLineEntry;
+                        break;
 
-                        // Left and Right Braces
-                        case N_LBRAC:
-                          // left bracket: 0,,NO_SECT,nesting level,address We
-                          // use the current number of symbols in the symbol
-                          // table in lieu of using nlist_idx in case we ever
-                          // start trimming entries out
-                          symbol_section = section_info.GetSection(
-                              nlist.n_sect, nlist.n_value);
-                          N_BRAC_indexes.push_back(sym_idx);
-                          type = eSymbolTypeScopeBegin;
-                          break;
+                      // Left and Right Braces
+                      case N_LBRAC:
+                        // left bracket: 0,,NO_SECT,nesting level,address We
+                        // use the current number of symbols in the symbol
+                        // table in lieu of using nlist_idx in case we ever
+                        // start trimming entries out
+                        symbol_section = section_info.GetSection(nlist.n_sect,
+                                                                 nlist.n_value);
+                        N_BRAC_indexes.push_back(sym_idx);
+                        type = eSymbolTypeScopeBegin;
+                        break;
 
-                        case N_RBRAC:
-                          // right bracket: 0,,NO_SECT,nesting level,address
-                          // Set the size of the N_LBRAC to the terminating
-                          // index of this N_RBRAC so that we can always skip
-                          // the entire symbol if we need to navigate more
-                          // quickly at the source level when parsing STABS
-                          symbol_section = section_info.GetSection(
-                              nlist.n_sect, nlist.n_value);
-                          if (!N_BRAC_indexes.empty()) {
-                            symbol_ptr =
-                                symtab->SymbolAtIndex(N_BRAC_indexes.back());
-                            symbol_ptr->SetByteSize(sym_idx + 1);
-                            symbol_ptr->SetSizeIsSibling(true);
-                            N_BRAC_indexes.pop_back();
-                          }
-                          type = eSymbolTypeScopeEnd;
-                          break;
+                      case N_RBRAC:
+                        // right bracket: 0,,NO_SECT,nesting level,address
+                        // Set the size of the N_LBRAC to the terminating
+                        // index of this N_RBRAC so that we can always skip
+                        // the entire symbol if we need to navigate more
+                        // quickly at the source level when parsing STABS
+                        symbol_section = section_info.GetSection(nlist.n_sect,
+                                                                 nlist.n_value);
+                        if (!N_BRAC_indexes.empty()) {
+                          symbol_ptr =
+                              symtab->SymbolAtIndex(N_BRAC_indexes.back());
+                          symbol_ptr->SetByteSize(sym_idx + 1);
+                          symbol_ptr->SetSizeIsSibling(true);
+                          N_BRAC_indexes.pop_back();
+                        }
+                        type = eSymbolTypeScopeEnd;
+                        break;
 
-                        case N_EXCL:
-                          // deleted include file: name,,NO_SECT,0,sum
-                          type = eSymbolTypeHeaderFile;
-                          break;
+                      case N_EXCL:
+                        // deleted include file: name,,NO_SECT,0,sum
+                        type = eSymbolTypeHeaderFile;
+                        break;
 
-                        // COMM scopes
-                        case N_BCOMM:
-                          // begin common: name,,NO_SECT,0,0
-                          // We use the current number of symbols in the symbol
-                          // table in lieu of using nlist_idx in case we ever
-                          // start trimming entries out
-                          type = eSymbolTypeScopeBegin;
-                          N_COMM_indexes.push_back(sym_idx);
-                          break;
+                      // COMM scopes
+                      case N_BCOMM:
+                        // begin common: name,,NO_SECT,0,0
+                        // We use the current number of symbols in the symbol
+                        // table in lieu of using nlist_idx in case we ever
+                        // start trimming entries out
+                        type = eSymbolTypeScopeBegin;
+                        N_COMM_indexes.push_back(sym_idx);
+                        break;
 
-                        case N_ECOML:
-                          // end common (local name): 0,,n_sect,0,address
-                          symbol_section = section_info.GetSection(
-                              nlist.n_sect, nlist.n_value);
-                          // Fall through
+                      case N_ECOML:
+                        // end common (local name): 0,,n_sect,0,address
+                        symbol_section = section_info.GetSection(nlist.n_sect,
+                                                                 nlist.n_value);
+                        // Fall through
 
-                        case N_ECOMM:
-                          // end common: name,,n_sect,0,0
-                          // Set the size of the N_BCOMM to the terminating
-                          // index of this N_ECOMM/N_ECOML so that we can
-                          // always skip the entire symbol if we need to
-                          // navigate more quickly at the source level when
-                          // parsing STABS
-                          if (!N_COMM_indexes.empty()) {
-                            symbol_ptr =
-                                symtab->SymbolAtIndex(N_COMM_indexes.back());
-                            symbol_ptr->SetByteSize(sym_idx + 1);
-                            symbol_ptr->SetSizeIsSibling(true);
-                            N_COMM_indexes.pop_back();
-                          }
-                          type = eSymbolTypeScopeEnd;
-                          break;
+                      case N_ECOMM:
+                        // end common: name,,n_sect,0,0
+                        // Set the size of the N_BCOMM to the terminating
+                        // index of this N_ECOMM/N_ECOML so that we can
+                        // always skip the entire symbol if we need to
+                        // navigate more quickly at the source level when
+                        // parsing STABS
+                        if (!N_COMM_indexes.empty()) {
+                          symbol_ptr =
+                              symtab->SymbolAtIndex(N_COMM_indexes.back());
+                          symbol_ptr->SetByteSize(sym_idx + 1);
+                          symbol_ptr->SetSizeIsSibling(true);
+                          N_COMM_indexes.pop_back();
+                        }
+                        type = eSymbolTypeScopeEnd;
+                        break;
 
-                        case N_LENG:
-                          // second stab entry with length information
-                          type = eSymbolTypeAdditional;
-                          break;
+                      case N_LENG:
+                        // second stab entry with length information
+                        type = eSymbolTypeAdditional;
+                        break;
 
-                        default:
-                          break;
-                        }
-                      } else {
-                        // uint8_t n_pext    = N_PEXT & nlist.n_type;
-                        uint8_t n_type = N_TYPE & nlist.n_type;
-                        sym[sym_idx].SetExternal((N_EXT & nlist.n_type) != 0);
-
-                        switch (n_type) {
-                        case N_INDR: {
-                          const char *reexport_name_cstr =
-                              strtab_data.PeekCStr(nlist.n_value);
-                          if (reexport_name_cstr && reexport_name_cstr[0]) {
-                            type = eSymbolTypeReExported;
-                            ConstString reexport_name(
-                                reexport_name_cstr +
-                                ((reexport_name_cstr[0] == '_') ? 1 : 0));
-                            sym[sym_idx].SetReExportedSymbolName(reexport_name);
-                            set_value = false;
-                            reexport_shlib_needs_fixup[sym_idx] = reexport_name;
-                            indirect_symbol_names.insert(
-                                ConstString(symbol_name +
-                                            ((symbol_name[0] == '_') ? 1 : 0)));
-                          } else
-                            type = eSymbolTypeUndefined;
-                        } break;
-
-                        case N_UNDF:
-                          if (symbol_name && symbol_name[0]) {
-                            ConstString undefined_name(
-                                symbol_name +
-                                ((symbol_name[0] == '_') ? 1 : 0));
-                            undefined_name_to_desc[undefined_name] =
-                                nlist.n_desc;
-                          }
-                        // Fall through
-                        case N_PBUD:
+                      default:
+                        break;
+                      }
+                    } else {
+                      // uint8_t n_pext    = N_PEXT & nlist.n_type;
+                      uint8_t n_type = N_TYPE & nlist.n_type;
+                      sym[sym_idx].SetExternal((N_EXT & nlist.n_type) != 0);
+
+                      switch (n_type) {
+                      case N_INDR: {
+                        const char *reexport_name_cstr =
+                            strtab_data.PeekCStr(nlist.n_value);
+                        if (reexport_name_cstr && reexport_name_cstr[0]) {
+                          type = eSymbolTypeReExported;
+                          ConstString reexport_name(
+                              reexport_name_cstr +
+                              ((reexport_name_cstr[0] == '_') ? 1 : 0));
+                          sym[sym_idx].SetReExportedSymbolName(reexport_name);
+                          set_value = false;
+                          reexport_shlib_needs_fixup[sym_idx] = reexport_name;
+                          indirect_symbol_names.insert(ConstString(
+                              symbol_name + ((symbol_name[0] == '_') ? 1 : 0)));
+                        } else
                           type = eSymbolTypeUndefined;
-                          break;
+                      } break;
 
-                        case N_ABS:
-                          type = eSymbolTypeAbsolute;
-                          break;
+                      case N_UNDF:
+                        if (symbol_name && symbol_name[0]) {
+                          ConstString undefined_name(
+                              symbol_name + ((symbol_name[0] == '_') ? 1 : 0));
+                          undefined_name_to_desc[undefined_name] = nlist.n_desc;
+                        }
+                      // Fall through
+                      case N_PBUD:
+                        type = eSymbolTypeUndefined;
+                        break;
 
-                        case N_SECT: {
-                          symbol_section = section_info.GetSection(
-                              nlist.n_sect, nlist.n_value);
+                      case N_ABS:
+                        type = eSymbolTypeAbsolute;
+                        break;
 
-                          if (symbol_section == NULL) {
-                            // TODO: warn about this?
-                            add_nlist = false;
-                            break;
-                          }
+                      case N_SECT: {
+                        symbol_section = section_info.GetSection(nlist.n_sect,
+                                                                 nlist.n_value);
 
-                          if (TEXT_eh_frame_sectID == nlist.n_sect) {
-                            type = eSymbolTypeException;
-                          } else {
-                            uint32_t section_type =
-                                symbol_section->Get() & SECTION_TYPE;
+                        if (symbol_section == NULL) {
+                          // TODO: warn about this?
+                          add_nlist = false;
+                          break;
+                        }
 
-                            switch (section_type) {
-                            case S_CSTRING_LITERALS:
-                              type = eSymbolTypeData;
-                              break; // section with only literal C strings
-                            case S_4BYTE_LITERALS:
-                              type = eSymbolTypeData;
-                              break; // section with only 4 byte literals
-                            case S_8BYTE_LITERALS:
-                              type = eSymbolTypeData;
-                              break; // section with only 8 byte literals
-                            case S_LITERAL_POINTERS:
-                              type = eSymbolTypeTrampoline;
-                              break; // section with only pointers to literals
-                            case S_NON_LAZY_SYMBOL_POINTERS:
-                              type = eSymbolTypeTrampoline;
-                              break; // section with only non-lazy symbol
-                                     // pointers
-                            case S_LAZY_SYMBOL_POINTERS:
-                              type = eSymbolTypeTrampoline;
-                              break; // section with only lazy symbol pointers
-                            case S_SYMBOL_STUBS:
-                              type = eSymbolTypeTrampoline;
-                              break; // section with only symbol stubs, byte
-                                     // size of stub in the reserved2 field
-                            case S_MOD_INIT_FUNC_POINTERS:
-                              type = eSymbolTypeCode;
-                              break; // section with only function pointers for
-                                     // initialization
-                            case S_MOD_TERM_FUNC_POINTERS:
+                        if (TEXT_eh_frame_sectID == nlist.n_sect) {
+                          type = eSymbolTypeException;
+                        } else {
+                          uint32_t section_type =
+                              symbol_section->Get() & SECTION_TYPE;
+
+                          switch (section_type) {
+                          case S_CSTRING_LITERALS:
+                            type = eSymbolTypeData;
+                            break; // section with only literal C strings
+                          case S_4BYTE_LITERALS:
+                            type = eSymbolTypeData;
+                            break; // section with only 4 byte literals
+                          case S_8BYTE_LITERALS:
+                            type = eSymbolTypeData;
+                            break; // section with only 8 byte literals
+                          case S_LITERAL_POINTERS:
+                            type = eSymbolTypeTrampoline;
+                            break; // section with only pointers to literals
+                          case S_NON_LAZY_SYMBOL_POINTERS:
+                            type = eSymbolTypeTrampoline;
+                            break; // section with only non-lazy symbol
+                                   // pointers
+                          case S_LAZY_SYMBOL_POINTERS:
+                            type = eSymbolTypeTrampoline;
+                            break; // section with only lazy symbol pointers
+                          case S_SYMBOL_STUBS:
+                            type = eSymbolTypeTrampoline;
+                            break; // section with only symbol stubs, byte
+                                   // size of stub in the reserved2 field
+                          case S_MOD_INIT_FUNC_POINTERS:
+                            type = eSymbolTypeCode;
+                            break; // section with only function pointers for
+                                   // initialization
+                          case S_MOD_TERM_FUNC_POINTERS:
+                            type = eSymbolTypeCode;
+                            break; // section with only function pointers for
+                                   // termination
+                          case S_INTERPOSING:
+                            type = eSymbolTypeTrampoline;
+                            break; // section with only pairs of function
+                                   // pointers for interposing
+                          case S_16BYTE_LITERALS:
+                            type = eSymbolTypeData;
+                            break; // section with only 16 byte literals
+                          case S_DTRACE_DOF:
+                            type = eSymbolTypeInstrumentation;
+                            break;
+                          case S_LAZY_DYLIB_SYMBOL_POINTERS:
+                            type = eSymbolTypeTrampoline;
+                            break;
+                          default:
+                            switch (symbol_section->GetType()) {
+                            case lldb::eSectionTypeCode:
                               type = eSymbolTypeCode;
-                              break; // section with only function pointers for
-                                     // termination
-                            case S_INTERPOSING:
-                              type = eSymbolTypeTrampoline;
-                              break; // section with only pairs of function
-                                     // pointers for interposing
-                            case S_16BYTE_LITERALS:
-                              type = eSymbolTypeData;
-                              break; // section with only 16 byte literals
-                            case S_DTRACE_DOF:
-                              type = eSymbolTypeInstrumentation;
                               break;
-                            case S_LAZY_DYLIB_SYMBOL_POINTERS:
-                              type = eSymbolTypeTrampoline;
-                              break;
-                            default:
-                              switch (symbol_section->GetType()) {
-                              case lldb::eSectionTypeCode:
-                                type = eSymbolTypeCode;
-                                break;
-                              case eSectionTypeData:
-                              case eSectionTypeDataCString: // Inlined C string
-                                                            // data
-                              case eSectionTypeDataCStringPointers: // Pointers
-                                                                    // to C
-                                                                    // string
-                                                                    // data
-                              case eSectionTypeDataSymbolAddress: // Address of
+                            case eSectionTypeData:
+                            case eSectionTypeDataCString: // Inlined C string
+                                                          // data
+                            case eSectionTypeDataCStringPointers: // Pointers
+                                                                  // to C
+                                                                  // string
+                                                                  // data
+                            case eSectionTypeDataSymbolAddress:   // Address of
                                                                   // a symbol in
                                                                   // the symbol
                                                                   // table
-                              case eSectionTypeData4:
-                              case eSectionTypeData8:
-                              case eSectionTypeData16:
-                                type = eSymbolTypeData;
-                                break;
-                              default:
-                                break;
-                              }
+                            case eSectionTypeData4:
+                            case eSectionTypeData8:
+                            case eSectionTypeData16:
+                              type = eSymbolTypeData;
+                              break;
+                            default:
                               break;
                             }
+                            break;
+                          }
 
-                            if (type == eSymbolTypeInvalid) {
-                              const char *symbol_sect_name =
-                                  symbol_section->GetName().AsCString();
-                              if (symbol_section->IsDescendant(
-                                      text_section_sp.get())) {
-                                if (symbol_section->IsClear(
-                                        S_ATTR_PURE_INSTRUCTIONS |
-                                        S_ATTR_SELF_MODIFYING_CODE |
-                                        S_ATTR_SOME_INSTRUCTIONS))
-                                  type = eSymbolTypeData;
-                                else
-                                  type = eSymbolTypeCode;
-                              } else if (symbol_section->IsDescendant(
-                                             data_section_sp.get()) ||
-                                         symbol_section->IsDescendant(
-                                             data_dirty_section_sp.get()) ||
-                                         symbol_section->IsDescendant(
-                                             data_const_section_sp.get())) {
-                                if (symbol_sect_name &&
-                                    ::strstr(symbol_sect_name, "__objc") ==
-                                        symbol_sect_name) {
-                                  type = eSymbolTypeRuntime;
-
-                                  if (symbol_name) {
-                                    llvm::StringRef symbol_name_ref(
-                                        symbol_name);
-                                    if (symbol_name_ref.startswith("_OBJC_")) {
-                                      static const llvm::StringRef
-                                          g_objc_v2_prefix_class(
-                                              "_OBJC_CLASS_$_");
-                                      static const llvm::StringRef
-                                          g_objc_v2_prefix_metaclass(
-                                              "_OBJC_METACLASS_$_");
-                                      static const llvm::StringRef
-                                          g_objc_v2_prefix_ivar(
-                                              "_OBJC_IVAR_$_");
-                                      if (symbol_name_ref.startswith(
-                                              g_objc_v2_prefix_class)) {
-                                        symbol_name_non_abi_mangled =
-                                            symbol_name + 1;
-                                        symbol_name =
-                                            symbol_name +
-                                            g_objc_v2_prefix_class.size();
-                                        type = eSymbolTypeObjCClass;
-                                        demangled_is_synthesized = true;
-                                      } else if (
-                                          symbol_name_ref.startswith(
-                                              g_objc_v2_prefix_metaclass)) {
-                                        symbol_name_non_abi_mangled =
-                                            symbol_name + 1;
-                                        symbol_name =
-                                            symbol_name +
-                                            g_objc_v2_prefix_metaclass.size();
-                                        type = eSymbolTypeObjCMetaClass;
-                                        demangled_is_synthesized = true;
-                                      } else if (symbol_name_ref.startswith(
-                                                     g_objc_v2_prefix_ivar)) {
-                                        symbol_name_non_abi_mangled =
-                                            symbol_name + 1;
-                                        symbol_name =
-                                            symbol_name +
-                                            g_objc_v2_prefix_ivar.size();
-                                        type = eSymbolTypeObjCIVar;
-                                        demangled_is_synthesized = true;
-                                      }
+                          if (type == eSymbolTypeInvalid) {
+                            const char *symbol_sect_name =
+                                symbol_section->GetName().AsCString();
+                            if (symbol_section->IsDescendant(
+                                    text_section_sp.get())) {
+                              if (symbol_section->IsClear(
+                                      S_ATTR_PURE_INSTRUCTIONS |
+                                      S_ATTR_SELF_MODIFYING_CODE |
+                                      S_ATTR_SOME_INSTRUCTIONS))
+                                type = eSymbolTypeData;
+                              else
+                                type = eSymbolTypeCode;
+                            } else if (symbol_section->IsDescendant(
+                                           data_section_sp.get()) ||
+                                       symbol_section->IsDescendant(
+                                           data_dirty_section_sp.get()) ||
+                                       symbol_section->IsDescendant(
+                                           data_const_section_sp.get())) {
+                              if (symbol_sect_name &&
+                                  ::strstr(symbol_sect_name, "__objc") ==
+                                      symbol_sect_name) {
+                                type = eSymbolTypeRuntime;
+
+                                if (symbol_name) {
+                                  llvm::StringRef symbol_name_ref(symbol_name);
+                                  if (symbol_name_ref.startswith("_OBJC_")) {
+                                    static const llvm::StringRef
+                                        g_objc_v2_prefix_class(
+                                            "_OBJC_CLASS_$_");
+                                    static const llvm::StringRef
+                                        g_objc_v2_prefix_metaclass(
+                                            "_OBJC_METACLASS_$_");
+                                    static const llvm::StringRef
+                                        g_objc_v2_prefix_ivar("_OBJC_IVAR_$_");
+                                    if (symbol_name_ref.startswith(
+                                            g_objc_v2_prefix_class)) {
+                                      symbol_name_non_abi_mangled =
+                                          symbol_name + 1;
+                                      symbol_name =
+                                          symbol_name +
+                                          g_objc_v2_prefix_class.size();
+                                      type = eSymbolTypeObjCClass;
+                                      demangled_is_synthesized = true;
+                                    } else if (
+                                        symbol_name_ref.startswith(
+                                            g_objc_v2_prefix_metaclass)) {
+                                      symbol_name_non_abi_mangled =
+                                          symbol_name + 1;
+                                      symbol_name =
+                                          symbol_name +
+                                          g_objc_v2_prefix_metaclass.size();
+                                      type = eSymbolTypeObjCMetaClass;
+                                      demangled_is_synthesized = true;
+                                    } else if (symbol_name_ref.startswith(
+                                                   g_objc_v2_prefix_ivar)) {
+                                      symbol_name_non_abi_mangled =
+                                          symbol_name + 1;
+                                      symbol_name =
+                                          symbol_name +
+                                          g_objc_v2_prefix_ivar.size();
+                                      type = eSymbolTypeObjCIVar;
+                                      demangled_is_synthesized = true;
                                     }
                                   }
-                                } else if (symbol_sect_name &&
-                                           ::strstr(symbol_sect_name,
-                                                    "__gcc_except_tab") ==
-                                               symbol_sect_name) {
-                                  type = eSymbolTypeException;
-                                } else {
-                                  type = eSymbolTypeData;
                                 }
                               } else if (symbol_sect_name &&
                                          ::strstr(symbol_sect_name,
-                                                  "__IMPORT") ==
+                                                  "__gcc_except_tab") ==
                                              symbol_sect_name) {
-                                type = eSymbolTypeTrampoline;
-                              } else if (symbol_section->IsDescendant(
-                                             objc_section_sp.get())) {
-                                type = eSymbolTypeRuntime;
-                                if (symbol_name && symbol_name[0] == '.') {
-                                  llvm::StringRef symbol_name_ref(symbol_name);
-                                  static const llvm::StringRef
-                                      g_objc_v1_prefix_class(
-                                          ".objc_class_name_");
-                                  if (symbol_name_ref.startswith(
-                                          g_objc_v1_prefix_class)) {
-                                    symbol_name_non_abi_mangled = symbol_name;
-                                    symbol_name = symbol_name +
-                                                  g_objc_v1_prefix_class.size();
-                                    type = eSymbolTypeObjCClass;
-                                    demangled_is_synthesized = true;
-                                  }
+                                type = eSymbolTypeException;
+                              } else {
+                                type = eSymbolTypeData;
+                              }
+                            } else if (symbol_sect_name &&
+                                       ::strstr(symbol_sect_name, "__IMPORT") ==
+                                           symbol_sect_name) {
+                              type = eSymbolTypeTrampoline;
+                            } else if (symbol_section->IsDescendant(
+                                           objc_section_sp.get())) {
+                              type = eSymbolTypeRuntime;
+                              if (symbol_name && symbol_name[0] == '.') {
+                                llvm::StringRef symbol_name_ref(symbol_name);
+                                static const llvm::StringRef
+                                    g_objc_v1_prefix_class(".objc_class_name_");
+                                if (symbol_name_ref.startswith(
+                                        g_objc_v1_prefix_class)) {
+                                  symbol_name_non_abi_mangled = symbol_name;
+                                  symbol_name = symbol_name +
+                                                g_objc_v1_prefix_class.size();
+                                  type = eSymbolTypeObjCClass;
+                                  demangled_is_synthesized = true;
                                 }
                               }
                             }
                           }
-                        } break;
                         }
+                      } break;
                       }
+                    }
 
-                      if (add_nlist) {
-                        uint64_t symbol_value = nlist.n_value;
-                        if (symbol_name_non_abi_mangled) {
-                          sym[sym_idx].GetMangled().SetMangledName(
-                              ConstString(symbol_name_non_abi_mangled));
-                          sym[sym_idx].GetMangled().SetDemangledName(
-                              ConstString(symbol_name));
-                        } else {
-                          bool symbol_name_is_mangled = false;
+                    if (add_nlist) {
+                      uint64_t symbol_value = nlist.n_value;
+                      if (symbol_name_non_abi_mangled) {
+                        sym[sym_idx].GetMangled().SetMangledName(
+                            ConstString(symbol_name_non_abi_mangled));
+                        sym[sym_idx].GetMangled().SetDemangledName(
+                            ConstString(symbol_name));
+                      } else {
+                        bool symbol_name_is_mangled = false;
 
-                          if (symbol_name && symbol_name[0] == '_') {
-                            symbol_name_is_mangled = symbol_name[1] == '_';
-                            symbol_name++; // Skip the leading underscore
-                          }
+                        if (symbol_name && symbol_name[0] == '_') {
+                          symbol_name_is_mangled = symbol_name[1] == '_';
+                          symbol_name++; // Skip the leading underscore
+                        }
 
-                          if (symbol_name) {
-                            ConstString const_symbol_name(symbol_name);
-                            sym[sym_idx].GetMangled().SetValue(
-                                const_symbol_name, symbol_name_is_mangled);
-                            if (is_gsym && is_debug) {
-                              const char *gsym_name =
-                                  sym[sym_idx]
-                                      .GetMangled()
-                                      .GetName(lldb::eLanguageTypeUnknown,
-                                               Mangled::ePreferMangled)
-                                      .GetCString();
-                              if (gsym_name)
-                                N_GSYM_name_to_sym_idx[gsym_name] = sym_idx;
-                            }
+                        if (symbol_name) {
+                          ConstString const_symbol_name(symbol_name);
+                          sym[sym_idx].GetMangled().SetValue(
+                              const_symbol_name, symbol_name_is_mangled);
+                          if (is_gsym && is_debug) {
+                            const char *gsym_name =
+                                sym[sym_idx]
+                                    .GetMangled()
+                                    .GetName(lldb::eLanguageTypeUnknown,
+                                             Mangled::ePreferMangled)
+                                    .GetCString();
+                            if (gsym_name)
+                              N_GSYM_name_to_sym_idx[gsym_name] = sym_idx;
                           }
                         }
-                        if (symbol_section) {
-                          const addr_t section_file_addr =
-                              symbol_section->GetFileAddress();
-                          if (symbol_byte_size == 0 &&
-                              function_starts_count > 0) {
-                            addr_t symbol_lookup_file_addr = nlist.n_value;
-                            // Do an exact address match for non-ARM addresses,
-                            // else get the closest since the symbol might be a
-                            // thumb symbol which has an address with bit zero
-                            // set
-                            FunctionStarts::Entry *func_start_entry =
-                                function_starts.FindEntry(
-                                    symbol_lookup_file_addr, !is_arm);
-                            if (is_arm && func_start_entry) {
-                              // Verify that the function start address is the
-                              // symbol address (ARM) or the symbol address + 1
-                              // (thumb)
-                              if (func_start_entry->addr !=
-                                      symbol_lookup_file_addr &&
-                                  func_start_entry->addr !=
-                                      (symbol_lookup_file_addr + 1)) {
-                                // Not the right entry, NULL it out...
-                                func_start_entry = NULL;
-                              }
+                      }
+                      if (symbol_section) {
+                        const addr_t section_file_addr =
+                            symbol_section->GetFileAddress();
+                        if (symbol_byte_size == 0 &&
+                            function_starts_count > 0) {
+                          addr_t symbol_lookup_file_addr = nlist.n_value;
+                          // Do an exact address match for non-ARM addresses,
+                          // else get the closest since the symbol might be a
+                          // thumb symbol which has an address with bit zero
+                          // set
+                          FunctionStarts::Entry *func_start_entry =
+                              function_starts.FindEntry(symbol_lookup_file_addr,
+                                                        !is_arm);
+                          if (is_arm && func_start_entry) {
+                            // Verify that the function start address is the
+                            // symbol address (ARM) or the symbol address + 1
+                            // (thumb)
+                            if (func_start_entry->addr !=
+                                    symbol_lookup_file_addr &&
+                                func_start_entry->addr !=
+                                    (symbol_lookup_file_addr + 1)) {
+                              // Not the right entry, NULL it out...
+                              func_start_entry = NULL;
                             }
-                            if (func_start_entry) {
-                              func_start_entry->data = true;
+                          }
+                          if (func_start_entry) {
+                            func_start_entry->data = true;
 
-                              addr_t symbol_file_addr = func_start_entry->addr;
-                              uint32_t symbol_flags = 0;
-                              if (is_arm) {
-                                if (symbol_file_addr & 1)
-                                  symbol_flags =
-                                      MACHO_NLIST_ARM_SYMBOL_IS_THUMB;
-                                symbol_file_addr &= THUMB_ADDRESS_BIT_MASK;
-                              }
+                            addr_t symbol_file_addr = func_start_entry->addr;
+                            uint32_t symbol_flags = 0;
+                            if (is_arm) {
+                              if (symbol_file_addr & 1)
+                                symbol_flags = MACHO_NLIST_ARM_SYMBOL_IS_THUMB;
+                              symbol_file_addr &= THUMB_ADDRESS_BIT_MASK;
+                            }
 
-                              const FunctionStarts::Entry
-                                  *next_func_start_entry =
-                                      function_starts.FindNextEntry(
-                                          func_start_entry);
-                              const addr_t section_end_file_addr =
-                                  section_file_addr +
-                                  symbol_section->GetByteSize();
-                              if (next_func_start_entry) {
-                                addr_t next_symbol_file_addr =
-                                    next_func_start_entry->addr;
-                                // Be sure the clear the Thumb address bit when
-                                // we calculate the size from the current and
-                                // next address
-                                if (is_arm)
-                                  next_symbol_file_addr &=
-                                      THUMB_ADDRESS_BIT_MASK;
-                                symbol_byte_size = std::min<lldb::addr_t>(
-                                    next_symbol_file_addr - symbol_file_addr,
-                                    section_end_file_addr - symbol_file_addr);
-                              } else {
-                                symbol_byte_size =
-                                    section_end_file_addr - symbol_file_addr;
-                              }
+                            const FunctionStarts::Entry *next_func_start_entry =
+                                function_starts.FindNextEntry(func_start_entry);
+                            const addr_t section_end_file_addr =
+                                section_file_addr +
+                                symbol_section->GetByteSize();
+                            if (next_func_start_entry) {
+                              addr_t next_symbol_file_addr =
+                                  next_func_start_entry->addr;
+                              // Be sure the clear the Thumb address bit when
+                              // we calculate the size from the current and
+                              // next address
+                              if (is_arm)
+                                next_symbol_file_addr &= THUMB_ADDRESS_BIT_MASK;
+                              symbol_byte_size = std::min<lldb::addr_t>(
+                                  next_symbol_file_addr - symbol_file_addr,
+                                  section_end_file_addr - symbol_file_addr);
+                            } else {
+                              symbol_byte_size =
+                                  section_end_file_addr - symbol_file_addr;
                             }
                           }
-                          symbol_value -= section_file_addr;
                         }
+                        symbol_value -= section_file_addr;
+                      }
 
-                        if (is_debug == false) {
-                          if (type == eSymbolTypeCode) {
-                            // See if we can find a N_FUN entry for any code
-                            // symbols. If we do find a match, and the name
-                            // matches, then we can merge the two into just the
-                            // function symbol to avoid duplicate entries in
-                            // the symbol table
-                            std::pair<ValueToSymbolIndexMap::const_iterator,
-                                      ValueToSymbolIndexMap::const_iterator>
-                                range;
-                            range = N_FUN_addr_to_sym_idx.equal_range(
-                                nlist.n_value);
-                            if (range.first != range.second) {
-                              bool found_it = false;
-                              for (ValueToSymbolIndexMap::const_iterator pos =
-                                       range.first;
-                                   pos != range.second; ++pos) {
-                                if (sym[sym_idx].GetMangled().GetName(
-                                        lldb::eLanguageTypeUnknown,
-                                        Mangled::ePreferMangled) ==
-                                    sym[pos->second].GetMangled().GetName(
-                                        lldb::eLanguageTypeUnknown,
-                                        Mangled::ePreferMangled)) {
-                                  m_nlist_idx_to_sym_idx[nlist_idx] =
-                                      pos->second;
-                                  // We just need the flags from the linker
-                                  // symbol, so put these flags
-                                  // into the N_FUN flags to avoid duplicate
-                                  // symbols in the symbol table
-                                  sym[pos->second].SetExternal(
-                                      sym[sym_idx].IsExternal());
-                                  sym[pos->second].SetFlags(nlist.n_type << 16 |
-                                                            nlist.n_desc);
-                                  if (resolver_addresses.find(nlist.n_value) !=
-                                      resolver_addresses.end())
-                                    sym[pos->second].SetType(
-                                        eSymbolTypeResolver);
-                                  sym[sym_idx].Clear();
-                                  found_it = true;
-                                  break;
-                                }
+                      if (is_debug == false) {
+                        if (type == eSymbolTypeCode) {
+                          // See if we can find a N_FUN entry for any code
+                          // symbols. If we do find a match, and the name
+                          // matches, then we can merge the two into just the
+                          // function symbol to avoid duplicate entries in
+                          // the symbol table
+                          std::pair<ValueToSymbolIndexMap::const_iterator,
+                                    ValueToSymbolIndexMap::const_iterator>
+                              range;
+                          range =
+                              N_FUN_addr_to_sym_idx.equal_range(nlist.n_value);
+                          if (range.first != range.second) {
+                            bool found_it = false;
+                            for (ValueToSymbolIndexMap::const_iterator pos =
+                                     range.first;
+                                 pos != range.second; ++pos) {
+                              if (sym[sym_idx].GetMangled().GetName(
+                                      lldb::eLanguageTypeUnknown,
+                                      Mangled::ePreferMangled) ==
+                                  sym[pos->second].GetMangled().GetName(
+                                      lldb::eLanguageTypeUnknown,
+                                      Mangled::ePreferMangled)) {
+                                m_nlist_idx_to_sym_idx[nlist_idx] = pos->second;
+                                // We just need the flags from the linker
+                                // symbol, so put these flags
+                                // into the N_FUN flags to avoid duplicate
+                                // symbols in the symbol table
+                                sym[pos->second].SetExternal(
+                                    sym[sym_idx].IsExternal());
+                                sym[pos->second].SetFlags(nlist.n_type << 16 |
+                                                          nlist.n_desc);
+                                if (resolver_addresses.find(nlist.n_value) !=
+                                    resolver_addresses.end())
+                                  sym[pos->second].SetType(eSymbolTypeResolver);
+                                sym[sym_idx].Clear();
+                                found_it = true;
+                                break;
                               }
-                              if (found_it)
-                                continue;
-                            } else {
-                              if (resolver_addresses.find(nlist.n_value) !=
-                                  resolver_addresses.end())
-                                type = eSymbolTypeResolver;
                             }
-                          } else if (type == eSymbolTypeData ||
-                                     type == eSymbolTypeObjCClass ||
-                                     type == eSymbolTypeObjCMetaClass ||
-                                     type == eSymbolTypeObjCIVar) {
-                            // See if we can find a N_STSYM entry for any data
-                            // symbols. If we do find a match, and the name
-                            // matches, then we can merge the two into just the
-                            // Static symbol to avoid duplicate entries in the
-                            // symbol table
-                            std::pair<ValueToSymbolIndexMap::const_iterator,
-                                      ValueToSymbolIndexMap::const_iterator>
-                                range;
-                            range = N_STSYM_addr_to_sym_idx.equal_range(
-                                nlist.n_value);
-                            if (range.first != range.second) {
-                              bool found_it = false;
-                              for (ValueToSymbolIndexMap::const_iterator pos =
-                                       range.first;
-                                   pos != range.second; ++pos) {
-                                if (sym[sym_idx].GetMangled().GetName(
-                                        lldb::eLanguageTypeUnknown,
-                                        Mangled::ePreferMangled) ==
-                                    sym[pos->second].GetMangled().GetName(
-                                        lldb::eLanguageTypeUnknown,
-                                        Mangled::ePreferMangled)) {
-                                  m_nlist_idx_to_sym_idx[nlist_idx] =
-                                      pos->second;
-                                  // We just need the flags from the linker
-                                  // symbol, so put these flags
-                                  // into the N_STSYM flags to avoid duplicate
-                                  // symbols in the symbol table
-                                  sym[pos->second].SetExternal(
-                                      sym[sym_idx].IsExternal());
-                                  sym[pos->second].SetFlags(nlist.n_type << 16 |
-                                                            nlist.n_desc);
-                                  sym[sym_idx].Clear();
-                                  found_it = true;
-                                  break;
-                                }
+                            if (found_it)
+                              continue;
+                          } else {
+                            if (resolver_addresses.find(nlist.n_value) !=
+                                resolver_addresses.end())
+                              type = eSymbolTypeResolver;
+                          }
+                        } else if (type == eSymbolTypeData ||
+                                   type == eSymbolTypeObjCClass ||
+                                   type == eSymbolTypeObjCMetaClass ||
+                                   type == eSymbolTypeObjCIVar) {
+                          // See if we can find a N_STSYM entry for any data
+                          // symbols. If we do find a match, and the name
+                          // matches, then we can merge the two into just the
+                          // Static symbol to avoid duplicate entries in the
+                          // symbol table
+                          std::pair<ValueToSymbolIndexMap::const_iterator,
+                                    ValueToSymbolIndexMap::const_iterator>
+                              range;
+                          range = N_STSYM_addr_to_sym_idx.equal_range(
+                              nlist.n_value);
+                          if (range.first != range.second) {
+                            bool found_it = false;
+                            for (ValueToSymbolIndexMap::const_iterator pos =
+                                     range.first;
+                                 pos != range.second; ++pos) {
+                              if (sym[sym_idx].GetMangled().GetName(
+                                      lldb::eLanguageTypeUnknown,
+                                      Mangled::ePreferMangled) ==
+                                  sym[pos->second].GetMangled().GetName(
+                                      lldb::eLanguageTypeUnknown,
+                                      Mangled::ePreferMangled)) {
+                                m_nlist_idx_to_sym_idx[nlist_idx] = pos->second;
+                                // We just need the flags from the linker
+                                // symbol, so put these flags
+                                // into the N_STSYM flags to avoid duplicate
+                                // symbols in the symbol table
+                                sym[pos->second].SetExternal(
+                                    sym[sym_idx].IsExternal());
+                                sym[pos->second].SetFlags(nlist.n_type << 16 |
+                                                          nlist.n_desc);
+                                sym[sym_idx].Clear();
+                                found_it = true;
+                                break;
                               }
-                              if (found_it)
+                            }
+                            if (found_it)
+                              continue;
+                          } else {
+                            const char *gsym_name =
+                                sym[sym_idx]
+                                    .GetMangled()
+                                    .GetName(lldb::eLanguageTypeUnknown,
+                                             Mangled::ePreferMangled)
+                                    .GetCString();
+                            if (gsym_name) {
+                              // Combine N_GSYM stab entries with the non
+                              // stab symbol
+                              ConstNameToSymbolIndexMap::const_iterator pos =
+                                  N_GSYM_name_to_sym_idx.find(gsym_name);
+                              if (pos != N_GSYM_name_to_sym_idx.end()) {
+                                const uint32_t GSYM_sym_idx = pos->second;
+                                m_nlist_idx_to_sym_idx[nlist_idx] =
+                                    GSYM_sym_idx;
+                                // Copy the address, because often the N_GSYM
+                                // address has an invalid address of zero
+                                // when the global is a common symbol
+                                sym[GSYM_sym_idx].GetAddressRef().SetSection(
+                                    symbol_section);
+                                sym[GSYM_sym_idx].GetAddressRef().SetOffset(
+                                    symbol_value);
+                                // We just need the flags from the linker
+                                // symbol, so put these flags
+                                // into the N_GSYM flags to avoid duplicate
+                                // symbols in the symbol table
+                                sym[GSYM_sym_idx].SetFlags(nlist.n_type << 16 |
+                                                           nlist.n_desc);
+                                sym[sym_idx].Clear();
                                 continue;
-                            } else {
-                              const char *gsym_name =
-                                  sym[sym_idx]
-                                      .GetMangled()
-                                      .GetName(lldb::eLanguageTypeUnknown,
-                                               Mangled::ePreferMangled)
-                                      .GetCString();
-                              if (gsym_name) {
-                                // Combine N_GSYM stab entries with the non
-                                // stab symbol
-                                ConstNameToSymbolIndexMap::const_iterator pos =
-                                    N_GSYM_name_to_sym_idx.find(gsym_name);
-                                if (pos != N_GSYM_name_to_sym_idx.end()) {
-                                  const uint32_t GSYM_sym_idx = pos->second;
-                                  m_nlist_idx_to_sym_idx[nlist_idx] =
-                                      GSYM_sym_idx;
-                                  // Copy the address, because often the N_GSYM
-                                  // address has an invalid address of zero
-                                  // when the global is a common symbol
-                                  sym[GSYM_sym_idx].GetAddressRef().SetSection(
-                                      symbol_section);
-                                  sym[GSYM_sym_idx].GetAddressRef().SetOffset(
-                                      symbol_value);
-                                  // We just need the flags from the linker
-                                  // symbol, so put these flags
-                                  // into the N_GSYM flags to avoid duplicate
-                                  // symbols in the symbol table
-                                  sym[GSYM_sym_idx].SetFlags(
-                                      nlist.n_type << 16 | nlist.n_desc);
-                                  sym[sym_idx].Clear();
-                                  continue;
-                                }
                               }
                             }
                           }
                         }
+                      }
 
-                        sym[sym_idx].SetID(nlist_idx);
-                        sym[sym_idx].SetType(type);
-                        if (set_value) {
-                          sym[sym_idx].GetAddressRef().SetSection(
-                              symbol_section);
-                          sym[sym_idx].GetAddressRef().SetOffset(symbol_value);
-                        }
-                        sym[sym_idx].SetFlags(nlist.n_type << 16 |
-                                              nlist.n_desc);
+                      sym[sym_idx].SetID(nlist_idx);
+                      sym[sym_idx].SetType(type);
+                      if (set_value) {
+                        sym[sym_idx].GetAddressRef().SetSection(symbol_section);
+                        sym[sym_idx].GetAddressRef().SetOffset(symbol_value);
+                      }
+                      sym[sym_idx].SetFlags(nlist.n_type << 16 | nlist.n_desc);
 
-                        if (symbol_byte_size > 0)
-                          sym[sym_idx].SetByteSize(symbol_byte_size);
+                      if (symbol_byte_size > 0)
+                        sym[sym_idx].SetByteSize(symbol_byte_size);
 
-                        if (demangled_is_synthesized)
-                          sym[sym_idx].SetDemangledNameIsSynthesized(true);
-                        ++sym_idx;
-                      } else {
-                        sym[sym_idx].Clear();
-                      }
+                      if (demangled_is_synthesized)
+                        sym[sym_idx].SetDemangledNameIsSynthesized(true);
+                      ++sym_idx;
+                    } else {
+                      sym[sym_idx].Clear();
                     }
-                    /////////////////////////////
                   }
-                  break; // No more entries to consider
+                  /////////////////////////////
                 }
+                break; // No more entries to consider
               }
+            }
 
-              for (const auto &pos : reexport_shlib_needs_fixup) {
-                const auto undef_pos = undefined_name_to_desc.find(pos.second);
-                if (undef_pos != undefined_name_to_desc.end()) {
-                  const uint8_t dylib_ordinal =
-                      llvm::MachO::GET_LIBRARY_ORDINAL(undef_pos->second);
-                  if (dylib_ordinal > 0 &&
-                      dylib_ordinal < dylib_files.GetSize())
-                    sym[pos.first].SetReExportedSymbolSharedLibrary(
-                        dylib_files.GetFileSpecAtIndex(dylib_ordinal - 1));
-                }
+            for (const auto &pos : reexport_shlib_needs_fixup) {
+              const auto undef_pos = undefined_name_to_desc.find(pos.second);
+              if (undef_pos != undefined_name_to_desc.end()) {
+                const uint8_t dylib_ordinal =
+                    llvm::MachO::GET_LIBRARY_ORDINAL(undef_pos->second);
+                if (dylib_ordinal > 0 && dylib_ordinal < dylib_files.GetSize())
+                  sym[pos.first].SetReExportedSymbolSharedLibrary(
+                      dylib_files.GetFileSpecAtIndex(dylib_ordinal - 1));
               }
             }
           }
         }
       }
     }
+  }
 
-    // Must reset this in case it was mutated above!
-    nlist_data_offset = 0;
+  // Must reset this in case it was mutated above!
+  nlist_data_offset = 0;
 #endif
 
-    if (nlist_data.GetByteSize() > 0) {
-
-      // If the sym array was not created while parsing the DSC unmapped
-      // symbols, create it now.
-      if (sym == nullptr) {
-        sym = symtab->Resize(symtab_load_command.nsyms +
-                             m_dysymtab.nindirectsyms);
-        num_syms = symtab->GetNumSymbols();
-      }
-
-      if (unmapped_local_symbols_found) {
-        assert(m_dysymtab.ilocalsym == 0);
-        nlist_data_offset += (m_dysymtab.nlocalsym * nlist_byte_size);
-        nlist_idx = m_dysymtab.nlocalsym;
-      } else {
-        nlist_idx = 0;
-      }
+  if (nlist_data.GetByteSize() > 0) {
 
-      typedef std::map<ConstString, uint16_t> UndefinedNameToDescMap;
-      typedef std::map<uint32_t, ConstString> SymbolIndexToName;
-      UndefinedNameToDescMap undefined_name_to_desc;
-      SymbolIndexToName reexport_shlib_needs_fixup;
-      for (; nlist_idx < symtab_load_command.nsyms; ++nlist_idx) {
-        struct nlist_64 nlist;
-        if (!nlist_data.ValidOffsetForDataOfSize(nlist_data_offset,
-                                                 nlist_byte_size))
-          break;
-
-        nlist.n_strx = nlist_data.GetU32_unchecked(&nlist_data_offset);
-        nlist.n_type = nlist_data.GetU8_unchecked(&nlist_data_offset);
-        nlist.n_sect = nlist_data.GetU8_unchecked(&nlist_data_offset);
-        nlist.n_desc = nlist_data.GetU16_unchecked(&nlist_data_offset);
-        nlist.n_value = nlist_data.GetAddress_unchecked(&nlist_data_offset);
+    // If the sym array was not created while parsing the DSC unmapped
+    // symbols, create it now.
+    if (sym == nullptr) {
+      sym =
+          symtab->Resize(symtab_load_command.nsyms + m_dysymtab.nindirectsyms);
+      num_syms = symtab->GetNumSymbols();
+    }
 
-        SymbolType type = eSymbolTypeInvalid;
-        const char *symbol_name = nullptr;
+    if (unmapped_local_symbols_found) {
+      assert(m_dysymtab.ilocalsym == 0);
+      nlist_data_offset += (m_dysymtab.nlocalsym * nlist_byte_size);
+      nlist_idx = m_dysymtab.nlocalsym;
+    } else {
+      nlist_idx = 0;
+    }
 
-        if (have_strtab_data) {
-          symbol_name = strtab_data.PeekCStr(nlist.n_strx);
+    typedef std::map<ConstString, uint16_t> UndefinedNameToDescMap;
+    typedef std::map<uint32_t, ConstString> SymbolIndexToName;
+    UndefinedNameToDescMap undefined_name_to_desc;
+    SymbolIndexToName reexport_shlib_needs_fixup;
+    for (; nlist_idx < symtab_load_command.nsyms; ++nlist_idx) {
+      struct nlist_64 nlist;
+      if (!nlist_data.ValidOffsetForDataOfSize(nlist_data_offset,
+                                               nlist_byte_size))
+        break;
 
-          if (symbol_name == nullptr) {
-            // No symbol should be NULL, even the symbols with no string values
-            // should have an offset zero which points to an empty C-string
-            Host::SystemLog(Host::eSystemLogError,
-                            "error: symbol[%u] has invalid string table offset "
-                            "0x%x in %s, ignoring symbol\n",
-                            nlist_idx, nlist.n_strx,
-                            module_sp->GetFileSpec().GetPath().c_str());
-            continue;
-          }
-          if (symbol_name[0] == '\0')
-            symbol_name = nullptr;
-        } else {
-          const addr_t str_addr = strtab_addr + nlist.n_strx;
-          Status str_error;
-          if (process->ReadCStringFromMemory(str_addr, memory_symbol_name,
-                                             str_error))
-            symbol_name = memory_symbol_name.c_str();
-        }
-        const char *symbol_name_non_abi_mangled = nullptr;
-
-        SectionSP symbol_section;
-        lldb::addr_t symbol_byte_size = 0;
-        bool add_nlist = true;
-        bool is_gsym = false;
-        bool is_debug = ((nlist.n_type & N_STAB) != 0);
-        bool demangled_is_synthesized = false;
-        bool set_value = true;
-        assert(sym_idx < num_syms);
-
-        sym[sym_idx].SetDebug(is_debug);
-
-        if (is_debug) {
-          switch (nlist.n_type) {
-          case N_GSYM:
-            // global symbol: name,,NO_SECT,type,0
-            // Sometimes the N_GSYM value contains the address.
-
-            // FIXME: In the .o files, we have a GSYM and a debug symbol for all
-            // the ObjC data.  They
-            // have the same address, but we want to ensure that we always find
-            // only the real symbol, 'cause we don't currently correctly
-            // attribute the GSYM one to the ObjCClass/Ivar/MetaClass symbol
-            // type.  This is a temporary hack to make sure the ObjectiveC
-            // symbols get treated correctly.  To do this right, we should
-            // coalesce all the GSYM & global symbols that have the same
-            // address.
-            is_gsym = true;
-            sym[sym_idx].SetExternal(true);
-
-            if (symbol_name && symbol_name[0] == '_' && symbol_name[1] == 'O') {
-              llvm::StringRef symbol_name_ref(symbol_name);
-              if (symbol_name_ref.startswith(g_objc_v2_prefix_class)) {
-                symbol_name_non_abi_mangled = symbol_name + 1;
-                symbol_name = symbol_name + g_objc_v2_prefix_class.size();
-                type = eSymbolTypeObjCClass;
-                demangled_is_synthesized = true;
-
-              } else if (symbol_name_ref.startswith(
-                             g_objc_v2_prefix_metaclass)) {
-                symbol_name_non_abi_mangled = symbol_name + 1;
-                symbol_name = symbol_name + g_objc_v2_prefix_metaclass.size();
-                type = eSymbolTypeObjCMetaClass;
-                demangled_is_synthesized = true;
-              } else if (symbol_name_ref.startswith(g_objc_v2_prefix_ivar)) {
-                symbol_name_non_abi_mangled = symbol_name + 1;
-                symbol_name = symbol_name + g_objc_v2_prefix_ivar.size();
-                type = eSymbolTypeObjCIVar;
-                demangled_is_synthesized = true;
-              }
-            } else {
-              if (nlist.n_value != 0)
-                symbol_section =
-                    section_info.GetSection(nlist.n_sect, nlist.n_value);
-              type = eSymbolTypeData;
+      nlist.n_strx = nlist_data.GetU32_unchecked(&nlist_data_offset);
+      nlist.n_type = nlist_data.GetU8_unchecked(&nlist_data_offset);
+      nlist.n_sect = nlist_data.GetU8_unchecked(&nlist_data_offset);
+      nlist.n_desc = nlist_data.GetU16_unchecked(&nlist_data_offset);
+      nlist.n_value = nlist_data.GetAddress_unchecked(&nlist_data_offset);
+
+      SymbolType type = eSymbolTypeInvalid;
+      const char *symbol_name = nullptr;
+
+      if (have_strtab_data) {
+        symbol_name = strtab_data.PeekCStr(nlist.n_strx);
+
+        if (symbol_name == nullptr) {
+          // No symbol should be NULL, even the symbols with no string values
+          // should have an offset zero which points to an empty C-string
+          Host::SystemLog(Host::eSystemLogError,
+                          "error: symbol[%u] has invalid string table offset "
+                          "0x%x in %s, ignoring symbol\n",
+                          nlist_idx, nlist.n_strx,
+                          module_sp->GetFileSpec().GetPath().c_str());
+          continue;
+        }
+        if (symbol_name[0] == '\0')
+          symbol_name = nullptr;
+      } else {
+        const addr_t str_addr = strtab_addr + nlist.n_strx;
+        Status str_error;
+        if (process->ReadCStringFromMemory(str_addr, memory_symbol_name,
+                                           str_error))
+          symbol_name = memory_symbol_name.c_str();
+      }
+      const char *symbol_name_non_abi_mangled = nullptr;
+
+      SectionSP symbol_section;
+      lldb::addr_t symbol_byte_size = 0;
+      bool add_nlist = true;
+      bool is_gsym = false;
+      bool is_debug = ((nlist.n_type & N_STAB) != 0);
+      bool demangled_is_synthesized = false;
+      bool set_value = true;
+      assert(sym_idx < num_syms);
+
+      sym[sym_idx].SetDebug(is_debug);
+
+      if (is_debug) {
+        switch (nlist.n_type) {
+        case N_GSYM:
+          // global symbol: name,,NO_SECT,type,0
+          // Sometimes the N_GSYM value contains the address.
+
+          // FIXME: In the .o files, we have a GSYM and a debug symbol for all
+          // the ObjC data.  They
+          // have the same address, but we want to ensure that we always find
+          // only the real symbol, 'cause we don't currently correctly
+          // attribute the GSYM one to the ObjCClass/Ivar/MetaClass symbol
+          // type.  This is a temporary hack to make sure the ObjectiveC
+          // symbols get treated correctly.  To do this right, we should
+          // coalesce all the GSYM & global symbols that have the same
+          // address.
+          is_gsym = true;
+          sym[sym_idx].SetExternal(true);
+
+          if (symbol_name && symbol_name[0] == '_' && symbol_name[1] == 'O') {
+            llvm::StringRef symbol_name_ref(symbol_name);
+            if (symbol_name_ref.startswith(g_objc_v2_prefix_class)) {
+              symbol_name_non_abi_mangled = symbol_name + 1;
+              symbol_name = symbol_name + g_objc_v2_prefix_class.size();
+              type = eSymbolTypeObjCClass;
+              demangled_is_synthesized = true;
+
+            } else if (symbol_name_ref.startswith(g_objc_v2_prefix_metaclass)) {
+              symbol_name_non_abi_mangled = symbol_name + 1;
+              symbol_name = symbol_name + g_objc_v2_prefix_metaclass.size();
+              type = eSymbolTypeObjCMetaClass;
+              demangled_is_synthesized = true;
+            } else if (symbol_name_ref.startswith(g_objc_v2_prefix_ivar)) {
+              symbol_name_non_abi_mangled = symbol_name + 1;
+              symbol_name = symbol_name + g_objc_v2_prefix_ivar.size();
+              type = eSymbolTypeObjCIVar;
+              demangled_is_synthesized = true;
             }
-            break;
-
-          case N_FNAME:
-            // procedure name (f77 kludge): name,,NO_SECT,0,0
-            type = eSymbolTypeCompiler;
-            break;
-
-          case N_FUN:
-            // procedure: name,,n_sect,linenumber,address
-            if (symbol_name) {
-              type = eSymbolTypeCode;
+          } else {
+            if (nlist.n_value != 0)
               symbol_section =
                   section_info.GetSection(nlist.n_sect, nlist.n_value);
+            type = eSymbolTypeData;
+          }
+          break;
 
-              N_FUN_addr_to_sym_idx.insert(
-                  std::make_pair(nlist.n_value, sym_idx));
-              // We use the current number of symbols in the symbol table in
-              // lieu of using nlist_idx in case we ever start trimming entries
-              // out
-              N_FUN_indexes.push_back(sym_idx);
-            } else {
-              type = eSymbolTypeCompiler;
-
-              if (!N_FUN_indexes.empty()) {
-                // Copy the size of the function into the original STAB entry
-                // so we don't have to hunt for it later
-                symtab->SymbolAtIndex(N_FUN_indexes.back())
-                    ->SetByteSize(nlist.n_value);
-                N_FUN_indexes.pop_back();
-                // We don't really need the end function STAB as it contains
-                // the size which we already placed with the original symbol,
-                // so don't add it if we want a minimal symbol table
-                add_nlist = false;
-              }
-            }
-            break;
+        case N_FNAME:
+          // procedure name (f77 kludge): name,,NO_SECT,0,0
+          type = eSymbolTypeCompiler;
+          break;
 
-          case N_STSYM:
-            // static symbol: name,,n_sect,type,address
-            N_STSYM_addr_to_sym_idx.insert(
-                std::make_pair(nlist.n_value, sym_idx));
+        case N_FUN:
+          // procedure: name,,n_sect,linenumber,address
+          if (symbol_name) {
+            type = eSymbolTypeCode;
             symbol_section =
                 section_info.GetSection(nlist.n_sect, nlist.n_value);
-            if (symbol_name && symbol_name[0]) {
-              type = ObjectFile::GetSymbolTypeFromName(symbol_name + 1,
-                                                       eSymbolTypeData);
+
+            N_FUN_addr_to_sym_idx.insert(
+                std::make_pair(nlist.n_value, sym_idx));
+            // We use the current number of symbols in the symbol table in
+            // lieu of using nlist_idx in case we ever start trimming entries
+            // out
+            N_FUN_indexes.push_back(sym_idx);
+          } else {
+            type = eSymbolTypeCompiler;
+
+            if (!N_FUN_indexes.empty()) {
+              // Copy the size of the function into the original STAB entry
+              // so we don't have to hunt for it later
+              symtab->SymbolAtIndex(N_FUN_indexes.back())
+                  ->SetByteSize(nlist.n_value);
+              N_FUN_indexes.pop_back();
+              // We don't really need the end function STAB as it contains
+              // the size which we already placed with the original symbol,
+              // so don't add it if we want a minimal symbol table
+              add_nlist = false;
             }
-            break;
+          }
+          break;
 
-          case N_LCSYM:
-            // .lcomm symbol: name,,n_sect,type,address
-            symbol_section =
-                section_info.GetSection(nlist.n_sect, nlist.n_value);
-            type = eSymbolTypeCommonBlock;
-            break;
+        case N_STSYM:
+          // static symbol: name,,n_sect,type,address
+          N_STSYM_addr_to_sym_idx.insert(
+              std::make_pair(nlist.n_value, sym_idx));
+          symbol_section = section_info.GetSection(nlist.n_sect, nlist.n_value);
+          if (symbol_name && symbol_name[0]) {
+            type = ObjectFile::GetSymbolTypeFromName(symbol_name + 1,
+                                                     eSymbolTypeData);
+          }
+          break;
 
-          case N_BNSYM:
-            // We use the current number of symbols in the symbol table in lieu
-            // of using nlist_idx in case we ever start trimming entries out
-            // Skip these if we want minimal symbol tables
-            add_nlist = false;
-            break;
+        case N_LCSYM:
+          // .lcomm symbol: name,,n_sect,type,address
+          symbol_section = section_info.GetSection(nlist.n_sect, nlist.n_value);
+          type = eSymbolTypeCommonBlock;
+          break;
 
-          case N_ENSYM:
-            // Set the size of the N_BNSYM to the terminating index of this
-            // N_ENSYM so that we can always skip the entire symbol if we need
-            // to navigate more quickly at the source level when parsing STABS
-            // Skip these if we want minimal symbol tables
-            add_nlist = false;
-            break;
+        case N_BNSYM:
+          // We use the current number of symbols in the symbol table in lieu
+          // of using nlist_idx in case we ever start trimming entries out
+          // Skip these if we want minimal symbol tables
+          add_nlist = false;
+          break;
 
-          case N_OPT:
-            // emitted with gcc2_compiled and in gcc source
-            type = eSymbolTypeCompiler;
-            break;
+        case N_ENSYM:
+          // Set the size of the N_BNSYM to the terminating index of this
+          // N_ENSYM so that we can always skip the entire symbol if we need
+          // to navigate more quickly at the source level when parsing STABS
+          // Skip these if we want minimal symbol tables
+          add_nlist = false;
+          break;
 
-          case N_RSYM:
-            // register sym: name,,NO_SECT,type,register
-            type = eSymbolTypeVariable;
-            break;
+        case N_OPT:
+          // emitted with gcc2_compiled and in gcc source
+          type = eSymbolTypeCompiler;
+          break;
 
-          case N_SLINE:
-            // src line: 0,,n_sect,linenumber,address
-            symbol_section =
-                section_info.GetSection(nlist.n_sect, nlist.n_value);
-            type = eSymbolTypeLineEntry;
-            break;
+        case N_RSYM:
+          // register sym: name,,NO_SECT,type,register
+          type = eSymbolTypeVariable;
+          break;
 
-          case N_SSYM:
-            // structure elt: name,,NO_SECT,type,struct_offset
-            type = eSymbolTypeVariableType;
-            break;
+        case N_SLINE:
+          // src line: 0,,n_sect,linenumber,address
+          symbol_section = section_info.GetSection(nlist.n_sect, nlist.n_value);
+          type = eSymbolTypeLineEntry;
+          break;
 
-          case N_SO:
-            // source file name
-            type = eSymbolTypeSourceFile;
-            if (symbol_name == nullptr) {
-              add_nlist = false;
-              if (N_SO_index != UINT32_MAX) {
-                // Set the size of the N_SO to the terminating index of this
-                // N_SO so that we can always skip the entire N_SO if we need
-                // to navigate more quickly at the source level when parsing
-                // STABS
-                symbol_ptr = symtab->SymbolAtIndex(N_SO_index);
-                symbol_ptr->SetByteSize(sym_idx);
-                symbol_ptr->SetSizeIsSibling(true);
+        case N_SSYM:
+          // structure elt: name,,NO_SECT,type,struct_offset
+          type = eSymbolTypeVariableType;
+          break;
+
+        case N_SO:
+          // source file name
+          type = eSymbolTypeSourceFile;
+          if (symbol_name == nullptr) {
+            add_nlist = false;
+            if (N_SO_index != UINT32_MAX) {
+              // Set the size of the N_SO to the terminating index of this
+              // N_SO so that we can always skip the entire N_SO if we need
+              // to navigate more quickly at the source level when parsing
+              // STABS
+              symbol_ptr = symtab->SymbolAtIndex(N_SO_index);
+              symbol_ptr->SetByteSize(sym_idx);
+              symbol_ptr->SetSizeIsSibling(true);
+            }
+            N_NSYM_indexes.clear();
+            N_INCL_indexes.clear();
+            N_BRAC_indexes.clear();
+            N_COMM_indexes.clear();
+            N_FUN_indexes.clear();
+            N_SO_index = UINT32_MAX;
+          } else {
+            // We use the current number of symbols in the symbol table in
+            // lieu of using nlist_idx in case we ever start trimming entries
+            // out
+            const bool N_SO_has_full_path = symbol_name[0] == '/';
+            if (N_SO_has_full_path) {
+              if ((N_SO_index == sym_idx - 1) && ((sym_idx - 1) < num_syms)) {
+                // We have two consecutive N_SO entries where the first
+                // contains a directory and the second contains a full path.
+                sym[sym_idx - 1].GetMangled().SetValue(ConstString(symbol_name),
+                                                       false);
+                m_nlist_idx_to_sym_idx[nlist_idx] = sym_idx - 1;
+                add_nlist = false;
+              } else {
+                // This is the first entry in a N_SO that contains a
+                // directory or a full path to the source file
+                N_SO_index = sym_idx;
               }
-              N_NSYM_indexes.clear();
-              N_INCL_indexes.clear();
-              N_BRAC_indexes.clear();
-              N_COMM_indexes.clear();
-              N_FUN_indexes.clear();
-              N_SO_index = UINT32_MAX;
-            } else {
-              // We use the current number of symbols in the symbol table in
-              // lieu of using nlist_idx in case we ever start trimming entries
-              // out
-              const bool N_SO_has_full_path = symbol_name[0] == '/';
-              if (N_SO_has_full_path) {
-                if ((N_SO_index == sym_idx - 1) && ((sym_idx - 1) < num_syms)) {
-                  // We have two consecutive N_SO entries where the first
-                  // contains a directory and the second contains a full path.
-                  sym[sym_idx - 1].GetMangled().SetValue(
-                      ConstString(symbol_name), false);
-                  m_nlist_idx_to_sym_idx[nlist_idx] = sym_idx - 1;
-                  add_nlist = false;
-                } else {
-                  // This is the first entry in a N_SO that contains a
-                  // directory or a full path to the source file
-                  N_SO_index = sym_idx;
-                }
-              } else if ((N_SO_index == sym_idx - 1) &&
-                         ((sym_idx - 1) < num_syms)) {
-                // This is usually the second N_SO entry that contains just the
-                // filename, so here we combine it with the first one if we are
-                // minimizing the symbol table
-                const char *so_path =
-                    sym[sym_idx - 1]
-                        .GetMangled()
-                        .GetDemangledName(lldb::eLanguageTypeUnknown)
-                        .AsCString();
-                if (so_path && so_path[0]) {
-                  std::string full_so_path(so_path);
-                  const size_t double_slash_pos = full_so_path.find("//");
-                  if (double_slash_pos != std::string::npos) {
-                    // The linker has been generating bad N_SO entries with
-                    // doubled up paths in the format "%s%s" where the first
-                    // string in the DW_AT_comp_dir, and the second is the
-                    // directory for the source file so you end up with a path
-                    // that looks like "/tmp/src//tmp/src/"
-                    FileSpec so_dir(so_path);
-                    if (!FileSystem::Instance().Exists(so_dir)) {
-                      so_dir.SetFile(&full_so_path[double_slash_pos + 1],
-                                     FileSpec::Style::native);
-                      if (FileSystem::Instance().Exists(so_dir)) {
-                        // Trim off the incorrect path
-                        full_so_path.erase(0, double_slash_pos + 1);
-                      }
+            } else if ((N_SO_index == sym_idx - 1) &&
+                       ((sym_idx - 1) < num_syms)) {
+              // This is usually the second N_SO entry that contains just the
+              // filename, so here we combine it with the first one if we are
+              // minimizing the symbol table
+              const char *so_path =
+                  sym[sym_idx - 1]
+                      .GetMangled()
+                      .GetDemangledName(lldb::eLanguageTypeUnknown)
+                      .AsCString();
+              if (so_path && so_path[0]) {
+                std::string full_so_path(so_path);
+                const size_t double_slash_pos = full_so_path.find("//");
+                if (double_slash_pos != std::string::npos) {
+                  // The linker has been generating bad N_SO entries with
+                  // doubled up paths in the format "%s%s" where the first
+                  // string in the DW_AT_comp_dir, and the second is the
+                  // directory for the source file so you end up with a path
+                  // that looks like "/tmp/src//tmp/src/"
+                  FileSpec so_dir(so_path);
+                  if (!FileSystem::Instance().Exists(so_dir)) {
+                    so_dir.SetFile(&full_so_path[double_slash_pos + 1],
+                                   FileSpec::Style::native);
+                    if (FileSystem::Instance().Exists(so_dir)) {
+                      // Trim off the incorrect path
+                      full_so_path.erase(0, double_slash_pos + 1);
                     }
                   }
-                  if (*full_so_path.rbegin() != '/')
-                    full_so_path += '/';
-                  full_so_path += symbol_name;
-                  sym[sym_idx - 1].GetMangled().SetValue(
-                      ConstString(full_so_path.c_str()), false);
-                  add_nlist = false;
-                  m_nlist_idx_to_sym_idx[nlist_idx] = sym_idx - 1;
                 }
-              } else {
-                // This could be a relative path to a N_SO
-                N_SO_index = sym_idx;
+                if (*full_so_path.rbegin() != '/')
+                  full_so_path += '/';
+                full_so_path += symbol_name;
+                sym[sym_idx - 1].GetMangled().SetValue(
+                    ConstString(full_so_path.c_str()), false);
+                add_nlist = false;
+                m_nlist_idx_to_sym_idx[nlist_idx] = sym_idx - 1;
               }
+            } else {
+              // This could be a relative path to a N_SO
+              N_SO_index = sym_idx;
             }
-            break;
-
-          case N_OSO:
-            // object file name: name,,0,0,st_mtime
-            type = eSymbolTypeObjectFile;
-            break;
-
-          case N_LSYM:
-            // local sym: name,,NO_SECT,type,offset
-            type = eSymbolTypeLocal;
-            break;
-
-          // INCL scopes
-          case N_BINCL:
-            // include file beginning: name,,NO_SECT,0,sum We use the current
-            // number of symbols in the symbol table in lieu of using nlist_idx
-            // in case we ever start trimming entries out
-            N_INCL_indexes.push_back(sym_idx);
-            type = eSymbolTypeScopeBegin;
-            break;
+          }
+          break;
 
-          case N_EINCL:
-            // include file end: name,,NO_SECT,0,0
-            // Set the size of the N_BINCL to the terminating index of this
-            // N_EINCL so that we can always skip the entire symbol if we need
-            // to navigate more quickly at the source level when parsing STABS
-            if (!N_INCL_indexes.empty()) {
-              symbol_ptr = symtab->SymbolAtIndex(N_INCL_indexes.back());
-              symbol_ptr->SetByteSize(sym_idx + 1);
-              symbol_ptr->SetSizeIsSibling(true);
-              N_INCL_indexes.pop_back();
-            }
-            type = eSymbolTypeScopeEnd;
-            break;
+        case N_OSO:
+          // object file name: name,,0,0,st_mtime
+          type = eSymbolTypeObjectFile;
+          break;
 
-          case N_SOL:
-            // #included file name: name,,n_sect,0,address
-            type = eSymbolTypeHeaderFile;
+        case N_LSYM:
+          // local sym: name,,NO_SECT,type,offset
+          type = eSymbolTypeLocal;
+          break;
 
-            // We currently don't use the header files on darwin
-            add_nlist = false;
-            break;
+        // INCL scopes
+        case N_BINCL:
+          // include file beginning: name,,NO_SECT,0,sum We use the current
+          // number of symbols in the symbol table in lieu of using nlist_idx
+          // in case we ever start trimming entries out
+          N_INCL_indexes.push_back(sym_idx);
+          type = eSymbolTypeScopeBegin;
+          break;
 
-          case N_PARAMS:
-            // compiler parameters: name,,NO_SECT,0,0
-            type = eSymbolTypeCompiler;
-            break;
+        case N_EINCL:
+          // include file end: name,,NO_SECT,0,0
+          // Set the size of the N_BINCL to the terminating index of this
+          // N_EINCL so that we can always skip the entire symbol if we need
+          // to navigate more quickly at the source level when parsing STABS
+          if (!N_INCL_indexes.empty()) {
+            symbol_ptr = symtab->SymbolAtIndex(N_INCL_indexes.back());
+            symbol_ptr->SetByteSize(sym_idx + 1);
+            symbol_ptr->SetSizeIsSibling(true);
+            N_INCL_indexes.pop_back();
+          }
+          type = eSymbolTypeScopeEnd;
+          break;
 
-          case N_VERSION:
-            // compiler version: name,,NO_SECT,0,0
-            type = eSymbolTypeCompiler;
-            break;
+        case N_SOL:
+          // #included file name: name,,n_sect,0,address
+          type = eSymbolTypeHeaderFile;
 
-          case N_OLEVEL:
-            // compiler -O level: name,,NO_SECT,0,0
-            type = eSymbolTypeCompiler;
-            break;
+          // We currently don't use the header files on darwin
+          add_nlist = false;
+          break;
 
-          case N_PSYM:
-            // parameter: name,,NO_SECT,type,offset
-            type = eSymbolTypeVariable;
-            break;
+        case N_PARAMS:
+          // compiler parameters: name,,NO_SECT,0,0
+          type = eSymbolTypeCompiler;
+          break;
 
-          case N_ENTRY:
-            // alternate entry: name,,n_sect,linenumber,address
-            symbol_section =
-                section_info.GetSection(nlist.n_sect, nlist.n_value);
-            type = eSymbolTypeLineEntry;
-            break;
+        case N_VERSION:
+          // compiler version: name,,NO_SECT,0,0
+          type = eSymbolTypeCompiler;
+          break;
 
-          // Left and Right Braces
-          case N_LBRAC:
-            // left bracket: 0,,NO_SECT,nesting level,address We use the
-            // current number of symbols in the symbol table in lieu of using
-            // nlist_idx in case we ever start trimming entries out
-            symbol_section =
-                section_info.GetSection(nlist.n_sect, nlist.n_value);
-            N_BRAC_indexes.push_back(sym_idx);
-            type = eSymbolTypeScopeBegin;
-            break;
+        case N_OLEVEL:
+          // compiler -O level: name,,NO_SECT,0,0
+          type = eSymbolTypeCompiler;
+          break;
 
-          case N_RBRAC:
-            // right bracket: 0,,NO_SECT,nesting level,address Set the size of
-            // the N_LBRAC to the terminating index of this N_RBRAC so that we
-            // can always skip the entire symbol if we need to navigate more
-            // quickly at the source level when parsing STABS
-            symbol_section =
-                section_info.GetSection(nlist.n_sect, nlist.n_value);
-            if (!N_BRAC_indexes.empty()) {
-              symbol_ptr = symtab->SymbolAtIndex(N_BRAC_indexes.back());
-              symbol_ptr->SetByteSize(sym_idx + 1);
-              symbol_ptr->SetSizeIsSibling(true);
-              N_BRAC_indexes.pop_back();
-            }
-            type = eSymbolTypeScopeEnd;
-            break;
+        case N_PSYM:
+          // parameter: name,,NO_SECT,type,offset
+          type = eSymbolTypeVariable;
+          break;
 
-          case N_EXCL:
-            // deleted include file: name,,NO_SECT,0,sum
-            type = eSymbolTypeHeaderFile;
-            break;
+        case N_ENTRY:
+          // alternate entry: name,,n_sect,linenumber,address
+          symbol_section = section_info.GetSection(nlist.n_sect, nlist.n_value);
+          type = eSymbolTypeLineEntry;
+          break;
 
-          // COMM scopes
-          case N_BCOMM:
-            // begin common: name,,NO_SECT,0,0
-            // We use the current number of symbols in the symbol table in lieu
-            // of using nlist_idx in case we ever start trimming entries out
-            type = eSymbolTypeScopeBegin;
-            N_COMM_indexes.push_back(sym_idx);
-            break;
+        // Left and Right Braces
+        case N_LBRAC:
+          // left bracket: 0,,NO_SECT,nesting level,address We use the
+          // current number of symbols in the symbol table in lieu of using
+          // nlist_idx in case we ever start trimming entries out
+          symbol_section = section_info.GetSection(nlist.n_sect, nlist.n_value);
+          N_BRAC_indexes.push_back(sym_idx);
+          type = eSymbolTypeScopeBegin;
+          break;
 
-          case N_ECOML:
-            // end common (local name): 0,,n_sect,0,address
-            symbol_section =
-                section_info.GetSection(nlist.n_sect, nlist.n_value);
-            LLVM_FALLTHROUGH;
+        case N_RBRAC:
+          // right bracket: 0,,NO_SECT,nesting level,address Set the size of
+          // the N_LBRAC to the terminating index of this N_RBRAC so that we
+          // can always skip the entire symbol if we need to navigate more
+          // quickly at the source level when parsing STABS
+          symbol_section = section_info.GetSection(nlist.n_sect, nlist.n_value);
+          if (!N_BRAC_indexes.empty()) {
+            symbol_ptr = symtab->SymbolAtIndex(N_BRAC_indexes.back());
+            symbol_ptr->SetByteSize(sym_idx + 1);
+            symbol_ptr->SetSizeIsSibling(true);
+            N_BRAC_indexes.pop_back();
+          }
+          type = eSymbolTypeScopeEnd;
+          break;
 
-          case N_ECOMM:
-            // end common: name,,n_sect,0,0
-            // Set the size of the N_BCOMM to the terminating index of this
-            // N_ECOMM/N_ECOML so that we can always skip the entire symbol if
-            // we need to navigate more quickly at the source level when
-            // parsing STABS
-            if (!N_COMM_indexes.empty()) {
-              symbol_ptr = symtab->SymbolAtIndex(N_COMM_indexes.back());
-              symbol_ptr->SetByteSize(sym_idx + 1);
-              symbol_ptr->SetSizeIsSibling(true);
-              N_COMM_indexes.pop_back();
-            }
-            type = eSymbolTypeScopeEnd;
-            break;
+        case N_EXCL:
+          // deleted include file: name,,NO_SECT,0,sum
+          type = eSymbolTypeHeaderFile;
+          break;
 
-          case N_LENG:
-            // second stab entry with length information
-            type = eSymbolTypeAdditional;
-            break;
+        // COMM scopes
+        case N_BCOMM:
+          // begin common: name,,NO_SECT,0,0
+          // We use the current number of symbols in the symbol table in lieu
+          // of using nlist_idx in case we ever start trimming entries out
+          type = eSymbolTypeScopeBegin;
+          N_COMM_indexes.push_back(sym_idx);
+          break;
 
-          default:
-            break;
+        case N_ECOML:
+          // end common (local name): 0,,n_sect,0,address
+          symbol_section = section_info.GetSection(nlist.n_sect, nlist.n_value);
+          LLVM_FALLTHROUGH;
+
+        case N_ECOMM:
+          // end common: name,,n_sect,0,0
+          // Set the size of the N_BCOMM to the terminating index of this
+          // N_ECOMM/N_ECOML so that we can always skip the entire symbol if
+          // we need to navigate more quickly at the source level when
+          // parsing STABS
+          if (!N_COMM_indexes.empty()) {
+            symbol_ptr = symtab->SymbolAtIndex(N_COMM_indexes.back());
+            symbol_ptr->SetByteSize(sym_idx + 1);
+            symbol_ptr->SetSizeIsSibling(true);
+            N_COMM_indexes.pop_back();
           }
-        } else {
-          // uint8_t n_pext    = N_PEXT & nlist.n_type;
-          uint8_t n_type = N_TYPE & nlist.n_type;
-          sym[sym_idx].SetExternal((N_EXT & nlist.n_type) != 0);
-
-          switch (n_type) {
-          case N_INDR: {
-            const char *reexport_name_cstr =
-                strtab_data.PeekCStr(nlist.n_value);
-            if (reexport_name_cstr && reexport_name_cstr[0]) {
-              type = eSymbolTypeReExported;
-              ConstString reexport_name(
-                  reexport_name_cstr +
-                  ((reexport_name_cstr[0] == '_') ? 1 : 0));
-              sym[sym_idx].SetReExportedSymbolName(reexport_name);
-              set_value = false;
-              reexport_shlib_needs_fixup[sym_idx] = reexport_name;
-              indirect_symbol_names.insert(
-                  ConstString(symbol_name + ((symbol_name[0] == '_') ? 1 : 0)));
-            } else
-              type = eSymbolTypeUndefined;
-          } break;
-
-          case N_UNDF:
-            if (symbol_name && symbol_name[0]) {
-              ConstString undefined_name(symbol_name +
-                                         ((symbol_name[0] == '_') ? 1 : 0));
-              undefined_name_to_desc[undefined_name] = nlist.n_desc;
-            }
-            LLVM_FALLTHROUGH;
+          type = eSymbolTypeScopeEnd;
+          break;
 
-          case N_PBUD:
+        case N_LENG:
+          // second stab entry with length information
+          type = eSymbolTypeAdditional;
+          break;
+
+        default:
+          break;
+        }
+      } else {
+        // uint8_t n_pext    = N_PEXT & nlist.n_type;
+        uint8_t n_type = N_TYPE & nlist.n_type;
+        sym[sym_idx].SetExternal((N_EXT & nlist.n_type) != 0);
+
+        switch (n_type) {
+        case N_INDR: {
+          const char *reexport_name_cstr = strtab_data.PeekCStr(nlist.n_value);
+          if (reexport_name_cstr && reexport_name_cstr[0]) {
+            type = eSymbolTypeReExported;
+            ConstString reexport_name(reexport_name_cstr +
+                                      ((reexport_name_cstr[0] == '_') ? 1 : 0));
+            sym[sym_idx].SetReExportedSymbolName(reexport_name);
+            set_value = false;
+            reexport_shlib_needs_fixup[sym_idx] = reexport_name;
+            indirect_symbol_names.insert(
+                ConstString(symbol_name + ((symbol_name[0] == '_') ? 1 : 0)));
+          } else
             type = eSymbolTypeUndefined;
-            break;
+        } break;
 
-          case N_ABS:
-            type = eSymbolTypeAbsolute;
-            break;
+        case N_UNDF:
+          if (symbol_name && symbol_name[0]) {
+            ConstString undefined_name(symbol_name +
+                                       ((symbol_name[0] == '_') ? 1 : 0));
+            undefined_name_to_desc[undefined_name] = nlist.n_desc;
+          }
+          LLVM_FALLTHROUGH;
 
-          case N_SECT: {
-            symbol_section =
-                section_info.GetSection(nlist.n_sect, nlist.n_value);
+        case N_PBUD:
+          type = eSymbolTypeUndefined;
+          break;
 
-            if (!symbol_section) {
-              // TODO: warn about this?
-              add_nlist = false;
-              break;
-            }
+        case N_ABS:
+          type = eSymbolTypeAbsolute;
+          break;
 
-            if (TEXT_eh_frame_sectID == nlist.n_sect) {
-              type = eSymbolTypeException;
-            } else {
-              uint32_t section_type = symbol_section->Get() & SECTION_TYPE;
+        case N_SECT: {
+          symbol_section = section_info.GetSection(nlist.n_sect, nlist.n_value);
 
-              switch (section_type) {
-              case S_CSTRING_LITERALS:
-                type = eSymbolTypeData;
-                break; // section with only literal C strings
-              case S_4BYTE_LITERALS:
-                type = eSymbolTypeData;
-                break; // section with only 4 byte literals
-              case S_8BYTE_LITERALS:
-                type = eSymbolTypeData;
-                break; // section with only 8 byte literals
-              case S_LITERAL_POINTERS:
-                type = eSymbolTypeTrampoline;
-                break; // section with only pointers to literals
-              case S_NON_LAZY_SYMBOL_POINTERS:
-                type = eSymbolTypeTrampoline;
-                break; // section with only non-lazy symbol pointers
-              case S_LAZY_SYMBOL_POINTERS:
-                type = eSymbolTypeTrampoline;
-                break; // section with only lazy symbol pointers
-              case S_SYMBOL_STUBS:
-                type = eSymbolTypeTrampoline;
-                break; // section with only symbol stubs, byte size of stub in
-                       // the reserved2 field
-              case S_MOD_INIT_FUNC_POINTERS:
-                type = eSymbolTypeCode;
-                break; // section with only function pointers for initialization
-              case S_MOD_TERM_FUNC_POINTERS:
+          if (!symbol_section) {
+            // TODO: warn about this?
+            add_nlist = false;
+            break;
+          }
+
+          if (TEXT_eh_frame_sectID == nlist.n_sect) {
+            type = eSymbolTypeException;
+          } else {
+            uint32_t section_type = symbol_section->Get() & SECTION_TYPE;
+
+            switch (section_type) {
+            case S_CSTRING_LITERALS:
+              type = eSymbolTypeData;
+              break; // section with only literal C strings
+            case S_4BYTE_LITERALS:
+              type = eSymbolTypeData;
+              break; // section with only 4 byte literals
+            case S_8BYTE_LITERALS:
+              type = eSymbolTypeData;
+              break; // section with only 8 byte literals
+            case S_LITERAL_POINTERS:
+              type = eSymbolTypeTrampoline;
+              break; // section with only pointers to literals
+            case S_NON_LAZY_SYMBOL_POINTERS:
+              type = eSymbolTypeTrampoline;
+              break; // section with only non-lazy symbol pointers
+            case S_LAZY_SYMBOL_POINTERS:
+              type = eSymbolTypeTrampoline;
+              break; // section with only lazy symbol pointers
+            case S_SYMBOL_STUBS:
+              type = eSymbolTypeTrampoline;
+              break; // section with only symbol stubs, byte size of stub in
+                     // the reserved2 field
+            case S_MOD_INIT_FUNC_POINTERS:
+              type = eSymbolTypeCode;
+              break; // section with only function pointers for initialization
+            case S_MOD_TERM_FUNC_POINTERS:
+              type = eSymbolTypeCode;
+              break; // section with only function pointers for termination
+            case S_INTERPOSING:
+              type = eSymbolTypeTrampoline;
+              break; // section with only pairs of function pointers for
+                     // interposing
+            case S_16BYTE_LITERALS:
+              type = eSymbolTypeData;
+              break; // section with only 16 byte literals
+            case S_DTRACE_DOF:
+              type = eSymbolTypeInstrumentation;
+              break;
+            case S_LAZY_DYLIB_SYMBOL_POINTERS:
+              type = eSymbolTypeTrampoline;
+              break;
+            default:
+              switch (symbol_section->GetType()) {
+              case lldb::eSectionTypeCode:
                 type = eSymbolTypeCode;
-                break; // section with only function pointers for termination
-              case S_INTERPOSING:
-                type = eSymbolTypeTrampoline;
-                break; // section with only pairs of function pointers for
-                       // interposing
-              case S_16BYTE_LITERALS:
-                type = eSymbolTypeData;
-                break; // section with only 16 byte literals
-              case S_DTRACE_DOF:
-                type = eSymbolTypeInstrumentation;
                 break;
-              case S_LAZY_DYLIB_SYMBOL_POINTERS:
-                type = eSymbolTypeTrampoline;
+              case eSectionTypeData:
+              case eSectionTypeDataCString:         // Inlined C string data
+              case eSectionTypeDataCStringPointers: // Pointers to C string
+                                                    // data
+              case eSectionTypeDataSymbolAddress:   // Address of a symbol in
+                                                    // the symbol table
+              case eSectionTypeData4:
+              case eSectionTypeData8:
+              case eSectionTypeData16:
+                type = eSymbolTypeData;
                 break;
               default:
-                switch (symbol_section->GetType()) {
-                case lldb::eSectionTypeCode:
-                  type = eSymbolTypeCode;
-                  break;
-                case eSectionTypeData:
-                case eSectionTypeDataCString:         // Inlined C string data
-                case eSectionTypeDataCStringPointers: // Pointers to C string
-                                                      // data
-                case eSectionTypeDataSymbolAddress:   // Address of a symbol in
-                                                      // the symbol table
-                case eSectionTypeData4:
-                case eSectionTypeData8:
-                case eSectionTypeData16:
-                  type = eSymbolTypeData;
-                  break;
-                default:
-                  break;
-                }
                 break;
               }
+              break;
+            }
 
-              if (type == eSymbolTypeInvalid) {
-                const char *symbol_sect_name =
-                    symbol_section->GetName().AsCString();
-                if (symbol_section->IsDescendant(text_section_sp.get())) {
-                  if (symbol_section->IsClear(S_ATTR_PURE_INSTRUCTIONS |
-                                              S_ATTR_SELF_MODIFYING_CODE |
-                                              S_ATTR_SOME_INSTRUCTIONS))
-                    type = eSymbolTypeData;
-                  else
-                    type = eSymbolTypeCode;
-                } else if (symbol_section->IsDescendant(
-                               data_section_sp.get()) ||
-                           symbol_section->IsDescendant(
-                               data_dirty_section_sp.get()) ||
-                           symbol_section->IsDescendant(
-                               data_const_section_sp.get())) {
-                  if (symbol_sect_name &&
-                      ::strstr(symbol_sect_name, "__objc") ==
-                          symbol_sect_name) {
-                    type = eSymbolTypeRuntime;
-
-                    if (symbol_name) {
-                      llvm::StringRef symbol_name_ref(symbol_name);
-                      if (symbol_name_ref.startswith("_OBJC_")) {
-                        static const llvm::StringRef g_objc_v2_prefix_class(
-                            "_OBJC_CLASS_$_");
-                        static const llvm::StringRef g_objc_v2_prefix_metaclass(
-                            "_OBJC_METACLASS_$_");
-                        static const llvm::StringRef g_objc_v2_prefix_ivar(
-                            "_OBJC_IVAR_$_");
-                        if (symbol_name_ref.startswith(
-                                g_objc_v2_prefix_class)) {
-                          symbol_name_non_abi_mangled = symbol_name + 1;
-                          symbol_name =
-                              symbol_name + g_objc_v2_prefix_class.size();
-                          type = eSymbolTypeObjCClass;
-                          demangled_is_synthesized = true;
-                        } else if (symbol_name_ref.startswith(
-                                       g_objc_v2_prefix_metaclass)) {
-                          symbol_name_non_abi_mangled = symbol_name + 1;
-                          symbol_name =
-                              symbol_name + g_objc_v2_prefix_metaclass.size();
-                          type = eSymbolTypeObjCMetaClass;
-                          demangled_is_synthesized = true;
-                        } else if (symbol_name_ref.startswith(
-                                       g_objc_v2_prefix_ivar)) {
-                          symbol_name_non_abi_mangled = symbol_name + 1;
-                          symbol_name =
-                              symbol_name + g_objc_v2_prefix_ivar.size();
-                          type = eSymbolTypeObjCIVar;
-                          demangled_is_synthesized = true;
-                        }
+            if (type == eSymbolTypeInvalid) {
+              const char *symbol_sect_name =
+                  symbol_section->GetName().AsCString();
+              if (symbol_section->IsDescendant(text_section_sp.get())) {
+                if (symbol_section->IsClear(S_ATTR_PURE_INSTRUCTIONS |
+                                            S_ATTR_SELF_MODIFYING_CODE |
+                                            S_ATTR_SOME_INSTRUCTIONS))
+                  type = eSymbolTypeData;
+                else
+                  type = eSymbolTypeCode;
+              } else if (symbol_section->IsDescendant(data_section_sp.get()) ||
+                         symbol_section->IsDescendant(
+                             data_dirty_section_sp.get()) ||
+                         symbol_section->IsDescendant(
+                             data_const_section_sp.get())) {
+                if (symbol_sect_name &&
+                    ::strstr(symbol_sect_name, "__objc") == symbol_sect_name) {
+                  type = eSymbolTypeRuntime;
+
+                  if (symbol_name) {
+                    llvm::StringRef symbol_name_ref(symbol_name);
+                    if (symbol_name_ref.startswith("_OBJC_")) {
+                      static const llvm::StringRef g_objc_v2_prefix_class(
+                          "_OBJC_CLASS_$_");
+                      static const llvm::StringRef g_objc_v2_prefix_metaclass(
+                          "_OBJC_METACLASS_$_");
+                      static const llvm::StringRef g_objc_v2_prefix_ivar(
+                          "_OBJC_IVAR_$_");
+                      if (symbol_name_ref.startswith(g_objc_v2_prefix_class)) {
+                        symbol_name_non_abi_mangled = symbol_name + 1;
+                        symbol_name =
+                            symbol_name + g_objc_v2_prefix_class.size();
+                        type = eSymbolTypeObjCClass;
+                        demangled_is_synthesized = true;
+                      } else if (symbol_name_ref.startswith(
+                                     g_objc_v2_prefix_metaclass)) {
+                        symbol_name_non_abi_mangled = symbol_name + 1;
+                        symbol_name =
+                            symbol_name + g_objc_v2_prefix_metaclass.size();
+                        type = eSymbolTypeObjCMetaClass;
+                        demangled_is_synthesized = true;
+                      } else if (symbol_name_ref.startswith(
+                                     g_objc_v2_prefix_ivar)) {
+                        symbol_name_non_abi_mangled = symbol_name + 1;
+                        symbol_name =
+                            symbol_name + g_objc_v2_prefix_ivar.size();
+                        type = eSymbolTypeObjCIVar;
+                        demangled_is_synthesized = true;
                       }
                     }
-                  } else if (symbol_sect_name &&
-                             ::strstr(symbol_sect_name, "__gcc_except_tab") ==
-                                 symbol_sect_name) {
-                    type = eSymbolTypeException;
-                  } else {
-                    type = eSymbolTypeData;
                   }
                 } else if (symbol_sect_name &&
-                           ::strstr(symbol_sect_name, "__IMPORT") ==
+                           ::strstr(symbol_sect_name, "__gcc_except_tab") ==
                                symbol_sect_name) {
-                  type = eSymbolTypeTrampoline;
-                } else if (symbol_section->IsDescendant(
-                               objc_section_sp.get())) {
-                  type = eSymbolTypeRuntime;
-                  if (symbol_name && symbol_name[0] == '.') {
-                    llvm::StringRef symbol_name_ref(symbol_name);
-                    static const llvm::StringRef g_objc_v1_prefix_class(
-                        ".objc_class_name_");
-                    if (symbol_name_ref.startswith(g_objc_v1_prefix_class)) {
-                      symbol_name_non_abi_mangled = symbol_name;
-                      symbol_name = symbol_name + g_objc_v1_prefix_class.size();
-                      type = eSymbolTypeObjCClass;
-                      demangled_is_synthesized = true;
-                    }
+                  type = eSymbolTypeException;
+                } else {
+                  type = eSymbolTypeData;
+                }
+              } else if (symbol_sect_name &&
+                         ::strstr(symbol_sect_name, "__IMPORT") ==
+                             symbol_sect_name) {
+                type = eSymbolTypeTrampoline;
+              } else if (symbol_section->IsDescendant(objc_section_sp.get())) {
+                type = eSymbolTypeRuntime;
+                if (symbol_name && symbol_name[0] == '.') {
+                  llvm::StringRef symbol_name_ref(symbol_name);
+                  static const llvm::StringRef g_objc_v1_prefix_class(
+                      ".objc_class_name_");
+                  if (symbol_name_ref.startswith(g_objc_v1_prefix_class)) {
+                    symbol_name_non_abi_mangled = symbol_name;
+                    symbol_name = symbol_name + g_objc_v1_prefix_class.size();
+                    type = eSymbolTypeObjCClass;
+                    demangled_is_synthesized = true;
                   }
                 }
               }
             }
-          } break;
           }
+        } break;
         }
+      }
 
-        if (add_nlist) {
-          uint64_t symbol_value = nlist.n_value;
-
-          if (symbol_name_non_abi_mangled) {
-            sym[sym_idx].GetMangled().SetMangledName(
-                ConstString(symbol_name_non_abi_mangled));
-            sym[sym_idx].GetMangled().SetDemangledName(
-                ConstString(symbol_name));
-          } else {
-            bool symbol_name_is_mangled = false;
+      if (add_nlist) {
+        uint64_t symbol_value = nlist.n_value;
 
-            if (symbol_name && symbol_name[0] == '_') {
-              symbol_name_is_mangled = symbol_name[1] == '_';
-              symbol_name++; // Skip the leading underscore
-            }
+        if (symbol_name_non_abi_mangled) {
+          sym[sym_idx].GetMangled().SetMangledName(
+              ConstString(symbol_name_non_abi_mangled));
+          sym[sym_idx].GetMangled().SetDemangledName(ConstString(symbol_name));
+        } else {
+          bool symbol_name_is_mangled = false;
 
-            if (symbol_name) {
-              ConstString const_symbol_name(symbol_name);
-              sym[sym_idx].GetMangled().SetValue(const_symbol_name,
-                                                 symbol_name_is_mangled);
-            }
+          if (symbol_name && symbol_name[0] == '_') {
+            symbol_name_is_mangled = symbol_name[1] == '_';
+            symbol_name++; // Skip the leading underscore
+          }
+
+          if (symbol_name) {
+            ConstString const_symbol_name(symbol_name);
+            sym[sym_idx].GetMangled().SetValue(const_symbol_name,
+                                               symbol_name_is_mangled);
           }
+        }
 
-          if (is_gsym) {
-            const char *gsym_name = sym[sym_idx]
-                                        .GetMangled()
-                                        .GetName(lldb::eLanguageTypeUnknown,
-                                                 Mangled::ePreferMangled)
-                                        .GetCString();
-            if (gsym_name)
-              N_GSYM_name_to_sym_idx[gsym_name] = sym_idx;
-          }
-
-          if (symbol_section) {
-            const addr_t section_file_addr = symbol_section->GetFileAddress();
-            if (symbol_byte_size == 0 && function_starts_count > 0) {
-              addr_t symbol_lookup_file_addr = nlist.n_value;
-              // Do an exact address match for non-ARM addresses, else get the
-              // closest since the symbol might be a thumb symbol which has an
-              // address with bit zero set
-              FunctionStarts::Entry *func_start_entry =
-                  function_starts.FindEntry(symbol_lookup_file_addr, !is_arm);
-              if (is_arm && func_start_entry) {
-                // Verify that the function start address is the symbol address
-                // (ARM) or the symbol address + 1 (thumb)
-                if (func_start_entry->addr != symbol_lookup_file_addr &&
-                    func_start_entry->addr != (symbol_lookup_file_addr + 1)) {
-                  // Not the right entry, NULL it out...
-                  func_start_entry = nullptr;
-                }
+        if (is_gsym) {
+          const char *gsym_name =
+              sym[sym_idx]
+                  .GetMangled()
+                  .GetName(lldb::eLanguageTypeUnknown, Mangled::ePreferMangled)
+                  .GetCString();
+          if (gsym_name)
+            N_GSYM_name_to_sym_idx[gsym_name] = sym_idx;
+        }
+
+        if (symbol_section) {
+          const addr_t section_file_addr = symbol_section->GetFileAddress();
+          if (symbol_byte_size == 0 && function_starts_count > 0) {
+            addr_t symbol_lookup_file_addr = nlist.n_value;
+            // Do an exact address match for non-ARM addresses, else get the
+            // closest since the symbol might be a thumb symbol which has an
+            // address with bit zero set
+            FunctionStarts::Entry *func_start_entry =
+                function_starts.FindEntry(symbol_lookup_file_addr, !is_arm);
+            if (is_arm && func_start_entry) {
+              // Verify that the function start address is the symbol address
+              // (ARM) or the symbol address + 1 (thumb)
+              if (func_start_entry->addr != symbol_lookup_file_addr &&
+                  func_start_entry->addr != (symbol_lookup_file_addr + 1)) {
+                // Not the right entry, NULL it out...
+                func_start_entry = nullptr;
               }
-              if (func_start_entry) {
-                func_start_entry->data = true;
+            }
+            if (func_start_entry) {
+              func_start_entry->data = true;
 
-                addr_t symbol_file_addr = func_start_entry->addr;
+              addr_t symbol_file_addr = func_start_entry->addr;
+              if (is_arm)
+                symbol_file_addr &= THUMB_ADDRESS_BIT_MASK;
+
+              const FunctionStarts::Entry *next_func_start_entry =
+                  function_starts.FindNextEntry(func_start_entry);
+              const addr_t section_end_file_addr =
+                  section_file_addr + symbol_section->GetByteSize();
+              if (next_func_start_entry) {
+                addr_t next_symbol_file_addr = next_func_start_entry->addr;
+                // Be sure the clear the Thumb address bit when we calculate
+                // the size from the current and next address
                 if (is_arm)
-                  symbol_file_addr &= THUMB_ADDRESS_BIT_MASK;
-
-                const FunctionStarts::Entry *next_func_start_entry =
-                    function_starts.FindNextEntry(func_start_entry);
-                const addr_t section_end_file_addr =
-                    section_file_addr + symbol_section->GetByteSize();
-                if (next_func_start_entry) {
-                  addr_t next_symbol_file_addr = next_func_start_entry->addr;
-                  // Be sure the clear the Thumb address bit when we calculate
-                  // the size from the current and next address
-                  if (is_arm)
-                    next_symbol_file_addr &= THUMB_ADDRESS_BIT_MASK;
-                  symbol_byte_size = std::min<lldb::addr_t>(
-                      next_symbol_file_addr - symbol_file_addr,
-                      section_end_file_addr - symbol_file_addr);
-                } else {
-                  symbol_byte_size = section_end_file_addr - symbol_file_addr;
-                }
+                  next_symbol_file_addr &= THUMB_ADDRESS_BIT_MASK;
+                symbol_byte_size = std::min<lldb::addr_t>(
+                    next_symbol_file_addr - symbol_file_addr,
+                    section_end_file_addr - symbol_file_addr);
+              } else {
+                symbol_byte_size = section_end_file_addr - symbol_file_addr;
               }
             }
-            symbol_value -= section_file_addr;
           }
+          symbol_value -= section_file_addr;
+        }
 
-          if (!is_debug) {
-            if (type == eSymbolTypeCode) {
-              // See if we can find a N_FUN entry for any code symbols. If we
-              // do find a match, and the name matches, then we can merge the
-              // two into just the function symbol to avoid duplicate entries
-              // in the symbol table
-              std::pair<ValueToSymbolIndexMap::const_iterator,
-                        ValueToSymbolIndexMap::const_iterator>
-                  range;
-              range = N_FUN_addr_to_sym_idx.equal_range(nlist.n_value);
-              if (range.first != range.second) {
-                bool found_it = false;
-                for (ValueToSymbolIndexMap::const_iterator pos = range.first;
-                     pos != range.second; ++pos) {
-                  if (sym[sym_idx].GetMangled().GetName(
-                          lldb::eLanguageTypeUnknown,
-                          Mangled::ePreferMangled) ==
-                      sym[pos->second].GetMangled().GetName(
-                          lldb::eLanguageTypeUnknown,
-                          Mangled::ePreferMangled)) {
-                    m_nlist_idx_to_sym_idx[nlist_idx] = pos->second;
-                    // We just need the flags from the linker symbol, so put
-                    // these flags into the N_FUN flags to avoid duplicate
-                    // symbols in the symbol table
-                    sym[pos->second].SetExternal(sym[sym_idx].IsExternal());
-                    sym[pos->second].SetFlags(nlist.n_type << 16 |
-                                              nlist.n_desc);
-                    if (resolver_addresses.find(nlist.n_value) !=
-                        resolver_addresses.end())
-                      sym[pos->second].SetType(eSymbolTypeResolver);
-                    sym[sym_idx].Clear();
-                    found_it = true;
-                    break;
-                  }
+        if (!is_debug) {
+          if (type == eSymbolTypeCode) {
+            // See if we can find a N_FUN entry for any code symbols. If we
+            // do find a match, and the name matches, then we can merge the
+            // two into just the function symbol to avoid duplicate entries
+            // in the symbol table
+            std::pair<ValueToSymbolIndexMap::const_iterator,
+                      ValueToSymbolIndexMap::const_iterator>
+                range;
+            range = N_FUN_addr_to_sym_idx.equal_range(nlist.n_value);
+            if (range.first != range.second) {
+              bool found_it = false;
+              for (ValueToSymbolIndexMap::const_iterator pos = range.first;
+                   pos != range.second; ++pos) {
+                if (sym[sym_idx].GetMangled().GetName(
+                        lldb::eLanguageTypeUnknown, Mangled::ePreferMangled) ==
+                    sym[pos->second].GetMangled().GetName(
+                        lldb::eLanguageTypeUnknown, Mangled::ePreferMangled)) {
+                  m_nlist_idx_to_sym_idx[nlist_idx] = pos->second;
+                  // We just need the flags from the linker symbol, so put
+                  // these flags into the N_FUN flags to avoid duplicate
+                  // symbols in the symbol table
+                  sym[pos->second].SetExternal(sym[sym_idx].IsExternal());
+                  sym[pos->second].SetFlags(nlist.n_type << 16 | nlist.n_desc);
+                  if (resolver_addresses.find(nlist.n_value) !=
+                      resolver_addresses.end())
+                    sym[pos->second].SetType(eSymbolTypeResolver);
+                  sym[sym_idx].Clear();
+                  found_it = true;
+                  break;
                 }
-                if (found_it)
-                  continue;
-              } else {
-                if (resolver_addresses.find(nlist.n_value) !=
-                    resolver_addresses.end())
-                  type = eSymbolTypeResolver;
               }
-            } else if (type == eSymbolTypeData ||
-                       type == eSymbolTypeObjCClass ||
-                       type == eSymbolTypeObjCMetaClass ||
-                       type == eSymbolTypeObjCIVar) {
-              // See if we can find a N_STSYM entry for any data symbols. If we
-              // do find a match, and the name matches, then we can merge the
-              // two into just the Static symbol to avoid duplicate entries in
-              // the symbol table
-              std::pair<ValueToSymbolIndexMap::const_iterator,
-                        ValueToSymbolIndexMap::const_iterator>
-                  range;
-              range = N_STSYM_addr_to_sym_idx.equal_range(nlist.n_value);
-              if (range.first != range.second) {
-                bool found_it = false;
-                for (ValueToSymbolIndexMap::const_iterator pos = range.first;
-                     pos != range.second; ++pos) {
-                  if (sym[sym_idx].GetMangled().GetName(
-                          lldb::eLanguageTypeUnknown,
-                          Mangled::ePreferMangled) ==
-                      sym[pos->second].GetMangled().GetName(
-                          lldb::eLanguageTypeUnknown,
-                          Mangled::ePreferMangled)) {
-                    m_nlist_idx_to_sym_idx[nlist_idx] = pos->second;
-                    // We just need the flags from the linker symbol, so put
-                    // these flags into the N_STSYM flags to avoid duplicate
-                    // symbols in the symbol table
-                    sym[pos->second].SetExternal(sym[sym_idx].IsExternal());
-                    sym[pos->second].SetFlags(nlist.n_type << 16 |
-                                              nlist.n_desc);
-                    sym[sym_idx].Clear();
-                    found_it = true;
-                    break;
-                  }
+              if (found_it)
+                continue;
+            } else {
+              if (resolver_addresses.find(nlist.n_value) !=
+                  resolver_addresses.end())
+                type = eSymbolTypeResolver;
+            }
+          } else if (type == eSymbolTypeData || type == eSymbolTypeObjCClass ||
+                     type == eSymbolTypeObjCMetaClass ||
+                     type == eSymbolTypeObjCIVar) {
+            // See if we can find a N_STSYM entry for any data symbols. If we
+            // do find a match, and the name matches, then we can merge the
+            // two into just the Static symbol to avoid duplicate entries in
+            // the symbol table
+            std::pair<ValueToSymbolIndexMap::const_iterator,
+                      ValueToSymbolIndexMap::const_iterator>
+                range;
+            range = N_STSYM_addr_to_sym_idx.equal_range(nlist.n_value);
+            if (range.first != range.second) {
+              bool found_it = false;
+              for (ValueToSymbolIndexMap::const_iterator pos = range.first;
+                   pos != range.second; ++pos) {
+                if (sym[sym_idx].GetMangled().GetName(
+                        lldb::eLanguageTypeUnknown, Mangled::ePreferMangled) ==
+                    sym[pos->second].GetMangled().GetName(
+                        lldb::eLanguageTypeUnknown, Mangled::ePreferMangled)) {
+                  m_nlist_idx_to_sym_idx[nlist_idx] = pos->second;
+                  // We just need the flags from the linker symbol, so put
+                  // these flags into the N_STSYM flags to avoid duplicate
+                  // symbols in the symbol table
+                  sym[pos->second].SetExternal(sym[sym_idx].IsExternal());
+                  sym[pos->second].SetFlags(nlist.n_type << 16 | nlist.n_desc);
+                  sym[sym_idx].Clear();
+                  found_it = true;
+                  break;
                 }
-                if (found_it)
+              }
+              if (found_it)
+                continue;
+            } else {
+              // Combine N_GSYM stab entries with the non stab symbol
+              const char *gsym_name = sym[sym_idx]
+                                          .GetMangled()
+                                          .GetName(lldb::eLanguageTypeUnknown,
+                                                   Mangled::ePreferMangled)
+                                          .GetCString();
+              if (gsym_name) {
+                ConstNameToSymbolIndexMap::const_iterator pos =
+                    N_GSYM_name_to_sym_idx.find(gsym_name);
+                if (pos != N_GSYM_name_to_sym_idx.end()) {
+                  const uint32_t GSYM_sym_idx = pos->second;
+                  m_nlist_idx_to_sym_idx[nlist_idx] = GSYM_sym_idx;
+                  // Copy the address, because often the N_GSYM address has
+                  // an invalid address of zero when the global is a common
+                  // symbol
+                  sym[GSYM_sym_idx].GetAddressRef().SetSection(symbol_section);
+                  sym[GSYM_sym_idx].GetAddressRef().SetOffset(symbol_value);
+                  // We just need the flags from the linker symbol, so put
+                  // these flags into the N_GSYM flags to avoid duplicate
+                  // symbols in the symbol table
+                  sym[GSYM_sym_idx].SetFlags(nlist.n_type << 16 | nlist.n_desc);
+                  sym[sym_idx].Clear();
                   continue;
-              } else {
-                // Combine N_GSYM stab entries with the non stab symbol
-                const char *gsym_name = sym[sym_idx]
-                                            .GetMangled()
-                                            .GetName(lldb::eLanguageTypeUnknown,
-                                                     Mangled::ePreferMangled)
-                                            .GetCString();
-                if (gsym_name) {
-                  ConstNameToSymbolIndexMap::const_iterator pos =
-                      N_GSYM_name_to_sym_idx.find(gsym_name);
-                  if (pos != N_GSYM_name_to_sym_idx.end()) {
-                    const uint32_t GSYM_sym_idx = pos->second;
-                    m_nlist_idx_to_sym_idx[nlist_idx] = GSYM_sym_idx;
-                    // Copy the address, because often the N_GSYM address has
-                    // an invalid address of zero when the global is a common
-                    // symbol
-                    sym[GSYM_sym_idx].GetAddressRef().SetSection(
-                        symbol_section);
-                    sym[GSYM_sym_idx].GetAddressRef().SetOffset(symbol_value);
-                    // We just need the flags from the linker symbol, so put
-                    // these flags into the N_GSYM flags to avoid duplicate
-                    // symbols in the symbol table
-                    sym[GSYM_sym_idx].SetFlags(nlist.n_type << 16 |
-                                               nlist.n_desc);
-                    sym[sym_idx].Clear();
-                    continue;
-                  }
                 }
               }
             }
           }
+        }
 
-          sym[sym_idx].SetID(nlist_idx);
-          sym[sym_idx].SetType(type);
-          if (set_value) {
-            sym[sym_idx].GetAddressRef().SetSection(symbol_section);
-            sym[sym_idx].GetAddressRef().SetOffset(symbol_value);
-          }
-          sym[sym_idx].SetFlags(nlist.n_type << 16 | nlist.n_desc);
-          if (nlist.n_desc & N_WEAK_REF)
-            sym[sym_idx].SetIsWeak(true);
+        sym[sym_idx].SetID(nlist_idx);
+        sym[sym_idx].SetType(type);
+        if (set_value) {
+          sym[sym_idx].GetAddressRef().SetSection(symbol_section);
+          sym[sym_idx].GetAddressRef().SetOffset(symbol_value);
+        }
+        sym[sym_idx].SetFlags(nlist.n_type << 16 | nlist.n_desc);
+        if (nlist.n_desc & N_WEAK_REF)
+          sym[sym_idx].SetIsWeak(true);
 
-          if (symbol_byte_size > 0)
-            sym[sym_idx].SetByteSize(symbol_byte_size);
+        if (symbol_byte_size > 0)
+          sym[sym_idx].SetByteSize(symbol_byte_size);
 
-          if (demangled_is_synthesized)
-            sym[sym_idx].SetDemangledNameIsSynthesized(true);
+        if (demangled_is_synthesized)
+          sym[sym_idx].SetDemangledNameIsSynthesized(true);
 
-          ++sym_idx;
-        } else {
-          sym[sym_idx].Clear();
-        }
+        ++sym_idx;
+      } else {
+        sym[sym_idx].Clear();
       }
+    }
 
-      for (const auto &pos : reexport_shlib_needs_fixup) {
-        const auto undef_pos = undefined_name_to_desc.find(pos.second);
-        if (undef_pos != undefined_name_to_desc.end()) {
-          const uint8_t dylib_ordinal =
-              llvm::MachO::GET_LIBRARY_ORDINAL(undef_pos->second);
-          if (dylib_ordinal > 0 && dylib_ordinal < dylib_files.GetSize())
-            sym[pos.first].SetReExportedSymbolSharedLibrary(
-                dylib_files.GetFileSpecAtIndex(dylib_ordinal - 1));
-        }
+    for (const auto &pos : reexport_shlib_needs_fixup) {
+      const auto undef_pos = undefined_name_to_desc.find(pos.second);
+      if (undef_pos != undefined_name_to_desc.end()) {
+        const uint8_t dylib_ordinal =
+            llvm::MachO::GET_LIBRARY_ORDINAL(undef_pos->second);
+        if (dylib_ordinal > 0 && dylib_ordinal < dylib_files.GetSize())
+          sym[pos.first].SetReExportedSymbolSharedLibrary(
+              dylib_files.GetFileSpecAtIndex(dylib_ordinal - 1));
       }
     }
+  }
 
-    uint32_t synthetic_sym_id = symtab_load_command.nsyms;
+  uint32_t synthetic_sym_id = symtab_load_command.nsyms;
 
-    if (function_starts_count > 0) {
-      uint32_t num_synthetic_function_symbols = 0;
-      for (i = 0; i < function_starts_count; ++i) {
-        if (!function_starts.GetEntryRef(i).data)
-          ++num_synthetic_function_symbols;
-      }
+  if (function_starts_count > 0) {
+    uint32_t num_synthetic_function_symbols = 0;
+    for (i = 0; i < function_starts_count; ++i) {
+      if (!function_starts.GetEntryRef(i).data)
+        ++num_synthetic_function_symbols;
+    }
 
-      if (num_synthetic_function_symbols > 0) {
-        if (num_syms < sym_idx + num_synthetic_function_symbols) {
-          num_syms = sym_idx + num_synthetic_function_symbols;
-          sym = symtab->Resize(num_syms);
-        }
-        for (i = 0; i < function_starts_count; ++i) {
-          const FunctionStarts::Entry *func_start_entry =
-              function_starts.GetEntryAtIndex(i);
-          if (!func_start_entry->data) {
-            addr_t symbol_file_addr = func_start_entry->addr;
-            uint32_t symbol_flags = 0;
-            if (is_arm) {
-              if (symbol_file_addr & 1)
-                symbol_flags = MACHO_NLIST_ARM_SYMBOL_IS_THUMB;
-              symbol_file_addr &= THUMB_ADDRESS_BIT_MASK;
-            }
-            Address symbol_addr;
-            if (module_sp->ResolveFileAddress(symbol_file_addr, symbol_addr)) {
-              SectionSP symbol_section(symbol_addr.GetSection());
-              uint32_t symbol_byte_size = 0;
-              if (symbol_section) {
-                const addr_t section_file_addr =
-                    symbol_section->GetFileAddress();
-                const FunctionStarts::Entry *next_func_start_entry =
-                    function_starts.FindNextEntry(func_start_entry);
-                const addr_t section_end_file_addr =
-                    section_file_addr + symbol_section->GetByteSize();
-                if (next_func_start_entry) {
-                  addr_t next_symbol_file_addr = next_func_start_entry->addr;
-                  if (is_arm)
-                    next_symbol_file_addr &= THUMB_ADDRESS_BIT_MASK;
-                  symbol_byte_size = std::min<lldb::addr_t>(
-                      next_symbol_file_addr - symbol_file_addr,
-                      section_end_file_addr - symbol_file_addr);
-                } else {
-                  symbol_byte_size = section_end_file_addr - symbol_file_addr;
-                }
-                sym[sym_idx].SetID(synthetic_sym_id++);
-                sym[sym_idx].GetMangled().SetDemangledName(
-                    GetNextSyntheticSymbolName());
-                sym[sym_idx].SetType(eSymbolTypeCode);
-                sym[sym_idx].SetIsSynthetic(true);
-                sym[sym_idx].GetAddressRef() = symbol_addr;
-                if (symbol_flags)
-                  sym[sym_idx].SetFlags(symbol_flags);
-                if (symbol_byte_size)
-                  sym[sym_idx].SetByteSize(symbol_byte_size);
-                ++sym_idx;
+    if (num_synthetic_function_symbols > 0) {
+      if (num_syms < sym_idx + num_synthetic_function_symbols) {
+        num_syms = sym_idx + num_synthetic_function_symbols;
+        sym = symtab->Resize(num_syms);
+      }
+      for (i = 0; i < function_starts_count; ++i) {
+        const FunctionStarts::Entry *func_start_entry =
+            function_starts.GetEntryAtIndex(i);
+        if (!func_start_entry->data) {
+          addr_t symbol_file_addr = func_start_entry->addr;
+          uint32_t symbol_flags = 0;
+          if (is_arm) {
+            if (symbol_file_addr & 1)
+              symbol_flags = MACHO_NLIST_ARM_SYMBOL_IS_THUMB;
+            symbol_file_addr &= THUMB_ADDRESS_BIT_MASK;
+          }
+          Address symbol_addr;
+          if (module_sp->ResolveFileAddress(symbol_file_addr, symbol_addr)) {
+            SectionSP symbol_section(symbol_addr.GetSection());
+            uint32_t symbol_byte_size = 0;
+            if (symbol_section) {
+              const addr_t section_file_addr = symbol_section->GetFileAddress();
+              const FunctionStarts::Entry *next_func_start_entry =
+                  function_starts.FindNextEntry(func_start_entry);
+              const addr_t section_end_file_addr =
+                  section_file_addr + symbol_section->GetByteSize();
+              if (next_func_start_entry) {
+                addr_t next_symbol_file_addr = next_func_start_entry->addr;
+                if (is_arm)
+                  next_symbol_file_addr &= THUMB_ADDRESS_BIT_MASK;
+                symbol_byte_size = std::min<lldb::addr_t>(
+                    next_symbol_file_addr - symbol_file_addr,
+                    section_end_file_addr - symbol_file_addr);
+              } else {
+                symbol_byte_size = section_end_file_addr - symbol_file_addr;
               }
+              sym[sym_idx].SetID(synthetic_sym_id++);
+              sym[sym_idx].GetMangled().SetDemangledName(
+                  GetNextSyntheticSymbolName());
+              sym[sym_idx].SetType(eSymbolTypeCode);
+              sym[sym_idx].SetIsSynthetic(true);
+              sym[sym_idx].GetAddressRef() = symbol_addr;
+              if (symbol_flags)
+                sym[sym_idx].SetFlags(symbol_flags);
+              if (symbol_byte_size)
+                sym[sym_idx].SetByteSize(symbol_byte_size);
+              ++sym_idx;
             }
           }
         }
       }
     }
+  }
 
-    // Trim our symbols down to just what we ended up with after removing any
-    // symbols.
-    if (sym_idx < num_syms) {
-      num_syms = sym_idx;
-      sym = symtab->Resize(num_syms);
-    }
-
-    // Now synthesize indirect symbols
-    if (m_dysymtab.nindirectsyms != 0) {
-      if (indirect_symbol_index_data.GetByteSize()) {
-        NListIndexToSymbolIndexMap::const_iterator end_index_pos =
-            m_nlist_idx_to_sym_idx.end();
-
-        for (uint32_t sect_idx = 1; sect_idx < m_mach_sections.size();
-             ++sect_idx) {
-          if ((m_mach_sections[sect_idx].flags & SECTION_TYPE) ==
-              S_SYMBOL_STUBS) {
-            uint32_t symbol_stub_byte_size =
-                m_mach_sections[sect_idx].reserved2;
-            if (symbol_stub_byte_size == 0)
-              continue;
+  // Trim our symbols down to just what we ended up with after removing any
+  // symbols.
+  if (sym_idx < num_syms) {
+    num_syms = sym_idx;
+    sym = symtab->Resize(num_syms);
+  }
+
+  // Now synthesize indirect symbols
+  if (m_dysymtab.nindirectsyms != 0) {
+    if (indirect_symbol_index_data.GetByteSize()) {
+      NListIndexToSymbolIndexMap::const_iterator end_index_pos =
+          m_nlist_idx_to_sym_idx.end();
+
+      for (uint32_t sect_idx = 1; sect_idx < m_mach_sections.size();
+           ++sect_idx) {
+        if ((m_mach_sections[sect_idx].flags & SECTION_TYPE) ==
+            S_SYMBOL_STUBS) {
+          uint32_t symbol_stub_byte_size = m_mach_sections[sect_idx].reserved2;
+          if (symbol_stub_byte_size == 0)
+            continue;
 
-            const uint32_t num_symbol_stubs =
-                m_mach_sections[sect_idx].size / symbol_stub_byte_size;
+          const uint32_t num_symbol_stubs =
+              m_mach_sections[sect_idx].size / symbol_stub_byte_size;
 
-            if (num_symbol_stubs == 0)
-              continue;
+          if (num_symbol_stubs == 0)
+            continue;
 
-            const uint32_t symbol_stub_index_offset =
-                m_mach_sections[sect_idx].reserved1;
-            for (uint32_t stub_idx = 0; stub_idx < num_symbol_stubs;
-                 ++stub_idx) {
-              const uint32_t symbol_stub_index =
-                  symbol_stub_index_offset + stub_idx;
-              const lldb::addr_t symbol_stub_addr =
-                  m_mach_sections[sect_idx].addr +
-                  (stub_idx * symbol_stub_byte_size);
-              lldb::offset_t symbol_stub_offset = symbol_stub_index * 4;
-              if (indirect_symbol_index_data.ValidOffsetForDataOfSize(
-                      symbol_stub_offset, 4)) {
-                const uint32_t stub_sym_id =
-                    indirect_symbol_index_data.GetU32(&symbol_stub_offset);
-                if (stub_sym_id & (INDIRECT_SYMBOL_ABS | INDIRECT_SYMBOL_LOCAL))
-                  continue;
+          const uint32_t symbol_stub_index_offset =
+              m_mach_sections[sect_idx].reserved1;
+          for (uint32_t stub_idx = 0; stub_idx < num_symbol_stubs; ++stub_idx) {
+            const uint32_t symbol_stub_index =
+                symbol_stub_index_offset + stub_idx;
+            const lldb::addr_t symbol_stub_addr =
+                m_mach_sections[sect_idx].addr +
+                (stub_idx * symbol_stub_byte_size);
+            lldb::offset_t symbol_stub_offset = symbol_stub_index * 4;
+            if (indirect_symbol_index_data.ValidOffsetForDataOfSize(
+                    symbol_stub_offset, 4)) {
+              const uint32_t stub_sym_id =
+                  indirect_symbol_index_data.GetU32(&symbol_stub_offset);
+              if (stub_sym_id & (INDIRECT_SYMBOL_ABS | INDIRECT_SYMBOL_LOCAL))
+                continue;
 
-                NListIndexToSymbolIndexMap::const_iterator index_pos =
-                    m_nlist_idx_to_sym_idx.find(stub_sym_id);
-                Symbol *stub_symbol = nullptr;
-                if (index_pos != end_index_pos) {
-                  // We have a remapping from the original nlist index to a
-                  // current symbol index, so just look this up by index
-                  stub_symbol = symtab->SymbolAtIndex(index_pos->second);
-                } else {
-                  // We need to lookup a symbol using the original nlist symbol
-                  // index since this index is coming from the S_SYMBOL_STUBS
-                  stub_symbol = symtab->FindSymbolByID(stub_sym_id);
-                }
+              NListIndexToSymbolIndexMap::const_iterator index_pos =
+                  m_nlist_idx_to_sym_idx.find(stub_sym_id);
+              Symbol *stub_symbol = nullptr;
+              if (index_pos != end_index_pos) {
+                // We have a remapping from the original nlist index to a
+                // current symbol index, so just look this up by index
+                stub_symbol = symtab->SymbolAtIndex(index_pos->second);
+              } else {
+                // We need to lookup a symbol using the original nlist symbol
+                // index since this index is coming from the S_SYMBOL_STUBS
+                stub_symbol = symtab->FindSymbolByID(stub_sym_id);
+              }
 
-                if (stub_symbol) {
-                  Address so_addr(symbol_stub_addr, section_list);
+              if (stub_symbol) {
+                Address so_addr(symbol_stub_addr, section_list);
 
-                  if (stub_symbol->GetType() == eSymbolTypeUndefined) {
-                    // Change the external symbol into a trampoline that makes
-                    // sense These symbols were N_UNDF N_EXT, and are useless
-                    // to us, so we can re-use them so we don't have to make up
-                    // a synthetic symbol for no good reason.
-                    if (resolver_addresses.find(symbol_stub_addr) ==
-                        resolver_addresses.end())
-                      stub_symbol->SetType(eSymbolTypeTrampoline);
-                    else
-                      stub_symbol->SetType(eSymbolTypeResolver);
-                    stub_symbol->SetExternal(false);
-                    stub_symbol->GetAddressRef() = so_addr;
-                    stub_symbol->SetByteSize(symbol_stub_byte_size);
-                  } else {
-                    // Make a synthetic symbol to describe the trampoline stub
-                    Mangled stub_symbol_mangled_name(stub_symbol->GetMangled());
-                    if (sym_idx >= num_syms) {
-                      sym = symtab->Resize(++num_syms);
-                      stub_symbol = nullptr; // this pointer no longer valid
-                    }
-                    sym[sym_idx].SetID(synthetic_sym_id++);
-                    sym[sym_idx].GetMangled() = stub_symbol_mangled_name;
-                    if (resolver_addresses.find(symbol_stub_addr) ==
-                        resolver_addresses.end())
-                      sym[sym_idx].SetType(eSymbolTypeTrampoline);
-                    else
-                      sym[sym_idx].SetType(eSymbolTypeResolver);
-                    sym[sym_idx].SetIsSynthetic(true);
-                    sym[sym_idx].GetAddressRef() = so_addr;
-                    sym[sym_idx].SetByteSize(symbol_stub_byte_size);
-                    ++sym_idx;
-                  }
+                if (stub_symbol->GetType() == eSymbolTypeUndefined) {
+                  // Change the external symbol into a trampoline that makes
+                  // sense These symbols were N_UNDF N_EXT, and are useless
+                  // to us, so we can re-use them so we don't have to make up
+                  // a synthetic symbol for no good reason.
+                  if (resolver_addresses.find(symbol_stub_addr) ==
+                      resolver_addresses.end())
+                    stub_symbol->SetType(eSymbolTypeTrampoline);
+                  else
+                    stub_symbol->SetType(eSymbolTypeResolver);
+                  stub_symbol->SetExternal(false);
+                  stub_symbol->GetAddressRef() = so_addr;
+                  stub_symbol->SetByteSize(symbol_stub_byte_size);
                 } else {
-                  if (log)
-                    log->Warning("symbol stub referencing symbol table symbol "
-                                 "%u that isn't in our minimal symbol table, "
-                                 "fix this!!!",
-                                 stub_sym_id);
+                  // Make a synthetic symbol to describe the trampoline stub
+                  Mangled stub_symbol_mangled_name(stub_symbol->GetMangled());
+                  if (sym_idx >= num_syms) {
+                    sym = symtab->Resize(++num_syms);
+                    stub_symbol = nullptr; // this pointer no longer valid
+                  }
+                  sym[sym_idx].SetID(synthetic_sym_id++);
+                  sym[sym_idx].GetMangled() = stub_symbol_mangled_name;
+                  if (resolver_addresses.find(symbol_stub_addr) ==
+                      resolver_addresses.end())
+                    sym[sym_idx].SetType(eSymbolTypeTrampoline);
+                  else
+                    sym[sym_idx].SetType(eSymbolTypeResolver);
+                  sym[sym_idx].SetIsSynthetic(true);
+                  sym[sym_idx].GetAddressRef() = so_addr;
+                  sym[sym_idx].SetByteSize(symbol_stub_byte_size);
+                  ++sym_idx;
                 }
+              } else {
+                if (log)
+                  log->Warning("symbol stub referencing symbol table symbol "
+                               "%u that isn't in our minimal symbol table, "
+                               "fix this!!!",
+                               stub_sym_id);
               }
             }
           }
         }
       }
     }
+  }
 
-    if (!trie_entries.empty()) {
-      for (const auto &e : trie_entries) {
-        if (e.entry.import_name) {
-          // Only add indirect symbols from the Trie entries if we didn't have
-          // a N_INDR nlist entry for this already
-          if (indirect_symbol_names.find(e.entry.name) ==
-              indirect_symbol_names.end()) {
-            // Make a synthetic symbol to describe re-exported symbol.
-            if (sym_idx >= num_syms)
-              sym = symtab->Resize(++num_syms);
-            sym[sym_idx].SetID(synthetic_sym_id++);
-            sym[sym_idx].GetMangled() = Mangled(e.entry.name);
-            sym[sym_idx].SetType(eSymbolTypeReExported);
-            sym[sym_idx].SetIsSynthetic(true);
-            sym[sym_idx].SetReExportedSymbolName(e.entry.import_name);
-            if (e.entry.other > 0 && e.entry.other <= dylib_files.GetSize()) {
-              sym[sym_idx].SetReExportedSymbolSharedLibrary(
-                  dylib_files.GetFileSpecAtIndex(e.entry.other - 1));
-            }
-            ++sym_idx;
+  if (!trie_entries.empty()) {
+    for (const auto &e : trie_entries) {
+      if (e.entry.import_name) {
+        // Only add indirect symbols from the Trie entries if we didn't have
+        // a N_INDR nlist entry for this already
+        if (indirect_symbol_names.find(e.entry.name) ==
+            indirect_symbol_names.end()) {
+          // Make a synthetic symbol to describe re-exported symbol.
+          if (sym_idx >= num_syms)
+            sym = symtab->Resize(++num_syms);
+          sym[sym_idx].SetID(synthetic_sym_id++);
+          sym[sym_idx].GetMangled() = Mangled(e.entry.name);
+          sym[sym_idx].SetType(eSymbolTypeReExported);
+          sym[sym_idx].SetIsSynthetic(true);
+          sym[sym_idx].SetReExportedSymbolName(e.entry.import_name);
+          if (e.entry.other > 0 && e.entry.other <= dylib_files.GetSize()) {
+            sym[sym_idx].SetReExportedSymbolSharedLibrary(
+                dylib_files.GetFileSpecAtIndex(e.entry.other - 1));
           }
+          ++sym_idx;
         }
       }
     }
+  }
 
-    //        StreamFile s(stdout, false);
-    //        s.Printf ("Symbol table before CalculateSymbolSizes():\n");
-    //        symtab->Dump(&s, NULL, eSortOrderNone);
-    // Set symbol byte sizes correctly since mach-o nlist entries don't have
-    // sizes
-    symtab->CalculateSymbolSizes();
+  //        StreamFile s(stdout, false);
+  //        s.Printf ("Symbol table before CalculateSymbolSizes():\n");
+  //        symtab->Dump(&s, NULL, eSortOrderNone);
+  // Set symbol byte sizes correctly since mach-o nlist entries don't have
+  // sizes
+  symtab->CalculateSymbolSizes();
 
-    //        s.Printf ("Symbol table after CalculateSymbolSizes():\n");
-    //        symtab->Dump(&s, NULL, eSortOrderNone);
+  //        s.Printf ("Symbol table after CalculateSymbolSizes():\n");
+  //        symtab->Dump(&s, NULL, eSortOrderNone);
 
-    return symtab->GetNumSymbols();
-  }
-  return 0;
+  return symtab->GetNumSymbols();
 }
 
 void ObjectFileMachO::Dump(Stream *s) {
@@ -5226,8 +5173,9 @@ lldb_private::Address ObjectFileMachO::G
 
           switch (m_header.cputype) {
           case llvm::MachO::CPU_TYPE_ARM:
-            if (flavor == 1 || flavor == 9) // ARM_THREAD_STATE/ARM_THREAD_STATE32
-                                            // from mach/arm/thread_status.h
+            if (flavor == 1 ||
+                flavor == 9) // ARM_THREAD_STATE/ARM_THREAD_STATE32
+                             // from mach/arm/thread_status.h
             {
               offset += 60; // This is the offset of pc in the GPR thread state
                             // data structure.
@@ -6014,334 +5962,334 @@ lldb::addr_t ObjectFileMachO::CalculateS
 bool ObjectFileMachO::SetLoadAddress(Target &target, lldb::addr_t value,
                                      bool value_is_offset) {
   ModuleSP module_sp = GetModule();
-  if (module_sp) {
-    size_t num_loaded_sections = 0;
-    SectionList *section_list = GetSectionList();
-    if (section_list) {
-      const size_t num_sections = section_list->GetSize();
-
-      if (value_is_offset) {
-        // "value" is an offset to apply to each top level segment
-        for (size_t sect_idx = 0; sect_idx < num_sections; ++sect_idx) {
-          // Iterate through the object file sections to find all of the
-          // sections that size on disk (to avoid __PAGEZERO) and load them
-          SectionSP section_sp(section_list->GetSectionAtIndex(sect_idx));
-          if (SectionIsLoadable(section_sp.get()))
-            if (target.GetSectionLoadList().SetSectionLoadAddress(
-                    section_sp, section_sp->GetFileAddress() + value))
-              ++num_loaded_sections;
-        }
-      } else {
-        // "value" is the new base address of the mach_header, adjust each
-        // section accordingly
+  if (!module_sp)
+    return false;
 
-        Section *mach_header_section = GetMachHeaderSection();
-        if (mach_header_section) {
-          for (size_t sect_idx = 0; sect_idx < num_sections; ++sect_idx) {
-            SectionSP section_sp(section_list->GetSectionAtIndex(sect_idx));
-
-            lldb::addr_t section_load_addr =
-                CalculateSectionLoadAddressForMemoryImage(
-                    value, mach_header_section, section_sp.get());
-            if (section_load_addr != LLDB_INVALID_ADDRESS) {
-              if (target.GetSectionLoadList().SetSectionLoadAddress(
-                      section_sp, section_load_addr))
-                ++num_loaded_sections;
-            }
-          }
+  SectionList *section_list = GetSectionList();
+  if (!section_list)
+    return false;
+
+  size_t num_loaded_sections = 0;
+  const size_t num_sections = section_list->GetSize();
+
+  if (value_is_offset) {
+    // "value" is an offset to apply to each top level segment
+    for (size_t sect_idx = 0; sect_idx < num_sections; ++sect_idx) {
+      // Iterate through the object file sections to find all of the
+      // sections that size on disk (to avoid __PAGEZERO) and load them
+      SectionSP section_sp(section_list->GetSectionAtIndex(sect_idx));
+      if (SectionIsLoadable(section_sp.get()))
+        if (target.GetSectionLoadList().SetSectionLoadAddress(
+                section_sp, section_sp->GetFileAddress() + value))
+          ++num_loaded_sections;
+    }
+  } else {
+    // "value" is the new base address of the mach_header, adjust each
+    // section accordingly
+
+    Section *mach_header_section = GetMachHeaderSection();
+    if (mach_header_section) {
+      for (size_t sect_idx = 0; sect_idx < num_sections; ++sect_idx) {
+        SectionSP section_sp(section_list->GetSectionAtIndex(sect_idx));
+
+        lldb::addr_t section_load_addr =
+            CalculateSectionLoadAddressForMemoryImage(
+                value, mach_header_section, section_sp.get());
+        if (section_load_addr != LLDB_INVALID_ADDRESS) {
+          if (target.GetSectionLoadList().SetSectionLoadAddress(
+                  section_sp, section_load_addr))
+            ++num_loaded_sections;
         }
       }
     }
-    return num_loaded_sections > 0;
   }
-  return false;
+  return num_loaded_sections > 0;
 }
 
 bool ObjectFileMachO::SaveCore(const lldb::ProcessSP &process_sp,
                                const FileSpec &outfile, Status &error) {
-  if (process_sp) {
-    Target &target = process_sp->GetTarget();
-    const ArchSpec target_arch = target.GetArchitecture();
-    const llvm::Triple &target_triple = target_arch.GetTriple();
-    if (target_triple.getVendor() == llvm::Triple::Apple &&
-        (target_triple.getOS() == llvm::Triple::MacOSX ||
-         target_triple.getOS() == llvm::Triple::IOS ||
-         target_triple.getOS() == llvm::Triple::WatchOS ||
-         target_triple.getOS() == llvm::Triple::TvOS)) {
-      // NEED_BRIDGEOS_TRIPLE target_triple.getOS() == llvm::Triple::BridgeOS))
-      // {
-      bool make_core = false;
-      switch (target_arch.GetMachine()) {
-      case llvm::Triple::aarch64:
-      case llvm::Triple::arm:
-      case llvm::Triple::thumb:
-      case llvm::Triple::x86:
-      case llvm::Triple::x86_64:
-        make_core = true;
-        break;
-      default:
-        error.SetErrorStringWithFormat("unsupported core architecture: %s",
-                                       target_triple.str().c_str());
-        break;
-      }
-
-      if (make_core) {
-        std::vector<segment_command_64> segment_load_commands;
-        //                uint32_t range_info_idx = 0;
-        MemoryRegionInfo range_info;
-        Status range_error = process_sp->GetMemoryRegionInfo(0, range_info);
-        const uint32_t addr_byte_size = target_arch.GetAddressByteSize();
-        const ByteOrder byte_order = target_arch.GetByteOrder();
-        if (range_error.Success()) {
-          while (range_info.GetRange().GetRangeBase() != LLDB_INVALID_ADDRESS) {
-            const addr_t addr = range_info.GetRange().GetRangeBase();
-            const addr_t size = range_info.GetRange().GetByteSize();
+  if (!process_sp)
+    return false;
 
-            if (size == 0)
-              break;
+  Target &target = process_sp->GetTarget();
+  const ArchSpec target_arch = target.GetArchitecture();
+  const llvm::Triple &target_triple = target_arch.GetTriple();
+  if (target_triple.getVendor() == llvm::Triple::Apple &&
+      (target_triple.getOS() == llvm::Triple::MacOSX ||
+       target_triple.getOS() == llvm::Triple::IOS ||
+       target_triple.getOS() == llvm::Triple::WatchOS ||
+       target_triple.getOS() == llvm::Triple::TvOS)) {
+    // NEED_BRIDGEOS_TRIPLE target_triple.getOS() == llvm::Triple::BridgeOS))
+    // {
+    bool make_core = false;
+    switch (target_arch.GetMachine()) {
+    case llvm::Triple::aarch64:
+    case llvm::Triple::arm:
+    case llvm::Triple::thumb:
+    case llvm::Triple::x86:
+    case llvm::Triple::x86_64:
+      make_core = true;
+      break;
+    default:
+      error.SetErrorStringWithFormat("unsupported core architecture: %s",
+                                     target_triple.str().c_str());
+      break;
+    }
 
-            // Calculate correct protections
-            uint32_t prot = 0;
-            if (range_info.GetReadable() == MemoryRegionInfo::eYes)
-              prot |= VM_PROT_READ;
-            if (range_info.GetWritable() == MemoryRegionInfo::eYes)
-              prot |= VM_PROT_WRITE;
-            if (range_info.GetExecutable() == MemoryRegionInfo::eYes)
-              prot |= VM_PROT_EXECUTE;
-
-            if (prot != 0) {
-              uint32_t cmd_type = LC_SEGMENT_64;
-              uint32_t segment_size = sizeof(segment_command_64);
-              if (addr_byte_size == 4) {
-                cmd_type = LC_SEGMENT;
-                segment_size = sizeof(segment_command);
-              }
-              segment_command_64 segment = {
-                  cmd_type,     // uint32_t cmd;
-                  segment_size, // uint32_t cmdsize;
-                  {0},          // char segname[16];
-                  addr, // uint64_t vmaddr;    // uint32_t for 32-bit Mach-O
-                  size, // uint64_t vmsize;    // uint32_t for 32-bit Mach-O
-                  0,    // uint64_t fileoff;   // uint32_t for 32-bit Mach-O
-                  size, // uint64_t filesize;  // uint32_t for 32-bit Mach-O
-                  prot, // uint32_t maxprot;
-                  prot, // uint32_t initprot;
-                  0,    // uint32_t nsects;
-                  0};   // uint32_t flags;
-              segment_load_commands.push_back(segment);
-            } else {
-              // No protections and a size of 1 used to be returned from old
-              // debugservers when we asked about a region that was past the
-              // last memory region and it indicates the end...
-              if (size == 1)
-                break;
+    if (make_core) {
+      std::vector<segment_command_64> segment_load_commands;
+      //                uint32_t range_info_idx = 0;
+      MemoryRegionInfo range_info;
+      Status range_error = process_sp->GetMemoryRegionInfo(0, range_info);
+      const uint32_t addr_byte_size = target_arch.GetAddressByteSize();
+      const ByteOrder byte_order = target_arch.GetByteOrder();
+      if (range_error.Success()) {
+        while (range_info.GetRange().GetRangeBase() != LLDB_INVALID_ADDRESS) {
+          const addr_t addr = range_info.GetRange().GetRangeBase();
+          const addr_t size = range_info.GetRange().GetByteSize();
+
+          if (size == 0)
+            break;
+
+          // Calculate correct protections
+          uint32_t prot = 0;
+          if (range_info.GetReadable() == MemoryRegionInfo::eYes)
+            prot |= VM_PROT_READ;
+          if (range_info.GetWritable() == MemoryRegionInfo::eYes)
+            prot |= VM_PROT_WRITE;
+          if (range_info.GetExecutable() == MemoryRegionInfo::eYes)
+            prot |= VM_PROT_EXECUTE;
+
+          if (prot != 0) {
+            uint32_t cmd_type = LC_SEGMENT_64;
+            uint32_t segment_size = sizeof(segment_command_64);
+            if (addr_byte_size == 4) {
+              cmd_type = LC_SEGMENT;
+              segment_size = sizeof(segment_command);
             }
-
-            range_error = process_sp->GetMemoryRegionInfo(
-                range_info.GetRange().GetRangeEnd(), range_info);
-            if (range_error.Fail())
+            segment_command_64 segment = {
+                cmd_type,     // uint32_t cmd;
+                segment_size, // uint32_t cmdsize;
+                {0},          // char segname[16];
+                addr, // uint64_t vmaddr;    // uint32_t for 32-bit Mach-O
+                size, // uint64_t vmsize;    // uint32_t for 32-bit Mach-O
+                0,    // uint64_t fileoff;   // uint32_t for 32-bit Mach-O
+                size, // uint64_t filesize;  // uint32_t for 32-bit Mach-O
+                prot, // uint32_t maxprot;
+                prot, // uint32_t initprot;
+                0,    // uint32_t nsects;
+                0};   // uint32_t flags;
+            segment_load_commands.push_back(segment);
+          } else {
+            // No protections and a size of 1 used to be returned from old
+            // debugservers when we asked about a region that was past the
+            // last memory region and it indicates the end...
+            if (size == 1)
               break;
           }
 
-          StreamString buffer(Stream::eBinary, addr_byte_size, byte_order);
+          range_error = process_sp->GetMemoryRegionInfo(
+              range_info.GetRange().GetRangeEnd(), range_info);
+          if (range_error.Fail())
+            break;
+        }
 
-          mach_header_64 mach_header;
-          if (addr_byte_size == 8) {
-            mach_header.magic = MH_MAGIC_64;
-          } else {
-            mach_header.magic = MH_MAGIC;
-          }
-          mach_header.cputype = target_arch.GetMachOCPUType();
-          mach_header.cpusubtype = target_arch.GetMachOCPUSubType();
-          mach_header.filetype = MH_CORE;
-          mach_header.ncmds = segment_load_commands.size();
-          mach_header.flags = 0;
-          mach_header.reserved = 0;
-          ThreadList &thread_list = process_sp->GetThreadList();
-          const uint32_t num_threads = thread_list.GetSize();
-
-          // Make an array of LC_THREAD data items. Each one contains the
-          // contents of the LC_THREAD load command. The data doesn't contain
-          // the load command + load command size, we will add the load command
-          // and load command size as we emit the data.
-          std::vector<StreamString> LC_THREAD_datas(num_threads);
-          for (auto &LC_THREAD_data : LC_THREAD_datas) {
-            LC_THREAD_data.GetFlags().Set(Stream::eBinary);
-            LC_THREAD_data.SetAddressByteSize(addr_byte_size);
-            LC_THREAD_data.SetByteOrder(byte_order);
-          }
-          for (uint32_t thread_idx = 0; thread_idx < num_threads;
-               ++thread_idx) {
-            ThreadSP thread_sp(thread_list.GetThreadAtIndex(thread_idx));
-            if (thread_sp) {
-              switch (mach_header.cputype) {
-              case llvm::MachO::CPU_TYPE_ARM64:
-                RegisterContextDarwin_arm64_Mach::Create_LC_THREAD(
-                    thread_sp.get(), LC_THREAD_datas[thread_idx]);
-                break;
+        StreamString buffer(Stream::eBinary, addr_byte_size, byte_order);
 
-              case llvm::MachO::CPU_TYPE_ARM:
-                RegisterContextDarwin_arm_Mach::Create_LC_THREAD(
-                    thread_sp.get(), LC_THREAD_datas[thread_idx]);
-                break;
+        mach_header_64 mach_header;
+        if (addr_byte_size == 8) {
+          mach_header.magic = MH_MAGIC_64;
+        } else {
+          mach_header.magic = MH_MAGIC;
+        }
+        mach_header.cputype = target_arch.GetMachOCPUType();
+        mach_header.cpusubtype = target_arch.GetMachOCPUSubType();
+        mach_header.filetype = MH_CORE;
+        mach_header.ncmds = segment_load_commands.size();
+        mach_header.flags = 0;
+        mach_header.reserved = 0;
+        ThreadList &thread_list = process_sp->GetThreadList();
+        const uint32_t num_threads = thread_list.GetSize();
+
+        // Make an array of LC_THREAD data items. Each one contains the
+        // contents of the LC_THREAD load command. The data doesn't contain
+        // the load command + load command size, we will add the load command
+        // and load command size as we emit the data.
+        std::vector<StreamString> LC_THREAD_datas(num_threads);
+        for (auto &LC_THREAD_data : LC_THREAD_datas) {
+          LC_THREAD_data.GetFlags().Set(Stream::eBinary);
+          LC_THREAD_data.SetAddressByteSize(addr_byte_size);
+          LC_THREAD_data.SetByteOrder(byte_order);
+        }
+        for (uint32_t thread_idx = 0; thread_idx < num_threads; ++thread_idx) {
+          ThreadSP thread_sp(thread_list.GetThreadAtIndex(thread_idx));
+          if (thread_sp) {
+            switch (mach_header.cputype) {
+            case llvm::MachO::CPU_TYPE_ARM64:
+              RegisterContextDarwin_arm64_Mach::Create_LC_THREAD(
+                  thread_sp.get(), LC_THREAD_datas[thread_idx]);
+              break;
 
-              case llvm::MachO::CPU_TYPE_I386:
-                RegisterContextDarwin_i386_Mach::Create_LC_THREAD(
-                    thread_sp.get(), LC_THREAD_datas[thread_idx]);
-                break;
+            case llvm::MachO::CPU_TYPE_ARM:
+              RegisterContextDarwin_arm_Mach::Create_LC_THREAD(
+                  thread_sp.get(), LC_THREAD_datas[thread_idx]);
+              break;
 
-              case llvm::MachO::CPU_TYPE_X86_64:
-                RegisterContextDarwin_x86_64_Mach::Create_LC_THREAD(
-                    thread_sp.get(), LC_THREAD_datas[thread_idx]);
-                break;
-              }
+            case llvm::MachO::CPU_TYPE_I386:
+              RegisterContextDarwin_i386_Mach::Create_LC_THREAD(
+                  thread_sp.get(), LC_THREAD_datas[thread_idx]);
+              break;
+
+            case llvm::MachO::CPU_TYPE_X86_64:
+              RegisterContextDarwin_x86_64_Mach::Create_LC_THREAD(
+                  thread_sp.get(), LC_THREAD_datas[thread_idx]);
+              break;
             }
           }
+        }
 
-          // The size of the load command is the size of the segments...
-          if (addr_byte_size == 8) {
-            mach_header.sizeofcmds = segment_load_commands.size() *
-                                     sizeof(struct segment_command_64);
-          } else {
-            mach_header.sizeofcmds =
-                segment_load_commands.size() * sizeof(struct segment_command);
-          }
+        // The size of the load command is the size of the segments...
+        if (addr_byte_size == 8) {
+          mach_header.sizeofcmds =
+              segment_load_commands.size() * sizeof(struct segment_command_64);
+        } else {
+          mach_header.sizeofcmds =
+              segment_load_commands.size() * sizeof(struct segment_command);
+        }
 
-          // and the size of all LC_THREAD load command
-          for (const auto &LC_THREAD_data : LC_THREAD_datas) {
-            ++mach_header.ncmds;
-            mach_header.sizeofcmds += 8 + LC_THREAD_data.GetSize();
-          }
-
-          // Write the mach header
-          buffer.PutHex32(mach_header.magic);
-          buffer.PutHex32(mach_header.cputype);
-          buffer.PutHex32(mach_header.cpusubtype);
-          buffer.PutHex32(mach_header.filetype);
-          buffer.PutHex32(mach_header.ncmds);
-          buffer.PutHex32(mach_header.sizeofcmds);
-          buffer.PutHex32(mach_header.flags);
+        // and the size of all LC_THREAD load command
+        for (const auto &LC_THREAD_data : LC_THREAD_datas) {
+          ++mach_header.ncmds;
+          mach_header.sizeofcmds += 8 + LC_THREAD_data.GetSize();
+        }
+
+        // Write the mach header
+        buffer.PutHex32(mach_header.magic);
+        buffer.PutHex32(mach_header.cputype);
+        buffer.PutHex32(mach_header.cpusubtype);
+        buffer.PutHex32(mach_header.filetype);
+        buffer.PutHex32(mach_header.ncmds);
+        buffer.PutHex32(mach_header.sizeofcmds);
+        buffer.PutHex32(mach_header.flags);
+        if (addr_byte_size == 8) {
+          buffer.PutHex32(mach_header.reserved);
+        }
+
+        // Skip the mach header and all load commands and align to the next
+        // 0x1000 byte boundary
+        addr_t file_offset = buffer.GetSize() + mach_header.sizeofcmds;
+        if (file_offset & 0x00000fff) {
+          file_offset += 0x00001000ull;
+          file_offset &= (~0x00001000ull + 1);
+        }
+
+        for (auto &segment : segment_load_commands) {
+          segment.fileoff = file_offset;
+          file_offset += segment.filesize;
+        }
+
+        // Write out all of the LC_THREAD load commands
+        for (const auto &LC_THREAD_data : LC_THREAD_datas) {
+          const size_t LC_THREAD_data_size = LC_THREAD_data.GetSize();
+          buffer.PutHex32(LC_THREAD);
+          buffer.PutHex32(8 + LC_THREAD_data_size); // cmd + cmdsize + data
+          buffer.Write(LC_THREAD_data.GetString().data(), LC_THREAD_data_size);
+        }
+
+        // Write out all of the segment load commands
+        for (const auto &segment : segment_load_commands) {
+          printf("0x%8.8x 0x%8.8x [0x%16.16" PRIx64 " - 0x%16.16" PRIx64
+                 ") [0x%16.16" PRIx64 " 0x%16.16" PRIx64
+                 ") 0x%8.8x 0x%8.8x 0x%8.8x 0x%8.8x]\n",
+                 segment.cmd, segment.cmdsize, segment.vmaddr,
+                 segment.vmaddr + segment.vmsize, segment.fileoff,
+                 segment.filesize, segment.maxprot, segment.initprot,
+                 segment.nsects, segment.flags);
+
+          buffer.PutHex32(segment.cmd);
+          buffer.PutHex32(segment.cmdsize);
+          buffer.PutRawBytes(segment.segname, sizeof(segment.segname));
           if (addr_byte_size == 8) {
-            buffer.PutHex32(mach_header.reserved);
-          }
-
-          // Skip the mach header and all load commands and align to the next
-          // 0x1000 byte boundary
-          addr_t file_offset = buffer.GetSize() + mach_header.sizeofcmds;
-          if (file_offset & 0x00000fff) {
-            file_offset += 0x00001000ull;
-            file_offset &= (~0x00001000ull + 1);
-          }
-
-          for (auto &segment : segment_load_commands) {
-            segment.fileoff = file_offset;
-            file_offset += segment.filesize;
-          }
-
-          // Write out all of the LC_THREAD load commands
-          for (const auto &LC_THREAD_data : LC_THREAD_datas) {
-            const size_t LC_THREAD_data_size = LC_THREAD_data.GetSize();
-            buffer.PutHex32(LC_THREAD);
-            buffer.PutHex32(8 + LC_THREAD_data_size); // cmd + cmdsize + data
-            buffer.Write(LC_THREAD_data.GetString().data(),
-                         LC_THREAD_data_size);
-          }
-
-          // Write out all of the segment load commands
-          for (const auto &segment : segment_load_commands) {
-            printf("0x%8.8x 0x%8.8x [0x%16.16" PRIx64 " - 0x%16.16" PRIx64
-                   ") [0x%16.16" PRIx64 " 0x%16.16" PRIx64
-                   ") 0x%8.8x 0x%8.8x 0x%8.8x 0x%8.8x]\n",
-                   segment.cmd, segment.cmdsize, segment.vmaddr,
-                   segment.vmaddr + segment.vmsize, segment.fileoff,
-                   segment.filesize, segment.maxprot, segment.initprot,
-                   segment.nsects, segment.flags);
-
-            buffer.PutHex32(segment.cmd);
-            buffer.PutHex32(segment.cmdsize);
-            buffer.PutRawBytes(segment.segname, sizeof(segment.segname));
-            if (addr_byte_size == 8) {
-              buffer.PutHex64(segment.vmaddr);
-              buffer.PutHex64(segment.vmsize);
-              buffer.PutHex64(segment.fileoff);
-              buffer.PutHex64(segment.filesize);
-            } else {
-              buffer.PutHex32(static_cast<uint32_t>(segment.vmaddr));
-              buffer.PutHex32(static_cast<uint32_t>(segment.vmsize));
-              buffer.PutHex32(static_cast<uint32_t>(segment.fileoff));
-              buffer.PutHex32(static_cast<uint32_t>(segment.filesize));
-            }
-            buffer.PutHex32(segment.maxprot);
-            buffer.PutHex32(segment.initprot);
-            buffer.PutHex32(segment.nsects);
-            buffer.PutHex32(segment.flags);
-          }
-
-          std::string core_file_path(outfile.GetPath());
-          auto core_file = FileSystem::Instance().Open(
-              outfile, File::eOpenOptionWrite | File::eOpenOptionTruncate |
-                           File::eOpenOptionCanCreate);
-          if (!core_file) {
-            error = core_file.takeError();
+            buffer.PutHex64(segment.vmaddr);
+            buffer.PutHex64(segment.vmsize);
+            buffer.PutHex64(segment.fileoff);
+            buffer.PutHex64(segment.filesize);
           } else {
-            // Read 1 page at a time
-            uint8_t bytes[0x1000];
-            // Write the mach header and load commands out to the core file
-            size_t bytes_written = buffer.GetString().size();
-            error = core_file.get()->Write(buffer.GetString().data(),
-                                           bytes_written);
-            if (error.Success()) {
-              // Now write the file data for all memory segments in the process
-              for (const auto &segment : segment_load_commands) {
-                if (core_file.get()->SeekFromStart(segment.fileoff) == -1) {
-                  error.SetErrorStringWithFormat(
-                      "unable to seek to offset 0x%" PRIx64 " in '%s'",
-                      segment.fileoff, core_file_path.c_str());
-                  break;
-                }
+            buffer.PutHex32(static_cast<uint32_t>(segment.vmaddr));
+            buffer.PutHex32(static_cast<uint32_t>(segment.vmsize));
+            buffer.PutHex32(static_cast<uint32_t>(segment.fileoff));
+            buffer.PutHex32(static_cast<uint32_t>(segment.filesize));
+          }
+          buffer.PutHex32(segment.maxprot);
+          buffer.PutHex32(segment.initprot);
+          buffer.PutHex32(segment.nsects);
+          buffer.PutHex32(segment.flags);
+        }
+
+        std::string core_file_path(outfile.GetPath());
+        auto core_file = FileSystem::Instance().Open(
+            outfile, File::eOpenOptionWrite | File::eOpenOptionTruncate |
+                         File::eOpenOptionCanCreate);
+        if (!core_file) {
+          error = core_file.takeError();
+        } else {
+          // Read 1 page at a time
+          uint8_t bytes[0x1000];
+          // Write the mach header and load commands out to the core file
+          size_t bytes_written = buffer.GetString().size();
+          error =
+              core_file.get()->Write(buffer.GetString().data(), bytes_written);
+          if (error.Success()) {
+            // Now write the file data for all memory segments in the process
+            for (const auto &segment : segment_load_commands) {
+              if (core_file.get()->SeekFromStart(segment.fileoff) == -1) {
+                error.SetErrorStringWithFormat(
+                    "unable to seek to offset 0x%" PRIx64 " in '%s'",
+                    segment.fileoff, core_file_path.c_str());
+                break;
+              }
 
-                printf("Saving %" PRId64
-                       " bytes of data for memory region at 0x%" PRIx64 "\n",
-                       segment.vmsize, segment.vmaddr);
-                addr_t bytes_left = segment.vmsize;
-                addr_t addr = segment.vmaddr;
-                Status memory_read_error;
-                while (bytes_left > 0 && error.Success()) {
-                  const size_t bytes_to_read =
-                      bytes_left > sizeof(bytes) ? sizeof(bytes) : bytes_left;
-
-                  // In a savecore setting, we don't really care about caching,
-                  // as the data is dumped and very likely never read again,
-                  // so we call ReadMemoryFromInferior to bypass it.
-                  const size_t bytes_read = process_sp->ReadMemoryFromInferior(
-                      addr, bytes, bytes_to_read, memory_read_error);
-
-                  if (bytes_read == bytes_to_read) {
-                    size_t bytes_written = bytes_read;
-                    error = core_file.get()->Write(bytes, bytes_written);
-                    bytes_left -= bytes_read;
-                    addr += bytes_read;
-                  } else {
-                    // Some pages within regions are not readable, those should
-                    // be zero filled
-                    memset(bytes, 0, bytes_to_read);
-                    size_t bytes_written = bytes_to_read;
-                    error = core_file.get()->Write(bytes, bytes_written);
-                    bytes_left -= bytes_to_read;
-                    addr += bytes_to_read;
-                  }
+              printf("Saving %" PRId64
+                     " bytes of data for memory region at 0x%" PRIx64 "\n",
+                     segment.vmsize, segment.vmaddr);
+              addr_t bytes_left = segment.vmsize;
+              addr_t addr = segment.vmaddr;
+              Status memory_read_error;
+              while (bytes_left > 0 && error.Success()) {
+                const size_t bytes_to_read =
+                    bytes_left > sizeof(bytes) ? sizeof(bytes) : bytes_left;
+
+                // In a savecore setting, we don't really care about caching,
+                // as the data is dumped and very likely never read again,
+                // so we call ReadMemoryFromInferior to bypass it.
+                const size_t bytes_read = process_sp->ReadMemoryFromInferior(
+                    addr, bytes, bytes_to_read, memory_read_error);
+
+                if (bytes_read == bytes_to_read) {
+                  size_t bytes_written = bytes_read;
+                  error = core_file.get()->Write(bytes, bytes_written);
+                  bytes_left -= bytes_read;
+                  addr += bytes_read;
+                } else {
+                  // Some pages within regions are not readable, those should
+                  // be zero filled
+                  memset(bytes, 0, bytes_to_read);
+                  size_t bytes_written = bytes_to_read;
+                  error = core_file.get()->Write(bytes, bytes_written);
+                  bytes_left -= bytes_to_read;
+                  addr += bytes_to_read;
                 }
               }
             }
           }
-        } else {
-          error.SetErrorString(
-              "process doesn't support getting memory region info");
         }
+      } else {
+        error.SetErrorString(
+            "process doesn't support getting memory region info");
       }
-      return true; // This is the right plug to handle saving core files for
-                   // this process
     }
+    return true; // This is the right plug to handle saving core files for
+                 // this process
   }
   return false;
 }




More information about the lldb-commits mailing list