blob: 1c64c28c37d88e72aa1ae2d289676725ffc13d51 [file] [log] [blame]
Ted Kremenekf6c62f32008-02-13 17:41:41 +00001//==- GRCoreEngine.cpp - Path-Sensitive Dataflow Engine ----------------*- C++ -*-//
Ted Kremenek3e743662008-01-14 23:24:37 +00002//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file defines a generic engine for intraprocedural, path-sensitive,
11// dataflow analysis via graph reachability engine.
12//
13//===----------------------------------------------------------------------===//
14
Ted Kremenekf6c62f32008-02-13 17:41:41 +000015#include "clang/Analysis/PathSensitive/GRCoreEngine.h"
Ted Kremenek3e743662008-01-14 23:24:37 +000016#include "clang/AST/Expr.h"
17#include "llvm/Support/Compiler.h"
18#include "llvm/Support/Casting.h"
19#include "llvm/ADT/DenseMap.h"
20#include <vector>
21
22using llvm::cast;
23using llvm::isa;
24using namespace clang;
25
26namespace {
27 class VISIBILITY_HIDDEN DFS : public GRWorkList {
28 llvm::SmallVector<GRWorkListUnit,20> Stack;
29public:
30 virtual bool hasWork() const {
31 return !Stack.empty();
32 }
33
34 virtual void Enqueue(const GRWorkListUnit& U) {
35 Stack.push_back(U);
36 }
37
38 virtual GRWorkListUnit Dequeue() {
39 assert (!Stack.empty());
40 const GRWorkListUnit& U = Stack.back();
41 Stack.pop_back(); // This technically "invalidates" U, but we are fine.
42 return U;
43 }
44};
45} // end anonymous namespace
46
Ted Kremenek2e12c2e2008-01-16 18:18:48 +000047// Place the dstor for GRWorkList here because it contains virtual member
48// functions, and we the code for the dstor generated in one compilation unit.
49GRWorkList::~GRWorkList() {}
50
Ted Kremenek3e743662008-01-14 23:24:37 +000051GRWorkList* GRWorkList::MakeDFS() { return new DFS(); }
52
53/// ExecuteWorkList - Run the worklist algorithm for a maximum number of steps.
Ted Kremenekf6c62f32008-02-13 17:41:41 +000054bool GRCoreEngineImpl::ExecuteWorkList(unsigned Steps) {
Ted Kremenek3e743662008-01-14 23:24:37 +000055
56 if (G->num_roots() == 0) { // Initialize the analysis by constructing
57 // the root if none exists.
58
Ted Kremenek997d8722008-01-29 00:33:40 +000059 CFGBlock* Entry = &getCFG().getEntry();
Ted Kremenek3e743662008-01-14 23:24:37 +000060
61 assert (Entry->empty() &&
62 "Entry block must be empty.");
63
64 assert (Entry->succ_size() == 1 &&
65 "Entry block must have 1 successor.");
66
67 // Get the solitary successor.
68 CFGBlock* Succ = *(Entry->succ_begin());
69
70 // Construct an edge representing the
71 // starting location in the function.
Ted Kremenek997d8722008-01-29 00:33:40 +000072 BlockEdge StartLoc(getCFG(), Entry, Succ);
Ted Kremenek3e743662008-01-14 23:24:37 +000073
Ted Kremenek90ae68f2008-02-12 18:08:17 +000074 // Set the current block counter to being empty.
75 WList->setBlockCounter(BCounterFactory.GetEmptyCounter());
76
Ted Kremenek3e743662008-01-14 23:24:37 +000077 // Generate the root.
78 GenerateNode(StartLoc, getInitialState());
79 }
80
81 while (Steps && WList->hasWork()) {
82 --Steps;
83 const GRWorkListUnit& WU = WList->Dequeue();
Ted Kremenek90ae68f2008-02-12 18:08:17 +000084
85 // Set the current block counter.
86 WList->setBlockCounter(WU.getBlockCounter());
87
88 // Retrieve the node.
Ted Kremenek3e743662008-01-14 23:24:37 +000089 ExplodedNodeImpl* Node = WU.getNode();
90
91 // Dispatch on the location type.
92 switch (Node->getLocation().getKind()) {
93 default:
94 assert (isa<BlockEdge>(Node->getLocation()));
95 HandleBlockEdge(cast<BlockEdge>(Node->getLocation()), Node);
96 break;
97
98 case ProgramPoint::BlockEntranceKind:
99 HandleBlockEntrance(cast<BlockEntrance>(Node->getLocation()), Node);
100 break;
101
102 case ProgramPoint::BlockExitKind:
Ted Kremeneke5843592008-01-15 00:24:08 +0000103 assert (false && "BlockExit location never occur in forward analysis.");
Ted Kremenek3e743662008-01-14 23:24:37 +0000104 break;
Ted Kremenekfa5a3d02008-04-29 21:04:26 +0000105
106 case ProgramPoint::PostLoadKind:
Ted Kremenek3e743662008-01-14 23:24:37 +0000107 case ProgramPoint::PostStmtKind:
108 HandlePostStmt(cast<PostStmt>(Node->getLocation()), WU.getBlock(),
109 WU.getIndex(), Node);
110 break;
111 }
112 }
113
114 return WList->hasWork();
115}
116
Ted Kremenekdf4a5b92008-03-05 19:08:15 +0000117void GRCoreEngineImpl::HandleBlockEdge(const BlockEdge& L,
118 ExplodedNodeImpl* Pred) {
Ted Kremenek3e743662008-01-14 23:24:37 +0000119
120 CFGBlock* Blk = L.getDst();
121
122 // Check if we are entering the EXIT block.
Ted Kremenek997d8722008-01-29 00:33:40 +0000123 if (Blk == &getCFG().getExit()) {
Ted Kremenek3e743662008-01-14 23:24:37 +0000124
Ted Kremenek997d8722008-01-29 00:33:40 +0000125 assert (getCFG().getExit().size() == 0
126 && "EXIT block cannot contain Stmts.");
Ted Kremenek3e743662008-01-14 23:24:37 +0000127
Ted Kremenek811c2b42008-04-11 22:03:04 +0000128 // Process the final state transition.
129 GREndPathNodeBuilderImpl Builder(Blk, Pred, this);
130 ProcessEndPath(Builder);
Ted Kremenek3e743662008-01-14 23:24:37 +0000131
Ted Kremenek3e743662008-01-14 23:24:37 +0000132 // This path is done. Don't enqueue any more nodes.
133 return;
134 }
Ted Kremenek17f4dbd2008-02-29 20:27:50 +0000135
136 // FIXME: Should we allow ProcessBlockEntrance to also manipulate state?
Ted Kremenek3e743662008-01-14 23:24:37 +0000137
Ted Kremenek17f4dbd2008-02-29 20:27:50 +0000138 if (ProcessBlockEntrance(Blk, Pred->State, WList->getBlockCounter()))
139 GenerateNode(BlockEntrance(Blk), Pred->State, Pred);
Ted Kremenek3e743662008-01-14 23:24:37 +0000140}
141
Ted Kremenekf6c62f32008-02-13 17:41:41 +0000142void GRCoreEngineImpl::HandleBlockEntrance(const BlockEntrance& L,
Ted Kremenekdf4a5b92008-03-05 19:08:15 +0000143 ExplodedNodeImpl* Pred) {
Ted Kremenek3e743662008-01-14 23:24:37 +0000144
Ted Kremenek90ae68f2008-02-12 18:08:17 +0000145 // Increment the block counter.
146 GRBlockCounter Counter = WList->getBlockCounter();
147 Counter = BCounterFactory.IncrementCount(Counter, L.getBlock()->getBlockID());
148 WList->setBlockCounter(Counter);
149
150 // Process the entrance of the block.
Ted Kremenek3e743662008-01-14 23:24:37 +0000151 if (Stmt* S = L.getFirstStmt()) {
Ted Kremenekb2cad312008-01-29 22:11:49 +0000152 GRStmtNodeBuilderImpl Builder(L.getBlock(), 0, Pred, this);
Ted Kremenek3e743662008-01-14 23:24:37 +0000153 ProcessStmt(S, Builder);
154 }
Ted Kremeneke5843592008-01-15 00:24:08 +0000155 else
156 HandleBlockExit(L.getBlock(), Pred);
Ted Kremenek3e743662008-01-14 23:24:37 +0000157}
158
Ted Kremenek3f91f032008-08-13 03:10:52 +0000159GRCoreEngineImpl::~GRCoreEngineImpl() {
160 delete WList;
161}
Ted Kremenek3e743662008-01-14 23:24:37 +0000162
Ted Kremenekf6c62f32008-02-13 17:41:41 +0000163void GRCoreEngineImpl::HandleBlockExit(CFGBlock * B, ExplodedNodeImpl* Pred) {
Ted Kremenek3e743662008-01-14 23:24:37 +0000164
Ted Kremenek9b4211d2008-01-29 22:56:11 +0000165 if (Stmt* Term = B->getTerminator()) {
166 switch (Term->getStmtClass()) {
167 default:
168 assert(false && "Analysis for this terminator not implemented.");
169 break;
Ted Kremenek822f7372008-02-12 21:51:20 +0000170
171 case Stmt::BinaryOperatorClass: // '&&' and '||'
172 HandleBranch(cast<BinaryOperator>(Term)->getLHS(), Term, B, Pred);
173 return;
Ted Kremenek9b4211d2008-01-29 22:56:11 +0000174
Ted Kremenek3f2f1ad2008-02-05 00:26:40 +0000175 case Stmt::ConditionalOperatorClass:
176 HandleBranch(cast<ConditionalOperator>(Term)->getCond(), Term, B, Pred);
Ted Kremenek822f7372008-02-12 21:51:20 +0000177 return;
178
179 // FIXME: Use constant-folding in CFG construction to simplify this
180 // case.
Ted Kremenek3f2f1ad2008-02-05 00:26:40 +0000181
182 case Stmt::ChooseExprClass:
183 HandleBranch(cast<ChooseExpr>(Term)->getCond(), Term, B, Pred);
Ted Kremenek822f7372008-02-12 21:51:20 +0000184 return;
Ted Kremenek3f2f1ad2008-02-05 00:26:40 +0000185
Ted Kremenek822f7372008-02-12 21:51:20 +0000186 case Stmt::DoStmtClass:
187 HandleBranch(cast<DoStmt>(Term)->getCond(), Term, B, Pred);
188 return;
189
190 case Stmt::ForStmtClass:
191 HandleBranch(cast<ForStmt>(Term)->getCond(), Term, B, Pred);
192 return;
Ted Kremenek632bcb82008-02-13 16:56:51 +0000193
194 case Stmt::ContinueStmtClass:
195 case Stmt::BreakStmtClass:
196 case Stmt::GotoStmtClass:
Ted Kremenek3f2f1ad2008-02-05 00:26:40 +0000197 break;
198
Ted Kremenek9b4211d2008-01-29 22:56:11 +0000199 case Stmt::IfStmtClass:
200 HandleBranch(cast<IfStmt>(Term)->getCond(), Term, B, Pred);
Ted Kremenek822f7372008-02-12 21:51:20 +0000201 return;
Ted Kremenek7022efb2008-02-13 00:24:44 +0000202
203 case Stmt::IndirectGotoStmtClass: {
204 // Only 1 successor: the indirect goto dispatch block.
205 assert (B->succ_size() == 1);
206
207 GRIndirectGotoNodeBuilderImpl
208 builder(Pred, B, cast<IndirectGotoStmt>(Term)->getTarget(),
209 *(B->succ_begin()), this);
210
211 ProcessIndirectGoto(builder);
212 return;
213 }
Ted Kremenek9b4211d2008-01-29 22:56:11 +0000214
Ted Kremenek80ebc1d2008-02-13 23:08:21 +0000215 case Stmt::SwitchStmtClass: {
216 GRSwitchNodeBuilderImpl builder(Pred, B,
217 cast<SwitchStmt>(Term)->getCond(),
218 this);
219
220 ProcessSwitch(builder);
221 return;
222 }
223
Ted Kremenek9b4211d2008-01-29 22:56:11 +0000224 case Stmt::WhileStmtClass:
225 HandleBranch(cast<WhileStmt>(Term)->getCond(), Term, B, Pred);
Ted Kremenek822f7372008-02-12 21:51:20 +0000226 return;
Ted Kremenek9b4211d2008-01-29 22:56:11 +0000227 }
228 }
Ted Kremenek822f7372008-02-12 21:51:20 +0000229
230 assert (B->succ_size() == 1 &&
231 "Blocks with no terminator should have at most 1 successor.");
Ted Kremenek3e743662008-01-14 23:24:37 +0000232
Ted Kremenek822f7372008-02-12 21:51:20 +0000233 GenerateNode(BlockEdge(getCFG(),B,*(B->succ_begin())), Pred->State, Pred);
Ted Kremenek3e743662008-01-14 23:24:37 +0000234}
235
Ted Kremenekf6c62f32008-02-13 17:41:41 +0000236void GRCoreEngineImpl::HandleBranch(Expr* Cond, Stmt* Term, CFGBlock * B,
Ted Kremenek9b4211d2008-01-29 22:56:11 +0000237 ExplodedNodeImpl* Pred) {
238 assert (B->succ_size() == 2);
239
Ted Kremenek90ae68f2008-02-12 18:08:17 +0000240 GRBranchNodeBuilderImpl Builder(B, *(B->succ_begin()), *(B->succ_begin()+1),
Ted Kremenek9b4211d2008-01-29 22:56:11 +0000241 Pred, this);
242
243 ProcessBranch(Cond, Term, Builder);
244}
245
Ted Kremenekf6c62f32008-02-13 17:41:41 +0000246void GRCoreEngineImpl::HandlePostStmt(const PostStmt& L, CFGBlock* B,
Ted Kremenek3e743662008-01-14 23:24:37 +0000247 unsigned StmtIdx, ExplodedNodeImpl* Pred) {
248
249 assert (!B->empty());
250
Ted Kremeneke5843592008-01-15 00:24:08 +0000251 if (StmtIdx == B->size())
252 HandleBlockExit(B, Pred);
Ted Kremenek3e743662008-01-14 23:24:37 +0000253 else {
Ted Kremenekb2cad312008-01-29 22:11:49 +0000254 GRStmtNodeBuilderImpl Builder(B, StmtIdx, Pred, this);
Ted Kremeneke914bb82008-01-16 22:13:19 +0000255 ProcessStmt((*B)[StmtIdx], Builder);
Ted Kremenek3e743662008-01-14 23:24:37 +0000256 }
257}
258
Ted Kremenek3e743662008-01-14 23:24:37 +0000259/// GenerateNode - Utility method to generate nodes, hook up successors,
260/// and add nodes to the worklist.
Ted Kremeneka7b8ffb2008-07-10 22:03:41 +0000261void GRCoreEngineImpl::GenerateNode(const ProgramPoint& Loc, const void* State,
262 ExplodedNodeImpl* Pred) {
Ted Kremenek3e743662008-01-14 23:24:37 +0000263
264 bool IsNew;
265 ExplodedNodeImpl* Node = G->getNodeImpl(Loc, State, &IsNew);
266
267 if (Pred)
268 Node->addPredecessor(Pred); // Link 'Node' with its predecessor.
269 else {
270 assert (IsNew);
271 G->addRoot(Node); // 'Node' has no predecessor. Make it a root.
272 }
273
274 // Only add 'Node' to the worklist if it was freshly generated.
Ted Kremenek90ae68f2008-02-12 18:08:17 +0000275 if (IsNew) WList->Enqueue(Node);
Ted Kremenek3e743662008-01-14 23:24:37 +0000276}
277
Ted Kremenekb2cad312008-01-29 22:11:49 +0000278GRStmtNodeBuilderImpl::GRStmtNodeBuilderImpl(CFGBlock* b, unsigned idx,
Ted Kremenekf6c62f32008-02-13 17:41:41 +0000279 ExplodedNodeImpl* N, GRCoreEngineImpl* e)
Ted Kremenekc072b822008-04-18 20:35:30 +0000280 : Eng(*e), B(*b), Idx(idx), Pred(N), LastNode(N) {
Ted Kremenek3e743662008-01-14 23:24:37 +0000281 Deferred.insert(N);
282}
283
Ted Kremenekb2cad312008-01-29 22:11:49 +0000284GRStmtNodeBuilderImpl::~GRStmtNodeBuilderImpl() {
Ted Kremenek3e743662008-01-14 23:24:37 +0000285 for (DeferredTy::iterator I=Deferred.begin(), E=Deferred.end(); I!=E; ++I)
Ted Kremeneka50d9852008-01-30 23:03:39 +0000286 if (!(*I)->isSink())
Ted Kremenek3e743662008-01-14 23:24:37 +0000287 GenerateAutoTransition(*I);
288}
289
Ted Kremenekb2cad312008-01-29 22:11:49 +0000290void GRStmtNodeBuilderImpl::GenerateAutoTransition(ExplodedNodeImpl* N) {
Ted Kremeneka50d9852008-01-30 23:03:39 +0000291 assert (!N->isSink());
Ted Kremenek3e743662008-01-14 23:24:37 +0000292
293 PostStmt Loc(getStmt());
294
295 if (Loc == N->getLocation()) {
296 // Note: 'N' should be a fresh node because otherwise it shouldn't be
297 // a member of Deferred.
298 Eng.WList->Enqueue(N, B, Idx+1);
299 return;
300 }
301
302 bool IsNew;
303 ExplodedNodeImpl* Succ = Eng.G->getNodeImpl(Loc, N->State, &IsNew);
304 Succ->addPredecessor(N);
305
306 if (IsNew)
307 Eng.WList->Enqueue(Succ, B, Idx+1);
308}
309
Ted Kremenek9a935fb2008-06-18 05:34:07 +0000310static inline ProgramPoint GetPostLoc(Stmt* S, ProgramPoint::Kind K) {
311 switch (K) {
312 default:
313 assert(false && "Invalid PostXXXKind.");
314
315 case ProgramPoint::PostStmtKind:
316 return PostStmt(S);
317
318 case ProgramPoint::PostLoadKind:
319 return PostLoad(S);
320
321 case ProgramPoint::PostPurgeDeadSymbolsKind:
322 return PostPurgeDeadSymbols(S);
323 }
324}
325
Ted Kremenekfa5a3d02008-04-29 21:04:26 +0000326ExplodedNodeImpl*
Ted Kremeneka7b8ffb2008-07-10 22:03:41 +0000327GRStmtNodeBuilderImpl::generateNodeImpl(Stmt* S, const void* State,
Ted Kremenek9a935fb2008-06-18 05:34:07 +0000328 ExplodedNodeImpl* Pred,
329 ProgramPoint::Kind K) {
Ted Kremenek3e743662008-01-14 23:24:37 +0000330
331 bool IsNew;
Ted Kremenek9a935fb2008-06-18 05:34:07 +0000332 ProgramPoint Loc = GetPostLoc(S, K);
333
Ted Kremenekfa5a3d02008-04-29 21:04:26 +0000334 ExplodedNodeImpl* N = Eng.G->getNodeImpl(Loc, State, &IsNew);
Ted Kremenek3e743662008-01-14 23:24:37 +0000335 N->addPredecessor(Pred);
336 Deferred.erase(Pred);
337
Ted Kremenek3e743662008-01-14 23:24:37 +0000338 if (IsNew) {
339 Deferred.insert(N);
340 LastNode = N;
341 return N;
342 }
343
344 LastNode = NULL;
345 return NULL;
346}
Ted Kremenek9b4211d2008-01-29 22:56:11 +0000347
Ted Kremeneka7b8ffb2008-07-10 22:03:41 +0000348ExplodedNodeImpl* GRBranchNodeBuilderImpl::generateNodeImpl(const void* State,
Ted Kremeneka50d9852008-01-30 23:03:39 +0000349 bool branch) {
Ted Kremenek9b4211d2008-01-29 22:56:11 +0000350 bool IsNew;
351
352 ExplodedNodeImpl* Succ =
353 Eng.G->getNodeImpl(BlockEdge(Eng.getCFG(), Src, branch ? DstT : DstF),
354 State, &IsNew);
355
356 Succ->addPredecessor(Pred);
357
Ted Kremenek7ff18932008-01-29 23:32:35 +0000358 if (branch) GeneratedTrue = true;
359 else GeneratedFalse = true;
360
Ted Kremeneka50d9852008-01-30 23:03:39 +0000361 if (IsNew) {
Ted Kremenek2531fce2008-01-30 23:24:39 +0000362 Deferred.push_back(Succ);
Ted Kremeneka50d9852008-01-30 23:03:39 +0000363 return Succ;
364 }
365
366 return NULL;
Ted Kremenek9b4211d2008-01-29 22:56:11 +0000367}
Ted Kremenek7ff18932008-01-29 23:32:35 +0000368
369GRBranchNodeBuilderImpl::~GRBranchNodeBuilderImpl() {
370 if (!GeneratedTrue) generateNodeImpl(Pred->State, true);
371 if (!GeneratedFalse) generateNodeImpl(Pred->State, false);
Ted Kremenek2531fce2008-01-30 23:24:39 +0000372
373 for (DeferredTy::iterator I=Deferred.begin(), E=Deferred.end(); I!=E; ++I)
Ted Kremenek90ae68f2008-02-12 18:08:17 +0000374 if (!(*I)->isSink()) Eng.WList->Enqueue(*I);
Ted Kremenek7ff18932008-01-29 23:32:35 +0000375}
Ted Kremenek7022efb2008-02-13 00:24:44 +0000376
Ted Kremenek7022efb2008-02-13 00:24:44 +0000377
378ExplodedNodeImpl*
Ted Kremenek2bba9012008-02-13 17:27:37 +0000379GRIndirectGotoNodeBuilderImpl::generateNodeImpl(const Iterator& I,
Ted Kremeneka7b8ffb2008-07-10 22:03:41 +0000380 const void* St,
Ted Kremenek7022efb2008-02-13 00:24:44 +0000381 bool isSink) {
382 bool IsNew;
383
384 ExplodedNodeImpl* Succ =
Ted Kremenek2bba9012008-02-13 17:27:37 +0000385 Eng.G->getNodeImpl(BlockEdge(Eng.getCFG(), Src, I.getBlock(), true),
Ted Kremenek7022efb2008-02-13 00:24:44 +0000386 St, &IsNew);
387
388 Succ->addPredecessor(Pred);
389
390 if (IsNew) {
391
392 if (isSink)
393 Succ->markAsSink();
394 else
395 Eng.WList->Enqueue(Succ);
396
397 return Succ;
398 }
399
400 return NULL;
401}
Ted Kremenek80ebc1d2008-02-13 23:08:21 +0000402
403
404ExplodedNodeImpl*
Ted Kremeneka7b8ffb2008-07-10 22:03:41 +0000405GRSwitchNodeBuilderImpl::generateCaseStmtNodeImpl(const Iterator& I,
406 const void* St) {
Ted Kremenek80ebc1d2008-02-13 23:08:21 +0000407
408 bool IsNew;
409
410 ExplodedNodeImpl* Succ = Eng.G->getNodeImpl(BlockEdge(Eng.getCFG(), Src,
411 I.getBlock()),
412 St, &IsNew);
413 Succ->addPredecessor(Pred);
414
415 if (IsNew) {
416 Eng.WList->Enqueue(Succ);
417 return Succ;
418 }
419
420 return NULL;
421}
422
423
424ExplodedNodeImpl*
Ted Kremeneka7b8ffb2008-07-10 22:03:41 +0000425GRSwitchNodeBuilderImpl::generateDefaultCaseNodeImpl(const void* St,
426 bool isSink) {
Ted Kremenek80ebc1d2008-02-13 23:08:21 +0000427
428 // Get the block for the default case.
429 assert (Src->succ_rbegin() != Src->succ_rend());
430 CFGBlock* DefaultBlock = *Src->succ_rbegin();
431
432 bool IsNew;
433
434 ExplodedNodeImpl* Succ = Eng.G->getNodeImpl(BlockEdge(Eng.getCFG(), Src,
435 DefaultBlock),
436 St, &IsNew);
437 Succ->addPredecessor(Pred);
438
439 if (IsNew) {
440 if (isSink)
441 Succ->markAsSink();
442 else
443 Eng.WList->Enqueue(Succ);
444
445 return Succ;
446 }
447
448 return NULL;
449}
Ted Kremenek811c2b42008-04-11 22:03:04 +0000450
451GREndPathNodeBuilderImpl::~GREndPathNodeBuilderImpl() {
452 // Auto-generate an EOP node if one has not been generated.
453 if (!HasGeneratedNode) generateNodeImpl(Pred->State);
454}
455
Ted Kremeneka7b8ffb2008-07-10 22:03:41 +0000456ExplodedNodeImpl* GREndPathNodeBuilderImpl::generateNodeImpl(const void* State){
Ted Kremenek811c2b42008-04-11 22:03:04 +0000457 HasGeneratedNode = true;
458
459 bool IsNew;
460
461 ExplodedNodeImpl* Node =
Ted Kremenek86051692008-04-16 22:30:40 +0000462 Eng.G->getNodeImpl(BlockEntrance(&B), State, &IsNew);
Ted Kremenek811c2b42008-04-11 22:03:04 +0000463
464
465 Node->addPredecessor(Pred);
466
467 if (IsNew) {
468 Node->markAsSink();
469 Eng.G->addEndOfPath(Node);
Ted Kremenekd004c412008-04-18 16:30:14 +0000470 return Node;
Ted Kremenek811c2b42008-04-11 22:03:04 +0000471 }
472
Ted Kremenekd004c412008-04-18 16:30:14 +0000473 return NULL;
Ted Kremenek811c2b42008-04-11 22:03:04 +0000474}