Implement lazy "copying" of structures and arrays in RegionStore. While

RegionStore already lazily abstracted the contents of arrays and structs, when
doing an assignment from one array/struct to another we did an explicit
element-wise copy, which resulted in a loss of laziness and huge performance
problem when analyzing many code bases.

Now RegionStoreManager handles such assignments using a new SVal could
'LazyCompoundSVal', which basically means the value of a given struct or array
(a MemRegion*) in a specific state (GRState). When we do a load from a field
whose encompassing struct binds to a LazyCompoundSVal, we essentially do a field
lookup in the original structure. This means we have essentially zero copying of
data for structs/arrays and everything stays lazy.


git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@78268 91177308-0d34-0410-b5e6-96231b3b80d8

1 files changed, 23 insertions, 1 deletions

diff --git a/include/clang/Analysis/PathSensitive/BasicValueFactory.h b/include/clang/Analysis/PathSensitive/BasicValueFactory.h
index 71a705d2d7..74d08e8410 100644
--- a/include/clang/Analysis/PathSensitive/BasicValueFactory.h
+++ b/include/clang/Analysis/PathSensitive/BasicValueFactory.h
@@ -25,6 +25,8 @@
 
 namespace clang {
   
+  class GRState;
+
 class CompoundValData : public llvm::FoldingSetNode {
   QualType T;
   llvm::ImmutableList<SVal> L;
@@ -43,6 +45,22 @@ public:
   void Profile(llvm::FoldingSetNodeID& ID) { Profile(ID, T, L); }
 };
 
+class LazyCompoundValData : public llvm::FoldingSetNode {
+  const GRState *state;
+  const TypedRegion *region;
+public:
+  LazyCompoundValData(const GRState *st, const TypedRegion *r)
+    : state(st), region(r) {}
+  
+  const GRState *getState() const { return state; }
+  const TypedRegion *getRegion() const { return region; }
+    
+  static void Profile(llvm::FoldingSetNodeID& ID, const GRState *state,
+                      const TypedRegion *region);
+  
+  void Profile(llvm::FoldingSetNodeID& ID) { Profile(ID, state, region); }
+};
+  
 class BasicValueFactory {
   typedef llvm::FoldingSet<llvm::FoldingSetNodeWrapper<llvm::APSInt> >
           APSIntSetTy;
@@ -56,6 +74,7 @@ class BasicValueFactory {
 
   llvm::ImmutableList<SVal>::Factory SValListFactory;
   llvm::FoldingSet<CompoundValData>  CompoundValDataSet;
+  llvm::FoldingSet<LazyCompoundValData> LazyCompoundValDataSet;
 
 public:
   BasicValueFactory(ASTContext& ctx, llvm::BumpPtrAllocator& Alloc) 
@@ -138,9 +157,12 @@ public:
     return getTruthValue(b, Ctx.IntTy);
   }
   
-  const CompoundValData* getCompoundValData(QualType T, 
+  const CompoundValData *getCompoundValData(QualType T, 
                                             llvm::ImmutableList<SVal> Vals);
   
+  const LazyCompoundValData *getLazyCompoundValData(const GRState *state,
+                                                    const TypedRegion *region);
+  
   llvm::ImmutableList<SVal> getEmptySValList() {
     return SValListFactory.GetEmptyList();
   }