contrib/llvm-project/clang/lib/StaticAnalyzer/Checkers/ObjCSelfInitChecker.cpp

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