Conditionalize usage of llvm::CallingConv::Swift on SWIFT_USE_SWIFTCALL macro

Author: aschwaighofer

include/swift/Runtime/Config.h

@@ -128,6 +128,11 @@
 
 #define SWIFT_LLVM_CC_RegisterPreservingCC llvm::CallingConv::PreserveMost
 
+#if SWIFT_USE_SWIFTCALL
+#define SWIFT_LLVM_CC_SwiftCC  llvm::CallingConv::Swift
+#else
+#define SWIFT_LLVM_CC_SwiftCC  llvm::CallingConv::C
+#endif
 
 // If defined, it indicates that runtime function wrappers
 // should be used on all platforms, even they do not support

lib/IRGen/GenCall.cpp

@@ -26,6 +26,7 @@
 #include "clang/CodeGen/ModuleBuilder.h"
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/SIL/SILType.h"
+#include "swift/Runtime/Config.h"
 #include "llvm/IR/CallSite.h"
 #include "llvm/Support/Compiler.h"
 
@@ -108,7 +109,7 @@ static void addInoutParameterAttributes(IRGenModule &IGM,
 
 static llvm::CallingConv::ID getFreestandingConvention(IRGenModule &IGM) {
   // TODO: use a custom CC that returns three scalars efficiently
-  return llvm::CallingConv::Swift;
+  return SWIFT_LLVM_CC(SwiftCC);
 }
 
 /// Expand the requirements of the given abstract calling convention
@@ -151,33 +152,33 @@ static void addIndirectResultAttributes(IRGenModule &IGM,
   attrs = attrs.addAttributes(IGM.LLVMContext, paramIndex + 1, resultAttrs);
 }
 
-static void addSwiftSelfAttributes(IRGenModule &IGM,
-                                   llvm::AttributeSet &attrs,
-                                   unsigned argIndex) {
+void IRGenModule::addSwiftSelfAttributes(llvm::AttributeSet &attrs,
+                                         unsigned argIndex) {
+  if (!UseSwiftCC)
+    return;
   static const llvm::Attribute::AttrKind attrKinds[] = {
     llvm::Attribute::SwiftSelf,
   };
   auto argAttrs =
-      llvm::AttributeSet::get(IGM.LLVMContext, argIndex + 1, attrKinds);
-  attrs = attrs.addAttributes(IGM.LLVMContext, argIndex + 1, argAttrs);
+      llvm::AttributeSet::get(this->LLVMContext, argIndex + 1, attrKinds);
+  attrs = attrs.addAttributes(this->LLVMContext, argIndex + 1, argAttrs);
 }
 
-static void addSwiftErrorAttributes(IRGenModule &IGM,
-                                    llvm::AttributeSet &attrs,
-                                    unsigned argIndex) {
+void IRGenModule::addSwiftErrorAttributes(llvm::AttributeSet &attrs,
+                                          unsigned argIndex) {
   // Don't add the swifterror attribute on ABI that don't pass it in a register.
   // We create a shadow stack location of the swifterror parameter for the
   // debugger on such platforms and so we can't mark the parameter with a
   // swifterror attribute.
-  if (!IGM.IsSwiftErrorInRegister)
+  if (!UseSwiftCC || !this->IsSwiftErrorInRegister)
     return;
 
   static const llvm::Attribute::AttrKind attrKinds[] = {
     llvm::Attribute::SwiftError,
   };
   auto argAttrs =
-      llvm::AttributeSet::get(IGM.LLVMContext, argIndex + 1, attrKinds);
-  attrs = attrs.addAttributes(IGM.LLVMContext, argIndex + 1, argAttrs);
+      llvm::AttributeSet::get(this->LLVMContext, argIndex + 1, attrKinds);
+  attrs = attrs.addAttributes(this->LLVMContext, argIndex + 1, argAttrs);
 }
 
 void irgen::addByvalArgumentAttributes(IRGenModule &IGM,
@@ -939,10 +940,10 @@ llvm::Type *SignatureExpansion::expandExternalSignatureTypes() {
       case clang::ParameterABI::Ordinary:
         break;
       case clang::ParameterABI::SwiftContext:
-        addSwiftSelfAttributes(IGM, Attrs, getCurParamIndex());
+        IGM.addSwiftSelfAttributes(Attrs, getCurParamIndex());
         break;
       case clang::ParameterABI::SwiftErrorResult:
-        addSwiftErrorAttributes(IGM, Attrs, getCurParamIndex());
+        IGM.addSwiftErrorAttributes(Attrs, getCurParamIndex());
         break;
       case clang::ParameterABI::SwiftIndirectResult:
         addIndirectResultAttributes(IGM, Attrs, getCurParamIndex(),claimSRet());
@@ -1115,7 +1116,7 @@ void SignatureExpansion::expandParameters() {
     auto curLength = ParamIRTypes.size(); (void) curLength;
 
     if (claimSelf())
-      addSwiftSelfAttributes(IGM, Attrs, curLength);
+      IGM.addSwiftSelfAttributes(Attrs, curLength);
     expand(FnType->getSelfParameter());
     assert(ParamIRTypes.size() == curLength + 1 &&
            "adding 'self' added unexpected number of parameters");
@@ -1141,7 +1142,7 @@ void SignatureExpansion::expandParameters() {
     };
     if (needsContext()) {
       if (claimSelf())
-        addSwiftSelfAttributes(IGM, Attrs, ParamIRTypes.size());
+        IGM.addSwiftSelfAttributes(Attrs, ParamIRTypes.size());
       ParamIRTypes.push_back(IGM.RefCountedPtrTy);
     }
   }
@@ -1151,7 +1152,7 @@ void SignatureExpansion::expandParameters() {
   // if we set the right attribute.
   if (FnType->hasErrorResult()) {
     if (claimError())
-      addSwiftErrorAttributes(IGM, Attrs, ParamIRTypes.size());
+      IGM.addSwiftErrorAttributes(Attrs, ParamIRTypes.size());
     llvm::Type *errorType = IGM.getStorageType(
         getSILFuncConventions().getSILType(FnType->getErrorResult()));
     ParamIRTypes.push_back(errorType->getPointerTo());
@@ -1493,7 +1494,7 @@ void CallEmission::setFromCallee() {
     assert(LastArgWritten > 0);
     Args[--LastArgWritten] = errorResultSlot.getAddress();
     addAttribute(LastArgWritten + 1, llvm::Attribute::NoCapture);
-    addSwiftErrorAttributes(IGF.IGM, Attrs, LastArgWritten);
+    IGF.IGM.addSwiftErrorAttributes(Attrs, LastArgWritten);
 
     // Fill in the context pointer if necessary.
     if (!contextPtr) {
@@ -1509,7 +1510,7 @@ void CallEmission::setFromCallee() {
            && "block function should not claimed to have data pointer");
     assert(LastArgWritten > 0);
     Args[--LastArgWritten] = contextPtr;
-    addSwiftSelfAttributes(IGF.IGM, Attrs, LastArgWritten);
+    IGF.IGM.addSwiftSelfAttributes(Attrs, LastArgWritten);
   }
 }
 

lib/IRGen/GenHeap.cpp

@@ -188,18 +188,6 @@ void irgen::emitDeallocatePartialClassInstance(IRGenFunction &IGF,
                          {object, metadata, size, alignMask});
 }
 
-/// TODO: Fix copy'and'paste of this function. Probably move it to IRGenFunction.h/.cpp?
-static void addSwiftSelfAttributes(IRGenModule &IGM,
-                                   llvm::AttributeSet &attrs,
-                                   unsigned argIndex) {
-  static const llvm::Attribute::AttrKind attrKinds[] = {
-    llvm::Attribute::SwiftSelf,
-  };
-  auto argAttrs =
-      llvm::AttributeSet::get(IGM.LLVMContext, argIndex + 1, attrKinds);
-  attrs = attrs.addAttributes(IGM.LLVMContext, argIndex + 1, argAttrs);
-}
-
 /// Create the destructor function for a layout.
 /// TODO: give this some reasonable name and possibly linkage.
 static llvm::Function *createDtorFn(IRGenModule &IGM,
@@ -209,10 +197,9 @@ static llvm::Function *createDtorFn(IRGenModule &IGM,
                            llvm::Function::PrivateLinkage,
                            "objectdestroy", &IGM.Module);
   auto attrs = IGM.constructInitialAttributes();
-  addSwiftSelfAttributes(IGM, attrs, 0);
+  IGM.addSwiftSelfAttributes(attrs, 0);
   fn->setAttributes(attrs);
-  // TODO: Introduce and use IGM.SwiftCC here.
-  fn->setCallingConv(llvm::CallingConv::Swift);
+  fn->setCallingConv(IGM.SwiftCC);
 
   IRGenFunction IGF(IGM, fn);
   if (IGM.DebugInfo)

lib/IRGen/IRGenModule.cpp

@@ -388,6 +388,9 @@ IRGenModule::IRGenModule(IRGenerator &irgen,
   else
     RegisterPreservingCC = DefaultCC;
 
+  SwiftCC = SWIFT_LLVM_CC(SwiftCC);
+  UseSwiftCC = (SwiftCC == llvm::CallingConv::Swift);
+
   if (IRGen.Opts.DebugInfoKind > IRGenDebugInfoKind::None)
     DebugInfo = new IRGenDebugInfo(IRGen.Opts, *CI, *this, Module, SF);
 

lib/IRGen/IRGenModule.h

@@ -476,6 +476,8 @@ class IRGenModule {
   llvm::CallingConv::ID C_CC;          /// standard C calling convention
   llvm::CallingConv::ID DefaultCC;     /// default calling convention
   llvm::CallingConv::ID RegisterPreservingCC; /// lightweight calling convention
+  llvm::CallingConv::ID SwiftCC;     /// swift calling convention
+  bool UseSwiftCC;
 
   llvm::FunctionType *getAssociatedTypeMetadataAccessFunctionTy();
   llvm::FunctionType *getAssociatedTypeWitnessTableAccessFunctionTy();
@@ -997,6 +999,12 @@ private:                            \
   /// the binary.
   void setTrueConstGlobal(llvm::GlobalVariable *var);
 
+  /// Add the swiftself attribute.
+  void addSwiftSelfAttributes(llvm::AttributeSet &attrs, unsigned argIndex);
+
+  /// Add the swifterror attribute.
+  void addSwiftErrorAttributes(llvm::AttributeSet &attrs, unsigned argIndex);
+
 private:
   llvm::Constant *getAddrOfLLVMVariable(LinkEntity entity,
                                         Alignment alignment,