}
public:
- // This method is only defined so that we can cast a
- // void* to FoldingSet<ExplodedNodeImpl> so that we can iterate
- // over the vertices of EdgeNodeSetMap in ExplodeGraphImpl.
- // The actual profiling of vertices will be done in the derived
- // class, ExplodedNode<>. Nodes will NEVER be INSERTED into the
- // FoldingSet using this Profile method (since it doesn't do anything).
- inline void Profile(llvm::FoldingSetNodeID& ID) const {
- assert (false && "Needs to be implemented in derived class.");
- }
/// getLocation - Returns the edge associated with the given node.
const ProgramPoint& getLocation() const { return Location; }
template <typename StateTy>
struct GRTrait {
- static inline void* toPtr(StateTy S) {
- return reinterpret_cast<void*>(S);
- }
- static inline StateTy toState(void* P) {
- return reinterpret_cast<StateTy>(P);
+ static inline void Profile(llvm::FoldingSetNodeID& ID, const StateTy* St) {
+ St->Profile(ID);
}
};
public:
/// Construct a ExplodedNodeImpl with the given node ID, program edge,
/// and state.
- explicit ExplodedNode(const ProgramPoint& loc, StateTy state)
- : ExplodedNodeImpl(loc, GRTrait<StateTy>::toPtr(state)) {}
+ explicit ExplodedNode(const ProgramPoint& loc, StateTy* St)
+ : ExplodedNodeImpl(loc, St) {}
/// getState - Returns the state associated with the node.
- inline StateTy getState() const {
- return GRTrait<StateTy>::toState(State);
+ inline StateTy* getState() const {
+ return static_cast<StateTy*>(State);
}
// Profiling (for FoldingSet).
static inline void Profile(llvm::FoldingSetNodeID& ID,
const ProgramPoint& Loc,
- StateTy state) {
+ StateTy* state) {
ID.Add(Loc);
GRTrait<StateTy>::Profile(ID, state);
}
protected:
virtual ExplodedNodeImpl*
getNodeImpl(const ProgramPoint& L, void* State, bool* IsNew) {
- return getNode(L, GRTrait<StateTy>::toState(State), IsNew);
+ return getNode(L, static_cast<StateTy*>(State), IsNew);
}
public:
/// where the 'Location' is a ProgramPoint in the CFG. If no node for
/// this pair exists, it is created. IsNew is set to true if
/// the node was freshly created.
- NodeTy* getNode(const ProgramPoint& L, StateTy State, bool* IsNew = NULL) {
+ NodeTy* getNode(const ProgramPoint& L, StateTy* State, bool* IsNew = NULL) {
// Profile 'State' to determine if we already have an existing node.
llvm::FoldingSetNodeID profile;
return static_cast<NodeTy*>(NB.getLastNode());
}
- NodeTy* generateNode(Stmt* S, StateTy State, NodeTy* Pred) {
- void *state = GRTrait<StateTy>::toPtr(State);
- return static_cast<NodeTy*>(NB.generateNodeImpl(S, state, Pred));
+ NodeTy* generateNode(Stmt* S, StateTy* St, NodeTy* Pred) {
+ return static_cast<NodeTy*>(NB.generateNodeImpl(S, St, Pred));
}
- NodeTy* generateNode(Stmt* S, StateTy State) {
- void *state = GRTrait<StateTy>::toPtr(State);
- return static_cast<NodeTy*>(NB.generateNodeImpl(S, state));
+ NodeTy* generateNode(Stmt* S, StateTy* St) {
+ return static_cast<NodeTy*>(NB.generateNodeImpl(S, St));
}
- NodeTy* Nodify(ExplodedNodeSet<NodeTy> Dst, Stmt* S,
- NodeTy* Pred, StateTy St) {
+ NodeTy* Nodify(ExplodedNodeSet<NodeTy>& Dst, Stmt* S,
+ NodeTy* Pred, StateTy* St) {
// If the state hasn't changed, don't generate a new node.
if (St == Pred->getState()) {
return static_cast<NodeTy*>(NB.getPredecessor());
}
- StateTy getState() const {
+ StateTy* getState() const {
return getPredecessor()->getState();
}
- inline NodeTy* generateNode(StateTy State, bool branch) {
- void *state = GRTrait<StateTy>::toPtr(State);
- return static_cast<NodeTy*>(NB.generateNodeImpl(state, branch));
+ inline NodeTy* generateNode(StateTy* St, bool branch) {
+ return static_cast<NodeTy*>(NB.generateNodeImpl(St, branch));
}
GRBlockCounter getBlockCounter() const {
inline Expr* getTarget() const { return NB.getTarget(); }
- inline NodeTy* generateNode(const iterator& I, StateTy St, bool isSink=false){
- void *state = GRTrait<StateTy>::toPtr(St);
- return static_cast<NodeTy*>(NB.generateNodeImpl(I, state, isSink));
+ inline NodeTy* generateNode(const iterator& I, StateTy* St, bool isSink=false){
+ return static_cast<NodeTy*>(NB.generateNodeImpl(I, St, isSink));
}
- inline StateTy getState() const {
- return GRTrait<StateTy>::toState(NB.getState());
+ inline StateTy* getState() const {
+ return static_cast<StateTy*>(NB.getState());
}
};
inline Expr* getCondition() const { return NB.getCondition(); }
- inline NodeTy* generateCaseStmtNode(const iterator& I, StateTy St) {
- void *state = GRTrait<StateTy>::toPtr(St);
- return static_cast<NodeTy*>(NB.generateCaseStmtNodeImpl(I, state));
+ inline NodeTy* generateCaseStmtNode(const iterator& I, StateTy* St) {
+ return static_cast<NodeTy*>(NB.generateCaseStmtNodeImpl(I, St));
}
- inline NodeTy* generateDefaultCaseNode(StateTy St, bool isSink = false) {
- void *state = GRTrait<StateTy>::toPtr(St);
- return static_cast<NodeTy*>(NB.generateDefaultCaseNodeImpl(state, isSink));
+ inline NodeTy* generateDefaultCaseNode(StateTy* St, bool isSink = false) {
+ return static_cast<NodeTy*>(NB.generateDefaultCaseNodeImpl(St, isSink));
}
- inline StateTy getState() const {
- return GRTrait<StateTy>::toState(NB.getState());
+ inline StateTy* getState() const {
+ return static_cast<StateTy*>(NB.getState());
}
};
CheckerTy* Checker;
virtual void* getInitialState() {
- return GRTrait<StateTy>::toPtr(getCheckerState().getInitialState());
+ return getCheckerState().getInitialState();
}
virtual void* ProcessEOP(CFGBlock* Blk, void* State) {
virtual bool ProcessBlockEntrance(CFGBlock* Blk, void* State,
GRBlockCounter BC) {
return Checker->ProcessBlockEntrance(Blk,
- GRTrait<StateTy>::toState(State), BC);
+ static_cast<StateTy*>(State), BC);
}
virtual void ProcessBranch(Expr* Condition, Stmt* Terminator,