Generate unchecked_ref_cast, not unchecked_ref_bit_cast.

This improves support for promoting to and generating
unchecked_ref_cast so we no longer need unchecked_ref_bit_cast, which
will just go away in the next commit.

Swift SVN r32597

Author: atrick

include/swift/SIL/SILBuilder.h

@@ -466,11 +466,6 @@ class SILBuilder {
     return insert(new (F.getModule()) UncheckedBitwiseCastInst(Loc, Op, Ty));
   }
 
-  // Create the appropriate cast instruction based on result type.
-  SILInstruction *createUncheckedBitCast(SILLocation Loc,
-                                         SILValue Op,
-                                         SILType Ty);
-
   RefToBridgeObjectInst *createRefToBridgeObject(SILLocation Loc,
                                                  SILValue Ref,
                                                  SILValue Bits) {
@@ -1043,6 +1038,21 @@ class SILBuilder {
                     ProjectBoxInst(loc, valueTy, boxOperand));
   }
 
+  //===--------------------------------------------------------------------===//
+  // Unchecked cast helpers
+  //===--------------------------------------------------------------------===//
+
+  // Create an UncheckedRefCast if the source and dest types are legal,
+  // otherwise return null.
+  // Unwrap or wrap optional types as needed.
+  SILInstruction *tryCreateUncheckedRefCast(SILLocation Loc, SILValue Op,
+                                            SILType ResultTy);
+
+  // Create the appropriate cast instruction based on result type.
+  SILInstruction *createUncheckedBitCast(SILLocation Loc,
+                                         SILValue Op,
+                                         SILType Ty);
+
   //===--------------------------------------------------------------------===//
   // Runtime failure
   //===--------------------------------------------------------------------===//

include/swift/SIL/SILInstruction.h

@@ -1527,12 +1527,6 @@ class UncheckedRefCastInst
 
   UncheckedRefCastInst(SILLocation Loc, SILValue Operand, SILType Ty)
     : UnaryInstructionBase(Loc, Operand, Ty) {}
-
-public:
-  // Only reference cast heap objects with single pointer representation.
-  static bool canRefCastType(SILType Ty) {
-    return Ty.isHeapObjectReferenceType();
-  }
 };
 
 /// Converts a heap object reference to a different type without any runtime
@@ -1611,16 +1605,6 @@ class UncheckedRefBitCastInst
 
   UncheckedRefBitCastInst(SILLocation Loc, SILValue Operand, SILType Ty)
     : UnaryInstructionBase(Loc, Operand, Ty) {}
-
-public:
-  // Reference bitcast from representations with single pointer low bits.
-  static bool canRefBitCastFromType(SILType Ty) {
-    return Ty.isHeapObjectReferenceType() || Ty.isClassExistentialType();
-  }
-  // Only reference bitcast to simple single pointer representations.
-  static bool canRefBitCastToType(SILType Ty) {
-    return Ty.isHeapObjectReferenceType();
-  }
 };
 
 /// Bitwise copy a value into another value of the same size or smaller.

include/swift/SIL/SILType.h

@@ -390,7 +390,11 @@ class SILType {
   /// reflexive. `fromType` may be larger than the given type and still be
   /// castable. It is the caller's responsibility to ensure that the overlapping
   /// fields are layout compatible.
-  static bool canUnsafeCastValue(SILType fromType, SILType toType, SILModule &M);
+  static bool canUnsafeCastValue(SILType fromType, SILType toType,
+                                 SILModule &M);
+
+  /// True if `operTy` can be cast by single-reference value into `resultTy`.
+  static bool canRefCast(SILType operTy, SILType resultTy, SILModule &M);
 
   /// True if the type is block-pointer-compatible, meaning it either is a block
   /// or is an Optional or ImplicitlyUnwrappedOptional with a block payload.
@@ -478,6 +482,17 @@ class SILType {
   SILType getAnyOptionalObjectType(SILModule &SILMod,
                                    OptionalTypeKind &OTK) const;
 
+  /// Unwraps one level of optional type.
+  /// Returns the lowered T if the given type is Optional<T> or IUO<T>.
+  /// Otherwise directly returns the given type.
+  static SILType unwrapAnyOptionalType(SILType Ty, SILModule &SILMod,
+                                       OptionalTypeKind &OTK) {
+    if (auto unwrappedTy = Ty.getAnyOptionalObjectType(SILMod, OTK))
+      return unwrappedTy;
+
+    return Ty;
+  };
+
   /// Classify this type as an optional type.
   OptionalTypeKind getOptionalTypeKind() const;
 

lib/IRGen/IRGenSIL.cpp

@@ -3535,14 +3535,16 @@ static void emitPointerCastInst(IRGenSILFunction &IGF,
   // The input may have witness tables or other additional data, but the class
   // reference is always first.
   from.claimAll();
-  
+
   auto schema = ti.getSchema();
   assert(schema.size() == 1
          && schema[0].isScalar()
          && "pointer schema is not a single scalar?!");
   auto castToType = schema[0].getScalarType();
-  
-  ptrValue = IGF.Builder.CreateBitCast(ptrValue, castToType);
+
+  // A retainable pointer representation may be wrapped in an optional, so we
+  // need to provide inttoptr/ptrtoint in addition to bitcast.
+  ptrValue = IGF.Builder.CreateBitOrPointerCast(ptrValue, castToType);
 
   Explosion to;
   to.add(ptrValue);

lib/SIL/SILBuilder.cpp

@@ -42,6 +42,18 @@ SILType SILBuilder::getPartialApplyResultType(SILType origTy, unsigned argCount,
   return SILType::getPrimitiveObjectType(appliedFnType);
 }
 
+// If legal, create an unchecked_ref_cast from the given operand and result
+// type, otherwise return null.
+SILInstruction *SILBuilder::tryCreateUncheckedRefCast(SILLocation Loc,
+                                                      SILValue Op,
+                                                      SILType ResultTy) {
+  auto &M = F.getModule();
+  if (!SILType::canRefCast(Op.getType(), ResultTy, M))
+    return nullptr;
+
+  return insert(new (M) UncheckedRefCastInst(Loc, Op, ResultTy));
+}
+
 // Create the appropriate cast instruction based on result type.
 SILInstruction *SILBuilder::createUncheckedBitCast(SILLocation Loc,
                                                    SILValue Op,
@@ -50,8 +62,8 @@ SILInstruction *SILBuilder::createUncheckedBitCast(SILLocation Loc,
   if (Ty.isTrivial(M))
     return insert(new (M) UncheckedTrivialBitCastInst(Loc, Op, Ty));
 
-  if (Op.getType().canBitCastAsSingleRef() && Ty.canBitCastAsSingleRef())
-    return insert(new (M) UncheckedRefBitCastInst(Loc, Op, Ty));
+  if (auto refCast = tryCreateUncheckedRefCast(Loc, Op, Ty))
+    return refCast;  
 
   // The destination type is nontrivial, and may be smaller than the source
   // type, so RC identity cannot be assumed.

lib/SIL/SILType.cpp

@@ -267,6 +267,19 @@ bool SILType::canUnsafeCastValue(SILType fromType, SILType toType,
   return false;
 }
 
+// Reference cast from representations with single pointer low bits.
+// Only reference cast to simple single pointer representations.
+//
+// TODO: handle casting to a loadable existential by generating
+// init_existential_ref. Until then, only promote to a heap object dest.
+bool SILType::canRefCast(SILType operTy, SILType resultTy, SILModule &M) {
+  OptionalTypeKind otk;
+  auto fromTy = unwrapAnyOptionalType(operTy, M, otk);
+  auto toTy = unwrapAnyOptionalType(resultTy, M, otk);
+  return (fromTy.isHeapObjectReferenceType() || fromTy.isClassExistentialType())
+    && toTy.isHeapObjectReferenceType();
+}
+
 SILType SILType::getFieldType(VarDecl *field, SILModule &M) const {
   assert(field->getDeclContext() == getNominalOrBoundGenericNominal());
   AbstractionPattern origFieldTy = M.Types.getAbstractionPattern(field);

lib/SIL/Verifier.cpp

@@ -2145,14 +2145,11 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
   void checkUncheckedRefCastInst(UncheckedRefCastInst *AI) {
     require(AI->getOperand().getType().isObject(),
             "unchecked_ref_cast operand must be a value");
-    require(AI->getOperand().getType().isHeapObjectReferenceType() ||
-            AI->getOperand().getType().isClassExistentialType(),
-            "unchecked_ref_cast operand must be a heap object reference or "
-            "class existential");
     require(AI->getType().isObject(),
             "unchecked_ref_cast result must be an object");
-    require(AI->getType().isHeapObjectReferenceType(),
-            "unchecked_ref_cast result must be a heap object reference");
+    require(SILType::canRefCast(AI->getOperand().getType(), AI->getType(),
+                                AI->getModule()),
+            "unchecked_ref_cast requires a heap object reference type");
   }
 
   void checkUncheckedRefCastAddrInst(UncheckedRefCastAddrInst *AI) {

lib/SILGen/SILGenBuiltin.cpp

@@ -506,26 +506,16 @@ emitBuiltinCastReference(SILGenFunction &gen,
   auto &toTL = gen.getTypeLowering(toTy);
   assert(!fromTL.isTrivial() && !toTL.isTrivial() && "expected ref type");
 
-  if (fromTL.isLoadable() || toTL.isLoadable()) {
-    if (UncheckedRefCastInst::canRefCastType(fromTL.getLoweredType())
-        && UncheckedRefCastInst::canRefCastType(toTL.getLoweredType())) {
+  if (fromTL.isLoadable() || toTL.isLoadable()) { 
+    if (auto refCast = gen.B.tryCreateUncheckedRefCast(loc, args[0].getValue(),
+                                                       toTL.getLoweredType())) {
       // Create a reference cast, forwarding the cleanup.
       // The cast takes the source reference.
-      auto &in = args[0];
-      SILValue out = gen.B.createUncheckedRefCast(loc, in.getValue(),
-                                              toTL.getLoweredType());
-      return ManagedValue(out, in.getCleanup());
-    }
-    if (UncheckedRefBitCastInst::canRefBitCastFromType(fromTL.getLoweredType())
-        && UncheckedRefBitCastInst::canRefBitCastToType(toTL.getLoweredType()))
-    {
-      auto &in = args[0];
-      SILValue out = gen.B.createUncheckedRefBitCast(loc, in.getValue(),
-                                                     toTL.getLoweredType());
-      return ManagedValue(out, in.getCleanup());
+      return ManagedValue(refCast, args[0].getCleanup());
     }
   }
-  // If casting between address-only types, cast the address.
+  // We are either casting between address-only types, or cannot promote to a
+  // cast of reference values.
   //
   // If the from/to types are invalid, then use a cast that will fail at
   // runtime. We cannot catch these errors with SIL verification because they
@@ -609,9 +599,9 @@ static ManagedValue emitBuiltinReinterpretCast(SILGenFunction &gen,
   SILValue out = gen.B.createUncheckedBitCast(loc, in.getValue(),
                                               toTL.getLoweredType());
 
-  // If the cast reduces to unchecked_ref_bit_cast, then the source and dest
+  // If the cast reduces to unchecked_ref_cast, then the source and dest
   // have identical cleanup, so just forward the cleanup as an optimization.
-  if (isa<UncheckedRefBitCastInst>(out))
+  if (isa<UncheckedRefCastInst>(out))
     return ManagedValue(out, in.getCleanup());
 
   // Otherwise leave the original cleanup and retain the cast value.

lib/SILGen/SILGenExpr.cpp

@@ -2365,8 +2365,8 @@ RValue RValueEmitter::visitInjectIntoOptionalExpr(InjectIntoOptionalExpr *E,
   if (mayLieAboutNonOptionalReturn(E->getSubExpr())) {
     auto result = SGF.emitRValueAsSingleValue(E->getSubExpr());
     auto optType = SGF.getLoweredLoadableType(E->getType());
-    SILValue bitcast = SGF.B.createUncheckedRefBitCast(E, result.getValue(),
-                                                       optType);
+    SILValue bitcast = SGF.B.createUncheckedBitCast(E, result.getValue(),
+                                                    optType);
     ManagedValue bitcastMV = ManagedValue(bitcast, result.getCleanup());
     return RValue(SGF, E, bitcastMV);
   }
@@ -2814,9 +2814,9 @@ static bool emitOptimizedOptionalEvaluation(OptionalEvaluationExpr *E,
                                                    optTL.getLoweredType());
     else
       // The optional object type is the same, so we assume the optional types
-      // are layout identical, allowing the use of unchecked_ref_bit_cast.
-      result = SGF.B.createUncheckedRefBitCast(E, subMV.forward(SGF),
-                                               optTL.getLoweredType());
+      // are layout identical, allowing the use of unchecked bit casts.
+      result = SGF.B.createUncheckedBitCast(E, subMV.forward(SGF),
+                                            optTL.getLoweredType());
     LoadableResult = result;
     return true;
   }

lib/SILGen/SILGenFunction.cpp

@@ -459,7 +459,7 @@ void SILGenFunction::emitArtificialTopLevel(ClassDecl *mainClass) {
                                NSStringFromClass->getType(),
                                SILType::getPrimitiveObjectType(OptNSStringTy),
                                {}, metaTy);
-    SILValue iuoptName = B.createUncheckedRefBitCast(mainClass, optName,
+    SILValue iuoptName = B.createUncheckedBitCast(mainClass, optName,
                               SILType::getPrimitiveObjectType(IUOptNSStringTy));
 
     // Call UIApplicationMain.