[ExecutionEngine] Check for libunwind before calling __register_frame

[hvdijk]

Summary

libgcc and libunwind have different flavours of register_frame. Both flavours are already correctly handled, except that the code to handle the libunwind flavour is guarded by APPLE. This change uses the presence of unw_add_dynamic_fde in libunwind instead to detect whether libunwind is used, rather than hardcoding it as Apple vs. non-Apple.

Fixes PR44074.

Thanks to Albert Jin <[e-mail]> and Chris Schafmeister <[e-mail]> for identifying the problem.

[lhames]

LGTM -- Thanks Harald. Do you have commit access? If not please let me know and I can commit this on your behalf.

Side note: I think we should revisit the dynamic registration APIs in libunwind to see if we can come up with something universal, but this seems like a good interim solution. I'll mention this on PR44074 too.

[hvdijk]

Thanks, I do have commit access, I'll push this once I can re-test against current main just to be sure.

I agree that it would be good to change libunwind's __register_frame to accept the same arguments that libgcc's version accepts, but I think we would need something like this patch regardless for the short term, as LLVM may be linked against older versions of libunwind that we will still want to support for now.

[tstellar]

llvm/lib/ExecutionEngine/RuntimeDyld/RTDyldMemoryManager.cpp

72

Should this be a runtime check and not a compile time check?

[hvdijk]

llvm/lib/ExecutionEngine/RuntimeDyld/RTDyldMemoryManager.cpp

72

It only makes a difference if we build against libgcc and then change it at runtime to use libunwind, or vice versa. In general, I think that if __register_frame behaves differently between the two versions, we cannot support that anyway. We could make it work specifically in the case of LLVM as a special exception, but if we want to make that work in general, it would be more useful to modify libunwind to be compatible with libgcc rather than making changes here.

[tstellar]

llvm/lib/ExecutionEngine/RuntimeDyld/RTDyldMemoryManager.cpp

72

OK, thanks.

llvm/cmake/config-ix.cmake

 check_c_compiler_flag("-Werror=unguarded-availability-new" "C_SUPPORTS_WERROR_UNGUARDED_AVAILABILITY_NEW")
 if(C_SUPPORTS_WERROR_UNGUARDED_AVAILABILITY_NEW)
   set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -Werror=unguarded-availability-new")
 endif()
 
 # Determine whether we can register EH tables.
 check_symbol_exists(__register_frame "${CMAKE_CURRENT_LIST_DIR}/unwind.h" HAVE_REGISTER_FRAME)
 check_symbol_exists(__deregister_frame "${CMAKE_CURRENT_LIST_DIR}/unwind.h" HAVE_DEREGISTER_FRAME)
+check_symbol_exists(__unw_add_dynamic_fde "${CMAKE_CURRENT_LIST_DIR}/unwind.h" HAVE_UNW_ADD_DYNAMIC_FDE)
 
 check_symbol_exists(_Unwind_Backtrace "unwind.h" HAVE__UNWIND_BACKTRACE)
 check_symbol_exists(getpagesize unistd.h HAVE_GETPAGESIZE)
 check_symbol_exists(sysconf unistd.h HAVE_SYSCONF)
 check_symbol_exists(getrusage sys/resource.h HAVE_GETRUSAGE)
 check_symbol_exists(setrlimit sys/resource.h HAVE_SETRLIMIT)
 check_symbol_exists(isatty unistd.h HAVE_ISATTY)
 check_symbol_exists(futimens sys/stat.h HAVE_FUTIMENS)

llvm/cmake/unwind.h

 // NOLINT: llvm-header-guard
 // __register_frame() is used with dynamically generated code to register the
 // FDE for a generated (JIT) code. This header provides protypes, since the gcc
 // version of unwind.h may not, so CMake can check if the corresponding symbols
 // exist in the runtime.
 extern void __register_frame(const void *fde);   // NOLINT
 extern void __deregister_frame(const void *fde); // NOLINT
+extern void __unw_add_dynamic_fde();             // NOLINT

llvm/include/llvm/Config/config.h.cmake

 #cmakedefine HAVE_DLADDR ${HAVE_DLADDR}
 
 /* Define to 1 if we can register EH frames on this platform. */
 #cmakedefine HAVE_REGISTER_FRAME ${HAVE_REGISTER_FRAME}
 
 /* Define to 1 if we can deregister EH frames on this platform. */
 #cmakedefine HAVE_DEREGISTER_FRAME ${HAVE_DEREGISTER_FRAME}
 
+/* Define if __unw_add_dynamic_fde() is available on this platform. */
+#cmakedefine HAVE_UNW_ADD_DYNAMIC_FDE ${HAVE_UNW_ADD_DYNAMIC_FDE}
+
 /* Define to 1 if you have the <errno.h> header file. */
 #cmakedefine HAVE_ERRNO_H ${HAVE_ERRNO_H}
 
 /* Define to 1 if you have the <fcntl.h> header file. */
 #cmakedefine HAVE_FCNTL_H ${HAVE_FCNTL_H}
 
 /* Define to 1 if you have the <fenv.h> header file. */
 #cmakedefine HAVE_FENV_H ${HAVE_FENV_H}

llvm/lib/ExecutionEngine/Orc/TargetProcess/RegisterEHFrames.cpp

static Error deregisterFrameWrapper(const void *P) {
   }
 
   return make_error<StringError>("could not deregister eh-frame: "
                                  "__deregister_frame function not found",
                                  inconvertibleErrorCode());
 }
 #endif
 
-#ifdef __APPLE__
+#ifdef HAVE_UNW_ADD_DYNAMIC_FDE
 
 template <typename HandleFDEFn>
-Error walkAppleEHFrameSection(const char *const SectionStart,
+Error walkLibunwindEHFrameSection(const char *const SectionStart,
                                   size_t SectionSize, HandleFDEFn HandleFDE) {
   const char *CurCFIRecord = SectionStart;
   const char *End = SectionStart + SectionSize;
   uint64_t Size = *reinterpret_cast<const uint32_t *>(CurCFIRecord);
 
   while (CurCFIRecord != End && Size != 0) {
     const char *OffsetField = CurCFIRecord + (Size == 0xffffffff ? 12 : 4);
     if (Size == 0xffffffff)
       Size = *reinterpret_cast<const uint64_t *>(CurCFIRecord + 4) + 12;
while (CurCFIRecord != End && Size != 0) {
     CurCFIRecord += Size;
 
     Size = *reinterpret_cast<const uint32_t *>(CurCFIRecord);
   }
 
   return Error::success();
 }
 
-#endif // __APPLE__
+#endif // HAVE_UNW_ADD_DYNAMIC_FDE
 
 Error registerEHFrameSection(const void *EHFrameSectionAddr,
                              size_t EHFrameSectionSize) {
-#ifdef __APPLE__
-  // On Darwin __register_frame has to be called for each FDE entry.
-  return walkAppleEHFrameSection(static_cast<const char *>(EHFrameSectionAddr),
-                                 EHFrameSectionSize, registerFrameWrapper);
+  /* libgcc and libunwind __register_frame behave differently. We use the
+   * presence of __unw_add_dynamic_fde to detect libunwind. */
+#ifdef HAVE_UNW_ADD_DYNAMIC_FDE
+  // With libunwind, __register_frame has to be called for each FDE entry.
+  return walkLibunwindEHFrameSection(
+      static_cast<const char *>(EHFrameSectionAddr), EHFrameSectionSize,
+      registerFrameWrapper);
 #else
-  // On Linux __register_frame takes a single argument:
+  // With libgcc, __register_frame takes a single argument:
   // a pointer to the start of the .eh_frame section.
 
   // How can it find the end? Because crtendS.o is linked
   // in and it has an .eh_frame section with four zero chars.
   return registerFrameWrapper(EHFrameSectionAddr);
 #endif
 }
 
 Error deregisterEHFrameSection(const void *EHFrameSectionAddr,
                                size_t EHFrameSectionSize) {
-#ifdef __APPLE__
-  return walkAppleEHFrameSection(static_cast<const char *>(EHFrameSectionAddr),
-                                 EHFrameSectionSize, deregisterFrameWrapper);
+#ifdef HAVE_UNW_ADD_DYNAMIC_FDE
+  return walkLibunwindEHFrameSection(
+      static_cast<const char *>(EHFrameSectionAddr), EHFrameSectionSize,
+      deregisterFrameWrapper);
 #else
   return deregisterFrameWrapper(EHFrameSectionAddr);
 #endif
 }
 
 } // end namespace orc
 } // end namespace llvm
 

llvm/lib/ExecutionEngine/RuntimeDyld/RTDyldMemoryManager.cpp

if (!Searched) {
     *(void **)&df = llvm::sys::DynamicLibrary::SearchForAddressOfSymbol(
         "__deregister_frame");
   }
   if (df)
     df(p);
 }
 #endif
 
-#ifdef __APPLE__
+/* libgcc and libunwind __register_frame behave differently. We use the presence
+ * of __unw_add_dynamic_fde to detect libunwind. */
+#ifdef HAVE_UNW_ADD_DYNAMIC_FDE
 
 static const char *processFDE(const char *Entry, bool isDeregister) {
   const char *P = Entry;
   uint32_t Length = *((const uint32_t *)P);
   P += 4;
   uint32_t Offset = *((const uint32_t *)P);
   if (Offset != 0) {
     if (isDeregister)