[builtin] Implement polymorphic builtins for all BUILTIN_BINARY_OPERATIONs.

TLDR: This patch introduces a new kind of builtin, "a polymorphic builtin". One
calls it like any other builtin, e.x.:

```
Builtin.generic_add(x, y)
```

but it has a contract: eventually
At constant propagation time, the optimizer attempts to specialize the
generic_add to the conc

DISCUSSION
----------

Today there are polymorphic like instructions in LLVM-IR. Yet, at the
swift and SIL level we represent these operations instead as Builtins whose
names are resolved by splatting the builtin into the name. For example, adding
two things in LLVM:

```
  %2 = add i64 %0, %1
  %2 = add <2 x i64> %0, %1
  %2 = add <4 x i64> %0, %1
  %2 = add <8 x i64> %0, %1
```

Each of the add operations are done by the same polymorphic instruction. In
constrast, we splat out these Builtins in swift today, i.e.:

```
let x, y: Builtin.Int32
Builtin.add_Int32(x, y)
let x, y: Builtin.Vec2xInt32
Builtin.add_Vec2xInt32(x, y)
...
```

In SIL, we translate these verbatim and then IRGen just lowers them to the
appropriate polymorphic instruction. Beyond being verbose, these prevent these
Builtins (which need static types) from being used in polymorphic contexts.

These operations in Swift look like:

Builtin.add_Vec2

Author: gottesmm

include/swift/AST/Builtins.def

@@ -51,30 +51,97 @@ BUILTIN_CAST_OR_BITCAST_OPERATION(SExtOrBitCast,  "sextOrBitCast",  "n")
 #undef BUILTIN_CAST_OR_BITCAST_OPERATION
 
 /// Binary operations have type (T,T) -> T.
+///
+/// We define two different sorts of operations varying when T is static,
+/// specifically:
+///
+/// 1. Overloaded statically typed operations. E.x:
+///
+///       builtin "add_Vec4xInt32"(Vec4xInt32, Vec4xInt32) : Vec4xInt32.
+///
+/// 2. Polymorphic typed operations that are valid only in raw SIL. By the time
+///    diagnostic constant propagation runs, these must have as its operand a
+///    fully specialized type. If the builtin has a type that is not one of its
+///    overloaded types, diagnostic constant propagation will emit a diagnostic
+///    saying the builtin's type has not been fully resolved. Otherwise,
+///    diagnostic constant propagation will transform the builtin to the
+///    relevant static overloaded builtin form. E.x.:
+///
+///       builtin "add"(Self, Self) : Self // *error*
+///
+///         OR
+///
+///       builtin "generic_add"(Vec4xInt32, Vec4xInt32) : Vec4xInt32
+///         ->
+///       builtin "add_Vec4xInt32"(Vec4xInt32, Vec4xInt32) : Vec4xInt32
+///
+/// NOTE: If a polymorphic typed operation is not static by the time guaranteed
+/// constant propagation runs, we emit a diagnostic to inform the user (who is
+/// assumed to be an expert user) to tell them the value was unspecialized. The
+/// typical way this specialization occurs today is via transparent inlining
+/// since the transparent inliner devirtualizes and specializes as it goes. Of
+/// course this means mandatory inlining must /always/ occur before diagnostic
+/// constant propagation.
+///
+/// NOTE: Often times the builtin infrastructure wants to treat all
+/// binary operation builtins generic or not the same way. To ensure
+/// we support all use cases in the compiler, we do not declare the
+/// operations as part of this builtin since often times this macro is
+/// used to generic code. Instead, we stamp this out using the
+/// overloaded_static, polymorphic, and all suffixed operations.
 #ifndef BUILTIN_BINARY_OPERATION
-#define BUILTIN_BINARY_OPERATION(Id, Name, Attrs, Overload) \
-          BUILTIN(Id, Name, Attrs)
+#define BUILTIN_BINARY_OPERATION(Id, Name, Attrs) BUILTIN(Id, Name, Attrs)
 #endif
-BUILTIN_BINARY_OPERATION(Add,     "add",      "n", IntegerOrVector)
-BUILTIN_BINARY_OPERATION(FAdd,    "fadd",     "n", FloatOrVector)
-BUILTIN_BINARY_OPERATION(And,     "and",      "n", IntegerOrVector)
-BUILTIN_BINARY_OPERATION(AShr,    "ashr",     "n", IntegerOrVector)
-BUILTIN_BINARY_OPERATION(LShr,    "lshr",     "n", IntegerOrVector)
-BUILTIN_BINARY_OPERATION(Or,      "or",       "n", IntegerOrVector)
-BUILTIN_BINARY_OPERATION(FDiv,    "fdiv",     "n", FloatOrVector)
-BUILTIN_BINARY_OPERATION(Mul,     "mul",      "n", IntegerOrVector)
-BUILTIN_BINARY_OPERATION(FMul,    "fmul",     "n", FloatOrVector)
-BUILTIN_BINARY_OPERATION(SDiv,    "sdiv",     "n", IntegerOrVector)
-BUILTIN_BINARY_OPERATION(ExactSDiv, "sdiv_exact", "n", IntegerOrVector)
-BUILTIN_BINARY_OPERATION(Shl,     "shl",      "n", IntegerOrVector)
-BUILTIN_BINARY_OPERATION(SRem,    "srem",     "n", IntegerOrVector)
-BUILTIN_BINARY_OPERATION(Sub,     "sub",      "n", IntegerOrVector)
-BUILTIN_BINARY_OPERATION(FSub,    "fsub",     "n", FloatOrVector)
-BUILTIN_BINARY_OPERATION(UDiv,    "udiv",     "n", IntegerOrVector)
-BUILTIN_BINARY_OPERATION(ExactUDiv, "udiv_exact", "n", IntegerOrVector)
-BUILTIN_BINARY_OPERATION(URem,    "urem",     "n", Integer)
-BUILTIN_BINARY_OPERATION(FRem,    "frem",     "n", FloatOrVector)
-BUILTIN_BINARY_OPERATION(Xor,     "xor",      "n", IntegerOrVector)
+
+#ifdef BUILTIN_BINARY_OPERATION_GENERIC_HELPER_STR
+#error "Do not define BUILTIN_BINARY_OPERATION_GENERIC_HELPER_STR before including this .def file"
+#endif
+
+#define BUILTIN_BINARY_OPERATION_GENERIC_HELPER_STR(NAME) #NAME
+
+#ifndef BUILTIN_BINARY_OPERATION_OVERLOADED_STATIC
+#define BUILTIN_BINARY_OPERATION_OVERLOADED_STATIC(Id, Name, Attrs, Overload) \
+  BUILTIN_BINARY_OPERATION(Id, Name, Attrs)
+#endif
+
+#ifndef BUILTIN_BINARY_OPERATION_POLYMORPHIC
+#define BUILTIN_BINARY_OPERATION_POLYMORPHIC(Id, Name, Attrs) \
+  BUILTIN_BINARY_OPERATION(Id, Name, Attrs)
+#endif
+
+// TODO: This needs a better name. We stringify generic_ in *_{OVERLOADED_STATIC,POLYMORPHIC}
+#ifndef BUILTIN_BINARY_OPERATION_ALL
+#define BUILTIN_BINARY_OPERATION_ALL(Id, Name, Attrs, Overload) \
+  BUILTIN_BINARY_OPERATION_OVERLOADED_STATIC(Id, BUILTIN_BINARY_OPERATION_GENERIC_HELPER_STR(Name), Attrs, Overload) \
+  BUILTIN_BINARY_OPERATION_POLYMORPHIC(Generic##Id, BUILTIN_BINARY_OPERATION_GENERIC_HELPER_STR(generic_##Name), Attrs)
+#endif
+
+// NOTE: Here we need our name field to be bare. We stringify them as
+// appropriately in BUILTIN_BINARY_OPERATION_{OVERLOADED_STATIC,POLYMORPHIC}.
+BUILTIN_BINARY_OPERATION_ALL(Add,     add,      "n", IntegerOrVector)
+BUILTIN_BINARY_OPERATION_ALL(FAdd,    fadd,     "n", FloatOrVector)
+BUILTIN_BINARY_OPERATION_ALL(And,     and,      "n", IntegerOrVector)
+BUILTIN_BINARY_OPERATION_ALL(AShr,    ashr,     "n", IntegerOrVector)
+BUILTIN_BINARY_OPERATION_ALL(LShr,    lshr,     "n", IntegerOrVector)
+BUILTIN_BINARY_OPERATION_ALL(Or,      or,       "n", IntegerOrVector)
+BUILTIN_BINARY_OPERATION_ALL(FDiv,    fdiv,     "n", FloatOrVector)
+BUILTIN_BINARY_OPERATION_ALL(Mul,     mul,      "n", IntegerOrVector)
+BUILTIN_BINARY_OPERATION_ALL(FMul,    fmul,     "n", FloatOrVector)
+BUILTIN_BINARY_OPERATION_ALL(SDiv,    sdiv,     "n", IntegerOrVector)
+BUILTIN_BINARY_OPERATION_ALL(ExactSDiv, sdiv_exact, "n", IntegerOrVector)
+BUILTIN_BINARY_OPERATION_ALL(Shl,     shl,      "n", IntegerOrVector)
+BUILTIN_BINARY_OPERATION_ALL(SRem,    srem,     "n", IntegerOrVector)
+BUILTIN_BINARY_OPERATION_ALL(Sub,     sub,      "n", IntegerOrVector)
+BUILTIN_BINARY_OPERATION_ALL(FSub,    fsub,     "n", FloatOrVector)
+BUILTIN_BINARY_OPERATION_ALL(UDiv,    udiv,     "n", IntegerOrVector)
+BUILTIN_BINARY_OPERATION_ALL(ExactUDiv, udiv_exact, "n", IntegerOrVector)
+BUILTIN_BINARY_OPERATION_ALL(URem,    urem,     "n", Integer)
+BUILTIN_BINARY_OPERATION_ALL(FRem,    frem,     "n", FloatOrVector)
+BUILTIN_BINARY_OPERATION_ALL(Xor,     xor,      "n", IntegerOrVector)
+#undef BUILTIN_BINARY_OPERATION_ALL
+#undef BUILTIN_BINARY_OPERATION_POLYMORPHIC
+#undef BUILTIN_BINARY_OPERATION_OVERLOADED_STATIC
+#undef BUILTIN_BINARY_OPERATION_GENERIC_HELPER_STR
 #undef BUILTIN_BINARY_OPERATION
 
 /// These builtins are analogous the similarly named llvm intrinsics. The

include/swift/AST/Builtins.h

@@ -83,6 +83,11 @@ enum class BuiltinValueKind {
 #include "swift/AST/Builtins.def"
 };
 
+/// Returns true if this is a polymorphic builtin that is only valid
+/// in raw sil and thus must be resolved to have concrete types by the
+/// time we are in canonical SIL.
+bool isPolymorphicBuiltin(BuiltinValueKind Id);
+
 /// Decode the type list of a builtin (e.g. mul_Int32) and return the base
 /// name (e.g. "mul").
 StringRef getBuiltinBaseName(ASTContext &C, StringRef Name,

include/swift/Basic/STLExtras.h

@@ -874,6 +874,12 @@ using all_true =
 template <class... Ts>
 using are_all_compound = all_true<std::is_compound<Ts>::value...>;
 
+/// Overload for producing optionals of type T where c++ type inference does not
+/// let you consider optional a subtype of T.
+template <typename T> Optional<T> make_optional(const T &t) {
+  return Optional<T>(t);
+}
+
 } // end namespace swift
 
 #endif // SWIFT_BASIC_INTERLEAVE_H

include/swift/SIL/InstructionUtils.h

@@ -142,6 +142,38 @@ bool onlyUsedByAssignByWrapper(PartialApplyInst *PAI);
 void findClosuresForFunctionValue(SILValue V,
                                   TinyPtrVector<PartialApplyInst *> &results);
 
+/// Given a polymorphic builtin \p bi that may be generic and thus have in/out
+/// params, stash all of the information needed for either specializing while
+/// inlining or propagating the type in constant propagation.
+///
+/// NOTE: If we perform this transformation, our builtin will no longer have any
+/// substitutions since we only substitute to concrete static overloads.
+struct PolymorphicBuiltinSpecializedOverloadInfo {
+  Identifier staticOverloadIdentifier;
+  SmallVector<SILType, 8> argTypes;
+  SILType resultType;
+  bool hasOutParam = false;
+
+#ifndef NDEBUG
+private:
+  bool isInitialized = false;
+#endif
+
+public:
+  PolymorphicBuiltinSpecializedOverloadInfo() = default;
+
+  bool init(SILModule &mod, BuiltinValueKind builtinKind,
+            ArrayRef<SILType> oldOperandTypes, SILType oldResultType);
+
+  bool init(BuiltinInst *bi);
+};
+
+/// Given a polymorphic builtin \p bi, analyze its types and create a builtin
+/// for the static overload that the builtin corresponds to. If \p bi is not a
+/// polymorphic builtin or does not have any available overload for these types,
+/// return SILValue().
+SILValue getStaticOverloadForSpecializedPolymorphicBuiltin(BuiltinInst *bi);
+
 } // end namespace swift
 
 #endif

include/swift/SIL/PatternMatch.h

@@ -649,7 +649,7 @@ using BuiltinApplyTy = typename Apply_match<BuiltinValueKind, Tys...>::Ty;
 #define BUILTIN_CAST_OR_BITCAST_OPERATION(Id, Name, Attrs) \
   BUILTIN_UNARY_OP_MATCH_WITH_ARG_MATCHER(Id, Id)
 
-#define BUILTIN_BINARY_OPERATION(Id, Name, Attrs, Overload) \
+#define BUILTIN_BINARY_OPERATION(Id, Name, Attrs)                              \
   BUILTIN_BINARY_OP_MATCH_WITH_ARG_MATCHER(Id, Id)
 
 #define BUILTIN_BINARY_PREDICATE(Id, Name, Attrs, Overload) \

include/swift/SIL/SILInstruction.h

@@ -523,6 +523,16 @@ class SILInstruction
     getAllOperands()[Num1].swap(getAllOperands()[Num2]);
   }
 
+private:
+  /// Predicate used to filter OperandTypeRange.
+  struct OperandToType;
+
+public:
+  using OperandTypeRange =
+      OptionalTransformRange<ArrayRef<Operand>, OperandToType>;
+  // NOTE: We always skip type dependent operands.
+  OperandTypeRange getOperandTypes() const;
+
   /// Return the list of results produced by this instruction.
   bool hasResults() const { return !getResults().empty(); }
   SILInstructionResultArray getResults() const { return getResultsImpl(); }
@@ -700,6 +710,22 @@ SILInstruction::getOperandValues(bool skipTypeDependentOperands) const
                            OperandToValue(*this, skipTypeDependentOperands));
 }
 
+struct SILInstruction::OperandToType {
+  const SILInstruction &i;
+
+  OperandToType(const SILInstruction &i) : i(i) {}
+
+  Optional<SILType> operator()(const Operand &use) const {
+    if (i.isTypeDependentOperand(use))
+      return None;
+    return use.get()->getType();
+  }
+};
+
+inline auto SILInstruction::getOperandTypes() const -> OperandTypeRange {
+  return OperandTypeRange(getAllOperands(), OperandToType(*this));
+}
+
 inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                                      const SILInstruction &I) {
   I.print(OS);
@@ -3009,7 +3035,7 @@ class BuiltinInst final
 
   /// Looks up the BuiltinKind of this builtin. Returns None if this is
   /// not a builtin.
-  llvm::Optional<BuiltinValueKind> getBuiltinKind() const {
+  Optional<BuiltinValueKind> getBuiltinKind() const {
     auto I = getBuiltinInfo();
     if (I.ID == BuiltinValueKind::None)
       return None;

lib/AST/Builtins.cpp

@@ -1181,6 +1181,15 @@ static ValueDecl *getOnceOperation(ASTContext &Context,
   }
 }
 
+static ValueDecl *getPolymorphicBinaryOperation(ASTContext &ctx,
+                                                Identifier id) {
+  BuiltinGenericSignatureBuilder builder(ctx);
+  builder.addParameter(makeGenericParam());
+  builder.addParameter(makeGenericParam());
+  builder.setResult(makeGenericParam());
+  return builder.build(id);
+}
+
 /// An array of the overloaded builtin kinds.
 static const OverloadedBuiltinKind OverloadedBuiltinKinds[] = {
   OverloadedBuiltinKind::None,
@@ -1191,8 +1200,10 @@ static const OverloadedBuiltinKind OverloadedBuiltinKinds[] = {
    OverloadedBuiltinKind::Special,
 #define BUILTIN_CAST_OR_BITCAST_OPERATION(id, attrs, name) \
    OverloadedBuiltinKind::Special,
-#define BUILTIN_BINARY_OPERATION(id, name, attrs, overload) \
-   OverloadedBuiltinKind::overload,
+#define BUILTIN_BINARY_OPERATION_OVERLOADED_STATIC(id, name, attrs, overload)  \
+  OverloadedBuiltinKind::overload,
+#define BUILTIN_BINARY_OPERATION_POLYMORPHIC(id, name, attrs)                  \
+  OverloadedBuiltinKind::Special,
 #define BUILTIN_BINARY_OPERATION_WITH_OVERFLOW(id, name, _, attrs, overload) \
    OverloadedBuiltinKind::overload,
 #define BUILTIN_BINARY_PREDICATE(id, name, attrs, overload) \
@@ -1777,11 +1788,22 @@ ValueDecl *swift::getBuiltinValueDecl(ASTContext &Context, Identifier Id) {
     return getEndUnpairedAccessOperation(Context, Id);
 
 #define BUILTIN(id, name, Attrs)
-#define BUILTIN_BINARY_OPERATION(id, name, attrs, overload)  case BuiltinValueKind::id:
+#define BUILTIN_BINARY_OPERATION(id, name, attrs)
+#define BUILTIN_BINARY_OPERATION_OVERLOADED_STATIC(id, name, attrs, overload)  \
+  case BuiltinValueKind::id:
 #include "swift/AST/Builtins.def"
     if (Types.size() != 1) return nullptr;
     return getBinaryOperation(Id, Types[0]);
 
+#define BUILTIN(id, name, attrs)
+#define BUILTIN_BINARY_OPERATION(id, name, attrs)
+#define BUILTIN_BINARY_OPERATION_POLYMORPHIC(id, name, attrs)                  \
+  case BuiltinValueKind::id:
+#include "swift/AST/Builtins.def"
+    if (!Types.empty())
+      return nullptr;
+    return getPolymorphicBinaryOperation(Context, Id);
+
 #define BUILTIN(id, name, Attrs)
 #define BUILTIN_BINARY_OPERATION_WITH_OVERFLOW(id, name, _, attrs, overload)  case BuiltinValueKind::id:
 #include "swift/AST/Builtins.def"
@@ -2034,6 +2056,21 @@ StringRef swift::getBuiltinName(BuiltinValueKind ID) {
   llvm_unreachable("bad BuiltinValueKind");
 }
 
+bool swift::isPolymorphicBuiltin(BuiltinValueKind id) {
+  switch (id) {
+  case BuiltinValueKind::None:
+    llvm_unreachable("no builtin kind");
+#define BUILTIN(Id, Name, Attrs)                                               \
+  case BuiltinValueKind::Id:                                                   \
+    return false;
+#define BUILTIN_BINARY_OPERATION_POLYMORPHIC(Id, Name, Attrs)                  \
+  case BuiltinValueKind::Id:                                                   \
+    return true;
+#include "swift/AST/Builtins.def"
+  }
+  llvm_unreachable("bad BuiltinValueKind");
+}
+
 BuiltinTypeKind BuiltinType::getBuiltinTypeKind() const {
   // If we do not have a vector or an integer our job is easy.
   return BuiltinTypeKind(std::underlying_type<TypeKind>::type(getKind()));

lib/IRGen/GenBuiltin.cpp

@@ -305,14 +305,18 @@ void irgen::emitBuiltinCall(IRGenFunction &IGF, const BuiltinInfo &Builtin,
   if (Builtin.ID == BuiltinValueKind::id) \
     return emitCastOrBitCastBuiltin(IGF, resultType, out, args, \
                                     BuiltinValueKind::id);
-  
-#define BUILTIN_BINARY_OPERATION(id, name, attrs, overload) \
-  if (Builtin.ID == BuiltinValueKind::id) { \
-    llvm::Value *lhs = args.claimNext(); \
-    llvm::Value *rhs = args.claimNext(); \
-    llvm::Value *v = IGF.Builder.Create##id(lhs, rhs); \
-    return out.add(v); \
+
+#define BUILTIN_BINARY_OPERATION_OVERLOADED_STATIC(id, name, attrs, overload)  \
+  if (Builtin.ID == BuiltinValueKind::id) {                                    \
+    llvm::Value *lhs = args.claimNext();                                       \
+    llvm::Value *rhs = args.claimNext();                                       \
+    llvm::Value *v = IGF.Builder.Create##id(lhs, rhs);                         \
+    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 should have been "    \
+         "lowered by IRGenPrepare");
 
 #define BUILTIN_RUNTIME_CALL(id, name, attrs)                                  \
   if (Builtin.ID == BuiltinValueKind::id) {                                    \