[cfe-commits] r167276 - in /cfe/trunk: include/clang/StaticAnalyzer/Core/PathSensitive/ lib/StaticAnalyzer/Checkers/ lib/StaticAnalyzer/Core/
Anna Zaks
ganna at apple.com
Fri Nov 2 18:40:22 PDT 2012
On Nov 1, 2012, at 6:54 PM, Jordan Rose <jordan_rose at apple.com> wrote:
> Author: jrose
> Date: Thu Nov 1 20:54:06 2012
> New Revision: 167276
>
> URL: http://llvm.org/viewvc/llvm-project?rev=167276&view=rev
> Log:
> [analyzer] Use nice macros for the common ProgramStateTraits (map, set, list).
>
> Also, move the REGISTER_*_WITH_PROGRAMSTATE macros to ProgramStateTrait.h.
>
I prefer the macros to live in the CheckerContext.h. I did see your comment about the original commit.
As you pointed out, the negatives of putting the macros into the CheckerContext is that the 2 internal users(maybe more in the future) will not be able to use it.
However, on the positive side, someone writing a checker would have all the main building blocks in one header file (no need to look in the obscure ProgramStateTrait.h).
Anyway, that's the reason I did not move it.
Anna.
> This doesn't get rid of /all/ explicit uses of ProgramStatePartialTrait,
> but it does get a lot of them.
>
> Modified:
> cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h
> cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramStateTrait.h
> cfe/trunk/lib/StaticAnalyzer/Checkers/CStringChecker.cpp
> cfe/trunk/lib/StaticAnalyzer/Checkers/GenericTaintChecker.cpp
> cfe/trunk/lib/StaticAnalyzer/Checkers/MacOSKeychainAPIChecker.cpp
> cfe/trunk/lib/StaticAnalyzer/Checkers/MallocChecker.cpp
> cfe/trunk/lib/StaticAnalyzer/Checkers/ObjCContainersChecker.cpp
> cfe/trunk/lib/StaticAnalyzer/Checkers/PthreadLockChecker.cpp
> cfe/trunk/lib/StaticAnalyzer/Checkers/RetainCountChecker.cpp
> cfe/trunk/lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp
> cfe/trunk/lib/StaticAnalyzer/Core/ProgramState.cpp
> cfe/trunk/lib/StaticAnalyzer/Core/RangeConstraintManager.cpp
>
> Modified: cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h?rev=167276&r1=167275&r2=167276&view=diff
> ==============================================================================
> --- cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h (original)
> +++ cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h Thu Nov 1 20:54:06 2012
> @@ -16,22 +16,6 @@
> #define LLVM_CLANG_SA_CORE_PATHSENSITIVE_CHECKERCONTEXT
>
> #include "clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h"
> -#include "llvm/ADT/ImmutableMap.h"
> -
> -/// Declares an immutable map of type NameTy, suitable for placement into
> -/// the ProgramState. The macro should not be used inside namespaces.
> -#define REGISTER_MAP_WITH_PROGRAMSTATE(Name, Key, Value) \
> - class Name {}; \
> - typedef llvm::ImmutableMap<Key, Value> Name ## Ty; \
> - namespace clang { \
> - namespace ento { \
> - template <> \
> - struct ProgramStateTrait<Name> \
> - : public ProgramStatePartialTrait<Name ## Ty> { \
> - static void *GDMIndex() { static int Index; return &Index; } \
> - }; \
> - } \
> - }
>
> namespace clang {
> namespace ento {
>
> Modified: cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramStateTrait.h
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramStateTrait.h?rev=167276&r1=167275&r2=167276&view=diff
> ==============================================================================
> --- cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramStateTrait.h (original)
> +++ cfe/trunk/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramStateTrait.h Thu Nov 1 20:54:06 2012
> @@ -31,6 +31,26 @@
> namespace ento {
> template <typename T> struct ProgramStatePartialTrait;
>
> + /// Declares a program state trait for type \p Type called \p Name, and
> + /// introduce a typedef named \c NameTy.
> + /// The macro should not be used inside namespaces, or for traits that must
> + /// be accessible from more than one translation unit.
> + #define REGISTER_TRAIT_WITH_PROGRAMSTATE(Name, Type) \
> + namespace { \
> + class Name {}; \
> + typedef Type Name ## Ty; \
> + } \
> + namespace clang { \
> + namespace ento { \
> + template <> \
> + struct ProgramStateTrait<Name> \
> + : public ProgramStatePartialTrait<Name ## Ty> { \
> + static void *GDMIndex() { static int Index; return &Index; } \
> + }; \
> + } \
> + }
> +
> +
> // Partial-specialization for ImmutableMap.
>
> template <typename Key, typename Data, typename Info>
> @@ -71,6 +91,17 @@
> }
> };
>
> + /// Helper for REGISTER_MAP_WITH_PROGRAMSTATE.
> + #define CLANG_ENTO_PROGRAMSTATE_MAP(Key, Value) llvm::ImmutableMap<Key, Value>
> +
> + /// Declares an immutable map of type \p NameTy, suitable for placement into
> + /// the ProgramState.
> + /// The macro should not be used inside namespaces, or for traits that must
> + /// be accessible from more than one translation unit.
> + #define REGISTER_MAP_WITH_PROGRAMSTATE(Name, Key, Value) \
> + REGISTER_TRAIT_WITH_PROGRAMSTATE(Name, \
> + CLANG_ENTO_PROGRAMSTATE_MAP(Key, Value))
> +
>
> // Partial-specialization for ImmutableSet.
>
> @@ -113,6 +144,14 @@
> }
> };
>
> + /// Declares an immutable list of type \p NameTy, suitable for placement into
> + /// the ProgramState.
> + /// The macro should not be used inside namespaces, or for traits that must
> + /// be accessible from more than one translation unit.
> + #define REGISTER_SET_WITH_PROGRAMSTATE(Name, Elem) \
> + REGISTER_TRAIT_WITH_PROGRAMSTATE(Name, llvm::ImmutableSet<Elem>)
> +
> +
> // Partial-specialization for ImmutableList.
>
> template <typename T>
> @@ -151,6 +190,14 @@
> }
> };
>
> + /// Declares an immutable list of type \p NameTy, suitable for placement into
> + /// the ProgramState.
> + /// The macro should not be used inside namespaces, or for traits that must
> + /// be accessible from more than one translation unit.
> + #define REGISTER_LIST_WITH_PROGRAMSTATE(Name, Elem) \
> + REGISTER_TRAIT_WITH_PROGRAMSTATE(Name, llvm::ImmutableList<Elem>)
> +
> +
> // Partial specialization for bool.
> template <> struct ProgramStatePartialTrait<bool> {
> typedef bool data_type;
>
> Modified: cfe/trunk/lib/StaticAnalyzer/Checkers/CStringChecker.cpp
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/StaticAnalyzer/Checkers/CStringChecker.cpp?rev=167276&r1=167275&r2=167276&view=diff
> ==============================================================================
> --- cfe/trunk/lib/StaticAnalyzer/Checkers/CStringChecker.cpp (original)
> +++ cfe/trunk/lib/StaticAnalyzer/Checkers/CStringChecker.cpp Thu Nov 1 20:54:06 2012
> @@ -188,21 +188,9 @@
> NonLoc right) const;
> };
>
> -class CStringLength {
> -public:
> - typedef llvm::ImmutableMap<const MemRegion *, SVal> EntryMap;
> -};
> } //end anonymous namespace
>
> -namespace clang {
> -namespace ento {
> - template <>
> - struct ProgramStateTrait<CStringLength>
> - : public ProgramStatePartialTrait<CStringLength::EntryMap> {
> - static void *GDMIndex() { return CStringChecker::getTag(); }
> - };
> -}
> -}
> +REGISTER_MAP_WITH_PROGRAMSTATE(CStringLength, const MemRegion *, SVal)
>
> //===----------------------------------------------------------------------===//
> // Individual checks and utility methods.
> @@ -1878,7 +1866,7 @@
> }
>
> bool CStringChecker::wantsRegionChangeUpdate(ProgramStateRef state) const {
> - CStringLength::EntryMap Entries = state->get<CStringLength>();
> + CStringLengthTy Entries = state->get<CStringLength>();
> return !Entries.isEmpty();
> }
>
> @@ -1888,7 +1876,7 @@
> ArrayRef<const MemRegion *> ExplicitRegions,
> ArrayRef<const MemRegion *> Regions,
> const CallEvent *Call) const {
> - CStringLength::EntryMap Entries = state->get<CStringLength>();
> + CStringLengthTy Entries = state->get<CStringLength>();
> if (Entries.isEmpty())
> return state;
>
> @@ -1908,10 +1896,10 @@
> }
> }
>
> - CStringLength::EntryMap::Factory &F = state->get_context<CStringLength>();
> + CStringLengthTy::Factory &F = state->get_context<CStringLength>();
>
> // Then loop over the entries in the current state.
> - for (CStringLength::EntryMap::iterator I = Entries.begin(),
> + for (CStringLengthTy::iterator I = Entries.begin(),
> E = Entries.end(); I != E; ++I) {
> const MemRegion *MR = I.getKey();
>
> @@ -1938,9 +1926,9 @@
> void CStringChecker::checkLiveSymbols(ProgramStateRef state,
> SymbolReaper &SR) const {
> // Mark all symbols in our string length map as valid.
> - CStringLength::EntryMap Entries = state->get<CStringLength>();
> + CStringLengthTy Entries = state->get<CStringLength>();
>
> - for (CStringLength::EntryMap::iterator I = Entries.begin(), E = Entries.end();
> + for (CStringLengthTy::iterator I = Entries.begin(), E = Entries.end();
> I != E; ++I) {
> SVal Len = I.getData();
>
> @@ -1956,12 +1944,12 @@
> return;
>
> ProgramStateRef state = C.getState();
> - CStringLength::EntryMap Entries = state->get<CStringLength>();
> + CStringLengthTy Entries = state->get<CStringLength>();
> if (Entries.isEmpty())
> return;
>
> - CStringLength::EntryMap::Factory &F = state->get_context<CStringLength>();
> - for (CStringLength::EntryMap::iterator I = Entries.begin(), E = Entries.end();
> + CStringLengthTy::Factory &F = state->get_context<CStringLength>();
> + for (CStringLengthTy::iterator I = Entries.begin(), E = Entries.end();
> I != E; ++I) {
> SVal Len = I.getData();
> if (SymbolRef Sym = Len.getAsSymbol()) {
>
> Modified: cfe/trunk/lib/StaticAnalyzer/Checkers/GenericTaintChecker.cpp
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/StaticAnalyzer/Checkers/GenericTaintChecker.cpp?rev=167276&r1=167275&r2=167276&view=diff
> ==============================================================================
> --- cfe/trunk/lib/StaticAnalyzer/Checkers/GenericTaintChecker.cpp (original)
> +++ cfe/trunk/lib/StaticAnalyzer/Checkers/GenericTaintChecker.cpp Thu Nov 1 20:54:06 2012
> @@ -192,13 +192,7 @@
> /// to the call post-visit. The values are unsigned integers, which are either
> /// ReturnValueIndex, or indexes of the pointer/reference argument, which
> /// points to data, which should be tainted on return.
> -namespace { struct TaintArgsOnPostVisit{}; }
> -namespace clang { namespace ento {
> -template<> struct ProgramStateTrait<TaintArgsOnPostVisit>
> - : public ProgramStatePartialTrait<llvm::ImmutableSet<unsigned> > {
> - static void *GDMIndex() { return GenericTaintChecker::getTag(); }
> -};
> -}}
> +REGISTER_SET_WITH_PROGRAMSTATE(TaintArgsOnPostVisit, unsigned)
>
> GenericTaintChecker::TaintPropagationRule
> GenericTaintChecker::TaintPropagationRule::getTaintPropagationRule(
> @@ -337,7 +331,7 @@
> // Depending on what was tainted at pre-visit, we determined a set of
> // arguments which should be tainted after the function returns. These are
> // stored in the state as TaintArgsOnPostVisit set.
> - llvm::ImmutableSet<unsigned> TaintArgs = State->get<TaintArgsOnPostVisit>();
> + TaintArgsOnPostVisitTy TaintArgs = State->get<TaintArgsOnPostVisit>();
> if (TaintArgs.isEmpty())
> return false;
>
>
> Modified: cfe/trunk/lib/StaticAnalyzer/Checkers/MacOSKeychainAPIChecker.cpp
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/StaticAnalyzer/Checkers/MacOSKeychainAPIChecker.cpp?rev=167276&r1=167275&r2=167276&view=diff
> ==============================================================================
> --- cfe/trunk/lib/StaticAnalyzer/Checkers/MacOSKeychainAPIChecker.cpp (original)
> +++ cfe/trunk/lib/StaticAnalyzer/Checkers/MacOSKeychainAPIChecker.cpp Thu Nov 1 20:54:06 2012
> @@ -158,16 +158,9 @@
> /// ProgramState traits to store the currently allocated (and not yet freed)
> /// symbols. This is a map from the allocated content symbol to the
> /// corresponding AllocationState.
> -typedef llvm::ImmutableMap<SymbolRef,
> - MacOSKeychainAPIChecker::AllocationState> AllocatedSetTy;
> -
> -namespace { struct AllocatedData {}; }
> -namespace clang { namespace ento {
> -template<> struct ProgramStateTrait<AllocatedData>
> - : public ProgramStatePartialTrait<AllocatedSetTy > {
> - static void *GDMIndex() { static int index = 0; return &index; }
> -};
> -}}
> +REGISTER_MAP_WITH_PROGRAMSTATE(AllocatedData,
> + SymbolRef,
> + MacOSKeychainAPIChecker::AllocationState)
>
> static bool isEnclosingFunctionParam(const Expr *E) {
> E = E->IgnoreParenCasts();
> @@ -571,13 +564,13 @@
> void MacOSKeychainAPIChecker::checkDeadSymbols(SymbolReaper &SR,
> CheckerContext &C) const {
> ProgramStateRef State = C.getState();
> - AllocatedSetTy ASet = State->get<AllocatedData>();
> + AllocatedDataTy ASet = State->get<AllocatedData>();
> if (ASet.isEmpty())
> return;
>
> bool Changed = false;
> AllocationPairVec Errors;
> - for (AllocatedSetTy::iterator I = ASet.begin(), E = ASet.end(); I != E; ++I) {
> + for (AllocatedDataTy::iterator I = ASet.begin(), E = ASet.end(); I != E; ++I) {
> if (SR.isLive(I->first))
> continue;
>
> @@ -619,7 +612,7 @@
> if (C.getLocationContext()->getParent() != 0)
> return;
>
> - AllocatedSetTy AS = state->get<AllocatedData>();
> + AllocatedDataTy AS = state->get<AllocatedData>();
> if (AS.isEmpty())
> return;
>
> @@ -627,7 +620,7 @@
> // found here, so report it.
> bool Changed = false;
> AllocationPairVec Errors;
> - for (AllocatedSetTy::iterator I = AS.begin(), E = AS.end(); I != E; ++I ) {
> + for (AllocatedDataTy::iterator I = AS.begin(), E = AS.end(); I != E; ++I ) {
> Changed = true;
> state = state->remove<AllocatedData>(I->first);
> // If the allocated symbol is null or if error code was returned at
>
> Modified: cfe/trunk/lib/StaticAnalyzer/Checkers/MallocChecker.cpp
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/StaticAnalyzer/Checkers/MallocChecker.cpp?rev=167276&r1=167275&r2=167276&view=diff
> ==============================================================================
> --- cfe/trunk/lib/StaticAnalyzer/Checkers/MallocChecker.cpp (original)
> +++ cfe/trunk/lib/StaticAnalyzer/Checkers/MallocChecker.cpp Thu Nov 1 20:54:06 2012
> @@ -338,25 +338,8 @@
> };
> } // end anonymous namespace
>
> -typedef llvm::ImmutableMap<SymbolRef, RefState> RegionStateTy;
> -typedef llvm::ImmutableMap<SymbolRef, ReallocPair > ReallocMap;
> -class RegionState {};
> -class ReallocPairs {};
> -namespace clang {
> -namespace ento {
> - template <>
> - struct ProgramStateTrait<RegionState>
> - : public ProgramStatePartialTrait<RegionStateTy> {
> - static void *GDMIndex() { static int x; return &x; }
> - };
> -
> - template <>
> - struct ProgramStateTrait<ReallocPairs>
> - : public ProgramStatePartialTrait<ReallocMap> {
> - static void *GDMIndex() { static int x; return &x; }
> - };
> -}
> -}
> +REGISTER_MAP_WITH_PROGRAMSTATE(RegionState, SymbolRef, RefState)
> +REGISTER_MAP_WITH_PROGRAMSTATE(ReallocPairs, SymbolRef, ReallocPair)
>
> namespace {
> class StopTrackingCallback : public SymbolVisitor {
> @@ -1073,8 +1056,8 @@
> }
>
> // Cleanup the Realloc Pairs Map.
> - ReallocMap RP = state->get<ReallocPairs>();
> - for (ReallocMap::iterator I = RP.begin(), E = RP.end(); I != E; ++I) {
> + ReallocPairsTy RP = state->get<ReallocPairs>();
> + for (ReallocPairsTy::iterator I = RP.begin(), E = RP.end(); I != E; ++I) {
> if (SymReaper.isDead(I->first) ||
> SymReaper.isDead(I->second.ReallocatedSym)) {
> state = state->remove<ReallocPairs>(I->first);
> @@ -1300,8 +1283,8 @@
>
> // Realloc returns 0 when reallocation fails, which means that we should
> // restore the state of the pointer being reallocated.
> - ReallocMap RP = state->get<ReallocPairs>();
> - for (ReallocMap::iterator I = RP.begin(), E = RP.end(); I != E; ++I) {
> + ReallocPairsTy RP = state->get<ReallocPairs>();
> + for (ReallocPairsTy::iterator I = RP.begin(), E = RP.end(); I != E; ++I) {
> // If the symbol is assumed to be NULL, remove it from consideration.
> ConstraintManager &CMgr = state->getConstraintManager();
> ConditionTruthVal AllocFailed = CMgr.isNull(state, I.getKey());
> @@ -1513,10 +1496,10 @@
>
> static SymbolRef findFailedReallocSymbol(ProgramStateRef currState,
> ProgramStateRef prevState) {
> - ReallocMap currMap = currState->get<ReallocPairs>();
> - ReallocMap prevMap = prevState->get<ReallocPairs>();
> + ReallocPairsTy currMap = currState->get<ReallocPairs>();
> + ReallocPairsTy prevMap = prevState->get<ReallocPairs>();
>
> - for (ReallocMap::iterator I = prevMap.begin(), E = prevMap.end();
> + for (ReallocPairsTy::iterator I = prevMap.begin(), E = prevMap.end();
> I != E; ++I) {
> SymbolRef sym = I.getKey();
> if (!currMap.lookup(sym))
>
> Modified: cfe/trunk/lib/StaticAnalyzer/Checkers/ObjCContainersChecker.cpp
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/StaticAnalyzer/Checkers/ObjCContainersChecker.cpp?rev=167276&r1=167275&r2=167276&view=diff
> ==============================================================================
> --- cfe/trunk/lib/StaticAnalyzer/Checkers/ObjCContainersChecker.cpp (original)
> +++ cfe/trunk/lib/StaticAnalyzer/Checkers/ObjCContainersChecker.cpp Thu Nov 1 20:54:06 2012
> @@ -55,16 +55,8 @@
> };
> } // end anonymous namespace
>
> -// ProgramState trait - a map from array symbol to it's state.
> -typedef llvm::ImmutableMap<SymbolRef, DefinedSVal> ArraySizeM;
> -
> -namespace { struct ArraySizeMap {}; }
> -namespace clang { namespace ento {
> -template<> struct ProgramStateTrait<ArraySizeMap>
> - : public ProgramStatePartialTrait<ArraySizeM > {
> - static void *GDMIndex() { return ObjCContainersChecker::getTag(); }
> -};
> -}}
> +// ProgramState trait - a map from array symbol to its state.
> +REGISTER_MAP_WITH_PROGRAMSTATE(ArraySizeMap, SymbolRef, DefinedSVal)
>
> void ObjCContainersChecker::addSizeInfo(const Expr *Array, const Expr *Size,
> CheckerContext &C) const {
>
> Modified: cfe/trunk/lib/StaticAnalyzer/Checkers/PthreadLockChecker.cpp
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/StaticAnalyzer/Checkers/PthreadLockChecker.cpp?rev=167276&r1=167275&r2=167276&view=diff
> ==============================================================================
> --- cfe/trunk/lib/StaticAnalyzer/Checkers/PthreadLockChecker.cpp (original)
> +++ cfe/trunk/lib/StaticAnalyzer/Checkers/PthreadLockChecker.cpp Thu Nov 1 20:54:06 2012
> @@ -43,15 +43,7 @@
> } // end anonymous namespace
>
> // GDM Entry for tracking lock state.
> -namespace { class LockSet {}; }
> -namespace clang {
> -namespace ento {
> -template <> struct ProgramStateTrait<LockSet> :
> - public ProgramStatePartialTrait<llvm::ImmutableList<const MemRegion*> > {
> - static void *GDMIndex() { static int x = 0; return &x; }
> -};
> -} // end of ento (ProgramState) namespace
> -} // end clang namespace
> +REGISTER_LIST_WITH_PROGRAMSTATE(LockSet, const MemRegion *)
>
>
> void PthreadLockChecker::checkPostStmt(const CallExpr *CE,
> @@ -163,7 +155,7 @@
> return;
>
> ProgramStateRef state = C.getState();
> - llvm::ImmutableList<const MemRegion*> LS = state->get<LockSet>();
> + LockSetTy LS = state->get<LockSet>();
>
> // FIXME: Better analysis requires IPA for wrappers.
> // FIXME: check for double unlocks
>
> Modified: cfe/trunk/lib/StaticAnalyzer/Checkers/RetainCountChecker.cpp
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/StaticAnalyzer/Checkers/RetainCountChecker.cpp?rev=167276&r1=167275&r2=167276&view=diff
> ==============================================================================
> --- cfe/trunk/lib/StaticAnalyzer/Checkers/RetainCountChecker.cpp (original)
> +++ cfe/trunk/lib/StaticAnalyzer/Checkers/RetainCountChecker.cpp Thu Nov 1 20:54:06 2012
> @@ -342,20 +342,7 @@
> // RefBindings - State used to track object reference counts.
> //===----------------------------------------------------------------------===//
>
> -typedef llvm::ImmutableMap<SymbolRef, RefVal> RefBindings;
> -
> -namespace clang {
> -namespace ento {
> -template<>
> -struct ProgramStateTrait<RefBindings>
> - : public ProgramStatePartialTrait<RefBindings> {
> - static void *GDMIndex() {
> - static int RefBIndex = 0;
> - return &RefBIndex;
> - }
> -};
> -}
> -}
> +REGISTER_MAP_WITH_PROGRAMSTATE(RefBindings, SymbolRef, RefVal)
>
> static inline const RefVal *getRefBinding(ProgramStateRef State,
> SymbolRef Sym) {
> @@ -3438,15 +3425,15 @@
> // too bad since the number of symbols we will track in practice are
> // probably small and evalAssume is only called at branches and a few
> // other places.
> - RefBindings B = state->get<RefBindings>();
> + RefBindingsTy B = state->get<RefBindings>();
>
> if (B.isEmpty())
> return state;
>
> bool changed = false;
> - RefBindings::Factory &RefBFactory = state->get_context<RefBindings>();
> + RefBindingsTy::Factory &RefBFactory = state->get_context<RefBindings>();
>
> - for (RefBindings::iterator I = B.begin(), E = B.end(); I != E; ++I) {
> + for (RefBindingsTy::iterator I = B.begin(), E = B.end(); I != E; ++I) {
> // Check if the symbol is null stop tracking the symbol.
> ConstraintManager &CMgr = state->getConstraintManager();
> ConditionTruthVal AllocFailed = CMgr.isNull(state, I.getKey());
> @@ -3607,10 +3594,10 @@
>
> void RetainCountChecker::checkEndPath(CheckerContext &Ctx) const {
> ProgramStateRef state = Ctx.getState();
> - RefBindings B = state->get<RefBindings>();
> + RefBindingsTy B = state->get<RefBindings>();
> ExplodedNode *Pred = Ctx.getPredecessor();
>
> - for (RefBindings::iterator I = B.begin(), E = B.end(); I != E; ++I) {
> + for (RefBindingsTy::iterator I = B.begin(), E = B.end(); I != E; ++I) {
> llvm::tie(Pred, state) = handleAutoreleaseCounts(state, Pred, /*Tag=*/0,
> Ctx, I->first, I->second);
> if (!state)
> @@ -3627,7 +3614,7 @@
> B = state->get<RefBindings>();
> SmallVector<SymbolRef, 10> Leaked;
>
> - for (RefBindings::iterator I = B.begin(), E = B.end(); I != E; ++I)
> + for (RefBindingsTy::iterator I = B.begin(), E = B.end(); I != E; ++I)
> state = handleSymbolDeath(state, I->first, I->second, Leaked);
>
> processLeaks(state, Leaked, Ctx, Pred);
> @@ -3651,7 +3638,7 @@
> ExplodedNode *Pred = C.getPredecessor();
>
> ProgramStateRef state = C.getState();
> - RefBindings B = state->get<RefBindings>();
> + RefBindingsTy B = state->get<RefBindings>();
>
> // Update counts from autorelease pools
> for (SymbolReaper::dead_iterator I = SymReaper.dead_begin(),
> @@ -3684,7 +3671,7 @@
> return;
>
> // Now generate a new node that nukes the old bindings.
> - RefBindings::Factory &F = state->get_context<RefBindings>();
> + RefBindingsTy::Factory &F = state->get_context<RefBindings>();
>
> for (SymbolReaper::dead_iterator I = SymReaper.dead_begin(),
> E = SymReaper.dead_end(); I != E; ++I)
> @@ -3697,12 +3684,12 @@
> void RetainCountChecker::printState(raw_ostream &Out, ProgramStateRef State,
> const char *NL, const char *Sep) const {
>
> - RefBindings B = State->get<RefBindings>();
> + RefBindingsTy B = State->get<RefBindings>();
>
> if (!B.isEmpty())
> Out << Sep << NL;
>
> - for (RefBindings::iterator I = B.begin(), E = B.end(); I != E; ++I) {
> + for (RefBindingsTy::iterator I = B.begin(), E = B.end(); I != E; ++I) {
> Out << I->first << " : ";
> I->second.print(Out);
> Out << NL;
>
> Modified: cfe/trunk/lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp?rev=167276&r1=167275&r2=167276&view=diff
> ==============================================================================
> --- cfe/trunk/lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp (original)
> +++ cfe/trunk/lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp Thu Nov 1 20:54:06 2012
> @@ -406,26 +406,20 @@
> return true;
> }
>
> -/// The GDM component containing the dynamic dispatch bifurcation info. When
> -/// the exact type of the receiver is not known, we want to explore both paths -
> -/// one on which we do inline it and the other one on which we don't. This is
> -/// done to ensure we do not drop coverage.
> -/// This is the map from the receiver region to a bool, specifying either we
> -/// consider this region's information precise or not along the given path.
> -namespace clang {
> -namespace ento {
> -enum DynamicDispatchMode { DynamicDispatchModeInlined = 1,
> - DynamicDispatchModeConservative };
> -
> -struct DynamicDispatchBifurcationMap {};
> -typedef llvm::ImmutableMap<const MemRegion*,
> - unsigned int> DynamicDispatchBifur;
> -template<> struct ProgramStateTrait<DynamicDispatchBifurcationMap>
> - : public ProgramStatePartialTrait<DynamicDispatchBifur> {
> - static void *GDMIndex() { static int index; return &index; }
> -};
> -
> -}}
> +// The GDM component containing the dynamic dispatch bifurcation info. When
> +// the exact type of the receiver is not known, we want to explore both paths -
> +// one on which we do inline it and the other one on which we don't. This is
> +// done to ensure we do not drop coverage.
> +// This is the map from the receiver region to a bool, specifying either we
> +// consider this region's information precise or not along the given path.
> +namespace {
> + enum DynamicDispatchMode {
> + DynamicDispatchModeInlined = 1,
> + DynamicDispatchModeConservative
> + };
> +}
> +REGISTER_MAP_WITH_PROGRAMSTATE(DynamicDispatchBifurcationMap,
> + const MemRegion *, unsigned)
>
> bool ExprEngine::inlineCall(const CallEvent &Call, const Decl *D,
> NodeBuilder &Bldr, ExplodedNode *Pred,
> @@ -734,7 +728,7 @@
> // Check if we've performed the split already - note, we only want
> // to split the path once per memory region.
> ProgramStateRef State = Pred->getState();
> - const unsigned int *BState =
> + const unsigned *BState =
> State->get<DynamicDispatchBifurcationMap>(BifurReg);
> if (BState) {
> // If we are on "inline path", keep inlining if possible.
>
> Modified: cfe/trunk/lib/StaticAnalyzer/Core/ProgramState.cpp
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/StaticAnalyzer/Core/ProgramState.cpp?rev=167276&r1=167275&r2=167276&view=diff
> ==============================================================================
> --- cfe/trunk/lib/StaticAnalyzer/Core/ProgramState.cpp (original)
> +++ cfe/trunk/lib/StaticAnalyzer/Core/ProgramState.cpp Thu Nov 1 20:54:06 2012
> @@ -713,15 +713,10 @@
> }
>
> /// The GDM component containing the dynamic type info. This is a map from a
> -/// symbol to it's most likely type.
> -namespace clang {
> -namespace ento {
> -typedef llvm::ImmutableMap<const MemRegion *, DynamicTypeInfo> DynamicTypeMap;
> -template<> struct ProgramStateTrait<DynamicTypeMap>
> - : public ProgramStatePartialTrait<DynamicTypeMap> {
> - static void *GDMIndex() { static int index; return &index; }
> -};
> -}}
> +/// symbol to its most likely type.
> +REGISTER_MAP_WITH_PROGRAMSTATE(DynamicTypeMap,
> + const MemRegion *,
> + DynamicTypeInfo)
>
> DynamicTypeInfo ProgramState::getDynamicTypeInfo(const MemRegion *Reg) const {
> Reg = Reg->StripCasts();
>
> Modified: cfe/trunk/lib/StaticAnalyzer/Core/RangeConstraintManager.cpp
> URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/StaticAnalyzer/Core/RangeConstraintManager.cpp?rev=167276&r1=167275&r2=167276&view=diff
> ==============================================================================
> --- cfe/trunk/lib/StaticAnalyzer/Core/RangeConstraintManager.cpp (original)
> +++ cfe/trunk/lib/StaticAnalyzer/Core/RangeConstraintManager.cpp Thu Nov 1 20:54:06 2012
> @@ -24,9 +24,6 @@
> using namespace clang;
> using namespace ento;
>
> -namespace { class ConstraintRange {}; }
> -static int ConstraintRangeIndex = 0;
> -
> /// A Range represents the closed range [from, to]. The caller must
> /// guarantee that from <= to. Note that Range is immutable, so as not
> /// to subvert RangeSet's immutability.
> @@ -280,17 +277,7 @@
> };
> } // end anonymous namespace
>
> -typedef llvm::ImmutableMap<SymbolRef,RangeSet> ConstraintRangeTy;
> -
> -namespace clang {
> -namespace ento {
> -template<>
> -struct ProgramStateTrait<ConstraintRange>
> - : public ProgramStatePartialTrait<ConstraintRangeTy> {
> - static inline void *GDMIndex() { return &ConstraintRangeIndex; }
> -};
> -}
> -}
> +REGISTER_MAP_WITH_PROGRAMSTATE(ConstraintRange, SymbolRef, RangeSet)
>
> namespace {
> class RangeConstraintManager : public SimpleConstraintManager{
>
>
> _______________________________________________
> cfe-commits mailing list
> cfe-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
More information about the cfe-commits
mailing list