Add indexTrieRoot to the SILModule to share across Analyses.

...and avoid reallocation.

This is immediately necessary for LICM, in addition to its current
uses. I suspect this could be used by many passes that work with
addresses. RLE/DSE should absolutely migrate to it.

Author: atrick

include/swift/SILOptimizer/Utils/IndexTrie.h renamed to include/swift/Basic/IndexTrie.h

@@ -13,6 +13,7 @@
 #ifndef SWIFT_SILOPTIMIZER_UTILS_INDEXTREE_H
 #define SWIFT_SILOPTIMIZER_UTILS_INDEXTREE_H
 
+#include "swift/Basic/LLVM.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
 #include <algorithm>

include/swift/SIL/SILModule.h

@@ -21,6 +21,7 @@
 #include "swift/AST/Builtins.h"
 #include "swift/AST/SILLayout.h"
 #include "swift/AST/SILOptions.h"
+#include "swift/Basic/IndexTrie.h"
 #include "swift/Basic/LangOptions.h"
 #include "swift/Basic/ProfileCounter.h"
 #include "swift/Basic/Range.h"
@@ -256,6 +257,10 @@ class SILModule {
   /// The indexed profile data to be used for PGO, or nullptr.
   std::unique_ptr<llvm::IndexedInstrProfReader> PGOReader;
 
+  /// A trie of integer indices that gives pointer identity to a path of
+  /// projections, shared between all functions in the module.
+  std::unique_ptr<IndexTrieNode> indexTrieRoot;
+
   /// The options passed into this SILModule.
   const SILOptions &Options;
 
@@ -655,6 +660,8 @@ class SILModule {
     PGOReader = std::move(IPR);
   }
 
+  IndexTrieNode *getIndexTrieRoot() { return indexTrieRoot.get(); }
+
   /// Can value operations (copies and destroys) on the given lowered type
   /// be performed in this module?
   bool isTypeABIAccessible(SILType type,

include/swift/SILOptimizer/Analysis/AccessSummaryAnalysis.h

@@ -19,10 +19,10 @@
 #ifndef SWIFT_SILOPTIMIZER_ANALYSIS_ACCESS_SUMMARY_ANALYSIS_H_
 #define SWIFT_SILOPTIMIZER_ANALYSIS_ACCESS_SUMMARY_ANALYSIS_H_
 
+#include "swift/Basic/IndexTrie.h"
 #include "swift/SIL/SILFunction.h"
 #include "swift/SIL/SILInstruction.h"
 #include "swift/SILOptimizer/Analysis/BottomUpIPAnalysis.h"
-#include "swift/SILOptimizer/Utils/IndexTrie.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
 
@@ -173,22 +173,13 @@ class AccessSummaryAnalysis : public BottomUpIPAnalysis {
 
   llvm::SpecificBumpPtrAllocator<FunctionInfo> Allocator;
 
-  /// A trie of integer indices that gives pointer identity to a path of
-  /// projections. This is shared between all functions in the module.
-  std::unique_ptr<IndexTrieNode> SubPathTrie;
-
 public:
-  AccessSummaryAnalysis() : BottomUpIPAnalysis(SILAnalysisKind::AccessSummary) {
-    SubPathTrie.reset(new IndexTrieNode());
-  }
+  AccessSummaryAnalysis()
+      : BottomUpIPAnalysis(SILAnalysisKind::AccessSummary) {}
 
   /// Returns a summary of the accesses performed by the given function.
   const FunctionSummary &getOrCreateSummary(SILFunction *Fn);
 
-  IndexTrieNode *getSubPathTrieRoot() {
-    return SubPathTrie.get();
-  }
-
   /// Returns an IndexTrieNode that represents the single subpath accessed from
   /// BAI or the root if no such node exists.
   const IndexTrieNode *findSubPathAccessed(BeginAccessInst *BAI);

lib/SIL/IR/SILModule.cpp

@@ -94,7 +94,8 @@ class SILModule::SerializationCallback final
 
 SILModule::SILModule(llvm::PointerUnion<FileUnit *, ModuleDecl *> context,
                      Lowering::TypeConverter &TC, const SILOptions &Options)
-    : Stage(SILStage::Raw), Options(Options), serialized(false),
+    : Stage(SILStage::Raw), indexTrieRoot(new IndexTrieNode()),
+      Options(Options), serialized(false),
       regDeserializationNotificationHandlerForNonTransparentFuncOME(false),
       regDeserializationNotificationHandlerForAllFuncOME(false),
       SerializeSILAction(), Types(TC) {

lib/SILOptimizer/Analysis/AccessSummaryAnalysis.cpp

@@ -49,9 +49,9 @@ void AccessSummaryAnalysis::processFunction(FunctionInfo *info,
 /// started by a begin_access and any flows of the arguments to other
 /// functions.
 void AccessSummaryAnalysis::processArgument(FunctionInfo *info,
-                                             SILFunctionArgument *argument,
-                                             ArgumentSummary &summary,
-                                             FunctionOrder &order) {
+                                            SILFunctionArgument *argument,
+                                            ArgumentSummary &summary,
+                                            FunctionOrder &order) {
   unsigned argumentIndex = argument->getIndex();
 
   // Use a worklist to track argument uses to be processed.
@@ -77,7 +77,7 @@ void AccessSummaryAnalysis::processArgument(FunctionInfo *info,
       // call.
       if (!callee || callee->empty()) {
         summary.mergeWith(SILAccessKind::Modify, apply.getLoc(),
-                          getSubPathTrieRoot());
+                          apply.getModule().getIndexTrieRoot());
         continue;
       }
       unsigned operandNumber = operand->getOperandNumber();
@@ -468,7 +468,6 @@ AccessSummaryAnalysis::getOrCreateSummary(SILFunction *fn) {
 void AccessSummaryAnalysis::AccessSummaryAnalysis::invalidate() {
   FunctionInfos.clear();
   Allocator.DestroyAll();
-  SubPathTrie.reset(new IndexTrieNode());
 }
 
 void AccessSummaryAnalysis::invalidate(SILFunction *F, InvalidationKind K) {
@@ -526,7 +525,7 @@ getSingleAddressProjectionUser(SingleValueInstruction *I) {
 
 const IndexTrieNode *
 AccessSummaryAnalysis::findSubPathAccessed(BeginAccessInst *BAI) {
-  IndexTrieNode *SubPath = getSubPathTrieRoot();
+  IndexTrieNode *SubPath = BAI->getModule().getIndexTrieRoot();
 
   // For each single-user projection of BAI, construct or get a node
   // from the trie representing the index of the field or tuple element

lib/SILOptimizer/Mandatory/DiagnoseStaticExclusivity.cpp

@@ -754,7 +754,7 @@ static void checkCaptureAccess(ApplySite Apply, AccessState &State) {
 
     // The unknown argument access is considered a modify of the root subpath.
     auto argAccess = RecordedAccess(SILAccessKind::Modify, Apply.getLoc(),
-                                    State.ASA->getSubPathTrieRoot());
+                                    Apply.getModule().getIndexTrieRoot());
 
     // Construct a conflicting RecordedAccess if one doesn't already exist.
     const AccessInfo &info = AccessIt->getSecond();

lib/SILOptimizer/Transforms/CopyPropagation.cpp

@@ -123,12 +123,12 @@
 /// ===----------------------------------------------------------------------===
 
 #define DEBUG_TYPE "copy-propagation"
+#include "swift/Basic/IndexTrie.h"
 #include "swift/SIL/InstructionUtils.h"
 #include "swift/SIL/Projection.h"
 #include "swift/SILOptimizer/PassManager/Passes.h"
 #include "swift/SILOptimizer/PassManager/Transforms.h"
 #include "swift/SILOptimizer/Utils/CFGOptUtils.h"
-#include "swift/SILOptimizer/Utils/IndexTrie.h"
 #include "swift/SILOptimizer/Utils/InstOptUtils.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Statistic.h"

lib/SILOptimizer/Transforms/DeadObjectElimination.cpp

@@ -24,6 +24,7 @@
 //===----------------------------------------------------------------------===//
 
 #define DEBUG_TYPE "dead-object-elim"
+#include "swift/Basic/IndexTrie.h"
 #include "swift/AST/ResilienceExpansion.h"
 #include "swift/SIL/BasicBlockUtils.h"
 #include "swift/SIL/DebugUtils.h"
@@ -38,7 +39,6 @@
 #include "swift/SILOptimizer/Analysis/ArraySemantic.h"
 #include "swift/SILOptimizer/PassManager/Passes.h"
 #include "swift/SILOptimizer/PassManager/Transforms.h"
-#include "swift/SILOptimizer/Utils/IndexTrie.h"
 #include "swift/SILOptimizer/Utils/InstOptUtils.h"
 #include "swift/SILOptimizer/Utils/SILSSAUpdater.h"
 #include "swift/SILOptimizer/Utils/ValueLifetime.h"