ObjCSelfInitChecker.cpp revision cde8cdbd6a662c636164465ad309b5f17ff01064
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/StaticAnalyzer/Core/Checker.h" 41#include "clang/StaticAnalyzer/Core/CheckerManager.h" 42#include "clang/StaticAnalyzer/Core/PathSensitive/Calls.h" 43#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h" 44#include "clang/StaticAnalyzer/Core/PathSensitive/ProgramStateTrait.h" 45#include "clang/StaticAnalyzer/Core/PathSensitive/ObjCMessage.h" 46#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h" 47#include "clang/AST/ParentMap.h" 48 49using namespace clang; 50using namespace ento; 51 52static bool shouldRunOnFunctionOrMethod(const NamedDecl *ND); 53static bool isInitializationMethod(const ObjCMethodDecl *MD); 54static bool isInitMessage(const ObjCMessage &msg); 55static bool isSelfVar(SVal location, CheckerContext &C); 56 57namespace { 58class ObjCSelfInitChecker : public Checker< check::PreObjCMessage, 59 check::PostObjCMessage, 60 check::PostStmt<ObjCIvarRefExpr>, 61 check::PreStmt<ReturnStmt>, 62 check::PreStmt<CallExpr>, 63 check::PostStmt<CallExpr>, 64 check::Location, 65 check::Bind > { 66public: 67 void checkPreObjCMessage(ObjCMessage msg, CheckerContext &C) const; 68 void checkPostObjCMessage(ObjCMessage msg, CheckerContext &C) const; 69 void checkPostStmt(const ObjCIvarRefExpr *E, CheckerContext &C) const; 70 void checkPreStmt(const ReturnStmt *S, CheckerContext &C) const; 71 void checkPreStmt(const CallExpr *CE, CheckerContext &C) const; 72 void checkPostStmt(const CallExpr *CE, CheckerContext &C) const; 73 void checkLocation(SVal location, bool isLoad, const Stmt *S, 74 CheckerContext &C) const; 75 void checkBind(SVal loc, SVal val, const Stmt *S, CheckerContext &C) const; 76 77 void checkPreStmt(const CallEvent &CE, CheckerContext &C) const; 78 void checkPostStmt(const CallEvent &CE, CheckerContext &C) const; 79 80}; 81} // end anonymous namespace 82 83namespace { 84 85class InitSelfBug : public BugType { 86 const std::string desc; 87public: 88 InitSelfBug() : BugType("Missing \"self = [(super or self) init...]\"", 89 categories::CoreFoundationObjectiveC) {} 90}; 91 92} // end anonymous namespace 93 94namespace { 95enum 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 105typedef llvm::ImmutableMap<SymbolRef, unsigned> SelfFlag; 106namespace { struct CalledInit {}; } 107namespace { struct PreCallSelfFlags {}; } 108 109namespace clang { 110namespace ento { 111 template<> 112 struct ProgramStateTrait<SelfFlag> : public ProgramStatePartialTrait<SelfFlag> { 113 static void *GDMIndex() { static int index = 0; return &index; } 114 }; 115 template <> 116 struct ProgramStateTrait<CalledInit> : public ProgramStatePartialTrait<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 ProgramStateTrait<PreCallSelfFlags> : public ProgramStatePartialTrait<unsigned> { 126 static void *GDMIndex() { static int index = 0; return &index; } 127 }; 128} 129} 130 131static SelfFlagEnum getSelfFlags(SVal val, ProgramStateRef 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 138static SelfFlagEnum getSelfFlags(SVal val, CheckerContext &C) { 139 return getSelfFlags(val, C.getState()); 140} 141 142static void addSelfFlag(ProgramStateRef 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 149static 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. 156static bool isInvalidSelf(const Expr *E, CheckerContext &C) { 157 SVal exprVal = C.getState()->getSVal(E, C.getLocationContext()); 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 166static 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 BugReport *report = 183 new BugReport(*new InitSelfBug(), errorStr, N); 184 C.EmitReport(report); 185} 186 187void 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.getCurrentAnalysisDeclContext()->getDecl()))) 196 return; 197 198 if (isInitMessage(msg)) { 199 // Tag the return value as the result of an initializer. 200 ProgramStateRef 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.getMessageExpr(), C.getLocationContext()); 208 addSelfFlag(state, V, SelfFlag_InitRes, C); 209 return; 210 } 211 212 // FIXME: ObjCMessage is going away. 213 ObjCMessageSend MsgWrapper(msg.getMessageExpr(), C.getState(), 214 C.getLocationContext()); 215 checkPostStmt(MsgWrapper, C); 216 217 // We don't check for an invalid 'self' in an obj-c message expression to cut 218 // down false positives where logging functions get information from self 219 // (like its class) or doing "invalidation" on self when the initialization 220 // fails. 221} 222 223void ObjCSelfInitChecker::checkPostStmt(const ObjCIvarRefExpr *E, 224 CheckerContext &C) const { 225 // FIXME: A callback should disable checkers at the start of functions. 226 if (!shouldRunOnFunctionOrMethod(dyn_cast<NamedDecl>( 227 C.getCurrentAnalysisDeclContext()->getDecl()))) 228 return; 229 230 checkForInvalidSelf(E->getBase(), C, 231 "Instance variable used while 'self' is not set to the result of " 232 "'[(super or self) init...]'"); 233} 234 235void ObjCSelfInitChecker::checkPreStmt(const ReturnStmt *S, 236 CheckerContext &C) const { 237 // FIXME: A callback should disable checkers at the start of functions. 238 if (!shouldRunOnFunctionOrMethod(dyn_cast<NamedDecl>( 239 C.getCurrentAnalysisDeclContext()->getDecl()))) 240 return; 241 242 checkForInvalidSelf(S->getRetValue(), C, 243 "Returning 'self' while it is not set to the result of " 244 "'[(super or self) init...]'"); 245} 246 247// When a call receives a reference to 'self', [Pre/Post]VisitGenericCall pass 248// the SelfFlags from the object 'self' point to before the call, to the new 249// object after the call. This is to avoid invalidation of 'self' by logging 250// functions. 251// Another common pattern in classes with multiple initializers is to put the 252// subclass's common initialization bits into a static function that receives 253// the value of 'self', e.g: 254// @code 255// if (!(self = [super init])) 256// return nil; 257// if (!(self = _commonInit(self))) 258// return nil; 259// @endcode 260// Until we can use inter-procedural analysis, in such a call, transfer the 261// SelfFlags to the result of the call. 262 263void ObjCSelfInitChecker::checkPreStmt(const CallExpr *CE, 264 CheckerContext &C) const { 265 // FIXME: This tree of switching can go away if/when we add a check::postCall. 266 const Expr *Callee = CE->getCallee()->IgnoreParens(); 267 ProgramStateRef State = C.getState(); 268 const LocationContext *LCtx = C.getLocationContext(); 269 SVal L = State->getSVal(Callee, LCtx); 270 271 if (dyn_cast_or_null<BlockDataRegion>(L.getAsRegion())) { 272 BlockCall Call(CE, State, LCtx); 273 checkPreStmt(Call, C); 274 } else if (const CXXMemberCallExpr *me = dyn_cast<CXXMemberCallExpr>(CE)) { 275 CXXMemberCall Call(me, State, LCtx); 276 checkPreStmt(Call, C); 277 } else { 278 FunctionCall Call(CE, State, LCtx); 279 checkPreStmt(Call, C); 280 } 281} 282 283void ObjCSelfInitChecker::checkPostStmt(const CallExpr *CE, 284 CheckerContext &C) const { 285 // FIXME: This tree of switching can go away if/when we add a check::postCall. 286 const Expr *Callee = CE->getCallee()->IgnoreParens(); 287 ProgramStateRef State = C.getState(); 288 const LocationContext *LCtx = C.getLocationContext(); 289 SVal L = State->getSVal(Callee, LCtx); 290 291 if (dyn_cast_or_null<BlockDataRegion>(L.getAsRegion())) { 292 BlockCall Call(CE, State, LCtx); 293 checkPostStmt(Call, C); 294 } else if (const CXXMemberCallExpr *me = dyn_cast<CXXMemberCallExpr>(CE)) { 295 CXXMemberCall Call(me, State, LCtx); 296 checkPostStmt(Call, C); 297 } else { 298 FunctionCall Call(CE, State, LCtx); 299 checkPostStmt(Call, C); 300 } 301} 302 303void ObjCSelfInitChecker::checkPreObjCMessage(ObjCMessage Msg, 304 CheckerContext &C) const { 305 // FIXME: ObjCMessage is going away. 306 ObjCMessageSend MsgWrapper(Msg.getMessageExpr(), C.getState(), 307 C.getLocationContext()); 308 checkPreStmt(MsgWrapper, C); 309} 310 311void ObjCSelfInitChecker::checkPreStmt(const CallEvent &CE, 312 CheckerContext &C) const { 313 ProgramStateRef state = C.getState(); 314 unsigned NumArgs = CE.getNumArgs(); 315 // If we passed 'self' as and argument to the call, record it in the state 316 // to be propagated after the call. 317 // Note, we could have just given up, but try to be more optimistic here and 318 // assume that the functions are going to continue initialization or will not 319 // modify self. 320 for (unsigned i = 0; i < NumArgs; ++i) { 321 SVal argV = CE.getArgSVal(i); 322 if (isSelfVar(argV, C)) { 323 unsigned selfFlags = getSelfFlags(state->getSVal(cast<Loc>(argV)), C); 324 C.addTransition(state->set<PreCallSelfFlags>(selfFlags)); 325 return; 326 } else if (hasSelfFlag(argV, SelfFlag_Self, C)) { 327 unsigned selfFlags = getSelfFlags(argV, C); 328 C.addTransition(state->set<PreCallSelfFlags>(selfFlags)); 329 return; 330 } 331 } 332} 333 334void ObjCSelfInitChecker::checkPostStmt(const CallEvent &CE, 335 CheckerContext &C) const { 336 ProgramStateRef state = C.getState(); 337 unsigned NumArgs = CE.getNumArgs(); 338 for (unsigned i = 0; i < NumArgs; ++i) { 339 SVal argV = CE.getArgSVal(i); 340 if (isSelfVar(argV, C)) { 341 // If the address of 'self' is being passed to the call, assume that the 342 // 'self' after the call will have the same flags. 343 // EX: log(&self) 344 SelfFlagEnum prevFlags = (SelfFlagEnum)state->get<PreCallSelfFlags>(); 345 state = state->remove<PreCallSelfFlags>(); 346 addSelfFlag(state, state->getSVal(cast<Loc>(argV)), prevFlags, C); 347 return; 348 } else if (hasSelfFlag(argV, SelfFlag_Self, C)) { 349 // If 'self' is passed to the call by value, assume that the function 350 // returns 'self'. So assign the flags, which were set on 'self' to the 351 // return value. 352 // EX: self = performMoreInitialization(self) 353 SelfFlagEnum prevFlags = (SelfFlagEnum)state->get<PreCallSelfFlags>(); 354 state = state->remove<PreCallSelfFlags>(); 355 const Expr *CallExpr = CE.getOriginExpr(); 356 if (CallExpr) 357 addSelfFlag(state, state->getSVal(CallExpr, C.getLocationContext()), 358 prevFlags, C); 359 return; 360 } 361 } 362} 363 364void ObjCSelfInitChecker::checkLocation(SVal location, bool isLoad, 365 const Stmt *S, 366 CheckerContext &C) const { 367 // Tag the result of a load from 'self' so that we can easily know that the 368 // value is the object that 'self' points to. 369 ProgramStateRef state = C.getState(); 370 if (isSelfVar(location, C)) 371 addSelfFlag(state, state->getSVal(cast<Loc>(location)), SelfFlag_Self, C); 372} 373 374 375void ObjCSelfInitChecker::checkBind(SVal loc, SVal val, const Stmt *S, 376 CheckerContext &C) const { 377 // Allow assignment of anything to self. Self is a local variable in the 378 // initializer, so it is legal to assign anything to it, like results of 379 // static functions/method calls. After self is assigned something we cannot 380 // reason about, stop enforcing the rules. 381 // (Only continue checking if the assigned value should be treated as self.) 382 if ((isSelfVar(loc, C)) && 383 !hasSelfFlag(val, SelfFlag_InitRes, C) && 384 !hasSelfFlag(val, SelfFlag_Self, C) && 385 !isSelfVar(val, C)) { 386 387 // Stop tracking the checker-specific state in the state. 388 ProgramStateRef State = C.getState(); 389 State = State->remove<CalledInit>(); 390 if (SymbolRef sym = loc.getAsSymbol()) 391 State = State->remove<SelfFlag>(sym); 392 C.addTransition(State); 393 } 394} 395 396// FIXME: A callback should disable checkers at the start of functions. 397static bool shouldRunOnFunctionOrMethod(const NamedDecl *ND) { 398 if (!ND) 399 return false; 400 401 const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(ND); 402 if (!MD) 403 return false; 404 if (!isInitializationMethod(MD)) 405 return false; 406 407 // self = [super init] applies only to NSObject subclasses. 408 // For instance, NSProxy doesn't implement -init. 409 ASTContext &Ctx = MD->getASTContext(); 410 IdentifierInfo* NSObjectII = &Ctx.Idents.get("NSObject"); 411 ObjCInterfaceDecl *ID = MD->getClassInterface()->getSuperClass(); 412 for ( ; ID ; ID = ID->getSuperClass()) { 413 IdentifierInfo *II = ID->getIdentifier(); 414 415 if (II == NSObjectII) 416 break; 417 } 418 if (!ID) 419 return false; 420 421 return true; 422} 423 424/// \brief Returns true if the location is 'self'. 425static bool isSelfVar(SVal location, CheckerContext &C) { 426 AnalysisDeclContext *analCtx = C.getCurrentAnalysisDeclContext(); 427 if (!analCtx->getSelfDecl()) 428 return false; 429 if (!isa<loc::MemRegionVal>(location)) 430 return false; 431 432 loc::MemRegionVal MRV = cast<loc::MemRegionVal>(location); 433 if (const DeclRegion *DR = dyn_cast<DeclRegion>(MRV.stripCasts())) 434 return (DR->getDecl() == analCtx->getSelfDecl()); 435 436 return false; 437} 438 439static bool isInitializationMethod(const ObjCMethodDecl *MD) { 440 return MD->getMethodFamily() == OMF_init; 441} 442 443static bool isInitMessage(const ObjCMessage &msg) { 444 return msg.getMethodFamily() == OMF_init; 445} 446 447//===----------------------------------------------------------------------===// 448// Registration. 449//===----------------------------------------------------------------------===// 450 451void ento::registerObjCSelfInitChecker(CheckerManager &mgr) { 452 mgr.registerChecker<ObjCSelfInitChecker>(); 453} 454