Merge pull request #7700 from shajrawi/unconditional_checked_cast

Add support for unconditional checked cast instruction for opaque value types + SILGen support for it

Author: Joe Shajrawi

docs/SIL.rst

@@ -4429,7 +4429,7 @@ Checked Conversions
 
 Some user-level cast operations can fail and thus require runtime checking.
 
-The `unconditional_checked_cast_addr`_ and `unconditional_checked_cast`_
+The `unconditional_checked_cast_addr`_, `unconditional_checked_cast_opaque`_ and `unconditional_checked_cast`_
 instructions performs an unconditional checked cast; it is a runtime failure
 if the cast fails. The `checked_cast_addr_br`_ and `checked_cast_br`_
 terminator instruction performs a conditional checked cast; it branches to one
@@ -4468,6 +4468,20 @@ unconditional_checked_cast_addr
 Performs a checked indirect conversion, causing a runtime failure if the
 conversion fails.
 
+unconditional_checked_cast_opaque
+`````````````````````````````````
+::
+
+  sil-instruction ::= 'unconditional_checked_cast_opaque' sil-operand 'to' sil-type
+
+  %1 = unconditional_checked_cast_opaque %0 : $A to $B
+  // $A must be not be an address
+  // $B must be an opaque value
+  // %1 will be of type $B
+
+Performs a checked conversion, causing a runtime failure if the
+conversion fails.
+
 Runtime Failures
 ~~~~~~~~~~~~~~~~
 

include/swift/SIL/SILBuilder.h

@@ -797,6 +797,13 @@ class SILBuilder {
         targetType));
   }
 
+  UnconditionalCheckedCastOpaqueInst *
+  createUnconditionalCheckedCastOpaque(SILLocation Loc, SILValue op,
+                                       SILType destTy) {
+    return insert(UnconditionalCheckedCastOpaqueInst::create(
+        getSILDebugLocation(Loc), op, destTy, F, OpenedArchetypes));
+  }
+
   RetainValueInst *createRetainValue(SILLocation Loc, SILValue operand,
                                      Atomicity atomicity) {
     assert(isParsing || F.hasUnqualifiedOwnership());

include/swift/SIL/SILCloner.h

@@ -1149,10 +1149,20 @@ SILCloner<ImplClass>::visitUnconditionalCheckedCastAddrInst(
                                                          SrcValue, SrcType,
                                                          DestValue, TargetType));
 }
-  
-template<typename ImplClass>
-void
-SILCloner<ImplClass>::visitRetainValueInst(RetainValueInst *Inst) {
+
+template <typename ImplClass>
+void SILCloner<ImplClass>::visitUnconditionalCheckedCastOpaqueInst(
+    UnconditionalCheckedCastOpaqueInst *Inst) {
+  SILLocation OpLoc = getOpLocation(Inst->getLoc());
+  SILValue OpValue = getOpValue(Inst->getOperand());
+  SILType OpType = getOpType(Inst->getType());
+  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
+  doPostProcess(Inst, getBuilder().createUnconditionalCheckedCastOpaque(
+                          OpLoc, OpValue, OpType));
+}
+
+template <typename ImplClass>
+void SILCloner<ImplClass>::visitRetainValueInst(RetainValueInst *Inst) {
   getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
   doPostProcess(Inst,
     getBuilder().createRetainValue(getOpLocation(Inst->getLoc()),

include/swift/SIL/SILInstruction.h

@@ -2836,6 +2836,26 @@ class UnconditionalCheckedCastAddrInst : public SILInstruction
   }
 };
 
+/// Perform an unconditional checked cast that aborts if the cast fails.
+/// The result of the checked cast is left in the destination.
+class UnconditionalCheckedCastOpaqueInst final
+    : public UnaryInstructionWithTypeDependentOperandsBase<
+          ValueKind::UnconditionalCheckedCastOpaqueInst,
+          UnconditionalCheckedCastOpaqueInst, ConversionInst, true> {
+  friend SILBuilder;
+
+  UnconditionalCheckedCastOpaqueInst(SILDebugLocation DebugLoc,
+                                     SILValue Operand,
+                                     ArrayRef<SILValue> TypeDependentOperands,
+                                     SILType DestTy)
+      : UnaryInstructionWithTypeDependentOperandsBase(
+            DebugLoc, Operand, TypeDependentOperands, DestTy) {}
+
+  static UnconditionalCheckedCastOpaqueInst *
+  create(SILDebugLocation DebugLoc, SILValue Operand, SILType DestTy,
+         SILFunction &F, SILOpenedArchetypesState &OpenedArchetypes);
+};
+
 /// StructInst - Represents a constructed loadable struct.
 class StructInst : public SILInstruction {
   friend SILBuilder;

include/swift/SIL/SILNodes.def

@@ -266,6 +266,7 @@ ABSTRACT_VALUE(SILInstruction, ValueBase)
     INST(ObjCMetatypeToObjectInst, ConversionInst, objc_metatype_to_object, None, DoesNotRelease)
     INST(ObjCExistentialMetatypeToObjectInst, ConversionInst, objc_existential_metatype_to_object, None,
          DoesNotRelease)
+    INST(UnconditionalCheckedCastOpaqueInst, ConversionInst, unconditional_checked_cast_opaque, None, DoesNotRelease)
     INST(UnconditionalCheckedCastInst, ConversionInst, unconditional_checked_cast, None, DoesNotRelease)
     VALUE_RANGE(ConversionInst, UpcastInst, UnconditionalCheckedCastInst)
   INST(IsNonnullInst, SILInstruction, is_nonnull, None, DoesNotRelease)

lib/IRGen/IRGenSIL.cpp

@@ -965,6 +965,8 @@ class IRGenSILFunction :
   void visitObjCToThickMetatypeInst(ObjCToThickMetatypeInst *i);
   void visitUnconditionalCheckedCastInst(UnconditionalCheckedCastInst *i);
   void visitUnconditionalCheckedCastAddrInst(UnconditionalCheckedCastAddrInst *i);
+  void visitUnconditionalCheckedCastOpaqueInst(
+      UnconditionalCheckedCastOpaqueInst *i);
   void visitObjCMetatypeToObjectInst(ObjCMetatypeToObjectInst *i);
   void visitObjCExistentialMetatypeToObjectInst(
                                         ObjCExistentialMetatypeToObjectInst *i);
@@ -4276,6 +4278,11 @@ void IRGenSILFunction::visitUnconditionalCheckedCastAddrInst(
                   i->getConsumptionKind(), CheckedCastMode::Unconditional);
 }
 
+void IRGenSILFunction::visitUnconditionalCheckedCastOpaqueInst(
+    swift::UnconditionalCheckedCastOpaqueInst *i) {
+  llvm_unreachable("unsupported instruction during IRGen");
+}
+
 void IRGenSILFunction::visitCheckedCastBranchInst(
                                               swift::CheckedCastBranchInst *i) {
   SILType destTy = i->getCastType();

lib/Parse/ParseSIL.cpp

@@ -2448,6 +2448,7 @@ bool SILParser::parseSILInstruction(SILBasicBlock *BB, SILBuilder &B) {
 
   // Checked Conversion instructions.
   case ValueKind::UnconditionalCheckedCastInst:
+  case ValueKind::UnconditionalCheckedCastOpaqueInst:
   case ValueKind::CheckedCastBranchInst: {
     SILType ty;
     SILValue destVal;
@@ -2470,7 +2471,12 @@ bool SILParser::parseSILInstruction(SILBasicBlock *BB, SILBuilder &B) {
         return true;
       ResultVal = B.createUnconditionalCheckedCast(InstLoc, Val, ty);
       break;
-    }    
+    } else if (Opcode == ValueKind::UnconditionalCheckedCastOpaqueInst) {
+      if (parseSILDebugLocation(InstLoc, B))
+        return true;
+      ResultVal = B.createUnconditionalCheckedCastOpaque(InstLoc, Val, ty);
+      break;
+    }
     // The conditional cast still needs its branch destinations.
     Identifier successBBName, failureBBName;
     SourceLoc successBBLoc, failureBBLoc;

lib/SIL/InstructionUtils.cpp

@@ -67,6 +67,7 @@ static bool isRCIdentityPreservingCast(ValueKind Kind) {
     case ValueKind::UncheckedRefCastInst:
     case ValueKind::UncheckedRefCastAddrInst:
     case ValueKind::UnconditionalCheckedCastInst:
+    case ValueKind::UnconditionalCheckedCastOpaqueInst:
     case ValueKind::RefToBridgeObjectInst:
     case ValueKind::BridgeObjectToRefInst:
       return true;
@@ -363,6 +364,7 @@ void ConformanceCollector::collect(swift::SILInstruction *I) {
     case ValueKind::AllocRefDynamicInst:
     case ValueKind::MetatypeInst:
     case ValueKind::UnconditionalCheckedCastInst:
+    case ValueKind::UnconditionalCheckedCastOpaqueInst:
       scanType(I->getType().getSwiftRValueType());
       break;
     case ValueKind::AllocStackInst: {

lib/SIL/SILInstructions.cpp

@@ -1772,6 +1772,21 @@ UnconditionalCheckedCastInst *UnconditionalCheckedCastInst::create(
                                                      TypeDependentOperands, DestTy);
 }
 
+UnconditionalCheckedCastOpaqueInst *UnconditionalCheckedCastOpaqueInst::create(
+    SILDebugLocation DebugLoc, SILValue Operand, SILType DestTy, SILFunction &F,
+    SILOpenedArchetypesState &OpenedArchetypes) {
+  SILModule &Mod = F.getModule();
+  SmallVector<SILValue, 8> TypeDependentOperands;
+  collectTypeDependentOperands(TypeDependentOperands, OpenedArchetypes, F,
+                               DestTy.getSwiftRValueType());
+  unsigned size =
+      totalSizeToAlloc<swift::Operand>(1 + TypeDependentOperands.size());
+  void *Buffer =
+      Mod.allocateInst(size, alignof(UnconditionalCheckedCastOpaqueInst));
+  return ::new (Buffer) UnconditionalCheckedCastOpaqueInst(
+      DebugLoc, Operand, TypeDependentOperands, DestTy);
+}
+
 CheckedCastBranchInst *CheckedCastBranchInst::create(
     SILDebugLocation DebugLoc, bool IsExact, SILValue Operand, SILType DestTy,
     SILBasicBlock *SuccessBB, SILBasicBlock *FailureBB, SILFunction &F,

lib/SIL/SILOwnershipVerifier.cpp

@@ -193,6 +193,7 @@ static bool isOwnershipForwardingValueKind(ValueKind K) {
   case ValueKind::RefToBridgeObjectInst:
   case ValueKind::BridgeObjectToRefInst:
   case ValueKind::UnconditionalCheckedCastInst:
+  case ValueKind::UnconditionalCheckedCastOpaqueInst:
   case ValueKind::TupleExtractInst:
   case ValueKind::StructExtractInst:
   case ValueKind::UncheckedEnumDataInst:
@@ -563,6 +564,7 @@ FORWARD_ANY_OWNERSHIP_INST(ConvertFunction)
 FORWARD_ANY_OWNERSHIP_INST(RefToBridgeObject)
 FORWARD_ANY_OWNERSHIP_INST(BridgeObjectToRef)
 FORWARD_ANY_OWNERSHIP_INST(UnconditionalCheckedCast)
+FORWARD_ANY_OWNERSHIP_INST(UnconditionalCheckedCastOpaque)
 FORWARD_ANY_OWNERSHIP_INST(MarkUninitialized)
 FORWARD_ANY_OWNERSHIP_INST(UncheckedEnumData)
 #undef FORWARD_ANY_OWNERSHIP_INST

lib/SIL/SILPrinter.cpp

@@ -1216,7 +1216,12 @@ class SILPrinter : public SILVisitor<SILPrinter> {
           << " to " << CI->getTargetType() << " in "
           << getIDAndType(CI->getDest());
   }
-  
+
+  void visitUnconditionalCheckedCastOpaqueInst(
+      UnconditionalCheckedCastOpaqueInst *CI) {
+    *this << getIDAndType(CI->getOperand()) << " to " << CI->getType();
+  }
+
   void visitCheckedCastAddrBranchInst(CheckedCastAddrBranchInst *CI) {
     *this << getCastConsumptionKindName(CI->getConsumptionKind()) << ' '
           << CI->getSourceType() << " in " << getIDAndType(CI->getSrc())

lib/SIL/SILValue.cpp

@@ -417,6 +417,7 @@ FORWARDING_OWNERSHIP_INST(Struct)
 FORWARDING_OWNERSHIP_INST(Tuple)
 FORWARDING_OWNERSHIP_INST(UncheckedRefCast)
 FORWARDING_OWNERSHIP_INST(UnconditionalCheckedCast)
+FORWARDING_OWNERSHIP_INST(UnconditionalCheckedCastOpaque)
 FORWARDING_OWNERSHIP_INST(Upcast)
 FORWARDING_OWNERSHIP_INST(MarkUninitialized)
 FORWARDING_OWNERSHIP_INST(UncheckedEnumData)

lib/SIL/SILVerifier.cpp

@@ -2509,6 +2509,11 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
     verifyOpenedArchetype(CI, CI->getType().getSwiftRValueType());
   }
 
+  void checkUnconditionalCheckedCastOpaqueInst(
+      UnconditionalCheckedCastOpaqueInst *CI) {
+    verifyOpenedArchetype(CI, CI->getType().getSwiftRValueType());
+  }
+
   /// Verify if a given type is or contains an opened archetype or dynamic self.
   /// If this is the case, verify that the provided instruction has a type
   /// dependent operand for it.

lib/SILGen/SILGenDynamicCast.cpp

@@ -56,15 +56,15 @@ namespace {
       SGFContext ctx;
 
       std::unique_ptr<TemporaryInitialization> temporary;
-      if (isOperandIndirect()) {
+      if (isOperandIndirect() && SGF.silConv.useLoweredAddresses()) {
         temporary = SGF.emitTemporary(Loc, origSourceTL);
         ctx = SGFContext(temporary.get());
       }
 
       auto result = SGF.emitRValueAsOrig(operand, mostGeneral,
                                          origSourceTL, ctx);
 
-      if (isOperandIndirect()) {
+      if (isOperandIndirect() && SGF.silConv.useLoweredAddresses()) {
         // Force the result into the temporary if it's not already there.
         if (!result.isInContext()) {
           result.forwardInto(SGF, Loc, temporary->getAddress());
@@ -87,7 +87,8 @@ namespace {
 
       // If we're using checked_cast_addr, take the operand (which
       // should be an address) and build into the destination buffer.
-      if (Strategy == CastStrategy::Address) {
+      if (Strategy == CastStrategy::Address &&
+          SGF.silConv.useLoweredAddresses()) {
         SILValue resultBuffer =
           createAbstractResultBuffer(hasAbstraction, origTargetTL, ctx);
         SGF.B.createUnconditionalCheckedCastAddr(Loc,
@@ -99,9 +100,15 @@ namespace {
                                              abstraction, origTargetTL, ctx));
       }
 
-      SILValue resultScalar =
-        SGF.B.createUnconditionalCheckedCast(Loc, operand.forward(SGF),
-                                             origTargetTL.getLoweredType());
+      SILValue resultScalar;
+      if (Strategy == CastStrategy::Address) {
+        resultScalar = SGF.B.createUnconditionalCheckedCastOpaque(
+            Loc, operand.forward(SGF), origTargetTL.getLoweredType());
+      } else {
+        resultScalar = SGF.B.createUnconditionalCheckedCast(
+            Loc, operand.forward(SGF), origTargetTL.getLoweredType());
+      }
+
       return RValue(SGF, Loc, TargetType,
                     finishFromResultScalar(hasAbstraction, resultScalar,
                                            CastConsumptionKind::TakeAlways,

lib/SILOptimizer/Utils/SILInliner.cpp

@@ -392,6 +392,7 @@ InlineCost swift::instructionInlineCost(SILInstruction &I) {
     case ValueKind::UncheckedTakeEnumDataAddrInst:
     case ValueKind::UnconditionalCheckedCastInst:
     case ValueKind::UnconditionalCheckedCastAddrInst:
+    case ValueKind::UnconditionalCheckedCastOpaqueInst:
     case ValueKind::UnmanagedToRefInst:
     case ValueKind::UnownedReleaseInst:
     case ValueKind::UnownedRetainInst:

lib/Serialization/DeserializeSIL.cpp

@@ -1892,6 +1892,13 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn, SILBasicBlock *BB,
                                                 successBB, failureBB);
     break;
   }
+  case ValueKind::UnconditionalCheckedCastOpaqueInst: {
+    SILValue Val = getLocalValue(
+        ValID, getSILType(MF->getType(TyID2), (SILValueCategory)TyCategory2));
+    SILType Ty = getSILType(MF->getType(TyID), (SILValueCategory)TyCategory);
+    ResultVal = Builder.createUnconditionalCheckedCastOpaque(Loc, Val, Ty);
+    break;
+  }
   case ValueKind::UnconditionalCheckedCastAddrInst:
   case ValueKind::CheckedCastAddrBranchInst: {
     CastConsumptionKind consumption = getCastConsumptionKind(ListOfValues[0]);

lib/Serialization/SerializeSIL.cpp

@@ -1301,6 +1301,18 @@ void SILSerializer::writeSILInstruction(const SILInstruction &SI) {
              llvm::makeArrayRef(listOfValues));
     break;
   }
+  case ValueKind::UnconditionalCheckedCastOpaqueInst: {
+    auto CI = cast<UnconditionalCheckedCastOpaqueInst>(&SI);
+    SILInstCastLayout::emitRecord(
+        Out, ScratchRecord, SILAbbrCodes[SILInstCastLayout::Code],
+        (unsigned)SI.getKind(), /*attr*/ 0,
+        S.addTypeRef(CI->getType().getSwiftRValueType()),
+        (unsigned)CI->getType().getCategory(),
+        S.addTypeRef(CI->getOperand()->getType().getSwiftRValueType()),
+        (unsigned)CI->getOperand()->getType().getCategory(),
+        addValueRef(CI->getOperand()));
+    break;
+  }
   case ValueKind::UncheckedRefCastAddrInst: {
     auto CI = cast<UncheckedRefCastAddrInst>(&SI);
     ValueID listOfValues[] = {

test/SILGen/opaque_values_silgen.swift

@@ -244,3 +244,23 @@ func s150___________anyArg(_: Any) {}
 func s160_______callAnyArg() {
   s150___________anyArg(42)
 }
+
+// Tests unconditional_checked_cast for opaque values
+// ---
+// CHECK-LABEL: sil hidden @_T020opaque_values_silgen21s170____force_convertxylF : $@convention(thin) <T> () -> @out T {
+// CHECK: bb0:
+// CHECK-NOT: alloc_stack
+// CHECK:   [[INT_TYPE:%.*]] = metatype $@thin Int.Type
+// CHECK:   [[INT_LIT:%.*]] = integer_literal $Builtin.Int2048, 42
+// CHECK:   [[INT_ARG:%.*]] = apply %{{.*}}([[INT_LIT]], [[INT_TYPE]]) : $@convention(method) (Builtin.Int2048, @thin Int.Type) -> Int
+// CHECK:   [[INT_CAST:%.*]] = unconditional_checked_cast_opaque [[INT_ARG]] : $Int to $T
+// CHECK:   [[CAST_BORROW:%.*]] = begin_borrow [[INT_CAST]] : $T
+// CHECK:   [[RETURN_VAL:%.*]] = copy_value [[CAST_BORROW]] : $T
+// CHECK:   end_borrow [[CAST_BORROW]] from [[INT_CAST]] : $T, $T
+// CHECK:   destroy_value [[INT_CAST]] : $T
+// CHECK:   return [[RETURN_VAL]] : $T
+// CHECK-LABEL: } // end sil function '_T020opaque_values_silgen21s170____force_convertxylF'
+func s170____force_convert<T>() -> T {
+  let x : T = 42 as! T
+  return x
+}

utils/sil-mode.el

@@ -153,7 +153,8 @@
                   'words) . font-lock-keyword-face)
 
    ;; Checked Conversions
-   `(,(regexp-opt '("unconditional_checked_cast" "unconditional_checked_cast_addr")
+   `(,(regexp-opt '("unconditional_checked_cast" "unconditional_checked_cast_addr"
+                    "unconditional_checked_cast_opaque")
                   'words) . font-lock-keyword-face)
    ;; Runtime Failures
    `(,(regexp-opt '("cond_fail")

utils/vim/syntax/sil.vim

@@ -40,7 +40,7 @@ syn keyword swiftKeyword init_existential_addr init_existential_opaque init_exis
 syn keyword swiftKeyword upcast address_to_pointer pointer_to_address pointer_to_thin_function unchecked_addr_cast unchecked_ref_cast unchecked_ref_cast_addr ref_to_raw_pointer ref_to_bridge_object ref_to_unmanaged unmanaged_to_ref raw_pointer_to_ref skipwhite
 syn keyword swiftKeyword convert_function thick_to_objc_metatype thin_function_to_pointer objc_to_thick_metatype thin_to_thick_function is_nonnull unchecked_ref_bit_cast unchecked_trivial_bit_cast bridge_object_to_ref bridge_object_to_word unchecked_bitwise_cast skipwhite
 syn keyword swiftKeyword objc_existential_metatype_to_object objc_metatype_to_object objc_protocol skipwhite
-syn keyword swiftKeyword unconditional_checked_cast unconditional_checked_cast_addr skipwhite
+syn keyword swiftKeyword unconditional_checked_cast unconditional_checked_cast_addr unconditional_checked_cast_opaque skipwhite
 syn keyword swiftKeyword cond_fail skipwhite
 syn keyword swiftKeyword unreachable return throw br cond_br switch_value select_enum select_enum_addr select_value switch_enum switch_enum_addr dynamic_method_br checked_cast_br checked_cast_addr_br skipwhite
 syn keyword swiftKeyword project_box project_existential_box project_value_buffer project_block_storage init_block_storage_header copy_block mark_dependence skipwhite