Merge pull request #84986 from gottesmm/release/6.2-rdar156525771

[6.2] Add support for TBI masking optimization for nonisolated(nonsending)

Author: gottesmm

SwiftCompilerSources/Sources/SIL/ForwardingInstruction.swift

@@ -462,6 +462,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

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

SwiftCompilerSources/Sources/SIL/Registration.swift

@@ -260,4 +260,5 @@ public func registerSILClasses() {
   register(ThunkInst.self)
   register(MergeIsolationRegionInst.self)
   register(IgnoredUseInst.self)
+  register(ImplicitActorToOpaqueIsolationCastInst.self)
 }

docs/ABI/Mangling.rst

@@ -701,6 +701,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

@@ -4535,6 +4535,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
 
 ```
@@ -4851,6 +4854,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

@@ -614,6 +614,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/IRGenOptions.h

@@ -604,6 +604,9 @@ class IRGenOptions {
   /// Paths to the pass plugins registered via -load-pass-plugin.
   std::vector<std::string> LLVMPassPlugins;
 
+  /// Set to true if we support AArch64TBI.
+  bool HasAArch64TBI = false;
+
   IRGenOptions()
       : OutputKind(IRGenOutputKind::LLVMAssemblyAfterOptimization),
         Verify(true), VerifyEach(false), OptMode(OptimizationMode::NotSet),
@@ -649,13 +652,12 @@ class IRGenOptions {
         UseFragileResilientProtocolWitnesses(false), EnableHotColdSplit(false),
         EmitAsyncFramePushPopMetadata(true), EmitTypeMallocForCoroFrame(true),
         AsyncFramePointerAll(false), UseProfilingMarkerThunks(false),
-        UseCoroCCX8664(false), UseCoroCCArm64(false),
-        MergeableTraps(false),
+        UseCoroCCX8664(false), UseCoroCCArm64(false), MergeableTraps(false),
         DebugInfoForProfiling(false), CmdArgs(),
         SanitizeCoverage(llvm::SanitizerCoverageOptions()),
         TypeInfoFilter(TypeInfoDumpFilter::All),
         PlatformCCallingConvention(llvm::CallingConv::C), UseCASBackend(false),
-        CASObjMode(llvm::CASBackendMode::Native) {
+        CASObjMode(llvm::CASBackendMode::Native), HasAArch64TBI(false) {
     DisableRoundTripDebugTypes = !CONDITIONAL_ASSERT_enabled();
   }
 

include/swift/AST/TypeNodes.def

@@ -144,7 +144,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, ...) \
@@ -234,6 +235,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

@@ -988,6 +988,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();
@@ -1999,6 +2006,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/Frontend/Frontend.h

@@ -274,6 +274,9 @@ class CompilerInvocation {
   /// C++ stdlib is the default for the specified target.
   void computeCXXStdlibOptions();
 
+  /// Compute whether or not we support aarch64TBI
+  void computeAArch64TBIOptions();
+
   /// Computes the runtime resource path relative to the given Swift
   /// executable.
   static void computeRuntimeResourcePathFromExecutablePath(