Runtime: split out extern "C" marker from SWIFT_RUNTIME_EXPORT

Although the runtime exported symbols must be exported with "C" linkage
and decoration, we split out the externalisation in the C++ mode.  This
is required to ensure that we are able to attribute the functions
without following the more stringent rules that clang now enforces which
place the attributes following the identifier to which they appertain,
resulting in the attributes interleaving within the signature.  The
resulting spelling is more difficult to process for humans as well as
more difficult to identify as function declarations making code perusal
a challenge, particularly for the uninitiated.

Author: compnerd

include/swift/Runtime/Heap.h

@@ -25,6 +25,7 @@
 #include "swift/shims/Visibility.h"
 
 namespace swift {
+SWIFT_BEGIN_DECLS
 // Allocate plain old memory. This is the generalized entry point
 // Never returns nil. The returned memory is uninitialized. 
 //
@@ -37,6 +38,8 @@ void *swift_slowAlloc(size_t bytes, size_t alignMask);
 SWIFT_RUNTIME_EXPORT
 void swift_slowDealloc(void *ptr, size_t bytes, size_t alignMask);
 
+SWIFT_END_DECLS
+
 /// Allocate and construct an instance of type \c T.
 ///
 /// \param args The arguments to pass to the constructor for \c T.

include/swift/Runtime/HeapObject.h

@@ -42,6 +42,8 @@ using HeapMetadata = TargetHeapMetadata<InProcess>;
 
 struct OpaqueValue;
 
+SWIFT_BEGIN_DECLS
+
 /// Allocates a new heap object.  The returned memory is
 /// uninitialized outside of the heap-object header.  The object
 /// has an initial retain count of 1, and its metadata is set to
@@ -92,11 +94,15 @@ HeapObject *swift_initStaticObject(HeapMetadata const *metadata,
 SWIFT_RUNTIME_EXPORT
 void swift_verifyEndOfLifetime(HeapObject *object);
 
+SWIFT_END_DECLS
+
 struct BoxPair {
   HeapObject *object;
   OpaqueValue *buffer;
 };
 
+SWIFT_BEGIN_DECLS
+
 /// Allocates a heap object that can contain a value of the given type.
 /// Returns a Box structure containing a HeapObject* pointer to the
 /// allocated object, and a pointer to the value inside the heap object.
@@ -344,6 +350,8 @@ void swift_deallocBox(HeapObject *object);
 SWIFT_RUNTIME_EXPORT
 OpaqueValue *swift_projectBox(HeapObject *object);
 
+SWIFT_END_DECLS
+
 /// RAII object that wraps a Swift heap object and releases it upon
 /// destruction.
 class SwiftRAII {
@@ -395,6 +403,8 @@ struct UnownedReference {
   HeapObject *Value;
 };
 
+SWIFT_BEGIN_DECLS
+
 /// Increment the unowned retain count.
 SWIFT_RUNTIME_EXPORT
 HeapObject *swift_unownedRetain(HeapObject *value);
@@ -453,6 +463,8 @@ void swift_nonatomic_unownedRetainStrongAndRelease(HeapObject *value);
 SWIFT_RUNTIME_EXPORT
 void swift_unownedCheck(HeapObject *value);
 
+SWIFT_END_DECLS
+
 static inline void swift_unownedInit(UnownedReference *ref, HeapObject *value) {
   ref->Value = value;
   swift_unownedRetain(value);
@@ -529,6 +541,8 @@ static inline bool swift_unownedIsEqual(UnownedReference *ref,
 // Defined in Runtime/WeakReference.h
 class WeakReference;
 
+SWIFT_BEGIN_DECLS
+
 /// Initialize a weak reference.
 ///
 /// \param ref - never null
@@ -1073,6 +1087,8 @@ static inline bool swift_unknownObjectUnownedIsEqual(UnownedReference *ref,
 
 #endif // SWIFT_OBJC_INTEROP
 
+SWIFT_END_DECLS
+
 struct TypeNamePair {
   const char *data;
   uintptr_t length;

include/swift/Runtime/Metadata.h

@@ -101,13 +101,17 @@ struct YieldOnceCoroutine<ResultTy(ArgTys...)> {
 
 #endif
 
+SWIFT_BEGIN_DECLS
+
 /// A standard routine, suitable for placement in the value witness
 /// table, for copying an opaque POD object.
 SWIFT_RUNTIME_EXPORT
 OpaqueValue *swift_copyPOD(OpaqueValue *dest,
                            OpaqueValue *src,
                            const Metadata *self);
 
+SWIFT_END_DECLS
+
 template <>
 inline void ValueWitnessTable::publishLayout(const TypeLayout &layout) {
   size = layout.size;
@@ -131,6 +135,8 @@ template <> inline bool ValueWitnessTable::checkIsComplete() const {
 
 // Standard value-witness tables.
 
+SWIFT_BEGIN_DECLS
+
 #define BUILTIN_TYPE(Symbol, _) \
   SWIFT_RUNTIME_EXPORT const ValueWitnessTable VALUE_WITNESS_SYM(Symbol);
 #define BUILTIN_POINTER_TYPE(Symbol, _) \
@@ -166,6 +172,8 @@ const ValueWitnessTable VALUE_WITNESS_SYM(EMPTY_TUPLE_MANGLING);        // ()
 SWIFT_RUNTIME_EXPORT
 const ValueWitnessTable METATYPE_VALUE_WITNESS_SYM(Bo); // Builtin.NativeObject.Type
 
+SWIFT_END_DECLS
+
 /// Return the value witnesses for unmanaged pointers.
 static inline const ValueWitnessTable &getUnmanagedPointerValueWitnesses() {
 #if __POINTER_WIDTH__ == 64
@@ -184,6 +192,8 @@ getUnmanagedPointerPointerValueWitnesses() {
 
 using OpaqueMetadata = TargetOpaqueMetadata<InProcess>;
 
+SWIFT_BEGIN_DECLS
+
 // Standard POD opaque metadata.
 // The "Int" metadata are used for arbitrary POD data with the
 // matching characteristics.
@@ -209,11 +219,15 @@ SWIFT_RUNTIME_EXPORT
 const
   FullMetadata<ExistentialTypeMetadata> METADATA_SYM(ANYOBJECT_MANGLING);
 
+SWIFT_END_DECLS
+
 
 /// True if two context descriptors in the currently running program describe
 /// the same context.
 bool equalContexts(const ContextDescriptor *a, const ContextDescriptor *b);
 
+SWIFT_BEGIN_DECLS
+
 /// Determines whether two type context descriptors describe the same type
 /// context.
 ///
@@ -228,11 +242,15 @@ SWIFT_CC(swift)
 bool swift_compareTypeContextDescriptors(const TypeContextDescriptor *lhs,
                                          const TypeContextDescriptor *rhs);
 
+SWIFT_END_DECLS
+
 /// Compute the bounds of class metadata with a resilient superclass.
 ClassMetadataBounds getResilientMetadataBounds(
                                            const ClassDescriptor *descriptor);
 int32_t getResilientImmediateMembersOffset(const ClassDescriptor *descriptor);
 
+SWIFT_BEGIN_DECLS
+
 /// Fetch a uniqued metadata object for a nominal type which requires
 /// singleton metadata initialization.
 SWIFT_RUNTIME_EXPORT SWIFT_CC(swift)
@@ -555,8 +573,12 @@ size_t swift_getTupleTypeLayout2(TypeLayout *tupleLayout,
                                  const TypeLayout *elt0,
                                  const TypeLayout *elt1);
 
+SWIFT_END_DECLS
+
 struct OffsetPair { size_t First; size_t Second; };
 
+SWIFT_BEGIN_DECLS
+
 /// Perform layout as if for a three-element tuple whose elements have
 /// the given layouts.
 ///
@@ -723,6 +745,8 @@ OpaqueValue *swift_assignExistentialWithCopy(OpaqueValue *dest,
                                              const OpaqueValue *src,
                                              const Metadata *type);
 
+SWIFT_END_DECLS
+
 /// Perform a copy-assignment from one existential container to another.
 /// Both containers must be of the same existential type representable with no
 /// witness tables.
@@ -828,6 +852,8 @@ inline constexpr unsigned swift_getFunctionPointerExtraInhabitantCount() {
 std::string nameForMetadata(const Metadata *type,
                             bool qualified = true);
 
+SWIFT_BEGIN_DECLS
+
 /// Register a block of protocol records for dynamic lookup.
 SWIFT_RUNTIME_EXPORT
 void swift_registerProtocols(const ProtocolRecord *begin,
@@ -843,6 +869,8 @@ SWIFT_RUNTIME_EXPORT
 void swift_registerTypeMetadataRecords(const TypeMetadataRecord *begin,
                                        const TypeMetadataRecord *end);
 
+SWIFT_END_DECLS
+
 /// Return the superclass, if any.  The result is nullptr for root
 /// classes and class protocol types.
 SWIFT_CC(swift)
@@ -862,6 +890,8 @@ void verifyMangledNameRoundtrip(const Metadata *metadata);
 SWIFT_CC(swift) SWIFT_RUNTIME_STDLIB_API
 const TypeContextDescriptor *swift_getTypeContextDescriptor(const Metadata *type);
 
+SWIFT_BEGIN_DECLS
+
 // Defined in KeyPath.swift in the standard library.
 SWIFT_RUNTIME_EXPORT
 const HeapObject *swift_getKeyPath(const void *pattern, const void *arguments);
@@ -900,6 +930,8 @@ void swift_enableDynamicReplacementScope(const DynamicReplacementScope *scope);
 SWIFT_RUNTIME_EXPORT
 void swift_disableDynamicReplacementScope(const DynamicReplacementScope *scope);
 
+SWIFT_END_DECLS
+
 #pragma clang diagnostic pop
 
 } // end namespace swift

stdlib/public/SwiftShims/swift/shims/Visibility.h

@@ -203,18 +203,18 @@
                  SWIFT_ATTRIBUTE_FOR_EXPORTS,                         \
                  SWIFT_ATTRIBUTE_FOR_IMPORTS)
 
-// SWIFT_EXPORT_FROM(LIBRARY) declares something to be a C-linkage
-// entity exported by the given library.
-//
-// SWIFT_RUNTIME_EXPORT is just SWIFT_EXPORT_FROM(swiftCore).
-//
-// TODO: use this in shims headers in overlays.
 #if defined(__cplusplus)
-#define SWIFT_EXPORT_FROM(LIBRARY) extern "C" SWIFT_EXPORT_FROM_ATTRIBUTE(LIBRARY)
+#define SWIFT_BEGIN_DECLS extern "C" {
+#define SWIFT_END_DECLS }
 #else
-#define SWIFT_EXPORT_FROM(LIBRARY) SWIFT_EXPORT_FROM_ATTRIBUTE(LIBRARY)
+#define SWIFT_BEGIN_DECLS
+#define SWIFT_END_DECLS
 #endif
-#define SWIFT_RUNTIME_EXPORT SWIFT_EXPORT_FROM(swiftCore)
+
+// SWIFT_RUNTIME_EXPORT is just SWIFT_EXPORT_FROM(swiftCore).
+//
+// TODO: use this in shims headers in overlays.
+#define SWIFT_RUNTIME_EXPORT SWIFT_EXPORT_FROM_ATTRIBUTE(LIBRARY)
 
 #if __cplusplus > 201402l && __has_cpp_attribute(fallthrough)
 #define SWIFT_FALLTHROUGH [[fallthrough]]