Merge remote-tracking branch 'origin/main' into rebranch

Author: swift-ci

include/swift/SIL/OwnershipUtils.h

@@ -630,6 +630,21 @@ struct BorrowedValue {
   /// necessarilly dominated by the borrow scope.
   void computeTransitiveLiveness(MultiDefPrunedLiveness &liveness) const;
 
+  /// Whether \p insts are completely within this borrow introducer's local
+  /// scope.
+  ///
+  /// Precondition: \p insts are dominated by the local borrow introducer.
+  ///
+  /// This ignores reborrows. The assumption is that, since \p insts are
+  /// dominated by this local scope, checking the extended borrow scope should
+  /// not be necessary to determine they are within the scope.
+  ///
+  /// \p deadEndBlocks is optional during transition. It will be completely
+  /// removed in an upcoming commit.
+  template <typename Instructions>
+  bool areWithinExtendedScope(Instructions insts,
+                              DeadEndBlocks *deadEndBlocks) const;
+
   /// Returns true if \p uses are completely within this borrow introducer's
   /// local scope.
   ///
@@ -1426,6 +1441,43 @@ bool isRedundantMoveValue(MoveValueInst *mvi);
 /// `forEndBorrowValue`, which is the operand value of an `end_borrow`.
 void updateReborrowFlags(SILValue forEndBorrowValue);
 
+/// A location at which a value is used.  Abstracts over explicit uses
+/// (operands) and implicit uses (instructions).
+struct UsePoint {
+  using Value = llvm::PointerUnion<SILInstruction *, Operand *>;
+  Value value;
+
+  UsePoint(Operand *op) : value(op) {}
+  UsePoint(SILInstruction *inst) : value(inst) {}
+  UsePoint(Value value) : value(value) {}
+
+  SILInstruction *getInstruction() const {
+    if (auto *op = dyn_cast<Operand *>(value)) {
+      return op->getUser();
+    }
+    return cast<SILInstruction *>(value);
+  }
+
+  Operand *getOperandOrNull() const { return dyn_cast<Operand *>(value); }
+
+  Operand *getOperand() const { return cast<Operand *>(value); }
+};
+
+struct UsePointToInstruction {
+  SILInstruction *operator()(const UsePoint point) const {
+    return point.getInstruction();
+  }
+};
+
+using UsePointInstructionRange =
+    TransformRange<ArrayRef<UsePoint>, UsePointToInstruction>;
+
+struct PointToOperand {
+  Operand *operator()(const UsePoint point) const { return point.getOperand(); }
+};
+
+using PointOperandRange = TransformRange<ArrayRef<UsePoint>, PointToOperand>;
+
 } // namespace swift
 
 #endif

include/swift/SIL/PrunedLiveness.h

@@ -729,6 +729,20 @@ class PrunedLiveRange : public PrunedLiveness {
   bool isWithinBoundary(SILInstruction *inst,
                         DeadEndBlocks *deadEndBlocks) const;
 
+  /// Whether all \p insts are between this def and the liveness boundary;
+  /// \p deadEndBlocks is optional.
+  template <typename Instructions>
+  bool areWithinBoundary(Instructions insts,
+                         DeadEndBlocks *deadEndBlocks) const {
+    assert(asImpl().isInitialized());
+
+    for (auto *inst : insts) {
+      if (!isWithinBoundary(inst, deadEndBlocks))
+        return false;
+    }
+    return true;
+  };
+
   /// Returns true when all \p uses are between this def and the liveness
   /// boundary \p deadEndBlocks is optional.
   bool areUsesWithinBoundary(ArrayRef<Operand *> uses,

include/swift/SIL/SILInstruction.h

@@ -670,6 +670,10 @@ class SILInstruction : public llvm::ilist_node<SILInstruction> {
   using TransformedOperandValueRange =
     OptionalTransformRange<ArrayRef<Operand>, OperandToTransformedValue>;
 
+  /// Functor for Operand::getUser()
+  struct OperandToUser;
+  using OperandUserRange = TransformRange<ArrayRef<Operand *>, OperandToUser>;
+
   static OperandValueRange getOperandValues(ArrayRef<Operand*> operands);
 
   OperandRefValueRange getOperandValues() const;
@@ -1021,6 +1025,12 @@ struct SILInstruction::OperandRefToValue {
   }
 };
 
+struct SILInstruction::OperandToUser {
+  SILInstruction *operator()(const Operand *use) const {
+    return const_cast<Operand *>(use)->getUser();
+  }
+};
+
 struct SILInstruction::FilterOperandToRealOperand {
   const SILInstruction &i;
 

lib/SIL/Utils/OwnershipUtils.cpp

@@ -975,8 +975,9 @@ computeTransitiveLiveness(MultiDefPrunedLiveness &liveness) const {
   });
 }
 
-bool BorrowedValue::areUsesWithinExtendedScope(
-    ArrayRef<Operand *> uses, DeadEndBlocks *deadEndBlocks) const {
+template <typename Instructions>
+bool BorrowedValue::areWithinExtendedScope(Instructions insts,
+                                           DeadEndBlocks *deadEndBlocks) const {
   // First make sure that we actually have a local scope. If we have a non-local
   // scope, then we have something (like a SILFunctionArgument) where a larger
   // semantic construct (in the case of SILFunctionArgument, the function
@@ -988,7 +989,20 @@ bool BorrowedValue::areUsesWithinExtendedScope(
   // Compute the local scope's liveness.
   MultiDefPrunedLiveness liveness(value->getFunction());
   computeTransitiveLiveness(liveness);
-  return liveness.areUsesWithinBoundary(uses, deadEndBlocks);
+  return liveness.areWithinBoundary(insts, deadEndBlocks);
+}
+
+template bool BorrowedValue::areWithinExtendedScope<UsePointInstructionRange>(
+    UsePointInstructionRange insts, DeadEndBlocks *deadEndBlocks) const;
+
+template bool
+BorrowedValue::areWithinExtendedScope<SILInstruction::OperandUserRange>(
+    SILInstruction::OperandUserRange insts, DeadEndBlocks *deadEndBlocks) const;
+
+bool BorrowedValue::areUsesWithinExtendedScope(
+    ArrayRef<Operand *> uses, DeadEndBlocks *deadEndBlocks) const {
+  SILInstruction::OperandUserRange users(uses, SILInstruction::OperandToUser());
+  return areWithinExtendedScope(users, deadEndBlocks);
 }
 
 // The visitor \p func is only called on final scope-ending uses, not reborrows.

lib/SIL/Utils/PrunedLiveness.cpp

@@ -796,14 +796,8 @@ static FunctionTest SSAPrunedLiveness__areUsesWithinBoundary(
 template <typename LivenessWithDefs>
 bool PrunedLiveRange<LivenessWithDefs>::areUsesWithinBoundary(
     ArrayRef<Operand *> uses, DeadEndBlocks *deadEndBlocks) const {
-  assert(asImpl().isInitialized());
-
-  for (auto *use : uses) {
-    auto *user = use->getUser();
-    if (!isWithinBoundary(user, deadEndBlocks))
-      return false;
-  }
-  return true;
+  SILInstruction::OperandUserRange users(uses, SILInstruction::OperandToUser());
+  return areWithinBoundary(users, deadEndBlocks);
 }
 
 template <typename LivenessWithDefs>

lib/SILOptimizer/Mandatory/OptimizeHopToExecutor.cpp

@@ -119,6 +119,12 @@ class OptimizeHopToExecutor {
 /// Search for hop_to_executor instructions and add their operands to \p actors.
 void OptimizeHopToExecutor::collectActors(Actors &actors) {
   int uniqueActorID = 0;
+
+  if (auto isolation = function->getActorIsolation();
+      isolation && isolation->isCallerIsolationInheriting()) {
+    actors[function->maybeGetIsolatedArgument()] = uniqueActorID++;
+  }
+
   for (SILBasicBlock &block : *function) {
     for (SILInstruction &inst : block) {
       if (auto *hop = dyn_cast<HopToExecutorInst>(&inst)) {
@@ -193,10 +199,7 @@ void OptimizeHopToExecutor::solveDataflowBackward() {
 /// Returns true if \p inst is a suspension point or an async call.
 static bool isSuspensionPoint(SILInstruction *inst) {
   if (auto applySite = FullApplySite::isa(inst)) {
-    // NOTE: For 6.2, we consider nonisolated(nonsending) to be a suspension
-    // point, when it really isn't. We do this so that we have a truly
-    // conservative change that does not change output.
-    if (applySite.isAsync())
+    if (applySite.isAsync() && !applySite.isCallerIsolationInheriting())
       return true;
     return false;
   }
@@ -213,8 +216,20 @@ bool OptimizeHopToExecutor::removeRedundantHopToExecutors(const Actors &actors)
 
   // Initialize the dataflow.
   for (BlockState &state : blockStates) {
-    state.entry = (state.block == function->getEntryBlock() ?
-                     BlockState::Unknown : BlockState::NotSet);
+    state.entry = [&]() -> int {
+      if (state.block != function->getEntryBlock()) {
+        return BlockState::NotSet;
+      }
+
+      if (auto isolation = function->getActorIsolation();
+          isolation && isolation->isCallerIsolationInheriting()) {
+        auto *fArg =
+            cast<SILFunctionArgument>(function->maybeGetIsolatedArgument());
+        return actors.lookup(SILValue(fArg));
+      }
+
+      return BlockState::Unknown;
+    }();
     state.intra = BlockState::NotSet;
     for (SILInstruction &inst : *state.block) {
       if (isSuspensionPoint(&inst)) {
@@ -316,44 +331,11 @@ void OptimizeHopToExecutor::updateNeedExecutor(int &needExecutor,
     return;
   }
 
-  // For 6.2 to be conservative, if we are calling a function with
-  // caller_isolation_inheriting isolation, treat the callsite as if the
-  // callsite is an instruction that needs an executor.
-  //
-  // DISCUSSION: The reason why we are doing this is that in 6.2, we are going
-  // to continue treating caller isolation inheriting functions as a suspension
-  // point for the purpose of eliminating redundant hop to executor to not make
-  // this optimization more aggressive. Post 6.2, we will stop treating caller
-  // isolation inheriting functions as suspension points, meaning this code can
-  // be deleted.
-  if (auto fas = FullApplySite::isa(inst);
-      fas && fas.isAsync() && fas.isCallerIsolationInheriting()) {
-    needExecutor = BlockState::ExecutorNeeded;
-    return;
-  }
-
-  // For 6.2, if we are in a caller isolation inheriting function, we need to
-  // treat its return as an executor needing function before
-  // isSuspensionPoint.
-  //
-  // DISCUSSION: We need to do this here since for 6.2, a caller isolation
-  // inheriting function is going to be considered a suspension point to be
-  // conservative and make this optimization strictly more conservative. Post
-  // 6.2, since caller isolation inheriting functions will no longer be
-  // considered suspension points, we will be able to sink this code into needs
-  // executor.
-  if (isa<ReturnInst>(inst)) {
-    if (auto isolation = inst->getFunction()->getActorIsolation();
-        isolation && isolation->isCallerIsolationInheriting()) {
-      needExecutor = BlockState::ExecutorNeeded;
-      return;
-    }
-  }
-
   if (isSuspensionPoint(inst)) {
     needExecutor = BlockState::NoExecutorNeeded;
     return;
   }
+
   if (needsExecutor(inst))
     needExecutor = BlockState::ExecutorNeeded;
 }
@@ -403,6 +385,29 @@ bool OptimizeHopToExecutor::needsExecutor(SILInstruction *inst) {
   if (isa<BeginBorrowInst>(inst) || isa<EndBorrowInst>(inst)) {
     return false;
   }
+
+  // A call to a caller isolation inheriting function does not create dead
+  // executors since caller isolation inheriting functions do not hop in their
+  // prologue.
+  if (auto fas = FullApplySite::isa(inst);
+      fas && fas.isAsync() && fas.isCallerIsolationInheriting()) {
+    return true;
+  }
+
+  // Treat returns from a caller isolation inheriting function as requiring the
+  // liveness of hop to executors before it.
+  //
+  // DISCUSSION: We do this since callers of callee functions with isolation
+  // inheriting isolation are not required to have a hop after the return from
+  // the callee function... so we have no guarantee that there isn't code in the
+  // caller that needs this hop to executor to run on the correct actor.
+  if (isa<ReturnInst>(inst)) {
+    if (auto isolation = inst->getFunction()->getActorIsolation();
+        isolation && isolation->isCallerIsolationInheriting()) {
+      return true;
+    }
+  }
+
   return inst->mayReadOrWriteMemory();
 }
 

lib/SILOptimizer/SemanticARC/CopyValueOpts.cpp

@@ -27,6 +27,7 @@
 #include "swift/SIL/MemAccessUtils.h"
 #include "swift/SIL/OwnershipUtils.h"
 #include "swift/SIL/Projection.h"
+#include "swift/SIL/Test.h"
 
 using namespace swift;
 using namespace swift::semanticarc;
@@ -170,7 +171,7 @@ bool SemanticARCOptVisitor::performGuaranteedCopyValueOptimization(
         return borrowScope.isLocalScope();
       });
 
-  auto destroys = lr.getDestroyingUses();
+  auto destroys = lr.getDestroyingInsts();
   if (destroys.empty() && haveAnyLocalScopes) {
     return false;
   }
@@ -196,8 +197,8 @@ bool SemanticARCOptVisitor::performGuaranteedCopyValueOptimization(
   // block.
   {
     if (llvm::any_of(borrowScopeIntroducers, [&](BorrowedValue borrowScope) {
-          return !borrowScope.areUsesWithinExtendedScope(
-              lr.getAllConsumingUses(), nullptr);
+          return !borrowScope.areWithinExtendedScope(lr.getAllConsumingInsts(),
+                                                     nullptr);
         })) {
       LLVM_DEBUG(llvm::dbgs() << "copy_value is extending borrow introducer "
                                  "lifetime, bailing out\n");
@@ -238,8 +239,8 @@ bool SemanticARCOptVisitor::performGuaranteedCopyValueOptimization(
       }
 
       if (llvm::any_of(borrowScopeIntroducers, [&](BorrowedValue borrowScope) {
-            return !borrowScope.areUsesWithinExtendedScope(
-                phiArgLR.getAllConsumingUses(), nullptr);
+            return !borrowScope.areWithinExtendedScope(
+                phiArgLR.getAllConsumingInsts(), nullptr);
           })) {
         return false;
       }
@@ -828,6 +829,20 @@ bool SemanticARCOptVisitor::tryPerformOwnedCopyValueOptimization(
   return true;
 }
 
+namespace swift::test {
+static FunctionTest SemanticARCOptsCopyValueOptsGuaranteedValueOptTest(
+    "semantic_arc_opts__copy_value_opts__guaranteed_value_opt",
+    [](auto &function, auto &arguments, auto &test) {
+      SemanticARCOptVisitor visitor(function, test.getPassManager(),
+                                    *test.getDeadEndBlocks(),
+                                    /*onlyMandatoryOpts=*/false);
+
+      visitor.performGuaranteedCopyValueOptimization(
+          cast<CopyValueInst>(arguments.takeInstruction()));
+      function.print(llvm::errs());
+    });
+} // end namespace swift::test
+
 //===----------------------------------------------------------------------===//
 //                            Top Level Entrypoint
 //===----------------------------------------------------------------------===//

lib/SILOptimizer/SemanticARC/OwnedToGuaranteedPhiOpt.cpp

@@ -212,7 +212,11 @@ bool swift::semanticarc::tryConvertOwnedPhisToGuaranteedPhis(Context &ctx) {
     SmallVector<std::pair<SILValue, unsigned>, 8> incomingValueUpdates;
     for (auto introducer : ownedValueIntroducers) {
       SILValue v = introducer.value;
-      OwnershipLiveRange lr(v);
+      SmallVector<std::pair<Operand *, SILValue>, 4> extraConsumes;
+      for (auto op : incomingValueOperandList) {
+        extraConsumes.push_back({op.getOperand(), op.getOriginal()});
+      }
+      OwnershipLiveRange lr(v, extraConsumes);
 
       // For now, we only handle copy_value for simplicity.
       //