Merge pull request swiftlang#30957 from eeckstein/fix-large-string-arrays

Several compile time fixes related to large string arrays.

Author: eeckstein

include/swift/AST/SILOptions.h

@@ -73,6 +73,9 @@ class SILOptions {
   /// Controls whether or not paranoid verification checks are run.
   bool VerifyAll = false;
 
+  /// If true, no SIL verification is done at all.
+  bool VerifyNone = false;
+
   /// Are we debugging sil serialization.
   bool DebugSerialization = false;
 

include/swift/Option/FrontendOptions.td

@@ -550,6 +550,9 @@ def sil_merge_partial_modules : Flag<["-"], "sil-merge-partial-modules">,
 def sil_verify_all : Flag<["-"], "sil-verify-all">,
   HelpText<"Verify SIL after each transform">;
 
+def sil_verify_none : Flag<["-"], "sil-verify-none">,
+  HelpText<"Completely disable SIL verification">;
+  
 def verify_all_substitution_maps : Flag<["-"], "verify-all-substitution-maps">,
   HelpText<"Verify all SubstitutionMaps on construction">;
 

include/swift/SIL/SILBasicBlock.h

@@ -110,6 +110,10 @@ public llvm::ilist_node<SILBasicBlock>, public SILAllocated<SILBasicBlock> {
     InstList.splice(end(), Other->InstList);
   }
 
+  void spliceAtBegin(SILBasicBlock *Other) {
+    InstList.splice(begin(), Other->InstList);
+  }
+
   bool empty() const { return InstList.empty(); }
   iterator begin() { return InstList.begin(); }
   iterator end() { return InstList.end(); }
@@ -202,6 +206,8 @@ public llvm::ilist_node<SILBasicBlock>, public SILAllocated<SILBasicBlock> {
 
   void cloneArgumentList(SILBasicBlock *Other);
 
+  void moveArgumentList(SILBasicBlock *from);
+
   /// Erase a specific argument from the arg list.
   void eraseArgument(int Index);
 

include/swift/SIL/SILInstructionWorklist.h

@@ -72,6 +72,9 @@ class SILInstructionWorklist : SILInstructionWorklistBase {
   /// Returns true if the worklist is empty.
   bool isEmpty() const { return worklist.empty(); }
 
+  /// Returns the number of elements in the worklist.
+  unsigned size() const { return worklist.size(); }
+
   /// Add the specified instruction to the worklist if it isn't already in it.
   void add(SILInstruction *instruction) {
     if (worklist.insert(instruction).second) {

include/swift/SILOptimizer/Analysis/EscapeAnalysis.h

@@ -652,6 +652,9 @@ class EscapeAnalysis : public BottomUpIPAnalysis {
     /// True if this is a summary graph.
     bool isSummaryGraph;
 
+    /// True if the graph could be computed.
+    bool valid = true;
+
     /// Track the currently active intrusive worklist -- one at a time.
     CGNodeWorklist *activeWorklist = nullptr;
 
@@ -859,6 +862,22 @@ class EscapeAnalysis : public BottomUpIPAnalysis {
     bool forwardTraverseDefer(CGNode *startNode, CGNodeVisitor &&visitor);
 
   public:
+  
+    /// Returns true if the graph could be computed.
+    ///
+    /// For very large functions (> 10000 nodes), graphs are not cumputed to
+    /// avoid quadratic complexity of the node merging algorithm.
+    bool isValid() const {
+      assert((valid || isEmpty()) && "invalid graph must not contain nodes");
+      return valid;
+    }
+    
+    /// Invalides the graph in case it's getting too large.
+    void invalidate() {
+      clear();
+      valid = false;
+    }
+  
     /// Get the content node pointed to by \p ptrVal.
     ///
     /// If \p ptrVal cannot be mapped to a node, return nullptr.
@@ -1045,8 +1064,7 @@ class EscapeAnalysis : public BottomUpIPAnalysis {
   /// If \p ai is an optimizable @_semantics("array.uninitialized") call, return
   /// valid call information.
   ArrayUninitCall
-  canOptimizeArrayUninitializedCall(ApplyInst *ai,
-                                    const ConnectionGraph *conGraph);
+  canOptimizeArrayUninitializedCall(ApplyInst *ai);
 
   /// Return true of this tuple_extract is the result of an optimizable
   /// @_semantics("array.uninitialized") call.

lib/Frontend/CompilerInvocation.cpp

@@ -984,6 +984,7 @@ static bool ParseSILArgs(SILOptions &Opts, ArgList &Args,
   Opts.DisableSILPerfOptimizations |= Args.hasArg(OPT_disable_sil_perf_optzns);
   Opts.CrossModuleOptimization |= Args.hasArg(OPT_CrossModuleOptimization);
   Opts.VerifyAll |= Args.hasArg(OPT_sil_verify_all);
+  Opts.VerifyNone |= Args.hasArg(OPT_sil_verify_none);
   Opts.DebugSerialization |= Args.hasArg(OPT_sil_debug_serialization);
   Opts.EmitVerboseSIL |= Args.hasArg(OPT_emit_verbose_sil);
   Opts.EmitSortedSIL |= Args.hasArg(OPT_emit_sorted_sil);

lib/SIL/IR/SILBasicBlock.cpp

@@ -142,6 +142,13 @@ void SILBasicBlock::cloneArgumentList(SILBasicBlock *Other) {
   }
 }
 
+void SILBasicBlock::moveArgumentList(SILBasicBlock *from) {
+  ArgumentList = std::move(from->ArgumentList);
+  for (SILArgument *arg : getArguments()) {
+    arg->parentBlock = this;
+  }
+}
+
 SILFunctionArgument *
 SILBasicBlock::createFunctionArgument(SILType Ty, const ValueDecl *D,
                                       bool disableEntryBlockVerification) {

lib/SIL/Verifier/SILVerifier.cpp

@@ -5232,33 +5232,37 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
 //                     Out of Line Verifier Run Functions
 //===----------------------------------------------------------------------===//
 
+static bool verificationEnabled(const SILModule &M) {
+#ifdef NDEBUG
+  if (!M.getOptions().VerifyAll)
+    return false;
+#endif
+  return !M.getOptions().VerifyNone;
+}
+
 /// verify - Run the SIL verifier to make sure that the SILFunction follows
 /// invariants.
 void SILFunction::verify(bool SingleFunction) const {
-#ifdef NDEBUG
-  if (!getModule().getOptions().VerifyAll)
+  if (!verificationEnabled(getModule()))
     return;
-#endif
+
   // Please put all checks in visitSILFunction in SILVerifier, not here. This
   // ensures that the pretty stack trace in the verifier is included with the
   // back trace when the verifier crashes.
   SILVerifier(*this, SingleFunction).verify();
 }
 
 void SILFunction::verifyCriticalEdges() const {
-#ifdef NDEBUG
-  if (!getModule().getOptions().VerifyAll)
+  if (!verificationEnabled(getModule()))
     return;
-#endif
+
   SILVerifier(*this, /*SingleFunction=*/true).verifyBranches(this);
 }
 
 /// Verify that a property descriptor follows invariants.
 void SILProperty::verify(const SILModule &M) const {
-#ifdef NDEBUG
-  if (!M.getOptions().VerifyAll)
+  if (!verificationEnabled(M))
     return;
-#endif
 
   auto *decl = getDecl();
   auto *dc = decl->getInnermostDeclContext();
@@ -5310,10 +5314,9 @@ void SILProperty::verify(const SILModule &M) const {
 
 /// Verify that a vtable follows invariants.
 void SILVTable::verify(const SILModule &M) const {
-#ifdef NDEBUG
-  if (!M.getOptions().VerifyAll)
+  if (!verificationEnabled(M))
     return;
-#endif
+
   for (auto &entry : getEntries()) {
     // All vtable entries must be decls in a class context.
     assert(entry.Method.hasDecl() && "vtable entry is not a decl");
@@ -5361,10 +5364,9 @@ void SILVTable::verify(const SILModule &M) const {
 
 /// Verify that a witness table follows invariants.
 void SILWitnessTable::verify(const SILModule &M) const {
-#ifdef NDEBUG
-  if (!M.getOptions().VerifyAll)
+  if (!verificationEnabled(M))
     return;
-#endif
+
   if (isDeclaration())
     assert(getEntries().empty() &&
            "A witness table declaration should not have any entries.");
@@ -5414,10 +5416,9 @@ void SILDefaultWitnessTable::verify(const SILModule &M) const {
 
 /// Verify that a global variable follows invariants.
 void SILGlobalVariable::verify() const {
-#ifdef NDEBUG
-  if (!getModule().getOptions().VerifyAll)
+  if (!verificationEnabled(getModule()))
     return;
-#endif
+
   assert(getLoweredType().isObject()
          && "global variable cannot have address type");
 
@@ -5439,10 +5440,9 @@ void SILGlobalVariable::verify() const {
 
 /// Verify the module.
 void SILModule::verify() const {
-#ifdef NDEBUG
-  if (!getOptions().VerifyAll)
+  if (!verificationEnabled(*this))
     return;
-#endif
+
   // Uniquing set to catch symbol name collisions.
   llvm::DenseSet<StringRef> symbolNames;
 

lib/SILOptimizer/Analysis/AliasAnalysis.cpp

@@ -661,6 +661,16 @@ AliasResult AliasAnalysis::aliasInner(SILValue V1, SILValue V2,
 }
 
 bool AliasAnalysis::canApplyDecrementRefCount(FullApplySite FAS, SILValue Ptr) {
+  // If the connection graph is invalid due to a very large function, we also
+  // skip all other tests, which might take significant time for a very large
+  // function.
+  // This is a workaround for some quadratic complexity in ARCSequenceOpt.
+  // TODO: remove this check once ARCSequenceOpt is retired or the quadratic
+  // behavior is fixed.
+  auto *conGraph = EA->getConnectionGraph(FAS.getFunction());
+  if (!conGraph->isValid())
+    return true;
+
   // Treat applications of no-return functions as decrementing ref counts. This
   // causes the apply to become a sink barrier for ref count increments.
   if (FAS.isCalleeNoReturn())

lib/SILOptimizer/Analysis/EscapeAnalysis.cpp

@@ -403,6 +403,7 @@ void EscapeAnalysis::ConnectionGraph::clear() {
   UsePoints.clear();
   UsePointTable.clear();
   NodeAllocator.DestroyAll();
+  valid = true;
   assert(ToMerge.empty());
 }
 
@@ -416,6 +417,9 @@ void EscapeAnalysis::ConnectionGraph::clear() {
 // it's interior property.
 EscapeAnalysis::CGNode *
 EscapeAnalysis::ConnectionGraph::getNode(SILValue V) {
+  if (!isValid())
+    return nullptr;
+
   // Early filter obvious non-pointer opcodes.
   if (isa<FunctionRefInst>(V) || isa<DynamicFunctionRefInst>(V) ||
       isa<PreviousDynamicFunctionRefInst>(V))
@@ -1028,6 +1032,9 @@ CGNode *EscapeAnalysis::ConnectionGraph::getReturnNode() {
 
 bool EscapeAnalysis::ConnectionGraph::mergeFrom(ConnectionGraph *SourceGraph,
                                                 CGNodeMap &Mapping) {
+  assert(isValid());
+  assert(SourceGraph->isValid());
+
   // The main point of the merging algorithm is to map each content node in the
   // source graph to a content node in this (destination) graph. This may
   // require creating new nodes or merging existing nodes in this graph.
@@ -1492,6 +1499,11 @@ void EscapeAnalysis::ConnectionGraph::print(llvm::raw_ostream &OS) const {
 #ifndef NDEBUG
   OS << "CG of " << F->getName() << '\n';
 
+  if (!isValid()) {
+    OS << "  invalid\n";
+    return;
+  }
+
   // Assign the same IDs to SILValues as the SILPrinter does.
   llvm::DenseMap<const SILNode *, unsigned> InstToIDMap;
   InstToIDMap[nullptr] = (unsigned)-1;
@@ -1595,6 +1607,7 @@ void EscapeAnalysis::ConnectionGraph::verify() const {
   // Invalidating EscapeAnalysis clears the connection graph.
   if (isEmpty())
     return;
+  assert(isValid());
 
   verifyStructure();
 
@@ -1608,7 +1621,7 @@ void EscapeAnalysis::ConnectionGraph::verify() const {
         continue;
 
       if (auto ai = dyn_cast<ApplyInst>(&i)) {
-        if (EA->canOptimizeArrayUninitializedCall(ai, this).isValid())
+        if (EA->canOptimizeArrayUninitializedCall(ai).isValid())
           continue;
       }
       for (auto result : i.getResults()) {
@@ -1728,10 +1741,21 @@ void EscapeAnalysis::buildConnectionGraph(FunctionInfo *FInfo,
     // Create edges for the instructions.
     for (auto &i : *bb) {
       analyzeInstruction(&i, FInfo, BottomUpOrder, RecursionDepth);
+      
+      // Bail if the graph gets too big. The node merging algorithm has
+      // quadratic complexity and we want to avoid this.
+      // TODO: fix the quadratic complexity (if possible) and remove this limit.
+      if (ConGraph->Nodes.size() > 10000) {
+        ConGraph->invalidate();
+        return false;
+      }
     }
     return true;
   });
 
+  if (!ConGraph->isValid())
+    return;
+
   // Second step: create defer-edges for block arguments.
   for (SILBasicBlock &BB : *ConGraph->F) {
     if (!reachable.isVisited(&BB))
@@ -1826,8 +1850,7 @@ bool EscapeAnalysis::buildConnectionGraphForDestructor(
 }
 
 EscapeAnalysis::ArrayUninitCall
-EscapeAnalysis::canOptimizeArrayUninitializedCall(
-    ApplyInst *ai, const ConnectionGraph *conGraph) {
+EscapeAnalysis::canOptimizeArrayUninitializedCall(ApplyInst *ai) {
   ArrayUninitCall call;
   // This must be an exact match so we don't accidentally optimize
   // "array.uninitialized_intrinsic".
@@ -1873,8 +1896,7 @@ bool EscapeAnalysis::canOptimizeArrayUninitializedResult(
   if (!ai)
     return false;
 
-  auto *conGraph = getConnectionGraph(ai->getFunction());
-  return canOptimizeArrayUninitializedCall(ai, conGraph).isValid();
+  return canOptimizeArrayUninitializedCall(ai).isValid();
 }
 
 // Handle @_semantics("array.uninitialized")
@@ -1924,7 +1946,7 @@ void EscapeAnalysis::analyzeInstruction(SILInstruction *I,
         return;
       case ArrayCallKind::kArrayUninitialized: {
         ArrayUninitCall call = canOptimizeArrayUninitializedCall(
-            cast<ApplyInst>(FAS.getInstruction()), ConGraph);
+            cast<ApplyInst>(FAS.getInstruction()));
         if (call.isValid()) {
           createArrayUninitializedSubgraph(call, ConGraph);
           return;
@@ -2480,6 +2502,16 @@ void EscapeAnalysis::recompute(FunctionInfo *Initial) {
 bool EscapeAnalysis::mergeCalleeGraph(SILInstruction *AS,
                                       ConnectionGraph *CallerGraph,
                                       ConnectionGraph *CalleeGraph) {
+  if (!CallerGraph->isValid())
+    return false;
+    
+  if (!CalleeGraph->isValid()) {
+    setAllEscaping(AS, CallerGraph);
+    // Conservatively assume that setting that setAllEscaping(AS) did change the
+    // graph.
+    return true;
+  }
+                                      
   // This CGNodeMap uses an intrusive worklist to keep track of Mapped nodes
   // from the CalleeGraph. Meanwhile, mergeFrom uses separate intrusive
   // worklists to update nodes in the CallerGraph.
@@ -2538,6 +2570,11 @@ bool EscapeAnalysis::mergeCalleeGraph(SILInstruction *AS,
 
 bool EscapeAnalysis::mergeSummaryGraph(ConnectionGraph *SummaryGraph,
                                         ConnectionGraph *Graph) {
+  if (!Graph->isValid()) {
+    bool changed = SummaryGraph->isValid();
+    SummaryGraph->invalidate();
+    return changed;
+  }
 
   // Make a 1-to-1 mapping of all arguments and the return value. This CGNodeMap
   // node map uses an intrusive worklist to keep track of Mapped nodes from the

lib/SILOptimizer/SILCombiner/SILCombine.cpp

@@ -131,7 +131,9 @@ class SILCombineCanonicalize final : CanonicalizeInstruction {
   }
 
   void notifyHasNewUsers(SILValue value) override {
-    Worklist.addUsersToWorklist(value);
+    if (Worklist.size() < 10000) {
+      Worklist.addUsersToWorklist(value);
+    }
     changed = true;
   }