[concurrency] Change #isolated to mask out 2 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.

The specific bits that we mask are the bottom two bits of the top nibble of the
TBI.

This will let us perform an optimization in the future where a caller can set
bits in the TBI byte to signal information dynamically to a
nonisolated(nonsending) callee. The intent is that this will let us signal to a
nonisolated(nonsending) callee that the caller isn't performing any isolated
work before it hops (or potentially a caller of the caller) hops meaning that
the nonisolated(nonsending) function can avoid a tail hop that restores
isolation after calling some sort of actor isolated call.

E.x.:

```swift
nonisolated(nonsending) func callsActor(_ a: MyActor) async {
  await a.doSomething()
}

@Concurrent func runOnBackground() async {}

actor A {
  func doSomething() async { ... }

  func caller() async {
    await callsActor(self)
    await runOnBackgroud()
  }
}
```

In the above case, the hop back in callsActor is not needed dynamically in
caller since we are going to immediately await ontot he background. But we do
not know that. An optimization can be written that can recognize this case and
dynamically tell via the tbi bits of the protocol witness table of the any Actor
call that the hop to executor call can avoid the hop.

Since this only applies to the implicit isolated any Actor parameter which is
only used for the purpose of hopping, it is safe to do this since when we hop we
just call the Actor unowned executor dispatch thunk which directly accesses the
witness table by loading from that pointer... meaning that anything set in the
TBI bit is irrelevent.

The only other way to grab this implicit bit is to use `#isolation` and that is
where this commit comes into play. Since we can access the actor via
`#isolation`, we need to ensure that we mask out the TBI bits so that the rest
of the runtime/compiled code never see the TBI bits. This is because we do not
want the fact that we are using these TBI bits to ever escape into other code
(e.x.: consider things that may cast).

So we have basically created a hermetically sealed world where we can pass
information from callee to caller using the protocol witness TBI bits.

I also provided a similar implementation for platforms without TBI that use the
tagged pointer bits of the protocol witness function. This is behind an
experimental feature flag called NonisolatedNonsendingDynamicHopElim that is
only available in asserts builds.

rdar://156525771

Author: gottesmm

include/swift/Basic/Features.def

@@ -541,6 +541,10 @@ SUPPRESSIBLE_EXPERIMENTAL_FEATURE(Lifetimes, true)
 /// Allow macro based aliases to be imported into Swift
 EXPERIMENTAL_FEATURE(ImportMacroAliases, true)
 
+/// Allow support for the nonisolated(nonsending) dynamic hop elim off of
+/// on platforms that do not support aarch64 tbi.
+EXPERIMENTAL_FEATURE(NonisolatedNonsendingDynamicHopElim, false)
+
 #undef EXPERIMENTAL_FEATURE_EXCLUDED_FROM_MODULE_INTERFACE
 #undef EXPERIMENTAL_FEATURE
 #undef UPCOMING_FEATURE

include/swift/Basic/LangOptions.h

@@ -670,6 +670,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/SILType.h

@@ -1025,6 +1025,10 @@ 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);
 

lib/AST/FeatureSet.cpp

@@ -123,6 +123,7 @@ UNINTERESTING_FEATURE(SuppressedAssociatedTypes)
 UNINTERESTING_FEATURE(StructLetDestructuring)
 UNINTERESTING_FEATURE(MacrosOnImports)
 UNINTERESTING_FEATURE(NonisolatedNonsendingByDefault)
+UNINTERESTING_FEATURE(NonisolatedNonsendingDynamicHopElim)
 UNINTERESTING_FEATURE(KeyPathWithMethodMembers)
 UNINTERESTING_FEATURE(ImportMacroAliases)
 UNINTERESTING_FEATURE(NoExplicitNonIsolated)

lib/DriverTool/sil_opt_main.cpp

@@ -814,6 +814,8 @@ int sil_opt_main(ArrayRef<const char *> argv, void *MainAddr) {
   Invocation.getLangOptions().UnavailableDeclOptimizationMode =
       options.UnavailableDeclOptimization;
 
+  Invocation.computeAArch64TBIOptions();
+
   // Enable strict concurrency if we have the feature specified or if it was
   // specified via a command line option to sil-opt.
   if (Invocation.getLangOptions().hasFeature(Feature::StrictConcurrency)) {

lib/Frontend/CompilerInvocation.cpp

@@ -382,6 +382,13 @@ setBridgingHeaderFromFrontendOptions(ClangImporterOptions &ImporterOpts,
       FrontendOpts.InputsAndOutputs.getFilenameOfFirstInput();
 }
 
+void CompilerInvocation::computeAArch64TBIOptions() {
+  auto &LLVMArgs = getFrontendOptions().LLVMArgs;
+  auto aarch64_use_tbi =
+      std::find(LLVMArgs.begin(), LLVMArgs.end(), "-aarch64-use-tbi");
+  LangOpts.HasAArch64TBI = aarch64_use_tbi != LLVMArgs.end();
+}
+
 void CompilerInvocation::computeCXXStdlibOptions() {
   // The MSVC driver in Clang is not aware of the C++ stdlib, and currently
   // always assumes libstdc++, which is incorrect: the Microsoft stdlib is
@@ -4108,6 +4115,8 @@ bool CompilerInvocation::parseArgs(
   setIRGenOutputOptsFromFrontendOptions(IRGenOpts, FrontendOpts);
   setBridgingHeaderFromFrontendOptions(ClangImporterOpts, FrontendOpts);
   computeCXXStdlibOptions();
+  computeAArch64TBIOptions();
+
   if (LangOpts.hasFeature(Feature::Embedded)) {
     IRGenOpts.InternalizeAtLink = true;
     IRGenOpts.DisableLegacyTypeInfo = true;

lib/IRGen/GenThunk.cpp

@@ -137,6 +137,23 @@ void IRGenThunk::prepareArguments() {
 
   if (isWitnessMethod) {
     witnessMetadata.SelfWitnessTable = original.takeLast();
+
+    // Mask out the bottom bits when we dispatch specifically to
+    // Actor.unownedExecutor if we NonisolatedNonsendingDynamicHopElim is
+    // enabled and we are not on a platform that supports TBI.
+    auto &langOpts = IGF.getSILModule().getASTContext().LangOpts;
+    if (langOpts.hasFeature(Feature::NonisolatedNonsendingDynamicHopElim) &&
+        !langOpts.HasAArch64TBI &&
+        IGF.CurFn->getName() == "$sScA15unownedExecutorScevgTj") {
+      auto type = llvm::Type::getInt64Ty(IGF.CurFn->getContext());
+      auto pointerCast = IGF.Builder.CreateBitOrPointerCast(
+          witnessMetadata.SelfWitnessTable, type);
+      witnessMetadata.SelfWitnessTable = IGF.Builder.CreateBitOrPointerCast(
+          IGF.Builder.CreateBinOp(llvm::Instruction::BinaryOps::And,
+                                  pointerCast,
+                                  llvm::ConstantInt::get(IGF.IGM.IntPtrTy, -4)),
+          witnessMetadata.SelfWitnessTable->getType());
+    }
     witnessMetadata.SelfMetadata = original.takeLast();
   }
 

lib/SIL/IR/SILType.cpp

@@ -103,6 +103,21 @@ SILType SILType::getEmptyTupleType(const ASTContext &C) {
   return getPrimitiveObjectType(C.TheEmptyTupleType);
 }
 
+SILType SILType::getTupleType(const ASTContext &ctx,
+                              ArrayRef<SILType> elementTypes) {
+  if (elementTypes.empty())
+    return SILType::getEmptyTupleType(ctx);
+
+  SmallVector<TupleTypeElt, 8> tupleTypeElts;
+  auto category = elementTypes[0].getCategory();
+  for (auto type : elementTypes) {
+    assert(type.getCategory() == category && "Mismatched tuple elt categories");
+    tupleTypeElts.push_back(TupleTypeElt(type.getRawASTType()));
+  }
+  auto tupleType = TupleType::get(tupleTypeElts, ctx);
+  return SILType::getPrimitiveType(tupleType->getCanonicalType(), category);
+}
+
 SILType SILType::getSILTokenType(const ASTContext &C) {
   return getPrimitiveObjectType(C.TheSILTokenType);
 }

lib/SILGen/CMakeLists.txt

@@ -3,6 +3,7 @@ add_swift_host_library(swiftSILGen STATIC
   ArgumentSource.cpp
   Cleanup.cpp
   Condition.cpp
+  ConcurrencyUtils.cpp
   FormalEvaluation.cpp
   ManagedValue.cpp
   ResultPlan.cpp