auto

Author: gottesmm

include/swift/SILOptimizer/Analysis/RegionAnalysis.h

@@ -88,10 +88,14 @@ class BlockPartitionState {
 
   TransferringOperandSetFactory &ptrSetFactory;
 
+  PartitionOpEvaluatorBasic::OperandToTransferringOpMap &opToTransferringOpMap;
+
   BlockPartitionState(SILBasicBlock *basicBlock,
                       PartitionOpTranslator &translator,
                       TransferringOperandSetFactory &ptrSetFactory,
-                      IsolationHistory::Factory &isolationHistoryFactory);
+                      IsolationHistory::Factory &isolationHistoryFactory,
+                      PartitionOpEvaluatorBasic::OperandToTransferringOpMap
+                          &opToTransferringOpMap);
 
 public:
   bool getLiveness() const { return isLive; }
@@ -397,6 +401,8 @@ class RegionAnalysisFunctionInfo {
 
   IsolationHistory::Factory isolationHistoryFactory;
 
+  PartitionOpEvaluatorBasic::OperandToTransferringOpMap opToTransferringOpMap;
+
   // We make this optional to prevent an issue that we have seen on windows when
   // capturing a field in a closure that is used to initialize a different
   // field.
@@ -492,6 +498,12 @@ class RegionAnalysisFunctionInfo {
     return valueMap;
   }
 
+  PartitionOpEvaluatorBasic::OperandToTransferringOpMap &
+  getOpToTransferringOpMap() {
+    assert(supportedFunction && "Unsupported Function?!");
+    return opToTransferringOpMap;
+  }
+
   bool isClosureCaptured(SILValue value, Operand *op);
 
   static SILValue getUnderlyingTrackedValue(SILValue value);

include/swift/SILOptimizer/Utils/PartitionUtils.h

@@ -512,14 +512,21 @@ class TransferringOperand {
     os << "\nUser: " << *getUser();
   }
 
+  void merge(bool newIsClosureCaptured, SILIsolationInfo newIsolationRegionInfo,
+             IsolationHistory newIsolationHistory) {
+    value.setInt(value.getInt() | newIsClosureCaptured);
+    isolationInfo = isolationInfo.merge(newIsolationRegionInfo);
+    isolationHistory.pushCFGHistoryJoin(newIsolationHistory.getHead());
+  }
+
   static void Profile(llvm::FoldingSetNodeID &id, Operand *op,
                       bool isClosureCaptured,
                       SILIsolationInfo isolationRegionInfo,
                       IsolationHistory isolationHistory) {
     id.AddPointer(op);
     id.AddBoolean(isClosureCaptured);
     isolationRegionInfo.Profile(id);
-    id.AddPointer(isolationHistory.getHead());
+    // We purposely do not track if isolation history changed.
   }
 
   void Profile(llvm::FoldingSetNodeID &id) const {
@@ -737,6 +744,17 @@ class Partition {
     fst.canonicalize();
     snd.canonicalize();
 
+    if (fst.regionToTransferredOpMap.size() !=
+        snd.regionToTransferredOpMap.size())
+      return false;
+    for (auto pair : fst.regionToTransferredOpMap) {
+      auto iter = snd.regionToTransferredOpMap.find(pair.first);
+      if (iter == snd.regionToTransferredOpMap.end() ||
+          iter->second != pair.second) {
+        return false;
+      }
+    }
+
     return fst.elementToRegionMap == snd.elementToRegionMap;
   }
 
@@ -1011,16 +1029,21 @@ struct PartitionOpEvaluator {
   using Region = PartitionPrimitives::Region;
   using TransferringOperandSetFactory =
       Partition::TransferringOperandSetFactory;
+  using OperandToTransferringOpMap =
+      llvm::SmallDenseMap<Operand *, TransferringOperand *, 1>;
 
 protected:
   TransferringOperandSetFactory &ptrSetFactory;
+  OperandToTransferringOpMap &operandToTransferringOpMap;
 
   Partition &p;
 
 public:
   PartitionOpEvaluator(Partition &p,
-                       TransferringOperandSetFactory &ptrSetFactory)
-      : ptrSetFactory(ptrSetFactory), p(p) {}
+                       TransferringOperandSetFactory &ptrSetFactory,
+                       OperandToTransferringOpMap &operandToTransferringOpMap)
+      : ptrSetFactory(ptrSetFactory),
+        operandToTransferringOpMap(operandToTransferringOpMap), p(p) {}
 
   /// Call shouldEmitVerboseLogging on our CRTP subclass.
   bool shouldEmitVerboseLogging() const {
@@ -1194,9 +1217,21 @@ struct PartitionOpEvaluator {
       }
 
       // Mark op.getOpArgs()[0] as transferred.
+      auto iter = operandToTransferringOpMap.find(op.getSourceOp());
+      if (iter != operandToTransferringOpMap.end()) {
+        iter->getSecond()->merge(isClosureCapturedElt,
+                                 transferredRegionIsolation,
+                                 p.getIsolationHistory());
+        auto *ptrSet = ptrSetFactory.get(iter->second);
+        p.markTransferred(op.getOpArgs()[0], ptrSet);
+        return;
+      }
+
       auto *ptrSet = ptrSetFactory.emplace(
           op.getSourceOp(), isClosureCapturedElt, transferredRegionIsolation,
           p.getIsolationHistory());
+      TransferringOperand *top = ptrSet->data()[0];
+      operandToTransferringOpMap.insert({op.getSourceOp(), top});
       p.markTransferred(op.getOpArgs()[0], ptrSet);
       return;
     }
@@ -1305,9 +1340,10 @@ struct PartitionOpEvaluatorBaseImpl : PartitionOpEvaluator<Subclass> {
       Partition::TransferringOperandSetFactory;
   using Super = PartitionOpEvaluator<Subclass>;
 
-  PartitionOpEvaluatorBaseImpl(Partition &workingPartition,
-                               TransferringOperandSetFactory &ptrSetFactory)
-      : Super(workingPartition, ptrSetFactory) {}
+  PartitionOpEvaluatorBaseImpl(
+      Partition &workingPartition, TransferringOperandSetFactory &ptrSetFactory,
+      typename Super::OperandToTransferringOpMap &operandToTransferringOpMap)
+      : Super(workingPartition, ptrSetFactory, operandToTransferringOpMap) {}
 
   /// Should we emit extra verbose logging statements when evaluating
   /// PartitionOps.
@@ -1373,9 +1409,12 @@ struct PartitionOpEvaluatorBaseImpl : PartitionOpEvaluator<Subclass> {
 /// behavior.
 struct PartitionOpEvaluatorBasic final
     : PartitionOpEvaluatorBaseImpl<PartitionOpEvaluatorBasic> {
-  PartitionOpEvaluatorBasic(Partition &workingPartition,
-                            TransferringOperandSetFactory &ptrSetFactory)
-      : PartitionOpEvaluatorBaseImpl(workingPartition, ptrSetFactory) {}
+  using Super = PartitionOpEvaluatorBaseImpl<PartitionOpEvaluatorBasic>;
+  PartitionOpEvaluatorBasic(
+      Partition &workingPartition, TransferringOperandSetFactory &ptrSetFactory,
+      Super::OperandToTransferringOpMap &operandToTransferringOpMap)
+      : PartitionOpEvaluatorBaseImpl(workingPartition, ptrSetFactory,
+                                     operandToTransferringOpMap) {}
 };
 
 } // namespace swift

lib/SILOptimizer/Analysis/RegionAnalysis.cpp

@@ -2954,10 +2954,13 @@ TranslationSemantics PartitionOpTranslator::visitCheckedCastAddrBranchInst(
 BlockPartitionState::BlockPartitionState(
     SILBasicBlock *basicBlock, PartitionOpTranslator &translator,
     TransferringOperandSetFactory &ptrSetFactory,
-    IsolationHistory::Factory &isolationHistoryFactory)
+    IsolationHistory::Factory &isolationHistoryFactory,
+    PartitionOpEvaluatorBasic::OperandToTransferringOpMap
+        &operandToTransferringOpMap)
     : entryPartition(isolationHistoryFactory.get()),
       exitPartition(isolationHistoryFactory.get()), basicBlock(basicBlock),
-      ptrSetFactory(ptrSetFactory) {
+      ptrSetFactory(ptrSetFactory),
+      opToTransferringOpMap(operandToTransferringOpMap) {
   translator.translateSILBasicBlock(basicBlock, blockPartitionOps);
 }
 
@@ -2967,12 +2970,15 @@ bool BlockPartitionState::recomputeExitFromEntry(
 
   struct ComputeEvaluator final
       : PartitionOpEvaluatorBaseImpl<ComputeEvaluator> {
+    using Super = PartitionOpEvaluatorBaseImpl<ComputeEvaluator>;
     PartitionOpTranslator &translator;
 
     ComputeEvaluator(Partition &workingPartition,
                      TransferringOperandSetFactory &ptrSetFactory,
-                     PartitionOpTranslator &translator)
-        : PartitionOpEvaluatorBaseImpl(workingPartition, ptrSetFactory),
+                     PartitionOpTranslator &translator,
+                     Super::OperandToTransferringOpMap &opToTransferringOpMap)
+        : PartitionOpEvaluatorBaseImpl(workingPartition, ptrSetFactory,
+                                       opToTransferringOpMap),
           translator(translator) {}
 
     SILIsolationInfo getIsolationRegionInfo(Element elt) const {
@@ -2989,7 +2995,8 @@ bool BlockPartitionState::recomputeExitFromEntry(
       return translator.isClosureCaptured(value, op->getUser());
     }
   };
-  ComputeEvaluator eval(workingPartition, ptrSetFactory, translator);
+  ComputeEvaluator eval(workingPartition, ptrSetFactory, translator,
+                        opToTransferringOpMap);
   for (const auto &partitionOp : blockPartitionOps) {
     // By calling apply without providing any error handling callbacks, errors
     // will be surpressed.  will be suppressed
@@ -3088,7 +3095,7 @@ RegionAnalysisFunctionInfo::RegionAnalysisFunctionInfo(
       PartitionOpTranslator(fn, pofi, valueMap, isolationHistoryFactory);
   blockStates.emplace(fn, [this](SILBasicBlock *block) -> BlockPartitionState {
     return BlockPartitionState(block, *translator, ptrSetFactory,
-                               isolationHistoryFactory);
+                               isolationHistoryFactory, opToTransferringOpMap);
   });
   // Mark all blocks as needing to be updated.
   for (auto &block : *fn) {

lib/SILOptimizer/Mandatory/TransferNonSendable.cpp

@@ -1332,6 +1332,8 @@ namespace {
 
 struct DiagnosticEvaluator final
     : PartitionOpEvaluatorBaseImpl<DiagnosticEvaluator> {
+  using Super = PartitionOpEvaluatorBaseImpl<DiagnosticEvaluator>;
+
   RegionAnalysisFunctionInfo *info;
   SmallFrozenMultiMap<TransferringOperandRef, SILInstruction *, 8>
       &transferOpToRequireInstMultiMap;
@@ -1346,9 +1348,11 @@ struct DiagnosticEvaluator final
       SmallFrozenMultiMap<TransferringOperandRef, SILInstruction *, 8>
           &transferOpToRequireInstMultiMap,
       SmallVectorImpl<TransferredNonTransferrableInfo>
-          &transferredNonTransferrable)
+          &transferredNonTransferrable,
+      Super::OperandToTransferringOpMap &opToTransferringOpMap)
       : PartitionOpEvaluatorBaseImpl(workingPartition,
-                                     info->getOperandSetFactory()),
+                                     info->getOperandSetFactory(),
+                                     opToTransferringOpMap),
         info(info),
         transferOpToRequireInstMultiMap(transferOpToRequireInstMultiMap),
         transferredNonTransferrable(transferredNonTransferrable) {}
@@ -1494,7 +1498,8 @@ void TransferNonSendableImpl::runDiagnosticEvaluator() {
     Partition workingPartition = blockState.getEntryPartition();
     DiagnosticEvaluator eval(workingPartition, regionInfo,
                              transferOpToRequireInstMultiMap,
-                             transferredNonTransferrableInfoList);
+                             transferredNonTransferrableInfoList,
+                             regionInfo->getOpToTransferringOpMap());
 
     // And then evaluate all of our partition ops on the entry partition.
     for (auto &partitionOp : blockState.getPartitionOps()) {