Implement shufflevector builtin. (swiftlang#36650)

This isn't _terribly_ useful as-is, because the only constant mask you can get at from Swift at present is the zeroinitializer, but even that is quite useful for optimizing the repeating: intializer on SIMD. At some future point we should wire up generating constant masks for the .even, .odd, .high and .low properties (and also eventually make shufflevector take non-constant masks in LLVM). But this is enough to be useful, so let's get it in.

Author: stephentyrone

include/swift/AST/Builtins.def

@@ -626,6 +626,9 @@ BUILTIN_MISC_OPERATION(ExtractElement, "extractelement", "n", Special)
 /// InsertElement has type (Vector<N, T>, T, Int32) -> Vector<N, T>.
 BUILTIN_MISC_OPERATION(InsertElement, "insertelement", "n", Special)
 
+// Shufflevector has type (VecN<T>, VecN<T>, VecM<Int32>) -> VecM<T>
+BUILTIN_MISC_OPERATION(ShuffleVector, "shufflevector", "n", Special)
+
 /// StaticReport has type (Builtin.Int1, Builtin.Int1, Builtin.RawPointer) -> ()
 BUILTIN_MISC_OPERATION(StaticReport, "staticReport", "", Special)
 
@@ -655,8 +658,6 @@ BUILTIN_MISC_OPERATION(UToUCheckedTrunc, "u_to_u_checked_trunc", "n", Special)
 /// IntToFPWithOverflow has type (Integer) -> Float
 BUILTIN_MISC_OPERATION(IntToFPWithOverflow, "itofp_with_overflow", "n", Special)
 
-// FIXME: shufflevector
-
 /// zeroInitializer has type <T> () -> T
 BUILTIN_MISC_OPERATION(ZeroInitializer, "zeroInitializer", "n", Special)
 

lib/AST/Builtins.cpp

@@ -1649,6 +1649,27 @@ static ValueDecl *getInsertElementOperation(ASTContext &Context, Identifier Id,
   return getBuiltinFunction(Id, ArgElts, VecTy);
 }
 
+static ValueDecl *getShuffleVectorOperation(ASTContext &Context, Identifier Id,
+                                 Type FirstTy, Type SecondTy) {
+  // (Vector<N, T>, Vector<N, T>, Vector<M, Int32) -> Vector<M, T>
+  auto VecTy = FirstTy->getAs<BuiltinVectorType>();
+  if (!VecTy)
+    return nullptr;
+  auto ElementTy = VecTy->getElementType();
+
+  auto IndexTy = SecondTy->getAs<BuiltinVectorType>();
+  if (!IndexTy)
+    return nullptr;
+  auto IdxElTy = IndexTy->getElementType()->getAs<BuiltinIntegerType>();
+  if (!IdxElTy || !IdxElTy->isFixedWidth() || IdxElTy->getFixedWidth() != 32)
+    return nullptr;
+
+  Type ArgElts[] = { VecTy, VecTy, IndexTy };
+  Type ResultTy = BuiltinVectorType::get(Context, ElementTy,
+                                         IndexTy->getNumElements());
+  return getBuiltinFunction(Id, ArgElts, ResultTy);
+}
+
 static ValueDecl *getStaticReportOperation(ASTContext &Context, Identifier Id) {
   auto BoolTy = BuiltinIntegerType::get(1, Context);
   auto MessageTy = Context.TheRawPointerType;
@@ -2594,6 +2615,10 @@ ValueDecl *swift::getBuiltinValueDecl(ASTContext &Context, Identifier Id) {
   case BuiltinValueKind::InsertElement:
     if (Types.size() != 3) return nullptr;
     return getInsertElementOperation(Context, Id, Types[0], Types[1], Types[2]);
+      
+  case BuiltinValueKind::ShuffleVector:
+    if (Types.size() != 2) return nullptr;
+    return getShuffleVectorOperation(Context, Id, Types[0], Types[1]);
 
   case BuiltinValueKind::StaticReport:
     if (!Types.empty()) return nullptr;

lib/IRGen/GenBuiltin.cpp

@@ -835,6 +835,16 @@ if (Builtin.ID == BuiltinValueKind::id) { \
     out.add(IGF.Builder.CreateInsertElement(vector, newValue, index));
     return;
   }
+  
+  if (Builtin.ID == BuiltinValueKind::ShuffleVector) {
+    using namespace llvm;
+
+    auto dict0 = args.claimNext();
+    auto dict1 = args.claimNext();
+    auto index = args.claimNext();
+    out.add(IGF.Builder.CreateShuffleVector(dict0, dict1, index));
+    return;
+  }
 
   if (Builtin.ID == BuiltinValueKind::SToSCheckedTrunc ||
       Builtin.ID == BuiltinValueKind::UToUCheckedTrunc ||

lib/SIL/IR/OperandOwnership.cpp

@@ -709,6 +709,7 @@ BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, SToUCheckedTrunc)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, Expect)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, Shl)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, GenericShl)
+BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, ShuffleVector)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, Sizeof)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, StaticReport)
 BUILTIN_OPERAND_OWNERSHIP(InstantaneousUse, Strideof)

lib/SIL/IR/ValueOwnership.cpp

@@ -569,6 +569,7 @@ UNOWNED_OR_NONE_DEPENDING_ON_RESULT(CmpXChg)
 UNOWNED_OR_NONE_DEPENDING_ON_RESULT(AtomicLoad)
 UNOWNED_OR_NONE_DEPENDING_ON_RESULT(ExtractElement)
 UNOWNED_OR_NONE_DEPENDING_ON_RESULT(InsertElement)
+UNOWNED_OR_NONE_DEPENDING_ON_RESULT(ShuffleVector)
 UNOWNED_OR_NONE_DEPENDING_ON_RESULT(ZeroInitializer)
 #undef UNOWNED_OR_NONE_DEPENDING_ON_RESULT
 

lib/SILOptimizer/Transforms/AccessEnforcementReleaseSinking.cpp

@@ -120,6 +120,7 @@ static bool isBarrier(SILInstruction *inst) {
     case BuiltinValueKind::OnFastPath:
     case BuiltinValueKind::ExtractElement:
     case BuiltinValueKind::InsertElement:
+    case BuiltinValueKind::ShuffleVector:
     case BuiltinValueKind::StaticReport:
     case BuiltinValueKind::AssertConf:
     case BuiltinValueKind::StringObjectOr:

test/IRGen/builtins.swift

@@ -172,6 +172,17 @@ func vector_bitcast_test_ii(_ src: Builtin.Int16) -> Builtin.Vec16xInt8 {
   return Builtin.sext_Vec16xInt1_Vec16xInt8(v16x1)   // CHECK: sext
 }
 
+func shufflevector_test(_ src: Builtin.FPIEEE32) -> Builtin.Vec4xFPIEEE32 {
+  // CHECK: insertelement <4 x float> zeroinitializer
+  // CHECK: shufflevector <4 x float>
+  let vec = Builtin.insertelement_Vec4xFPIEEE32_FPIEEE32_Int32(
+    Builtin.zeroInitializer(), src, Builtin.zeroInitializer()
+  )
+  return Builtin.shufflevector_Vec4xFPIEEE32_Vec4xInt32(
+    vec, vec, Builtin.zeroInitializer()
+  )
+}
+
 func intrinsic_test(_ i32: inout Builtin.Int32, i16: inout Builtin.Int16,
                     _ v8i16: Builtin.Vec8xInt16) {
   // CHECK: intrinsic_test