- fixes

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/Utilities/OwnershipLiveness.swift

@@ -803,7 +803,7 @@ extension InteriorUseWalker {
     }
     var enclosingValues = Stack<Value>(context)
     defer { enclosingValues.deinitialize() }
-    gatherEnclosingValues(for: guaranteedPhi.value, in: &enclosingValues,
+    gatherEnclosingValues(for: guaranteedPhi.value.lookThroughBorrowedFromUser, in: &enclosingValues,
                           context)
     guard enclosingValues.contains(definingValue) else {
       // Since definingValue is not an enclosing value, it must be

SwiftCompilerSources/Sources/Optimizer/Utilities/Verifier.swift

@@ -58,7 +58,7 @@ private extension Argument {
       var forwardingBorrowedFromFound = false
       for use in phi.value.uses {
         precondition(use.instruction is BorrowedFromInst,
-                     "guaranteed phi \(self) has non borrowed-from use \(use)")
+                     "guaranteed phi: \(self)\n has non borrowed-from use: \(use)")
         if use.index == 0 {
           precondition(!forwardingBorrowedFromFound, "phi \(self) has multiple forwarding borrowed-from uses")
           forwardingBorrowedFromFound = true

include/swift/SILOptimizer/Utils/Devirtualize.h

@@ -68,7 +68,7 @@ SubstitutionMap getWitnessMethodSubstitutions(SILModule &Module, ApplySite AI,
 ///
 /// Return the new apply and true if the CFG was also modified.
 std::pair<ApplySite, bool>
-tryDevirtualizeApply(ApplySite AI, ClassHierarchyAnalysis *CHA,
+tryDevirtualizeApply(SILPassManager *pm, ApplySite AI, ClassHierarchyAnalysis *CHA,
                      OptRemark::Emitter *ORE = nullptr,
                      bool isMandatory = false);
 bool canDevirtualizeApply(FullApplySite AI, ClassHierarchyAnalysis *CHA);
@@ -86,7 +86,8 @@ CanType getSelfInstanceType(CanType ClassOrMetatypeType);
 ///
 /// Return the new apply and true if the CFG was also modified.
 std::pair<FullApplySite, bool>
-devirtualizeClassMethod(FullApplySite AI, SILValue ClassInstance, ClassDecl *CD,
+devirtualizeClassMethod(SILPassManager *pm,
+                        FullApplySite AI, SILValue ClassInstance, ClassDecl *CD,
                         CanType classType, OptRemark::Emitter *ORE);
 
 /// Attempt to devirtualize the given apply site, which is known to be
@@ -97,7 +98,8 @@ devirtualizeClassMethod(FullApplySite AI, SILValue ClassInstance, ClassDecl *CD,
 ///
 /// Return the new apply and true if the CFG was also modified.
 std::pair<FullApplySite, bool>
-tryDevirtualizeClassMethod(FullApplySite AI, SILValue ClassInstance,
+tryDevirtualizeClassMethod(SILPassManager *pm,
+                           FullApplySite AI, SILValue ClassInstance,
                            ClassDecl *CD, CanType ClassType,
                            OptRemark::Emitter *ORE,
                            bool isEffectivelyFinalMethod = false);
@@ -110,7 +112,8 @@ tryDevirtualizeClassMethod(FullApplySite AI, SILValue ClassInstance,
 /// the original apply site.
 ///
 /// Return the new apply and true if the CFG was also modified.
-std::pair<ApplySite, bool> tryDevirtualizeWitnessMethod(ApplySite AI,
+std::pair<ApplySite, bool> tryDevirtualizeWitnessMethod(SILPassManager *pm,
+                                                        ApplySite AI,
                                                         OptRemark::Emitter *ORE,
                                                         bool isMandatory);
 

include/swift/SILOptimizer/Utils/InstOptUtils.h

@@ -192,7 +192,8 @@ SILValue getConcreteValueOfExistentialBoxAddr(SILValue addr,
 /// BranchInst (a phi is never the last guaranteed user). \p builder's current
 /// insertion point must dominate all \p usePoints.
 std::pair<SILValue, bool /* changedCFG */>
-castValueToABICompatibleType(SILBuilder *builder, SILLocation Loc,
+castValueToABICompatibleType(SILBuilder *builder, SILPassManager *pm,
+                             SILLocation Loc,
                              SILValue value, SILType srcTy, SILType destTy,
                              ArrayRef<SILInstruction *> usePoints);
 /// Peek through trivial Enum initialization, typically for pointless

lib/SILOptimizer/Mandatory/MandatoryInlining.cpp

@@ -772,9 +772,9 @@ getCalleeFunction(SILFunction *F, FullApplySite AI, bool &IsThick,
   return CalleeFunction;
 }
 
-static SILInstruction *tryDevirtualizeApplyHelper(FullApplySite InnerAI,
+static SILInstruction *tryDevirtualizeApplyHelper(SILPassManager *pm, FullApplySite InnerAI,
                                                   ClassHierarchyAnalysis *CHA) {
-  auto NewInst = tryDevirtualizeApply(InnerAI, CHA).first;
+  auto NewInst = tryDevirtualizeApply(pm, InnerAI, CHA).first;
   if (!NewInst)
     return InnerAI.getInstruction();
 
@@ -804,7 +804,8 @@ static SILInstruction *tryDevirtualizeApplyHelper(FullApplySite InnerAI,
 ///
 /// \returns true if successful, false if failed due to circular inlining.
 static bool
-runOnFunctionRecursively(SILOptFunctionBuilder &FuncBuilder, SILFunction *F,
+runOnFunctionRecursively(SILOptFunctionBuilder &FuncBuilder, SILPassManager *pm,
+                         SILFunction *F,
                          FullApplySite AI, DenseFunctionSet &FullyInlinedSet,
                          ImmutableFunctionSet::Factory &SetFactory,
                          ImmutableFunctionSet CurrentInliningSet,
@@ -855,7 +856,7 @@ runOnFunctionRecursively(SILOptFunctionBuilder &FuncBuilder, SILFunction *F,
       // *NOTE* If devirtualization succeeds, devirtInst may not be InnerAI,
       // but a casted result of InnerAI or even a block argument due to
       // abstraction changes when calling the witness or class method.
-      auto *devirtInst = tryDevirtualizeApplyHelper(InnerAI, CHA);
+      auto *devirtInst = tryDevirtualizeApplyHelper(pm, InnerAI, CHA);
       // If devirtualization succeeds, make sure we record that this function
       // changed.
       if (devirtInst != InnerAI.getInstruction())
@@ -879,7 +880,7 @@ runOnFunctionRecursively(SILOptFunctionBuilder &FuncBuilder, SILFunction *F,
 
       // Then recursively process it first before trying to inline it.
       if (!runOnFunctionRecursively(
-              FuncBuilder, CalleeFunction, InnerAI, FullyInlinedSet, SetFactory,
+              FuncBuilder, pm, CalleeFunction, InnerAI, FullyInlinedSet, SetFactory,
               CurrentInliningSet, CHA, changedFunctions)) {
         // If we failed due to circular inlining, then emit some notes to
         // trace back the failure if we have more information.
@@ -1040,7 +1041,7 @@ class MandatoryInlining : public SILModuleTransform {
       if (F.wasDeserializedCanonical())
         continue;
 
-      runOnFunctionRecursively(FuncBuilder, &F, FullApplySite(),
+      runOnFunctionRecursively(FuncBuilder, getPassManager(), &F, FullApplySite(),
                                FullyInlinedSet, SetFactory,
                                SetFactory.getEmptySet(), CHA, changedFunctions);
 

lib/SILOptimizer/PassManager/PassManager.cpp

@@ -1566,8 +1566,9 @@ bool BridgedPassContext::tryDeleteDeadClosure(BridgedInstruction closure, bool n
 
 BridgedPassContext::DevirtResult BridgedPassContext::tryDevirtualizeApply(BridgedInstruction apply,
                                                                           bool isMandatory) const {
-  auto cha = invocation->getPassManager()->getAnalysis<ClassHierarchyAnalysis>();
-  auto result = ::tryDevirtualizeApply(ApplySite(apply.unbridged()), cha,
+  SILPassManager *pm = invocation->getPassManager();
+  auto cha = pm->getAnalysis<ClassHierarchyAnalysis>();
+  auto result = ::tryDevirtualizeApply(pm, ApplySite(apply.unbridged()), cha,
                                        nullptr, isMandatory);
   if (result.first) {
     OptionalBridgedInstruction newApply(result.first.getInstruction()->asSILNode());

lib/SILOptimizer/SILCombiner/SILCombinerMiscVisitors.cpp

@@ -1995,7 +1995,8 @@ SILCombiner::visitDifferentiableFunctionExtractInst(DifferentiableFunctionExtrac
       return nullptr;
 
     std::tie(newValue, std::ignore) =
-      castValueToABICompatibleType(&Builder, DFEI->getLoc(),
+      castValueToABICompatibleType(&Builder, parentTransform->getPassManager(),
+                                   DFEI->getLoc(),
                                    newValue,
                                    newValue->getType(), DFEI->getType(), {});
   }

lib/SILOptimizer/Transforms/Devirtualizer.cpp

@@ -78,7 +78,7 @@ void Devirtualizer::devirtualizeAppliesInFunction(SILFunction &F,
   for (auto Apply : Applies) {
     ApplySite NewInst;
     bool modifiedCFG;
-    std::tie(NewInst, modifiedCFG) = tryDevirtualizeApply(Apply, CHA, &ORE);
+    std::tie(NewInst, modifiedCFG) = tryDevirtualizeApply(getPassManager(), Apply, CHA, &ORE);
     if (!NewInst)
       continue;
 

lib/SILOptimizer/Transforms/SimplifyCFG.cpp

@@ -2186,11 +2186,13 @@ bool SimplifyCFG::simplifySwitchEnumBlock(SwitchEnumInst *SEI) {
                                                 EnumCase.get());
     }
     Builder.createBranch(loc, LiveBlock, PayLoad);
+    SEI->eraseFromParent();
+    updateBorrowedFromPhis(PM, { cast<SILPhiArgument>(LiveBlock->getArgument(0)) });
   } else {
     Builder.createBranch(loc, LiveBlock);
+    SEI->eraseFromParent();
   }
 
-  SEI->eraseFromParent();
   if (EI && isInstructionTriviallyDead(EI)) {
     EI->replaceAllUsesOfAllResultsWithUndef();
     EI->eraseFromParent();
@@ -2571,7 +2573,7 @@ bool SimplifyCFG::simplifyTryApplyBlock(TryApplyInst *TAI) {
       }
       // Cast argument if required.
       std::tie(Arg, std::ignore) = castValueToABICompatibleType(
-          &Builder, TAI->getLoc(), Arg, origConv.getSILArgumentType(i, context),
+          &Builder, PM, TAI->getLoc(), Arg, origConv.getSILArgumentType(i, context),
           targetConv.getSILArgumentType(calleeArgIdx, context), {TAI});
       Args.push_back(Arg);
       calleeArgIdx += 1;
@@ -2606,7 +2608,7 @@ bool SimplifyCFG::simplifyTryApplyBlock(TryApplyInst *TAI) {
     // Non-guaranteed values don't need use points when casting.
     SILValue CastedResult;
     std::tie(CastedResult, std::ignore) = castValueToABICompatibleType(
-      &Builder, Loc, NewAI, ResultTy, OrigResultTy, /*usePoints*/ {});
+      &Builder, PM, Loc, NewAI, ResultTy, OrigResultTy, /*usePoints*/ {});
 
     BranchInst *branch = Builder.createBranch(Loc, NormalBB, { CastedResult });
 
@@ -3704,7 +3706,7 @@ bool SimplifyCFG::simplifyArgument(SILBasicBlock *BB, unsigned i) {
   if (!A->hasOneUse())
     return false;
 
-  auto *Use = *A->use_begin();
+  auto *Use = *lookThroughBorrowedFromUser(A)->use_begin();
   auto *User = Use->getUser();
 
   auto disableInOSSA = [](SingleValueInstruction *inst) {
@@ -3750,6 +3752,10 @@ bool SimplifyCFG::simplifyArgument(SILBasicBlock *BB, unsigned i) {
   // Okay, we'll replace the BB arg with one with the right type, replace
   // the uses in this block, and then rewrite the branch operands.
   LLVM_DEBUG(llvm::dbgs() << "unwrap argument:" << *A);
+  if (auto *bfi = getBorrowedFromUser(A)) {
+    bfi->replaceAllUsesWith(A);
+    bfi->eraseFromParent();
+  }
   A->replaceAllUsesWith(SILUndef::get(A->getType(), *BB->getParent()));
   auto *NewArg = BB->replacePhiArgument(i, proj->getType(),
                                         BB->getArgument(i)->getOwnershipKind());
@@ -3772,6 +3778,8 @@ bool SimplifyCFG::simplifyArgument(SILBasicBlock *BB, unsigned i) {
 
   proj->eraseFromParent();
 
+  updateBorrowedFromPhis(PM, { NewArg });
+
   return true;
 }
 

lib/SILOptimizer/Transforms/SpeculativeDevirtualizer.cpp

@@ -122,7 +122,7 @@ static FullApplySite CloneApply(FullApplySite AI, SILValue SelfArg,
 
 /// Insert monomorphic inline caches for a specific class or metatype
 /// type \p SubClassTy.
-static FullApplySite speculateMonomorphicTarget(FullApplySite AI,
+static FullApplySite speculateMonomorphicTarget(SILPassManager *pm, FullApplySite AI,
                                                 CanType SubType, ClassDecl *CD,
                                                 CanType ClassType,
                                                 CheckedCastBranchInst *&CCBI) {
@@ -228,7 +228,7 @@ static FullApplySite speculateMonomorphicTarget(FullApplySite AI,
   ++NumTargetsPredicted;
 
   // Devirtualize the apply instruction on the identical path.
-  auto NewInst = devirtualizeClassMethod(IdenAI, DownCastedClassInstance, CD,
+  auto NewInst = devirtualizeClassMethod(pm, IdenAI, DownCastedClassInstance, CD,
                                          ClassType, nullptr)
                      .first;
   assert(NewInst && "Expected to be able to devirtualize apply!");
@@ -378,7 +378,7 @@ static bool isDefaultCaseKnown(ClassHierarchyAnalysis *CHA,
 
 /// Try to speculate the call target for the call \p AI. This function
 /// returns true if a change was made.
-static bool tryToSpeculateTarget(FullApplySite AI, ClassHierarchyAnalysis *CHA,
+static bool tryToSpeculateTarget(SILPassManager *pm, FullApplySite AI, ClassHierarchyAnalysis *CHA,
                                  OptRemark::Emitter &ORE) {
   ClassMethodInst *CMI = cast<ClassMethodInst>(AI.getCallee());
 
@@ -409,7 +409,7 @@ static bool tryToSpeculateTarget(FullApplySite AI, ClassHierarchyAnalysis *CHA,
     ClassHierarchyAnalysis::ClassList Subs;
     if (isDefaultCaseKnown(CHA, AI, CD, Subs)) {
       auto NewInst =
-          tryDevirtualizeClassMethod(AI, SubTypeValue, CD, ClassType, &ORE)
+          tryDevirtualizeClassMethod(pm, AI, SubTypeValue, CD, ClassType, &ORE)
               .first;
       if (NewInst)
         deleteDevirtualizedApply(AI);
@@ -418,7 +418,7 @@ static bool tryToSpeculateTarget(FullApplySite AI, ClassHierarchyAnalysis *CHA,
 
     LLVM_DEBUG(llvm::dbgs() << "Inserting monomorphic speculative call for "
                "class " << CD->getName() << "\n");
-    return !!speculateMonomorphicTarget(AI, SubType, CD, ClassType, LastCCBI);
+    return !!speculateMonomorphicTarget(pm, AI, SubType, CD, ClassType, LastCCBI);
   }
 
   // True if any instructions were changed or generated.
@@ -454,7 +454,7 @@ static bool tryToSpeculateTarget(FullApplySite AI, ClassHierarchyAnalysis *CHA,
   }
 
   auto FirstAI =
-      speculateMonomorphicTarget(AI, SubType, CD, ClassType, LastCCBI);
+      speculateMonomorphicTarget(pm, AI, SubType, CD, ClassType, LastCCBI);
   if (FirstAI) {
     Changed = true;
     AI = FirstAI;
@@ -516,7 +516,7 @@ static bool tryToSpeculateTarget(FullApplySite AI, ClassHierarchyAnalysis *CHA,
     }
 
     // Pass the metatype of the subclass.
-    auto NewAI = speculateMonomorphicTarget(AI, ClassOrMetatypeType, S,
+    auto NewAI = speculateMonomorphicTarget(pm, AI, ClassOrMetatypeType, S,
                                             CanClassType, LastCCBI);
     if (!NewAI) {
       ++NotHandledSubsNum;
@@ -573,7 +573,7 @@ static bool tryToSpeculateTarget(FullApplySite AI, ClassHierarchyAnalysis *CHA,
     return true;
   }
   auto NewInst =
-      tryDevirtualizeClassMethod(AI, SubTypeValue, CD, ClassType, nullptr)
+      tryDevirtualizeClassMethod(pm, AI, SubTypeValue, CD, ClassType, nullptr)
           .first;
   if (NewInst) {
     ORE.emit(RB);
@@ -622,7 +622,7 @@ namespace {
       OptRemark::Emitter ORE(DEBUG_TYPE, CurFn);
       // Go over the collected calls and try to insert speculative calls.
       for (auto AI : ToSpecialize)
-        Changed |= tryToSpeculateTarget(AI, CHA, ORE);
+        Changed |= tryToSpeculateTarget(getPassManager(), AI, CHA, ORE);
 
       if (Changed) {
         CurFn.getModule().linkFunction(&CurFn, SILModule::LinkingMode::LinkAll);