Teach the importer to import any clang vector type as SIMDn<Scalar>. (swiftlang#23454)

* Teach the importer to import any vector type as SIMDN<Scalar>.

Instead of having a known set of vector types, check to see if the
element type conforms to SIMDScalar; if it does, see if we have a
SIMDN defined with the right number of elements. If both are satisfied,
import the vector type as that Swift type.

By making this change, we gain the ability to import vector types
that aren't defined in terms of the Darwin simd module, which lets
us use C API with vector types on other platforms. It also lets us
import *every* vector type that Swift can represent, rather than the
small subset that are currently hardcoded.

* Increased test coverage for increased SIMD types that we can import.

Includes some minor cleanup from review. Also eliminates the old
simd_sans_simd test, since we can now import all of these types even when the simd module isn't imported.

Author: stephentyrone

include/swift/AST/KnownProtocols.def

@@ -67,6 +67,7 @@ PROTOCOL(Error)
 PROTOCOL_(ErrorCodeProtocol)
 PROTOCOL(OptionSet)
 PROTOCOL(CaseIterable)
+PROTOCOL(SIMDScalar)
 
 PROTOCOL_(BridgedNSError)
 PROTOCOL_(BridgedStoredNSError)

lib/ClangImporter/ImportType.cpp

@@ -510,36 +510,36 @@ namespace {
     }
 
     ImportResult VisitVectorType(const clang::VectorType *type) {
-      auto *SIMD = Impl.tryLoadSIMDModule();
-      if (!SIMD)
-        return Type();
-      
-      // Map the element type and count to a Swift name, such as
-      // float x 3 => Float3.
-      SmallString<16> name;
-      {
-        llvm::raw_svector_ostream names(name);
-        
-        if (auto builtinTy
-              = dyn_cast<clang::BuiltinType>(type->getElementType())){
-          switch (builtinTy->getKind()) {
-#define MAP_SIMD_TYPE(TYPE_NAME, __, BUILTIN_KIND)   \
-          case clang::BuiltinType::BUILTIN_KIND: \
-            names << #TYPE_NAME;                 \
-            break;
-#include "swift/ClangImporter/SIMDMappedTypes.def"
-          default:
-            // A vector type we don't know how to map.
-            return Type();
+      // Get the imported element type and count.
+      Type element = Impl.importTypeIgnoreIUO(
+        type->getElementType(), ImportTypeKind::Abstract,
+        false /* No NSUIntegerAsInt */, Bridgeability::None,
+        OptionalTypeKind::OTK_None);
+      unsigned count = type->getNumElements();
+      // Import vector-of-one as the element type.
+      if (count == 1) { return element; }
+      // Imported element type needs to conform to SIMDScalar.
+      auto nominal = element->getAnyNominal();
+      auto simdscalar = Impl.SwiftContext.getProtocol(KnownProtocolKind::SIMDScalar);
+      SmallVector<ProtocolConformance *, 2> conformances;
+      if (simdscalar && nominal->lookupConformance(nominal->getParentModule(),
+                                                   simdscalar, conformances)) {
+        // Element type conforms to SIMDScalar. Get the SIMDn generic type
+        // if it exists.
+        SmallString<8> name("SIMD");
+        name.append(std::to_string(count));
+        if (auto vector = Impl.getNamedSwiftType(Impl.getStdlibModule(), name)) {
+          if (auto unbound = vector->getAs<UnboundGenericType>()) {
+            // All checks passed: the imported element type is SIMDScalar,
+            // and a generic SIMDn type exists with n == count. Construct the
+            // bound generic type and return that.
+            return BoundGenericType::get(
+              cast<NominalTypeDecl>(unbound->getDecl()), Type(), { element }
+            );
           }
-        } else {
-          return Type();
         }
-        
-        names << type->getNumElements();
       }
-      
-      return Impl.getNamedSwiftType(SIMD, name);
+      return Type();
     }
 
     ImportResult VisitFunctionProtoType(const clang::FunctionProtoType *type) {
@@ -2326,11 +2326,6 @@ ModuleDecl *ClangImporter::Implementation::tryLoadFoundationModule() {
                        ImportForwardDeclarations, checkedModules);
 }
 
-ModuleDecl *ClangImporter::Implementation::tryLoadSIMDModule() {
-  return tryLoadModule(SwiftContext, SwiftContext.Id_simd,
-                       ImportForwardDeclarations, checkedModules);
-}
-
 Type ClangImporter::Implementation::getNamedSwiftType(ModuleDecl *module,
                                                       StringRef name) {
   if (!module)

lib/ClangImporter/ImporterImpl.h

@@ -888,12 +888,6 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
   /// into the ASTContext.
   ModuleDecl *tryLoadFoundationModule();
 
-  /// Returns the "SIMD" module, if it can be loaded.
-  ///
-  /// After this has been called, the SIMD module will or won't be loaded
-  /// into the ASTContext.
-  ModuleDecl *tryLoadSIMDModule();
-
   /// Retrieves the Swift wrapper for the given Clang module, creating
   /// it if necessary.
   ClangModuleUnit *getWrapperForModule(const clang::Module *underlying);

lib/IRGen/GenMeta.cpp

@@ -4109,6 +4109,7 @@ SpecialProtocol irgen::getSpecialProtocolID(ProtocolDecl *P) {
   case KnownProtocolKind::Hashable:
   case KnownProtocolKind::CaseIterable:
   case KnownProtocolKind::Comparable:
+  case KnownProtocolKind::SIMDScalar:
   case KnownProtocolKind::ObjectiveCBridgeable:
   case KnownProtocolKind::DestructorSafeContainer:
   case KnownProtocolKind::SwiftNewtypeWrapper:

stdlib/public/Darwin/simd/simd.swift.gyb

@@ -44,23 +44,19 @@ public extension SIMD where Scalar : FixedWidthInteger {
 component = ['x','y','z','w']
 scalar_types = ['Float','Double','Int32','UInt32']
 ctype = { 'Float':'float', 'Double':'double', 'Int32':'int', 'UInt32':'uint'}
-llvm_type = { 'Float':'FPIEEE32', 'Double':'FPIEEE64', 'Int32':'Int32', 'UInt32':'Int32' }
 floating_types = ['Float','Double']
-cardinal = { 2:'two', 3:'three', 4:'four'}
 }%
 
 %for scalar in scalar_types:
 % for count in [2, 3, 4]:
 %  vectype = ctype[scalar] + str(count)
-%  llvm_vectype = "Vec" + str(count) + "x" + llvm_type[scalar]
 %  vecsize = (8 if scalar == 'Double' else 4) * (4 if count == 3 else count)
 %  vecalign = (16 if vecsize > 16 else vecsize)
-%  extractelement = "extractelement_" + llvm_vectype + "_Int32"
-%  insertelement = "insertelement_" + llvm_vectype + "_" + llvm_type[scalar] + "_Int32"
 %  is_floating = scalar in floating_types
 %  is_signed = scalar[0] != 'U'
 %  wrap = "" if is_floating else "&"
 
+@available(swift, deprecated: 5.1, message: "Use SIMD${count}<${scalar}>")
 public typealias ${vectype} = SIMD${count}<${scalar}>
 
 %  if is_signed:

test/ClangImporter/simd.swift

@@ -1,19 +1,79 @@
 // RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -module-name main -typecheck -verify %s
 
 import c_simd
-import simd
 
-let f4: float4 = makes_float4()
-let i3: int3 = makes_int3()
-let d2: double2 = makes_double2()
-let u4: uint4 = makes_uint4()
+let char2_value: char2 = makes_char2()
+let char64_value: char64 = makes_char64()
+let uchar3_value: uchar3 = makes_uchar3()
+let uchar32_value: uchar32 = makes_uchar32()
+let short3_value: short3 = makes_short3()
+let short8_value: short8 = makes_short8()
+let ushort1_value: ushort1 = makes_ushort1()
+let ushort16_value: ushort16 = makes_ushort16()
+let int3_value: int3 = makes_int3()
+let int32_value: int32 = makes_int32()
+let uint4_value: uint4 = makes_uint4()
+let uint2_value: uint2 = makes_uint2()
+let long2_value: long2 = makes_long2()
+let long8_value: long8 = makes_long8()
+let ulong4_value: ulong4 = makes_ulong4()
+let ulong1_value: ulong1 = makes_ulong1()
+let ll3_value: ll3 = makes_ll3()
+let ll8_value: ll8 = makes_ll8()
+let ull4_value: ull4 = makes_ull4()
+let ull16_value: ull16 = makes_ull16()
+let float2_value: float2 = makes_float2()
+let float3_value: float3 = makes_float3()
+let float4_value: float4 = makes_float4()
+let float8_value: float8 = makes_float8()
+let float16_value: float16 = makes_float16()
+let double2_value: double2 = makes_double2()
+let double3_value: double3 = makes_double3()
+let double4_value: double4 = makes_double4()
+let double8_value: double8 = makes_double8()
 
-takes_float4(f4)
-takes_int3(i3)
-takes_double2(d2)
-takes_uint4(u4)
+takes_char2(char2_value)
+takes_char64(char64_value)
+takes_uchar3(uchar3_value)
+takes_uchar32(uchar32_value)
+takes_short3(short3_value)
+takes_short8(short8_value)
+takes_ushort1(ushort1_value)
+takes_ushort16(ushort16_value)
+takes_int3(int3_value)
+takes_int32(int32_value)
+takes_uint4(uint4_value)
+takes_uint2(uint2_value)
+takes_long2(long2_value)
+takes_long8(long8_value)
+takes_ulong4(ulong4_value)
+takes_ulong1(ulong1_value)
+takes_ll3(ll3_value)
+takes_ll8(ll8_value)
+takes_ull4(ull4_value)
+takes_ull16(ull16_value)
+takes_float2(float2_value)
+takes_float3(float3_value)
+takes_float4(float4_value)
+takes_float8(float8_value)
+takes_float16(float16_value)
+takes_double2(double2_value)
+takes_double3(double3_value)
+takes_double4(double4_value)
+takes_double8(double8_value)
 
-// byte17 isn't available since there isn't a type in the simd module to map it to.
+// These shouldn't be imported, since there's no type to map them to.
 
-let b17 = makes_byte17 // expected-error{{unresolved identifier 'makes_byte17'}}
-takes_byte17(b17)  // expected-error{{unresolved identifier 'takes_byte17'}}
+let char17_value = makes_char17()   // expected-error{{unresolved identifier 'makes_char17'}}
+let uchar21_value = makes_uchar21() // expected-error{{unresolved identifier 'makes_uchar21'}}
+let short5_value = makes_short5()   // expected-error{{unresolved identifier 'makes_short5'}}
+let ushort6_value = makes_ushort6() // expected-error{{unresolved identifier 'makes_ushort6'}}
+let int128_value = makes_int128()   // expected-error{{unresolved identifier 'makes_int128'}}
+let uint20_value = makes_uint20()   // expected-error{{unresolved identifier 'makes_uint20'}}
+
+takes_char17(char17_value)   // expected-error{{unresolved identifier 'takes_char17'}}
+takes_uchar21(uchar21_value) // expected-error{{unresolved identifier 'takes_uchar21'}}
+takes_short5(short5_value)   // expected-error{{unresolved identifier 'takes_short5'}}
+takes_ushort6(ushort6_value) // expected-error{{unresolved identifier 'takes_ushort6'}}
+takes_int128(int128_value)   // expected-error{{unresolved identifier 'takes_int128'}}
+takes_uint20(uint20_value)   // expected-error{{unresolved identifier 'takes_uint20'}}

test/ClangImporter/simd_sans_simd.swift

@@ -1,20 +1,111 @@
-typedef int int3 __attribute__((__ext_vector_type__(3)));
-typedef float float3 __attribute__((__ext_vector_type__(3)));
-typedef float float4 __attribute__((__ext_vector_type__(4)));
-typedef double double2 __attribute__((__ext_vector_type__(2)));
-typedef unsigned int uint4 __attribute__((__ext_vector_type__(4)));
-typedef unsigned char byte17 __attribute__((__ext_vector_type__(17)));
+// Types that we should be able to import.
+typedef char __attribute__((ext_vector_type(2))) char2;
+typedef char __attribute__((ext_vector_type(64))) char64;
+typedef unsigned char __attribute__((ext_vector_type(3))) uchar3;
+typedef unsigned char __attribute__((ext_vector_type(32))) uchar32;
+typedef short __attribute__((ext_vector_type(3))) short3;
+typedef short __attribute__((ext_vector_type(8))) short8;
+typedef unsigned short __attribute__((ext_vector_type(1))) ushort1;
+typedef unsigned short __attribute__((ext_vector_type(16))) ushort16;
+typedef int __attribute__((ext_vector_type(3))) int3;
+typedef int __attribute__((ext_vector_type(32))) int32;
+typedef unsigned int __attribute__((ext_vector_type(4))) uint4;
+typedef unsigned int __attribute__((ext_vector_type(2))) uint2;
+typedef long __attribute__((ext_vector_type(2))) long2;
+typedef long __attribute__((ext_vector_type(8))) long8;
+typedef unsigned long __attribute__((ext_vector_type(4))) ulong4;
+typedef unsigned long __attribute__((ext_vector_type(1))) ulong1;
+typedef long long __attribute__((ext_vector_type(3))) ll3;
+typedef long long __attribute__((ext_vector_type(8))) ll8;
+typedef unsigned long long __attribute__((ext_vector_type(4))) ull4;
+typedef unsigned long long __attribute__((ext_vector_type(16))) ull16;
 
-int3    makes_int3(void);
-uint4   makes_uint4(void);
-float3  makes_float3(void);
-float4  makes_float4(void);
-double2 makes_double2(void);
-byte17  makes_byte17(void);
+typedef float __attribute__((ext_vector_type(2))) float2;
+typedef float __attribute__((ext_vector_type(3))) float3;
+typedef float __attribute__((ext_vector_type(4))) float4;
+typedef float __attribute__((ext_vector_type(8))) float8;
+typedef float __attribute__((ext_vector_type(16))) float16;
+typedef double __attribute__((ext_vector_type(2))) double2;
+typedef double __attribute__((ext_vector_type(3))) double3;
+typedef double __attribute__((ext_vector_type(4))) double4;
+typedef double __attribute__((ext_vector_type(8))) double8;
 
-void takes_int3(int3 x);
-void takes_uint4(uint4 x);
-void takes_float3(float3 x);
-void takes_float4(float4 x);
-void takes_double2(double2 x);
-void takes_byte17(byte17 x);
+// Types that we should not be able to import.
+typedef char __attribute__((ext_vector_type(17))) char17;
+typedef unsigned char __attribute__((ext_vector_type(21))) uchar21;
+typedef short __attribute__((ext_vector_type(5))) short5;
+typedef unsigned short __attribute__((ext_vector_type(6))) ushort6;
+typedef int __attribute__((ext_vector_type(128))) int128;
+typedef unsigned int __attribute__((ext_vector_type(20))) uint20;
+
+char2 makes_char2();
+char64 makes_char64();
+uchar3 makes_uchar3();
+uchar32 makes_uchar32();
+short3 makes_short3();
+short8 makes_short8();
+ushort1 makes_ushort1();
+ushort16 makes_ushort16();
+int3 makes_int3();
+int32 makes_int32();
+uint4 makes_uint4();
+uint2 makes_uint2();
+long2 makes_long2();
+long8 makes_long8();
+ulong4 makes_ulong4();
+ulong1 makes_ulong1();
+ll3 makes_ll3();
+ll8 makes_ll8();
+ull4 makes_ull4();
+ull16 makes_ull16();
+float2 makes_float2();
+float3 makes_float3();
+float4 makes_float4();
+float8 makes_float8();
+float16 makes_float16();
+double2 makes_double2();
+double3 makes_double3();
+double4 makes_double4();
+double8 makes_double8();
+char17 makes_char17();
+uchar21 makes_uchar21();
+short5 makes_short5();
+ushort6 makes_ushort6();
+int128 makes_int128();
+uint20 makes_uint20();
+
+takes_char2(char2);
+takes_char64(char64);
+takes_uchar3(uchar3);
+takes_uchar32(uchar32);
+takes_short3(short3);
+takes_short8(short8);
+takes_ushort1(ushort1);
+takes_ushort16(ushort16);
+takes_int3(int3);
+takes_int32(int32);
+takes_uint4(uint4);
+takes_uint2(uint2);
+takes_long2(long2);
+takes_long8(long8);
+takes_ulong4(ulong4);
+takes_ulong1(ulong1);
+takes_ll3(ll3);
+takes_ll8(ll8);
+takes_ull4(ull4);
+takes_ull16(ull16);
+takes_float2(float2);
+takes_float3(float3);
+takes_float4(float4);
+takes_float8(float8);
+takes_float16(float16);
+takes_double2(double2);
+takes_double3(double3);
+takes_double4(double4);
+takes_double8(double8);
+takes_char17(char17);
+takes_uchar21(uchar21);
+takes_short5(short5);
+takes_ushort6(ushort6);
+takes_int128(int128);
+takes_uint20(uint20);