Merge pull request #83346 from gottesmm/pr-df6aafa41c61b9a9a6ee4965a1564ec2946a0dc9

[concurrency] Change #isolated to mask out the TBI bits of the witness pointer of the implicit isolated any Actor pointer so we can do optimizations on TBI supporting platforms in the future.

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/ABI/Mangling.rst

@@ -705,6 +705,9 @@ Types
   type ::= type 'Bv' NATURAL '_'             // Builtin.Vec<n>x<type>
   type ::= type type 'BV'                    // Builtin.FixedArray<N, T>
   type ::= 'Bw'                              // Builtin.Word
+#if SWIFT_RUNTIME_VERSION >= 6.2
+  type ::= 'BA'                              // Builtin.ImplicitActor
+#endif
   type ::= function-signature 'c'            // function type (escaping)
   type ::= function-signature 'X' FUNCTION-KIND // special function type
   type ::= bound-generic-type

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/AST/TypeNodes.def

@@ -143,7 +143,8 @@ ABSTRACT_TYPE(Builtin, Type)
   BUILTIN_CONCRETE_TYPE(BuiltinVector, BuiltinType)
   BUILTIN_GENERIC_TYPE(BuiltinFixedArray, BuiltinType)
   BUILTIN_CONCRETE_TYPE(BuiltinUnboundGeneric, BuiltinType)
-  TYPE_RANGE(Builtin, BuiltinInteger, BuiltinUnboundGeneric)
+  BUILTIN_CONCRETE_TYPE(BuiltinImplicitActor, BuiltinType)
+  TYPE_RANGE(Builtin, BuiltinInteger, BuiltinImplicitActor)
 TYPE(Tuple, Type)
 ABSTRACT_TYPE(ReferenceStorage, Type)
 #define REF_STORAGE(Name, ...) \
@@ -233,6 +234,7 @@ SINGLETON_TYPE(RawPointer, BuiltinRawPointer)
 SINGLETON_TYPE(RawUnsafeContinuation, BuiltinRawUnsafeContinuation)
 SINGLETON_TYPE(NativeObject, BuiltinNativeObject)
 SINGLETON_TYPE(BridgeObject, BuiltinBridgeObject)
+SINGLETON_TYPE(ImplicitActor, BuiltinImplicitActor)
 SINGLETON_TYPE(UnsafeValueBuffer, BuiltinUnsafeValueBuffer)
 SINGLETON_TYPE(DefaultActorStorage, BuiltinDefaultActorStorage)
 SINGLETON_TYPE(NonDefaultDistributedActorStorage, BuiltinNonDefaultDistributedActorStorage)

include/swift/AST/Types.h

@@ -1003,6 +1003,13 @@ class alignas(1 << TypeAlignInBits) TypeBase
   /// Determines whether this type is an any actor type.
   bool isAnyActorType();
 
+  /// Is this a type whose value is a value that a function can use in an
+  /// isolated parameter position. This could be a type that actually conforms
+  /// to AnyActor or it could be a type like any Actor, Optional<any Actor> or
+  /// Builtin.ImplicitActor that do not conform to Actor but from which we can
+  /// derive a value that conforms to the Actor protocol.
+  bool canBeIsolatedTo();
+
   /// Returns true if this type conforms to Sendable, or if its a function type
   /// that is @Sendable.
   bool isSendableType();
@@ -2019,6 +2026,19 @@ BEGIN_CAN_TYPE_WRAPPER(BuiltinVectorType, BuiltinType)
   PROXY_CAN_TYPE_SIMPLE_GETTER(getElementType)
 END_CAN_TYPE_WRAPPER(BuiltinVectorType, BuiltinType)
 
+class BuiltinImplicitActorType : public BuiltinType {
+  friend class ASTContext;
+
+  BuiltinImplicitActorType(const ASTContext &context)
+      : BuiltinType(TypeKind::BuiltinImplicitActor, context) {}
+
+public:
+  static bool classof(const TypeBase *T) {
+    return T->getKind() == TypeKind::BuiltinImplicitActor;
+  }
+};
+DEFINE_EMPTY_CAN_TYPE_WRAPPER(BuiltinImplicitActorType, BuiltinType)
+
 /// Size descriptor for a builtin integer type. This is either a fixed bit
 /// width or an abstract target-dependent value such as "size of a pointer".
 class BuiltinIntegerWidth {

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

@@ -1330,6 +1330,17 @@ class SILBuilder {
         forwardingOwnershipKind));
   }
 
+  /// Create an unchecked_value_cast when Ownership SSA is enabled and
+  /// unchecked_bitwise_cast otherwise.
+  ///
+  /// Intended to be used in utility code that needs to support both Ownership
+  /// SSA and non-Ownership SSA code.
+  SILValue emitUncheckedValueCast(SILLocation loc, SILValue op, SILType ty) {
+    if (hasOwnership())
+      return createUncheckedValueCast(loc, op, ty);
+    return createUncheckedBitwiseCast(loc, op, ty);
+  }
+
   RefToBridgeObjectInst *createRefToBridgeObject(SILLocation Loc, SILValue Ref,
                                                  SILValue Bits) {
     return createRefToBridgeObject(Loc, Ref, Bits, Ref->getOwnershipKind());
@@ -2334,6 +2345,19 @@ class SILBuilder {
         getSILDebugLocation(Loc), Operand, Kind));
   }
 
+  SILValue emitUncheckedOwnershipConversion(SILLocation Loc, SILValue Operand,
+                                            ValueOwnershipKind Kind) {
+    if (!hasOwnership())
+      return Operand;
+    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));
@@ -2353,6 +2377,18 @@ class SILBuilder {
                                 dependenceKind);
   }
 
+  /// Emit a mark_dependence instruction placing the kind only if ownership is
+  /// set in the current function.
+  ///
+  /// This is intended to be used in code that is generic over Ownership SSA and
+  /// non-Ownership SSA code.
+  SILValue emitMarkDependence(SILLocation Loc, SILValue value, SILValue base,
+                              MarkDependenceKind dependenceKind) {
+    return createMarkDependence(Loc, value, base, value->getOwnershipKind(),
+                                hasOwnership() ? dependenceKind
+                                               : MarkDependenceKind::Escaping);
+  }
+
   MarkDependenceInst *
   createMarkDependence(SILLocation Loc, SILValue value, SILValue base,
                        ValueOwnershipKind forwardingOwnershipKind,