Rewrite switch dispatch emission.

Specialization now recurses on only that prefix of the
current matrix which shares a specialization form
(essentially, a pattern kind) with the head row.  This is
inferior to the previous algorithm in a number of ways: we
may require more switches to perform a single dispatch, and
we may introduce more redundant variables in the leaves.
However, it also means that we will have fully specialized a
row along exactly one path in the decision tree, which makes
it much easier to work with dispatches that introduce new
cleanups.

This change also changes switch-dispatch to use the new
dynamic-cast instructions.

Incidentally fixes rdar://16401831.

Swift SVN r19336

Author: rjmccall

lib/SILGen/SILGenExpr.cpp

@@ -1595,6 +1595,7 @@ namespace {
       SILBasicBlock *trueBB = SGF.B.splitBlockForFallthrough();
 
       // Emit the branch.
+      SILValue scalarOperandValue;
       SILValue resultBuffer;
       if (Strategy == CastStrategy::Address) {
         assert(operand.getType().isAddress());
@@ -1605,9 +1606,13 @@ namespace {
                                           resultBuffer, TargetType,
                                           trueBB, falseBB);
       } else {
-        assert(!operand.getType().isAddress());
-        SGF.B.createCheckedCastBranch(Loc, /*exact*/ false,
-                                      operand.forward(SGF),
+        // Tolerate being passed an address here.  It comes up during switch
+        //emission.
+        scalarOperandValue = operand.forward(SGF);
+        if (scalarOperandValue.getType().isAddress()) {
+          scalarOperandValue = SGF.B.createLoad(Loc, scalarOperandValue);
+        }
+        SGF.B.createCheckedCastBranch(Loc, /*exact*/ false, scalarOperandValue,
                                       origTargetTL.getLoweredType(),
                                       trueBB, falseBB);
       }
@@ -1628,6 +1633,7 @@ namespace {
         }
 
         handleTrue(result);
+        assert(!SGF.B.hasValidInsertionPoint() && "handler did not end block");
       }
 
       // Emit the failure block.
@@ -1637,10 +1643,11 @@ namespace {
         // If we're using the scalar strategy, handle the consumption rules.
         if (Strategy != CastStrategy::Address &&
             shouldDestroyOnFailure(consumption)) {
-          SGF.B.emitReleaseValueOperation(Loc, operand.getValue());
+          SGF.B.emitReleaseValueOperation(Loc, scalarOperandValue);
         }
 
         handleFalse();
+        assert(!SGF.B.hasValidInsertionPoint() && "handler did not end block");
       }
     }
 
@@ -1742,38 +1749,33 @@ static RValue emitUnconditionalCheckedCast(SILGenFunction &SGF,
   return emitter.emitUnconditionalCast(operandValue, C);
 }
 
-SILValue
-SILGenFunction::emitCheckedCastAbstractionChange(SILLocation loc,
-                                       SILValue original,
-                                       const TypeLowering &origTL,
-                                       ArrayRef<const TypeLowering *> castTLs) {
-  // If we're casting a thin metatype, make it thick.
-  if (auto metatype = original.getType().getAs<MetatypeType>()) {
-    if (metatype->getRepresentation() == MetatypeRepresentation::Thin) {
-      auto thickTy = CanMetatypeType::get(metatype.getInstanceType(),
-                                          MetatypeRepresentation::Thick);
-      return B.createMetatype(loc, SILType::getPrimitiveObjectType(thickTy));
-    }
-    return original;
-  }
-  
-  // If the original type is already address-only, we don't need to abstract
-  // further.
-  if (origTL.isAddressOnly()) {
-    return SILValue();
-  }
-  
-  // If any of the cast-to types are address-only, spill to a temporary.
-  if (std::find_if(castTLs.begin(), castTLs.end(),
-                   [](const TypeLowering *tl){ return tl->isAddressOnly(); })
-        != castTLs.end()) {
-    SILValue temp = emitTemporaryAllocation(loc, origTL.getLoweredType());
-    B.createStore(loc, original, temp);
-    return temp;
+/// Treating this as a successful operation, turn a CMV into a +1 MV.
+ManagedValue SILGenFunction::getManagedValue(SILLocation loc,
+                                             ConsumableManagedValue value) {
+  // If the consumption rules say that this is already +1 given a
+  // successful operation, just use the value.
+  if (value.isOwned())
+    return value.getFinalManagedValue();
+
+  SILType valueTy = value.getType();
+  auto &valueTL = getTypeLowering(valueTy);
+
+  // If the type is trivial, it's always +1.
+  if (valueTL.isTrivial())
+    return ManagedValue::forUnmanaged(value.getValue());
+
+  // If it's an object, retain and enter a release cleanup.
+  if (valueTy.isObject()) {
+    valueTL.emitRetainValue(B, loc, value.getValue());
+    return emitManagedRValueWithCleanup(value.getValue(), valueTL);
   }
-  
-  // Otherwise, no abstraction change is needed.
-  return SILValue();
+
+  // Otherwise, produce a temporary and copy into that.
+  auto temporary = emitTemporary(loc, valueTL);
+  valueTL.emitCopyInto(B, loc, value.getValue(), temporary->getAddress(),
+                       IsNotTake, IsInitialization);
+  temporary->finishInitialization(*this);
+  return temporary->getManagedAddress();
 }
 
 void SILGenFunction::emitCheckedCastBranch(SILLocation loc, Expr *source,
@@ -1787,6 +1789,18 @@ void SILGenFunction::emitCheckedCastBranch(SILLocation loc, Expr *source,
                           handleTrue, handleFalse);
 }
 
+void SILGenFunction::emitCheckedCastBranch(SILLocation loc,
+                                           ConsumableManagedValue src,
+                                           CanType sourceType,
+                                           CanType targetType,
+                                           SGFContext ctx,
+                                std::function<void(ManagedValue)> handleTrue,
+                                           std::function<void()> handleFalse) {
+  CheckedCastEmitter emitter(*this, loc, sourceType, targetType);
+  emitter.emitConditional(src.getFinalManagedValue(), src.getFinalConsumption(),
+                          ctx, handleTrue, handleFalse);
+}
+
 std::pair<SILBasicBlock*, SILBasicBlock*>
 SILGenFunction::emitCheckedCastBranch(SILLocation loc,
                                       SILValue original,

lib/SILGen/SILGenFunction.h

@@ -743,6 +743,10 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
 
   void emitReturnExpr(SILLocation loc, Expr *ret);
 
+  /// Turn a consumable managed value into a +1 managed value.
+  ManagedValue getManagedValue(SILLocation loc,
+                               ConsumableManagedValue value);
+
   /// Convert a value with the abstraction patterns of the original type
   /// to a value with the abstraction patterns of the substituted type.
   ManagedValue emitOrigToSubstValue(SILLocation loc, ManagedValue input,
@@ -828,22 +832,6 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   /// Emit a dynamic subscript.
   RValue emitDynamicSubscriptExpr(DynamicSubscriptExpr *e, SGFContext c);
 
-  /// \brief Emits the abstraction change needed, if any, to perform casts from
-  /// the type represented by \c origTL to each of the types represented by
-  /// \c castTLs.
-  ///
-  /// \param loc      The AST location associated with the operation.
-  /// \param original The value to cast.
-  /// \param origTL   The original type.
-  /// \param castTLs  The types to which to cast.
-  ///
-  /// \returns The value shifted to the highest abstraction level necessary
-  /// for the casts, or a null SILValue if no abstraction changes are needed.
-  SILValue emitCheckedCastAbstractionChange(SILLocation loc,
-                                       SILValue original,
-                                       const TypeLowering &origTL,
-                                       ArrayRef<const TypeLowering *> castTLs);
-  
   /// \brief Emit a conditional checked cast branch. Does not re-abstract the
   /// argument to the success branch. Terminates the current BB.
   ///
@@ -867,6 +855,12 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
                         const TypeLowering &castTL,
                         CheckedCastKind kind);
 
+  void emitCheckedCastBranch(SILLocation loc, ConsumableManagedValue src,
+                             CanType sourceType, CanType targetType,
+                             SGFContext C,
+                             std::function<void(ManagedValue)> handleTrue,
+                             std::function<void()> handleFalse);
+
   void emitCheckedCastBranch(SILLocation loc, Expr *src,
                              Type targetType, SGFContext C,
                              std::function<void(ManagedValue)> handleTrue,