Fixing array legth inference performance issue

Author: Machiry

clang/include/clang/CConv/AVarBoundsInfo.h

@@ -119,10 +119,6 @@ class AvarBoundsInference {
                              AVarGraph &BKGraph,
                              bool CheckImmediate = false);
 
-  bool intersectBounds(std::set<ProgramVar *> &ProgVars,
-                       ABounds::BoundsKind BK,
-                       std::set<ABounds *> &CurrB);
-
   // Check if bounds specified by Bnds are declared bounds of K.
   bool areDeclaredBounds(BoundsKey K,
                          const std::pair<ABounds::BoundsKind,
@@ -192,7 +188,6 @@ class AVarBoundsInfo {
   BoundsKey getVariable(clang::FieldDecl *FD);
   BoundsKey getVariable(clang::FunctionDecl *FD);
   BoundsKey getConstKey(uint64_t value);
-  bool fetchAllConstKeys(uint64_t value, std::set<BoundsKey> &AllKeys);
 
   // Generate a random bounds key to be used for inference.
   BoundsKey getRandomBKey();
@@ -270,8 +265,8 @@ class AVarBoundsInfo {
   BoundsKey BCount;
   // Map of VarKeys and corresponding program variables.
   std::map<BoundsKey, ProgramVar *> PVarInfo;
-  // Map of APSInt (constants) and set of BoundKeys that correspond to it.
-  std::map<uint64_t, std::set<BoundsKey>> ConstVarKeys;
+  // 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.
   // Only the outer most pointer can have bounds.

clang/include/clang/CConv/ConstraintsGraph.h

@@ -137,7 +137,17 @@ class DataGraph :
     invalidateBFSCache();
   }
 
-  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

@@ -400,10 +400,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;
 }
@@ -512,25 +514,18 @@ BoundsKey AVarBoundsInfo::getVarKey(PersistentSourceLoc &PSL) {
 }
 
 BoundsKey AVarBoundsInfo::getConstKey(uint64_t value) {
-  BoundsKey NK = ++BCount;
-  std::string ConsString = std::to_string(value);
-  ProgramVar *NPV =
-    ProgramVar::createNewProgramVar(NK,
-                                    ConsString,
-                                    GlobalScope::getGlobalScope(),
-                                    true);
-  insertProgramVar(NK, NPV);
-  ConstVarKeys[value].insert(NK);
-  return NK;
-}
-
-bool AVarBoundsInfo::fetchAllConstKeys(uint64_t value,
-                                       std::set<BoundsKey> &AllKeys) {
-  if (ConstVarKeys.find(value) != ConstVarKeys.end()) {
-    AllKeys.insert(ConstVarKeys[value].begin(), ConstVarKeys[value].end());
-    return true;
+  if (ConstVarKeys.find(value) == ConstVarKeys.end()) {
+    BoundsKey NK = ++BCount;
+    std::string ConsString = std::to_string(value);
+    ProgramVar *NPV =
+      ProgramVar::createNewProgramVar(NK,
+                                      ConsString,
+                                      GlobalScope::getGlobalScope(),
+                                      true);
+    insertProgramVar(NK, NPV);
+    ConstVarKeys[value] = NK;
   }
-  return false;
+  return ConstVarKeys[value];
 }
 
 BoundsKey AVarBoundsInfo::getVarKey(llvm::APSInt &API) {
@@ -712,15 +707,6 @@ bool AvarBoundsInference::getReachableBoundKeys(const ProgramVarScope *DstScope,
   AllFKeys.clear();
   AllFKeys.insert(FromVarK);
 
-  // If this is a constant? Then get all bounds keys that
-  // correspond to the same constant
-  if (SBVar->IsNumConstant()) {
-    uint64_t ConsVal;
-    std::istringstream IS(SBVar->getVarName());
-    IS >> ConsVal;
-    BI->fetchAllConstKeys(ConsVal, AllFKeys);
-  }
-
   for (auto CurrVarK : AllFKeys) {
     // Find all the in scope variables reachable from the CurrVarK
     // bounds variable.
@@ -731,6 +717,24 @@ bool AvarBoundsInference::getReachableBoundKeys(const ProgramVarScope *DstScope,
     });
   }
 
+  // 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();
 }
 
@@ -1229,11 +1233,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);
 
   std::set<BoundsKey> ArrNeededBounds, ArrNeededBoundsNew;
   ArrNeededBounds.clear();