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