Merge pull request #309 from correctcomputation/arrbndsdebug

Fixing array length inference performance issue

Author: Machiry

clang/include/clang/CConv/AVarBoundsInfo.h

@@ -103,12 +103,10 @@ class AvarBoundsInference {
                            AVarGraph &BKGraph,
                            std::set<ABounds *> &EB);
 
-  bool intersectBounds(std::set<ProgramVar *> &ProgVars,
-                       ABounds::BoundsKind BK,
-                       std::set<ABounds *> &CurrB);
-
-  bool getRelevantBounds(std::set<BoundsKey> &RBKeys,
-                         std::set<ABounds *> &ResBounds);
+  // Check if bounds specified by Bnds are declared bounds of K.
+  bool areDeclaredBounds(BoundsKey K,
+                         const std::pair<ABounds::BoundsKind,
+                                         std::set<BoundsKey>> &Bnds);
 
   bool predictBounds(BoundsKey K, std::set<BoundsKey> &Neighbours,
                      AVarGraph &BKGraph,
@@ -238,7 +236,7 @@ class AVarBoundsInfo {
   BoundsKey BCount;
   // Map of VarKeys and corresponding program variables.
   std::map<BoundsKey, ProgramVar *> PVarInfo;
-  // Map of APSInt (constants) and corresponding VarKeys.
+  // Map of APSInt (constants) and a BoundKey that correspond to it.
   std::map<uint64_t, BoundsKey> ConstVarKeys;
   // Map of BoundsKey and corresponding prioritized bounds information.
   // Note that although each PSL could have multiple ConstraintKeys Ex: **p.

clang/include/clang/CConv/ConstraintsGraph.h

@@ -134,7 +134,17 @@ class DataGraph :
     BL->connectTo(*BR);
   }
 
-  bool getNeighbors(Data D, std::set<Data> &DataSet, bool Succ){
+  void addUniqueEdge(Data L, Data R) {
+    NodeType *BL = this->findOrCreateNode(L);
+    NodeType *BR = this->findOrCreateNode(R);
+    llvm::SmallVector<EdgeType*, 10> Edges;
+    BL->findEdgesTo(*BR, Edges);
+    if (Edges.empty()) {
+      addEdge(L, R);
+    }
+  }
+
+  bool getNeighbors(Data D, std::set<Data> &DataSet, bool Succ) {
     auto *N = this->findNode(NodeType(D));
     if (N == this->end())
       return false;

clang/lib/CConv/AVarBoundsInfo.cpp

@@ -393,10 +393,12 @@ bool AVarBoundsInfo::addAssignment(BoundsKey L, BoundsKey R) {
     // dependency and never will be able to find the bounds for the return
     // value.
     if (L != R)
-      ProgVarGraph.addEdge(R, L);
+      ProgVarGraph.addUniqueEdge(R, L);
   } else {
-    ProgVarGraph.addEdge(L, R);
-    ProgVarGraph.addEdge(R, L);
+    ProgVarGraph.addUniqueEdge(R, L);
+    ProgramVar *PV = getProgramVar(R);
+    if (!(PV && PV->IsNumConstant()))
+      ProgVarGraph.addUniqueEdge(L, R);
   }
   return true;
 }
@@ -712,7 +714,45 @@ bool AvarBoundsInference::inferPossibleBounds(BoundsKey K, ABounds *SB,
     }
   }
 
-  return RetVal;
+  // All constants are reachable!
+  if (SBVar->IsNumConstant()) {
+    PotK.insert(FromVarK);
+  }
+
+  // Get all bounds key that are equivalent to FromVarK
+  std::set<BoundsKey> AllFKeys;
+  AllFKeys.clear();
+  AllFKeys.insert(FromVarK);
+
+  for (auto CurrVarK : AllFKeys) {
+    // Find all the in scope variables reachable from the CurrVarK
+    // bounds variable.
+    ScopeVisitor TV(DstScope, PotK, BI->PVarInfo,
+                    BI->PointerBoundsKey);
+    BKGraph.visitBreadthFirst(CurrVarK, [&TV](BoundsKey BK) {
+      TV.visitBoundsKey(BK);
+    });
+  }
+
+  // This is to get all the constants that are assigned to the variables
+  // reachable from FromVarK.
+  if (!SBVar->IsNumConstant()) {
+    std::set<BoundsKey> ReachableCons;
+    std::set<BoundsKey> Pre;
+    for (auto CK : PotK) {
+      Pre.clear();
+      BKGraph.getPredecessors(CK, Pre);
+      for (auto T : Pre) {
+        auto *TVar = BI->getProgramVar(T);
+        if (TVar->IsNumConstant()) {
+          ReachableCons.insert(T);
+        }
+      }
+    }
+    PotK.insert(ReachableCons.begin(), ReachableCons.end());
+  }
+
+  return !PotK.empty();
 }
 
 bool AvarBoundsInference::getRelevantBounds(std::set<BoundsKey> &RBKeys,
@@ -1065,11 +1105,10 @@ bool AVarBoundsInfo::performFlowAnalysis(ProgramInfo *PI) {
   // Any thing changed? which means bounds of a variable changed
   // Which means we need to recompute the flow based bounds for
   // all arrays that have flow based bounds.
-  if (keepHighestPriorityBounds(ArrPointerBoundsKey)) {
-    // Remove flow inferred bounds, if exist for all the array pointers.
-    for (auto TBK : ArrPointerBoundsKey)
-      removeBounds(TBK, FlowInferred);
-  }
+  keepHighestPriorityBounds(ArrPointerBoundsKey);
+  // Remove flow inferred bounds, if exist for all the array pointers.
+  for (auto TBK : ArrPointerBoundsKey)
+    removeBounds(TBK, FlowInferred);
 
   // Next, get the ARR pointers that has bounds.
   // These are pointers with bounds.