Rename SymbolID to SymbolRef. This is a precursor to some overhauling of the representation of symbolic values.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@60575 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/lib/Analysis/BasicConstraintManager.cpp b/lib/Analysis/BasicConstraintManager.cpp
index f4290ff..7c303b2 100644
--- a/lib/Analysis/BasicConstraintManager.cpp
+++ b/lib/Analysis/BasicConstraintManager.cpp
@@ -22,8 +22,8 @@
namespace {
-typedef llvm::ImmutableMap<SymbolID,GRState::IntSetTy> ConstNotEqTy;
-typedef llvm::ImmutableMap<SymbolID,const llvm::APSInt*> ConstEqTy;
+typedef llvm::ImmutableMap<SymbolRef,GRState::IntSetTy> ConstNotEqTy;
+typedef llvm::ImmutableMap<SymbolRef,const llvm::APSInt*> ConstEqTy;
// BasicConstraintManager only tracks equality and inequality constraints of
// constants and integer variables.
@@ -52,34 +52,34 @@
const GRState* AssumeSymInt(const GRState* St, bool Assumption,
const SymIntConstraint& C, bool& isFeasible);
- const GRState* AssumeSymNE(const GRState* St, SymbolID sym,
+ const GRState* AssumeSymNE(const GRState* St, SymbolRef sym,
const llvm::APSInt& V, bool& isFeasible);
- const GRState* AssumeSymEQ(const GRState* St, SymbolID sym,
+ const GRState* AssumeSymEQ(const GRState* St, SymbolRef sym,
const llvm::APSInt& V, bool& isFeasible);
- const GRState* AssumeSymLT(const GRState* St, SymbolID sym,
+ const GRState* AssumeSymLT(const GRState* St, SymbolRef sym,
const llvm::APSInt& V, bool& isFeasible);
- const GRState* AssumeSymGT(const GRState* St, SymbolID sym,
+ const GRState* AssumeSymGT(const GRState* St, SymbolRef sym,
const llvm::APSInt& V, bool& isFeasible);
- const GRState* AssumeSymGE(const GRState* St, SymbolID sym,
+ const GRState* AssumeSymGE(const GRState* St, SymbolRef sym,
const llvm::APSInt& V, bool& isFeasible);
- const GRState* AssumeSymLE(const GRState* St, SymbolID sym,
+ const GRState* AssumeSymLE(const GRState* St, SymbolRef sym,
const llvm::APSInt& V, bool& isFeasible);
const GRState* AssumeInBound(const GRState* St, SVal Idx, SVal UpperBound,
bool Assumption, bool& isFeasible);
- const GRState* AddEQ(const GRState* St, SymbolID sym, const llvm::APSInt& V);
+ const GRState* AddEQ(const GRState* St, SymbolRef sym, const llvm::APSInt& V);
- const GRState* AddNE(const GRState* St, SymbolID sym, const llvm::APSInt& V);
+ const GRState* AddNE(const GRState* St, SymbolRef sym, const llvm::APSInt& V);
- const llvm::APSInt* getSymVal(const GRState* St, SymbolID sym);
- bool isNotEqual(const GRState* St, SymbolID sym, const llvm::APSInt& V) const;
- bool isEqual(const GRState* St, SymbolID sym, const llvm::APSInt& V) const;
+ const llvm::APSInt* getSymVal(const GRState* St, SymbolRef sym);
+ bool isNotEqual(const GRState* St, SymbolRef sym, const llvm::APSInt& V) const;
+ bool isEqual(const GRState* St, SymbolRef sym, const llvm::APSInt& V) const;
const GRState* RemoveDeadBindings(const GRState* St,
StoreManager::LiveSymbolsTy& LSymbols,
@@ -189,7 +189,7 @@
case nonloc::SymbolValKind: {
nonloc::SymbolVal& SV = cast<nonloc::SymbolVal>(Cond);
- SymbolID sym = SV.getSymbol();
+ SymbolRef sym = SV.getSymbol();
if (Assumption)
return AssumeSymNE(St, sym, BasicVals.getValue(0, SymMgr.getType(sym)),
@@ -266,7 +266,7 @@
}
const GRState*
-BasicConstraintManager::AssumeSymNE(const GRState* St, SymbolID sym,
+BasicConstraintManager::AssumeSymNE(const GRState* St, SymbolRef sym,
const llvm::APSInt& V, bool& isFeasible) {
// First, determine if sym == X, where X != V.
if (const llvm::APSInt* X = getSymVal(St, sym)) {
@@ -287,7 +287,7 @@
}
const GRState*
-BasicConstraintManager::AssumeSymEQ(const GRState* St, SymbolID sym,
+BasicConstraintManager::AssumeSymEQ(const GRState* St, SymbolRef sym,
const llvm::APSInt& V, bool& isFeasible) {
// First, determine if sym == X, where X != V.
if (const llvm::APSInt* X = getSymVal(St, sym)) {
@@ -310,7 +310,7 @@
// These logic will be handled in another ConstraintManager.
const GRState*
-BasicConstraintManager::AssumeSymLT(const GRState* St, SymbolID sym,
+BasicConstraintManager::AssumeSymLT(const GRState* St, SymbolRef sym,
const llvm::APSInt& V, bool& isFeasible) {
// Is 'V' the smallest possible value?
@@ -325,7 +325,7 @@
}
const GRState*
-BasicConstraintManager::AssumeSymGT(const GRState* St, SymbolID sym,
+BasicConstraintManager::AssumeSymGT(const GRState* St, SymbolRef sym,
const llvm::APSInt& V, bool& isFeasible) {
// Is 'V' the largest possible value?
@@ -340,7 +340,7 @@
}
const GRState*
-BasicConstraintManager::AssumeSymGE(const GRState* St, SymbolID sym,
+BasicConstraintManager::AssumeSymGE(const GRState* St, SymbolRef sym,
const llvm::APSInt& V, bool& isFeasible) {
// Reject a path if the value of sym is a constant X and !(X >= V).
@@ -369,7 +369,7 @@
}
const GRState*
-BasicConstraintManager::AssumeSymLE(const GRState* St, SymbolID sym,
+BasicConstraintManager::AssumeSymLE(const GRState* St, SymbolRef sym,
const llvm::APSInt& V, bool& isFeasible) {
// Reject a path if the value of sym is a constant X and !(X <= V).
@@ -439,14 +439,14 @@
};
}
-const GRState* BasicConstraintManager::AddEQ(const GRState* St, SymbolID sym,
+const GRState* BasicConstraintManager::AddEQ(const GRState* St, SymbolRef sym,
const llvm::APSInt& V) {
// Create a new state with the old binding replaced.
GRStateRef state(St, StateMgr);
return state.set<ConstEqTy>(sym, &V);
}
-const GRState* BasicConstraintManager::AddNE(const GRState* St, SymbolID sym,
+const GRState* BasicConstraintManager::AddNE(const GRState* St, SymbolRef sym,
const llvm::APSInt& V) {
GRStateRef state(St, StateMgr);
@@ -464,12 +464,12 @@
}
const llvm::APSInt* BasicConstraintManager::getSymVal(const GRState* St,
- SymbolID sym) {
+ SymbolRef sym) {
const ConstEqTy::data_type* T = St->get<ConstEqTy>(sym);
return T ? *T : NULL;
}
-bool BasicConstraintManager::isNotEqual(const GRState* St, SymbolID sym,
+bool BasicConstraintManager::isNotEqual(const GRState* St, SymbolRef sym,
const llvm::APSInt& V) const {
// Retrieve the NE-set associated with the given symbol.
@@ -479,7 +479,7 @@
return T ? T->contains(&V) : false;
}
-bool BasicConstraintManager::isEqual(const GRState* St, SymbolID sym,
+bool BasicConstraintManager::isEqual(const GRState* St, SymbolRef sym,
const llvm::APSInt& V) const {
// Retrieve the EQ-set associated with the given symbol.
const ConstEqTy::data_type* T = St->get<ConstEqTy>(sym);
@@ -497,7 +497,7 @@
ConstEqTy::Factory& CEFactory = state.get_context<ConstEqTy>();
for (ConstEqTy::iterator I = CE.begin(), E = CE.end(); I!=E; ++I) {
- SymbolID sym = I.getKey();
+ SymbolRef sym = I.getKey();
if (!LSymbols.count(sym)) {
DSymbols.insert(sym);
CE = CEFactory.Remove(CE, sym);
@@ -509,7 +509,7 @@
ConstNotEqTy::Factory& CNEFactory = state.get_context<ConstNotEqTy>();
for (ConstNotEqTy::iterator I = CNE.begin(), E = CNE.end(); I != E; ++I) {
- SymbolID sym = I.getKey();
+ SymbolRef sym = I.getKey();
if (!LSymbols.count(sym)) {
DSymbols.insert(sym);
CNE = CNEFactory.Remove(CNE, sym);
diff --git a/lib/Analysis/BasicValueFactory.cpp b/lib/Analysis/BasicValueFactory.cpp
index 7ce305e..2c7d6a3 100644
--- a/lib/Analysis/BasicValueFactory.cpp
+++ b/lib/Analysis/BasicValueFactory.cpp
@@ -98,7 +98,7 @@
}
const SymIntConstraint&
-BasicValueFactory::getConstraint(SymbolID sym, BinaryOperator::Opcode Op,
+BasicValueFactory::getConstraint(SymbolRef sym, BinaryOperator::Opcode Op,
const llvm::APSInt& V) {
llvm::FoldingSetNodeID ID;
diff --git a/lib/Analysis/BugReporter.cpp b/lib/Analysis/BugReporter.cpp
index 905c697..8274ce7 100644
--- a/lib/Analysis/BugReporter.cpp
+++ b/lib/Analysis/BugReporter.cpp
@@ -326,7 +326,7 @@
class VISIBILITY_HIDDEN NotableSymbolHandler
: public StoreManager::BindingsHandler {
- SymbolID Sym;
+ SymbolRef Sym;
const GRState* PrevSt;
Stmt* S;
GRStateManager& VMgr;
@@ -336,14 +336,14 @@
public:
- NotableSymbolHandler(SymbolID sym, const GRState* prevst, Stmt* s,
+ NotableSymbolHandler(SymbolRef sym, const GRState* prevst, Stmt* s,
GRStateManager& vmgr, ExplodedNode<GRState>* pred,
PathDiagnostic& pd, BugReporter& br)
: Sym(sym), PrevSt(prevst), S(s), VMgr(vmgr), Pred(pred), PD(pd), BR(br) {}
bool HandleBinding(StoreManager& SMgr, Store store, MemRegion* R, SVal V) {
- SymbolID ScanSym;
+ SymbolRef ScanSym;
if (loc::SymbolVal* SV = dyn_cast<loc::SymbolVal>(&V))
ScanSym = SV->getSymbol();
@@ -412,7 +412,7 @@
}
static void HandleNotableSymbol(ExplodedNode<GRState>* N, Stmt* S,
- SymbolID Sym, BugReporter& BR,
+ SymbolRef Sym, BugReporter& BR,
PathDiagnostic& PD) {
ExplodedNode<GRState>* Pred = N->pred_empty() ? 0 : *N->pred_begin();
@@ -432,7 +432,7 @@
class VISIBILITY_HIDDEN ScanNotableSymbols
: public StoreManager::BindingsHandler {
- llvm::SmallSet<SymbolID, 10> AlreadyProcessed;
+ llvm::SmallSet<SymbolRef, 10> AlreadyProcessed;
ExplodedNode<GRState>* N;
Stmt* S;
GRBugReporter& BR;
@@ -444,7 +444,7 @@
: N(n), S(s), BR(br), PD(pd) {}
bool HandleBinding(StoreManager& SMgr, Store store, MemRegion* R, SVal V) {
- SymbolID ScanSym;
+ SymbolRef ScanSym;
if (loc::SymbolVal* SV = dyn_cast<loc::SymbolVal>(&V))
ScanSym = SV->getSymbol();
diff --git a/lib/Analysis/CFRefCount.cpp b/lib/Analysis/CFRefCount.cpp
index 461754e..cb0cbd1 100644
--- a/lib/Analysis/CFRefCount.cpp
+++ b/lib/Analysis/CFRefCount.cpp
@@ -1267,7 +1267,7 @@
// RefBindings - State used to track object reference counts.
//===----------------------------------------------------------------------===//
-typedef llvm::ImmutableMap<SymbolID, RefVal> RefBindings;
+typedef llvm::ImmutableMap<SymbolRef, RefVal> RefBindings;
static int RefBIndex = 0;
namespace clang {
@@ -1281,8 +1281,8 @@
// ARBindings - State used to track objects in autorelease pools.
//===----------------------------------------------------------------------===//
-typedef llvm::ImmutableSet<SymbolID> ARPoolContents;
-typedef llvm::ImmutableList< std::pair<SymbolID, ARPoolContents*> > ARBindings;
+typedef llvm::ImmutableSet<SymbolRef> ARPoolContents;
+typedef llvm::ImmutableList< std::pair<SymbolRef, ARPoolContents*> > ARBindings;
static int AutoRBIndex = 0;
namespace clang {
@@ -1301,13 +1301,13 @@
class VISIBILITY_HIDDEN CFRefCount : public GRSimpleVals {
public:
// Type definitions.
- typedef llvm::DenseMap<GRExprEngine::NodeTy*,std::pair<Expr*, SymbolID> >
+ typedef llvm::DenseMap<GRExprEngine::NodeTy*,std::pair<Expr*, SymbolRef> >
ReleasesNotOwnedTy;
typedef ReleasesNotOwnedTy UseAfterReleasesTy;
typedef llvm::DenseMap<GRExprEngine::NodeTy*,
- std::vector<std::pair<SymbolID,bool> >*>
+ std::vector<std::pair<SymbolRef,bool> >*>
LeaksTy;
class BindingsPrinter : public GRState::Printer {
@@ -1324,10 +1324,10 @@
ReleasesNotOwnedTy ReleasesNotOwned;
LeaksTy Leaks;
- RefBindings Update(RefBindings B, SymbolID sym, RefVal V, ArgEffect E,
+ RefBindings Update(RefBindings B, SymbolRef sym, RefVal V, ArgEffect E,
RefVal::Kind& hasErr, RefBindings::Factory& RefBFactory);
- RefVal::Kind& Update(GRStateRef& state, SymbolID sym, RefVal V,
+ RefVal::Kind& Update(GRStateRef& state, SymbolRef sym, RefVal V,
ArgEffect E, RefVal::Kind& hasErr) {
state = state.set<RefBindings>(Update(state.get<RefBindings>(), sym, V,
@@ -1341,11 +1341,11 @@
Expr* NodeExpr, Expr* ErrorExpr,
ExplodedNode<GRState>* Pred,
const GRState* St,
- RefVal::Kind hasErr, SymbolID Sym);
+ RefVal::Kind hasErr, SymbolRef Sym);
std::pair<GRStateRef, bool>
HandleSymbolDeath(GRStateManager& VMgr, const GRState* St,
- const Decl* CD, SymbolID sid, RefVal V, bool& hasLeak);
+ const Decl* CD, SymbolRef sid, RefVal V, bool& hasLeak);
public:
@@ -1487,7 +1487,7 @@
Expr* NodeExpr, Expr* ErrorExpr,
ExplodedNode<GRState>* Pred,
const GRState* St,
- RefVal::Kind hasErr, SymbolID Sym) {
+ RefVal::Kind hasErr, SymbolRef Sym) {
Builder.BuildSinks = true;
GRExprEngine::NodeTy* N = Builder.MakeNode(Dst, NodeExpr, Pred, St);
@@ -1555,13 +1555,13 @@
RefVal::Kind hasErr = (RefVal::Kind) 0;
unsigned idx = 0;
Expr* ErrorExpr = NULL;
- SymbolID ErrorSym = 0;
+ SymbolRef ErrorSym = 0;
for (ExprIterator I = arg_beg; I != arg_end; ++I, ++idx) {
SVal V = state.GetSVal(*I);
if (isa<loc::SymbolVal>(V)) {
- SymbolID Sym = cast<loc::SymbolVal>(V).getSymbol();
+ SymbolRef Sym = cast<loc::SymbolVal>(V).getSymbol();
if (RefBindings::data_type* T = state.get<RefBindings>(Sym))
if (Update(state, Sym, *T, GetArgE(Summ, idx), hasErr)) {
ErrorExpr = *I;
@@ -1594,7 +1594,7 @@
SVal X = state.GetSVal(*MR);
if (isa<loc::SymbolVal>(X)) {
- SymbolID Sym = cast<loc::SymbolVal>(X).getSymbol();
+ SymbolRef Sym = cast<loc::SymbolVal>(X).getSymbol();
state = state.remove<RefBindings>(Sym);
}
@@ -1606,7 +1606,7 @@
// FIXME: handle structs.
if (Loc::IsLocType(T) || (T->isIntegerType() && T->isScalarType())) {
- SymbolID NewSym =
+ SymbolRef NewSym =
Eng.getSymbolManager().getConjuredSymbol(*I, T, Count);
state = state.BindLoc(*MR,
@@ -1635,7 +1635,7 @@
if (!ErrorExpr && Receiver) {
SVal V = state.GetSVal(Receiver);
if (isa<loc::SymbolVal>(V)) {
- SymbolID Sym = cast<loc::SymbolVal>(V).getSymbol();
+ SymbolRef Sym = cast<loc::SymbolVal>(V).getSymbol();
if (const RefVal* T = state.get<RefBindings>(Sym))
if (Update(state, Sym, *T, GetReceiverE(Summ), hasErr)) {
ErrorExpr = Receiver;
@@ -1671,7 +1671,7 @@
if (Loc::IsLocType(T) || (T->isIntegerType() && T->isScalarType())) {
unsigned Count = Builder.getCurrentBlockCount();
- SymbolID Sym = Eng.getSymbolManager().getConjuredSymbol(Ex, Count);
+ SymbolRef Sym = Eng.getSymbolManager().getConjuredSymbol(Ex, Count);
SVal X = Loc::IsLocType(Ex->getType())
? cast<SVal>(loc::SymbolVal(Sym))
@@ -1702,7 +1702,7 @@
case RetEffect::OwnedAllocatedSymbol:
case RetEffect::OwnedSymbol: {
unsigned Count = Builder.getCurrentBlockCount();
- SymbolID Sym = Eng.getSymbolManager().getConjuredSymbol(Ex, Count);
+ SymbolRef Sym = Eng.getSymbolManager().getConjuredSymbol(Ex, Count);
QualType RetT = GetReturnType(Ex, Eng.getContext());
state = state.set<RefBindings>(Sym, RefVal::makeOwned(RetT));
@@ -1722,7 +1722,7 @@
case RetEffect::NotOwnedSymbol: {
unsigned Count = Builder.getCurrentBlockCount();
- SymbolID Sym = Eng.getSymbolManager().getConjuredSymbol(Ex, Count);
+ SymbolRef Sym = Eng.getSymbolManager().getConjuredSymbol(Ex, Count);
QualType RetT = GetReturnType(Ex, Eng.getContext());
state = state.set<RefBindings>(Sym, RefVal::makeNotOwned(RetT));
@@ -1770,7 +1770,7 @@
SVal V = Eng.getStateManager().GetSVal(St, Receiver );
if (isa<loc::SymbolVal>(V)) {
- SymbolID Sym = cast<loc::SymbolVal>(V).getSymbol();
+ SymbolRef Sym = cast<loc::SymbolVal>(V).getSymbol();
if (const RefVal* T = St->get<RefBindings>(Sym)) {
QualType Ty = T->getType();
@@ -1839,7 +1839,7 @@
// (3) we are binding to a memregion with stack storage that the store
// does not understand.
- SymbolID Sym = cast<loc::SymbolVal>(Val).getSymbol();
+ SymbolRef Sym = cast<loc::SymbolVal>(Val).getSymbol();
GRStateRef state(St, Eng.getStateManager());
if (!isa<loc::MemRegionVal>(TargetLV))
@@ -1878,7 +1878,7 @@
std::pair<GRStateRef,bool>
CFRefCount::HandleSymbolDeath(GRStateManager& VMgr,
const GRState* St, const Decl* CD,
- SymbolID sid,
+ SymbolRef sid,
RefVal V, bool& hasLeak) {
GRStateRef state(St, VMgr);
@@ -1913,7 +1913,7 @@
const GRState* St = Builder.getState();
RefBindings B = St->get<RefBindings>();
- llvm::SmallVector<std::pair<SymbolID, bool>, 10> Leaked;
+ llvm::SmallVector<std::pair<SymbolRef, bool>, 10> Leaked;
const Decl* CodeDecl = &Eng.getGraph().getCodeDecl();
for (RefBindings::iterator I = B.begin(), E = B.end(); I != E; ++I) {
@@ -1935,11 +1935,11 @@
if (!N)
return;
- std::vector<std::pair<SymbolID,bool> >*& LeaksAtNode = Leaks[N];
+ std::vector<std::pair<SymbolRef,bool> >*& LeaksAtNode = Leaks[N];
assert (!LeaksAtNode);
- LeaksAtNode = new std::vector<std::pair<SymbolID,bool> >();
+ LeaksAtNode = new std::vector<std::pair<SymbolRef,bool> >();
- for (llvm::SmallVector<std::pair<SymbolID,bool>, 10>::iterator
+ for (llvm::SmallVector<std::pair<SymbolRef,bool>, 10>::iterator
I = Leaked.begin(), E = Leaked.end(); I != E; ++I)
(*LeaksAtNode).push_back(*I);
}
@@ -1957,7 +1957,7 @@
// FIXME: a lot of copy-and-paste from EvalEndPath. Refactor.
RefBindings B = St->get<RefBindings>();
- llvm::SmallVector<std::pair<SymbolID,bool>, 10> Leaked;
+ llvm::SmallVector<std::pair<SymbolRef,bool>, 10> Leaked;
for (GRStateManager::DeadSymbolsTy::const_iterator
I=Dead.begin(), E=Dead.end(); I!=E; ++I) {
@@ -1986,11 +1986,11 @@
if (!N)
return;
- std::vector<std::pair<SymbolID,bool> >*& LeaksAtNode = Leaks[N];
+ std::vector<std::pair<SymbolRef,bool> >*& LeaksAtNode = Leaks[N];
assert (!LeaksAtNode);
- LeaksAtNode = new std::vector<std::pair<SymbolID,bool> >();
+ LeaksAtNode = new std::vector<std::pair<SymbolRef,bool> >();
- for (llvm::SmallVector<std::pair<SymbolID,bool>, 10>::iterator
+ for (llvm::SmallVector<std::pair<SymbolRef,bool>, 10>::iterator
I = Leaked.begin(), E = Leaked.end(); I != E; ++I)
(*LeaksAtNode).push_back(*I);
}
@@ -2013,7 +2013,7 @@
return;
// Get the reference count binding (if any).
- SymbolID Sym = cast<loc::SymbolVal>(V).getSymbol();
+ SymbolRef Sym = cast<loc::SymbolVal>(V).getSymbol();
const RefVal* T = state.get<RefBindings>(Sym);
if (!T)
@@ -2084,7 +2084,7 @@
return state;
}
-RefBindings CFRefCount::Update(RefBindings B, SymbolID sym,
+RefBindings CFRefCount::Update(RefBindings B, SymbolRef sym,
RefVal V, ArgEffect E,
RefVal::Kind& hasErr,
RefBindings::Factory& RefBFactory) {
@@ -2270,9 +2270,9 @@
//===---------===//
class VISIBILITY_HIDDEN CFRefReport : public RangedBugReport {
- SymbolID Sym;
+ SymbolRef Sym;
public:
- CFRefReport(CFRefBug& D, ExplodedNode<GRState> *n, SymbolID sym)
+ CFRefReport(CFRefBug& D, ExplodedNode<GRState> *n, SymbolRef sym)
: RangedBugReport(D, n), Sym(sym) {}
virtual ~CFRefReport() {}
@@ -2293,7 +2293,7 @@
beg = end = 0;
}
- SymbolID getSymbol() const { return Sym; }
+ SymbolRef getSymbol() const { return Sym; }
virtual PathDiagnosticPiece* getEndPath(BugReporter& BR,
ExplodedNode<GRState>* N);
@@ -2491,12 +2491,12 @@
namespace {
class VISIBILITY_HIDDEN FindUniqueBinding :
public StoreManager::BindingsHandler {
- SymbolID Sym;
+ SymbolRef Sym;
MemRegion* Binding;
bool First;
public:
- FindUniqueBinding(SymbolID sym) : Sym(sym), Binding(0), First(true) {}
+ FindUniqueBinding(SymbolRef sym) : Sym(sym), Binding(0), First(true) {}
bool HandleBinding(StoreManager& SMgr, Store store, MemRegion* R, SVal val) {
if (const loc::SymbolVal* SV = dyn_cast<loc::SymbolVal>(&val)) {
@@ -2527,7 +2527,7 @@
static std::pair<ExplodedNode<GRState>*,MemRegion*>
GetAllocationSite(GRStateManager* StateMgr, ExplodedNode<GRState>* N,
- SymbolID Sym) {
+ SymbolRef Sym) {
// Find both first node that referred to the tracked symbol and the
// memory location that value was store to.
@@ -2678,7 +2678,7 @@
for (CFRefCount::leaks_iterator I = TF.leaks_begin(),
E = TF.leaks_end(); I != E; ++I) {
- std::vector<std::pair<SymbolID, bool> >& SymV = *(I->second);
+ std::vector<std::pair<SymbolRef, bool> >& SymV = *(I->second);
unsigned n = SymV.size();
for (unsigned i = 0; i < n; ++i) {
@@ -2701,7 +2701,7 @@
// With leaks, we want to unique them by the location where they were
// allocated, and only report a single path.
- SymbolID Sym = static_cast<CFRefReport&>(R).getSymbol();
+ SymbolRef Sym = static_cast<CFRefReport&>(R).getSymbol();
ExplodedNode<GRState>* AllocNode =
GetAllocationSite(0, R.getEndNode(), Sym).first;
diff --git a/lib/Analysis/GRExprEngine.cpp b/lib/Analysis/GRExprEngine.cpp
index 5d4136d..b3b311a 100644
--- a/lib/Analysis/GRExprEngine.cpp
+++ b/lib/Analysis/GRExprEngine.cpp
@@ -1799,11 +1799,11 @@
// UnknownVal.
if (InitVal.isUnknown()) {
if (Loc::IsLocType(T)) {
- SymbolID Sym = SymMgr.getConjuredSymbol(InitEx, Count);
+ SymbolRef Sym = SymMgr.getConjuredSymbol(InitEx, Count);
InitVal = loc::SymbolVal(Sym);
}
else if (T->isIntegerType() && T->isScalarType()) {
- SymbolID Sym = SymMgr.getConjuredSymbol(InitEx, Count);
+ SymbolRef Sym = SymMgr.getConjuredSymbol(InitEx, Count);
InitVal = nonloc::SymbolVal(Sym);
}
}
@@ -2399,7 +2399,7 @@
if (RightV.isUnknown() && (Loc::IsLocType(T) ||
(T->isScalarType() && T->isIntegerType()))) {
unsigned Count = Builder->getCurrentBlockCount();
- SymbolID Sym = SymMgr.getConjuredSymbol(B->getRHS(), Count);
+ SymbolRef Sym = SymMgr.getConjuredSymbol(B->getRHS(), Count);
RightV = Loc::IsLocType(T)
? cast<SVal>(loc::SymbolVal(Sym))
@@ -2562,7 +2562,7 @@
// The symbolic value is actually for the type of the left-hand side
// expression, not the computation type, as this is the value the
// LValue on the LHS will bind to.
- SymbolID Sym = SymMgr.getConjuredSymbol(B->getRHS(), LTy, Count);
+ SymbolRef Sym = SymMgr.getConjuredSymbol(B->getRHS(), LTy, Count);
LHSVal = Loc::IsLocType(LTy)
? cast<SVal>(loc::SymbolVal(Sym))
: cast<SVal>(nonloc::SymbolVal(Sym));
diff --git a/lib/Analysis/GRSimpleVals.cpp b/lib/Analysis/GRSimpleVals.cpp
index 783bccc..c1f455b 100644
--- a/lib/Analysis/GRSimpleVals.cpp
+++ b/lib/Analysis/GRSimpleVals.cpp
@@ -415,7 +415,7 @@
QualType T = CE->getType();
if (Loc::IsLocType(T) || (T->isIntegerType() && T->isScalarType())) {
unsigned Count = Builder.getCurrentBlockCount();
- SymbolID Sym = Eng.getSymbolManager().getConjuredSymbol(CE, Count);
+ SymbolRef Sym = Eng.getSymbolManager().getConjuredSymbol(CE, Count);
SVal X = Loc::IsLocType(CE->getType())
? cast<SVal>(loc::SymbolVal(Sym))
diff --git a/lib/Analysis/GRState.cpp b/lib/Analysis/GRState.cpp
index 83ab508..221ab06 100644
--- a/lib/Analysis/GRState.cpp
+++ b/lib/Analysis/GRState.cpp
@@ -7,7 +7,7 @@
//
//===----------------------------------------------------------------------===//
//
-// This file defines SymbolID, ExprBindKey, and GRState*
+// This file defines SymbolRef, ExprBindKey, and GRState*
//
//===----------------------------------------------------------------------===//
diff --git a/lib/Analysis/MemRegion.cpp b/lib/Analysis/MemRegion.cpp
index 86f8571..d771526 100644
--- a/lib/Analysis/MemRegion.cpp
+++ b/lib/Analysis/MemRegion.cpp
@@ -90,7 +90,7 @@
DeclRegion::ProfileRegion(ID, D, superRegion, getKind());
}
-void SymbolicRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, SymbolID sym) {
+void SymbolicRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, SymbolRef sym) {
ID.AddInteger((unsigned) MemRegion::SymbolicRegionKind);
ID.AddInteger(sym.getNumber());
}
@@ -300,7 +300,7 @@
}
/// getSymbolicRegion - Retrieve or create a "symbolic" memory region.
-SymbolicRegion* MemRegionManager::getSymbolicRegion(const SymbolID sym) {
+SymbolicRegion* MemRegionManager::getSymbolicRegion(const SymbolRef sym) {
llvm::FoldingSetNodeID ID;
SymbolicRegion::ProfileRegion(ID, sym);
diff --git a/lib/Analysis/RegionStore.cpp b/lib/Analysis/RegionStore.cpp
index 07399f4..563a1fe 100644
--- a/lib/Analysis/RegionStore.cpp
+++ b/lib/Analysis/RegionStore.cpp
@@ -734,7 +734,7 @@
// Mark all non-live symbols that this region references as dead.
if (const SymbolicRegion* SymR = dyn_cast<SymbolicRegion>(R)) {
- SymbolID Sym = SymR->getSymbol();
+ SymbolRef Sym = SymR->getSymbol();
if (!LSymbols.count(Sym)) DSymbols.insert(Sym);
}
diff --git a/lib/Analysis/SVals.cpp b/lib/Analysis/SVals.cpp
index 524904d..6ee311c 100644
--- a/lib/Analysis/SVals.cpp
+++ b/lib/Analysis/SVals.cpp
@@ -29,9 +29,9 @@
// FIXME: This is a rat's nest. Cleanup.
if (isa<loc::SymbolVal>(this))
- return symbol_iterator(SymbolID((uintptr_t)Data));
+ return symbol_iterator(SymbolRef((uintptr_t)Data));
else if (isa<nonloc::SymbolVal>(this))
- return symbol_iterator(SymbolID((uintptr_t)Data));
+ return symbol_iterator(SymbolRef((uintptr_t)Data));
else if (isa<nonloc::SymIntConstraintVal>(this)) {
const SymIntConstraint& C =
cast<nonloc::SymIntConstraintVal>(this)->getConstraint();
diff --git a/lib/Analysis/SymbolManager.cpp b/lib/Analysis/SymbolManager.cpp
index c49d127..0132029 100644
--- a/lib/Analysis/SymbolManager.cpp
+++ b/lib/Analysis/SymbolManager.cpp
@@ -16,7 +16,7 @@
using namespace clang;
-SymbolID SymbolManager::getSymbol(VarDecl* D) {
+SymbolRef SymbolManager::getSymbol(VarDecl* D) {
assert (isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D) ||
D->hasGlobalStorage());
@@ -52,7 +52,7 @@
return SymbolCounter++;
}
-SymbolID SymbolManager::getElementSymbol(const MemRegion* R,
+SymbolRef SymbolManager::getElementSymbol(const MemRegion* R,
const llvm::APSInt* Idx){
llvm::FoldingSetNodeID ID;
SymbolDataElement::Profile(ID, R, Idx);
@@ -70,7 +70,7 @@
return SymbolCounter++;
}
-SymbolID SymbolManager::getFieldSymbol(const MemRegion* R, const FieldDecl* D) {
+SymbolRef SymbolManager::getFieldSymbol(const MemRegion* R, const FieldDecl* D) {
llvm::FoldingSetNodeID ID;
SymbolDataField::Profile(ID, R, D);
void* InsertPos;
@@ -87,7 +87,7 @@
return SymbolCounter++;
}
-SymbolID SymbolManager::getConjuredSymbol(Stmt* E, QualType T, unsigned Count) {
+SymbolRef SymbolManager::getConjuredSymbol(Stmt* E, QualType T, unsigned Count) {
llvm::FoldingSetNodeID profile;
SymbolConjured::Profile(profile, E, T, Count);
@@ -107,7 +107,7 @@
return SymbolCounter++;
}
-const SymbolData& SymbolManager::getSymbolData(SymbolID Sym) const {
+const SymbolData& SymbolManager::getSymbolData(SymbolRef Sym) const {
DataMapTy::const_iterator I = DataMap.find(Sym);
assert (I != DataMap.end());
return *I->second;