---

yaml
---
r: 348606
b: refs/heads/master
c: 4a0430b
h: refs/heads/master

Author: swift-ci

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: d675268238e951b61a63197e9c0a6a24133327cd
+refs/heads/master: 4a0430b79c5a4fb485219f2e21a8eeb2455e906c
 refs/heads/master-next: 203b3026584ecad859eb328b2e12490099409cd5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/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(SILFunction *fn, 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

trunk/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);
@@ -3007,7 +3033,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;

trunk/lib/SIL/InstructionUtils.cpp

@@ -14,10 +14,12 @@
 #include "swift/SIL/InstructionUtils.h"
 #include "swift/AST/SubstitutionMap.h"
 #include "swift/Basic/NullablePtr.h"
+#include "swift/Basic/STLExtras.h"
 #include "swift/SIL/DebugUtils.h"
 #include "swift/SIL/Projection.h"
 #include "swift/SIL/SILArgument.h"
 #include "swift/SIL/SILBasicBlock.h"
+#include "swift/SIL/SILBuilder.h"
 #include "swift/SIL/SILVisitor.h"
 
 using namespace swift;
@@ -530,3 +532,146 @@ void swift::findClosuresForFunctionValue(
     // Ignore other unrecognized values that feed this applied argument.
   }
 }
+
+bool PolymorphicBuiltinSpecializedOverloadInfo::init(
+    SILFunction *fn, BuiltinValueKind builtinKind,
+    ArrayRef<SILType> oldOperandTypes, SILType oldResultType) {
+#ifndef NDEBUG
+  assert(!isInitialized && "Expected uninitialized info");
+  SWIFT_DEFER { isInitialized = true; };
+#endif
+  if (!isPolymorphicBuiltin(builtinKind))
+    return false;
+
+  // Ok, at this point we know that we have a true polymorphic builtin. See if
+  // we have an overload for its current operand type.
+  StringRef name = getBuiltinName(builtinKind);
+  StringRef prefix = "generic_";
+  assert(name.startswith(prefix) &&
+         "Invalid polymorphic builtin name! Prefix should be Generic$OP?!");
+  SmallString<32> staticOverloadName;
+  staticOverloadName.append(name.drop_front(prefix.size()));
+
+  // If our first argument is an address, we know we have an indirect @out
+  // parameter by convention since all of these polymorphic builtins today never
+  // take indirect parameters without an indirect out result parameter. We stash
+  // this information and validate that if we have an out param, that our result
+  // is equal to the empty tuple type.
+  if (oldOperandTypes[0].isAddress()) {
+    if (oldResultType != fn->getModule().Types.getEmptyTupleType())
+      return false;
+
+    hasOutParam = true;
+    SILType firstType = oldOperandTypes.front();
+
+    // We only handle polymorphic builtins with trivial types today.
+    if (!firstType.is<BuiltinType>() || !firstType.isTrivial(*fn)) {
+      return false;
+    }
+
+    resultType = firstType.getObjectType();
+    oldOperandTypes = oldOperandTypes.drop_front();
+  } else {
+    resultType = oldResultType;
+  }
+
+  // Then go through all of our values and bail if any after substitution are
+  // not concrete builtin types. Otherwise, stash each of them in the argTypes
+  // array as objects. We will convert them as appropriate.
+  for (SILType ty : oldOperandTypes) {
+    // If after specialization, we do not have a trivial builtin type, bail.
+    if (!ty.is<BuiltinType>() || !ty.isTrivial(*fn)) {
+      return false;
+    }
+
+    // Otherwise, we have an object builtin type ready to go.
+    argTypes.push_back(ty.getObjectType());
+  }
+
+  // Ok, we have all builtin types. Infer the underlying polymorphic builtin
+  // name form our first argument.
+  CanBuiltinType builtinType = argTypes.front().getAs<BuiltinType>();
+  SmallString<32> builtinTypeNameStorage;
+  StringRef typeName = builtinType->getTypeName(builtinTypeNameStorage, false);
+  staticOverloadName.append("_");
+  staticOverloadName.append(typeName);
+
+  auto &ctx = fn->getASTContext();
+  staticOverloadIdentifier = ctx.getIdentifier(staticOverloadName);
+  return true;
+}
+
+bool PolymorphicBuiltinSpecializedOverloadInfo::init(BuiltinInst *bi) {
+#ifndef NDEBUG
+  assert(!isInitialized && "Can not init twice?!");
+  SWIFT_DEFER { isInitialized = true; };
+#endif
+
+  // First quickly make sure we have a /real/ BuiltinValueKind, not an intrinsic
+  // or None.
+  auto kind = bi->getBuiltinKind();
+  if (!kind)
+    return false;
+
+  SmallVector<SILType, 8> oldOperandTypes;
+  copy(bi->getOperandTypes(), std::back_inserter(oldOperandTypes));
+  assert(bi->getNumResults() == 1 &&
+         "We expect a tuple here instead of real args");
+  SILType oldResultType = bi->getResult(0)->getType();
+  return init(bi->getFunction(), *kind, oldOperandTypes, oldResultType);
+}
+
+SILValue
+swift::getStaticOverloadForSpecializedPolymorphicBuiltin(BuiltinInst *bi) {
+
+  PolymorphicBuiltinSpecializedOverloadInfo info;
+  if (!info.init(bi))
+    return SILValue();
+
+  SmallVector<SILValue, 8> rawArgsData;
+  copy(bi->getOperandValues(), std::back_inserter(rawArgsData));
+
+  SILValue result = bi->getResult(0);
+  MutableArrayRef<SILValue> rawArgs = rawArgsData;
+
+  if (info.hasOutParam) {
+    result = rawArgs.front();
+    rawArgs = rawArgs.drop_front();
+  }
+
+  assert(bi->getNumResults() == 1 &&
+         "We assume that builtins have a single result today. If/when this "
+         "changes, this code needs to be updated");
+
+  SILBuilderWithScope builder(bi);
+
+  // Ok, now we know that we can convert this to our specialized
+  // builtin. Prepare the arguments for the specialized value, loading the
+  // values if needed and storing the result into an out parameter if needed.
+  //
+  // NOTE: We only support polymorphic builtins with trivial types today, so we
+  // use load/store trivial as a result.
+  SmallVector<SILValue, 8> newArgs;
+  for (SILValue arg : rawArgs) {
+    if (arg->getType().isObject()) {
+      newArgs.push_back(arg);
+      continue;
+    }
+
+    SILValue load = builder.emitLoadValueOperation(
+        bi->getLoc(), arg, LoadOwnershipQualifier::Trivial);
+    newArgs.push_back(load);
+  }
+
+  BuiltinInst *newBI =
+      builder.createBuiltin(bi->getLoc(), info.staticOverloadIdentifier,
+                            info.resultType, {}, newArgs);
+
+  // If we have an out parameter initialize it now.
+  if (info.hasOutParam) {
+    builder.emitStoreValueOperation(newBI->getLoc(), newBI->getResult(0),
+                                    result, StoreOwnershipQualifier::Trivial);
+  }
+
+  return newBI;
+}

trunk/lib/SIL/SILVerifier.cpp

@@ -500,7 +500,27 @@ struct ImmutableAddressUseVerifier {
       if (inst->isTypeDependentOperand(*use))
         continue;
 
+      // TODO: Can this switch be restructured so break -> error, continue ->
+      // next iteration, return -> return the final result.
       switch (inst->getKind()) {
+      case SILInstructionKind::BuiltinInst: {
+        // If we are processing a polymorphic builtin that takes an address,
+        // skip the builtin. This is because the builtin must be specialized to
+        // a non-memory reading builtin that works on trivial object values
+        // before the diagnostic passes end (or be DCEed) or we emit a
+        // diagnostic.
+        if (auto builtinKind = cast<BuiltinInst>(inst)->getBuiltinKind()) {
+          if (isPolymorphicBuiltin(*builtinKind)) {
+            break;
+          }
+        }
+
+        // Otherwise this is a builtin that we are not expecting to see, so bail
+        // and assert.
+        llvm::errs() << "Unhandled, unexpected builtin instruction: " << *inst;
+        llvm_unreachable("invoking standard assertion failure");
+        break;
+      }
       case SILInstructionKind::MarkDependenceInst:
       case SILInstructionKind::LoadBorrowInst:
       case SILInstructionKind::DebugValueAddrInst:

trunk/lib/SILOptimizer/Utils/ConstantFolding.cpp

@@ -14,6 +14,7 @@
 
 #include "swift/AST/DiagnosticsSIL.h"
 #include "swift/AST/Expr.h"
+#include "swift/SIL/InstructionUtils.h"
 #include "swift/SIL/PatternMatch.h"
 #include "swift/SIL/SILBuilder.h"
 #include "swift/SILOptimizer/Utils/CastOptimizer.h"
@@ -23,7 +24,7 @@
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Support/Debug.h"
 
-#define DEBUG_TYPE "constant-folding"
+#define DEBUG_TYPE "sil-constant-folding"
 
 using namespace swift;
 
@@ -582,6 +583,21 @@ constantFoldAndCheckDivision(BuiltinInst *BI, BuiltinValueKind ID,
   return B.createIntegerLiteral(BI->getLoc(), BI->getType(), ResVal);
 }
 
+static SILValue specializePolymorphicBuiltin(BuiltinInst *bi,
+                                             BuiltinValueKind id,
+                                             Optional<bool> &resultsInError) {
+  // If we are not a polymorphic builtin, return an empty SILValue()
+  // so we keep on scanning.
+  if (!isPolymorphicBuiltin(id))
+    return SILValue();
+
+  // Otherwise, try to perform the mapping.
+  if (auto newBuiltin = getStaticOverloadForSpecializedPolymorphicBuiltin(bi))
+    return newBuiltin;
+
+  return SILValue();
+}
+
 /// Fold binary operations.
 ///
 /// The list of operations we constant fold might not be complete. Start with
@@ -1593,6 +1609,15 @@ void ConstantFolder::initializeWorklist(SILFunction &f) {
         continue;
       }
 
+      if (auto *bi = dyn_cast<BuiltinInst>(inst)) {
+        if (auto kind = bi->getBuiltinKind()) {
+          if (isPolymorphicBuiltin(kind.getValue())) {
+            WorkList.insert(bi);
+            continue;
+          }
+        }
+      }
+
       // If we have nominal type literals like struct, tuple, enum visit them
       // like we do in the worklist to see if we can fold any projection
       // manipulation operations.
@@ -1804,6 +1829,29 @@ ConstantFolder::processWorkList() {
       continue;
     }
 
+    if (auto *bi = dyn_cast<BuiltinInst>(I)) {
+      if (auto kind = bi->getBuiltinKind()) {
+        Optional<bool> ResultsInError;
+        if (EnableDiagnostics)
+          ResultsInError = false;
+        if (SILValue v = specializePolymorphicBuiltin(bi, kind.getValue(),
+                                                      ResultsInError)) {
+          // If bi had a result, RAUW.
+          if (bi->getResult(0)->getType() !=
+              bi->getModule().Types.getEmptyTupleType())
+            bi->replaceAllUsesWith(v);
+          // Then delete no matter what.
+          bi->eraseFromParent();
+          InvalidateInstructions = true;
+        }
+
+        // If we did not pass in a None and the optional is set to true, add the
+        // user to our error set.
+        if (ResultsInError.hasValue() && ResultsInError.getValue())
+          ErrorSet.insert(bi);
+      }
+    }
+
     // Go through all users of the constant and try to fold them.
     FoldedUsers.clear();
     for (auto Result : I->getResults()) {