On Nov 1, 2012, at 6:54 PM, Jordan Rose <[email protected]> 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 > [email protected] > http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits _______________________________________________ cfe-commits mailing list [email protected] http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
