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

   1 //== ObjCSelfInitChecker.cpp - Checker for 'self' initialization -*- 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 defines ObjCSelfInitChecker, a builtin check that checks for uses of
  11 // 'self' before proper initialization.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 // This checks initialization methods to verify that they assign 'self' to the
  16 // result of an initialization call (e.g. [super init], or [self initWith..])
  17 // before using 'self' or any instance variable.
  18 //
  19 // To perform the required checking, values are tagged with flags that indicate
  20 // 1) if the object is the one pointed to by 'self', and 2) if the object
  21 // is the result of an initializer (e.g. [super init]).
  22 //
  23 // Uses of an object that is true for 1) but not 2) trigger a diagnostic.
  24 // The uses that are currently checked are:
  25 //  - Using instance variables.
  26 //  - Returning the object.
  27 //
  28 // Note that we don't check for an invalid 'self' that is the receiver of an
  29 // obj-c message expression to cut down false positives where logging functions
  30 // get information from self (like its class) or doing "invalidation" on self
  31 // when the initialization fails.
  32 //
  33 // Because the object that 'self' points to gets invalidated when a call
  34 // receives a reference to 'self', the checker keeps track and passes the flags
  35 // for 1) and 2) to the new object that 'self' points to after the call.
  36 //
  37 // FIXME (rdar://7937506): In the case of:
  38 //   [super init];
  39 //   return self;
  40 // Have an extra PathDiagnosticPiece in the path that says "called [super init],
  41 // but didn't assign the result to self."
  42
  43 //===----------------------------------------------------------------------===//
  44
  45 // FIXME: Somehow stick the link to Apple's documentation about initializing
  46 // objects in the diagnostics.
  47 // http://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/ObjectiveC/Articles/ocAllocInit.html
  48
  49 #include "ClangSACheckers.h"
  50 #include "clang/StaticAnalyzer/Core/Checker.h"
  51 #include "clang/StaticAnalyzer/Core/CheckerManager.h"
  52 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
  53 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramStateTrait.h"
  54 #include "clang/StaticAnalyzer/Core/PathSensitive/ObjCMessage.h"
  55 #include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
  56 #include "clang/AST/ParentMap.h"
  57
  58 using namespace clang;
  59 using namespace ento;
  60
  61 static bool shouldRunOnFunctionOrMethod(const NamedDecl *ND);
  62 static bool isInitializationMethod(const ObjCMethodDecl *MD);
  63 static bool isInitMessage(const ObjCMessage &msg);
  64 static bool isSelfVar(SVal location, CheckerContext &C);
  65
  66 namespace {
  67 class ObjCSelfInitChecker : public Checker<
  68                                              check::PostObjCMessage,
  69                                              check::PostStmt<ObjCIvarRefExpr>,
  70                                              check::PreStmt<ReturnStmt>,
  71                                              check::PreStmt<CallExpr>,
  72                                              check::PostStmt<CallExpr>,
  73                                              check::Location > {
  74 public:
  75   void checkPostObjCMessage(ObjCMessage msg, CheckerContext &C) const;
  76   void checkPostStmt(const ObjCIvarRefExpr *E, CheckerContext &C) const;
  77   void checkPreStmt(const ReturnStmt *S, CheckerContext &C) const;
  78   void checkPreStmt(const CallExpr *CE, CheckerContext &C) const;
  79   void checkPostStmt(const CallExpr *CE, CheckerContext &C) const;
  80   void checkLocation(SVal location, bool isLoad, const Stmt *S,
  81                      CheckerContext &C) const;
  82 };
  83 } // end anonymous namespace
  84
  85 namespace {
  86
  87 class InitSelfBug : public BugType {
  88   const std::string desc;
  89 public:
  90   InitSelfBug() : BugType("missing \"self = [(super or self) init...]\"",
  91                           "missing \"self = [(super or self) init...]\"") {}
  92 };
  93
  94 } // end anonymous namespace
  95
  96 namespace {
  97 enum SelfFlagEnum {
  98   /// \brief No flag set.
  99   SelfFlag_None = 0x0,
 100   /// \brief Value came from 'self'.
 101   SelfFlag_Self    = 0x1,
 102   /// \brief Value came from the result of an initializer (e.g. [super init]).
 103   SelfFlag_InitRes = 0x2
 104 };
 105 }
 106
 107 typedef llvm::ImmutableMap<SymbolRef, unsigned> SelfFlag;
 108 namespace { struct CalledInit {}; }
 109 namespace { struct PreCallSelfFlags {}; }
 110
 111 namespace clang {
 112 namespace ento {
 113   template<>
 114   struct ProgramStateTrait<SelfFlag> : public ProgramStatePartialTrait<SelfFlag> {
 115     static void *GDMIndex() { static int index = 0; return &index; }
 116   };
 117   template <>
 118   struct ProgramStateTrait<CalledInit> : public ProgramStatePartialTrait<bool> {
 119     static void *GDMIndex() { static int index = 0; return &index; }
 120   };
 121
 122   /// \brief A call receiving a reference to 'self' invalidates the object that
 123   /// 'self' contains. This keeps the "self flags" assigned to the 'self'
 124   /// object before the call so we can assign them to the new object that 'self'
 125   /// points to after the call.
 126   template <>
 127   struct ProgramStateTrait<PreCallSelfFlags> : public ProgramStatePartialTrait<unsigned> {
 128     static void *GDMIndex() { static int index = 0; return &index; }
 129   };
 130 }
 131 }
 132
 133 static SelfFlagEnum getSelfFlags(SVal val, const ProgramState *state) {
 134   if (SymbolRef sym = val.getAsSymbol())
 135     if (const unsigned *attachedFlags = state->get<SelfFlag>(sym))
 136       return (SelfFlagEnum)*attachedFlags;
 137   return SelfFlag_None;
 138 }
 139
 140 static SelfFlagEnum getSelfFlags(SVal val, CheckerContext &C) {
 141   return getSelfFlags(val, C.getState());
 142 }
 143
 144 static void addSelfFlag(const ProgramState *state, SVal val,
 145                         SelfFlagEnum flag, CheckerContext &C) {
 146   // We tag the symbol that the SVal wraps.
 147   if (SymbolRef sym = val.getAsSymbol())
 148     C.addTransition(state->set<SelfFlag>(sym, getSelfFlags(val, C) | flag));
 149 }
 150
 151 static bool hasSelfFlag(SVal val, SelfFlagEnum flag, CheckerContext &C) {
 152   return getSelfFlags(val, C) & flag;
 153 }
 154
 155 /// \brief Returns true of the value of the expression is the object that 'self'
 156 /// points to and is an object that did not come from the result of calling
 157 /// an initializer.
 158 static bool isInvalidSelf(const Expr *E, CheckerContext &C) {
 159   SVal exprVal = C.getState()->getSVal(E);
 160   if (!hasSelfFlag(exprVal, SelfFlag_Self, C))
 161     return false; // value did not come from 'self'.
 162   if (hasSelfFlag(exprVal, SelfFlag_InitRes, C))
 163     return false; // 'self' is properly initialized.
 164
 165   return true;
 166 }
 167
 168 static void checkForInvalidSelf(const Expr *E, CheckerContext &C,
 169                                 const char *errorStr) {
 170   if (!E)
 171     return;
 172
 173   if (!C.getState()->get<CalledInit>())
 174     return;
 175
 176   if (!isInvalidSelf(E, C))
 177     return;
 178
 179   // Generate an error node.
 180   ExplodedNode *N = C.generateSink();
 181   if (!N)
 182     return;
 183
 184   BugReport *report =
 185     new BugReport(*new InitSelfBug(), errorStr, N);
 186   C.EmitReport(report);
 187 }
 188
 189 void ObjCSelfInitChecker::checkPostObjCMessage(ObjCMessage msg,
 190                                                CheckerContext &C) const {
 191   // When encountering a message that does initialization (init rule),
 192   // tag the return value so that we know later on that if self has this value
 193   // then it is properly initialized.
 194
 195   // FIXME: A callback should disable checkers at the start of functions.
 196   if (!shouldRunOnFunctionOrMethod(dyn_cast<NamedDecl>(
 197                                      C.getCurrentAnalysisContext()->getDecl())))
 198     return;
 199
 200   if (isInitMessage(msg)) {
 201     // Tag the return value as the result of an initializer.
 202     const ProgramState *state = C.getState();
 203
 204     // FIXME this really should be context sensitive, where we record
 205     // the current stack frame (for IPA).  Also, we need to clean this
 206     // value out when we return from this method.
 207     state = state->set<CalledInit>(true);
 208
 209     SVal V = state->getSVal(msg.getOriginExpr());
 210     addSelfFlag(state, V, SelfFlag_InitRes, C);
 211     return;
 212   }
 213
 214   // We don't check for an invalid 'self' in an obj-c message expression to cut
 215   // down false positives where logging functions get information from self
 216   // (like its class) or doing "invalidation" on self when the initialization
 217   // fails.
 218 }
 219
 220 void ObjCSelfInitChecker::checkPostStmt(const ObjCIvarRefExpr *E,
 221                                         CheckerContext &C) const {
 222   // FIXME: A callback should disable checkers at the start of functions.
 223   if (!shouldRunOnFunctionOrMethod(dyn_cast<NamedDecl>(
 224                                      C.getCurrentAnalysisContext()->getDecl())))
 225     return;
 226
 227   checkForInvalidSelf(E->getBase(), C,
 228     "Instance variable used while 'self' is not set to the result of "
 229                                                  "'[(super or self) init...]'");
 230 }
 231
 232 void ObjCSelfInitChecker::checkPreStmt(const ReturnStmt *S,
 233                                        CheckerContext &C) const {
 234   // FIXME: A callback should disable checkers at the start of functions.
 235   if (!shouldRunOnFunctionOrMethod(dyn_cast<NamedDecl>(
 236                                      C.getCurrentAnalysisContext()->getDecl())))
 237     return;
 238
 239   checkForInvalidSelf(S->getRetValue(), C,
 240     "Returning 'self' while it is not set to the result of "
 241                                                  "'[(super or self) init...]'");
 242 }
 243
 244 // When a call receives a reference to 'self', [Pre/Post]VisitGenericCall pass
 245 // the SelfFlags from the object 'self' point to before the call, to the new
 246 // object after the call. This is to avoid invalidation of 'self' by logging
 247 // functions.
 248 // Another common pattern in classes with multiple initializers is to put the
 249 // subclass's common initialization bits into a static function that receives
 250 // the value of 'self', e.g:
 251 // @code
 252 //   if (!(self = [super init]))
 253 //     return nil;
 254 //   if (!(self = _commonInit(self)))
 255 //     return nil;
 256 // @endcode
 257 // Until we can use inter-procedural analysis, in such a call, transfer the
 258 // SelfFlags to the result of the call.
 259
 260 void ObjCSelfInitChecker::checkPreStmt(const CallExpr *CE,
 261                                        CheckerContext &C) const {
 262   const ProgramState *state = C.getState();
 263   for (CallExpr::const_arg_iterator
 264          I = CE->arg_begin(), E = CE->arg_end(); I != E; ++I) {
 265     SVal argV = state->getSVal(*I);
 266     if (isSelfVar(argV, C)) {
 267       unsigned selfFlags = getSelfFlags(state->getSVal(cast<Loc>(argV)), C);
 268       C.addTransition(state->set<PreCallSelfFlags>(selfFlags));
 269       return;
 270     } else if (hasSelfFlag(argV, SelfFlag_Self, C)) {
 271       unsigned selfFlags = getSelfFlags(argV, C);
 272       C.addTransition(state->set<PreCallSelfFlags>(selfFlags));
 273       return;
 274     }
 275   }
 276 }
 277
 278 void ObjCSelfInitChecker::checkPostStmt(const CallExpr *CE,
 279                                         CheckerContext &C) const {
 280   const ProgramState *state = C.getState();
 281   for (CallExpr::const_arg_iterator
 282          I = CE->arg_begin(), E = CE->arg_end(); I != E; ++I) {
 283     SVal argV = state->getSVal(*I);
 284     if (isSelfVar(argV, C)) {
 285       SelfFlagEnum prevFlags = (SelfFlagEnum)state->get<PreCallSelfFlags>();
 286       state = state->remove<PreCallSelfFlags>();
 287       addSelfFlag(state, state->getSVal(cast<Loc>(argV)), prevFlags, C);
 288       return;
 289     } else if (hasSelfFlag(argV, SelfFlag_Self, C)) {
 290       SelfFlagEnum prevFlags = (SelfFlagEnum)state->get<PreCallSelfFlags>();
 291       state = state->remove<PreCallSelfFlags>();
 292       addSelfFlag(state, state->getSVal(CE), prevFlags, C);
 293       return;
 294     }
 295   }
 296 }
 297
 298 void ObjCSelfInitChecker::checkLocation(SVal location, bool isLoad,
 299                                         const Stmt *S,
 300                                         CheckerContext &C) const {
 301   // Tag the result of a load from 'self' so that we can easily know that the
 302   // value is the object that 'self' points to.
 303   const ProgramState *state = C.getState();
 304   if (isSelfVar(location, C))
 305     addSelfFlag(state, state->getSVal(cast<Loc>(location)), SelfFlag_Self, C);
 306 }
 307
 308 // FIXME: A callback should disable checkers at the start of functions.
 309 static bool shouldRunOnFunctionOrMethod(const NamedDecl *ND) {
 310   if (!ND)
 311     return false;
 312
 313   const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(ND);
 314   if (!MD)
 315     return false;
 316   if (!isInitializationMethod(MD))
 317     return false;
 318
 319   // self = [super init] applies only to NSObject subclasses.
 320   // For instance, NSProxy doesn't implement -init.
 321   ASTContext &Ctx = MD->getASTContext();
 322   IdentifierInfo* NSObjectII = &Ctx.Idents.get("NSObject");
 323   ObjCInterfaceDecl *ID = MD->getClassInterface()->getSuperClass();
 324   for ( ; ID ; ID = ID->getSuperClass()) {
 325     IdentifierInfo *II = ID->getIdentifier();
 326
 327     if (II == NSObjectII)
 328       break;
 329   }
 330   if (!ID)
 331     return false;
 332
 333   return true;
 334 }
 335
 336 /// \brief Returns true if the location is 'self'.
 337 static bool isSelfVar(SVal location, CheckerContext &C) {
 338   AnalysisContext *analCtx = C.getCurrentAnalysisContext();
 339   if (!analCtx->getSelfDecl())
 340     return false;
 341   if (!isa<loc::MemRegionVal>(location))
 342     return false;
 343
 344   loc::MemRegionVal MRV = cast<loc::MemRegionVal>(location);
 345   if (const DeclRegion *DR = dyn_cast<DeclRegion>(MRV.getRegion()))
 346     return (DR->getDecl() == analCtx->getSelfDecl());
 347
 348   return false;
 349 }
 350
 351 static bool isInitializationMethod(const ObjCMethodDecl *MD) {
 352   return MD->getMethodFamily() == OMF_init;
 353 }
 354
 355 static bool isInitMessage(const ObjCMessage &msg) {
 356   return msg.getMethodFamily() == OMF_init;
 357 }
 358
 359 //===----------------------------------------------------------------------===//
 360 // Registration.
 361 //===----------------------------------------------------------------------===//
 362
 363 void ento::registerObjCSelfInitChecker(CheckerManager &mgr) {
 364   mgr.registerChecker<ObjCSelfInitChecker>();
 365 }