Add swiftcc attribute for runtime functions called from Swift

Author: kateinoigakukun

include/swift/Demangling/Demangle.h

@@ -637,6 +637,7 @@ llvm::StringRef makeSymbolicMangledNameStringRef(const char *base);
 //// define what these will be.
 /// \returns the demangled name. Returns nullptr if the input String is not a
 /// Swift mangled name.
+SWIFT_CC(swift)
 SWIFT_RUNTIME_EXPORT
 char *swift_demangle(const char *mangledName,
                      size_t mangledNameLength,

include/swift/Runtime/HeapObject.h

@@ -205,10 +205,13 @@ void swift_nonatomic_release_n(HeapObject *object, uint32_t n);
 
 // Refcounting observation hooks for memory tools. Don't use these.
 SWIFT_RUNTIME_EXPORT
+SWIFT_CC(swift)
 size_t swift_retainCount(HeapObject *object);
 SWIFT_RUNTIME_EXPORT
+SWIFT_CC(swift)
 size_t swift_unownedRetainCount(HeapObject *object);
 SWIFT_RUNTIME_EXPORT
+SWIFT_CC(swift)
 size_t swift_weakRetainCount(HeapObject *object);
 
 /// Is this pointer a non-null unique reference to an object

lib/IRGen/GenBuiltin.cpp

@@ -398,10 +398,17 @@ if (Builtin.ID == BuiltinValueKind::id) { \
     call->addAttribute(llvm::AttributeList::FirstArgIndex + 1,
                        llvm::Attribute::ReadOnly);
 
-    auto attrs = call->getAttributes();
-    IGF.IGM.addSwiftSelfAttributes(attrs, 0);
-    IGF.IGM.addSwiftErrorAttributes(attrs, 1);
-    call->setAttributes(attrs);
+    // Remove swiftself and swifterror attribute to match signature generated from
+    // RuntimeFunctions.def. These two parameters are passed using swifterror and swiftself,
+    // but the definition of swift_willThrow generated from the def file doesn't has those
+    // attributes due to the def file limitation. In WebAssembly context, these attributes are
+    // lowered as usual parameters, so this doesn't have any side effects.
+    if (IGF.IGM.TargetInfo.OutputObjectFormat != llvm::Triple::Wasm) {
+      auto attrs = call->getAttributes();
+      IGF.IGM.addSwiftSelfAttributes(attrs, 0);
+      IGF.IGM.addSwiftErrorAttributes(attrs, 1);
+      call->setAttributes(attrs);
+    }
 
     IGF.Builder.CreateStore(llvm::ConstantPointerNull::get(IGF.IGM.ErrorPtrTy),
                             errorBuffer);

lib/IRGen/GenKeyPath.cpp

@@ -278,7 +278,8 @@ getLayoutFunctionForComputedComponent(IRGenModule &IGM,
 
   auto layoutFn = llvm::Function::Create(fnTy,
     llvm::GlobalValue::PrivateLinkage, "keypath_get_arg_layout", IGM.getModule());
-    
+  layoutFn->setCallingConv(IGM.SwiftCC);
+
   {
     IRGenFunction IGF(IGM, layoutFn);
     if (IGM.DebugInfo)
@@ -378,6 +379,7 @@ getWitnessTableForComputedComponent(IRGenModule &IGM,
                                                  /*vararg*/ false);
       auto destroyFn = llvm::Function::Create(destroyType,
         llvm::GlobalValue::PrivateLinkage, "keypath_destroy", IGM.getModule());
+      destroyFn->setCallingConv(IGM.SwiftCC);
       destroy = destroyFn;
 
       IRGenFunction IGF(IGM, destroyFn);
@@ -426,6 +428,7 @@ getWitnessTableForComputedComponent(IRGenModule &IGM,
                                               /*vararg*/ false);
       auto copyFn = llvm::Function::Create(copyType,
         llvm::GlobalValue::PrivateLinkage, "keypath_copy", IGM.getModule());
+      copyFn->setCallingConv(IGM.SwiftCC);
       copy = copyFn;
 
       IRGenFunction IGF(IGM, copyFn);
@@ -539,6 +542,8 @@ getInitializerForComputedComponent(IRGenModule &IGM,
 
   auto initFn = llvm::Function::Create(fnTy,
     llvm::GlobalValue::PrivateLinkage, "keypath_arg_init", IGM.getModule());
+  initFn->setCallingConv(IGM.SwiftCC);
+
 
   {
     IRGenFunction IGF(IGM, initFn);

stdlib/public/SwiftShims/HeapObject.h

@@ -74,17 +74,25 @@ struct HeapObject {
 #ifdef __cplusplus
 extern "C" {
 #endif
+#if __has_attribute(swiftcall)
+#define SWIFT_CC_swift __attribute__((swiftcall))
+#else
+#define SWIFT_CC_swift
+#endif
 
 SWIFT_RUNTIME_STDLIB_API
 void _swift_instantiateInertHeapObject(void *address,
                                        const HeapMetadata *metadata);
 
+SWIFT_CC_swift
 SWIFT_RUNTIME_STDLIB_API
 __swift_size_t swift_retainCount(HeapObject *obj);
 
+SWIFT_CC_swift
 SWIFT_RUNTIME_STDLIB_API
 __swift_size_t swift_unownedRetainCount(HeapObject *obj);
 
+SWIFT_CC_swift
 SWIFT_RUNTIME_STDLIB_API
 __swift_size_t swift_weakRetainCount(HeapObject *obj);
 

stdlib/public/runtime/Demangle.cpp

@@ -638,6 +638,7 @@ swift::_swift_buildDemanglingForMetadata(const Metadata *type,
 // NB: This function is not used directly in the Swift codebase, but is
 // exported for Xcode support and is used by the sanitizers. Please coordinate
 // before changing.
+SWIFT_CC(swift)
 char *swift_demangle(const char *mangledName,
                      size_t mangledNameLength,
                      char *outputBuffer,

stdlib/public/runtime/ErrorObject.h

@@ -206,9 +206,21 @@ SWIFT_RUNTIME_STDLIB_API
 void swift_errorRelease(SwiftError *object);
 
 /// Breakpoint hook for debuggers.
+#ifdef __wasm__
+// Notes:
+// Remove swiftself and swifterror attribute to match signature generated from
+// RuntimeFunctions.def. These two parameters are passed using swifterror and swiftself,
+// but the definition of swift_willThrow generated from the def file doesn't has those
+// attributes due to the def file limitation. In WebAssembly context, these attributes are
+// lowered as usual parameters, so this doesn't have any side effects.
+SWIFT_CC(swift) SWIFT_RUNTIME_STDLIB_API
+void swift_willThrow(void *unused,
+                     SwiftError **object);
+#else
 SWIFT_CC(swift) SWIFT_RUNTIME_STDLIB_API
 void swift_willThrow(SWIFT_CONTEXT void *unused,
                      SWIFT_ERROR_RESULT SwiftError **object);
+#endif
 
 /// Halt in response to an error.
 SWIFT_CC(swift) SWIFT_RUNTIME_STDLIB_API LLVM_ATTRIBUTE_NORETURN

stdlib/public/runtime/ErrorObjectCommon.cpp

@@ -27,9 +27,17 @@ using namespace swift;
 void (*swift::_swift_willThrow)(SwiftError *error);
 
 /// Breakpoint hook for debuggers, and calls _swift_willThrow if set.
+#ifdef __wasm__
+// Notes:
+// The reason of this ifdef is described in header file.
+SWIFT_CC(swift) void
+swift::swift_willThrow(void *unused, SwiftError **error)
+#else
 SWIFT_CC(swift) void
 swift::swift_willThrow(SWIFT_CONTEXT void *unused,
-                       SWIFT_ERROR_RESULT SwiftError **error) {
+                       SWIFT_ERROR_RESULT SwiftError **error)
+#endif
+{
   // Cheap check to bail out early, since we expect there to be no callbacks
   // the vast majority of the time.
   if (SWIFT_LIKELY(!_swift_willThrow))

stdlib/public/runtime/HeapObject.cpp

@@ -253,6 +253,7 @@ class BoxCacheEntry {
 
 static SimpleGlobalCache<BoxCacheEntry> Boxes;
 
+SWIFT_CC(swift)
 BoxPair swift::swift_makeBoxUnique(OpaqueValue *buffer, const Metadata *type,
                                     size_t alignMask) {
   auto *inlineBuffer = reinterpret_cast<ValueBuffer*>(buffer);
@@ -278,6 +279,7 @@ BoxPair swift::swift_makeBoxUnique(OpaqueValue *buffer, const Metadata *type,
   }
 }
 
+SWIFT_CC(swift)
 BoxPair swift::swift_allocBox(const Metadata *type) {
   // Get the heap metadata for the box.
   auto metadata = &Boxes.getOrInsert(type).first->Data;
@@ -420,16 +422,19 @@ void swift::swift_nonatomic_release_n(HeapObject *object, uint32_t n) {
     object->refCounts.decrementAndMaybeDeinitNonAtomic(n);
 }
 
+SWIFT_CC(swift)
 size_t swift::swift_retainCount(HeapObject *object) {
   if (isValidPointerForNativeRetain(object))
     return object->refCounts.getCount();
   return 0;
 }
 
+SWIFT_CC(swift)
 size_t swift::swift_unownedRetainCount(HeapObject *object) {
   return object->refCounts.getUnownedCount();
 }
 
+SWIFT_CC(swift)
 size_t swift::swift_weakRetainCount(HeapObject *object) {
   return object->refCounts.getWeakCount();
 }

stdlib/public/runtime/Numeric.cpp

@@ -50,10 +50,12 @@ static T convert(IntegerLiteral value) {
   return result;
 }
 
+SWIFT_CC(swift)
 float swift::swift_intToFloat32(IntegerLiteral value) {
   return convert<float>(value);
 }
 
+SWIFT_CC(swift)
 double swift::swift_intToFloat64(IntegerLiteral value) {
   return convert<double>(value);
 }