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 //===----------------------------------------------------------------------===// 38 39 #include "ClangSACheckers.h" 40 #include "clang/AST/ParentMap.h" 41 #include "clang/StaticAnalyzer/Core/BugReporter/BugType.h" 42 #include "clang/StaticAnalyzer/Core/Checker.h" 43 #include "clang/StaticAnalyzer/Core/CheckerManager.h" 44 #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h" 45 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h" 46 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramStateTrait.h" 47 #include "llvm/Support/raw_ostream.h" 48 49 using namespace clang; 50 using namespace ento; 51 52 static bool shouldRunOnFunctionOrMethod(const NamedDecl *ND); 53 static bool isInitializationMethod(const ObjCMethodDecl *MD); 54 static bool isInitMessage(const ObjCMethodCall &Msg); 55 static bool isSelfVar(SVal location, CheckerContext &C); 56 57 namespace { 58 class ObjCSelfInitChecker : public Checker< check::PostObjCMessage, 59 check::PostStmt<ObjCIvarRefExpr>, 60 check::PreStmt<ReturnStmt>, 61 check::PreCall, 62 check::PostCall, 63 check::Location, 64 check::Bind > { 65 mutable std::unique_ptr<BugType> BT; 66 67 void checkForInvalidSelf(const Expr *E, CheckerContext &C, 68 const char *errorStr) const; 69 70 public: 71 ObjCSelfInitChecker() {} 72 void checkPostObjCMessage(const ObjCMethodCall &Msg, CheckerContext &C) const; 73 void checkPostStmt(const ObjCIvarRefExpr *E, CheckerContext &C) const; 74 void checkPreStmt(const ReturnStmt *S, CheckerContext &C) const; 75 void checkLocation(SVal location, bool isLoad, const Stmt *S, 76 CheckerContext &C) const; 77 void checkBind(SVal loc, SVal val, const Stmt *S, CheckerContext &C) const; 78 79 void checkPreCall(const CallEvent &CE, CheckerContext &C) const; 80 void checkPostCall(const CallEvent &CE, CheckerContext &C) const; 81 82 void printState(raw_ostream &Out, ProgramStateRef State, 83 const char *NL, const char *Sep) const override; 84 }; 85 } // end anonymous namespace 86 87 namespace { 88 enum SelfFlagEnum { 89 /// \brief No flag set. 90 SelfFlag_None = 0x0, 91 /// \brief Value came from 'self'. 92 SelfFlag_Self = 0x1, 93 /// \brief Value came from the result of an initializer (e.g. [super init]). 94 SelfFlag_InitRes = 0x2 95 }; 96 } 97 98 REGISTER_MAP_WITH_PROGRAMSTATE(SelfFlag, SymbolRef, unsigned) 99 REGISTER_TRAIT_WITH_PROGRAMSTATE(CalledInit, bool) 100 101 /// \brief A call receiving a reference to 'self' invalidates the object that 102 /// 'self' contains. This keeps the "self flags" assigned to the 'self' 103 /// object before the call so we can assign them to the new object that 'self' 104 /// points to after the call. 105 REGISTER_TRAIT_WITH_PROGRAMSTATE(PreCallSelfFlags, unsigned) 106 107 static SelfFlagEnum getSelfFlags(SVal val, ProgramStateRef state) { 108 if (SymbolRef sym = val.getAsSymbol()) 109 if (const unsigned *attachedFlags = state->get<SelfFlag>(sym)) 110 return (SelfFlagEnum)*attachedFlags; 111 return SelfFlag_None; 112 } 113 114 static SelfFlagEnum getSelfFlags(SVal val, CheckerContext &C) { 115 return getSelfFlags(val, C.getState()); 116 } 117 118 static void addSelfFlag(ProgramStateRef state, SVal val, 119 SelfFlagEnum flag, CheckerContext &C) { 120 // We tag the symbol that the SVal wraps. 121 if (SymbolRef sym = val.getAsSymbol()) { 122 state = state->set<SelfFlag>(sym, getSelfFlags(val, state) | flag); 123 C.addTransition(state); 124 } 125 } 126 127 static bool hasSelfFlag(SVal val, SelfFlagEnum flag, CheckerContext &C) { 128 return getSelfFlags(val, C) & flag; 129 } 130 131 /// \brief Returns true of the value of the expression is the object that 'self' 132 /// points to and is an object that did not come from the result of calling 133 /// an initializer. 134 static bool isInvalidSelf(const Expr *E, CheckerContext &C) { 135 SVal exprVal = C.getState()->getSVal(E, C.getLocationContext()); 136 if (!hasSelfFlag(exprVal, SelfFlag_Self, C)) 137 return false; // value did not come from 'self'. 138 if (hasSelfFlag(exprVal, SelfFlag_InitRes, C)) 139 return false; // 'self' is properly initialized. 140 141 return true; 142 } 143 144 void ObjCSelfInitChecker::checkForInvalidSelf(const Expr *E, CheckerContext &C, 145 const char *errorStr) const { 146 if (!E) 147 return; 148 149 if (!C.getState()->get<CalledInit>()) 150 return; 151 152 if (!isInvalidSelf(E, C)) 153 return; 154 155 // Generate an error node. 156 ExplodedNode *N = C.generateErrorNode(); 157 if (!N) 158 return; 159 160 if (!BT) 161 BT.reset(new BugType(this, "Missing \"self = [(super or self) init...]\"", 162 categories::CoreFoundationObjectiveC)); 163 C.emitReport(llvm::make_unique<BugReport>(*BT, errorStr, N)); 164 } 165 166 void ObjCSelfInitChecker::checkPostObjCMessage(const ObjCMethodCall &Msg, 167 CheckerContext &C) const { 168 // When encountering a message that does initialization (init rule), 169 // tag the return value so that we know later on that if self has this value 170 // then it is properly initialized. 171 172 // FIXME: A callback should disable checkers at the start of functions. 173 if (!shouldRunOnFunctionOrMethod(dyn_cast<NamedDecl>( 174 C.getCurrentAnalysisDeclContext()->getDecl()))) 175 return; 176 177 if (isInitMessage(Msg)) { 178 // Tag the return value as the result of an initializer. 179 ProgramStateRef state = C.getState(); 180 181 // FIXME this really should be context sensitive, where we record 182 // the current stack frame (for IPA). Also, we need to clean this 183 // value out when we return from this method. 184 state = state->set<CalledInit>(true); 185 186 SVal V = state->getSVal(Msg.getOriginExpr(), C.getLocationContext()); 187 addSelfFlag(state, V, SelfFlag_InitRes, C); 188 return; 189 } 190 191 // We don't check for an invalid 'self' in an obj-c message expression to cut 192 // down false positives where logging functions get information from self 193 // (like its class) or doing "invalidation" on self when the initialization 194 // fails. 195 } 196 197 void ObjCSelfInitChecker::checkPostStmt(const ObjCIvarRefExpr *E, 198 CheckerContext &C) const { 199 // FIXME: A callback should disable checkers at the start of functions. 200 if (!shouldRunOnFunctionOrMethod(dyn_cast<NamedDecl>( 201 C.getCurrentAnalysisDeclContext()->getDecl()))) 202 return; 203 204 checkForInvalidSelf( 205 E->getBase(), C, 206 "Instance variable used while 'self' is not set to the result of " 207 "'[(super or self) init...]'"); 208 } 209 210 void ObjCSelfInitChecker::checkPreStmt(const ReturnStmt *S, 211 CheckerContext &C) const { 212 // FIXME: A callback should disable checkers at the start of functions. 213 if (!shouldRunOnFunctionOrMethod(dyn_cast<NamedDecl>( 214 C.getCurrentAnalysisDeclContext()->getDecl()))) 215 return; 216 217 checkForInvalidSelf(S->getRetValue(), C, 218 "Returning 'self' while it is not set to the result of " 219 "'[(super or self) init...]'"); 220 } 221 222 // When a call receives a reference to 'self', [Pre/Post]Call pass 223 // the SelfFlags from the object 'self' points to before the call to the new 224 // object after the call. This is to avoid invalidation of 'self' by logging 225 // functions. 226 // Another common pattern in classes with multiple initializers is to put the 227 // subclass's common initialization bits into a static function that receives 228 // the value of 'self', e.g: 229 // @code 230 // if (!(self = [super init])) 231 // return nil; 232 // if (!(self = _commonInit(self))) 233 // return nil; 234 // @endcode 235 // Until we can use inter-procedural analysis, in such a call, transfer the 236 // SelfFlags to the result of the call. 237 238 void ObjCSelfInitChecker::checkPreCall(const CallEvent &CE, 239 CheckerContext &C) const { 240 // FIXME: A callback should disable checkers at the start of functions. 241 if (!shouldRunOnFunctionOrMethod(dyn_cast<NamedDecl>( 242 C.getCurrentAnalysisDeclContext()->getDecl()))) 243 return; 244 245 ProgramStateRef state = C.getState(); 246 unsigned NumArgs = CE.getNumArgs(); 247 // If we passed 'self' as and argument to the call, record it in the state 248 // to be propagated after the call. 249 // Note, we could have just given up, but try to be more optimistic here and 250 // assume that the functions are going to continue initialization or will not 251 // modify self. 252 for (unsigned i = 0; i < NumArgs; ++i) { 253 SVal argV = CE.getArgSVal(i); 254 if (isSelfVar(argV, C)) { 255 unsigned selfFlags = getSelfFlags(state->getSVal(argV.castAs<Loc>()), C); 256 C.addTransition(state->set<PreCallSelfFlags>(selfFlags)); 257 return; 258 } else if (hasSelfFlag(argV, SelfFlag_Self, C)) { 259 unsigned selfFlags = getSelfFlags(argV, C); 260 C.addTransition(state->set<PreCallSelfFlags>(selfFlags)); 261 return; 262 } 263 } 264 } 265 266 void ObjCSelfInitChecker::checkPostCall(const CallEvent &CE, 267 CheckerContext &C) const { 268 // FIXME: A callback should disable checkers at the start of functions. 269 if (!shouldRunOnFunctionOrMethod(dyn_cast<NamedDecl>( 270 C.getCurrentAnalysisDeclContext()->getDecl()))) 271 return; 272 273 ProgramStateRef state = C.getState(); 274 SelfFlagEnum prevFlags = (SelfFlagEnum)state->get<PreCallSelfFlags>(); 275 if (!prevFlags) 276 return; 277 state = state->remove<PreCallSelfFlags>(); 278 279 unsigned NumArgs = CE.getNumArgs(); 280 for (unsigned i = 0; i < NumArgs; ++i) { 281 SVal argV = CE.getArgSVal(i); 282 if (isSelfVar(argV, C)) { 283 // If the address of 'self' is being passed to the call, assume that the 284 // 'self' after the call will have the same flags. 285 // EX: log(&self) 286 addSelfFlag(state, state->getSVal(argV.castAs<Loc>()), prevFlags, C); 287 return; 288 } else if (hasSelfFlag(argV, SelfFlag_Self, C)) { 289 // If 'self' is passed to the call by value, assume that the function 290 // returns 'self'. So assign the flags, which were set on 'self' to the 291 // return value. 292 // EX: self = performMoreInitialization(self) 293 addSelfFlag(state, CE.getReturnValue(), prevFlags, C); 294 return; 295 } 296 } 297 298 C.addTransition(state); 299 } 300 301 void ObjCSelfInitChecker::checkLocation(SVal location, bool isLoad, 302 const Stmt *S, 303 CheckerContext &C) const { 304 if (!shouldRunOnFunctionOrMethod(dyn_cast<NamedDecl>( 305 C.getCurrentAnalysisDeclContext()->getDecl()))) 306 return; 307 308 // Tag the result of a load from 'self' so that we can easily know that the 309 // value is the object that 'self' points to. 310 ProgramStateRef state = C.getState(); 311 if (isSelfVar(location, C)) 312 addSelfFlag(state, state->getSVal(location.castAs<Loc>()), SelfFlag_Self, 313 C); 314 } 315 316 317 void ObjCSelfInitChecker::checkBind(SVal loc, SVal val, const Stmt *S, 318 CheckerContext &C) const { 319 // Allow assignment of anything to self. Self is a local variable in the 320 // initializer, so it is legal to assign anything to it, like results of 321 // static functions/method calls. After self is assigned something we cannot 322 // reason about, stop enforcing the rules. 323 // (Only continue checking if the assigned value should be treated as self.) 324 if ((isSelfVar(loc, C)) && 325 !hasSelfFlag(val, SelfFlag_InitRes, C) && 326 !hasSelfFlag(val, SelfFlag_Self, C) && 327 !isSelfVar(val, C)) { 328 329 // Stop tracking the checker-specific state in the state. 330 ProgramStateRef State = C.getState(); 331 State = State->remove<CalledInit>(); 332 if (SymbolRef sym = loc.getAsSymbol()) 333 State = State->remove<SelfFlag>(sym); 334 C.addTransition(State); 335 } 336 } 337 338 void ObjCSelfInitChecker::printState(raw_ostream &Out, ProgramStateRef State, 339 const char *NL, const char *Sep) const { 340 SelfFlagTy FlagMap = State->get<SelfFlag>(); 341 bool DidCallInit = State->get<CalledInit>(); 342 SelfFlagEnum PreCallFlags = (SelfFlagEnum)State->get<PreCallSelfFlags>(); 343 344 if (FlagMap.isEmpty() && !DidCallInit && !PreCallFlags) 345 return; 346 347 Out << Sep << NL << *this << " :" << NL; 348 349 if (DidCallInit) 350 Out << " An init method has been called." << NL; 351 352 if (PreCallFlags != SelfFlag_None) { 353 if (PreCallFlags & SelfFlag_Self) { 354 Out << " An argument of the current call came from the 'self' variable." 355 << NL; 356 } 357 if (PreCallFlags & SelfFlag_InitRes) { 358 Out << " An argument of the current call came from an init method." 359 << NL; 360 } 361 } 362 363 Out << NL; 364 for (SelfFlagTy::iterator I = FlagMap.begin(), E = FlagMap.end(); 365 I != E; ++I) { 366 Out << I->first << " : "; 367 368 if (I->second == SelfFlag_None) 369 Out << "none"; 370 371 if (I->second & SelfFlag_Self) 372 Out << "self variable"; 373 374 if (I->second & SelfFlag_InitRes) { 375 if (I->second != SelfFlag_InitRes) 376 Out << " | "; 377 Out << "result of init method"; 378 } 379 380 Out << NL; 381 } 382 } 383 384 385 // FIXME: A callback should disable checkers at the start of functions. 386 static bool shouldRunOnFunctionOrMethod(const NamedDecl *ND) { 387 if (!ND) 388 return false; 389 390 const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(ND); 391 if (!MD) 392 return false; 393 if (!isInitializationMethod(MD)) 394 return false; 395 396 // self = [super init] applies only to NSObject subclasses. 397 // For instance, NSProxy doesn't implement -init. 398 ASTContext &Ctx = MD->getASTContext(); 399 IdentifierInfo* NSObjectII = &Ctx.Idents.get("NSObject"); 400 ObjCInterfaceDecl *ID = MD->getClassInterface()->getSuperClass(); 401 for ( ; ID ; ID = ID->getSuperClass()) { 402 IdentifierInfo *II = ID->getIdentifier(); 403 404 if (II == NSObjectII) 405 break; 406 } 407 if (!ID) 408 return false; 409 410 return true; 411 } 412 413 /// \brief Returns true if the location is 'self'. 414 static bool isSelfVar(SVal location, CheckerContext &C) { 415 AnalysisDeclContext *analCtx = C.getCurrentAnalysisDeclContext(); 416 if (!analCtx->getSelfDecl()) 417 return false; 418 if (!location.getAs<loc::MemRegionVal>()) 419 return false; 420 421 loc::MemRegionVal MRV = location.castAs<loc::MemRegionVal>(); 422 if (const DeclRegion *DR = dyn_cast<DeclRegion>(MRV.stripCasts())) 423 return (DR->getDecl() == analCtx->getSelfDecl()); 424 425 return false; 426 } 427 428 static bool isInitializationMethod(const ObjCMethodDecl *MD) { 429 return MD->getMethodFamily() == OMF_init; 430 } 431 432 static bool isInitMessage(const ObjCMethodCall &Call) { 433 return Call.getMethodFamily() == OMF_init; 434 } 435 436 //===----------------------------------------------------------------------===// 437 // Registration. 438 //===----------------------------------------------------------------------===// 439 440 void ento::registerObjCSelfInitChecker(CheckerManager &mgr) { 441 mgr.registerChecker<ObjCSelfInitChecker>(); 442 } 443