[sil] Add a new instruction cast_implicit_actor_to_optional_actor.

This instruction converts Builtin.ImplicitActor to Optional<any Actor>. In the
process of doing so, it masks out the bits we may have stolen from the witness
table pointer of Builtin.ImplicitActor. The bits that we mask out are the bottom
two bits of the top nibble of the TBI space on platforms that support TBI (that
is bit 60,61 on arm64). On platforms that do not support TBI, we just use the
bottom two tagged pointer bits (0,1).

By using an instruction, we avoid having to represent the bitmasking that we are
performing at the SIL level and can instead just make the emission of the
bitmasking an IRGen detail. It also allows us to move detection if we are
compiling for AArch64 to be an IRGen flag instead of a LangOpts flag.

The instruction is a guaranteed forwarding instruction since we want to treat
its result as a borrowed projection from the Builtin.ImplicitActor.

Author: gottesmm

SwiftCompilerSources/Sources/SIL/ForwardingInstruction.swift

@@ -467,6 +467,12 @@ extension BorrowedFromInst: ForwardingInstruction {
   public var canForwardOwnedValues: Bool { false }
 }
 
+extension ImplicitActorToOpaqueIsolationCastInst: ConversionInstruction {
+  public var preservesRepresentation: Bool { true }
+  public var canForwardGuaranteedValues: Bool { true }
+  public var canForwardOwnedValues: Bool { false }
+}
+
 // -----------------------------------------------------------------------------
 // ownership transition instructions
 

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -2060,3 +2060,6 @@ final public class MergeIsolationRegionInst : Instruction {
 
 final public class IgnoredUseInst : Instruction, UnaryInstruction {
 }
+
+final public class ImplicitActorToOpaqueIsolationCastInst
+  : SingleValueInstruction, UnaryInstruction {}

SwiftCompilerSources/Sources/SIL/Registration.swift

@@ -265,6 +265,7 @@ private func registerSILClasses() {
   register(ThunkInst.self)
   register(MergeIsolationRegionInst.self)
   register(IgnoredUseInst.self)
+  register(ImplicitActorToOpaqueIsolationCastInst.self)
 }
 
 private func registerUtilities() {

docs/SIL/Instructions.md

@@ -4555,6 +4555,9 @@ copy.
 The resulting value must meet the usual ownership requirements; for
 example, a trivial type must have '.none' ownership.
 
+NOTE: A guaranteed result value is assumed to be a non-dependent guaranteed
+value like a function argument.
+
 ### ref_to_raw_pointer
 
 ```
@@ -4871,6 +4874,27 @@ TODO
 
 TODO
 
+### cast_implicitactor_to_opaqueisolation
+
+```
+sil-instruction ::= 'cast_implicitactor_to_opaqueisolation' sil-operand
+
+%1 = cast_implicitactor_to_opaqueisolation %0 : $Builtin.ImplicitActor
+// %0 must have guaranteed ownership
+// %1 must have guaranteed ownership
+// %1 will have type $Optional<any Actor>
+```
+
+Convert a `$Builtin.ImplicitActor` to a `$Optional<any Actor>` masking out any
+bits that we have stolen from the witness table pointer.
+
+At IRGen time, we lower this to the relevant masking operations, allowing us to
+avoid exposing these low level details to the SIL optimizer. On platforms where
+we support TBI, IRGen uses a mask that is the bottom 2 bits of the top nibble of
+the pointer. On 64 bit platforms this is bit 60,61. If the platform does not
+support TBI, then IRGen uses the bottom two tagged pointer bits of the pointer
+(bits 0,1).
+
 ## Checked Conversions
 
 Some user-level cast operations can fail and thus require runtime

include/swift/AST/DiagnosticsParse.def

@@ -621,6 +621,12 @@ ERROR(sil_operand_has_incorrect_moveonlywrapped,none,
 ERROR(sil_operand_not_ref_storage_address,none,
       "%0 operand of '%1' must have address of %2 type",
       (StringRef, StringRef, ReferenceOwnership))
+ERROR(sil_operand_has_wrong_ownership_kind,none,
+      "operand has ownership kind %0 but ownership kind %1 was expected",
+      (StringRef, StringRef))
+ERROR(sil_operand_has_incompatible_ownership_kind,none,
+      "operand has ownership kind %0 but ownership kind compatible with %1 was expected",
+      (StringRef, StringRef))
 ERROR(sil_integer_literal_not_integer_type,none,
       "integer_literal instruction requires a 'Builtin.Int<n>' type", ())
 ERROR(sil_integer_literal_not_well_formed,none,

include/swift/SIL/InstWrappers.h

@@ -301,6 +301,8 @@ class ForwardingOperation {
       return &forwardingInst->getOperandRef(TuplePackExtractInst::TupleOperand);
     case SILInstructionKind::BorrowedFromInst:
       return &forwardingInst->getOperandRef(0);
+    case SILInstructionKind::ImplicitActorToOpaqueIsolationCastInst:
+      return &forwardingInst->getOperandRef(0);
     default:
       int numRealOperands = forwardingInst->getNumRealOperands();
       if (numRealOperands == 0) {
@@ -344,6 +346,7 @@ class ForwardingOperation {
     case SILInstructionKind::StructExtractInst:
     case SILInstructionKind::DifferentiableFunctionExtractInst:
     case SILInstructionKind::LinearFunctionExtractInst:
+    case SILInstructionKind::ImplicitActorToOpaqueIsolationCastInst:
       return true;
     default:
       return false;
@@ -352,6 +355,8 @@ class ForwardingOperation {
 
   /// Return true if the forwarded value has the same representation. If true,
   /// then the result can be mapped to the same storage without a move or copy.
+  ///
+  /// See ForwardingInstruction.swift preservesRepresentation().
   bool hasSameRepresentation() const;
 
   /// Return true if the forwarded value is address-only either before or after

include/swift/SIL/SILBuilder.h

@@ -2341,6 +2341,12 @@ class SILBuilder {
     return createUncheckedOwnershipConversion(Loc, Operand, Kind);
   }
 
+  ImplicitActorToOpaqueIsolationCastInst *
+  createImplicitActorToOpaqueIsolationCast(SILLocation Loc, SILValue Value) {
+    return insert(new (getModule()) ImplicitActorToOpaqueIsolationCastInst(
+        getSILDebugLocation(Loc), Value));
+  }
+
   FixLifetimeInst *createFixLifetime(SILLocation Loc, SILValue Operand) {
     return insert(new (getModule())
                       FixLifetimeInst(getSILDebugLocation(Loc), Operand));

include/swift/SIL/SILCloner.h

@@ -3153,6 +3153,16 @@ void SILCloner<ImplClass>::visitUncheckedOwnershipConversionInst(
                                     getOpValue(Inst->getOperand()), Kind));
 }
 
+template <typename ImplClass>
+void SILCloner<ImplClass>::visitImplicitActorToOpaqueIsolationCastInst(
+    ImplicitActorToOpaqueIsolationCastInst *Inst) {
+  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
+
+  recordClonedInstruction(
+      Inst, getBuilder().createImplicitActorToOpaqueIsolationCast(
+                getOpLocation(Inst->getLoc()), getOpValue(Inst->getValue())));
+}
+
 template <typename ImplClass>
 void SILCloner<ImplClass>::visitMarkDependenceInst(MarkDependenceInst *Inst) {
   getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));

include/swift/SIL/SILInstruction.h

@@ -8789,6 +8789,18 @@ class UncheckedOwnershipConversionInst
   }
 };
 
+class ImplicitActorToOpaqueIsolationCastInst final
+    : public UnaryInstructionBase<
+          SILInstructionKind::ImplicitActorToOpaqueIsolationCastInst,
+          OwnershipForwardingSingleValueInstruction> {
+  friend SILBuilder;
+
+  ImplicitActorToOpaqueIsolationCastInst(SILDebugLocation loc, SILValue value);
+
+public:
+  SILValue getValue() const { return getOperand(); }
+};
+
 enum class MarkDependenceKind {
   Unresolved, Escaping, NonEscaping
 };
@@ -11653,6 +11665,7 @@ OwnershipForwardingSingleValueInstruction::classof(SILInstructionKind kind) {
   case SILInstructionKind::FunctionExtractIsolationInst:
   case SILInstructionKind::DropDeinitInst:
   case SILInstructionKind::BorrowedFromInst:
+  case SILInstructionKind::ImplicitActorToOpaqueIsolationCastInst:
     return true;
   default:
     return false;

include/swift/SIL/SILNodes.def

@@ -423,6 +423,8 @@ ABSTRACT_VALUE_AND_INST(SingleValueInstruction, ValueBase, SILInstruction)
                       SingleValueInstruction, None, DoesNotRelease)
     SINGLE_VALUE_INST(ObjCExistentialMetatypeToObjectInst, objc_existential_metatype_to_object,
                       SingleValueInstruction, None, DoesNotRelease)
+    SINGLE_VALUE_INST(ImplicitActorToOpaqueIsolationCastInst, implicitactor_to_opaqueisolation_cast,
+                      SingleValueInstruction, None, DoesNotRelease)
     // unconditional_checked_cast_inst is only MayRead to prevent a subsequent
     // release of the cast's source from being hoisted above the cast:
     // retain X