Merge pull request #3739 from swiftwasm/main

[pull] swiftwasm from main

Author: pull[bot]

include/swift/Basic/DAGNodeWorklist.h renamed to include/swift/Basic/GraphNodeWorklist.h

@@ -1,4 +1,4 @@
-//===--- DAGNodeWorklist.h --------------------------------------*- C++ -*-===//
+//===--- GraphNodeWorklist.h ------------------------------------*- C++ -*-===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -10,8 +10,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef SWIFT_BASIC_DAGNODEWORKLIST_H
-#define SWIFT_BASIC_DAGNODEWORKLIST_H
+#ifndef SWIFT_BASIC_GRAPHNODEWORKLIST_H
+#define SWIFT_BASIC_GRAPHNODEWORKLIST_H
 
 #include "swift/Basic/LLVM.h"
 #include "llvm/ADT/SmallPtrSet.h"
@@ -25,23 +25,22 @@
 ///
 /// The primary API has two methods: intialize() and pop(). Others are provided
 /// for flexibility.
-///
-/// TODO: This also works well for cyclic graph traversal. Particularly CFG
-/// traversal. So we should probably just call it GraphNodeWorklist.
-template <typename T, unsigned SmallSize> struct DAGNodeWorklist {
+template <typename T, unsigned SmallSize>
+struct GraphNodeWorklist {
   llvm::SmallPtrSet<T, SmallSize> nodeVisited;
   llvm::SmallVector<T, SmallSize> nodeVector;
 
-  DAGNodeWorklist() = default;
+  GraphNodeWorklist() = default;
 
-  DAGNodeWorklist(const DAGNodeWorklist &) = delete;
+  GraphNodeWorklist(const GraphNodeWorklist &) = delete;
 
   void initialize(T t) {
     clear();
     insert(t);
   }
 
-  template <typename R> void initializeRange(R &&range) {
+  template <typename R>
+  void initializeRange(R &&range) {
     clear();
     nodeVisited.insert(range.begin(), range.end());
     nodeVector.append(range.begin(), range.end());
@@ -64,4 +63,4 @@ template <typename T, unsigned SmallSize> struct DAGNodeWorklist {
   }
 };
 
-#endif // SWIFT_BASIC_DAGNODEWORKLIST_H
+#endif // SWIFT_BASIC_GRAPHNODEWORKLIST_H

include/swift/SILOptimizer/Analysis/EscapeAnalysis.h

@@ -1059,8 +1059,8 @@ class EscapeAnalysis : public BottomUpIPAnalysis {
   // returns an instantiated array struct and unsafe pointer to the elements.
   struct ArrayUninitCall {
     SILValue arrayStorageRef;
-    TupleExtractInst *arrayStruct = nullptr;
-    TupleExtractInst *arrayElementPtr = nullptr;
+    SILValue arrayStruct = nullptr;
+    SILValue arrayElementPtr = nullptr;
 
     bool isValid() const {
       return arrayStorageRef && arrayStruct && arrayElementPtr;
@@ -1072,9 +1072,9 @@ class EscapeAnalysis : public BottomUpIPAnalysis {
   ArrayUninitCall
   canOptimizeArrayUninitializedCall(ApplyInst *ai);
 
-  /// Return true of this tuple_extract is the result of an optimizable
+  /// Return true of this tuple_extract/destructure_tuple is the result of an optimizable
   /// @_semantics("array.uninitialized") call.
-  bool canOptimizeArrayUninitializedResult(TupleExtractInst *tei);
+  bool canOptimizeArrayUninitializedResult(SILInstruction *tei);
 
   /// Handle a call to "@_semantics(array.uninitialized") precisely by mapping
   /// each call result to a separate graph node and relating them to the

include/swift/SILOptimizer/Utils/CanonicalOSSALifetime.h

@@ -96,7 +96,7 @@
 #ifndef SWIFT_SILOPTIMIZER_UTILS_CANONICALOSSALIFETIME_H
 #define SWIFT_SILOPTIMIZER_UTILS_CANONICALOSSALIFETIME_H
 
-#include "swift/Basic/DAGNodeWorklist.h"
+#include "swift/Basic/GraphNodeWorklist.h"
 #include "swift/Basic/SmallPtrSetVector.h"
 #include "swift/SIL/PrunedLiveness.h"
 #include "swift/SIL/SILInstruction.h"
@@ -271,10 +271,10 @@ class CanonicalizeOSSALifetime {
   llvm::SmallPtrSet<DebugValueInst *, 8> debugValues;
 
   /// Visited set for general def-use traversal that prevents revisiting values.
-  DAGNodeWorklist<SILValue, 8> defUseWorklist;
+  GraphNodeWorklist<SILValue, 8> defUseWorklist;
 
   /// Visited set general CFG traversal that prevents revisiting blocks.
-  DAGNodeWorklist<SILBasicBlock *, 8> blockWorklist;
+  GraphNodeWorklist<SILBasicBlock *, 8> blockWorklist;
 
   /// Pruned liveness for the extended live range including copies. For this
   /// purpose, only consuming instructions are considered "lifetime

include/swift/SILOptimizer/Utils/CanonicalizeBorrowScope.h

@@ -27,7 +27,7 @@
 #ifndef SWIFT_SILOPTIMIZER_UTILS_CANONICALIZEBORROWSCOPES_H
 #define SWIFT_SILOPTIMIZER_UTILS_CANONICALIZEBORROWSCOPES_H
 
-#include "swift/Basic/DAGNodeWorklist.h"
+#include "swift/Basic/GraphNodeWorklist.h"
 #include "swift/Basic/SmallPtrSetVector.h"
 #include "swift/SIL/OwnershipUtils.h"
 #include "swift/SIL/PrunedLiveness.h"
@@ -69,10 +69,10 @@ class CanonicalizeBorrowScope {
   InstructionDeleter &deleter;
 
   /// Visited set for general def-use traversal that prevents revisiting values.
-  DAGNodeWorklist<SILValue, 8> defUseWorklist;
+  GraphNodeWorklist<SILValue, 8> defUseWorklist;
 
   /// Visited set general CFG traversal that prevents revisiting blocks.
-  DAGNodeWorklist<SILBasicBlock *, 8> blockWorklist;
+  GraphNodeWorklist<SILBasicBlock *, 8> blockWorklist;
 
   /// Record any copies outside the borrow scope that were updated. This
   /// includes the outer copy that us used by outer uses and copies for any

include/swift/SILOptimizer/Utils/OwnershipOptUtils.h

@@ -148,11 +148,10 @@ struct OwnershipFixupContext {
   InstModCallbacks &callbacks;
   DeadEndBlocks &deBlocks;
 
-
-  // FIXME: remove these two vectors once BorrowedLifetimeExtender is used
-  // everywhere.
-  SmallVector<Operand *, 8> transitiveBorrowedUses;
-  SmallVector<PhiOperand, 8> recursiveReborrows;
+  // Cache the use-points for the lifetime of an inner guaranteed value (which
+  // does not introduce a borrow scope) after checking validity. These will be
+  // used again to extend the lifetime of the replacement value.
+  SmallVector<Operand *, 8> guaranteedUsePoints;
 
   /// Extra state initialized by OwnershipRAUWFixupHelper::get() that we use
   /// when RAUWing addresses. This ensures we do not need to recompute this
@@ -162,6 +161,8 @@ struct OwnershipFixupContext {
     /// compute all transitive address uses of oldValue. If we find that we do
     /// need this fixed up, then we will copy our interior pointer base value
     /// and use this to seed that new lifetime.
+    ///
+    /// FIXME: shouldn't these already be covered by guaranteedUsePoints?
     SmallVector<Operand *, 8> allAddressUsesFromOldValue;
 
     /// This is the interior pointer (e.g. ref_element_addr)
@@ -184,8 +185,7 @@ struct OwnershipFixupContext {
       : callbacks(callbacks), deBlocks(deBlocks) {}
 
   void clear() {
-    transitiveBorrowedUses.clear();
-    recursiveReborrows.clear();
+    guaranteedUsePoints.clear();
     extraAddressFixupInfo.allAddressUsesFromOldValue.clear();
     extraAddressFixupInfo.base = AccessBase();
   }
@@ -212,6 +212,8 @@ class OwnershipRAUWHelper {
 private:
   OwnershipFixupContext *ctx;
   SILValue oldValue;
+  // newValue is the aspirational replacement. It might not be the actual
+  // replacement after SILCombine fixups (like type casting) and OSSA fixups.
   SILValue newValue;
 
 public:
@@ -253,21 +255,27 @@ class OwnershipRAUWHelper {
   /// Perform OSSA fixup on newValue and return a fixed-up value based that can
   /// be used to replace all uses of oldValue.
   ///
-  /// This is so that we can avoid creating "forwarding" transformation
-  /// instructions before we know if we can perform the RAUW. Any such
-  /// "forwarding" transformation must be performed upon \p newValue at \p
-  /// oldValue's insertion point so that we can then here RAUW the transformed
-  /// \p newValue.
+  /// This is only used by clients that must transform \p newValue, such as
+  /// adding type casts, before it can be used to replace \p oldValue.
+  ///
+  /// \p rewrittenNewValue is only passed when the client needs to regenerate
+  /// newValue after checking its RAUW validity, but before performing OSSA
+  /// fixup on it.
+  SILValue prepareReplacement(SILValue rewrittenNewValue = SILValue());
+
+  /// Perform the actual RAUW--replace all uses if \p oldValue.
+  ///
+  /// Precondition: \p replacementValue is either invalid or has the same type
+  /// as \p oldValue and is a valid OSSA replacement.
   SILBasicBlock::iterator
-  perform(SingleValueInstruction *maybeTransformedNewValue = nullptr);
+  perform(SILValue replacementValue = SILValue());
 
 private:
-  SILBasicBlock::iterator replaceAddressUses(SingleValueInstruction *oldValue,
-                                             SILValue newValue);
-
   void invalidate() {
     ctx = nullptr;
   }
+
+  SILValue getReplacementAddress();
 };
 
 /// A utility composed ontop of OwnershipFixupContext that knows how to replace

lib/Driver/DarwinToolChains.cpp

@@ -600,11 +600,11 @@ toolchains::Darwin::addDeploymentTargetArgs(ArgStringList &Arguments,
         micro = 0;
       }
 
-      // Mac Catalyst was introduced with an iOS deployment target of 13.0;
+      // Mac Catalyst was introduced with an iOS deployment target of 13.1;
       // the linker doesn't want to see a deployment target before that.
       if (major < 13) {
         major = 13;
-        minor = 0;
+        minor = 1;
         micro = 0;
       }
     } else {

lib/SIL/Utils/OwnershipUtils.cpp

@@ -11,9 +11,8 @@
 //===----------------------------------------------------------------------===//
 
 #include "swift/SIL/OwnershipUtils.h"
-#include "swift/Basic/DAGNodeWorklist.h"
 #include "swift/Basic/Defer.h"
-#include "swift/Basic/DAGNodeWorklist.h"
+#include "swift/Basic/GraphNodeWorklist.h"
 #include "swift/Basic/SmallPtrSetVector.h"
 #include "swift/SIL/InstructionUtils.h"
 #include "swift/SIL/LinearLifetimeChecker.h"
@@ -179,7 +178,7 @@ bool swift::findInnerTransitiveGuaranteedUses(
   // grow exponentially without the membership check. It's fine to do this
   // membership check locally in this function (within a borrow scope) because
   // it isn't needed for the immediate uses, only the transitive uses.
-  DAGNodeWorklist<Operand *, 8> worklist;
+  GraphNodeWorklist<Operand *, 8> worklist;
   for (Operand *use : guaranteedValue->getUses()) {
     if (use->getOperandOwnership() != OperandOwnership::NonUse)
       worklist.insert(use);
@@ -1438,7 +1437,7 @@ void swift::findTransitiveReborrowBaseValuePairs(
 void swift::visitTransitiveEndBorrows(
     BorrowedValue beginBorrow,
     function_ref<void(EndBorrowInst *)> visitEndBorrow) {
-  DAGNodeWorklist<SILValue, 4> worklist;
+  GraphNodeWorklist<SILValue, 4> worklist;
   worklist.insert(beginBorrow.value);
 
   while (!worklist.empty()) {

lib/SILOptimizer/Analysis/EscapeAnalysis.cpp

@@ -250,6 +250,14 @@ SILValue EscapeAnalysis::getPointerBase(SILValue value) {
     }
     return pointerOperand;
   }
+  case ValueKind::MultipleValueInstructionResult: {
+    if (auto *dt = dyn_cast<DestructureTupleInst>(value)) {
+      if (canOptimizeArrayUninitializedResult(dt))
+        return SILValue();
+      return dt->getOperand();
+    }
+    return SILValue();
+  }
   default:
     return SILValue();
   }
@@ -1939,6 +1947,11 @@ EscapeAnalysis::canOptimizeArrayUninitializedCall(ApplyInst *ai) {
         continue;
       }
     }
+    if (auto *dt = dyn_cast<DestructureTupleInst>(use->getUser())) {
+      call.arrayStruct = dt->getResult(0);
+      call.arrayElementPtr = dt->getResult(1);
+      continue;
+    }
     // If there are any other uses, such as a release_value, erase the previous
     // call info and bail out.
     call.arrayStruct = nullptr;
@@ -1957,8 +1970,9 @@ EscapeAnalysis::canOptimizeArrayUninitializedCall(ApplyInst *ai) {
 }
 
 bool EscapeAnalysis::canOptimizeArrayUninitializedResult(
-    TupleExtractInst *tei) {
-  ApplyInst *ai = dyn_cast<ApplyInst>(tei->getOperand());
+    SILInstruction *extract) {
+  assert(isa<TupleExtractInst>(extract) || isa<DestructureTupleInst>(extract));
+  ApplyInst *ai = dyn_cast<ApplyInst>(extract->getOperand(0));
   if (!ai)
     return false;
 
@@ -2362,11 +2376,17 @@ void EscapeAnalysis::analyzeInstruction(SILInstruction *I,
       // This is a tuple_extract which extracts the second result of an
       // array.uninitialized call (otherwise getPointerBase should have already
       // looked through it).
-      auto *TEI = cast<TupleExtractInst>(I);
-      assert(canOptimizeArrayUninitializedResult(TEI)
+      assert(canOptimizeArrayUninitializedResult(I)
              && "tuple_extract should be handled as projection");
       return;
     }
+    case SILInstructionKind::DestructureTupleInst: {
+      if (canOptimizeArrayUninitializedResult(I)) {
+        return;
+      }
+      setAllEscaping(I, ConGraph);
+      return;
+    }
     case SILInstructionKind::UncheckedRefCastAddrInst: {
       auto *URCAI = cast<UncheckedRefCastAddrInst>(I);
       CGNode *SrcNode = ConGraph->getNode(URCAI->getSrc());