[cxx-interop] Support SIMD types in reverse interop

This supports both built-in vector types and the SIMDX<T> Swift types
that are used through type aliases like float3. These SIMD types are
passed via compatibility structs (with their valued memcpy-d into the
ABI compatible struct) as they have special ABI rules. E.g., a float3 is
not passed as float3, but as float4 on the ABI level.

Previously, we did not expose simd types from Swift to C++ (unless the
SIMD types were impoted from clang).

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;
 
@@ -101,13 +106,19 @@ void PrimitiveTypeMapping::initialize(ASTContext &ctx) {
 #define MAP_SIMD_TYPE(BASENAME, _, __)                                         \
   StringRef simd2##BASENAME = "swift_" #BASENAME "2";                          \
   mappedTypeNames[{ctx.Id_simd, ctx.getIdentifier(#BASENAME "2")}] = {         \
-      simd2##BASENAME, simd2##BASENAME, simd2##BASENAME, false};               \
+      simd2##BASENAME, simd2##BASENAME, simd2##BASENAME, false, true};         \
+  mappedTypeNames[{ctx.Id_simd, ctx.getIdentifier("simd_" #BASENAME "2")}] = { \
+      simd2##BASENAME, simd2##BASENAME, simd2##BASENAME, false, true};         \
   StringRef simd3##BASENAME = "swift_" #BASENAME "3";                          \
   mappedTypeNames[{ctx.Id_simd, ctx.getIdentifier(#BASENAME "3")}] = {         \
-      simd3##BASENAME, simd3##BASENAME, simd3##BASENAME, false};               \
+      simd3##BASENAME, simd3##BASENAME, simd3##BASENAME, false, true};         \
+  mappedTypeNames[{ctx.Id_simd, ctx.getIdentifier("simd_" #BASENAME "3")}] = { \
+      simd3##BASENAME, simd3##BASENAME, simd3##BASENAME, false, true};         \
   StringRef simd4##BASENAME = "swift_" #BASENAME "4";                          \
   mappedTypeNames[{ctx.Id_simd, ctx.getIdentifier(#BASENAME "4")}] = {         \
-      simd4##BASENAME, simd4##BASENAME, simd4##BASENAME, false};
+      simd4##BASENAME, simd4##BASENAME, simd4##BASENAME, false, true};         \
+  mappedTypeNames[{ctx.Id_simd, ctx.getIdentifier("simd_" #BASENAME "4")}] = { \
+      simd4##BASENAME, simd4##BASENAME, simd4##BASENAME, false, true};
 #include "swift/ClangImporter/SIMDMappedTypes.def"
   static_assert(SWIFT_MAX_IMPORTED_SIMD_ELEMENTS == 4,
                 "must add or remove special name mappings if max number of "
@@ -130,15 +141,17 @@ PrimitiveTypeMapping::getMappedTypeInfoOrNull(const TypeDecl *typeDecl) {
 std::optional<PrimitiveTypeMapping::ClangTypeInfo>
 PrimitiveTypeMapping::getKnownObjCTypeInfo(const TypeDecl *typeDecl) {
   if (auto *typeInfo = getMappedTypeInfoOrNull(typeDecl))
-    return ClangTypeInfo{typeInfo->objcName, typeInfo->canBeNullable};
+    return ClangTypeInfo{typeInfo->objcName, typeInfo->canBeNullable,
+                         typeInfo->simd};
   return std::nullopt;
 }
 
 std::optional<PrimitiveTypeMapping::ClangTypeInfo>
 PrimitiveTypeMapping::getKnownCTypeInfo(const TypeDecl *typeDecl) {
   if (auto *typeInfo = getMappedTypeInfoOrNull(typeDecl)) {
     if (typeInfo->cName)
-      return ClangTypeInfo{*typeInfo->cName, typeInfo->canBeNullable};
+      return ClangTypeInfo{*typeInfo->cName, typeInfo->canBeNullable,
+                           typeInfo->simd};
   }
   return std::nullopt;
 }
@@ -147,7 +160,32 @@ std::optional<PrimitiveTypeMapping::ClangTypeInfo>
 PrimitiveTypeMapping::getKnownCxxTypeInfo(const TypeDecl *typeDecl) {
   if (auto *typeInfo = getMappedTypeInfoOrNull(typeDecl)) {
     if (typeInfo->cxxName)
-      return ClangTypeInfo{*typeInfo->cxxName, typeInfo->canBeNullable};
+      return ClangTypeInfo{*typeInfo->cxxName, typeInfo->canBeNullable,
+                           typeInfo->simd};
   }
   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, true};
+}

lib/PrintAsClang/PrimitiveTypeMapping.h

@@ -21,18 +21,21 @@ 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 {
     StringRef name;
     bool canBeNullable;
+    bool simd;
   };
 
   /// Returns the Objective-C type name and nullability for the given Swift
@@ -47,6 +50,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);
 
@@ -58,6 +63,7 @@ class PrimitiveTypeMapping {
     // The C++ name of the Swift type.
     std::optional<StringRef> cxxName;
     bool canBeNullable;
+    bool simd = false;
   };
 
   FullClangTypeInfo *getMappedTypeInfoOrNull(const TypeDecl *typeDecl);