[libunwind] Make .eh_frame scanning/caching optional

[rprichard]

Summary

Add another macro, _LIBUNWIND_SUPPORT_DWARF_SECTION, that indicates
that the location and length of .eh_frame is known, and that .eh_frame
should be scanned to find an FDE. There are a few reasons to turn this
code off:

• When there is a valid .eh_frame_hdr section, scanning .eh_frame is unnecessary.
• When .eh_frame is located using PT_GNU_EH_FRAME, the length of the section is unknown.
• If the unwinder uses dl_iterate_phdr, then entries that are automatically added to DwarfFDECache would become invalid if the module containing the entry were unloaded. (On Apple systems, DwarfFDECache registers dyldUnloadHook to remove unloaded entries.)
• Omitting the dwarf_section and dwarf_section_length fields reduces memory use in the FrameHeaderCache.

For a bare-metal target, the location of both .eh_frame and
.eh_frame_hdr is known, but maybe the .eh_frame_hdr is unused/empty,
so enable both methods. .eh_frame is only scanned if the index is
unavailable.

Add a new dso_length field to track the length of the PT_LOAD segment
used by the FrameHeaderCache. Previously, the FrameHeaderCache used the
dwarf_section_length field for this purpose.

Fix the calculation of ehSectionEnd in CFI_Parser<A>::findFDE.

Above the dso_base field declaration, remove the redundant reference to
_LIBUNWIND_SUPPORT_DWARF_INDEX. If _LIBUNWIND_SUPPORT_DWARF_INDEX is
defined, then _LIBUNWIND_SUPPORT_DWARF_UNWIND is also defined.

Fixes PR36005 and PR46829.

[rprichard]

Stylistic changes.

[rprichard]

Split out the chain-of-ifdefs change into D86768.

[rprichard]

FWIW, when compact unwinding defers to DWARF (compactSaysUseDwarf), the unwinder begins a scan of .eh_frame at a given offset. Is that really the right behavior, or will the offset always point directly at the appropriate FDE (as with the DWARF index .eh_frame_hdr)?

Aside: For most architectures, when UnwindCursor::setInfoBasedOnIPRegister calls compactSaysUseDwarf, dwarfOffset isn't initialized, but it is read. The value is properly initialized on [arm, arm64, i386, x86_64], though, and I'm guessing those are the architectures that are practically used with compact unwinding.

[rprichard]

If the unwinder uses dl_iterate_phdr, then entries that are automatically added to DwarfFDECache would become invalid if the module containing the entry were unloaded. (On Apple systems, DwarfFDECache registers dyldUnloadHook to remove unloaded entries.)

AFAICT, this is also a problem for Windows DWARF EH, which relies on scanning an .eh_frame section. e.g. A stale cachedFDE could point into the middle of an FDE/CIE with an arbitrary outcome. Maybe decodeFDE crashes, or maybe it decodes something that looks like a match. I'm not sure if it can be fixed without disabling the caching. If so, then I'd wonder if the caching is worth keeping. (Bare-metal could use .eh_frame_hdr, and I'm not sure whether Apple systems actually need the full __eh_frame scan.)

Windows also has SEH exceptions, which I think don't have this problem.

[rprichard]

The Linux ABI Extensions spec describes the binary search table of .eh_frame_hdr as optional, so maybe falling back to .eh_frame scanning could be necessary to accommodate some ELF files? I wonder what situation results in an omitted search table. ld.bfd does have code for outputting .eh_frame_hdr without a search table.

[mstorsjo]

In D86256#2244077, @rprichard wrote:

If the unwinder uses dl_iterate_phdr, then entries that are automatically added to DwarfFDECache would become invalid if the module containing the entry were unloaded. (On Apple systems, DwarfFDECache registers dyldUnloadHook to remove unloaded entries.)

AFAICT, this is also a problem for Windows DWARF EH, which relies on scanning an .eh_frame section. e.g. A stale cachedFDE could point into the middle of an FDE/CIE with an arbitrary outcome. Maybe decodeFDE crashes, or maybe it decodes something that looks like a match. I'm not sure if it can be fixed without disabling the caching. If so, then I'd wonder if the caching is worth keeping. (Bare-metal could use .eh_frame_hdr, and I'm not sure whether Apple systems actually need the full __eh_frame scan.)

Indeed, that's correct. I guess a stale cache entry would only ever be hit if there's another DLL loaded into the same address range as the previous one, but if that happens and unwidning hits a cached entry, pretty much anything could happen. Not really sure if there's any good callbacks for when other DLLs are unloaded...

Disabling the cache in those cases might be safest - even though it probably gives a good speedup for all practical cases, the risks it imposes are pretty bad as well...

Windows also has SEH exceptions, which I think don't have this problem.

It's handled quite differently there, yeah.

Regarding the rest of the patch, I don't have enough experience with these details on ELF platforms to have much of an informed opinion... The windows specific bits look good though.

[mstorsjo]

The commit description talks about making the caching optional, but I don't really see that aspect in the patch - or maybe I'm just not studying it closely enough?

[rprichard]

In D86256#2270331, @mstorsjo wrote:

The commit description talks about making the caching optional, but I don't really see that aspect in the patch - or maybe I'm just not studying it closely enough?

Oh, by optional, I just meant that the .eh_frame scanning and caching are both controlled by the new _LIBUNWIND_SUPPORT_DWARF_SECTION macro, which is left off for some targets.

In D86256#2255830, @rprichard wrote:

The Linux ABI Extensions spec describes the binary search table of .eh_frame_hdr as optional, so maybe falling back to .eh_frame scanning could be necessary to accommodate some ELF files? I wonder what situation results in an omitted search table. ld.bfd does have code for outputting .eh_frame_hdr without a search table.

It looks like both ld.bfd and ld.gold have code paths that output an .eh_frame_hdr without a search table. This can happen if they're not able to parse .eh_frame. AFAICT, LLD always outputs the search table (EhFrameHeader::write), and aborts if it can't parse .eh_frame. One example of this: If a CIE has an unrecognized augmentation code, then the linker may be unable to parse the R code, and without that, it can't read the FDE initial_location field, because the R code specifies its encoding. LLD avoids this problem by aborting if it can't read the R code (EhReader::getFdeEncoding).

libgcc appears to fall back to scanning .eh_frame if .eh_frame_hdr doesn't have the FDE, and it can scan beyond the end of the segment containing the .eh_frame section, if the section doesn't end with a terminator.

Perhaps a more conservative fix for PR46829 is to match libgcc's behavior here, by disabling the end-of-section tracking for dl_iterate_phdr. e.g. by setting dwarf_section_length to -1. In that case, then PR36005's true fix is to link against a crtend.o with the .eh_frame terminator. (Or use LLD, which automatically inserts the terminator.)

[MaskRay]

In D86256#2272678, @rprichard wrote:

Perhaps a more conservative fix for PR46829 is to match libgcc's behavior here, by disabling the end-of-section tracking for dl_iterate_phdr. e.g. by setting dwarf_section_length to -1. In that case, then PR36005's true fix is to link against a crtend.o with the .eh_frame terminator. (Or use LLD, which automatically inserts the terminator.)

Haven't read through the discussions. Just want to comment "Or use LLD, which automatically inserts the terminator" - the zero terminator CIE is to work around a glibc issue D46566

[rprichard]

Just want to comment "Or use LLD, which automatically inserts the terminator" - the zero terminator CIE is to work around a glibc issue D46566

The need for the terminator seems more fundamental:

• In theory (and in the LSB5 spec), .eh_frame_hdr's search table is optional, or perhaps it could be incomplete? (e.g. see this mailing list post)
• libgcc (and LLVM's libunwind) accommodate an incomplete/omitted search table by falling back to scanning .eh_frame.
• A PC might not be present in .eh_frame, so the unwinder needs to know when it reaches the end of .eh_frame.
• .eh_frame_hdr records the location of .eh_frame, but not the size.
• Therefore, a terminator is required.

If .eh_frame_hdr had also included the size of .eh_frame, then a terminator wouldn't be needed. My impression is that the terminator predates .eh_frame_hdr. e.g. The __register_frame_info function takes a pointer to the start of .eh_frame, but no size.

crtend.o normally provides the terminator, and bfd/gold appear to preserve it. So, if crtend.o isn't used, then .eh_frame is unterminated (e.g. PR36005). I noticed that bfd/gold remove a terminator if I try to add one before actual CIE/FDE records. LLD 6.0.0 seems to strip all terminators, including crtend.o's terminator, so the output is never terminated. Current LLD adds the terminator unconditionally, so the output is always terminated, even without crtend.o.

This Phabricator revision assumes that .eh_frame_hdr's search table is sufficient, and maybe it is, at least on some targets? I suspect the bfd/gold linkers issue a warning if they don't output a search table, and lld always outputs it.

Two more ways the search table can be omitted:

• With the gold linker, if .eh_frame has only a terminator, then the generated .eh_frame_hdr's table is omitted. LLD instead outputs a 0-entry search table.
• ld.bfd seems to omit the search table if it can't use relative relocations to refer to functions. I don't really understand what's happening there. Maybe HPPA is an example?

Maybe the .eh_frame fallback scan can be skipped when .eh_frame_hdr has a search table. This should work as long as the table is never incomplete, and I suspect it'd make the terminator unnecessary most of the time.

For now, I think I'll work on a patch that simply removes the broken .eh_frame size calculation.

[rprichard]

I uploaded D87750, an alternative to this patch.

[rprichard]

Abandoned in favor of D87750.

libunwind/src/AddressSpace.hpp

struct dyld_unwind_sections
     uintptr_t                   dwarf_section_length;
     const void*                 compact_unwind_section;
     uintptr_t                   compact_unwind_section_length;
   };
 
   // In 10.7.0 or later, libSystem.dylib implements this function.
   extern "C" bool _dyld_find_unwind_sections(void *, dyld_unwind_sections *);
 
-#elif defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND) && defined(_LIBUNWIND_IS_BAREMETAL)
+#elif defined(_LIBUNWIND_IS_BAREMETAL)
 
   // When statically linked on bare-metal, the symbols for the EH table are looked
   // up without going through the dynamic loader.
 
   // The following linker script may be used to produce the necessary sections and symbols.
   // Unless the --eh-frame-hdr linker option is provided, the section is not generated
   // and does not take space in the output file.
   //
   //   .eh_frame :
   //   {
   //       __eh_frame_start = .;
   //       KEEP(*(.eh_frame))
   //       __eh_frame_end = .;
   //   }
   //
   //   .eh_frame_hdr :
   //   {
   //       KEEP(*(.eh_frame_hdr))
   //   }
   //
   //   __eh_frame_hdr_start = SIZEOF(.eh_frame_hdr) > 0 ? ADDR(.eh_frame_hdr) : 0;
   //   __eh_frame_hdr_end = SIZEOF(.eh_frame_hdr) > 0 ? . : 0;
 
+  #if defined(_LIBUNWIND_SUPPORT_DWARF_SECTION)
     extern char __eh_frame_start;
     extern char __eh_frame_end;
-
+  #endif
   #if defined(_LIBUNWIND_SUPPORT_DWARF_INDEX)
     extern char __eh_frame_hdr_start;
     extern char __eh_frame_hdr_end;
   #endif
-
-#elif defined(_LIBUNWIND_ARM_EHABI) && defined(_LIBUNWIND_IS_BAREMETAL)
-
+  #if defined(_LIBUNWIND_ARM_EHABI)
     // When statically linked on bare-metal, the symbols for the EH table are looked
     // up without going through the dynamic loader.
     extern char __exidx_start;
     extern char __exidx_end;
+  #endif
 
-#elif defined(_LIBUNWIND_ARM_EHABI) || defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
-
-// ELF-based systems may use dl_iterate_phdr() to access sections
-// containing unwinding information. 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.
-#ifndef _WIN32
-#include <link.h>
-#else
+#elif defined(_WIN32)
   #include <windows.h>
   #include <psapi.h>
-#endif
-#if !defined(ElfW)
-#define ElfW(type) Elf_##type
-#endif
-
+#elif defined(_LIBUNWIND_USE_DL_ITERATE_PHDR) ||                               \
+      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_DWARF_INDEX) ||       \
+#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_SUPPORT_DWARF_UNWIND)
+#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)
LocalAddressSpace::getEncodedP(pint_t &addr, pint_t end, uint8_t encoding,
   }
 
   if (encoding & DW_EH_PE_indirect)
     result = getP(result);
 
   return result;
 }
 
-#ifdef __APPLE__
-#elif defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND) && defined(_LIBUNWIND_IS_BAREMETAL)
-#elif defined(_LIBUNWIND_ARM_EHABI) && defined(_LIBUNWIND_IS_BAREMETAL)
-#elif defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND) && defined(_WIN32)
-#elif defined(_LIBUNWIND_SUPPORT_SEH_UNWIND) && defined(_WIN32)
-#elif defined(_LIBUNWIND_ARM_EHABI) && defined(__BIONIC__)
-// Code inside findUnwindSections handles all these cases.
-//
-// Although the above ifdef chain is ugly, there doesn't seem to be a cleaner
-// way to handle it. The generalized boolean expression is:
-//
-//  A OR (B AND C) OR (D AND C) OR (B AND E) OR (F AND E) OR (D AND G)
-//
-// Running it through various boolean expression simplifiers gives expressions
-// that don't help at all.
-#elif defined(_LIBUNWIND_ARM_EHABI) || defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
+#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;

 }
 
 struct _LIBUNWIND_HIDDEN dl_iterate_cb_data {
   LocalAddressSpace *addressSpace;
   UnwindInfoSections *sects;
   uintptr_t targetAddr;
 };
 
-#if defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
-  #if !defined(_LIBUNWIND_SUPPORT_DWARF_INDEX)
-    #error "_LIBUNWIND_SUPPORT_DWARF_UNWIND requires _LIBUNWIND_SUPPORT_DWARF_INDEX on this platform."
+#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->dwarf_section_length = phdr->p_memsz;
+      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) {
#endif
   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) {
-      EHHeaderParser<LocalAddressSpace>::EHHeaderInfo hdrInfo;
+      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;
-      found_hdr = EHHeaderParser<LocalAddressSpace>::decodeEHHdr(
-          *cbdata->addressSpace, eh_frame_hdr_start, phdr->p_memsz,
-          hdrInfo);
-      if (found_hdr)
-        cbdata->sects->dwarf_section = hdrInfo.eh_frame_ptr;
     } 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;
     }
   }
-  cbdata->sects->dwarf_section_length = 0;
   return 0;
 }
 
-#else  // defined(LIBUNWIND_SUPPORT_DWARF_UNWIND)
-// Given all the #ifdef's above, the code here is for
-// defined(LIBUNWIND_ARM_EHABI)
+#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);
if (phdr->p_type == PT_LOAD) {
       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  // defined(LIBUNWIND_SUPPORT_DWARF_UNWIND)
-#endif  // defined(_LIBUNWIND_ARM_EHABI) || defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
+
+#endif
+#endif  // defined(_LIBUNWIND_USE_DL_ITERATE_PHDR)
 
 
 inline bool LocalAddressSpace::findUnwindSections(pint_t targetAddr,
                                                   UnwindInfoSections &info) {
 #ifdef __APPLE__
   dyld_unwind_sections dyldInfo;
   if (_dyld_find_unwind_sections((void *)targetAddr, &dyldInfo)) {
     info.dso_base                      = (uintptr_t)dyldInfo.mh;
- #if defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
+ #if defined(_LIBUNWIND_SUPPORT_DWARF_SECTION)
     info.dwarf_section                 = (uintptr_t)dyldInfo.dwarf_section;
     info.dwarf_section_length          = dyldInfo.dwarf_section_length;
  #endif
     info.compact_unwind_section        = (uintptr_t)dyldInfo.compact_unwind_section;
     info.compact_unwind_section_length = dyldInfo.compact_unwind_section_length;
     return true;
   }
-#elif defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND) && defined(_LIBUNWIND_IS_BAREMETAL)
+#elif defined(_LIBUNWIND_IS_BAREMETAL)
+  bool result = false;
+ #if defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
+  info.dso_base = 0;
+ #endif
+ #if defined(_LIBUNWIND_SUPPORT_DWARF_SECTION)
   // Bare metal is statically linked, so no need to ask the dynamic loader
   info.dwarf_section_length = (uintptr_t)(&__eh_frame_end - &__eh_frame_start);
   info.dwarf_section =        (uintptr_t)(&__eh_frame_start);
   _LIBUNWIND_TRACE_UNWINDING("findUnwindSections: section %p length %p",
                              (void *)info.dwarf_section, (void *)info.dwarf_section_length);
+  result = result || info.dwarf_section_length;
+ #endif
  #if defined(_LIBUNWIND_SUPPORT_DWARF_INDEX)
   info.dwarf_index_section =        (uintptr_t)(&__eh_frame_hdr_start);
   info.dwarf_index_section_length = (uintptr_t)(&__eh_frame_hdr_end - &__eh_frame_hdr_start);
   _LIBUNWIND_TRACE_UNWINDING("findUnwindSections: index section %p length %p",
                              (void *)info.dwarf_index_section, (void *)info.dwarf_index_section_length);
+  result = result || info.dwarf_index_section_length;
  #endif
-  if (info.dwarf_section_length)
-    return true;
-#elif defined(_LIBUNWIND_ARM_EHABI) && defined(_LIBUNWIND_IS_BAREMETAL)
-  // Bare metal is statically linked, so no need to ask the dynamic loader
+ #if defined(_LIBUNWIND_ARM_EHABI)
   info.arm_section =        (uintptr_t)(&__exidx_start);
   info.arm_section_length = (uintptr_t)(&__exidx_end - &__exidx_start);
   _LIBUNWIND_TRACE_UNWINDING("findUnwindSections: section %p length %p",
                              (void *)info.arm_section, (void *)info.arm_section_length);
-  if (info.arm_section && info.arm_section_length)
-    return true;
-#elif defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND) && defined(_WIN32)
+  result = result || (info.arm_section && info.arm_section_length);
+ #endif
+  return result;
+#elif defined(_LIBUNWIND_SUPPORT_DWARF_SECTION) && defined(_WIN32)
   HMODULE mods[1024];
   HANDLE process = GetCurrentProcess();
   DWORD needed;
 
   if (!EnumProcessModules(process, mods, sizeof(mods), &needed)) {
     DWORD err = GetLastError();
     _LIBUNWIND_TRACE_UNWINDING("findUnwindSections: EnumProcessModules failed, "
                                "returned error %d", (int)err);
#elif defined(_LIBUNWIND_SUPPORT_DWARF_SECTION) && defined(_WIN32)
   }
   return false;
 #elif defined(_LIBUNWIND_SUPPORT_SEH_UNWIND) && defined(_WIN32)
   // Don't even bother, since Windows has functions that do all this stuff
   // for us.
   (void)targetAddr;
   (void)info;
   return true;
-#elif defined(_LIBUNWIND_ARM_EHABI) && defined(__BIONIC__)
-  // For ARM EHABI, Bionic didn't implement dl_iterate_phdr until API 21. After
-  // API 21, dl_iterate_phdr exists, but dl_unwind_find_exidx is much faster.
+#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_ARM_EHABI) || defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
+#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);
 #endif
 
   return false;
 }
 

libunwind/src/DwarfParser.hpp

#endif
   struct PrologInfoStackEntry {
     PrologInfoStackEntry(PrologInfoStackEntry *n, const PrologInfo &i)
         : next(n), info(i) {}
     PrologInfoStackEntry *next;
     PrologInfo info;
   };
 
   static bool findFDE(A &addressSpace, pint_t pc, pint_t ehSectionStart,
-                      uint32_t sectionLength, pint_t fdeHint, FDE_Info *fdeInfo,
-                      CIE_Info *cieInfo);
+                      uint32_t sectionLength, pint_t scanStart,
+                      FDE_Info *fdeInfo, CIE_Info *cieInfo);
   static const char *decodeFDE(A &addressSpace, pint_t fdeStart,
                                FDE_Info *fdeInfo, CIE_Info *cieInfo);
   static bool parseFDEInstructions(A &addressSpace, const FDE_Info &fdeInfo,
                                    const CIE_Info &cieInfo, pint_t upToPC,
                                    int arch, PrologInfo *results);
 
   static const char *parseCIE(A &addressSpace, pint_t cie, CIE_Info *cieInfo);
 
const char *CFI_Parser<A>::decodeFDE(A &addressSpace, pint_t fdeStart,
   fdeInfo->pcStart = pcStart;
   fdeInfo->pcEnd = pcStart + pcRange;
   return NULL; // success
 }
 
 /// Scan an eh_frame section to find an FDE for a pc
 template <typename A>
 bool CFI_Parser<A>::findFDE(A &addressSpace, pint_t pc, pint_t ehSectionStart,
-                            uint32_t sectionLength, pint_t fdeHint,
+                            uint32_t sectionLength, pint_t scanStart,
                             FDE_Info *fdeInfo, CIE_Info *cieInfo) {
   //fprintf(stderr, "findFDE(0x%llX)\n", (long long)pc);
-  pint_t p = (fdeHint != 0) ? fdeHint : ehSectionStart;
-  const pint_t ehSectionEnd = p + sectionLength;
+  pint_t p = scanStart;
+  const pint_t ehSectionEnd = ehSectionStart + sectionLength;
   while (p < ehSectionEnd) {
     pint_t currentCFI = p;
     //fprintf(stderr, "findFDE() CFI at 0x%llX\n", (long long)p);
     pint_t cfiLength = addressSpace.get32(p);
     p += 4;
     if (cfiLength == 0xffffffff) {
       // 0xffffffff means length is really next 8 bytes
       cfiLength = (pint_t)addressSpace.get64(p);

libunwind/src/FrameHeaderCache.hpp

 // 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.dwarf_section_length; };
+    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
void resetCache() {
     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;

libunwind/src/UnwindCursor.hpp

int stepWithEHABI() {
     return UNW_STEP_SUCCESS;
   }
 #endif
 
 #if defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
   bool getInfoFromFdeCie(const typename CFI_Parser<A>::FDE_Info &fdeInfo,
                          const typename CFI_Parser<A>::CIE_Info &cieInfo,
                          pint_t pc, uintptr_t dso_base);
-  bool getInfoFromDwarfSection(pint_t pc, const UnwindInfoSections &sects,
-                                            uint32_t fdeSectionOffsetHint=0);
   int stepWithDwarfFDE() {
     return DwarfInstructions<A, R>::stepWithDwarf(_addressSpace,
                                               (pint_t)this->getReg(UNW_REG_IP),
                                               (pint_t)_info.unwind_info,
                                               _registers, _isSignalFrame);
   }
 #endif
 
+#if defined(_LIBUNWIND_SUPPORT_DWARF_SECTION)
+  bool getInfoFromDwarfSection(pint_t pc, const UnwindInfoSections &sects,
+                               uint32_t fdeSectionOffsetHint = 0);
+#endif
+
 #if defined(_LIBUNWIND_SUPPORT_COMPACT_UNWIND)
   bool getInfoFromCompactEncodingSection(pint_t pc,
                                             const UnwindInfoSections &sects);
   int stepWithCompactEncoding() {
   #if defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
     if ( compactSaysUseDwarf() )
       return stepWithDwarfFDE();
   #endif
if (CFI_Parser<A>::parseFDEInstructions(_addressSpace, fdeInfo, cieInfo, pc,
     _info.format            = dwarfEncoding();
     _info.unwind_info       = fdeInfo.fdeStart;
     _info.unwind_info_size  = static_cast<uint32_t>(fdeInfo.fdeLength);
     _info.extra             = static_cast<unw_word_t>(dso_base);
     return true;
   }
   return false;
 }
+#endif
 
+#if defined(_LIBUNWIND_SUPPORT_DWARF_SECTION)
 template <typename A, typename R>
-bool UnwindCursor<A, R>::getInfoFromDwarfSection(pint_t pc,
-                                                const UnwindInfoSections &sects,
-                                                uint32_t fdeSectionOffsetHint) {
+bool UnwindCursor<A, R>::getInfoFromDwarfSection(
+    pint_t pc, const UnwindInfoSections &sects, uint32_t fdeSectionOffsetHint) {
   typename CFI_Parser<A>::FDE_Info fdeInfo;
   typename CFI_Parser<A>::CIE_Info cieInfo;
-  bool foundFDE = false;
-  bool foundInCache = false;
-  // If compact encoding table gave offset into dwarf section, go directly there
-  if (fdeSectionOffsetHint != 0) {
-    foundFDE = CFI_Parser<A>::findFDE(_addressSpace, pc, sects.dwarf_section,
-                                    (uint32_t)sects.dwarf_section_length,
-                                    sects.dwarf_section + fdeSectionOffsetHint,
-                                    &fdeInfo, &cieInfo);
-  }
-#if defined(_LIBUNWIND_SUPPORT_DWARF_INDEX)
-  if (!foundFDE && (sects.dwarf_index_section != 0)) {
-    foundFDE = EHHeaderParser<A>::findFDE(
-        _addressSpace, pc, sects.dwarf_index_section,
-        (uint32_t)sects.dwarf_index_section_length, &fdeInfo, &cieInfo);
-  }
-#endif
-  if (!foundFDE) {
-    // otherwise, search cache of previously found FDEs.
+
+  // If there is a compact encoding hint, then we start the scan at the hint,
+  // and we neither search nor add to the cache.
+  const bool useCache = (fdeSectionOffsetHint == 0);
+
+  if (useCache) {
+    // For some configs (e.g. bare-metal), the dso_base will be zero, so this
+    // cache search will also find dynamically-registered FDEs.
     pint_t cachedFDE = DwarfFDECache<A>::findFDE(sects.dso_base, pc);
     if (cachedFDE != 0) {
-      foundFDE =
-          CFI_Parser<A>::findFDE(_addressSpace, pc, sects.dwarf_section,
-                                 (uint32_t)sects.dwarf_section_length,
-                                 cachedFDE, &fdeInfo, &cieInfo);
-      foundInCache = foundFDE;
+      if (CFI_Parser<A>::findFDE(_addressSpace, pc, sects.dwarf_section,
+                                 static_cast<uint32_t>(sects.dwarf_section_length),
+                                 cachedFDE, &fdeInfo, &cieInfo)) {
+        if (getInfoFromFdeCie(fdeInfo, cieInfo, pc, sects.dso_base))
+          return true;
       }
     }
-  if (!foundFDE) {
-    // Still not found, do full scan of __eh_frame section.
-    foundFDE = CFI_Parser<A>::findFDE(_addressSpace, pc, sects.dwarf_section,
-                                      (uint32_t)sects.dwarf_section_length, 0,
-                                      &fdeInfo, &cieInfo);
   }
-  if (foundFDE) {
+
+  if (CFI_Parser<A>::findFDE(_addressSpace, pc, sects.dwarf_section,
+                             static_cast<uint32_t>(sects.dwarf_section_length),
+                             sects.dwarf_section + fdeSectionOffsetHint,
+                             &fdeInfo, &cieInfo)) {
     if (getInfoFromFdeCie(fdeInfo, cieInfo, pc, sects.dso_base)) {
-      // Add to cache (to make next lookup faster) if we had no hint
-      // and there was no index.
-      if (!foundInCache && (fdeSectionOffsetHint == 0)) {
-  #if defined(_LIBUNWIND_SUPPORT_DWARF_INDEX)
-        if (sects.dwarf_index_section == 0)
-  #endif
+      if (useCache) {
         DwarfFDECache<A>::add(sects.dso_base, fdeInfo.pcStart, fdeInfo.pcEnd,
                               fdeInfo.fdeStart);
       }
       return true;
     }
   }
+
   //_LIBUNWIND_DEBUG_LOG("can't find/use FDE for pc=0x%llX", (uint64_t)pc);
   return false;
 }
-#endif // defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
-
+#endif // defined(_LIBUNWIND_SUPPORT_DWARF_SECTION)
 
 #if defined(_LIBUNWIND_SUPPORT_COMPACT_UNWIND)
 template <typename A, typename R>
 bool UnwindCursor<A, R>::getInfoFromCompactEncodingSection(pint_t pc,
                                               const UnwindInfoSections &sects) {
   const bool log = false;
   if (log)
     fprintf(stderr, "getInfoFromCompactEncodingSection(pc=0x%llX, mh=0x%llX)\n",
#endif
 
   // Ask address space object to find unwind sections for this pc.
   UnwindInfoSections sects;
   if (_addressSpace.findUnwindSections(pc, sects)) {
 #if defined(_LIBUNWIND_SUPPORT_COMPACT_UNWIND)
     // If there is a compact unwind encoding table, look there first.
     if (sects.compact_unwind_section != 0) {
       if (this->getInfoFromCompactEncodingSection(pc, sects)) {
-  #if defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
-        // Found info in table, done unless encoding says to use dwarf.
+  #if defined(_LIBUNWIND_SUPPORT_DWARF_SECTION)
+        // Found info in table, done unless encoding says to use dwarf. Scan
+        // __eh_frame if we have a non-zero hint. Otherwise, we'll scan the
+        // entire __eh_frame below.
         uint32_t dwarfOffset;
-        if ((sects.dwarf_section != 0) && compactSaysUseDwarf(&dwarfOffset)) {
-          if (this->getInfoFromDwarfSection(pc, sects, dwarfOffset)) {
-            // found info in dwarf, done
+        if ((sects.dwarf_section != 0) && compactSaysUseDwarf(&dwarfOffset) &&
+            (dwarfOffset != 0)) {
+          if (this->getInfoFromDwarfSection(pc, sects, dwarfOffset))
             return;
-          }
-        }
   #endif
         // If unwind table has entry, but entry says there is no unwind info,
         // record that we have no unwind info.
         if (_info.format == 0)
           _unwindInfoMissing = true;
         return;
       }
     }
 #endif // defined(_LIBUNWIND_SUPPORT_COMPACT_UNWIND)
 
 #if defined(_LIBUNWIND_SUPPORT_SEH_UNWIND)
     // If there is SEH unwind info, look there next.
     if (this->getInfoFromSEH(pc))
       return;
 #endif
 
-#if defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
-    // If there is dwarf unwind info, look there next.
-    if (sects.dwarf_section != 0) {
-      if (this->getInfoFromDwarfSection(pc, sects)) {
-        // found info in dwarf, done
+    bool hasDwarfIndex = false;
+#if defined(_LIBUNWIND_SUPPORT_DWARF_INDEX)
+    if (sects.dwarf_index_section != 0) {
+      hasDwarfIndex = true;
+      typename CFI_Parser<A>::FDE_Info fdeInfo;
+      typename CFI_Parser<A>::CIE_Info cieInfo;
+      if (EHHeaderParser<A>::findFDE(
+              _addressSpace, pc, sects.dwarf_index_section,
+              static_cast<uint32_t>(sects.dwarf_index_section_length), &fdeInfo,
+              &cieInfo)) {
+        if (getInfoFromFdeCie(fdeInfo, cieInfo, pc, sects.dso_base))
           return;
       }
     }
 #endif
+#if defined(_LIBUNWIND_SUPPORT_DWARF_SECTION)
+    // If we have both eh_frame and its index (e.g. for a bare-metal target),
+    // and the index doesn't have the FDE, there is no need to scan the
+    // eh_frame.
+    if ((sects.dwarf_section != 0) && !hasDwarfIndex) {
+      if (this->getInfoFromDwarfSection(pc, sects))
+        return;
+    }
+#endif
+    (void)hasDwarfIndex;
 
 #if defined(_LIBUNWIND_ARM_EHABI)
     // If there is ARM EHABI unwind info, look there next.
     if (sects.arm_section != 0 && this->getInfoFromEHABISection(pc, sects))
       return;
 #endif
   }
 
#endif // #if defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
   // no unwind info, flag that we can't reliably unwind
   _unwindInfoMissing = true;
 }
 
 template <typename A, typename R>
 int UnwindCursor<A, R>::step() {
   // Bottom of stack is defined is when unwind info cannot be found.
   if (_unwindInfoMissing)
     return UNW_STEP_END;
 
   // Use unwinding info to modify register set as if function returned.
   int result;
 #if defined(_LIBUNWIND_SUPPORT_COMPACT_UNWIND)
   result = this->stepWithCompactEncoding();
 #elif defined(_LIBUNWIND_SUPPORT_SEH_UNWIND)
   result = this->stepWithSEHData();
 #elif defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
   result = this->stepWithDwarfFDE();
 #elif defined(_LIBUNWIND_ARM_EHABI)
   result = this->stepWithEHABI();
 #else
   #error Need _LIBUNWIND_SUPPORT_COMPACT_UNWIND or \
               _LIBUNWIND_SUPPORT_SEH_UNWIND or \
               _LIBUNWIND_SUPPORT_DWARF_UNWIND or \
               _LIBUNWIND_ARM_EHABI
 #endif
 
   // update info based on new PC
   if (result == UNW_STEP_SUCCESS) {
     this->setInfoBasedOnIPRegister(true);
     if (_unwindInfoMissing)
       return UNW_STEP_END;
   }
 
   return result;
 }
 
 template <typename A, typename R>
 void UnwindCursor<A, R>::getInfo(unw_proc_info_t *info) {
   if (_unwindInfoMissing)

libunwind/src/config.h

 //===----------------------------- config.h -------------------------------===//
 //
 // 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
 //
 //
 //  Defines macros used within libunwind project.
 //
 //===----------------------------------------------------------------------===//
 
 
 #ifndef LIBUNWIND_CONFIG_H
 #define LIBUNWIND_CONFIG_H
 
 #include <assert.h>
 #include <stdio.h>
 #include <stdint.h>
 #include <stdlib.h>
 
+#include <__libunwind_config.h>
+
 // Define static_assert() unless already defined by compiler.
 #ifndef __has_feature
   #define __has_feature(__x) 0
 #endif
 #if !(__has_feature(cxx_static_assert)) && !defined(static_assert)
   #define static_assert(__b, __m) \
       extern int compile_time_assert_failed[ ( __b ) ? 1 : -1 ]  \
                                                   __attribute__( ( unused ) );
 #endif
 
 // Platform specific configuration defines.
 #ifdef __APPLE__
   #if defined(FOR_DYLD)
     #define _LIBUNWIND_SUPPORT_COMPACT_UNWIND 1
   #else
     #define _LIBUNWIND_SUPPORT_COMPACT_UNWIND 1
-    #define _LIBUNWIND_SUPPORT_DWARF_UNWIND 1
+    #define _LIBUNWIND_SUPPORT_DWARF_SECTION 1
   #endif
 #elif defined(_WIN32)
   #ifdef __SEH__
     #define _LIBUNWIND_SUPPORT_SEH_UNWIND 1
   #else
-    #define _LIBUNWIND_SUPPORT_DWARF_UNWIND 1
+    #define _LIBUNWIND_SUPPORT_DWARF_SECTION 1
+  #endif
+#elif defined(_LIBUNWIND_IS_BAREMETAL)
+  #if !defined(_LIBUNWIND_ARM_EHABI)
+    // Prefer to use the index, but if that's empty, we'll fall back to scanning
+    // .eh_frame.
+    #define _LIBUNWIND_SUPPORT_DWARF_INDEX 1
+    #define _LIBUNWIND_SUPPORT_DWARF_SECTION 1
   #endif
+#elif defined(_LIBUNWIND_ARM_EHABI) && defined(__BIONIC__)
+  // For ARM EHABI, Bionic didn't implement dl_iterate_phdr until API 21. After
+  // API 21, dl_iterate_phdr exists, but dl_unwind_find_exidx is much faster.
+  #define _LIBUNWIND_USE_DL_UNWIND_FIND_EXIDX 1
 #else
-  #if defined(__ARM_DWARF_EH__) || !defined(__arm__)
-    #define _LIBUNWIND_SUPPORT_DWARF_UNWIND 1
+  #define _LIBUNWIND_USE_DL_ITERATE_PHDR 1
+  #if !defined(_LIBUNWIND_ARM_EHABI)
     #define _LIBUNWIND_SUPPORT_DWARF_INDEX 1
   #endif
 #endif
+#if defined(_LIBUNWIND_SUPPORT_DWARF_INDEX) ||                                 \
+    defined(_LIBUNWIND_SUPPORT_DWARF_SECTION)
+  #define _LIBUNWIND_SUPPORT_DWARF_UNWIND 1
+#endif
 
 #if defined(_LIBUNWIND_DISABLE_VISIBILITY_ANNOTATIONS)
   #define _LIBUNWIND_EXPORT
   #define _LIBUNWIND_HIDDEN
 #else
   #if !defined(__ELF__) && !defined(__MACH__)
     #define _LIBUNWIND_EXPORT __declspec(dllexport)
     #define _LIBUNWIND_HIDDEN

libunwind/test/frameheadercache_test.pass.cpp

 // The other libunwind tests don't test internal interfaces, so the include path
 // is a little wonky.
 #include "../src/config.h"
 
 // Only run this test under supported configurations.
-// The frame header cache should work fine for other architectures,
-// but the #ifdefs end up being even more complicated than this.
 
-#if defined(__x86_64__) && defined(_LIBUNWIND_USE_FRAME_HEADER_CACHE)
-
-// This #if chain is ugly, but see the comments in AddressSpace.hpp for
-// the reasoning.
-
-#ifdef __APPLE__
-int main() { return 0; }
-#elif defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND) && defined(_LIBUNWIND_IS_BAREMETAL)
-int main() { return 0; }
-#elif defined(_LIBUNWIND_ARM_EHABI) && defined(_LIBUNWIND_IS_BAREMETAL)
-int main() { return 0; }
-#elif defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND) && defined(_WIN32)
-int main() { return 0; }
-#elif defined(_LIBUNWIND_SUPPORT_SEH_UNWIND) && defined(_WIN32)
-int main() { return 0; }
-#elif defined(_LIBUNWIND_ARM_EHABI) && defined(__BIONIC__)
-int main() { return 0; }
-#elif defined(_LIBUNWIND_ARM_EHABI) || defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
+#if defined(_LIBUNWIND_USE_DL_ITERATE_PHDR) &&                                 \
+    defined(_LIBUNWIND_SUPPORT_DWARF_INDEX) &&                                 \
+    defined(_LIBUNWIND_USE_FRAME_HEADER_CACHE)
 
 #include <link.h>
 #include <stdio.h>
 
 // This file defines several of the data structures needed here,
 // and includes FrameHeaderCache.hpp as well.
 #include "../src/AddressSpace.hpp"
 
 #define kBaseAddr 0xFFF000
-#define kDwarfSectionLength 0xFF
+#define kDsoLength 0xFF
 
 using namespace libunwind;
 
 int main() {
   FrameHeaderCache FHC;
   struct dl_phdr_info PInfo;
   memset(&PInfo, 0, sizeof(PInfo));
   // The cache itself should only care about these two fields--they
   // tell the cache to invalidate or not; everything else is handled
   // by AddressSpace.hpp.
   PInfo.dlpi_adds = 6;
   PInfo.dlpi_subs = 7;
 
   UnwindInfoSections UIS;
   UIS.dso_base = kBaseAddr;
-  UIS.dwarf_section_length = kDwarfSectionLength;
+  UIS.dso_length = kDsoLength;
   dl_iterate_cb_data CBData;
   // Unused by the cache.
   CBData.addressSpace = nullptr;
   CBData.sects = &UIS;
   CBData.targetAddr = kBaseAddr + 1;
 
   // Nothing present, shouldn't find.
   if (FHC.find(&PInfo, 0, &CBData))
int main() {
 
   FHC.add(&UIS);
   CBData.targetAddr = kBaseAddr - 1;
   // Shouldn't find something outside of the addresses.
   if (FHC.find(&PInfo, 0, &CBData))
     abort();
   // Add enough things to the cache that the entry is evicted.
   for (int i = 0; i < 9; i++) {
-    UIS.dso_base = kBaseAddr + (kDwarfSectionLength * i);
+    UIS.dso_base = kBaseAddr + (kDsoLength * i);
     FHC.add(&UIS);
   }
   CBData.targetAddr = kBaseAddr;
   // Should have been evicted.
   if (FHC.find(&PInfo, 0, &CBData))
     abort();
   return 0;
 }
-#else
-int main() { return 0; }
-#endif
+
 #else
 int main() { return 0;}
 #endif