blob: a6d1e079c489d57864bf6e2f33873acae021fd05 [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
Argyrios Kyrtzidisd2592a32010-12-22 18:53:44 +000014#include "ExprEngineExperimentalChecks.h"
Ted Kremenek21142582010-12-23 19:38:26 +000015#include "clang/StaticAnalyzer/BugReporter/BugType.h"
16#include "clang/StaticAnalyzer/PathSensitive/CheckerVisitor.h"
17#include "clang/StaticAnalyzer/PathSensitive/GRState.h"
18#include "clang/StaticAnalyzer/PathSensitive/GRStateTrait.h"
19#include "clang/StaticAnalyzer/PathSensitive/SymbolManager.h"
Zhongxing Xuc1960952010-06-16 05:38:05 +000020#include "llvm/ADT/ImmutableMap.h"
21
22using namespace clang;
Ted Kremenek9ef65372010-12-23 07:20:52 +000023using namespace ento;
Zhongxing Xuc1960952010-06-16 05:38:05 +000024
25namespace {
26
Zhongxing Xu9843ba92010-07-19 01:52:29 +000027struct StreamState {
Zhongxing Xu766c2012010-07-23 14:14:59 +000028 enum Kind { Opened, Closed, OpenFailed, Escaped } K;
Zhongxing Xu9843ba92010-07-19 01:52:29 +000029 const Stmt *S;
30
31 StreamState(Kind k, const Stmt *s) : K(k), S(s) {}
32
33 bool isOpened() const { return K == Opened; }
34 bool isClosed() const { return K == Closed; }
Chris Lattnerfae96222010-09-03 04:34:38 +000035 //bool isOpenFailed() const { return K == OpenFailed; }
36 //bool isEscaped() const { return K == Escaped; }
Zhongxing Xu9843ba92010-07-19 01:52:29 +000037
38 bool operator==(const StreamState &X) const {
39 return K == X.K && S == X.S;
40 }
41
42 static StreamState getOpened(const Stmt *s) { return StreamState(Opened, s); }
43 static StreamState getClosed(const Stmt *s) { return StreamState(Closed, s); }
Zhongxing Xu47dc37f2010-07-22 14:01:01 +000044 static StreamState getOpenFailed(const Stmt *s) {
45 return StreamState(OpenFailed, s);
46 }
Zhongxing Xu766c2012010-07-23 14:14:59 +000047 static StreamState getEscaped(const Stmt *s) {
48 return StreamState(Escaped, s);
49 }
Zhongxing Xu9843ba92010-07-19 01:52:29 +000050
51 void Profile(llvm::FoldingSetNodeID &ID) const {
52 ID.AddInteger(K);
53 ID.AddPointer(S);
54 }
55};
56
Zhongxing Xuc1960952010-06-16 05:38:05 +000057class StreamChecker : public CheckerVisitor<StreamChecker> {
Zhongxing Xu47dc37f2010-07-22 14:01:01 +000058 IdentifierInfo *II_fopen, *II_tmpfile, *II_fclose, *II_fread, *II_fwrite,
Zhongxing Xuc7de88b2010-06-22 07:50:21 +000059 *II_fseek, *II_ftell, *II_rewind, *II_fgetpos, *II_fsetpos,
60 *II_clearerr, *II_feof, *II_ferror, *II_fileno;
Zhongxing Xu766c2012010-07-23 14:14:59 +000061 BuiltinBug *BT_nullfp, *BT_illegalwhence, *BT_doubleclose, *BT_ResourceLeak;
Zhongxing Xuc1960952010-06-16 05:38:05 +000062
63public:
Zhongxing Xu23d90f92010-06-18 02:47:46 +000064 StreamChecker()
Zhongxing Xu47dc37f2010-07-22 14:01:01 +000065 : II_fopen(0), II_tmpfile(0) ,II_fclose(0), II_fread(0), II_fwrite(0),
Zhongxing Xuc7de88b2010-06-22 07:50:21 +000066 II_fseek(0), II_ftell(0), II_rewind(0), II_fgetpos(0), II_fsetpos(0),
67 II_clearerr(0), II_feof(0), II_ferror(0), II_fileno(0),
Zhongxing Xu766c2012010-07-23 14:14:59 +000068 BT_nullfp(0), BT_illegalwhence(0), BT_doubleclose(0),
69 BT_ResourceLeak(0) {}
Zhongxing Xuc1960952010-06-16 05:38:05 +000070
71 static void *getTag() {
72 static int x;
73 return &x;
74 }
75
Ted Kremenek9c149532010-12-01 21:57:22 +000076 virtual bool evalCallExpr(CheckerContext &C, const CallExpr *CE);
77 void evalDeadSymbols(CheckerContext &C, SymbolReaper &SymReaper);
Argyrios Kyrtzidisd2592a32010-12-22 18:53:44 +000078 void evalEndPath(EndPathNodeBuilder &B, void *tag, ExprEngine &Eng);
Zhongxing Xu766c2012010-07-23 14:14:59 +000079 void PreVisitReturnStmt(CheckerContext &C, const ReturnStmt *S);
Zhongxing Xuc1960952010-06-16 05:38:05 +000080
81private:
Zhongxing Xuc7de88b2010-06-22 07:50:21 +000082 void Fopen(CheckerContext &C, const CallExpr *CE);
Zhongxing Xu47dc37f2010-07-22 14:01:01 +000083 void Tmpfile(CheckerContext &C, const CallExpr *CE);
Zhongxing Xu9843ba92010-07-19 01:52:29 +000084 void Fclose(CheckerContext &C, const CallExpr *CE);
Zhongxing Xuc7de88b2010-06-22 07:50:21 +000085 void Fread(CheckerContext &C, const CallExpr *CE);
86 void Fwrite(CheckerContext &C, const CallExpr *CE);
87 void Fseek(CheckerContext &C, const CallExpr *CE);
88 void Ftell(CheckerContext &C, const CallExpr *CE);
Zhongxing Xu23d90f92010-06-18 02:47:46 +000089 void Rewind(CheckerContext &C, const CallExpr *CE);
Zhongxing Xuc7de88b2010-06-22 07:50:21 +000090 void Fgetpos(CheckerContext &C, const CallExpr *CE);
91 void Fsetpos(CheckerContext &C, const CallExpr *CE);
92 void Clearerr(CheckerContext &C, const CallExpr *CE);
93 void Feof(CheckerContext &C, const CallExpr *CE);
94 void Ferror(CheckerContext &C, const CallExpr *CE);
95 void Fileno(CheckerContext &C, const CallExpr *CE);
Zhongxing Xu47dc37f2010-07-22 14:01:01 +000096
97 void OpenFileAux(CheckerContext &C, const CallExpr *CE);
Zhongxing Xuc7de88b2010-06-22 07:50:21 +000098
Zhongxing Xu12d213d2010-06-24 12:52:28 +000099 const GRState *CheckNullStream(SVal SV, const GRState *state,
100 CheckerContext &C);
Zhongxing Xu9843ba92010-07-19 01:52:29 +0000101 const GRState *CheckDoubleClose(const CallExpr *CE, const GRState *state,
102 CheckerContext &C);
Zhongxing Xuc1960952010-06-16 05:38:05 +0000103};
104
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000105} // end anonymous namespace
Zhongxing Xuc1960952010-06-16 05:38:05 +0000106
Zhongxing Xu9843ba92010-07-19 01:52:29 +0000107namespace clang {
Ted Kremenek9ef65372010-12-23 07:20:52 +0000108namespace ento {
Zhongxing Xu9843ba92010-07-19 01:52:29 +0000109 template <>
110 struct GRStateTrait<StreamState>
111 : public GRStatePartialTrait<llvm::ImmutableMap<SymbolRef, StreamState> > {
112 static void *GDMIndex() { return StreamChecker::getTag(); }
113 };
114}
Argyrios Kyrtzidis5a4f98f2010-12-22 18:53:20 +0000115}
Zhongxing Xu9843ba92010-07-19 01:52:29 +0000116
Ted Kremenek9ef65372010-12-23 07:20:52 +0000117void ento::RegisterStreamChecker(ExprEngine &Eng) {
Zhongxing Xuc1960952010-06-16 05:38:05 +0000118 Eng.registerCheck(new StreamChecker());
119}
120
Ted Kremenek9c149532010-12-01 21:57:22 +0000121bool StreamChecker::evalCallExpr(CheckerContext &C, const CallExpr *CE) {
Zhongxing Xuc1960952010-06-16 05:38:05 +0000122 const GRState *state = C.getState();
123 const Expr *Callee = CE->getCallee();
124 SVal L = state->getSVal(Callee);
125 const FunctionDecl *FD = L.getAsFunctionDecl();
126 if (!FD)
127 return false;
128
129 ASTContext &Ctx = C.getASTContext();
130 if (!II_fopen)
131 II_fopen = &Ctx.Idents.get("fopen");
Zhongxing Xu47dc37f2010-07-22 14:01:01 +0000132 if (!II_tmpfile)
133 II_tmpfile = &Ctx.Idents.get("tmpfile");
Zhongxing Xu9843ba92010-07-19 01:52:29 +0000134 if (!II_fclose)
135 II_fclose = &Ctx.Idents.get("fclose");
Zhongxing Xuc1960952010-06-16 05:38:05 +0000136 if (!II_fread)
137 II_fread = &Ctx.Idents.get("fread");
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000138 if (!II_fwrite)
139 II_fwrite = &Ctx.Idents.get("fwrite");
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000140 if (!II_fseek)
141 II_fseek = &Ctx.Idents.get("fseek");
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000142 if (!II_ftell)
143 II_ftell = &Ctx.Idents.get("ftell");
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000144 if (!II_rewind)
145 II_rewind = &Ctx.Idents.get("rewind");
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000146 if (!II_fgetpos)
147 II_fgetpos = &Ctx.Idents.get("fgetpos");
148 if (!II_fsetpos)
149 II_fsetpos = &Ctx.Idents.get("fsetpos");
150 if (!II_clearerr)
151 II_clearerr = &Ctx.Idents.get("clearerr");
152 if (!II_feof)
153 II_feof = &Ctx.Idents.get("feof");
154 if (!II_ferror)
155 II_ferror = &Ctx.Idents.get("ferror");
156 if (!II_fileno)
157 II_fileno = &Ctx.Idents.get("fileno");
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000158
Zhongxing Xuc1960952010-06-16 05:38:05 +0000159 if (FD->getIdentifier() == II_fopen) {
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000160 Fopen(C, CE);
Zhongxing Xuc1960952010-06-16 05:38:05 +0000161 return true;
162 }
Zhongxing Xu47dc37f2010-07-22 14:01:01 +0000163 if (FD->getIdentifier() == II_tmpfile) {
164 Tmpfile(C, CE);
165 return true;
166 }
Zhongxing Xu9843ba92010-07-19 01:52:29 +0000167 if (FD->getIdentifier() == II_fclose) {
168 Fclose(C, CE);
169 return true;
170 }
Zhongxing Xuc1960952010-06-16 05:38:05 +0000171 if (FD->getIdentifier() == II_fread) {
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000172 Fread(C, CE);
Zhongxing Xuc1960952010-06-16 05:38:05 +0000173 return true;
174 }
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000175 if (FD->getIdentifier() == II_fwrite) {
176 Fwrite(C, CE);
177 return true;
178 }
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000179 if (FD->getIdentifier() == II_fseek) {
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000180 Fseek(C, CE);
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000181 return true;
182 }
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000183 if (FD->getIdentifier() == II_ftell) {
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000184 Ftell(C, CE);
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000185 return true;
186 }
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000187 if (FD->getIdentifier() == II_rewind) {
188 Rewind(C, CE);
189 return true;
190 }
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000191 if (FD->getIdentifier() == II_fgetpos) {
192 Fgetpos(C, CE);
193 return true;
194 }
195 if (FD->getIdentifier() == II_fsetpos) {
196 Fsetpos(C, CE);
197 return true;
198 }
199 if (FD->getIdentifier() == II_clearerr) {
200 Clearerr(C, CE);
201 return true;
202 }
203 if (FD->getIdentifier() == II_feof) {
204 Feof(C, CE);
205 return true;
206 }
207 if (FD->getIdentifier() == II_ferror) {
208 Ferror(C, CE);
209 return true;
210 }
211 if (FD->getIdentifier() == II_fileno) {
212 Fileno(C, CE);
213 return true;
214 }
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000215
Zhongxing Xuc1960952010-06-16 05:38:05 +0000216 return false;
217}
218
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000219void StreamChecker::Fopen(CheckerContext &C, const CallExpr *CE) {
Zhongxing Xu47dc37f2010-07-22 14:01:01 +0000220 OpenFileAux(C, CE);
221}
222
223void StreamChecker::Tmpfile(CheckerContext &C, const CallExpr *CE) {
224 OpenFileAux(C, CE);
225}
226
227void StreamChecker::OpenFileAux(CheckerContext &C, const CallExpr *CE) {
Zhongxing Xuc1960952010-06-16 05:38:05 +0000228 const GRState *state = C.getState();
229 unsigned Count = C.getNodeBuilder().getCurrentBlockCount();
Ted Kremenekc8413fd2010-12-02 07:49:45 +0000230 SValBuilder &svalBuilder = C.getSValBuilder();
231 DefinedSVal RetVal =
232 cast<DefinedSVal>(svalBuilder.getConjuredSymbolVal(0, CE, Count));
Zhongxing Xuc1960952010-06-16 05:38:05 +0000233 state = state->BindExpr(CE, RetVal);
Zhongxing Xu47dc37f2010-07-22 14:01:01 +0000234
Zhongxing Xuc1960952010-06-16 05:38:05 +0000235 ConstraintManager &CM = C.getConstraintManager();
236 // Bifurcate the state into two: one with a valid FILE* pointer, the other
237 // with a NULL.
238 const GRState *stateNotNull, *stateNull;
Ted Kremenek28f47b92010-12-01 22:16:56 +0000239 llvm::tie(stateNotNull, stateNull) = CM.assumeDual(state, RetVal);
Zhongxing Xu47dc37f2010-07-22 14:01:01 +0000240
Ted Kremenek80460372010-09-03 01:07:04 +0000241 if (SymbolRef Sym = RetVal.getAsSymbol()) {
242 // if RetVal is not NULL, set the symbol's state to Opened.
243 stateNotNull =
244 stateNotNull->set<StreamState>(Sym,StreamState::getOpened(CE));
245 stateNull =
246 stateNull->set<StreamState>(Sym, StreamState::getOpenFailed(CE));
Zhongxing Xu9843ba92010-07-19 01:52:29 +0000247
Ted Kremenek80460372010-09-03 01:07:04 +0000248 C.addTransition(stateNotNull);
249 C.addTransition(stateNull);
250 }
Zhongxing Xuc1960952010-06-16 05:38:05 +0000251}
252
Zhongxing Xu9843ba92010-07-19 01:52:29 +0000253void StreamChecker::Fclose(CheckerContext &C, const CallExpr *CE) {
254 const GRState *state = CheckDoubleClose(CE, C.getState(), C);
255 if (state)
256 C.addTransition(state);
257}
258
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000259void StreamChecker::Fread(CheckerContext &C, const CallExpr *CE) {
Zhongxing Xuc1960952010-06-16 05:38:05 +0000260 const GRState *state = C.getState();
Zhongxing Xu12d213d2010-06-24 12:52:28 +0000261 if (!CheckNullStream(state->getSVal(CE->getArg(3)), state, C))
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000262 return;
263}
Zhongxing Xuc1960952010-06-16 05:38:05 +0000264
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000265void StreamChecker::Fwrite(CheckerContext &C, const CallExpr *CE) {
266 const GRState *state = C.getState();
Zhongxing Xu12d213d2010-06-24 12:52:28 +0000267 if (!CheckNullStream(state->getSVal(CE->getArg(3)), state, C))
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000268 return;
269}
270
271void StreamChecker::Fseek(CheckerContext &C, const CallExpr *CE) {
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000272 const GRState *state = C.getState();
Zhongxing Xu0c2e8c82010-06-24 13:36:41 +0000273 if (!(state = CheckNullStream(state->getSVal(CE->getArg(0)), state, C)))
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000274 return;
Zhongxing Xu0c2e8c82010-06-24 13:36:41 +0000275 // Check the legality of the 'whence' argument of 'fseek'.
276 SVal Whence = state->getSVal(CE->getArg(2));
Zhongxing Xu0c2e8c82010-06-24 13:36:41 +0000277 const nonloc::ConcreteInt *CI = dyn_cast<nonloc::ConcreteInt>(&Whence);
Ted Kremenek02b49bb2010-09-07 20:45:26 +0000278
Zhongxing Xu0c2e8c82010-06-24 13:36:41 +0000279 if (!CI)
Ted Kremenek02b49bb2010-09-07 20:45:26 +0000280 return;
Zhongxing Xu0c2e8c82010-06-24 13:36:41 +0000281
282 int64_t x = CI->getValue().getSExtValue();
Ted Kremenek02b49bb2010-09-07 20:45:26 +0000283 if (x >= 0 && x <= 2)
Zhongxing Xu0c2e8c82010-06-24 13:36:41 +0000284 return;
Zhongxing Xu0c2e8c82010-06-24 13:36:41 +0000285
Ted Kremenekd048c6e2010-12-20 21:19:09 +0000286 if (ExplodedNode *N = C.generateNode(state)) {
Ted Kremenek02b49bb2010-09-07 20:45:26 +0000287 if (!BT_illegalwhence)
288 BT_illegalwhence = new BuiltinBug("Illegal whence argument",
289 "The whence argument to fseek() should be "
290 "SEEK_SET, SEEK_END, or SEEK_CUR.");
291 BugReport *R = new BugReport(*BT_illegalwhence,
292 BT_illegalwhence->getDescription(), N);
293 C.EmitReport(R);
294 }
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000295}
Zhongxing Xuc1960952010-06-16 05:38:05 +0000296
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000297void StreamChecker::Ftell(CheckerContext &C, const CallExpr *CE) {
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000298 const GRState *state = C.getState();
Zhongxing Xu12d213d2010-06-24 12:52:28 +0000299 if (!CheckNullStream(state->getSVal(CE->getArg(0)), state, C))
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000300 return;
301}
Zhongxing Xuc1960952010-06-16 05:38:05 +0000302
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000303void StreamChecker::Rewind(CheckerContext &C, const CallExpr *CE) {
304 const GRState *state = C.getState();
Zhongxing Xu12d213d2010-06-24 12:52:28 +0000305 if (!CheckNullStream(state->getSVal(CE->getArg(0)), state, C))
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000306 return;
307}
308
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000309void StreamChecker::Fgetpos(CheckerContext &C, const CallExpr *CE) {
310 const GRState *state = C.getState();
Zhongxing Xu12d213d2010-06-24 12:52:28 +0000311 if (!CheckNullStream(state->getSVal(CE->getArg(0)), state, C))
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000312 return;
313}
314
315void StreamChecker::Fsetpos(CheckerContext &C, const CallExpr *CE) {
316 const GRState *state = C.getState();
Zhongxing Xu12d213d2010-06-24 12:52:28 +0000317 if (!CheckNullStream(state->getSVal(CE->getArg(0)), state, C))
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000318 return;
319}
320
321void StreamChecker::Clearerr(CheckerContext &C, const CallExpr *CE) {
322 const GRState *state = C.getState();
Zhongxing Xu12d213d2010-06-24 12:52:28 +0000323 if (!CheckNullStream(state->getSVal(CE->getArg(0)), state, C))
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000324 return;
325}
326
327void StreamChecker::Feof(CheckerContext &C, const CallExpr *CE) {
328 const GRState *state = C.getState();
Zhongxing Xu12d213d2010-06-24 12:52:28 +0000329 if (!CheckNullStream(state->getSVal(CE->getArg(0)), state, C))
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000330 return;
331}
332
333void StreamChecker::Ferror(CheckerContext &C, const CallExpr *CE) {
334 const GRState *state = C.getState();
Zhongxing Xu12d213d2010-06-24 12:52:28 +0000335 if (!CheckNullStream(state->getSVal(CE->getArg(0)), state, C))
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000336 return;
337}
338
339void StreamChecker::Fileno(CheckerContext &C, const CallExpr *CE) {
340 const GRState *state = C.getState();
Zhongxing Xu12d213d2010-06-24 12:52:28 +0000341 if (!CheckNullStream(state->getSVal(CE->getArg(0)), state, C))
Zhongxing Xuc7de88b2010-06-22 07:50:21 +0000342 return;
343}
344
Zhongxing Xu12d213d2010-06-24 12:52:28 +0000345const GRState *StreamChecker::CheckNullStream(SVal SV, const GRState *state,
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000346 CheckerContext &C) {
347 const DefinedSVal *DV = dyn_cast<DefinedSVal>(&SV);
348 if (!DV)
Ted Kremenek2b11fb22010-06-24 16:26:12 +0000349 return 0;
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000350
351 ConstraintManager &CM = C.getConstraintManager();
352 const GRState *stateNotNull, *stateNull;
Ted Kremenek28f47b92010-12-01 22:16:56 +0000353 llvm::tie(stateNotNull, stateNull) = CM.assumeDual(state, *DV);
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000354
355 if (!stateNotNull && stateNull) {
Ted Kremenekd048c6e2010-12-20 21:19:09 +0000356 if (ExplodedNode *N = C.generateSink(stateNull)) {
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000357 if (!BT_nullfp)
358 BT_nullfp = new BuiltinBug("NULL stream pointer",
Zhongxing Xub3f40312010-06-16 05:56:39 +0000359 "Stream pointer might be NULL.");
Zhongxing Xu23d90f92010-06-18 02:47:46 +0000360 BugReport *R =new BugReport(*BT_nullfp, BT_nullfp->getDescription(), N);
361 C.EmitReport(R);
Zhongxing Xuc1960952010-06-16 05:38:05 +0000362 }
Zhongxing Xu12d213d2010-06-24 12:52:28 +0000363 return 0;
Zhongxing Xuc1960952010-06-16 05:38:05 +0000364 }
Zhongxing Xuab421302010-06-24 13:09:02 +0000365 return stateNotNull;
Zhongxing Xuc1960952010-06-16 05:38:05 +0000366}
Zhongxing Xu9843ba92010-07-19 01:52:29 +0000367
368const GRState *StreamChecker::CheckDoubleClose(const CallExpr *CE,
Eli Friedmana7e68452010-08-22 01:00:03 +0000369 const GRState *state,
370 CheckerContext &C) {
Zhongxing Xu9843ba92010-07-19 01:52:29 +0000371 SymbolRef Sym = state->getSVal(CE->getArg(0)).getAsSymbol();
Ted Kremenek80460372010-09-03 01:07:04 +0000372 if (!Sym)
373 return state;
Zhongxing Xu9843ba92010-07-19 01:52:29 +0000374
375 const StreamState *SS = state->get<StreamState>(Sym);
Zhongxing Xu1c7370f2010-08-05 23:24:13 +0000376
377 // If the file stream is not tracked, return.
378 if (!SS)
379 return state;
Zhongxing Xu9843ba92010-07-19 01:52:29 +0000380
381 // Check: Double close a File Descriptor could cause undefined behaviour.
382 // Conforming to man-pages
383 if (SS->isClosed()) {
Ted Kremenekd048c6e2010-12-20 21:19:09 +0000384 ExplodedNode *N = C.generateSink();
Zhongxing Xu9843ba92010-07-19 01:52:29 +0000385 if (N) {
386 if (!BT_doubleclose)
Eli Friedmana7e68452010-08-22 01:00:03 +0000387 BT_doubleclose = new BuiltinBug("Double fclose",
388 "Try to close a file Descriptor already"
389 " closed. Cause undefined behaviour.");
Zhongxing Xu9843ba92010-07-19 01:52:29 +0000390 BugReport *R = new BugReport(*BT_doubleclose,
Eli Friedmana7e68452010-08-22 01:00:03 +0000391 BT_doubleclose->getDescription(), N);
Zhongxing Xu9843ba92010-07-19 01:52:29 +0000392 C.EmitReport(R);
393 }
394 return NULL;
395 }
396
397 // Close the File Descriptor.
398 return state->set<StreamState>(Sym, StreamState::getClosed(CE));
399}
Zhongxing Xu766c2012010-07-23 14:14:59 +0000400
Ted Kremenek9c149532010-12-01 21:57:22 +0000401void StreamChecker::evalDeadSymbols(CheckerContext &C,SymbolReaper &SymReaper) {
Zhongxing Xu766c2012010-07-23 14:14:59 +0000402 for (SymbolReaper::dead_iterator I = SymReaper.dead_begin(),
Eli Friedmana7e68452010-08-22 01:00:03 +0000403 E = SymReaper.dead_end(); I != E; ++I) {
Zhongxing Xu766c2012010-07-23 14:14:59 +0000404 SymbolRef Sym = *I;
405 const GRState *state = C.getState();
406 const StreamState *SS = state->get<StreamState>(Sym);
407 if (!SS)
408 return;
409
410 if (SS->isOpened()) {
Ted Kremenekd048c6e2010-12-20 21:19:09 +0000411 ExplodedNode *N = C.generateSink();
Zhongxing Xu766c2012010-07-23 14:14:59 +0000412 if (N) {
Eli Friedmana7e68452010-08-22 01:00:03 +0000413 if (!BT_ResourceLeak)
414 BT_ResourceLeak = new BuiltinBug("Resource Leak",
415 "Opened File never closed. Potential Resource leak.");
416 BugReport *R = new BugReport(*BT_ResourceLeak,
417 BT_ResourceLeak->getDescription(), N);
418 C.EmitReport(R);
Zhongxing Xu766c2012010-07-23 14:14:59 +0000419 }
420 }
421 }
422}
423
Argyrios Kyrtzidisd2592a32010-12-22 18:53:44 +0000424void StreamChecker::evalEndPath(EndPathNodeBuilder &B, void *tag,
425 ExprEngine &Eng) {
Zhongxing Xu766c2012010-07-23 14:14:59 +0000426 SaveAndRestore<bool> OldHasGen(B.HasGeneratedNode);
427 const GRState *state = B.getState();
428 typedef llvm::ImmutableMap<SymbolRef, StreamState> SymMap;
429 SymMap M = state->get<StreamState>();
430
431 for (SymMap::iterator I = M.begin(), E = M.end(); I != E; ++I) {
432 StreamState SS = I->second;
433 if (SS.isOpened()) {
434 ExplodedNode *N = B.generateNode(state, tag, B.getPredecessor());
435 if (N) {
436 if (!BT_ResourceLeak)
437 BT_ResourceLeak = new BuiltinBug("Resource Leak",
Eli Friedmana7e68452010-08-22 01:00:03 +0000438 "Opened File never closed. Potential Resource leak.");
Zhongxing Xu766c2012010-07-23 14:14:59 +0000439 BugReport *R = new BugReport(*BT_ResourceLeak,
Eli Friedmana7e68452010-08-22 01:00:03 +0000440 BT_ResourceLeak->getDescription(), N);
Zhongxing Xu766c2012010-07-23 14:14:59 +0000441 Eng.getBugReporter().EmitReport(R);
442 }
443 }
444 }
445}
446
447void StreamChecker::PreVisitReturnStmt(CheckerContext &C, const ReturnStmt *S) {
448 const Expr *RetE = S->getRetValue();
449 if (!RetE)
450 return;
451
452 const GRState *state = C.getState();
453 SymbolRef Sym = state->getSVal(RetE).getAsSymbol();
454
455 if (!Sym)
456 return;
457
458 const StreamState *SS = state->get<StreamState>(Sym);
459 if(!SS)
460 return;
461
462 if (SS->isOpened())
463 state = state->set<StreamState>(Sym, StreamState::getEscaped(S));
464
465 C.addTransition(state);
466}