Tweaks to naming, comments; removed method from bimap

Author: john-h-kastner

clang/include/clang/CConv/ConstraintsGraph.h

@@ -36,17 +36,34 @@ class DataNode : public llvm::DGNode<DataNode<DataType, EdgeType>, EdgeType> {
 
   DataType getData() const { return Data; }
 
-  void addPred(EdgeType &E){ PredEdges.insert(&E); }
-  const llvm::SetVector<EdgeType *> &getPreds() { return PredEdges; }
+  void connectTo(NodeType &Other) {
+    auto *BLR = new EdgeType(Other);
+    this->addEdge(*BLR);
+    auto *BRL = new EdgeType(*this);
+    Other.addPredecessor(*BRL);
+  }
+
+  const llvm::SetVector<EdgeType *> &getPredecessors() {
+    return PredecessorEdges;
+  }
 
+  // Nodes are defined exactly by the data they contain, not by their
+  // connections to other nodes.
   bool isEqualTo(const DataNode &N) const { return this->Data == N.Data; }
 
 private:
+  // Data element stored in each node. This is used by isEqualTo to discriminate
+  // between nodes.
   DataType Data;
 
-  llvm::SetVector<EdgeType *> PredEdges;
+  // While the constraint graph is directed, we want to efficiently traverse
+  // edges in the opposite direction. This set contains an edge entry pointing
+  // back to every node that has an edge to this node.
+  llvm::SetVector<EdgeType *> PredecessorEdges;
+  void addPredecessor(EdgeType &E){ PredecessorEdges.insert(&E); }
 };
 
+// Boilerplate template specialization
 template<typename Data, typename EdgeType>
 struct llvm::GraphTraits<DataNode<Data, EdgeType> *> {
   using NodeRef = DataNode<Data, EdgeType> *;
@@ -110,13 +127,9 @@ class DataGraph :
   }
 
   void addEdge(Data L, Data R) {
-    NodeType *BL = this->addVertex(L);
-    NodeType *BR = this->addVertex(R);
-
-    auto *BLR = new EdgeType(*BR);
-    BL->addEdge(*BLR);
-    auto *BRL = new EdgeType(*BL);
-    BR->addPred(*BRL);
+    NodeType *BL = this->findOrCreateNode(L);
+    NodeType *BR = this->findOrCreateNode(R);
+    BL->connectTo(*BR);
   }
 
   bool getNeighbors(Data D, std::set<Data> &DataSet, bool Succ){
@@ -128,7 +141,7 @@ class DataGraph :
     if (Succ)
       Edges = (*N)->getEdges();
     else
-      Edges = (*N)->getPreds();
+      Edges = (*N)->getPredecessors();
     for (auto *E : Edges)
       DataSet.insert(E->getTargetNode().getData());
     return !DataSet.empty();
@@ -151,7 +164,10 @@ class DataGraph :
   }
 
 protected:
-  virtual NodeType *addVertex(Data D) {
+  // Finds the node containing the Data if it exists, otherwise a new Node
+  // is allocated. Node equality is defined only by the data stored in a node,
+  // so if any node already contains the data, this node will be found.
+  virtual NodeType *findOrCreateNode(Data D) {
     auto *OldN = this->findNode(NodeType(D));
     if (OldN != this->end())
       return *OldN;
@@ -182,7 +198,7 @@ class ConstraintsGraph : public DataGraph<Atom *> {
 protected:
   // Add vertex is overridden to save const atoms as they are added to the graph
   // so that getAllConstAtoms can efficiently retrieve them.
-  NodeType *addVertex(Atom *A) override;
+  NodeType *findOrCreateNode(Atom *A) override;
 private:
   std::set<ConstAtom*> AllConstAtoms;
 };

clang/include/clang/CConv/Utils.h

@@ -33,39 +33,26 @@ typedef std::map<PersistentSourceLoc,
 typedef std::map<clang::Decl *, clang::DeclStmt *> VariableDecltoStmtMap;
 
 // Replacement for boost:bimap. A wrapper class around two std::maps to enable
-// map lookup in from key to value or from value to key.
+// map lookup from key to value or from value to key.
 template <typename KeyT, typename ValueT>
 class BiMap {
 public:
-  BiMap() { }
-  ~BiMap() { KtoVal.clear(); ValToK.clear();}
+  BiMap() = default;
+  ~BiMap() { clear(); }
 
   void insert(KeyT KO, ValueT VO) {
     KtoVal[KO] = VO;
     ValToK[VO] = KO;
   }
 
-  typename std::map<KeyT, ValueT>::const_iterator find(const KeyT &K) {
-    return KtoVal.find(K);
-  }
-
-  typename std::map<KeyT, ValueT>::const_iterator end() {
-    return KtoVal.end();
-  }
-
-  const std::map<KeyT, ValueT> &left() {
-    return KtoVal;
-  }
-
-  const std::map<ValueT, KeyT> &right() {
-    return ValToK;
-  }
-
   void clear() {
     KtoVal.clear();
     ValToK.clear();
   }
 
+  const std::map<KeyT, ValueT> &left() { return KtoVal; }
+  const std::map<ValueT, KeyT> &right() { return ValToK; }
+
 private:
   std::map<KeyT, ValueT> KtoVal;
   std::map<ValueT, KeyT> ValToK;

clang/lib/CConv/AVarBoundsInfo.cpp

@@ -277,7 +277,7 @@ ProgramVar *AVarBoundsInfo::getProgramVar(BoundsKey VK) {
 }
 
 bool AVarBoundsInfo::hasVarKey(PersistentSourceLoc &PSL) {
-  return DeclVarMap.find(PSL) != DeclVarMap.end();
+  return DeclVarMap.left().find(PSL) != DeclVarMap.left().end();
 }
 
 BoundsKey AVarBoundsInfo::getVarKey(PersistentSourceLoc &PSL) {

clang/lib/CConv/ConstraintsGraph.cpp

@@ -12,11 +12,11 @@
 #include "clang/CConv/ConstraintsGraph.h"
 #include <iostream>
 
-ConstraintsGraph::NodeType *ConstraintsGraph::addVertex(Atom *A) {
+ConstraintsGraph::NodeType *ConstraintsGraph::findOrCreateNode(Atom *A) {
   // Save all the const atoms.
   if (auto *CA = clang::dyn_cast<ConstAtom>(A))
     AllConstAtoms.insert(CA);
-  return DataGraph::addVertex(A);
+  return DataGraph::findOrCreateNode(A);
 }
 
 std::set<ConstAtom*> &ConstraintsGraph::getAllConstAtoms() {
@@ -76,10 +76,10 @@ std::string llvm::DOTGraphTraits<GraphVizOutputGraph>::getEdgeAttributes
 void GraphVizOutputGraph::mergeConstraintGraph(const ConstraintsGraph &Graph,
                                                GraphVizEdge::EdgeKind EK) {
   for (auto *N : Graph.Nodes) {
-    auto *S = addVertex(N->getData());
+    auto *S = findOrCreateNode(N->getData());
     for (auto *E : N->getEdges()) {
       Atom *TargetData = E->getTargetNode().getData();
-      auto *D = addVertex(TargetData);
+      auto *D = findOrCreateNode(TargetData);
       if (D->hasEdgeTo(*S)) {
         llvm::SmallVector<GraphVizEdge*, 2> Edges;
         D->findEdgesTo(*S, Edges);