[cxx-interop] Better support SIMD types

rdar://153218744

Author: Gabor Horvath

lib/IRGen/IRABIDetailsProvider.cpp

@@ -38,6 +38,7 @@
 #include "clang/CodeGen/ModuleBuilder.h"
 #include "clang/CodeGen/SwiftCallingConv.h"
 #include "llvm/IR/DerivedTypes.h"
+#include <optional>
 
 using namespace swift;
 using namespace irgen;
@@ -59,13 +60,25 @@ getPrimitiveTypeFromLLVMType(ASTContext &ctx, const llvm::Type *type) {
     default:
       return std::nullopt;
     }
-  } else if (type->isFloatTy()) {
+  }
+  if (type->isFloatTy()) {
     return ctx.getFloatType();
-  } else if (type->isDoubleTy()) {
+  }
+  if (type->isDoubleTy()) {
     return ctx.getDoubleType();
-  } else if (type->isPointerTy()) {
+  }
+  if (type->isPointerTy()) {
     return ctx.getOpaquePointerType();
   }
+  if (const auto *vecTy = dyn_cast<llvm::VectorType>(type)) {
+    auto elemTy = getPrimitiveTypeFromLLVMType(ctx, vecTy->getElementType());
+    if (!elemTy)
+      return std::nullopt;
+    auto elemCount = vecTy->getElementCount();
+    if (!elemCount.isFixed())
+      return std::nullopt;
+    return BuiltinVectorType::get(ctx, *elemTy, elemCount.getFixedValue());
+  }
   // FIXME: Handle vector type.
   return std::nullopt;
 }

lib/PrintAsClang/PrimitiveTypeMapping.cpp

@@ -14,8 +14,13 @@
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/Module.h"
+#include "swift/AST/Type.h"
+#include "swift/AST/Types.h"
 #include "swift/Basic/Assertions.h"
 #include "swift/ClangImporter/ClangImporter.h"
+#include <cctype>
+#include <optional>
+#include <string>
 
 using namespace swift;
 
@@ -102,11 +107,17 @@ void PrimitiveTypeMapping::initialize(ASTContext &ctx) {
   StringRef simd2##BASENAME = "swift_" #BASENAME "2";                          \
   mappedTypeNames[{ctx.Id_simd, ctx.getIdentifier(#BASENAME "2")}] = {         \
       simd2##BASENAME, simd2##BASENAME, simd2##BASENAME, false};               \
+  mappedTypeNames[{ctx.Id_simd, ctx.getIdentifier("simd_" #BASENAME "2")}] = { \
+      simd2##BASENAME, simd2##BASENAME, simd2##BASENAME, false};               \
   StringRef simd3##BASENAME = "swift_" #BASENAME "3";                          \
   mappedTypeNames[{ctx.Id_simd, ctx.getIdentifier(#BASENAME "3")}] = {         \
       simd3##BASENAME, simd3##BASENAME, simd3##BASENAME, false};               \
+  mappedTypeNames[{ctx.Id_simd, ctx.getIdentifier("simd_" #BASENAME "3")}] = { \
+      simd3##BASENAME, simd3##BASENAME, simd3##BASENAME, false};               \
   StringRef simd4##BASENAME = "swift_" #BASENAME "4";                          \
   mappedTypeNames[{ctx.Id_simd, ctx.getIdentifier(#BASENAME "4")}] = {         \
+      simd4##BASENAME, simd4##BASENAME, simd4##BASENAME, false};               \
+  mappedTypeNames[{ctx.Id_simd, ctx.getIdentifier("simd_" #BASENAME "4")}] = { \
       simd4##BASENAME, simd4##BASENAME, simd4##BASENAME, false};
 #include "swift/ClangImporter/SIMDMappedTypes.def"
   static_assert(SWIFT_MAX_IMPORTED_SIMD_ELEMENTS == 4,
@@ -151,3 +162,27 @@ PrimitiveTypeMapping::getKnownCxxTypeInfo(const TypeDecl *typeDecl) {
   }
   return std::nullopt;
 }
+
+std::optional<PrimitiveTypeMapping::ClangTypeInfo>
+PrimitiveTypeMapping::getKnownSIMDTypeInfo(Type t, ASTContext &ctx) {
+  auto vecTy = t->getAs<BuiltinVectorType>();
+  if (!vecTy)
+    return std::nullopt;
+
+  auto elemTy = vecTy->getElementType();
+  auto numElems = vecTy->getNumElements();
+
+  if (mappedTypeNames.empty())
+    initialize(ctx);
+
+  Identifier moduleName = ctx.Id_simd;
+  std::string elemTyName = elemTy.getString();
+  // While the element type starts with an upper case, vector types start with
+  // lower case.
+  elemTyName[0] = std::tolower(elemTyName[0]);
+  Identifier name = ctx.getIdentifier(elemTyName + std::to_string(numElems));
+  auto iter = mappedTypeNames.find({moduleName, name});
+  if (iter == mappedTypeNames.end())
+    return std::nullopt;
+  return ClangTypeInfo{*iter->second.cName, false};
+}

lib/PrintAsClang/PrimitiveTypeMapping.h

@@ -21,13 +21,15 @@ namespace swift {
 
 class ASTContext;
 class TypeDecl;
+class Type;
 
 /// Provides a mapping from Swift's primitive types to C / Objective-C / C++
 /// primitive types.
 ///
 /// Certain types have mappings that differ in different language modes.
-/// For example, Swift's `Int` maps to `NSInteger` for Objective-C declarations,
-/// but to something like `intptr_t` or `swift::Int` for C and C++ declarations.
+/// For example, Swift's `Int` maps to `NSInteger` for Objective-C
+/// declarations, but to something like `intptr_t` or `swift::Int` for C and
+/// C++ declarations.
 class PrimitiveTypeMapping {
 public:
   struct ClangTypeInfo {
@@ -47,6 +49,8 @@ class PrimitiveTypeMapping {
   /// primitive type declaration, or \c None if no such type name exists.
   std::optional<ClangTypeInfo> getKnownCxxTypeInfo(const TypeDecl *typeDecl);
 
+  std::optional<ClangTypeInfo> getKnownSIMDTypeInfo(Type t, ASTContext &ctx);
+
 private:
   void initialize(ASTContext &ctx);
 

lib/PrintAsClang/PrintClangFunction.cpp

@@ -53,14 +53,14 @@ getKnownTypeInfo(const TypeDecl *typeDecl, PrimitiveTypeMapping &typeMapping,
 }
 
 bool isKnownType(Type t, PrimitiveTypeMapping &typeMapping,
-                 OutputLanguageMode languageMode) {
+                 OutputLanguageMode languageMode, ASTContext &ctx) {
   if (auto *typeAliasType = dyn_cast<TypeAliasType>(t.getPointer())) {
     auto aliasInfo =
         getKnownTypeInfo(typeAliasType->getDecl(), typeMapping, languageMode);
     if (aliasInfo != std::nullopt)
       return true;
     return isKnownType(typeAliasType->getSinglyDesugaredType(), typeMapping,
-                       languageMode);
+                       languageMode, ctx);
   }
 
   const TypeDecl *typeDecl;
@@ -80,6 +80,8 @@ bool isKnownType(Type t, PrimitiveTypeMapping &typeMapping,
            isa<clang::ObjCInterfaceDecl>(
                classType->getClassOrBoundGenericClass()->getClangDecl());
   }
+  if (t->getAs<BuiltinVectorType>())
+    return (bool)typeMapping.getKnownSIMDTypeInfo(t, ctx);
 
   if (auto *structDecl = t->getStructOrBoundGenericStruct())
     typeDecl = structDecl;
@@ -88,12 +90,13 @@ bool isKnownType(Type t, PrimitiveTypeMapping &typeMapping,
   return getKnownTypeInfo(typeDecl, typeMapping, languageMode) != std::nullopt;
 }
 
-bool isKnownCxxType(Type t, PrimitiveTypeMapping &typeMapping) {
-  return isKnownType(t, typeMapping, OutputLanguageMode::Cxx);
+bool isKnownCxxType(Type t, PrimitiveTypeMapping &typeMapping,
+                    ASTContext &ctx) {
+  return isKnownType(t, typeMapping, OutputLanguageMode::Cxx, ctx);
 }
 
-bool isKnownCType(Type t, PrimitiveTypeMapping &typeMapping) {
-  return isKnownType(t, typeMapping, OutputLanguageMode::ObjC);
+bool isKnownCType(Type t, PrimitiveTypeMapping &typeMapping, ASTContext &ctx) {
+  return isKnownType(t, typeMapping, OutputLanguageMode::ObjC, ctx);
 }
 
 struct CFunctionSignatureTypePrinterModifierDelegate {
@@ -463,7 +466,7 @@ class CFunctionSignatureTypePrinter
     llvm::SaveAndRestore<FunctionSignatureTypeUse> typeUseNormal(
         typeUseKind, FunctionSignatureTypeUse::TypeReference);
     // FIXME: We can definitely support pointers to known Clang types.
-    if (!isKnownCType(args.front(), typeMapping))
+    if (!isKnownCType(args.front(), typeMapping, BGT->getASTContext()))
       return ClangRepresentation(ClangRepresentation::unsupported);
     auto partRepr = visitPart(args.front(), OTK_None, /*isInOutParam=*/false);
     if (partRepr.isUnsupported())
@@ -572,9 +575,11 @@ DeclAndTypeClangFunctionPrinter::printClangFunctionReturnType(
 static void addABIRecordToTypeEncoding(llvm::raw_ostream &typeEncodingOS,
                                        clang::CharUnits offset,
                                        clang::CharUnits end, Type t,
-                                       PrimitiveTypeMapping &typeMapping) {
-  auto info =
-      typeMapping.getKnownCTypeInfo(t->getNominalOrBoundGenericNominal());
+                                       PrimitiveTypeMapping &typeMapping,
+                                       ASTContext &ctx) {
+  auto info = typeMapping.getKnownSIMDTypeInfo(t, ctx);
+  if (!info)
+    info = typeMapping.getKnownCTypeInfo(t->getNominalOrBoundGenericNominal());
   assert(info);
   typeEncodingOS << '_';
   for (char c : info->name) {
@@ -605,7 +610,8 @@ static std::string encodeTypeInfo(const T &abiTypeInfo,
   ClangSyntaxPrinter(moduleContext->getASTContext(), typeEncodingOS).printBaseName(moduleContext);
   abiTypeInfo.enumerateRecordMembers(
       [&](clang::CharUnits offset, clang::CharUnits end, Type t) {
-        addABIRecordToTypeEncoding(typeEncodingOS, offset, end, t, typeMapping);
+        addABIRecordToTypeEncoding(typeEncodingOS, offset, end, t, typeMapping,
+                                   moduleContext->getASTContext());
       });
   return std::move(typeEncodingOS.str());
 }
@@ -652,7 +658,8 @@ static bool printDirectReturnOrParamCType(
                                              clang::CharUnits end, Type t) {
         lastOffset = offset;
         ++Count;
-        addABIRecordToTypeEncoding(typeEncodingOS, offset, end, t, typeMapping);
+        addABIRecordToTypeEncoding(typeEncodingOS, offset, end, t, typeMapping,
+                                   emittedModule->getASTContext());
       }))
     return false;
   if (isResultType && Count == 0) {
@@ -664,7 +671,7 @@ static bool printDirectReturnOrParamCType(
   assert(Count > 0 && "missing return values");
 
   // FIXME: is this "prettyfying" logic sound for multiple return values?
-  if (isKnownCType(valueType, typeMapping) ||
+  if (isKnownCType(valueType, typeMapping, emittedModule->getASTContext()) ||
       (Count == 1 && lastOffset.isZero() && !valueType->hasTypeParameter() &&
        (valueType->isAnyClassReferenceType() ||
         isOptionalObjCExistential(valueType) ||
@@ -683,7 +690,10 @@ static bool printDirectReturnOrParamCType(
     abiTypeInfo.enumerateRecordMembers([&](clang::CharUnits offset,
                                            clang::CharUnits end, Type t) {
       auto info =
-          typeMapping.getKnownCTypeInfo(t->getNominalOrBoundGenericNominal());
+          typeMapping.getKnownSIMDTypeInfo(t, emittedModule->getASTContext());
+      if (!info)
+        info =
+            typeMapping.getKnownCTypeInfo(t->getNominalOrBoundGenericNominal());
       os << "  " << info->name;
       if (info->canBeNullable)
         os << " _Nullable";
@@ -962,8 +972,8 @@ ClangRepresentation DeclAndTypeClangFunctionPrinter::printFunctionSignature(
                     ->isAnyClassReferenceType());
           if (isConst)
             functionSignatureOS << "const ";
-          if (isKnownCType(param.getParamDecl().getInterfaceType(),
-                           typeMapping) ||
+          if (isKnownCType(param.getParamDecl().getInterfaceType(), typeMapping,
+                           FD->getASTContext()) ||
               (!param.getParamDecl().getInterfaceType()->hasTypeParameter() &&
                param.getParamDecl()
                    .getInterfaceType()
@@ -1079,7 +1089,7 @@ void DeclAndTypeClangFunctionPrinter::printCxxToCFunctionParameterUse(
     Type type, StringRef name, const ModuleDecl *moduleContext, bool isInOut,
     bool isIndirect, std::string directTypeEncoding, bool forceSelf) {
   auto namePrinter = [&]() { ClangSyntaxPrinter(moduleContext->getASTContext(), os).printIdentifier(name); };
-  if (!isKnownCxxType(type, typeMapping) &&
+  if (!isKnownCxxType(type, typeMapping, moduleContext->getASTContext()) &&
       !hasKnownOptionalNullableCxxMapping(type)) {
     if (type->is<GenericTypeParamType>()) {
       os << "swift::" << cxx_synthesis::getCxxImplNamespaceName()
@@ -1463,7 +1473,7 @@ void DeclAndTypeClangFunctionPrinter::printCxxThunkBody(
 
   // Values types are returned either direcly in their C representation, or
   // indirectly by a pointer.
-  if (!isKnownCxxType(resultTy, typeMapping) &&
+  if (!isKnownCxxType(resultTy, typeMapping, moduleContext->getASTContext()) &&
       !hasKnownOptionalNullableCxxMapping(resultTy)) {
     if (const auto *gtpt = resultTy->getAs<GenericTypeParamType>()) {
       printGenericReturnSequence(os, gtpt, printCallToCFunc);

test/Interop/CxxToSwiftToCxx/simd-bridge-cxx-struct-back-to-cxx.swift

@@ -43,5 +43,14 @@ public func passStruct(_ x : Struct) {
 }
 
 // CHECK: class SWIFT_SYMBOL("s:8UseCxxTy6StructV") Struct final {
-// CHECK-NOT: init(
-// CHECK:  // Unavailable in C++: Swift global function 'passStruct(_:)'
+
+// CHECK: SWIFT_INLINE_THUNK void passStruct(const Struct& x) noexcept SWIFT_SYMBOL("s:8UseCxxTy10passStructyyAA0E0VF") {
+// CHECK-NEXT:   UseCxxTy::_impl::$s8UseCxxTy10passStructyyAA0E0VF(UseCxxTy::_impl::swift_interop_passDirect_UseCxxTy_swift_float4_0_16_swift_float4_16_32_swift_float4_32_48_swift_float4_48_64(UseCxxTy::_impl::_impl_Struct::getOpaquePointer(x)));
+// CHECK-NEXT:}
+
+// CHECK:  SWIFT_INLINE_THUNK Struct Struct::init() {
+// CHECK-NEXT:  return UseCxxTy::_impl::_impl_Struct::returnNewValue([&](char * _Nonnull result) SWIFT_INLINE_THUNK_ATTRIBUTES {
+// CHECK-NEXT:    UseCxxTy::_impl::swift_interop_returnDirect_UseCxxTy_swift_float4_0_16_swift_float4_16_32_swift_float4_32_48_swift_float4_48_64(result, UseCxxTy::_impl::$s8UseCxxTy6StructVACycfC());
+// CHECK-NEXT:  });
+// CHECK-NEXT:  }
+

test/Interop/SwiftToCxx/stdlib/swift-simd-in-cxx-execution.cpp

@@ -0,0 +1,22 @@
+// RUN: %empty-directory(%t)
+
+// RUN: %target-swift-frontend %S/swift-simd-in-cxx.swift -module-name SIMD -clang-header-expose-decls=all-public -typecheck -verify -emit-clang-header-path %t/simd.h
+
+// RUN: %target-interop-build-clangxx -c %s -I %t -o %t/swift-simd-execution.o
+// RUN: %target-interop-build-swift %S/swift-simd-in-cxx.swift -o %t/swift-simd-execution -Xlinker %t/swift-simd-execution.o -module-name SIMD -Xfrontend -entry-point-function-name -Xfrontend swiftMain
+
+// RUN: %target-codesign %t/swift-simd-execution
+// RUN: %target-run %t/swift-simd-execution | %FileCheck %s
+
+// REQUIRES: executable_test
+
+#include <assert.h>
+#include "simd.h"
+
+int main() {
+  swift_float3 vec{1.0, 2.0, 3.0};
+  SIMD::swiftThingSIMD(vec);
+// CHECK: SIMD3<Float>(1.0, 2.0, 0.0)
+  return 0;
+}
+

test/Interop/SwiftToCxx/stdlib/swift-simd-in-cxx.swift

@@ -0,0 +1,26 @@
+// RUN: %empty-directory(%t)
+
+// RUN: %target-swift-frontend %s -module-name UseSIMD -cxx-interoperability-mode=default -clang-header-expose-decls=all-public -typecheck -verify -emit-clang-header-path %t/UseSIMD.h
+// RUN: %FileCheck %s < %t/UseSIMD.h
+
+// RUN: %target-interop-build-clangxx -std=gnu++20 -fobjc-arc -c -x objective-c++-header %t/UseSIMD.h -o %t/o.o
+
+// REQUIRES: objc_interop
+
+import simd
+
+public func swiftThingScalar(a: Float) {}
+public func swiftThingSIMD(a: simd_float3) {
+    print(a)
+}
+
+// CHECK: SWIFT_EXTERN void $s7UseSIMD010swiftThingB01ays5SIMD3VySfG_tF(swift_float3 a) SWIFT_NOEXCEPT SWIFT_CALL; // swiftThingSIMD(a:)
+// CHECK: SWIFT_EXTERN void $s7UseSIMD16swiftThingScalar1aySf_tF(float a) SWIFT_NOEXCEPT SWIFT_CALL; // swiftThingScalar(a:)
+
+// CHECK:      WIFT_INLINE_THUNK void swiftThingSIMD(swift_float3 a) noexcept SWIFT_SYMBOL("s:7UseSIMD010swiftThingB01ays5SIMD3VySfG_tF") {
+// CHECK-NEXT:   UseSIMD::_impl::$s7UseSIMD010swiftThingB01ays5SIMD3VySfG_tF(a);
+// CHECK-NEXT: }
+
+// CHECK:      WIFT_INLINE_THUNK void swiftThingScalar(float a) noexcept SWIFT_SYMBOL("s:7UseSIMD16swiftThingScalar1aySf_tF") {
+// CHECK-NEXT:   UseSIMD::_impl::$s7UseSIMD16swiftThingScalar1aySf_tF(a);
+// CHECK-NEXT: }