Clean up the newly created Projection. NFC.

trentxintong · trentxintong · commit d59d567a776d · 2016-02-10T14:46:08.000-08:00
- Update comments.
- Correct 80 col violations mostly due to renaming NewProjection to Projection.
- Remove dead functions
diff --git a/include/swift/SIL/Projection.h b/include/swift/SIL/Projection.h
@@ -103,7 +103,7 @@ constexpr unsigned MaxPointerProjectionKind = ((1 << TypeAlignInBits) - 1);
 /// Make sure that our tagged pointer assumptions are true. See comment above
 /// the declaration of ProjectionKind.
 static_assert(unsigned(ProjectionKind::LastPointerKind) <=
-                  unsigned(MaxPointerProjectionKind),
+              unsigned(MaxPointerProjectionKind),
               "Too many projection kinds to fit in Projection");
 
 static inline bool isCastProjectionKind(ProjectionKind Kind) {
@@ -130,7 +130,7 @@ struct ProjectionIndex {
   SILValue Aggregate;
   unsigned Index;
 
-  explicit ProjectionIndex(SILValue V) :Index(~0U) {
+  explicit ProjectionIndex(SILValue V) : Index(~0U) {
     switch (V->getKind()) {
     default:
       break;
@@ -281,7 +281,7 @@ class Projection {
       return BaseType.getEnumElementType(getEnumElementDecl(BaseType), M);
     case ProjectionKind::Box:
       return SILType::getPrimitiveAddressType(BaseType.castTo<SILBoxType>()->
-                                                getBoxedType());
+                                              getBoxedType());
     case ProjectionKind::Tuple:
       return BaseType.getTupleElementType(getIndex());
     case ProjectionKind::Upcast:
@@ -315,24 +315,6 @@ class Projection {
     return *Iter;
   }
 
-  ValueDecl *getValueDecl(SILType BaseType) const {
-    assert(isValid());
-    switch (getKind()) {
-    case ProjectionKind::Enum:
-      return getEnumElementDecl(BaseType);
-    case ProjectionKind::Struct:
-    case ProjectionKind::Class:
-      return getVarDecl(BaseType);
-    case ProjectionKind::Upcast:
-    case ProjectionKind::RefCast:
-    case ProjectionKind::BitwiseCast:
-    case ProjectionKind::Index:
-    case ProjectionKind::Tuple:
-    case ProjectionKind::Box:
-      llvm_unreachable("ProjectionKind that does not have a value decl?");
-    }
-  }
-
   SILType getCastType(SILType BaseType) const {
     assert(isValid());
     assert(getKind() == ProjectionKind::Upcast ||
@@ -483,6 +465,7 @@ class ProjectionPath {
 private:
   SILType BaseType;
   SILType MostDerivedType;
+  /// A path from base to most-derived.
   PathTy Path;
 
 public:
@@ -555,7 +538,7 @@ class ProjectionPath {
   /// types via ref_element_addr. If Start is an address type though, End will
   /// always also be an address type.
   static Optional<ProjectionPath> getProjectionPath(SILValue Start,
-                                                       SILValue End);
+                                                    SILValue End);
 
   /// Treating a projection path as an ordered set, if RHS is a prefix of LHS,
   /// return the projection path with that prefix removed.
@@ -595,27 +578,6 @@ class ProjectionPath {
   /// subsequence of the other.
   SubSeqRelation_t computeSubSeqRelation(const ProjectionPath &RHS) const;
 
-  /// Returns true if this is a projection path that takes an address base type
-  /// to an address derived type.
-  bool isAddressProjectionPath() const;
-
-  /// Returns true if this is a projection path that takes an object base type
-  /// to an object derived type.
-  bool isObjectProjectionPath() const;
-
-  /// Find all object projection paths from I that matches this projection
-  /// path. Return the tails of each extract path in T.
-  bool
-  findMatchingObjectProjectionPaths(SILInstruction *I,
-                                    SmallVectorImpl<SILInstruction *> &T) const;
-
-  /// If this is an address projection path and \p Base is a SILValue with the
-  /// object version of said type, use \p B and \p Loc to recreate the stored
-  /// address projection path as an object projection path from \p Base. Return
-  /// the SILValue at the end of the path.
-  SILValue createObjectProjections(SILBuilder &B, SILLocation Loc,
-                                   SILValue Base);
-
   /// Pushes an element to the path.
   void push_back(const Projection &Proj) { Path.push_back(Proj); }
 
@@ -713,13 +675,8 @@ class ProjectionTreeNode {
   /// invalidating our pointers.
   unsigned Index;
 
-  /// The base type from which this projection tree node is derived via Proj. It
-  /// is necessary to maintain a separate such entry from BaseValues since we
-  /// may have projection tree nodes without any BaseValues since we completely
-  /// explode non-enum scalar values to the leafs of our tree.
-  ///
-  /// In the root of the tree, this is the actual type.
-  SILType BaseType;
+  /// The type this projection tree node represents.
+  SILType NodeType;
 
   /// The projection that this node represents. None in the root.
   llvm::Optional<Projection> Proj;
@@ -755,14 +712,14 @@ class ProjectionTreeNode {
   };
 
   /// Constructor for the root of the tree.
-  ProjectionTreeNode(SILType BaseTy)
-    : Index(0), BaseType(BaseTy), Proj(), Parent(),
+  ProjectionTreeNode(SILType NodeTy)
+    : Index(0), NodeType(NodeTy), Proj(), Parent(),
       NonProjUsers(), ChildProjections(), Initialized(false), IsLive(false) {}
 
   // Normal constructor for non-root nodes.
-  ProjectionTreeNode(ProjectionTreeNode *Parent, unsigned Index, SILType BaseTy,
+  ProjectionTreeNode(ProjectionTreeNode *Parent, unsigned Index, SILType NodeTy,
                      Projection P)
-    : Index(Index), BaseType(BaseTy), Proj(P),
+    : Index(Index), NodeType(NodeTy), Proj(P),
       Parent(Parent->getIndex()), NonProjUsers(), ChildProjections(),
       Initialized(false), IsLive(false) {}
 
@@ -776,9 +733,9 @@ class ProjectionTreeNode {
      return llvm::makeArrayRef(ChildProjections);
   }
 
-  llvm::Optional<Projection> &getProjection() {
-    return Proj;
-  }
+  llvm::Optional<Projection> &getProjection() { return Proj; }
+
+  SILType getType() const { return NodeType; }
 
   bool isRoot() const {
     // Root does not have a parent. So if we have a parent, we cannot be root.
@@ -794,10 +751,6 @@ class ProjectionTreeNode {
     }
   }
 
-  SILType getType() const {
-    return BaseType;
-  }
-
   ProjectionTreeNode *getChildForProjection(ProjectionTree &Tree,
                                                const Projection &P);
 
@@ -819,9 +772,6 @@ class ProjectionTreeNode {
     return getParent(Tree);
   }
 
-
-  llvm::Optional<Projection> getProjection() const { return Proj; }
-
 private:
   void addNonProjectionUser(Operand *Op) {
     IsLive = true;
diff --git a/lib/SIL/Projection.cpp b/lib/SIL/Projection.cpp
@@ -37,7 +37,11 @@ static_assert(std::is_standard_layout<Projection>::value,
 //                              Utility 
 //===----------------------------------------------------------------------===//
 
-/// We do not support symbolic projections yet, only 32-bit unsigned integers.
+/// Extract an integer index from a SILValue.
+///
+/// Return true if IndexVal is a constant index representable as unsigned
+/// int. We do not support symbolic projections yet, only 32-bit unsigned
+/// integers.
 bool swift::getIntegerIndex(SILValue IndexVal, unsigned &IndexConst) {
   if (auto *IndexLiteral = dyn_cast<IntegerLiteralInst>(IndexVal)) {
     APInt ConstInt = IndexLiteral->getValue();
@@ -187,7 +191,7 @@ Projection::Projection(SILInstruction *I) : Value() {
 
 NullablePtr<SILInstruction>
 Projection::createObjectProjection(SILBuilder &B, SILLocation Loc,
-                                      SILValue Base) const {
+                                   SILValue Base) const {
   SILType BaseTy = Base->getType();
 
   // We can only create a value projection from an object.
@@ -221,7 +225,7 @@ Projection::createObjectProjection(SILBuilder &B, SILLocation Loc,
 
 NullablePtr<SILInstruction>
 Projection::createAddressProjection(SILBuilder &B, SILLocation Loc,
-                                       SILValue Base) const {
+                                    SILValue Base) const {
   SILType BaseTy = Base->getType();
 
   // We can only create an address projection from an object, unless we have a
@@ -259,8 +263,8 @@ Projection::createAddressProjection(SILBuilder &B, SILLocation Loc,
   }
 }
 
-void Projection::getFirstLevelProjections(
-    SILType Ty, SILModule &Mod, llvm::SmallVectorImpl<Projection> &Out) {
+void Projection::getFirstLevelProjections(SILType Ty, SILModule &Mod,
+                                  llvm::SmallVectorImpl<Projection> &Out) {
   if (auto *S = Ty.getStructOrBoundGenericStruct()) {
     unsigned Count = 0;
     for (auto *VDecl : S->getStoredProperties()) {
@@ -319,11 +323,11 @@ void Projection::getFirstLevelProjections(
 }
 
 //===----------------------------------------------------------------------===//
-//                            New Projection Path
+//                            Projection Path
 //===----------------------------------------------------------------------===//
 
 Optional<ProjectionPath> ProjectionPath::getProjectionPath(SILValue Start,
-                                                                 SILValue End) {
+                                                           SILValue End) {
   ProjectionPath P(Start->getType(), End->getType());
 
   // If Start == End, there is a "trivial" projection path in between the
@@ -364,8 +368,8 @@ Optional<ProjectionPath> ProjectionPath::getProjectionPath(SILValue Start,
 ///
 /// This means that the two objects have the same base but access different
 /// fields of the base object.
-bool ProjectionPath::hasNonEmptySymmetricDifference(
-    const ProjectionPath &RHS) const {
+bool 
+ProjectionPath::hasNonEmptySymmetricDifference(const ProjectionPath &RHS) const{
   // First make sure that both of our base types are the same.
   if (BaseType != RHS.BaseType)
     return false;
@@ -489,63 +493,9 @@ ProjectionPath::computeSubSeqRelation(const ProjectionPath &RHS) const {
   return SubSeqRelation_t::RHSStrictSubSeqOfLHS;
 }
 
-bool ProjectionPath::findMatchingObjectProjectionPaths(
-    SILInstruction *I, SmallVectorImpl<SILInstruction *> &T) const {
-  // We only support unary instructions.
-  if (I->getNumOperands() != 1)
-    return false;
-
-  // Check that the base result type of I is equivalent to this types base path.
-  if (I->getOperand(0)->getType().copyCategory(BaseType) != BaseType)
-    return false;
-
-  // We maintain the head of our worklist so we can use our worklist as a queue
-  // and work in breadth first order. This makes sense since we want to process
-  // in levels so we can maintain one tail list and delete the tail list when we
-  // move to the next level.
-  unsigned WorkListHead = 0;
-  llvm::SmallVector<SILInstruction *, 8> WorkList;
-  WorkList.push_back(I);
-
-  // Start at the root of the list.
-  for (auto PI = rbegin(), PE = rend(); PI != PE; ++PI) {
-    // When we start a new level, clear the tail list.
-    T.clear();
-
-    // If we have an empty worklist, return false. We have been unable to
-    // complete the list.
-    unsigned WorkListSize = WorkList.size();
-    if (WorkListHead == WorkListSize)
-      return false;
-
-    // Otherwise, process each instruction in the worklist.
-    for (; WorkListHead != WorkListSize; WorkListHead++) {
-      SILInstruction *Ext = WorkList[WorkListHead];
-
-      // If the current projection does not match I, continue and process the
-      // next instruction.
-      if (!PI->matchesObjectProjection(Ext)) {
-        continue;
-      }
-
-      // Otherwise, we know that Ext matched this projection path and we should
-      // visit all of its uses and add Ext itself to our tail list.
-      T.push_back(Ext);
-      for (auto *Op : Ext->getUses()) {
-        WorkList.push_back(Op->getUser());
-      }
-    }
-
-    // Reset the worklist size.
-    WorkListSize = WorkList.size();
-  }
-
-  return true;
-}
-
 Optional<ProjectionPath>
 ProjectionPath::removePrefix(const ProjectionPath &Path,
-                                const ProjectionPath &Prefix) {
+                             const ProjectionPath &Prefix) {
   // We can only subtract paths that have the same base.
   if (Path.BaseType != Prefix.BaseType)
     return llvm::NoneType::None;
@@ -575,19 +525,6 @@ ProjectionPath::removePrefix(const ProjectionPath &Path,
   return P;
 }
 
-SILValue ProjectionPath::createObjectProjections(SILBuilder &B,
-                                                    SILLocation Loc,
-                                                    SILValue Base) {
-  assert(BaseType.isAddress());
-  assert(Base->getType().isObject());
-  assert(Base->getType().getAddressType() == BaseType);
-  SILValue Val = Base;
-  for (auto iter : Path) {
-    Val = iter.createObjectProjection(B, Loc, Val).get();
-  }
-  return Val;
-}
-
 raw_ostream &ProjectionPath::print(raw_ostream &os, SILModule &M) {
   // Match how the memlocation print tests expect us to print projection paths.
   //
@@ -685,7 +622,7 @@ void ProjectionPath::verify(SILModule &M) {
 
 void
 ProjectionPath::expandTypeIntoLeafProjectionPaths(SILType B, SILModule *Mod,
-                                                     ProjectionPathList &Paths) {
+                                                  ProjectionPathList &Paths) {
   // Perform a BFS to expand the given type into projectionpath each of
   // which contains 1 field from the type.
   llvm::SmallVector<ProjectionPath, 8> Worklist;
@@ -751,7 +688,7 @@ ProjectionPath::expandTypeIntoLeafProjectionPaths(SILType B, SILModule *Mod,
 
 void
 ProjectionPath::expandTypeIntoNodeProjectionPaths(SILType B, SILModule *Mod,
-                                                     ProjectionPathList &Paths) {
+                                                  ProjectionPathList &Paths) {
   // Perform a BFS to expand the given type into projectionpath each of
   // which contains 1 field from the type.
   llvm::SmallVector<ProjectionPath, 8> Worklist;
@@ -905,7 +842,6 @@ ProjectionTreeNode::getChildForProjection(ProjectionTree &Tree,
       return N;
     }
   }
-
   return nullptr;
 }
 
@@ -932,10 +868,8 @@ createProjection(SILBuilder &B, SILLocation Loc, SILValue Arg) const {
   return Proj->createProjection(B, Loc, Arg);
 }
 
-
 void
-ProjectionTreeNode::
-processUsersOfValue(ProjectionTree &Tree,
+ProjectionTreeNode::processUsersOfValue(ProjectionTree &Tree,
                     llvm::SmallVectorImpl<ValueNodePair> &Worklist,
                     SILValue Value) {
   DEBUG(llvm::dbgs() << "    Looking at Users:\n");
@@ -1232,14 +1166,14 @@ ProjectionTree::computeExplodedArgumentValueInner(SILBuilder &Builder,
                                                      Node->getType(),
                                                      ChildValues);
 
-  assert(AI.get() && "Failed to get a part of the debug value");
+  assert(AI.get() && "Failed to get a part of value");
   return SILValue(AI.get());
 }
 
 SILValue
-ProjectionTree::computeExplodedArgumentValue(SILBuilder &Builder, 
-                                             SILLocation Loc,
-                                             llvm::SmallVector<SILValue, 8> &LeafValues) {
+ProjectionTree::computeExplodedArgumentValue(
+                            SILBuilder &Builder,  SILLocation Loc,
+                            llvm::SmallVector<SILValue, 8> &LeafValues) {
   // Construct the leaf index to leaf value map.
   llvm::DenseMap<unsigned, SILValue> LeafIndexToValue;
   for (unsigned i = 0; i < LeafValues.size(); ++i) {
@@ -1388,7 +1322,8 @@ getNextValidNode(llvm::SmallVectorImpl<ProjectionTreeNode *> &Worklist,
 
   ProjectionTreeNode *Node = Worklist.back();
 
-  // If the Node is not complete, then we have reached a dead lock. This should never happen.
+  // If the Node is not complete, then we have reached a dead lock. This should
+  // never happen.
   //
   // TODO: Prove this and put the proof here.
   if (CheckForDeadLock && !isComplete(Node)) {
