[CMake][ExecutionEngine] add HAVE_(DE)REGISTER_FRAME as a config.h macros

[daltenty]

Summary

The macro HAVE_EHTABLE_SUPPORT is used by parts of ExecutionEngine to tell register_frame/deregister_frame is available to register the
FDE for a generated (JIT) code. It's currently set by a slowly growing set of macro tests in the respective headers, which is updated now and then when it fails to link on some platform or another due to the symbols being missing (see for example https://bugs.llvm.org/show_bug.cgi?id=5715).

This change converts the macro in two HAVE_(DE)REGISTER_FRAME config.h macros (like most of the other HAVE_* macros) and set's them based on whether CMake can actually find a definition for these symbols to link to at configuration time.

[daltenty]

• Adjust so we don't alter the MVS case

[Xiangling_L]

Do we want to take advantage of this patch to move those checks into the cmake configure so we don't need to duplicate the logic in 2 files as @sfertile mentioned previously?

[daltenty]

In D87114#2280184, @Xiangling_L wrote:

Do we want to take advantage of this patch to move those checks into the cmake configure so we don't need to duplicate the logic in 2 files as @sfertile mentioned previously?

I think that makes a lot of sense, that would allow for making it an overridable configuration setting. We'll just have to be careful to replicate the behaviour of the conditions here. I'll proceed in that direction.

[hubert.reinterpretcast]

General comment: CMake is not the only mechanism for making the conditions common; a header file is capable of the same.

[daltenty]

• Upgrade HAVE_EHTABLE_SUPPORT to a real config.h macro

[daltenty]

• Add a newline

[hubert.reinterpretcast]

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

62

I think the name is not appropriate in the wider context. I suggest having separate config variables for each of the functions (like the one for _Unwind_Backtrace) and then using those to define HAVE_EHTABLE_SUPPORT where it is defined before this patch.

[daltenty]

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

62

I think that makes sense, though I'd prefer to drop the macro HAVE_EHTABLE_SUPPORT entirely then. What this code is really looking for the presence of the registration / deregistration functions anyway, nothing else.

[daltenty]

• Cut out the middle man of 'HAVE_EHTABLE_SUPPORT' and just say what we mean.

[hubert.reinterpretcast]

llvm/lib/ExecutionEngine/RuntimeDyld/RTDyldMemoryManager.cpp

35–37

Just noting that, since the fallback path attempts to use the functions in question by finding them at runtime, I guess none of the macros queried here is actually effective at preventing an attempt to register the frame.

It is still possible that the macros were effective at preventing a hard load-dependency on certain DLLs though. @daltenty, should __SEH__ and __USING_SJLJ_EXCEPTIONS__ continue to force the fallback path?

[daltenty]

llvm/lib/ExecutionEngine/RuntimeDyld/RTDyldMemoryManager.cpp

35–37

I think that seems advisable for the reason you note.

[daltenty]

• Add back in SEH and SJLJ eh guards

[MaskRay]

llvm/cmake/config-ix.cmake

209

Is CMAKE_CURRENT_LIST_DIR needed?

[daltenty]

llvm/cmake/config-ix.cmake

209

Yes, looks like CMake just inserts the arg as-is into the test program and we want to use the header stub, not the system unwind.h.

[hubert.reinterpretcast]

LGTM; thanks!

llvm/lib/ExecutionEngine/RuntimeDyld/RTDyldMemoryManager.cpp

35–37

Thanks.

[daltenty]

• Prefer cmakedefine to cmakedefine01 because the later doesn't work with defined() macro checks

[daltenty]

• Suppress linter warnings for header stub

llvm/cmake/config-ix.cmake

 
 # Prevent check_symbol_exists from using API that is not supported for a given
 # deployment target.
 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)
+
+if(HAVE_REGISTER_FRAME AND HAVE_DEREGISTER_FRAME)
+  set(HAVE_EHTABLE_SUPPORT TRUE CACHE INTERNAL "")
+endif()
+
 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)
 check_symbol_exists(futimes sys/time.h HAVE_FUTIMES)

llvm/cmake/unwind.h

+// __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);
+extern void __deregister_frame(const void *fde);

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

 #cmakedefine HAVE_DLFCN_H ${HAVE_DLFCN_H}
 
 /* Define if dlopen() is available on this platform. */
 #cmakedefine HAVE_DLOPEN ${HAVE_DLOPEN}
 
 /* Define if dladdr() is available on this platform. */
 #cmakedefine HAVE_DLADDR ${HAVE_DLADDR}
 
+/* Define to 1 if we can register EH tables on this platform. */
+#cmakedefine01 HAVE_EHTABLE_SUPPORT
+
 /* 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/JITLink/EHFrameSupport.cpp

 //===-------- JITLink_EHFrameSupport.cpp - JITLink eh-frame utils ---------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "EHFrameSupportImpl.h"
 
 #include "llvm/BinaryFormat/Dwarf.h"
+#include "llvm/Config/config.h"
 #include "llvm/Support/DynamicLibrary.h"
 
 #define DEBUG_TYPE "jitlink"
 
 namespace llvm {
 namespace jitlink {
 
 EHFrameSplitter::EHFrameSplitter(StringRef EHFrameSectionName)
Expected<Symbol &> EHFrameEdgeFixer::getOrCreateSymbol(ParseContext &PC,
   auto *B = PC.AddrToBlock.getBlockCovering(Addr);
   if (!B)
     return make_error<JITLinkError>("No symbol or block covering address " +
                                     formatv("{0:x16}", Addr));
 
   return PC.G.addAnonymousSymbol(*B, Addr - B->getAddress(), 0, false, false);
 }
 
-// Determine whether we can register EH tables.
-#if (defined(__GNUC__) && !defined(__ARM_EABI__) && !defined(__ia64__) &&      \
-     !(defined(_AIX) && defined(__ibmxl__)) && !defined(__MVS__) &&            \
-     !defined(__SEH__) && !defined(__USING_SJLJ_EXCEPTIONS__))
-#define HAVE_EHTABLE_SUPPORT 1
-#else
-#define HAVE_EHTABLE_SUPPORT 0
-#endif
-
 #if HAVE_EHTABLE_SUPPORT
 extern "C" void __register_frame(const void *);
 extern "C" void __deregister_frame(const void *);
 
 Error registerFrameWrapper(const void *P) {
   __register_frame(P);
   return Error::success();
 }

llvm/lib/ExecutionEngine/RuntimeDyld/RTDyldMemoryManager.cpp

#ifdef __linux__
   #include <fcntl.h>
   #include <unistd.h>
 #endif
 
 namespace llvm {
 
 RTDyldMemoryManager::~RTDyldMemoryManager() {}
 
-// Determine whether we can register EH tables.
-#if (defined(__GNUC__) && !defined(__ARM_EABI__) && !defined(__ia64__) &&      \
-     !(defined(_AIX) && defined(__ibmxl__)) && !defined(__MVS__) &&            \
-     !defined(__SEH__) && !defined(__USING_SJLJ_EXCEPTIONS__))
-#define HAVE_EHTABLE_SUPPORT 1
-#else
-#define HAVE_EHTABLE_SUPPORT 0
-#endif
-
 #if HAVE_EHTABLE_SUPPORT
 extern "C" void __register_frame(void *);
 extern "C" void __deregister_frame(void *);
 #else
 // The building compiler does not have __(de)register_frame but
 // it may be found at runtime in a dynamically-loaded library.
 // For example, this happens when building LLVM with Visual C++
 // but using the MingW runtime.