blob: a209c505ebb921e1c8a5622a304216e910072067 [file] [log] [blame]
Zhongxing Xuc1960952010-06-16 05:38:05 +00001//===-- StreamChecker.cpp -----------------------------------------*- C++ -*--//
2//
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 checkers that model and check stream handling functions.
11//
12//===----------------------------------------------------------------------===//
13
14#include "GRExprEngineExperimentalChecks.h"
15#include "clang/Checker/BugReporter/BugType.h"
16#include "clang/Checker/PathSensitive/CheckerVisitor.h"
17#include "clang/Checker/PathSensitive/GRState.h"
18#include "clang/Checker/PathSensitive/GRStateTrait.h"
19#include "clang/Checker/PathSensitive/SymbolManager.h"
20#include "llvm/ADT/ImmutableMap.h"
21
22using namespace clang;
23
24namespace {
25
Zhongxing Xu9843ba92010-07-19 01:52:29 +000026struct StreamState {
Zhongxing Xu766c2012010-07-23 14:14:59 +000027 enum Kind { Opened, Closed, OpenFailed, Escaped } K;
Zhongxing Xu9843ba92010-07-19 01:52:29 +000028 const Stmt *S;
29
30 StreamState(Kind k, const Stmt *s) : K(k), S(s) {}
31
32 bool isOpened() const { return K == Opened; }
33 bool isClosed() const { return K == Closed; }
Chris Lattnerfae96222010-09-03 04:34:38 +000034 //bool isOpenFailed() const { return K == OpenFailed; }
35 //bool isEscaped() const { return K == Escaped; }
Zhongxing Xu9843ba92010-07-19 01:52:29 +000036
37 bool operator==(const StreamState &X) const {
38 return K == X.K && S == X.S;
39 }
40
41 static StreamState getOpened(const Stmt *s) { return StreamState(Opened, s); }
42 static StreamState getClosed(const Stmt *s) { return StreamState(Closed, s); }
Zhongxing Xu47dc37f2010-07-22 14:01:01 +000043 static StreamState getOpenFailed(const Stmt *s) {
44 return StreamState(OpenFailed, s);
45 }
Zhongxing Xu766c2012010-07-23 14:14:59 +000046 static StreamState getEscaped(const Stmt *s) {
47 return StreamState(Escaped, s);
48 }
Zhongxing Xu9843ba92010-07-19 01:52:29 +000049
50 void Profile(llvm::FoldingSetNodeID &ID) const {
51 ID.AddInteger(K);
52 ID.AddPointer(S);
53 }
54};
55
Zhongxing Xuc1960952010-06-16 05:38:05 +000056class StreamChecker : public CheckerVisitor<StreamChecker> {
Zhongxing Xu47dc37f2010-07-22 14:01:01 +000057 IdentifierInfo *II_fopen, *II_tmpfile, *II_fclose, *II_fread, *II_fwrite,
Zhongxing Xuc7de88b2010-06-22 07:50:21 +000058 *II_fseek, *II_ftell, *II_rewind, *II_fgetpos, *II_fsetpos,
59 *II_clearerr, *II_feof, *II_ferror, *II_fileno;
Zhongxing Xu766c2012010-07-23 14:14:59 +000060 BuiltinBug *BT_nullfp, *BT_illegalwhence, *BT_doubleclose, *BT_ResourceLeak;
Zhongxing Xuc1960952010-06-16 05:38:05 +000061
62public:
Zhongxing Xu23d90f92010-06-18 02:47:46 +000063 StreamChecker()
Zhongxing Xu47dc37f2010-07-22 14:01:01 +000064 : II_fopen(0), II_tmpfile(0) ,II_fclose(0), II_fread(0), II_fwrite(0),
Zhongxing Xuc7de88b2010-06-22 07:50:21 +000065 II_fseek(0), II_ftell(0), II_rewind(0), II_fgetpos(0), II_fsetpos(0),
66 II_clearerr(0), II_feof(0), II_ferror(0), II_fileno(0),
Zhongxing Xu766c2012010-07-23 14:14:59 +000067 BT_nullfp(0), BT_illegalwhence(0), BT_doubleclose(0),
68 BT_ResourceLeak(0) {}
Zhongxing Xuc1960952010-06-16 05:38:05 +000069
70 static void *getTag() {
71 static int x;
72 return &x;
73 }
74
Ted Kremenek9c149532010-12-01 21:57:22 +000075 virtual bool evalCallExpr(CheckerContext &C, const CallExpr *CE);
76 void evalDeadSymbols(CheckerContext &C, SymbolReaper &SymReaper);
77 void evalEndPath(GREndPathNodeBuilder &B, void *tag, GRExprEngine &Eng);
Zhongxing Xu766c2012010-07-23 14:14:59 +000078 void PreVisitReturnStmt(CheckerContext &C, const ReturnStmt *S);
Zhongxing Xuc1960952010-06-16 05:38:05 +000079
80private:
Zhongxing Xuc7de88b2010-06-22 07:50:21 +000081 void Fopen(CheckerContext &C, const CallExpr *CE);
Zhongxing Xu47dc37f2010-07-22 14:01:01 +000082 void Tmpfile(CheckerContext &C, const CallExpr *CE);
Zhongxing Xu9843ba92010-07-19 01:52:29 +000083 void Fclose(CheckerContext &C, const CallExpr *CE);
Zhongxing Xuc7de88b2010-06-22 07:50:21 +000084 void Fread(CheckerContext &C, const CallExpr *CE);
85 void Fwrite(CheckerContext &C, const CallExpr *CE);
86 void Fseek(CheckerContext &C, const CallExpr *CE);
87 void Ftell(CheckerContext &C, const CallExpr *CE);
Zhongxing Xu23d90f92010-06-18 02:47:46 +000088 void Rewind(CheckerContext &C, const CallExpr *CE);
Zhongxing Xuc7de88b2010-06-22 07:50:21 +000089 void Fgetpos(CheckerContext &C, const CallExpr *CE);
90 void Fsetpos(CheckerContext &C, const CallExpr *CE);
91 void Clearerr(CheckerContext &C, const CallExpr *CE);
92 void Feof(CheckerContext &C, const CallExpr *CE);
93 void Ferror(CheckerContext &C, const CallExpr *CE);
94 void Fileno(CheckerContext &C, const CallExpr *CE);
Zhongxing Xu47dc37f2010-07-22 14:01:01 +000095
96 void OpenFileAux(CheckerContext &C, const CallExpr *CE);
Zhongxing Xuc7de88b2010-06-22 07:50:21 +000097
Zhongxing Xu12d213d2010-06-24 12:52:28 +000098 const GRState *CheckNullStream(SVal SV, const GRState *state,
99 CheckerContext &C);
Zhongxing Xu9843ba92010-07-19 01:52:29 +0000100 const GRState *CheckDoubleClose(const CallExpr *CE, const GRState *state,
101 CheckerContext &C);
Zhongxing Xuc1960952010-06-16 05:38:05 +0000102};
103
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000104} // end anonymous namespace
Zhongxing Xuc1960952010-06-16 05:38:05 +0000105
Zhongxing Xu9843ba92010-07-19 01:52:29 +0000106namespace clang {
107 template <>
108 struct GRStateTrait<StreamState>
109 : public GRStatePartialTrait<llvm::ImmutableMap<SymbolRef, StreamState> > {
110 static void *GDMIndex() { return StreamChecker::getTag(); }
111 };
112}
113
Zhongxing Xuc1960952010-06-16 05:38:05 +0000114void clang::RegisterStreamChecker(GRExprEngine &Eng) {
115 Eng.registerCheck(new StreamChecker());
116}
117
Ted Kremenek9c149532010-12-01 21:57:22 +0000118bool StreamChecker::evalCallExpr(CheckerContext &C, const CallExpr *CE) {
Zhongxing Xuc1960952010-06-16 05:38:05 +0000119 const GRState *state = C.getState();
120 const Expr *Callee = CE->getCallee();
121 SVal L = state->getSVal(Callee);
122 const FunctionDecl *FD = L.getAsFunctionDecl();
123 if (!FD)
124 return false;
125
126 ASTContext &Ctx = C.getASTContext();
127 if (!II_fopen)
128 II_fopen = &Ctx.Idents.get("fopen");
Zhongxing Xu47dc37f2010-07-22 14:01:01 +0000129 if (!II_tmpfile)
130 II_tmpfile = &Ctx.Idents.get("tmpfile");
Zhongxing Xu9843ba92010-07-19 01:52:29 +0000131 if (!II_fclose)
132 II_fclose = &Ctx.Idents.get("fclose");
Zhongxing Xuc1960952010-06-16 05:38:05 +0000133 if (!II_fread)
134 II_fread = &Ctx.Idents.get("fread");
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000135 if (!II_fwrite)
136 II_fwrite = &Ctx.Idents.get("fwrite");
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000137 if (!II_fseek)
138 II_fseek = &Ctx.Idents.get("fseek");
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000139 if (!II_ftell)
140 II_ftell = &Ctx.Idents.get("ftell");
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000141 if (!II_rewind)
142 II_rewind = &Ctx.Idents.get("rewind");
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000143 if (!II_fgetpos)
144 II_fgetpos = &Ctx.Idents.get("fgetpos");
145 if (!II_fsetpos)
146 II_fsetpos = &Ctx.Idents.get("fsetpos");
147 if (!II_clearerr)
148 II_clearerr = &Ctx.Idents.get("clearerr");
149 if (!II_feof)
150 II_feof = &Ctx.Idents.get("feof");
151 if (!II_ferror)
152 II_ferror = &Ctx.Idents.get("ferror");
153 if (!II_fileno)
154 II_fileno = &Ctx.Idents.get("fileno");
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000155
Zhongxing Xuc1960952010-06-16 05:38:05 +0000156 if (FD->getIdentifier() == II_fopen) {
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000157 Fopen(C, CE);
Zhongxing Xuc1960952010-06-16 05:38:05 +0000158 return true;
159 }
Zhongxing Xu47dc37f2010-07-22 14:01:01 +0000160 if (FD->getIdentifier() == II_tmpfile) {
161 Tmpfile(C, CE);
162 return true;
163 }
Zhongxing Xu9843ba92010-07-19 01:52:29 +0000164 if (FD->getIdentifier() == II_fclose) {
165 Fclose(C, CE);
166 return true;
167 }
Zhongxing Xuc1960952010-06-16 05:38:05 +0000168 if (FD->getIdentifier() == II_fread) {
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000169 Fread(C, CE);
Zhongxing Xuc1960952010-06-16 05:38:05 +0000170 return true;
171 }
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000172 if (FD->getIdentifier() == II_fwrite) {
173 Fwrite(C, CE);
174 return true;
175 }
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000176 if (FD->getIdentifier() == II_fseek) {
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000177 Fseek(C, CE);
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000178 return true;
179 }
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000180 if (FD->getIdentifier() == II_ftell) {
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000181 Ftell(C, CE);
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000182 return true;
183 }
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000184 if (FD->getIdentifier() == II_rewind) {
185 Rewind(C, CE);
186 return true;
187 }
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000188 if (FD->getIdentifier() == II_fgetpos) {
189 Fgetpos(C, CE);
190 return true;
191 }
192 if (FD->getIdentifier() == II_fsetpos) {
193 Fsetpos(C, CE);
194 return true;
195 }
196 if (FD->getIdentifier() == II_clearerr) {
197 Clearerr(C, CE);
198 return true;
199 }
200 if (FD->getIdentifier() == II_feof) {
201 Feof(C, CE);
202 return true;
203 }
204 if (FD->getIdentifier() == II_ferror) {
205 Ferror(C, CE);
206 return true;
207 }
208 if (FD->getIdentifier() == II_fileno) {
209 Fileno(C, CE);
210 return true;
211 }
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000212
Zhongxing Xuc1960952010-06-16 05:38:05 +0000213 return false;
214}
215
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000216void StreamChecker::Fopen(CheckerContext &C, const CallExpr *CE) {
Zhongxing Xu47dc37f2010-07-22 14:01:01 +0000217 OpenFileAux(C, CE);
218}
219
220void StreamChecker::Tmpfile(CheckerContext &C, const CallExpr *CE) {
221 OpenFileAux(C, CE);
222}
223
224void StreamChecker::OpenFileAux(CheckerContext &C, const CallExpr *CE) {
Zhongxing Xuc1960952010-06-16 05:38:05 +0000225 const GRState *state = C.getState();
226 unsigned Count = C.getNodeBuilder().getCurrentBlockCount();
227 ValueManager &ValMgr = C.getValueManager();
Zhongxing Xu70154852010-06-16 05:52:03 +0000228 DefinedSVal RetVal = cast<DefinedSVal>(ValMgr.getConjuredSymbolVal(0, CE,
229 Count));
Zhongxing Xuc1960952010-06-16 05:38:05 +0000230 state = state->BindExpr(CE, RetVal);
Zhongxing Xu47dc37f2010-07-22 14:01:01 +0000231
Zhongxing Xuc1960952010-06-16 05:38:05 +0000232 ConstraintManager &CM = C.getConstraintManager();
233 // Bifurcate the state into two: one with a valid FILE* pointer, the other
234 // with a NULL.
235 const GRState *stateNotNull, *stateNull;
Ted Kremenek28f47b92010-12-01 22:16:56 +0000236 llvm::tie(stateNotNull, stateNull) = CM.assumeDual(state, RetVal);
Zhongxing Xu47dc37f2010-07-22 14:01:01 +0000237
Ted Kremenek80460372010-09-03 01:07:04 +0000238 if (SymbolRef Sym = RetVal.getAsSymbol()) {
239 // if RetVal is not NULL, set the symbol's state to Opened.
240 stateNotNull =
241 stateNotNull->set<StreamState>(Sym,StreamState::getOpened(CE));
242 stateNull =
243 stateNull->set<StreamState>(Sym, StreamState::getOpenFailed(CE));
Zhongxing Xu9843ba92010-07-19 01:52:29 +0000244
Ted Kremenek80460372010-09-03 01:07:04 +0000245 C.addTransition(stateNotNull);
246 C.addTransition(stateNull);
247 }
Zhongxing Xuc1960952010-06-16 05:38:05 +0000248}
249
Zhongxing Xu9843ba92010-07-19 01:52:29 +0000250void StreamChecker::Fclose(CheckerContext &C, const CallExpr *CE) {
251 const GRState *state = CheckDoubleClose(CE, C.getState(), C);
252 if (state)
253 C.addTransition(state);
254}
255
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000256void StreamChecker::Fread(CheckerContext &C, const CallExpr *CE) {
Zhongxing Xuc1960952010-06-16 05:38:05 +0000257 const GRState *state = C.getState();
Zhongxing Xu12d213d2010-06-24 12:52:28 +0000258 if (!CheckNullStream(state->getSVal(CE->getArg(3)), state, C))
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000259 return;
260}
Zhongxing Xuc1960952010-06-16 05:38:05 +0000261
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000262void StreamChecker::Fwrite(CheckerContext &C, const CallExpr *CE) {
263 const GRState *state = C.getState();
Zhongxing Xu12d213d2010-06-24 12:52:28 +0000264 if (!CheckNullStream(state->getSVal(CE->getArg(3)), state, C))
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000265 return;
266}
267
268void StreamChecker::Fseek(CheckerContext &C, const CallExpr *CE) {
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000269 const GRState *state = C.getState();
Zhongxing Xu0c2e8c82010-06-24 13:36:41 +0000270 if (!(state = CheckNullStream(state->getSVal(CE->getArg(0)), state, C)))
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000271 return;
Zhongxing Xu0c2e8c82010-06-24 13:36:41 +0000272 // Check the legality of the 'whence' argument of 'fseek'.
273 SVal Whence = state->getSVal(CE->getArg(2));
Zhongxing Xu0c2e8c82010-06-24 13:36:41 +0000274 const nonloc::ConcreteInt *CI = dyn_cast<nonloc::ConcreteInt>(&Whence);
Ted Kremenek02b49bb2010-09-07 20:45:26 +0000275
Zhongxing Xu0c2e8c82010-06-24 13:36:41 +0000276 if (!CI)
Ted Kremenek02b49bb2010-09-07 20:45:26 +0000277 return;
Zhongxing Xu0c2e8c82010-06-24 13:36:41 +0000278
279 int64_t x = CI->getValue().getSExtValue();
Ted Kremenek02b49bb2010-09-07 20:45:26 +0000280 if (x >= 0 && x <= 2)
Zhongxing Xu0c2e8c82010-06-24 13:36:41 +0000281 return;
Zhongxing Xu0c2e8c82010-06-24 13:36:41 +0000282
Ted Kremenek02b49bb2010-09-07 20:45:26 +0000283 if (ExplodedNode *N = C.GenerateNode(state)) {
284 if (!BT_illegalwhence)
285 BT_illegalwhence = new BuiltinBug("Illegal whence argument",
286 "The whence argument to fseek() should be "
287 "SEEK_SET, SEEK_END, or SEEK_CUR.");
288 BugReport *R = new BugReport(*BT_illegalwhence,
289 BT_illegalwhence->getDescription(), N);
290 C.EmitReport(R);
291 }
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000292}
Zhongxing Xuc1960952010-06-16 05:38:05 +0000293
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000294void StreamChecker::Ftell(CheckerContext &C, const CallExpr *CE) {
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000295 const GRState *state = C.getState();
Zhongxing Xu12d213d2010-06-24 12:52:28 +0000296 if (!CheckNullStream(state->getSVal(CE->getArg(0)), state, C))
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000297 return;
298}
Zhongxing Xuc1960952010-06-16 05:38:05 +0000299
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000300void StreamChecker::Rewind(CheckerContext &C, const CallExpr *CE) {
301 const GRState *state = C.getState();
Zhongxing Xu12d213d2010-06-24 12:52:28 +0000302 if (!CheckNullStream(state->getSVal(CE->getArg(0)), state, C))
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000303 return;
304}
305
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000306void StreamChecker::Fgetpos(CheckerContext &C, const CallExpr *CE) {
307 const GRState *state = C.getState();
Zhongxing Xu12d213d2010-06-24 12:52:28 +0000308 if (!CheckNullStream(state->getSVal(CE->getArg(0)), state, C))
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000309 return;
310}
311
312void StreamChecker::Fsetpos(CheckerContext &C, const CallExpr *CE) {
313 const GRState *state = C.getState();
Zhongxing Xu12d213d2010-06-24 12:52:28 +0000314 if (!CheckNullStream(state->getSVal(CE->getArg(0)), state, C))
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000315 return;
316}
317
318void StreamChecker::Clearerr(CheckerContext &C, const CallExpr *CE) {
319 const GRState *state = C.getState();
Zhongxing Xu12d213d2010-06-24 12:52:28 +0000320 if (!CheckNullStream(state->getSVal(CE->getArg(0)), state, C))
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000321 return;
322}
323
324void StreamChecker::Feof(CheckerContext &C, const CallExpr *CE) {
325 const GRState *state = C.getState();
Zhongxing Xu12d213d2010-06-24 12:52:28 +0000326 if (!CheckNullStream(state->getSVal(CE->getArg(0)), state, C))
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000327 return;
328}
329
330void StreamChecker::Ferror(CheckerContext &C, const CallExpr *CE) {
331 const GRState *state = C.getState();
Zhongxing Xu12d213d2010-06-24 12:52:28 +0000332 if (!CheckNullStream(state->getSVal(CE->getArg(0)), state, C))
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000333 return;
334}
335
336void StreamChecker::Fileno(CheckerContext &C, const CallExpr *CE) {
337 const GRState *state = C.getState();
Zhongxing Xu12d213d2010-06-24 12:52:28 +0000338 if (!CheckNullStream(state->getSVal(CE->getArg(0)), state, C))
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000339 return;
340}
341
Zhongxing Xu12d213d2010-06-24 12:52:28 +0000342const GRState *StreamChecker::CheckNullStream(SVal SV, const GRState *state,
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000343 CheckerContext &C) {
344 const DefinedSVal *DV = dyn_cast<DefinedSVal>(&SV);
345 if (!DV)
Ted Kremenek2b11fb22010-06-24 16:26:12 +0000346 return 0;
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000347
348 ConstraintManager &CM = C.getConstraintManager();
349 const GRState *stateNotNull, *stateNull;
Ted Kremenek28f47b92010-12-01 22:16:56 +0000350 llvm::tie(stateNotNull, stateNull) = CM.assumeDual(state, *DV);
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000351
352 if (!stateNotNull && stateNull) {
353 if (ExplodedNode *N = C.GenerateSink(stateNull)) {
354 if (!BT_nullfp)
355 BT_nullfp = new BuiltinBug("NULL stream pointer",
Zhongxing Xub3f40312010-06-16 05:56:39 +0000356 "Stream pointer might be NULL.");
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000357 BugReport *R =new BugReport(*BT_nullfp, BT_nullfp->getDescription(), N);
358 C.EmitReport(R);
Zhongxing Xuc1960952010-06-16 05:38:05 +0000359 }
Zhongxing Xu12d213d2010-06-24 12:52:28 +0000360 return 0;
Zhongxing Xuc1960952010-06-16 05:38:05 +0000361 }
Zhongxing Xuab421302010-06-24 13:09:02 +0000362 return stateNotNull;
Zhongxing Xuc1960952010-06-16 05:38:05 +0000363}
Zhongxing Xu9843ba92010-07-19 01:52:29 +0000364
365const GRState *StreamChecker::CheckDoubleClose(const CallExpr *CE,
Eli Friedmana7e68452010-08-22 01:00:03 +0000366 const GRState *state,
367 CheckerContext &C) {
Zhongxing Xu9843ba92010-07-19 01:52:29 +0000368 SymbolRef Sym = state->getSVal(CE->getArg(0)).getAsSymbol();
Ted Kremenek80460372010-09-03 01:07:04 +0000369 if (!Sym)
370 return state;
Zhongxing Xu9843ba92010-07-19 01:52:29 +0000371
372 const StreamState *SS = state->get<StreamState>(Sym);
Zhongxing Xu1c7370f2010-08-05 23:24:13 +0000373
374 // If the file stream is not tracked, return.
375 if (!SS)
376 return state;
Zhongxing Xu9843ba92010-07-19 01:52:29 +0000377
378 // Check: Double close a File Descriptor could cause undefined behaviour.
379 // Conforming to man-pages
380 if (SS->isClosed()) {
381 ExplodedNode *N = C.GenerateSink();
382 if (N) {
383 if (!BT_doubleclose)
Eli Friedmana7e68452010-08-22 01:00:03 +0000384 BT_doubleclose = new BuiltinBug("Double fclose",
385 "Try to close a file Descriptor already"
386 " closed. Cause undefined behaviour.");
Zhongxing Xu9843ba92010-07-19 01:52:29 +0000387 BugReport *R = new BugReport(*BT_doubleclose,
Eli Friedmana7e68452010-08-22 01:00:03 +0000388 BT_doubleclose->getDescription(), N);
Zhongxing Xu9843ba92010-07-19 01:52:29 +0000389 C.EmitReport(R);
390 }
391 return NULL;
392 }
393
394 // Close the File Descriptor.
395 return state->set<StreamState>(Sym, StreamState::getClosed(CE));
396}
Zhongxing Xu766c2012010-07-23 14:14:59 +0000397
Ted Kremenek9c149532010-12-01 21:57:22 +0000398void StreamChecker::evalDeadSymbols(CheckerContext &C,SymbolReaper &SymReaper) {
Zhongxing Xu766c2012010-07-23 14:14:59 +0000399 for (SymbolReaper::dead_iterator I = SymReaper.dead_begin(),
Eli Friedmana7e68452010-08-22 01:00:03 +0000400 E = SymReaper.dead_end(); I != E; ++I) {
Zhongxing Xu766c2012010-07-23 14:14:59 +0000401 SymbolRef Sym = *I;
402 const GRState *state = C.getState();
403 const StreamState *SS = state->get<StreamState>(Sym);
404 if (!SS)
405 return;
406
407 if (SS->isOpened()) {
408 ExplodedNode *N = C.GenerateSink();
409 if (N) {
Eli Friedmana7e68452010-08-22 01:00:03 +0000410 if (!BT_ResourceLeak)
411 BT_ResourceLeak = new BuiltinBug("Resource Leak",
412 "Opened File never closed. Potential Resource leak.");
413 BugReport *R = new BugReport(*BT_ResourceLeak,
414 BT_ResourceLeak->getDescription(), N);
415 C.EmitReport(R);
Zhongxing Xu766c2012010-07-23 14:14:59 +0000416 }
417 }
418 }
419}
420
Ted Kremenek9c149532010-12-01 21:57:22 +0000421void StreamChecker::evalEndPath(GREndPathNodeBuilder &B, void *tag,
Eli Friedmana7e68452010-08-22 01:00:03 +0000422 GRExprEngine &Eng) {
Zhongxing Xu766c2012010-07-23 14:14:59 +0000423 SaveAndRestore<bool> OldHasGen(B.HasGeneratedNode);
424 const GRState *state = B.getState();
425 typedef llvm::ImmutableMap<SymbolRef, StreamState> SymMap;
426 SymMap M = state->get<StreamState>();
427
428 for (SymMap::iterator I = M.begin(), E = M.end(); I != E; ++I) {
429 StreamState SS = I->second;
430 if (SS.isOpened()) {
431 ExplodedNode *N = B.generateNode(state, tag, B.getPredecessor());
432 if (N) {
433 if (!BT_ResourceLeak)
434 BT_ResourceLeak = new BuiltinBug("Resource Leak",
Eli Friedmana7e68452010-08-22 01:00:03 +0000435 "Opened File never closed. Potential Resource leak.");
Zhongxing Xu766c2012010-07-23 14:14:59 +0000436 BugReport *R = new BugReport(*BT_ResourceLeak,
Eli Friedmana7e68452010-08-22 01:00:03 +0000437 BT_ResourceLeak->getDescription(), N);
Zhongxing Xu766c2012010-07-23 14:14:59 +0000438 Eng.getBugReporter().EmitReport(R);
439 }
440 }
441 }
442}
443
444void StreamChecker::PreVisitReturnStmt(CheckerContext &C, const ReturnStmt *S) {
445 const Expr *RetE = S->getRetValue();
446 if (!RetE)
447 return;
448
449 const GRState *state = C.getState();
450 SymbolRef Sym = state->getSVal(RetE).getAsSymbol();
451
452 if (!Sym)
453 return;
454
455 const StreamState *SS = state->get<StreamState>(Sym);
456 if(!SS)
457 return;
458
459 if (SS->isOpened())
460 state = state->set<StreamState>(Sym, StreamState::getEscaped(S));
461
462 C.addTransition(state);
463}