Merge similar functions in TypeExpansionAnalysis.

Author: trentxintong

include/swift/SILAnalysis/TypeExpansionAnalysis.h

@@ -13,20 +13,28 @@
 #define SWIFT_SILANALYSIS_TYPEEXPANSIONANALYSIS_H
 
 #include "swift/SIL/Projection.h"
+#include "swift/SIL/SILType.h"
 #include "swift/SIL/SILValue.h"
 #include "swift/SILAnalysis/Analysis.h"
 #include "llvm/ADT/DenseMap.h"
 
 namespace swift {
 
+/// Type expansion kind.
+enum class TEKind { 
+  TELeaf, // Leaf nodes expansion.
+  TENode  // Intermediate and leaf nodes expansion.
+}; 
+
+using TypeExpansionMap = llvm::DenseMap<SILType, ProjectionPathList>;
+
 /// This analysis determines memory effects during destruction.
 class TypeExpansionAnalysis : public SILAnalysis {
-  using TypeExpansionMap = llvm::DenseMap<SILType, ProjectionPathList>;
   /// Caches the type to leaf node expansion.
-  TypeExpansionMap LeafTECache;
+  TypeExpansionMap TELeafCache;
   /// Caches the type to each node expansion, including intermediate nodes as
   /// well as leaf nodes in the type tree.
-  TypeExpansionMap NodeTECache;
+  TypeExpansionMap TENodeCache;
 
 public:
   TypeExpansionAnalysis(SILModule *M)
@@ -36,11 +44,10 @@ class TypeExpansionAnalysis : public SILAnalysis {
     return S->getKind() == AnalysisKind::TypeExpansion;
   }
 
-  /// Return ProjectionPath to every leaf node of the given type.
-  const ProjectionPathList &getTypeLeafExpansion(SILType B, SILModule *Mod);
-  /// Returns the ProjectionPath to every leaf and intermediate node of the
-  /// given type.
-  const ProjectionPathList &getTypeNodeExpansion(SILType B, SILModule *Mod);
+  /// Return ProjectionPath to every leaf or intermediate node of the given type.
+  const ProjectionPathList &getTypeExpansionProjectionPaths(SILType B,
+                                                            SILModule *Mod,
+                                                            TEKind K);
 };
 }
 #endif

lib/SIL/MemLocation.cpp

@@ -116,7 +116,8 @@ void MemLocation::expand(MemLocation &Base, SILModule *M, MemLocationList &Locs,
   // Construct the MemLocation by appending the projection path from the
   // accessed node to the leaf nodes.
   ProjectionPath &BasePath = Base.getPath().getValue();
-  for (const auto &P : TE->getTypeLeafExpansion(Base.getType(), M)) {
+  for (const auto &P : TE->getTypeExpansionProjectionPaths(Base.getType(), M,
+                                                           TEKind::TELeaf)) {
     Locs.push_back(MemLocation(Base.getBase(), P.getValue(), BasePath));
   }
 }
@@ -127,7 +128,8 @@ void MemLocation::reduce(MemLocation &Base, SILModule *M, MemLocationSet &Locs,
   // accessed node to the leaf nodes.
   MemLocationList Nodes;
   ProjectionPath &BasePath = Base.getPath().getValue();
-  for (const auto &P : TE->getTypeNodeExpansion(Base.getType(), M)) {
+  for (const auto &P : TE->getTypeExpansionProjectionPaths(Base.getType(), M,
+                                                           TEKind::TENode)) {
     Nodes.push_back(MemLocation(Base.getBase(), P.getValue(), BasePath));
   }
 
@@ -172,7 +174,8 @@ void MemLocation::expandWithValues(MemLocation &Base, SILValue &Val,
   // path
   // from the accessed node to the leaf nodes.
   ProjectionPath &BasePath = Base.getPath().getValue();
-  for (const auto &P : TE->getTypeLeafExpansion(Base.getType(), M)) {
+  for (const auto &P : TE->getTypeExpansionProjectionPaths(Base.getType(), M,
+                                                           TEKind::TELeaf)) {
     Locs.push_back(MemLocation(Base.getBase(), P.getValue(), BasePath));
     Vals.push_back(LoadStoreValue(Val, P.getValue()));
   }
@@ -190,7 +193,8 @@ SILValue MemLocation::reduceWithValues(MemLocation &Base, SILModule *M,
   // Base memory location.
   MemLocationList ALocs;
   ProjectionPath &BasePath = Base.getPath().getValue();
-  for (const auto &P : TE->getTypeNodeExpansion(Base.getType(), M)) {
+  for (const auto &P : TE->getTypeExpansionProjectionPaths(Base.getType(), M,
+                                                           TEKind::TENode)) {
     ALocs.push_back(MemLocation(Base.getBase(), P.getValue(), BasePath));
   }
 

lib/SILAnalysis/TypeExpansionAnalysis.cpp

@@ -1,51 +1,55 @@
+//===---------- TypeExpansionAnalysis.cpp - Type Expansion Analysis -------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2015 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#define DEBUG_TYPE "typeexpansion-analysis"
 #include "swift/SILAnalysis/TypeExpansionAnalysis.h"
 #include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILModule.h"
 #include "llvm/Support/Debug.h"
 
-#define DEBUG_TYPE "typeexpansion-analysis"
-
 using namespace swift;
 
-// The MemoryBehavior Cache must not grow beyond this size.
+// The TypeExpansion Cache must not grow beyond this size.
 // We limit the size of the MB cache to 2**12 because we want to limit the
 // memory usage of this cache.
 static const int TypeExpansionAnalysisMaxCacheSize = 4096;
 
-const ProjectionPathList & 
-TypeExpansionAnalysis::getTypeLeafExpansion(SILType B, SILModule *Mod) {
+const ProjectionPathList &
+TypeExpansionAnalysis::getTypeExpansionProjectionPaths(SILType B, SILModule *Mod,
+                                                       TEKind Kind) {
+  // Which cache we should be looking up.
+  bool IsLeaf = Kind == TEKind::TELeaf;
+  TypeExpansionMap &Cache = IsLeaf ? TELeafCache : TENodeCache;
+
   // Check whether we have the type expansion.
-  if (LeafTECache.find(B) != LeafTECache.end()) {
-    return LeafTECache.find(B)->second;
+  auto Iter = Cache.find(B);
+  if (Iter != Cache.end()) {
+    return Iter->second;
   }   
 
   // Flush the cache if the size of the cache is too large.
-  if (LeafTECache.size() > TypeExpansionAnalysisMaxCacheSize) {
-    LeafTECache.clear();
+  if (Cache.size() > TypeExpansionAnalysisMaxCacheSize) {
+    Cache.clear();
   }
 
-  // Need to build the type expansion.
-  LeafTECache[B] = ProjectionPathList();
-  ProjectionPath::expandTypeIntoLeafProjectionPaths(B, Mod, LeafTECache[B]);
-  return LeafTECache[B];
-}
-
-const ProjectionPathList & 
-TypeExpansionAnalysis::getTypeNodeExpansion(SILType B, SILModule *Mod) {
-  // Check whether we have the type expansion.
-  if (NodeTECache.find(B) != NodeTECache.end()) {
-    return NodeTECache.find(B)->second;
-  }   
-
-  // Flush the cache if the size of the cache is too large.
-  if (NodeTECache.size() > TypeExpansionAnalysisMaxCacheSize) {
-    NodeTECache.clear();
+  // Build the type expansion for the leaf nodes.
+  if (IsLeaf) {
+    ProjectionPath::expandTypeIntoLeafProjectionPaths(B, Mod, Cache[B]);
+    return Cache[B];
   }
 
-  // Need to build the type expansion.
-  NodeTECache[B] = ProjectionPathList();
-  ProjectionPath::expandTypeIntoNodeProjectionPaths(B, Mod, NodeTECache[B]);
-  return NodeTECache[B];
+  // Build the type expansion for the internal and leaf nodes.
+  ProjectionPath::expandTypeIntoNodeProjectionPaths(B, Mod, Cache[B]);
+  return Cache[B];
 }
 
 SILAnalysis *swift::createTypeExpansionAnalysis(SILModule *M) {