[libunwind] Split out UnwindInfoSections and dl_iterate_phdr lookup

[rprichard]

Summary

Move the dl_iterate_phdr-based unwind info lookup code into
FrameHeaderCache.hpp and rename it to DlIteratePhdrLookup.hpp.

Remove the unused dl_iterate_cb_data::addressSpace field.

Previously, FrameHeaderCache.hpp was included inside
"namespace libunwind { ... }", and the header recursively included
other headers. Now, DlIteratePhdrLookup.hpp is included in the global
namespace, following the ordinary convention. The lookup code uses the
UnwindInfoSections struct, so break the circular dependency by moving
the struct into its own file.

[rprichard]

Rebase this change.

libunwind/src/AddressSpace.hpp

 
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "libunwind.h"
 #include "config.h"
+#include "DlIteratePhdrLookup.hpp"
 #include "dwarf2.h"
 #include "EHHeaderParser.hpp"
 #include "Registers.hpp"
+#include "UnwindInfoSections.hpp"
 
 #ifndef _LIBUNWIND_USE_DLADDR
   #if !defined(_LIBUNWIND_IS_BAREMETAL) && !defined(_WIN32)
     #define _LIBUNWIND_USE_DLADDR 1
   #else
     #define _LIBUNWIND_USE_DLADDR 0
   #endif
 #endif

 extern char __exidx_start;
 extern char __exidx_end;
 
 #elif defined(_WIN32)
 
 #include <windows.h>
 #include <psapi.h>
 
-#elif defined(_LIBUNWIND_USE_DL_ITERATE_PHDR) ||                               \
-      defined(_LIBUNWIND_USE_DL_UNWIND_FIND_EXIDX)
+#elif defined(_LIBUNWIND_USE_DL_UNWIND_FIND_EXIDX)
 
 #include <link.h>
 
 #endif
 
 namespace libunwind {
 
-/// Used by findUnwindSections() to return info about needed sections.
-struct UnwindInfoSections {
-#if defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND) ||                                \
-    defined(_LIBUNWIND_SUPPORT_COMPACT_UNWIND)
-  // No dso_base for SEH or ARM EHABI.
-  uintptr_t       dso_base;
-#endif
-#if defined(_LIBUNWIND_USE_DL_ITERATE_PHDR) &&                                 \
-    defined(_LIBUNWIND_SUPPORT_DWARF_INDEX)
-  uintptr_t       dso_length;
-#endif
-#if defined(_LIBUNWIND_SUPPORT_DWARF_SECTION)
-  uintptr_t       dwarf_section;
-  uintptr_t       dwarf_section_length;
-#endif
-#if defined(_LIBUNWIND_SUPPORT_DWARF_INDEX)
-  uintptr_t       dwarf_index_section;
-  uintptr_t       dwarf_index_section_length;
-#endif
-#if defined(_LIBUNWIND_SUPPORT_COMPACT_UNWIND)
-  uintptr_t       compact_unwind_section;
-  uintptr_t       compact_unwind_section_length;
-#endif
-#if defined(_LIBUNWIND_ARM_EHABI)
-  uintptr_t       arm_section;
-  uintptr_t       arm_section_length;
-#endif
-};
-
-
 /// LocalAddressSpace is used as a template parameter to UnwindCursor when
 /// unwinding a thread in the same process.  The wrappers compile away,
 /// making local unwinds fast.
 class _LIBUNWIND_HIDDEN LocalAddressSpace {
 public:
   typedef uintptr_t pint_t;
   typedef intptr_t  sint_t;
   uint8_t         get8(pint_t addr) {
LocalAddressSpace::getEncodedP(pint_t &addr, pint_t end, uint8_t encoding,
   }
 
   if (encoding & DW_EH_PE_indirect)
     result = getP(result);
 
   return result;
 }
 
-#if defined(_LIBUNWIND_USE_DL_ITERATE_PHDR)
-
-// The ElfW() macro for pointer-size independent ELF header traversal is not
-// provided by <link.h> on some systems (e.g., FreeBSD). On these systems the
-// data structures are just called Elf_XXX. Define ElfW() locally.
-#if !defined(ElfW)
-  #define ElfW(type) Elf_##type
-#endif
-#if !defined(Elf_Half)
-  typedef ElfW(Half) Elf_Half;
-#endif
-#if !defined(Elf_Phdr)
-  typedef ElfW(Phdr) Elf_Phdr;
-#endif
-#if !defined(Elf_Addr)
-  typedef ElfW(Addr) Elf_Addr;
-#endif
-
-static Elf_Addr calculateImageBase(struct dl_phdr_info *pinfo) {
-  Elf_Addr image_base = pinfo->dlpi_addr;
-#if defined(__ANDROID__) && __ANDROID_API__ < 18
-  if (image_base == 0) {
-    // Normally, an image base of 0 indicates a non-PIE executable. On
-    // versions of Android prior to API 18, the dynamic linker reported a
-    // dlpi_addr of 0 for PIE executables. Compute the true image base
-    // using the PT_PHDR segment.
-    // See https://github.com/android/ndk/issues/505.
-    for (Elf_Half i = 0; i < pinfo->dlpi_phnum; i++) {
-      const Elf_Phdr *phdr = &pinfo->dlpi_phdr[i];
-      if (phdr->p_type == PT_PHDR) {
-        image_base = reinterpret_cast<Elf_Addr>(pinfo->dlpi_phdr) -
-          phdr->p_vaddr;
-        break;
-      }
-    }
-  }
-#endif
-  return image_base;
-}
-
-struct _LIBUNWIND_HIDDEN dl_iterate_cb_data {
-  LocalAddressSpace *addressSpace;
-  UnwindInfoSections *sects;
-  uintptr_t targetAddr;
-};
-
-#if defined(_LIBUNWIND_SUPPORT_DWARF_INDEX)
-  #if defined(_LIBUNWIND_SUPPORT_DWARF_SECTION)
-    // dl_iterate_phdr finds PT_GNU_EH_FRAME (.eh_frame_hdr section), which
-    // provides the start of the .eh_frame section, but not its length. The
-    // .eh_frame length isn't strictly necessary if we assume the section ends
-    // with a terminator, but sometimes it doesn't, and if we have the index,
-    // then scanning .eh_frame shouldn't be necessary anyway.
-    #error _LIBUNWIND_SUPPORT_DWARF_SECTION is unsupported with dl_iterate_phdr.
-  #endif
-
-#if defined(_LIBUNWIND_USE_FRAME_HEADER_CACHE)
-#include "FrameHeaderCache.hpp"
-
-// Typically there is one cache per process, but when libunwind is built as a
-// hermetic static library, then each shared object may have its own cache.
-static FrameHeaderCache TheFrameHeaderCache;
-#endif
-
-static bool checkAddrInSegment(const Elf_Phdr *phdr, size_t image_base,
-                               dl_iterate_cb_data *cbdata) {
-  if (phdr->p_type == PT_LOAD) {
-    uintptr_t begin = image_base + phdr->p_vaddr;
-    uintptr_t end = begin + phdr->p_memsz;
-    if (cbdata->targetAddr >= begin && cbdata->targetAddr < end) {
-      cbdata->sects->dso_base = begin;
-      cbdata->sects->dso_length = phdr->p_memsz;
-      return true;
-    }
-  }
-  return false;
-}
-
-static int findUnwindSectionsByPhdr(struct dl_phdr_info *pinfo,
-                                    size_t pinfo_size, void *data) {
-  auto cbdata = static_cast<dl_iterate_cb_data *>(data);
-  if (pinfo->dlpi_phnum == 0 || cbdata->targetAddr < pinfo->dlpi_addr)
-    return 0;
-#if defined(_LIBUNWIND_USE_FRAME_HEADER_CACHE)
-  if (TheFrameHeaderCache.find(pinfo, pinfo_size, data))
-    return 1;
-#else
-  // Avoid warning about unused variable.
-  (void)pinfo_size;
-#endif
-
-  Elf_Addr image_base = calculateImageBase(pinfo);
-  bool found_obj = false;
-  bool found_hdr = false;
-
-  // Third phdr is usually the executable phdr.
-  if (pinfo->dlpi_phnum > 2)
-    found_obj = checkAddrInSegment(&pinfo->dlpi_phdr[2], image_base, cbdata);
-
-  // PT_GNU_EH_FRAME is usually near the end. Iterate backward. We already know
-  // that there is one or more phdrs.
-  for (Elf_Half i = pinfo->dlpi_phnum; i > 0; i--) {
-    const Elf_Phdr *phdr = &pinfo->dlpi_phdr[i - 1];
-    if (!found_hdr && phdr->p_type == PT_GNU_EH_FRAME) {
-      found_hdr = true;
-      uintptr_t eh_frame_hdr_start = image_base + phdr->p_vaddr;
-      cbdata->sects->dwarf_index_section = eh_frame_hdr_start;
-      cbdata->sects->dwarf_index_section_length = phdr->p_memsz;
-    } else if (!found_obj) {
-      found_obj = checkAddrInSegment(phdr, image_base, cbdata);
-    }
-    if (found_obj && found_hdr) {
-#if defined(_LIBUNWIND_USE_FRAME_HEADER_CACHE)
-      TheFrameHeaderCache.add(cbdata->sects);
-#endif
-      return 1;
-    }
-  }
-  return 0;
-}
-
-#elif defined(_LIBUNWIND_ARM_EHABI)
-
-static int findUnwindSectionsByPhdr(struct dl_phdr_info *pinfo, size_t,
-                                    void *data) {
-  auto *cbdata = static_cast<dl_iterate_cb_data *>(data);
-  bool found_obj = false;
-  bool found_hdr = false;
-
-  assert(cbdata);
-  assert(cbdata->sects);
-
-  if (cbdata->targetAddr < pinfo->dlpi_addr)
-    return 0;
-
-  Elf_Addr image_base = calculateImageBase(pinfo);
-
-  for (Elf_Half i = 0; i < pinfo->dlpi_phnum; i++) {
-    const Elf_Phdr *phdr = &pinfo->dlpi_phdr[i];
-    if (phdr->p_type == PT_LOAD) {
-      uintptr_t begin = image_base + phdr->p_vaddr;
-      uintptr_t end = begin + phdr->p_memsz;
-      if (cbdata->targetAddr >= begin && cbdata->targetAddr < end)
-        found_obj = true;
-    } else if (phdr->p_type == PT_ARM_EXIDX) {
-      uintptr_t exidx_start = image_base + phdr->p_vaddr;
-      cbdata->sects->arm_section = exidx_start;
-      cbdata->sects->arm_section_length = phdr->p_memsz;
-      found_hdr = true;
-    }
-  }
-  return found_obj && found_hdr;
-}
-
-#endif
-#endif  // defined(_LIBUNWIND_USE_DL_ITERATE_PHDR)
-
-
 inline bool LocalAddressSpace::findUnwindSections(pint_t targetAddr,
                                                   UnwindInfoSections &info) {
 #if defined(__APPLE__) && defined(_LIBUNWIND_SUPPORT_COMPACT_UNWIND)
   dyld_unwind_sections dyldInfo;
   if (_dyld_find_unwind_sections((void *)targetAddr, &dyldInfo)) {
     info.dso_base                      = (uintptr_t)dyldInfo.mh;
  #if defined(_LIBUNWIND_SUPPORT_DWARF_SECTION)
     info.dwarf_section                 = (uintptr_t)dyldInfo.dwarf_section;

 #elif defined(_LIBUNWIND_USE_DL_UNWIND_FIND_EXIDX)
   int length = 0;
   info.arm_section =
       (uintptr_t)dl_unwind_find_exidx((_Unwind_Ptr)targetAddr, &length);
   info.arm_section_length = (uintptr_t)length * sizeof(EHABIIndexEntry);
   if (info.arm_section && info.arm_section_length)
     return true;
 #elif defined(_LIBUNWIND_USE_DL_ITERATE_PHDR)
-  dl_iterate_cb_data cb_data = {this, &info, targetAddr};
-  int found = dl_iterate_phdr(findUnwindSectionsByPhdr, &cb_data);
-  return static_cast<bool>(found);
+  return findUnwindSectionsByDlIteratePhdr(targetAddr, info);
 #endif
 
   return false;
 }
 
 
 inline bool LocalAddressSpace::findOtherFDE(pint_t targetAddr, pint_t &fde) {
   // TO DO: if OS has way to dynamically register FDEs, check that.

libunwind/src/CMakeLists.txt

if((APPLE AND CMAKE_VERSION VERSION_LESS 3.19) OR (MINGW AND CMAKE_VERSION VERSION_LESS 3.17))
   set_source_files_properties(${LIBUNWIND_ASM_SOURCES} PROPERTIES LANGUAGE C)
 endif()
 
 set(LIBUNWIND_HEADERS
     AddressSpace.hpp
     assembly.h
     CompactUnwinder.hpp
     config.h
+    DlIteratePhdrLookup.hpp
     dwarf2.h
     DwarfInstructions.hpp
     DwarfParser.hpp
     EHHeaderParser.hpp
-    FrameHeaderCache.hpp
     libunwind_ext.h
     Registers.hpp
     RWMutex.hpp
     Unwind-EHABI.h
     UnwindCursor.hpp
+    UnwindInfoSections.hpp
     ../include/libunwind.h
     ../include/unwind.h
     )
 if(APPLE)
   list(APPEND LIBUNWIND_HEADERS
     ../include/mach-o/compact_unwind_encoding.h
     )
 endif()

libunwind/src/DlIteratePhdrLookup.hpp

+//===-DlIteratePhdrLookup.hpp ---------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Finds unwind information using dl_iterate_phdr. Caches the elf program
+// headers necessary to unwind the stack more efficiently in the presence of
+// many dsos.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __DL_ITERATE_PHDR_LOOKUP_HPP__
+#define __DL_ITERATE_PHDR_LOOKUP_HPP__
+
+#include "config.h"
+
+#if defined(_LIBUNWIND_USE_DL_ITERATE_PHDR)
+
+#include <assert.h>
+#include <limits.h>
+#include <link.h>
+
+#include "UnwindInfoSections.hpp"
+
+namespace libunwind {
+
+#ifdef _LIBUNWIND_DEBUG_FRAMEHEADER_CACHE
+#define _LIBUNWIND_FRAMEHEADERCACHE_TRACE0(x) _LIBUNWIND_LOG0(x)
+#define _LIBUNWIND_FRAMEHEADERCACHE_TRACE(msg, ...)                            \
+  _LIBUNWIND_LOG(msg, __VA_ARGS__)
+#else
+#define _LIBUNWIND_FRAMEHEADERCACHE_TRACE0(x)
+#define _LIBUNWIND_FRAMEHEADERCACHE_TRACE(msg, ...)
+#endif
+
+// The ElfW() macro for pointer-size independent ELF header traversal is not
+// provided by <link.h> on some systems (e.g., FreeBSD). On these systems the
+// data structures are just called Elf_XXX. Define ElfW() locally.
+#if !defined(ElfW)
+  #define ElfW(type) Elf_##type
+#endif
+#if !defined(Elf_Half)
+  typedef ElfW(Half) Elf_Half;
+#endif
+#if !defined(Elf_Phdr)
+  typedef ElfW(Phdr) Elf_Phdr;
+#endif
+#if !defined(Elf_Addr)
+  typedef ElfW(Addr) Elf_Addr;
+#endif
+
+static Elf_Addr calculateImageBase(struct dl_phdr_info *pinfo) {
+  Elf_Addr image_base = pinfo->dlpi_addr;
+#if defined(__ANDROID__) && __ANDROID_API__ < 18
+  if (image_base == 0) {
+    // Normally, an image base of 0 indicates a non-PIE executable. On
+    // versions of Android prior to API 18, the dynamic linker reported a
+    // dlpi_addr of 0 for PIE executables. Compute the true image base
+    // using the PT_PHDR segment.
+    // See https://github.com/android/ndk/issues/505.
+    for (Elf_Half i = 0; i < pinfo->dlpi_phnum; i++) {
+      const Elf_Phdr *phdr = &pinfo->dlpi_phdr[i];
+      if (phdr->p_type == PT_PHDR) {
+        image_base = reinterpret_cast<Elf_Addr>(pinfo->dlpi_phdr) -
+          phdr->p_vaddr;
+        break;
+      }
+    }
+  }
+#endif
+  return image_base;
+}
+
+struct _LIBUNWIND_HIDDEN dl_iterate_cb_data {
+  UnwindInfoSections *sects;
+  uintptr_t targetAddr;
+};
+
+#if defined(_LIBUNWIND_SUPPORT_DWARF_INDEX)
+  #if defined(_LIBUNWIND_SUPPORT_DWARF_SECTION)
+    // dl_iterate_phdr finds PT_GNU_EH_FRAME (.eh_frame_hdr section), which
+    // provides the start of the .eh_frame section, but not its length. The
+    // .eh_frame length isn't strictly necessary if we assume the section ends
+    // with a terminator, but sometimes it doesn't, and if we have the index,
+    // then scanning .eh_frame shouldn't be necessary anyway.
+    #error _LIBUNWIND_SUPPORT_DWARF_SECTION is unsupported with dl_iterate_phdr.
+  #endif
+
+// This cache should only be be used from within a dl_iterate_phdr callback.
+// dl_iterate_phdr does the necessary synchronization to prevent problems
+// with concurrent access via the libc load lock. Adding synchronization
+// for other uses is possible, but not currently done.
+
+#if defined(_LIBUNWIND_USE_FRAME_HEADER_CACHE)
+class _LIBUNWIND_HIDDEN FrameHeaderCache {
+  struct CacheEntry {
+    uintptr_t LowPC() { return Info.dso_base; };
+    uintptr_t HighPC() { return Info.dso_base + Info.dso_length; };
+    UnwindInfoSections Info;
+    CacheEntry *Next;
+  };
+
+  static const size_t kCacheEntryCount = 8;
+
+  // Can't depend on the C++ standard library in libunwind, so use an array to
+  // allocate the entries, and two linked lists for ordering unused and recently
+  // used entries.  FIXME: Would the the extra memory for a doubly-linked list
+  // be better than the runtime cost of traversing a very short singly-linked
+  // list on a cache miss? The entries themselves are all small and consecutive,
+  // so unlikely to cause page faults when following the pointers. The memory
+  // spent on additional pointers could also be spent on more entries.
+
+  CacheEntry Entries[kCacheEntryCount];
+  CacheEntry *MostRecentlyUsed;
+  CacheEntry *Unused;
+
+  void resetCache() {
+    _LIBUNWIND_FRAMEHEADERCACHE_TRACE0("FrameHeaderCache reset");
+    MostRecentlyUsed = nullptr;
+    Unused = &Entries[0];
+    for (size_t i = 0; i < kCacheEntryCount - 1; i++) {
+      Entries[i].Next = &Entries[i + 1];
+    }
+    Entries[kCacheEntryCount - 1].Next = nullptr;
+  }
+
+  bool cacheNeedsReset(dl_phdr_info *PInfo) {
+    // C libraries increment dl_phdr_info.adds and dl_phdr_info.subs when
+    // loading and unloading shared libraries. If these values change between
+    // iterations of dl_iterate_phdr, then invalidate the cache.
+
+    // These are static to avoid needing an initializer, and unsigned long long
+    // because that is their type within the extended dl_phdr_info.  Initialize
+    // these to something extremely unlikely to be found upon the first call to
+    // dl_iterate_phdr.
+    static unsigned long long LastAdds = ULLONG_MAX;
+    static unsigned long long LastSubs = ULLONG_MAX;
+    if (PInfo->dlpi_adds != LastAdds || PInfo->dlpi_subs != LastSubs) {
+      // Resetting the entire cache is a big hammer, but this path is rare--
+      // usually just on the very first call, when the cache is empty anyway--so
+      // added complexity doesn't buy much.
+      LastAdds = PInfo->dlpi_adds;
+      LastSubs = PInfo->dlpi_subs;
+      resetCache();
+      return true;
+    }
+    return false;
+  }
+
+public:
+  bool find(dl_phdr_info *PInfo, size_t, void *data) {
+    if (cacheNeedsReset(PInfo) || MostRecentlyUsed == nullptr)
+      return false;
+
+    auto *CBData = static_cast<dl_iterate_cb_data *>(data);
+    CacheEntry *Current = MostRecentlyUsed;
+    CacheEntry *Previous = nullptr;
+    while (Current != nullptr) {
+      _LIBUNWIND_FRAMEHEADERCACHE_TRACE(
+          "FrameHeaderCache check %lx in [%lx - %lx)", CBData->targetAddr,
+          Current->LowPC(), Current->HighPC());
+      if (Current->LowPC() <= CBData->targetAddr &&
+          CBData->targetAddr < Current->HighPC()) {
+        _LIBUNWIND_FRAMEHEADERCACHE_TRACE(
+            "FrameHeaderCache hit %lx in [%lx - %lx)", CBData->targetAddr,
+            Current->LowPC(), Current->HighPC());
+        if (Previous) {
+          // If there is no Previous, then Current is already the
+          // MostRecentlyUsed, and no need to move it up.
+          Previous->Next = Current->Next;
+          Current->Next = MostRecentlyUsed;
+          MostRecentlyUsed = Current;
+        }
+        *CBData->sects = Current->Info;
+        return true;
+      }
+      Previous = Current;
+      Current = Current->Next;
+    }
+    _LIBUNWIND_FRAMEHEADERCACHE_TRACE("FrameHeaderCache miss for address %lx",
+                                      CBData->targetAddr);
+    return false;
+  }
+
+  void add(const UnwindInfoSections *UIS) {
+    CacheEntry *Current = nullptr;
+
+    if (Unused != nullptr) {
+      Current = Unused;
+      Unused = Unused->Next;
+    } else {
+      Current = MostRecentlyUsed;
+      CacheEntry *Previous = nullptr;
+      while (Current->Next != nullptr) {
+        Previous = Current;
+        Current = Current->Next;
+      }
+      Previous->Next = nullptr;
+      _LIBUNWIND_FRAMEHEADERCACHE_TRACE("FrameHeaderCache evict [%lx - %lx)",
+                                        Current->LowPC(), Current->HighPC());
+    }
+
+    Current->Info = *UIS;
+    Current->Next = MostRecentlyUsed;
+    MostRecentlyUsed = Current;
+    _LIBUNWIND_FRAMEHEADERCACHE_TRACE("FrameHeaderCache add [%lx - %lx)",
+                                      MostRecentlyUsed->LowPC(),
+                                      MostRecentlyUsed->HighPC());
+  }
+};
+
+// Typically there is one cache per process, but when libunwind is built as a
+// hermetic static library, then each shared object may have its own cache.
+static FrameHeaderCache TheFrameHeaderCache;
+#endif // defined(_LIBUNWIND_USE_FRAME_HEADER_CACHE)
+
+static bool checkAddrInSegment(const Elf_Phdr *phdr, size_t image_base,
+                               dl_iterate_cb_data *cbdata) {
+  if (phdr->p_type == PT_LOAD) {
+    uintptr_t begin = image_base + phdr->p_vaddr;
+    uintptr_t end = begin + phdr->p_memsz;
+    if (cbdata->targetAddr >= begin && cbdata->targetAddr < end) {
+      cbdata->sects->dso_base = begin;
+      cbdata->sects->dso_length = phdr->p_memsz;
+      return true;
+    }
+  }
+  return false;
+}
+
+static int findUnwindSectionsByPhdr(struct dl_phdr_info *pinfo,
+                                    size_t pinfo_size, void *data) {
+  auto cbdata = static_cast<dl_iterate_cb_data *>(data);
+  if (pinfo->dlpi_phnum == 0 || cbdata->targetAddr < pinfo->dlpi_addr)
+    return 0;
+#if defined(_LIBUNWIND_USE_FRAME_HEADER_CACHE)
+  if (TheFrameHeaderCache.find(pinfo, pinfo_size, data))
+    return 1;
+#else
+  // Avoid warning about unused variable.
+  (void)pinfo_size;
+#endif
+
+  Elf_Addr image_base = calculateImageBase(pinfo);
+  bool found_obj = false;
+  bool found_hdr = false;
+
+  // Third phdr is usually the executable phdr.
+  if (pinfo->dlpi_phnum > 2)
+    found_obj = checkAddrInSegment(&pinfo->dlpi_phdr[2], image_base, cbdata);
+
+  // PT_GNU_EH_FRAME is usually near the end. Iterate backward. We already know
+  // that there is one or more phdrs.
+  for (Elf_Half i = pinfo->dlpi_phnum; i > 0; i--) {
+    const Elf_Phdr *phdr = &pinfo->dlpi_phdr[i - 1];
+    if (!found_hdr && phdr->p_type == PT_GNU_EH_FRAME) {
+      found_hdr = true;
+      uintptr_t eh_frame_hdr_start = image_base + phdr->p_vaddr;
+      cbdata->sects->dwarf_index_section = eh_frame_hdr_start;
+      cbdata->sects->dwarf_index_section_length = phdr->p_memsz;
+    } else if (!found_obj) {
+      found_obj = checkAddrInSegment(phdr, image_base, cbdata);
+    }
+    if (found_obj && found_hdr) {
+#if defined(_LIBUNWIND_USE_FRAME_HEADER_CACHE)
+      TheFrameHeaderCache.add(cbdata->sects);
+#endif
+      return 1;
+    }
+  }
+  return 0;
+}
+
+#elif defined(_LIBUNWIND_ARM_EHABI)
+
+static int findUnwindSectionsByPhdr(struct dl_phdr_info *pinfo, size_t,
+                                    void *data) {
+  auto *cbdata = static_cast<dl_iterate_cb_data *>(data);
+  bool found_obj = false;
+  bool found_hdr = false;
+
+  assert(cbdata);
+  assert(cbdata->sects);
+
+  if (cbdata->targetAddr < pinfo->dlpi_addr)
+    return 0;
+
+  Elf_Addr image_base = calculateImageBase(pinfo);
+
+  for (Elf_Half i = 0; i < pinfo->dlpi_phnum; i++) {
+    const Elf_Phdr *phdr = &pinfo->dlpi_phdr[i];
+    if (phdr->p_type == PT_LOAD) {
+      uintptr_t begin = image_base + phdr->p_vaddr;
+      uintptr_t end = begin + phdr->p_memsz;
+      if (cbdata->targetAddr >= begin && cbdata->targetAddr < end)
+        found_obj = true;
+    } else if (phdr->p_type == PT_ARM_EXIDX) {
+      uintptr_t exidx_start = image_base + phdr->p_vaddr;
+      cbdata->sects->arm_section = exidx_start;
+      cbdata->sects->arm_section_length = phdr->p_memsz;
+      found_hdr = true;
+    }
+  }
+  return found_obj && found_hdr;
+}
+
+#endif
+
+static bool findUnwindSectionsByDlIteratePhdr(uintptr_t targetAddr,
+                                              UnwindInfoSections &info) {
+  dl_iterate_cb_data cb_data = {&info, targetAddr};
+  int found = dl_iterate_phdr(findUnwindSectionsByPhdr, &cb_data);
+  return static_cast<bool>(found);
+}
+
+} // namespace libunwind
+
+#endif // defined(_LIBUNWIND_USE_DL_ITERATE_PHDR)
+#endif // __DL_ITERATE_PHDR_LOOKUP_HPP__

libunwind/src/FrameHeaderCache.hpp

-//===-FrameHeaderCache.hpp ------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-// Cache the elf program headers necessary to unwind the stack more efficiently
-// in the presence of many dsos.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef __FRAMEHEADER_CACHE_HPP__
-#define __FRAMEHEADER_CACHE_HPP__
-
-#include "config.h"
-#include <limits.h>
-
-#ifdef _LIBUNWIND_DEBUG_FRAMEHEADER_CACHE
-#define _LIBUNWIND_FRAMEHEADERCACHE_TRACE0(x) _LIBUNWIND_LOG0(x)
-#define _LIBUNWIND_FRAMEHEADERCACHE_TRACE(msg, ...)                            \
-  _LIBUNWIND_LOG(msg, __VA_ARGS__)
-#else
-#define _LIBUNWIND_FRAMEHEADERCACHE_TRACE0(x)
-#define _LIBUNWIND_FRAMEHEADERCACHE_TRACE(msg, ...)
-#endif
-
-// This cache should only be be used from within a dl_iterate_phdr callback.
-// dl_iterate_phdr does the necessary synchronization to prevent problems
-// with concurrent access via the libc load lock. Adding synchronization
-// for other uses is possible, but not currently done.
-
-class _LIBUNWIND_HIDDEN FrameHeaderCache {
-  struct CacheEntry {
-    uintptr_t LowPC() { return Info.dso_base; };
-    uintptr_t HighPC() { return Info.dso_base + Info.dso_length; };
-    UnwindInfoSections Info;
-    CacheEntry *Next;
-  };
-
-  static const size_t kCacheEntryCount = 8;
-
-  // Can't depend on the C++ standard library in libunwind, so use an array to
-  // allocate the entries, and two linked lists for ordering unused and recently
-  // used entries.  FIXME: Would the the extra memory for a doubly-linked list
-  // be better than the runtime cost of traversing a very short singly-linked
-  // list on a cache miss? The entries themselves are all small and consecutive,
-  // so unlikely to cause page faults when following the pointers. The memory
-  // spent on additional pointers could also be spent on more entries.
-
-  CacheEntry Entries[kCacheEntryCount];
-  CacheEntry *MostRecentlyUsed;
-  CacheEntry *Unused;
-
-  void resetCache() {
-    _LIBUNWIND_FRAMEHEADERCACHE_TRACE0("FrameHeaderCache reset");
-    MostRecentlyUsed = nullptr;
-    Unused = &Entries[0];
-    for (size_t i = 0; i < kCacheEntryCount - 1; i++) {
-      Entries[i].Next = &Entries[i + 1];
-    }
-    Entries[kCacheEntryCount - 1].Next = nullptr;
-  }
-
-  bool cacheNeedsReset(dl_phdr_info *PInfo) {
-    // C libraries increment dl_phdr_info.adds and dl_phdr_info.subs when
-    // loading and unloading shared libraries. If these values change between
-    // iterations of dl_iterate_phdr, then invalidate the cache.
-
-    // These are static to avoid needing an initializer, and unsigned long long
-    // because that is their type within the extended dl_phdr_info.  Initialize
-    // these to something extremely unlikely to be found upon the first call to
-    // dl_iterate_phdr.
-    static unsigned long long LastAdds = ULLONG_MAX;
-    static unsigned long long LastSubs = ULLONG_MAX;
-    if (PInfo->dlpi_adds != LastAdds || PInfo->dlpi_subs != LastSubs) {
-      // Resetting the entire cache is a big hammer, but this path is rare--
-      // usually just on the very first call, when the cache is empty anyway--so
-      // added complexity doesn't buy much.
-      LastAdds = PInfo->dlpi_adds;
-      LastSubs = PInfo->dlpi_subs;
-      resetCache();
-      return true;
-    }
-    return false;
-  }
-
-public:
-  bool find(dl_phdr_info *PInfo, size_t, void *data) {
-    if (cacheNeedsReset(PInfo) || MostRecentlyUsed == nullptr)
-      return false;
-
-    auto *CBData = static_cast<dl_iterate_cb_data *>(data);
-    CacheEntry *Current = MostRecentlyUsed;
-    CacheEntry *Previous = nullptr;
-    while (Current != nullptr) {
-      _LIBUNWIND_FRAMEHEADERCACHE_TRACE(
-          "FrameHeaderCache check %lx in [%lx - %lx)", CBData->targetAddr,
-          Current->LowPC(), Current->HighPC());
-      if (Current->LowPC() <= CBData->targetAddr &&
-          CBData->targetAddr < Current->HighPC()) {
-        _LIBUNWIND_FRAMEHEADERCACHE_TRACE(
-            "FrameHeaderCache hit %lx in [%lx - %lx)", CBData->targetAddr,
-            Current->LowPC(), Current->HighPC());
-        if (Previous) {
-          // If there is no Previous, then Current is already the
-          // MostRecentlyUsed, and no need to move it up.
-          Previous->Next = Current->Next;
-          Current->Next = MostRecentlyUsed;
-          MostRecentlyUsed = Current;
-        }
-        *CBData->sects = Current->Info;
-        return true;
-      }
-      Previous = Current;
-      Current = Current->Next;
-    }
-    _LIBUNWIND_FRAMEHEADERCACHE_TRACE("FrameHeaderCache miss for address %lx",
-                                      CBData->targetAddr);
-    return false;
-  }
-
-  void add(const UnwindInfoSections *UIS) {
-    CacheEntry *Current = nullptr;
-
-    if (Unused != nullptr) {
-      Current = Unused;
-      Unused = Unused->Next;
-    } else {
-      Current = MostRecentlyUsed;
-      CacheEntry *Previous = nullptr;
-      while (Current->Next != nullptr) {
-        Previous = Current;
-        Current = Current->Next;
-      }
-      Previous->Next = nullptr;
-      _LIBUNWIND_FRAMEHEADERCACHE_TRACE("FrameHeaderCache evict [%lx - %lx)",
-                                        Current->LowPC(), Current->HighPC());
-    }
-
-    Current->Info = *UIS;
-    Current->Next = MostRecentlyUsed;
-    MostRecentlyUsed = Current;
-    _LIBUNWIND_FRAMEHEADERCACHE_TRACE("FrameHeaderCache add [%lx - %lx)",
-                                      MostRecentlyUsed->LowPC(),
-                                      MostRecentlyUsed->HighPC());
-  }
-};
-
-#endif // __FRAMEHEADER_CACHE_HPP__

libunwind/src/UnwindInfoSections.hpp

+//===-UnwindInfoSections.hpp ----------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// Define the UnwindInfoSections struct used by findUnwindSections.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __UNWIND_INFO_SECTIONS_HPP__
+#define __UNWIND_INFO_SECTIONS_HPP__
+
+#include <stdint.h>
+
+#include "config.h"
+
+namespace libunwind {
+
+/// Used by findUnwindSections() to return info about needed sections.
+struct UnwindInfoSections {
+#if defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND) ||                                \
+    defined(_LIBUNWIND_SUPPORT_COMPACT_UNWIND)
+  // No dso_base for SEH or ARM EHABI.
+  uintptr_t       dso_base;
+#endif
+#if defined(_LIBUNWIND_USE_DL_ITERATE_PHDR) &&                                 \
+    defined(_LIBUNWIND_SUPPORT_DWARF_INDEX)
+  uintptr_t       dso_length;
+#endif
+#if defined(_LIBUNWIND_SUPPORT_DWARF_SECTION)
+  uintptr_t       dwarf_section;
+  uintptr_t       dwarf_section_length;
+#endif
+#if defined(_LIBUNWIND_SUPPORT_DWARF_INDEX)
+  uintptr_t       dwarf_index_section;
+  uintptr_t       dwarf_index_section_length;
+#endif
+#if defined(_LIBUNWIND_SUPPORT_COMPACT_UNWIND)
+  uintptr_t       compact_unwind_section;
+  uintptr_t       compact_unwind_section_length;
+#endif
+#if defined(_LIBUNWIND_ARM_EHABI)
+  uintptr_t       arm_section;
+  uintptr_t       arm_section_length;
+#endif
+};
+
+} // namespace libunwind
+
+#endif // __UNWIND_INFO_SECTIONS_HPP__