Lower Swiftcc by LLVM

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/Demangling/DemangleNodes.def

@@ -201,7 +201,6 @@ CONTEXT_NODE(Structure)
 CONTEXT_NODE(Subscript)
 NODE(Suffix)
 NODE(ThinFunctionType)
-NODE(ThinToThickForwarder)
 NODE(Tuple)
 NODE(TupleElement)
 NODE(TupleElementName)

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/Demangling/Context.cpp

@@ -88,7 +88,6 @@ bool Context::isThunkSymbol(llvm::StringRef MangledName) {
     MangledName = stripSuffix(MangledName);
     // First do a quick check
     if (MangledName.endswith("TA") ||  // partial application forwarder
-        MangledName.endswith("Tu")||   // thin-to-thick forwarder
         MangledName.endswith("Ta") ||  // ObjC partial application forwarder
         MangledName.endswith("To") ||  // swift-as-ObjC thunk
         MangledName.endswith("TO") ||  // ObjC-as-swift thunk
@@ -108,7 +107,6 @@ bool Context::isThunkSymbol(llvm::StringRef MangledName) {
         case Node::Kind::NonObjCAttribute:
         case Node::Kind::PartialApplyObjCForwarder:
         case Node::Kind::PartialApplyForwarder:
-        case Node::Kind::ThinToThickForwarder:
         case Node::Kind::ReabstractionThunkHelper:
         case Node::Kind::ReabstractionThunk:
         case Node::Kind::ProtocolWitness:

lib/Demangling/Demangler.cpp

@@ -113,7 +113,6 @@ bool swift::Demangle::isFunctionAttr(Node::Kind kind) {
     case Node::Kind::DirectMethodReferenceAttribute:
     case Node::Kind::VTableAttribute:
     case Node::Kind::PartialApplyForwarder:
-    case Node::Kind::ThinToThickForwarder:
     case Node::Kind::PartialApplyObjCForwarder:
     case Node::Kind::OutlinedVariable:
     case Node::Kind::OutlinedBridgedMethod:
@@ -550,8 +549,7 @@ NodePointer Demangler::demangleSymbol(StringRef MangledName,
   while (NodePointer FuncAttr = popNode(isFunctionAttr)) {
     Parent->addChild(FuncAttr, *this);
     if (FuncAttr->getKind() == Node::Kind::PartialApplyForwarder ||
-        FuncAttr->getKind() == Node::Kind::PartialApplyObjCForwarder ||
-        FuncAttr->getKind() == Node::Kind::ThinToThickForwarder)
+        FuncAttr->getKind() == Node::Kind::PartialApplyObjCForwarder)
       Parent = FuncAttr;
   }
   for (Node *Nd : NodeStack) {
@@ -2180,7 +2178,6 @@ NodePointer Demangler::demangleThunkOrSpecialization() {
     case 'd': return createNode(Node::Kind::DirectMethodReferenceAttribute);
     case 'a': return createNode(Node::Kind::PartialApplyObjCForwarder);
     case 'A': return createNode(Node::Kind::PartialApplyForwarder);
-    case 'u': return createNode(Node::Kind::ThinToThickForwarder);
     case 'm': return createNode(Node::Kind::MergedFunction);
     case 'X': return createNode(Node::Kind::DynamicallyReplaceableFunctionVar);
     case 'x': return createNode(Node::Kind::DynamicallyReplaceableFunctionKey);

lib/Demangling/NodePrinter.cpp

@@ -467,7 +467,6 @@ class NodePrinter {
     case Node::Kind::Subscript:
     case Node::Kind::Suffix:
     case Node::Kind::ThinFunctionType:
-    case Node::Kind::ThinToThickForwarder:
     case Node::Kind::TupleElement:
     case Node::Kind::TypeMangling:
     case Node::Kind::TypeMetadata:
@@ -1234,14 +1233,6 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
     Printer << "@convention(thin) ";
     printFunctionType(nullptr, Node);
     return nullptr;
-  case Node::Kind::ThinToThickForwarder:
-    Printer << "thin-to-thick forwarder";
-
-    if (Node->hasChildren()) {
-      Printer << " for ";
-      printChildren(Node);
-    }
-    return nullptr;
   case Node::Kind::FunctionType:
   case Node::Kind::UncurriedFunctionType:
     printFunctionType(nullptr, Node);

lib/Demangling/OldDemangler.cpp

@@ -364,15 +364,6 @@ class OldDemangler {
         DEMANGLE_CHILD_OR_RETURN(forwarder, Global);
       return forwarder;
     }
-
-    // thin-to-thick thunks.
-    if (Mangled.nextIf("Pu")) {
-      Node::Kind kind = Node::Kind::ThinToThickForwarder;
-      auto forwarder = Factory.createNode(kind);
-      if (Mangled.nextIf("__T"))
-        DEMANGLE_CHILD_OR_RETURN(forwarder, Global);
-      return forwarder;
-    }
 
     // Top-level types, for various consumers.
     if (Mangled.nextIf('t')) {

lib/Demangling/OldRemangler.cpp

@@ -574,11 +574,6 @@ void Remangler::mangleProtocolSelfConformanceDescriptor(Node *node) {
   mangleProtocol(node->begin()[0]);
 }
 
-void Remangler::mangleThinToThickForwarder(Node *node) {
-  Buffer << "Pu__T";
-  mangleSingleChildNode(node); // global
-}
-
 void Remangler::manglePartialApplyForwarder(Node *node) {
   Buffer << "PA__T";
   mangleSingleChildNode(node); // global

lib/Demangling/Remangler.cpp

@@ -1738,11 +1738,6 @@ void Remangler::mangleOwningMutableAddressor(Node *node) {
   mangleAbstractStorage(node->getFirstChild(), "aO");
 }
 
-void Remangler::mangleThinToThickForwarder(Node *node) {
-  mangleChildNodesReversed(node);
-  Buffer << "Tu";
-}
-
 void Remangler::manglePartialApplyForwarder(Node *node) {
   mangleChildNodesReversed(node);
   Buffer << "TA";

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 have 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/GenFunc.cpp

@@ -700,62 +700,6 @@ static unsigned findSinglePartiallyAppliedParameterIndexIgnoringEmptyTypes(
   return firstNonEmpty;
 }
 
-
-llvm::Function *irgen::getThinToThickForwarder(IRGenModule &IGM,
-                                               const Optional<FunctionPointer> &staticFnPtr,
-                                               const CanSILFunctionType origType) {
-  auto origSig = IGM.getSignature(origType);
-  llvm::FunctionType *origFnTy = origSig.getType();
-  auto origTy = origSig.getType()->getPointerTo();
-
-  llvm::SmallVector<llvm::Type *, 4> thunkParams;
-
-  for (unsigned i = 0; i < origFnTy->getNumParams(); ++i)
-    thunkParams.push_back(origFnTy->getParamType(i));
-
-  thunkParams.push_back(IGM.RefCountedPtrTy);
-
-  auto thunkType = llvm::FunctionType::get(origFnTy->getReturnType(),
-                                           thunkParams,
-                                           /*vararg*/ false);
-
-  StringRef FnName;
-  if (staticFnPtr)
-    FnName = staticFnPtr->getPointer()->getName();
-
-  IRGenMangler Mangler;
-  std::string thunkName = Mangler.mangleThinToThickForwarder(FnName);
-
-
-  // FIXME: Maybe cache the thunk by function and closure types?.
-  llvm::Function *fwd =
-  llvm::Function::Create(thunkType, llvm::Function::InternalLinkage,
-                         llvm::StringRef(thunkName), &IGM.Module);
-
-  fwd->setAttributes(origSig.getAttributes());
-  fwd->addAttribute(llvm::AttributeList::FirstArgIndex + origFnTy->getNumParams(), llvm::Attribute::SwiftSelf);
-  IRGenFunction IGF(IGM, fwd);
-  if (IGM.DebugInfo)
-    IGM.DebugInfo->emitArtificialFunction(IGF, fwd);
-  auto args = IGF.collectParameters();
-  auto rawFnPtr = args.takeLast();
-
-  // It comes out of the context as an i8*. Cast to the function type.
-  rawFnPtr = IGF.Builder.CreateBitCast(rawFnPtr, origTy);
-
-  auto fnPtr = FunctionPointer(rawFnPtr, origSig);
-
-  auto result = IGF.Builder.CreateCall(fnPtr, args.claimAll());
-
-  // Return the result, if we have one.
-  if (result->getType()->isVoidTy())
-    IGF.Builder.CreateRetVoid();
-  else
-    IGF.Builder.CreateRet(result);
-  return fwd;
-}
-
-
 /// Emit the forwarding stub function for a partial application.
 ///
 /// If 'layout' is null, there is a single captured value of

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);

lib/IRGen/IRGenMangler.cpp

@@ -78,21 +78,6 @@ std::string IRGenMangler::manglePartialApplyForwarder(StringRef FuncName) {
   return finalize();
 }
 
-std::string IRGenMangler::mangleThinToThickForwarder(StringRef FuncName) {
-  if (FuncName.empty()) {
-    beginMangling();
-  } else {
-    if (FuncName.startswith(MANGLING_PREFIX_STR)) {
-      Buffer << FuncName;
-    } else {
-      beginMangling();
-      appendIdentifier(FuncName);
-    }
-  }
-  appendOperator("Tu");
-  return finalize();
-}
-
 SymbolicMangling
 IRGenMangler::withSymbolicReferences(IRGenModule &IGM,
                                   llvm::function_ref<void ()> body) {

lib/IRGen/IRGenMangler.h

@@ -512,7 +512,6 @@ class IRGenMangler : public Mangle::ASTMangler {
   }
 
   std::string manglePartialApplyForwarder(StringRef FuncName);
-  std::string mangleThinToThickForwarder(StringRef FuncName);
 
   std::string mangleTypeForForeignMetadataUniquing(Type type) {
     return mangleTypeWithoutPrefix(type);

lib/IRGen/IRGenSIL.cpp

@@ -4732,60 +4732,8 @@ void IRGenSILFunction::visit##KIND##Inst(swift::KIND##Inst *i) {  \
 #include "swift/AST/ReferenceStorage.def"
 #undef NOOP_CONVERSION
 
-
-static FunctionPointer
-getLoweredFunctionPointer(IRGenSILFunction &IGF, SILValue v) {
-  LoweredValue &lv = IGF.getLoweredValue(v);
-  auto fnType = v->getType().castTo<SILFunctionType>();
-
-  switch (lv.kind) {
-  case LoweredValue::Kind::ContainedAddress:
-  case LoweredValue::Kind::StackAddress:
-  case LoweredValue::Kind::DynamicallyEnforcedAddress:
-  case LoweredValue::Kind::OwnedAddress:
-  case LoweredValue::Kind::EmptyExplosion:
-  case LoweredValue::Kind::CoroutineState:
-  case LoweredValue::Kind::ObjCMethod:
-    llvm_unreachable("not a valid function");
-
-  case LoweredValue::Kind::FunctionPointer: {
-    return lv.getFunctionPointer();
-  }
-  case LoweredValue::Kind::SingletonExplosion: {
-    llvm::Value *fnPtr = lv.getKnownSingletonExplosion();
-    return FunctionPointer::forExplosionValue(IGF, fnPtr, fnType);
-  }
-  case LoweredValue::Kind::ExplosionVector: {
-    Explosion ex = lv.getExplosion(IGF, v->getType());
-    llvm::Value *fnPtr = ex.claimNext();
-    auto fn = FunctionPointer::forExplosionValue(IGF, fnPtr, fnType);
-    return fn;
-  }
-  }
-  llvm_unreachable("bad kind");
-}
-
 void IRGenSILFunction::visitThinToThickFunctionInst(
                                             swift::ThinToThickFunctionInst *i) {
-  auto fn = getLoweredFunctionPointer(*this, i->getCallee());
-  auto fnTy = i->getCallee()->getType().castTo<SILFunctionType>();
-  if (IGM.TargetInfo.OutputObjectFormat == llvm::Triple::Wasm && !fnTy->hasErrorResult()) {
-    Optional<FunctionPointer> staticFn;
-    if (fn.isConstant()) staticFn = fn;
-    auto thunkFn = getThinToThickForwarder(IGM, staticFn, fnTy);
-    Explosion from = getLoweredExplosion(i->getOperand());
-    Explosion to;
-    auto fnPtr = Builder.CreateBitCast(thunkFn, IGM.Int8PtrTy);
-    to.add(fnPtr);
-    llvm::Value *ctx = from.claimNext();
-    if (fnTy->isNoEscape())
-      ctx = Builder.CreateBitCast(ctx, IGM.OpaquePtrTy);
-    else
-      ctx = Builder.CreateBitCast(ctx, IGM.RefCountedPtrTy);
-    to.add(ctx);
-    setLoweredExplosion(i, to);
-    return;
-  }
   // Take the incoming function pointer and add a null context pointer to it.
   Explosion from = getLoweredExplosion(i->getOperand());
   Explosion to;

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,