Setting hardcode SWIFT_NOEXCEPT and noexcept flags only to

non-throwing functions.
Activating swift-functions-errors tests
Inserting macros and additional parameters in C and C++ functions following the pattern to lowering to LLVM IR.

Author: Robertorosmaninho

include/swift/IRGen/IRABIDetailsProvider.h

@@ -47,6 +47,16 @@ class IRABIDetailsProvider {
     SizeType alignment;
   };
 
+  /// Information about any ABI additional parameters.
+  struct ABIAdditionalParam {
+    enum class ABIParameterRole { Self, Error };
+
+    ABIParameterRole role;
+    TypeDecl *type;
+  };
+
+  SmallVector<ABIAdditionalParam, 1> ABIAdditionalParams;
+
   /// Returns the size and alignment for the given type, or \c None if the type
   /// is not a fixed layout type.
   llvm::Optional<SizeAndAlignment>
@@ -99,6 +109,10 @@ class IRABIDetailsProvider {
   /// their tag indices from the given EnumDecl
   llvm::MapVector<EnumElementDecl *, unsigned> getEnumTagMapping(EnumDecl *ED);
 
+  /// Returns the additional params if they exist after lowering the function.
+  SmallVector<ABIAdditionalParam, 1>
+  getFunctionABIAdditionalParams(AbstractFunctionDecl *fd);
+
 private:
   std::unique_ptr<IRABIDetailsProviderImpl> impl;
 };

include/swift/SIL/SILFunction.h

@@ -472,6 +472,9 @@ class SILFunction
   SILFunction *getDynamicallyReplacedFunction() const {
     return ReplacedFunction;
   }
+
+  static SILFunction *getFunction(SILDeclRef ref, SILModule &M);
+
   void setDynamicallyReplacedFunction(SILFunction *f) {
     assert(ReplacedFunction == nullptr && "already set");
     assert(!hasObjCReplacement());

lib/IRGen/IRABIDetailsProvider.cpp

@@ -11,6 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "swift/IRGen/IRABIDetailsProvider.h"
+#include "Callee.h"
 #include "FixedTypeInfo.h"
 #include "GenEnum.h"
 #include "GenType.h"
@@ -21,7 +22,9 @@
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/IRGenOptions.h"
 #include "swift/AST/Types.h"
+#include "swift/SIL/SILFunctionBuilder.h"
 #include "swift/SIL/SILModule.h"
+#include "swift/Subsystems.h"
 #include "clang/CodeGen/ModuleBuilder.h"
 #include "clang/CodeGen/SwiftCallingConv.h"
 #include "llvm/IR/DerivedTypes.h"
@@ -125,8 +128,8 @@ class IRABIDetailsProviderImpl {
 
   llvm::MapVector<EnumElementDecl *, unsigned> getEnumTagMapping(EnumDecl *ED) {
     llvm::MapVector<EnumElementDecl *, unsigned> elements;
-    auto &enumImplStrat = getEnumImplStrategy(
-        IGM, ED->getDeclaredType()->getCanonicalType());
+    auto &enumImplStrat =
+        getEnumImplStrategy(IGM, ED->getDeclaredType()->getCanonicalType());
 
     for (auto *element : ED->getAllElements()) {
       auto tagIdx = enumImplStrat.getTagIndex(element);
@@ -136,6 +139,30 @@ class IRABIDetailsProviderImpl {
     return elements;
   }
 
+  llvm::SmallVector<IRABIDetailsProvider::ABIAdditionalParam, 1>
+  getFunctionABIAdditionalParams(AbstractFunctionDecl *afd) {
+    llvm::SmallVector<IRABIDetailsProvider::ABIAdditionalParam, 1> params;
+
+    auto function = SILFunction::getFunction(SILDeclRef(afd), *silMod);
+
+    auto silFuncType = function->getLoweredFunctionType();
+    auto funcPointerKind =
+        FunctionPointerKind(FunctionPointerKind::BasicKind::Function);
+    auto signature = Signature::getUncached(IGM, silFuncType, funcPointerKind);
+
+    for (auto attrSet : signature.getAttributes()) {
+      if (attrSet.hasAttribute(llvm::Attribute::AttrKind::SwiftSelf))
+        params.push_back(
+            {IRABIDetailsProvider::ABIAdditionalParam::ABIParameterRole::Self,
+             typeConverter.Context.getOpaquePointerDecl()});
+      if (attrSet.hasAttribute(llvm::Attribute::AttrKind::SwiftError))
+        params.push_back(
+            {IRABIDetailsProvider::ABIAdditionalParam::ABIParameterRole::Error,
+             typeConverter.Context.getOpaquePointerDecl()});
+    }
+    return params;
+  }
+
 private:
   Lowering::TypeConverter typeConverter;
   // Default silOptions are sufficient, as we don't need to generated SIL.
@@ -158,6 +185,12 @@ IRABIDetailsProvider::getTypeSizeAlignment(const NominalTypeDecl *TD) {
   return impl->getTypeSizeAlignment(TD);
 }
 
+llvm::SmallVector<IRABIDetailsProvider::ABIAdditionalParam, 1>
+IRABIDetailsProvider::getFunctionABIAdditionalParams(
+    AbstractFunctionDecl *afd) {
+  return impl->getFunctionABIAdditionalParams(afd);
+}
+
 bool IRABIDetailsProvider::shouldPassIndirectly(Type t) {
   return impl->shouldPassIndirectly(t);
 }

lib/PrintAsClang/DeclAndTypePrinter.cpp

@@ -43,6 +43,7 @@
 #include "clang/AST/DeclObjC.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/SourceManager.h"
+#include "SwiftToClangInteropContext.h"
 
 using namespace swift;
 using namespace swift::objc_translation;
@@ -937,6 +938,28 @@ class DeclAndTypePrinter::Implementation
     StringRef symbolName;
   };
 
+  // Converts the array of ABIAdditionalParam into an array of AdditionalParam
+  void convertABIAdditionalParams(
+      AbstractFunctionDecl *FD, Type resultTy,
+      llvm::SmallVector<IRABIDetailsProvider::ABIAdditionalParam, 1> ABIparams,
+      llvm::SmallVector<DeclAndTypeClangFunctionPrinter::AdditionalParam, 2>
+          &params) {
+    for (auto param : ABIparams) {
+      if (param.role ==
+          IRABIDetailsProvider::ABIAdditionalParam::ABIParameterRole::Self)
+        params.push_back(
+            {DeclAndTypeClangFunctionPrinter::AdditionalParam::Role::Self,
+             resultTy->getASTContext().getOpaquePointerType(),
+             /*isIndirect=*/
+             isa<FuncDecl>(FD) ? cast<FuncDecl>(FD)->isMutating() : false});
+      if (param.role ==
+          IRABIDetailsProvider::ABIAdditionalParam::ABIParameterRole::Error)
+        params.push_back(
+            {DeclAndTypeClangFunctionPrinter::AdditionalParam::Role::Error,
+             resultTy->getASTContext().getOpaquePointerType()});
+    }
+  }
+
   // Print out the extern C Swift ABI function signature.
   FuncionSwiftABIInformation printSwiftABIFunctionSignatureAsCxxFunction(
       AbstractFunctionDecl *FD, Optional<FunctionType *> givenFuncType = None,
@@ -962,7 +985,9 @@ class DeclAndTypePrinter::Implementation
     DeclAndTypeClangFunctionPrinter funcPrinter(os, owningPrinter.prologueOS,
                                                 owningPrinter.typeMapping,
                                                 owningPrinter.interopContext);
-    llvm::SmallVector<DeclAndTypeClangFunctionPrinter::AdditionalParam, 1>
+    auto ABIparams = owningPrinter.interopContext.getIrABIDetails()
+                         .getFunctionABIAdditionalParams(FD);
+    llvm::SmallVector<DeclAndTypeClangFunctionPrinter::AdditionalParam, 2>
         additionalParams;
     if (selfTypeDeclContext && !isa<ConstructorDecl>(FD)) {
       additionalParams.push_back(
@@ -971,14 +996,19 @@ class DeclAndTypePrinter::Implementation
            /*isIndirect=*/
            isa<FuncDecl>(FD) ? cast<FuncDecl>(FD)->isMutating() : false});
     }
+    if (funcTy->isThrowing() && !ABIparams.empty())
+      convertABIAdditionalParams(FD, resultTy, ABIparams, additionalParams);
+
     funcPrinter.printFunctionSignature(
         FD, funcABI.getSymbolName(), resultTy,
         DeclAndTypeClangFunctionPrinter::FunctionSignatureKind::CFunctionProto,
         additionalParams);
     // Swift functions can't throw exceptions, we can only
     // throw them from C++ when emitting C++ inline thunks for the Swift
     // functions.
-    os << " SWIFT_NOEXCEPT";
+    // FIXME: Support throwing exceptions for Swift errors.
+    if (!funcTy->isThrowing())
+      os << " SWIFT_NOEXCEPT";
     if (!funcABI.useCCallingConvention())
       os << " SWIFT_CALL";
     printAvailability(FD);
@@ -1013,16 +1043,25 @@ class DeclAndTypePrinter::Implementation
     DeclAndTypeClangFunctionPrinter funcPrinter(os, owningPrinter.prologueOS,
                                                 owningPrinter.typeMapping,
                                                 owningPrinter.interopContext);
+    llvm::SmallVector<DeclAndTypeClangFunctionPrinter::AdditionalParam, 2>
+        additionalParams;
+    auto ABIparams = owningPrinter.interopContext.getIrABIDetails()
+                         .getFunctionABIAdditionalParams(FD);
+    if (funcTy->isThrowing() && !ABIparams.empty())
+      convertABIAdditionalParams(FD, resultTy, ABIparams, additionalParams);
+
     funcPrinter.printFunctionSignature(
         FD, FD->getName().getBaseIdentifier().get(), resultTy,
         DeclAndTypeClangFunctionPrinter::FunctionSignatureKind::CxxInlineThunk);
     // FIXME: Support throwing exceptions for Swift errors.
-    os << " noexcept";
+    if (!funcTy->isThrowing())
+      os << " noexcept";
     printFunctionClangAttributes(FD, funcTy);
     printAvailability(FD);
     os << " {\n";
     funcPrinter.printCxxThunkBody(funcABI.getSymbolName(), resultTy,
-                                  FD->getParameters());
+                                  FD->getParameters(), additionalParams,
+                                  funcTy->isThrowing());
     os << "}\n";
   }
 

lib/PrintAsClang/PrintAsClang.cpp

@@ -320,6 +320,7 @@ static void writePrologue(raw_ostream &out, ASTContext &ctx,
   emitMacro("SWIFT_CALL", "__attribute__((swiftcall))");
   emitMacro("SWIFT_INDIRECT_RESULT", "__attribute__((swift_indirect_result))");
   emitMacro("SWIFT_CONTEXT", "__attribute__((swift_context))");
+  emitMacro("SWIFT_ERROR_RESULT", "__attribute__((swift_error_result))");
   // SWIFT_NOEXCEPT applies 'noexcept' in C++ mode only.
   emitCxxConditional(
       out, [&] { emitMacro("SWIFT_NOEXCEPT", "noexcept"); },

lib/PrintAsClang/PrintClangFunction.cpp

@@ -284,17 +284,23 @@ void DeclAndTypeClangFunctionPrinter::printFunctionSignature(
       os << ", ";
     HasParams = true;
     interleaveComma(additionalParams, os, [&](const AdditionalParam &param) {
-      assert(param.role == AdditionalParam::Role::Self);
-      CFunctionSignatureTypePrinterModifierDelegate delegate;
-      delegate.prefixIndirectParamValueTypeInC = [](raw_ostream &os) {
-        os << "SWIFT_CONTEXT ";
-      };
-      if (param.isIndirect) {
-        (*delegate.prefixIndirectParamValueTypeInC)(os);
-        os << "void * _Nonnull _self";
-      } else {
-        print(param.type, OptionalTypeKind::OTK_None, "_self",
-              /*isInOut*/ false, delegate);
+      if (param.role == AdditionalParam::Role::Self) {
+        CFunctionSignatureTypePrinterModifierDelegate delegate;
+        delegate.prefixIndirectParamValueTypeInC = [](raw_ostream &os) {
+          os << "SWIFT_CONTEXT ";
+        };
+        if (FD->hasThrows())
+          os << "SWIFT_CONTEXT ";
+        if (param.isIndirect) {
+          (*delegate.prefixIndirectParamValueTypeInC)(os);
+          os << "void * _Nonnull _self";
+        } else {
+          print(param.type, OptionalTypeKind::OTK_None, "_self",
+                /*isInOut*/ false, delegate);
+        }
+      } else if (param.role ==  AdditionalParam::Role::Error) {
+        os << "SWIFT_ERROR_RESULT ";
+        os << "void ** _error";
       }
     });
   }
@@ -338,7 +344,11 @@ void DeclAndTypeClangFunctionPrinter::printCxxToCFunctionParameterUse(
 
 void DeclAndTypeClangFunctionPrinter::printCxxThunkBody(
     StringRef swiftSymbolName, Type resultTy, const ParameterList *params,
-    ArrayRef<AdditionalParam> additionalParams) {
+    ArrayRef<AdditionalParam> additionalParams, bool hasThrows) {
+  if (hasThrows) {
+    os << "  void* opaqueError = nullptr;\n";
+    os << "  void* self = nullptr;\n";
+  }
   auto printCallToCFunc = [&](Optional<StringRef> additionalParam) {
     os << cxx_synthesis::getCxxImplNamespaceName() << "::" << swiftSymbolName
        << '(';
@@ -371,10 +381,18 @@ void DeclAndTypeClangFunctionPrinter::printCxxThunkBody(
       if (hasParams)
         os << ", ";
       interleaveComma(additionalParams, os, [&](const AdditionalParam &param) {
-        assert(param.role == AdditionalParam::Role::Self);
-        printCxxToCFunctionParameterUse(param.type, "*this", /*isInOut=*/false,
-                                        /*isIndirect=*/param.isIndirect,
-                                        param.role);
+         if (param.role == AdditionalParam::Role::Self && !hasThrows)
+          printCxxToCFunctionParameterUse(param.type, "*this", /*isInOut=*/false,
+                                          /*isIndirect=*/param.isIndirect,
+                                          param.role);
+         else if(param.role == AdditionalParam::Role::Self && hasThrows)
+            printCxxToCFunctionParameterUse(param.type, "self", /*isInOut=*/false,
+                                            /*isIndirect=*/param.isIndirect,
+                                            param.role);
+         else if(param.role == AdditionalParam::Role::Error && hasThrows)
+           printCxxToCFunctionParameterUse(param.type, "&opaqueError", /*isInOut=*/false,
+                                           /*isIndirect=*/param.isIndirect,
+                                           param.role);
       });
     }
 
@@ -447,7 +465,7 @@ void DeclAndTypeClangFunctionPrinter::printCxxMethod(
         /*isIndirect=*/isMutating,
     });
   printCxxThunkBody(swiftSymbolName, resultTy, FD->getParameters(),
-                    additionalParams);
+                    additionalParams, FD->hasThrows());
   os << "  }\n";
 }
 

lib/PrintAsClang/PrintClangFunction.h

@@ -15,6 +15,7 @@
 
 #include "swift/AST/Type.h"
 #include "swift/Basic/LLVM.h"
+#include "swift/IRGen/IRABIDetailsProvider.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
@@ -52,7 +53,7 @@ class DeclAndTypeClangFunctionPrinter {
 
   /// Information about any additional parameters.
   struct AdditionalParam {
-    enum class Role { Self };
+    enum class Role { Self, Error };
 
     Role role;
     Type type;
@@ -83,7 +84,8 @@ class DeclAndTypeClangFunctionPrinter {
   /// Swift function.
   void printCxxThunkBody(StringRef swiftSymbolName, Type resultTy,
                          const ParameterList *params,
-                         ArrayRef<AdditionalParam> additionalParams = {});
+                         ArrayRef<AdditionalParam> additionalParams = {},
+                         bool hasThrows = false);
 
   /// Print the Swift method as C++ method declaration/definition, including
   /// constructors.

lib/SIL/IR/SILFunction.cpp

@@ -21,6 +21,7 @@
 #include "swift/SIL/SILProfiler.h"
 #include "swift/SIL/CFG.h"
 #include "swift/SIL/PrettyStackTrace.h"
+#include "../../SILGen/SILGen.h"
 #include "swift/AST/Availability.h"
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/Module.h"
@@ -874,3 +875,8 @@ visitArgEffects(std::function<void(int, bool, ArgEffectKind)> c) const {
     idx++;
   }
 }
+
+SILFunction *SILFunction::getFunction(SILDeclRef ref, SILModule &M) {
+  swift::Lowering::SILGenModule SILGenModule(M, ref.getModuleContext());
+  return SILGenModule.getFunction(ref, swift::NotForDefinition);
+}

test/Interop/SwiftToCxx/functions/swift-functions-errors-execution.cpp

@@ -9,7 +9,6 @@
 // RUN: %target-run %t/swift-functions-errors-execution | %FileCheck %s
 
 // REQUIRES: executable_test
-// XFAIL: *
 
 #include <cassert>
 #include "functions.h"
@@ -24,4 +23,4 @@ int main() {
 }
 
 // CHECK: passEmptyThrowFunction
-// CHECK-NEXT: passThrowFunction
+// CHECK-NEXT: passThrowFunction

test/Interop/SwiftToCxx/functions/swift-functions-errors.swift

@@ -8,22 +8,22 @@
 
 // CHECK-LABEL: namespace _impl {
 
-// CHECK: SWIFT_EXTERN void $s9Functions18emptyThrowFunctionyyKF(void) SWIFT_CALL; // emptyThrowFunction()
-// CHECK: SWIFT_EXTERN void $s9Functions13throwFunctionyyKF(void) SWIFT_CALL; // throwFunction()
+// CHECK: SWIFT_EXTERN void $s9Functions18emptyThrowFunctionyyKF(SWIFT_CONTEXT void * _Nonnull _self, SWIFT_ERROR_RESULT void ** _error) SWIFT_CALL; // emptyThrowFunction()
+// CHECK: SWIFT_EXTERN void $s9Functions13throwFunctionyyKF(SWIFT_CONTEXT void * _Nonnull _self, SWIFT_ERROR_RESULT void ** _error) SWIFT_CALL; // throwFunction()
 
 // CHECK: }
 
-//XFAIL: *
-
-enum NaiveErrors: Error {
+enum NaiveErrors : Error {
     case returnError
     case throwError
 }
 
 public func emptyThrowFunction() throws { print("passEmptyThrowFunction") }
 
 // CHECK: inline void emptyThrowFunction() {
-// CHECK: return _impl::$s9Functions18emptyThrowFunctionyyKF();
+// CHECK: void* opaqueError = nullptr;
+// CHECK: void* self = nullptr;
+// CHECK: return _impl::$s9Functions18emptyThrowFunctionyyKF(self, &opaqueError);
 // CHECK: }
 
 public func throwFunction() throws {
@@ -32,5 +32,7 @@ public func throwFunction() throws {
 }
 
 // CHECK: inline void throwFunction() {
-// CHECK: return _impl::$s9Functions13throwFunctionyyKF();
-// CHECK: }
+// CHECK: void* opaqueError = nullptr;
+// CHECK: void* self = nullptr;
+// CHECK: return _impl::$s9Functions13throwFunctionyyKF(self, &opaqueError);
+// CHECK: }