continue;
// Dispatch to the plug-in transfer function.
- St = EvalCall(CE, cast<LVal>(L), (*DI)->getState());
+
+ unsigned size = Dst.size();
+
+ EvalCall(Dst, CE, cast<LVal>(L), *DI);
+
+ if (Dst.size() == size)
+ Nodify(Dst, CE, *DI, St);
}
// Check for the "noreturn" attribute.
// Transfer function for Function Calls.
//===----------------------------------------------------------------------===//
-ValueState*
-GRSimpleVals::EvalCall(ValueStateManager& StateMgr, ValueManager& ValMgr,
- CallExpr* CE, LVal L, ValueState* St) {
+void GRSimpleVals::EvalCall(ExplodedNodeSet<ValueState>& Dst,
+ ValueStateManager& StateMgr,
+ GRStmtNodeBuilder<ValueState>& Builder,
+ ValueManager& ValMgr,
+ CallExpr* CE, LVal L,
+ ExplodedNode<ValueState>* Pred) {
+
+ ValueState* St = Pred->getState();
// Invalidate all arguments passed in by reference (LVals).
if (isa<LVal>(V))
St = StateMgr.SetRVal(St, cast<LVal>(V), UnknownVal());
}
-
- return St;
+
+ Builder.Nodify(Dst, CE, Pred, St);
}
// Calls.
- virtual ValueState* EvalCall(ValueStateManager& StateMgr,
- ValueManager& ValMgr,
- CallExpr* CE, LVal L,
- ValueState* St);
+ virtual void EvalCall(ExplodedNodeSet<ValueState>& Dst,
+ ValueStateManager& StateMgr,
+ GRStmtNodeBuilder<ValueState>& Builder,
+ ValueManager& ValMgr,
+ CallExpr* CE, LVal L,
+ ExplodedNode<ValueState>* Pred);
protected:
};
-template <typename NodeTy>
+template <typename StateTy>
class ExplodedNodeSet {
+ typedef ExplodedNode<StateTy> NodeTy;
typedef llvm::SmallPtrSet<NodeTy*,5> ImplTy;
ImplTy Impl;
return static_cast<NodeTy*>(NB.generateNodeImpl(S, St));
}
- NodeTy* Nodify(ExplodedNodeSet<NodeTy>& Dst, Stmt* S,
+ NodeTy* Nodify(ExplodedNodeSet<StateTy>& Dst, Stmt* S,
NodeTy* Pred, StateTy* St) {
// If the state hasn't changed, don't generate a new node.
typedef GRBranchNodeBuilder<GRExprEngine> BranchNodeBuilder;
typedef GRIndirectGotoNodeBuilder<GRExprEngine> IndirectGotoNodeBuilder;
typedef GRSwitchNodeBuilder<GRExprEngine> SwitchNodeBuilder;
- typedef ExplodedNodeSet<NodeTy> NodeSet;
+ typedef ExplodedNodeSet<StateTy> NodeSet;
protected:
/// G - the simulation graph.
return TF->EvalBinOp(ValMgr, Op, cast<NonLVal>(L), cast<NonLVal>(R));
}
- ValueState* EvalCall(CallExpr* CE, LVal L, ValueState* St) {
- return TF->EvalCall(StateMgr, ValMgr, CE, L, St);
+ void EvalCall(NodeSet& Dst, CallExpr* CE, LVal L, NodeTy* Pred) {
+ assert (Builder && "GRStmtNodeBuilder must be defined.");
+ return TF->EvalCall(Dst, StateMgr, *Builder, ValMgr, CE, L, Pred);
}
ValueState* MarkBranch(ValueState* St, Stmt* Terminator, bool branchTaken);
// Calls.
- virtual ValueState* EvalCall(ValueStateManager& StateMgr,
- ValueManager& ValMgr, CallExpr* CE, LVal L,
- ValueState* St) = 0;
+ virtual void EvalCall(ExplodedNodeSet<ValueState>& Dst,
+ ValueStateManager& StateMgr,
+ GRStmtNodeBuilder<ValueState>& Builder,
+ ValueManager& ValMgr, CallExpr* CE, LVal L,
+ ExplodedNode<ValueState>* Pred) = 0;
};
} // end clang namespace