contrib/llvm/tools/clang/lib/StaticAnalyzer/Checkers/SimpleStreamChecker.cpp

   1 //===-- SimpleStreamChecker.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 // Defines a checker for proper use of fopen/fclose APIs.
  11 //   - If a file has been closed with fclose, it should not be accessed again.
  12 //   Accessing a closed file results in undefined behavior.
  13 //   - If a file was opened with fopen, it must be closed with fclose before
  14 //   the execution ends. Failing to do so results in a resource leak.
  15 //
  16 //===----------------------------------------------------------------------===//
  17
  18 #include "ClangSACheckers.h"
  19 #include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
  20 #include "clang/StaticAnalyzer/Core/Checker.h"
  21 #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
  22 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
  23
  24 using namespace clang;
  25 using namespace ento;
  26
  27 namespace {
  28 typedef SmallVector<SymbolRef, 2> SymbolVector;
  29
  30 struct StreamState {
  31 private:
  32   enum Kind { Opened, Closed } K;
  33   StreamState(Kind InK) : K(InK) { }
  34
  35 public:
  36   bool isOpened() const { return K == Opened; }
  37   bool isClosed() const { return K == Closed; }
  38
  39   static StreamState getOpened() { return StreamState(Opened); }
  40   static StreamState getClosed() { return StreamState(Closed); }
  41
  42   bool operator==(const StreamState &X) const {
  43     return K == X.K;
  44   }
  45   void Profile(llvm::FoldingSetNodeID &ID) const {
  46     ID.AddInteger(K);
  47   }
  48 };
  49
  50 class SimpleStreamChecker : public Checker<check::PostCall,
  51                                            check::PreCall,
  52                                            check::DeadSymbols,
  53                                            check::PointerEscape> {
  54
  55   mutable IdentifierInfo *IIfopen, *IIfclose;
  56
  57   OwningPtr<BugType> DoubleCloseBugType;
  58   OwningPtr<BugType> LeakBugType;
  59
  60   void initIdentifierInfo(ASTContext &Ctx) const;
  61
  62   void reportDoubleClose(SymbolRef FileDescSym,
  63                          const CallEvent &Call,
  64                          CheckerContext &C) const;
  65
  66   void reportLeaks(SymbolVector LeakedStreams,
  67                    CheckerContext &C,
  68                    ExplodedNode *ErrNode) const;
  69
  70   bool guaranteedNotToCloseFile(const CallEvent &Call) const;
  71
  72 public:
  73   SimpleStreamChecker();
  74
  75   /// Process fopen.
  76   void checkPostCall(const CallEvent &Call, CheckerContext &C) const;
  77   /// Process fclose.
  78   void checkPreCall(const CallEvent &Call, CheckerContext &C) const;
  79
  80   void checkDeadSymbols(SymbolReaper &SymReaper, CheckerContext &C) const;
  81
  82   /// Stop tracking addresses which escape.
  83   ProgramStateRef checkPointerEscape(ProgramStateRef State,
  84                                     const InvalidatedSymbols &Escaped,
  85                                     const CallEvent *Call,
  86                                     PointerEscapeKind Kind) const;
  87 };
  88
  89 } // end anonymous namespace
  90
  91 /// The state of the checker is a map from tracked stream symbols to their
  92 /// state. Let's store it in the ProgramState.
  93 REGISTER_MAP_WITH_PROGRAMSTATE(StreamMap, SymbolRef, StreamState)
  94
  95 namespace {
  96 class StopTrackingCallback : public SymbolVisitor {
  97   ProgramStateRef state;
  98 public:
  99   StopTrackingCallback(ProgramStateRef st) : state(st) {}
 100   ProgramStateRef getState() const { return state; }
 101
 102   bool VisitSymbol(SymbolRef sym) {
 103     state = state->remove<StreamMap>(sym);
 104     return true;
 105   }
 106 };
 107 } // end anonymous namespace
 108
 109
 110 SimpleStreamChecker::SimpleStreamChecker() : IIfopen(0), IIfclose(0) {
 111   // Initialize the bug types.
 112   DoubleCloseBugType.reset(new BugType("Double fclose",
 113                                        "Unix Stream API Error"));
 114
 115   LeakBugType.reset(new BugType("Resource Leak",
 116                                 "Unix Stream API Error"));
 117   // Sinks are higher importance bugs as well as calls to assert() or exit(0).
 118   LeakBugType->setSuppressOnSink(true);
 119 }
 120
 121 void SimpleStreamChecker::checkPostCall(const CallEvent &Call,
 122                                         CheckerContext &C) const {
 123   initIdentifierInfo(C.getASTContext());
 124
 125   if (!Call.isGlobalCFunction())
 126     return;
 127
 128   if (Call.getCalleeIdentifier() != IIfopen)
 129     return;
 130
 131   // Get the symbolic value corresponding to the file handle.
 132   SymbolRef FileDesc = Call.getReturnValue().getAsSymbol();
 133   if (!FileDesc)
 134     return;
 135
 136   // Generate the next transition (an edge in the exploded graph).
 137   ProgramStateRef State = C.getState();
 138   State = State->set<StreamMap>(FileDesc, StreamState::getOpened());
 139   C.addTransition(State);
 140 }
 141
 142 void SimpleStreamChecker::checkPreCall(const CallEvent &Call,
 143                                        CheckerContext &C) const {
 144   initIdentifierInfo(C.getASTContext());
 145
 146   if (!Call.isGlobalCFunction())
 147     return;
 148
 149   if (Call.getCalleeIdentifier() != IIfclose)
 150     return;
 151
 152   if (Call.getNumArgs() != 1)
 153     return;
 154
 155   // Get the symbolic value corresponding to the file handle.
 156   SymbolRef FileDesc = Call.getArgSVal(0).getAsSymbol();
 157   if (!FileDesc)
 158     return;
 159
 160   // Check if the stream has already been closed.
 161   ProgramStateRef State = C.getState();
 162   const StreamState *SS = State->get<StreamMap>(FileDesc);
 163   if (SS && SS->isClosed()) {
 164     reportDoubleClose(FileDesc, Call, C);
 165     return;
 166   }
 167
 168   // Generate the next transition, in which the stream is closed.
 169   State = State->set<StreamMap>(FileDesc, StreamState::getClosed());
 170   C.addTransition(State);
 171 }
 172
 173 static bool isLeaked(SymbolRef Sym, const StreamState &SS,
 174                      bool IsSymDead, ProgramStateRef State) {
 175   if (IsSymDead && SS.isOpened()) {
 176     // If a symbol is NULL, assume that fopen failed on this path.
 177     // A symbol should only be considered leaked if it is non-null.
 178     ConstraintManager &CMgr = State->getConstraintManager();
 179     ConditionTruthVal OpenFailed = CMgr.isNull(State, Sym);
 180     return !OpenFailed.isConstrainedTrue();
 181   }
 182   return false;
 183 }
 184
 185 void SimpleStreamChecker::checkDeadSymbols(SymbolReaper &SymReaper,
 186                                            CheckerContext &C) const {
 187   ProgramStateRef State = C.getState();
 188   SymbolVector LeakedStreams;
 189   StreamMapTy TrackedStreams = State->get<StreamMap>();
 190   for (StreamMapTy::iterator I = TrackedStreams.begin(),
 191                              E = TrackedStreams.end(); I != E; ++I) {
 192     SymbolRef Sym = I->first;
 193     bool IsSymDead = SymReaper.isDead(Sym);
 194
 195     // Collect leaked symbols.
 196     if (isLeaked(Sym, I->second, IsSymDead, State))
 197       LeakedStreams.push_back(Sym);
 198
 199     // Remove the dead symbol from the streams map.
 200     if (IsSymDead)
 201       State = State->remove<StreamMap>(Sym);
 202   }
 203
 204   ExplodedNode *N = C.addTransition(State);
 205   reportLeaks(LeakedStreams, C, N);
 206 }
 207
 208 void SimpleStreamChecker::reportDoubleClose(SymbolRef FileDescSym,
 209                                             const CallEvent &Call,
 210                                             CheckerContext &C) const {
 211   // We reached a bug, stop exploring the path here by generating a sink.
 212   ExplodedNode *ErrNode = C.generateSink();
 213   // If we've already reached this node on another path, return.
 214   if (!ErrNode)
 215     return;
 216
 217   // Generate the report.
 218   BugReport *R = new BugReport(*DoubleCloseBugType,
 219       "Closing a previously closed file stream", ErrNode);
 220   R->addRange(Call.getSourceRange());
 221   R->markInteresting(FileDescSym);
 222   C.emitReport(R);
 223 }
 224
 225 void SimpleStreamChecker::reportLeaks(SymbolVector LeakedStreams,
 226                                                CheckerContext &C,
 227                                                ExplodedNode *ErrNode) const {
 228   // Attach bug reports to the leak node.
 229   // TODO: Identify the leaked file descriptor.
 230   for (SmallVector<SymbolRef, 2>::iterator
 231       I = LeakedStreams.begin(), E = LeakedStreams.end(); I != E; ++I) {
 232     BugReport *R = new BugReport(*LeakBugType,
 233         "Opened file is never closed; potential resource leak", ErrNode);
 234     R->markInteresting(*I);
 235     C.emitReport(R);
 236   }
 237 }
 238
 239 bool SimpleStreamChecker::guaranteedNotToCloseFile(const CallEvent &Call) const{
 240   // If it's not in a system header, assume it might close a file.
 241   if (!Call.isInSystemHeader())
 242     return false;
 243
 244   // Handle cases where we know a buffer's /address/ can escape.
 245   if (Call.argumentsMayEscape())
 246     return false;
 247
 248   // Note, even though fclose closes the file, we do not list it here
 249   // since the checker is modeling the call.
 250
 251   return true;
 252 }
 253
 254 // If the pointer we are tracking escaped, do not track the symbol as
 255 // we cannot reason about it anymore.
 256 ProgramStateRef
 257 SimpleStreamChecker::checkPointerEscape(ProgramStateRef State,
 258                                         const InvalidatedSymbols &Escaped,
 259                                         const CallEvent *Call,
 260                                         PointerEscapeKind Kind) const {
 261   // If we know that the call cannot close a file, there is nothing to do.
 262   if ((Kind == PSK_DirectEscapeOnCall ||
 263        Kind == PSK_IndirectEscapeOnCall) &&
 264       guaranteedNotToCloseFile(*Call)) {
 265     return State;
 266   }
 267
 268   for (InvalidatedSymbols::const_iterator I = Escaped.begin(),
 269                                           E = Escaped.end();
 270                                           I != E; ++I) {
 271     SymbolRef Sym = *I;
 272
 273     // The symbol escaped. Optimistically, assume that the corresponding file
 274     // handle will be closed somewhere else.
 275     State = State->remove<StreamMap>(Sym);
 276   }
 277   return State;
 278 }
 279
 280 void SimpleStreamChecker::initIdentifierInfo(ASTContext &Ctx) const {
 281   if (IIfopen)
 282     return;
 283   IIfopen = &Ctx.Idents.get("fopen");
 284   IIfclose = &Ctx.Idents.get("fclose");
 285 }
 286
 287 void ento::registerSimpleStreamChecker(CheckerManager &mgr) {
 288   mgr.registerChecker<SimpleStreamChecker>();
 289 }