Merge remote-tracking branch 'origin/master' into master-next

Author: swift-ci

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

@@ -4110,6 +4110,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);

test/Inputs/clang-importer-sdk/usr/include/simd.h

@@ -18,10 +18,9 @@ if not os.path.exists(os.path.join(swift_src_root, '.git')):
 returncode = subprocess.call(
     ['git', '-C', swift_src_root, 'grep', r'\bDEBUG[(]'])
 if returncode == 0:  # We found some DEBUG in there.
-    print('\n'
-          '*** The DEBUG'
-          '(...) macro is being renamed to LLVM_DEBUG(...);\n'
-          '*** please use that instead.')
+    print("""
+*** The {DEBUG}(...) macro is being renamed to LLVM_DEBUG(...);
+*** please use that instead.""".format(DEBUG='DEBUG'))
     sys.exit(1)
 
 # If you see a failure in this test, that means you introduced a use of the