From 14491490a5276ff4da9b28100fb8e7d442944288 Mon Sep 17 00:00:00 2001 From: Ted Kremenek Date: Thu, 6 Dec 2012 19:40:32 +0000 Subject: [PATCH] Revert "[analyzer] Aggressively cut back on the canonicalization in RegionStore." Jordan and I discussed this, and we are going to do this another way. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@169538 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/StaticAnalyzer/Core/RegionStore.cpp | 68 +++++++++++-------------- 1 file changed, 31 insertions(+), 37 deletions(-) diff --git a/lib/StaticAnalyzer/Core/RegionStore.cpp b/lib/StaticAnalyzer/Core/RegionStore.cpp index d23dc250f8..5ad38a7991 100644 --- a/lib/StaticAnalyzer/Core/RegionStore.cpp +++ b/lib/StaticAnalyzer/Core/RegionStore.cpp @@ -217,8 +217,7 @@ public: public: // Made public for helper classes. - RegionBindings removeSubRegionBindings(RegionBindings B, const SubRegion *R, - bool Canonicalize = true); + RegionBindings removeSubRegionBindings(RegionBindings B, const SubRegion *R); RegionBindings addBinding(RegionBindings B, BindingKey K, SVal V); @@ -228,17 +227,13 @@ public: // Made public for helper classes. const SVal *lookup(RegionBindings B, BindingKey K); const SVal *lookup(RegionBindings B, const MemRegion *R, BindingKey::Kind k); - RegionBindings removeBinding(RegionBindings B, BindingKey K, - bool Canonicalize); + RegionBindings removeBinding(RegionBindings B, BindingKey K); RegionBindings removeBinding(RegionBindings B, const MemRegion *R, - BindingKey::Kind k, bool Canonicalize = true) { - return removeBinding(B, BindingKey::Make(R, k), Canonicalize); - } + BindingKey::Kind k); - RegionBindings removeBinding(RegionBindings B, const MemRegion *R, - bool Canonicalize = true) { - return removeBinding(removeBinding(B, R, BindingKey::Direct, false), - R, BindingKey::Default, Canonicalize); + RegionBindings removeBinding(RegionBindings B, const MemRegion *R) { + return removeBinding(removeBinding(B, R, BindingKey::Direct), R, + BindingKey::Default); } RegionBindings removeCluster(RegionBindings B, const MemRegion *R); @@ -569,15 +564,12 @@ static bool isCompatibleWithFields(BindingKey K, const FieldVector &Fields) { } RegionBindings RegionStoreManager::removeSubRegionBindings(RegionBindings B, - const SubRegion *R, - bool Canonicalize) { + const SubRegion *R) { BindingKey SRKey = BindingKey::Make(R, BindingKey::Default); const MemRegion *ClusterHead = SRKey.getBaseRegion(); if (R == ClusterHead) { // We can remove an entire cluster's bindings all in one go. - if (Canonicalize) - return RBFactory.remove(B, R); - return RBFactory.add(B, R, CBFactory.getEmptyMap(), /*Canonicalize=*/false); + return RBFactory.remove(B, R); } FieldVector FieldsInSymbolicSubregions; @@ -622,7 +614,7 @@ RegionBindings RegionStoreManager::removeSubRegionBindings(RegionBindings B, NextKey.getOffset() - SRKey.getOffset() < Length) { // Case 1: The next binding is inside the region we're invalidating. // Remove it. - Result = CBFactory.remove(Result, NextKey, /*Canonicalize=*/false); + Result = CBFactory.remove(Result, NextKey); } else if (NextKey.getOffset() == SRKey.getOffset()) { // Case 2: The next binding is at the same offset as the region we're @@ -632,7 +624,7 @@ RegionBindings RegionStoreManager::removeSubRegionBindings(RegionBindings B, // FIXME: This is probably incorrect; consider invalidating an outer // struct whose first field is bound to a LazyCompoundVal. if (NextKey.isDirect()) - Result = CBFactory.remove(Result, NextKey, /*Canonicalize=*/false); + Result = CBFactory.remove(Result, NextKey); } } else if (NextKey.hasSymbolicOffset()) { @@ -643,13 +635,13 @@ RegionBindings RegionStoreManager::removeSubRegionBindings(RegionBindings B, // we'll be conservative and remove it. if (NextKey.isDirect()) if (isCompatibleWithFields(NextKey, FieldsInSymbolicSubregions)) - Result = CBFactory.remove(Result, NextKey, /*Canonicalize=*/false); + Result = CBFactory.remove(Result, NextKey); } else if (const SubRegion *BaseSR = dyn_cast(Base)) { // Case 4: The next key is symbolic, but we changed a known // super-region. In this case the binding is certainly no longer valid. if (R == Base || BaseSR->isSubRegionOf(R)) if (isCompatibleWithFields(NextKey, FieldsInSymbolicSubregions)) - Result = CBFactory.remove(Result, NextKey, /*Canonicalize=*/false); + Result = CBFactory.remove(Result, NextKey); } } } @@ -658,14 +650,11 @@ RegionBindings RegionStoreManager::removeSubRegionBindings(RegionBindings B, // we don't treat the base region as uninitialized anymore. // FIXME: This isn't very precise; see the example in the loop. if (HasSymbolicOffset) - Result = CBFactory.add(Result, SRKey, UnknownVal(), /*Canonicalize=*/false); + Result = CBFactory.add(Result, SRKey, UnknownVal()); - if (Canonicalize) { - if (Result.isEmpty()) - return RBFactory.remove(B, ClusterHead, Canonicalize); - Result = CBFactory.getCanonicalMap(Result); - } - return RBFactory.add(B, ClusterHead, Result, Canonicalize); + if (Result.isEmpty()) + return RBFactory.remove(B, ClusterHead); + return RBFactory.add(B, ClusterHead, Result); } namespace { @@ -840,7 +829,7 @@ RegionBindings RegionStoreManager::invalidateGlobalRegion(MemRegion::Kind K, /* type does not matter */ Ctx.IntTy, Count); - B = removeBinding(B, GS, /*Canonicalize=*/false); + B = removeBinding(B, GS); B = addBinding(B, BindingKey::Make(GS, BindingKey::Default), V); // Even if there are no bindings in the global scope, we still need to @@ -1541,7 +1530,7 @@ StoreRef RegionStoreManager::Bind(Store store, Loc L, SVal V) { // Perform the binding. RegionBindings B = GetRegionBindings(store); - B = removeSubRegionBindings(B, cast(R), /*Canonicalize=*/false); + B = removeSubRegionBindings(B, cast(R)); BindingKey Key = BindingKey::Make(R, BindingKey::Direct); return StoreRef(addBinding(B, Key, V).getRootWithoutRetain(), *this); } @@ -1749,7 +1738,7 @@ StoreRef RegionStoreManager::BindAggregate(Store store, const TypedRegion *R, // we will invalidate. Then add the new binding. RegionBindings B = GetRegionBindings(store); - B = removeSubRegionBindings(B, R, /*Canonicalize=*/false); + B = removeSubRegionBindings(B, R); B = addBinding(B, R, BindingKey::Default, Val); return StoreRef(B.getRootWithoutRetain(), *this); @@ -1793,17 +1782,22 @@ const SVal *RegionStoreManager::lookup(RegionBindings B, } RegionBindings RegionStoreManager::removeBinding(RegionBindings B, - BindingKey K, - bool Canonicalize) { + BindingKey K) { const MemRegion *Base = K.getBaseRegion(); const ClusterBindings *Cluster = B.lookup(Base); if (!Cluster) return B; - ClusterBindings NewCluster = CBFactory.remove(*Cluster, K, Canonicalize); - if (Canonicalize && NewCluster.isEmpty()) + ClusterBindings NewCluster = CBFactory.remove(*Cluster, K); + if (NewCluster.isEmpty()) return RBFactory.remove(B, Base); - return RBFactory.add(B, Base, NewCluster, Canonicalize); + return RBFactory.add(B, Base, NewCluster); +} + +RegionBindings RegionStoreManager::removeBinding(RegionBindings B, + const MemRegion *R, + BindingKey::Kind k){ + return removeBinding(B, BindingKey::Make(R, k)); } RegionBindings RegionStoreManager::removeCluster(RegionBindings B, @@ -1976,7 +1970,7 @@ StoreRef RegionStoreManager::removeDeadBindings(Store store, continue; // Remove the dead entry. - B = RBFactory.remove(B, Base, /*Canonicalize=*/false); + B = removeCluster(B, Base); if (const SymbolicRegion *SymR = dyn_cast(Base)) SymReaper.maybeDead(SymR->getSymbol()); @@ -1992,7 +1986,7 @@ StoreRef RegionStoreManager::removeDeadBindings(Store store, } } - return StoreRef(RBFactory.getCanonicalMap(B).getRootWithoutRetain(), *this); + return StoreRef(B.getRootWithoutRetain(), *this); } //===----------------------------------------------------------------------===// -- 2.40.0