Merge pull request #1357 from swiftix/wip-runtime-calling-convention

Prepare the ground for using a new calling convention for functions from the runtime library

Author: swiftix

include/swift/Runtime/Config.h

@@ -62,4 +62,127 @@
 // Bring in visibility attribute macros
 #include "../../../stdlib/public/SwiftShims/Visibility.h"
 
+// Define mappings for calling conventions.
+
+// Annotation for specifying a calling convention of
+// a runtime function. It should be used with declarations
+// of runtime functions like this:
+// void runtime_function_name() SWIFT_CC(RegisterPreservingCC)
+#define SWIFT_CC(CC) SWIFT_CC_##CC
+
+#define SWIFT_CC_preserve_most __attribute__((preserve_most))
+#define SWIFT_CC_preserve_all  __attribute__((preserve_all))
+#define SWIFT_CC_c
+
+// Map a logical calling convention (e.g. RegisterPreservingCC) to LLVM calling
+// convention.
+#define SWIFT_LLVM_CC(CC) SWIFT_LLVM_CC_##CC
+
+// Currently, RuntimeFunction.def uses the following calling conventions:
+// DefaultCC, RegisterPreservingCC.
+// If new runtime calling conventions are added later, they need to be mapped
+// here to something appropriate.
+
+// DefaultCC is usually the standard C calling convention.
+#define SWIFT_CC_DefaultCC SWIFT_CC_c
+#define SWIFT_CC_DefaultCC_IMPL SWIFT_CC_c
+#define SWIFT_LLVM_CC_DefaultCC llvm::CallingConv::C
+
+// If defined, it indicates that runtime function wrappers
+// should be used on all platforms, even they do not support
+// the new calling convention which requires this.
+#define SWIFT_RT_USE_WRAPPERS_ALWAYS 1
+
+// If defined, it indicates that this calling convention is
+// supported by the currnet target.
+// TODO: Define it once the runtime calling convention support has
+// been integrated into clang and llvm.
+//#define RT_USE_RegisterPreservingCC
+
+// RegisterPreservingCC is a dedicated runtime calling convention to be used
+// when calling the most popular runtime functions.
+#if defined(RT_USE_RegisterPreservingCC) && __has_attribute(preserve_most) &&  \
+    (defined(__aarch64__) || defined(__x86_64__))
+
+// Targets supporting the dedicated runtime convention should use it.
+// If a runtime function is using this calling convention, it can
+// be invoked only by means of a wrapper, which performs an indirect
+// call. Wrappers are generated by the IRGen and added to object files.
+// As a result, runtime functions are invoked only indirectly from
+// the user code.
+// This is a workaround for dynamic linking issues, where a dynamic
+// linker may clobber some of the callee-saved registers defined by
+// this new calling convention when it performs lazy binding of
+// runtime functions using this new calling convention.
+#define SWIFT_CC_RegisterPreservingCC                          \
+  SWIFT_CC_preserve_most
+#define SWIFT_CC_RegisterPreservingCC_IMPL                     \
+  SWIFT_CC_preserve_most
+#define SWIFT_LLVM_CC_RegisterPreservingCC llvm::CallingConv::PreserveMost
+
+// Indicate that wrappers should be used, because it is required
+// for the calling convention to get around dynamic linking issues.
+#define SWIFT_RT_USE_WRAPPERS 1
+
+#else
+
+// Targets not supporting the dedicated runtime calling convention
+// should use the standard calling convention instead.
+// No wrappers are required in this case by the calling convention.
+#define SWIFT_CC_RegisterPreservingCC SWIFT_CC_c
+#define SWIFT_CC_RegisterPreservingCC_IMPL SWIFT_CC_c
+#define SWIFT_LLVM_CC_RegisterPreservingCC llvm::CallingConv::C
+
+#endif
+
+// Bring in visibility attribute macros for library visibility.
+#include "llvm/Support/Compiler.h"
+
+// Generates a name of the runtime enrty's implementation by
+// adding an underscore as a prefix and a suffix.
+#define SWIFT_RT_ENTRY_IMPL(Name) _##Name##_
+
+// Library internal way to invoke the implementation of a runtime entry.
+// E.g. a runtime function  may be called internally via its public API
+// or via the function pointer.
+#define SWIFT_RT_ENTRY_CALL(Name) Name
+
+// Name of the symbol holding a reference to the
+// implementation of a runtime entry.
+#define SWIFT_RT_ENTRY_REF(Name) _##Name
+
+// String representation of the symbol's name.
+#define SWIFT_RT_ENTRY_REF_AS_STR(Name) "_" #Name
+
+#if defined(SWIFT_RT_USE_WRAPPERS_ALWAYS)
+#define SWIFT_RT_USE_WRAPPERS
+#endif
+
+#if defined(SWIFT_RT_USE_WRAPPERS)
+
+// Both the runtime functions and their implementation are hidden and
+// can be directly referenced only inside the runtime library.
+// User code can access these runtime entries only indirectly
+// via a global function pointer.
+// NOTE: In principle, entries may have LLVM_LIBRARY_VISIBILITY,
+// because they are never called directly from the code
+// produced by IRGen.
+// But some of the runtime entries are invoked directly from
+// the foundation. Therefore they should be visible.
+#define SWIFT_RT_ENTRY_VISIBILITY SWIFT_RUNTIME_EXPORT
+#define SWIFT_RT_ENTRY_IMPL_VISIBILITY LLVM_LIBRARY_VISIBILITY
+
+// Prefix of wrappers generated for runtime functions.
+#define SWIFT_WRAPPER_PREFIX "rt_"
+
+#else
+
+// Runtime functions are exported, because it should be possible
+// to invoke them directly from the user code. But internal
+// implementations of runtime functions do not need to be exported.
+#define SWIFT_RT_ENTRY_VISIBILITY SWIFT_RUNTIME_EXPORT
+#define SWIFT_RT_ENTRY_IMPL_VISIBILITY LLVM_LIBRARY_VISIBILITY
+
+#endif
+
 #endif // SWIFT_RUNTIME_CONFIG_H

include/swift/Runtime/Enum.h

@@ -50,10 +50,13 @@ extern "C" void swift_initEnumValueWitnessTableSinglePayload(
 /// \returns -1 if the payload case is inhabited. If an empty case is inhabited,
 ///          returns a value greater than or equal to zero and less than
 ///          emptyCases.
-SWIFT_RUNTIME_EXPORT
+SWIFT_RT_ENTRY_VISIBILITY
 extern "C" int swift_getEnumCaseSinglePayload(const OpaqueValue *value,
                                               const Metadata *payload,
-                                              unsigned emptyCases);
+                                              unsigned emptyCases)
+  SWIFT_CC(RegisterPreservingCC);
+
+
 
 /// \brief Store the tag value for the given case into a single-payload enum,
 ///        whose associated payload (if any) has already been initialized.
@@ -66,11 +69,12 @@ extern "C" int swift_getEnumCaseSinglePayload(const OpaqueValue *value,
 ///                    case, or a value greater than or equal to zero and less
 ///                    than emptyCases for an empty case.
 /// \param emptyCases - the number of empty cases in the enum.
-SWIFT_RUNTIME_EXPORT
+SWIFT_RT_ENTRY_VISIBILITY
 extern "C" void swift_storeEnumTagSinglePayload(OpaqueValue *value,
                                                  const Metadata *payload,
                                                  int whichCase,
-                                                 unsigned emptyCases);
+                                                 unsigned emptyCases)
+  SWIFT_CC(RegisterPreservingCC);
 
 /// \brief Initialize the value witness table for a generic, multi-payload
 ///        enum instance.