[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.

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(BuiltinImplicitIsolationActor, BuiltinType)
+  TYPE_RANGE(Builtin, BuiltinInteger, BuiltinImplicitIsolationActor)
 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(ImplicitIsolationActor, BuiltinImplicitIsolationActor)
 SINGLETON_TYPE(UnsafeValueBuffer, BuiltinUnsafeValueBuffer)
 SINGLETON_TYPE(DefaultActorStorage, BuiltinDefaultActorStorage)
 SINGLETON_TYPE(NonDefaultDistributedActorStorage, BuiltinNonDefaultDistributedActorStorage)

include/swift/AST/Types.h

@@ -2014,6 +2014,19 @@ BEGIN_CAN_TYPE_WRAPPER(BuiltinVectorType, BuiltinType)
   PROXY_CAN_TYPE_SIMPLE_GETTER(getElementType)
 END_CAN_TYPE_WRAPPER(BuiltinVectorType, BuiltinType)
 
+class BuiltinImplicitIsolationActorType : public BuiltinType {
+  friend class ASTContext;
+
+  BuiltinImplicitIsolationActorType(const ASTContext &context)
+      : BuiltinType(TypeKind::BuiltinImplicitIsolationActor, context) {}
+
+public:
+  static bool classof(const TypeBase *T) {
+    return T->getKind() == TypeKind::BuiltinImplicitIsolationActor;
+  }
+};
+DEFINE_EMPTY_CAN_TYPE_WRAPPER(BuiltinImplicitIsolationActorType, 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/Basic/LangOptions.h

@@ -671,6 +671,9 @@ namespace swift {
     bool RestrictNonProductionExperimentalFeatures = false;
 #endif
 
+    /// Set to true if we support AArch64TBI.
+    bool HasAArch64TBI = false;
+
     bool isConcurrencyModelTaskToThread() const {
       return ActiveConcurrencyModel == ConcurrencyModel::TaskToThread;
     }

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(

include/swift/SIL/ConcurrencyUtils.h

@@ -0,0 +1,40 @@
+//===--- ConcurrencyUtils.h -----------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2025 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_SIL_CONCURRENCYUTILS_H
+#define SWIFT_SIL_CONCURRENCYUTILS_H
+
+#include "swift/SIL/SILType.h"
+
+namespace swift {
+
+class SILValue;
+class SILBuilder;
+class SILLocation;
+
+/// Clear the implicit isolated bits of value.
+///
+/// \p value must be Builtin.ImplicitIsolationActor
+///
+/// \p finalType if empty, we always return
+/// Builtin.ImplicitIsolationActor. Otherwise we bitcast to finalType after
+/// tieing the lifetime of the result to \p value.
+SILValue clearImplicitIsolationActorBits(SILBuilder &b, SILLocation loc,
+                                         SILValue value,
+                                         SILType finalType = {});
+
+SILValue setImplicitIsolationActorBits(SILBuilder &b, SILLocation loc,
+                                       SILValue value);
+
+} // namespace swift
+
+#endif

include/swift/SIL/SILBuilder.h

@@ -1334,6 +1334,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());
@@ -2338,6 +2349,13 @@ class SILBuilder {
         getSILDebugLocation(Loc), Operand, Kind));
   }
 
+  SILValue emitUncheckedOwnershipConversion(SILLocation Loc, SILValue Operand,
+                                            ValueOwnershipKind Kind) {
+    if (!hasOwnership())
+      return Operand;
+    return createUncheckedOwnershipConversion(Loc, Operand, Kind);
+  }
+
   FixLifetimeInst *createFixLifetime(SILLocation Loc, SILValue Operand) {
     return insert(new (getModule())
                       FixLifetimeInst(getSILDebugLocation(Loc), Operand));
@@ -2357,6 +2375,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,

include/swift/SIL/SILType.h

@@ -266,6 +266,10 @@ class SILType {
 
   bool isBuiltinBridgeObject() const { return is<BuiltinBridgeObjectType>(); }
 
+  bool isBuiltinImplicitIsolationActor() const {
+    return is<BuiltinImplicitIsolationActorType>();
+  }
+
   SILType getBuiltinVectorElementType() const {
     auto vector = castTo<BuiltinVectorType>();
     return getPrimitiveObjectType(vector.getElementType());
@@ -1025,9 +1029,16 @@ class SILType {
   /// Return '()'
   static SILType getEmptyTupleType(const ASTContext &C);
 
+  /// Return (elementTypes).
+  static SILType getTupleType(const ASTContext &ctx,
+                              ArrayRef<SILType> elementTypes);
+
   /// Get the type for opaque actor isolation values.
   static SILType getOpaqueIsolationType(const ASTContext &C);
 
+  /// Return Builtin.ImplicitIsolationActor.
+  static SILType getBuiltinImplicitIsolationActorType(const ASTContext &ctx);
+
   //
   // Utilities for treating SILType as a pointer-like type.
   //

include/swift/Strings.h

@@ -144,6 +144,9 @@ constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_NATIVEOBJECT = {
 /// The name of the Builtin type for BridgeObject
 constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_BRIDGEOBJECT = {
     "Builtin.BridgeObject"};
+constexpr static BuiltinNameStringLiteral
+    BUILTIN_TYPE_NAME_IMPLICITISOLATIONACTOR = {
+        "Builtin.ImplicitIsolationActor"};
 /// The name of the Builtin type for RawPointer
 constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_RAWPOINTER = {
     "Builtin.RawPointer"};

lib/AST/ASTDumper.cpp

@@ -6109,6 +6109,8 @@ namespace {
     TRIVIAL_TYPE_PRINTER(BuiltinRawUnsafeContinuation, builtin_raw_unsafe_continuation)
     TRIVIAL_TYPE_PRINTER(BuiltinNativeObject, builtin_native_object)
     TRIVIAL_TYPE_PRINTER(BuiltinBridgeObject, builtin_bridge_object)
+    TRIVIAL_TYPE_PRINTER(BuiltinImplicitIsolationActor,
+                         builtin_implicit_isolated_actor)
     TRIVIAL_TYPE_PRINTER(BuiltinUnsafeValueBuffer, builtin_unsafe_value_buffer)
     TRIVIAL_TYPE_PRINTER(SILToken, sil_token)
 

lib/AST/ASTMangler.cpp

@@ -1458,6 +1458,8 @@ void ASTMangler::appendType(Type type, GenericSignature sig,
       auto loc = cast<LocatableType>(tybase);
       return appendType(loc->getSinglyDesugaredType(), sig, forDecl);
     }
+    case TypeKind::BuiltinImplicitIsolationActor:
+      return appendOperator("BA");
     case TypeKind::BuiltinFixedArray: {
       auto bfa = cast<BuiltinFixedArrayType>(tybase);
       appendType(bfa->getSize(), sig, forDecl);

lib/AST/ASTPrinter.cpp

@@ -6156,6 +6156,7 @@ class TypePrinter : public TypeVisitor<TypePrinter, void, NonRecursivePrintOptio
   ASTPRINTER_PRINT_BUILTINTYPE(BuiltinIntegerType)
   ASTPRINTER_PRINT_BUILTINTYPE(BuiltinFloatType)
   ASTPRINTER_PRINT_BUILTINTYPE(BuiltinUnboundGenericType)
+  ASTPRINTER_PRINT_BUILTINTYPE(BuiltinImplicitIsolationActorType)
 #undef ASTPRINTER_PRINT_BUILTINTYPE
 
   void visitBuiltinFixedArrayType(BuiltinFixedArrayType *T,