[polymorphic-builtin] Rather than asserting in IRGen if we see a builtin that was not specialized, turn the builtin into a trap.

I forgot about this part of the design when I was working on this. To ensure
that the whole design works as expected, I included a small end-to-end test
using an experimental design for simd that uses polymorphic builtins that test
this functionally.

NOTE: The experimental design is only intended to exercise the code functionally.

rdar://48248417

Author: gottesmm

lib/IRGen/GenBuiltin.cpp

@@ -314,9 +314,14 @@ void irgen::emitBuiltinCall(IRGenFunction &IGF, const BuiltinInfo &Builtin,
     return out.add(v);                                                         \
   }
 #define BUILTIN_BINARY_OPERATION_POLYMORPHIC(id, name, attrs)                  \
-  assert(Builtin.ID != BuiltinValueKind::id &&                                 \
-         "This builtin should never be seen by IRGen. It is invalid in "       \
-         "Lowered sil");
+  if (Builtin.ID == BuiltinValueKind::id) {                                    \
+    /* This builtin must be guarded so that dynamically it is never called. */ \
+    IGF.emitTrap("invalid use of polymorphic builtin", /*Unreachable*/ false); \
+    auto returnValue = llvm::UndefValue::get(IGF.IGM.Int8PtrTy);               \
+    /* Consume the arguments of the builtin. */                                \
+    (void)args.claimAll();                                                     \
+    return out.add(returnValue);                                               \
+  }
 
 #define BUILTIN_RUNTIME_CALL(id, name, attrs)                                  \
   if (Builtin.ID == BuiltinValueKind::id) {                                    \

lib/SIL/SILVerifier.cpp

@@ -1654,10 +1654,6 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
       verifyLLVMIntrinsic(BI, BI->getIntrinsicInfo().ID);
       return;
     }
-
-    require(BI->getModule().getStage() != SILStage::Lowered ||
-                !isPolymorphicBuiltin(*BI->getBuiltinKind()),
-            "Polymorphic builtins are illegal in lowered SIL?!");
   }
 
   void checkFunctionRefBaseInst(FunctionRefBaseInst *FRI) {

test/IRGen/polymorphic_builtins.swift

@@ -0,0 +1,50 @@
+// This line tests that IRGen is properly turning the unspecialized builtins
+// into traps.
+//
+// RUN: %target-swift-frontend -emit-ir -parse-as-library -parse-stdlib %s | %FileCheck %s
+
+// Make sure we are not eliminating these builtins before IRGen runs. As part of
+// the builtin's contract, we expect IRGen to convert them to traps, not
+// anything before.
+//
+// RUN: %target-swift-frontend -emit-sil -parse-as-library -parse-stdlib %s | %FileCheck --check-prefix=SIL %s
+
+import Swift
+
+// SIL-LABEL: sil [transparent] [serialized] @$s20polymorphic_builtins11_isConcrete4typeSbxm_tlF : $@convention(thin) <T> (@thick T.Type) -> Bool {
+// SIL: builtin "isConcrete"<T>({{%[0-9]*}} : $@thick T.Type) : $Builtin.Int1
+// SIL: // end sil function '$s20polymorphic_builtins11_isConcrete4typeSbxm_tlF'
+@_transparent
+public func _isConcrete<T>(type: T.Type) -> Bool {
+  return Bool(_builtinBooleanLiteral: Builtin.isConcrete(type))
+}
+
+// SIL-LABEL: sil [transparent] [serialized] @$s20polymorphic_builtins41calleeAddVectorsGenericTransparentGuardedyxx_xtlF : $@convention(thin) <T> (@in_guaranteed T, @in_guaranteed T) -> @out T {
+// SIL: builtin "isConcrete"<T>({{%[0-9]*}} : $@thick T.Type) : $Builtin.Int1
+// SIL: builtin "generic_add"<T>(
+// SIL: } // end sil function '$s20polymorphic_builtins41calleeAddVectorsGenericTransparentGuardedyxx_xtlF'
+
+// CHECK-LABEL: define{{( dllexport)?}}{{( protected)?}} swiftcc void @"$s20polymorphic_builtins41calleeAddVectorsGenericTransparentGuardedyxx_xtlF"(
+// CHECK: br i1 false, label %[[CONCRETE_LABEL:[0-9][0-9]*]], label %[[NON_CONCRETE_LABEL:[0-9][0-9]*]]
+//
+// CHECK: <label>:[[CONCRETE_LABEL]]:
+// CHECK:   call void @llvm.trap()
+// CHECK:   br label %[[EPILOGUE_BLOCK:[0-9][0-9]*]]
+//
+// CHECK: <label>:[[NON_CONCRETE_LABEL]]
+// CHECK:   br label %[[EPILOGUE_BLOCK]]
+///
+// CHECK: <label>:[[EPILOGUE_BLOCK]]:
+// CHECK:   ret void
+// CHECK-NEXT: }
+@_transparent
+public func calleeAddVectorsGenericTransparentGuarded<T>(_ lhs: T, _ rhs: T) -> T {
+  if _isConcrete(T.self) {
+    return Builtin.generic_add(lhs, rhs)
+  }
+  return lhs
+}
+
+public func callerAddVectorsGenericTransparent(_ lhs: Builtin.Vec4xInt32, _ rhs: Builtin.Vec4xInt32) -> Builtin.Vec4xInt32 {
+  return calleeAddVectorsGenericTransparentGuarded(lhs, rhs)
+}