[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

 //   .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)
 

 #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)

 }
 
 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;
 }
 
 #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);

 
 
 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_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)
+  bool result = false;
+ #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;
+  return result;
 #elif defined(_LIBUNWIND_ARM_EHABI) && defined(_LIBUNWIND_IS_BAREMETAL)
   // Bare metal is statically linked, so no need to ask the dynamic loader
   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)
+#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);

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

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) {
+  // If there is a compact encoding hint, then start the scan at the hint, and
+  // neither search nor add to the cache.
+  const bool useCache = (fdeSectionOffsetHint == 0);
+  if (useCache) {
     // otherwise, search cache of previously found 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) {
+        // Add to cache (to make next lookup faster).
         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)
#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, 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
   }
 

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.
 //

 #if defined(__USING_SJLJ_EXCEPTIONS__)
   // None of these macros apply to SJLJ unwinding.
 #elif defined(__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(__BIONIC__) && defined(_LIBUNWIND_ARM_EHABI)
   // 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
 #elif defined(_LIBUNWIND_IS_BAREMETAL)
   #if !defined(_LIBUNWIND_ARM_EHABI)
+    // Fall back to scanning .eh_frame if the index is unavailable.
     #define _LIBUNWIND_SUPPORT_DWARF_UNWIND 1
+    #define _LIBUNWIND_SUPPORT_DWARF_SECTION 1
     #define _LIBUNWIND_SUPPORT_DWARF_INDEX 1
   #endif
 #else
   // Assume an ELF system with a dl_iterate_phdr function.
   #define _LIBUNWIND_USE_DL_ITERATE_PHDR 1
   #if !defined(_LIBUNWIND_ARM_EHABI)
     #define _LIBUNWIND_SUPPORT_DWARF_UNWIND 1
     #define _LIBUNWIND_SUPPORT_DWARF_INDEX 1

libunwind/test/frameheadercache_test.pass.cpp

 #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